lattris 0.1.3 → 0.2.0

package/dist/nouns/contact.js

@@ -0,0 +1,142 @@
+import { formatContact } from "../render/rows.js";
+import { verbsOf } from "./form.js";
+const CONTACT_HELP = [
+    'contact — the people and AIs you work with. A contact is yours alone: it',
+    'names someone so a block can say whose expression it is, and an AI role',
+    'so its contact can point at its page.',
+    '',
+    'Usage:',
+    '  lattris contact add --name "<v>" [--email <v>] [--ai]',
+    '                                              record a person by name; --email keeps',
+    '                                              their address as your own note',
+    '  lattris contact create "<name>" [--ai] [--email <v>]',
+    '                                              the same, with the name first',
+    '  lattris contact list                        every contact of yours, as the API sends them',
+    '  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',
+    '                                              it at a block of yours (an AI role at its page)',
+    '',
+    '  --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',
+    '  --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.',
+    '',
+    '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.'
+].join('\n');
+const CONTACT_UPDATE_USAGE = 'Usage: lattris contact update <id> [--name "<v>"] [--email <v> | --clear-email] [--ai | --person] [--root <block-id>]';
+const contactRow = (c) => formatContact(c);
+export const contacts = {
+    name: 'contacts',
+    words: { singular: 'contact', plural: 'contacts' },
+    grammar: 'noun-first',
+    help: CONTACT_HELP,
+    helpBeforeAuth: true,
+    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' },
+            switches: ['--ai'],
+            positionals: 0,
+            requiredFlags: ['name'],
+            request: {
+                method: 'POST',
+                path: '/contacts',
+                body: {
+                    displayName: { flag: 'name' },
+                    type: { switch: '--ai', value: 'ai' },
+                    email: { flag: 'email' }
+                }
+            },
+            render: (c) => `Recorded contact ${contactRow(c)}`
+        },
+        create: {
+            usage: 'Usage: lattris contact create "<name>" [--ai] [--email <v>]',
+            flags: { '--email': 'email' },
+            switches: ['--ai'],
+            positionals: 1,
+            request: {
+                method: 'POST',
+                path: '/contacts',
+                body: {
+                    displayName: { positional: 0 },
+                    type: { switch: '--ai', value: 'ai' },
+                    email: { flag: 'email' }
+                }
+            },
+            render: (c) => `Recorded contact ${contactRow(c)}`
+        },
+        list: {
+            usage: 'Usage: lattris contact list',
+            positionals: 0,
+            unknownFlagIsUsage: true,
+            request: { method: 'GET', path: '/contacts' },
+            render: (list) => list.length === 0
+                ? 'No contacts yet. `lattris contact create "<name>"` records one.'
+                : list.map(formatContact).join('\n')
+        },
+        get: {
+            usage: 'Usage: lattris contact get <id>',
+            idPositionals: [0],
+            positionals: 1,
+            unknownFlagIsUsage: true,
+            request: { method: 'GET', path: '/contacts' },
+            pickFromList: {
+                none: 'No contact {typed} among yours. {hint:contact list} shows them.\n',
+                ambiguous: '{typed} is ambiguous among your contacts:\n{matches}\n'
+            },
+            render: contactRow
+        },
+        update: {
+            usage: CONTACT_UPDATE_USAGE,
+            flags: { '--name': 'name', '--root': 'root', '--email': 'email' },
+            switches: ['--ai', '--person', '--clear-email'],
+            positionals: 1,
+            uuidPositionals: [0],
+            idPositionals: [0],
+            contradictions: [
+                {
+                    a: '--ai',
+                    b: '--person',
+                    message: '--ai and --person contradict each other; pass one.\n'
+                },
+                {
+                    a: '--clear-email',
+                    b: 'email',
+                    message: '--email and --clear-email contradict each other; pass one.\n'
+                }
+            ],
+            uuidFlags: [
+                {
+                    key: 'root',
+                    message: '--root takes the full id of one of your own blocks, never a prefix: {value}\n'
+                }
+            ],
+            request: {
+                method: 'PATCH',
+                path: '/contacts/{p0}',
+                body: {
+                    type: [
+                        { switch: '--ai', value: 'ai' },
+                        { switch: '--person', value: 'person' }
+                    ],
+                    rootBlockId: { flag: 'root' },
+                    displayName: { flag: 'name' },
+                    email: [{ flag: 'email' }, { switch: '--clear-email', value: null }]
+                },
+                emptyBodyMessage: `Nothing to update: pass --name, --email, --clear-email, --ai, --person or --root.\n${CONTACT_UPDATE_USAGE}\n`
+            },
+            render: (c) => `Updated contact ${contactRow(c)}`
+        }
+    })
+};
+//# sourceMappingURL=contact.js.map

