@mafdet/cli 0.3.0 → 0.4.0

package/dist/tui/adapters/models.js

@@ -0,0 +1,146 @@
+// CLI-020 · What the picker may offer, and how a default is remembered.
+//
+// The admission rule is not restated here. `intersectModels` and
+// `isAgentEligible` are the CLI's single answer to "may this model be used,
+// and may the agent drive it", and the picker asks them rather than deciding
+// for itself - a second opinion in the UI is how a UI ends up widening
+// permissions.
+import { mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync, } from "node:fs";
+import { dirname, join } from "node:path";
+import { fetchAccessibleModels, fetchCatalog, intersectModels, } from "../../api/models.js";
+import { buildRuntime } from "../../commands/runtime.js";
+import { parseUserConfig } from "../../config/config.js";
+import { userConfigPath } from "../../config/paths.js";
+import { formatUsd } from "../../output/money.js";
+/**
+ * The catalogue does not publish a per-route RPM - checked against the live
+ * `/models` response, which has 31 models and no rate field at all. Plan §19.5
+ * says to show `unknown` rather than guess from the model id, so this constant
+ * exists to make the absence explicit instead of quietly dropping the column.
+ */
+export const ROUTE_RPM_AVAILABLE = false;
+export async function loadCatalogue(options) {
+    const runtime = buildRuntime({
+        ...options.io,
+        env: { ...options.io.env, MAFDET_API_KEY: options.apiKey },
+    });
+    const [accessible, catalog] = await Promise.all([
+        fetchAccessibleModels(runtime.dataPlane),
+        fetchCatalog(runtime.accountPlane),
+    ]);
+    const sets = intersectModels(accessible, catalog);
+    const chat = sets.available.filter((model) => (model.apiSurface ?? "CHAT_COMPLETIONS") === "CHAT_COMPLETIONS");
+    return {
+        ...sets,
+        chat,
+        agentReady: chat.filter((model) => model.agentEligible),
+    };
+}
+/** One line of facts under a model's name. Only what the catalogue states. */
+export function describeModel(model) {
+    const parts = [];
+    if (model.provider !== undefined)
+        parts.push(model.provider);
+    parts.push(model.apiSurface ?? "CHAT_COMPLETIONS");
+    parts.push(model.agentEligible ? "tools verified" : "no verified tools");
+    if (model.contextLength !== undefined) {
+        parts.push(`${Math.round(model.contextLength / 1000)}K context`);
+    }
+    const price = priceSummary(model);
+    if (price !== undefined)
+        parts.push(price);
+    if (model.deprecated === true) {
+        parts.push(model.replacement_model_id
+            ? `DEPRECATED - use ${model.replacement_model_id}`
+            : "DEPRECATED");
+    }
+    return parts.join(" - ");
+}
+function priceSummary(model) {
+    const input = model.inputPricePer1mMicroUsd;
+    const output = model.outputPricePer1mMicroUsd;
+    if (input === undefined || output === undefined)
+        return undefined;
+    return `${formatUsd(input)}/${formatUsd(output)} per 1M`;
+}
+/**
+ * Filter by a typed query. Matches the id, the display name, the provider and
+ * the capabilities, so "tool", "deepseek" and "flash" all narrow the list the
+ * way a user would expect.
+ */
+export function filterModels(models, query) {
+    const needle = query.trim().toLowerCase();
+    if (needle.length === 0)
+        return models;
+    return models.filter((model) => {
+        const haystack = [
+            model.modelId,
+            model.displayName ?? "",
+            model.provider ?? "",
+            model.apiSurface ?? "",
+            ...(model.capabilities ?? []),
+            model.agentEligible ? "tools agent" : "",
+        ]
+            .join(" ")
+            .toLowerCase();
+        return haystack.includes(needle);
+    });
+}
+/**
+ * Remember a default model in the user config.
+ *
+ * Only `model` is written, and the existing file is re-validated on the way
+ * through, so this can never introduce a credential or an endpoint into a file
+ * that is not allowed to carry one. The write is atomic: a crash must not
+ * leave a half-written config that the next run refuses to parse.
+ */
+export function saveDefaultModel(options) {
+    const path = options.configPath ?? userConfigPath(options.env);
+    try {
+        let existing = {};
+        try {
+            const raw = JSON.parse(readFileSync(path, "utf8"));
+            // Validating first means a file we would refuse to read is also a file
+            // we refuse to edit, rather than one we silently rewrite.
+            existing = parseUserConfig(raw, path);
+        }
+        catch (error) {
+            if (error.code !== "ENOENT") {
+                if (error instanceof SyntaxError) {
+                    return { saved: false, path, problem: `${path} is not valid JSON` };
+                }
+                return {
+                    saved: false,
+                    path,
+                    problem: error instanceof Error ? error.message : String(error),
+                };
+            }
+        }
+        const next = { ...existing, model: options.modelId };
+        mkdirSync(dirname(path), { recursive: true });
+        const temp = join(dirname(path), `.${Date.now()}.config.tmp`);
+        try {
+            writeFileSync(temp, `${JSON.stringify(next, null, 2)}\n`, {
+                mode: 0o600,
+            });
+            renameSync(temp, path);
+        }
+        catch (error) {
+            try {
+                unlinkSync(temp);
+            }
+            catch {
+                // The temp file may never have been created.
+            }
+            throw error;
+        }
+        return { saved: true, path };
+    }
+    catch (error) {
+        return {
+            saved: false,
+            path,
+            problem: error instanceof Error ? error.message : String(error),
+        };
+    }
+}

