lattris 0.1.4 → 0.2.1

package/dist/memory/capture-session.js

@@ -0,0 +1,168 @@
+import { extractChain } from "./extract-claude-jsonl.js";
+import { ChainSaveError, driveChain } from "./save-session-chain.js";
+import { loadReceipts, saveReceipts } from "../store/chains.js";
+import { allowWords, isRefusalValue, needsYesWords, resolveBornShares, withShares } from "../memory/capture-common.js";
+import { emit } from "../render/output.js";
+import { sanitizeForTerminal } from "../render/text.js";
+import { classifyApiError } from "../request/door.js";
+import { EXIT, refusal } from "../store/exit.js";
+import { refusalOf } from "../request/api-fetch.js";
+import { signedIn } from "../request/access-token.js";
+export const formatSavedSession = (r) => {
+    const lines = [
+        `Saved session ${r.block.id}  (outcome: ${r.outcome}, turns stored: ${r.turnCount})`
+    ];
+    if (r.block.title)
+        lines.push(`  title        ${sanitizeForTerminal(r.block.title)}`);
+    lines.push(`  capturedAt   ${r.block.capturedAt}`);
+    return lines.join('\n');
+};
+export const buildCaptureSessionBody = (turns, flags, asNew, shares) => {
+    const body = { turns };
+    if (flags.title !== undefined)
+        body.title = flags.title;
+    if (flags.intent !== undefined)
+        body.intent = flags.intent;
+    if (flags.capturedAt !== undefined)
+        body.capturedAt = flags.capturedAt;
+    if (flags.source !== undefined)
+        body.source = flags.source;
+    if (flags.conversationId !== undefined)
+        body.externalConversationId = flags.conversationId;
+    if (flags.extends !== undefined)
+        body.extends = flags.extends;
+    if (flags.from !== undefined)
+        body.from = Number(flags.from);
+    if (asNew)
+        body.asNewBlock = true;
+    withShares(body, shares);
+    if (flags.continuesFrom !== undefined)
+        body.continuesFrom = flags.continuesFrom;
+    if (flags.forkedFrom !== undefined)
+        body.forkedFrom = flags.forkedFrom;
+    if (flags.aiSummary !== undefined)
+        body.aiSummary = flags.aiSummary;
+    if (flags.contributor !== undefined)
+        body.contributor = flags.contributor;
+    return body;
+};
+export const captureSession = async (cfg, io, content, flags, opts) => {
+    let turns;
+    try {
+        turns = JSON.parse(content);
+    }
+    catch {
+        return refusal('stdin must be a JSON array of turns — [{"speaker":"user","text":"…"}, …]. ' +
+            'Run `lattris capture memory --type session` for the form.\n');
+    }
+    if (!Array.isArray(turns) || turns.length === 0) {
+        return refusal('stdin must be a NON-EMPTY JSON array of turns — a session is at least one turn.\n');
+    }
+    if (flags.from !== undefined && !/^\d+$/.test(flags.from)) {
+        return refusal(`--from must be a non-negative integer, got: ${flags.from}\n`);
+    }
+    if (opts.shareWith.length > 0 && !opts.yes) {
+        return refusal(needsYesWords('session', allowWords(opts.shareWith)));
+    }
+    const accessToken = await signedIn(io, cfg);
+    if (typeof accessToken !== 'string')
+        return accessToken;
+    let shares;
+    if (opts.shareWith.length > 0 || opts.deny.length > 0) {
+        const resolved = await resolveBornShares(cfg, io, accessToken, opts.shareWith, opts.deny);
+        if (isRefusalValue(resolved))
+            return resolved;
+        shares = resolved;
+    }
+    const result = await io.api(accessToken, `${cfg.apiUrl}/memories/sessions`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(buildCaptureSessionBody(turns, flags, opts.asNew, shares))
+    });
+    if (!result.ok)
+        return refusalOf(result);
+    io.stdout.write(`${formatSavedSession(result.data)}\n`);
+};
+const TRANSCRIPT_INAPPLICABLE_FLAGS = [
+    ['--intent', 'intent'],
+    ['--captured-at', 'capturedAt'],
+    ['--source', 'source'],
+    ['--conversation-id', 'conversationId'],
+    ['--extends', 'extends'],
+    ['--from', 'from'],
+    ['--continues-from', 'continuesFrom'],
+    ['--forked-from', 'forkedFrom']
+];
+const formatChainEpoch = (r) => `epoch ${r.epoch}: ${r.outcome}${r.forked ? ' (forked)' : ''} — block ${r.blockId}, ${r.turnCount} turns stored`;
+export const captureSessionTranscript = async (cfg, io, file, flags, asNew, sharesNamed = false) => {
+    for (const [name, key] of TRANSCRIPT_INAPPLICABLE_FLAGS) {
+        if (flags[key] !== undefined) {
+            return refusal(`${name} does not apply when capturing from a transcript — the chain drive ` +
+                `derives it. Only --title and --ai-summary ride this form.\n`);
+        }
+    }
+    if (sharesNamed) {
+        return refusal('--share-with and --deny do not apply when capturing from a transcript — the chain ' +
+            'drive derives it. Only --title and --ai-summary ride this form.\n');
+    }
+    if (asNew) {
+        return refusal('--as-new does not apply when capturing from a transcript — a fork is detected ' +
+            'and saved by the drive itself.\n');
+    }
+    let jsonl;
+    try {
+        jsonl = io.store.files.readFileSync(file, 'utf8');
+    }
+    catch (e) {
+        const code = e.code ?? 'error';
+        return refusal(`Cannot read transcript ${file} (${code}).\n`);
+    }
+    const chain = extractChain(jsonl);
+    const shapeLine = chain.shape === 'subagent'
+        ? `Read a subagent transcript (agent ${chain.agentId ?? '?'}): ${chain.epochs.length} epoch(s).\n`
+        : `Read a main-session transcript: ${chain.epochs.length} epoch(s).\n`;
+    if (chain.shape === 'subagent' || io.stdout.isTTY)
+        io.stderr.write(shapeLine);
+    if (chain.epochs.length === 0) {
+        return refusal('No dialogue found on the active path — nothing to save.\n', EXIT.GENERIC);
+    }
+    const accessToken = await signedIn(io, cfg);
+    if (typeof accessToken !== 'string')
+        return accessToken;
+    const save = async (body) => {
+        const res = await io.api(accessToken, `${cfg.apiUrl}/memories/sessions`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(body)
+        });
+        const text = res.rawText;
+        let parsed;
+        try {
+            const b = JSON.parse(text);
+            parsed = b && typeof b === 'object' ? b : {};
+        }
+        catch {
+            parsed = { message: text.slice(0, 200) };
+        }
+        return { status: res.status, body: parsed };
+    };
+    const receipts = loadReceipts(io.store, chain.conversationId);
+    let results;
+    try {
+        results = await driveChain(chain, receipts, { title: flags.title, aiSummary: flags.aiSummary, contributor: flags.contributor }, save);
+    }
+    catch (e) {
+        if (e instanceof ChainSaveError) {
+            const { message, next, exit } = classifyApiError(e.status, e.body);
+            return {
+                message: '',
+                exit,
+                answer: { kind: 'door', message: `epoch ${e.epoch}: ${message}`, next }
+            };
+        }
+        throw e;
+    }
+    saveReceipts(io.store, chain.conversationId, receipts);
+    emit(io, results, JSON.stringify(results), (rs) => rs.map(formatChainEpoch).join('\n'));
+};
+//# sourceMappingURL=capture-session.js.map

