@turri-dev/cli 0.1.3-next.17f0f7f → 0.1.3-next.79e2ad0

package/dist/cli-options.js

@@ -0,0 +1,82 @@
+import { conformanceOption, overrideConfig, reviewOption, splitModelSpec } from "./config.js";
+/**
+ * The command line of turri's commands: their words, and the options that stand for the config's own keys - kept apart
+ * from the commands that use them, so a light one (doctor) reads them as a regenerate does without loading it.
+ */
+/**
+ * A command's arguments: the positional ones, `--flag`s and `--name value` options (`--name=value` too) -
+ * `--coding-model` is `--model`. An option it does not take is refused, rather than taking the word after it, and so is an
+ * option with no value - the end of the words, or another option where its value should be.
+ */
+export function parseArgs(argv, flags, usage, valued = []) {
+    const positional = [];
+    const options = {};
+    const takes = new Set(["--model", ...valued]);
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        const [name, inline] = arg.startsWith("--") && arg.includes("=") ? [arg.slice(0, arg.indexOf("=")), arg.slice(arg.indexOf("=") + 1)] : [arg, undefined];
+        const option = name === "--coding-model" ? "--model" : name;
+        if (arg === "-h" || arg === "--help") {
+            console.log(usage);
+            process.exit(0);
+        }
+        else if (flags.includes(option) && inline === undefined)
+            options[option.slice(2)] = "yes";
+        else if (takes.has(option)) {
+            // Its value is the next word - never another option, which would be taken as the value and lost.
+            const value = inline ?? argv[i + 1];
+            if (value === undefined || (inline === undefined && value.startsWith("--"))) {
+                console.error(`${usage}\n\n${name} needs a value${value !== undefined ? `, not the option ${value}` : ""} - ${name}=<value> gives one that starts with --.`);
+                process.exit(1);
+            }
+            if (inline === undefined)
+                i += 1;
+            options[option.slice(2)] = value;
+        }
+        else if (arg.startsWith("-")) {
+            console.error(`${usage}\n\nNo such option: ${name}.`);
+            process.exit(1);
+        }
+        else
+            positional.push(arg);
+    }
+    return { positional, options };
+}
+/** An option's value, as parseArgs left it: refused when it was given with none. */
+export function optionValue(options, name) {
+    const value = options[name];
+    if (name in options && (value === undefined || value.trim() === ""))
+        failOption(`--${name} needs a value`);
+    return value;
+}
+/**
+ * The options that stand for the config's own keys - `--harness-model`, `--coding-model` (`--model`), `--judge-model`
+ * and, as asked, `--review` and `--conformance-tests` - read as if config.turri.yaml had them, in their place in the
+ * order the config resolves them in (overrideConfig): a run, or doctor, with them is the same as one with them in the
+ * file. Exits on a value it cannot read.
+ */
+export function configKeyOptions(options, take = {}) {
+    const tests = take.conformance === true ? optionValue(options, "conformance-tests") : undefined;
+    const setting = tests !== undefined ? conformanceOption(tests) : undefined;
+    if (tests !== undefined && setting === undefined)
+        failOption(`--conformance-tests takes all, chosen, module or false, not ${tests}`);
+    const reviewed = take.review === true ? optionValue(options, "review") : undefined;
+    const review = reviewed !== undefined ? reviewOption(reviewed) : undefined;
+    if (reviewed !== undefined && review === undefined)
+        failOption(`--review takes true or false, not ${reviewed}`);
+    const model = (name, key) => {
+        const spec = optionValue(options, name);
+        return spec !== undefined ? { [key]: splitModelSpec(spec) } : {};
+    };
+    overrideConfig({
+        ...model("harness-model", "harnessModel"),
+        ...model("model", "codingModel"),
+        ...model("judge-model", "judgeModel"),
+        ...(setting !== undefined ? { conformanceTests: setting } : {}),
+        ...(review !== undefined ? { review } : {}),
+    });
+}
+function failOption(message) {
+    console.error(message);
+    process.exit(1);
+}

package/dist/conform-cli.js

