@turri-dev/cli 0.2.0 → 0.2.1-next.bc56a0d

package/dist/setup.js

@@ -1,18 +1,21 @@
 import { spawnSync } from "node:child_process";
+import { spawnAsync } from "./spawn-async.js";
 import { existsSync, rmSync, statSync } from "node:fs";
 import { join, relative, resolve } 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, sandboxWith } from "./regenerate/os-sandbox.js";
+import { ModelRegistry } from "@earendil-works/pi-coding-agent";
+import { EXTENSION_PROVIDERS, installedProviders, runtimeWithProviders } from "./installed-providers.js";
+import { globalExtensionFile, MIN_NODE, nodeVersionOk, PACKAGE_ROOT, turriIdentity } from "./environment.js";
+import { fetchLatest, newerThan, turrisOnPath, versionFindings } from "./turri-versions.js";
+import { sandboxAvailable, sandboxWithAsync } from "./regenerate/os-sandbox.js";
 import { findTestScripts, onThisMachine } from "./regenerate/test-scripts.js";
 import { configKeyOptions, parseArgs } from "./cli-options.js";
 import { CONFIG_FILE, hasProjectConfig, readProjectConfig, stackConfigFile, stackOf, stacksOf } from "./config.js";
 import { checkModels, modelsInUse, piModelAccess } from "./model-check.js";
 import { bedrockRegionFor, describeBedrockRegion, regionInGeography } from "./bedrock-region.js";
-import { baseFiles } from "./regenerate/base-folder.js";
+import { baseFilesAsync } from "./regenerate/base-folder.js";
 import { brand } from "./brand.js";
-import { readScript, scriptAgainstMachine, stackOnMachine } from "./stack.js";
+import { readScript, scriptAgainstMachine, stackOnMachineAsync } from "./stack.js";
 const MARK = { ok: "✓", missing: "✗", limited: "!", info: "·" };
 function checkNode() {
     const version = process.versions.node;
@@ -66,9 +69,9 @@ export function checkSandbox(wall = sandboxAvailable(), platform = process.platf
  * 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 = {}) {
+export async function checkProject(project, machine = {}) {
     const checks = [];
-    for (const { module, needs, missing } of stackOnMachine(project, machine.has, machine.jdk)) {
+    for (const { module, needs, missing } of await stackOnMachineAsync(project, machine.has, machine.jdk)) {
         if (needs.length === 0)
             continue;
         checks.push(missing.length === 0
@@ -99,9 +102,10 @@ export function checkProject(project, machine = {}) {
     }
     return checks;
 }
-async function checkProvider() {
+async function checkProvider(project = process.cwd()) {
     try {
-        const runtime = await ModelRuntime.create();
+        // pi's providers, and those the person's installed pi extensions register - a Claude subscription through Claude Code.
+        const runtime = await runtimeWithProviders(await installedProviders(project));
         const available = new ModelRegistry(runtime).getAvailable();
         const providers = [...new Set(available.map((model) => model.provider))];
         if (providers.length > 0) {
@@ -118,17 +122,46 @@ async function checkProvider() {
         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 itself: whether it is the newest npm has - asked now - and every turri on the PATH, which runs, and what hides a
+ * newer one behind an older (turri-versions.ts). What to do, said under each.
+ */
+async function checkTurri() {
+    const own = turriIdentity();
+    const onPath = turrisOnPath();
+    const latest = own.git_commit === null ? await fetchLatest() : undefined;
+    const findings = versionFindings({ ...(latest !== undefined ? { latest } : {}), onPath });
+    const version = own.version ?? "?";
+    const outdated = findings.find((finding) => finding.kind === "outdated");
+    const versionCheck = own.git_commit !== null
+        ? { level: "info", name: "turri version", detail: `${version}, from a clone - not compared with npm` }
+        : outdated !== undefined
+            ? { level: "limited", name: "turri version", detail: outdated.text, fix: outdated.fixes.join("; ") }
+            : latest === undefined
+                ? { level: "info", name: "turri version", detail: `${version} - npm did not answer, so it is not compared` }
+                : own.version !== null && newerThan(latest, own.version)
+                    ? // Older than npm's, with a newer turri installed already: the PATH check says which, and what hides it.
+                        { level: "limited", name: "turri version", detail: `${version} - npm has ${latest}, and a newer turri is installed already: see turri on PATH` }
+                    : { level: "ok", name: "turri version", detail: `${version} - the newest on npm` };
+    if (onPath.length === 0) {
+        return [
+            versionCheck,
+            {
+                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",
+            },
+        ];
+    }
+    const copies = onPath.map((turri) => `${turri.path}  turri ${turri.version ?? "?"}  (${[turri.runs ? "runs" : "hidden", ...(turri.self ? ["this one"] : []), ...(turri.clone ? ["a clone"] : [])].join(", ")})`);
+    const hidden = findings.filter((finding) => finding.kind !== "outdated");
+    const pathCheck = hidden.length > 0
+        ? // Every turri, then what to do, in order: a step a line.
+            { level: "missing", name: "turri on PATH", detail: hidden[0].text, more: [...copies, ...hidden.flatMap((finding) => finding.fixes).map((fix) => `→ ${fix}`)] }
+        : { level: "ok", name: "turri on PATH", detail: onPath.length === 1 ? onPath[0].path : `${onPath.length} turris - the first, which runs, is the newest`, ...(onPath.length > 1 ? { more: copies } : {}) };
+    return [versionCheck, pathCheck];
 }
 /**
  * turri loaded into every `pi` - a file an older `turri setup` wrote into pi's extensions. turri and pi are kept apart
@@ -175,9 +208,9 @@ export async function checkProjectModels(project, access) {
 function asksModels(options) {
     return options.models === true && options.dir !== undefined && (hasProjectConfig(options.dir) || options.modelsGiven === true);
 }
-/** Whether `command` runs with `env` - its PATH looked in, as the agents' shells and the testing scripts would. */
-function runs(command, env) {
-    return spawnSync(command, ["--version"], { stdio: "ignore", windowsHide: true, env }).status === 0;
+/** Whether `command` runs with `env` - its PATH looked in, as the agents' shells and the testing scripts would. Never holds a host's thread up. */
+async function runs(command, env) {
+    return (await spawnAsync(command, ["--version"], { env })).status === 0;
 }
 /**
  * Whether this machine - and, with `dir`, that project - is ready for turri, as checks. It prints nothing and asks
@@ -188,41 +221,94 @@ export async function doctor(options = {}) {
 }
 async function allChecks(options) {
     const env = options.env ?? process.env;
-    const checks = [checkNode(), checkShell(runs("bash", env)), checkGit(runs("git", env)), checkSandbox(sandboxWith(env)), await checkProvider()];
+    // Each check that runs a command runs it without holding the thread up - a host asks on its own - side by side.
+    const [bash, git, wall, provider] = await Promise.all([runs("bash", env), runs("git", env), sandboxWithAsync(env), checkProvider(options.dir)]);
+    const checks = [checkNode(), checkShell(bash), checkGit(git), checkSandbox(wall), provider];
     if (options.cli === true)
-        checks.push(checkPath(), ...checkGlobal());
+        checks.push(...(await checkTurri()), ...checkGlobal());
     // In a project: what it needs of this machine, and whether its models answer.
     const project = options.dir;
     if (project === undefined)
         return checks;
     if (hasProjectConfig(project) || existsSync(join(project, "plain_modules")))
-        checks.push(...checkProject(project, { has: (command) => onThisMachine(command, env) !== undefined }));
+        checks.push(...(await checkProject(project, { has: (command) => onThisMachine(command, env) !== undefined })));
     if (hasProjectConfig(project))
-        checks.push(...checkBedrockRegion(project, env), ...checkBaseFolders(project));
+        checks.push(...checkBedrockRegion(project, env), ...(await checkClaudeSubscription(project, env)), ...(await checkBaseFolders(project)));
     if (asksModels(options))
         checks.push(...(await checkProjectModels(project)));
     return checks;
 }
+/** The environment pi-claude-code refuses to run with: each points Claude Code at an API key or another backend, not the subscription. */
+export const CLAUDE_CODE_CONFLICTS = ["ANTHROPIC_API_KEY", "ANTHROPIC_AUTH_TOKEN", "ANTHROPIC_BASE_URL", "ANTHROPIC_FOUNDRY_API_KEY"];
+const CLAUDE_CODE_BACKENDS = ["CLAUDE_CODE_USE_BEDROCK", "CLAUDE_CODE_USE_VERTEX", "CLAUDE_CODE_USE_FOUNDRY"];
+const claudeCodeProbe = (project) => ({
+    installed: async () => (await installedProviders(project))?.getRegisteredProviderIds().includes("claude-code") === true,
+    async status(command, env) {
+        const run = await spawnAsync(command, ["auth", "status"], { env, timeout: 15_000 });
+        if (run.error !== undefined)
+            return undefined;
+        try {
+            return JSON.parse(run.stdout);
+        }
+        catch {
+            return { loggedIn: false };
+        }
+    },
+    which: (command, env) => (command.includes("/") ? (existsSync(command) ? command : undefined) : onThisMachine(command, env)),
+});
+/**
+ * A Claude subscription through Claude Code, when the project's config names a `claude-code/...` model: everything
+ * pi-claude-code needs, in the order it needs it - its extension installed, Claude Code on the PATH, signed in to a Pro or
+ * Max subscription, and nothing in the environment it refuses. Nothing when no model is a claude-code one.
+ */
+export async function checkClaudeSubscription(project, env = process.env, probe = claudeCodeProbe(project)) {
+    const configs = [readProjectConfig(project), ...stacksOf(project).map((stack) => readProjectConfig(project, stack))];
+    const named = [...new Set(configs.flatMap((config) => modelsInUse(config)).filter((used) => used.spec.startsWith("claude-code/")).map((used) => used.spec))];
+    if (named.length === 0)
+        return [];
+    const name = "Claude subscription";
+    const extension = EXTENSION_PROVIDERS["claude-code"];
+    if (!(await probe.installed())) {
+        return [{ level: "missing", name, detail: `${named.join(", ")} need pi-claude-code, pi's extension for a Claude subscription, which is not installed`, fix: extension.install }];
+    }
+    const command = env.PI_CLAUDE_CODE_COMMAND?.trim() || "claude";
+    const found = probe.which(command, env);
+    if (found === undefined) {
+        return [{ level: "missing", name, detail: `Claude Code (${command}) is not on the PATH - every claude-code request goes through it`, fix: "npm install -g @anthropic-ai/claude-code - or name it in PI_CLAUDE_CODE_COMMAND" }];
+    }
+    const configDir = env.PI_CLAUDE_CODE_CONFIG_DIR?.trim();
+    const status = await probe.status(found, configDir ? { ...env, CLAUDE_CONFIG_DIR: configDir } : env);
+    if (status?.loggedIn !== true)
+        return [{ level: "missing", name, detail: `Claude Code (${found}) is not signed in`, fix: "claude auth login - with the Claude account that has the Pro or Max subscription" }];
+    if (status.subscriptionType === undefined || status.subscriptionType === "") {
+        return [{ level: "missing", name, detail: `Claude Code is signed in${status.authMethod !== undefined ? ` (${status.authMethod})` : ""}, but not to a Claude subscription`, fix: "claude auth logout, then claude auth login with the account that has the Pro or Max subscription" }];
+    }
+    const conflicts = [...CLAUDE_CODE_CONFLICTS.filter((key) => (env[key] ?? "") !== ""), ...CLAUDE_CODE_BACKENDS.filter((key) => /^(1|true|yes|on)$/i.test(env[key]?.trim() ?? ""))];
+    if (conflicts.length > 0) {
+        return [{ level: "missing", name, detail: `${conflicts.join(", ")} ${conflicts.length === 1 ? "is" : "are"} set: pi-claude-code refuses to run with ${conflicts.length === 1 ? "it" : "them"}, as ${conflicts.length === 1 ? "it points" : "they point"} Claude Code away from the subscription`, fix: `unset ${conflicts.join(" ")} where turri starts - your shell's profile, say` }];
+    }
+    return [{ level: "ok", name, detail: `pi-claude-code installed, Claude Code signed in to ${status.subscriptionType} - for ${named.join(", ")}` }];
+}
 /**
  * The base folders the project's config names - its own, and each stack's - each there with its files, or not: a codebase
  * that requires nothing starts from one, and its first pulse stops when it is not there. Nothing when none is named.
  */
-export function checkBaseFolders(project) {
+export async function checkBaseFolders(project) {
     const named = new Map();
     for (const [stack, config] of [[undefined, readProjectConfig(project)], ...stacksOf(project).map((stack) => [stack, readProjectConfig(project, stack)])]) {
         if (config.baseFolder === undefined)
             continue;
         named.set(config.baseFolder, [...(named.get(config.baseFolder) ?? []), stack === undefined ? CONFIG_FILE : stackConfigFile(stack)]);
     }
-    return [...named].map(([folder, files]) => {
+    return Promise.all([...named].map(async ([folder, files]) => {
         const path = resolve(project, folder);
         const name = `base folder ${folder}`;
         if (!existsSync(path) || !statSync(path).isDirectory()) {
             return { level: "missing", name, detail: `${existsSync(path) ? "not a folder" : "not there"} - named in ${files.join(", ")}`, fix: "make the folder, or name the right one in base-folder:, by path from the project's folder" };
         }
-        const count = baseFiles(path).length;
+        const count = (await baseFilesAsync(path)).length;
         return { level: "ok", name, detail: `${count} file${count === 1 ? "" : "s"} to start a codebase from - named in ${files.join(", ")}` };
-    });
+    }));
 }
 /**
  * The AWS region a project's Bedrock models are called in, when it uses any: turri's, the person's or the profile's - and

package/dist/spawn-async.d.ts

@@ -0,0 +1,18 @@
+/** A command's run, as `spawnSync` gives it - its exit status (null when it did not exit), its output, what kept it from starting. */
+export interface AsyncRun {
+    status: number | null;
+    stdout: string;
+    stderr: string;
+    error?: Error;
+}
+/**
+ * A command run without holding the thread up - `spawnSync`'s answer, awaited. For what a host asks on its own thread
+ * (doctor): a check never keeps the host from answering meanwhile. `timeout` kills it after that many milliseconds.
+ */
+export declare function spawnAsync(command: string, args: string[], options?: {
+    env?: NodeJS.ProcessEnv;
+    timeout?: number;
+    cwd?: string;
+}): Promise<AsyncRun>;
+/** The host's turn: whatever waits on its thread runs before the next step of a long piece of work. */
+export declare const yieldToHost: () => Promise<void>;

package/dist/spawn-async.js

@@ -0,0 +1,35 @@
+import { spawn } from "node:child_process";
+/**
+ * A command run without holding the thread up - `spawnSync`'s answer, awaited. For what a host asks on its own thread
+ * (doctor): a check never keeps the host from answering meanwhile. `timeout` kills it after that many milliseconds.
+ */
+export function spawnAsync(command, args, options = {}) {
+    return new Promise((resolve) => {
+        let stdout = "";
+        let stderr = "";
+        let settled = false;
+        const done = (run) => {
+            if (settled)
+                return;
+            settled = true;
+            if (timer !== undefined)
+                clearTimeout(timer);
+            resolve(run);
+        };
+        let child;
+        try {
+            child = spawn(command, args, { env: options.env, cwd: options.cwd, stdio: ["ignore", "pipe", "pipe"], windowsHide: true });
+        }
+        catch (error) {
+            done({ status: null, stdout, stderr, error: error instanceof Error ? error : new Error(String(error)) });
+            return;
+        }
+        const timer = options.timeout !== undefined ? setTimeout(() => child.kill("SIGKILL"), options.timeout) : undefined;
+        child.stdout?.setEncoding("utf8").on("data", (chunk) => (stdout += chunk));
+        child.stderr?.setEncoding("utf8").on("data", (chunk) => (stderr += chunk));
+        child.on("error", (error) => done({ status: null, stdout, stderr, error }));
+        child.on("close", (status) => done({ status, stdout, stderr }));
+    });
+}
+/** The host's turn: whatever waits on its thread runs before the next step of a long piece of work. */
+export const yieldToHost = () => new Promise((resolve) => setImmediate(resolve));

package/dist/stack.d.ts

@@ -19,6 +19,14 @@ export declare function projectImplementationReqs(project: string): Array<{
     module: string;
     reqs: string[];
 }>;
+/**
+ * `projectImplementationReqs`, giving the host's thread back between modules: a host - doctor on its own thread - answers
+ * meanwhile. Each module is parsed as `plainFileParser` keeps it, so the chain below one parsed already is not again.
+ */
+export declare function projectImplementationReqsAsync(project: string): Promise<Array<{
+    module: string;
+    reqs: string[];
+}>>;
 /**
  * What a project's modules need of this machine, and which of it the machine lacks - `has` finding a command, and on
  * macOS a JDK behind `java` (`toolchainCheck`), asked at most once.
@@ -28,6 +36,12 @@ export declare function stackOnMachine(project: string, has?: (command: string)
     needs: StackNeed[];
     missing: StackNeed[];
 }>;
+/** `stackOnMachine`, never holding the host's thread up: the modules parsed one a turn, a JDK looked for without blocking. */
+export declare function stackOnMachineAsync(project: string, has?: (command: string) => boolean, jdk?: () => boolean | Promise<boolean>): Promise<Array<{
+    module: string;
+    needs: StackNeed[];
+    missing: StackNeed[];
+}>>;
 /**
  * The standard library's languages, and what builds and tests their stacks here - every command needed. Python's stacks
  * run through uv, which fetches Python itself; TypeScript's through npm; Java's through the Maven or Gradle wrapper,

package/dist/stack.js

@@ -1,4 +1,5 @@
 import { spawnSync } from "node:child_process";
+import { spawnAsync, yieldToHost } from "./spawn-async.js";
 import { existsSync, readdirSync, readFileSync } from "node:fs";
 import { basename, join } from "node:path";
 import { plainFileParser, withParseCache } from "./plain/parser.js";
@@ -55,6 +56,32 @@ export function projectImplementationReqs(project) {
         return modules;
     });
 }
+/**
+ * `projectImplementationReqs`, giving the host's thread back between modules: a host - doctor on its own thread - answers
+ * meanwhile. Each module is parsed as `plainFileParser` keeps it, so the chain below one parsed already is not again.
+ */
+export async function projectImplementationReqsAsync(project) {
+    let files;
+    try {
+        files = readdirSync(project).filter((name) => name.endsWith(".plain"));
+    }
+    catch {
+        return [];
+    }
+    const modules = [];
+    for (const name of files) {
+        await yieldToHost();
+        const path = join(project, name);
+        try {
+            const [module, tree] = plainFileParser(basename(path), resolveTemplateDirs(path), { allowNoFunctionalities: true });
+            modules.push({ module, reqs: sectionsOf(tree)["implementation reqs"] });
+        }
+        catch {
+            // As projectImplementationReqs: nothing named here.
+        }
+    }
+    return modules;
+}
 /** Whether a command is on this machine's PATH. */
 const onPath = (command) => onThisMachine(command) !== undefined;
 /**
@@ -63,8 +90,19 @@ const onPath = (command) => onThisMachine(command) !== undefined;
  */
 export function stackOnMachine(project, has = onPath, jdk = jdkHere) {
     let found;
-    const here = toolchainCheck(has, () => (found ??= jdk()));
-    return projectImplementationReqs(project).map(({ module, reqs }) => {
+    return needsAgainst(projectImplementationReqs(project), toolchainCheck(has, () => (found ??= jdk())));
+}
+/** `stackOnMachine`, never holding the host's thread up: the modules parsed one a turn, a JDK looked for without blocking. */
+export async function stackOnMachineAsync(project, has = onPath, jdk = jdkHereAsync) {
+    const modules = await projectImplementationReqsAsync(project);
+    // Asked only when a module needs Java and java is on the PATH - as stackOnMachine asks it, at most once.
+    let found = false;
+    if (modules.some(({ reqs }) => stackOf(reqs.join("\n")).some((need) => need.commands.includes("java"))) && has("java"))
+        found = await jdk();
+    return needsAgainst(modules, toolchainCheck(has, () => found));
+}
+function needsAgainst(modules, here) {
+    return modules.map(({ module, reqs }) => {
         const needs = stackOf(reqs.join("\n"));
         return { module, needs, missing: needs.filter((need) => !need.commands.some(here)) };
     });
@@ -81,6 +119,10 @@ export const STDLIB_LANGUAGES = [
     { language: "Rust", commands: ["cargo"] },
     { language: "Java", commands: ["java"] },
 ];
+/** `jdkHere`, without holding the thread up. */
+async function jdkHereAsync() {
+    return process.platform !== "darwin" || (await spawnAsync("/usr/libexec/java_home", [])).status === 0;
+}
 /** Whether this machine has a JDK behind `java`: anywhere but macOS, java found says so; on macOS, `java_home` finding one. */
 function jdkHere() {
     return process.platform !== "darwin" || spawnSync("/usr/libexec/java_home", [], { stdio: "ignore" }).status === 0;

package/dist/turri-versions.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Which turri runs, which is newest, and which others are on this machine - so a person who installed a new turri and
+ * is still running an old one is told so, and how to fix it, where they look: the banner as turri starts (from what the
+ * last check found, never waiting on the network), and `turri --version` and `turri doctor` (asking npm then and there).
+ * A turri run from a clone is the developer's: it is never told to update.
+ */
+export declare const PACKAGE_NAME = "@turri-dev/cli";
+/** Whether version `a` is newer than `b`: major, minor, patch - and a release over a prerelease of the same. */
+export declare function newerThan(a: string, b: string): boolean;
+/** The newest version npm had when it was last asked, and when - nothing when it never was. */
+export declare function latestKnown(): {
+    version: string;
+    checkedAt: number;
+} | undefined;
+/** The newest version npm has now, kept for the next start - nothing when npm does not answer in time. */
+export declare function fetchLatest(timeoutMs?: number): Promise<string | undefined>;
+/**
+ * Ask npm again in the background when what it said last is old: what it says now, once it answers - undefined when it
+ * was not asked, or did not answer. Never waited for by what starts turri.
+ */
+export declare function refreshLatestLater(): Promise<string | undefined>;
+/** A turri on this machine's PATH. */
+export interface TurriOnPath {
+    /** The command, as the PATH has it. */
+    path: string;
+    /** The package it runs. */
+    root: string;
+    version?: string;
+    /** Run from a clone - npm link, or a script pointing into one. */
+    clone: boolean;
+    /** The one a bare `turri` runs: the first on the PATH. */
+    runs: boolean;
+    /** The one running now. */
+    self: boolean;
+}
+/** Every turri on the PATH, in its order - the first is what a bare `turri` runs. */
+export declare function turrisOnPath(path?: string, self?: string, platform?: NodeJS.Platform): TurriOnPath[];
+/** How to take a turri off the PATH, by where it is: another Node version of nvm, a linked clone, or an npm prefix. */
+export declare function removalOf(turri: Pick<TurriOnPath, "path" | "clone" | "root">, platform?: NodeJS.Platform): string;
+/** What is wrong with the turri running, and what to do: each a line, with its fixes. */
+export interface VersionFinding {
+    /** Updating is all it needs. */
+    kind: "outdated" | "shadowed" | "behind";
+    text: string;
+    /** The same, as the banner says it in a line: what is newer, and what to run. */
+    short: string;
+    fixes: string[];
+}
+/**
+ * What the turri running, the newest npm has (`latest`, when known) and the turris on the PATH say together: nothing when
+ * all is well. A turri from a clone is told nothing of npm's.
+ */
+export declare function versionFindings(options?: {
+    latest?: string;
+    onPath?: TurriOnPath[];
+    self?: {
+        version?: string;
+        clone: boolean;
+        root: string;
+    };
+}): VersionFinding[];
+/** `turri --version`: the version line, then where this turri is, what npm has - asked now - and every turri on the PATH. */
+export declare function describeVersion(versionLine: string): Promise<string>;
+/**
+ * What the banner says as turri starts: a line a finding, short - what is newer and what to run - from what npm said at
+ * the last check and the turris on the PATH, never waiting on the network; the check for next time started behind it.
+ */
+export declare function bannerWarnings(): {
+    lines: string[];
+    later: Promise<string | undefined>;
+};