package/dist/memory/delete.js

@@ -0,0 +1,88 @@
+import { parseArgs } from "../request/flags.js";
+import { confirmAction } from "../render/prompt.js";
+import { renderRunHint, sanitizeForTerminal } from "../render/text.js";
+import { EXIT, isRefusal, refusal } from "../store/exit.js";
+import { noteWriteHeaders, requireWriteIdentity } from "../store/write-identity.js";
+import { refusalOf } from "../request/api-fetch.js";
+import { signedIn } from "../request/access-token.js";
+import { ambiguousText } from "../render/rows.js";
+const deleteOne = async (cfg, io, idOrPrefix, yes) => {
+    const identity = requireWriteIdentity(io.store, io.stdin.isTTY);
+    if (isRefusal(identity))
+        return identity;
+    const accessToken = await signedIn(io, cfg);
+    if (typeof accessToken !== 'string')
+        return accessToken;
+    const fetched = await io.api(accessToken, `${cfg.apiUrl}/memories/${encodeURIComponent(idOrPrefix)}`);
+    if (!fetched.ok)
+        return refusalOf(fetched, ambiguousText(fetched.body));
+    const title = sanitizeForTerminal(fetched.data.title ?? '(untitled)');
+    const deleteId = fetched.data.id;
+    if (typeof fetched.data.fingerprint === 'string') {
+        io.stderr.write(`Moving "${title}" (${deleteId}) to deleted items. Its history stays; restore returns it private.\n`);
+        const result = await io.api(accessToken, `${cfg.apiUrl}/memories/${encodeURIComponent(deleteId)}`, {
+            method: 'DELETE',
+            headers: {
+                ...noteWriteHeaders(identity),
+                'X-Lattris-Base-Fingerprint': fetched.data.fingerprint
+            }
+        });
+        if (!result.ok)
+            return refusalOf(result);
+        io.stderr.write(`Moved memory ${deleteId} to deleted items. ${renderRunHint(['get', 'deleted'])} lists it; ` +
+            `${renderRunHint(['restore', 'memory', deleteId])} brings it back.\n`);
+        return;
+    }
+    if (!io.stdin.isTTY && !yes) {
+        return refusal('Refusing to permanently delete without confirmation on a non-interactive session. Pass --yes to skip the prompt.\n');
+    }
+    if (io.stdin.isTTY) {
+        const confirmed = await confirmAction(io, `Delete "${title}" (${deleteId}) permanently? [y/N] `);
+        if (confirmed === 'interrupted') {
+            return refusal('Cancelled.\n', EXIT.GENERIC);
+        }
+        if (confirmed === 'no') {
+            io.stderr.write('Cancelled.\n');
+            return;
+        }
+    }
+    const result = await io.api(accessToken, `${cfg.apiUrl}/memories/${encodeURIComponent(deleteId)}`, { method: 'DELETE' });
+    if (!result.ok)
+        return refusalOf(result, ambiguousText(result.body));
+    io.stderr.write(`Deleted memory ${deleteId}\n`);
+};
+export const DELETE_HELP = [
+    'delete — remove one memory.',
+    '',
+    'A NOTE moves to deleted items. Its history stays; restore returns it private.',
+    'The note is read first and its fingerprint sent with the removal, so a note',
+    'that changed since you read it is refused and nothing changes. No prompt:',
+    'nothing is lost. `lattris get deleted` lists what is there; `lattris restore`',
+    'brings one back; `lattris erase` is the separate, permanent second step.',
+    '',
+    'Every other type (a photo, a video, a session, a recording) is still',
+    'permanently deleted here, with the prompt a permanent act keeps.',
+    '',
+    'Usage:',
+    '  lattris delete memory <id-or-prefix> [--yes]',
+    '',
+    '  --yes   for a permanent delete only: required when not at a terminal (there',
+    '          is no prompt to answer there); at a terminal you are always asked.',
+    '          A note never asks and never needs it.',
+    '',
+    'Alias: remove → delete'
+].join('\n');
+export const deleteMemory = async (cfg, io, rest) => {
+    const yes = rest.includes('--yes');
+    const { positionals, unknown, notAnId } = parseArgs({}, rest.filter((a) => a !== '--yes'), [0]);
+    if (unknown) {
+        return refusal(`Unknown flag: ${unknown}\n`);
+    }
+    if (notAnId)
+        return refusal(notAnId);
+    if (positionals.length !== 1) {
+        return refusal(`Usage: lattris delete memory <id> [--yes]\n`);
+    }
+    return deleteOne(cfg, io, positionals[0], yes);
+};
+//# sourceMappingURL=delete.js.map