package/dist/tui/agent-surface.d.ts

@@ -0,0 +1,25 @@
+import { runSession, type SessionOptions, type SessionSummary } from "../agent/session.js";
+import { type TerminalCapabilities } from "./theme.js";
+import type { WidgetIo } from "./widgets.js";
+export interface AgentSurfaceOptions {
+    readonly io: WidgetIo;
+    readonly capabilities: TerminalCapabilities;
+    readonly stdout: {
+        write(text: string): unknown;
+    };
+    /** Everything runSession needs except the parts this surface supplies. */
+    readonly session: Omit<SessionOptions, "stdout" | "stderr" | "readLine" | "approver" | "onEvent">;
+    /** Injected by the tests; production uses runSession. */
+    readonly run?: typeof runSession;
+}
+/**
+ * Read one line of a goal or slash command.
+ *
+ * A separate reader from the widgets: this one echoes, because a prompt you
+ * cannot see what you typed into is unusable, and unlike the key field there
+ * is nothing secret here.
+ */
+export declare function promptLine(io: WidgetIo, prompt: string): Promise<string | undefined>;
+export declare function runAgentSurface(options: AgentSurfaceOptions): Promise<SessionSummary>;
+export declare function renderSummary(summary: SessionSummary, capabilities: TerminalCapabilities): string;
+//# sourceMappingURL=agent-surface.d.ts.map

package/dist/tui/agent-surface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-surface.d.ts","sourceRoot":"","sources":["../../src/tui/agent-surface.ts"],"names":[],"mappings":"AAQA,OAAO,EACL,UAAU,EACV,KAAK,cAAc,EACnB,KAAK,cAAc,EACpB,MAAM,qBAAqB,CAAC;AAI7B,OAAO,EAAW,KAAK,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAEhE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAE7C,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,EAAE,EAAE,QAAQ,CAAC;IACtB,QAAQ,CAAC,YAAY,EAAE,oBAAoB,CAAC;IAC5C,QAAQ,CAAC,MAAM,EAAE;QAAE,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAA;KAAE,CAAC;IAClD,0EAA0E;IAC1E,QAAQ,CAAC,OAAO,EAAE,IAAI,CACpB,cAAc,EACd,QAAQ,GAAG,QAAQ,GAAG,UAAU,GAAG,UAAU,GAAG,SAAS,CAC1D,CAAC;IACF,yDAAyD;IACzD,QAAQ,CAAC,GAAG,CAAC,EAAE,OAAO,UAAU,CAAC;CAClC;AAED;;;;;;GAMG;AACH,wBAAsB,UAAU,CAC9B,EAAE,EAAE,QAAQ,EACZ,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CA+B7B;AAED,wBAAsB,eAAe,CACnC,OAAO,EAAE,mBAAmB,GAC3B,OAAO,CAAC,cAAc,CAAC,CAkCzB;AAED,wBAAgB,aAAa,CAC3B,OAAO,EAAE,cAAc,EACvB,YAAY,EAAE,oBAAoB,GACjC,MAAM,CAgBR"}

package/dist/tui/agent-surface.js

