lattris 0.1.4 → 0.2.1

package/dist/memory/get.js

@@ -0,0 +1,246 @@
+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";
+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',
+    '--for': 'for',
+    '--for-phone': 'forPhone'
+};
+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);
+    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');
+    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);
+    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)
+            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.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)
+            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', 'for', 'forPhone'].find((key) => flags[key] !== undefined);
+            if (ownerOnly !== undefined) {
+                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);
+        }
+        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

package/dist/memory/history.js

@@ -0,0 +1,134 @@
+import { parseArgs } from "../request/flags.js";
+import { formatDeletedPage } from "../memory/views.js";
+import { emit } from "../render/output.js";
+import { renderRunHint, sanitizeForTerminal } from "../render/text.js";
+import { refusal } from "../store/exit.js";
+import { refusalOf } from "../request/api-fetch.js";
+import { signedIn } from "../request/access-token.js";
+import { ambiguousText } from "../render/rows.js";
+export const formatHistoryItem = (i) => {
+    const who = i.actor.agentLabel
+        ? `${sanitizeForTerminal(i.actor.sessionId)} (${sanitizeForTerminal(i.actor.agentLabel)})`
+        : sanitizeForTerminal(i.actor.sessionId);
+    const rev = i.revisionNo === null ? '-' : `rev ${i.revisionNo}`;
+    const extra = [
+        i.restoredFromRevisionNo !== null ? `from rev ${i.restoredFromRevisionNo}` : undefined,
+        i.overwriteReason !== null ? `reason: ${sanitizeForTerminal(i.overwriteReason)}` : undefined,
+        i.baseline ? 'baseline' : undefined
+    ]
+        .filter((x) => x !== undefined)
+        .join('; ');
+    return `${i.recordedAt}  ${i.action.padEnd(12)}  ${rev.padEnd(9)}  ${who}${extra ? `  (${extra})` : ''}  ${i.operationId}`;
+};
+export const formatHistoryPage = (page, headFingerprint) => {
+    const lines = [];
+    if (headFingerprint)
+        lines.push(`head fingerprint  ${headFingerprint}`, '');
+    else
+        lines.push('head fingerprint  (not on this page)', '');
+    lines.push(...page.items.map((i) => formatHistoryItem(i)));
+    if (page.items.length === 0)
+        lines.push('(no history)');
+    lines.push('', `history starts at revision ${page.coverage.startsAtRevisionNo}` +
+        (page.coverage.baselineRecordedAt ? ` (baseline ${page.coverage.baselineRecordedAt})` : '') +
+        ` \u2014 ${sanitizeForTerminal(page.coverage.note, Infinity)}`);
+    if (page.nextBeforeOperation) {
+        lines.push(`More: --before ${page.nextBeforeOperation}`);
+    }
+    return lines.join('\n');
+};
+export const formatRevision = (r) => {
+    const lines = [
+        `revisionNo   ${r.revisionNo ?? '-'}`,
+        `fingerprint  ${r.fingerprint}`,
+        `recordedAt   ${r.recordedAt}`,
+        `action       ${r.action}`,
+        `session      ${sanitizeForTerminal(r.actor.sessionId)}${r.actor.agentLabel ? ` (${sanitizeForTerminal(r.actor.agentLabel)})` : ''}`
+    ];
+    if (r.restoredFromRevisionNo !== null)
+        lines.push(`restoredFrom rev ${r.restoredFromRevisionNo}`);
+    if (r.overwriteReason !== null)
+        lines.push(`reason       ${sanitizeForTerminal(r.overwriteReason)}`);
+    if (r.snapshot.intent)
+        lines.push(`intent       ${sanitizeForTerminal(r.snapshot.intent)}`);
+    if (r.snapshot.capturedAt)
+        lines.push(`capturedAt   ${r.snapshot.capturedAt}`);
+    if (r.snapshot.title)
+        lines.push(`title        ${sanitizeForTerminal(r.snapshot.title)}`);
+    if (r.snapshot.aiSummary)
+        lines.push(`aiSummary    ${sanitizeForTerminal(r.snapshot.aiSummary, Infinity)}`);
+    lines.push('', sanitizeForTerminal(r.snapshot.content, Infinity));
+    return lines.join('\n');
+};
+const HISTORY_FLAG_NAMES = {
+    '--limit': 'limit',
+    '--before': 'before'
+};
+export const getHistory = async (cfg, io, rest) => {
+    const { flags, positionals, unknown, notAnId } = parseArgs(HISTORY_FLAG_NAMES, rest, [0]);
+    if (unknown) {
+        return refusal(`Unknown flag: ${unknown}\n`);
+    }
+    if (notAnId)
+        return refusal(notAnId);
+    if (positionals.length !== 1) {
+        return refusal(`Usage: lattris get history <id> [--limit <n>] [--before <operation-id>]\n`);
+    }
+    const accessToken = await signedIn(io, cfg);
+    if (typeof accessToken !== 'string')
+        return accessToken;
+    const url = new URL(`${cfg.apiUrl}/memories/${encodeURIComponent(positionals[0])}/revisions`);
+    if (flags.limit !== undefined)
+        url.searchParams.set('limit', flags.limit);
+    if (flags.before !== undefined)
+        url.searchParams.set('beforeOperation', flags.before);
+    const result = await io.api(accessToken, url);
+    if (!result.ok)
+        return refusalOf(result, ambiguousText(result.body));
+    emit(io, result.data, result.rawText, (page) => formatHistoryPage(page, page.head?.fingerprint));
+};
+export const REVISION_NO_SHAPE = /^[1-9][0-9]{0,17}$/;
+export const getRevision = async (cfg, io, idOrPrefix, revisionNo) => {
+    if (!REVISION_NO_SHAPE.test(revisionNo)) {
+        return refusal(`--revision must be a positive number from the history: ${revisionNo}\n`);
+    }
+    const accessToken = await signedIn(io, cfg);
+    if (typeof accessToken !== 'string')
+        return accessToken;
+    const result = await io.api(accessToken, `${cfg.apiUrl}/memories/${encodeURIComponent(idOrPrefix)}/revisions/${revisionNo}`);
+    if (!result.ok)
+        return refusalOf(result, ambiguousText(result.body));
+    emit(io, result.data, result.rawText, formatRevision);
+};
+const DELETED_FLAG_NAMES = {
+    '--limit': 'limit',
+    '--cursor': 'cursor'
+};
+export const getDeleted = async (cfg, io, rest) => {
+    const { flags, positionals, unknown } = parseArgs(DELETED_FLAG_NAMES, rest);
+    if (unknown) {
+        return refusal(`Unknown flag: ${unknown}\n`);
+    }
+    if (positionals.length > 0) {
+        return refusal(`Unexpected argument: ${positionals[0]}\n`);
+    }
+    const accessToken = await signedIn(io, cfg);
+    if (typeof accessToken !== 'string')
+        return accessToken;
+    const url = new URL(`${cfg.apiUrl}/memories`);
+    url.searchParams.set('state', 'deleted');
+    if (flags.limit !== undefined)
+        url.searchParams.set('limit', flags.limit);
+    if (flags.cursor !== undefined)
+        url.searchParams.set('cursor', flags.cursor);
+    const result = await io.api(accessToken, url);
+    if (!result.ok)
+        return refusalOf(result);
+    emit(io, result.data, result.rawText, (page) => {
+        const lines = [formatDeletedPage(page)].filter((l) => l.length > 0);
+        if (page.nextCursor)
+            lines.push(`More: ${renderRunHint(['get', 'deleted', '--cursor', page.nextCursor])}`);
+        return lines.join('\n');
+    });
+};
+//# sourceMappingURL=history.js.map

