weircon-front/erindringer.py

"""Erindringer: familien fortæller sine minder (eller fører dagbog) til en AI-interviewer.

Interviewer = Claude (Anthropic Messages API via httpx; ingen SDK), der stiller ét spørgsmål ad
gangen og følger op på det, personen lige har sagt. Spørgsmålet læses op af ElevenLabs (cachet pr.
tekst), svaret optages i browseren, transskriberes af ElevenLabs STT og gemmes som mp3 + tekst.
Klippene bruges som råstof til podcasten (Slægtens Stemmer) og som personlig dagbog.

Data (ikke i git, persondata):
    DATA/erindringer/projekter.json          slug -> titel, beskrivelse, kontekst (til Claude), start (spørgsmål)
    DATA/erindringer/personer.json           pid -> navn, bruger | noegle, projekter, oprettet, sidst
    DATA/erindringer/klip/<pid>/<id>.mp3     svaret (mono 64 kbit)
    DATA/erindringer/klip/<pid>/<id>.json    id, tid, projekt, samtale, spoergsmaal, tekst, varighed, favorit
    DATA/erindringer/tts/<sha>.mp3           oplæste spørgsmål

Personer: indloggede brugere har pid "u:<username>" og kan altid føre dagbog; gæster (familie uden
login) får pid "g:<slug>" og en hemmelig nøgle i adressen, som podcasten gør det. Admin bestemmer,
hvilke projekter en person inviteres til; projektet "dagbog" er altid åbent for indloggede.
"""
import hashlib
import json
import os
import re
import secrets
import subprocess
import tempfile
import time
from pathlib import Path

import httpx

import config

ROOT = config.DATA / "erindringer"
PROJEKTER = ROOT / "projekter.json"
PERSONER = ROOT / "personer.json"
KLIP = ROOT / "klip"
TTS = ROOT / "tts"
SLUG = re.compile(r"^[a-z0-9][a-z0-9-]{0,40}$")
KEY = re.compile(r"^[A-Za-z0-9_-]{32,64}$")
KLIPID = re.compile(r"^[0-9]{8}-[0-9]{6}-[a-f0-9]{6}$")
PID = re.compile(r"^[ug]:[A-Za-z0-9_.@-]{1,64}$")

ANTHROPIC_KEY = os.environ.get("ANTHROPIC_API_KEY", "")
ANTHROPIC_WORKSPACE = os.environ.get("ANTHROPIC_WORKSPACE_ID", "")
MODEL = os.environ.get("ERINDRINGER_MODEL", "claude-sonnet-5")
ELEVEN_KEY = os.environ.get("ELEVEN_API_KEY", "")
VOICE = os.environ.get("ERINDRINGER_VOICE", "tJDFCHyviItsYF1qqToS")  # Leif, podcastens fortæller
MAX_SVAR_SEK = 15 * 60
MAX_UPLOAD = 40 * 1024 * 1024

DAGBOG = {
    "titel": "Dagbog",
    "beskrivelse": "Hvad der fylder lige nu. Et par minutter, når du har lyst; interviewerens spørgsmål hjælper dig i gang.",
    "kontekst": "Dette er personens private dagbog. Spørg til hverdagen, til det der fylder, til små og store ting, "
                "og følg op på det, personen selv bringer på bane. Vær nysgerrig uden at være nærgående.",
    "start": ["Hvad har fyldt mest for dig i dag?", "Hvad har du tænkt på i denne uge?",
              "Er der sket noget siden sidst, du gerne vil huske?"],
}


# ---------------- fil-hjælpere ----------------

def _læs(p: Path, standard):
    try:
        return json.loads(p.read_text())
    except (OSError, ValueError):
        return standard


def _skriv(p: Path, data) -> None:
    p.parent.mkdir(parents=True, exist_ok=True)
    tmp = p.with_name("." + p.name + ".tmp")
    tmp.write_text(json.dumps(data, ensure_ascii=False, indent=1))
    os.replace(tmp, p)


def _nu() -> str:
    return time.strftime("%Y-%m-%dT%H:%M:%S%z")


# ---------------- projekter ----------------

def projekter() -> dict:
    p = _læs(PROJEKTER, {})
    p.setdefault("dagbog", dict(DAGBOG))
    return p


def projekt(slug: str) -> dict | None:
    if not SLUG.match(slug or ""):
        return None
    p = projekter().get(slug)
    return {**p, "slug": slug} if p else None


