@turri-dev/cli 0.0.0-stage → 0.1.1

package/dist/review/live.js

@@ -0,0 +1,165 @@
+import { ask, BEGIN, createJudge } from "../pi.js";
+import { createVerdictTool } from "../tools.js";
+function livePrompt(opts) {
+    return [
+        "You are a reviewer reading work that is still being written. You did not write it and",
+        "you have no stake in it. Judge what is on disk against the rubric only.",
+        "",
+        "<rubric>",
+        opts.rubric,
+        "</rubric>",
+        "",
+        `<under review>\n${opts.scope}\n</under review>`,
+        "",
+        opts.cleared.length > 0
+            ? `<already cleared>\n${opts.cleared.join("\n")}\n</already cleared>\n\nDo not re-report anything about work listed here unless it has since changed.\n`
+            : "",
+        opts.replies.length > 0
+            ? `<the user has since answered>\n${opts.replies.join("\n")}\n</the user has since answered>\n`
+            : "",
+        "Read the files yourself with the tools you have. Nothing has been pasted in for you.",
+        "",
+        "The work is unfinished by design: later parts of it have not been written yet. Judge",
+        "only what is claimed to be under review. Never report something as missing because it",
+        "has not been reached yet, and never ask for the phase to be finished.",
+        "",
+        "Call submit_verdict exactly once. Every violation must quote the offending text",
+        "verbatim and name one concrete fix. If a violation cannot be settled from the files -",
+        "it needs a decision only the user can make - put that single question in 'question'.",
+    ]
+        .filter((part) => part !== "")
+        .join("\n");
+}
+function defaultJudge(opts) {
+    return async (prompt) => {
+        let captured;
+        const { session } = await createJudge({
+            cwd: opts.cwd,
+            verdictTool: createVerdictTool((v) => {
+                captured = v;
+            }),
+            modelSpec: opts.spec.model ?? opts.defaultModel,
+            borrowAuthFrom: opts.executor,
+            extraTools: opts.spec.judgeTools,
+            task: prompt,
+        });
+        try {
+            await ask(session, BEGIN);
+        }
+        finally {
+            session.dispose();
+        }
+        return captured;
+    };
+}
+export function createLiveReviewer(opts) {
+    const judge = opts.judge ??
+        defaultJudge({
+            cwd: opts.cwd,
+            spec: opts.spec,
+            executor: opts.executor,
+            defaultModel: opts.defaultModel,
+        });
+    const pending = [];
+    const all = [];
+    const questions = [];
+    /** Every question ever asked, so an answer can arrive after it was handed over. */
+    const asked = new Map();
+    const replies = [];
+    const cleared = [];
+    let dirty = null;
+    let running = null;
+    let passes = 0;
+    async function onePass(scope) {
+        passes += 1;
+        const captured = await judge(livePrompt({ rubric: opts.rubric, scope, cleared, replies: [...replies] }));
+        const violations = captured?.verdict === "fail" ? captured.violations : [];
+        for (const v of violations) {
+            const finding = { scope, criterion: v.criterion, evidence: v.evidence, fix: v.fix };
+            pending.push(finding);
+            all.push(finding);
+        }
+        if (violations.length === 0) {
+            cleared.push(scope);
+        }
+        else if (captured?.question) {
+            const question = { id: `q${asked.size + 1}`, scope, question: captured.question };
+            asked.set(question.id, question);
+            questions.push(question);
+        }
+        opts.onPass?.({ scope, findings: violations.length });
+    }
+    /**
+     * One pass at a time, and only one queued behind it. A pass always reads the file as it
+     * is when it starts, so the newest scope supersedes anything queued before it.
+     */
+    function pump() {
+        if (running !== null || dirty === null)
+            return;
+        const scope = dirty;
+        dirty = null;
+        running = onePass(scope)
+            // A reviewer that fell over must not take the interview down with it. The phase gate
+            // still runs its own judges at the end, so nothing is silently skipped.
+            .catch(() => { })
+            .then(() => {
+            running = null;
+            pump();
+        });
+    }
+    return {
+        notice(scope) {
+            dirty = scope;
+            pump();
+        },
+        take() {
+            return pending.splice(0, pending.length);
+        },
+        takeQuestions() {
+            return questions.splice(0, questions.length);
+        },
+        reply(questionId, answer) {
+            const question = asked.get(questionId);
+            if (question === undefined)
+                return false;
+            replies.push(`${question.question} -> ${answer}`);
+            return true;
+        },
+        async settle() {
+            while (running !== null || dirty !== null) {
+                if (running !== null)
+                    await running;
+                pump();
+            }
+            const findings = [...pending];
+            return { clean: findings.length === 0, findings };
+        },
+        history() {
+            return [...all];
+        },
+        passes() {
+            return passes;
+        },
+    };
+}
+export function describeFindings(findings) {
+    const lines = findings.map((f) => `- [${f.scope}] ${f.criterion}: ${f.evidence} -> ${f.fix}`);
+    return [
+        `The reviewer reading along behind you found ${findings.length === 1 ? "something" : `${findings.length} things`}:`,
+        ...lines,
+        "",
+        "Fix the specification now, before the next question, and re-queue anything already built " +
+            "from it with regenerate: true. Do not argue with the review and do not write a reply - " +
+            "edit the spec.",
+    ].join("\n");
+}
+export function describeQuestions(questions) {
+    const lines = questions.map((q) => `- (${q.id}) ${q.question}`);
+    return [
+        "The reviewer needs the user to settle something it cannot decide from the specs:",
+        ...lines,
+        "",
+        "Ask the user this with ask_user at your next turn, say it comes from the review, then " +
+            "write the answer to disk and pass it back with reply_to_review.",
+    ].join("\n");
+}

