{{ b.num }}{{ b.titel }}
+{{ b.beschreibung }}
+-
+
- + {{ s.titel }}Rand + +
Keine Subbausteine.
+diff --git a/backend/bausteine.py b/backend/bausteine.py
index 002d7d1..99e8136 100644
--- a/backend/bausteine.py
+++ b/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]
diff --git a/backend/config.py b/backend/config.py
index 30d6813..6771aea 100644
--- a/backend/config.py
+++ b/backend/config.py
@@ -6,6 +6,7 @@ STORAGE_DIR = PROJECT_ROOT / "storage"
FRONTEND_DIST = PROJECT_ROOT / "frontend" / "dist"
DB_PATH = STORAGE_DIR / "creator.db"
PROJECTS_DIR = PROJECT_ROOT / "projects"
+UNI_DIR = PROJECT_ROOT / "uni"
MAX_CONCURRENT_GENERATIONS = 10
@@ -42,6 +43,8 @@ TIMEOUTS = {
"subbaustein_check": (300, 15), # Judge entscheidet strittige Subbausteine im Chunk
"stufe": (300, 10), # Subbausteine einstufen je Chunk
"stufe_check": (300, 10), # Judge entscheidet strittige Stufen im Chunk
+ "relevanz": (300, 10), # Subbausteine relevant/rand je Chunk
+ "relevanz_check": (300, 10), # Judge entscheidet strittige Relevanz im Chunk
"writer": (600, 120), # pro Section im Chunk
"lese_check": (300, 10), # pro Section im Paket
"onepager_recherche": (900, 0),
@@ -55,6 +58,7 @@ TIMEOUTS = {
FORMAT_ANTEIL = {
"MiniGuide": (0.05, 0.10, 8, "einen kompakten Anfänger-Guide — der schnelle Einstieg ins Thema"),
"Guide": (0.25, 0.35, 20, "einen ausführlichen Anfänger-Guide — ein solides Fundament im Thema"),
+ "ProGuide": (0.0, 1.0, 0, "einen fokussierten Guide — alles Relevante ohne Randthemen"),
"FullGuide": (0.90, 1.00, 0, "einen Komplett-Guide — das ganze Thema"),
}
diff --git a/backend/elements.py b/backend/elements.py
index 9369c79..577033e 100644
--- a/backend/elements.py
+++ b/backend/elements.py
@@ -71,7 +71,7 @@ def _topic_context(topic: str, limit: int = 12000) -> str:
bp = bausteine_path(topic)
if bp.exists():
parts.append(bp.read_text(encoding="utf-8"))
- for fmt in ("FullGuide", "Guide", "MiniGuide", "OnePager"):
+ for fmt in ("FullGuide", "ProGuide", "Guide", "MiniGuide", "OnePager"):
content = _json_datei(guide_content_path(topic, fmt))
if content:
for ch in content.get("chapters", []):
diff --git a/backend/guide.py b/backend/guide.py
index 4add19a..99c4681 100644
--- a/backend/guide.py
+++ b/backend/guide.py
@@ -407,13 +407,26 @@ async def _generate_sections(
"Wähle, was diesem Zweck dient — lass weg, was dafür nicht nötig ist."
)
- # Schritt 0: Auswahl-Konsens (5 Agenten → Voting → Mapping → Klärungs-Loop)
- auswahl = await _konsens_auswahl(
- ctx, files, entries, k_min, k_max, auswahl_auftrag, format_name,
- bausteine_liste, instructions,
- )
- if auswahl is None:
- return None
+ # Subbausteine je Baustein (Sidecar) — früh geladen: ProGuide wählt darüber aus,
+ # Nicht-FullGuide filtert später Rand-Subbausteine. Fehlt sie → {} (Fallback).
+ subs_raw = _load_subbausteine(topic)
+
+ # Schritt 0: Auswahl. ProGuide ist deterministisch — alle Bausteine mit ≥1
+ # relevantem Subbaustein. Fallback (keine Relevanz-Daten): alle Bausteine.
+ if format_name == "ProGuide":
+ auswahl = [num for num in entries
+ if any(s.get("relevanz") == "relevant" for s in subs_raw.get(_titel(entries[num]), []))]
+ if not auswahl:
+ _log(topic, "ProGuide: keine Relevanz-Daten — alle Bausteine genommen")
+ auswahl = list(entries)
+ else:
+ # Auswahl-Konsens (5 Agenten → Voting → Mapping → Klärungs-Loop)
+ auswahl = await _konsens_auswahl(
+ ctx, files, entries, k_min, k_max, auswahl_auftrag, format_name,
+ bausteine_liste, instructions,
+ )
+ if auswahl is None:
+ return None
sel_entries = {num: entries[num] for num in auswahl}
soll = len(sel_entries)
@@ -487,9 +500,16 @@ async def _generate_sections(
# dieselbe Aufteilung: 1 Agent je ~30 Bausteine (gedeckelt).
total_sections = sum(len(c["nums"]) for c in plan)
chunks = _split_chunks(plan, min(WRITER_MAX, max(1, math.ceil(total_sections / WRITER_SECTIONS))))
- # Subbausteine je Baustein (Sidecar). Fehlt sie → leer → Inhalte/Writer laufen
- # auf Baustein-Granularität weiter (Fallback für Alt-Themen ohne Sidecar).
- subs_by_titel = _load_subbausteine(topic)
+ # Subbausteine je Baustein. Rand-Subbausteine fliegen aus allen Guides AUSSER
+ # FullGuide (Fokus). Subs ohne Relevanz-Feld (Alt-Themen) bleiben erhalten.
+ # Fehlt die Sidecar → leer → Inhalte/Writer laufen auf Baustein-Granularität.
+ subs_by_titel = subs_raw
+ if format_name != "FullGuide":
+ subs_by_titel = {
+ t: [s for s in subs if s.get("relevanz") != "rand"]
+ for t, subs in subs_raw.items()
+ }
+ subs_by_titel = {t: subs for t, subs in subs_by_titel.items() if subs}
zuteilungen = [_zuteilung_subs(chunk, entries, subs_by_titel) for chunk in chunks]
chunk_sizes = [sum(len(c["nums"]) for c in chunk) for chunk in chunks]
writer_count = len(chunks)
diff --git a/backend/models.py b/backend/models.py
index b2ebe65..f889b8c 100644
--- a/backend/models.py
+++ b/backend/models.py
@@ -5,6 +5,7 @@ FormatType = Literal[
"OnePager",
"MiniGuide",
"Guide",
+ "ProGuide",
"FullGuide",
]
@@ -50,6 +51,37 @@ class ProjectResponse(BaseModel):
name: str
+class FolderResponse(BaseModel):
+ name: str
+ ort: str # relativer Pfad ab Repo-Root (z.B. "projects/foo")
+
+
+class BausteineQuelleUpdate(BaseModel):
+ topic: str = Field(min_length=1, max_length=100)
+ type: SourceType = "thema"
+ ort: str = Field(default="", max_length=2000)
+ spec: str = Field(default="", max_length=2000)
+
+
+class BausteineQuelleResponse(BaseModel):
+ type: SourceType
+ ort: str
+ spec: str
+
+
+class SubbausteinInfo(BaseModel):
+ titel: str
+ stufe: Literal["einfach", "mittel", "schwer"]
+ relevanz: Literal["relevant", "rand"] | None = None
+
+
+class BausteinUebersicht(BaseModel):
+ num: int
+ titel: str
+ beschreibung: str = ""
+ subbausteine: list[SubbausteinInfo] = []
+
+
class ProviderInfo(BaseModel):
id: str
available: bool
diff --git a/backend/pipeline.py b/backend/pipeline.py
index d3bc89b..36e48d3 100644
--- a/backend/pipeline.py
+++ b/backend/pipeline.py
@@ -158,6 +158,32 @@ def _stufen_schema(data, ids: set[int] | None = None):
return out
+_RELEVANZ = ("relevant", "rand")
+
+
+def _relevanz_schema(data, ids: set[int] | None = None):
+ """{"relevanz": {"1": "relevant", …}} → {id: relevanz} · sonst None.
+
+ Relevanz ∈ {relevant, rand} (binär). Wie `_stufen_schema`: sind `ids` gegeben,
+ müssen mindestens diese abgedeckt sein (Extras erlaubt).
+ """
+ if not isinstance(data, dict) or not isinstance(data.get("relevanz"), dict) or not data["relevanz"]:
+ return None
+ out: dict[int, str] = {}
+ for k, v in data["relevanz"].items():
+ try:
+ num = int(k)
+ except (ValueError, TypeError):
+ return None
+ wert = str(v).strip().casefold()
+ if wert not in _RELEVANZ:
+ return None
+ out[num] = wert
+ if ids is not None and not ids <= set(out):
+ return None
+ return out
+
+
_MAX_RESTARTS = 2
diff --git a/backend/regeln.py b/backend/regeln.py
index d4fcefa..95a179d 100644
--- a/backend/regeln.py
+++ b/backend/regeln.py
@@ -18,10 +18,11 @@ from paths import bausteine_path, guide_content_path
from textkit import _norm_titel
MAX_OFFENE_GUIDES = 3
-VORSTUFE = {"Guide": "MiniGuide", "FullGuide": "Guide"}
+VORSTUFE = {"Guide": "MiniGuide", "ProGuide": "Guide", "FullGuide": "Guide"}
# Welches Niveau die Vorstufe erreichen muss, um das Format freizuschalten.
-FREISCHALT_LEVEL = {"Guide": "absolviert", "FullGuide": "verstanden"}
-FORMATE = ("MiniGuide", "Guide", "FullGuide")
+# ProGuide hängt parallel zu FullGuide an „Guide absolviert" — kein Pflicht-Gate vor FullGuide.
+FREISCHALT_LEVEL = {"Guide": "absolviert", "ProGuide": "absolviert", "FullGuide": "verstanden"}
+FORMATE = ("MiniGuide", "Guide", "ProGuide", "FullGuide")
async def lade_lernstand() -> tuple[list[dict], dict[str, set[str]], dict[str, dict[str, set[str]]]]:
diff --git a/backend/routes.py b/backend/routes.py
index 0fb4f6e..0b0446e 100644
--- a/backend/routes.py
+++ b/backend/routes.py
@@ -7,7 +7,7 @@ from fastapi import APIRouter, HTTPException
from fastapi.responses import FileResponse
from agents import provider_available
-from config import PROJECTS_DIR, PROVIDERS
+from config import PROJECTS_DIR, UNI_DIR, PROVIDERS
from database import (
create_guide, delete_guide, get_guide, list_guides,
create_topic, list_topics as db_list_topics, delete_topic,
@@ -16,7 +16,7 @@ from database import (
get_vertiefung, set_vertiefung, list_vertiefungen,
list_baustein_progress, set_baustein_score, set_baustein_streak, set_baustein_absolviert, set_baustein_verstanden, set_baustein_gemeistert, delete_baustein_daten,
)
-from bausteine import generate_bausteine, cancel_bausteine, bausteine_status, active_bausteine, reset_bausteine
+from bausteine import generate_bausteine, cancel_bausteine, bausteine_status, active_bausteine, reset_bausteine, lade_quelle, lade_uebersicht
from elements import generate_element, chat_with_guide, chat_with_element, check_element, style_element, refine_suggestion
from lernen import NOETIG, MASTERY, MEISTERN, baustein_chat, baustein_diskussion, baustein_element_anlegen, pruefung_bewertung, pruefung_bewertung_schnell, pruefung_frage, score_berechnen, streak_berechnen, vertiefung_generieren
from guide import generate_guide, guide_slot_dateien
@@ -31,6 +31,7 @@ from models import (
ElementUpdateRequest, ElementCheckRequest, ElementCheckResponse, ElementStyleResponse,
ElementRefineRequest, ElementRefineResponse,
ProgressUpdate, ProgressResponse, ProjectResponse, ProviderInfo,
+ FolderResponse, BausteineQuelleUpdate, BausteineQuelleResponse, BausteinUebersicht,
VertiefungRequest, VertiefungResponse,
BausteinChatRequest, BausteinChatResponse,
BausteinPruefungRequest, BausteinPruefungResponse, BausteinLernstandResponse,
@@ -113,6 +114,18 @@ async def remove_project(name: str):
return {"ok": True}
+@router.get("/folders", response_model=list[FolderResponse])
+async def list_folders(kind: str):
+ """Ordner für die Quellen-Auswahl: kind=projekt → projects/, kind=uni → uni/."""
+ base = {"projekt": (PROJECTS_DIR, "projects"), "uni": (UNI_DIR, "uni")}.get(kind)
+ if base is None:
+ raise HTTPException(400, "kind muss 'projekt' oder 'uni' sein")
+ root, prefix = base
+ if not root.is_dir():
+ return []
+ return [{"name": e.name, "ort": f"{prefix}/{e.name}"} for e in sorted(root.iterdir()) if e.is_dir()]
+
+
# --- Bausteine ---
@router.get("/bausteine/status", response_model=BausteineStatusResponse)
@@ -161,6 +174,39 @@ async def remove_bausteine(topic: str):
return {"ok": True}
+def _validate_quelle(typ: str, ort: str) -> None:
+ """Quellen-Eingabe prüfen (gleiche Regeln wie beim Erstellen)."""
+ if typ in ("projekt", "uni"):
+ ordner = safe_ordner(ort)
+ if ordner is None or not ordner.is_dir():
+ raise HTTPException(400, "Ordner ungültig oder nicht gefunden (Pfad relativ zum Projekt-Root, kein ../).")
+ elif typ == "link":
+ if not ort.lower().startswith(("http://", "https://")):
+ raise HTTPException(400, "Link muss mit http:// oder https:// beginnen.")
+
+
+@router.get("/bausteine/quelle", response_model=BausteineQuelleResponse)
+async def get_bausteine_quelle(topic: str):
+ return lade_quelle(topic)
+
+
+@router.put("/bausteine/quelle", response_model=BausteineQuelleResponse)
+async def update_bausteine_quelle(req: BausteineQuelleUpdate):
+ """Nur speichern — KEINE Neugenerierung. Quellen-/Spec-Wahl überschreiben."""
+ topic, typ, ort = req.topic.strip(), req.type, req.ort.strip()
+ _validate_quelle(typ, ort)
+ qp = quelle_path(topic)
+ qp.parent.mkdir(parents=True, exist_ok=True)
+ daten = {"type": typ, "ort": ort, "spec": req.spec.strip()}
+ atomic_write_json(qp, daten)
+ return daten
+
+
+@router.get("/bausteine/uebersicht", response_model=list[BausteinUebersicht])
+async def get_bausteine_uebersicht(topic: str):
+ return lade_uebersicht(topic)
+
+
# --- Baustein-Lernen: Vertiefung, Chat, Prüfung ---
async def _bester_text(topic: str, baustein: str) -> str | None:
diff --git a/frontend/src/App.vue b/frontend/src/App.vue
index 5a3585d..dc287bf 100644
--- a/frontend/src/App.vue
+++ b/frontend/src/App.vue
@@ -1,14 +1,14 @@
+
+
+ {{ b.beschreibung }} Keine Subbausteine.{{ topic }}
+ Bausteine-Übersicht
+ {{ items.length }} Bausteine · {{ subTotal }} Subbausteine
+
+
+ {{ b.num }}{{ b.titel }}
+
+
+
{{ sourceHint }}
+ > + + +Lade…
+ + +