package/dist/memory/erase.js

@@ -0,0 +1,67 @@
+import { parseArgs } from "../request/flags.js";
+import { confirmAction } from "../render/prompt.js";
+import { FINGERPRINT_SHAPE } from "../memory/update-help.js";
+import { EXIT, isRefusal, refusal } from "../store/exit.js";
+import { noteWriteHeaders, requireWriteIdentity } from "../store/write-identity.js";
+import { refusalOf } from "../request/api-fetch.js";
+import { signedIn } from "../request/access-token.js";
+import { ambiguousText } from "../render/rows.js";
+export const ERASE_HELP = [
+    'erase — permanently erase a note that is already in deleted items. No undo.',
+    '',
+    'Usage:',
+    '  lattris erase memory <id-or-prefix> --base-fingerprint <head> [--yes]',
+    '',
+    '  --base-fingerprint  required; the fingerprint `lattris get deleted` shows for it.',
+    '  --yes               required when not at a terminal; at a terminal you are asked.',
+    '',
+    'Only a note in deleted items can be erased: delete it first. Erase purges its',
+    'words and every revision; the id and handle remain as a marker, and links that',
+    'pointed at it keep their reasons. There is no undo.'
+].join('\n');
+const ERASE_FLAG_NAMES = {
+    '--base-fingerprint': 'baseFingerprint'
+};
+export const eraseMemory = async (cfg, io, rest) => {
+    const yes = rest.includes('--yes');
+    const { flags, positionals, unknown, notAnId } = parseArgs(ERASE_FLAG_NAMES, rest.filter((a) => a !== '--yes'), [0]);
+    if (unknown) {
+        return refusal(`Unknown flag: ${unknown}\n`);
+    }
+    if (notAnId)
+        return refusal(notAnId);
+    if (positionals.length !== 1 || flags.baseFingerprint === undefined) {
+        return refusal(`Usage: lattris erase memory <id> --base-fingerprint <head> [--yes]\n`);
+    }
+    if (!FINGERPRINT_SHAPE.test(flags.baseFingerprint)) {
+        return refusal(`--base-fingerprint must be the 64 lowercase hex characters the deleted list printed: ${flags.baseFingerprint}\n`);
+    }
+    if (!io.stdin.isTTY && !yes) {
+        return refusal('Refusing to erase without confirmation on a non-interactive session. Pass --yes to skip the prompt. No undo.\n');
+    }
+    const identity = requireWriteIdentity(io.store, io.stdin.isTTY);
+    if (isRefusal(identity))
+        return identity;
+    if (io.stdin.isTTY) {
+        const confirmed = await confirmAction(io, `Erase ${positionals[0]} permanently? Its words and every revision go; the id stays as a marker. No undo. [y/N] `);
+        if (confirmed === 'interrupted') {
+            return refusal('Cancelled.\n', EXIT.GENERIC);
+        }
+        if (confirmed === 'no') {
+            io.stderr.write('Cancelled.\n');
+            return;
+        }
+    }
+    const accessToken = await signedIn(io, cfg);
+    if (typeof accessToken !== 'string')
+        return accessToken;
+    const result = await io.api(accessToken, `${cfg.apiUrl}/memories/${encodeURIComponent(positionals[0])}/erase`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', ...noteWriteHeaders(identity) },
+        body: JSON.stringify({ baseFingerprint: flags.baseFingerprint })
+    });
+    if (!result.ok)
+        return refusalOf(result, ambiguousText(result.body));
+    io.stderr.write(`Erased memory ${positionals[0]}. No undo.\n`);
+};
+//# sourceMappingURL=erase.js.map