@@ -1,4 +1,5 @@
-import { headlessOptions, parseArgs, runLoop } from "./loop-cli.js";
+import { parseArgs } from "./cli-options.js";
+import { headlessOptions, runLoop } from "./loop-cli.js";
 const USAGE = `usage: turri conform <file.plain> [frid ...] [options]
 
 Writes and runs the black-box conformance tests of a module's functional specs - those named, or

package/dist/loop-cli.js

@@ -1,7 +1,7 @@
 import { sweepOrphanedGroups } from "./regenerate/shell.js";
 import { createInterface } from "node:readline/promises";
 import { resolve, sep } from "node:path";
-import { configForSpec, conformanceOption, reviewOption, inheritModel, modelOnly, modelSpec, overrideConfig, projectModels, readProjectConfig, roleModel, ROLE_THINKING, splitModelSpec, } from "./config.js";
+import { configForSpec, inheritModel, modelOnly, modelSpec, projectModels, readProjectConfig, roleModel, ROLE_THINKING, splitModelSpec, } from "./config.js";
 import { PACKAGE_ROOT } from "./environment.js";
 import { c } from "./module-report.js";
 import { tryItCommand } from "./regenerate/delivery.js";
@@ -13,6 +13,7 @@ import { MODULES_DIR, projectDirOf } from "./regenerate/paths.js";
 import { exportModule } from "./regenerate/release.js";
 import { listFiles } from "./regenerate/testing.js";
 import { startRunReport } from "./run-report.js";
+import { configKeyOptions, optionValue } from "./cli-options.js";
 /**
  * What every command that builds - `turri regenerate`, `conform`, `spec-diff` - does around its own
  * request of the work loop, as the chat does it: the project's models, a job that fails run once more and, failing again,
@@ -235,83 +236,15 @@ function reportModels(project, model) {
 }
 /**
  * The options every command that regenerates takes for a headless run: `--report` and `--build-dir`, and the config's
- * own keys - `--harness-model`, `--coding-model` (`--model`), `--judge-model`, `--review` and, where `conformance` is
- * true, `--conformance-tests` - read as if config.turri.yaml had them, the config's order of them kept (overrideConfig).
- * Exits on a value it cannot read.
+ * own keys (configKeyOptions) - `--harness-model`, `--coding-model` (`--model`), `--judge-model`, `--review` and, where
+ * `conformance` is true, `--conformance-tests` - read as if config.turri.yaml had them. Exits on a value it cannot read.
  */
 export function headlessOptions(options, conformance) {
-    const given = (name) => {
-        const value = options[name];
-        if (name in options && (value === undefined || value.trim() === ""))
-            failOption(`--${name} needs a value`);
-        return value;
-    };
-    const tests = conformance ? given("conformance-tests") : undefined;
-    const setting = tests !== undefined ? conformanceOption(tests) : undefined;
-    if (tests !== undefined && setting === undefined)
-        failOption(`--conformance-tests takes all, chosen, module or false, not ${tests}`);
-    const reviewed = given("review");
-    const review = reviewed !== undefined ? reviewOption(reviewed) : undefined;
-    if (reviewed !== undefined && review === undefined)
-        failOption(`--review takes true or false, not ${reviewed}`);
-    const model = (name) => {
-        const spec = given(name);
-        return spec !== undefined ? { [name === "model" ? "codingModel" : name === "harness-model" ? "harnessModel" : "judgeModel"]: splitModelSpec(spec) } : {};
-    };
-    overrideConfig({
-        ...model("harness-model"),
-        ...model("model"),
-        ...model("judge-model"),
-        ...(setting !== undefined ? { conformanceTests: setting } : {}),
-        ...(review !== undefined ? { review } : {}),
-    });
-    const report = given("report");
-    const buildDir = given("build-dir");
+    configKeyOptions(options, { conformance, review: true });
+    const report = optionValue(options, "report");
+    const buildDir = optionValue(options, "build-dir");
     return { ...(report !== undefined ? { report } : {}), ...(buildDir !== undefined ? { buildDir } : {}) };
 }
-function failOption(message) {
-    console.error(message);
-    process.exit(1);
-}
-/**
- * A command's arguments: the positional ones, `--flag`s and `--name value` options (`--name=value` too) -
- * `--coding-model` is `--model`. An option it does not take is refused, rather than taking the word after it, and so is an
- * option with no value - the end of the words, or another option where its value should be.
- */
-export function parseArgs(argv, flags, usage, valued = []) {
-    const positional = [];
-    const options = {};
-    const takes = new Set(["--model", ...valued]);
-    for (let i = 0; i < argv.length; i += 1) {
-        const arg = argv[i];
-        const [name, inline] = arg.startsWith("--") && arg.includes("=") ? [arg.slice(0, arg.indexOf("=")), arg.slice(arg.indexOf("=") + 1)] : [arg, undefined];
-        const option = name === "--coding-model" ? "--model" : name;
-        if (arg === "-h" || arg === "--help") {
-            console.log(usage);
-            process.exit(0);
-        }
-        else if (flags.includes(option) && inline === undefined)
-            options[option.slice(2)] = "yes";
-        else if (takes.has(option)) {
-            // Its value is the next word - never another option, which would be taken as the value and lost.
-            const value = inline ?? argv[i + 1];
-            if (value === undefined || (inline === undefined && value.startsWith("--"))) {
-                console.error(`${usage}\n\n${name} needs a value${value !== undefined ? `, not the option ${value}` : ""} - ${name}=<value> gives one that starts with --.`);
-                process.exit(1);
-            }
-            if (inline === undefined)
-                i += 1;
-            options[option.slice(2)] = value;
-        }
-        else if (arg.startsWith("-")) {
-            console.error(`${usage}\n\nNo such option: ${name}.`);
-            process.exit(1);
-        }
-        else
-            positional.push(arg);
-    }
-    return { positional, options };
-}
 /** Yes or no at the terminal - or undefined when there is none, and so no one to ask. */
 async function askAtTerminal(title, body) {
     if (process.stdin.isTTY !== true)

package/dist/regenerate-cli.js

@@ -1,5 +1,6 @@
 import { CONFIG_FILE, readProjectConfig } from "./config.js";
-import { headlessOptions, parseArgs, runLoop } from "./loop-cli.js";
+import { parseArgs } from "./cli-options.js";
+import { headlessOptions, runLoop } from "./loop-cli.js";
 const USAGE = `usage: turri regenerate [file.plain] [frid ...] [options]
 
 Regenerates the module's code from its spec as it is now, and everything it requires, bottom first, as

