@velum-labs/routekit-cli-ui 0.9.0

package/dist/prompt.js

@@ -0,0 +1,246 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * The prompt facade. On a raw-capable interactive TTY prompts render as Ink
+ * components (arrow-key select, checkbox multi-select, live confirm/text);
+ * otherwise they fall back to numbered/line prompts read from buffered stdin,
+ * so piped answers and CI keep working
+ * exactly as before. Every prompt settles into a persistent one-line answer.
+ */
+import { createInterface } from "node:readline";
+import { canPromptInteractively, isInteractive, uiStream } from "./runtime.js";
+import { bold, cyan, dim, glyph, gray, green } from "./theme.js";
+import { mountInk, settleInk } from "./ink/presenter.js";
+import { ConfirmPrompt, FuzzySelectPrompt, GhostTextPrompt, MultiSelectPrompt, SelectPrompt, TextPrompt } from "./ink/prompts.js";
+import { Store } from "./ink/store.js";
+/** Returned by prompts with `allowBack: true` when the user presses Esc. */
+export const BACK = Symbol("prompt.back");
+const out = uiStream();
+// For non-interactive input (piped/redirected/empty stdin) we read all of stdin
+// exactly once and serve answers line by line. This supports scripted input
+// and falls back to "" (the prompt
+// default) once exhausted — without the fragile behavior of attaching multiple
+// readline interfaces to an already-ended stdin.
+let bufferedLines;
+let bufferedRead = false;
+async function ensureBufferedStdin() {
+    if (bufferedRead)
+        return;
+    bufferedRead = true;
+    if (process.stdin.isTTY || process.stdin.readableEnded) {
+        bufferedLines = [];
+        return;
+    }
+    const chunks = [];
+    await new Promise((resolve) => {
+        process.stdin.on("data", (chunk) => chunks.push(Buffer.from(chunk)));
+        process.stdin.once("end", () => resolve());
+        process.stdin.once("error", () => resolve());
+    });
+    bufferedLines = Buffer.concat(chunks).toString("utf8").split("\n");
+}
+/**
+ * Read a single line from stdin, prompting on stderr. On a TTY this reads live;
+ * otherwise it draws from buffered stdin and resolves to "" when there is no
+ * more input, so callers fall back to their default instead of hanging.
+ */
+async function readLine(promptText) {
+    if (!process.stdin.isTTY) {
+        out.write(promptText);
+        await ensureBufferedStdin();
+        const next = bufferedLines?.shift();
+        out.write("\n");
+        return (next ?? "").trim();
+    }
+    return new Promise((resolve) => {
+        const rl = createInterface({ input: process.stdin, output: out });
+        let answered = false;
+        rl.question(promptText, (answer) => {
+            answered = true;
+            rl.close();
+            resolve(answer.trim());
+        });
+        rl.on("close", () => {
+            if (!answered)
+                resolve("");
+        });
+    });
+}
+/** True when prompts should render as Ink components. */
+function richPrompts() {
+    return canPromptInteractively() && isInteractive();
+}
+/** Mount an Ink prompt, resolve on submit, and settle to a one-line answer. */
+function runInkPrompt(build) {
+    return new Promise((resolve) => {
+        let settled = false;
+        const node = build({
+            submit: (value, answer) => {
+                if (settled)
+                    return;
+                settled = true;
+                settleInk(instance);
+                out.write(`${green(glyph.tick())} ${answer}\n`);
+                resolve(value);
+            },
+            abort: () => {
+                if (settled)
+                    return;
+                settled = true;
+                settleInk(instance);
+                out.write("\n");
+                process.exit(130);
+            },
+            back: () => {
+                if (settled)
+                    return;
+                settled = true;
+                settleInk(instance);
+                out.write(`${gray(glyph.arrow())} ${dim("back")}\n`);
+                resolve(BACK);
+            }
+        });
+        const instance = mountInk(node);
+    });
+}
+function answerLine(message, answer) {
+    return `${bold(message)} ${dim(`· ${answer}`)}`;
+}
+function optionAt(options, index) {
+    const option = options[index];
+    if (option === undefined)
+        throw new Error(`option index out of range: ${index}`);
+    return option;
+}
+export async function select(input) {
+    const { options } = input;
+    if (options.length === 0)
+        throw new Error("select requires at least one option");
+    const fallbackIndex = Math.min(Math.max(input.defaultIndex ?? 0, 0), options.length - 1);
+    if (!richPrompts()) {
+        return selectNumbered(input.message, options, fallbackIndex);
+    }
+    return runInkPrompt(({ submit, abort, back }) => (_jsx(SelectPrompt, { message: input.message, options: options, defaultIndex: fallbackIndex, onSubmit: (value, label) => submit(value, answerLine(input.message, label)), onAbort: abort, onBack: input.allowBack === true ? back : undefined })));
+}
+export async function fuzzySelect(input) {
+    let options = input.options;
+    if (!richPrompts()) {
+        if (options.length === 0 && input.refresh !== undefined) {
+            try {
+                options = await input.refresh();
+            }
+            catch {
+                // no fresh data either; fall through to the empty-list guard
+            }
+        }
+        if (options.length === 0)
+            throw new Error(`no options available: ${input.message}`);
+        return selectNumbered(input.message, options, 0);
+    }
+    const feed = new Store({
+        options: options,
+        loading: input.refresh !== undefined,
+        ...(input.refreshNote !== undefined ? { note: input.refreshNote } : {})
+    });
+    if (input.refresh !== undefined) {
+        void input
+            .refresh()
+            .then((fresh) => {
+            feed.set((state) => ({ ...state, options: fresh, loading: false }));
+        })
+            .catch(() => {
+            feed.set((state) => ({ ...state, loading: false }));
+        });
+    }
+    return runInkPrompt(({ submit, abort, back }) => (_jsx(FuzzySelectPrompt, { message: input.message, feed: feed, placeholder: input.placeholder, onSubmit: (value, label) => submit(value, answerLine(input.message, label)), onAbort: abort, onBack: input.allowBack === true ? back : undefined })));
+}
+/**
+ * Free text with an inline ghost suggestion completed from `suggestions`
+ * (Tab or → accepts). Falls back to the plain text prompt off-TTY.
+ */
+export async function autocompleteText(input) {
+    if (!richPrompts()) {
+        return text({
+            message: input.message,
+            ...(input.defaultValue !== undefined ? { defaultValue: input.defaultValue } : {}),
+            ...(input.placeholder !== undefined ? { placeholder: input.placeholder } : {})
+        });
+    }
+    return runInkPrompt(({ submit, abort, back }) => (_jsx(GhostTextPrompt, { message: input.message, suggestions: input.suggestions, defaultValue: input.defaultValue ?? "", placeholder: input.placeholder, onSubmit: (value) => submit(value, answerLine(input.message, value.length > 0 ? value : "(empty)")), onAbort: abort, onBack: input.allowBack === true ? back : undefined })));
+}
+async function selectNumbered(message, options, fallbackIndex) {
+    out.write(`${bold(message)}\n`);
+    options.forEach((option, index) => {
+        const marker = index === fallbackIndex ? cyan(`${index + 1}`) : `${index + 1}`;
+        const hint = option.hint !== undefined ? dim(` — ${option.hint}`) : "";
+        out.write(`  ${marker}) ${option.label}${hint}\n`);
+    });
+    const answer = await readLine(`Choose [1-${options.length}] (${fallbackIndex + 1}): `);
+    if (answer.length === 0)
+        return optionAt(options, fallbackIndex).value;
+    const byNumber = Number.parseInt(answer, 10);
+    if (Number.isInteger(byNumber) && byNumber >= 1 && byNumber <= options.length) {
+        return optionAt(options, byNumber - 1).value;
+    }
+    const byLabel = options.findIndex((option) => option.label.toLowerCase() === answer.toLowerCase());
+    if (byLabel >= 0)
+        return optionAt(options, byLabel).value;
+    return optionAt(options, fallbackIndex).value;
+}
+/**
+ * Multi-choice selection. On a raw-capable TTY this is an Ink checkbox list;
+ * otherwise it reads comma-separated numbers from stdin (empty input keeps the
+ * default selection).
+ */
+export async function multiselect(input) {
+    const { options } = input;
+    if (options.length === 0)
+        return [];
+    const defaults = new Set((input.defaultSelected ?? []).filter((index) => index >= 0 && index < options.length));
+    if (!richPrompts()) {
+        out.write(`${bold(input.message)}\n`);
+        options.forEach((option, index) => {
+            const marker = defaults.has(index) ? cyan(`${index + 1}`) : `${index + 1}`;
+            const hint = option.hint !== undefined ? dim(` — ${option.hint}`) : "";
+            out.write(`  ${marker}) ${option.label}${hint}\n`);
+        });
+        const fallback = [...defaults].sort((left, right) => left - right).map((index) => index + 1);
+        const answer = await readLine(`Choose numbers, comma-separated (${fallback.length > 0 ? fallback.join(",") : "none"}): `);
+        const picked = answer.length === 0 ? fallback : answer.split(",").map((part) => Number.parseInt(part.trim(), 10));
+        const indices = [...new Set(picked)]
+            .filter((num) => Number.isInteger(num) && num >= 1 && num <= options.length)
+            .map((num) => num - 1)
+            .sort((left, right) => left - right);
+        return indices.map((index) => optionAt(options, index).value);
+    }
+    // No onBack handler is mounted, so BACK can never resolve here.
+    return runInkPrompt(({ submit, abort }) => (_jsx(MultiSelectPrompt, { message: input.message, options: options, defaultSelected: defaults, onSubmit: (values, labels) => submit(values, answerLine(input.message, labels.length > 0 ? labels.join(", ") : "(none)")), onAbort: abort })));
+}
+export async function confirm(input) {
+    const def = input.defaultValue ?? false;
+    if (!richPrompts()) {
+        const hint = def ? "[Y/n]" : "[y/N]";
+        const answer = (await readLine(`${bold(input.message)} ${dim(hint)} `)).toLowerCase();
+        if (answer.length === 0)
+            return def;
+        return answer === "y" || answer === "yes";
+    }
+    return runInkPrompt(({ submit, abort, back }) => (_jsx(ConfirmPrompt, { message: input.message, defaultValue: def, onSubmit: (value) => submit(value, answerLine(input.message, value ? "yes" : "no")), onAbort: abort, onBack: input.allowBack === true ? back : undefined })));
+}
+export async function text(input) {
+    if (!richPrompts()) {
+        const suffix = input.defaultValue !== undefined && input.defaultValue.length > 0 ? dim(` (${input.defaultValue})`) : "";
+        const answer = await readLine(`${bold(input.message)}${suffix} `);
+        if (answer.length === 0)
+            return input.defaultValue ?? "";
+        return answer;
+    }
+    return runInkPrompt(({ submit, abort, back }) => (_jsx(TextPrompt, { message: input.message, defaultValue: input.defaultValue ?? "", ...(input.placeholder !== undefined ? { placeholder: input.placeholder } : {}), onSubmit: (value) => submit(value, answerLine(input.message, value.length > 0 ? value : "(empty)")), onAbort: abort, onBack: input.allowBack === true ? back : undefined })));
+}
+/** A success line for the end of a wizard. */
+export function done(message) {
+    out.write(`${green(glyph.tick())} ${message}\n`);
+}
+/** A neutral note line. */
+export function note(message) {
+    out.write(`${gray(glyph.arrow())} ${message}\n`);
+}

