lattris 0.2.0 → 0.2.1

package/dist/memory/get.js

@@ -1,4 +1,5 @@
 import { parseArgs } from "../request/flags.js";
+import { contactIdFor } from "../memory/access.js";
 import { getRevision } from "../memory/history.js";
 import { composeAddress, formatMemoryDetail, formatMemoryPage, formatNodeWalk, ownHandleFor, parseWebsiteMemoryAddress } from "../memory/views.js";
 import { emit } from "../render/output.js";
@@ -80,9 +81,21 @@ const GET_FLAG_NAMES = {
     '--with': 'with',
     '--links': 'links',
     '--depth': 'depth',
-    '--content': 'content'
+    '--content': 'content',
+    '--for': 'for',
+    '--for-phone': 'forPhone'
 };
-const LIST_ONLY_FLAGS = ['type', 'intent', 'limit', 'cursor', 'q', 'with', 'sharedWithMe'];
+const LIST_ONLY_FLAGS = [
+    'type',
+    'intent',
+    'limit',
+    'cursor',
+    'q',
+    'with',
+    'sharedWithMe',
+    'for',
+    'forPhone'
+];
 const WALK_ONLY_FLAGS = ['links', 'depth', 'revision'];
 const listMemories = async (cfg, io, flags) => {
     const accessToken = await signedIn(io, cfg);
@@ -105,10 +118,22 @@ const listMemories = async (cfg, io, flags) => {
         url.searchParams.set('content', flags.content);
     if (flags.sharedWithMe)
         url.searchParams.set('sharedWithMe', '1');
+    if (flags.for !== undefined && flags.forPhone !== undefined) {
+        return refusal('--for and --for-phone name one audience; pass one.\n');
+    }
+    if (flags.for !== undefined) {
+        const contact = await contactIdFor(cfg, io, accessToken, flags.for);
+        if ('exit' in contact)
+            return contact;
+        url.searchParams.set('forContact', contact.id);
+    }
+    if (flags.forPhone !== undefined)
+        url.searchParams.set('forPhone', flags.forPhone);
     const result = await io.api(accessToken, url);
     if (!result.ok)
         return refusalOf(result);
-    emit(io, result.data, result.rawText, formatMemoryPage);
+    const asked = flags.forPhone ?? flags.for;
+    emit(io, result.data, result.rawText, (page) => formatMemoryPage(page, asked));
     if (result.data.nextCursor) {
         const argv = ['get', 'memories'];
         if (flags.type !== undefined)
@@ -119,6 +144,10 @@ const listMemories = async (cfg, io, flags) => {
             argv.push('--q', flags.q);
         if (flags.with !== undefined)
             argv.push('--with', flags.with);
+        if (flags.for !== undefined)
+            argv.push('--for', flags.for);
+        if (flags.forPhone !== undefined)
+            argv.push('--for-phone', flags.forPhone);
         if (flags.limit !== undefined)
             argv.push('--limit', flags.limit);
         if (flags.content !== undefined)
@@ -195,9 +224,13 @@ export const getMemories = async (cfg, io, rest, noun) => {
             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);
+            const ownerOnly = ['type', 'intent', 'q', 'with', 'sharedWithMe', 'for', 'forPhone'].find((key) => flags[key] !== undefined);
             if (ownerOnly !== undefined) {
-                const flagName = ownerOnly === 'sharedWithMe' ? 'shared-with-me' : ownerOnly;
+                const flagName = ownerOnly === 'sharedWithMe'
+                    ? 'shared-with-me'
+                    : ownerOnly === 'forPhone'
+                        ? 'for-phone'
+                        : ownerOnly;
                 return refusal(`--${flagName} does not apply to a wall listing.\n`);
             }
             return getWallMemories(cfg, io, flags.by, flags);

package/dist/memory/recording.js

@@ -2,7 +2,7 @@ import { createHash } from 'node:crypto';
 import { parseArgs } from "../request/flags.js";
 import { HELP_TOKENS } from "../request/flags.js";
 import { RECORDING_FORMATS, TRANSCRIPT_CONVERTERS, buildRecordingBody, formatRecording, mimeForAudio } from "../memory/transcript.js";
-import { SHARE_AUDIENCES } from "../memory/capture-common.js";
+import { allowWords, checkShareWords, isRefusalValue, needsYesWords, resolveBornShares, takeShareFlags } from "../memory/capture-common.js";
 import { emit } from "../render/output.js";
 import { confirmAction } from "../render/prompt.js";
 import { sanitizeForTerminal } from "../render/text.js";
@@ -41,7 +41,10 @@ Usage:
   --captured-at <t>   when it was recorded (ISO 8601; the future is refused)
   --duration <n>      length in seconds
   --span <uuid>       group it into one of your spans
-  --share-with public make it public immediately
+  --share-with <who>  who may see it from birth: public, all-contacts, or a contact
+                      (repeatable); asks at a terminal, needs --yes on a pipe
+  --deny <who>        who may not, whatever else allows it: all-contacts or a
+                      contact (repeatable); asks nothing
   --contributor <id>  whose expression it is — a contact id
   --allow-banned-words  keep a flagged word in the title deliberately
 
@@ -60,7 +63,6 @@ const RECORDING_FLAG_NAMES = {
     '--captured-at': 'capturedAt',
     '--duration': 'duration',
     '--span': 'span',
-    '--share-with': 'shareWith',
     '--contributor': 'contributor'
 };
 export const captureRecording = async (cfg, io, args) => {
@@ -70,22 +72,21 @@ export const captureRecording = async (cfg, io, args) => {
     }
     const allowBanned = args.includes('--allow-banned-words');
     const yes = args.includes('--yes');
-    const { flags, positionals, unknown } = parseArgs(RECORDING_FLAG_NAMES, args.filter((a) => a !== '--allow-banned-words' && a !== '--yes'));
-    if (unknown) {
-        return refusal(`Unknown flag: ${unknown}\n`);
+    const taken = takeShareFlags(args.filter((a) => a !== '--allow-banned-words' && a !== '--yes'));
+    const { flags, positionals, unknown } = parseArgs(RECORDING_FLAG_NAMES, taken.rest);
+    if (unknown ?? taken.unknown) {
+        return refusal(`Unknown flag: ${unknown ?? taken.unknown}\n`);
     }
     if (positionals.length > 1) {
         return refusal(`Unexpected argument: ${positionals[1]}\n`);
     }
     const transcriptFile = positionals[0];
-    if (flags.shareWith !== undefined &&
-        !SHARE_AUDIENCES.includes(flags.shareWith)) {
-        return refusal(`Unknown audience: ${flags.shareWith}. Accepted: ${SHARE_AUDIENCES.join(', ')}\n`);
-    }
-    if (flags.shareWith !== undefined && !io.stdin.isTTY && !yes) {
-        return refusal('This will save the recording AND make it public — anyone, including people ' +
-            'without accounts. There is no prompt here (the content already arrived on ' +
-            'a pipe) — pass --yes once the person has confirmed both facts.\n');
+    const badShareWords = checkShareWords(taken.shareWith, taken.deny);
+    if (badShareWords)
+        return badShareWords;
+    const allows = allowWords(taken.shareWith);
+    if (allows.length > 0 && !io.stdin.isTTY && !yes) {
+        return refusal(needsYesWords('recording', allows));
     }
     if (transcriptFile === undefined && flags.audio === undefined && flags.sourceUrl === undefined) {
         return refusal('A recording needs at least one of: a transcript file, --audio, or --source-url.\n');
@@ -134,6 +135,25 @@ export const captureRecording = async (cfg, io, args) => {
     if (flags.duration !== undefined && !/^\d+$/.test(flags.duration)) {
         return refusal(`--duration must be a whole number of seconds: ${flags.duration}\n`);
     }
+    if (allows.length > 0 && io.stdin.isTTY) {
+        const answer = await confirmAction(io, `Share "${sanitizeForTerminal(flags.title ?? '(untitled)')}" with ${allows.join(', ')}? [y/N] `);
+        if (answer === 'interrupted')
+            return refusal('Cancelled.\n', EXIT.GENERIC);
+        if (answer === 'no') {
+            io.stderr.write('Cancelled.\n');
+            return;
+        }
+    }
+    const accessToken = await signedIn(io, cfg);
+    if (typeof accessToken !== 'string')
+        return accessToken;
+    let shares;
+    if (taken.shareWith.length > 0 || taken.deny.length > 0) {
+        const resolved = await resolveBornShares(cfg, io, accessToken, taken.shareWith, taken.deny);
+        if (isRefusalValue(resolved))
+            return resolved;
+        shares = resolved;
+    }
     const body = buildRecordingBody({
         transcript,
         upload,
@@ -141,7 +161,8 @@ export const captureRecording = async (cfg, io, args) => {
         title: flags.title,
         capturedAt: flags.capturedAt,
         spanId: flags.span,
-        audience: flags.shareWith,
+        audience: shares?.audience,
+        access: shares !== undefined && shares.access.length > 0 ? shares.access : undefined,
         contributor: flags.contributor,
         sourceName: flags.sourceName,
         titleAtSource: flags.titleAtSource,
@@ -150,18 +171,6 @@ export const captureRecording = async (cfg, io, args) => {
         durationSeconds: flags.duration === undefined ? undefined : Number(flags.duration),
         allowBannedWords: allowBanned
     });
-    if (flags.shareWith !== undefined && io.stdin.isTTY) {
-        const answer = await confirmAction(io, `Share "${sanitizeForTerminal(flags.title ?? '(untitled)')}" with public — anyone, including people without accounts? [y/N] `);
-        if (answer === 'interrupted')
-            return refusal('Cancelled.\n', EXIT.GENERIC);
-        if (answer === 'no') {
-            io.stderr.write('Cancelled.\n');
-            return;
-        }
-    }
-    const accessToken = await signedIn(io, cfg);
-    if (typeof accessToken !== 'string')
-        return accessToken;
     const created = await io.api(accessToken, `${cfg.apiUrl}/memories/recordings`, {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },

package/dist/memory/transcript.js

@@ -1,3 +1,4 @@
+import { waitsForNameLines } from "../render/rows.js";
 import { sanitizeForTerminal } from "../render/text.js";
 const AUDIO_MIME_BY_EXT = {
     mp3: 'audio/mpeg',
@@ -80,6 +81,8 @@ export const formatRecording = (r) => {
     if (r.durationSeconds)
         lines.push(`  duration     ${r.durationSeconds}s`);
     lines.push(`  capturedAt   ${r.capturedAt}`);
+    for (const sentence of waitsForNameLines(r.access))
+        lines.push(`  website      ${sentence}`);
     return lines.join('\n');
 };
 //# sourceMappingURL=transcript.js.map

package/dist/memory/views.js

@@ -1,4 +1,4 @@
-import { formatAudiences } from "../render/rows.js";
+import { describeForContact, formatAccess, formatAudiences } from "../render/rows.js";
 import { sanitizeForTerminal } from "../render/text.js";
 import { stripTrailingSlash } from "../store/environment.js";
 export const formatDeletedLine = (b) => `${b.id}  ${b.deletedAt ?? '-'}  rev ${b.revisionNo ?? '-'}  ${b.fingerprint ?? '-'}  ${sanitizeForTerminal(b.title ?? '(untitled)')}`;
@@ -74,6 +74,8 @@ export const formatMemoryDetail = (m, address) => {
     if (m.source)
         lines.push(`source       ${sanitizeForTerminal(m.source)}`);
     lines.push(`audiences    ${formatAudiences(m.audiences)}`);
+    if (Array.isArray(m.access))
+        lines.push(`access       ${formatAccess(m.access)}`);
     if (m.fingerprint)
         lines.push(`fingerprint  ${m.fingerprint}`);
     if (m.revisionNo)
@@ -92,7 +94,13 @@ export const formatMemoryDetail = (m, address) => {
     }
     return lines.join('\n');
 };
-export const formatMemoryPage = (page) => page.items.map((i) => formatBlockLine(i)).join('\n');
+export const formatMemoryPage = (page, asked) => {
+    const rows = page.items.map((i) => formatBlockLine(i));
+    if (page.forContact === undefined)
+        return rows.join('\n');
+    const header = `for          ${describeForContact(page.forContact, asked)}`;
+    return [header, ...(rows.length === 0 ? ['(nothing they may see)'] : rows)].join('\n');
+};
 export const formatFindingAid = (a) => {
     const lines = [`id           ${a.id}`, `handle       ${a.handle}`, `type         ${a.type}`];
     if (a.title)

package/dist/nouns/contact.js

@@ -1,4 +1,5 @@
 import { formatContact } from "../render/rows.js";
+import { renderRunHint, sanitizeForTerminal } from "../render/text.js";
 import { verbsOf } from "./form.js";
 const CONTACT_HELP = [
     'contact — the people and AIs you work with. A contact is yours alone: it',
@@ -6,33 +7,61 @@ const CONTACT_HELP = [
     'so its contact can point at its page.',
     '',
     'Usage:',
-    '  lattris contact add --name "<v>" [--email <v>] [--ai]',
+    '  lattris contact add --name "<v>" [--email <v>] [--phone <v>] [--ai]',
     '                                              record a person by name; --email keeps',
     '                                              their address as your own note',
-    '  lattris contact create "<name>" [--ai] [--email <v>]',
+    '  lattris contact create "<name>" [--ai] [--email <v>] [--phone <v>]',
     '                                              the same, with the name first',
-    '  lattris contact list                        every contact of yours, as the API sends them',
+    '  lattris contact list [--phone <v>]          every contact of yours, as the API sends them;',
+    '                                              --phone answers the one holding that number, or none',
     '  lattris contact get <id>                    one contact, by its full id or a unique prefix',
-    '  lattris contact update <id> [--name "<v>"] [--email <v> | --clear-email] [--ai | --person] [--root <block-id>]',
-    '                                              rename, change the email or the kind, or point',
+    '  lattris contact update <id> [--name "<v>"] [--email <v> | --clear-email] [--phone <v> | --clear-phone] [--ai | --person] [--root <block-id>]',
+    '                                              rename, change the email, the number or the kind, or point',
     '                                              it at a block of yours (an AI role at its page)',
+    '  lattris contact delete <id-or-name> [--yes] remove a contact nothing holds on to: asks at a',
+    '                                              terminal, needs --yes on a pipe',
     '',
     '  --email <v>        the address you keep for this contact. It is your record',
     '                     alone: the contact never sees it, nobody else reads it,',
     '                     and changing it asks nobody',
+    '  --phone <v>        the number a chat reaches this contact at, in full',
+    '                     international form: + then digits, like +61412345678.',
+    '                     One per contact, and no two of your contacts may hold',
+    '                     one number. An AI contact holds none.',
     '  --root <block-id>  the full id of one of your own blocks, never a prefix; the',
     '                     API refuses a block you do not own',
     '',
     'A contact shows "linked" once it stands for a Lattris account: yours are',
     'linked when someone accepts the invitation you minted for that contact,',
     'and the person who invited you appears among your contacts, linked, the',
-    'moment you accept. Sharing with --with needs a linked contact.',
+    'moment you accept. A share or a deny names any contact, linked or not;',
+    'a linked contact also sees a share on the website.',
     '',
     'Another person’s contact is not yours to read or change: the API answers',
     'not found. A block names a contact with --contributor <id>, on capture and',
-    'on update memory alike.'
+    'on update memory alike.',
+    '',
+    'A contact that contributed a memory, that an invitation links, or that a',
+    'deny names cannot be deleted: the API refuses and says which. A deny is',
+    'lifted with `lattris undeny memory <id> --to <contact>` first, so the same',
+    'number added back later never skips it.'
 ].join('\n');
-const CONTACT_UPDATE_USAGE = 'Usage: lattris contact update <id> [--name "<v>"] [--email <v> | --clear-email] [--ai | --person] [--root <block-id>]';
+const deniedBlocksWords = (body, contactId) => {
+    if (body.code !== 'contact:has-denies')
+        return '';
+    const blocks = body.detail?.blocks;
+    if (!Array.isArray(blocks) || blocks.length === 0)
+        return '';
+    const lines = blocks.map((b) => `  ${b.id}  ${sanitizeForTerminal(b.title ?? '(untitled)')}  — ${renderRunHint([
+        'undeny',
+        'memory',
+        b.id,
+        '--to',
+        contactId
+    ])}`);
+    return `Denies naming this contact:\n${lines.join('\n')}\n`;
+};
+const CONTACT_UPDATE_USAGE = 'Usage: lattris contact update <id> [--name "<v>"] [--email <v> | --clear-email] [--phone <v> | --clear-phone] [--ai | --person] [--root <block-id>]';
 const contactRow = (c) => formatContact(c);
 export const contacts = {
     name: 'contacts',
@@ -43,8 +72,8 @@ export const contacts = {
     unknownVerb: 'Unknown contact verb: {verb}\n\n' + CONTACT_HELP + '\n',
     verbs: verbsOf({
         add: {
-            usage: 'Usage: lattris contact add --name "<v>" [--email <v>] [--ai]',
-            flags: { '--name': 'name', '--email': 'email' },
+            usage: 'Usage: lattris contact add --name "<v>" [--email <v>] [--phone <v>] [--ai]',
+            flags: { '--name': 'name', '--email': 'email', '--phone': 'phone' },
             switches: ['--ai'],
             positionals: 0,
             requiredFlags: ['name'],
@@ -54,14 +83,15 @@ export const contacts = {
                 body: {
                     displayName: { flag: 'name' },
                     type: { switch: '--ai', value: 'ai' },
-                    email: { flag: 'email' }
+                    email: { flag: 'email' },
+                    phone: { flag: 'phone' }
                 }
             },
             render: (c) => `Recorded contact ${contactRow(c)}`
         },
         create: {
-            usage: 'Usage: lattris contact create "<name>" [--ai] [--email <v>]',
-            flags: { '--email': 'email' },
+            usage: 'Usage: lattris contact create "<name>" [--ai] [--email <v>] [--phone <v>]',
+            flags: { '--email': 'email', '--phone': 'phone' },
             switches: ['--ai'],
             positionals: 1,
             request: {
@@ -70,18 +100,22 @@ export const contacts = {
                 body: {
                     displayName: { positional: 0 },
                     type: { switch: '--ai', value: 'ai' },
-                    email: { flag: 'email' }
+                    email: { flag: 'email' },
+                    phone: { flag: 'phone' }
                 }
             },
             render: (c) => `Recorded contact ${contactRow(c)}`
         },
         list: {
-            usage: 'Usage: lattris contact list',
+            usage: 'Usage: lattris contact list [--phone <v>]',
+            flags: { '--phone': 'phone' },
             positionals: 0,
             unknownFlagIsUsage: true,
-            request: { method: 'GET', path: '/contacts' },
-            render: (list) => list.length === 0
-                ? 'No contacts yet. `lattris contact create "<name>"` records one.'
+            request: { method: 'GET', path: '/contacts', query: { phone: { flag: 'phone' } } },
+            render: (list, context) => list.length === 0
+                ? context.flags.phone !== undefined
+                    ? `No contact of yours holds ${sanitizeForTerminal(context.flags.phone)}.`
+                    : 'No contacts yet. `lattris contact create "<name>"` records one.'
                 : list.map(formatContact).join('\n')
         },
         get: {
@@ -98,8 +132,8 @@ export const contacts = {
         },
         update: {
             usage: CONTACT_UPDATE_USAGE,
-            flags: { '--name': 'name', '--root': 'root', '--email': 'email' },
-            switches: ['--ai', '--person', '--clear-email'],
+            flags: { '--name': 'name', '--root': 'root', '--email': 'email', '--phone': 'phone' },
+            switches: ['--ai', '--person', '--clear-email', '--clear-phone'],
             positionals: 1,
             uuidPositionals: [0],
             idPositionals: [0],
@@ -113,6 +147,11 @@ export const contacts = {
                     a: '--clear-email',
                     b: 'email',
                     message: '--email and --clear-email contradict each other; pass one.\n'
+                },
+                {
+                    a: '--clear-phone',
+                    b: 'phone',
+                    message: '--phone and --clear-phone contradict each other; pass one.\n'
                 }
             ],
             uuidFlags: [
@@ -131,11 +170,33 @@ export const contacts = {
                     ],
                     rootBlockId: { flag: 'root' },
                     displayName: { flag: 'name' },
-                    email: [{ flag: 'email' }, { switch: '--clear-email', value: null }]
+                    email: [{ flag: 'email' }, { switch: '--clear-email', value: null }],
+                    phone: [{ flag: 'phone' }, { switch: '--clear-phone', value: null }]
                 },
-                emptyBodyMessage: `Nothing to update: pass --name, --email, --clear-email, --ai, --person or --root.\n${CONTACT_UPDATE_USAGE}\n`
+                emptyBodyMessage: `Nothing to update: pass --name, --email, --clear-email, --phone, --clear-phone, --ai, --person or --root.\n${CONTACT_UPDATE_USAGE}\n`
             },
             render: (c) => `Updated contact ${contactRow(c)}`
+        },
+        delete: {
+            usage: 'Usage: lattris contact delete <id-or-name> [--yes]',
+            switches: ['--yes'],
+            positionals: 1,
+            idPositionals: [0],
+            steps: {
+                contact: { from: ['p0'] },
+                pipedNeedsYes: {
+                    message: 'Refusing to delete a contact without confirmation on a non-interactive session. Pass --yes to skip the prompt.\n'
+                },
+                confirm: {
+                    question: 'Delete contact "{name}" ({contact.id}) permanently? [y/N] ',
+                    onNo: { text: 'Cancelled.\n', to: 'stderr' },
+                    onInterrupted: { text: 'Cancelled.\n', exit: 1 }
+                }
+            },
+            request: { method: 'DELETE', path: '/contacts/{contact.id}' },
+            refusalWords: (body, context) => deniedBlocksWords(body, context.contact?.id ?? ''),
+            renderTo: 'stderr',
+            render: (_answer, context) => `Deleted contact ${sanitizeForTerminal(context.contact?.displayName ?? context.positionals[0])}`
         }
     })
 };

package/dist/nouns/index.js

@@ -6,7 +6,7 @@ import { datasets } from "./datasets.js";
 import { LINK_HELP, edges } from "./edges.js";
 import { INVITE_HELP, invites } from "./invite.js";
 import { ASK_HELP, CLOSE_HELP, CLOSE_USAGE, questions } from "./questions.js";
-import { SHARE_HELP, UNSHARE_HELP, grants } from "./share.js";
+import { DENY_HELP, SHARE_HELP, UNDENY_HELP, UNSHARE_HELP, grants } from "./share.js";
 export const listNouns = [contacts, questions, edges, invites, grants, datasets];
 export const listVerbs = {
     ask: { help: ASK_HELP, helpBeforeAuth: true },
@@ -29,6 +29,20 @@ export const listVerbs = {
         help: UNSHARE_HELP,
         bareIsHelp: true,
         badNoun: { stderr: 'Usage: lattris unshare memory <id> [--with <audience>]\n' }
+    },
+    deny: {
+        help: DENY_HELP,
+        helpBeforeAuth: true,
+        bareIsHelp: true,
+        badNoun: { stderr: 'Usage: lattris deny memory <id> --to <all-contacts | contact>\n' }
+    },
+    undeny: {
+        help: UNDENY_HELP,
+        helpBeforeAuth: true,
+        bareIsHelp: true,
+        badNoun: {
+            stderr: 'Usage: lattris undeny memory <id> --to <all-contacts | contact> [--yes]\n'
+        }
     }
 };
 //# sourceMappingURL=index.js.map