package/dist/{extract-claude-jsonl.js → memory/extract-claude-jsonl.js}

@@ -1,47 +1,3 @@
-// Deterministic extractor: a Claude Code transcript
-// (~/.claude/projects/<project>/<session>.jsonl) in, ordered epoch turns out
-// (session-block spec §Skill — each rule verified against a real
-// transcript corpus, never inferred from vendor docs).
-// Extraction is MECHANICAL — one place for this vendor's shape, zero
-// judgment: the same file always yields the same epochs, byte for byte.
-// The AI-judgment touchpoints (when to save, title, ai_summary) live in the
-// skill, never here.
-//
-// An internal module behind `lattris capture session <transcript.jsonl>`
-// (main.ts) — not a command of its own.
-//
-// The settled extraction rules, in the spec's own words:
-// - The transcript is a TREE, not a list: every entry carries uuid/
-//   parentUuid; the conversation is the walk from the live leaf up, never
-//   file line order. Dead branches (rewinds) stay in the file and are simply
-//   not on the walked path.
-// - The chain break at compaction: the system/compact_boundary entry has
-//   parentUuid null; continuity is its logicalParentUuid — a naive
-//   parent-walk silently truncates at the last compaction, so the walk
-//   bridges it. Each boundary starts a NEW EPOCH; the summary rides the
-//   isCompactSummary user entry and becomes the next epoch's opening
-//   kind: 'compaction-summary' marker turn.
-// - Most "user" entries are not the person: promptSource 'typed' +
-//   origin.kind 'human' is the person; tool_result carriers, meta entries
-//   and task notifications are machinery; isSidechain entries are subagent
-//   noise — all stripped.
-// - Thinking blocks are OUT (private scratchpad, not dialogue); an
-//   assistant turn is its message's text blocks only, and one API message
-//   spans MULTIPLE jsonl entries (one content block each, same message.id)
-//   — concatenated in path order.
-// - Peer-session messages are stamped as their own speaker
-//   (peer:<origin.name>), never the owner; the body is origin.body (the
-//   raw message, without the harness's delivery wrapper).
-// - Two file shapes. A MAIN transcript is the person's session; sidechain
-//   entries inside it are a subagent's turns interleaved, and noise. A
-//   SUBAGENT transcript (…/<session>/subagents/agent-<id>.jsonl) is that
-//   subagent's own file: every path entry is isSidechain with an agentId,
-//   its first user entry is the parent's prompt (no promptSource, no
-//   origin), and its later user entries are tool_result carriers. The
-//   shape is read from the file and named on the result, and the same
-//   chain of epochs comes out of either.
-//
-// Zero imports beyond node built-ins, mirroring main.ts's own discipline.
 const parseLines = (jsonl) => {
     const entries = [];
     for (const line of jsonl.split('\n')) {
@@ -52,24 +8,13 @@ const parseLines = (jsonl) => {
             if (parsed && typeof parsed === 'object')
                 entries.push(parsed);
         }
-        catch {
-            // A torn tail line (the file is appended live) is not a conversation
-            // fact — skipped, deterministically.
-        }
+        catch { }
     }
     return entries;
 };