package/dist/runtime.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Interaction-mode detection. The CLI's rich surfaces (Ink components,
+ * prompts, live checklists) only render when we are attached to an interactive
+ * terminal and not running under CI; otherwise everything degrades to plain
+ * line logs so pipes, captures, and `node --test` stay deterministic.
+ */
+/** True under a recognized CI environment. */
+export declare function isCI(): boolean;
+/** The stream all UI is written to (stderr; stdout is reserved for tool output). */
+export declare function uiStream(): NodeJS.WriteStream;
+/**
+ * Force non-interactive mode for the rest of the process (the `--no-input` /
+ * `--json` global flags). Also exports `ROUTEKIT_NO_TUI=1` so spawned children
+ * inherit the same posture.
+ */
+export declare function forceNonInteractive(): void;
+/** True when we should render rich, animated UI to `stream`. */
+export declare function isInteractive(stream?: NodeJS.WriteStream): boolean;
+/** True when we can read interactive keypresses (raw mode) from stdin. */
+export declare function canPromptInteractively(): boolean;

package/dist/runtime.js

@@ -0,0 +1,47 @@
+/**
+ * Interaction-mode detection. The CLI's rich surfaces (Ink components,
+ * prompts, live checklists) only render when we are attached to an interactive
+ * terminal and not running under CI; otherwise everything degrades to plain
+ * line logs so pipes, captures, and `node --test` stay deterministic.
+ */
+/** True under a recognized CI environment. */
+export function isCI() {
+    const env = process.env;
+    return Boolean(env.CI === "true" ||
+        env.CI === "1" ||
+        env.CONTINUOUS_INTEGRATION ||
+        env.GITHUB_ACTIONS ||
+        env.GITLAB_CI ||
+        env.BUILDKITE ||
+        env.CIRCLECI);
+}
+/** The stream all UI is written to (stderr; stdout is reserved for tool output). */
+export function uiStream() {
+    return process.stderr;
+}
+let forcedNonInteractive = false;
+/**
+ * Force non-interactive mode for the rest of the process (the `--no-input` /
+ * `--json` global flags). Also exports `ROUTEKIT_NO_TUI=1` so spawned children
+ * inherit the same posture.
+ */
+export function forceNonInteractive() {
+    forcedNonInteractive = true;
+    process.env.ROUTEKIT_NO_TUI = "1";
+}
+/** True when we should render rich, animated UI to `stream`. */
+export function isInteractive(stream = uiStream()) {
+    if (forcedNonInteractive)
+        return false;
+    if (process.env.ROUTEKIT_NO_TUI === "1")
+        return false;
+    if (isCI())
+        return false;
+    return Boolean(stream.isTTY);
+}
+/** True when we can read interactive keypresses (raw mode) from stdin. */
+export function canPromptInteractively() {
+    if (forcedNonInteractive)
+        return false;
+    return Boolean(process.stdin.isTTY) && !isCI() && process.env.ROUTEKIT_NO_TUI !== "1";
+}

