npm - openwriter - Versions diffs - 0.36.2 → 0.37.0 - Mend

openwriter 0.36.2 → 0.37.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (15) hide show

package/dist/bin/pad.js +4 -1
package/dist/client/assets/index-BBEdpqBq.js +215 -0
package/dist/client/assets/{index-CQTcQ6xr.css → index-Dz0iuWDM.css} +1 -1
package/dist/client/index.html +2 -2
package/dist/server/attribution.js +330 -0
package/dist/server/commits.js +215 -0
package/dist/server/index.js +97 -0
package/dist/server/mcp.js +33 -7
package/dist/server/state.js +125 -9
package/dist/server/versions.js +31 -8
package/dist/server/ws.js +22 -3
package/package.json +1 -1
package/skill/SKILL.md +3 -3
package/skill/docs/setup.md +2 -2
package/dist/client/assets/index-BaXu2PtF.js +0 -215

package/dist/client/index.html CHANGED Viewed

@@ -10,8 +10,8 @@
     <link rel="preconnect" href="https://fonts.googleapis.com" />
     <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
     <link href="https://fonts.googleapis.com/css2?family=Charter:ital,wght@0,400;0,700;1,400&family=Crimson+Pro:ital,wght@0,300;0,400;0,600;0,700;1,400&family=DM+Sans:ital,wght@0,400;0,500;0,600;0,700;1,400&family=DM+Serif+Display&family=IBM+Plex+Mono:wght@400;500;600&family=IBM+Plex+Sans:wght@400;500;600&family=Inter:wght@400;500;600;700&family=Libre+Baskerville:ital,wght@0,400;0,700;1,400&family=Literata:ital,opsz,wght@0,7..72,400;0,7..72,600;0,7..72,700;1,7..72,400&family=Newsreader:ital,opsz,wght@0,6..72,400;0,6..72,600;1,6..72,400&family=Playfair+Display:wght@400;600;700;900&family=Source+Serif+4:ital,opsz,wght@0,8..60,400;0,8..60,600;0,8..60,700;1,8..60,400&family=Space+Grotesk:wght@400;500;600;700&family=Space+Mono:wght@400;700&display=swap" rel="stylesheet" />
-    <script type="module" crossorigin src="/assets/index-BaXu2PtF.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-CQTcQ6xr.css">
+    <script type="module" crossorigin src="/assets/index-BBEdpqBq.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-Dz0iuWDM.css">
   </head>
   <body>
     <div id="root"></div>

package/dist/server/attribution.js ADDED Viewed