@@ -0,0 +1,95 @@
+// CLI-021 · The agent, drawn.
+//
+// This drives `runSession` - the same function `mafdet agent` uses - with its
+// own reader, writers and approver. That is deliberate and it is what the
+// plan's completion criterion asks for: the two surfaces cannot produce
+// different models, tools, approvals or costs, because there is only one
+// implementation of all four. What differs is the drawing.
+import { runSession, } from "../agent/session.js";
+import { formatUsd } from "../output/money.js";
+import { tuiApprover } from "./approval.js";
+import { palette } from "./theme.js";
+import { renderCard, ToolCardLog } from "./tool-card.js";
+/**
+ * Read one line of a goal or slash command.
+ *
+ * A separate reader from the widgets: this one echoes, because a prompt you
+ * cannot see what you typed into is unusable, and unlike the key field there
+ * is nothing secret here.
+ */
+export async function promptLine(io, prompt) {
+    const { accent } = palette(io.capabilities);
+    let buffer = "";
+    const redraw = () => {
+        const ESC = String.fromCharCode(27);
+        io.write(`${ESC}[2K${ESC}[G${accent(prompt)}${buffer}`);
+    };
+    redraw();
+    for (;;) {
+        const keys = await io.nextKeys();
+        if (keys === undefined) {
+            io.write("\n");
+            return undefined;
+        }
+        for (const key of keys) {
+            if (key.kind === "enter") {
+                io.write("\n");
+                return buffer;
+            }
+            if (key.kind === "backspace") {
+                buffer = buffer.slice(0, -1);
+            }
+            else if (key.kind === "char") {
+                buffer += key.value;
+            }
+            else if (key.kind === "interrupt" || key.kind === "eof") {
+                io.write("\n");
+                return undefined;
+            }
+        }
+        redraw();
+    }
+}
+export async function runAgentSurface(options) {
+    const { io, capabilities } = options;
+    const { dim, bold } = palette(capabilities);
+    const cards = new ToolCardLog();
+    const run = options.run ?? runSession;
+    const onEvent = (event) => {
+        const changed = cards.apply(event);
+        if (changed !== undefined) {
+            options.stdout.write(renderCard(changed, capabilities));
+            return;
+        }
+        if (event.type === "rate_limited") {
+            // Waiting is not the same as being stuck, and the difference matters
+            // when someone is deciding whether to press Ctrl+C.
+            options.stdout.write(dim(`  rate limited - waiting ${Math.round(event.waitMs / 1000)}s\n`));
+        }
+    };
+    const summary = await run({
+        ...options.session,
+        stdout: (text) => void options.stdout.write(text),
+        // The line session sends progress to stderr so it survives redirection.
+        // Here everything is on one terminal, so it goes to the same place.
+        stderr: (text) => void options.stdout.write(dim(text)),
+        approver: tuiApprover(io),
+        readLine: () => promptLine(io, "> "),
+        onEvent,
+    });
+    options.stdout.write(renderSummary(summary, capabilities));
+    return summary;
+}
+export function renderSummary(summary, capabilities) {
+    const { dim, bold } = palette(capabilities);
+    return ([
+        "",
+        bold("  Session summary"),
+        dim(`  goals            ${summary.goals}`),
+        dim(`  model requests   ${summary.modelRequests}`),
+        dim(`  tool runs        ${summary.toolRuns}`),
+        dim(`  tokens           ${summary.promptTokens} in / ${summary.completionTokens} out`),
+        dim(`  estimated cost   ${formatUsd(summary.costMicroUsd.toString())}`),
+        "",
+    ].join("\n") + "\n");
+}

package/dist/tui/app.d.ts

@@ -0,0 +1,25 @@
+import { ExitCode } from "../output/exit-codes.js";
+import type { CommandIo } from "../commands/runtime.js";
+import { type GuardHost } from "./terminal.js";
+export interface TuiOptions {
+    readonly version: string;
+    readonly workspace: string;
+    readonly stdout: {
+        write(text: string): unknown;
+    };
+    readonly stderr: {
+        write(text: string): unknown;
+    };
+    readonly stdin: NodeJS.ReadStream | {
+        isTTY?: boolean;
+        isRaw?: boolean;
+    };
+    readonly env: Readonly<Record<string, string | undefined>>;
+    readonly host: GuardHost;
+    readonly columns: number | undefined;
+    readonly commandIo: CommandIo;
+    /** The bare invocation's flags, for --allow-write / --allow-command. */
+    readonly argv: readonly string[];
+}
+export declare function runTui(options: TuiOptions): Promise<ExitCode>;
+//# sourceMappingURL=app.d.ts.map

