@turri-dev/cli 0.1.6 → 0.1.7-next.ccadaa0

package/dist/extension.js

@@ -30,7 +30,7 @@ import { checkPlainFile, checkPlainTargets, formatCheckResults } from "./plain/c
 import { whyFailed } from "./regenerate/diagnose-job.js";
 import { createWorkLoop, describeModules, isUpToDate, previewJobs } from "./regenerate/loop.js";
 import { brandNeon, brandPink, plainPaint } from "./regenerate/plain-palette.js";
-import { halfBlocks, JELLYFISH_FRAME_MS, JELLYFISH_TEXT_FRAMES } from "./jellyfish.js";
+import { halfBlocks, JELLYFISH_FRAME_MS, JELLYFISH_SEQUENCE, JELLYFISH_TEXT_FRAMES } from "./jellyfish.js";
 import { createJobPanel, didNotPass, keyPressed, PANEL_KEY, spinner } from "./regenerate/job-panel.js";
 import { clickToFocus, dockedWidth, narrowChat, shade, shadeChat } from "./regenerate/panel-dock.js";
 import { overPictureRow, PICTURE_AT } from "./picture-row.js";
@@ -80,8 +80,17 @@ const PACKAGE_ROOT = dirname(dirname(fileURLToPath(import.meta.url)));
  */
 export function askUserVia(ctx, onExchange, 
 /** Given, "/btw ..." typed as an answer is a side question: answered with this, and the question asked again. */
-aside) {
+aside, 
+/** A host's own dialogs (TurriHost.dialogs), the question put in them instead of the terminal's. */
+dialogs) {
     return async (request) => {
+        if (dialogs !== undefined) {
+            const asking = (asked) => runAsk(asked, dialogs);
+            const bare = { ...request, said: undefined };
+            const answer = aside !== undefined ? await askWithAsides(bare, asking, aside) : await asking(bare);
+            onExchange(request.question, answer, [request.context, request.said].map((part) => part?.trim() ?? "").filter((part) => part !== "").join("\n\n") || undefined);
+            return answer;
+        }
         if (!ctx.hasUI) {
             return "No user is available to answer. Decide yourself, and say in your report what you assumed.";
         }
@@ -156,9 +165,9 @@ function hookPeekKey(ctx) {
  * pick from, several at once, "Something else…" to type instead, "Chat about this" to talk it over in
  * the chat first - so a question with a handful of answers is picked, not typed.
  */
-export function chatAskUserTool() {
+export function chatAskUserTool(dialogs) {
     let conversation;
-    const tool = createAskUserTool((request) => (conversation !== undefined ? askUserVia(conversation, () => { })(request) : Promise.resolve("No user is available to answer.")), undefined, undefined, undefined, "reply");
+    const tool = createAskUserTool((request) => (conversation !== undefined ? askUserVia(conversation, () => { }, undefined, dialogs)(request) : Promise.resolve("No user is available to answer.")), undefined, undefined, undefined, "reply");
     return {
         ...tool,
         promptGuidelines: [
@@ -171,7 +180,14 @@ export function chatAskUserTool() {
         },
     };
 }
-export default function (pi) {
+/** The host each conversation's jobs report to, for the work loop made for them later. */
+const hosts = new WeakMap();
+/** turri's conversation as an extension of pi's, for a host that runs it itself: see TurriHost. */
+export function createTurriExtension(host = {}) {
+    return (pi) => turriExtension(pi, host);
+}
+export default createTurriExtension();
+function turriExtension(pi, host) {
     dropNoise();
     const cwd = process.cwd();
     // turri's own skills, and the project's - .turri/skills, .agents/skills (skills.ts).
@@ -189,7 +205,10 @@ export default function (pi) {
     const deployState = createDeployState();
     const jobs = createJobRegistry({
         // The loop's plan changed - a module being planned, or planned: the live panel shows it at once.
-        onNotify: () => panel.refresh(),
+        onNotify: () => {
+            panel.refresh();
+            host.onPlanChange?.();
+        },
         // A job that fails is run once more; failing again, it and every job behind it fail, and the
         // harness - which can read the skills, the rules, the code, the tests and turri itself -
         // works out why, and what has to be done.
@@ -208,9 +227,13 @@ export default function (pi) {
             });
             return diagnosis !== undefined ? describeDiagnosis(diagnosis) : undefined;
         },
-        onChange: () => panel.refresh(),
+        onChange: (job) => {
+            panel.refresh();
+            host.onJobChange?.(job);
+        },
         onFinish: (job) => {
             panel.refresh();
+            host.onJobChange?.(job);
             // Queued again as another job: that one says how it went.
             if (job.replacedBy !== undefined)
                 return;
@@ -236,6 +259,8 @@ export default function (pi) {
             }, { triggerTurn: true, deliverAs: "followUp" });
         },
     });
+    hosts.set(jobs, host);
+    host.onJobs?.(jobs);
     // The ***plain rules go into the system prompt in full, every turn. The block is
     // identical each time, so it sits inside the cached prefix rather than invalidating it.
     // With them, the instruction to do turri's work with its tools rather than its command
@@ -375,7 +400,7 @@ export default function (pi) {
     registerBranding(pi, discoveredSkills);
     registerInterviewLog(pi);
     registerJobTools(pi, jobs, cwd);
-    registerCheckPlain(pi, cwd);
+    registerCheckPlain(pi, cwd, host.dialogs);
     registerRegenerate(pi, cwd, jobs);
     registerDrift(pi, cwd, jobs);
     registerGlimpse(pi, cwd, jobs);
@@ -549,7 +574,7 @@ export default function (pi) {
                     push(`  Q: ${question}`);
                     push(`  A: ${answer}`);
                     recordExchange(pi, { skill: skill.name, question, answer, ...(said !== undefined && said.trim() !== "" ? { said: said.trim() } : {}) });
-                }, (question) => askOnTheSide(pi, ctx, cwd, jobs, question)),
+                }, (question) => askOnTheSide(pi, ctx, cwd, jobs, question), host.dialogs),
                 model: conversationModel(ctx),
                 // Renders queued by a step land in the same registry as everything else, so
                 // pulses sees them without knowing a skill started them.
@@ -1326,6 +1351,7 @@ function workLoopFor(jobs, cwd, ctx) {
         });
         shared = { loop, from };
         workLoops.set(jobs, shared);
+        hosts.get(jobs)?.onWorkLoop?.(loop);
     }
     shared.from.ctx = ctx;
     return shared.loop;
@@ -1932,9 +1958,9 @@ function jobLines(all) {
  * so it needs no external tool, no API key and no credits - and it is the only honest way
  * to answer "is this spec valid?" without generating anything.
  */
-function registerCheckPlain(pi, cwd) {
+function registerCheckPlain(pi, cwd, dialogs) {
     pi.registerTool(checkPlainTool(cwd));
-    pi.registerTool(chatAskUserTool());
+    pi.registerTool(chatAskUserTool(dialogs));
     // The web, for the conversation too - a library's documentation, an API, an error; curl is its
     // bash. Run here, like the rendering agents' (see render/web.ts).
     for (const tool of createWebTools())
@@ -2327,8 +2353,8 @@ function registerBranding(pi, skills) {
             ...(data.pending > 0 ? [theme.fg("warning", `${data.pending} skill${data.pending === 1 ? "" : "s"} failed to load`)] : []),
             ...(data.sandbox !== undefined && data.sandbox.level !== "ok" ? [theme.fg(data.sandbox.level === "limited" ? "warning" : "error", data.sandbox.text)] : []),
         ];
-        // The jellyfish turri is named after, in ink for the theme's background: a picture where the
-        // terminal shows images, drawn in text where it does not.
+        // The jellyfish turri is named after, regenerating, in ink for the theme's background: a picture
+        // where the terminal shows images, drawn in text where it does not.
         return new Banner(lines, (rule) => theme.fg("borderMuted", rule), jellyfishArt(theme.appearance, (theme.getColorMode?.() ?? "truecolor") === "truecolor"));
     });
     pi.on("session_start", (_event, ctx) => {
@@ -2351,10 +2377,15 @@ function registerBranding(pi, skills) {
         }
     });
 }
-/** How many rows the banner's jellyfish takes at most: as tall as the one drawn in text. */
-const JELLYFISH_ROWS = 10;
-/** Which frame of the jellyfish every banner shows, moved on by `animateJellyfish`. */
+/**
+ * How many rows the banner's picture takes at most: its frame reaches down to the sea floor the polyp stands on, so it
+ * is given more than the jellyfish drawn in text, ten.
+ */
+const JELLYFISH_ROWS = 14;
+/** How far along its sequence the jellyfish every banner shows is, moved on by `animateJellyfish`. */
 let jellyfishFrame = 0;
+/** The frame the jellyfish is on: the one its sequence has at this point. */
+const shownFrame = () => JELLYFISH_SEQUENCE[jellyfishFrame % JELLYFISH_SEQUENCE.length];
 let jellyfishTimer;
 /**
  * Moves the jellyfish on a frame every JELLYFISH_FRAME_MS while the banner is on the screen. An entry's
@@ -2455,7 +2486,7 @@ class Banner {
         const text = this.lines.flatMap((line) => wrapTextWithAnsi(line, Math.max(1, width - 1 - left)));
         const height = Math.max(text.length, placed?.rows ?? 0);
         const above = Math.floor((height - text.length) / 2);
-        const drawn = placed?.kind === "text" ? placed.frames[jellyfishFrame % placed.frames.length] : undefined;
+        const drawn = placed?.kind === "text" ? placed.frames[shownFrame()] : undefined;
         const rows = Array.from({ length: height }, (_, row) => {
             const line = text[row - above];
             const jellyfish = drawn !== undefined ? (drawn[row] ?? " ".repeat(placed.columns)) : " ".repeat(placed?.columns ?? 0);
@@ -2476,7 +2507,7 @@ class Banner {
         const kitty = getCapabilities().images === "kitty";
         if (kitty && this.kittyImageId === undefined)
             this.kittyImageId = allocateImageId();
-        const result = renderImage(art.frames[jellyfishFrame % art.frames.length], art.dimensions, {
+        const result = renderImage(art.frames[shownFrame()], art.dimensions, {
             maxWidthCells: room,
             maxHeightCells: rows,
             imageId: this.kittyImageId,

package/dist/genome.d.ts

@@ -0,0 +1,62 @@
+import { type Reporter } from "./graph.ts";
+import type { ToolDefinition } from "@earendil-works/pi-coding-agent";
+import { type Skill } from "./skill.ts";
+import { type AskUser } from "./tools.ts";
+import type { JobRegistry } from "./regenerate/jobs.ts";
+import type { WorkLoop } from "./regenerate/loop.ts";
+export interface EscalationRequest {
+    step: string;
+    artifact: string;
+    critique: string;
+    question: string;
+}
+export interface RunSkillResult {
+    skill: Skill;
+    ok: boolean;
+    artifacts: Record<string, string>;
+    /** The last step's artifact - what the caller usually wants. */
+    output: string;
+}
+/**
+ * Run one skill to completion. The only entry point: the CLI and the Pi extension
+ * both go through here, so a skill behaves identically whether a human launched it
+ * or a conversational agent decided to.
+ */
+export declare function runSkill(opts: {
+    skillDir: string;
+    cwd: string;
+    runDir: string;
+    report: Reporter;
+    /** Called when a gate cannot be satisfied. Return true to accept the artifact anyway. */
+    escalate: (request: EscalationRequest) => Promise<boolean>;
+    /** Lets a step interview the user. Omitted: the skill runs with nobody to ask. */
+    askUser?: AskUser;
+    /** "provider/model-id" for the executor and the judges. Omitted: pi's default. */
+    model?: string;
+    /** Lets steps build functionalities in the background while the interview continues. */
+    renderQueue?: WorkLoop;
+    /** What the user has already said, so the skill does not re-ask it. */
+    context?: string;
+    /** Pick up the run of this skill that was interrupted here, rather than start a new one. */
+    resume?: boolean;
+    /**
+     * Tools the conversation's agent has that the skill's agent needs as well, because the person
+     * talks to the skill's agent while it runs - choosing the render model, for one.
+     */
+    sharedTools?: ToolDefinition[];
+    /**
+     * The conversation's tools that act on the work loop (loop-tools.ts): drift, for every skill with the loop - how its
+     * builds stand - and regenerate and halt for a skill that names them in its allowed-tools.
+     */
+    loopTools?: ToolDefinition[];
+    /** The jobs the render queue runs, for a skill that waits for its builds and reads what they recorded. */
+    jobs?: JobRegistry;
+}): Promise<RunSkillResult>;
+/** Whether there is a run of this skill here that was interrupted, and could be resumed. */
+export declare function interruptedRun(runDir: string, skillName: string): {
+    step?: string;
+    updatedAt: string;
+} | undefined;
+/** Human-readable one-liner per step, for logs and tool output. */
+export declare function describeGates(skill: Skill): string[];
+export type { Reporter };

