monograph 0.1.0__py3-none-any.whl

monograph/__init__.py

@@ -0,0 +1,11 @@
+"""monograph — diary -> memoir -> narrated audio, local-first.
+
+Only light things are imported at top level so `import monograph` stays cheap and
+free of heavy optional dependencies. Pull backends from their submodules
+(`monograph.narrate`, `monograph.index`, ...) when you need them.
+"""
+from .config import Config
+from . import types
+
+__version__ = "0.1.0"
+__all__ = ["Config", "types", "__version__"]

monograph/app.py

@@ -0,0 +1,113 @@
+"""Diary Companion — a local, private Streamlit app for exploring a journal:
+find forgotten entries, follow a thread across the years, see your story freshly.
+Ported from diary_app.py. Retrieval goes through monograph's LocalIndex (no faiss
+/ pickle), and the family age context is optional config, not hardcoded.
+
+Launch it with:   monograph app
+
+It reads an index built by `monograph index` (default base name "diary_index").
+Age labels appear if a monograph.toml with a [people] table sits in the folder:
+
+    [people]
+    Cash = "2007-01-10"
+    Camille = "2008-01-31"
+"""
+from __future__ import annotations
+import os
+from datetime import date
+from pathlib import Path
+
+import streamlit as st
+
+
+@st.cache_resource
+def _load_index(base: str):
+    from monograph.index.local import LocalIndex
+    return LocalIndex.load(base)
+
+
+def _load_people() -> dict:
+    try:
+        import tomllib
+        p = Path("monograph.toml")
+        if p.exists():
+            data = tomllib.loads(p.read_text(encoding="utf-8"))
+            return {k: date.fromisoformat(v) for k, v in data.get("people", {}).items()}
+    except Exception:
+        pass
+    return {}
+
+
+def _age_at(birth: date, d: date) -> int:
+    return d.year - birth.year - ((d.month, d.day) < (birth.month, birth.day))
+
+
+def run():
+    st.set_page_config(page_title="Diary Companion", page_icon="📖", layout="wide")
+    st.title("📖 Diary Companion")
+    st.caption("A private, local space to find, revisit, and reflect on your own "
+               "entries. Nothing leaves this machine.")
+
+    base = st.sidebar.text_input("Index path",
+                                 value=os.environ.get("MONOGRAPH_INDEX", "diary_index"))
+    try:
+        idx = _load_index(base)
+    except Exception as e:
+        st.error(f"Couldn't load an index at '{base}'. Build one first:\n\n"
+                 f"`monograph index --diary <your diary> --out {base}`\n\n({e})")
+        st.stop()
+
+    people = _load_people()
+    dated = [e for e in idx.entries if e.entry_date]
+    span = (f"{min(e.entry_date for e in dated)} → {max(e.entry_date for e in dated)}"
+            if dated else "no dates")
+    st.sidebar.success(f"{len(idx.entries)} entries loaded ({span})")
+
+    st.sidebar.header("Find a thread")
+    theme = st.sidebar.text_input("Search by theme or feeling",
+                                  placeholder="e.g. a recovery, feeling alone, hope")
+    k = st.sidebar.slider("How many entries to surface", 5, 100, 30, step=5)
+    min_score = st.sidebar.slider("Relevance threshold", 0.0, 0.6, 0.20, step=0.02,
+                                  help="Higher = only stronger matches.")
+    order = st.sidebar.radio("Show in order of", ["Chronological", "Relevance"])
+
+    if not theme:
+        st.info("Enter a theme or feeling in the sidebar to surface related entries "
+                "from across your journal, shown with their dates so you can follow "
+                "how a thread developed over time.")
+        st.stop()
+
+    hits = [(e, s) for e, s in idx.search(theme, k=k) if s >= min_score]
+    if not hits:
+        st.warning("No entries matched. Lower the relevance threshold or rephrase.")
+        st.stop()
+
+    if order == "Chronological":
+        hits.sort(key=lambda es: es[0].entry_date or date.min)
+    else:
+        hits.sort(key=lambda es: es[1], reverse=True)
+
+    st.subheader(f"{len(hits)} entries related to “{theme}”")
+    years = [e.entry_date.year for e, _ in hits if e.entry_date]
+    if years:
+        counts = {y: years.count(y) for y in range(min(years), max(years) + 1)}
+        st.caption("When these entries fall (a first glimpse of the pattern):")
+        st.bar_chart({"entries": counts})
+    st.divider()
+
+    for e, score in hits:
+        d = e.entry_date
+        weekday = e.meta.get("weekday") or (d.strftime("%A") if d else "")
+        cols = st.columns([3, 1])
+        cols[0].markdown(f"**{d or '?'} · {weekday}**")
+        if people and d:
+            ages = " · ".join(f"{n} {_age_at(b, d)}" for n, b in people.items())
+            cols[1].markdown(f"<div style='text-align:right;color:gray;font-size:0.8em'>"
+                             f"{ages}</div>", unsafe_allow_html=True)
+        st.write(e.text)
+        st.caption(f"relevance {score:.2f}")
+        st.divider()
+
+
+if __name__ == "__main__":
+    run()

