Spezialisierung gehört zum Thema, Hinweise zur Version

Thema „Game Design“ plus Spezialisierung „digitale Sammelkartenspiele“
wird zur Bezeichnung „Game Design – digitale Sammelkartenspiele“
(Ordner, Liste). Die Prompts bekommen das Hauptthema und die
Spezialisierung getrennt. „Neue Version“ ändert nur noch die Hinweise.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>

backend/main.py

@@ -34,7 +34,6 @@ class ThemaNeu(BaseModel):
 
 class VersionNeu(BaseModel):
     hinweise: str | None = None          # None: wie die bisherige Version
-    spezialisierung: str | None = None
 
 
 class Position(BaseModel):
@@ -73,7 +72,8 @@ def _thema_info(t: dict) -> dict | None:
     if not vs:
         return None
     neueste = vs[-1]
-    return {"slug": t["slug"], "name": t["name"], "titel": t["titel"], "hinweise": t.get("hinweise", ""), "spezialisierung": t.get("spezialisierung", ""),
+    return {"slug": t["slug"], "name": t["name"], "thema": t.get("thema") or t["name"], "spezialisierung": t.get("spezialisierung", ""),
+            "titel": t["titel"], "hinweise": t.get("hinweise", ""),
             "angelegt": t.get("angelegt", ""), "status": neueste["status"], "laeuft": neueste["laeuft"],
             "stufe": neueste["stufe"], "versionen": vs}
 
@@ -86,7 +86,7 @@ async def themen():
 @app.post("/api/themen")
 async def thema_anlegen(body: ThemaNeu):
     name = body.name.strip()
-    if not state.name_ok(name):
+    if not state.name_ok(name) or not state.name_ok(state.bezeichnung(name, body.spezialisierung.strip())):
         raise HTTPException(400, "Ungültiger Name")
     try:
         return _thema_info(state.anlegen(name, body.hinweise, body.spezialisierung))
@@ -110,9 +110,9 @@ async def thema_loeschen(slug: str):
 
 @app.post("/api/themen/{slug}/versionen")
 async def version_anlegen(slug: str, body: VersionNeu | None = None):
-    """Neue Version: frischer Lauf ohne Wissen über die Vorgänger; Hinweise und Spezialisierung wahlweise geändert."""
+    """Neue Version: frischer Lauf ohne Wissen über die Vorgänger; Hinweise wahlweise geändert."""
     b = body or VersionNeu()
-    key = state.version_anlegen(_thema(slug)["name"], b.hinweise, b.spezialisierung)
+    key = state.version_anlegen(_thema(slug)["name"], b.hinweise)
     return {"v": int(key.rsplit("/v", 1)[1])}
 
 
@@ -121,8 +121,8 @@ async def zustand(slug: str, n: int):
     key = _key(slug, n)
     t = _thema(slug)
     st = state.zustand(key)
-    h, sp = state.eingaben(key)
-    return {"slug": slug, "name": t["name"], "version": n, "titel": t["titel"], **st, "hinweise": h, "spezialisierung": sp,
+    return {"slug": slug, "name": t["name"], "thema": t.get("thema") or t["name"], "version": n, "titel": t["titel"], **st,
+            "hinweise": state.hinweise_von(key), "spezialisierung": state.spezialisierung_von(key),
             "deutung": st.get("deutung") or state.deutung(key), "ereignisse": st["ereignisse"][-100:]}
 
 

backend/pipeline.py

@@ -73,9 +73,9 @@ def _offen(name: str) -> None:
 
 
 def _thema(name: str) -> tuple[str, str, str]:
-    """Titel, Hinweise, Spezialisierung – die Eingaben gelten je Version."""
+    """Hauptthema (ohne Spezialisierung), Hinweise der Version, Spezialisierung des Themas."""
     t = state.thema(name) or {}
-    return (t.get("titel") or name, *state.eingaben(name))
+    return t.get("thema") or state.thema_von(name), state.hinweise_von(name), state.spezialisierung_von(name)
 
 
 def _kapitel(name: str) -> list[dict]:

backend/state.py

@@ -55,32 +55,32 @@ def name_von_slug(sl: str) -> str | None:
     return next((t["name"] for t in themen() if t.get("slug") == sl), None)
 
 
-def version_anlegen(name: str, hinweise: str | None = None, spezialisierung: str | None = None) -> str:
-    """Neue Version; ohne Angabe übernimmt sie Hinweise und Spezialisierung der neuesten Version (bzw. des Themas)."""
+def version_anlegen(name: str, hinweise: str | None = None) -> str:
+    """Neue Version; ohne Angabe übernimmt sie die Hinweise der neuesten Version (bzw. des Themas)."""
     vs = versionen(name)
-    alt_h, alt_s = eingaben(f"{name}/v{vs[-1]}") if vs else _eingaben_thema(name)
+    alt = hinweise_von(f"{name}/v{vs[-1]}") if vs else (thema(name) or {}).get("hinweise", "")
     key = f"{name}/v{(vs or [0])[-1] + 1}"
     v = verzeichnis(key)
     for u in ("quellen", "buch", "berichte", "arbeit"):
         (v / u).mkdir(parents=True)
-    st = leerer_zustand()
-    st["hinweise"] = (alt_h if hinweise is None else hinweise).strip()
-    st["spezialisierung"] = (alt_s if spezialisierung is None else spezialisierung).strip()
-    _schreiben(v / "state.json", st)
+    _schreiben(v / "state.json", {**leerer_zustand(), "hinweise": (alt if hinweise is None else hinweise).strip()})
     return key
 
 
-def _eingaben_thema(name: str) -> tuple[str, str]:
-    t = thema(name) or {}
-    return t.get("hinweise", ""), t.get("spezialisierung", "")
-
-
-def eingaben(key: str) -> tuple[str, str]:
-    """Hinweise und Spezialisierung einer Version; alte Versionen ohne eigene Eingaben nehmen die des Themas."""
+def hinweise_von(key: str) -> str:
+    """Hinweise gelten je Version; alte Versionen ohne eigene nehmen die des Themas."""
     st = zustand(key)
-    if "hinweise" in st:
-        return st["hinweise"], st.get("spezialisierung", "")
-    return _eingaben_thema(key)
+    return st["hinweise"] if "hinweise" in st else (thema(key) or {}).get("hinweise", "")
+
+
+def spezialisierung_von(key: str) -> str:
+    """Die Spezialisierung gehört zum Thema: eine andere Spezialisierung ist ein anderes Buch."""
+    return (thema(key) or {}).get("spezialisierung", "")
+
+
+def bezeichnung(name: str, spezialisierung: str) -> str:
+    """Ordner- und Anzeigename: „Game Design – digitale Sammelkartenspiele“."""
+    return f"{name} – {spezialisierung}" if spezialisierung else name
 
 
 def version_loeschen(key: str) -> None:
@@ -138,13 +138,17 @@ def themen() -> list[dict]:
 
 
 def anlegen(name: str, hinweise: str, spezialisierung: str = "") -> dict:
-    d = config.STORAGE / name
+    """name ist das Hauptthema („Game Design“), die Spezialisierung grenzt es ein; beides zusammen bildet die Bezeichnung."""
+    spezialisierung = spezialisierung.strip()
+    bez = bezeichnung(name, spezialisierung)
+    d = config.STORAGE / bez
     if d.exists():
         raise ValueError("Thema existiert schon")
     d.mkdir(parents=True)
-    t = {"name": name, "slug": slug_frei(name), "titel": name, "hinweise": hinweise.strip(), "spezialisierung": spezialisierung.strip(), "angelegt": jetzt()}
+    t = {"name": bez, "thema": name, "spezialisierung": spezialisierung, "slug": slug_frei(bez), "titel": bez,
+         "hinweise": hinweise.strip(), "angelegt": jetzt()}
     _schreiben(d / "thema.json", t)
-    version_anlegen(name)
+    version_anlegen(bez)
     return t
 
 
@@ -156,14 +160,14 @@ def loeschen(name: str) -> None:
 
 def zuruecksetzen(key: str) -> None:
     v = verzeichnis(key)
-    h, s = eingaben(key)
+    h = hinweise_von(key)
     _cache.pop(key, None)
     for u in ("quellen", "buch", "berichte", "arbeit"):
         shutil.rmtree(v / u, ignore_errors=True)
         (v / u).mkdir()
     for f in ("deutung.json", "log.jsonl", "state.json", "position.json"):
         (v / f).unlink(missing_ok=True)
-    _schreiben(v / "state.json", {**leerer_zustand(), "hinweise": h, "spezialisierung": s})
+    _schreiben(v / "state.json", {**leerer_zustand(), "hinweise": h})
 
 
 def thema(key: str) -> dict | None: