@turri-dev/cli 0.0.0-stage → 0.1.2-next.48dacfc

package/dist/model-check.js

@@ -0,0 +1,117 @@
+import { join } from "node:path";
+import { getAgentDir, ModelRegistry, ModelRuntime } from "@earendil-works/pi-coding-agent";
+import { AGENT_ROLES, projectModels, roleModel } from "./config.js";
+/** Every model the config uses, each once, with the settings that name it - the two models first. */
+export function modelsInUse(config) {
+    const used = new Map();
+    const add = (spec, by) => {
+        if (spec === undefined)
+            return;
+        used.set(spec, [...(used.get(spec) ?? []), by]);
+    };
+    const { harness, coding } = projectModels(config);
+    add(harness?.model, "harness-model");
+    add(coding?.model, "coding-model");
+    add(config.judgeModel?.model, "judge-model");
+    // A role named under models: runs on its own model - or what it inherits, when its entry names only how it thinks.
+    for (const role of AGENT_ROLES) {
+        if (config.models?.[role] === undefined || role === "chat" || role === "coding")
+            continue;
+        add(roleModel(config, role)?.model, `models.${role}`);
+    }
+    add(config.models?.default?.model, "models.default");
+    return [...used].map(([spec, usedBy]) => ({ spec, usedBy: [...new Set(usedBy)] }));
+}
+/** pi's own model runtime, with pi's credentials - auth.json, models.json and the environment - as turri's agents have them. */
+export async function piModelAccess() {
+    const agentDir = getAgentDir();
+    const runtime = await ModelRuntime.create({ authPath: join(agentDir, "auth.json"), modelsPath: join(agentDir, "models.json") });
+    const registry = new ModelRegistry(runtime);
+    return {
+        find: (provider, id) => registry.find(provider, id),
+        known: (provider) => runtime.getModels(provider).map((model) => model.id),
+        async ask(model) {
+            try {
+                const reply = await runtime.completeSimple(model, { messages: [{ role: "user", content: "Reply with the one word: ok", timestamp: Date.now() }] }, { maxTokens: 64, signal: AbortSignal.timeout(60_000) });
+                return reply.stopReason === "error" || reply.stopReason === "aborted" ? (reply.errorMessage ?? `the request ended: ${reply.stopReason}`) : undefined;
+            }
+            catch (error) {
+                return error instanceof Error ? error.message : String(error);
+            }
+        },
+    };
+}
+/** The credentials pi reads for a provider, as its sign-in says them. */
+function signIn(provider) {
+    const keys = {
+        anthropic: "ANTHROPIC_API_KEY, or /login in turri",
+        openai: "OPENAI_API_KEY, or /login in turri",
+        google: "GEMINI_API_KEY",
+        "amazon-bedrock": "AWS_PROFILE (aws configure, or aws sso login) or AWS_BEARER_TOKEN_BEDROCK, and AWS_REGION",
+    };
+    return keys[provider] ?? `the key pi reads for ${provider}, or /login in turri - https://pi.dev lists them`;
+}
+/** What to do about a provider's error, from what it says. */
+export function fixFor(provider, problem) {
+    const text = problem.toLowerCase();
+    if (/access (to|denied).*model|don't have access|not authorized to (invoke|access)|model access|accessdenied/.test(text) && provider === "amazon-bedrock") {
+        return "ask for access to this model in the Bedrock console, under model access - for the region in AWS_REGION";
+    }
+    if (/provider is not configured|no credentials|not logged in/.test(text))
+        return `sign in to ${provider}: ${signIn(provider)}`;
+    if (/401|403|unauthori[sz]ed|forbidden|invalid.*(api key|x-api-key|token|credential)|credential|security token|could not load|unable to locate|expired|no api key|missing api key|authentication/.test(text)) {
+        return `check the credentials pi reads for ${provider}: ${signIn(provider)}`;
+    }
+    if (/region|endpoint|enotfound|getaddrinfo/.test(text))
+        return provider === "amazon-bedrock" ? "check AWS_REGION: the model has to be served there" : "check the network, and the provider's endpoint";
+    if (/not found|404|does not exist|unknown model|invalid model/.test(text))
+        return "the provider does not serve this model id: change it in config.turri.yaml";
+    if (/429|rate|quota|overloaded|capacity/.test(text))
+        return "the provider is busy or the quota is used up: try again later";
+    if (/timeout|timed out|aborted/.test(text))
+        return "the provider did not answer in time: check the network, then try again";
+    return `see what the provider said; the credentials pi reads for ${provider}: ${signIn(provider)}`;
+}
+/** How many characters two names share from their start. */
+function commonPrefix(a, b) {
+    let at = 0;
+    while (at < a.length && at < b.length && a[at] === b[at])
+        at += 1;
+    return at;
+}
+/** Each model the config uses, tried: answered, or what is wrong and what to do. One request a model. */
+export async function checkModels(models, access) {
+    return Promise.all(models.map(async ({ spec, usedBy }) => {
+        const slash = spec.indexOf("/");
+        if (slash === -1)
+            return { ok: false, spec, usedBy, problem: "not provider/model-id", fix: "write it as provider/model-id - amazon-bedrock/global.openai.gpt-6-astra" };
+        const [provider, id] = [spec.slice(0, slash), spec.slice(slash + 1)];
+        const model = access.find(provider, id);
+        if (model === undefined) {
+            const known = access.known(provider);
+            if (known.length === 0)
+                return { ok: false, spec, usedBy, problem: `pi knows no provider ${provider}`, fix: "use a provider pi supports - https://pi.dev" };
+            // The closest first: the most of its words in common - claude, haiku - then the most of its characters in order.
+            const words = id.toLowerCase().split(/[^a-z0-9]+/).filter((word) => word !== "");
+            const score = (other) => {
+                const theirs = other.toLowerCase().split(/[^a-z0-9]+/);
+                return words.filter((word) => theirs.includes(word)).length * 100 + commonPrefix(id.toLowerCase(), other.toLowerCase());
+            };
+            const scored = known.map((other) => ({ other, score: score(other) })).filter((entry) => entry.score >= 100);
+            // Only those sharing as many words as the best: claude-haiku-* for claude-haiku-9-9, not every claude.
+            const most = Math.max(0, ...scored.map((entry) => Math.floor(entry.score / 100)));
+            const close = scored
+                .filter((entry) => Math.floor(entry.score / 100) === most)
+                .sort((a, b) => b.score - a.score)
+                .slice(0, 3)
+                .map((entry) => entry.other);
+            return { ok: false, spec, usedBy, problem: `pi knows no model ${id} at ${provider}`, fix: close.length > 0 ? `did you mean ${close.map((other) => `${provider}/${other}`).join(", ")}?` : `change it in config.turri.yaml to a model pi knows at ${provider}` };
+        }
+        const started = Date.now();
+        const problem = await access.ask(model);
+        if (problem === undefined)
+            return { ok: true, spec, usedBy, ms: Date.now() - started };
+        const said = problem.split("\n").find((line) => line.trim() !== "")?.trim().slice(0, 300) ?? problem;
+        return { ok: false, spec, usedBy, problem: said, fix: fixFor(provider, problem) };
+    }));
+}