package/dist/nouns/datasets.js

@@ -0,0 +1,109 @@
+import { formatCatalogue, formatDescription, formatRow } from "../render/datasets.js";
+import { sanitizeForTerminal } from "../render/text.js";
+export const GET_DATASETS_HELP = [
+    'get — read your datasets: what the API keeps, and your rows in it.',
+    '',
+    'Usage:',
+    '  lattris get datasets                  every dataset the API takes, whether you hold',
+    '                                        rows there, and their earliest and latest time',
+    '  lattris get dataset <name>            one dataset: its identity, its filters, each',
+    '                                        field with its type and bounds, an example line',
+    '  lattris get rows <name> [field=value …] [--from <time>] [--to <time>] [--limit <n>] [--cursor <token>]',
+    '                                        one page of your rows, in the dataset’s own order',
+    '  lattris get row <name> <id>           one row, by its id',
+    '',
+    '  field=value       a filter, sent as typed, split at the first =. The dataset',
+    '                    names its filters (get dataset <name>); the API refuses a',
+    '                    missing, unknown or doubled one, or a bad value, and names',
+    '                    what it takes. A word with no = is refused here.',
+    '  --from <time>     the page starts at this time; --to <time> ends it',
+    '  --limit <n>       rows a page; the dataset names its default and its maximum',
+    '  --cursor <token>  the nextCursor of the page before. At a terminal, a page with',
+    '                    more after it prints the command that reads the next one.',
+    '',
+    'On a pipe each answer is the API’s JSON, byte for byte. At a terminal: one line',
+    'per dataset, the description labelled, one row per line, a row one field per line.',
+    '',
+    'The API owns every name, filter and field; the CLI keeps no list of them.',
+    'To save rows: lattris capture rows <name>. To remove one: lattris delete row <name> <id>.'
+].join('\n');
+export const DELETE_ROW_HELP = [
+    'delete row — remove one row of a dataset, permanently.',
+    '',
+    'Usage:',
+    '  lattris delete row <name> <id> [--yes]',
+    '',
+    'A row has no deleted items and no history: the delete cannot be undone.',
+    '',
+    '  --yes   required when not at a terminal (there is no prompt to answer',
+    '          there); at a terminal you are always asked.',
+    '',
+    'A row that other rows still reference is refused, and the refusal names the',
+    'datasets that hold them: delete those first, or keep it.',
+    '',
+    'Alias: remove → delete'
+].join('\n');
+const NAME_AND_ID = [0, 1];
+export const datasets = {
+    name: 'datasets',
+    words: { singular: 'dataset', plural: 'datasets' },
+    help: GET_DATASETS_HELP,
+    verbs: [
+        {
+            verb: 'get',
+            nouns: ['datasets'],
+            form: {
+                usage: 'Usage: lattris get datasets',
+                positionals: 0,
+                request: { method: 'GET', path: '/datasets' },
+                render: (entries) => formatCatalogue(entries)
+            }
+        },
+        {
+            verb: 'get',
+            nouns: ['dataset'],
+            form: {
+                usage: 'Usage: lattris get dataset <name>',
+                positionals: 1,
+                idPositionals: [0],
+                request: { method: 'GET', path: '/datasets/{p0}' },
+                render: (description) => formatDescription(description)
+            }
+        },
+        {
+            verb: 'get',
+            nouns: ['row'],
+            form: {
+                usage: 'Usage: lattris get row <name> <id>',
+                positionals: 2,
+                idPositionals: NAME_AND_ID,
+                request: { method: 'GET', path: '/datasets/{p0}/rows/{p1}' },
+                render: (row) => formatRow(row)
+            }
+        },
+        {
+            verb: 'delete',
+            nouns: ['row'],
+            form: {
+                usage: 'Usage: lattris delete row <name> <id> [--yes]',
+                switches: ['--yes'],
+                positionals: 2,
+                idPositionals: NAME_AND_ID,
+                steps: {
+                    pipedNeedsYes: {
+                        message: 'Refusing to permanently delete without confirmation on a non-interactive session. Pass --yes to skip the prompt.\n'
+                    },
+                    confirm: {
+                        question: 'Delete row {p1} of {p0} permanently? [y/N] ',
+                        onNo: { text: 'Cancelled.\n', to: 'stderr' },
+                        onInterrupted: { text: 'Cancelled.\n', exit: 1 }
+                    }
+                },
+                request: { method: 'DELETE', path: '/datasets/{p0}/rows/{p1}' },
+                renderTo: 'stderr',
+                render: (_answer, context) => `Deleted row ${sanitizeForTerminal(context.positionals[1])} of ${sanitizeForTerminal(context.positionals[0])}`
+            }
+        }
+    ]
+};
+//# sourceMappingURL=datasets.js.map

