tobias/podcast-mindmap
1
0
Fork 0
Code Issues 12 Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: tobias:83669c528bc7b6048b98740aafffad35d83b98ab
Branches Tags
tobias:main
..
compare: tobias:aa60f22820f7ab3087ab5b7c02159ee98c19c6ea
Branches Tags
tobias:main

No commits in common. "83669c528bc7b6048b98740aafffad35d83b98ab" and "aa60f22820f7ab3087ab5b7c02159ee98c19c6ea" have entirely different histories.
83669c528b ... aa60f22820

7 changed files with 135 additions and 1637 deletions
Show Stats Expand all files Collapse all files

129
backend/app.py
View File

@ -114,135 +114,6 @@ def get_words(podcast_id: str, episode_id: str):
}
def _table_exists(db, name: str) -> bool:
return db.execute(
"SELECT 1 FROM sqlite_master WHERE type='table' AND name=?", (name,)
).fetchone() is not None
@app.get("/api/podcasts/{podcast_id}/episodes/{episode_id}/claims")
def get_episode_claims(podcast_id: str, episode_id: str, claim_type: Optional[str] = None):
"""Claims (Behauptungen) für eine Episode."""
db = get_db()
if not _table_exists(db, "claims"):
db.close()
return {"available": False, "claims": []}
sql = ("SELECT id, paragraph_idx, claim_text, claim_type, verifiable, start_time "
"FROM claims WHERE podcast_id = ? AND episode_id = ?")
params = [podcast_id, episode_id]
if claim_type:
sql += " AND claim_type = ?"
params.append(claim_type)
sql += " ORDER BY paragraph_idx, id"
rows = db.execute(sql, params).fetchall()
db.close()
return {"available": True, "claims": [dict(r) for r in rows]}
@app.get("/api/podcasts/{podcast_id}/episodes/{episode_id}/questions")
def get_episode_questions(podcast_id: str, episode_id: str, question_type: Optional[str] = None,
answered: Optional[str] = None):
"""Fragen einer Episode."""
db = get_db()
if not _table_exists(db, "questions"):
db.close()
return {"available": False, "questions": []}
sql = ("SELECT id, paragraph_idx, question_text, question_type, answered, "
"answered_by_podcast, answered_by_episode, answered_by_idx, start_time "
"FROM questions WHERE podcast_id = ? AND episode_id = ?")
params = [podcast_id, episode_id]
if question_type:
sql += " AND question_type = ?"
params.append(question_type)
if answered:
sql += " AND answered = ?"
params.append(answered)
sql += " ORDER BY paragraph_idx, id"
rows = db.execute(sql, params).fetchall()
db.close()
return {"available": True, "questions": [dict(r) for r in rows]}
@app.get("/api/podcasts/{podcast_id}/episodes/{episode_id}/analyses-summary")
def get_episode_analyses_summary(podcast_id: str, episode_id: str):
"""Zähler für die Analyse-Datentöpfe einer Episode (für UI-Buttons)."""
db = get_db()
out = {}
if _table_exists(db, "claims"):
out["claims"] = db.execute(
"SELECT COUNT(*) FROM claims WHERE podcast_id = ? AND episode_id = ?",
(podcast_id, episode_id)
).fetchone()[0]
if _table_exists(db, "questions"):
out["questions"] = db.execute(
"SELECT COUNT(*) FROM questions WHERE podcast_id = ? AND episode_id = ?",
(podcast_id, episode_id)
).fetchone()[0]
out["questions_unanswered"] = db.execute(
"SELECT COUNT(*) FROM questions WHERE podcast_id = ? AND episode_id = ? AND answered = 'no'",
(podcast_id, episode_id)
).fetchone()[0]
db.close()
return out
@app.get("/api/analyses/gaps")
def get_gaps_analysis(min_size: int = 0, missing_in: Optional[str] = None, limit: int = 200):
"""Leerstellen-Analyse (#14): Cluster, die in mindestens einem Podcast fehlen."""
path = Path(DATA_DIR) / "gaps_analysis.json"
if not path.exists():
return {"available": False}
try:
with open(path) as f:
data = json.load(f)
except Exception:
return {"available": False}
gaps = data.get("gaps", [])
if min_size > 0:
gaps = [g for g in gaps if g.get("cluster_size", 0) >= min_size]
if missing_in:
gaps = [g for g in gaps if g.get("missing_in") == missing_in]
gaps = gaps[:limit]
return {
"available": True,
"total_paragraphs": data.get("total_paragraphs"),
"podcasts": data.get("podcasts", []),
"n_clusters": data.get("n_clusters"),
"clusters": data.get("clusters", []),
"gaps": gaps,
}
@app.get("/api/analyses/shifts")
def get_shifts_analysis(podcast: Optional[str] = None, theme: Optional[str] = None,
min_drift: float = 0.0, limit: int = 200):
"""Narrative-Shift-Analyse (#15): Drift zwischen aufeinanderfolgenden Episoden je Theme."""
path = Path(DATA_DIR) / "narrative_shifts.json"
if not path.exists():
return {"available": False}
try:
with open(path) as f:
data = json.load(f)
except Exception:
return {"available": False}
shifts = data.get("shifts", [])
if podcast:
shifts = [s for s in shifts if s.get("podcast") == podcast]
if theme:
shifts = [s for s in shifts if s.get("theme") == theme]
if min_drift > 0:
shifts = [s for s in shifts if s.get("max_drift", 0) >= min_drift]
shifts = shifts[:limit]
podcasts = sorted({s.get("podcast") for s in data.get("shifts", []) if s.get("podcast")})
return {
"available": True,
"total_themes_tracked": data.get("total_themes_tracked"),
"themes": data.get("themes", []),
"podcasts": podcasts,
"shifts": shifts,
}
@app.get("/api/search")
def search(q: str = Query(..., min_length=2), podcast_id: Optional[str] = None, limit: int = 50):
"""Full-text search across all transcripts."""

70
scripts/analyse_arguments.py
View File