package/dist/memory/recording-update.js

@@ -0,0 +1,128 @@
+import { parseArgs } from "../request/flags.js";
+import { RECORDING_FORMATS, TRANSCRIPT_CONVERTERS, formatRecording } from "../memory/transcript.js";
+import { emit } from "../render/output.js";
+import { EXIT, refusal } from "../store/exit.js";
+import { refusalOf } from "../request/api-fetch.js";
+import { signedIn } from "../request/access-token.js";
+import { ambiguousText } from "../render/rows.js";
+const RECORDING_UPDATE_HELP = [
+    'update recording — correct a recording’s transcript or its speaker map.',
+    '',
+    'The transcript is replace-whole (turns AND the speaker map are one record);',
+    'the speaker map is the recording’s one correctable finding aid — who each',
+    'voice is.',
+    '',
+    'Usage:',
+    '  lattris update recording transcript <id> <file> [--format json|a] [--force]',
+    '  lattris update recording speakers <id> <key>=<value> [<key>=<value> …]',
+    '',
+    '  transcript   replaces the whole transcript from <file> (same converters as',
+    '               capture recording). --force is REQUIRED when the transcript is',
+    '               the recording’s ONLY substance — those words ARE the record,',
+    '               and the server refuses to replace them without it and says so.',
+    '',
+    '  speakers     corrects the map, one key=value per declared speaker key:',
+    '                 <key>=me            claim that voice as your own',
+    '                 <key>=<contact-id>  map it to one of your contacts',
+    '                 <key>=clear         remove both (back to label-only)',
+    '               A key the recording does not declare is a 404 — the map is',
+    '               corrected, never widened. Labels are the record and unreachable',
+    '               here (re-send the transcript to change a label).'
+].join('\n');
+const updateRecordingTranscript = async (cfg, io, args) => {
+    const force = args.includes('--force');
+    const { flags, positionals, unknown, notAnId } = parseArgs({ '--format': 'format' }, args.filter((a) => a !== '--force'), [0]);
+    if (unknown) {
+        return refusal(`Unknown flag: ${unknown}\n`);
+    }
+    if (notAnId)
+        return refusal(notAnId);
+    if (positionals.length !== 2) {
+        return refusal('Usage: lattris update recording transcript <id> <file> [--force]\n');
+    }
+    const [id, file] = positionals;
+    const format = flags.format ?? (file.toLowerCase().endsWith('.json') ? 'json' : 'a');
+    const convert = TRANSCRIPT_CONVERTERS[format];
+    if (convert === undefined) {
+        return refusal(`Unknown --format: ${format}. Accepted: ${RECORDING_FORMATS.join(', ')}.\n`);
+    }
+    let transcript;
+    try {
+        transcript = convert(io.store.files.readFileSync(file, 'utf8'));
+    }
+    catch (e) {
+        return refusal(`Could not read or parse ${file} as --format ${format}: ${e instanceof Error ? e.message : 'invalid'}\n`);
+    }
+    const accessToken = await signedIn(io, cfg);
+    if (typeof accessToken !== 'string')
+        return accessToken;
+    const result = await io.api(accessToken, `${cfg.apiUrl}/memories/${encodeURIComponent(id)}/transcript`, {
+        method: 'PUT',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(force ? { transcript, force: true } : { transcript })
+    });
+    if (!result.ok)
+        return refusalOf(result, ambiguousText(result.body));
+    emit(io, result.data, result.rawText, (r) => `Updated transcript.\n\n${formatRecording(r)}`);
+};
+export const buildSpeakerCorrection = (value) => {
+    if (value === 'me')
+        return { me: true };
+    if (value === 'clear' || value === 'none')
+        return { contactId: null };
+    if (/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value))
+        return { contactId: value };
+    return null;
+};
+const updateRecordingSpeakers = async (cfg, io, args) => {
+    const { positionals, unknown, notAnId } = parseArgs({}, args, [0]);
+    if (unknown) {
+        return refusal(`Unknown flag: ${unknown}\n`);
+    }
+    if (notAnId)
+        return refusal(notAnId);
+    if (positionals.length < 2) {
+        return refusal('Usage: lattris update recording speakers <id> <key>=me|<contact-id>|clear [<key>=… …]\n');
+    }
+    const [id, ...pairs] = positionals;
+    const speakers = {};
+    for (const pair of pairs) {
+        const eq = pair.indexOf('=');
+        if (eq <= 0) {
+            return refusal(`Each correction is <key>=<value>: ${pair}\n`);
+        }
+        const key = pair.slice(0, eq);
+        if (Object.prototype.hasOwnProperty.call(speakers, key)) {
+            return refusal(`speaker "${key}" given twice — one correction per speaker per call.\n`);
+        }
+        const correction = buildSpeakerCorrection(pair.slice(eq + 1));
+        if (correction === null) {
+            return refusal(`${key}: a correction is me, a contact id (full UUID), or clear — not "${pair.slice(eq + 1)}".\n`);
+        }
+        speakers[key] = correction;
+    }
+    const accessToken = await signedIn(io, cfg);
+    if (typeof accessToken !== 'string')
+        return accessToken;
+    const result = await io.api(accessToken, `${cfg.apiUrl}/memories/${encodeURIComponent(id)}/speakers`, {
+        method: 'PUT',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ speakers })
+    });
+    if (!result.ok)
+        return refusalOf(result, ambiguousText(result.body));
+    emit(io, result.data, result.rawText, (r) => `Updated speakers.\n\n${formatRecording(r)}`);
+};
+export const updateRecording = async (cfg, io, rest) => {
+    const sub = rest[0];
+    if (sub === 'transcript') {
+        return updateRecordingTranscript(cfg, io, rest.slice(1));
+    }
+    if (sub === 'speakers') {
+        return updateRecordingSpeakers(cfg, io, rest.slice(1));
+    }
+    io.stdout.write(`${RECORDING_UPDATE_HELP}\n`);
+    if (sub !== undefined)
+        return refusal('', EXIT.USAGE);
+};
+//# sourceMappingURL=recording-update.js.map