package/dist/nouns/edges.js

@@ -0,0 +1,106 @@
+import { formatAmendedEdge, formatEdgeReceipt } from "../render/rows.js";
+import { sanitizeForTerminal } from "../render/text.js";
+const LINK_HELP = [
+    'link — state that one memory leads to another.',
+    '',
+    'An edge is a directed claim: FROM leads to TO, under a verb the server’s',
+    'registry owns. The reason is written to the FUTURE WALKER — when is this',
+    'edge worth following («read this next if …») — routing guidance, never a',
+    'restatement of the relationship. Every edge states why it exists, so',
+    '--reason is required: there is no default and the CLI will never invent',
+    'one.',
+    '',
+    'One family, three verbs:',
+    '',
+    '  lattris link <from> <to> --verb <verb> --reason "..."     create the edge',
+    '  lattris unlink <from> <to> --verb <verb>                  remove it',
+    '  lattris update edge <from> --verb <verb> --to <to> --reason "..."',
+    '                                            rewrite the reason (see update)',
+    '',
+    '  <from>     the cause-side block — full id or a >=4-char prefix; an',
+    '             ambiguous prefix refuses and lists the matches',
+    '  <to>       the effect-side block — the FULL id (the wire addresses the',
+    '             edge by it; it does not search)',
+    '  --verb     required; the server’s registry is the ONE authority on the',
+    '             vocabulary — an unknown verb refuses WITH the accepted set',
+    '             for the exact pair sent, and the CLI carries no copy',
+    '  --reason   link only; required, one line — why this edge exists',
+    '',
+    'unlink states WHICH edge (from, verb, to), never why — it takes no',
+    '--reason. Deleting an edge deletes the claim; the blocks stay.',
+    '',
+    'linked → prints the edge as written. unlinked → confirms the identity.'
+].join('\n');
+const TO_MESSAGE = '<to> must be the FULL block id (the wire addresses the edge by it; it does not search): {value}\n';
+const linkVerb = {
+    verb: 'link',
+    form: {
+        usage: 'Usage: lattris link <from> <to> --verb <verb> --reason "..."',
+        flags: { '--verb': 'verb', '--reason': 'reason' },
+        positionals: 2,
+        idPositionals: [0],
+        requiredFlags: ['verb', 'reason'],
+        missingFlagsMessage: true,
+        uuidPositionalMessages: [{ index: 1, message: TO_MESSAGE }],
+        request: {
+            method: 'POST',
+            path: '/memories/{p0}/edges',
+            body: { verb: { flag: 'verb' }, toBlockId: { positional: 1 }, reason: { flag: 'reason' } }
+        },
+        ambiguousRefusal: true,
+        render: (e) => formatEdgeReceipt('Linked.', e)
+    }
+};
+const unlinkVerb = {
+    verb: 'unlink',
+    form: {
+        usage: 'Usage: lattris unlink <from> <to> --verb <verb>',
+        flags: { '--verb': 'verb' },
+        positionals: 2,
+        idPositionals: [0],
+        requiredFlags: ['verb'],
+        missingFlagsMessage: true,
+        uuidPositionalMessages: [{ index: 1, message: TO_MESSAGE }],
+        request: {
+            method: 'DELETE',
+            path: '/memories/{p0}/edges',
+            body: { verb: { flag: 'verb' }, toBlockId: { positional: 1 } }
+        },
+        ambiguousRefusal: true,
+        renderAlways: true,
+        render: (_e, typed) => `Unlinked.  (verb: ${sanitizeForTerminal(typed.flags.verb ?? '')})\n  from    ${typed.positionals[0]}\n  to      ${typed.positionals[1]}`
+    }
+};
+const updateEdge = {
+    verb: 'update',
+    nouns: ['edge', 'edges'],
+    form: {
+        usage: 'Usage: lattris update edge <id> --verb <verb> --to <id> --reason "..."',
+        idPositionals: [0],
+        flags: { '--verb': 'verb', '--to': 'to', '--reason': 'reason' },
+        positionals: 1,
+        requiredFlags: ['verb', 'to', 'reason'],
+        missingFlagsMessage: true,
+        uuidFlags: [
+            {
+                key: 'to',
+                message: '--to must be the FULL block id from the edge as read (never a prefix): {value}\n'
+            }
+        ],
+        request: {
+            method: 'PATCH',
+            path: '/memories/{p0}/edges',
+            body: { verb: { flag: 'verb' }, toBlockId: { flag: 'to' }, reason: { flag: 'reason' } }
+        },
+        ambiguousRefusal: true,
+        render: (e) => formatAmendedEdge(e)
+    }
+};
+export { LINK_HELP };
+export const edges = {
+    name: 'edges',
+    words: { singular: 'edge', plural: 'edges' },
+    help: LINK_HELP,
+    verbs: [linkVerb, unlinkVerb, updateEdge]
+};
+//# sourceMappingURL=edges.js.map