package/dist/tui/app.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"app.d.ts","sourceRoot":"","sources":["../../src/tui/app.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AACnD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AAYxD,OAAO,EAAwB,KAAK,SAAS,EAAE,MAAM,eAAe,CAAC;AAQrE,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,MAAM,EAAE;QAAE,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAA;KAAE,CAAC;IAClD,QAAQ,CAAC,MAAM,EAAE;QAAE,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAA;KAAE,CAAC;IAClD,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,UAAU,GAAG;QAAE,KAAK,CAAC,EAAE,OAAO,CAAC;QAAC,KAAK,CAAC,EAAE,OAAO,CAAA;KAAE,CAAC;IACzE,QAAQ,CAAC,GAAG,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC,CAAC;IAC3D,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IACzB,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,CAAC;IACrC,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAC;IAC9B,wEAAwE;IACxE,QAAQ,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,CAAC;CAClC;AAED,wBAAsB,MAAM,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,QAAQ,CAAC,CAuFnE"}

package/dist/tui/app.js

@@ -0,0 +1,159 @@
+// CLI-018/019 · The TUI entry point.
+//
+// The shape is what matters and it is already load-bearing: the TUI owns no
+// API client, no model truth and no permission policy. It renders, collects
+// input, and reaches everything else through the existing adapters. The model
+// picker (CLI-020) and the agent surface (CLI-021) attach after onboarding.
+import { existsSync } from "node:fs";
+import { ExitCode } from "../output/exit-codes.js";
+import { loadCatalogue, saveDefaultModel } from "./adapters/models.js";
+import { renderBanner } from "./banner.js";
+import { keyboard } from "./input.js";
+import { runOnboarding } from "./onboarding.js";
+import { noAgentModelsNotice, pickModel } from "./picker.js";
+import { palette, detectCapabilities, } from "./theme.js";
+import { followResize } from "./resize.js";
+import { installTerminalGuard } from "./terminal.js";
+import { inspectWorkspace, renderWorkspaceSummary, } from "./workspace-summary.js";
+import { parsePermissions, startAgent } from "./start-agent.js";
+import { select } from "./widgets.js";
+export async function runTui(options) {
+    // Live, not a snapshot: a window resized mid-session must not keep laying
+    // out for the width it used to be.
+    const live = followResize(detectCapabilities({
+        stdoutIsTTY: true, // decideEntry already established this
+        columns: options.columns,
+        env: options.env,
+    }), options.stdout);
+    const capabilities = live.capabilities;
+    const guard = installTerminalGuard({
+        stdout: options.stdout,
+        stdin: options.stdin,
+        host: options.host,
+        onFatal: (error) => {
+            const message = error instanceof Error ? error.message : String(error);
+            options.stderr.write(`mafdet: ${message}\n`);
+        },
+    });
+    const keys = keyboard(options.stdin);
+    const io = {
+        write: (text) => void options.stdout.write(text),
+        nextKeys: () => keys.nextKeys(),
+        capabilities,
+    };
+    try {
+        options.stdout.write(renderBanner({
+            version: options.version,
+            workspace: options.workspace,
+            capabilities,
+        }));
+        const auth = await runOnboarding({
+            io,
+            commandIo: options.commandIo,
+            capabilities,
+        });
+        if (auth.kind === "cancelled") {
+            options.stdout.write("\nNothing was changed. Run 'mafdet help' for the\n");
+            options.stdout.write("commands that work without an interactive session.\n");
+            return ExitCode.Cancelled;
+        }
+        const chosen = await chooseModel({
+            io,
+            commandIo: options.commandIo,
+            apiKey: auth.apiKey,
+            capabilities,
+            stdout: options.stdout,
+        });
+        if (chosen === undefined)
+            return ExitCode.Cancelled;
+        options.stdout.write(renderWorkspaceSummary(inspectWorkspace(options.workspace, existsSync), capabilities));
+        return await startAgent({
+            io,
+            capabilities,
+            stdout: options.stdout,
+            commandIo: options.commandIo,
+            apiKey: auth.apiKey,
+            model: chosen,
+            workspace: options.workspace,
+            permissions: parsePermissions(options.argv),
+        });
+    }
+    finally {
+        live.stop();
+        keys.close();
+        guard.restore();
+        guard.release();
+    }
+}
+/**
+ * Pick a model, then offer to remember it.
+ *
+ * Only the model id is ever persisted. The key stays in memory for the life of
+ * the process, which is the promise onboarding made.
+ */
+async function chooseModel(options) {
+    const { dim, bold } = palette(options.capabilities);
+    options.stdout.write(dim("  loading the model catalogue...\n"));
+    let catalogue;
+    try {
+        catalogue = await loadCatalogue({
+            apiKey: options.apiKey,
+            io: options.commandIo,
+        });
+    }
+    catch (error) {
+        // A plane being unreachable is a thing to report, not a stack trace to
+        // drop on someone. The commands still work, and saying which ones is more
+        // use than the exception.
+        const message = error instanceof Error ? error.message : String(error);
+        options.stdout.write(`\n  ${bold("could not load the model list")}: ${message}\n` +
+            dim("  the key is fine - this is the catalogue or the network.\n") +
+            dim("  'mafdet doctor' will say which, and 'mafdet chat --model <id>'\n") +
+            dim("  still works if you already know the model you want.\n\n"));
+        return undefined;
+    }
+    if (catalogue.chat.length === 0) {
+        options.stdout.write(`\n  ${bold("this key cannot call any chat model")}\n` +
+            dim("  check the key's model permissions in the console, or run\n") +
+            dim("  'mafdet models list' to see what it can reach.\n\n"));
+        return undefined;
+    }
+    if (catalogue.agentReady.length === 0) {
+        options.stdout.write(noAgentModelsNotice(catalogue.chat.length, options.capabilities));
+    }
+    const picked = await pickModel(options.io, {
+        models: catalogue.chat,
+        // Fail closed: offer only agent-capable models when any exist, so a
+        // model the agent cannot drive never becomes the session's default.
+        agentOnly: catalogue.agentReady.length > 0,
+        current: options.commandIo.env?.MAFDET_MODEL,
+    });
+    if (picked.kind === "cancelled" || picked.model === undefined)
+        return undefined;
+    const remember = await select(options.io, {
+        title: `Remember ${picked.model.modelId} as your default?`,
+        items: [
+            {
+                value: false,
+                label: "Not now",
+                detail: "use it for this session only",
+            },
+            {
+                value: true,
+                label: "Yes, save it",
+                detail: "writes only the model name - never the key",
+            },
+        ],
+    });
+    if (remember.kind === "picked" && remember.value === true) {
+        const saved = saveDefaultModel({
+            modelId: picked.model.modelId,
+            env: options.commandIo.env ?? {},
+            configPath: options.commandIo.userConfigFile,
+        });
+        options.stdout.write(saved.saved
+            ? dim(`  saved to ${saved.path}\n`)
+            : dim(`  could not save to ${saved.path}: ${saved.problem}\n`));
+    }
+    return picked.model;
+}