package/dist/test/cli-ui.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/cli-ui.test.js

@@ -0,0 +1,230 @@
+import assert from "node:assert/strict";
+import { getEventListeners } from "node:events";
+import { test } from "node:test";
+import { formatBytes, relativeTime } from "../format.js";
+import { PlainPresenter, renderKeyValueLines, renderTableLines } from "../plain.js";
+import { isInteractive } from "../runtime.js";
+import { watch } from "../presenter.js";
+import { bold, box, brandBanner, brandHeader, cyan, glyph, gradient, stripAnsi, supportsColor, wrapAnsi } from "../theme.js";
+function withNoColor(work) {
+    const prev = process.env.NO_COLOR;
+    process.env.NO_COLOR = "1";
+    try {
+        work();
+    }
+    finally {
+        if (prev === undefined)
+            delete process.env.NO_COLOR;
+        else
+            process.env.NO_COLOR = prev;
+    }
+}
+/** A PlainPresenter capturing its stderr lines for assertions. */
+function capturingPresenter() {
+    let output = "";
+    const stream = {
+        write: (chunk) => {
+            output += chunk;
+            return true;
+        }
+    };
+    return {
+        presenter: new PlainPresenter(stream),
+        lines: () => output.split("\n").filter((line) => line.length > 0)
+    };
+}
+test("color helpers no-op and glyphs use ASCII when color is disabled", () => {
+    withNoColor(() => {
+        assert.equal(supportsColor(), false);
+        assert.equal(bold("hi"), "hi");
+        assert.equal(cyan("hi"), "hi");
+        assert.equal(glyph.tick(), "[ok]");
+        assert.equal(glyph.cross(), "[x]");
+    });
+});
+test("isInteractive is false under the test runner (no TTY)", () => {
+    assert.equal(isInteractive(), false);
+});
+test("brandBanner degrades to the one-line header without color", () => {
+    withNoColor(() => {
+        assert.equal(brandBanner("subtitle"), brandHeader("subtitle"));
+    });
+});
+test("stripAnsi removes styling escapes", () => {
+    assert.equal(stripAnsi("\u001b[1m\u001b[36mhi\u001b[39m\u001b[22m"), "hi");
+});
+test("gradient returns the text unchanged without truecolor", () => {
+    withNoColor(() => {
+        assert.equal(gradient("fusionkit"), "fusionkit");
+    });
+});
+test("box frames a titled block, aligned to the widest line", () => {
+    withNoColor(() => {
+        const out = box("t", ["aa", "bbbb"]);
+        const lines = out.split("\n");
+        assert.equal(lines.length, 4, "top + two body lines + bottom");
+        const widths = lines.map((line) => stripAnsi(line).length);
+        assert.ok(widths.every((width) => width === widths[0]), `frame lines should share a width, got ${widths.join(",")}`);
+        assert.match(out, /bbbb/);
+    });
+});
+test("box wraps overflowing lines instead of overflowing the frame", () => {
+    withNoColor(() => {
+        const long = Array.from({ length: 30 }, (_, index) => `word${index}`).join(" ");
+        const out = box("t", ["short", long]);
+        const lines = out.split("\n");
+        const widths = lines.map((line) => stripAnsi(line).length);
+        assert.ok(lines.length > 4, "the long line should wrap into extra body lines");
+        assert.ok(widths.every((width) => width === widths[0]), `frame lines should share a width, got ${widths.join(",")}`);
+        // Without terminal columns the box caps at 84 total width.
+        assert.ok((widths[0] ?? 0) <= 84, `frame width should stay within the cap, got ${widths[0]}`);
+    });
+});
+test("wrapAnsi keeps every wrapped line within width and self-contained", () => {
+    const styled = `\u001b[2m${Array.from({ length: 12 }, () => "chunk").join(" ")}\u001b[22m end`;
+    const lines = wrapAnsi(styled, 24);
+    assert.ok(lines.length > 1, "should wrap");
+    for (const line of lines) {
+        assert.ok(stripAnsi(line).length <= 24, `line too wide: ${JSON.stringify(line)}`);
+    }
+    // The dim style stays open across breaks: continuations reopen it and every
+    // styled line closes with a full reset.
+    assert.ok(lines[0]?.startsWith("\u001b[2m"));
+    assert.ok(lines[0]?.endsWith("\u001b[0m"));
+    assert.ok(lines[1]?.startsWith("\u001b[2m"));
+    // A word longer than the width is hard-split rather than overflowing.
+    const hard = wrapAnsi("x".repeat(50), 20);
+    assert.deepEqual(hard.map((line) => line.length), [20, 20, 10]);
+});
+test("formatBytes uses binary units", () => {
+    assert.equal(formatBytes(0), "0 B");
+    assert.equal(formatBytes(1024), "1 KB");
+    assert.equal(formatBytes(1536), "1.5 KB");
+    assert.equal(formatBytes(5 * 1024 ** 3), "5 GB");
+});
+test("relativeTime buckets into s/m/h/d", () => {
+    assert.equal(relativeTime(Date.now()), "0s ago");
+    assert.equal(relativeTime(Date.now() - 90_000), "2m ago");
+});
+test("renderTableLines aligns columns against visible width", () => {
+    withNoColor(() => {
+        const lines = renderTableLines([
+            ["a", "bb"],
+            ["ccc", "d"]
+        ], { head: ["x", "y"] });
+        assert.deepEqual(lines, ["x    y", "a    bb", "ccc  d"]);
+    });
+});
+test("renderKeyValueLines pads labels and appends tags", () => {
+    withNoColor(() => {
+        const lines = renderKeyValueLines([
+            { label: "tool", value: "codex", tag: "(default)" },
+            { label: "budget", value: "$5" }
+        ]);
+        assert.deepEqual(lines, ["  tool    codex (default)", "  budget  $5"]);
+    });
+});
+test("plain presenter checklist prints one line per transition", () => {
+    withNoColor(() => {
+        const { presenter, lines } = capturingPresenter();
+        const checklist = presenter.checklist([{ id: "a", label: "step a" }], { title: "boot" });
+        checklist.setActive("a");
+        checklist.setDone("a", "ok");
+        checklist.stop();
+        assert.deepEqual(lines(), ["boot", "> step a", "[ok] step a ok"]);
+    });
+});
+test("plain presenter task settles to a status line", () => {
+    withNoColor(() => {
+        const { presenter, lines } = capturingPresenter();
+        const task = presenter.task("working");
+        task.succeed("done working");
+        assert.deepEqual(lines(), ["> working", "[ok] done working"]);
+    });
+});
+test("plain presenter progress prints milestones, not every update", () => {
+    withNoColor(() => {
+        const { presenter, lines } = capturingPresenter();
+        const progress = presenter.progress("model");
+        progress.update({ downloaded: 10, total: 100 });
+        progress.update({ downloaded: 11, total: 100 });
+        progress.update({ downloaded: 55, total: 100 });
+        progress.succeed();
+        const output = lines();
+        assert.equal(output.filter((line) => line.includes("10%")).length, 1);
+        assert.equal(output.filter((line) => line.includes("50%")).length, 1);
+        assert.match(output[output.length - 1] ?? "", /\[ok\] model/);
+    });
+});
+test("plain presenter liveFrame appends timestamped snapshots", () => {
+    withNoColor(() => {
+        const { presenter, lines } = capturingPresenter();
+        const frame = presenter.liveFrame();
+        frame.render(["first"]);
+        frame.render(() => ["second", "detail"]);
+        frame.stop();
+        const output = lines();
+        assert.equal(output.filter((line) => /^\[\d{4}-\d{2}-\d{2}T/.test(line)).length, 2);
+        assert.deepEqual(output.filter((line) => !line.startsWith("[")), ["first", "second", "detail"]);
+    });
+});
+test("watch renders fetch errors and cancels an in-flight refresh on abort", async () => {
+    const { presenter, lines } = capturingPresenter();
+    const abort = new AbortController();
+    let calls = 0;
+    await watch(presenter, 0.1, () => {
+        calls += 1;
+        if (calls === 1)
+            throw new Error("temporary");
+        abort.abort();
+        return ["healthy"];
+    }, { signal: abort.signal });
+    assert.equal(calls, 2);
+    assert.ok(lines().some((line) => line.includes("error: temporary")));
+    assert.equal(lines().includes("healthy"), false);
+});
+test("watch does not poll with a pre-aborted signal", async () => {
+    const { presenter, lines } = capturingPresenter();
+    const abort = new AbortController();
+    abort.abort();
+    let calls = 0;
+    await watch(presenter, 0.1, () => {
+        calls += 1;
+        return ["unexpected"];
+    }, { signal: abort.signal });
+    assert.equal(calls, 0);
+    assert.deepEqual(lines(), []);
+});
+test("watch does not start a refresh when abort wins the microtask race", async () => {
+    const { presenter } = capturingPresenter();
+    const abort = new AbortController();
+    let calls = 0;
+    queueMicrotask(() => abort.abort());
+    await watch(presenter, 0.1, () => {
+        calls += 1;
+        return ["unexpected"];
+    }, { signal: abort.signal });
+    assert.equal(calls, 0);
+});
+test("watch removes interval abort listeners after each refresh", async () => {
+    const { presenter } = capturingPresenter();
+    const abort = new AbortController();
+    let calls = 0;
+    let maximumListeners = 0;
+    await watch(presenter, 0.1, (signal) => {
+        calls += 1;
+        maximumListeners = Math.max(maximumListeners, getEventListeners(signal, "abort").length);
+        if (calls === 3)
+            abort.abort();
+        return [`frame ${calls}`];
+    }, { signal: abort.signal });
+    assert.equal(calls, 3);
+    assert.ok(maximumListeners <= 1, `abort listeners accumulated: ${maximumListeners}`);
+});
+test("plain presenter status renders glyph, detail, and hint", () => {
+    withNoColor(() => {
+        const { presenter, lines } = capturingPresenter();
+        presenter.status("fail", "uv / uvx", "not found", "install uv");
+        assert.deepEqual(lines(), ["  [x] uv / uvx not found", "    > install uv"]);
+    });
+});

package/dist/test/ink.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/ink.test.js

@@ -0,0 +1,96 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { render } from "ink-testing-library";
+import { ChecklistView, LiveFrameView, ProgressView, TaskView } from "../ink/components.js";
+import { ConfirmPrompt, SelectPrompt } from "../ink/prompts.js";
+import { Store } from "../ink/store.js";
+const ENTER = "\r";
+const ARROW_DOWN = "\u001b[B";
+function frame(text) {
+    return text ?? "";
+}
+test("ChecklistView renders steps and live detail updates", async () => {
+    const store = new Store({
+        title: "booting",
+        steps: [
+            { id: "a", label: "router", status: "active" },
+            { id: "b", label: "gateway", status: "pending" }
+        ]
+    });
+    const { lastFrame, unmount } = render(_jsx(ChecklistView, { store: store }));
+    assert.match(frame(lastFrame()), /booting/);
+    assert.match(frame(lastFrame()), /router/);
+    assert.match(frame(lastFrame()), /gateway/);
+    store.set((state) => ({
+        ...state,
+        steps: state.steps.map((step) => (step.id === "a" ? { ...step, status: "done", detail: "ready" } : step))
+    }));
+    await new Promise((resolve) => setTimeout(resolve, 20));
+    assert.match(frame(lastFrame()), /ready/);
+    unmount();
+});
+test("TaskView renders the spinner text and settles", async () => {
+    const store = new Store({ text: "warming engine" });
+    const { lastFrame, unmount } = render(_jsx(TaskView, { store: store }));
+    assert.match(frame(lastFrame()), /warming engine/);
+    store.set(() => ({ text: "warming engine", settled: { kind: "success", text: "engine ready" } }));
+    await new Promise((resolve) => setTimeout(resolve, 20));
+    assert.match(frame(lastFrame()), /engine ready/);
+    unmount();
+});
+test("ProgressView renders a bar with percent and totals", () => {
+    const store = new Store({
+        label: "model",
+        downloaded: 512,
+        total: 1024,
+        startedAt: Date.now() - 1000
+    });
+    const { lastFrame, unmount } = render(_jsx(ProgressView, { store: store }));
+    assert.match(frame(lastFrame()), /50%/);
+    assert.match(frame(lastFrame()), /512 B \/ 1 KB/);
+    unmount();
+});
+test("LiveFrameView replaces the complete multi-line frame", async () => {
+    const store = new Store({ lines: ["first", "old detail"] });
+    const { lastFrame, unmount } = render(_jsx(LiveFrameView, { store: store }));
+    assert.match(frame(lastFrame()), /first/);
+    assert.match(frame(lastFrame()), /old detail/);
+    store.set(() => ({ lines: ["second", "new detail"] }));
+    await new Promise((resolve) => setTimeout(resolve, 20));
+    assert.doesNotMatch(frame(lastFrame()), /old detail/);
+    assert.match(frame(lastFrame()), /second/);
+    assert.match(frame(lastFrame()), /new detail/);
+    unmount();
+});
+test("SelectPrompt navigates with arrows and submits on enter", async () => {
+    let submitted;
+    const { stdin, unmount } = render(_jsx(SelectPrompt, { message: "Pick a tool", options: [
+            { value: "codex", label: "codex" },
+            { value: "claude", label: "claude" }
+        ], defaultIndex: 0, onSubmit: (value) => {
+            submitted = value;
+        }, onAbort: () => {
+            throw new Error("aborted");
+        } }));
+    await new Promise((resolve) => setTimeout(resolve, 20));
+    stdin.write(ARROW_DOWN);
+    await new Promise((resolve) => setTimeout(resolve, 20));
+    stdin.write(ENTER);
+    await new Promise((resolve) => setTimeout(resolve, 20));
+    assert.equal(submitted, "claude");
+    unmount();
+});
+test("ConfirmPrompt submits the default on enter and toggles with y/n", async () => {
+    let answer;
+    const { stdin, unmount } = render(_jsx(ConfirmPrompt, { message: "Proceed?", defaultValue: true, onSubmit: (value) => {
+            answer = value;
+        }, onAbort: () => {
+            throw new Error("aborted");
+        } }));
+    await new Promise((resolve) => setTimeout(resolve, 20));
+    stdin.write("n");
+    await new Promise((resolve) => setTimeout(resolve, 20));
+    assert.equal(answer, false);
+    unmount();
+});