@viraatdas/rudder 0.1.2 → 0.3.0

package/dist/tui.js

@@ -0,0 +1,721 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import fsp from "node:fs/promises";
+import { useCallback, useEffect, useState } from "react";
+import { Box, Text, render, useApp, useInput, useWindowSize } from "ink";
+import { currentBranch, findRepoRoot } from "./git.js";
+import { eventsPath, listRuns, loadConfig, outputPath, } from "./state.js";
+import { continueRun, mergeRun, startRun, stopRun } from "./run-manager.js";
+import { pathExists, shortenHome } from "./util.js";
+const BACKENDS = ["claude", "codex", "acpx"];
+export async function runInteractiveTui(defaults) {
+    const instance = render(_jsx(RudderTui, { defaults: defaults ?? {} }), {
+        alternateScreen: true,
+        exitOnCtrlC: false,
+        maxFps: 60,
+    });
+    await instance.waitUntilExit();
+}
+function RudderTui({ defaults }) {
+    const app = useApp();
+    const size = useWindowSize();
+    const [repoRoot, setRepoRoot] = useState(() => findRepoRoot());
+    const [branch, setBranch] = useState("HEAD");
+    const [config, setConfig] = useState(null);
+    const [backend, setBackend] = useState(defaults.backend ?? "claude");
+    const [model, setModel] = useState(defaults.model);
+    const [worktreeMode, setWorktreeMode] = useState(defaults.worktree === false ? "auto" : "always");
+    const [runs, setRuns] = useState([]);
+    const [selectedRunId, setSelectedRunId] = useState();
+    const [targetRunId, setTargetRunId] = useState();
+    const [expandedRunIds, setExpandedRunIds] = useState(new Set());
+    const [transcriptExpanded, setTranscriptExpanded] = useState(false);
+    const [input, setInput] = useState("");
+    const [notice, setNotice] = useState("Ready");
+    const [helpOpen, setHelpOpen] = useState(false);
+    const [submitting, setSubmitting] = useState(false);
+    const [preferencesLoaded, setPreferencesLoaded] = useState(false);
+    const refresh = useCallback(async () => {
+        const root = findRepoRoot();
+        const [nextConfig, nextBranch, nextRuns] = await Promise.all([
+            loadConfig(),
+            currentBranch(root),
+            loadUiRuns(root),
+        ]);
+        setRepoRoot(root);
+        setConfig(nextConfig);
+        setBranch(nextBranch);
+        setRuns(nextRuns);
+        if (!preferencesLoaded) {
+            setBackend(defaults.backend ?? nextConfig.lastUsedBackend ?? nextConfig.defaultBackend);
+            setModel(defaults.model);
+            setPreferencesLoaded(true);
+        }
+        setSelectedRunId((current) => current ?? nextRuns[0]?.id);
+    }, [defaults.backend, defaults.model, preferencesLoaded]);
+    useEffect(() => {
+        void refresh();
+        const timer = setInterval(() => {
+            void refresh();
+        }, input ? 1500 : 900);
+        return () => clearInterval(timer);
+    }, [input, refresh]);
+    const selectedIndex = Math.max(0, runs.findIndex((run) => run.id === selectedRunId));
+    const selectedRun = runs[selectedIndex];
+    const targetRun = targetRunId ? runs.find((run) => run.id === targetRunId) : undefined;
+    const activeCount = runs.filter((run) => isActive(run.status)).length;
+    const selectedExpanded = Boolean(selectedRun && expandedRunIds.has(selectedRun.id));
+    const submitTask = useCallback(async (task) => {
+        const trimmed = task.trim();
+        if (!trimmed || submitting) {
+            return;
+        }
+        setSubmitting(true);
+        if (targetRun) {
+            setNotice(`Sending to ${shortId(targetRun.id)}...`);
+            try {
+                const run = await continueRun({
+                    runId: targetRun.id,
+                    prompt: trimmed,
+                    silent: true,
+                });
+                setInput("");
+                setSelectedRunId(run.id);
+                setExpandedRunIds((current) => new Set(current).add(run.id));
+                setNotice(`Sent to ${shortId(run.id)}`);
+                await refresh();
+            }
+            catch (error) {
+                setNotice(error instanceof Error ? error.message : String(error));
+            }
+            finally {
+                setSubmitting(false);
+            }
+            return;
+        }
+        setNotice(`Starting ${backend}...`);
+        try {
+            const run = await startRun({
+                task: trimmed,
+                backend,
+                model,
+                detach: true,
+                worktree: worktreeMode === "always",
+                silent: true,
+                view: "shell",
+            });
+            setInput("");
+            setSelectedRunId(run.id);
+            setExpandedRunIds((current) => new Set(current).add(run.id));
+            setNotice(`Started ${run.id}`);
+            await refresh();
+        }
+        catch (error) {
+            setNotice(error instanceof Error ? error.message : String(error));
+        }
+        finally {
+            setSubmitting(false);
+        }
+    }, [backend, model, refresh, submitting, targetRun, worktreeMode]);
+    const handleCommand = useCallback(async (line) => {
+        const [command = "", ...args] = line.slice(1).trim().split(/\s+/).filter(Boolean);
+        switch (command) {
+            case "":
+            case "help":
+            case "?":
+                setHelpOpen((value) => !value);
+                setInput("");
+                return;
+            case "q":
+            case "quit":
+            case "exit":
+                app.exit();
+                return;
+            case "backend":
+                if (isBackend(args[0])) {
+                    chooseBackend(args[0], setBackend, setModel, setNotice);
+                }
+                else {
+                    setNotice("Usage: /backend claude|codex|acpx");
+                }
+                setInput("");
+                return;
+            case "agent":
+            case "continue": {
+                const run = resolveUiRun(runs, args[0] ?? selectedRun?.id);
+                if (run) {
+                    setTargetRunId(run.id);
+                    setSelectedRunId(run.id);
+                    setNotice(`Typing to ${shortId(run.id)}`);
+                }
+                else {
+                    setNotice("No agent selected");
+                }
+                setInput("");
+                return;
+            }
+            case "new":
+                setTargetRunId(undefined);
+                setNotice("Typing starts a new agent");
+                setInput("");
+                return;
+            case "model":
+                setModel(args.join(" ") || undefined);
+                setNotice(args.length ? `Model ${args.join(" ")}` : "Using backend default model");
+                setInput("");
+                return;
+            case "worktree":
+                setWorktreeMode(args[0] === "always" || args[0] === "on" ? "always" : "auto");
+                setNotice(`Worktrees ${args[0] === "always" || args[0] === "on" ? "always" : "auto"}`);
+                setInput("");
+                return;
+            case "stop":
+                await runAction(args[0] ?? selectedRun?.id, async (id) => stopRun(id, { silent: true }), "Stopped", setNotice, refresh);
+                setInput("");
+                return;
+            case "merge":
+                await runAction(args[0] ?? selectedRun?.id, async (id) => mergeRun(id, args.includes("--allow-dirty"), { silent: true }), "Merged", setNotice, refresh);
+                setInput("");
+                return;
+            case "merge-all":
+                await mergeReadyRuns(runs, args.includes("--allow-dirty"), setNotice, refresh);
+                setInput("");
+                return;
+            case "clear":
+                setExpandedRunIds(new Set());
+                setNotice("Collapsed all runs");
+                setInput("");
+                return;
+            default:
+                setNotice(`Unknown command: /${command}`);
+                setInput("");
+        }
+    }, [app, refresh, runs, selectedRun?.id]);
+    useInput((value, key) => {
+        if (key.ctrl && value === "c") {
+            app.exit();
+            return;
+        }
+        if (key.escape) {
+            if (input) {
+                setInput("");
+            }
+            else if (helpOpen) {
+                setHelpOpen(false);
+            }
+            else if (transcriptExpanded) {
+                setTranscriptExpanded(false);
+            }
+            return;
+        }
+        if (key.tab || value === "\t") {
+            cycleBackend(backend, setBackend, setModel, setNotice);
+            return;
+        }
+        if (key.upArrow || (input.length === 0 && value === "k")) {
+            selectRelative(runs, selectedRunId, -1, setSelectedRunId);
+            return;
+        }
+        if (key.downArrow || (input.length === 0 && value === "j")) {
+            selectRelative(runs, selectedRunId, 1, setSelectedRunId);
+            return;
+        }
+        if (key.pageUp) {
+            selectRelative(runs, selectedRunId, -5, setSelectedRunId);
+            return;
+        }
+        if (key.pageDown) {
+            selectRelative(runs, selectedRunId, 5, setSelectedRunId);
+            return;
+        }
+        if (key.return) {
+            if (input.trim().startsWith("/")) {
+                void handleCommand(input);
+            }
+            else {
+                void submitTask(input);
+            }
+            return;
+        }
+        if ((key.meta && (key.backspace || key.delete)) || value === "\u001b\u007f" || value === "\u001b\b") {
+            setInput((current) => deletePreviousWord(current));
+            return;
+        }
+        if (key.ctrl && value === "w") {
+            setInput((current) => deletePreviousWord(current));
+            return;
+        }
+        if (key.backspace || key.delete || value === "\u007f" || value === "\b") {
+            setInput((current) => current.slice(0, -1));
+            return;
+        }
+        if (input.length === 0 && value === "q") {
+            app.exit();
+            return;
+        }
+        if (input.length === 0 && value === "?") {
+            setHelpOpen((current) => !current);
+            return;
+        }
+        if (input.length === 0 && value === "r") {
+            void refresh();
+            setNotice("Refreshed");
+            return;
+        }
+        if (input.length === 0 && value === "b") {
+            cycleBackend(backend, setBackend, setModel, setNotice);
+            return;
+        }
+        if (input.length === 0 && value === "c" && selectedRun) {
+            setTargetRunId(selectedRun.id);
+            setNotice(`Typing to ${shortId(selectedRun.id)}`);
+            return;
+        }
+        if (input.length === 0 && value === "n") {
+            setTargetRunId(undefined);
+            setNotice("Typing starts a new agent");
+            return;
+        }
+        if (input.length === 0 && value === "w") {
+            setWorktreeMode((current) => current === "auto" ? "always" : "auto");
+            return;
+        }
+        if (input.length === 0 && value === "x" && selectedRun) {
+            setExpandedRunIds((current) => toggleSet(current, selectedRun.id));
+            return;
+        }
+        if (input.length === 0 && value === "l" && selectedRun) {
+            setTranscriptExpanded((current) => !current);
+            return;
+        }
+        if (input.length === 0 && value === "s" && selectedRun) {
+            void runAction(selectedRun.id, async (id) => stopRun(id, { silent: true }), "Stopped", setNotice, refresh);
+            return;
+        }
+        if (input.length === 0 && value === "m" && selectedRun) {
+            void runAction(selectedRun.id, async (id) => mergeRun(id, false, { silent: true }), "Merged", setNotice, refresh);
+            return;
+        }
+        if (input.length === 0 && value === "M") {
+            void mergeReadyRuns(runs, false, setNotice, refresh);
+            return;
+        }
+        if (isPrintable(value)) {
+            setInput((current) => current + value);
+        }
+    });
+    const width = Math.max(80, size.columns);
+    const height = Math.max(24, size.rows);
+    const railWidth = Math.min(42, Math.max(30, Math.floor(width * 0.34)));
+    const detailWidth = Math.max(30, width - railWidth - 1);
+    const detailHeight = Math.max(8, height - 8);
+    return (_jsxs(Box, { flexDirection: "column", width: width, height: height, children: [_jsx(Header, { width: width, repoRoot: repoRoot, branch: branch, backend: backend, model: model ?? modelForBackend(backend, config), activeCount: activeCount, worktreeMode: worktreeMode }), _jsxs(Box, { flexGrow: 1, minHeight: 0, children: [_jsx(RunRail, { runs: runs, selectedRunId: selectedRun?.id, targetRunId: targetRunId, width: railWidth, expandedRunIds: expandedRunIds }), _jsx(Box, { flexDirection: "column", flexGrow: 1, marginLeft: 1, children: _jsx(DetailPane, { run: selectedRun, width: detailWidth, height: detailHeight, expanded: selectedExpanded, transcriptExpanded: transcriptExpanded }) })] }), helpOpen ? _jsx(Help, {}) : null, _jsx(PromptDock, { input: input, backend: backend, model: model ?? modelForBackend(backend, config), notice: notice, submitting: submitting, targetRun: targetRun }), _jsx(Footer, {})] }));
+}
+function Header(props) {
+    const contentWidth = Math.max(10, props.width - 4);
+    const label = `rudder  ${shortenHome(props.repoRoot)} ${props.branch}  |  ${props.backend}${props.model ? ` ${props.model}` : ""}  |  worktree:${props.worktreeMode}  active:${props.activeCount}`;
+    return (_jsx(Box, { borderStyle: "single", borderColor: "cyan", paddingX: 1, children: _jsx(Text, { bold: true, color: "cyan", children: fitLine(label, contentWidth) }) }));
+}
+function RunRail(props) {
+    const visible = props.runs.slice(0, 12);
+    return (_jsxs(Box, { flexDirection: "column", width: props.width, borderStyle: "single", borderColor: "gray", paddingX: 1, children: [_jsxs(Box, { justifyContent: "space-between", children: [_jsx(Text, { bold: true, children: "agents" }), _jsxs(Text, { color: "gray", children: [props.runs.length, " runs"] })] }), visible.length === 0 ? (_jsx(Box, { marginTop: 1, children: _jsx(Text, { color: "gray", children: "No runs yet. Type a task below." }) })) : null, visible.map((run) => (_jsx(RunCard, { run: run, selected: run.id === props.selectedRunId, targeted: run.id === props.targetRunId, expanded: props.expandedRunIds.has(run.id), width: props.width - 4 }, run.id)))] }));
+}
+function RunCard(props) {
+    const tone = statusColor(props.run.status);
+    const label = props.selected ? ">" : " ";
+    const task = truncate(props.run.task, Math.max(12, props.width - 14));
+    const progress = completionPercent(props.run);
+    const summary = truncate(runSummary(props.run), Math.max(12, props.width - 8));
+    const meta = `${progressBar(progress)} ${progress}%`;
+    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Text, { wrap: "truncate", color: props.selected ? "white" : "gray", bold: props.selected, children: [label, " ", meta, " ", statusGlyph(props.run.status), " ", props.run.backend, " ", task] }), _jsxs(Text, { wrap: "truncate", color: tone, children: ["  ", props.run.worktree.enabled ? "wt" : "co", " ", props.targeted ? "typing " : "", summary] })] }));
+}
+function DetailPane(props) {
+    if (!props.run) {
+        return (_jsx(Box, { width: props.width, height: props.height, borderStyle: "single", borderColor: "gray", paddingX: 1, flexDirection: "column", children: _jsx(Text, { color: "gray", children: "No agent selected." }) }));
+    }
+    const workLimit = props.expanded ? 10 : 5;
+    const outputHeight = props.transcriptExpanded ? Math.max(8, props.height - 7) : Math.max(5, Math.floor(props.height * 0.45));
+    const contentWidth = Math.max(10, props.width - 4);
+    const progress = completionPercent(props.run);
+    return (_jsxs(Box, { width: props.width, height: props.height, borderStyle: "single", borderColor: statusColor(props.run.status), paddingX: 1, flexDirection: "column", children: [_jsx(Text, { children: " " }), _jsx(Text, { wrap: "truncate", color: statusColor(props.run.status), children: fitLine(`${props.run.status}  ${progress}%  ${props.run.backend} ${shortId(props.run.id)}  ${props.run.task}`, contentWidth) }), _jsx(Text, { wrap: "truncate", color: "gray", children: fitLine(props.run.worktree.enabled ? shortenHome(props.run.worktree.path) : "current checkout", contentWidth) }), _jsx(Text, { wrap: "truncate", color: canMerge(props.run) ? "green" : "gray", children: fitLine(canMerge(props.run) ? "[m] merge this  [M] merge all ready" : runSummary(props.run), contentWidth) }), !props.transcriptExpanded ? (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { bold: true, children: "work" }), props.run.work.slice(-workLimit).map((item, index) => (_jsx(Text, { color: toneColor(item.tone), wrap: "truncate", children: formatWorkLine(item, contentWidth) }, `${item.label}-${index}`))), props.run.work.length === 0 ? _jsx(Text, { color: "gray", children: "No worker events yet." }) : null] })) : null, _jsxs(Box, { flexDirection: "column", marginTop: 1, minHeight: 0, children: [_jsx(Text, { bold: true, children: "transcript" }), _jsx(Box, { height: outputHeight, overflow: "hidden", flexDirection: "column", children: tailLines(props.run.output, outputHeight).map((line, index) => (_jsx(Text, { wrap: "truncate", children: line || " " }, index))) })] })] }));
+}
+function Help() {
+    return (_jsxs(Box, { borderStyle: "single", borderColor: "yellow", paddingX: 1, flexDirection: "column", children: [_jsx(Text, { bold: true, color: "yellow", children: "keys" }), _jsxs(Text, { children: [_jsx(Text, { color: "cyan", children: "Enter" }), " submit task or slash command   ", _jsx(Text, { color: "cyan", children: "Tab" }), " switch backend   ", _jsx(Text, { color: "cyan", children: "j/k" }), " or arrows select run"] }), _jsxs(Text, { children: [_jsx(Text, { color: "cyan", children: "x" }), " expand/collapse   ", _jsx(Text, { color: "cyan", children: "l" }), " transcript   ", _jsx(Text, { color: "cyan", children: "c" }), " type to selected   ", _jsx(Text, { color: "cyan", children: "n" }), " new agent"] }), _jsxs(Text, { children: [_jsx(Text, { color: "cyan", children: "w" }), " worktree auto/always   ", _jsx(Text, { color: "cyan", children: "s" }), " stop   ", _jsx(Text, { color: "cyan", children: "m" }), " merge selected   ", _jsx(Text, { color: "cyan", children: "M" }), " merge all ready"] }), _jsx(Text, { color: "gray", children: "Slash: /backend claude|codex|acpx, /model <name>, /agent, /new, /worktree, /stop, /merge, /merge-all, /exit" })] }));
+}
+function PromptDock(props) {
+    const label = props.targetRun ? `agent ${shortId(props.targetRun.id)}` : "task";
+    return (_jsxs(Box, { borderStyle: "single", borderColor: "cyan", paddingX: 1, justifyContent: "space-between", children: [_jsxs(Text, { children: [_jsx(Text, { color: props.submitting ? "yellow" : "cyan", children: props.submitting ? "starting" : label }), _jsxs(Text, { children: ["  ", props.input] }), _jsx(Text, { color: "cyan", children: "_" })] }), _jsxs(Text, { color: "gray", children: [props.notice, "  ", props.backend, props.model ? ` ${props.model}` : ""] })] }));
+}
+function Footer() {
+    return (_jsx(Box, { children: _jsx(Text, { color: "gray", children: "Enter submit  Tab backend  c continue  n new  j/k  m/M merge  ? help  q quit" }) }));
+}
+async function loadUiRuns(repoRoot) {
+    const runs = await listRuns(repoRoot);
+    return await Promise.all(runs.map(async (run) => {
+        const [output, events] = await Promise.all([
+            readTextIfExists(outputPath(repoRoot, run.id)),
+            readEvents(repoRoot, run.id),
+        ]);
+        return {
+            ...run,
+            output,
+            events,
+            work: buildWork(events, run),
+        };
+    }));
+}
+async function readTextIfExists(file) {
+    if (!(await pathExists(file))) {
+        return "";
+    }
+    return await fsp.readFile(file, "utf8").catch(() => "");
+}
+async function readEvents(repoRoot, runId) {
+    const file = eventsPath(repoRoot, runId);
+    const raw = await readTextIfExists(file);
+    return raw
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .map((line) => {
+        try {
+            return JSON.parse(line);
+        }
+        catch {
+            return null;
+        }
+    })
+        .filter((event) => Boolean(event));
+}
+function buildWork(events, run) {
+    const items = [];
+    for (const event of events) {
+        if (event.type === "run.created") {
+            items.push({ label: run.worktree.enabled ? "worktree prepared" : "checkout claimed", detail: event.message, tone: "info" });
+            continue;
+        }
+        if (event.type === "run.continued") {
+            items.push({ label: "user follow-up", detail: event.message, tone: "info" });
+            continue;
+        }
+        if (event.type === "steerer.waiting") {
+            items.push({ label: "auto-steering wait", detail: "10s grace period", tone: "warning" });
+            continue;
+        }
+        if (event.type === "steerer.prompt") {
+            items.push({ label: "auto-steering", detail: "review prompt sent", tone: "info" });
+            continue;
+        }
+        if (event.type === "planner.spec") {
+            items.push({ label: "planner contract", detail: "acceptance criteria generated", tone: "info" });
+            continue;
+        }
+        if (event.type === "run.started") {
+            items.push({ label: "worker started", detail: objectField(event.data, "command") ?? run.backend, tone: "info" });
+            continue;
+        }
+        if (event.type === "backend.output") {
+            const tool = toolSummary(event.data);
+            if (tool) {
+                items.push(tool);
+            }
+            continue;
+        }
+        if (event.type === "backend.error") {
+            items.push({ label: "backend error", detail: event.message, tone: "danger" });
+            continue;
+        }
+        if (event.type === "verifier.result") {
+            const missing = missingCount(event.data);
+            items.push({ label: "verifier", detail: missing ? `${missing} missing item${missing === 1 ? "" : "s"}` : "accepted", tone: missing ? "warning" : "success" });
+            continue;
+        }
+        if (event.type === "run.completed") {
+            items.push({ label: "completed", detail: event.message, tone: "success" });
+            continue;
+        }
+        if (event.type === "run.failed") {
+            items.push({ label: "failed", detail: event.message, tone: "danger" });
+            continue;
+        }
+        if (event.type === "run.cancelled") {
+            items.push({ label: "cancelled", detail: event.message, tone: "warning" });
+            continue;
+        }
+        if (event.type === "merge.result") {
+            items.push({ label: "merge", detail: event.message, tone: event.message?.includes("conflict") ? "warning" : "success" });
+        }
+    }
+    return compactWork(items);
+}
+function toolSummary(data) {
+    if (!isRecord(data) || data.type !== "stream_event" || !isRecord(data.event)) {
+        return null;
+    }
+    const event = data.event;
+    if (event.type === "content_block_start" && isRecord(event.content_block)) {
+        const block = event.content_block;
+        if (block.type === "tool_use") {
+            return { label: "tool", detail: typeof block.name === "string" ? block.name : "tool_use", tone: "muted" };
+        }
+    }
+    return null;
+}
+function compactWork(items) {
+    const compacted = [];
+    for (const item of items) {
+        const last = compacted.at(-1);
+        if (last && last.label === item.label && last.detail === item.detail && last.tone === item.tone) {
+            continue;
+        }
+        compacted.push(item);
+    }
+    return compacted;
+}
+function formatWorkLine(item, width) {
+    const raw = `${workGlyph(item.tone)} ${item.label}${item.detail ? `  ${item.detail}` : ""}`;
+    return fitLine(raw, width);
+}
+function fitLine(value, width) {
+    return truncate(value, width).padEnd(width, " ");
+}
+async function runAction(runId, action, success, setNotice, refresh) {
+    if (!runId) {
+        setNotice("No run selected");
+        return;
+    }
+    try {
+        await action(runId);
+        setNotice(`${success} ${shortId(runId)}`);
+        await refresh();
+    }
+    catch (error) {
+        setNotice(error instanceof Error ? error.message : String(error));
+    }
+}
+async function mergeReadyRuns(runs, allowDirty, setNotice, refresh) {
+    const ready = runs.filter(canMerge);
+    if (ready.length === 0) {
+        setNotice("No completed worktree runs ready to merge");
+        return;
+    }
+    setNotice(`Merging ${ready.length} run${ready.length === 1 ? "" : "s"}...`);
+    let merged = 0;
+    for (const run of ready) {
+        await mergeRun(run.id, allowDirty, { silent: true });
+        merged += 1;
+    }
+    setNotice(`Merged ${merged} run${merged === 1 ? "" : "s"}`);
+    await refresh();
+}
+function selectRelative(runs, selectedRunId, delta, setSelectedRunId) {
+    if (runs.length === 0) {
+        return;
+    }
+    const index = Math.max(0, runs.findIndex((run) => run.id === selectedRunId));
+    const next = Math.min(runs.length - 1, Math.max(0, index + delta));
+    setSelectedRunId(runs[next]?.id);
+}
+function cycleBackend(current, setBackend, setModel, setNotice) {
+    const index = BACKENDS.indexOf(current);
+    chooseBackend(BACKENDS[(index + 1) % BACKENDS.length] ?? "claude", setBackend, setModel, setNotice);
+}
+function chooseBackend(backend, setBackend, setModel, setNotice) {
+    setBackend(backend);
+    setModel(undefined);
+    setNotice(`Backend ${backend}`);
+}
+function toggleSet(current, value) {
+    const next = new Set(current);
+    if (next.has(value)) {
+        next.delete(value);
+    }
+    else {
+        next.add(value);
+    }
+    return next;
+}
+function modelForBackend(backend, config) {
+    if (!config) {
+        return undefined;
+    }
+    if (backend === "claude") {
+        return config.backends.claude?.model;
+    }
+    if (backend === "codex") {
+        return config.backends.codex?.model;
+    }
+    return config.backends.acpx?.model;
+}
+function resolveUiRun(runs, runId) {
+    if (!runId) {
+        return undefined;
+    }
+    return runs.find((run) => run.id === runId || run.id.startsWith(runId));
+}
+function isBackend(value) {
+    return value === "claude" || value === "codex" || value === "acpx";
+}
+function isPrintable(value) {
+    return value.length > 0 && !/[\u0000-\u001f\u007f]/.test(value);
+}
+function isActive(status) {
+    return status === "created" || status === "running" || status === "steering" || status === "verifying";
+}
+function statusGlyph(status) {
+    if (status === "completed" || status === "merged") {
+        return "ok";
+    }
+    if (status === "failed" || status === "merge-conflict") {
+        return "!!";
+    }
+    if (status === "cancelled") {
+        return "--";
+    }
+    return "..";
+}
+function statusColor(status) {
+    if (status === "completed" || status === "merged") {
+        return "green";
+    }
+    if (status === "failed" || status === "merge-conflict") {
+        return "red";
+    }
+    if (status === "cancelled") {
+        return "yellow";
+    }
+    if (status === "verifying" || status === "steering") {
+        return "magenta";
+    }
+    return "cyan";
+}
+function toneColor(tone) {
+    if (tone === "success") {
+        return "green";
+    }
+    if (tone === "warning") {
+        return "yellow";
+    }
+    if (tone === "danger") {
+        return "red";
+    }
+    if (tone === "info") {
+        return "cyan";
+    }
+    return "gray";
+}
+function workGlyph(tone) {
+    if (tone === "success") {
+        return "ok";
+    }
+    if (tone === "warning") {
+        return "??";
+    }
+    if (tone === "danger") {
+        return "!!";
+    }
+    if (tone === "info") {
+        return "->";
+    }
+    return "--";
+}
+function completionPercent(run) {
+    if (run.status === "merged") {
+        return 100;
+    }
+    if (run.status === "completed") {
+        return 95;
+    }
+    if (run.status === "merge-conflict") {
+        return 85;
+    }
+    if (run.status === "failed" || run.status === "cancelled") {
+        return 50;
+    }
+    if (run.status === "steering") {
+        return 88;
+    }
+    if (run.status === "verifying") {
+        return 82;
+    }
+    const labels = new Set(run.work.map((item) => item.label));
+    let value = 8;
+    if (labels.has("worktree prepared") || labels.has("checkout claimed")) {
+        value = 18;
+    }
+    if (labels.has("planner contract")) {
+        value = 28;
+    }
+    if (labels.has("worker started")) {
+        value = 45;
+    }
+    if (run.output.trim()) {
+        value = Math.max(value, 60);
+    }
+    return value;
+}
+function progressBar(percent) {
+    const width = 6;
+    const filled = Math.max(0, Math.min(width, Math.round((percent / 100) * width)));
+    return `[${"#".repeat(filled)}${"-".repeat(width - filled)}]`;
+}
+function canMerge(run) {
+    return run.status === "completed" && run.worktree.enabled;
+}
+function runSummary(run) {
+    const latestWork = run.work.at(-1);
+    if (run.status === "steering") {
+        return "auto-steering after completion";
+    }
+    if (latestWork) {
+        return `${latestWork.label}${latestWork.detail ? `: ${latestWork.detail}` : ""}`;
+    }
+    const latestLine = tailLines(run.output, 1)[0];
+    if (latestLine && latestLine !== "No transcript yet.") {
+        return latestLine;
+    }
+    return run.status;
+}
+function deletePreviousWord(value) {
+    return value.replace(/\s+$/, "").replace(/\S+$/, "");
+}
+function missingCount(data) {
+    if (!isRecord(data) || !Array.isArray(data.missing)) {
+        return 0;
+    }
+    return data.missing.length;
+}
+function objectField(data, key) {
+    return isRecord(data) && typeof data[key] === "string" ? data[key] : undefined;
+}
+function isRecord(value) {
+    return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function tailLines(text, maxLines) {
+    const normalized = text.replace(/\r/g, "");
+    const lines = normalized.includes("\n") ? normalized.split("\n") : chunkLine(normalized, 96);
+    const visible = lines.filter((line, index) => line.length > 0 || index < lines.length - 1).slice(-Math.max(1, maxLines));
+    return visible.length ? visible : ["No transcript yet."];
+}
+function chunkLine(text, width) {
+    if (!text) {
+        return [];
+    }
+    const chunks = [];
+    for (let i = 0; i < text.length; i += width) {
+        chunks.push(text.slice(i, i + width));
+    }
+    return chunks;
+}
+function shortId(runId) {
+    return runId.slice(0, 14);
+}
+function truncate(value, width) {
+    if (value.length <= width) {
+        return value;
+    }
+    if (width <= 1) {
+        return value.slice(0, width);
+    }
+    return `${value.slice(0, Math.max(0, width - 3))}...`;
+}
+//# sourceMappingURL=tui.js.map