monograph/arc/__init__.py

@@ -0,0 +1,21 @@
+"""arc — the memoir-structure engine: distill a diary into signals, write a
+reconnaissance report, and propose candidate spines. This is the heart of
+monograph, ported from memoir_recon.py and spine_proposer.py and generalized so
+all domain content lives in a `Lenses` object the writer supplies.
+
+    from monograph.index import get_embedder
+    from monograph.llm import get_llm
+    from monograph.types import Lenses
+
+    embed = get_embedder("local")
+    report = recon_report(entries, embed, lenses=Lenses.default())   # markdown
+    evidence = build_evidence(entries, embed, lenses=Lenses.default())
+    spines = propose_spines(evidence, get_llm("ollama", cfg))        # candidate books
+"""
+from .analyze import build_evidence
+from .recon import recon_report
+from .spine import propose_spines
+from .scenes import scenes_by_aspect, scenes_report
+
+__all__ = ["build_evidence", "recon_report", "propose_spines",
+           "scenes_by_aspect", "scenes_report"]

monograph/arc/analyze.py

@@ -0,0 +1,64 @@
+"""Distill a diary into an Evidence pack — aspect prevalence and trend, a
+timeline, turning points, recurring people, and a capped set of representative
+snippets. This is the structured, privacy-preserving summary handed to the LLM
+in propose_spines (the whole journal is never sent). Ported from
+spine_proposer.build_evidence; all domain content comes from Lenses.
+"""
+from __future__ import annotations
+import numpy as np
+
+from ..types import DiaryEntry, Lenses, Evidence
+from .scenes import build_frame, extract_entities, turning_points, snippet
+
+
+def build_evidence(entries: list[DiaryEntry], embed, lenses: Lenses | None = None,
+                   min_year: int | None = None, max_year: int | None = None,
+                   per_aspect: int = 3, entry_embeddings=None) -> Evidence:
+    lenses = lenses or Lenses.default()
+    df, E = build_frame(entries, lenses, embed, entry_embeddings)
+
+    yr = df["dt"].dt.year
+    if min_year is None and max_year is None:
+        df["valid"] = df["dt"].notna()
+    else:
+        lo = min_year if min_year is not None else -(10 ** 9)
+        hi = max_year if max_year is not None else 10 ** 9
+        df["valid"] = df["dt"].notna() & yr.between(lo, hi)
+    valid = df[df["valid"]]
+    vidx = valid.index.to_numpy()
+
+    order = valid.sort_values("dt").index.to_numpy()
+    half = len(order) // 2
+    early, late = set(order[:half]), set(order[half:])
+
+    aspects, ref_ids = [], set()
+    for a in lenses.aspects:
+        share = (valid["top_aspect"] == a).mean() * 100 if len(valid) else 0.0
+        e_share = np.mean([df.at[i, "top_aspect"] == a for i in early]) if early else 0
+        l_share = np.mean([df.at[i, "top_aspect"] == a for i in late]) if late else 0
+        trend = ("rising" if l_share > e_share * 1.25
+                 else "falling" if l_share < e_share * 0.8 else "steady")
+        s = df.loc[vidx, "asp_" + a].to_numpy() if len(vidx) else np.array([])
+        top = vidx[s.argsort()[::-1][:per_aspect]] if len(vidx) else np.array([], dtype=int)
+        ref_ids.update(int(i) for i in top)
+        aspects.append({"name": a, "share_pct": round(float(share), 1),
+                        "trend": trend, "top_ids": [int(i) for i in top]})
+
+    tps, _ = turning_points(valid)
+    turning = []
+    for t, z in tps:
+        mask = valid["dt"].dt.to_period("M") == t.to_period("M")
+        ids = valid.index[mask].to_numpy()[:2]
+        ref_ids.update(int(i) for i in ids)
+        turning.append({"month": t.strftime("%Y-%m"), "z": round(z, 2),
+                        "ids": [int(i) for i in ids]})
+
+    entities = extract_entities(valid["text"], lenses.name_stop)
+    timeline = {int(y): int(c)
+                for y, c in valid["dt"].dt.year.value_counts().sort_index().items()}
+    snippets = {int(i): f"{df.at[i, 'dt'].date().isoformat()} — {snippet(df.at[i, 'text'])}"
+                for i in sorted(ref_ids)}
+
+    return Evidence(n_entries=int(len(df)), n_valid=int(len(valid)), aspects=aspects,
+                    timeline=timeline, turning_points=turning, entities=entities,
+                    snippets=snippets)