-// Path-bearing entries: the tree the walk runs over. Everything else
-// (attachments, file-history, queue bookkeeping…) never carries dialogue.
 const isPathEntry = (e) => typeof e.uuid === 'string' &&
     (e.type === 'user' || e.type === 'assistant' || e.type === 'system');
-// The ACTIVE path, live leaf up, oldest-first on return.
-// The live leaf is the LAST path-bearing entry in file order — the file is
-// an append log, so its tail is the current tip; every dead branch hangs off
-// an earlier fork and is unreachable walking UP from here. The compaction
-// bridge: parentUuid null + logicalParentUuid set continues the walk into
-// the previous epoch.
-export const walkActivePath = (entries) => {
+const walkActivePath = (entries) => {
     const byUuid = new Map();
     for (const e of entries) {
         if (typeof e.uuid === 'string')
@@ -80,7 +25,7 @@ export const walkActivePath = (entries) => {
     const seen = new Set();
     while (cursor) {
         if (typeof cursor.uuid !== 'string' || seen.has(cursor.uuid))
-            break; // cycle guard
+            break;
         seen.add(cursor.uuid);
         path.push(cursor);
         const parentId = cursor.parentUuid ?? cursor.logicalParentUuid;
@@ -98,14 +43,7 @@ const textOf = (content) => {
         .map((b) => b.text)
         .join('\n\n');
 };
-// The shape of a FILE, judged over every path-bearing entry before any
-// walk: a subagent's own file has all of them marked isSidechain with an
-// agentId; anything else is a main transcript, where a sidechain entry is
-// another agent's turn and noise, even at the file's tail. Judged before
-// the walk because the walk starts at the last path entry in file order,
-// and a main file whose tail is a subagent's appended turns would
-// otherwise be walked from the subagent's leaf.
-export const shapeOf = (entries) => {
+const shapeOf = (entries) => {
     const bearing = entries.filter(isPathEntry);
     return bearing.length > 0 &&
         bearing.every((e) => e.isSidechain === true && typeof e.agentId === 'string')
@@ -114,7 +52,7 @@ export const shapeOf = (entries) => {
 };
 const carriesToolResult = (content) => Array.isArray(content) &&
     content.some((b) => b && typeof b === 'object' && b.type === 'tool_result');
-export const classify = (e, shape = 'main') => {
+const classify = (e, shape = 'main') => {
     if (shape === 'main' && e.isSidechain === true)
         return { kind: 'noise' };
     if (e.type === 'system') {
@@ -123,16 +61,12 @@ export const classify = (e, shape = 'main') => {
             : { kind: 'noise' };
     }
     if (e.type === 'user') {
-        // The compaction summary — identified by its flag BEFORE any
-        // person/machinery classification (it is neither).
         if (e.isCompactSummary === true) {
             const text = textOf(e.message?.content);
             return text.trim().length > 0 ? { kind: 'marker', text, entry: e } : { kind: 'noise' };
         }
         if (e.origin?.kind === 'peer') {
             const name = typeof e.origin.name === 'string' && e.origin.name.length > 0 ? e.origin.name : 'unknown';
-            // origin.body is the raw peer message; the entry's own content wraps
-            // it in the harness's delivery boilerplate, which is machinery.
             const body = typeof e.origin.body === 'string' ? e.origin.body : textOf(e.message?.content);
             return body.trim().length > 0
                 ? { kind: 'peer', speaker: `peer:${name}`, text: body, entry: e }
@@ -142,22 +76,13 @@ export const classify = (e, shape = 'main') => {
             const text = textOf(e.message?.content);
             return text.trim().length > 0 ? { kind: 'person', text, entry: e } : { kind: 'noise' };
         }
-        // In a subagent's own file the parent's prompt carries no promptSource
-        // and no origin: it is the user entry that is words and not a
-        // tool_result carrier.
         if (shape === 'subagent' && e.isMeta !== true && !carriesToolResult(e.message?.content)) {
             const text = textOf(e.message?.content);
             return text.trim().length > 0 ? { kind: 'person', text, entry: e } : { kind: 'noise' };
         }
-        // tool_result carriers, meta entries, task notifications, queued
-        // machinery — not dialogue.
         return { kind: 'noise' };
     }
     if (e.type === 'assistant') {
-        // Text blocks only — thinking is OUT (deliberate: private scratchpad,
-        // never dialogue), tool_use is
-        // machinery. One entry carries one block; same-message entries merge in
-        // the caller.
         const text = textOf(e.message?.content);
         return text.trim().length > 0
             ? { kind: 'assistant-block', messageId: e.message?.id, text, entry: e }
@@ -178,31 +103,19 @@ const toTurn = (speaker, text, entry, kind) => {
         turn.externalParentMessageId = parent;
     return turn;
 };
-// The whole extraction: entries → active path → epochs of ordered turns.
 export const extractChain = (jsonl) => {
     const entries = parseLines(jsonl);
     const shape = shapeOf(entries);
-    // In a main file the sidechain entries are noise before the walk too, so
-    // the live leaf is the person's last word and never a subagent's.
     const path = walkActivePath(shape === 'main' ? entries.filter((e) => e.isSidechain !== true) : entries);
     const agentId = shape === 'subagent'
         ? (path.map((e) => e.agentId).find((a) => typeof a === 'string') ?? null)
         : null;
     const sessionId = path.map((e) => e.sessionId).find((s) => typeof s === 'string') ?? null;
-    // A subagent's conversation identity is its own: the parent's session id
-    // and its agent id together, distinct from the parent's and from every
-    // sibling's, the same on every capture of the same file. The receipts and
-    // the conversation nomination key on it, so two siblings captured under
-    // one session never extend or fork each other. Joined with a separator a
-    // file name can carry, since the receipts file is named by it.
     const conversationId = shape === 'subagent' && sessionId !== null && agentId !== null
         ? `${sessionId}--agent-${agentId}`
         : sessionId;
     const epochs = [];
     let current = [];
-    // The assistant merge: consecutive path entries sharing message.id are
-    // one API message — their text blocks concatenate into ONE turn (path
-    // order), stamped with the FIRST entry's ids/time.
     let pendingAssistant = null;
     const flushAssistant = () => {
         if (!pendingAssistant)
@@ -228,8 +141,6 @@ export const extractChain = (jsonl) => {
             continue;
         flushAssistant();
         if (c.kind === 'epoch-boundary') {
-            // A new epoch begins. The boundary itself carries no words — the
-            // summary marker (the next epoch's first classified entry) does.
             if (current.length > 0)
                 epochs.push(current);
             current = [];

package/dist/memory/get-help.js

@@ -0,0 +1,72 @@
+export const GET_HELP = [
+    'get — read your memories or a public wall.',
+    '',
+    'Nouns:',
+    '  memories   your list, or one wall with --by <owner-handle>',
+    '  memory     one, by website address or id with --by <owner-handle> \u2014 its edges ride along',
+    '  history    one note\u2019s history: every change, newest first, and the head fingerprint',
+    '  deleted    your deleted items, with the fingerprint restore and erase need',
+    '  questions  the questions left on your tree, open first',
+    '  access     may one contact, or one number, see a memory, and because of what',
+    '',
+    'Usage:',
+    '  lattris get memories [--shared-with-me] [--q <words>] [--type <name>] [--intent <name>] [--with <audience>] [--for <contact> | --for-phone <number>] [--limit <n>] [--cursor <token>] [--content 0|1]',
+    '  lattris get memories --by <owner-handle> [--limit <n>] [--cursor <token>] [--content 0|1]',
+    '  lattris get memory <website-address|id> [--by <owner-handle>] [--links 0|1] [--depth <n>] [--content 0|1]',
+    '  lattris get memory <id-or-prefix> --revision <n>      one revision, as history kept it',
+    '  lattris get history <id-or-prefix> [--limit <n>] [--before <operation-id>]',
+    '  lattris get deleted [--limit <n>] [--cursor <token>]',
+    '  lattris get questions [--mine]',
+    '  lattris get access <memory-id-or-prefix> --for <contact | number>',
+    '',
+    '  --q        <words>   only memories whose title or content contains these words,',
+    '                       matched as one literal phrase, case-insensitive. Needs 3+',
+    '                       characters and at least one distinctive word — a query of',
+    '                       only common words ("the", "and", ...) is refused; pick a',
+    '                       name or a particular noun instead.',
+    '  --type     <name>    filter to one type',
+    '  --intent   <name>    filter to one intent',
+    '  --with     <audience>  your own footprint: public (has that grant) or nobody',
+    '                       (private — no grant at all)',
+    '  --limit    <n>       page size, 1-100 (default 50)',
+    '  --cursor   <token>   the nextCursor from a previous page',
+    '  --by      <handle>  one wall on the website address; an id without a',
+    '                       session needs it, while a full address carries it',
+    '  --shared-with-me     list memories other people granted to you; each row',
+    '                       names its owner and whether it is on your graph',
+    '  --for      <contact> what one of your contacts may see of your memories: an',
+    '                       exact name or id from `lattris contact list`. The rows',
+    '                       carry what they would see; the first line names them',
+    '  --for-phone <number> the same for a phone number in full international',
+    '                       form; a number no contact holds is a stranger, who',
+    '                       sees public memories only',
+    '',
+    '  --links    0|1       edges on the one memory (default 1): direction, verb,',
+    '                       reason, and each neighbour\u2019s finding aid. --links 0',
+    '                       restores the bare read, byte-identical on the wire.',
+    '  --depth    <n>       expand neighbours recursively (finding aid + links',
+    '                       past the anchor; the API owns the range) \u2014 needs links',
+    '  --content  0|1       0 answers the finding aid only (id, handle, type,',
+    '                       title, aiSummary) \u2014 the cheap look before a full read;',
+    '                       on the list, 0 drops the excerpts and keeps every other',
+    '                       field a writer needs (fingerprint, revisionNo, structureHash)',
+    '  --mine     (questions) the ones YOU asked, with how each closed',
+    '',
+    '  --revision <n>       the snapshot numbered n: title, words, metadata, its',
+    '                       fingerprint and who recorded it. Restore it with',
+    '                       `lattris restore memory <id> --revision <n> --base-fingerprint <head>`.',
+    '  --before   <op-id>   (history) the page before that operation \u2014 the',
+    '                       nextBeforeOperation a previous page printed',
+    '',
+    'Every read of a note prints its fingerprint (the head of its history) and',
+    'revisionNo; every read prints structureHash, a hash of the block\u2019s links and',
+    'grants as this reader sees them. An edit sends the fingerprint back as --base-fingerprint.',
+    'Your own read of a memory also prints `access`: every allow and deny on it.',
+    '',
+    "A memory's web address is <site>/by/<owner-handle>/memories/<slug>-<memory-handle>.",
+    'A /by read asks for JSON with Accept: application/json; it sends a bearer',
+    'only when the session has a live one. `get memory` prints the address at a TTY.',
+    '',
+    'Aliases: read, show, view, fetch → get'
+].join('\n');
+//# sourceMappingURL=get-help.js.map