package/dist/rules.js

@@ -0,0 +1,47 @@
+import { readFileSync, readdirSync } from "node:fs";
+import { basename, join } from "node:path";
+import { stdlibCatalogue } from "./stdlib.js";
+/**
+ * The ***plain authoring rules.
+ *
+ * These are loaded in full into every session's system prompt. They are large - around
+ * 40k tokens - and that is the deliberate trade: a rule the model has to decide to go and
+ * read is a rule it can skip, and these govern every spec this project writes.
+ */
+export function loadRules(rulesDir, off = []) {
+    let entries;
+    try {
+        // A project's config.turri.yaml can leave rules out (rules-off): by name, with or without .md.
+        const left = new Set(off.map((name) => name.replace(/\.md$/, "")));
+        entries = readdirSync(rulesDir).filter((entry) => entry.endsWith(".md") && !left.has(basename(entry, ".md"))).sort();
+    }
+    catch {
+        return [];
+    }
+    return entries.map((entry) => {
+        const name = basename(entry, ".md");
+        const content = readFileSync(join(rulesDir, entry), "utf8").trim();
+        // The standard library's rule carries what is in it, read from the templates themselves.
+        return { name, content: name === "stdlib" ? [content, stdlibCatalogue()].filter(Boolean).join("\n\n") : content };
+    });
+}
+/** The block appended to the system prompt. Identical every turn, so it stays cacheable. */
+export function renderRulesBlock(rules) {
+    if (rules.length === 0)
+        return "";
+    const body = rules
+        .map((rule) => `<rule name="${rule.name}">\n${rule.content}\n</rule>`)
+        .join("\n\n");
+    return [
+        "<plain-rules>",
+        "The authoring rules for ***plain specifications. They are binding: when writing or",
+        "editing a .plain file, follow them exactly rather than inferring from surrounding text.",
+        "",
+        body,
+        "</plain-rules>",
+    ].join("\n");
+}
+export function rulesSummary(rules) {
+    const chars = rules.reduce((total, rule) => total + rule.content.length, 0);
+    return `${rules.length} rules, ~${Math.round(chars / 4000)}k tokens`;
+}

