lattris 0.1.4 → 0.2.1

package/dist/nouns/questions.js

@@ -0,0 +1,116 @@
+import { formatAsked, formatClosed, formatQuestionList } from "../render/rows.js";
+export const ASK_HELP = [
+    'ask — leave a question on someone’s tree.',
+    '',
+    'Usage:',
+    '  echo "Where did the export land?" | lattris ask <handle> [--about <block-id>]',
+    '',
+    'The question comes from stdin — one per ask, prose only: that text is the',
+    'whole of what crosses to the tree’s owner. --about anchors it to the node',
+    'you stood on when the tree ran out (a block id readable on that owner’s wall).',
+    '',
+    'The owner closes it with a close pointing at the node that answers.',
+    'Watch yours: lattris get questions --mine'
+].join('\n');
+const askVerb = {
+    verb: 'ask',
+    form: {
+        usage: 'Usage: echo "…" | lattris ask <handle> [--about <block-id>]',
+        flags: { '--about': 'about' },
+        positionals: 1,
+        stdinBody: {
+            atTty: 'The question comes from stdin: echo "…" | lattris ask <handle>\n',
+            empty: 'Nothing to ask — the question comes from stdin.\n'
+        },
+        request: {
+            method: 'POST',
+            path: '/by/{p0}/questions',
+            body: { body: { stdin: true }, aboutBlockId: { flag: 'about' } }
+        },
+        render: (q) => formatAsked(q)
+    }
+};
+const CLOSE_USAGE = [
+    'Usage: lattris close question <id-or-prefix> --close-as updated|already-answered --block <ref> [--note "…"]',
+    '       lattris close question <id-or-prefix> --close-as declined --note "…"'
+].join('\n');
+export const CLOSE_HELP = [
+    'close — close a question in your inbox.',
+    '',
+    CLOSE_USAGE,
+    '',
+    '  <id-or-prefix>     the question’s full UUID, or a >=4-char hex prefix over',
+    '                     YOUR OWN questions — an ambiguous prefix refuses and',
+    '                     lists the candidates, like `get memory`',
+    '',
+    '  updated            the question changed the tree — --block points at the',
+    '                     node that now answers it (required)',
+    '  already-answered   the tree already held the answer — --block points at',
+    '                     it (required)',
+    '  declined           you won’t act on it — no --block, and --note is required:',
+    '                     there is no answering node, so the words ARE the closure',
+    '',
+    '  --block <ref>      the memory’s full UUID, or an address ending in its',
+    '                     handle (slug-blind: price-list-abcd and bare abcd both',
+    '                     land) — NEVER a prefix, deliberately: the asker reads',
+    '                     this pointer back, so it must name one block exactly',
+    '  --note "…"         the closure in plain words (what the asker reads back);',
+    '                     optional beside a --block, required for declined — the',
+    '                     server refuses without it and says so',
+    '',
+    'The API is authoritative on the vocabulary — an unknown close value refuses',
+    'with the accepted set. Your inbox: lattris get questions'
+].join('\n');
+const closeVerb = {
+    verb: 'close',
+    nouns: ['question', 'questions'],
+    form: {
+        usage: CLOSE_USAGE,
+        idPositionals: [0],
+        flags: { '--close-as': 'closedAs', '--block': 'block', '--note': 'note' },
+        positionals: 1,
+        requiredFlags: ['closedAs'],
+        requireWhen: [
+            {
+                key: 'closedAs',
+                values: ['updated', 'already-answered'],
+                needs: 'block',
+                message: `--close-as {value} needs --block <ref>: the block that now answers the question.\n${CLOSE_USAGE}\n`
+            }
+        ],
+        request: {
+            method: 'PATCH',
+            path: '/questions/{p0}',
+            body: {
+                closedAs: { flag: 'closedAs' },
+                closeBlockId: { flag: 'block' },
+                closeNote: { flag: 'note' }
+            }
+        },
+        render: (q) => formatClosed(q)
+    }
+};
+const getQuestions = {
+    verb: 'get',
+    nouns: ['question', 'questions'],
+    form: {
+        usage: 'Usage: lattris get questions [--mine]',
+        switches: ['--mine'],
+        positionals: 0,
+        unknownFlagIsUsage: true,
+        request: { method: 'GET', path: '/questions{--mine:/mine}' },
+        render: (qs, context) => qs.length > 0
+            ? formatQuestionList(qs)
+            : context.on.has('--mine')
+                ? "You have asked no questions on other people's trees."
+                : 'No questions on your tree.'
+    }
+};
+export const questions = {
+    name: 'questions',
+    words: { singular: 'question', plural: 'questions' },
+    help: CLOSE_HELP,
+    verbs: [askVerb, closeVerb, getQuestions]
+};
+export { CLOSE_USAGE };
+//# sourceMappingURL=questions.js.map