package/dist/nouns/form.js

@@ -0,0 +1,2 @@
+export const verbsOf = (forms) => Object.entries(forms).map(([verb, form]) => ({ verb, form }));
+//# sourceMappingURL=form.js.map

package/dist/nouns/index.js

@@ -0,0 +1,34 @@
+export { verbsOf } from "./form.js";
+export { audiencesOf } from "./share.js";
+import { contacts } from "./contact.js";
+import { CONSENT_HELP } from "./consent.js";
+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";
+export const listNouns = [contacts, questions, edges, invites, grants, datasets];
+export const listVerbs = {
+    ask: { help: ASK_HELP, helpBeforeAuth: true },
+    close: {
+        help: CLOSE_HELP,
+        helpBeforeAuth: true,
+        bareIsHelp: true,
+        badNoun: { stderr: `${CLOSE_USAGE}\n` }
+    },
+    link: { help: LINK_HELP, helpBeforeAuth: true, bareIsHelp: true },
+    unlink: { help: LINK_HELP, helpBeforeAuth: true, bareIsHelp: true },
+    invite: { help: INVITE_HELP },
+    consent: { help: CONSENT_HELP, helpBeforeAuth: true },
+    share: {
+        help: SHARE_HELP,
+        bareIsHelp: true,
+        badNoun: { stderr: 'Usage: lattris share memory <id> --with <audience> [--yes]\n' }
+    },
+    unshare: {
+        help: UNSHARE_HELP,
+        bareIsHelp: true,
+        badNoun: { stderr: 'Usage: lattris unshare memory <id> [--with <audience>]\n' }
+    }
+};
+//# sourceMappingURL=index.js.map

package/dist/nouns/invite.js

