lattris 0.1.4 → 0.2.0

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,63 @@
+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',
+    '',
+    'Usage:',
+    '  lattris get memories [--shared-with-me] [--q <words>] [--type <name>] [--intent <name>] [--with <audience>] [--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]',
+    '',
+    '  --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',
+    '',
+    '  --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.',
+    '',
+    "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

package/dist/memory/get.js

@@ -0,0 +1,213 @@
+import { parseArgs } from "../request/flags.js";
+import { getRevision } from "../memory/history.js";
+import { composeAddress, formatMemoryDetail, formatMemoryPage, formatNodeWalk, ownHandleFor, parseWebsiteMemoryAddress } from "../memory/views.js";
+import { emit } from "../render/output.js";
+import { ambiguousText } from "../render/rows.js";
+import { renderRunHint } from "../render/text.js";
+import { optionalAccessToken, signedIn } from "../request/access-token.js";
+import { refusalOf } from "../request/api-fetch.js";
+import { refusal } from "../store/exit.js";
+import { loadSession, saveSession } from "../store/session.js";
+export const buildGetMemoryUrl = (webUrl, ownerHandle, ref, flags) => {
+    const url = new URL(`${webUrl}/by/${encodeURIComponent(ownerHandle)}/memories/${encodeURIComponent(ref)}`);
+    const links = flags.links ?? '1';
+    const bare = links === '0' && flags.depth === undefined && flags.content === undefined;
+    if (!bare) {
+        url.searchParams.set('links', links);
+        if (flags.depth !== undefined)
+            url.searchParams.set('depth', flags.depth);
+        if (flags.content !== undefined)
+            url.searchParams.set('content', flags.content);
+    }
+    return url;
+};
+const getMemory = async (cfg, io, idOrAddress, flags, by) => {
+    const isAddress = /^https?:\/\//i.test(idOrAddress);
+    const address = isAddress ? parseWebsiteMemoryAddress(cfg.webUrl, idOrAddress) : undefined;
+    if (isAddress && !address) {
+        return refusal(`The memory address must be on ${cfg.webUrl}/by/<owner>/memories/<ref>.\n`);
+    }
+    if (address && by && address.ownerHandle !== by) {
+        return refusal('--by must name the same owner as the memory address.\n');
+    }
+    const storedSession = loadSession(io.store);
+    let ownerHandle = address?.ownerHandle ?? by ?? storedSession?.handle;
+    let accessToken;
+    if (!ownerHandle && storedSession) {
+        accessToken = await optionalAccessToken(io, cfg);
+        if (accessToken) {
+            ownerHandle = await ownHandleFor(cfg, io, accessToken);
+            if (ownerHandle) {
+                const currentSession = loadSession(io.store);
+                if (currentSession && currentSession.handle !== ownerHandle) {
+                    saveSession(io.store, { ...currentSession, handle: ownerHandle });
+                }
+            }
+        }
+    }
+    if (!ownerHandle) {
+        return refusal('A memory id needs its wall: use get memory <website-address> or get memory <id> --by <owner-handle>.\n');
+    }
+    accessToken ??= await optionalAccessToken(io, cfg);
+    const url = buildGetMemoryUrl(cfg.webUrl, ownerHandle, address?.ref ?? idOrAddress, flags);
+    const enveloped = url.search !== '';
+    const result = await io.api(accessToken, url, {
+        headers: { Accept: 'application/json' },
+        retryAnonymousOn401: true
+    }, 'web');
+    if (!result.ok) {
+        return refusalOf(result, ambiguousText(result.body) +
+            (result.body.code === 'memory:not-found' && !address && !by
+                ? 'For another wall, use get memory <website-address> or get memory <id> --by <owner-handle>.\n'
+                : ''));
+    }
+    const record = enveloped ? result.data.node : result.data;
+    const displayAddress = io.stdout.isTTY
+        ? composeAddress(cfg.webUrl, ownerHandle, record)
+        : undefined;
+    emit(io, result.data, result.rawText, () => enveloped
+        ? formatNodeWalk(result.data, displayAddress)
+        : formatMemoryDetail(result.data, displayAddress));
+};
+const GET_FLAG_NAMES = {
+    '--by': 'by',
+    '--revision': 'revision',
+    '--type': 'type',
+    '--intent': 'intent',
+    '--limit': 'limit',
+    '--cursor': 'cursor',
+    '--q': 'q',
+    '--with': 'with',
+    '--links': 'links',
+    '--depth': 'depth',
+    '--content': 'content'
+};
+const LIST_ONLY_FLAGS = ['type', 'intent', 'limit', 'cursor', 'q', 'with', 'sharedWithMe'];
+const WALK_ONLY_FLAGS = ['links', 'depth', 'revision'];
+const listMemories = async (cfg, io, flags) => {
+    const accessToken = await signedIn(io, cfg);
+    if (typeof accessToken !== 'string')
+        return accessToken;
+    const url = new URL(`${cfg.apiUrl}/memories`);
+    if (flags.type !== undefined)
+        url.searchParams.set('type', flags.type);
+    if (flags.intent !== undefined)
+        url.searchParams.set('intent', flags.intent);
+    if (flags.limit !== undefined)
+        url.searchParams.set('limit', flags.limit);
+    if (flags.cursor !== undefined)
+        url.searchParams.set('cursor', flags.cursor);
+    if (flags.q !== undefined)
+        url.searchParams.set('q', flags.q);
+    if (flags.with !== undefined)
+        url.searchParams.set('audience', flags.with);
+    if (flags.content !== undefined)
+        url.searchParams.set('content', flags.content);
+    if (flags.sharedWithMe)
+        url.searchParams.set('sharedWithMe', '1');
+    const result = await io.api(accessToken, url);
+    if (!result.ok)
+        return refusalOf(result);
+    emit(io, result.data, result.rawText, formatMemoryPage);
+    if (result.data.nextCursor) {
+        const argv = ['get', 'memories'];
+        if (flags.type !== undefined)
+            argv.push('--type', flags.type);
+        if (flags.intent !== undefined)
+            argv.push('--intent', flags.intent);
+        if (flags.q !== undefined)
+            argv.push('--q', flags.q);
+        if (flags.with !== undefined)
+            argv.push('--with', flags.with);
+        if (flags.limit !== undefined)
+            argv.push('--limit', flags.limit);
+        if (flags.content !== undefined)
+            argv.push('--content', flags.content);
+        if (flags.sharedWithMe)
+            argv.push('--shared-with-me');
+        argv.push('--cursor', result.data.nextCursor);
+        io.stderr.write(`More: ${renderRunHint(argv)}\n`);
+    }
+};
+const getWallMemories = async (cfg, io, ownerHandle, flags) => {
+    const accessToken = await optionalAccessToken(io, cfg);
+    const url = new URL(`${cfg.webUrl}/by/${encodeURIComponent(ownerHandle)}/memories`);
+    if (flags.limit !== undefined)
+        url.searchParams.set('limit', flags.limit);
+    if (flags.cursor !== undefined)
+        url.searchParams.set('cursor', flags.cursor);
+    if (flags.content !== undefined)
+        url.searchParams.set('content', flags.content);
+    const result = await io.api(accessToken, url, {
+        headers: { Accept: 'application/json' },
+        retryAnonymousOn401: true
+    }, 'web');
+    if (!result.ok)
+        return refusalOf(result);
+    emit(io, result.data, result.rawText, formatMemoryPage);
+    if (result.data.nextCursor) {
+        const argv = ['get', 'memories', '--by', ownerHandle];
+        if (flags.limit !== undefined)
+            argv.push('--limit', flags.limit);
+        if (flags.content !== undefined)
+            argv.push('--content', flags.content);
+        argv.push('--cursor', result.data.nextCursor);
+        io.stderr.write(`More: ${renderRunHint(argv)}\n`);
+    }
+};
+export const getMemories = async (cfg, io, rest, noun) => {
+    const sharedWithMeCount = rest.filter((arg) => arg === '--shared-with-me').length;
+    if (sharedWithMeCount > 1) {
+        return refusal('--shared-with-me was given more than once. Send it once.\n');
+    }
+    const { flags, positionals, unknown, notAnId } = parseArgs(GET_FLAG_NAMES, rest.filter((arg) => arg !== '--shared-with-me'), [0]);
+    if (sharedWithMeCount === 1)
+        flags.sharedWithMe = '1';
+    if (unknown) {
+        return refusal(`Unknown flag: ${unknown}\n`);
+    }
+    if (notAnId && !/^https?:\/\//i.test(positionals[0]))
+        return refusal(notAnId);
+    if (positionals.length > 1) {
+        return refusal(`Unexpected argument: ${positionals[1]}\n`);
+    }
+    const id = positionals[0];
+    if (id !== undefined) {
+        const inapplicable = LIST_ONLY_FLAGS.find((k) => flags[k] !== undefined);
+        if (inapplicable !== undefined) {
+            return refusal(`--${inapplicable} does not apply to a single memory.\n`);
+        }
+        if (flags.revision !== undefined) {
+            if (flags.by !== undefined || /^https?:\/\//i.test(id)) {
+                return refusal('A revision read uses your own id or prefix; --by and website addresses do not apply.\n');
+            }
+            const walkFlag = ['links', 'depth', 'content'].find((k) => flags[k] !== undefined);
+            if (walkFlag !== undefined) {
+                return refusal(`--${walkFlag} does not apply to a revision read.\n`);
+            }
+            return getRevision(cfg, io, id, flags.revision);
+        }
+        return getMemory(cfg, io, id, { links: flags.links, depth: flags.depth, content: flags.content }, flags.by);
+    }
+    else if (noun === 'memories') {
+        const walkFlag = WALK_ONLY_FLAGS.find((k) => flags[k] !== undefined);
+        if (walkFlag !== undefined) {
+            return refusal(`--${walkFlag} applies to a single memory, not the list.\n`);
+        }
+        if (flags.by !== undefined) {
+            const ownerOnly = ['type', 'intent', 'q', 'with', 'sharedWithMe'].find((key) => flags[key] !== undefined);
+            if (ownerOnly !== undefined) {
+                const flagName = ownerOnly === 'sharedWithMe' ? 'shared-with-me' : ownerOnly;
+                return refusal(`--${flagName} does not apply to a wall listing.\n`);
+            }
+            return getWallMemories(cfg, io, flags.by, flags);
+        }
+        else {
+            return listMemories(cfg, io, flags);
+        }
+    }
+    else {
+        return refusal('A website address or id is required for a single memory. To list your own: lattris get memories\n');
+    }
+};
+//# sourceMappingURL=get.js.map