package/dist/self-invocation.js

@@ -0,0 +1,110 @@
+/**
+ * Keeping the conversation's agent on its own tools.
+ *
+ * The agent has a shell, and turri has a command line - so it can build a module by
+ * running `turri regenerate` through bash, or start another pi with `pi -p`. That run is a
+ * second, headless turri: outside this conversation's job queue, its panel and
+ * `/halt`, on whatever model the command line picks, fighting the conversation's own jobs for
+ * the same build directories. It is never the right call unless the person asked for the
+ * command line, so the harness refuses it and names the tool to use instead.
+ */
+/** The tool that does what a turri subcommand does, from inside the conversation. */
+const TOOL_FOR = {
+    regenerate: "regenerate",
+    glimpse: "glimpse",
+    conform: "conform",
+    cultivate: "cultivate",
+    release: "release",
+    "spec-diff": "regenerate",
+    chat: "nothing - you are the conversation already",
+    ask: "nothing - you are the conversation already",
+};
+/** The npm scripts in this repo, by the subcommand they run. */
+const NPM_SCRIPT = {
+    regenerate: "regenerate",
+    conform: "conform",
+    cultivate: "cultivate",
+    chat: "chat",
+    ask: "ask",
+};
+/** The source entry points, by the subcommand they are. */
+const ENTRY = {
+    "regenerate-cli": "regenerate",
+    "conform-cli": "conform",
+    "spec-diff-cli": "spec-diff",
+    "cultivate-cli": "cultivate",
+    "release-cli": "release",
+};
+/** Where a command starts: the start of the string, or after a separator. */
+const AT_COMMAND = String.raw `(?:^|[\s;&|()\x60$])`;
+/**
+ * What a shell command would run of turri or pi itself, if anything: the subcommand,
+ * or "pi" for another pi. `turri validate`, `drift` and `lineage` are not in it - they start no
+ * agent - and neither are setup and doctor.
+ */
+export function selfInvocation(command) {
+    const cli = new RegExp(`${AT_COMMAND}(?:npx\\s+)?turri\\s+(regenerate|glimpse|conform|cultivate|release|spec-diff)\\b`).exec(command);
+    if (cli)
+        return cli[1];
+    const launcher = new RegExp(`(?:bin/turri\\.mjs|src/cli\\.ts)\\s+(regenerate|glimpse|conform|cultivate|release|spec-diff)\\b`).exec(command);
+    if (launcher)
+        return launcher[1];
+    // turri alone, or with options, is the conversation - where a command starts, not a word an argument names (`which turri`).
+    const bare = /(?:^|[;&|()\x60$]\s*|\bnohup\s+|\bnpx\s+)turri(?=\s+-|\s*$|\s*[;&|)>])(?:\s+(-\S+))?/.exec(command) ??
+        /(?:bin\/turri\.mjs|src\/cli\.ts)(?=\s+-|\s*$|\s*[;&|)>])(?:\s+(-\S+))?/.exec(command);
+    if (bare && !["-h", "--help"].includes(bare[1] ?? ""))
+        return "chat";
+    const npm = new RegExp(`${AT_COMMAND}npm\\s+run\\s+(${Object.values(NPM_SCRIPT).join("|")})\\b`).exec(command);
+    if (npm)
+        return npm[1];
+    const entry = new RegExp(`src/(${Object.keys(ENTRY).join("|")})\\.ts\\b`).exec(command);
+    if (entry)
+        return ENTRY[entry[1]];
+    if (/pi-launch\.ts\b/.test(command))
+        return "pi";
+    // Another pi - but only one that would run an agent. pi configuring or describing itself
+    // (installing an extension, listing models, its version) is pi's own business.
+    for (const match of command.matchAll(new RegExp(`${AT_COMMAND}(?:npx\\s+)?pi(?:\\s+(\\S+)|\\s*$|\\s*[;&|)])`, "g"))) {
+        const first = match[1];
+        if (first === undefined || !PI_CONFIGURES.has(first))
+            return "pi";
+    }
+    return undefined;
+}
+/** pi's commands and flags that manage or describe pi rather than start an agent. */
+const PI_CONFIGURES = new Set([
+    "install", "remove", "uninstall", "update", "list", "config", "auth",
+    "--version", "-v", "--help", "-h", "--list-models",
+]);
+/**
+ * Whether the person's message asks for the command line: it says so, or names the command.
+ * Read from their own words only - an agent that decided on its own does not get through.
+ */
+export function askedForCommandLine(message) {
+    const text = message.toLowerCase();
+    return (/\b(headless|command[ -]line|cli|terminal|shell|in bash|via bash|through bash|npm run|nohup)\b/.test(text) ||
+        /\bturri\s+(regenerate|glimpse|conform|spec-diff|cultivate|release)\b/.test(text) ||
+        /(^|\s)turri\s+-p\b/.test(text) ||
+        /(^|\s)pi\s+-p\b/.test(text));
+}
+/** What the agent is told when the call is refused. */
+export function refusal(what) {
+    const instead = what === "pi"
+        ? "Do not start another agent: do the work here, with this conversation's tools."
+        : `Use ${TOOL_FOR[what] ?? "the matching turri tool"} instead.`;
+    return (`Not run: that starts turri${what === "pi" ? "'s agent" : ` ${what}`} again from the shell - a separate, headless ` +
+        "run outside this conversation, its jobs, the panel and /halt. " +
+        `${instead} Run turri from the command line only when the user asks for that.`);
+}
+/** The instruction that goes into the conversation's system prompt. */
+export const TOOLS_NOT_CLI = [
+    "<turri-tools>",
+    "In this conversation, you do your work with your tools - regenerate, conform, cultivate and the rest - which run as",
+    "background jobs the user can watch and halt. To try what is regenerated, release it - never by hand in plain_modules. Never",
+    "run your own command line (turri regenerate, glimpse, conform, spec-diff, cultivate, release, turri itself; npm run",
+    "regenerate and the like) or start another pi through bash:",
+    "that is a separate headless run the user cannot see or stop. Only when the user explicitly asks for the",
+    "command line, run it. Configuring pi itself - pi install, update, list, config, auth, or its settings files -",
+    "is fine; it starts no agent.",
+    "</turri-tools>",
+].join("\n");