def gem_projekt(slug: str, titel: str, beskrivelse: str, kontekst: str, start: list[str]) -> bool:
    if not SLUG.match(slug or "") or not titel.strip():
        return False
    p = projekter()
    gammel = p.get(slug, {})
    p[slug] = {"titel": titel.strip(), "beskrivelse": beskrivelse.strip(), "kontekst": kontekst.strip(),
               "start": [s.strip() for s in start if s.strip()], "oprettet": gammel.get("oprettet") or _nu()}
    _skriv(PROJEKTER, p)
    return True


def slet_projekt(slug: str) -> bool:
    p = projekter()
    if slug == "dagbog" or slug not in p:
        return False
    del p[slug]
    _skriv(PROJEKTER, p)
    ps = personer()
    for v in ps.values():
        if slug in v.get("projekter", []):
            v["projekter"].remove(slug)
    _skriv(PERSONER, ps)
    return True


# ---------------- personer ----------------

def personer() -> dict:
    return _læs(PERSONER, {})


def person(pid: str) -> dict | None:
    if not PID.match(pid or ""):
        return None
    v = personer().get(pid)
    return {**v, "pid": pid} if v else None


def person_for_bruger(username: str, navn: str) -> dict:
    """Indlogget bruger: oprettes første gang, dagbog er altid med."""
    pid = f"u:{username}"
    ps = personer()
    v = ps.get(pid)
    if v is None:
        v = {"navn": navn or username, "bruger": username, "projekter": ["dagbog"], "oprettet": _nu()}
        ps[pid] = v
    else:
        if navn and v.get("navn") != navn:
            v["navn"] = navn
        if "dagbog" not in v.setdefault("projekter", []):
            v["projekter"].insert(0, "dagbog")
    v["sidst"] = _nu()
    _skriv(PERSONER, ps)
    return {**v, "pid": pid}


def person_for_noegle(key: str) -> dict | None:
    if not KEY.match(key or ""):
        return None
    for pid, v in personer().items():
        if v.get("noegle") == key and not v.get("lukket"):
            v["sidst"] = _nu()
            ps = personer(); ps[pid]["sidst"] = v["sidst"]; _skriv(PERSONER, ps)
            return {**v, "pid": pid}
    return None


def ny_gaest(navn: str, projekt_slugs: list[str]) -> dict:
    base = re.sub(r"[^a-z0-9]+", "-", navn.lower().replace("æ", "ae").replace("ø", "oe").replace("å", "aa")).strip("-")[:30] or "gaest"
    ps = personer()
    slug, n = base, 2
    while f"g:{slug}" in ps:
        slug, n = f"{base}-{n}", n + 1
    pid = f"g:{slug}"
    ps[pid] = {"navn": navn.strip(), "noegle": secrets.token_urlsafe(32), "projekter": list(projekt_slugs),
               "oprettet": _nu()}
    _skriv(PERSONER, ps)
    return {**ps[pid], "pid": pid}


def saet_projekter(pid: str, projekt_slugs: list[str]) -> bool:
    ps = personer()
    if pid not in ps:
        return False
    ps[pid]["projekter"] = [s for s in projekt_slugs if s in projekter()]
    if pid.startswith("u:") and "dagbog" not in ps[pid]["projekter"]:
        ps[pid]["projekter"].insert(0, "dagbog")
    _skriv(PERSONER, ps)
    return True


def ny_noegle(pid: str) -> str | None:
    ps = personer()
    if pid not in ps or not pid.startswith("g:"):
        return None
    ps[pid]["noegle"] = secrets.token_urlsafe(32)
    ps[pid].pop("lukket", None)
    _skriv(PERSONER, ps)
    return ps[pid]["noegle"]


def luk_gaest(pid: str, lukket: bool) -> bool:
    ps = personer()
    if pid not in ps or not pid.startswith("g:"):
        return False
    if lukket:
        ps[pid]["lukket"] = _nu()
    else:
        ps[pid].pop("lukket", None)
    _skriv(PERSONER, ps)
    return True


def alle_personer() -> list[dict]:
    ud = []
    for pid, v in personer().items():
        ud.append({**v, "pid": pid, "antal": len(klip_for(pid))})
    return sorted(ud, key=lambda v: (v.get("sidst") or v.get("oprettet") or ""), reverse=True)


