lattris 0.1.0

package/dist/save-session-chain.js

@@ -0,0 +1,136 @@
+// The whole-chain materialiser (session-block spec: "the extractor
+// materialises the WHOLE chain oldest-epoch-first on every save — extend an
+// epoch's block where it exists, create-and-link where it doesn't —
+// complete, idempotent, regardless of when the person last saved"; block-
+// graph spec: "The whole loop — epoch detection, chain materialisation,
+// fork handling, edge writing, reasons — is a deterministic script reading
+// the jsonl on one side and the CLI/API's own responses on the other").
+//
+// An internal module behind `lattris capture session <transcript.jsonl>`
+// (main.ts), which owns the IO: the token, the POST, the receipts dir, the
+// door rendering. What lives here is the deterministic drive loop and the
+// receipts store — machine-read receipts and refusal CODES, never parsed
+// prose. Per epoch, oldest first:
+//   - a RECEIPT HINT exists for this epoch (a prior run's own receipt,
+//     cached under the state dir): save with `extends` — the server's
+//     fingerprints decide; a divergence 409 is the scripted fork signal →
+//     re-submit `asNewBlock` + `forkedFrom` that block (the server verifies
+//     THAT claim too — the hint only ever nominates, per the law: "receipts
+//     and external ids are hints; the server's fingerprint comparison is
+//     the truth").
+//   - no hint: a plain save (`externalConversationId` nomination resolves a
+//     known epoch; otherwise create), with `continuesFrom` naming the
+//     PREVIOUS epoch's block from THIS run's receipts — the chain edge.
+//     A forked block carries its `forked_into` edge INSTEAD of a chain edge
+//     (the door's one-born-with-edge rule); continuity stays derivable
+//     through the origin's own chain — edge-economy, nothing duplicated.
+//   - the receipt (outcome + block id + turn count) is recorded back into
+//     the hint file, so the next run resumes exactly where the truth is.
+//
+// The AI-judgment inputs are --title, --ai-summary (applied to the LIVE —
+// last — epoch's save only), and --contributor (applied to EVERY epoch's
+// save — attribution is a whole-chain fact, not an epoch-specific one, and
+// an extend's own save carries it so re-running with the flag heals older
+// epochs of the same chain); everything else is mechanical.
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+// A save the drive loop could not scriptedly react to (anything beyond the
+// divergence-fork and stale-hint outcomes above). Typed, carrying the wire's
+// own status and body, so the command can render it through the CLI's one
+// door rule (classifyApiError → renderDoor) with the house exit codes — a
+// 401 mid-chain must read as NOAUTH, not a generic failure.
+export class ChainSaveError extends Error {
+    // Explicit fields, not constructor parameter properties — those are
+    // TS-only syntax the no-build `node --experimental-strip-types` run
+    // cannot erase (strip-only mode refuses them outright).
+    epoch;
+    status;
+    body;
+    constructor(epoch, status, body) {
+        super(`epoch ${epoch} save failed (${status} ${body.code ?? ''}): ${body.message ?? 'no message'}`);
+        this.epoch = epoch;
+        this.status = status;
+        this.body = body;
+    }
+}
+export const driveChain = async (chain, receipts, judgment, save) => {
+    const results = [];
+    let previousBlockId;
+    for (let k = 0; k < chain.epochs.length; k++) {
+        const turns = chain.epochs[k];
+        const isLive = k === chain.epochs.length - 1;
+        const base = { turns, source: chain.source };
+        if (chain.conversationId !== null)
+            base.externalConversationId = chain.conversationId;
+        if (isLive && judgment.title !== undefined)
+            base.title = judgment.title;
+        if (isLive && judgment.aiSummary !== undefined)
+            base.aiSummary = judgment.aiSummary;
+        // contributor rides EVERY epoch, not just the live one — attribution is a
+        // whole-chain fact, and an extend re-running with the flag heals older
+        // epochs whose original save predated the contact.
+        if (judgment.contributor !== undefined)
+            base.contributor = judgment.contributor;
+        const hinted = receipts.epochs[String(k)];
+        let outcome;
+        let forked = false;
+        if (hinted !== undefined) {
+            outcome = await save({ ...base, extends: hinted });
+            if (outcome.status === 409 && outcome.body.code === 'memory:session-diverged') {
+                // The scripted fork reaction: the walked path rewound-and-diverged
+                // from what that block holds — a NEW record, its origin claimed and
+                // server-verified. No continuesFrom here (the door's one-edge rule);
+                // the chain stays derivable through the origin.
+                outcome = await save({ ...base, asNewBlock: true, forkedFrom: hinted });
+                forked = true;
+            }
+            else if (outcome.status === 400 && outcome.body.code === 'memory:unknown-extends') {
+                // The hint went stale (the block was deleted) — hints never decide:
+                // fall back to the no-hint path.
+                outcome = await save(previousBlockId !== undefined ? { ...base, continuesFrom: previousBlockId } : base);
+            }
+        }
+        else {
+            outcome = await save(previousBlockId !== undefined && k > 0 ? { ...base, continuesFrom: previousBlockId } : base);
+        }
+        if (outcome.status !== 200 || !outcome.body.block?.id) {
+            throw new ChainSaveError(k, outcome.status, outcome.body);
+        }
+        const blockId = outcome.body.block.id;
+        receipts.epochs[String(k)] = blockId;
+        results.push({
+            epoch: k,
+            blockId,
+            outcome: outcome.body.outcome ?? 'unknown',
+            turnCount: outcome.body.turnCount ?? turns.length,
+            forked
+        });
+        previousBlockId = blockId;
+    }
+    return results;
+};
+// ─── the receipts store (hints, never decisions) ────────────────────────────
+// Lives under the CLI's own state dir — the command passes sessionDir() in, so
+// this module never re-derives the LATTRIS_HOME/XDG resolution main.ts owns.
+// Same 0700/0600 hygiene as the session file: a receipt names block ids in the
+// person's own record.
+const receiptsPath = (dir, conversationId) => join(dir, 'chains', `${conversationId}.json`);
+export const loadReceipts = (dir, conversationId) => {
+    if (conversationId === null)
+        return { epochs: {} };
+    try {
+        return JSON.parse(readFileSync(receiptsPath(dir, conversationId), 'utf8'));
+    }
+    catch {
+        return { epochs: {} };
+    }
+};
+export const saveReceipts = (dir, conversationId, receipts) => {
+    if (conversationId === null)
+        return;
+    mkdirSync(join(dir, 'chains'), { recursive: true, mode: 0o700 });
+    writeFileSync(receiptsPath(dir, conversationId), JSON.stringify(receipts, null, 2), {
+        mode: 0o600
+    });
+};
+//# sourceMappingURL=save-session-chain.js.map

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "lattris",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "First-party CLI for Lattris — sign in, capture notes and sessions, and read your own tree from the terminal.",
+  "keywords": [
+    "lattris",
+    "cli",
+    "notes",
+    "knowledge"
+  ],
+  "license": "UNLICENSED",
+  "homepage": "https://lattris.com",
+  "bin": {
+    "lattris": "./dist/main.js"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "files": [
+    "dist/main.js",
+    "dist/extract-claude-jsonl.js",
+    "dist/save-session-chain.js",
+    "dist/build.json"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
+}