@@ -0,0 +1,330 @@
+/**
+ * Document author-attribution — the capture core.
+ *
+ * One system, folded from three that already exist (versions + activity log +
+ * the node-identity matcher's per-sentence fingerprints). See
+ * adr/document-history-attribution.md and chip-notes/author-attribution-design.md.
+ *
+ * THE LOAD-BEARING DECISION: blame is anchored to `sentenceHash`, never to a
+ * nodeId or a matcher mutation label. A sentence's author follows its content
+ * hash — the SAME `simpleHash(text + terminator)` the fingerprint/enrichment
+ * path already computes every save (see node-fingerprint.ts / enrichment.ts).
+ * Because the anchor is content-addressed, attribution survives split, merge,
+ * type-change, heavy-rewrite-that-re-mints-an-id, and paste-back without any
+ * dependence on node-id lineage:
+ *   - a sentence whose hash is unchanged keeps its author (it didn't change);
+ *   - a sentence whose hash is new is attributed to the current actor;
+ *   - a removed sentence's author is retained in `retired` so paste-back revives it.
+ *
+ * Tiers (adr invariant 4):
+ *   Tier C = .versions/{docId}/{ts}.md   — commit / restore (versions.ts)
+ *   Tier B = _history/{docId}.jsonl      — append-only attributed EditEvents
+ *   Tier A = _blame/{docId}.json         — materialized current blame (this module)
+ *
+ * This file holds the PURE core (`computeBlame`, `summarizeBlame`) plus the
+ * per-doc sidecar IO. It is intentionally free of any state.ts coupling so it
+ * unit-tests in isolation (scripts/test-attribution.mjs).
+ */
+import { existsSync, mkdirSync, readFileSync, appendFileSync, statSync, renameSync, unlinkSync } from 'fs';
+import { join } from 'path';
+import { getDataDir, atomicWriteFileSync } from './helpers.js';
+import { splitSentences, simpleHash } from './node-fingerprint.js';
+const RETIRED_CAP = 1000; // bound paste-back memory per doc
+// Bound the append-only edit log. At rotation, the live file is rolled to
+// `.1` (overwriting any prior `.1`) and a fresh file started — so the log
+// never grows past ~2x the cap. Old per-event detail ages out; commit
+// SUMMARIES live in the (tiny, never-rotated) commit manifest, so the
+// human-readable history survives rotation. Recent detail (the useful part)
+// always stays. adr: adr/document-history-attribution.md
+const MAX_HISTORY_BYTES = 5 * 1024 * 1024;
+function blameDir() { return join(getDataDir(), '_blame'); }
+function historyDir() { return join(getDataDir(), '_history'); }
+function blamePath(docId) { return join(blameDir(), `${docId}.json`); }
+function historyPath(docId) { return join(historyDir(), `${docId}.jsonl`); }
+/** Per-block ordered sentence hashes — the same hashing the fingerprint path uses. */
+export function blockSentenceHashes(block) {
+    const out = [];
+    for (const s of splitSentences(block.text || '')) {
+        out.push(simpleHash(s.text + s.terminator));
+    }
+    return out;
+}
+/**
+ * PURE: given the prior blame (or null on first save), the current blocks, the
+ * acting party, and a timestamp, produce the next blame state + the list of
+ * sentence-level changes this save introduced.
+ *
+ * No IO, no globals — every input is a parameter.
+ */
+export function computeBlame(prev, blocks, actor, ts) {
+    // Flat prior author lookup by content hash: live sentences first, then
+    // retired (paste-back). Live wins when a hash appears in both.
+    const priorByHash = new Map();
+    if (prev) {
+        for (const hash of Object.keys(prev.retired))
+            priorByHash.set(hash, prev.retired[hash]);
+        for (const nodeId of Object.keys(prev.nodes)) {
+            const sents = prev.nodes[nodeId].sentences;
+            for (const hash of Object.keys(sents))
+                priorByHash.set(hash, sents[hash]);
+        }
+    }
+    const liveBefore = new Set();
+    if (prev)
+        for (const nodeId of Object.keys(prev.nodes)) {
+            for (const hash of Object.keys(prev.nodes[nodeId].sentences))
+                liveBefore.add(hash);
+        }
+    const nodes = {};
+    const spans = [];
+    const currentHashes = new Set();
+    for (const block of blocks) {
+        const nodeId = block.id;
+        if (!nodeId)
+            continue; // post-matcher every real block has an id; guard anyway
+        const hashes = blockSentenceHashes(block);
+        if (hashes.length === 0)
+            continue; // containers / empty blocks carry no prose
+        const nodeExistedBefore = !!(prev && prev.nodes[nodeId]);
+        const nodeBlame = nodes[nodeId] || { sentences: {} };
+        for (const hash of hashes) {
+            currentHashes.add(hash);
+            const prior = priorByHash.get(hash);
+            if (prior) {
+                // Unchanged content — author unchanged. (Includes paste-back: a hash
+                // resurfacing from `retired` inherits its original author, not the paster.)
+                nodeBlame.sentences[hash] = { ...prior };
+            }
+            else {
+                // New content — attributed to the current actor.
+                nodeBlame.sentences[hash] = { firstBy: actor, lastBy: actor, firstTs: ts, lastTs: ts };
+                spans.push({ nodeId, sentenceHash: hash, op: nodeExistedBefore ? 'edit' : 'add', actor });
+            }
+        }
+        nodes[nodeId] = nodeBlame;
+    }
+    // Removed = previously-live hashes now absent. Retire them (bounded) so a
+    // later paste-back revives the original author.
+    const retired = {};
+    if (prev)
+        for (const hash of Object.keys(prev.retired)) {
+            if (!currentHashes.has(hash))
+                retired[hash] = prev.retired[hash];
+        }
+    for (const hash of liveBefore) {
+        if (!currentHashes.has(hash)) {
+            const sb = priorByHash.get(hash);
+            if (sb) {
+                retired[hash] = sb;
+                spans.push({ nodeId: '', sentenceHash: hash, op: 'remove', actor });
+            }
+        }
+    }
+    capRetired(retired);
+    const seq = (prev?.lastSeq ?? 0) + (spans.length > 0 ? 1 : 0);
+    const blame = {
+        versionTs: prev?.versionTs ?? 0,
+        attributionSince: prev?.attributionSince ?? ts,
+        lastSeq: seq,
+        nodes,
+        retired,
+    };
+    return { blame, spans };
+}
+/** Drop oldest retired entries (by lastTs) past the cap. */
+function capRetired(retired) {
+    const keys = Object.keys(retired);
+    if (keys.length <= RETIRED_CAP)
+        return;
+    keys.sort((a, b) => retired[a].lastTs - retired[b].lastTs);
+    for (const k of keys.slice(0, keys.length - RETIRED_CAP))
+        delete retired[k];
+}
+/**
+ * PURE rollup for the heatmap + doc-header %. Weighted by character count so a
+ * one-line agent heading does not count the same as a 300-word human paragraph.
+ */
+export function summarizeBlame(blame, blocks) {
+    const chars = { human: 0, agent: 0, unknown: 0 };
+    const nodeOrigin = {};
+    for (const block of blocks) {
+        const nodeId = block.id;
+        if (!nodeId)
+            continue;
+        const sents = splitSentences(block.text || '');
+        if (sents.length === 0)
+            continue;
+        const nb = blame?.nodes[nodeId];
+        let sawHuman = false, sawAgent = false, sawUnknown = false;
+        for (const s of sents) {
+            const hash = simpleHash(s.text + s.terminator);
+            const by = nb?.sentences[hash]?.lastBy ?? 'unknown';
+            const len = s.text.length + s.terminator.length;
+            chars[by] += len;
+            if (by === 'human')
+                sawHuman = true;
+            else if (by === 'agent')
+                sawAgent = true;
+            else
+                sawUnknown = true;
+        }
+        nodeOrigin[nodeId] = sawHuman && sawAgent ? 'mixed'
+            : sawAgent ? 'agent' : sawHuman ? 'human' : 'unknown';
+    }
+    const total = chars.human + chars.agent + chars.unknown || 1;
+    return {
+        chars,
+        percent: {
+            human: Math.round((chars.human / total) * 100),
+            agent: Math.round((chars.agent / total) * 100),
+            unknown: Math.round((chars.unknown / total) * 100),
+        },
+        nodes: nodeOrigin,
+    };
+}
+// ============================================================================
+// SIDECAR IO  (Tier A: _blame/{docId}.json · Tier B: _history/{docId}.jsonl)
+// ============================================================================
+export function readBlame(docId) {
+    if (!docId)
+        return null;
+    const path = blamePath(docId);
+    if (!existsSync(path))
+        return null;
+    try {
+        const parsed = JSON.parse(readFileSync(path, 'utf-8'));
+        if (parsed && typeof parsed === 'object' && parsed.nodes)
+            return parsed;
+    }
+    catch { /* corrupt sidecar — treat as absent, rebuildable from history+versions */ }
+    return null;
+}
+export function writeBlame(docId, blame) {
+    if (!docId)
+        return;
+    const dir = blameDir();
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+    atomicWriteFileSync(blamePath(docId), JSON.stringify(blame));
+}
+/** Roll the history log to `.1` when it exceeds the cap, then start fresh. */
+function rotateHistoryIfNeeded(path) {
+    try {
+        if (!existsSync(path) || statSync(path).size < MAX_HISTORY_BYTES)
+            return;
+        const rolled = `${path}.1`;
+        if (existsSync(rolled)) {
+            try {
+                unlinkSync(rolled);
+            }
+            catch { /* best-effort */ }
+        }
+        renameSync(path, rolled);
+    }
+    catch { /* best-effort — never block a save */ }
+}
+/** Append one EditEvent to the per-doc history log (Tier B). Best-effort. */
+export function appendEditEvent(docId, event) {
+    if (!docId || event.spans.length === 0)
+        return;
+    try {
+        const dir = historyDir();
+        if (!existsSync(dir))
+            mkdirSync(dir, { recursive: true });
+        const path = historyPath(docId);
+        rotateHistoryIfNeeded(path);
+        appendFileSync(path, JSON.stringify(event) + '\n');
+    }
+    catch { /* history is observational — never block a save */ }
+}
+/** Read the full per-doc edit history (Tier B), oldest-first. */
+export function readHistory(docId) {
+    if (!docId)
+        return [];
+    const path = historyPath(docId);
+    if (!existsSync(path))
+        return [];
+    const out = [];
+    try {
+        for (const line of readFileSync(path, 'utf-8').split('\n')) {
+            if (!line)
+                continue;
+            try {
+                const e = JSON.parse(line);
+                if (e && typeof e.ts === 'number' && Array.isArray(e.spans))
+                    out.push(e);
+            }
+            catch { /* skip malformed */ }
+        }
+    }
+    catch { /* ignore */ }
+    return out;
+}
+/**
+ * True when two blame states have the same node ids AND the same sentence-hash
+ * set per node — i.e. the materialized blame is structurally identical. Used to
+ * skip a redundant sidecar rewrite when a save produced no authorship change.
+ * (Authors can't differ here: this is only consulted when spans is empty, which
+ * means no sentence was added/edited/removed, so per-hash authors are unchanged.)
+ */
+function sameBlameShape(a, b) {
+    const an = Object.keys(a.nodes), bn = Object.keys(b.nodes);
+    if (an.length !== bn.length)
+        return false;
+    for (const id of an) {
+        const bNode = b.nodes[id];
+        if (!bNode)
+            return false;
+        const ah = Object.keys(a.nodes[id].sentences), bh = Object.keys(bNode.sentences);
+        if (ah.length !== bh.length)
+            return false;
+        for (const h of ah)
+            if (!bNode.sentences[h])
+                return false;
+    }
+    return true;
+}
+/**
+ * The single capture entry point called from writeToDisk(). Reads prior blame,
+ * computes the delta, persists Tier A + Tier B. Returns the summary for callers
+ * that want to broadcast it. Best-effort: never throws into the save path.
+ *
+ * `actor` is REQUIRED and save-scoped (adr invariant 3) — there is no default.
+ */
+export function captureAttribution(docId, blocks, actor, ts, via) {
+    if (!docId)
+        return null;
+    try {
+        const prev = readBlame(docId);
+        const { blame, spans } = computeBlame(prev, blocks, actor, ts);
+        if (spans.length > 0) {
+            appendEditEvent(docId, { ts, docId, actor, seq: blame.lastSeq, versionTs: blame.versionTs, via, spans });
+            writeBlame(docId, blame);
+        }
+        else if (!prev || !sameBlameShape(prev, blame)) {
+            // No authored change this save. Only rewrite the sidecar when the node
+            // shape actually shifted (e.g. a matcher id-translation re-keyed nodes
+            // with unchanged content) — otherwise the file is byte-identical and the
+            // write is pure IO churn. Skips a full _blame rewrite on every keystroke-
+            // debounced save that didn't change authorship.
+            writeBlame(docId, blame);
+        }
+        return summarizeBlame(blame, blocks);
+    }
+    catch {
+        return null;
+    }
+}
+/** Stamp the version cut onto the current blame (called when a snapshot is written). */
+export function bindBlameToVersion(docId, versionTs) {
+    if (!docId || !versionTs)
+        return;
+    try {
+        const blame = readBlame(docId);
+        if (blame && blame.versionTs !== versionTs) {
+            blame.versionTs = versionTs;
+            writeBlame(docId, blame);
+        }
+    }
+    catch { /* best-effort */ }
+}