def maa(p: dict, slug: str) -> bool:
    return slug in (p.get("projekter") or []) and projekt(slug) is not None


# ---------------- klip ----------------

def _klipmappe(pid: str) -> Path:
    return KLIP / pid.replace(":", "_")


def klip_for(pid: str, projekt_slug: str | None = None, samtale: str | None = None) -> list[dict]:
    """Klip for en person, ældste først."""
    d = _klipmappe(pid)
    if not PID.match(pid or "") or not d.exists():
        return []
    ud = []
    for meta in d.glob("*.json"):
        if not KLIPID.match(meta.stem):
            continue
        k = _læs(meta, None)
        if not k or not (d / f"{meta.stem}.mp3").exists():
            continue
        if projekt_slug and k.get("projekt") != projekt_slug:
            continue
        if samtale and k.get("samtale") != samtale:
            continue
        ud.append(k)
    return sorted(ud, key=lambda k: k["id"])


def klip(pid: str, kid: str) -> dict | None:
    if not PID.match(pid or "") or not KLIPID.match(kid or ""):
        return None
    k = _læs(_klipmappe(pid) / f"{kid}.json", None)
    return k if k and k.get("id") == kid else None


def klip_fil(pid: str, kid: str) -> Path | None:
    if not PID.match(pid or "") or not KLIPID.match(kid or ""):
        return None
    p = _klipmappe(pid) / f"{kid}.mp3"
    return p if p.exists() else None


def _varighed(p: Path) -> int:
    try:
        ud = subprocess.run(["ffprobe", "-v", "error", "-show_entries", "format=duration", "-of", "csv=p=0", str(p)],
                            capture_output=True, text=True, timeout=30).stdout.strip()
        return int(float(ud))
    except (OSError, ValueError, subprocess.SubprocessError):
        return 0


def gem_svar(pid: str, projekt_slug: str, samtale: str, spoergsmaal: str, lyd: bytes | None, filnavn: str,
             tekst: str | None) -> dict:
    """Gem et svar: lyd konverteres til mp3 og transskriberes; ren tekst gemmes som det er.
    Returnerer klip-metadata. Kaster ValueError med besked til brugeren."""
    if not PID.match(pid or "") or not SLUG.match(projekt_slug or ""):
        raise ValueError("Ugyldig person eller projekt.")
    d = _klipmappe(pid)
    d.mkdir(parents=True, exist_ok=True)
    kid = time.strftime("%Y%m%d-%H%M%S") + "-" + secrets.token_hex(3)
    mp3 = d / f"{kid}.mp3"
    varighed = 0
    if lyd:
        if len(lyd) > MAX_UPLOAD:
            raise ValueError("Optagelsen er for stor. Prøv at dele den op i to svar.")
        suffix = "." + (re.sub(r"[^a-z0-9]", "", (filnavn or "").rsplit(".", 1)[-1].lower()) or "webm")
        with tempfile.NamedTemporaryFile(suffix=suffix, delete=False) as tmp:
            tmp.write(lyd)
            raa = Path(tmp.name)
        try:
            r = subprocess.run(["ffmpeg", "-y", "-v", "error", "-i", str(raa), "-vn", "-ac", "1", "-ar", "44100",
                                "-c:a", "libmp3lame", "-b:a", "64k", str(mp3)], capture_output=True, text=True, timeout=300)
            if r.returncode or not mp3.exists():
                raise ValueError("Optagelsen kunne ikke læses. Prøv igen, eller skriv svaret i stedet.")
            varighed = _varighed(mp3)
            if varighed > MAX_SVAR_SEK:
                mp3.unlink(missing_ok=True)
                raise ValueError("Svaret er længere end et kvarter. Del det op, så bliver det også nemmere at bruge.")
            if tekst is None or not tekst.strip():
                tekst = transskriber(mp3)
        finally:
            raa.unlink(missing_ok=True)
    else:
        if not (tekst or "").strip():
            raise ValueError("Der kom hverken lyd eller tekst med.")
        # Tekstsvar: en stille mp3 på 1 s, så alle klip har samme form (afspiller + tekst).
        subprocess.run(["ffmpeg", "-y", "-v", "error", "-f", "lavfi", "-i", "anullsrc=r=44100:cl=mono", "-t", "1",
                        "-c:a", "libmp3lame", "-b:a", "32k", str(mp3)], capture_output=True, timeout=60)
    meta = {"id": kid, "tid": _nu(), "projekt": projekt_slug, "samtale": samtale, "spoergsmaal": spoergsmaal.strip()[:600],
            "tekst": (tekst or "").strip(), "varighed": varighed, "favorit": False, "skrevet": not lyd}
    _skriv(d / f"{kid}.json", meta)
    return meta


