@turri-dev/cli 0.1.9 → 0.1.10

package/dist/doctor-tool.d.ts

@@ -0,0 +1,11 @@
+import { type ToolDefinition } from "@earendil-works/pi-coding-agent";
+type AnyTool = ToolDefinition<any, any, any>;
+/**
+ * doctor: `turri doctor`'s checks from inside the conversation - this machine, and the project the conversation is in -
+ * against turri's own environment, the one its pulses run with, not the agent's shell's. Changes nothing; asks the
+ * project's models only when told to, a request a model.
+ */
+export declare function doctorTool(options: {
+    cwd: string;
+}): AnyTool;
+export {};

package/dist/doctor-tool.js

@@ -0,0 +1,33 @@
+import { join } from "node:path";
+import { defineTool } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+import { projectDirOf } from "./regenerate/paths.js";
+import { describeChecks, doctor, verdictOf } from "./setup.js";
+/**
+ * doctor: `turri doctor`'s checks from inside the conversation - this machine, and the project the conversation is in -
+ * against turri's own environment, the one its pulses run with, not the agent's shell's. Changes nothing; asks the
+ * project's models only when told to, a request a model.
+ */
+export function doctorTool(options) {
+    return defineTool({
+        name: "doctor",
+        label: "Doctor",
+        description: "Whether this machine and this project are ready for turri, as turri doctor checks it: Node, bash, git, which OS " +
+            "sandbox is up under the agents' commands, whether a model provider has credentials, the toolchains the modules' " +
+            "implementation reqs name and what the testing scripts run that this machine lacks - against the PATH turri's pulses " +
+            "run with. With models: true, each model config.turri.yaml names is asked for a word with this machine's credentials - " +
+            "a request a model, which costs money. Changes nothing.",
+        promptSnippet: "doctor: turri's self check - this machine and project, ready or what to fix",
+        promptGuidelines: [
+            "Use doctor, not `turri doctor` in the shell, to check whether this machine and project are ready - when the person asks, when a pulse fails for a missing toolchain or command, or before the first build on a machine. Ask the models (models: true) only when the person asks, or a model fails to answer: it costs a request a model.",
+        ],
+        parameters: Type.Object({
+            models: Type.Optional(Type.Boolean({ description: "Ask each model the project's config names for a word - one paid request a model. Default false" })),
+        }),
+        async execute(_id, params) {
+            const checks = await doctor({ dir: projectDirOf(join(options.cwd, "session.plain")), models: params.models === true });
+            const verdict = verdictOf(checks);
+            return { content: [{ type: "text", text: describeChecks(checks) }], details: { ready: verdict.ready, limited: verdict.limited } };
+        },
+    });
+}

package/dist/extension.js

@@ -46,6 +46,7 @@ import { defaultBuildDir } from "./regenerate/paths.js";
 import { describeTurnIncident, describeUsage, onModelEvent } from "./regenerate/activity.js";
 import { ledgerWanted, startLedger } from "./regenerate/ledger.js";
 import { describePastPulse, describeRuns, earlierPulses, ledgerProjects } from "./regenerate/ledger-view.js";
+import { doctorTool } from "./doctor-tool.js";
 import { ledgerTool } from "./ledger-tools.js";
 import { describeSpecConflict } from "./regenerate/stop-report.js";
 import { inheritProviders, inheritThinkingLevel } from "./pi.js";
@@ -1497,6 +1498,7 @@ function registerJobTools(pi, jobs, cwd) {
         },
     });
     pi.registerTool(ledgerTool({ cwd }));