package/dist/server/commits.js ADDED Viewed

@@ -0,0 +1,215 @@
+/**
+ * Version commits — the attributed git-history layer over the version system.
+ *
+ * A COMMIT is a boundary cut (agent finished writing / human accepted / manual
+ * Save-version) that bundles the attributed edit-events recorded since the
+ * previous commit into one reviewable unit. The 30s auto-snapshots in
+ * versions.ts are demoted to a hidden restore safety-net; commits are what the
+ * Versions panel shows as history.
+ *
+ * This builds entirely on the Phase-1 substrate — it does NOT capture anything
+ * new. The `_history/{docId}.jsonl` EditEvents (from attribution.ts) already
+ * record which node/sentence changed, by whom, with what op. A commit just
+ * delimits a ts-range of that log, rolls it up, and pins a content snapshot.
+ *
+ * Storage: `_commits/{docId}.jsonl` (append-only, one Commit per line).
+ *
+ * adr: adr/document-history-attribution.md
+ */
+import { existsSync, mkdirSync, readFileSync, appendFileSync } from 'fs';
+import { join } from 'path';
+import { getDataDir } from './helpers.js';
+import { readHistory } from './attribution.js';
+import { writeSnapshotMarkdown, getVersionContent, pruneVersions } from './versions.js';
+function commitsDir() { return join(getDataDir(), '_commits'); }
+function commitsPath(docId) { return join(commitsDir(), `${docId}.jsonl`); }
+/** All commits for a doc, oldest-first (file order). */
+export function listCommits(docId) {
+    if (!docId)
+        return [];
+    const path = commitsPath(docId);
+    if (!existsSync(path))
+        return [];
+    const out = [];
+    try {
+        for (const line of readFileSync(path, 'utf-8').split('\n')) {
+            if (!line)
+                continue;
+            try {
+                const c = JSON.parse(line);
+                if (c && typeof c.ts === 'number')
+                    out.push(c);
+            }
+            catch { /* skip malformed */ }
+        }
+    }
+    catch { /* ignore */ }
+    return out;
+}
+function lastCommit(docId) {
+    const all = listCommits(docId);
+    return all.length > 0 ? all[all.length - 1] : null;
+}
+/** Roll a set of EditEvents up into a per-actor changeset tally. */
+export function rollupChangeset(events) {
+    const summary = { added: 0, edited: 0, removed: 0, byActor: {} };
+    const actorSet = new Set();
+    for (const e of events) {
+        for (const span of e.spans) {
+            const actor = span.actor;
+            actorSet.add(actor);
+            const tally = summary.byActor[actor] || { added: 0, edited: 0, removed: 0 };
+            if (span.op === 'add') {
+                summary.added++;
+                tally.added++;
+            }
+            else if (span.op === 'edit') {
+                summary.edited++;
+                tally.edited++;
+            }
+            else if (span.op === 'remove') {
+                summary.removed++;
+                tally.removed++;
+            }
+            summary.byActor[actor] = tally;
+        }
+    }
+    return { summary, actors: Array.from(actorSet) };
+}
+/**
+ * Create a commit at a boundary. Bundles the _history events recorded since the
+ * previous commit, rolls them up, pins a content snapshot, and appends the
+ * manifest entry. Returns the Commit, or null when there is nothing new to
+ * commit (no empty commits). Best-effort callers wrap in try/catch.
+ *
+ * `markdown` is the current on-disk doc content to snapshot for this commit;
+ * `nowTs` is the commit timestamp (pass the save/event time so it's deterministic).
+ */
+export function commitVersion(docId, markdown, opts) {
+    if (!docId)
+        return null;
+    const prev = lastCommit(docId);
+    const fromTs = prev ? prev.ts : 0;
+    // Bundle the attributed edit-events since the previous commit.
+    const events = readHistory(docId).filter((e) => e.ts > fromTs && e.ts <= opts.nowTs);
+    if (events.length === 0)
+        return null; // nothing changed since the last commit
+    const { summary, actors } = rollupChangeset(events);
+    // No net authored change (e.g. only no-op events) — skip.
+    if (summary.added + summary.edited + summary.removed === 0)
+        return null;
+    // Pin the content for this commit so its diff (vs the parent) is reproducible.
+    // writeSnapshotMarkdown dedups identical content; pruneVersions then bounds the
+    // snapshot store by the standard retention (max 50 / keep-7-days) — so commit
+    // snapshots don't accumulate without limit. The commit manifest is tiny and
+    // kept forever; only old commits' restorable *content* ages out (the panel's
+    // `restorable` flag reflects this). adr: adr/document-history-attribution.md
+    const snapshotTs = writeSnapshotMarkdown(docId, markdown);
+    pruneVersions(docId);
+    const commit = {
+        ts: opts.nowTs,
+        parent: prev ? prev.ts : null,
+        fromTs,
+        trigger: opts.trigger,
+        actors,
+        snapshotTs,
+        summary,
+    };
+    if (opts.note)
+        commit.note = opts.note;
+    try {
+        const dir = commitsDir();
+        if (!existsSync(dir))
+            mkdirSync(dir, { recursive: true });
+        appendFileSync(commitsPath(docId), JSON.stringify(commit) + '\n');
+    }
+    catch {
+        return null;
+    }
+    return commit;
+}
+/**
+ * The attributed change detail for one commit — the raw events that made it up,
+ * resolved against the commit's snapshot so the panel can show the actual
+ * changed node text alongside who changed it. Returns null if the commit or its
+ * snapshot is gone (pruned).
+ */
+export function getCommitDetail(docId, commitTs) {
+    const all = listCommits(docId);
+    const commit = all.find((c) => c.ts === commitTs);
+    if (!commit)
+        return null;
+    const events = readHistory(docId).filter((e) => e.ts > commit.fromTs && e.ts <= commit.ts);
+    return {
+        commit,
+        parentSnapshotTs: commit.parent ? (all.find((c) => c.ts === commit.parent)?.snapshotTs ?? null) : null,
+        events,
+    };
+}
+/** Convenience: does this commit's snapshot still exist on disk (not pruned)? */
+export function commitSnapshotAvailable(docId, commitTs) {
+    const c = listCommits(docId).find((x) => x.ts === commitTs);
+    return !!(c && getVersionContent(docId, c.snapshotTs) !== null);
+}
+/**
+ * Read a doc's current on-disk content and commit. Thin wrapper used by the
+ * trigger sites (agent-finished / accept / manual) so they don't each
+ * re-implement the file read. The snapshot is the canonical disk content (the
+ * restorable state); the changeset is sourced from the attributed _history
+ * events (always correct re: what/who, independent of pending state). Callers
+ * pass the filePath directly — commits.ts deliberately does NOT depend on
+ * documents.ts/state.ts so the capture sites in state.ts can call into it
+ * without an import cycle. Returns null on read failure or nothing-to-commit.
+ */
+export function commitFromFile(docId, filePath, opts) {
+    if (!docId || !filePath || !existsSync(filePath))
+        return null;
+    let markdown;
+    try {
+        markdown = readFileSync(filePath, 'utf-8');
+    }
+    catch {
+        return null;
+    }
+    return commitVersion(docId, markdown, opts);
+}
+/**
+ * Debounced agent-finished commit, PER DOC. Called from the capture sites
+ * (writeToDisk / flushDocToFile) on every agent write — those are the only
+ * places that reliably see EVERY agent edit tool (write_to_pad, populate, etc.)
+ * AND know the exact target docId + filePath. A burst of rapid agent writes to
+ * one doc coalesces into a single commit (~1.5s). commitFromFile is idempotent
+ * (no new events → no-op). adr: adr/document-history-attribution.md
+ */
+const agentCommitTimers = new Map();
+export function scheduleAgentCommit(docId, filePath) {
+    if (!docId || !filePath)
+        return;
+    const existing = agentCommitTimers.get(docId);
+    if (existing)
+        clearTimeout(existing);
+    agentCommitTimers.set(docId, setTimeout(() => {
+        agentCommitTimers.delete(docId);
+        try {
+            commitFromFile(docId, filePath, { trigger: 'agent-finished', actor: 'agent', nowTs: Date.now() });
+        }
+        catch { /* best-effort */ }
+    }, 1500));
+}
+/** Build a compact one-line changeset label, e.g. "+3 agent · 2 edited you". */
+export function summaryLine(summary) {
+    const parts = [];
+    for (const actor of Object.keys(summary.byActor)) {
+        const t = summary.byActor[actor];
+        const bits = [];
+        if (t.added)
+            bits.push(`+${t.added}`);
+        if (t.edited)
+            bits.push(`~${t.edited}`);
+        if (t.removed)
+            bits.push(`-${t.removed}`);
+        if (bits.length)
+            parts.push(`${bits.join(' ')} ${actor === 'human' ? 'you' : actor}`);
+    }
+    return parts.join(' · ') || 'no changes';
+}

