update

backend/bausteine.py

@@ -24,11 +24,11 @@ from jsonio import read_json_file as _json_datei
 from paths import arbeit_dir, bausteine_path, project_dir, subbausteine_path, quelle_path, quelle_crawl_dir, safe_ordner
 from crawl import crawl
 from pipeline import (
-    CANCELLED, FAILED, GenContext, _extra, _log, _prompt, _race, _rest_schema,
+    CANCELLED, FAILED, GenContext, _extra, _log, _prompt, _race, _relevanz_schema, _rest_schema,
     _runde_schema, _semaphore, _str_liste, _stufen_schema, _timeout, run_single_slot,
 )
 from textkit import (
-    _eindeutige_titel, _norm_titel, _parse_auswahl, _parse_subbausteine, _titel,
+    _eindeutige_titel, _lade_bausteine, _norm_titel, _parse_auswahl, _parse_subbausteine, _titel,
     _titel_aufloesen, _titel_index, _vormerge,
 )
 
@@ -50,6 +50,7 @@ BAUSTEINE_STEPS = (
     "Recherche", "Konsolidierung", "Klärung",
     "Subbausteine finden", "Subbausteine wählen", "Subbausteine klären",
     "Stufen finden", "Stufen wählen", "Stufen klären",
+    "Relevanz finden", "Relevanz wählen", "Relevanz klären",
 )
 
 
@@ -78,6 +79,36 @@ def _crawl_fertig(topic: str) -> bool:
     return (quelle_crawl_dir(topic) / ".done").exists()  # Marker erst bei sauberem Abschluss
 
 