package/dist/module-report.js

@@ -0,0 +1,9 @@
+/** Colours for what the command line prints. */
+export const c = {
+    dim: (s) => `\x1b[2m${s}\x1b[0m`,
+    bold: (s) => `\x1b[1m${s}\x1b[0m`,
+    green: (s) => `\x1b[32m${s}\x1b[0m`,
+    red: (s) => `\x1b[31m${s}\x1b[0m`,
+    yellow: (s) => `\x1b[33m${s}\x1b[0m`,
+    cyan: (s) => `\x1b[36m${s}\x1b[0m`,
+};

package/dist/pi-launch.js

@@ -0,0 +1,31 @@
+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 { dirname, join } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { main, SettingsManager } from "@earendil-works/pi-coding-agent";
+import "./terminal-images.js";
+/**
+ * pi, started the way its own CLI starts it, for `turri`.
+ *
+ * The one difference: pi's startup header - its version, key hints and the list of every
+ * loaded skill, extension and theme - is left out, because turri shows its own. pi only
+ * takes that from the `quietStartup` setting, and a setting would quiet every `pi` on the
+ * machine, so it is answered for this run instead. `--verbose` still shows it.
+ */
+const args = process.argv.slice(2);
+if (!args.includes("--verbose")) {
+    SettingsManager.prototype.getQuietStartup = () => true;
+}
+// pi's own keys stand: a new line is shift+enter or ctrl+j. turri's side panel is on ctrl+h (job-panel.ts PANEL_KEY).
+// What pi's CLI does before main: the process title, pi's environment markers, the HTTP
+// dispatcher. Not exported, so loaded from the file - beside pi's entry point, wherever npm put it.
+const setup = pathToFileURL(join(dirname(fileURLToPath(import.meta.resolve("@earendil-works/pi-coding-agent"))), "cli", "setup.js")).href;
+const { setupCli } = (await import(__rewriteRelativeImportExtension(setup)));
+setupCli();
+await main(args);