package/dist/setup.js

@@ -0,0 +1,245 @@
+import { spawnSync } from "node:child_process";
+import { existsSync, rmSync } from "node:fs";
+import { join, relative } from "node:path";
+import { createInterface } from "node:readline/promises";
+import { ModelRegistry, ModelRuntime } from "@earendil-works/pi-coding-agent";
+import { globalExtensionFile, MIN_NODE, nodeVersionOk, PACKAGE_ROOT, turriOnPath } from "./environment.js";
+import { sandboxAvailable } from "./regenerate/os-sandbox.js";
+import { findTestScripts } from "./regenerate/test-scripts.js";
+import { hasProjectConfig, readProjectConfig, stackOf } from "./config.js";
+import { checkModels, modelsInUse, piModelAccess } from "./model-check.js";
+import { brand } from "./brand.js";
+import { readScript, scriptAgainstMachine, stackOnMachine } from "./stack.js";
+const MARK = { ok: "✓", missing: "✗", limited: "!", info: "·" };
+function checkNode() {
+    const version = process.versions.node;
+    return nodeVersionOk(version)
+        ? { level: "ok", name: "Node", detail: version }
+        : {
+            level: "missing",
+            name: "Node",
+            detail: `${version} - turri needs ${MIN_NODE.join(".")} or newer`,
+            fix: "install a newer Node (https://nodejs.org, or `brew install node`)",
+        };
+}
+/** bash: every agent command and every testing script runs with it, on every platform. */
+export function checkShell(found = spawnSync("bash", ["--version"], { stdio: "ignore", windowsHide: true }).status === 0, platform = process.platform) {
+    if (found)
+        return { level: "ok", name: "bash", detail: "on the PATH - agents' commands and the testing scripts run with it" };
+    return {
+        level: "missing",
+        name: "bash",
+        detail: "not on the PATH - agents' commands and the testing scripts run with it",
+        fix: platform === "win32" ? "install Git for Windows (Git Bash), and put its bash on the PATH" : "install bash with your system's package manager",
+    };
+}
+/** Which wall is up under the agents' commands, and - where none starts - why, and how to give it one. */
+export function checkSandbox(wall = sandboxAvailable(), platform = process.platform) {
+    if (wall.kind === "seatbelt")
+        return { level: "ok", name: "OS sandbox", detail: "Seatbelt - under the command check and the audit" };
+    if (wall.kind === "bubblewrap") {
+        return { level: "ok", name: "OS sandbox", detail: `bubblewrap${wall.proc === "bind" ? ", the host's /proc bound (this container masks its own)" : ""} - under the command check and the audit` };
+    }
+    return {
+        level: platform === "win32" ? "info" : "limited",
+        name: "OS sandbox",
+        detail: `none - ${wall.why}; the command check and the audit hold alone`,
+        ...(wall.fix !== undefined ? { fix: wall.fix } : {}),
+    };
+}
+/**
+ * In a project: each module's toolchains, as its implementation reqs name them, against this machine's PATH; and each
+ * testing script against this machine - a program it names that is not here, a toolchain it runs that is not on the
+ * PATH. Nothing outside a project.
+ */
+export function checkProject(project, machine = {}) {
+    const checks = [];
+    for (const { module, needs, missing } of stackOnMachine(project, machine.has)) {
+        if (needs.length === 0)
+            continue;
+        checks.push(missing.length === 0
+            ? { level: "ok", name: `${module}`, detail: `has ${needs.map((need) => need.toolchain).join(", ")}` }
+            : {
+                level: "missing",
+                name: `${module}`,
+                detail: `its implementation reqs need ${missing.map((need) => `${need.toolchain} (${need.words.join(", ")})`).join(", ")}, which this machine lacks`,
+                fix: `install ${missing.map((need) => need.toolchain).join(" and ")} on this machine - the agents use its toolchains, and install none`,
+            });
+    }
+    const scripts = findTestScripts(project);
+    for (const script of [scripts.unit, scripts.prepare, scripts.conformance]) {
+        if (script === undefined)
+            continue;
+        const text = readScript(script);
+        if (text === undefined)
+            continue;
+        const found = scriptAgainstMachine(text, machine);
+        if (found.length === 0)
+            continue;
+        checks.push({
+            level: "limited",
+            name: relative(project, script),
+            detail: "does not fit this machine - it is yours to fix:",
+            more: found,
+        });
+    }
+    return checks;
+}
+async function checkProvider() {
+    try {
+        const runtime = await ModelRuntime.create();
+        const available = new ModelRegistry(runtime).getAvailable();
+        const providers = [...new Set(available.map((model) => model.provider))];
+        if (providers.length > 0) {
+            return { level: "ok", name: "Model provider", detail: `${providers.join(", ")} (${available.length} models)` };
+        }
+    }
+    catch {
+        // Reported as missing below.
+    }
+    return {
+        level: "missing",
+        name: "Model provider",
+        detail: "no model has credentials",
+        fix: "run `pi` and use /login, or set an API key (ANTHROPIC_API_KEY, OPENAI_API_KEY, GEMINI_API_KEY, ...)",
+    };
+}
+function checkPath() {
+    const found = turriOnPath();
+    return found
+        ? { level: "ok", name: "turri on PATH", detail: found }
+        : {
+            level: "limited",
+            name: "turri on PATH",
+            detail: "not found",
+            // A clone has its sources; the package from npm has only what was compiled from them.
+            fix: existsSync(join(PACKAGE_ROOT, "src")) ? `cd ${PACKAGE_ROOT} && npm link` : "npm install -g @turri-dev/cli",
+        };
+}
+/**
+ * turri loaded into every `pi` - a file an older `turri setup` wrote into pi's extensions. turri and pi are kept apart
+ * now: `turri` starts pi with turri, and a plain `pi` stays pi. Said only when the file is there, for doctor to remove.
+ */
+function checkGlobal() {
+    const file = globalExtensionFile();
+    if (file === undefined)
+        return [];
+    return [
+        {
+            level: "limited",
+            name: "turri in every pi",
+            detail: `${file} loads turri into every plain pi too`,
+            fix: "turri doctor offers to remove it, below - turri keeps starting with turri",
+        },
+    ];
+}
+/**
+ * In a project: each model its config names - with the stack chosen, that stack's over it - tried with one short
+ * request. A model that answers is ready; one that does not says what the provider said, and what to do about it.
+ */
+export async function checkProjectModels(project, access) {
+    const used = modelsInUse(readProjectConfig(project, stackOf(project)));
+    if (used.length === 0) {
+        return [{ level: "missing", name: "Models", detail: "config.turri.yaml names none", fix: "turri init-config writes the two models" }];
+    }
+    let verdicts;
+    try {
+        verdicts = await checkModels(used, access ?? (await piModelAccess()));
+    }
+    catch (error) {
+        return [{ level: "missing", name: "Models", detail: `pi's models could not be read: ${error instanceof Error ? error.message : String(error)}` }];
+    }
+    return verdicts.map((verdict) => {
+        const name = verdict.usedBy.join(", ");
+        return verdict.ok
+            ? { level: "ok", name, detail: `${verdict.spec} answered (${(verdict.ms / 1000).toFixed(1)}s)` }
+            : { level: "missing", name, detail: verdict.spec, more: [verdict.problem], fix: verdict.fix };
+    });
+}
+async function allChecks(options = {}) {
+    const checks = [checkNode(), checkShell(), checkSandbox(), await checkProvider(), checkPath(), ...checkGlobal()];
+    // In a project: what it needs of this machine, and whether its models answer.
+    const project = process.cwd();
+    if (hasProjectConfig(project) || existsSync(join(project, "plain_modules"))) {
+        checks.push(...checkProject(project));
+        if (options.models !== false && hasProjectConfig(project)) {
+            console.log(brand.muted("Asking each model the config names for a word..."));
+            checks.push(...(await checkProjectModels(project)));
+        }
+    }
+    return checks;
+}
+function report(checks) {
+    const paint = { ok: brand.success, missing: brand.error, limited: brand.warning, info: brand.muted };
+    // The names in one column, however long the longest - `judge-model, models.judge` - is.
+    const width = Math.max(20, ...checks.map((check) => check.name.length)) + 1;
+    const under = " ".repeat(width + 4);
+    console.log("");
+    for (const check of checks) {
+        const name = check.level === "missing" ? brand.bold(check.name.padEnd(width)) : check.name.padEnd(width);
+        console.log(`  ${paint[check.level](MARK[check.level])} ${name}${check.level === "info" ? brand.muted(check.detail) : check.detail}`);
+        for (const line of check.more ?? [])
+            console.log(`${under}${brand.muted(line)}`);
+        if (check.fix && check.level !== "ok")
+            console.log(`${under}${brand.accent(`→ ${check.fix}`)}`);
+    }
+    const missing = checks.filter((check) => check.level === "missing");
+    const limited = checks.filter((check) => check.level === "limited");
+    console.log("");
+    if (missing.length > 0) {
+        console.log(brand.error(`Not ready: ${missing.length} thing${missing.length === 1 ? "" : "s"} to fix (✗ above).`));
+        return 1;
+    }
+    console.log(limited.length > 0 ? brand.warning("Ready, with limits (! above).") : brand.success("Ready."));
+    return 0;
+}
+/**
+ * Ask a yes/no question. With --yes, yes. With no terminal to ask on, no - nothing is changed
+ * without asking - and it says so, so a piped run shows what it would have done.
+ */
+async function confirm(question, fallback, yes) {
+    if (yes)
+        return true;
+    if (!process.stdin.isTTY) {
+        console.log(`${question} - not asked: no terminal. Run turri doctor in a terminal, or with --yes.`);
+        return false;
+    }
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        const answer = (await rl.question(`${question} ${fallback ? "[Y/n]" : "[y/N]"} `)).trim().toLowerCase();
+        return answer === "" ? fallback : answer.startsWith("y");
+    }
+    finally {
+        rl.close();
+    }
+}
+/**
+ * Take turri out of every `pi`: the extension file an older `turri setup` wrote. The themes it copied stay - they only
+ * add turri's themes to pi's list.
+ */
+function removeGlobalExtension() {
+    const file = globalExtensionFile();
+    if (file === undefined)
+        return;
+    rmSync(file, { force: true });
+    console.log(`  removed ${file}`);
+}
+export async function main(args) {
+    if (args.includes("--help") || args.includes("-h")) {
+        console.log("usage: turri doctor [--no-models] [--yes]\n\nCheck everything turri needs - in a project, what its modules need of this machine too, and that\n" +
+            "each model its config names answers with this machine's credentials (one short request a model;\n--no-models skips it).\n" +
+            "It changes nothing but this, asked first: a plain pi that an older turri made load turri too is put back to\n" +
+            "plain pi. --yes answers yes.");
+        return 0;
+    }
+    console.log(brand.bold(brand.accent("Checking what turri needs.")));
+    if (!nodeVersionOk())
+        return report([checkNode()]);
+    const code = report(await allChecks({ models: !args.includes("--no-models") }));
+    // turri and pi are kept apart: a plain pi does not start turri. An older turri's file that made it do so goes, asked.
+    const global = globalExtensionFile();
+    if (global !== undefined && (await confirm(`\nA plain \`pi\` loads turri too, through ${global}. Remove it, so pi stays pi?`, true, args.includes("--yes") || args.includes("-y")))) {
+        removeGlobalExtension();
+    }
+    return code;
+}