def ret_tekst(pid: str, kid: str, tekst: str) -> bool:
    k = klip(pid, kid)
    if not k:
        return False
    k["tekst"] = tekst.strip()[:20000]
    k["redigeret"] = _nu()
    _skriv(_klipmappe(pid) / f"{kid}.json", k)
    return True


def saet_favorit(pid: str, kid: str, favorit: bool) -> bool:
    k = klip(pid, kid)
    if not k:
        return False
    k["favorit"] = favorit
    _skriv(_klipmappe(pid) / f"{kid}.json", k)
    return True


def slet_klip(pid: str, kid: str) -> bool:
    k = klip(pid, kid)
    if not k:
        return False
    d = _klipmappe(pid)
    (d / f"{kid}.json").unlink(missing_ok=True)
    (d / f"{kid}.mp3").unlink(missing_ok=True)
    return True


# ---------------- ElevenLabs: tale ----------------

def transskriber(mp3: Path) -> str:
    if not ELEVEN_KEY:
        return ""
    try:
        with open(mp3, "rb") as f:
            r = httpx.post("https://api.elevenlabs.io/v1/speech-to-text", headers={"xi-api-key": ELEVEN_KEY},
                           data={"model_id": "scribe_v2", "language_code": "da"},
                           files={"file": (mp3.name, f, "audio/mpeg")}, timeout=600)
        if r.status_code == 200:
            return (r.json().get("text") or "").strip()
    except httpx.HTTPError:
        pass
    return ""


def tts_sti(tekst: str) -> Path | None:
    """Oplæst spørgsmål, cachet på tekstens hash; None hvis det ikke kunne laves."""
    tekst = (tekst or "").strip()
    if not tekst or not ELEVEN_KEY:
        return None
    sha = hashlib.sha256((VOICE + "|" + tekst).encode()).hexdigest()[:32]
    p = TTS / f"{sha}.mp3"
    if p.exists():
        return p
    TTS.mkdir(parents=True, exist_ok=True)
    body = {"text": tekst, "model_id": "eleven_v4", "language_code": "da",
            "voice_settings": {"stability": 0.5, "similarity_boost": 0.8, "style": 0.2, "use_speaker_boost": True}}
    try:
        r = httpx.post(f"https://api.elevenlabs.io/v1/text-to-speech/{VOICE}?output_format=mp3_44100_64",
                       headers={"xi-api-key": ELEVEN_KEY}, json=body, timeout=120)
        if r.status_code == 200 and r.content[:3] in (b"ID3", b"\xff\xfb", b"\xff\xf3"):
            tmp = p.with_name("." + p.name + ".tmp")
            tmp.write_bytes(r.content)
            os.replace(tmp, p)
            return p
    except httpx.HTTPError:
        pass
    return None


def tts_fil(sha: str) -> Path | None:
    if not re.match(r"^[a-f0-9]{32}$", sha or ""):
        return None
    p = TTS / f"{sha}.mp3"
    return p if p.exists() else None


# ---------------- Claude: interviewer ----------------

SYSTEM = """Du er en varm, nysgerrig interviewer for en dansk familie. Du hjælper et familiemedlem med at
fortælle sine minder (eller føre dagbog) ved at stille ÉT kort spørgsmål ad gangen på dansk.

Regler:
- Spørg konkret og hverdagsnært: steder, personer, lyde, lugte, hvad man lavede, hvad man følte. Et spørgsmål er på højst to sætninger.
- Følg op på det, personen lige har fortalt (navne, steder, ting de kun nævnte kort), før du skifter emne. Brug personens egne ord.
- Led ikke vidnet: foreslå ikke svar, og ret ikke personen. Hvis noget i det sagte strider mod baggrunden, så spørg nysgerrigt i stedet for at påpege det.
- Hold en rolig, respektfuld tone, ingen smiger, ingen udråbstegn, ingen "fantastisk". Skriv som man taler. Brug aldrig tankestreger.
- Hvis personen virker træt, skriver kort eller siger de vil stoppe, så stil et let, afrundende spørgsmål og sæt "afslut" til true.
- Gentag ikke et spørgsmål, der allerede er stillet i samtalen. Vend tilbage til startspørgsmålene, hvis samtalen går i stå.
- Svar KUN med JSON: {"spoergsmaal": "...", "afslut": false}"""