package/dist/tui/approval.d.ts

@@ -0,0 +1,27 @@
+import type { ApprovalRequest, Approver } from "../agent/approvals.js";
+import { type TerminalCapabilities } from "./theme.js";
+import { type WidgetIo } from "./widgets.js";
+export interface DiffPanel {
+    readonly lines: readonly string[];
+    readonly hiddenLines: number;
+}
+/**
+ * Prepare a preview for the terminal.
+ *
+ * The preview is a diff or a command line built from the model's output, so it
+ * is stripped of control sequences first. Long previews are cut rather than
+ * flooded: a thousand-line diff scrolls the question itself off the screen,
+ * and being asked to approve something you can no longer see is worse than
+ * being told there is more.
+ */
+export declare function diffPanel(preview: string, columns: number): DiffPanel;
+export declare function renderApprovalRequest(request: ApprovalRequest, capabilities: TerminalCapabilities): string;
+/**
+ * An approver that shows the change and asks, once, for this change only.
+ *
+ * Cancelling the prompt is a refusal. That is the same rule the line-based
+ * approver uses for a bare Enter: the safe answer has to be the one you get by
+ * not thinking about it.
+ */
+export declare function tuiApprover(io: WidgetIo): Approver;
+//# sourceMappingURL=approval.d.ts.map

package/dist/tui/approval.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"approval.d.ts","sourceRoot":"","sources":["../../src/tui/approval.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,eAAe,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAEvE,OAAO,EAAW,KAAK,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAChE,OAAO,EAAU,KAAK,QAAQ,EAAE,MAAM,cAAc,CAAC;AAKrD,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;CAC9B;AAED;;;;;;;;GAQG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,SAAS,CAMrE;AAQD,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,eAAe,EACxB,YAAY,EAAE,oBAAoB,GACjC,MAAM,CAkBR;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,EAAE,EAAE,QAAQ,GAAG,QAAQ,CAmBlD"}