package/dist/setup.js

@@ -6,6 +6,7 @@ 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 { configKeyOptions, parseArgs } from "./cli-options.js";
 import { hasProjectConfig, readProjectConfig, stackOf } from "./config.js";
 import { checkModels, modelsInUse, piModelAccess } from "./model-check.js";
 import { brand } from "./brand.js";
@@ -151,7 +152,7 @@ function checkGlobal() {
 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" }];
+        return [{ level: "missing", name: "Models", detail: "config.turri.yaml names none", fix: "turri init-config writes the two models - or name them here: --harness-model, --coding-model" }];
     }
     let verdicts;
     try {
@@ -167,16 +168,17 @@ export async function checkProjectModels(project, access) {
             : { level: "missing", name, detail: verdict.spec, more: [verdict.problem], fix: verdict.fix };
     });
 }
+/** `modelsGiven`: models named on the command line - checked wherever doctor runs, a project or not. */
 async function allChecks(options = {}) {
     const checks = [checkNode(), checkShell(), checkGit(), 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"))) {
+    const inProject = hasProjectConfig(project) || existsSync(join(project, "plain_modules"));
+    if (inProject)
         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)));
-        }
+    if (options.models !== false && (hasProjectConfig(project) || options.modelsGiven === true)) {
+        console.log(brand.muted("Asking each model the config names for a word..."));
+        checks.push(...(await checkProjectModels(project)));
     }
     return checks;
 }
@@ -235,21 +237,27 @@ function removeGlobalExtension() {
     rmSync(file, { force: true });
     console.log(`  removed ${file}`);
 }
+const USAGE = [
+    "usage: turri doctor [--harness-model <m>] [--coding-model <m>] [--judge-model <m>] [--no-models] [--yes]",
+    "",
+    "Check everything turri needs - in a project, what its modules need of this machine too, and that",
+    "each model its config names answers with this machine's credentials (one short request a model;",
+    "--no-models skips it). The model options are read as the config's keys, as turri regenerate reads them:",
+    "a headless run's models can be checked before it starts, with no config.turri.yaml.",
+    "It changes nothing but this, asked first: a plain pi that an older turri made load turri too is put back to",
+    "plain pi. --yes answers yes.",
+].join("\n");
 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;
-    }
+    const { options } = parseArgs(args, ["--no-models", "--yes", "-y"], USAGE, ["--harness-model", "--judge-model"]);
+    configKeyOptions(options);
     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") }));
+    const modelsGiven = ["harness-model", "model", "judge-model"].some((name) => options[name] !== undefined);
+    const code = report(await allChecks({ models: options["no-models"] === undefined, modelsGiven }));
     // 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")))) {
+    if (global !== undefined && (await confirm(`\nA plain \`pi\` loads turri too, through ${global}. Remove it, so pi stays pi?`, true, options.yes !== undefined || args.includes("-y")))) {
         removeGlobalExtension();
     }
     return code;

package/dist/spec-diff-cli.js

@@ -2,7 +2,8 @@ import { readFileSync } from "node:fs";
 import { resolve } from "node:path";
 import { checkPlainFile } from "./plain/check.js";
 import { applySpecDiff, revertSpecDiff } from "./regenerate/regenerate.js";