monograph/arc/recon.py

@@ -0,0 +1,137 @@
+"""Reconnaissance report over a diary: split into optional strands, cluster each
+into recurring situation-types, score aspects, trace the emotional trajectory,
+flag turning points, and (for a compare/contrast memoir) pair one strand's
+situations with their nearest echoes in another. Returns Markdown.
+
+Ported from memoir_recon.py. The present/past split there is now just a two-entry
+`Lenses.strands`; with no strands it degrades to a single-strand report.
+"""
+from __future__ import annotations
+import numpy as np
+
+from ..types import DiaryEntry, Lenses
+from .scenes import build_frame, centroid, top_terms, kmeans, snippet, turning_points
+
+
+def recon_report(entries: list[DiaryEntry], embed, lenses: Lenses | None = None,
+                 spine_percentile: float = 55, min_year: int | None = None,
+                 max_year: int | None = None, entry_embeddings=None) -> str:
+    import pandas as pd
+    lenses = lenses or Lenses.default()
+    df, E = build_frame(entries, lenses, embed, entry_embeddings)
+
+    strand_names = list(lenses.strands.keys())
+    if strand_names:
+        S = np.stack([E @ centroid(embed(seeds)) for seeds in lenses.strands.values()], 1)
+        df["strand"] = [strand_names[i] for i in S.argmax(1)]
+        relevance = S.max(1)
+    else:
+        df["strand"] = "all"
+        relevance = df[["asp_" + a for a in lenses.aspects]].to_numpy().max(1)
+    df["spine"] = relevance >= np.quantile(relevance, spine_percentile / 100.0)
+
+    out = ["# Memoir reconnaissance", "",
+           f"{len(df)} entries · {int(df['dt'].notna().sum())} dated · "
+           f"spine subset: {int(df['spine'].sum())} entries "
+           f"(top {100 - spine_percentile:.0f}% by relevance).", ""]
+    if strand_names:
+        out += ["Strands: " + " vs. ".join(strand_names), ""]
+
+    # strands over time
+    if strand_names:
+        dd = df[df["spine"] & df["dt"].notna()].copy()
+        dd["year"] = dd["dt"].dt.year
+        pivot = dd.pivot_table(index="year", columns="strand", values="text",
+                               aggfunc="count", fill_value=0)
+        out += ["## Strands over time (spine entries per year)", "",
+                "| year | " + " | ".join(strand_names) + " |",
+                "|---|" + "---|" * len(strand_names)]
+        for y, row in pivot.iterrows():
+            out.append("| " + str(y) + " | "
+                       + " | ".join(str(int(row.get(n, 0))) for n in strand_names) + " |")
+        out.append("")
+
+    # clusters per strand
+    def cluster_block(strand, title):
+        idx = df.index[df["spine"] & (df["strand"] == strand)].to_numpy()
+        if len(idx) < 6:
+            return [f"## {title}", "", "_(too few entries to cluster)_", ""]
+        labels, k = kmeans(E[idx], k=len(idx) // 30 + 3)
+        block = [f"## {title}  ({len(idx)} entries, {k} themes)", ""]
+        for c in range(k):
+            members = idx[labels == c]
+            if len(members) == 0:
+                continue
+            sub_c = centroid(E[members])
+            order = members[(E[members] @ sub_c).argsort()[::-1]]
+            terms = top_terms([df.at[i, "text"] for i in members])
+            yrs = df.loc[members, "dt"].dt.year.dropna()
+            span = f"{int(yrs.min())}-{int(yrs.max())}" if len(yrs) else "undated"
+            block.append(f"**Theme {c + 1}** ({len(members)} entries, {span}) — {terms}")
+            for i in order[:2]:
+                d = df.at[i, "dt"]
+                ds = d.date().isoformat() if pd.notna(d) else "?"
+                block.append(f"  - *{ds}*: {snippet(df.at[i, 'text'])}")
+            block.append("")
+        return block
+
+    for strand in (strand_names or ["all"]):
+        label = strand if strand != "all" else "recurring situations"
+        out += cluster_block(strand, f"{label} — recurring situations")
+
+    # aspect distribution
+    out += ["## Aspects across the spine", "", "| aspect | entries |", "|---|---|"]
+    for a, n in df[df["spine"]]["top_aspect"].value_counts().items():
+        out.append(f"| {a} | {int(n)} |")
+    out.append("")
+
+    # compare / contrast between the first two strands
+    if len(strand_names) >= 2:
+        a_name, b_name = strand_names[0], strand_names[1]
+        a_idx = df.index[df["spine"] & (df["strand"] == a_name)].to_numpy()
+        b_idx = df.index[df["spine"] & (df["strand"] == b_name)].to_numpy()
+        out += [f"## Compare / contrast — {a_name} situations and their {b_name} echoes", ""]
+        if len(a_idx) >= 6 and len(b_idx) >= 1:
+            labels, k = kmeans(E[a_idx], k=len(a_idx) // 30 + 3)
+            for c in range(k):
+                members = a_idx[labels == c]
+                if len(members) == 0:
+                    continue
+                cc = centroid(E[members])
+                rep = members[(E[members] @ cc).argmax()]
+                echoes = b_idx[(E[b_idx] @ cc).argsort()[::-1][:2]]
+                drep = df.at[rep, "dt"]
+                out.append(f"**{a_name}:** *{drep.date().isoformat() if pd.notna(drep) else '?'}*: "
+                           f"{snippet(df.at[rep, 'text'])}")
+                for e in echoes:
+                    de = df.at[e, "dt"]
+                    out.append(f"  - **{b_name} echo** "
+                               f"*{de.date().isoformat() if pd.notna(de) else '?'}*: "
+                               f"{snippet(df.at[e, 'text'])}")
+                out.append("")
+        else:
+            out.append("_(not enough paired material — lower spine_percentile)_\n")
+
+    # emotional trajectory + turning points
+    md = df[df["spine"] & df["dt"].notna()].copy()
+    tps, monthly = turning_points(md)
+    out += ["## Emotional trajectory (spine entries, monthly mean valence)", "",
+            "Valence > 0 leans warm/positive, < 0 leans hard/negative.", ""]
+    if len(monthly) >= 6:
+        yr = monthly.resample("YS").mean()
+        out += ["| year | mean valence |", "|---|---|"]
+        for d, v in yr.items():
+            out.append(f"| {d.year} | {v:+.3f} |")
+        out.append("")
+        out += ["### Candidate turning points (largest month-to-month swings)", ""]
+        mi = md.set_index("dt").sort_index()
+        for t, z in tps:
+            near = mi[(mi.index.year == t.year) & (mi.index.month == t.month)]
+            out.append(f"**{t.strftime('%B %Y')}** (Δvalence z={z:+.2f})")
+            for i in range(min(2, len(near))):
+                out.append(f"  - {snippet(near.iloc[i]['text'])}")
+            out.append("")
+    else:
+        out.append("_(not enough dated spine entries for a trajectory)_\n")
+
+    return "\n".join(out)

monograph/arc/scenes.py

@@ -0,0 +1,172 @@
+"""Signal extraction shared by the arc stage: build the scored frame of entries,
+cluster them into recurring situation-types (scenes/themes), score aspects and
+valence, find turning points, and spot recurring people. Generalized from
+memoir_recon.py / spine_proposer.py — all domain content comes in via Lenses.
+"""
+from __future__ import annotations
+import re
+import numpy as np
+
+from ..types import DiaryEntry, Lenses, Scene
+
+
+def snippet(t: str, n: int = 260) -> str:
+    t = re.sub(r"\s+", " ", t or "").strip()
+    return t[:n] + ("…" if len(t) > n else "")
+
+
+def centroid(vecs: np.ndarray) -> np.ndarray:
+    c = vecs.mean(axis=0)
+    nrm = np.linalg.norm(c)
+    return c / nrm if nrm else c
+
+
+def top_terms(texts, k: int = 6) -> str:
+    from sklearn.feature_extraction.text import TfidfVectorizer
+    try:
+        v = TfidfVectorizer(stop_words="english", token_pattern=r"[A-Za-z][A-Za-z]{2,}",
+                            max_features=4000)
+        X = v.fit_transform(texts)
+        scores = np.asarray(X.mean(axis=0)).ravel()
+        vocab = np.array(v.get_feature_names_out())
+        return ", ".join(vocab[scores.argsort()[::-1][:k]])
+    except ValueError:
+        return "(not enough text)"
+
+
+def kmeans(sub: np.ndarray, k: int):
+    from sklearn.cluster import KMeans
+    k = max(2, min(k, max(2, len(sub) // 15)))
+    km = KMeans(n_clusters=k, n_init=10, random_state=0).fit(sub)
+    return km.labels_, k
+
+
+def build_frame(entries: list[DiaryEntry], lenses: Lenses, embed,
+                entry_embeddings: np.ndarray | None = None):
+    """Return (df, E): a pandas frame of entries scored against the lenses, plus
+    the embedding matrix. `embed` is any callable list[str] -> np.ndarray."""
+    import pandas as pd
+    df = pd.DataFrame([{"date": e.entry_date, "text": e.text} for e in entries])
+    df["dt"] = pd.to_datetime(df["date"], errors="coerce")
+    E = entry_embeddings if entry_embeddings is not None else embed(df["text"].tolist())
+
+    for name, phrase in lenses.aspects.items():
+        df["asp_" + name] = E @ embed([phrase])[0]
+    df["top_aspect"] = df[["asp_" + a for a in lenses.aspects]].idxmax(axis=1).str.replace(
+        "asp_", "", regex=False)
+
+    pos = np.stack([E @ embed([p])[0] for p in lenses.emo_pos], 1).mean(1)
+    neg = np.stack([E @ embed([p])[0] for p in lenses.emo_neg], 1).mean(1)
+    df["valence"] = pos - neg
+    return df, E
+
+
+def extract_entities(texts, name_stop, min_count: int = 8, limit: int = 20):
+    counts: dict[str, int] = {}
+    for t in texts:
+        for tok in re.findall(r"\b[A-Z][a-z]+\b", t or ""):
+            if tok not in name_stop:
+                counts[tok] = counts.get(tok, 0) + 1
+    return [{"name": k, "count": v}
+            for k, v in sorted(counts.items(), key=lambda x: -x[1]) if v >= min_count][:limit]
+
+
+def turning_points(valid_df, top_n: int = 6):
+    """Months with the biggest valence swings. Returns [(period_ts, zscore)]."""
+    md = valid_df.copy().set_index("dt").sort_index()
+    monthly = md["valence"].resample("MS").mean().dropna()
+    if len(monthly) < 6:
+        return [], monthly
+    chg = monthly.diff()
+    z = (chg - chg.mean()) / (chg.std() or 1)
+    picks = sorted(z.abs().sort_values(ascending=False).head(top_n).index)
+    return [(t, float(z.loc[t])) for t in picks], monthly
+
+
+def _valid_mask(df, min_year, max_year):
+    if min_year is None and max_year is None:
+        return df["dt"].notna()
+    yr = df["dt"].dt.year
+    lo = min_year if min_year is not None else -(10 ** 9)
+    hi = max_year if max_year is not None else 10 ** 9
+    return df["dt"].notna() & yr.between(lo, hi)
+
+
+def scenes_by_aspect(entries: list[DiaryEntry], embed, lenses: Lenses | None = None,
+                     per_aspect: int = 15, min_year: int | None = None,
+                     max_year: int | None = None, entry_embeddings=None) -> dict[str, list[Scene]]:
+    """For each aspect, the entries that read most strongly as it — candidate
+    scenes, ranked. Ported from memoir_scenes.py: rank, don't cluster, because
+    logistics-style daily logs are too similar to cluster well."""
+    import pandas as pd
+    lenses = lenses or Lenses.default()
+    df, _ = build_frame(entries, lenses, embed, entry_embeddings)
+    valid_idx = df.index[_valid_mask(df, min_year, max_year)].to_numpy()
+    result: dict[str, list[Scene]] = {}
+    for a in lenses.aspects:
+        if not len(valid_idx):
+            result[a] = []
+            continue
+        s = df.loc[valid_idx, "asp_" + a].to_numpy()
+        order = valid_idx[s.argsort()[::-1][:per_aspect]]
+        scenes = []
+        for i in order:
+            d = df.at[i, "dt"]
+            when = d.date().isoformat() if pd.notna(d) else None
+            scenes.append(Scene(
+                title=f"{a} — {when or '?'}",
+                summary=snippet(df.at[i, "text"]),
+                entries=[entries[i]] if i < len(entries) else [],
+                when=when,
+                meta={"aspect": a, "score": float(df.at[i, "asp_" + a])},
+            ))
+        result[a] = scenes
+    return result
+
+
+def scenes_report(entries: list[DiaryEntry], embed, lenses: Lenses | None = None,
+                  per_aspect: int = 15, min_year: int | None = None,
+                  max_year: int | None = None, entry_embeddings=None) -> str:
+    """Markdown shortlist of candidate scenes by aspect, plus the aspect mix,
+    turning points, and out-of-range dates. Ported from memoir_scenes.py."""
+    import pandas as pd
+    lenses = lenses or Lenses.default()
+    df, _ = build_frame(entries, lenses, embed, entry_embeddings)
+    df["valid"] = _valid_mask(df, min_year, max_year)
+    out_of_range = df[df["dt"].notna() & ~df["valid"]]
+
+    out = ["# Memoir scenes — candidate material by emotional aspect", "",
+           f"{len(df)} entries · {int(df['valid'].sum())} in range. Each section lists the "
+           "entries that read most strongly as that feeling — your shortlist of scenes, "
+           "not errand-logs.", "",
+           "## Aspect mix (each in-range entry's dominant feeling)", "",
+           "| aspect | entries |", "|---|---|"]
+    for a, n in df[df["valid"]]["top_aspect"].value_counts().items():
+        out.append(f"| {a} | {int(n)} |")
+    out.append("")
+
+    by_aspect = scenes_by_aspect(entries, embed, lenses, per_aspect, min_year, max_year,
+                                 entry_embeddings=None)
+    for a, scenes in by_aspect.items():
+        out += [f"## {a.upper()} — top {per_aspect} candidate scenes", ""]
+        for sc in scenes:
+            out.append(f"- *{sc.when or '?'}* (score {sc.meta['score']:.2f}): {sc.summary}")
+        out.append("")
+
+    tps, _ = turning_points(df[df["valid"]])
+    if tps:
+        mi = df[df["valid"]].set_index("dt").sort_index()
+        out += ["## Candidate turning points (biggest month-to-month swings)", ""]
+        for t, z in tps:
+            near = mi[(mi.index.year == t.year) & (mi.index.month == t.month)]
+            out.append(f"**{t.strftime('%B %Y')}** (z={z:+.2f})")
+            for i in range(min(2, len(near))):
+                out.append(f"  - {snippet(near.iloc[i]['text'])}")
+            out.append("")
+
+    if len(out_of_range):
+        out += ["## Entries with out-of-range dates (likely parser typos to fix)", ""]
+        for _, r in out_of_range.iterrows():
+            out.append(f"- parsed as {r['dt'].date().isoformat()}: {snippet(r['text'], 160)}")
+        out.append("")
+    return "\n".join(out)

monograph/arc/spine.py

@@ -0,0 +1,80 @@
+"""Propose candidate memoir spines from an Evidence pack, via any LLM. Ported
+from spine_proposer.py: the system prompt and evidence formatting are already
+domain-agnostic; only the Ollama call was specific, and that now lives behind the
+LLM interface.
+
+Each spine is one possible book — a throughline question, the arc it implies, the
+scenes it draws on, and (crucially) what the journal is *missing* that the author
+would have to write from memory.
+"""
+from __future__ import annotations
+
+from ..types import Evidence, Spine
+from ..llm import LLM
+from ..llm.ollama_backend import parse_json
+
+SYSTEM = (
+    "You are a literary memoir editor doing structural reconnaissance on a writer's "
+    "multi-year personal journal. You are given only aggregate signals and a capped "
+    "set of representative entry snippets — never the whole journal. "
+    "Propose 3 to 6 candidate SPINES the journal could become: distinct memoirs, each "
+    "organized around one transformation or question.\n"
+    "Hard rules:\n"
+    "- Ground every spine ONLY in the evidence provided. Do not invent events, people, "
+    "or feelings.\n"
+    "- A diary records logistics and the present; it lacks interiority, retrospection, "
+    "and anything before it starts. For EACH spine, state plainly in "
+    "'missing_to_author' what is NOT in the journal and would have to be written from "
+    "memory (e.g. childhood, how the writer was parented, what a moment felt like "
+    "inside).\n"
+    "- 'throughline' must be a QUESTION the reader follows.\n"
+    "- 'scene_ids' must be chosen only from the provided snippet ids.\n"
+    "Return ONLY JSON of the form: {\"spines\": [ {\"id\": str, \"title\": str, "
+    "\"throughline\": str, \"arc\": str, \"draws_on\": {\"aspects\": [str], "
+    "\"people\": [str], \"period\": str}, \"scene_ids\": [int], \"strengths\": str, "
+    "\"missing_to_author\": str} ] }"
+)
+
+
+def _build_user(ev: Evidence) -> str:
+    lines = ["EVIDENCE PACK", "", f"{ev.n_valid} dated entries in range.", "",
+             "Aspect lenses (share of entries where this is the dominant feeling, and "
+             "how its prevalence trends early->late):"]
+    for a in ev.aspects:
+        lines.append(f"- {a['name']}: {a['share_pct']}% ({a['trend']}); example ids {a['top_ids']}")
+    lines += ["", "Entries per year: " + ", ".join(f"{y}:{c}" for y, c in ev.timeline.items())]
+    lines += ["", "Biggest emotional swings (candidate turning points):"]
+    for t in ev.turning_points:
+        lines.append(f"- {t['month']} (z={t['z']}); ids {t['ids']}")
+    lines += ["", "Recurring people: " + ", ".join(f"{e['name']}({e['count']})" for e in ev.entities)]
+    lines += ["", "REPRESENTATIVE SNIPPETS (cite these ids in scene_ids):"]
+    for i, text in ev.snippets.items():
+        lines.append(f"[{i}] {text}")
+    lines += ["", "Now propose the candidate spines as JSON."]
+    return "\n".join(lines)
+
+
+def propose_spines(evidence: Evidence, llm: LLM, temperature: float = 0.4) -> list[Spine]:
+    """Ask the LLM for candidate spines and return them as Spine objects. The raw
+    fields (throughline, draws_on, scene_ids, strengths, missing_to_author) are
+    kept in Spine.meta, with resolved snippet texts for the chosen scene_ids."""
+    content = llm.complete(_build_user(evidence), system=SYSTEM,
+                           temperature=temperature, json_mode=True)
+    result = parse_json(content)
+    raw = result.get("spines", result if isinstance(result, list) else [])
+    spines = []
+    for sp in raw:
+        scene_ids = sp.get("scene_ids", [])
+        scene_texts = {int(i): evidence.snippets.get(int(i))
+                       for i in scene_ids if str(i).lstrip("-").isdigit()}
+        spines.append(Spine(
+            title=sp.get("title", "(untitled)"),
+            premise=sp.get("throughline", ""),
+            arc=sp.get("arc", ""),
+            scenes=[],
+            meta={"id": sp.get("id"), "draws_on": sp.get("draws_on", {}),
+                  "scene_ids": scene_ids, "scene_texts": scene_texts,
+                  "strengths": sp.get("strengths", ""),
+                  "missing_to_author": sp.get("missing_to_author", "")},
+        ))
+    return spines