package/dist/nouns/share.js

@@ -0,0 +1,266 @@
+import { audienceOf, formatAccessRow, formatAudiences, waitsForNameSentence } from "../render/rows.js";
+import { renderRunHint, sanitizeForTerminal } from "../render/text.js";
+import { consent } from "./consent.js";
+const ALL_CONTACTS = 'all-contacts';
+const AUDIENCE_WORDS = '--with is required. Use public, all-contacts, or one of your contact names or ids.\n';
+const DENY_WORDS = '--to is required. Use all-contacts or one of your contact names or ids.\n';
+const PUBLIC_CANNOT_BE_DENIED = 'public cannot be denied: a deny names a contact or all-contacts. To stop sharing with everyone, unshare --with public.\n';
+export const SHARE_HELP = [
+    'share — allow an audience to see a memory: public, all your contacts,',
+    'or one contact. A contact needs no Lattris account; a linked contact also',
+    'sees it on the website.',
+    '',
+    'Usage:',
+    '  lattris share memory <id-or-prefix> --with <public | all-contacts | contact> [--yes]',
+    '',
+    '  --with   public, all-contacts, or an exact contact name or id from',
+    '           `lattris contact list`. The words public and all-contacts win',
+    '           over a contact of that name; reach such a contact by its id.',
+    '           group:<name> is reserved for groups, which are not built yet.',
+    '  --yes    required when not at a terminal; at a terminal you are always',
+    '           asked, --yes or not.',
+    '',
+    'A deny on the memory beats any allow: the answer names who is still shut',
+    'out, and `lattris undeny` lifts it. Sharing with an audience that already',
+    'has access succeeds and changes nothing.',
+    '',
+    'Alias: publish → share'
+].join('\n');
+export const DENY_HELP = [
+    'deny — shut a memory to one contact or to all your contacts, whatever',
+    'else allows it. Nothing is asked: a deny is the safe direction.',
+    '',
+    'Usage:',
+    '  lattris deny memory <id-or-prefix> --to <all-contacts | contact>',
+    '',
+    '  --to     all-contacts, or an exact contact name or id from',
+    '           `lattris contact list`. public cannot be denied. group:<name>',
+    '           is reserved for groups, which are not built yet.',
+    '',
+    'A deny cannot hold while the memory is public or shared on the website',
+    'with the person it would shut out; the refusal names the share in the',
+    'way. `lattris undeny` lifts a deny.'
+].join('\n');
+export const UNDENY_HELP = [
+    'undeny — lift a deny from a memory, for one contact or for all your',
+    'contacts. It opens the memory to whatever allows it, so it asks at a',
+    'terminal and needs --yes on a pipe.',
+    '',
+    'Usage:',
+    '  lattris undeny memory <id-or-prefix> --to <all-contacts | contact> [--yes]'
+].join('\n');
+const isAccessGrant = (grant) => typeof grant === 'object' &&
+    grant !== null &&
+    'shutBy' in grant &&
+    Array.isArray(grant.shutBy);
+const whoWasShared = (grant, context) => context.contact?.displayName !== undefined
+    ? sanitizeForTerminal(context.contact.displayName)
+    : context.reserved === ALL_CONTACTS
+        ? 'all contacts'
+        : String(grant.kind ?? '');
+const shareSentences = (grant, context) => {
+    const lines = [
+        `Shared memory ${context.memory?.id ?? context.positionals[0]} with ${whoWasShared(grant, context)}`
+    ];
+    if (!isAccessGrant(grant))
+        return lines;
+    if (grant.paired) {
+        lines.push(`${sanitizeForTerminal(grant.contactName ?? '')} is linked to an account, so the website shows it too.`);
+    }
+    else if (grant.unpairedBecause === 'owner-has-no-name') {
+        lines.push(waitsForNameSentence(grant.contactName ?? ''));
+    }
+    if (grant.shutBy.length > 0) {
+        const denies = grant.shutBy.map(formatAccessRow).join(', ');
+        lines.push(grant.kind === 'contact'
+            ? `${sanitizeForTerminal(grant.contactName ?? '')} is still shut out by: ${denies}`
+            : `Still shut out by a deny of their own: ${grant.shutBy.map(audienceOf).join(', ')}`);
+    }
+    return lines;
+};
+const otherEffectWords = (asked) => (body, context) => {
+    if (body.code !== 'memory:withdraw-effect-mismatch')
+        return '';
+    const found = body.detail?.effect === 'deny' ? 'deny' : 'allow';
+    if (found === asked)
+        return '';
+    const id = context.memory?.id ?? context.positionals[0];
+    const who = context.contact?.id ?? ALL_CONTACTS;
+    return found === 'deny'
+        ? `This is a deny, not a share. Lift it with: ${renderRunHint(['undeny', 'memory', id, '--to', who])}\n`
+        : `This is a share, not a deny. Withdraw it with: ${renderRunHint(['unshare', 'memory', id, '--with', who])}\n`;
+};
+const inTheWay = (body) => {
+    const rows = body.detail?.blockedBy;
+    if (!Array.isArray(rows) || rows.length === 0)
+        return '';
+    return `In the way: ${rows.map(formatAccessRow).join(', ')}\n`;
+};
+const contactBody = (effect) => ({
+    kind: { value: 'contact' },
+    contactId: { context: 'contact.id' },
+    effect: { value: effect }
+});
+const shareVerb = {
+    verb: 'share',
+    nouns: ['memory', 'memories'],
+    form: {
+        usage: 'Usage: lattris share memory <id> --with <audience> [--yes]',
+        flags: { '--with': 'with' },
+        switches: ['--yes'],
+        positionals: 1,
+        idPositionals: [0],
+        steps: {
+            requireFlag: { key: 'with', message: AUDIENCE_WORDS },
+            pipedNeedsYes: {
+                message: 'Refusing to share without confirmation on a non-interactive session. Pass --yes to skip the prompt.\n'
+            },
+            contact: { from: ['flag:with'], publicWord: 'public', reserved: [ALL_CONTACTS] },
+            memory: 'at-tty',
+            confirm: {
+                question: 'Share "{title}" ({memory.id}) with {audience}? [y/N] ',
+                onNo: { text: 'Cancelled.\n', to: 'stderr' },
+                onInterrupted: { text: 'Cancelled.\n', exit: 1 }
+            }
+        },
+        request: {
+            method: 'POST',
+            path: '/memories/{memory.id}/grants',
+            body: contactBody('allow'),
+            bodyWithPublic: { audience: 'public' },
+            bodyFor: { [ALL_CONTACTS]: { kind: 'all_contacts' } }
+        },
+        ambiguousRefusal: true,
+        refusalWords: inTheWay,
+        render: (grant, context) => shareSentences(grant, context).join('\n')
+    }
+};
+const denyVerb = {
+    verb: 'deny',
+    nouns: ['memory', 'memories'],
+    form: {
+        usage: 'Usage: lattris deny memory <id> --to <all-contacts | contact>',
+        flags: { '--to': 'to' },
+        positionals: 1,
+        idPositionals: [0],
+        steps: {
+            requireFlag: { key: 'to', message: DENY_WORDS },
+            contact: {
+                from: ['flag:to'],
+                reserved: [ALL_CONTACTS],
+                refusedWords: { public: PUBLIC_CANNOT_BE_DENIED }
+            }
+        },
+        request: {
+            method: 'POST',
+            path: '/memories/{memory.id}/grants',
+            body: contactBody('deny'),
+            bodyFor: { [ALL_CONTACTS]: { kind: 'all_contacts', effect: 'deny' } }
+        },
+        ambiguousRefusal: true,
+        refusalWords: inTheWay,
+        render: (_grant, context) => `Denied memory ${context.positionals[0]} to ${context.contact ? sanitizeForTerminal(context.contact.displayName) : 'all contacts'}`
+    }
+};
+const undenyVerb = {
+    verb: 'undeny',
+    nouns: ['memory', 'memories'],
+    form: {
+        usage: 'Usage: lattris undeny memory <id> --to <all-contacts | contact> [--yes]',
+        flags: { '--to': 'to' },
+        switches: ['--yes'],
+        positionals: 1,
+        idPositionals: [0],
+        steps: {
+            requireFlag: { key: 'to', message: DENY_WORDS },
+            pipedNeedsYes: {
+                message: 'Refusing to lift a deny without confirmation on a non-interactive session. Pass --yes to skip the prompt.\n'
+            },
+            contact: {
+                from: ['flag:to'],
+                reserved: [ALL_CONTACTS],
+                refusedWords: { public: PUBLIC_CANNOT_BE_DENIED }
+            },
+            memory: 'at-tty',
+            confirm: {
+                question: 'Lift the deny on "{title}" ({memory.id}) for {audience}? [y/N] ',
+                onNo: { text: 'Cancelled.\n', to: 'stderr' },
+                onInterrupted: { text: 'Cancelled.\n', exit: 1 }
+            }
+        },
+        request: {
+            method: 'DELETE',
+            path: '/memories/{memory.id}/grants/contact/{contact.id}?effect=deny',
+            pathFor: { [ALL_CONTACTS]: '/memories/{memory.id}/grants/all-contacts?effect=deny' }
+        },
+        ambiguousRefusal: true,
+        refusalWords: otherEffectWords('deny'),
+        renderTo: 'stderr',
+        render: (_data, context) => `Lifted the deny on memory ${context.memory?.id ?? context.positionals[0]} for ${context.contact ? sanitizeForTerminal(context.contact.displayName) : 'all contacts'}`
+    }
+};
+export const UNSHARE_HELP = [
+    'unshare — withdraw an audience from a memory. No confirmation — withdrawal',
+    'is the safe direction.',
+    '',
+    'Usage:',
+    '  lattris unshare memory <id-or-prefix> --with <public | all-contacts | contact>',
+    '',
+    '  --with   public, all-contacts, or an exact contact name or id from',
+    '           `lattris contact list`. For a contact, the website row paired',
+    '           with its allow goes too, and so does a website share written',
+    '           before contact shares existed. group:<name> is reserved for',
+    '           groups, which are not built yet.',
+    '',
+    'Bare (no --with): refuses and shows what the memory is currently shared',
+    'with, so you can see the state and the fix in one line. A deny is lifted',
+    'with `lattris undeny`, not here.',
+    '',
+    'Alias: unpublish → unshare'
+].join('\n');
+const unshareVerb = {
+    verb: 'unshare',
+    nouns: ['memory', 'memories'],
+    form: {
+        usage: 'Usage: lattris unshare memory <id> [--with <audience>]',
+        flags: { '--with': 'with' },
+        positionals: 1,
+        idPositionals: [0],
+        steps: {
+            contact: { from: ['flag:with'], publicWord: 'public', reserved: [ALL_CONTACTS] },
+            memory: 'always',
+            noAudienceReport: {
+                key: 'with',
+                first: AUDIENCE_WORDS,
+                second: '"{title}" ({memory.id}) is currently shared with: {audiences}\n'
+            }
+        },
+        request: {
+            method: 'DELETE',
+            path: '/memories/{memory.id}/grants/contact/{contact.id}?effect=allow',
+            pathWithPublic: '/memories/{memory.id}/grants/public',
+            pathFor: { [ALL_CONTACTS]: '/memories/{memory.id}/grants/all-contacts?effect=allow' },
+            fallback: {
+                status: 404,
+                path: '/memories/{memory.id}/grants/person/{contact.claimedPersonId}',
+                when: 'contact.linked'
+            }
+        },
+        ambiguousRefusal: true,
+        refusalWords: otherEffectWords('allow'),
+        renderTo: 'stderr',
+        render: (_data, context) => `Unshared memory ${context.memory?.id ?? ''} from ${context.contact
+            ? sanitizeForTerminal(context.contact.displayName)
+            : context.reserved === ALL_CONTACTS
+                ? 'all contacts'
+                : 'public'}`
+    }
+};
+export const audiencesOf = (memory) => formatAudiences(memory.audiences);
+export const grants = {
+    name: 'grants',
+    words: { singular: 'grant', plural: 'grants' },
+    help: SHARE_HELP,
+    verbs: [shareVerb, unshareVerb, denyVerb, undenyVerb, consent]
+};
+//# sourceMappingURL=share.js.map