package/dist/graph.d.ts

@@ -0,0 +1,52 @@
+import type { AgentSession } from "@earendil-works/pi-coding-agent";
+import { type LiveReviewer } from "./review/live.ts";
+import { type Skill } from "./skill.ts";
+export type Decision = "advance" | "retry" | "escalate" | "abort";
+export declare const GenomeState: import("@langchain/langgraph").AnnotationRoot<{
+    artifacts: import("@langchain/langgraph").BaseChannel<Record<string, string>, Record<string, string> | import("@langchain/langgraph").OverwriteValue<Record<string, string>>, unknown>;
+    attempts: import("@langchain/langgraph").BaseChannel<Record<string, number>, Record<string, number> | import("@langchain/langgraph").OverwriteValue<Record<string, number>>, unknown>;
+    /** Judge feedback for the step currently being retried. */
+    critique: import("@langchain/langgraph").BaseChannel<string, string | import("@langchain/langgraph").OverwriteValue<string>, unknown>;
+    decision: import("@langchain/langgraph").BaseChannel<Decision, Decision | import("@langchain/langgraph").OverwriteValue<Decision>, unknown>;
+}>;
+export type GenomeStateType = typeof GenomeState.State;
+export interface Reporter {
+    step(name: string, attempt: number): void;
+    artifact(path: string, body: string): void;
+    gate(name: string, judges: number): void;
+    /** One continuous-review pass finished while the step was still running. */
+    livePass?(step: string, scope: string, findings: number): void;
+    /** The continuous reviewer's closing word, read at the gate. */
+    liveReview?(name: string, passes: number, findings: number): void;
+    judge(index: number, model: string, verdict: string, violations: number): void;
+    outcome(name: string, decision: Decision, critique: string): void;
+    /** One thing the skill's agent just did - a tool call, as one short line - for a view of it while it works. */
+    activity?(line: string): void;
+    /** The skill's agent's words as they stream, from the start of each reply: `fresh` when a new one begins. */
+    said?(delta: string, fresh: boolean): void;
+}
+/** How many times a step whose turn ends on a question in its reply is sent back to carry on. */
+export declare const QUESTION_NUDGES = 2;
+/** Whether a reply ends on a question: its last line, its markdown left aside, ends with a question mark. */
+export declare function endsOnQuestion(reply: string): boolean;
+export declare function compileSkill(opts: {
+    skill: Skill;
+    cwd: string;
+    runDir: string;
+    executor: AgentSession;
+    report: Reporter;
+    /** Default model for the judges, when a gate does not name one of its own. */
+    model?: string;
+    /** What the user has already said, carried in from the conversation that started this. */
+    context?: string;
+    /** Reviewers already reading along, by step name. Their findings gate the step too. */
+    liveReviewers?: Map<string, LiveReviewer>;
+    /** Start at this step instead of the first: a resumed run, picking up where it stopped. */
+    startAt?: string;
+    /** Called as each step starts, with the state it starts from - what a resumed run restores. */
+    onStepStart?: (step: string, state: GenomeStateType) => void;
+    /** Called once a step is reported started, before its agent is prompted: the harness's own question goes here. */
+    beforeStep?: (step: string) => Promise<void>;
+    /** What the harness tells the agent as a step starts, beside its instructions - the questioning level, say. */
+    stepNote?: (step: string) => string | undefined;
+}): any;