+    pi.registerTool(doctorTool({ cwd }));
     pi.registerTool({
         name: "pulses",
         label: "Pulses",
@@ -1992,7 +1994,7 @@ export const JOB_FINISHED_REACTION = [
     "  JavaVirtualMachines, a version manager the person uses - mise, asdf, sdkman, nvm). Then ask the person with ask_user",
     "  to let you put it in place the way this machine installs things - the exact command, `brew install openjdk@21`,",
     "  `mise use -g java@21`, `sdk install maven` - and on yes run it in your shell, check that the command is found now as",
-    "  the testing script would find it (`command -v`, `turri doctor`), and resume. A tool installed where the PATH turri",
+    "  the testing script would find it (`command -v`, then the doctor tool, which looks on turri's own PATH), and resume. A tool installed where the PATH turri",
     "  was started with does not reach needs turri restarted: say so, with the line for the shell profile. On no, or when it",
     "  needs what you cannot do - sudo with a password, a licence, a download behind a login - tell the person exactly what",
     "  to do, and that \"resume\" picks it up once it is in.",

package/dist/host.d.ts

@@ -10,7 +10,9 @@ export type { AskUserIO } from "./ask.ts";
 export * as pi from "@earendil-works/pi-coding-agent";
 export { configForSpec, debugMode, hasProjectConfig, modelSpec, projectModels, readProjectConfig, stacksOf, type ProjectConfig } from "./config.ts";
 export { MODULES_DIR, projectDirOf, resolveTemplateDirs } from "./regenerate/paths.ts";
-export { BEDROCK_DEFAULT, BEDROCK_REGIONS, bedrockModels, initConfig, VENDORS, type BedrockChoice, type Vendor } from "./init-config.ts";
+export { BEDROCK_DEFAULT, BEDROCK_GEOGRAPHIES, BEDROCK_IN_REGION, BEDROCK_REGIONS, bedrockAwsRegion, bedrockDefaultModels, bedrockMakers, bedrockModels, bedrockModelsIn, bedrockNeedsAwsRegion, bedrockPlaceOf, initConfig, makerLabel, VENDORS, type BedrockChoice, type BedrockMaker, type BedrockOffer, type InitConfigOptions, type ModelChoice, type ModelSet, type Vendor, } from "./init-config.ts";
+export { piModelCatalogue, type CatalogueModel, type ModelCatalogue } from "./model-check.ts";
+export { doctor, type Check, type DoctorOptions, type Level } from "./setup.ts";
 export { checkPlainFile, type CheckResult } from "./plain/check.ts";
 export { plainFileParser } from "./plain/parser.ts";
 export { FUNCTIONAL_REQUIREMENTS, iterateFunctionalSpecs } from "./plain/spec.ts";

package/dist/host.js

@@ -11,8 +11,12 @@ export * as pi from "@earendil-works/pi-coding-agent";
 // The project and its settings.
 export { configForSpec, debugMode, hasProjectConfig, modelSpec, projectModels, readProjectConfig, stacksOf } from "./config.js";
 export { MODULES_DIR, projectDirOf, resolveTemplateDirs } from "./regenerate/paths.js";
-// A project's first config.turri.yaml, as `turri init-config` writes it - the vendor whose models it takes chosen by the host.
-export { BEDROCK_DEFAULT, BEDROCK_REGIONS, bedrockModels, initConfig, VENDORS } from "./init-config.js";
+// A project's first config.turri.yaml, as `turri init-config` writes it - the vendor, or the two models themselves, chosen by the host.
+export { BEDROCK_DEFAULT, BEDROCK_GEOGRAPHIES, BEDROCK_IN_REGION, BEDROCK_REGIONS, bedrockAwsRegion, bedrockDefaultModels, bedrockMakers, bedrockModels, bedrockModelsIn, bedrockNeedsAwsRegion, bedrockPlaceOf, initConfig, makerLabel, VENDORS, } from "./init-config.js";
+// pi's model catalogue, read without a request: what initConfig checks the models given against, and what a host offers.
+export { piModelCatalogue } from "./model-check.js";
+// Whether this machine, and a project on it, is ready for turri - as `turri doctor` checks it, printing nothing.
+export { doctor } from "./setup.js";
 // A spec: parsed, checked, coloured.
 export { checkPlainFile } from "./plain/check.js";
 export { plainFileParser } from "./plain/parser.js";

package/dist/init-config.d.ts

@@ -1,3 +1,4 @@
+import { type CatalogueModel, type ModelCatalogue } from "./model-check.ts";
 /**
  * `turri init-config`: a project's first config.turri.yaml - the two models, a strong one to talk to and a smaller one to
  * write the code - so a new project starts with a choice that works rather than an empty file. It asks which vendor's
@@ -8,29 +9,80 @@
  * Then it says what to do next: where the file is - turri reads it from that folder and the folders below it, nowhere
  * else - and how to sign in to the vendor so pi, which turri runs on, can reach the models.
  *
- * Amazon Bedrock serves Anthropic's and OpenAI's models in a geography each - an inference profile, `eu.`, `us.`,
- * `global.` - so it asks which of the two, and where. A config.turri.yaml already there keeps everything but the two models; a new one takes
- * from a config.yaml beside it the keys turri reads too.
+ * Amazon Bedrock serves many makers' models - Anthropic's, OpenAI's, xAI's, Meta's... - each in a geography, an inference
+ * profile its id starts with (`global.`, `us.`, `eu.`, ...), or in the AWS region it is called in: it asks whose, where, and
+ * which two, from pi's catalogue - turri's own pair offered where it has one. The two models can be given instead, any pair
+ * pi's catalogue has, and are checked against it. A config.turri.yaml already there keeps everything but the two models; a
+ * new one takes from a config.yaml beside it the keys turri reads too.
  */
 /** A vendor whose models the quick start config is filled in with. */
 export type Vendor = "anthropic" | "openai" | "google" | "amazon-bedrock" | "other";
-/** Whose models Amazon Bedrock serves here. */
-export type BedrockMaker = "anthropic" | "openai";
-/** Amazon Bedrock's choice: whose models, and the geography of the inference profile they run in. */
+/** Whose models Amazon Bedrock serves: the maker a model's id names after its geography - anthropic, openai, xai, meta... */
+export type BedrockMaker = string;
+/**
+ * Amazon Bedrock's choice: the geography of the inference profile the models run in, and whose they are - read from the
+ * models when they are given, Anthropic's when nothing says.
+ */
 export interface BedrockChoice {
-    maker: BedrockMaker;
+    maker?: BedrockMaker;
     region: string;
 }
-/** The geographies Bedrock serves each maker's two models in, as pi knows them - the first the default. */
-export declare const BEDROCK_REGIONS: Record<BedrockMaker, string[]>;
-/** Bedrock's models for a maker in a geography: Opus 5.5 and Haiku 5.5, or GPT-6 Astra and Luna. */
-export declare function bedrockModels(choice: BedrockChoice): {
+/** The three models a config names: the one you talk to, the one that codes, and a strong one for the judging examples. */
+export interface ModelSet {
     harness: string;
     coding: string;
     strong: string;
+}
+/** The two models given, full specs without a thinking level - `amazon-bedrock/global.xai.grok-4.7`; strong is harness unless named. */
+export type ModelChoice = Omit<ModelSet, "strong"> & {
+    strong?: string;
 };
+/** The makers turri has a pair of its own for on Bedrock. */
+type PresetMaker = "anthropic" | "openai";
+/** The geographies turri's own pair for each maker is served in - the first the default. Every other: bedrockMakers. */
+export declare const BEDROCK_REGIONS: Record<PresetMaker, string[]>;
+/** The geographies an inference profile's id starts with, in the order they are offered. */
+export declare const BEDROCK_GEOGRAPHIES: string[];
+/** A Bedrock model whose id names no geography: served in the AWS region it is called in. */
+export declare const BEDROCK_IN_REGION = "in-region";
+/** The AWS region to call a geography's models in - AWS_REGION's value. */
+export declare function bedrockAwsRegion(geography: string): string;
+/**
+ * Whether a geography's models need AWS_REGION set: every one but global, us and in-region, which pi's us-east-1 serves.
+ * pi calls Bedrock in AWS_REGION, else - with an AWS_PROFILE - the profile's region, else us-east-1. It pins eu's
+ * endpoint itself only with neither AWS_REGION nor AWS_PROFILE set, so eu needs it too.
+ */
+export declare function bedrockNeedsAwsRegion(geography: string): boolean;
+/** Where a Bedrock model is served and whose it is, from its id or spec: `global.xai.grok-4.7` - global, xai; `meta.llama4` - in-region, meta. */
+export declare function bedrockPlaceOf(model: string): {
+    geography: string;
+    maker: BedrockMaker;
+};
+/** A maker's - or a provider's - name, as the messages say it: xAI for xai; its id when turri has no name for it. */
+export declare function makerLabel(maker: string): string;
+/** A maker pi's catalogue serves on Bedrock, and the geographies it serves its chat models in - in the order they are offered. */
+export interface BedrockOffer {
+    maker: BedrockMaker;
+    label: string;
+    regions: string[];
+}
+/** Every maker pi's catalogue serves on Bedrock - Anthropic and OpenAI first, the rest by name - with their geographies. */
+export declare function bedrockMakers(catalogue: ModelCatalogue): BedrockOffer[];
+/** A maker's chat models in a geography, as pi's catalogue has them on Bedrock. */
+export declare function bedrockModelsIn(catalogue: ModelCatalogue, choice: Required<BedrockChoice>): CatalogueModel[];
+/** turri's own pair on Bedrock for a maker in a geography: Opus 5.5 and Haiku 5.5, or GPT-6 Astra and Luna. */
+export declare function bedrockModels(choice: {
+    maker?: PresetMaker;
+    region: string;
+}): ModelSet;
+/**
+ * The pair to offer for a maker in a geography: turri's own where it has one; else, from pi's catalogue, the strongest
+ * that reasons to talk to - price standing in for strength - and the cheapest costing at least a fifth of it to code,
+ * ties to the newest. Undefined when the catalogue has none of the maker's models there.
+ */
+export declare function bedrockDefaultModels(catalogue: ModelCatalogue, choice: BedrockChoice): ModelSet | undefined;
 /** Bedrock's default: Anthropic's models, anywhere. */
-export declare const BEDROCK_DEFAULT: BedrockChoice;
+export declare const BEDROCK_DEFAULT: Required<BedrockChoice>;
 interface VendorPreset {
     label: string;
     /** The model you talk to: it writes the specs and plans the work. */
@@ -72,16 +124,16 @@ export declare const DEFAULTS: {
 };
 /** How many pulses run at once without a setting: half this machine's cores, one to four - as regenerate/jobs.ts has it. */
 export declare function defaultParallel(cores?: number): number;
-/** The quick start config.turri.yaml for a vendor's models - for Bedrock, the maker and geography chosen. */
-export declare function quickStartConfig(vendor?: Vendor, bedrock?: BedrockChoice): string;
+/** The quick start config.turri.yaml for a vendor's models - for Bedrock, the maker and geography chosen - or the models given. */
+export declare function quickStartConfig(vendor?: Vendor, bedrock?: BedrockChoice, models?: ModelSet): string;
 /** The quick start config for the mix of vendors: what turri wrote before it asked. */
 export declare const QUICK_START_CONFIG: string;
 /** A vendor from what was typed: its number in the list, or its name. */
 export declare function vendorOf(answer: string): Vendor | undefined;
-/** Bedrock's maker from what was typed: its number - 1 Anthropic, 2 OpenAI - or its name. */
-export declare function bedrockMakerOf(answer: string): BedrockMaker | undefined;
-/** A geography the maker's models are served in, from what was typed: its number in the list, or its name. */
-export declare function bedrockRegionOf(maker: BedrockMaker, answer: string): string | undefined;
+/** Bedrock's maker from what was typed: its number in the list - with no catalogue, 1 Anthropic, 2 OpenAI - or its name. */
+export declare function bedrockMakerOf(answer: string, catalogue?: ModelCatalogue): BedrockMaker | undefined;
+/** A geography the maker's models are served in, from what was typed: its number in the list, or its name - pi's catalogue's, or without it turri's pair's. */
+export declare function bedrockRegionOf(maker: BedrockMaker, answer: string, catalogue?: ModelCatalogue): string | undefined;
 /**
  * What a config.yaml in `folder` says that turri reads too - another tool's testing scripts, say - by turri's names
  * (`template_dir` read as `template-dir`), in the file's order; and the keys it leaves, turri reading none of them. The
@@ -91,19 +143,27 @@ export declare function sharedWithLegacy(folder: string): {
     carried: Array<[string, unknown]>;
     left: string[];
 };
-/**
- * Write the quick start config.turri.yaml in `dir`, with what a config.yaml beside it says that turri reads too. One already
- * there keeps everything but its two models, which are set to the vendor's - `force` writes the whole of it again. Says
- * what it did.
- */
-export declare function initConfig(dir: string, options?: {
+export interface InitConfigOptions {
+    /** Write the whole file again, not only the two models of one already there. */
     force?: boolean;
+    /** Whose models: read from the models when they are given, other when nothing says. */
     vendor?: Vendor;
+    /** On Amazon Bedrock: the geography, and whose models - read from the models when they are given. */
     bedrock?: BedrockChoice;
-}): {
+    /** The two models - any pair pi's catalogue has as chat models - in place of the vendor's own. */
+    models?: ModelChoice;
+    /** pi's catalogue, to check the models against - read from pi when it is needed and not given. */
+    catalogue?: ModelCatalogue;
+}
+/**
+ * Write the quick start config.turri.yaml in `dir`, with what a config.yaml beside it says that turri reads too. One already
+ * there keeps everything but its two models, which are set to the vendor's - or the ones given - and `force` writes the
+ * whole of it again. Says what it did; a model pi's catalogue does not have writes nothing and says so.
+ */
+export declare function initConfig(dir: string, options?: InitConfigOptions): Promise<{
     written: boolean;
     message: string;
-};
-/** `turri init-config [--vendor <vendor>] [--maker <maker>] [--region <geography>] [--force] [folder]`. */
+}>;
+/** `turri init-config [--vendor <vendor>] [--maker <maker>] [--region <geography>] [--harness-model <spec> --coding-model <spec>] [--force] [folder]`. */
 export declare function main(args: string[]): Promise<number>;
 export {};