package/dist/nouns/words.js

@@ -0,0 +1,81 @@
+export const VERB_ALIASES = {
+    read: 'get',
+    show: 'get',
+    view: 'get',
+    fetch: 'get',
+    remove: 'delete',
+    publish: 'share',
+    unpublish: 'unshare'
+};
+export const USAGE_LINES = [
+    '  lattris login                Sign in via the browser (PKCE) and store the session',
+    '  lattris setup                Transition this repo’s Claude to Lattris as its memory system',
+    '  lattris use <name|path>      Bind this directory to an actor (.lattris; bare `use` shows, --clear removes)',
+    '  lattris whoami               Print "<name> · #<lattris_no>" for the signed-in person',
+    '  lattris set name "<value>"   Set the name shown on your public page',
+    '  lattris set root <id>        Set the block a walker starts from on your tree (whoami shows it)',
+    '  lattris set banned-words     The words your own notes refuse (bare shows; words given replace; --clear)',
+    '  lattris capture memory       Capture a memory — `echo "…" | lattris capture memory`',
+    '  lattris capture session <transcript>  Save an AI conversation — the whole chain from its file',
+    '  lattris capture recording    Keep a recording \u2014 held audio, a source, or a transcript file',
+    '  lattris get memories         List your memories, newest first, with filters (--for <contact> for what they may see)',
+    '  lattris contact create "<name>"  Record a person or an AI you work with (--ai, --phone); add, list, get, update, delete',
+    '  lattris invite <contact>     Mint an invitation for one of your person contacts',
+    '  lattris get invites          List the invitations you have minted',
+    '  lattris get memory <id>      Read one memory back \u2014 words and edges (--links/--depth/--content)',
+    '  lattris ask <handle>         Leave a question on someone\u2019s tree \u2014 `echo "\u2026" | lattris ask <handle>`',
+    '  lattris get questions        The questions on your tree, open first (--mine: ones you asked)',
+    '  lattris close question <id>  Close a question (--close-as updated|declined|already-answered)',
+    '  lattris share memory <id>    Allow an audience to see it (--with public | all-contacts | <contact>)',
+    '  lattris unshare memory <id>  Withdraw an audience (--with public | all-contacts | <contact>)',
+    '  lattris deny memory <id>     Shut it to a contact or all contacts, whatever allows it (--to)',
+    '  lattris undeny memory <id>   Lift a deny (--to all-contacts | <contact>)',
+    '  lattris get access <id>      May a contact or a number see it, and because of what (--for)',
+    '  lattris consent <id>         Put a memory shared with you on your graph (--withdraw reverses)',
+    '  lattris link <from> <to>     State that one memory leads to another (--verb, --reason)',
+    '  lattris unlink <from> <to>   Remove that claim (--verb; the blocks stay)',
+    '  lattris update edge <from>   Rewrite an edge\u2019s reason (--verb, --to, --reason)',
+    '  lattris update memory <id>   Correct a memory — `echo "…" | lattris update memory <id> --base-fingerprint <fp>`',
+    '  lattris update recording     Replace a recording\u2019s transcript, or name its speakers',
+    '  lattris get history <id>     A note\u2019s history: every change, newest first, and the head fingerprint',
+    '  lattris delete memory <id>   Move a note to deleted items (its history stays); other types delete',
+    '  lattris get deleted          Your deleted items, with the fingerprint restore and erase need',
+    '  lattris restore memory <id>  Bring a note back, or an earlier revision (--revision, --base-fingerprint)',
+    '  lattris erase memory <id>    Permanently erase a note in deleted items. No undo.',
+    '  lattris resend <request.json>  Send a kept request again, exactly (a lost capture or overwrite)',
+    '  lattris get datasets         The datasets the API keeps, whether you hold rows, and their time range',
+    '  lattris get dataset <name>   One dataset: its identity, filters, fields and an example line',
+    '  lattris get rows <name>      One page of a dataset\u2019s rows (field=value filters, --from, --to, --limit)',
+    '  lattris get row <name> <id>  One row of a dataset',
+    '  lattris capture rows <name>  Save rows \u2014 newline-delimited JSON on stdin, sent in pieces of 5,000 lines',
+    '  lattris delete row <name> <id>  Remove one row of a dataset, permanently',
+    '  lattris logout               Forget the stored session'
+];
+export const COMMAND_WORDS = new Set([
+    'login',
+    'setup',
+    'use',
+    'whoami',
+    'set',
+    'capture',
+    'get',
+    'ask',
+    'close',
+    'delete',
+    'update',
+    'link',
+    'unlink',
+    'invite',
+    'share',
+    'unshare',
+    'deny',
+    'undeny',
+    'consent',
+    'restore',
+    'erase',
+    'resend',
+    'contact',
+    'logout',
+    '--as'
+]);
+//# sourceMappingURL=words.js.map