@ -16,13 +16,8 @@ import sqlite3
from openai import OpenAI
# Lokaler Helper
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
from json_utils import parse_llm_json
DB_PATH = sys.argv[1] if len(sys.argv) > 1 else "data/db.sqlite"
LIMIT = int(sys.argv[2]) if len(sys.argv) > 2 and not sys.argv[2].startswith("--") else 500
RERUN_ERRORS = "--rerun-errors" in sys.argv
LIMIT = int(sys.argv[2]) if len(sys.argv) > 2 else 500
API_KEY = os.environ.get("DASHSCOPE_API_KEY", "")
BASE_URL = "https://dashscope-intl.aliyuncs.com/compatible-mode/v1"
@ -51,8 +46,6 @@ Absatz B ({meta_b}):
Welche logische Relation besteht von A zu B?"""
last_err = None
for attempt in range(3):
try:
resp = client.chat.completions.create(
model=MODEL,
@ -61,27 +54,17 @@ Welche logische Relation besteht von A zu B?"""
{"role": "user", "content": user_msg},
],
temperature=0.1,
max_tokens=200,
max_tokens=150,
)
content = resp.choices[0].message.content
usage = getattr(resp, "usage", None)
tokens = (usage.prompt_tokens, usage.completion_tokens) if usage else (0, 0)
try:
parsed = parse_llm_json(content, expect="object")
parsed["_tokens"] = tokens
return parsed
except ValueError as pe:
last_err = f"parse: {pe}"
# Bei Parse-Fehler kein Retry: das Modell wuerde wieder dasselbe liefern.
break
content = resp.choices[0].message.content.strip()
# Parse JSON from response
if content.startswith("```"):
content = content.split("```")[1].strip()
if content.startswith("json"):
content = content[4:].strip()
return json.loads(content)
except Exception as e:
last_err = str(e)
# Retry bei Netzwerk/Rate-Limit
if attempt < 2:
time.sleep(2 ** attempt)
continue
break
return {"relation": "error", "confidence": 0, "explanation": str(last_err), "_tokens": (0, 0)}
return {"relation": "error", "confidence": 0, "explanation": str(e)}
def main():
@ -90,8 +73,7 @@ def main():
sys.exit(1)
client = OpenAI(api_key=API_KEY, base_url=BASE_URL)
db = sqlite3.connect(DB_PATH, timeout=60.0)
db.execute("PRAGMA busy_timeout=60000")
db = sqlite3.connect(DB_PATH)
db.row_factory = sqlite3.Row
# Create output table
@ -105,27 +87,6 @@ def main():
CREATE INDEX IF NOT EXISTS idx_arglinks ON argument_links(relation);
""")
if RERUN_ERRORS:
# Hole error-Records, loesche sie, baue Eingabe-Liste daraus auf.
err_rows = db.execute("""
SELECT al.source_podcast as podcast_id, al.source_episode, al.source_idx,
al.target_podcast, al.target_episode, al.target_idx, al.score,
p1.text as source_text, p2.text as target_text,
e1.title as source_title, e1.guest as source_guest,
e2.title as target_title, e2.guest as target_guest
FROM argument_links al
JOIN paragraphs p1 ON al.source_podcast = p1.podcast_id AND al.source_episode = p1.episode_id AND al.source_idx = p1.idx
JOIN paragraphs p2 ON al.target_podcast = p2.podcast_id AND al.target_episode = p2.episode_id AND al.target_idx = p2.idx
JOIN episodes e1 ON al.source_podcast = e1.podcast_id AND al.source_episode = e1.id
JOIN episodes e2 ON al.target_podcast = e2.podcast_id AND al.target_episode = e2.id
WHERE al.relation = 'error'
""").fetchall()
rows = err_rows
del_count = db.execute("DELETE FROM argument_links WHERE relation='error'").rowcount
db.commit()
print(f"RE-RUN: {del_count} error-Records geloescht, {len(rows)} werden neu klassifiziert.")
existing = set()
else:
# Get top semantic links (cross-episode, prefer cross-podcast)
rows = db.execute("""
SELECT sl.podcast_id, sl.source_episode, sl.source_idx,
@ -155,8 +116,6 @@ def main():
processed = 0
skipped = 0
total_in_tokens = 0
total_out_tokens = 0
for i, row in enumerate(rows):
key = f"{row['podcast_id']}{row['source_episode']}{row['source_idx']}{row['target_podcast']}{row['target_episode']}{row['target_idx']}"
@ -173,10 +132,6 @@ def main():
row["target_text"][:800], meta_b
)
in_t, out_t = result.pop("_tokens", (0, 0))
total_in_tokens += in_t
total_out_tokens += out_t
db.execute(
"INSERT INTO argument_links (source_podcast, source_episode, source_idx, "
"target_podcast, target_episode, target_idx, relation, confidence, explanation, score) "
@ -203,9 +158,6 @@ def main():
print("Verteilung:")
for s in stats:
print(f" {s['relation']}: {s['c']}")
# qwen-plus: ~$0.40/1M input, ~$1.20/1M output (DashScope intl, grobe Schaetzung)
cost = total_in_tokens / 1e6 * 0.40 + total_out_tokens / 1e6 * 1.20
print(f"Tokens: in={total_in_tokens} out={total_out_tokens} ~${cost:.4f}")
db.close()

65
scripts/curate_debates.py
View File

@ -15,12 +15,8 @@ import sqlite3
from openai import OpenAI
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
from json_utils import parse_llm_json
DB_PATH = sys.argv[1] if len(sys.argv) > 1 else "data/db.sqlite"
LIMIT = int(sys.argv[2]) if len(sys.argv) > 2 and not sys.argv[2].startswith("--") else 100
RERUN_ERRORS = "--rerun-errors" in sys.argv
LIMIT = int(sys.argv[2]) if len(sys.argv) > 2 else 100
API_KEY = os.environ.get("DASHSCOPE_API_KEY", "")
BASE_URL = "https://dashscope-intl.aliyuncs.com/compatible-mode/v1"
MODEL = "qwen-plus"
@ -46,8 +42,6 @@ Podcast B — {meta_b}:
Erstelle die Gegenüberstellung."""
last_err = None
for attempt in range(3):
try:
resp = client.chat.completions.create(
model=MODEL,
@ -56,25 +50,16 @@ Erstelle die Gegenüberstellung."""
{"role": "user", "content": user_msg},
],
temperature=0.2,
max_tokens=400,
max_tokens=300,
)
content = resp.choices[0].message.content
usage = getattr(resp, "usage", None)
tokens = (usage.prompt_tokens, usage.completion_tokens) if usage else (0, 0)
try:
parsed = parse_llm_json(content, expect="object")
parsed["_tokens"] = tokens
return parsed
except ValueError as pe:
last_err = f"parse: {pe}"
break
content = resp.choices[0].message.content.strip()
if content.startswith("```"):
content = content.split("```")[1].strip()
if content.startswith("json"):
content = content[4:].strip()
return json.loads(content)
except Exception as e:
last_err = str(e)
if attempt < 2:
time.sleep(2 ** attempt)
continue
break
return {"topic": "error", "agreement": "", "divergence": "", "insight": str(last_err), "_tokens": (0, 0)}
return {"topic": "error", "agreement": "", "divergence": "", "insight": str(e)}
def main():
@ -83,8 +68,7 @@ def main():
sys.exit(1)
client = OpenAI(api_key=API_KEY, base_url=BASE_URL)
db = sqlite3.connect(DB_PATH, timeout=60.0)
db.execute("PRAGMA busy_timeout=60000")
db = sqlite3.connect(DB_PATH)
db.row_factory = sqlite3.Row
db.executescript("""
@ -98,28 +82,6 @@ def main():
CREATE INDEX IF NOT EXISTS idx_debates_topic ON debates(topic);
""")
if RERUN_ERRORS:
rows = db.execute("""
SELECT d.source_podcast as podcast_id, d.source_episode, d.source_idx,
d.target_podcast, d.target_episode, d.target_idx, d.score,
p1.text as source_text, p2.text as target_text,
pc1.name as source_podcast_name, pc2.name as target_podcast_name,
e1.title as source_title, e1.guest as source_guest,
e2.title as target_title, e2.guest as target_guest
FROM debates d
JOIN paragraphs p1 ON d.source_podcast = p1.podcast_id AND d.source_episode = p1.episode_id AND d.source_idx = p1.idx
JOIN paragraphs p2 ON d.target_podcast = p2.podcast_id AND d.target_episode = p2.episode_id AND d.target_idx = p2.idx
JOIN episodes e1 ON d.source_podcast = e1.podcast_id AND d.source_episode = e1.id
JOIN episodes e2 ON d.target_podcast = e2.podcast_id AND d.target_episode = e2.id
JOIN podcasts pc1 ON d.source_podcast = pc1.id
JOIN podcasts pc2 ON d.target_podcast = pc2.id
WHERE d.topic = 'error'
""").fetchall()
del_count = db.execute("DELETE FROM debates WHERE topic='error'").rowcount
db.commit()
print(f"RE-RUN: {del_count} error-Records geloescht, {len(rows)} werden neu kuratiert.")
existing = set()
else:
# Get strongest cross-podcast links
rows = db.execute("""
SELECT sl.podcast_id, sl.source_episode, sl.source_idx,
@ -150,8 +112,6 @@ def main():
pass
processed = 0
total_in_tokens = 0
total_out_tokens = 0
for i, row in enumerate(rows):
key = f"{row['podcast_id']}{row['source_episode']}{row['source_idx']}{row['target_podcast']}{row['target_episode']}{row['target_idx']}"
if key in existing:
@ -161,9 +121,6 @@ def main():
meta_b = f"{row['target_podcast_name']} / {row['target_episode']}: {row['target_title']} ({row['target_guest']})"
result = curate_pair(client, row["source_text"][:800], meta_a, row["target_text"][:800], meta_b)
in_t, out_t = result.pop("_tokens", (0, 0))
total_in_tokens += in_t
total_out_tokens += out_t
db.execute(
"INSERT INTO debates (topic, source_podcast, source_episode, source_idx, "
@ -189,8 +146,6 @@ def main():
print("Top-Themen:")
for t in topics:
print(f" {t['topic']}: {t['c']}")
cost = total_in_tokens / 1e6 * 0.40 + total_out_tokens / 1e6 * 1.20
print(f"Tokens: in={total_in_tokens} out={total_out_tokens} ~${cost:.4f}")
db.close()

294
scripts/extract_quotes.py
View File

@ -1,294 +0,0 @@
#!/usr/bin/env python3
"""Auto-Quote-Extraktion fuer einen Podcast (z.B. LdN).
Pro Episode: Qwen erhaelt das (gekuerzte) Transkript als Paragraphen-Array.
Output: 3-5 markante Zitate als JSON, mit para_idx, text, verbatim, speaker, is_top, themes.
Audio-Timestamps werden aus der `paragraphs`-Tabelle ueber `para_idx` zugeordnet.
Nutzung:
DASHSCOPE_API_KEY=... python3 extract_quotes.py [db-pfad] [podcast_id]
Bei wiederholtem Aufruf: Episoden mit bestehenden Quotes werden uebersprungen.
"""
import json
import os
import re
import sys
import time
import sqlite3
from openai import OpenAI
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
from json_utils import parse_llm_json
DB_PATH = sys.argv[1] if len(sys.argv) > 1 else "data/db.sqlite"
PODCAST_ID = sys.argv[2] if len(sys.argv) > 2 else "ldn"
API_KEY = os.environ.get("DASHSCOPE_API_KEY", "")
BASE_URL = "https://dashscope-intl.aliyuncs.com/compatible-mode/v1"
MODEL = "qwen-plus"
# Konservatives Pricing fuer Budget-Tracking (qwen-plus intl)
COST_IN = 0.0008 / 1000
COST_OUT = 0.002 / 1000
PARA_CHAR_LIMIT = 600 # pro Paragraph
HARD_BUDGET_USD = 1.50
SYSTEM_PROMPT = """Du bist Diskursanalyst. Du erhaeltst ein Podcast-Transkript als Paragraphen-Liste mit Index-Markern [P0], [P1], ...
Waehle 3 bis 5 markante Zitate, die fuer diese Episode/diesen Diskurs charakteristisch sind. Praeferenz fuer:
- Pointierte Aussagen, Thesen, Schluesselformulierungen
- Konkrete Beispiele, die ein groesseres Argument verdichten
- Aussagen mit klarer Sprecher-Position
KEINE Floskeln, KEINE Begruessungen, KEINE Werbeblock-Zitate.
Antworte NUR mit einem JSON-Array. Jedes Element:
{
"para_idx": <int>, // Index des Paragraphen (P-Marker)
"text": "<geglaettete Form, ohne Fuellwoerter, ein Satz>",
"verbatim": "<woertlicher Snippet aus dem Transkript, max. 2 Saetze>",
"speaker": "<Name oder leerer String>",
"is_top": <true wenn dies das prominenteste Zitat der Episode ist, sonst false; max. 1x true pro Antwort>,
"themes": ["<theme-id>", ...] // ZWINGEND nur aus den erlaubten IDs (siehe unten); leeres Array wenn unklar
}
ERLAUBTE THEME-IDs (NUR diese verwenden, sonst leeres Array):
gaza-nahost, haushalt-investitionen, klima-verkehr, krieg-ukraine, migration-asyl, parteienlandschaft, trump-usa
"""
class Budget:
def __init__(self, hard_limit_usd):
self.hard_limit = hard_limit_usd
self.tokens_in = 0
self.tokens_out = 0
def add(self, usage):
if usage:
self.tokens_in += getattr(usage, "prompt_tokens", 0) or 0
self.tokens_out += getattr(usage, "completion_tokens", 0) or 0
def cost(self):
return self.tokens_in * COST_IN + self.tokens_out * COST_OUT
def over(self):
return self.cost() > self.hard_limit
def load_themes(db, podcast_id):
return [r["id"] for r in db.execute("SELECT id FROM themes WHERE podcast_id=?", (podcast_id,)).fetchall()]
def build_user_msg(episode, paragraphs):
head = f"Episode {episode['id']}: {episode['title'][:200]}"
if episode.get("guest"):
head += f" (Gast: {episode['guest']})"
blocks = []
for p in paragraphs:
snippet = p["text"][:PARA_CHAR_LIMIT]
blocks.append(f"[P{p['idx']}] {snippet}")
return head + "\n\n" + "\n\n".join(blocks)
def call_llm(client, user_msg, budget):
last_err = None
for attempt in range(2):
try:
resp = client.chat.completions.create(
model=MODEL,
messages=[
{"role": "system", "content": SYSTEM_PROMPT},
{"role": "user", "content": user_msg},
],
temperature=0.2,
max_tokens=1500,
)
budget.add(getattr(resp, "usage", None))
content = resp.choices[0].message.content
try:
return parse_llm_json(content, expect="array"), None
except ValueError as pe:
last_err = f"parse: {pe} :: head={content[:200]}"
break
except Exception as e:
last_err = str(e)
if attempt < 1:
time.sleep(2)
continue
return None, last_err
def next_quote_id(db, podcast_id):
rows = db.execute(
"SELECT id FROM quotes WHERE podcast_id=? AND id LIKE 'q%'", (podcast_id,)
).fetchall()
max_n = 0
for r in rows:
m = re.match(r"q(\d+)$", r["id"])
if m:
n = int(m.group(1))
if n > max_n:
max_n = n
return max_n + 1
def process_episode(db, client, episode, allowed_themes, budget, next_id):
paras = db.execute(
"SELECT idx, start_time, end_time, text FROM paragraphs "
"WHERE podcast_id=? AND episode_id=? ORDER BY idx",
(episode["podcast_id"], episode["id"]),
).fetchall()
if not paras:
return 0, next_id, "no-paragraphs"
paragraph_dicts = [dict(p) for p in paras]
para_lookup = {p["idx"]: p for p in paragraph_dicts}
user_msg = build_user_msg(dict(episode), paragraph_dicts)
result, err = call_llm(client, user_msg, budget)
if result is None:
return 0, next_id, f"llm-fail: {err}"
if not isinstance(result, list):
return 0, next_id, "llm: no array"
inserted = 0
top_count = 0
for item in result:
if not isinstance(item, dict):
continue
try:
idx = int(item.get("para_idx", -1))
except (TypeError, ValueError):
continue
para = para_lookup.get(idx)
if not para:
continue
text = (item.get("text") or "").strip()
verbatim = (item.get("verbatim") or "").strip()
speaker = (item.get("speaker") or "").strip()
if not text and not verbatim:
continue
themes_raw = item.get("themes") or []
if not isinstance(themes_raw, list):
themes_raw = []
themes = [t for t in themes_raw if t in allowed_themes]
is_top_raw = item.get("is_top")
is_top = bool(is_top_raw) and top_count == 0
if is_top:
top_count += 1
qid = f"q{next_id}"
next_id += 1
try:
db.execute(
"INSERT INTO quotes (id, podcast_id, episode_id, text, verbatim, speaker, "
"start_time, end_time, is_top_quote, themes_json) "
"VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
(qid, episode["podcast_id"], episode["id"],
text[:1000], verbatim[:2000], speaker[:200],
para["start_time"], para["end_time"], 1 if is_top else 0,
json.dumps(themes, ensure_ascii=False)),
)
inserted += 1
except sqlite3.IntegrityError:
# Duplikat - skip
pass
return inserted, next_id, None
def main():
if not API_KEY:
print("DASHSCOPE_API_KEY nicht gesetzt.")
sys.exit(1)
client = OpenAI(api_key=API_KEY, base_url=BASE_URL, timeout=60.0, max_retries=1)
db = sqlite3.connect(DB_PATH, timeout=30.0)
db.execute("PRAGMA busy_timeout=30000")
db.row_factory = sqlite3.Row
# Sicherstellen, dass quotes-Tabelle existiert (sollte sie)
db.executescript("""
CREATE TABLE IF NOT EXISTS quotes (
id TEXT, podcast_id TEXT, episode_id TEXT,
text TEXT, verbatim TEXT, speaker TEXT,
start_time REAL, end_time REAL,
is_top_quote BOOLEAN, themes_json TEXT,
PRIMARY KEY (podcast_id, id)
);
CREATE INDEX IF NOT EXISTS idx_quotes_episode ON quotes(podcast_id, episode_id);
""")
allowed_themes = load_themes(db, PODCAST_ID)
print(f"Erlaubte Themes ({PODCAST_ID}): {allowed_themes}")
episodes = db.execute(
"SELECT id, podcast_id, title, guest FROM episodes WHERE podcast_id=? ORDER BY id",
(PODCAST_ID,),
).fetchall()
print(f"Verarbeite {len(episodes)} Episoden fuer {PODCAST_ID}…")
# Skip episodes with existing quotes
done = set()
for r in db.execute(
"SELECT DISTINCT episode_id FROM quotes WHERE podcast_id=?", (PODCAST_ID,)
).fetchall():
done.add(r["episode_id"])
print(f" {len(done)} Episoden haben bereits Quotes — werden uebersprungen")
next_id = next_quote_id(db, PODCAST_ID)
print(f" Naechste Quote-ID: q{next_id}")
budget = Budget(hard_limit_usd=HARD_BUDGET_USD)
total_inserted = 0
failures = []
for i, ep in enumerate(episodes):
if ep["id"] in done:
continue
if budget.over():
print(f"!! Budget ueberschritten ({budget.cost():.4f} USD) — Abbruch")
break
try:
n, next_id, err = process_episode(db, client, ep, allowed_themes, budget, next_id)
except Exception as e:
n, err = 0, str(e)
total_inserted += n
if err:
failures.append((ep["id"], err))
# Commit nach jeder Episode (Crash-Sicherheit)
db.commit()
print(f" [{i+1}/{len(episodes)}] {ep['id']}: +{n} quotes "
f"(total={total_inserted}, cost=${budget.cost():.4f}, err={'-' if not err else err[:80]})", flush=True)
time.sleep(0.4)
db.commit()
print()
print("=== Zusammenfassung Aufgabe B ===")
print(f" Quotes inserted: {total_inserted}")
print(f" Tokens in={budget.tokens_in} out={budget.tokens_out}")
print(f" Kosten ~${budget.cost():.4f}")
if failures:
print(f" Fehler in {len(failures)} Episoden, erste 5:")
for ep_id, err in failures[:5]:
print(f" {ep_id}: {err[:120]}")
# Sanity-Check: Quotes pro Episode
counts = db.execute(
"SELECT episode_id, COUNT(*) c FROM quotes WHERE podcast_id=? GROUP BY episode_id ORDER BY c",
(PODCAST_ID,),
).fetchall()
print(f" Episoden mit Quotes: {len(counts)}")
if counts:
cs = [c["c"] for c in counts]
print(f" Quotes/Episode: min={min(cs)} max={max(cs)} mean={sum(cs)/len(cs):.1f}")
db.close()
if __name__ == "__main__":
main()

322
scripts/json_utils.py
View File

@ -1,322 +0,0 @@
"""Robuster JSON-Parser fuer LLM-Antworten.
Behebt typische Probleme:
- Markdown-Codefences (```json ... ```)
- Vorspann/Nachspann ausserhalb des JSON-Blocks
- Trailing commas
- Unescaped quotes innerhalb von Strings (heuristisch)
- Smart-Quotes
"""
import json
import re
from typing import Any, Optional
def _strip_codefence(s: str) -> str:
s = s.strip()
if s.startswith("```"):
# entferne erste Zeile ```... und schliessende ```
s = re.sub(r"^```[a-zA-Z0-9_-]*\s*\n?", "", s)
s = re.sub(r"\n?```\s*$", "", s)
return s.strip()
def _find_balanced(s: str, open_char: str, close_char: str) -> Optional[str]:
"""Extrahiere ersten balancierten {...} oder [...]-Block, respektiert String-Literals.
Wenn keine vollstaendige Balance erreicht wird (truncated JSON), wird der bis zum
Ende verfuegbare Block zurueckgegeben — das Repair-Pipeline-Stadium kann den dann
ggf. ergaenzen.
"""
start = s.find(open_char)
if start == -1:
return None
depth = 0
in_str = False
esc = False
for i in range(start, len(s)):
c = s[i]
if in_str:
if esc:
esc = False
elif c == "\\":
esc = True
elif c == '"':
in_str = False
continue
if c == '"':
in_str = True
continue
if c == open_char:
depth += 1
elif c == close_char:
depth -= 1
if depth == 0:
return s[start:i + 1]
# Truncated: gib trotzdem den bisher gesehenen Block zurueck
return s[start:]
def _close_truncated(block: str, open_char: str, close_char: str) -> str:
"""Schliesst einen abgeschnittenen JSON-Block heuristisch.
Ansatz:
1. Scanne Zeichen, tracke (in_string, esc, depth).
2. Wenn am Ende ein String offen ist: schliesse mit ".
3. Schneide einen evtl. unvollstaendigen Wert-Tail nach dem letzten
sicheren Komma/Open-Brace/Close-Brace.
4. Ergaenze fehlende } / ] entsprechend depth.
"""
s = block
in_str = False
esc = False
depth = 0
# last_safe = Position direkt nach einem komplett-abgeschlossenen Element
# (komma, open, close), das heisst: wir koennen dort ohne Datenverlust schneiden.
last_safe = 0
for i, c in enumerate(s):
if in_str:
if esc:
esc = False
elif c == "\\":
esc = True
elif c == '"':
in_str = False
last_safe = i + 1
continue
if c == '"':
in_str = True
continue
if c in "{[":
depth += 1
last_safe = i + 1
elif c in "}]":
depth -= 1
last_safe = i + 1
elif c == ",":
last_safe = i # vor dem Komma ist sicher
elif c == ":":
# Doppelpunkt: kein safe-cut hier
pass
elif not c.isspace():
# Wert-Token (Zahl, true/false/null)
last_safe = i + 1
# Falls String am Ende offen: alle Zeichen behalten, am Ende " ergaenzen.
# Sonst: schneiden auf last_safe (entfernt unvollstaendige Werte/Keys).
if in_str:
# String einfach schliessen, lass Inhalt drin
s = s + '"'
else:
s = s[:last_safe] if last_safe > 0 else s
# Trailing whitespace + comma entfernen
s = re.sub(r"[\s,]+$", "", s)
# Pruefe ob letzter Token ein Key ohne Wert ist: "..." am Ende vor depth-close
# Pattern: ... "key" oder ... "key": (ohne Wert) -> entferne diesen unfertigen Eintrag
# Naive Heuristik: wenn der Inhalt mit "key" oder "key": endet ohne folgenden Wert,
# schneide bis zum letzten , oder { vor dieser Stelle.
# Recompute depth nach den Aenderungen
depth = 0
in_str = False
esc = False
for c in s:
if in_str:
if esc:
esc = False
elif c == "\\":
esc = True
elif c == '"':
in_str = False
continue
if c == '"':
in_str = True
elif c in "{[":
depth += 1
elif c in "}]":
depth -= 1
# Wenn wir mit "key" oder "key": (ohne Wert!) enden, schneide bis vorheriger ,/{.
# Wichtig: nur wenn vor diesem `"..."` ein `,` oder `{` (also Key-Position) liegt,
# nicht wenn ein `:` (Wert-Position) liegt.
tail_match = re.search(r'("[^"]*")(\s*:?)\s*$', s)
if tail_match and not s.rstrip().endswith(("}", "]")):
before = s[:tail_match.start()].rstrip()
prev_char = before[-1] if before else ""
# Nur trimmen, wenn dies ein Key ohne Wert ist (vor sich , oder {)
if prev_char in ",{":
cut = max(s.rfind(",", 0, tail_match.start()), s.rfind("{", 0, tail_match.start()))
if cut > 0:
s = s[:cut].rstrip().rstrip(",")
# depth neu berechnen
depth = 0
in_str = False
esc = False
for c in s:
if in_str:
if esc:
esc = False
elif c == "\\":
esc = True
elif c == '"':
in_str = False
continue
if c == '"':
in_str = True
elif c in "{[":
depth += 1
elif c in "}]":
depth -= 1
# Fehlende Klammern ergaenzen — kann gemischt sein, einfach von rechts pruefen
# was offen ist.
# Wir wissen: am Anfang ist open_char, depth zaehlt {[ +1 und }] -1.
# Fuer korrektes Schliessen muessen wir die Reihenfolge der offenen
# Klammern kennen. Vereinfachung: zaehle separat.
open_curly = s.count("{") - s.count("}")
open_brack = s.count("[") - s.count("]")
# Annahme: schliessende Klammern in umgekehrter Reihenfolge der oeffnenden
# Naive: suche letzte offene Klammer und schliesse damit.
while open_curly > 0 or open_brack > 0:
# finde letzte offene Klammer im String (ausserhalb von strings)
last_open = None
in_str = False
esc = False
for i, c in enumerate(s):
if in_str:
if esc:
esc = False
elif c == "\\":
esc = True
elif c == '"':
in_str = False
continue
if c == '"':
in_str = True
elif c in "{[":
last_open = (i, c)
if last_open is None:
break
# schliesse die zuletzt geoeffnete (innerste am rechten Rand)
# Aber: koennten dazwischen schon geschlossene sein. Vereinfacht:
# schliesse ab Ende.
if open_curly > 0 and (open_brack == 0 or last_open[1] == "{"):
s += "}"
open_curly -= 1
elif open_brack > 0:
s += "]"
open_brack -= 1
else:
break
return s
def _normalize_quotes(s: str) -> str:
# Ersetze typografische Anfuehrungszeichen durch ASCII (nur ausserhalb von String-Werten heikel,
# aber pragmatisch: Modelle setzen sie fast nur als Begrenzer falsch).
return (s.replace("“", '"').replace("”", '"')
.replace("„", '"').replace("‟", '"')
.replace("‘", "'").replace("’", "'"))
def _strip_trailing_commas(s: str) -> str:
return re.sub(r",(\s*[}\]])", r"\1", s)
def _escape_inner_quotes(block: str) -> str:
"""Heuristik: in JSON-Strings unescaped " in escaped \" umwandeln.
Idee: Wir scannen Token fuer Token. Wenn wir in einem String sind und ein " auftritt,
pruefen wir, ob danach ein Strukturzeichen (`,`, `}`, `]`, `:` mit moeglichem Whitespace)
folgt. Wenn nicht, ist es ein eingebettetes Anfuehrungszeichen und wird escaped.
"""
out = []
in_str = False
esc = False
i = 0
while i < len(block):
c = block[i]
if not in_str:
out.append(c)
if c == '"':
in_str = True
i += 1
continue
# in_str = True
if esc:
out.append(c)
esc = False
i += 1
continue
if c == "\\":
out.append(c)
esc = True
i += 1
continue
if c == '"':
# Schau voraus: erlaubt nur whitespace + [,}\]:]
j = i + 1
while j < len(block) and block[j] in " \t\r\n":
j += 1
if j >= len(block) or block[j] in ",}]:":
# echtes Stringende
out.append(c)
in_str = False
else:
# eingebettetes Quote -> escapen
out.append("\\\"")
i += 1
continue
out.append(c)
i += 1
return "".join(out)
def parse_llm_json(content: str, expect: str = "object") -> Any:
"""Parst eine LLM-Antwort robust als JSON.
Args:
content: Rohantwort des Modells.
expect: 'object' oder 'array'.
Returns:
geparstes Python-Objekt.
Raises:
ValueError, wenn nichts geparst werden konnte.
"""
if content is None:
raise ValueError("leere Antwort")
s = _normalize_quotes(_strip_codefence(content))
open_c, close_c = ("{", "}") if expect == "object" else ("[", "]")
block = _find_balanced(s, open_c, close_c)
if block is None:
# Fallback: vielleicht steht doch das andere Format drin
alt_open, alt_close = ("[", "]") if expect == "object" else ("{", "}")
block = _find_balanced(s, alt_open, alt_close)
if block is None:
raise ValueError(f"kein {expect} gefunden in: {content[:200]}")
closed = _close_truncated(block, open_c, close_c)
attempts = [
block,
_strip_trailing_commas(block),
_escape_inner_quotes(block),
_strip_trailing_commas(_escape_inner_quotes(block)),
closed,
_strip_trailing_commas(closed),
_escape_inner_quotes(closed),
_strip_trailing_commas(_escape_inner_quotes(closed)),
]
last_err = None
for attempt in attempts:
try:
return json.loads(attempt)
except json.JSONDecodeError as e:
last_err = e
continue
raise ValueError(f"JSON-Parse fehlgeschlagen nach Repair-Versuchen: {last_err}; raw={content[:300]}")

239
scripts/rerun_errors.py
View File

@ -1,239 +0,0 @@
#!/usr/bin/env python3
"""Re-Run der fehlerhaften Records in `debates` und `argument_links` mit robustem JSON-Parser.
Vorgehen:
- Lade alle Records mit topic='error' (debates) bzw. relation='error' (argument_links)
- Hole Source-/Target-Paragraph aus DB
- Sende erneut an qwen-plus, parse mit json_utils.parse_llm_json
- UPDATE bestehenden Eintrag
Nutzung:
DASHSCOPE_API_KEY=... python3 rerun_errors.py [db-pfad]
"""
import json
import os
import sys
import time
import sqlite3
from openai import OpenAI
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
from json_utils import parse_llm_json
DB_PATH = sys.argv[1] if len(sys.argv) > 1 else "data/db.sqlite"
API_KEY = os.environ.get("DASHSCOPE_API_KEY", "")
BASE_URL = "https://dashscope-intl.aliyuncs.com/compatible-mode/v1"
MODEL = "qwen-plus"
# Kosten qwen-plus (DashScope intl, Stand 2025): $0.0008 / 1k input, $0.002 / 1k output
COST_IN = 0.0008 / 1000
COST_OUT = 0.002 / 1000
DEBATES_SYSTEM = """Du bist ein Diskursanalyst. Du erhältst zwei Textabschnitte aus VERSCHIEDENEN Podcasts, die dasselbe Thema behandeln.
Erstelle eine kurze Gegenüberstellung. Antworte NUR mit JSON:
{
"topic": "Das gemeinsame Thema in 3-5 Wörtern",
"agreement": "Worin stimmen beide überein? (1-2 Sätze)",
"divergence": "Worin unterscheiden sie sich? (1-2 Sätze, oder 'keine wesentliche Divergenz')",
"insight": "Was lernt man durch die Gegenüberstellung, das man aus keinem der beiden allein lernen würde? (1 Satz)"
}"""
ARGS_SYSTEM = """Du bist ein Diskursanalyst. Du erhältst zwei Textabschnitte aus Podcast-Transkripten.
Klassifiziere die logische Relation zwischen ihnen. Antworte NUR mit einem JSON-Objekt:
{"relation": "...", "confidence": 0.0-1.0, "explanation": "Ein Satz Begruendung"}
Moegliche Relationen:
- "erweitert": B baut auf A auf, ergaenzt, vertieft
- "widerspricht": B widerspricht A, nennt Gegenargument
- "belegt": B liefert Evidenz/Daten fuer A's These
- "relativiert": B schraenkt A ein, nennt Ausnahmen/Bedingungen
- "gleicher_punkt": A und B sagen im Kern dasselbe
- "kein_bezug": Trotz thematischer Naehe kein logischer Bezug"""
class Budget:
def __init__(self, hard_limit_usd):
self.hard_limit = hard_limit_usd
self.tokens_in = 0
self.tokens_out = 0
def add(self, usage):
if usage:
self.tokens_in += getattr(usage, "prompt_tokens", 0) or 0
self.tokens_out += getattr(usage, "completion_tokens", 0) or 0
def cost(self):
return self.tokens_in * COST_IN + self.tokens_out * COST_OUT
def over(self):
return self.cost() > self.hard_limit
def call_llm(client, system, user, max_tokens, budget):
last_err = None
for attempt in range(2):
try:
resp = client.chat.completions.create(
model=MODEL,
messages=[
{"role": "system", "content": system},
{"role": "user", "content": user},
],
temperature=0.1 if "Klassifiziere" in system else 0.2,
max_tokens=max_tokens,
)
budget.add(getattr(resp, "usage", None))
content = resp.choices[0].message.content
try:
return parse_llm_json(content, expect="object"), None
except ValueError as pe:
last_err = f"parse: {pe}"
# Ein Retry mit anderer Temperature waere moeglich; wir akzeptieren parse-fail
break
except Exception as e:
last_err = str(e)
if attempt < 1:
time.sleep(2)
continue
return None, last_err
def rerun_debates(db, client, budget):
rows = db.execute("""
SELECT d.id as did, d.source_podcast, d.source_episode, d.source_idx,
d.target_podcast, d.target_episode, d.target_idx,
p1.text as source_text, p2.text as target_text,
pc1.name as source_pname, pc2.name as target_pname,
e1.title as source_title, e1.guest as source_guest,
e2.title as target_title, e2.guest as target_guest
FROM debates d
JOIN paragraphs p1 ON d.source_podcast = p1.podcast_id AND d.source_episode = p1.episode_id AND d.source_idx = p1.idx
JOIN paragraphs p2 ON d.target_podcast = p2.podcast_id AND d.target_episode = p2.episode_id AND d.target_idx = p2.idx
JOIN episodes e1 ON d.source_podcast = e1.podcast_id AND d.source_episode = e1.id
JOIN episodes e2 ON d.target_podcast = e2.podcast_id AND d.target_episode = e2.id
JOIN podcasts pc1 ON d.source_podcast = pc1.id
JOIN podcasts pc2 ON d.target_podcast = pc2.id
WHERE d.topic = 'error'
""").fetchall()
print(f"[debates] {len(rows)} Error-Records zu reparieren")
fixed = 0
still_err = 0
for i, r in enumerate(rows):
if budget.over():
print(f"[debates] Kosten-Limit erreicht bei {i}/{len(rows)} (cost=${budget.cost():.4f})")
break
meta_a = f"{r['source_pname']} / {r['source_episode']}: {r['source_title']} ({r['source_guest']})"
meta_b = f"{r['target_pname']} / {r['target_episode']}: {r['target_title']} ({r['target_guest']})"
user = (f"Podcast A — {meta_a}:\n\"{r['source_text'][:800]}\"\n\n"
f"Podcast B — {meta_b}:\n\"{r['target_text'][:800]}\"\n\n"
"Erstelle die Gegenueberstellung.")
result, err = call_llm(client, DEBATES_SYSTEM, user, 600, budget)
if result is not None and result.get("topic"):
db.execute(
"UPDATE debates SET topic=?, agreement=?, divergence=?, insight=? WHERE id=?",
(result.get("topic", "")[:120],
result.get("agreement", "")[:1000],
result.get("divergence", "")[:1000],
result.get("insight", "")[:1000],
r["did"]),
)
fixed += 1
else:
still_err += 1
db.execute(
"UPDATE debates SET insight=? WHERE id=?",
(f"rerun-failed: {err}"[:500], r["did"]),
)
if (i + 1) % 10 == 0:
db.commit()
print(f" [debates] {i+1}/{len(rows)} gefixt={fixed} still_err={still_err} cost=${budget.cost():.4f}")
time.sleep(0.3)
db.commit()
print(f"[debates] fertig: gefixt={fixed} still_err={still_err}")
return fixed, still_err
def rerun_args(db, client, budget):
rows = db.execute("""
SELECT a.id as aid, a.source_podcast, a.source_episode, a.source_idx,
a.target_podcast, a.target_episode, a.target_idx,
p1.text as source_text, p2.text as target_text,
e1.title as source_title, e1.guest as source_guest,
e2.title as target_title, e2.guest as target_guest
FROM argument_links a
JOIN paragraphs p1 ON a.source_podcast = p1.podcast_id AND a.source_episode = p1.episode_id AND a.source_idx = p1.idx
JOIN paragraphs p2 ON a.target_podcast = p2.podcast_id AND a.target_episode = p2.episode_id AND a.target_idx = p2.idx
JOIN episodes e1 ON a.source_podcast = e1.podcast_id AND a.source_episode = e1.id
JOIN episodes e2 ON a.target_podcast = e2.podcast_id AND a.target_episode = e2.id
WHERE a.relation = 'error'
""").fetchall()
print(f"[argument_links] {len(rows)} Error-Records zu reparieren")
fixed = 0
still_err = 0
for i, r in enumerate(rows):
if budget.over():
print(f"[args] Kosten-Limit erreicht bei {i}/{len(rows)} (cost=${budget.cost():.4f})")
break
meta_a = f"{r['source_episode']}: {r['source_title']} — {r['source_guest']}"
meta_b = f"{r['target_episode']}: {r['target_title']} — {r['target_guest']}"
user = (f"Absatz A ({meta_a}):\n\"{r['source_text'][:800]}\"\n\n"
f"Absatz B ({meta_b}):\n\"{r['target_text'][:800]}\"\n\n"
"Welche logische Relation besteht von A zu B?")
result, err = call_llm(client, ARGS_SYSTEM, user, 350, budget)
if result is not None and result.get("relation") and result.get("relation") != "error":
db.execute(
"UPDATE argument_links SET relation=?, confidence=?, explanation=? WHERE id=?",
(str(result.get("relation", ""))[:60],
float(result.get("confidence", 0) or 0),
str(result.get("explanation", ""))[:1000],
r["aid"]),
)
fixed += 1
else:
still_err += 1
db.execute(
"UPDATE argument_links SET explanation=? WHERE id=?",
(f"rerun-failed: {err}"[:500], r["aid"]),
)
if (i + 1) % 20 == 0:
db.commit()
print(f" [args] {i+1}/{len(rows)} gefixt={fixed} still_err={still_err} cost=${budget.cost():.4f}")
time.sleep(0.25)
db.commit()
print(f"[argument_links] fertig: gefixt={fixed} still_err={still_err}")
return fixed, still_err
def main():
if not API_KEY:
print("DASHSCOPE_API_KEY nicht gesetzt.")
sys.exit(1)
client = OpenAI(api_key=API_KEY, base_url=BASE_URL, timeout=30.0, max_retries=1)
db = sqlite3.connect(DB_PATH, timeout=30)
db.row_factory = sqlite3.Row
db.execute("PRAGMA busy_timeout=30000")
# Aufgabe-A-Budget: 1 USD
budget = Budget(hard_limit_usd=1.0)
print(f"DB: {DB_PATH}, Modell: {MODEL}")
d_fixed, d_err = rerun_debates(db, client, budget)
a_fixed, a_err = rerun_args(db, client, budget)
print()
print("=== Zusammenfassung Aufgabe A ===")
print(f" debates gefixt={d_fixed} still_err={d_err}")
print(f" argument_links gefixt={a_fixed} still_err={a_err}")
print(f" Tokens in={budget.tokens_in} out={budget.tokens_out}")
print(f" Kosten ~${budget.cost():.4f}")
db.close()
if __name__ == "__main__":
main()

479
webapp/index.html
View File

@ -591,16 +591,6 @@ const TranscriptView = {
panel.innerHTML = html;
// Cache word elements + start times for fast binary-search sync
if (this.words) {
this._wordEls = Array.from(panel.querySelectorAll('.word[data-ws]'));
this._wordTimes = this._wordEls.map(el => parseFloat(el.dataset.ws));
this.activeWordIdx = -1;
} else {
this._wordEls = null;
this._wordTimes = null;
}
// Detect user scroll
panel.onscroll = () => { this.userScrolled = true; };
@ -630,51 +620,27 @@ const TranscriptView = {
}
}
// Word-level sync (#12) — binary search + delta updates
if (!this._wordEls || this._wordEls.length === 0) return;
const times = this._wordTimes;
let lo = 0, hi = times.length - 1, newIdx = -1;
while (lo <= hi) {
const mid = (lo + hi) >> 1;
if (times[mid] <= time) { newIdx = mid; lo = mid + 1; }
else hi = mid - 1;
}
// Past the end of the last word? Treat it as spoken, no active word.
if (newIdx >= 0) {
const we = parseFloat(this._wordEls[newIdx].dataset.we);
if (time > we + 0.05) newIdx = -2; // sentinel: all up to length-1 spoken
}
const targetIdx = newIdx === -2 ? this._wordEls.length - 1 : newIdx;
const prevIdx = this.activeWordIdx;
if (targetIdx === prevIdx && newIdx !== -2) return;
// Word-level sync (#12)
if (this.words) {
const prev = document.querySelector('.word.word-active');
if (prev) prev.classList.replace('word-active', 'word-spoken');
if (targetIdx > prevIdx) {
// Forward: mark old active + words in between as spoken
if (prevIdx >= 0) {
const prevEl = this._wordEls[prevIdx];
prevEl.classList.remove('word-active');
prevEl.classList.add('word-spoken');
}
for (let i = Math.max(0, prevIdx + 1); i < targetIdx; i++) {
this._wordEls[i].classList.add('word-spoken');
}
if (newIdx >= 0) {
this._wordEls[targetIdx].classList.add('word-active');
} else {
// Past last word
this._wordEls[targetIdx].classList.add('word-spoken');
}
} else if (targetIdx < prevIdx) {
// Backward seek: clear classes from targetIdx+1 .. prevIdx
for (let i = targetIdx + 1; i <= prevIdx; i++) {
this._wordEls[i].classList.remove('word-active', 'word-spoken');
}
if (targetIdx >= 0 && newIdx !== -2) {
this._wordEls[targetIdx].classList.remove('word-spoken');
this._wordEls[targetIdx].classList.add('word-active');
// Find current word by time
const wordEl = document.querySelector(`.word[data-ws]`);
if (wordEl) {
const allWords = document.querySelectorAll('.word[data-ws]');
for (const w of allWords) {
const ws = parseFloat(w.dataset.ws);
const we = parseFloat(w.dataset.we);
if (time >= ws && time < we) {
w.classList.add('word-active');
break;
} else if (time >= we) {
w.classList.add('word-spoken');
}
}
}
}
this.activeWordIdx = newIdx === -2 ? targetIdx : newIdx;
},
seekTo(time) {
@ -735,331 +701,6 @@ const TranscriptView = {
}
};
// ── Analysis View (#16 claims / #17 questions) ──
const AnalysisView = {
visible: false,
mode: null,
episodeId: null,
items: null,
filter: null,
answeredFilter: null,
async show(episodeId, mode) {
if (!CURRENT_PODCAST) return;
TranscriptView.hide(); AnalysisView.hide(); GapsView.hide(); ShiftsView.hide();
this.episodeId = episodeId;
this.mode = mode;
this.visible = true;
this.filter = null;
this.answeredFilter = null;
const panel = document.getElementById('panel');
const ep = DATA.episodes.find(e => e.id === episodeId);
const staffel = DATA.staffeln.find(s => s.id === ep.staffel);
panel.innerHTML = `<h2 style="color:${staffel.color}">${ep.id}: ${ep.title} — ${mode === 'claims' ? 'Behauptungen' : 'Fragen'}</h2><p class="subtitle">Lädt …</p>`;
try {
const r = await fetch(`${API_BASE}/api/podcasts/${CURRENT_PODCAST}/episodes/${episodeId}/${mode}`);
const data = await r.json();
this.items = data[mode] || [];
} catch (e) {
panel.innerHTML += `<p style="color:var(--accent-warm)">Fehler: ${escHtml(e.message)}</p>`;
return;
}
this.render();
},
render() {
if (!this.visible || !this.items) return;
const panel = document.getElementById('panel');
const ep = DATA.episodes.find(e => e.id === this.episodeId);
const staffel = DATA.staffeln.find(s => s.id === ep.staffel);
const typeKey = this.mode === 'claims' ? 'claim_type' : 'question_type';
let html = `<h2 style="color:${staffel.color}">${ep.id}: ${ep.title} — ${this.mode === 'claims' ? 'Behauptungen' : 'Fragen'}</h2>`;
html += `<p class="subtitle">${ep.guest} · ${this.items.length} Einträge</p>`;
html += `<button class="transcript-toggle" onclick="showEpisodeById('${ep.id}')">← Zurück zur Episode</button>`;
// Type-Filter
const types = [...new Set(this.items.map(i => i[typeKey]))].sort();
html += `<div style="margin-top:12px;display:flex;flex-wrap:wrap;gap:6px">`;
const chip = (label, count, active, onclick) =>
`<span class="theme-tag" style="cursor:pointer;${active ? 'background:var(--accent)33;border-color:var(--accent);color:var(--text)' : ''}" onclick="${onclick}">${label} (${count})</span>`;
html += chip('alle', this.items.length, !this.filter, `AnalysisView.setFilter(null)`);
types.forEach(t => {
const n = this.items.filter(i => i[typeKey] === t).length;
html += chip(t, n, this.filter === t, `AnalysisView.setFilter('${t}')`);
});
html += '</div>';
// Answered-Filter (nur Fragen)
if (this.mode === 'questions') {
html += `<div style="margin-top:6px;display:flex;flex-wrap:wrap;gap:6px">`;
const states = ['no', 'partial', 'yes', 'self_answered'];
const labels = {no:'unbeantwortet', partial:'teilweise', yes:'beantwortet', self_answered:'selbst beantwortet'};
html += chip('beliebig', this.items.length, !this.answeredFilter, `AnalysisView.setAnsweredFilter(null)`);
states.forEach(s => {
const n = this.items.filter(i => i.answered === s).length;
if (n > 0) html += chip(labels[s], n, this.answeredFilter === s, `AnalysisView.setAnsweredFilter('${s}')`);
});
html += '</div>';
}
// Items
let filtered = this.items;
if (this.filter) filtered = filtered.filter(i => i[typeKey] === this.filter);
if (this.answeredFilter) filtered = filtered.filter(i => i.answered === this.answeredFilter);
if (filtered.length === 0) {
html += `<p class="subtitle" style="margin-top:16px">Keine Einträge mit aktuellem Filter.</p>`;
}
filtered.forEach(it => {
const ts = (it.start_time !== null && it.start_time !== undefined) ? fmtTime(it.start_time) : '–';
const text = this.mode === 'claims' ? it.claim_text : it.question_text;
const type = it[typeKey];
let badges = `<span class="theme-tag" style="font-size:10px;margin-right:4px">${type}</span>`;
if (this.mode === 'claims' && it.verifiable) {
badges += `<span class="theme-tag" style="font-size:10px;margin-right:4px;opacity:0.7">verifizierbar</span>`;
}
if (this.mode === 'questions') {
const a = it.answered;
const lbl = {no:'offen', partial:'teilweise', yes:'beantwortet', self_answered:'selbst beantwortet'}[a] || a;
const col = a === 'no' ? 'var(--accent-warm)' : (a === 'yes' ? 'var(--accent-green)' : 'var(--text-muted)');
badges += `<span class="theme-tag" style="font-size:10px;margin-right:4px;color:${col};border-color:${col}44">${lbl}</span>`;
}
html += `<div class="transcript-para" onclick="AnalysisView.jumpTo(${it.start_time || 0})">`;
html += `<span class="ts">${ts}</span>`;
html += badges;
html += escHtml(text);
html += '</div>';
});
panel.innerHTML = html;
},
setFilter(t) { this.filter = t; this.render(); },
setAnsweredFilter(s) { this.answeredFilter = s; this.render(); },
jumpTo(time) {
TranscriptView.show(this.episodeId, time);
},
hide() { this.visible = false; this.episodeId = null; this.items = null; }
};
// ── Gaps View (#14 Leerstellen-Detektor) ──
const GapsView = {
visible: false,
data: null,
missingFilter: null,
minSize: 0,
async show() {
TranscriptView.hide(); AnalysisView.hide(); GapsView.hide(); ShiftsView.hide();
this.visible = true;
const panel = document.getElementById('panel');
panel.innerHTML = `<h2>Leerstellen</h2><p class="subtitle">Lädt …</p>`;
try {
const r = await fetch(`${API_BASE}/api/analyses/gaps`);
const data = await r.json();
if (!data.available) {
panel.innerHTML = `<h2>Leerstellen</h2><p class="subtitle">Keine Leerstellen-Analyse vorhanden.</p>`;
return;
}
this.data = data;
} catch (e) {
panel.innerHTML = `<h2>Leerstellen</h2><p style="color:var(--accent-warm)">Fehler: ${escHtml(e.message)}</p>`;
return;
}
this.render();
},
render() {
if (!this.visible || !this.data) return;
const panel = document.getElementById('panel');
const d = this.data;
let html = `<h2>Leerstellen</h2>`;
html += `<p class="subtitle">${d.gaps.length} Themen-Cluster fehlen in mindestens einem Podcast · ${d.n_clusters} Cluster aus ${d.total_paragraphs} Absätzen über ${(d.podcasts || []).join(', ')}</p>`;
const podcasts = d.podcasts || [];
const chip = (label, count, active, onclick) =>
`<span class="theme-tag" style="cursor:pointer;${active ? 'background:var(--accent)33;border-color:var(--accent);color:var(--text)' : ''}" onclick="${onclick}">${label}${count !== null ? ` (${count})` : ''}</span>`;
html += `<div style="margin-top:12px;display:flex;flex-wrap:wrap;gap:6px">`;
html += chip('alle Podcasts', d.gaps.length, !this.missingFilter, `GapsView.setMissing(null)`);
podcasts.forEach(p => {
const n = d.gaps.filter(g => g.missing_in === p).length;
if (n > 0) html += chip(`fehlt in ${p}`, n, this.missingFilter === p, `GapsView.setMissing('${p}')`);
});
html += '</div>';
let filtered = d.gaps;
if (this.missingFilter) filtered = filtered.filter(g => g.missing_in === this.missingFilter);
if (this.minSize > 0) filtered = filtered.filter(g => g.cluster_size >= this.minSize);
if (filtered.length === 0) {
html += `<p class="subtitle" style="margin-top:16px">Keine Leerstellen mit aktuellem Filter.</p>`;
}
filtered.forEach(g => {
html += `<div class="transcript-para" style="cursor:default">`;
html += `<div style="display:flex;justify-content:space-between;gap:8px;margin-bottom:6px">`;
html += `<strong>${escHtml(g.cluster_label)}</strong>`;
html += `<span class="theme-tag" style="font-size:10px;color:var(--accent-warm);border-color:var(--accent-warm)44">fehlt in ${escHtml(g.missing_in)}</span>`;
html += `</div>`;
html += `<div class="subtitle" style="margin-bottom:6px">${g.cluster_size} Absätze · ${g.present_in_count} im anderen Podcast</div>`;
(g.representative || []).slice(0, 3).forEach(r => {
const epClickable = r.podcast === CURRENT_PODCAST;
const click = epClickable ? `onclick="GapsView.jumpTo('${r.episode}')"` : '';
const cur = epClickable ? 'cursor:pointer;' : '';
html += `<div style="${cur}padding:6px 0;border-top:1px solid var(--border)" ${click}>`;
html += `<span class="ts">${escHtml(r.podcast)}/${escHtml(r.episode)}</span> `;
html += escHtml(r.text);
html += `</div>`;
});
html += `</div>`;
});
panel.innerHTML = html;
},
setMissing(p) { this.missingFilter = p; this.render(); },
jumpTo(episodeId) {
if (!CURRENT_PODCAST) return;
const ep = DATA && DATA.episodes && DATA.episodes.find(e => e.id === episodeId);
if (ep) showEpisode(ep);
},
hide() { this.visible = false; }
};
// ── Shifts View (#15 Narrative Shift Detection) ──
const ShiftsView = {
visible: false,
data: null,
podcastFilter: null,
themeFilter: null,
expanded: {},
async show() {
TranscriptView.hide(); AnalysisView.hide(); GapsView.hide(); ShiftsView.hide();
this.visible = true;
const panel = document.getElementById('panel');
panel.innerHTML = `<h2>Narrative Shifts</h2><p class="subtitle">Lädt …</p>`;
try {
const r = await fetch(`${API_BASE}/api/analyses/shifts`);
const data = await r.json();
if (!data.available) {
panel.innerHTML = `<h2>Narrative Shifts</h2><p class="subtitle">Keine Shift-Analyse vorhanden.</p>`;
return;
}
this.data = data;
} catch (e) {
panel.innerHTML = `<h2>Narrative Shifts</h2><p style="color:var(--accent-warm)">Fehler: ${escHtml(e.message)}</p>`;
return;
}
this.render();
},
render() {
if (!this.visible || !this.data) return;
const panel = document.getElementById('panel');
const d = this.data;
let html = `<h2>Narrative Shifts</h2>`;
html += `<p class="subtitle">${d.shifts.length} Theme-Verläufe in ${(d.podcasts || []).join(', ')} · ${d.total_themes_tracked} Themen getrackt · semantische Drift zwischen aufeinanderfolgenden Episoden</p>`;
const chip = (label, count, active, onclick) =>
`<span class="theme-tag" style="cursor:pointer;${active ? 'background:var(--accent)33;border-color:var(--accent);color:var(--text)' : ''}" onclick="${onclick}">${label}${count !== null ? ` (${count})` : ''}</span>`;
html += `<div style="margin-top:12px;display:flex;flex-wrap:wrap;gap:6px">`;
html += chip('alle Podcasts', d.shifts.length, !this.podcastFilter, `ShiftsView.setPodcast(null)`);
(d.podcasts || []).forEach(p => {
const n = d.shifts.filter(s => s.podcast === p).length;
if (n > 0) html += chip(p, n, this.podcastFilter === p, `ShiftsView.setPodcast('${p}')`);
});
html += '</div>';
const themesPresent = [...new Set(d.shifts.map(s => s.theme))].sort();
html += `<div style="margin-top:6px;display:flex;flex-wrap:wrap;gap:6px">`;
html += chip('alle Themen', null, !this.themeFilter, `ShiftsView.setTheme(null)`);
themesPresent.forEach(t => {
html += chip(t, null, this.themeFilter === t, `ShiftsView.setTheme('${t}')`);
});
html += '</div>';
let filtered = d.shifts;
if (this.podcastFilter) filtered = filtered.filter(s => s.podcast === this.podcastFilter);
if (this.themeFilter) filtered = filtered.filter(s => s.theme === this.themeFilter);
filtered = filtered.slice().sort((a, b) => (b.max_drift || 0) - (a.max_drift || 0));
if (filtered.length === 0) {
html += `<p class="subtitle" style="margin-top:16px">Keine Shifts mit aktuellem Filter.</p>`;
}
filtered.forEach(s => {
const key = `${s.podcast}__${s.theme}`;
const isOpen = !!this.expanded[key];
const meanPct = ((s.mean_drift || 0) * 100).toFixed(0);
const maxPct = ((s.max_drift || 0) * 100).toFixed(0);
const spikes = s.spikes || [];
html += `<div class="transcript-para" style="cursor:default">`;
html += `<div style="display:flex;justify-content:space-between;gap:8px;margin-bottom:6px;align-items:baseline">`;
html += `<strong>${escHtml(s.theme)}</strong>`;
html += `<span class="theme-tag" style="font-size:10px">${escHtml(s.podcast)}</span>`;
html += `</div>`;
html += `<div class="subtitle" style="margin-bottom:6px">`;
html += `${s.n_episodes} Episoden · Mittel-Drift ${meanPct}% · Max-Drift ${maxPct}%`;
if (spikes.length) html += ` · <span style="color:var(--accent-warm)">${spikes.length} Spike${spikes.length > 1 ? 's' : ''}</span>`;
html += `</div>`;
// Top-Drifts (Spikes oder Top 3)
const top = spikes.length ? spikes : (s.drifts || []).slice().sort((a,b) => (b.drift||0)-(a.drift||0)).slice(0, 3);
top.forEach(dr => {
const pct = ((dr.drift || 0) * 100).toFixed(0);
const fromClick = `ShiftsView.jumpTo('${s.podcast}','${dr.from}')`;
const toClick = `ShiftsView.jumpTo('${s.podcast}','${dr.to}')`;
html += `<div style="display:flex;align-items:center;gap:8px;padding:4px 0;border-top:1px solid var(--border);font-size:13px">`;
html += `<span class="ts" style="cursor:pointer" onclick="${fromClick}">${escHtml(dr.from)}</span>`;
html += `<span style="color:var(--text-muted)">→</span>`;
html += `<span class="ts" style="cursor:pointer" onclick="${toClick}">${escHtml(dr.to)}</span>`;
html += `<span style="margin-left:auto;color:${(dr.drift||0) > 0.5 ? 'var(--accent-warm)' : 'var(--text-muted)'}">${pct}%</span>`;
html += `</div>`;
});
// Toggle für vollständige Drift-Sequenz
const allDrifts = s.drifts || [];
if (allDrifts.length > top.length) {
html += `<div style="margin-top:6px"><span class="theme-tag" style="cursor:pointer;font-size:11px" onclick="ShiftsView.toggle('${key}')">${isOpen ? 'verkürzen' : `alle ${allDrifts.length} Übergänge zeigen`}</span></div>`;
if (isOpen) {
html += `<div style="margin-top:6px;display:flex;flex-wrap:wrap;gap:4px">`;
allDrifts.forEach(dr => {
const pct = ((dr.drift || 0) * 100).toFixed(0);
const intensity = Math.min(1, (dr.drift || 0) / 0.6);
const bg = `rgba(220,120,80,${(0.1 + intensity * 0.5).toFixed(2)})`;
html += `<span title="${escHtml(dr.from)} → ${escHtml(dr.to)}: ${pct}%" style="font-size:10px;padding:2px 6px;border-radius:3px;background:${bg};cursor:pointer" onclick="ShiftsView.jumpTo('${s.podcast}','${dr.to}')">${escHtml(dr.to)} ${pct}%</span>`;
});
html += `</div>`;
}
}
html += `</div>`;
});
panel.innerHTML = html;
},
setPodcast(p) { this.podcastFilter = p; this.render(); },
setTheme(t) { this.themeFilter = t; this.render(); },
toggle(key) { this.expanded[key] = !this.expanded[key]; this.render(); },
jumpTo(podcastId, episodeId) {
if (CURRENT_PODCAST !== podcastId) return;
const ep = DATA && DATA.episodes && DATA.episodes.find(e => e.id === episodeId);
if (ep) showEpisode(ep);
},
hide() { this.visible = false; }
};
// ── Search ──
const Search = {
init() {
@ -1156,7 +797,7 @@ const Search = {
showResults(results, query) {
const panel = document.getElementById('panel');
TranscriptView.hide(); AnalysisView.hide(); GapsView.hide(); ShiftsView.hide();
TranscriptView.hide();
if (results.length === 0) {
panel.innerHTML = `<p class="subtitle">Keine Treffer für "${escHtml(query)}"</p>`;
@ -1184,7 +825,7 @@ const Search = {
},
showSemanticResults(results, query) {
TranscriptView.hide(); AnalysisView.hide(); GapsView.hide(); ShiftsView.hide();
TranscriptView.hide();
const panel = document.getElementById('panel');
let html = `<h2>${results.length} semantische Treffer für "${escHtml(query)}" <span class="semantic-badge">KI</span></h2>`;
results.forEach(r => {
@ -1197,7 +838,7 @@ const Search = {
},
showApiResults(results, query) {
TranscriptView.hide(); AnalysisView.hide(); GapsView.hide(); ShiftsView.hide();
TranscriptView.hide();
const panel = document.getElementById('panel');
let html = `<h2>${results.length} Treffer für "${escHtml(query)}"</h2>`;
results.forEach(r => {
@ -1337,8 +978,6 @@ function showPodcastSelector(podcasts) {
if (podcasts.length > 1) {
selectorHtml += '<div class="compare-actions">';
selectorHtml += '<button class="compare-btn" onclick="startCompare()">Podcasts vergleichen</button>';
selectorHtml += '<button class="compare-btn" onclick="GapsView.show()">Leerstellen anzeigen</button>';
selectorHtml += '<button class="compare-btn" onclick="ShiftsView.show()">Narrative Shifts</button>';
selectorHtml += '</div>';
}
@ -1485,15 +1124,11 @@ function init() {
document.getElementById('app-title').innerHTML = ALL_PODCASTS.length > 1
? `<span style="cursor:pointer" onclick="showPodcastList()" title="Zurück zur Übersicht">←</span> <span>${escHtml(name)}</span>`
: `<span>${escHtml(name)}</span>`;
const gapsBtn = ALL_PODCASTS.length > 1
? `<p style="margin-top:12px"><button class="transcript-toggle" onclick="GapsView.show()">Leerstellen anzeigen</button> <button class="transcript-toggle" onclick="ShiftsView.show()">Narrative Shifts</button></p>`
: '';
document.getElementById('welcome-panel').innerHTML = `
<h2>${escHtml(name)}</h2>
<p>${escHtml(DATA.description || '')}<br>
${DATA.episodes.length} Folgen, ${DATA.staffeln.length} Staffeln, ${DATA.quotes.length} Zitate</p>
<p style="margin-top:16px">Klicke auf einen Themenknoten oder eine Episode.</p>
${gapsBtn}`;
<p style="margin-top:16px">Klicke auf einen Themenknoten oder eine Episode.</p>`;
buildFilters();
// Wait for DOM to render the SVG element before building the graph
@ -1548,27 +1183,16 @@ function buildGraph() {
svg.attr('viewBox', `0 0 ${W} ${H}`).attr('preserveAspectRatio', 'xMidYMid meet');
const nodes = [], links = [], episodeMap = {};
const hasThemes = (DATA.themes || []).length > 0;
const hasQuotes = (DATA.quotes || []).length > 0;
nodes.push({ id: 'center', type: 'center', label: (DATA.name || 'PODCAST').replace(/\s+/g, '\n'),
r: 40 * sc, fx: W / 2, fy: H / 2, color: '#60a5fa' });
if (hasThemes) {
DATA.themes.forEach(t => {
const ml = isMobile ? 18 : 25;
nodes.push({ id: t.id, type: 'theme', label: t.label.length > ml ? t.label.substring(0, ml - 3) + '…' : t.label,
fullLabel: t.label, description: t.description, r: 28 * sc, color: t.color, episodes: t.episodes });
links.push({ source: 'center', target: t.id, type: 'center-theme' });
});
} else {
// Fallback: staffeln as hubs
DATA.staffeln.forEach(s => {
nodes.push({ id: `staffel-${s.id}`, type: 'staffel', label: `S${s.id}: ${s.name}`,
fullLabel: s.name, staffel: s.id, r: 28 * sc, color: s.color });
links.push({ source: 'center', target: `staffel-${s.id}`, type: 'center-theme' });
});
}
DATA.episodes.forEach(ep => {
const st = DATA.staffeln.find(s => s.id === ep.staffel);
@ -1578,19 +1202,10 @@ function buildGraph() {
episodeMap[ep.id] = n;
});
if (hasThemes) {
DATA.themes.forEach(t => t.episodes.forEach(epId => {
if (episodeMap[epId]) links.push({ source: t.id, target: epId, type: 'theme-episode' });
}));
} else {
DATA.episodes.forEach(ep => {
if (DATA.staffeln.find(s => s.id === ep.staffel)) {
links.push({ source: `staffel-${ep.staffel}`, target: ep.id, type: 'theme-episode' });
}
});
}
if (hasQuotes) {
DATA.quotes.filter(q => q.isTopQuote || q.startTime !== null).forEach(q => {
const ep = episodeMap[q.episode];
nodes.push({ id: q.id, type: 'quote', text: q.text, speaker: q.speaker, episode: q.episode,
@ -1599,7 +1214,6 @@ function buildGraph() {
r: (q.isTopQuote ? 6 : 4) * sc, color: ep ? ep.color : '#666', staffel: ep ? ep.staffel : 0 });
links.push({ source: q.episode, target: q.id, type: 'episode-quote' });
});
}
simulation = d3.forceSimulation(nodes)
.force('link', d3.forceLink(links).id(d => d.id).distance(d => {
@ -1644,7 +1258,7 @@ function buildGraph() {
epNodes.append('circle').attr('r', d => d.r).attr('fill', 'transparent').attr('stroke', d => d.color).attr('stroke-width', 1.5);
epNodes.append('text').attr('dy', 4).text(d => d.label);
const themeNodes = nodeG.selectAll('.node-theme').data(nodes.filter(n => n.type === 'theme' || n.type === 'staffel')).join('g')
const themeNodes = nodeG.selectAll('.node-theme').data(nodes.filter(n => n.type === 'theme')).join('g')
.attr('class', 'node-theme').call(drag(simulation));
themeNodes.append('circle').attr('r', d => d.r).attr('fill', d => d.color + '33').attr('stroke', d => d.color);
themeNodes.append('text').attr('dy', d => -d.r - 8).text(d => d.label);
@ -1671,18 +1285,10 @@ function updateVisibility() {
const s = activeStaffel;
window._quoteNodes.style('display', d => s === 0 || d.staffel === s ? null : 'none');
window._epNodes.style('display', d => s === 0 || d.staffel === s ? null : 'none');
if (window._themeNodes) {
window._themeNodes.style('display', d => {
if (d.type !== 'staffel') return null;
return s === 0 || d.staffel === s ? null : 'none';
});
}
window._linkEls.style('display', d => {
if (s === 0) return null;
const tgt = typeof d.target === 'object' ? d.target : window._nodes.find(n => n.id === d.target);
const src = typeof d.source === 'object' ? d.source : window._nodes.find(n => n.id === d.source);
if (tgt && tgt.staffel && tgt.staffel !== s) return 'none';
if (src && src.type === 'staffel' && src.staffel !== s) return 'none';
return null;
});
}
@ -1704,7 +1310,6 @@ function drag(sim) {
if (d.type !== 'center') { d.fx = null; d.fy = null; }
if (!moved) {
if (d.type === 'theme') showTheme(d);
else if (d.type === 'staffel') filterStaffel(d.staffel);
else if (d.type === 'episode') showEpisode(d);
else if (d.type === 'quote') showQuoteDetail(d);
}
@ -1713,7 +1318,7 @@ function drag(sim) {
// ── Panel: Theme ──
function showTheme(theme) {
TranscriptView.hide(); AnalysisView.hide(); GapsView.hide(); ShiftsView.hide();
TranscriptView.hide();
const panel = document.getElementById('panel');
const td = DATA.themes.find(t => t.id === theme.id);
const quotes = DATA.quotes.filter(q => q.themes.includes(theme.id));
@ -1739,7 +1344,6 @@ function showTheme(theme) {
// ── Panel: Episode ──
function showEpisode(ep) {
TranscriptView.hide();
AnalysisView.hide();
const panel = document.getElementById('panel');
const epData = DATA.episodes.find(e => e.id === (ep.id || ep));
const staffel = DATA.staffeln.find(s => s.id === epData.staffel);
@ -1749,24 +1353,9 @@ function showEpisode(ep) {
html += `<p class="subtitle">Gast: ${epData.guest} · Staffel ${epData.staffel}: ${staffel.name}</p>`;
html += `<p class="subtitle">${quotes.length} Zitate</p>`;
// Action buttons
// Transcript button
if (epData.audioFile) {
html += `<button class="transcript-toggle" onclick="TranscriptView.show('${epData.id}')">Transkript lesen</button> `;
}
if (CURRENT_PODCAST) {
html += `<button class="transcript-toggle" id="btn-claims-${epData.id}" onclick="AnalysisView.show('${epData.id}','claims')">Behauptungen</button> `;
html += `<button class="transcript-toggle" id="btn-questions-${epData.id}" onclick="AnalysisView.show('${epData.id}','questions')">Fragen</button>`;
fetch(`${API_BASE}/api/podcasts/${CURRENT_PODCAST}/episodes/${epData.id}/analyses-summary`)
.then(r => r.json())
.then(s => {
const cb = document.getElementById('btn-claims-' + epData.id);
if (cb && typeof s.claims === 'number') cb.textContent = `Behauptungen (${s.claims})`;
const qb = document.getElementById('btn-questions-' + epData.id);
if (qb && typeof s.questions === 'number') {
const open = s.questions_unanswered ? `, ${s.questions_unanswered} offen` : '';
qb.textContent = `Fragen (${s.questions}${open})`;
}
}).catch(() => {});
html += `<button class="transcript-toggle" onclick="TranscriptView.show('${epData.id}')">Transkript lesen</button>`;
}
const epThemes = DATA.themes.filter(t => t.episodes.includes(epData.id));
@ -2119,28 +1708,14 @@ function buildTimeline() {
}
container.style.display = '';
const hasQuotes = (DATA.quotes || []).length > 0;
let html = '<div style="max-width:900px;margin:0 auto">';
DATA.staffeln.forEach(staffel => {
const eps = DATA.episodes.filter(e => e.staffel === staffel.id);
html += `<div style="margin-bottom:24px">`;
html += `<h3 style="color:${staffel.color};font-size:14px;margin-bottom:12px">Staffel ${staffel.id}: ${staffel.name} <span style="color:var(--text-muted);font-weight:400">· ${eps.length} Folgen</span></h3>`;
html += `<h3 style="color:${staffel.color};font-size:14px;margin-bottom:12px">Staffel ${staffel.id}: ${staffel.name}</h3>`;
eps.forEach(ep => {
if (!hasQuotes) {
html += `<div style="display:flex;gap:12px;margin-bottom:8px;align-items:flex-start">`;
html += `<div style="min-width:60px;text-align:right">`;
html += `<div style="font-size:12px;font-weight:600;color:${staffel.color}">${ep.id}</div>`;
if (ep.guest) html += `<div style="font-size:10px;color:var(--text-muted)">${escHtml(ep.guest)}</div>`;
html += `</div>`;
html += `<div style="flex:1">`;
html += `<div style="font-size:13px;font-weight:500;cursor:pointer" onclick="showEpisodeById('${ep.id}')">${escHtml(ep.title)}</div>`;
html += `</div>`;
html += `</div>`;
return;
}
const quotes = DATA.quotes.filter(q => q.episode === ep.id);
const topQuotes = quotes.filter(q => q.isTopQuote);