-import { headlessOptions, parseArgs, runLoop } from "./loop-cli.js";
+import { parseArgs } from "./cli-options.js";
+import { headlessOptions, runLoop } from "./loop-cli.js";
 const USAGE = `usage: turri spec-diff <file.plain> <diff-file> [options]
 
 Applies a change to the specs, given as a git diff of the .plain files, and builds it: the headless

package/docs/headless.md

@@ -14,7 +14,8 @@ Everything marked `✗` stops the run, so fix those first. Two more things matte
   a module's implementation reqs name that this machine lacks.
 - **The models.** In a project, `turri doctor` sends each model `config.turri.yaml` names one short request, as turri's
   agents will - so a key the provider refuses, a model pi does not know or an account without access to it shows now,
-  not an hour into the run.
+  not an hour into the run. Models the run is given on the command line are given to doctor the same way -
+  `--harness-model`, `--coding-model`, `--judge-model`, read as the config's keys - and are checked with the config's.
 - **Credentials that do not expire mid-run.** An API key in the environment
   (`ANTHROPIC_API_KEY`, `OPENAI_API_KEY`, `GEMINI_API_KEY`, ...) or pi's saved login - whatever
   `doctor` shows as the model provider.
@@ -260,9 +261,16 @@ turri regenerate app.plain --harness-model amazon-bedrock/eu.anthropic.claude-op
 - **What it needs:** Node 22.19 or newer, `bash`, `git` (each module's history, and the spec diffs
   the work is planned from), `/bin/sh` with `kill` and `sleep`, a writable `HOME` (pi keeps
   `~/.pi/agent/auth.json` there, even with no login - or set `PI_CODING_AGENT_DIR`) and `TMPDIR`, and
-  the toolchains the project's testing scripts and implementation reqs name. `turri doctor --no-models`
-  in the project checks them; `--no-models` because a `config.yaml` written for another tool names no models, and
-  doctor would count that against it.
+  the toolchains the project's testing scripts and implementation reqs name. `turri doctor` in the project, given
+  the run's models, checks them all and that each model answers - at the start of the task's log, not when a pulse
+  fails:
+
+  ```bash
+  turri doctor --harness-model amazon-bedrock/eu.anthropic.claude-opus-5-5 \
+    --coding-model amazon-bedrock/eu.anthropic.claude-sonnet-5-5 --judge-model amazon-bedrock/eu.anthropic.claude-opus-5-5
+  ```
+
+  It exits 1 on anything marked `✗`.
 - **Without bubblewrap:** a container that cannot make user namespaces - no
   `--security-opt seccomp=unconfined` - has no OS sandbox. turri runs anyway, the command check and the
   audit holding alone under the agents' commands; `turri doctor` shows it as `!`, not `✗`. Installing

package/docs/installation.md

@@ -68,7 +68,7 @@ In a project - a folder with `config.turri.yaml` (or the old `config.yaml`) or `
 | --- | --- |
 | each module's toolchains | what its implementation reqs name - Python, Node, Java, Go, Rust, C/C++, Zig, ... - against this machine's PATH: the agents use this machine's toolchains and install none, so a missing one is yours to install |
 | the testing scripts | what in them this machine does not have: a program named by its whole path that is not here (a macOS-only `/usr/libexec/java_home` on Linux), a toolchain they run that is not on the PATH |
-| the models | each model `config.turri.yaml` names - `harness-model`, `coding-model`, `judge-model`, every role under `models:` - sent one short request through pi, with the credentials turri's agents will use, for any provider pi supports. One that answers is ready; for one that does not, it says what the provider said and what to do: the credentials pi reads for that provider (`AWS_PROFILE` and `AWS_REGION` for Amazon Bedrock, `OPENAI_API_KEY`, `/login`, ...), model access in the Bedrock console, the closest model ids pi knows for one it does not. `--no-models` skips it |
+| the models | each model `config.turri.yaml` names - `harness-model`, `coding-model`, `judge-model`, every role under `models:` - sent one short request through pi, with the credentials turri's agents will use, for any provider pi supports. One that answers is ready; for one that does not, it says what the provider said and what to do: the credentials pi reads for that provider (`AWS_PROFILE` and `AWS_REGION` for Amazon Bedrock, `OPENAI_API_KEY`, `/login`, ...), model access in the Bedrock console, the closest model ids pi knows for one it does not. `--harness-model`, `--coding-model` (`--model`) and `--judge-model` name models as the config's keys, as `turri regenerate` reads them - checked in a project or not. `--no-models` skips it |
 
 Removing that file is the one thing `doctor` changes, and it asks first; `turri doctor --yes` says yes. Run without a
 terminal - piped, or in CI - it asks nothing and changes nothing. Run it again whenever something breaks;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@turri-dev/cli",
-  "version": "0.1.3-next.17f0f7f",
+  "version": "0.1.3-next.79e2ad0",
   "license": "MIT",
   "type": "module",
   "repository": {