@prestack/thread 0.0.3 → 0.1.1

package/dist/core/{asking.js → answers.js}

@@ -1,22 +1,10 @@
-var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
-    if (typeof path === "string" && /^\.\.?\//.test(path)) {
-        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
-            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
-        });
-    }
-    return path;
-};
-import { createHash, randomBytes } from 'node:crypto';
-import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { dirname, join, relative } from 'node:path';
-import { argv, env, exit, stderr, stdin, stdout } from 'node:process';
+import { createHash } from 'node:crypto';
+import { existsSync, readFileSync, writeFileSync } from "./files.js";
+import { join, relative } from 'node:path';
+import { argv, exit, stderr, stdin, stdout } from 'node:process';
 import { createInterface } from 'node:readline';
-import { pathToFileURL } from 'node:url';
-import { CONSTRAINTS } from "../integrity/constraint.js";
-import { LISTS, descend, listFields, listShape, shapeFields, shapesNamed } from "./descend.js";
-import { quoted } from "./rows.js";
-const RECEIPTS = join(tmpdir(), 'thread-create');
+import { LISTS, listFields, listShape, shapesNamed } from "./descend.js";
+import { quoted, valuesIn } from "./rows.js";
 export const RECEIPT = '--receipt';
 export const ENDS = '.';
 export const FROM = '--from';
@@ -100,66 +88,6 @@ export function scoped(given, opens) {
     return { own, each };
 }
 const locate = (one) => one.at > 0 ? `line ${String(one.at)}` : `\`--${one.key}\``;
-let meanings;
-function coined(word) {
-    if (meanings === undefined) {
-        const found = new Map();
-        try {
-            for (const [id, held] of descend().coined) {
-                const first = held.said[0];
-                if (first !== undefined && first !== '')
-                    found.set(id, first);
-            }
-        }
-        catch {
-            found.clear();
-        }
-        meanings = found;
-    }
-    return meanings.get(word);
-}
-export function asksOf(noun, shape, said, computed) {
-    const fields = typeof shape === 'string' ? shapeFields(shape).map((one) => ({ ...one, boolean: false })) : shape;
-    if (fields.length === 0) {
-        refuse(`nothing installed here states what a ${noun} is made of, so \`thread create ${noun}\` has no questions to ` +
-            `ask. It reads that from the shape a ${noun} is declared with rather than from a list kept beside it. ` +
-            'Run `npx thread attach` to see whether the package that states it is taken on.');
-    }
-    const spoken = { ...said };
-    for (const one of fields) {
-        if (spoken[one.name] !== undefined || computed.includes(one.name))
-            continue;
-        const meaning = coined(one.name) ?? (one.guide === '' ? undefined : one.guide);
-        if (meaning === undefined)
-            continue;
-        spoken[one.name] = { guide: meaning };
-    }
-    const mute = fields
-        .filter((one) => one.required && !computed.includes(one.name) && spoken[one.name] === undefined)
-        .map((one) => one.name);
-    if (mute.length > 0) {
-        const one = mute.length === 1;
-        refuse(`every ${noun} states ${mute.join(', ')}, and \`thread create ${noun}\` never asks for ${one ? 'it' : 'them'}. ` +
-            `It would write a ${noun} with no ${mute.join(' and no ')}, and tell you it worked. ` +
-            `Give ${one ? 'it' : 'each'} a sentence where this command lists what it asks, or name ${one ? 'it' : 'them'} ` +
-            'as something the command fills in.');
-    }
-    return Object.keys(spoken).map((one) => {
-        const told = spoken[one];
-        const known = fields.find((each) => each.name === one);
-        const spare = told.optional ?? (known !== undefined && !known.required);
-        return {
-            at: one,
-            guide: known?.boolean === true ? `${told.guide} — yes or no` : told.guide,
-            ...(told.asks === undefined ? {} : { asks: told.asks }),
-            ...(spare ? { optional: true } : {}),
-            ...(known?.list === true ? { list: true } : {}),
-            ...(known?.map === true ? { map: true } : {}),
-            ...(known?.boolean === true ? { boolean: true } : {}),
-            ...(known?.worded === true ? { worded: true } : {}),
-        };
-    });
-}
 export const named = (all) => all.map((one) => one.at);
 export const prompted = (one) => one.asks ?? `${one.at} — ${one.guide}${one.optional === true ? ', or blank' : ''}: `;
 export const mapped = (one, said) => one.map === true && !(one.worded === true && !said.includes('='));
