@turri-dev/cli 0.1.27-next.763d091 → 0.1.28-next.d5f2680

package/dist/conformance-switch.js

@@ -0,0 +1,108 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { defineTool } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+import { adoptLegacyConfig, CONFIG_FILE, CONFIG_KEYS, configForSpec, readConfigFile, readProjectConfig, stackConfigFileIn, stackForModule, stackOf, stacksOf } from "./config.js";
+import { withSetting, writeSetting } from "./config-edit.js";
+/**
+ * Whether a project's functional specs are conformance tested: `conformance-tests:` in its config, a stack's own over the
+ * project's, false when unset. Off, nothing of conformance testing runs - no conformance pulse, no conformance testing
+ * script, the test advisor and the chat's conform and evaluate_tests off; the test plain files there are kept, and not
+ * tested. The chat always knows it, and how they are turned on: the person asking for tests, or agreeing to the chat's
+ * offer of them, turns them on - for this session and the next, written into the config.
+ */
+/** The chat's tools that run conformance testing: there while the tests are on. */
+export const CONFORMANCE_TOOLS = ["conform", "evaluate_tests"];
+/** The chat's tool that turns them on: there while they are off. */
+export const TURN_ON_TOOL = "turn_on_conformance_tests";
+/** Whether a module's functional specs are conformance tested: its stack's `conformance-tests:` over the project's. */
+export function conformanceTestsOn(plainFile) {
+    try {
+        return configForSpec(resolve(plainFile)).conformanceTests === true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Whether the project conformance tests anything: its own config, or a stack's - for the chat's tools, which are the project's. */
+export function conformanceTestsOnIn(project) {
+    try {
+        const stacks = [stackOf(project), ...stacksOf(project)].filter((stack) => stack !== undefined);
+        return readProjectConfig(project).conformanceTests === true || stacks.some((stack) => readProjectConfig(project, stack).conformanceTests === true);
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Turn conformance testing on: `conformance-tests: true` written where the module's value comes from - its stack's file
+ * when that names the key, else config.turri.yaml - and in effect at once. Says which file.
+ */
+export function turnOnConformanceTests(project, plainFile) {
+    const stack = plainFile !== undefined ? stackForModule(resolve(plainFile)) : stackOf(project);
+    if (stack !== undefined) {
+        const file = join(project, stackConfigFileIn(project, stack));
+        if (existsSync(file) && readConfigFile(file).conformanceTests !== undefined) {
+            adoptLegacyConfig(project);
+            const own = join(project, stackConfigFileIn(project, stack));
+            writeFileSync(own, withSetting(readFileSync(own, "utf8"), CONFIG_KEYS.conformanceTests, true));
+            return stackConfigFileIn(project, stack);
+        }
+    }
+    writeSetting(project, CONFIG_KEYS.conformanceTests, true);
+    return CONFIG_FILE;
+}
+/**
+ * What the chat is told of conformance testing, every turn: what it is, whether it is on here, and - off - how it is
+ * turned on, and that it may offer it.
+ */
+export function conformanceBlock(on) {
+    const what = "Conformance tests are black-box tests that start the built software and check it from outside, against the scenarios " +
+        "of a functional spec's test plain file - written by turri's agents once the code is built, and run with the whole suite " +
+        "each time more lands, so nothing that worked quietly breaks. Unit tests are always written with the code; conformance " +
+        "tests are the project's choice: `conformance-tests:` in config.turri.yaml.";
+    return [
+        "<conformance-tests>",
+        what,
+        on
+            ? "They are on here (conformance-tests: true): functional specs with scenarios are conformance tested, and the test advisor checks new ones in the background."
+            : [
+                "They are off here (conformance-tests: false, or unset): no scenarios are written or tested, no conformance testing script, the test",
+                "advisor is off, and conform and evaluate_tests are not among your tools. Test plain files already there are kept, and not tested.",
+                `When the person asks for conformance tests, or testing scenarios, call ${TURN_ON_TOOL} - their asking is their yes - then`,
+                "go on with what they asked: the test reqs, the conformance testing script, the scenarios.",
+                "You may offer them yourself, once and in a line, never turning them on unasked: when a functional spec could go wrong",
+                "silently, or the coding agent keeps failing at one - say what they would add, and ask. A yes, and you call the tool.",
+                "Asked how they are turned on: by asking you, or /turri-config conformance-tests true.",
+            ].join("\n"),
+        "</conformance-tests>",
+    ].join("\n");
+}
+/**
+ * turn_on_conformance_tests: the chat turns conformance testing on, the person having asked for it or agreed to it.
+ * `turnOn` is the session's (extension.ts `turnOnConformance`): the setting written, every chat's tools switched - the
+ * file written, from the project.
+ */
+export function turnOnConformanceTestsTool(options) {
+    return defineTool({
+        name: TURN_ON_TOOL,
+        label: "Turn on conformance tests",
+        description: "Turn conformance tests on for this project - conformance-tests: true in its config, for this session and the next - " +
+            "once the person asked for conformance tests or testing scenarios, or agreed when you offered them. conform and " +
+            "evaluate_tests become your tools, the test advisor starts checking new functional specs, and the work loop writes " +
+            "and runs the conformance tests of every functional spec with scenarios once its code is built. Never call it unasked.",
+        promptSnippet: `${TURN_ON_TOOL}: turn conformance tests on, the person having asked for them or agreed`,
+        parameters: Type.Object({
+            plain_file: Type.Optional(Type.String({ description: "The module the tests are for: its stack's config is written when that names the key. Omitted: config.turri.yaml." })),
+        }),
+        async execute(_id, params) {
+            const file = options.turnOn(params.plain_file);
+            const text = `Conformance tests are on for this project now - conformance-tests: true, written in ${file}. Say so to the person in a line. ` +
+                "conform and evaluate_tests are your tools from your next turn, and the test advisor checks new functional specs. Go on " +
+                "with what they asked: the test reqs, the conformance testing script, the scenarios - in that order, only what is missing. " +
+                "Functional specs with scenarios written already, their code built, are tested once the module is next regenerated: " +
+                "call conform for them to have their tests written now.";
+            return { content: [{ type: "text", text }], details: { file } };
+        },
+    });
+}

package/dist/cultivate-cli.js

@@ -8,6 +8,7 @@ import { loadSkill } from "./skill.js";
 import { discoverSkills } from "./skills.js";
 import { PACKAGE_ROOT } from "./environment.js";
 import { c } from "./module-report.js";
+import { skillModel } from "./config.js";
 const reporter = {
     step: (name, attempt) => console.log(`\n${c.bold(c.accent(`> step ${name}`))} ${c.dim(`attempt ${attempt}`)}`),
     artifact: (path, body) => {
@@ -44,17 +45,26 @@ const reporter = {
 async function main() {
     const args = process.argv.slice(2);
     const modelIndex = args.indexOf("--model");
-    const model = modelIndex === -1 ? undefined : args[modelIndex + 1];
-    const skillArg = args.filter((arg, i) => !arg.startsWith("--") && i !== modelIndex + 1)[0];
+    const modelAsked = modelIndex === -1 ? undefined : args[modelIndex + 1];
+    // The word after --model is the model, never the skill - and with no --model, no word is.
+    const skillArg = args.filter((arg, i) => !arg.startsWith("--") && (modelIndex === -1 || i !== modelIndex + 1))[0];
     if (!skillArg) {
         console.error("usage: turri cultivate <skill name | path-to-skill-dir> [--model provider/id]");
         process.exit(1);
     }
     const cwd = process.cwd();
     // A folder with a SKILL.md, or a skill by name: turri's own or the project's (skills.ts).
-    const named = existsSync(join(skillArg, "SKILL.md")) ? undefined : discoverSkills(PACKAGE_ROOT, cwd).skills.find((found) => found.name === skillArg);
+    const isFolder = existsSync(join(skillArg, "SKILL.md"));
+    const skills = isFolder ? [] : discoverSkills(PACKAGE_ROOT, cwd).skills;
+    const named = skills.find((found) => found.name === skillArg);
+    if (!isFolder && named === undefined) {
+        console.error(`No skill named ${skillArg}, and no SKILL.md in a folder of that name. The skills: ${skills.map((found) => found.name).join(", ")}.`);
+        process.exit(1);
+    }
     const skillDir = named?.dir ?? skillArg;
     const skill = loadSkill(skillDir);
+    // A skill that names the coding model (metadata.model: coding) runs on it, harness-model on the rest; --model wins.
+    const model = modelAsked ?? skillModel(cwd, skill.model === "coding" ? "coding" : "harness");
     console.log(c.bold(`skill: ${skill.name}`));
     for (const line of describeGates(skill))
         console.log(`  ${c.dim(line)}`);
@@ -97,7 +107,7 @@ async function main() {
     console.log(`\n${result.ok ? c.success(c.bold("run complete")) : c.error(c.bold("run aborted at a gate"))} ${c.dim(`artifacts in ${relative(cwd, skillRunDir(cwd, skill.name))}`)}`);
     process.exit(result.ok ? 0 : 1);
 }
-main().catch((err) => {
-    console.error(err);
+main().catch((error) => {
+    console.error(error instanceof Error ? error.message : error);
     process.exit(1);
 });

package/dist/drift-cli.js

@@ -1,4 +1,5 @@
 import { readProjectConfig, CONFIG_FILE } from "./config.js";
+import { refuseTestPlainFile } from "./test-plain-files.js";
 import { createJobRegistry } from "./regenerate/jobs.js";
 import { createWorkLoop, describeDrift } from "./regenerate/loop.js";
 const USAGE = `usage: turri drift [file.plain]
@@ -16,6 +17,7 @@ if (named === undefined) {
     process.exit(1);
 }
 try {
+    refuseTestPlainFile(named);
     const loop = createWorkLoop({ registry: createJobRegistry(), cwd: process.cwd(), planner: false, dryRun: true });
     console.log(describeDrift(loop.drift(named)));
 }

package/dist/extension.d.ts

@@ -4,6 +4,7 @@ import { stackOnMachine } from "./stack.ts";
 import { createAskUserTool } from "./tools.ts";
 import { fromWorkingDir } from "./loop-tools.ts";
 import { type WorkLoop } from "./regenerate/loop.ts";
+import { type TestAdvisor } from "./regenerate/advisor-runs.ts";
 import { type AskUser, type AskUserIO } from "./ask.ts";
 import { type TurriCore, type TurriHost } from "./chats.ts";
 /**
@@ -38,6 +39,11 @@ export type { TurriHost } from "./chats.ts";
 export declare function createTurriCore(host?: TurriHost, options?: {
     persist?: boolean;
     dialogs?: (chat: string) => AskUserIO | undefined;
+    /**
+     * Whether the session has a test advisor (docs/test-advisor.md): the terminal's chat and a host - never pi's print,
+     * json and rpc modes, which end when the answer is printed, nor a headless command, which builds its own loop.
+     */
+    advisor?: boolean;
 }): TurriCore;
 /** The session of this process: pi-launch.ts's, or one made as pi first builds the extension (`pi -e src/extension.ts`). */
 export declare function processSession(make?: () => TurriCore): TurriCore;
@@ -116,6 +122,15 @@ export declare function machineNeeds(cwd: string, work?: (cwd: string) => Return
  * tools' defaults.
  */
 export declare function projectConfigBlock(root: string): string;
+/**
+ * Conformance tests turned on, for the session: `conformance-tests: true` written where the module's value comes from
+ * (conformance-switch.ts), and every open chat's tools switched to match - what the chat's turn_on_conformance_tests and a
+ * host's turnOnConformanceTests both do. `plainFile`, absolute or from the project, picks the module whose stack's file
+ * is written when that names the key. Returns the file written, from the project. Starts no conformance pulse.
+ */
+export declare function turnOnConformance(core: TurriCore, plainFile?: string): string;
+/** The session's test advisor, when it has one: the chat's and a host's - never pi's print, json and rpc modes'. */
+export declare function sessionAdvisor(session: TurriCore): TestAdvisor | undefined;
 export { fromWorkingDir };
 /**
  * What the agent is to do with a job that just ended, unasked: what the project's guidance says to do then, or else say