lattris 0.2.0 → 0.2.1

package/dist/nouns/share.js

@@ -1,21 +1,106 @@
-import { formatAudiences } from "../render/rows.js";
+import { audienceOf, formatAccessRow, formatAudiences, waitsForNameSentence } from "../render/rows.js";
+import { renderRunHint, sanitizeForTerminal } from "../render/text.js";
 import { consent } from "./consent.js";
-const NOT_LINKED = 'This contact is not linked to an account yet. Invite them from this contact; accepting links it.\n';
+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 — grant public or a person contact access to a memory.',
+    '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-or-contact> [--yes]',
+    '  lattris share memory <id-or-prefix> --with <public | all-contacts | contact> [--yes]',
     '',
-    '  --with   public, or an exact contact name or id from `lattris contact list`.',
-    '  --yes                required when not at a terminal; at a terminal you',
-    '                       are always asked, --yes or not.',
+    '  --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.',
     '',
-    'Idempotent: sharing with an audience that already has access succeeds and',
-    'changes nothing.',
+    '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'],
@@ -26,14 +111,11 @@ const shareVerb = {
         positionals: 1,
         idPositionals: [0],
         steps: {
-            requireFlag: {
-                key: 'with',
-                message: '--with is required. Use public or one of your contact names or ids.\n'
-            },
+            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', mustBeLinked: NOT_LINKED },
+            contact: { from: ['flag:with'], publicWord: 'public', reserved: [ALL_CONTACTS] },
             memory: 'at-tty',
             confirm: {
                 question: 'Share "{title}" ({memory.id}) with {audience}? [y/N] ',
@@ -44,14 +126,77 @@ const shareVerb = {
         request: {
             method: 'POST',
             path: '/memories/{memory.id}/grants',
-            body: {
-                kind: { value: 'person' },
-                contactId: { context: 'contact.id' }
+            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'
             },
-            bodyWithPublic: { audience: 'public' }
+            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,
-        render: (grant, context) => `Shared memory ${context.memory?.id ?? context.positionals[0]} with ${context.contact?.displayName ?? grant.kind}`
+        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 = [
@@ -59,12 +204,17 @@ export const UNSHARE_HELP = [
     'is the safe direction.',
     '',
     'Usage:',
-    '  lattris unshare memory <id-or-prefix> --with <public-or-contact>',
+    '  lattris unshare memory <id-or-prefix> --with <public | all-contacts | contact>',
     '',
-    '  --with   public, or an exact contact name or id from `lattris contact list`.',
+    '  --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.',
+    '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');
@@ -77,22 +227,33 @@ const unshareVerb = {
         positionals: 1,
         idPositionals: [0],
         steps: {
-            contact: { from: ['flag:with'], publicWord: 'public', mustBeLinked: NOT_LINKED },
+            contact: { from: ['flag:with'], publicWord: 'public', reserved: [ALL_CONTACTS] },
             memory: 'always',
             noAudienceReport: {
                 key: 'with',
-                first: '--with is required. Use public or one of your contact names or ids.\n',
+                first: AUDIENCE_WORDS,
                 second: '"{title}" ({memory.id}) is currently shared with: {audiences}\n'
             }
         },
         request: {
             method: 'DELETE',
-            path: '/memories/{memory.id}/grants/person/{contact.claimedPersonId}',
-            pathWithPublic: '/memories/{memory.id}/grants/public'
+            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?.displayName ?? 'public'}`
+        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);
@@ -100,6 +261,6 @@ export const grants = {
     name: 'grants',
     words: { singular: 'grant', plural: 'grants' },
     help: SHARE_HELP,
-    verbs: [shareVerb, unshareVerb, consent]
+    verbs: [shareVerb, unshareVerb, denyVerb, undenyVerb, consent]
 };
 //# sourceMappingURL=share.js.map

package/dist/nouns/words.js

@@ -18,16 +18,19 @@ export const USAGE_LINES = [
     '  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',
-    '  lattris contact create "<name>"  Record a person or an AI you work with (--ai); add, list, get, update',
+    '  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>    Grant an audience access (--with public)',
-    '  lattris unshare memory <id>  Withdraw an audience (--with public)',
+    '  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)',
@@ -65,6 +68,8 @@ export const COMMAND_WORDS = new Set([
     'invite',
     'share',
     'unshare',
+    'deny',
+    'undeny',
     'consent',
     'restore',
     'erase',

package/dist/registry/memory.js

@@ -4,6 +4,7 @@ import { CAPTURE_INDEX, CAPTURE_NOTE_HELP, CAPTURE_SESSION_HELP } from "../memor
 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";
@@ -37,6 +38,7 @@ export const memoryNouns = [
             },
             { 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 },
@@ -73,10 +75,14 @@ export const memoryVerbs = {
         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 : GET_HELP,
+        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 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'
+            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: {

package/dist/render/rows.js

@@ -1,8 +1,41 @@
-import { sanitizeForTerminal } from "./text.js";
+import { renderRunHint, sanitizeForTerminal } from "./text.js";
+import { isUuidKey } from "../store/write-identity.js";
 export const formatContact = (c) => `${sanitizeForTerminal(c.displayName)} · ${c.type} · ${c.id}` +
     `${c.claimedPersonId ? ' · linked' : ''}` +
     `${c.email ? ` · email ${sanitizeForTerminal(c.email)}` : ''}` +
+    `${c.phone ? ` · phone ${sanitizeForTerminal(c.phone)}` : ''}` +
     `${c.rootBlockId ? ` · root ${c.rootBlockId}` : ''}`;
+export const resolveContact = (contacts, selector) => {
+    if (isUuidKey(selector)) {
+        const contact = contacts.find((c) => c.id.toLowerCase() === selector.toLowerCase());
+        return contact ? { kind: 'found', contact } : { kind: 'missing-id' };
+    }
+    const folded = selector.toLowerCase();
+    const matches = contacts.filter((c) => c.displayName.toLowerCase() === folded);
+    if (matches.length === 1)
+        return { kind: 'found', contact: matches[0] };
+    if (matches.length > 1)
+        return { kind: 'ambiguous', matches };
+    return { kind: 'missing-name', displayName: selector };
+};
+export const isGroupWord = (word) => word.trim().toLowerCase().startsWith('group:');
+export const groupsNotBuilt = (word) => `${sanitizeForTerminal(word)} names a group, and groups are not built yet. A contact called that is reached by its id.\n`;
+export const audienceOf = (r) => r.kind === 'public'
+    ? 'public'
+    : r.kind === 'all_contacts'
+        ? 'all contacts'
+        : r.kind === 'person'
+            ? `${sanitizeForTerminal(r.contactName ?? r.personId ?? '')} (website)`
+            : sanitizeForTerminal(r.contactName ?? r.contactId ?? '');
+export const formatAccessRow = (r) => `${r.effect} ${audienceOf(r)}`;
+export const waitsForNameSentence = (name) => `${sanitizeForTerminal(name)} is linked to an account, but the website share waits until you set your name (${renderRunHint(['set', 'name'])}).`;
+export const waitsForNameLines = (rows) => (rows ?? [])
+    .filter((r) => r.unpairedBecause === 'owner-has-no-name' && r.contactName)
+    .map((r) => waitsForNameSentence(r.contactName ?? ''));
+export const formatAccess = (rows) => rows.length === 0 ? '(nothing set)' : rows.map(formatAccessRow).join('; ');
+export const describeForContact = (c, asked) => c === null
+    ? `no contact holds ${sanitizeForTerminal(asked ?? 'that number')}; a stranger sees public memories only`
+    : `${sanitizeForTerminal(c.displayName)} (${c.type}${c.phone ? `, ${sanitizeForTerminal(c.phone)}` : ''})`;
 export const formatQuestion = (q) => {
     const lines = [`id           ${q.id}`, `createdAt    ${q.createdAt}`];
     if (q.kind === 'share') {

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "lattris",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "type": "module",
-  "description": "First-party CLI for Lattris \u2014 sign in, capture notes and sessions, and read your own tree from the terminal.",
+  "description": "First-party CLI for Lattris — sign in, capture notes and sessions, and read your own tree from the terminal.",
   "keywords": [
     "lattris",
     "cli",