package/dist/server/index.js CHANGED Viewed

@@ -480,6 +480,103 @@ export async function startHttpServer(options = {}) {
             res.status(500).json({ error: err.message });
         }
     });
+    // Author attribution (voice-shape heatmap data). Returns char-weighted
+    // composition + per-node origin (human|agent|mixed|unknown) for a doc.
+    // The heatmap colours the live editor by nodeOrigins; the header shows percent.
+    // adr: adr/document-history-attribution.md
+    app.get('/api/attribution/:docId', async (req, res) => {
+        try {
+            const { docId } = req.params;
+            const { readBlame, summarizeBlame } = await import('./attribution.js');
+            const { tiptapToBlocks } = await import('./node-blocks.js');
+            let doc = null;
+            if (getDocId() === docId) {
+                doc = getDocument();
+            }
+            else {
+                const { filenameByDocId } = await import('./documents.js');
+                const { loadDocFromDisk } = await import('./pending-overlay.js');
+                const fn = filenameByDocId(docId);
+                if (fn) {
+                    try {
+                        doc = loadDocFromDisk(fn).document;
+                    }
+                    catch {
+                        doc = null;
+                    }
+                }
+            }
+            const blame = readBlame(docId);
+            if (!doc) {
+                res.json({ tracked: blame !== null, percent: { human: 0, agent: 0, unknown: 0 }, chars: { human: 0, agent: 0, unknown: 0 }, nodeOrigins: {}, attributionSince: blame?.attributionSince ?? null });
+                return;
+            }
+            const summary = summarizeBlame(blame, tiptapToBlocks(doc));
+            res.json({ tracked: blame !== null, percent: summary.percent, chars: summary.chars, nodeOrigins: summary.nodes, attributionSince: blame?.attributionSince ?? null });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // Version commits — the attributed git-history for a doc (newest first), each
+    // with a one-line changeset label. adr: adr/document-history-attribution.md
+    app.get('/api/commits/:docId', async (req, res) => {
+        try {
+            const { listCommits, summaryLine, commitSnapshotAvailable } = await import('./commits.js');
+            const commits = listCommits(req.params.docId)
+                .map((c) => ({ ...c, label: summaryLine(c.summary), restorable: commitSnapshotAvailable(req.params.docId, c.ts) }))
+                .reverse(); // newest first for the panel
+            res.json({ commits });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // One commit's attributed change detail (the per-event diff data the panel
+    // renders when a commit row is expanded).
+    app.get('/api/commit-detail/:docId/:ts', async (req, res) => {
+        try {
+            const { getCommitDetail } = await import('./commits.js');
+            const detail = getCommitDetail(req.params.docId, Number(req.params.ts));
+            if (!detail) {
+                res.status(404).json({ error: 'commit not found' });
+                return;
+            }
+            res.json(detail);
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // Manual "Save version" — create a commit now with an optional note. The
+    // changeset is whatever attributed edits have accrued since the last commit.
+    app.post('/api/commit', async (req, res) => {
+        try {
+            const { docId, note } = req.body || {};
+            if (!docId || typeof docId !== 'string') {
+                res.status(400).json({ error: 'docId required' });
+                return;
+            }
+            // Flush the active doc so its latest edits are on disk before we snapshot.
+            if (getDocId() === docId) {
+                try {
+                    save();
+                }
+                catch { /* best-effort */ }
+            }
+            const { commitFromFile } = await import('./commits.js');
+            const { filenameByDocId } = await import('./documents.js');
+            const { resolveDocPath } = await import('./helpers.js');
+            const fn = filenameByDocId(docId);
+            const commit = fn
+                ? commitFromFile(docId, resolveDocPath(fn), { trigger: 'manual', actor: 'human', note: typeof note === 'string' ? note : undefined, nowTs: Date.now() })
+                : null;
+            res.json({ committed: commit !== null, commit });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
     // References: full rebuild across all docs (idempotent rescue path).
     // Walks every .md, extracts legacy prose `doc:` links from body, merges
     // their targets into `references:`, strips any legacy `backlinks:` field.