package/dist/skill-progress.js

@@ -0,0 +1,78 @@
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+const PLAIN = { heading: (t) => t, done: (t) => t, now: (t) => t, muted: (t) => t };
+/** The shortest a join between two phases is drawn: ` ━━ `. */
+const JOIN = 2;
+/** How much of the width the phases take, centred in it - stretched across it, the joins read as a ruler. */
+const SHARE = 0.6;
+/** The least room between the phases and the skill's name on the left, or where it is on the right. */
+const GAP = 3;
+/** Below this width the line is drawn compact, from the left: there is no room to spare. */
+const NARROW = 60;
+/**
+ * The line across `width`: the skill's name at the left edge, where it is at the right edge, and between them its
+ * phases, centred in the whole width across its share of it, the joins stretched to fill it - clear of both ends. Too
+ * narrow for that, compact from the left, the phases first, as many as fit.
+ */
+export function skillProgressLine(progress, width, style = PLAIN) {
+    // One phase or none: nothing to be partway through - the spinner and the skill's name, and the attempt after a gate sent it back.
+    if (progress.phases.length <= 1) {
+        const again = progress.attempt > 1 ? style.muted(`   attempt ${progress.attempt}`) : "";
+        return truncateToWidth(`${style.now(progress.frame)} ${style.heading(progress.skill)}${again}`, width, "…");
+    }
+    const head = style.heading(progress.skill);
+    const tail = style.muted(whereItIs(progress));
+    const steps = stepsOf(progress, style);
+    const shortest = visibleWidth(phasesAcross(progress, steps, 0, style));
+    const sides = visibleWidth(head) + visibleWidth(tail) + 2 * GAP;
+    if (width < NARROW || sides + shortest > width)
+        return compact(progress, steps, width, style);
+    // Its share, or as little as the ends leave it - kept centred while that keeps it clear of them.
+    const room = width - 2 * (Math.max(visibleWidth(head), visibleWidth(tail)) + GAP);
+    const across = Math.max(shortest, Math.min(Math.floor(width * SHARE), room));
+    const bar = phasesAcross(progress, steps, across, style);
+    const barWidth = visibleWidth(bar);
+    const from = Math.min(Math.max(Math.floor((width - barWidth) / 2), visibleWidth(head) + GAP), width - visibleWidth(tail) - GAP - barWidth);
+    const after = width - from - barWidth - visibleWidth(tail);
+    return `${head}${" ".repeat(from - visibleWidth(head))}${bar}${" ".repeat(Math.max(0, after))}${tail}`;
+}
+/** Where it is: the phase it is in, of how many - and the attempt, after a gate sent it back. */
+function whereItIs(progress) {
+    if (progress.current < 0)
+        return "starting";
+    return `phase ${progress.current + 1} of ${progress.phases.length}${progress.attempt > 1 ? `, attempt ${progress.attempt}` : ""}`;
+}
+/** Each phase as it is drawn: done ticked, the one it is in marked, the rest to come. */
+function stepsOf(progress, style) {
+    const { phases, current } = progress;
+    return phases.map((phase, at) => at < current ? style.done(`✓ ${phase}`) : at === current ? style.now(`${progress.frame} ${phase}`) : style.muted(`○ ${phase}`));
+}
+/** A join between two phases, `length` long: a stretch walked heavy, in the colour of what is done; one to come, light. */
+function joinOf(at, length, current, style) {
+    return at <= current ? style.done(` ${"━".repeat(length)} `) : style.muted(` ${"─".repeat(length)} `);
+}
+/** The phases across `width`, the joins stretched to fill it - at their shortest, when it is less than that takes. */
+function phasesAcross(progress, steps, width, style) {
+    const joins = Math.max(0, steps.length - 1);
+    const fixed = steps.reduce((sum, step) => sum + visibleWidth(step), 0) + joins * (JOIN + 2);
+    const spare = Math.max(0, width - fixed);
+    const length = (at) => JOIN + (joins === 0 ? 0 : Math.floor(spare / joins) + (at <= spare % joins ? 1 : 0));
+    return steps.map((step, at) => (at === 0 ? step : `${joinOf(at, length(at), progress.current, style)}${step}`)).join("");
+}
+/** The line from the left, every join at its shortest - where it is left out first, then the phases cut, to fit `width`. */
+function compact(progress, steps, width, style) {
+    const line = `${style.heading(progress.skill)}  ${phasesAcross(progress, steps, 0, style)}`;
+    const full = `${line}   ${style.muted(whereItIs(progress))}`;
+    return visibleWidth(full) <= width ? full : truncateToWidth(line, width, "…");
+}
+/**
+ * The line under it: the phase it is in, and what that phase does - centred under the phases, cut short where it
+ * does not fit. Nothing before the first phase starts, or for a phase the skill does not describe.
+ */
+export function skillAboutLine(progress, width, style = PLAIN) {
+    const phase = progress.phases[progress.current];
+    if (progress.phases.length <= 1 || phase === undefined || progress.about === undefined || progress.about === "")
+        return undefined;
+    const text = truncateToWidth(`${phase} - ${progress.about}`, width, "…");
+    const left = width < NARROW ? 0 : Math.floor((width - visibleWidth(text)) / 2);
+    return `${" ".repeat(left)}${style.muted(text)}`;
+}