def _historik(pid: str, projekt_slug: str, samtale: str) -> tuple[list[dict], list[dict]]:
    """(denne samtale, tidligere svar i projektet) som korte dicts til prompten."""
    alle = klip_for(pid, projekt_slug)
    denne = [k for k in alle if k.get("samtale") == samtale]
    tidligere = [k for k in alle if k.get("samtale") != samtale][-30:]
    return denne, tidligere


def _kort(k: dict, n: int = 700) -> dict:
    return {"dato": (k.get("tid") or "")[:10], "spoergsmaal": k.get("spoergsmaal", ""),
            "svar": (k.get("tekst") or "")[:n]}


async def naeste_spoergsmaal(p: dict, pr: dict, samtale: str) -> tuple[str, bool]:
    """Næste spørgsmål til personen i projektet. Falder tilbage til startspørgsmålene uden nøgle/ved fejl."""
    denne, tidligere = _historik(p["pid"], pr["slug"], samtale)
    stillede = {k.get("spoergsmaal") for k in denne + tidligere}
    start = [s for s in (pr.get("start") or DAGBOG["start"]) if s not in stillede] or list(pr.get("start") or DAGBOG["start"])
    if not denne:
        return start[0], False            # samtalen åbner altid med et af projektets egne spørgsmål
    if not ANTHROPIC_KEY:
        return start[len(denne) % len(start)], False
    payload = {
        "person": {"navn": p.get("navn")},
        "projekt": {"titel": pr.get("titel"), "beskrivelse": pr.get("beskrivelse"), "baggrund": pr.get("kontekst", "")[:6000],
                    "startspoergsmaal": pr.get("start") or []},
        "tidligere_samtaler": [_kort(k, 300) for k in tidligere],
        "denne_samtale": [_kort(k) for k in denne],
        "antal_svar_i_dag": len(denne),
    }
    headers = {"x-api-key": ANTHROPIC_KEY, "anthropic-version": "2023-06-01", "content-type": "application/json"}
    if ANTHROPIC_WORKSPACE:
        headers["anthropic-workspace-id"] = ANTHROPIC_WORKSPACE
    body = {"model": MODEL, "max_tokens": 300, "system": SYSTEM,
            "messages": [{"role": "user", "content": "Her er samtalen indtil nu som JSON. Stil næste spørgsmål.\n\n"
                                                      + json.dumps(payload, ensure_ascii=False)}]}
    try:
        async with httpx.AsyncClient(timeout=60) as c:
            r = await c.post("https://api.anthropic.com/v1/messages", headers=headers, json=body)
        if r.status_code == 200:
            tekst = "".join(b.get("text", "") for b in r.json().get("content", []) if b.get("type") == "text")
            m = re.search(r"\{.*\}", tekst, re.S)
            if m:
                svar = json.loads(m.group(0))
                q = (svar.get("spoergsmaal") or "").strip().replace("—", ",").replace(" - ", ", ")
                if q:
                    return q[:400], bool(svar.get("afslut"))
    except (httpx.HTTPError, ValueError):
        pass
    return start[len(denne) % len(start)], False


def ny_samtale() -> str:
    return time.strftime("%Y%m%d") + "-" + secrets.token_hex(3)


def eksport(pid: str) -> bytes:
    """Zip med alle klip (mp3 + json) og en samlet tekstfil, til podcast-produktionen."""
    import io
    import zipfile
    k = klip_for(pid)
    buf = io.BytesIO()
    with zipfile.ZipFile(buf, "w", zipfile.ZIP_DEFLATED) as z:
        linjer = []
        for x in k:
            f = klip_fil(pid, x["id"])
            if f:
                z.write(f, f"{x['id']}.mp3")
            z.writestr(f"{x['id']}.json", json.dumps(x, ensure_ascii=False, indent=1))
            linjer.append(f"## {x['id']} · {x.get('tid', '')[:16]} · {x.get('projekt')}{' · favorit' if x.get('favorit') else ''}\n"
                          f"Spørgsmål: {x.get('spoergsmaal', '')}\n\n{x.get('tekst', '')}\n")
        z.writestr("alle_svar.md", "\n".join(linjer))
    return buf.getvalue()