+_STUFEN = ("einfach", "mittel", "schwer")
+
+
+def lade_uebersicht(topic: str) -> list[dict]:
+    """Strukturierte Baustein-Liste für die Übersicht: Titel + Beschreibung + Subbausteine/Stufen.
+
+    Verbindet bausteine.md (Nummer/Titel/Beschreibung) mit der Sidecar subbausteine.json
+    (Key = Titel). Fehlt die Sidecar, sind die Subbaustein-Listen leer.
+    """
+    entries = _lade_bausteine(_read(bausteine_path(topic)))
+    sidecar = _json_datei(subbausteine_path(topic))
+    sidecar = sidecar if isinstance(sidecar, dict) else {}
+    out = []
+    for num, entry in entries.items():
+        titel = _titel(entry)
+        teile = entry.split(" — ", 1)
+        beschreibung = teile[1].strip() if len(teile) == 2 else ""
+        subbausteine = [
+            {
+                "titel": t,
+                "stufe": s.get("stufe") if s.get("stufe") in _STUFEN else "mittel",
+                "relevanz": s.get("relevanz") if s.get("relevanz") in ("relevant", "rand") else None,
+            }
+            for s in (sidecar.get(titel) or [])
+            if isinstance(s, dict) and (t := str(s.get("titel", "")).strip())
+        ]
+        out.append({"num": num, "titel": titel, "beschreibung": beschreibung, "subbausteine": subbausteine})
+    return out
+
+
 def _bausteine_steps(topic: str) -> tuple:
     """Schritte je Quelle: link bekommt vorne „Quelle laden", projekt zusätzlich „Ergänzung".
 
@@ -89,6 +120,7 @@ def _bausteine_steps(topic: str) -> tuple:
     rest = (
         "Subbausteine finden", "Subbausteine wählen", "Subbausteine klären",
         "Stufen finden", "Stufen wählen", "Stufen klären",
+        "Relevanz finden", "Relevanz wählen", "Relevanz klären",
     )
     mitte = base + (("Ergänzung",) if q["type"] == "projekt" else ()) + rest
     return (("Quelle laden",) if q["type"] == "link" else ()) + mitte
@@ -117,7 +149,7 @@ def _bausteine_files(topic: str) -> dict:
 def _alle_slot_dateien(files: dict) -> list[Path]:
     arbeit = files["arbeit"]
     # Subbaustein-/Stufen-Slots sind pro Chunk dynamisch — per Glob einsammeln.
-    dyn = (list(arbeit.glob("subbaustein-*")) + list(arbeit.glob("stufe-*"))) if arbeit.is_dir() else []
+    dyn = (list(arbeit.glob("subbaustein-*")) + list(arbeit.glob("stufe-*")) + list(arbeit.glob("relevanz-*"))) if arbeit.is_dir() else []
     return [
         *files["recherche"], files["recherche_mapping"],
         *(p for slots in files["auswahl"].values() for p in slots),
@@ -153,8 +185,12 @@ def _resume_step(topic: str) -> int:
         return _step_idx(topic, "Klärung")
     if q["type"] == "projekt" and not files["ergaenzung"].exists():
         return _step_idx(topic, "Ergänzung")
-    if _sidecar_schema(_json_datei(files["sidecar"])) is not None:
-        return len(_bausteine_steps(topic))
+    sidecar = _json_datei(files["sidecar"])
+    if _sidecar_schema(sidecar) is not None:
+        # Stufen fertig; nur noch Relevanz offen?
+        if _relevanz_komplett(sidecar):
+            return len(_bausteine_steps(topic))
+        return _step_idx(topic, "Relevanz finden")
     if _sub_roh_schema(_json_datei(files["sub_roh"])) is None:
         return _step_idx(topic, "Subbausteine finden")
     return _step_idx(topic, "Stufen finden")
@@ -287,7 +323,7 @@ def _sub_roh_schema(data):
 
 
 def _sidecar_schema(data):
-    """{Baustein-Titel: [{titel, stufe}, …]} → dict · sonst None (finale Sidecar)."""
+    """{Baustein-Titel: [{titel, stufe}, …]} → dict · sonst None (Sidecar mit Stufen)."""
     if not isinstance(data, dict) or not data:
         return None
     for v in data.values():
@@ -299,6 +335,17 @@ def _sidecar_schema(data):
     return data
 
 
+def _relevanz_komplett(data) -> bool:
+    """Jeder Subbaustein der Sidecar trägt eine gültige Relevanz (relevant/rand)?"""
+    if not isinstance(data, dict) or not data:
+        return False
+    return all(
+        isinstance(s, dict) and s.get("relevanz") in ("relevant", "rand")
+        for v in data.values() if isinstance(v, list)
+        for s in v
+    )
+
+
 def _read(p: Path) -> str:
     return p.read_text(encoding="utf-8") if p.exists() else ""
 
@@ -574,6 +621,115 @@ async def _stufen_block(ctx: GenContext, set_p, files: dict, roh: dict, instruct
     return sidecar
 
 
+async def _relevanz_block(ctx: GenContext, set_p, files: dict, sidecar: dict, instructions: str) -> dict | None:
+    """Block D: drei Phasen mit Barriere — Finden (relevant/rand), Wählen (Vote), Klären.
+    Items aus der Sidecar; lokale IDs 1..n pro Paket → globale gid.
+    → {gid: relevanz} oder None bei Abbruch/Recherche-Fehler. Default bei Lücke/Streit: 'relevant'."""
+    topic, provider, is_cancelled = ctx.topic, ctx.provider, ctx.is_cancelled
+    arbeit = files["arbeit"]
+    items = [(titel, sub["titel"]) for titel, subs in sidecar.items() for sub in subs]  # globale id = index+1
+    if not items:
+        return {}
+    chunks = _chunk_nums(list(range(len(items))), _n_chunks(len(items), STUFE_CHUNK))
+    n = len(chunks)
+
+    def rater_paths(c):
+        return [arbeit / f"relevanz-c{c}-{i}.json" for i in (1, 2, 3)]
+
+    def lset(item_idxs):
+        return set(range(1, len(item_idxs) + 1))
+
+    # Phase „Relevanz finden": pro Paket 3 Rater (min. 2), lokale IDs.
+    async def _rate(c, item_idxs):
+        local_set = lset(item_idxs)
+        paths = rater_paths(c)
+        vorhanden = sum(1 for p in paths if _relevanz_schema(_json_datei(p), local_set))
+        if vorhanden >= 2:
+            return True
+        enum = "\n".join(f"{k}. [{items[j][0]}] {items[j][1]}" for k, j in enumerate(item_idxs, 1))
+        offen = [(i, p) for i, p in enumerate(paths, 1) if not _relevanz_schema(_json_datei(p), local_set)]
+        slots = [{
+            "key": f"bausteine-{topic}-relevanz-c{c}-{i}",
+            "prompt": _prompt("Relevanz-Recherche", topic=topic, subbausteine=enum, out_path=p, extra=_extra(instructions)),
+            "role": "fast", "capabilities": "files",
+            "payload": (lambda result, p=p, ids=local_set: _relevanz_schema(_json_datei(p), ids)),
+        } for i, p in offen]
+        neu = await _race(topic, f"Relevanz Paket {c}", slots, 2 - vorhanden, _timeout("relevanz", len(item_idxs)), provider, cancelled=is_cancelled, grace=KONSENS_GRACE)
+        return not is_cancelled() and neu is not None
+
+    set_p(f"Relevanz finden ({n} Pakete)…", step=_step_idx(topic, "Relevanz finden"))
+    oks = await asyncio.gather(*[_rate(c, idxs) for c, idxs in enumerate(chunks, 1)], return_exceptions=True)
+    if is_cancelled():
+        return None
+    if not all(ok is True for ok in oks):
+        _bausteine_errors[topic] = "Relevanz fehlgeschlagen (Recherche)"
+        return None
+
+    # Phase „Relevanz wählen": Code-Vote je Paket → (ergebnis, strittig).
+    set_p(f"Relevanz wählen ({n} Pakete)…", step=_step_idx(topic, "Relevanz wählen"))
+    vote_by_c = {}
+    for c, item_idxs in enumerate(chunks, 1):
+        local_set = lset(item_idxs)
+        rater = [d for p in rater_paths(c) if (d := _relevanz_schema(_json_datei(p), local_set))]
+        ergebnis: dict[int, str] = {}
+        strittig: dict[int, list[str]] = {}
+        for k in range(1, len(item_idxs) + 1):
+            stimmen = [d[k] for d in rater if k in d]
+            zaehler: dict[str, int] = {}
+            for s in stimmen:
+                zaehler[s] = zaehler.get(s, 0) + 1
+            best = max(zaehler.values(), default=0)
+            gewinner = [s for s, v in zaehler.items() if v == best]
+            if len(gewinner) == 1 and best >= 2:
+                ergebnis[k] = gewinner[0]
+            else:
+                strittig[k] = stimmen
+        vote_by_c[c] = (ergebnis, strittig)
+
+    # Phase „Relevanz klären": Judge je Paket mit Strittigem, alle parallel.
+    async def _klaere(c, item_idxs):
+        ergebnis, strittig = vote_by_c[c]
+        if strittig:
+            judge_path = arbeit / f"relevanz-final-c{c}.json"
+            entsch = _relevanz_schema(_json_datei(judge_path), set(strittig))
+            if entsch is None:
+                strittig_block = "\n".join(
+                    f"{k}. [{items[item_idxs[k - 1]][0]}] {items[item_idxs[k - 1]][1]} — Stimmen: {', '.join(stimmen) or 'keine'}"
+                    for k, stimmen in strittig.items()
+                )
+                status, entsch = await run_single_slot(
+                    ctx, f"Relevanz-Klärung {c}",
+                    key=f"bausteine-{topic}-relevanz-final-c{c}",
+                    prompt=_prompt("Relevanz-Mapping", topic=topic, strittig=strittig_block, out_path=judge_path, extra=_extra(instructions)),
+                    role="judge", capabilities="files",
+                    payload=lambda result, p=judge_path, ids=set(strittig): _relevanz_schema(_json_datei(p), ids),
+                    timeout=_timeout("relevanz_check", len(strittig)),
+                )
+                if status == FAILED:
+                    _log(topic, f"Relevanz-Klärung Paket {c} fehlgeschlagen — Default 'relevant'")
+                entsch = entsch if isinstance(entsch, dict) else {}
+            # Strittige ohne Entscheid → 'relevant' (nie versehentlich ausschließen).
+            ergebnis = {**{k: "relevant" for k in strittig}, **ergebnis, **entsch}
+        return {item_idxs[k - 1] + 1: rel for k, rel in ergebnis.items()}
+
+    set_p(f"Relevanz klären ({n} Pakete)…", step=_step_idx(topic, "Relevanz klären"))
+    parts = await asyncio.gather(*[_klaere(c, idxs) for c, idxs in enumerate(chunks, 1)], return_exceptions=True)
+    if is_cancelled():
+        return None
+    relevanz_by_id: dict[int, str] = {}
+    for c, part in enumerate(parts, 1):
+        if not isinstance(part, dict):
+            # Klärung ist nicht fatal: Vote-Ergebnis + Default 'relevant' für Strittige.
+            if isinstance(part, BaseException):
+                _log(topic, f"Relevanz-Klärung Paket {c}: {type(part).__name__}: {part}")
+            ergebnis, strittig = vote_by_c[c]
+            item_idxs = chunks[c - 1]
+            merged = {**{k: "relevant" for k in strittig}, **ergebnis}
+            part = {item_idxs[k - 1] + 1: s for k, s in merged.items()}
+        relevanz_by_id.update(part)
+    return relevanz_by_id
+
+
 async def generate_bausteine(topic: str, instructions: str = "", provider: str = DEFAULT_PROVIDER) -> None:
     if topic in _bausteine_progress:
         return
@@ -834,6 +990,24 @@ async def generate_bausteine(topic: str, instructions: str = "", provider: str =
                 if sidecar is None:
                     return
                 atomic_write_json(files["sidecar"], sidecar, indent=1)
+
+            # Block D: Relevanz je Subbaustein (relevant/rand) → in die Sidecar mergen.
+            # Eigene Phase nach den Stufen; treibt das ProGuide-Format (alle Bausteine
+            # mit ≥1 relevantem Subbaustein) und filtert Rand-Subs aus den Guides.
+            sidecar = _json_datei(files["sidecar"])
+            if _sidecar_schema(sidecar) is not None and not _relevanz_komplett(sidecar):
+                relevanz_by_id = await _relevanz_block(ctx, set_p, files, sidecar, instructions)
+                if is_cancelled():
+                    abgebrochen()
+                    return
+                if relevanz_by_id is None:
+                    return  # Fehler ist gesetzt
+                gid = 0
+                for subs in sidecar.values():
+                    for sub in subs:
+                        gid += 1
+                        sub["relevanz"] = relevanz_by_id.get(gid, "relevant")
+                atomic_write_json(files["sidecar"], sidecar, indent=1)
     except Exception as e:
         log.exception("[%s] Bausteine-Generierung fehlgeschlagen", topic)
         _bausteine_errors[topic] = str(e)[:2000]