package/dist/registry/datasets.js

@@ -0,0 +1,15 @@
+import { captureRows } from "../datasets/capture.js";
+import { getRows } from "../datasets/page.js";
+import { GET_DATASETS_HELP } from "../nouns/datasets.js";
+export const datasetNouns = [
+    {
+        name: 'rows',
+        words: { singular: 'row', plural: 'rows' },
+        help: GET_DATASETS_HELP,
+        verbs: [
+            { verb: 'get', nouns: ['rows'], handler: getRows },
+            { verb: 'capture', nouns: ['rows'], handler: captureRows }
+        ]
+    }
+];
+//# sourceMappingURL=datasets.js.map

package/dist/registry/entry.js

@@ -0,0 +1,51 @@
+import { LOGIN_HELP, WHOAMI_HELP, login, logout, whoami } from "../entry/session.js";
+import { SET_HELP, setBannedWords, setName, setRoot } from "../entry/set.js";
+import { setup } from "../entry/setup.js";
+import { use } from "../entry/use.js";
+export const entryNouns = [
+    {
+        name: 'session',
+        words: { singular: 'session', plural: 'sessions' },
+        help: LOGIN_HELP,
+        verbs: [
+            { verb: 'login', handler: login },
+            { verb: 'logout', handler: async (_cfg, io) => logout(io) },
+            { verb: 'whoami', handler: whoami },
+            { verb: 'setup', handler: setup },
+            { verb: 'use', handler: use }
+        ]
+    },
+    {
+        name: 'person',
+        words: { singular: 'person', plural: 'persons' },
+        help: SET_HELP,
+        verbs: [
+            { verb: 'set', nouns: ['name'], handler: setName },
+            { verb: 'set', nouns: ['root'], handler: setRoot },
+            { verb: 'set', nouns: ['banned-words'], handler: setBannedWords }
+        ]
+    }
+];
+export const entryVerbs = {
+    login: { help: LOGIN_HELP, helpBeforeAuth: true },
+    logout: {
+        help: [
+            'Usage: lattris logout',
+            '',
+            'Signs this machine dir out: removes its session file, so the next',
+            'command that needs a session asks for lattris login. Nothing is sent',
+            'to the server; with no session there it still prints "Logged out."',
+            'Exit 1 when the session file cannot be removed.'
+        ].join('\n'),
+        helpBeforeAuth: true
+    },
+    whoami: { help: WHOAMI_HELP, helpBeforeAuth: true },
+    setup: {},
+    use: {},
+    set: {
+        help: SET_HELP,
+        bareIsHelp: true,
+        badNoun: { stderr: 'Unknown field: {noun}\n\n', stdout: `${SET_HELP}\n` }
+    }
+};
+//# sourceMappingURL=entry.js.map