package/dist/tui/approval.js

@@ -0,0 +1,79 @@
+// CLI-021 · The approval panel.
+//
+// This is a renderer for the existing `Approver` interface, not a second
+// approval system. The agent loop still calls `approve()` and still refuses
+// when there is no approver, so the TUI cannot grant anything the line-based
+// session could not. There is no "always allow" here and no session-wide
+// consent: the plan forbids both, and adding one would make every other
+// guarantee about writes conditional on a keystroke someone made once.
+import { stripAnsi } from "../agent/command-policy.js";
+import { palette } from "./theme.js";
+import { select } from "./widgets.js";
+/** Lines of a preview shown before it is collapsed. */
+const PREVIEW_LIMIT = 40;
+/**
+ * Prepare a preview for the terminal.
+ *
+ * The preview is a diff or a command line built from the model's output, so it
+ * is stripped of control sequences first. Long previews are cut rather than
+ * flooded: a thousand-line diff scrolls the question itself off the screen,
+ * and being asked to approve something you can no longer see is worse than
+ * being told there is more.
+ */
+export function diffPanel(preview, columns) {
+    const all = stripAnsi(preview).split("\n");
+    const kept = all
+        .slice(0, PREVIEW_LIMIT)
+        .map((line) => clip(line, columns - 4));
+    return { lines: kept, hiddenLines: Math.max(all.length - kept.length, 0) };
+}
+function clip(text, width) {
+    const chars = [...text];
+    if (width <= 3 || chars.length <= width)
+        return text;
+    return chars.slice(0, width - 3).join("") + "...";
+}
+export function renderApprovalRequest(request, capabilities) {
+    const { bold, dim, accent } = palette(capabilities);
+    const panel = diffPanel(request.preview, capabilities.columns);
+    const lines = ["", `  ${bold(stripAnsi(request.summary))}`, ""];
+    for (const line of panel.lines) {
+        // Diff markers get the accent so additions and removals are findable
+        // without colour being required to read them.
+        lines.push(line.startsWith("+") || line.startsWith("-")
+            ? `    ${accent(line)}`
+            : `    ${dim(line)}`);
+    }
+    if (panel.hiddenLines > 0) {
+        lines.push(dim(`    ... ${panel.hiddenLines} more line(s) not shown`));
+    }
+    lines.push("");
+    return lines.join("\n") + "\n";
+}
+/**
+ * An approver that shows the change and asks, once, for this change only.
+ *
+ * Cancelling the prompt is a refusal. That is the same rule the line-based
+ * approver uses for a bare Enter: the safe answer has to be the one you get by
+ * not thinking about it.
+ */
+export function tuiApprover(io) {
+    return {
+        async approve(request) {
+            io.write(renderApprovalRequest(request, io.capabilities));
+            const answer = await select(io, {
+                title: "Apply this change?",
+                items: [
+                    { value: false, label: "No", detail: "nothing is changed or run" },
+                    {
+                        value: true,
+                        label: "Yes, once",
+                        detail: "applies only this change",
+                    },
+                ],
+            });
+            // Cancelled, ended input, or "No" - all of them mean no.
+            return answer.kind === "picked" && answer.value === true;
+        },
+    };
+}

package/dist/tui/banner.d.ts

@@ -0,0 +1,13 @@
+import { type TerminalCapabilities } from "./theme.js";
+export interface BannerInput {
+    readonly version: string;
+    readonly workspace: string;
+    readonly capabilities: TerminalCapabilities;
+}
+/**
+ * The wordmark, or a single line when the terminal is too narrow to hold it
+ * without wrapping — a wrapped wordmark looks like a rendering bug.
+ */
+export declare function wordmark(capabilities: TerminalCapabilities): string[];
+export declare function renderBanner(input: BannerInput): string;
+//# sourceMappingURL=banner.d.ts.map

package/dist/tui/banner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"banner.d.ts","sourceRoot":"","sources":["../../src/tui/banner.ts"],"names":[],"mappings":"AAOA,OAAO,EAA2B,KAAK,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAqBhF,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,YAAY,EAAE,oBAAoB,CAAC;CAC7C;AASD;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,YAAY,EAAE,oBAAoB,GAAG,MAAM,EAAE,CAOrE;AAuBD,wBAAgB,YAAY,CAAC,KAAK,EAAE,WAAW,GAAG,MAAM,CAyCvD"}