package/dist/host.d.ts

@@ -0,0 +1,21 @@
+/**
+ * turri for a host that runs it itself - a desktop app, an editor - imported as `@turri-dev/cli/host`: the
+ * conversation as pi's extension, with the host told of its jobs and asking its questions (createTurriExtension), and
+ * what a host shows beside it - a spec parsed, checked and coloured, how far each functional spec is built, the work a
+ * spec change would plan. It is turri's own code, as the terminal runs it; a 0.x release may change any of it.
+ */
+export { createTurriExtension, type TurriHost } from "./extension.ts";
+export type { AskUserIO } from "./ask.ts";
+/** pi itself, as turri's extension is built against it: a host makes its session with this one, not another copy. */
+export * as pi from "@earendil-works/pi-coding-agent";
+export { configForSpec, 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 { checkPlainFile, type CheckResult } from "./plain/check.ts";
+export { plainFileParser } from "./plain/parser.ts";
+export { FUNCTIONAL_REQUIREMENTS, iterateFunctionalSpecs } from "./plain/spec.ts";
+export { highlightLines, roleOf, type PlainRole } from "./plain/highlight.ts";
+export { createWorkLoop, describeModules, functionalityCompletion, promptOf, type DriftReport, type ModuleStatus, type WorkLoop } from "./regenerate/loop.ts";
+export { createJobRegistry, defaultParallelJobs, type Job, type JobRegistry } from "./regenerate/jobs.ts";
+export { describeTurnIncident, onModelEvent, type TranscriptEntry } from "./regenerate/activity.ts";
+export { sweepOrphanedGroups } from "./regenerate/shell.ts";

package/dist/host.js

@@ -0,0 +1,25 @@
+/**
+ * turri for a host that runs it itself - a desktop app, an editor - imported as `@turri-dev/cli/host`: the
+ * conversation as pi's extension, with the host told of its jobs and asking its questions (createTurriExtension), and
+ * what a host shows beside it - a spec parsed, checked and coloured, how far each functional spec is built, the work a
+ * spec change would plan. It is turri's own code, as the terminal runs it; a 0.x release may change any of it.
+ */
+// The conversation.
+export { createTurriExtension } from "./extension.js";
+/** pi itself, as turri's extension is built against it: a host makes its session with this one, not another copy. */
+export * as pi from "@earendil-works/pi-coding-agent";
+// The project and its settings.
+export { configForSpec, 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 spec: parsed, checked, coloured.
+export { checkPlainFile } from "./plain/check.js";
+export { plainFileParser } from "./plain/parser.js";
+export { FUNCTIONAL_REQUIREMENTS, iterateFunctionalSpecs } from "./plain/spec.js";
+export { highlightLines, roleOf } from "./plain/highlight.js";
+// The work: what is built, what is left, and the jobs that build it.
+export { createWorkLoop, describeModules, functionalityCompletion, promptOf } from "./regenerate/loop.js";
+export { createJobRegistry, defaultParallelJobs } from "./regenerate/jobs.js";
+export { describeTurnIncident, onModelEvent } from "./regenerate/activity.js";
+export { sweepOrphanedGroups } from "./regenerate/shell.js";

package/dist/identity.d.ts

@@ -0,0 +1,2 @@
+/** Who the conversation's agent is: turri, and what it does - first, so it speaks as turri, in the first person. */
+export declare const TURRI_IDENTITY: string;

package/dist/init-config.d.ts

@@ -0,0 +1,106 @@
+/**
+ * `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
+ * models you use and fills in theirs. Every other setting is written out with the value turri uses for it (DEFAULTS),
+ * so the file says how the project is built; the optional ones, which have no value of their own - the testing
+ * scripts, `module`, `judge-model`, `models` - are there commented out, with an example. docs/config.md has them all.
+ *
+ * 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.
+ */
+/** 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. */
+export interface BedrockChoice {
+    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): {
+    harness: string;
+    coding: string;
+    strong: string;
+};
+/** Bedrock's default: Anthropic's models, anywhere. */
+export declare const BEDROCK_DEFAULT: BedrockChoice;
+interface VendorPreset {
+    label: string;
+    /** The model you talk to: it writes the specs and plans the work. */
+    harness: string;
+    /** The smaller, cheaper one that writes the code. */
+    coding: string;
+    /** A strong model for the commented-out judge, reviewer and debugger examples. */
+    strong: string;
+    /** The environment variables pi reads the vendor's keys from - pi's own names (pi.dev, providers). */
+    keys: Array<{
+        vendor: string;
+        variable: string;
+    }>;
+}
+export declare const VENDORS: Record<Vendor, VendorPreset>;
+/**
+ * A config.turri.yaml with its two models set to these lines, and nothing else changed: each key's line - and the lines
+ * indented under it, when it is written as a block - replaced where it is, or put at the top when it is not there.
+ */
+export declare function withModels(text: string, lines: [string, string]): string;
+/**
+ * What turri does with each setting the config leaves out, written into the quick start config so it says so. They
+ * must stay what the code falls back to - tests/init-config.test.ts holds them to the constants they mirror.
+ */
+export declare const DEFAULTS: {
+    readonly conformanceTests: false;
+    readonly review: false;
+    readonly mutationTesting: true;
+    readonly allowToStopJobs: true;
+    readonly releaseAfterPulse: false;
+    readonly testingScriptsRunOn: "in-place";
+    readonly turnLimit: 120;
+    readonly compactAt: 100000;
+    readonly maxSpecsPerPulse: 3;
+    readonly maxLinesPerPulse: 120;
+};
+/** 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 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;
+/**
+ * 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
+ * two models are the vendor's, so they are not taken.
+ */
+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?: {
+    force?: boolean;
+    vendor?: Vendor;
+    bedrock?: BedrockChoice;
+}): {
+    written: boolean;
+    message: string;
+};
+/** `turri init-config [--vendor <vendor>] [--maker <maker>] [--region <geography>] [--force] [folder]`. */
+export declare function main(args: string[]): Promise<number>;
+export {};

package/dist/jellyfish.d.ts

@@ -0,0 +1,35 @@
+/**
+ * The jellyfish turri is named after, in pixels, regenerating: a polyp on the sea floor grows into the jellyfish, it
+ * swims a while, then sinks back to the floor and the polyp grows again - the design system's hero and its lifecycle
+ * (its pixel kit's `sprite("hero")` and `cycleFrames()`, ported here pixel for pixel). The banner's pictures are
+ * rendered from these frames (scripts/jellyfish-frames.mjs writes assets/jellyfish/); where a terminal shows no
+ * images the same frames are drawn here in half blocks, at a third of the size.
+ */
+/**
+ * What a pixel is: the bell's pink, its midtone and shadow, its rim, its highlight, the gut, and a tentacle - whole,
+ * half seen, or a polyp's crown, a little more than half.
+ */
+type Pixel = "p" | "m" | "i" | "e" | "h" | "o" | "N" | "n" | "c";
+/** The pixels' colours on a dark background and a light one - the tentacles blue whale on light, where neon does not show. */
+export declare const JELLYFISH_COLOURS: Record<"dark" | "light", Record<Pixel, string>>;
+/** How much of a pixel shows, for a picture's alpha. */
+export declare function jellyfishAlpha(pixel: string): number;
+/** The jellyfish's frames, each as rows of pixels: what the pictures are rendered from. */
+export declare const JELLYFISH_FRAMES: string[][];
+export declare const JELLYFISH_WIDTH: number;
+export declare const JELLYFISH_HEIGHT: number;
+/**
+ * The order the frames play in, round and round: the polyp a moment, growing into the jellyfish, swimming four
+ * seconds - a stroke every five frames - then sinking, and the polyp growing back.
+ */
+export declare const JELLYFISH_SEQUENCE: number[];
+/** How long each frame shows. */
+export declare const JELLYFISH_FRAME_MS = 150;
+/** The frames as a terminal without images draws them, in half blocks: the same order, a third of the size. */
+export declare const JELLYFISH_TEXT_FRAMES: string[][];
+/**
+ * A frame drawn in half blocks for a terminal that shows no images: two pixels a cell, the upper one the text's colour
+ * and the lower one the background's, in as many colours as the terminal has: a column a pixel, a row every two.
+ */
+export declare function halfBlocks(pixels: string[], appearance: "dark" | "light", truecolor: boolean): string[];
+export {};