package/dist/registry/index.js

@@ -0,0 +1,17 @@
+import { datasetNouns } from "./datasets.js";
+import { entryNouns, entryVerbs } from "./entry.js";
+import { memoryNouns, memoryVerbs } from "./memory.js";
+import { listNouns, listVerbs } from "../nouns/index.js";
+export const registry = {
+    nouns: [...listNouns, ...memoryNouns, ...entryNouns, ...datasetNouns],
+    verbs: { ...listVerbs, ...memoryVerbs, ...entryVerbs }
+};
+export const commandWordsOf = (r) => [
+    ...new Set([
+        ...r.nouns
+            .filter((n) => n.grammar === 'noun-first')
+            .flatMap((n) => [n.words.singular, ...(n.words.aliases ?? [])]),
+        ...r.nouns.filter((n) => n.grammar !== 'noun-first').flatMap((n) => n.verbs.map((v) => v.verb))
+    ])
+];
+//# sourceMappingURL=index.js.map

package/dist/registry/memory.js

@@ -0,0 +1,116 @@
+import { CAPTURE_ROWS_HELP } from "../datasets/capture.js";
+import { DELETE_ROW_HELP, GET_DATASETS_HELP } from "../nouns/datasets.js";
+import { CAPTURE_INDEX, CAPTURE_NOTE_HELP, CAPTURE_SESSION_HELP } from "../memory/capture-help.js";
+import { asksForSessionForm, captureMemory } from "../memory/capture-note.js";
+import { DELETE_HELP, deleteMemory } from "../memory/delete.js";
+import { ERASE_HELP, eraseMemory } from "../memory/erase.js";
+import { GET_ACCESS_HELP, getAccess } from "../memory/access.js";
+import { GET_HELP } from "../memory/get-help.js";
+import { getMemories } from "../memory/get.js";
+import { getDeleted, getHistory } from "../memory/history.js";
+import { CAPTURE_RECORDING_HELP, captureRecording } from "../memory/recording.js";
+import { updateRecording } from "../memory/recording-update.js";
+import { RESEND_HELP, resend } from "../memory/resend.js";
+import { RESTORE_HELP, restoreMemory } from "../memory/restore.js";
+import { UPDATE_HELP } from "../memory/update-help.js";
+import { updateMemory } from "../memory/update.js";
+export const memoryNouns = [
+    {
+        name: 'memories',
+        words: { singular: 'memory', plural: 'memories', aliases: ['note'] },
+        help: GET_HELP,
+        verbs: [
+            { verb: 'capture', nouns: ['note', 'memory'], handler: captureMemory },
+            {
+                verb: 'capture',
+                nouns: ['session'],
+                handler: (cfg, io, rest) => captureMemory(cfg, io, ['--type', 'session', ...rest])
+            },
+            {
+                verb: 'get',
+                nouns: ['memory'],
+                handler: (cfg, io, rest) => getMemories(cfg, io, rest, 'memory')
+            },
+            {
+                verb: 'get',
+                nouns: ['memories'],
+                handler: (cfg, io, rest) => getMemories(cfg, io, rest, 'memories')
+            },
+            { verb: 'get', nouns: ['history'], handler: getHistory },
+            { verb: 'get', nouns: ['deleted'], handler: getDeleted },
+            { verb: 'get', nouns: ['access'], handler: getAccess },
+            { verb: 'update', nouns: ['memory', 'memories'], handler: updateMemory },
+            { verb: 'delete', nouns: ['memory', 'memories'], handler: deleteMemory },
+            { verb: 'restore', nouns: ['memory', 'memories', 'note'], handler: restoreMemory },
+            { verb: 'erase', nouns: ['memory', 'memories', 'note'], handler: eraseMemory },
+            { verb: 'resend', handler: resend }
+        ]
+    },
+    {
+        name: 'recordings',
+        words: { singular: 'recording', plural: 'recordings' },
+        help: CAPTURE_RECORDING_HELP,
+        verbs: [
+            { verb: 'capture', nouns: ['recording'], handler: captureRecording },
+            { verb: 'update', nouns: ['recording', 'recordings'], handler: updateRecording }
+        ]
+    }
+];
+const captureHelp = (args) => {
+    if (args[0] === 'rows')
+        return CAPTURE_ROWS_HELP;
+    if (args[0] === 'session' || asksForSessionForm(args))
+        return CAPTURE_SESSION_HELP;
+    if (args[0] === 'note' || args[0] === 'memory')
+        return CAPTURE_NOTE_HELP;
+    if (args[0] === 'recording')
+        return CAPTURE_RECORDING_HELP;
+    return CAPTURE_INDEX;
+};
+export const memoryVerbs = {
+    capture: {
+        help: captureHelp,
+        helpBeforeAuth: true,
+        bareIsHelp: true,
+        badNoun: { stderr: 'Unknown capture form: {noun}\n\n', stdout: `${CAPTURE_INDEX}\n` }
+    },
+    get: {
+        help: (args) => ['datasets', 'dataset', 'rows', 'row'].includes(args[0])
+            ? GET_DATASETS_HELP
+            : args[0] === 'access'
+                ? GET_ACCESS_HELP
+                : GET_HELP,
+        bareIsHelp: true,
+        badNoun: {
+            stderr: 'Usage: lattris get memories | lattris get memory <id> | lattris get access <id> --for <contact | number> | lattris get history <id> | lattris get deleted | lattris get invites | lattris get questions | lattris get datasets | lattris get dataset <name> | lattris get rows <name> | lattris get row <name> <id>\n'
+        }
+    },
+    update: {
+        help: UPDATE_HELP,
+        bareIsHelp: true,
+        badNoun: { stderr: 'Usage: lattris update memory <id>\n' }
+    },
+    delete: {
+        help: (args) => (args[0] === 'row' ? DELETE_ROW_HELP : DELETE_HELP),
+        bareIsHelp: true,
+        badNoun: {
+            stderr: 'Usage: lattris delete memory <id> [--yes] | lattris delete row <name> <id> [--yes]\n'
+        }
+    },
+    restore: {
+        help: RESTORE_HELP,
+        helpBeforeAuth: true,
+        bareIsHelp: true,
+        badNoun: {
+            stderr: 'Usage: lattris restore memory <id> --revision <n> --base-fingerprint <head>\n'
+        }
+    },
+    erase: {
+        help: ERASE_HELP,
+        helpBeforeAuth: true,
+        bareIsHelp: true,
+        badNoun: { stderr: 'Usage: lattris erase memory <id> --base-fingerprint <head> [--yes]\n' }
+    },
+    resend: { help: RESEND_HELP, helpBeforeAuth: true }
+};
+//# sourceMappingURL=memory.js.map