@@ -0,0 +1,98 @@
+import { formatContact } from "../render/rows.js";
+import { sanitizeForTerminal } from "../render/text.js";
+const inviteLink = (webUrl, token) => `${webUrl}/i/${token}`;
+const formatInvite = (webUrl, i) => {
+    const label = i.targetName ? ` — ${sanitizeForTerminal(i.targetName)}` : '';
+    if (i.redeemedAt) {
+        const who = i.redeemedBy
+            ? `${sanitizeForTerminal(i.redeemedBy.displayName ?? i.redeemedBy.handle)} (${sanitizeForTerminal(i.redeemedBy.handle)})`
+            : 'someone';
+        return `taken${label}\n  by ${who} on ${i.redeemedAt}`;
+    }
+    if (i.revokedAt)
+        return `revoked${label}\n  minted ${i.createdAt}`;
+    return `live${label}\n  ${inviteLink(webUrl, i.token)}\n  minted ${i.createdAt}`;
+};
+const INVITE_HELP = [
+    'invite — bring one person in.',
+    '',
+    'Mints a single-use invitation and prints the link. Hand it to ONE person.',
+    'It is spent when someone signs up with it.',
+    '',
+    'AN INVITATION IS NOT PERMISSION. It records who brought someone. Whether an',
+    'address may register at all is a separate decision, made by hand — so a',
+    'person can hold a good invitation and still be turned away. Tell them that',
+    'when you send it.',
+    '',
+    'Usage:',
+    '  lattris invite <contact-name-or-id> [--yes]',
+    '  lattris invite --for <name-or-id> [--yes]   compatibility spelling',
+    '',
+    'The contact must be one of yours. A name is matched exactly, ignoring case.',
+    'If that name does not exist, a person contact is created before minting.',
+    'Duplicate names are never guessed: use the contact id shown by',
+    '`lattris contact list`.',
+    '',
+    '  --yes   required when not at a terminal (there is no prompt to answer',
+    '          there); at a terminal you are always asked.',
+    '',
+    'To see the ones you have out: lattris get invites'
+].join('\n');
+const inviteVerb = {
+    verb: 'invite',
+    form: {
+        usage: INVITE_HELP,
+        flags: { '--for': 'for' },
+        switches: ['--yes'],
+        positionals: 0,
+        positionalsAtMost: 1,
+        contradictions: [{ a: 'p0', b: 'for', message: `${INVITE_HELP}\n` }],
+        steps: {
+            contact: {
+                from: ['p0', 'flag:for'],
+                required: 'A contact name or id is required.\n',
+                mustBePerson: '{name} is an AI contact. An invitation must go to a person contact.\n',
+                createIfMissing: true
+            },
+            pipedNeedsYes: {
+                message: 'Refusing to mint without confirmation. Pass --yes once the person has asked you to invite someone.\n'
+            },
+            confirm: {
+                question: 'Mint an invitation for {name}? [y/N] ',
+                whenMissing: 'Create person contact "{name}" and mint their invitation? [y/N] ',
+                onNo: { text: 'Not minted.\n', to: 'stdout' }
+            }
+        },
+        request: { method: 'POST', path: '/invites', body: { contactId: { context: 'contact.id' } } },
+        render: (data, context) => {
+            const i = data;
+            const contact = context.contact;
+            return (`${context.createdContact ? `Recorded person contact ${formatContact(contact)}.\n\n` : ''}` +
+                `Invitation minted${i.targetName ? ` for ${i.targetName}` : ''}.\n\n` +
+                `  ${inviteLink(context.webUrl, i.token)}\n\n` +
+                `Hand it to ONE person — it is spent when someone signs up with it.\n` +
+                `It is not permission to join; whether they may register is decided separately.\n` +
+                `You can see it again with: lattris get invites`);
+        }
+    }
+};
+const getInvites = {
+    verb: 'get',
+    nouns: ['invite', 'invites'],
+    form: {
+        usage: 'Usage: lattris get invites',
+        positionals: 0,
+        request: { method: 'GET', path: '/invites' },
+        render: (list, context) => list.length === 0
+            ? 'No invitations yet. `lattris invite <contact>` mints one.'
+            : list.map((i) => formatInvite(context.webUrl, i)).join('\n\n')
+    }
+};
+export { INVITE_HELP };
+export const invites = {
+    name: 'invites',
+    words: { singular: 'invite', plural: 'invites' },
+    help: INVITE_HELP,
+    verbs: [inviteVerb, getInvites]
+};
+//# sourceMappingURL=invite.js.map

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