From d07218307f6786b5f1a5f7d28b7696f7905baf88 Mon Sep 17 00:00:00 2001 From: team3 Date: Mon, 5 Oct 2026 20:45:40 +0200 Subject: [PATCH] =?UTF-8?q?Stufe=20Lektorat:=20Sprache=20gl=C3=A4tten,=20A?= =?UTF-8?q?bschnitt=20f=C3=BCr=20Abschnitt?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Nach der Prüfung glättet ein Lektor ohne Werkzeuge jeden Abschnitt (Satzbau, Zusammenhang, Wortwahl, Begriffe erinnern). Eingebaute Verlustprüfung: Bezeichner, Zahlen, Überschriften, Code, Diagramme, Querverweise, Umfang ±20 % – sonst bleibt das Original. Alte Zustände bekommen die Stufe beim Laden nachgetragen. Co-Authored-By: Claude Fable 5.1 --- API.md | 7 ++++ backend/agenten.py | 17 +++++++++ backend/config.py | 2 + backend/lektorat.py | 89 +++++++++++++++++++++++++++++++++++++++++++++ backend/pipeline.py | 28 +++++++++++++- backend/state.py | 7 ++++ prompts/lektorat.md | 23 ++++++++++++ 7 files changed, 171 insertions(+), 2 deletions(-) create mode 100644 backend/lektorat.py create mode 100644 prompts/lektorat.md diff --git a/API.md b/API.md index 650fae8..7a3e2e2 100644 --- a/API.md +++ b/API.md @@ -24,6 +24,13 @@ Ohne `v2` gilt die neueste Version. - `POST /api/themen/{slug}/v{N}/reset` – löscht alles in der Version außer dem Zustand „neu“ - `GET|PUT /api/themen/{slug}/v{N}/position` – Leseposition `{abschnitt, lesemodus}` +## Stufen + +`recherche → gliederung → schreiben → pruefung → lektorat → konsistenz → montage`. Das Lektorat glättet jedes geprüfte Kapitel +Abschnitt für Abschnitt sprachlich (ohne Werkzeuge, `prompts/lektorat.md`); ein Abschnitt wird nur übernommen, wenn Bezeichner, +Zahlen, Überschriften, Codeblöcke, Diagramme und Querverweise erhalten sind und der Umfang nicht über 20 % wächst. Marker: `berichte/lektorat-NN.md`. +Alte Zustände ohne diese Stufe bekommen sie beim Laden nachgetragen. + ## Zustand eines Laufs `GET /api/themen/{slug}/v{N}` → diff --git a/backend/agenten.py b/backend/agenten.py index 6f1133e..1df82fd 100644 --- a/backend/agenten.py +++ b/backend/agenten.py @@ -74,3 +74,20 @@ async def laufen(name: str, agent_id: str, stufe_id: str, titel: str, prompt: st state.ereignis(name, agent_id, "ende" if status == "fertig" else "fehler", f"{status} · {kosten:.2f} USD · {a['werkzeuge']} Werkzeugaufrufe" + (f" · {fehler}" if fehler else "")) return {"status": status, "bericht": bericht, "kosten": kosten, "tokens": tokens} + + +async def fragen(prompt: str, *, system: str, effort: str = "medium") -> tuple[str, float, int]: + """Eine einzelne Modellantwort ohne Werkzeuge (für das Lektorat). → (Text, Kosten, Tokens)""" + options = ClaudeAgentOptions(model=config.MODELL, effort=effort, max_turns=1, allowed_tools=[], system_prompt=system) + text, kosten, tokens = [], 0.0, 0 + async for m in query(prompt=prompt, options=options): + if isinstance(m, AssistantMessage): + for b in m.content: + if isinstance(b, TextBlock): + text.append(b.text) + elif isinstance(m, ResultMessage): + kosten = m.total_cost_usd or 0.0 + u = m.usage or {} + tokens = sum(int(u.get(k) or 0) for k in + ("input_tokens", "output_tokens", "cache_creation_input_tokens", "cache_read_input_tokens")) + return "".join(text).strip(), kosten, tokens diff --git a/backend/config.py b/backend/config.py index c94cb6b..918d641 100644 --- a/backend/config.py +++ b/backend/config.py @@ -9,6 +9,7 @@ PORT = 8020 MODELL = "claude-opus-5-5" EFFORT = "high" PARALLEL = 5 # gleichzeitige Kapitel-Agenten +LEKTORAT_PARALLEL = 8 # gleichzeitige Lektorat-Anfragen (ohne Werkzeuge, je Abschnitt) MAX_TURNS = 800 KONSISTENZ_GRUPPE = 5 # Kapitel je Querverweis-Agent LESE_WPM = 120 @@ -18,6 +19,7 @@ STUFEN = [ ("gliederung", "Gliederung"), ("schreiben", "Kapitel schreiben"), ("pruefung", "Kapitel prüfen"), + ("lektorat", "Sprache glätten"), ("konsistenz", "Querverweise und Vorwort"), ("montage", "Buch zusammensetzen"), ] diff --git a/backend/lektorat.py b/backend/lektorat.py new file mode 100644 index 0000000..9eb7cb8 --- /dev/null +++ b/backend/lektorat.py @@ -0,0 +1,89 @@ +"""Lektorat: jedes geprüfte Kapitel wird Abschnitt für Abschnitt sprachlich geglättet (ohne Werkzeuge). +Ein Abschnitt wird nur übernommen, wenn nichts verloren ging (Bezeichner, Zahlen, Überschriften, Code, Verweise, Diagramme) +und der Umfang nicht über 20 % wächst; sonst bleibt der Originalabschnitt.""" +import asyncio +import re + +from . import agenten, config, prompts, state + +SYSTEM = "Du bist Lektor für deutschsprachige Sachbuchprosa. Du antwortest nur mit dem überarbeiteten Text." +_sem = asyncio.Semaphore(config.LEKTORAT_PARALLEL) + + +def teilen(text: str) -> list[str]: + """Kapiteltext → [Kopf (Titel + Einleitung), Abschnitt 1, Abschnitt 2, …], jeweils mit ihrer ##-Überschrift.""" + return [t for t in re.split(r"(?m)^(?=## )", text) if t.strip()] + + +def _bezeichner(t: str) -> set[str]: + return {x.strip() for x in re.findall(r"`([^`\n]{1,80})`", t)} + + +def pruefen(alt: str, neu: str) -> list[str]: + """Was beim Glätten verloren ging oder dazukam – leer, wenn der Abschnitt übernommen werden darf.""" + fehler = [] + if not neu.strip(): + return ["leere Antwort"] + for name, rx in (("Überschriften", r"^#{1,4} .*$"), ("Querverweise", r"→ (?:Abschnitt|Kapitel) [0-9.]+")): + a, n = re.findall(rx, alt, flags=re.M), re.findall(rx, neu, flags=re.M) + if sorted(a) != sorted(n): + fehler.append(f"{name} verändert") + for name, rx in (("Codeblöcke", r"^```(?!diagramm)"), ("Diagramme", r"^```diagramm")): + if len(re.findall(rx, alt, flags=re.M)) != len(re.findall(rx, neu, flags=re.M)): + fehler.append(f"{name} verändert") + fehlt = {b for b in _bezeichner(alt) - _bezeichner(neu) if b not in neu} + if fehlt: + fehler.append("Bezeichner fehlen: " + ", ".join(sorted(fehlt)[:5])) + zahlen = set(re.findall(r"\b\d+(?:[.,]\d+)?\b", alt)) - set(re.findall(r"\b\d+(?:[.,]\d+)?\b", neu)) + if zahlen: + fehler.append("Zahlen fehlen: " + ", ".join(sorted(zahlen)[:5])) + wa, wn = len(alt.split()), len(neu.split()) + if wn > wa * 1.2: + fehler.append(f"zu lang: {wn} statt {wa} Wörter") + if wn < wa * 0.8: + fehler.append(f"zu kurz: {wn} statt {wa} Wörter") + return fehler + + +async def _abschnitt(thema: str, text: str) -> tuple[str, float, int, list[str]]: + async with _sem: + neu, kosten, tokens = await agenten.fragen(prompts.laden("lektorat", thema=thema, abschnitt=text), system=SYSTEM) + neu = re.sub(r"^```(?:markdown|md)?\s*\n(.*)\n```\s*$", r"\1", neu.strip(), flags=re.S) # falls das Modell alles in einen Block packt + fehler = pruefen(text, neu) + return (text if fehler else neu.rstrip() + "\n"), kosten, tokens, fehler + + +async def kapitel(name: str, k: dict, thema: str) -> dict: + """Glättet ein Kapitel; schreibt die Datei, den Agenteneintrag und den Bericht. → {"status", "kosten"}""" + agent_id = f"lektorat-{k['n']:02d}" + a = state.agent_eintrag(name, agent_id, "lektorat", f"Kapitel {k['n']} glätten") + state.ereignis(name, agent_id, "start", f"Kapitel {k['n']} glätten") + pfad = state.verzeichnis(name) / "buch" / k["datei"] + try: + teile = teilen(pfad.read_text()) + ergebnisse = await asyncio.gather(*(_abschnitt(thema, t) for t in teile)) + except asyncio.CancelledError: + state.agent_fertig(name, a, "abgebrochen", "", 0.0, 0) + state.ereignis(name, agent_id, "ende", "abgebrochen") + raise + except Exception as e: + state.agent_fertig(name, a, "fehler", f"**Fehler:** {type(e).__name__}: {e}", 0.0, 0) + state.ereignis(name, agent_id, "fehler", f"fehler · {type(e).__name__}") + return {"status": "fehler", "kosten": 0.0} + neu = "\n".join(t.rstrip("\n") + "\n" for t, *_ in ergebnisse) + vorher = sum(len(t.split()) for t in teile) + nachher = len(neu.split()) + kosten = sum(r[1] for r in ergebnisse) + tokens = sum(r[2] for r in ergebnisse) + behalten = [(i, f) for i, (_, _, _, f) in enumerate(ergebnisse) if f] + pfad.write_text(neu) + zeilen = [f"Kapitel {k['n']} geglättet: {len(teile)} Teile, {vorher} → {nachher} Wörter ({100 * nachher / max(1, vorher) - 100:+.0f} %)."] + if behalten: + zeilen.append(f"{len(behalten)} Teil(e) blieben im Original, weil die Prüfung anschlug: " + + "; ".join(f"Teil {i}: {', '.join(f)}" for i, f in behalten)) + bericht = "\n".join(zeilen) + a["werkzeuge"] = len(teile) + state.agent_fertig(name, a, "fertig", bericht, kosten, tokens) + state.bericht_schreiben(name, agent_id, bericht) + state.ereignis(name, agent_id, "ende", f"fertig · {kosten:.2f} USD · {len(teile)} Abschnitte" + (f" · {len(behalten)} im Original" if behalten else "")) + return {"status": "fertig", "kosten": kosten} diff --git a/backend/pipeline.py b/backend/pipeline.py index 401d0ef..36ac5cb 100644 --- a/backend/pipeline.py +++ b/backend/pipeline.py @@ -3,7 +3,7 @@ Dateimarker (Bericht existiert = Agent fertig).""" import asyncio import logging -from . import agenten, config, gliederung, montage, prompts, state +from . import agenten, config, gliederung, lektorat, montage, prompts, state log = logging.getLogger("buchwerk") _laeufe: dict[str, asyncio.Task] = {} @@ -184,6 +184,30 @@ async def st_pruefung(name: str) -> None: await _parallel(name, "pruefung", aufgaben) +async def st_lektorat(name: str) -> None: + """Geprüfte Kapitel sprachlich glätten; Marker: berichte/lektorat-NN.md.""" + thema, _ = _thema(name) + kap = [k for k in _kapitel(name) if (state.verzeichnis(name) / "buch" / k["datei"]).exists()] + s = state.stufe(name, "lektorat") + offen = [k for k in kap if state.bericht_lesen(name, f"pruefung-{k['n']:02d}") and not state.bericht_lesen(name, f"lektorat-{k['n']:02d}")] + s.update(gesamt=len(kap), fertig=len(kap) - len(offen)) + sem = asyncio.Semaphore(config.PARALLEL) + fehler = [] + + async def eins(k): + async with sem: + r = await lektorat.kapitel(name, k, thema) + if r["status"] == "fertig": + s["fertig"] += 1 + else: + fehler.append(f"Kapitel {k['n']}") + state.speichern(name) + + await asyncio.gather(*(eins(k) for k in offen)) + if fehler: + raise Abbruch("Lektorat gescheitert bei " + ", ".join(fehler[:5]) + " – „Fortsetzen“ wiederholt nur die offenen") + + async def st_konsistenz(name: str) -> None: thema, _ = _thema(name) kap = _kapitel(name) @@ -211,4 +235,4 @@ async def st_montage(name: str) -> None: STUFEN_FN = {"recherche": st_recherche, "gliederung": st_gliederung, "schreiben": st_schreiben, - "pruefung": st_pruefung, "konsistenz": st_konsistenz, "montage": st_montage} + "pruefung": st_pruefung, "lektorat": st_lektorat, "konsistenz": st_konsistenz, "montage": st_montage} diff --git a/backend/state.py b/backend/state.py index 452f9d4..49d3968 100644 --- a/backend/state.py +++ b/backend/state.py @@ -165,6 +165,13 @@ def zustand(name: str) -> dict: for a in st["agenten"]: if a["status"] == "laeuft": a["status"] = "abgebrochen" + # Später hinzugekommene Stufen (z. B. Lektorat) in alte Zustände einfügen, in der Reihenfolge der Konfiguration + vorhanden = {x["id"] for x in st["stufen"]} + if vorhanden != {sid for sid, _ in config.STUFEN}: + alt = {x["id"]: x for x in st["stufen"]} + fertig = st.get("status") == "fertig" + st["stufen"] = [alt.get(sid) or {"id": sid, "titel": t, "status": "fertig" if fertig else "offen", "fertig": 0, "gesamt": 0, + "kosten_usd": 0.0, "tokens": 0, "gestartet": "", "beendet": ""} for sid, t in config.STUFEN] _cache[name] = st return _cache[name] diff --git a/prompts/lektorat.md b/prompts/lektorat.md new file mode 100644 index 0000000..9571cc2 --- /dev/null +++ b/prompts/lektorat.md @@ -0,0 +1,23 @@ +Du bist Lektor eines deutschsprachigen Sachbuchs zum Thema „{{thema}}“. Die Leser kennen das Thema nicht, lesen alles und wollen es verstehen, nicht anwenden. Überarbeite den folgenden Abschnitt nur sprachlich. + +Regeln: +1. Satzbau: meist 12–18 Wörter, ein Gedanke je Satz, höchstens ein Nebensatz. Keine Semikolon-Ketten. +2. Zusammenhang ausschreiben: Jeder Satz knüpft an den vorigen an. Den Begriff wiederholen statt „es“, „dies“, „dieser Mechanismus“. Grund und Folge stehen im Text („weil“, „deshalb“, „dadurch“, „damit“). An jeder Absatzgrenze ein Brückensatz, der sagt, was der neue Absatz mit dem vorigen zu tun hat. +3. Wortwahl: Verben statt Substantivierungen; keine Füllwörter („grundsätzlich“, „im Wesentlichen“, „durchaus“). +4. Ein Fachbegriff wird beim zweiten Auftreten mit einem halben Satz in Erinnerung gerufen. + +Unverändert bleiben: alle Fakten, Zahlen, Namen, Bezeichner in `Code-Schrift`, Codeblöcke, Tabellen, Diagramme (```diagramm), Überschriften, Querverweise „(→ …)“ und Quellenangaben. Nichts weglassen, nichts hinzufügen, nicht kürzen. Der Text darf höchstens 10 % länger werden. + +Beispiel 1 – vorher: +„Neben der Welle führt der Code Buchhaltung, die sich bei jedem Streichen mitändert: die Zahl der verbleibenden Muster je Zelle, die Summe ihrer Gewichte und die Summe der Terme w · log w.“ +nachher: +„Neben der Welle führt der Code Buchhaltung. Diese Buchhaltung ändert sich bei jedem Streichen mit. Dazu gehören die Zahl der verbleibenden Muster je Zelle, die Summe ihrer Gewichte und die Summe der Terme w · log w.“ + +Beispiel 2 – vorher: +„Am wichtigsten ist die Fähigkeit zur Selbstauskunft, die auch Reflexion genannt wird. Jedes Objekt kann seinen Klassennamen nennen. Außerdem kann ein Objekt Signale aussenden.“ +nachher: +„Am wichtigsten unter diesen Gemeinsamkeiten ist die Fähigkeit zur Selbstauskunft, die auch Reflexion genannt wird. Dank Reflexion kann jedes Objekt seinen Klassennamen nennen. Neben der Reflexion bietet `Object` auch Signale. Mit Signalen informiert ein Objekt andere Objekte über Ereignisse.“ + +Gib nur den überarbeiteten Markdown-Text des Abschnitts aus, ohne Kommentar. + +{{abschnitt}}