@@ -364,7 +292,6 @@ export function seeding(kids, root) {
                     `\`${TYPED} read ${one.at}\` prints what is there.`);
                 continue;
             }
-            mkdirSync(dirname(into), { recursive: true });
             writeFileSync(into, one.body.endsWith('\n') ? one.body : `${one.body}\n`, 'utf8');
             said.push(`wrote ${one.at} with the body you gave it.`);
         }
@@ -457,16 +384,11 @@ export async function bodied(what, shows, piped, all, line) {
     const written = held.join('\n').trim();
     return written === '' ? undefined : written;
 }
-export function guidance(all) {
-    const width = Math.max(...all.map((one) => one.at.length)) + 3;
-    const under = ' '.repeat(width + 2);
-    return all.flatMap((one) => {
-        const lines = wrapped(one.optional === true ? `${one.guide.replace(/\.$/, '')}. Leave it blank and it is not stated` : one.guide, '');
-        return [`  ${`${one.at}:`.padEnd(width)}${lines[0] ?? ''}`, ...lines.slice(1).map((each) => `${under}${each}`)];
-    });
-}
 export function only(given, allowed, where) {
-    for (const one of ownAnswers(given)) {
+    unasked(ownAnswers(given), allowed, where);
+}
+export function unasked(given, allowed, where) {
+    for (const one of given) {
         if (CARRIES.includes(one.key) || one.key === WRITES)
             continue;
         if (allowed.includes(one.key))
@@ -517,7 +439,6 @@ export function marked(parts) {
 const citesOf = (held) => Array.isArray(held)
     ? held.filter((one) => one !== null && typeof one === 'object' && typeof one.on === 'string' && typeof one.said === 'string')
     : [];
-const HELD = ['holds', 'declares'];
 const NAMED_SHAPE = /^[A-Za-z_][A-Za-z0-9_]*$/;
 const rowLike = (one) => one !== null && typeof one === 'object' && typeof one.id === 'string' && typeof one.describes === 'string';
 const kinded = (shape) => shape
@@ -567,7 +488,7 @@ export async function declared(tree) {
         walked.add(at);
         let read;
         try {
-            read = (await import(__rewriteRelativeImportExtension(pathToFileURL(join(tree.at, at)).href)));
+            read = valuesIn(readFileSync(join(tree.at, at)));
         }
         catch {
             return;
@@ -576,7 +497,7 @@ export async function declared(tree) {
             const node = value;
             const lists = Array.isArray(value)
                 ? [{ list: name, rows: value }]
-                : HELD.flatMap((list) => {
+                : ['holds', 'declares'].flatMap((list) => {
                     const rows = node?.[list];
                     return Array.isArray(rows) ? [{ list, rows }] : [];
                 });
@@ -673,68 +594,6 @@ export function nouns(all, verb = 'create') {
     }
     return found;
 }
-const spends = (root, nonce) => join(RECEIPTS, `${createHash('sha256').update(root).digest('hex').slice(0, 16)}-${nonce}.txt`);
-const stamp = (listing) => createHash('sha256').update(listing).digest('hex').slice(0, 12);
-function beingMade() {
-    const words = argv.slice(2).filter((one) => !one.startsWith('-'));
-    if (words[0] === 'create' && typeof words[1] === 'string' && words[1] !== '')
-        return words[1];
-    const file = (argv[1] ?? '').split('\\').join('/').split('/').at(-1) ?? '';
-    return file.replace(/\.[^.]+$/, '');
-}
-export const SKILLS_AT = 'thread/knowledge';
-export function skillOf(noun) {
-    return `${SKILLS_AT}/${noun}.md`;
-}
-function readTheSkill() {
-    const noun = env.THREAD_NOUN ?? beingMade();
-    if (noun === '')
-        return [];
-    return [
-        '',
-        `READ ${skillOf(noun)} BEFORE YOU WRITE ANYTHING. It is this command's own output, kept as a`,
-        'file, and it lists everything that already exists. Building a second copy of something the tree',
-        'already has is the most expensive mistake available here and it has already been made: thirteen',
-        'elements were declared in one app that every one of them already shipped.',
-        '',
-        'If that file is not there, run `npx thread skills` and it will be.',
-    ];
-}
-export function issue(root, listing) {
-    const nonce = randomBytes(6).toString('hex');
-    mkdirSync(RECEIPTS, { recursive: true });
-    writeFileSync(spends(root, nonce), `${stamp(listing)}\n`, 'utf8');
-    const said = readTheSkill();
-    if (said.length > 0)
-        stdout.write(`${said.join('\n')}\n`);
-    return nonce;
-}
-export function spend(root, listing, offered, sheet) {
-    if (offered === undefined || offered.startsWith('-')) {
-        refuse(`\`${RECEIPT}\` was handed nothing to check. Run \`thread create\` with no arguments — it lists what is ` +
-            'here and issues a receipt to hand back.');
-    }
-    const path = spends(root, offered);
-    if (!existsSync(path)) {
-        refuse(`\`${offered}\` is not a receipt this tree issued, or it has been spent already — one run per receipt. ` +
-            'Run `thread create` again and use the one it prints.');
-    }
-    let when = '';
-    try {
-        when = readFileSync(path, 'utf8').trim();
-    }
-    catch {
-        when = '';
-    }
-    process.on('exit', (code) => {
-        if (code === 0)
-            rmSync(path, { force: true });
-    });
-    if (when !== stamp(listing)) {
-        refuse(`${sheet} has changed since that receipt was issued, so what you read is not what is here. ` +
-            'Run `thread create` again.');
-    }
-}
 export function asking(held) {
     const piped = answered();
     const rl = piped ? undefined : createInterface({ input: stdin, output: stdout });
@@ -848,191 +707,13 @@ export function handed() {
     }
     return stood;
 }
-export const TYPED = 'npx thread';
-const folded = (said, pad, room = 92) => {
-    const out = [];
-    let line = '';
-    for (const word of said.split(/\s+/)) {
-        if (line === '')
-            line = word;
-        else if (`${line} ${word}`.length <= room)
-            line = `${line} ${word}`;
-        else {
-            out.push(line);
-            line = word;
-        }
-    }
-    if (line !== '')
-        out.push(line);
-    return out.map((one) => `${pad}${one}`);
-};
-const parented = (() => {
-    const one = CONSTRAINTS.find((each) => each.id === 'twice-parented');
-    if (one === undefined) {
-        return [
-            '',
-            'THIS PAGE CANNOT STATE THE RULE. It reads what may declare a file out of the `twice-parented`',
-            'rule, and no rule by that name ships any more. Whatever governs this now, it is not said here —',
-            `\`${TYPED} create rule\` lists every rule that does exist.`,
-        ];
-    }
-    return [
-        '',
-        'which one you pick is a rule rather than a preference, and a check refuses the tree over it:',
-        '',
-        `  ${one.id}`,
-        ...folded(`bans ${one.bans}.`, '    '),
-        ...folded(one.instead.replace(/^./, (each) => each.toUpperCase()), '    '),
-    ];
-})();
-const NEXT = {
-    declares: 'It writes the file from that, and nothing else runs. A file already on disk is left alone and the row simply names it.',
-    derives: `It writes NO file at \`at:\`, because the command in \`by:\` writes that one — which is why there is no ${asFlag(BODY)} here to give. If this tree has no command answering \`by:\`, that generator is declared first and ${asFlag(WRITES)} is what goes in it.`,
-    seeds: `TWO files come out of this and a different hand writes each, which is the whole reason there are two bodies. If this tree has no command answering \`by:\`, that generator is declared here too, so one run leaves the row, the generator and the file.`,
-};
-export const VERBS = [
-    'nothing is in this tree until a row names it, and which of three lists the row sits in says who',
-    'wrote the file. Pick the one that is true and the rest of this framework follows from it:',
-    '',
-    '  declares   a person wrote it. Exactly one row may ever declare an address, and a second is',
-    '             refused: a file with two owners has two answers for where it came from and the tree',
-    '             can give neither.',
-    '  derives    a command wrote it. Delete the file, run the command again, and the same bytes come',
-    '             back. Many rows may derive one address, because a derivation owns nothing — it states',
-    '             `by:`, the command that writes it, and `runs:`, what catches it drifting.',
-    '  seeds      a command wrote the shape and a person fills in the part no machine can supply. Many',
-    '             rows may seed one address as well, and it is proved by shape rather than by bytes,',
-    '             because half of what is on disk is your own writing.',
-    '',
-    `a file in none of them is not in this app at all — \`${TYPED} descent\` names every one it reached`,
-    'and every one it did not, and nothing undeclared is compiled in or shipped.',
-    '',
-    'and the list decides what this command does next, not just what the row says. What it does next is',
-    'ASK FOR BODIES, and there are two of them, which are never the same text and never the same file:',
-    '',
-    `  ${asFlag(BODY).padEnd(10)} the body of the file the row names. A person wrote it.`,
-    `  ${asFlag(WRITES).padEnd(10)} the body of the GENERATOR — the code that writes a template into that file.`,
-    '',
-    'give each as text on the command. Neither may be taken out of a file, because a file is not a',
-    'receipt: nothing here checked it and no descent reached it. Single-quote a body that holds quotes.',
-    '',
-    'so each list takes a different set of them, and giving one where the other belongs is the mistake',
-    'this section exists to stop:',
-    '',
-    ...LISTS.flatMap((list) => {
-        const takes = [
-            ...(WRITTEN.includes(list) ? [asFlag(WRITES)] : []),
-            ...(BODIED.includes(list) ? [asFlag(BODY)] : []),
-        ];
-        const said = folded(`takes ${takes.length === 0 ? 'no body at all' : takes.join(' and ')}. ${NEXT[list] ?? ''}`, '             ');
-        return said.map((line, at) => (at === 0 ? `  ${list.padEnd(11)}${line.trim()}` : line));
-    }),
-    ...parented,
-];
-export const grows = (sheetAt, noun) => {
-    const shaped = noun.split('-').map((one) => `${one.slice(0, 1).toUpperCase()}${one.slice(1)}`).join('');
-    return [
-        `this is also how the CLI grows. A list of rows in ${sheetAt} becomes a command: declare`,
-        `\`export const THINGS: readonly Thing[] = []\` beside what is already there and \`${TYPED} create thing\``,
-        'answers from that moment, asking for whatever a `Thing` states and writing the row into that list.',
-        '',
-        `The same is true of what you have now: \`${TYPED} create ${noun}\` exists because ${sheetAt} declares`,
-        `\`${shaped}\`. Nothing was added to a list of commands anywhere — the CLI reads what your tree says.`,
-    ];
-};
-export const VALUED = 'THREAD_VALUED';
-export function answering(noun) {
-    return [
-        ...(env[VALUED] === '1' ? [] : [...VERBS, '']),
-        'what `new` asks. Give each answer as a flag on one command and close with the receipt:',
-        '',
-        `  ${TYPED} create ${noun} new --<answer> <value> ... ${RECEIPT} <receipt>`,
-        '',
-        'Flags need no terminal, no pipe and no file, so that form works everywhere. The two others',
-        'each need something you may not have: one answer to a line on stdin needs a shell that can',
-        'redirect, and `--answers <path>` needs a way to write the file first. Use them when you have',
-        'them; the line above is the one that never depends on it.',
-        '',
-        'Where a question repeats — a list of things, each with answers of its own — there are no',
-        'separate flag names for the inner ones. Give the group\'s own flag again to begin the next,',
-        'then its answers after it, reusing the same words. They are read in the order you write them,',
-        'and everything before the first group flag belongs to the thing itself.',
-        '',
-        'the answers, in order:',
-    ];
-}
+export const TYPED = 'thread';
 export const CARRIED = [
     { verb: 'read', typed: `${TYPED} read <row>`, does: 'prints every field a row states' },
     { verb: 'edit', typed: `${TYPED} edit <row> --<field> <value>`, does: 'changes any field it was declared with' },
     { verb: 'remove', typed: `${TYPED} edit <row> --remove`, does: 'takes the row out of the tree' },
 ];
 const elsewhere = CARRIED.map((one) => `\`${one.typed}\` ${one.does}`);
-export const ELSEWHERE = [
-    'reading a row, changing one of its answers and taking it out are done in one place, whatever',
-    'declared it \u2014 name the row by its id or by the mark printed beside it above:',
-    '',
-    ...CARRIED.map((one) => `  ${one.typed.padEnd(40)}${one.does}`),
-];
-const opening = (said) => said.split(/(?<=\.)\s/)[0] ?? said;
-const article = (word) => (/^[aeiou]/.test(word) ? 'an' : 'a');
-export function taught(noun, told, commands) {
-    const one = told.get(noun);
-    const opens = [
-        [`${TYPED} read <id>`, 'the row, and the file it names'],
-        [`${TYPED} create ${noun}`, 'this list again, with a fresh receipt'],
-        ...(commands.has('thread inspect')
-            ? [[`${TYPED} inspect <word>`, 'every row whose name or sentence carries the word']]
-            : []),
-    ];
-    const top = one?.top;
-    const siblings = top === undefined
-        ? []
-        : [...told]
-            .filter(([, each]) => each.top?.id === top.id && each.describes !== '')
-            .sort(([left], [right]) => (left < right ? -1 : 1));
-    const pad = Math.max(0, ...siblings.map(([word]) => word.length)) + 3;
-    return [
-        'DO NOT CREATE WHAT ALREADY EXISTS. Everything listed below is declared and yours to use. A thing',
-        'you cannot find is usually one of these under a word you have not met \u2014 read the sentences, not',
-        'the names.',
-        '',
-        'IF NOTHING FITS, SAY SO AND STOP. Do not coin a name: a name is a meaning, and a meaning is',
-        'declared rather than invented. Being told the list is short a thing is a useful answer.',
-        '',
-        'NOW GO AND OPEN ONE. A sentence is a summary, and every expensive mistake here was made from a',
-        'summary. These print the real thing, and none of them writes anything:',
-        '',
-        ...opens.map(([said, does]) => `  ${said.padEnd(30)}${does}`),
-        '',
-        ...(one === undefined || one.describes === ''
-            ? []
-            : [
-                `what ${article(noun)} ${noun} is:`,
-                '',
-                ...wrapped(one.describes, '  '),
-                ...one.cites.flatMap((said) => ['', ...wrapped(`said on ${said.on}: "${said.said}"`, '  ')]),
-                '',
-            ]),
-        ...(top === undefined || siblings.length < 2
-            ? []
-            : [
-                `${top.id} \u2014 ${opening(top.describes)}`,
-                'what it makes, and what each one is. Pick the one that is true before declaring anything:',
-                '',
-                ...siblings.flatMap(([word, each]) => {
-                    const lines = wrapped(opening(each.describes), '');
-                    return [`  ${word.padEnd(pad)}${lines[0] ?? ''}`, ...lines.slice(1).map((line) => `${' '.repeat(pad + 2)}${line}`)];
-                }),
-                '',
-            ]),
-    ];
-}
-export function reminded(noun) {
-    const lists = noun === undefined || noun === 'meta'
-        ? `\`${TYPED} create\` lists what this tree makes, and any noun run bare lists what exists, each with its sentence`
-        : `\`${TYPED} create ${noun}\` lists what exists, each with its sentence`;
-    return `thread: before the next thing, ${lists}. Do not create what already exists, and if nothing fits, say so and stop.`;
-}
 export function wordsIn(offered) {
     const values = new Set([argv[argv.indexOf(RECEIPT) + 1], argv[argv.indexOf(ANSWERS) + 1], ...flagged().map((one) => one.value)]);
     const words = argv.slice(2).filter((one) => !one.startsWith('-') && !values.has(one));