@mrace07/kairo 0.1.0

package/dist/interface/cli/tui.js

@@ -0,0 +1,910 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { execFileSync } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { basename, relative, resolve } from "node:path";
+import { Box, render, Text, useApp, useInput } from "ink";
+import TextInput from "ink-text-input";
+import parseDiff from "parse-diff";
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { ProviderError } from "../../domain/provider-error.js";
+import { autoInteractionMode, greetingResponse, interactionIntentState, } from "../../application/interaction-routing.js";
+import { setAutoModelRoutingEnabled, setJevEnabled, setJevFeature, setModelSelection, } from "../../infrastructure/configuration/config.js";
+import { JevDecisionProvider } from "../../infrastructure/providers/jev-safety-advisor.js";
+import { modelRoutingState, quotaFallbackModels, selectAutoModel, } from "../../application/model-routing.js";
+import { isProviderId, providerById, providerRegistry, } from "../../infrastructure/providers/provider-registry.js";
+import { formatMetrics, formatPlan, formatTrace } from "./task-trace.js";
+const colors = {
+    accent: "#7dd3fc",
+    accentSoft: "#a5b4fc",
+    muted: "#64748b",
+    textSoft: "#94a3b8",
+    success: "#4ade80",
+    warning: "#fbbf24",
+    danger: "#fb7185",
+    jev: "#c084fc",
+};
+export const slashCommands = [
+    { name: "/help", description: "Show commands and shortcuts" },
+    { name: "/plan", description: "Toggle read-only planning mode" },
+    { name: "/build", description: "Build the latest saved plan" },
+    { name: "/models", description: "Choose a model" },
+    { name: "/auto", description: "Toggle Jev automatic model routing" },
+    { name: "/jev", description: "Manage the Jev safety advisor" },
+    { name: "/new", description: "Start a new session" },
+    { name: "/resume", description: "Continue a task or open a session", acceptsArgument: true },
+    { name: "/history", description: "List saved sessions" },
+    { name: "/status", description: "Show the latest task status" },
+    { name: "/trace", description: "Show task trace", acceptsArgument: true },
+    { name: "/changes", description: "Show changed files" },
+    { name: "/verify", description: "Run a verification command", acceptsArgument: true },
+    { name: "/compact", description: "Save a context checkpoint" },
+    { name: "/cancel", description: "Cancel the current task" },
+    { name: "/logout", description: "Remove the active provider credential" },
+    { name: "/quit", description: "Exit Kairo" },
+];
+/** Reads only compact repository metadata for the header. */
+export function repositoryStatus(workspace) {
+    const git = process.platform === "darwin" ? "/usr/bin/git" : "git";
+    const run = (args) => execFileSync(git, args, {
+        cwd: workspace,
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"],
+        timeout: 2_000,
+    }).trim();
+    try {
+        const branch = run(["branch", "--show-current"]) || undefined;
+        const status = run(["status", "--short", "--untracked-files=normal"]);
+        return { branch, changedFiles: status ? status.split("\n").length : 0 };
+    }
+    catch {
+        return { changedFiles: 0 };
+    }
+}
+/** Returns an exit-code-tolerant Git command result; `git diff` uses exit code 1 for changes. */
+function gitOutput(workspace, args) {
+    const git = process.platform === "darwin" ? "/usr/bin/git" : "git";
+    try {
+        return execFileSync(git, args, {
+            cwd: workspace,
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "pipe"],
+            timeout: 2_000,
+        });
+    }
+    catch (error) {
+        const output = error.stdout;
+        return typeof output === "string" ? output : output?.toString();
+    }
+}
+function gitSucceeds(workspace, args) {
+    const git = process.platform === "darwin" ? "/usr/bin/git" : "git";
+    try {
+        execFileSync(git, args, {
+            cwd: workspace,
+            stdio: "ignore",
+            timeout: 2_000,
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Builds a reviewable working-tree patch for a file Kairo touched. This deliberately uses the
+ * current Git state rather than claiming to isolate just the agent's edits.
+ */
+export function changedFileReview(workspace, path) {
+    const absolute = resolve(workspace, path);
+    const workspaceRelative = relative(workspace, absolute);
+    if (workspaceRelative.startsWith("..") ||
+        workspaceRelative === "" ||
+        workspaceRelative.includes("../"))
+        return { path, diff: "", unavailable: "This path is outside the active workspace." };
+    const tracked = gitSucceeds(workspace, ["ls-files", "--error-unmatch", "--", path]);
+    if (tracked && gitSucceeds(workspace, ["rev-parse", "--verify", "HEAD"])) {
+        const diff = gitOutput(workspace, ["diff", "--no-ext-diff", "--unified=3", "HEAD", "--", path]);
+        if (diff !== undefined)
+            return { path, diff };
+    }
+    if (existsSync(absolute)) {
+        const diff = gitOutput(workspace, [
+            "diff",
+            "--no-index",
+            "--unified=3",
+            "--",
+            "/dev/null",
+            path,
+        ]);
+        if (diff)
+            return { path, diff };
+        try {
+            return {
+                path,
+                diff: readFileSync(absolute, "utf8"),
+                unavailable: "No Git diff is available; showing the current file instead.",
+            };
+        }
+        catch {
+            // Fall through to a short, actionable empty state.
+        }
+    }
+    return { path, diff: "", unavailable: "No current Git diff is available for this file." };
+}
+/** Finds palette entries while the user is typing a slash-command name. */
+export function matchingSlashCommands(input) {
+    if (!input.startsWith("/") || input.includes(" "))
+        return [];
+    return slashCommands.filter((command) => command.name.startsWith(input.toLowerCase()));
+}
+function commandInput(command) {
+    return `${command.name}${"acceptsArgument" in command && command.acceptsArgument ? " " : ""}`;
+}
+/** Flattens the supported provider registry into the options shown by `/models`. */
+export function modelOptions() {
+    return providerRegistry.flatMap((provider) => provider.models.map((model) => ({
+        provider: provider.id,
+        model: model.id,
+        label: `${provider.name} — ${model.label}${model.recommended ? " (recommended)" : ""}`,
+    })));
+}
+/** Bridges the agent's approval port to the active Ink application. */
+export class TuiApproval {
+    request;
+    constructor(request) {
+        this.request = request;
+    }
+    async approve(call, description) {
+        return new Promise((resolve) => this.request({ call, description, resolve }));
+    }
+}
+/** `/plan` is intentionally a live toggle, never a one-shot planning command. */
+export function interactionModeAfterCommand(mode, command) {
+    return command === "/plan" ? (mode === "build" ? "plan" : "build") : mode;
+}
+/** Reflects a completed Jev planning route in the persistent TUI interaction mode. */
+export function interactionModeAfterTask(mode, taskMode) {
+    return taskMode === "planning" ? "plan" : mode;
+}
+export function ModeBadge({ mode }) {
+    return (_jsx(Text, { bold: true, color: mode === "plan" ? "yellow" : "green", children: mode === "plan" ? "PLAN" : "BUILD" }));
+}
+function entryColor(entry) {
+    if (entry.kind === "user")
+        return "cyan";
+    if (entry.kind === "error")
+        return "red";
+    if (entry.kind === "system")
+        return "yellow";
+    return undefined;
+}
+function entryLabel(kind) {
+    return { user: "YOU", assistant: "KAIRO", system: "SYSTEM", error: "ERROR" }[kind];
+}
+/** A compact chat row that keeps requests, answers, and operational notices distinct. */
+export function TranscriptRow({ entry }) {
+    const color = entryColor(entry);
+    const isConversation = entry.kind === "user" || entry.kind === "assistant";
+    return (_jsxs(Box, { flexDirection: "column", marginTop: isConversation ? 1 : 0, children: [_jsx(Text, { bold: true, color: color, dimColor: entry.kind === "system", children: entryLabel(entry.kind) }), _jsx(Box, { paddingLeft: 1, children: entry.kind === "assistant" && !entry.text ? (_jsx(LoadingIndicator, { label: "Generating response" })) : (_jsx(Text, { color: color, wrap: "wrap", children: entry.text })) })] }));
+}
+function LoadingIndicator({ label, color = "yellow" }) {
+    const frames = ["◐", "◓", "◑", "◒"];
+    const [frame, setFrame] = useState(0);
+    useEffect(() => {
+        const timer = setInterval(() => setFrame((current) => (current + 1) % frames.length), 120);
+        timer.unref();
+        return () => clearInterval(timer);
+    }, []);
+    return (_jsxs(Text, { color: color, children: [frames[frame], " ", label, "\u2026"] }));
+}
+/** Converts a Git patch into the line-oriented model used by Kairo's terminal review view. */
+export function inlineDiff(review) {
+    const file = parseDiff(review.diff)[0];
+    if (!file)
+        return undefined;
+    return {
+        path: review.path,
+        additions: file.additions,
+        deletions: file.deletions,
+        hunks: file.chunks.map((chunk) => ({
+            header: chunk.content,
+            lines: chunk.changes.map((change) => {
+                if (change.type === "add")
+                    return { kind: "addition", newLine: change.ln, text: change.content.slice(1) };
+                if (change.type === "del")
+                    return { kind: "deletion", oldLine: change.ln, text: change.content.slice(1) };
+                return {
+                    kind: "context",
+                    oldLine: change.ln1,
+                    newLine: change.ln2,
+                    text: change.content.slice(1),
+                };
+            }),
+        })),
+    };
+}
+function lineNumberWidth(diff) {
+    const largest = Math.max(1, ...diff.hunks.flatMap((hunk) => hunk.lines.flatMap((line) => [line.oldLine ?? 0, line.newLine ?? 0])));
+    return String(largest).length;
+}
+function InlineDiffLineRow({ line, width, }) {
+    const isAddition = line.kind === "addition";
+    const isDeletion = line.kind === "deletion";
+    const marker = isAddition ? "+" : isDeletion ? "-" : " ";
+    const number = isDeletion ? line.oldLine : line.newLine;
+    const foreground = isAddition ? "#86efac" : isDeletion ? "#fca5a5" : undefined;
+    const background = isAddition ? "#14532d" : isDeletion ? "#450a0a" : undefined;
+    return (_jsxs(Box, { children: [_jsx(Text, { color: foreground, children: marker }), _jsxs(Text, { color: colors.muted, children: [" ", String(number ?? "").padStart(width), " "] }), _jsx(Text, { color: foreground, backgroundColor: background, wrap: "wrap", children: line.text || " " })] }));
+}
+function DiffPreview({ review }) {
+    const diff = inlineDiff(review);
+    return (_jsxs(Box, { flexDirection: "column", children: [review.unavailable ? _jsx(Text, { color: colors.warning, children: review.unavailable }) : null, diff ? (_jsxs(_Fragment, { children: [_jsxs(Text, { bold: true, color: colors.textSoft, children: ["Edited ", diff.path, " ", _jsxs(Text, { color: colors.success, children: ["(+", diff.additions] }), " ", _jsxs(Text, { color: colors.danger, children: ["-", diff.deletions, ")"] })] }), diff.hunks.map((hunk, hunkIndex) => (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: colors.muted, children: hunk.header }), hunk.lines.map((line, lineIndex) => (_jsx(InlineDiffLineRow, { line: line, width: lineNumberWidth(diff) }, `${hunkIndex}-${lineIndex}-${line.text}`)))] }, `${hunkIndex}-${hunk.header}`)))] })) : review.diff ? (_jsx(Text, { children: review.diff })) : null] }));
+}
+function ChangesPanel({ workspace, files, selected, }) {
+    const selectedPath = files[selected];
+    const review = selectedPath ? changedFileReview(workspace, selectedPath) : undefined;
+    return (_jsxs(Box, { borderStyle: "round", borderColor: colors.accent, flexDirection: "column", marginTop: 1, paddingX: 1, children: [_jsxs(Box, { justifyContent: "space-between", children: [_jsxs(Text, { bold: true, color: colors.accent, children: ["CHANGES \u00B7 ", files.length] }), _jsx(Text, { color: colors.muted, children: "working-tree diff" })] }), _jsx(Text, { color: colors.textSoft, children: "Files Kairo touched in this task. Git may include earlier local edits." }), _jsx(Box, { flexDirection: "column", marginTop: 1, children: files.map((file, index) => (_jsxs(Text, { color: index === selected ? colors.accent : colors.textSoft, bold: index === selected, children: [index === selected ? "›" : " ", " ", file] }, file))) }), review ? (_jsxs(Box, { borderStyle: "single", borderColor: colors.muted, flexDirection: "column", marginTop: 1, paddingX: 1, children: [_jsx(Text, { bold: true, children: review.path }), _jsx(DiffPreview, { review: review })] })) : null, _jsx(Text, { color: colors.muted, children: "\u2191/\u2193 select \u00B7 n/p next file \u00B7 Esc close" })] }));
+}
+export function BrandMark() {
+    return (_jsxs(Box, { flexDirection: "column", alignItems: "center", children: [_jsx(Text, { bold: true, color: colors.accent, children: "██╗  ██╗ █████╗ ██╗██████╗  ██████╗" }), _jsx(Text, { bold: true, color: colors.accent, children: "██║ ██╔╝██╔══██╗██║██╔══██╗██╔═══██╗" }), _jsx(Text, { bold: true, color: colors.accentSoft, children: "█████╔╝ ███████║██║██████╔╝██║   ██║" }), _jsx(Text, { bold: true, color: colors.accentSoft, children: "██╔═██╗ ██╔══██║██║██╔══██╗██║   ██║" }), _jsx(Text, { bold: true, color: colors.accentSoft, children: "██║  ██╗██║  ██║██║██║  ██║╚██████╔╝" }), _jsx(Text, { color: colors.muted, children: "╚═╝  ╚═╝╚═╝  ╚═╝╚═╝╚═╝  ╚═╝ ╚═════╝" })] }));
+}
+function EmptyState({ mode, workspace, repo, }) {
+    return (_jsxs(Box, { flexDirection: "column", alignItems: "center", marginTop: 2, marginBottom: 1, children: [_jsx(BrandMark, {}), _jsx(Box, { marginTop: 1, children: _jsx(Text, { bold: true, color: colors.textSoft, children: "dependable coding, right in your terminal" }) }), _jsxs(Box, { marginTop: 1, children: [_jsx(Text, { color: colors.muted, children: basename(workspace) }), repo.branch ? _jsxs(Text, { color: colors.muted, children: [" \u00B7 ", repo.branch] }) : null, repo.changedFiles ? (_jsxs(Text, { color: colors.warning, children: [" \u00B7 ", repo.changedFiles, " changed"] })) : null] }), _jsx(Box, { flexDirection: "column", marginTop: 2, children: [
+                    ["/plan", "inspect first, change nothing"],
+                    ["/models", "choose the coding model"],
+                    ["/resume", "continue previous work"],
+                    ["/help", "see every command"],
+                ].map(([command, description]) => (_jsxs(Box, { children: [_jsx(Text, { bold: true, color: colors.accent, children: command.padEnd(11) }), _jsx(Text, { color: colors.textSoft, children: description })] }, command))) }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: colors.muted, children: mode === "plan" ? "Read-only planning is active" : "Describe an outcome to begin" }) })] }));
+}
+function WorkspaceBar({ workspace, repo, model, }) {
+    return (_jsxs(Box, { borderStyle: "round", borderColor: colors.muted, paddingX: 1, justifyContent: "space-between", children: [_jsxs(Box, { children: [_jsx(Text, { bold: true, color: colors.accent, children: "KAIRO" }), _jsxs(Text, { color: colors.textSoft, children: [" \u00B7 ", basename(workspace)] }), repo.branch ? _jsxs(Text, { color: colors.muted, children: [" \u00B7 ", repo.branch] }) : null, repo.changedFiles ? (_jsxs(Text, { color: colors.warning, children: [" \u00B7 ", repo.changedFiles, " changed"] })) : null] }), _jsxs(Text, { color: colors.muted, children: [model.provider, "/", model.model] })] }));
+}
+function ApprovalCard({ pending }) {
+    const [summary, ...details] = pending.description.split("\n");
+    const command = summary.startsWith("Run command");
+    const scopedWrite = (pending.call.name === "write_file" || pending.call.name === "edit_file") &&
+        typeof pending.call.args.path === "string" &&
+        Boolean(pending.call.args.path.trim());
+    return (_jsxs(Box, { borderStyle: "round", borderColor: colors.warning, flexDirection: "column", marginTop: 1, paddingX: 1, children: [_jsxs(Box, { justifyContent: "space-between", children: [_jsx(Text, { bold: true, color: colors.warning, children: "REVIEW ACTION" }), _jsx(Text, { bold: true, color: colors.danger, children: command ? "COMMAND" : "WRITE" })] }), _jsx(Text, { color: colors.textSoft, children: summary }), details.length ? _jsx(Text, { children: details.join("\n") }) : null, _jsx(Box, { marginTop: 1, children: scopedWrite ? (_jsxs(_Fragment, { children: [_jsx(Text, { bold: true, color: colors.success, children: "y / Enter allow this file for task" }), _jsx(Text, { color: colors.muted, children: " \u00B7 " }), _jsx(Text, { color: colors.textSoft, children: "o allow once" }), _jsx(Text, { color: colors.muted, children: " \u00B7 " }), _jsx(Text, { bold: true, color: colors.danger, children: "n / Esc deny" })] })) : (_jsxs(_Fragment, { children: [_jsx(Text, { bold: true, color: colors.success, children: "y / Enter allow" }), _jsx(Text, { color: colors.muted, children: " \u00B7 " }), _jsx(Text, { bold: true, color: colors.danger, children: "n / Esc deny" })] })) })] }));
+}
+/** Renders one bounded Kairo session and dispatches terminal commands without readline. */
+export function KairoTui(props) {
+    const { exit } = useApp();
+    const [active, setActive] = useState(props.session);
+    const [repo, setRepo] = useState(() => repositoryStatus(props.session.workspace));
+    const [selection, setSelection] = useState(props.initialSelection);
+    const [apiKey, setApiKey] = useState(props.initialApiKey);
+    const [jevKey, setJevKey] = useState(props.initialJevKey);
+    const [jevEnabled, setJevEnabledState] = useState(props.initialJevEnabled);
+    const [jevFeatures, setJevFeatures] = useState(props.initialJevFeatures);
+    const [autoModelRouting, setAutoModelRouting] = useState(props.initialAutoModelRoutingEnabled);
+    const [routedSelection, setRoutedSelection] = useState();
+    const [mode, setMode] = useState("build");
+    const [input, setInput] = useState("");
+    const [entries, setEntries] = useState([]);
+    const [busy, setBusy] = useState("idle");
+    const [changesTask, setChangesTask] = useState();
+    const [changesIndex, setChangesIndex] = useState(0);
+    const [pendingApproval, setPendingApproval] = useState();
+    const [modelPicker, setModelPicker] = useState(false);
+    const [modelIndex, setModelIndex] = useState(0);
+    const [credentialModel, setCredentialModel] = useState();
+    const [credentialInput, setCredentialInput] = useState("");
+    const [credentialError, setCredentialError] = useState();
+    const [savingCredential, setSavingCredential] = useState(false);
+    const [jevPanel, setJevPanel] = useState(false);
+    const [jevIndex, setJevIndex] = useState(0);
+    const [jevCredentialInput, setJevCredentialInput] = useState("");
+    const [jevCredentialError, setJevCredentialError] = useState();
+    const [jevCredentialMode, setJevCredentialMode] = useState(false);
+    const [savingJevCredential, setSavingJevCredential] = useState(false);
+    const [commandIndex, setCommandIndex] = useState(0);
+    const models = useMemo(modelOptions, []);
+    const commandMatches = useMemo(() => matchingSlashCommands(input), [input]);
+    const approval = useMemo(() => new TuiApproval((pending) => {
+        setBusy("acting");
+        setPendingApproval(pending);
+    }), []);
+    const agent = useMemo(() => apiKey
+        ? props.createAgent(approval, selection, apiKey, jevEnabled && jevKey ? new JevDecisionProvider(jevKey) : undefined, jevFeatures)
+        : undefined, [apiKey, approval, jevEnabled, jevFeatures, jevKey, props.createAgent, selection]);
+    const resolveTaskAgent = useCallback(async (request) => {
+        if (!autoModelRouting || !jevEnabled || !jevKey || !agent) {
+            setRoutedSelection(undefined);
+            return agent && { agent, selection, fallbacks: [] };
+        }
+        const providerKeys = new Map(await Promise.all(providerRegistry.map(async (provider) => [provider.id, await props.credentials.get(provider.id)])));
+        const available = models.flatMap((model) => {
+            const apiKey = providerKeys.get(model.provider);
+            const tier = providerById(model.provider).models.find((item) => item.id === model.model)?.tier;
+            return apiKey && tier ? [{ ...model, apiKey, tier }] : [];
+        });
+        if (!available.length) {
+            setRoutedSelection(undefined);
+            return { agent, selection, fallbacks: [] };
+        }
+        try {
+            const decision = await new JevDecisionProvider(jevKey).modelTier(modelRoutingState(request, available));
+            if (decision.confidence < 0.85) {
+                setRoutedSelection(undefined);
+                return { agent, selection, fallbacks: [] };
+            }
+            const routed = selectAutoModel(available, selection, decision.value);
+            if (!routed) {
+                setRoutedSelection(undefined);
+                return { agent, selection, fallbacks: [] };
+            }
+            setRoutedSelection({ provider: routed.provider, model: routed.model });
+            const routedSelection = { provider: routed.provider, model: routed.model };
+            return {
+                agent: props.createAgent(approval, routedSelection, routed.apiKey, new JevDecisionProvider(jevKey), jevFeatures),
+                selection: routedSelection,
+                fallbacks: quotaFallbackModels(available, routedSelection, selection, decision.value),
+            };
+        }
+        catch {
+            setRoutedSelection(undefined);
+            return { agent, selection, fallbacks: [] };
+        }
+    }, [agent, approval, autoModelRouting, jevEnabled, jevFeatures, jevKey, models, props, selection]);
+    const classifyInteraction = useCallback(async (request) => {
+        const localResponse = greetingResponse(request);
+        if (localResponse)
+            return { intent: "conversation", localResponse };
+        if (!jevEnabled || !jevKey || !jevFeatures.routing)
+            return { intent: "repository_task" };
+        try {
+            const decision = await new JevDecisionProvider(jevKey).intent(interactionIntentState(request));
+            return decision.confidence >= 0.85
+                ? { intent: decision.value }
+                : { intent: "repository_task" };
+        }
+        catch {
+            return { intent: "repository_task" };
+        }
+    }, [jevEnabled, jevFeatures.routing, jevKey]);
+    const append = useCallback((kind, text) => {
+        setEntries((current) => [...current, { id: current.length, kind, text }]);
+    }, []);
+    const appendStream = useCallback((entryId, chunk) => {
+        setEntries((current) => current.map((entry) => entry.id === entryId ? { ...entry, text: entry.text + chunk } : entry));
+    }, []);
+    const answerApproval = useCallback((decision) => {
+        if (!pendingApproval)
+            return;
+        setPendingApproval(undefined);
+        append("system", decision === "task_file"
+            ? `Approved writes to ${String(pendingApproval.call.args.path)} for this task.`
+            : decision
+                ? "Approved action."
+                : "Denied action.");
+        pendingApproval.resolve(decision);
+    }, [append, pendingApproval]);
+    useInput((inputKey, key) => {
+        if (!pendingApproval)
+            return;
+        const scopedWrite = (pendingApproval.call.name === "write_file" || pendingApproval.call.name === "edit_file") &&
+            typeof pendingApproval.call.args.path === "string" &&
+            Boolean(pendingApproval.call.args.path.trim());
+        if (inputKey.toLowerCase() === "y" || key.return)
+            answerApproval(scopedWrite ? "task_file" : true);
+        if (inputKey.toLowerCase() === "o" && scopedWrite)
+            answerApproval(true);
+        if (inputKey.toLowerCase() === "n" || key.escape)
+            answerApproval(false);
+    });
+    useInput((inputKey, key) => {
+        if (!changesTask)
+            return;
+        if (key.escape)
+            return setChangesTask(undefined);
+        const fileCount = changesTask.changedFiles.length;
+        if (key.upArrow || inputKey.toLowerCase() === "p")
+            return setChangesIndex((current) => Math.max(0, current - 1));
+        if (key.downArrow || inputKey.toLowerCase() === "n")
+            return setChangesIndex((current) => Math.min(fileCount - 1, current + 1));
+    });
+    const saveJevCredential = useCallback(async (value) => {
+        if (savingJevCredential)
+            return;
+        const key = value.trim();
+        if (!key)
+            return setJevCredentialError("API key cannot be empty.");
+        setSavingJevCredential(true);
+        setJevCredentialError(undefined);
+        try {
+            await new JevDecisionProvider(key).validate();
+            await props.credentials.save("jev", key);
+            await setJevEnabled(true);
+            setJevKey(key);
+            setJevEnabledState(true);
+            setJevCredentialInput("");
+            setJevCredentialMode(false);
+            setJevPanel(false);
+            append("system", "Jev safety advisor enabled.");
+        }
+        catch (error) {
+            setJevCredentialError(error.message);
+        }
+        finally {
+            setSavingJevCredential(false);
+        }
+    }, [append, props.credentials, savingJevCredential]);
+    useInput((inputKey, key) => {
+        if (!jevPanel || savingJevCredential)
+            return;
+        if (jevCredentialMode) {
+            if (key.escape) {
+                setJevCredentialInput("");
+                setJevCredentialError(undefined);
+                setJevCredentialMode(false);
+            }
+            return;
+        }
+        if (key.escape)
+            return setJevPanel(false);
+        if (key.upArrow)
+            return setJevIndex((current) => Math.max(0, current - 1));
+        if (key.downArrow)
+            return setJevIndex((current) => Math.min(6, current + 1));
+        if (key.return || /^[1-7]$/.test(inputKey)) {
+            const action = /^[1-7]$/.test(inputKey) ? Number(inputKey) - 1 : jevIndex;
+            if (action === 0) {
+                if (!jevKey) {
+                    setJevCredentialError("Add a TypeSafe API key before enabling Jev.");
+                    setJevCredentialMode(true);
+                    return;
+                }
+                const next = !jevEnabled;
+                void setJevEnabled(next).then(() => {
+                    setJevEnabledState(next);
+                    append("system", `Jev safety advisor ${next ? "enabled" : "disabled"}.`);
+                });
+                return setJevPanel(false);
+            }
+            if (action === 1) {
+                const next = !jevFeatures.routing;
+                void setJevFeature("routing", next).then(() => setJevFeatures((current) => ({ ...current, routing: next })));
+                return;
+            }
+            if (action === 2) {
+                const next = !jevFeatures.safety;
+                void setJevFeature("safety", next).then(() => setJevFeatures((current) => ({ ...current, safety: next })));
+                return;
+            }
+            if (action === 3) {
+                const next = !jevFeatures.recovery;
+                void setJevFeature("recovery", next).then(() => setJevFeatures((current) => ({ ...current, recovery: next })));
+                return;
+            }
+            if (action === 4) {
+                const next = !jevFeatures.autonomy;
+                void setJevFeature("autonomy", next).then(() => setJevFeatures((current) => ({ ...current, autonomy: next })));
+                return;
+            }
+            if (action === 5) {
+                setJevCredentialInput("");
+                setJevCredentialError(undefined);
+                setJevCredentialMode(true);
+                return;
+            }
+            if (action === 6) {
+                void props.credentials.clear("jev").then(async () => {
+                    await setJevEnabled(false);
+                    setJevKey(undefined);
+                    setJevEnabledState(false);
+                    setJevPanel(false);
+                    append("system", "Jev credential removed.");
+                });
+            }
+        }
+    });
+    const chooseModel = useCallback(async (next) => {
+        const nextKey = await props.credentials.get(next.provider);
+        if (!nextKey) {
+            setCredentialInput("");
+            setCredentialError(undefined);
+            setCredentialModel(next);
+            return;
+        }
+        await setModelSelection(next);
+        await setAutoModelRoutingEnabled(false);
+        setSelection(next);
+        setApiKey(nextKey);
+        setAutoModelRouting(false);
+        setRoutedSelection(undefined);
+        append("system", `Using ${next.provider}/${next.model}.`);
+    }, [append, props.credentials]);
+    const saveCredential = useCallback(async (value) => {
+        if (!credentialModel || savingCredential)
+            return;
+        const key = value.trim();
+        if (!key)
+            return setCredentialError("API key cannot be empty.");
+        setSavingCredential(true);
+        setCredentialError(undefined);
+        try {
+            await providerById(credentialModel.provider).validate(key);
+            await props.credentials.save(credentialModel.provider, key);
+            await setModelSelection(credentialModel);
+            await setAutoModelRoutingEnabled(false);
+            setSelection(credentialModel);
+            setApiKey(key);
+            setAutoModelRouting(false);
+            setRoutedSelection(undefined);
+            setCredentialInput("");
+            setCredentialModel(undefined);
+            append("system", `Using ${credentialModel.provider}/${credentialModel.model}.`);
+        }
+        catch (error) {
+            setCredentialError(error.message);
+        }
+        finally {
+            setSavingCredential(false);
+        }
+    }, [append, credentialModel, props.credentials, savingCredential]);
+    useInput((inputKey, key) => {
+        if (!credentialModel || savingCredential)
+            return;
+        if (key.escape) {
+            setCredentialInput("");
+            setCredentialError(undefined);
+            setCredentialModel(undefined);
+        }
+    });
+    useInput((inputKey, key) => {
+        if (!modelPicker)
+            return;
+        if (key.escape)
+            return setModelPicker(false);
+        if (key.upArrow)
+            return setModelIndex((current) => Math.max(0, current - 1));
+        if (key.downArrow)
+            return setModelIndex((current) => Math.min(models.length - 1, current + 1));
+        if (key.return) {
+            const next = models[modelIndex];
+            setModelPicker(false);
+            if (next)
+                void chooseModel(next);
+        }
+        if (/^[1-9]$/.test(inputKey)) {
+            const next = models[Number(inputKey) - 1];
+            if (next) {
+                setModelPicker(false);
+                void chooseModel(next);
+            }
+        }
+    });
+    const runTask = useCallback(async (request, requestedMode) => {
+        // Render optimistically before routing can make a network request through Jev.
+        append("user", request);
+        setBusy(requestedMode === "plan" ? "planning" : "acting");
+        const interaction = requestedMode === "build" || autoModelRouting
+            ? await classifyInteraction(request)
+            : undefined;
+        const taskMode = autoModelRouting && interaction ? autoInteractionMode(interaction.intent) : requestedMode;
+        if (autoModelRouting && taskMode !== mode)
+            setMode(taskMode);
+        setBusy(taskMode === "plan" ? "planning" : "acting");
+        if (interaction?.intent === "conversation") {
+            setBusy("idle");
+            return append("assistant", interaction.localResponse ?? "How can I help?");
+        }
+        if (!agent) {
+            setBusy("idle");
+            return append("error", "No active credential. Use /models to add a provider API key.");
+        }
+        const entryId = entries.length + 1;
+        setEntries((current) => [...current, { id: entryId, kind: "assistant", text: "" }]);
+        const onAgentText = (chunk) => {
+            if (chunk === "\n[Jev routed this request to a one-time read-only plan]\n") {
+                setMode("plan");
+                return;
+            }
+            if (/^\n\[Tool] [^\n]+\n$/.test(chunk) ||
+                chunk === "\n[Plan saved]\n" ||
+                chunk === "\n[Verification passed]\n" ||
+                chunk === "\n[Verification failed]\n")
+                return;
+            appendStream(entryId, chunk);
+        };
+        try {
+            const route = taskMode === "build" && interaction?.intent === "repository_task"
+                ? await resolveTaskAgent(request)
+                : agent && { agent, selection, fallbacks: [] };
+            if (!route)
+                throw new Error("No credential is available for the selected model.");
+            let taskAgent = route.agent;
+            if (taskMode === "plan")
+                await taskAgent.plan(active.id, request, onAgentText);
+            else if (interaction?.intent === "answer")
+                await taskAgent.answer(active.id, request, onAgentText);
+            else {
+                try {
+                    await taskAgent.run(active.id, request, onAgentText);
+                }
+                catch (error) {
+                    if (!(error instanceof ProviderError) || error.category !== "quota")
+                        throw error;
+                    let latestError = error;
+                    for (const fallback of route.fallbacks) {
+                        append("system", `Automatic fallback: ${route.selection.provider}/${route.selection.model} reached its quota; switching to ${fallback.provider}/${fallback.model}.`);
+                        taskAgent = props.createAgent(approval, { provider: fallback.provider, model: fallback.model }, fallback.apiKey, new JevDecisionProvider(jevKey), jevFeatures);
+                        try {
+                            await taskAgent.retryAfterProviderQuota(active.id, onAgentText);
+                            latestError = undefined;
+                            break;
+                        }
+                        catch (fallbackError) {
+                            latestError = fallbackError;
+                            if (!(fallbackError instanceof ProviderError) || fallbackError.category !== "quota")
+                                throw fallbackError;
+                        }
+                    }
+                    if (latestError)
+                        throw latestError;
+                }
+            }
+            const task = taskAgent.status(active.id);
+            setMode((current) => interactionModeAfterTask(current, task?.mode));
+            if (task?.changedFiles.length) {
+                setChangesIndex(0);
+                setChangesTask(task);
+            }
+            if (task?.mode === "planning" && task.plan)
+                append("system", formatPlan(task.plan));
+            if (task?.status === "cancelled")
+                append("system", "Task cancelled.");
+            setRepo(repositoryStatus(active.workspace));
+            setBusy("idle");
+        }
+        catch (error) {
+            setRepo(repositoryStatus(active.workspace));
+            setBusy("idle");
+            // CodingAgent already rendered and persisted a terminal task failure. Avoid echoing it.
+            if (agent.status(active.id)?.status !== "failed")
+                append("error", `Kairo: ${error.message}`);
+        }
+    }, [
+        active.id,
+        active.workspace,
+        agent,
+        append,
+        appendStream,
+        approval,
+        autoModelRouting,
+        classifyInteraction,
+        entries.length,
+        jevFeatures,
+        jevKey,
+        props,
+        resolveTaskAgent,
+        selection,
+        mode,
+    ]);
+    const submit = useCallback(async (value) => {
+        let line = value.trim();
+        if (!line || busy !== "idle" || pendingApproval)
+            return;
+        const selectedCommand = commandMatches[commandIndex];
+        if (selectedCommand && line !== selectedCommand.name) {
+            if ("acceptsArgument" in selectedCommand && selectedCommand.acceptsArgument) {
+                setInput(commandInput(selectedCommand));
+                return;
+            }
+            line = selectedCommand.name;
+        }
+        setInput("");
+        if (line === "/help") {
+            return append("system", slashCommands
+                .map((command) => `${command.name.padEnd(10)} ${command.description}`)
+                .join("\n"));
+        }
+        if (line === "/plan") {
+            const next = interactionModeAfterCommand(mode, line);
+            setMode(next);
+            return;
+        }
+        if (line === "/build") {
+            setMode("build");
+            const latest = agent?.status(active.id);
+            if (latest?.status === "planned" && latest.plan) {
+                append("system", "Building the saved plan.");
+                await runTask("Implement the saved plan and verify the result.", "build");
+            }
+            return;
+        }
+        if (line === "/quit" || line === "/exit")
+            return exit();
+        if (line === "/new") {
+            const next = props.store.create(active.workspace);
+            setActive(next);
+            setMode("build");
+            setEntries([]);
+            setChangesTask(undefined);
+            setRepo(repositoryStatus(next.workspace));
+            return append("system", `New session: ${next.id} — BUILD mode.`);
+        }
+        if (line === "/history") {
+            return append("system", props.store
+                .list()
+                .map((item) => `${item.id}  ${item.workspace}`)
+                .join("\n") || "No sessions.");
+        }
+        if (line === "/status" || line === "/changes") {
+            const task = agent?.status(active.id);
+            if (line === "/changes" && task?.changedFiles.length) {
+                setChangesIndex(0);
+                return setChangesTask(task);
+            }
+            return append("system", !task
+                ? "No task has run in this session."
+                : line === "/changes"
+                    ? task.changedFiles.join("\n") || "No files changed."
+                    : `${task.status} (${task.mode}): ${task.prompt}\n${formatMetrics(props.store.taskEvents(task.id))}`);
+        }
+        if (line === "/trace" || line.startsWith("/trace ")) {
+            const task = line === "/trace" ? agent?.status(active.id) : props.store.task(line.slice(7).trim());
+            return append("system", task && task.sessionId === active.id
+                ? formatTrace(task, props.store.taskEvents(task.id))
+                : "Task not found in this session.");
+        }
+        if (line === "/compact")
+            return append("system", agent?.compact(active.id) ? "Context checkpoint saved." : "No task to compact.");
+        if (line === "/cancel") {
+            agent?.cancel(active.id);
+            setBusy("acting");
+            return append("system", "Task cancelled.");
+        }
+        if (line === "/resume" || line.startsWith("/resume ")) {
+            const sessionId = line.slice(7).trim();
+            if (sessionId) {
+                const next = props.store.get(sessionId);
+                if (!next)
+                    return append("error", "Session not found.");
+                setActive(next);
+                setMode("build");
+                setRepo(repositoryStatus(next.workspace));
+                return append("system", `Resumed ${next.id} — BUILD mode.`);
+            }
+            if (!agent)
+                return append("error", "No active credential.");
+            setMode("build");
+            setBusy("acting");
+            try {
+                await agent.resume(active.id, (chunk) => append("assistant", chunk));
+                setBusy("idle");
+            }
+            catch (error) {
+                setBusy("idle");
+                append("error", `Kairo: ${error.message}`);
+            }
+            return;
+        }
+        if (line.startsWith("/verify ")) {
+            if (!agent)
+                return append("error", "No active credential.");
+            setBusy("verifying");
+            try {
+                await agent.verify(active.id, line.slice(8).trim(), (chunk) => append("assistant", chunk));
+                setRepo(repositoryStatus(active.workspace));
+                setBusy("idle");
+            }
+            catch (error) {
+                setBusy("idle");
+                append("error", `Kairo: ${error.message}`);
+            }
+            return;
+        }
+        if (line === "/auto") {
+            if (!autoModelRouting && (!jevEnabled || !jevKey))
+                return append("error", "Enable Jev and add its API key with /jev before enabling auto routing.");
+            const next = !autoModelRouting;
+            await setAutoModelRoutingEnabled(next);
+            setAutoModelRouting(next);
+            setRoutedSelection(undefined);
+            return append("system", next
+                ? "Automatic Jev model routing enabled. Your selected model remains the fallback."
+                : `Manual model selection enabled: ${selection.provider}/${selection.model}.`);
+        }
+        if (line === "/models") {
+            const selected = models.findIndex((item) => item.provider === selection.provider && item.model === selection.model);
+            setModelIndex(Math.max(0, selected));
+            setModelPicker(true);
+            return;
+        }
+        if (line === "/jev") {
+            setJevCredentialInput("");
+            setJevCredentialError(undefined);
+            setJevCredentialMode(false);
+            setJevIndex(0);
+            setJevPanel(true);
+            return;
+        }
+        if (line === "/model" || line.startsWith("/model ")) {
+            const [provider, ...modelParts] = line.slice(6).trim().split(/\s+/);
+            if (!provider || !modelParts.length || !isProviderId(provider))
+                return append("system", `Current model: ${selection.provider}/${selection.model}\nUse: /model <gemini|groq|mistral> <model-id>`);
+            const next = { provider, model: modelParts.join(" ") };
+            await chooseModel(next);
+            return;
+        }
+        if (line === "/logout") {
+            await props.credentials.clear(selection.provider);
+            setApiKey(undefined);
+            return append("system", `${selection.provider} credential removed. Use /model with another logged-in provider.`);
+        }
+        await runTask(line, mode);
+    }, [
+        active,
+        agent,
+        append,
+        busy,
+        exit,
+        mode,
+        autoModelRouting,
+        jevEnabled,
+        jevKey,
+        pendingApproval,
+        props.credentials,
+        props.store,
+        runTask,
+        selection,
+        models,
+        chooseModel,
+        commandIndex,
+        commandMatches,
+    ]);
+    useInput((inputKey, key) => {
+        if (changesTask || pendingApproval || modelPicker || jevPanel || !commandMatches.length)
+            return;
+        if (key.upArrow)
+            return setCommandIndex((current) => Math.max(0, current - 1));
+        if (key.downArrow)
+            return setCommandIndex((current) => Math.min(commandMatches.length - 1, current + 1));
+        if (key.tab) {
+            const selected = commandMatches[commandIndex];
+            if (!selected)
+                return;
+            if ("acceptsArgument" in selected && selected.acceptsArgument) {
+                setInput(commandInput(selected));
+            }
+            else {
+                void submit(selected.name);
+            }
+        }
+    });
+    const visibleEntries = entries.slice(-8);
+    const hiddenEntries = entries.length - visibleEntries.length;
+    const terminalHeight = process.stdout.rows ? Math.max(20, process.stdout.rows - 1) : undefined;
+    const activeModel = routedSelection ?? selection;
+    return (_jsxs(Box, { flexDirection: "column", minHeight: terminalHeight, children: [entries.length ? (_jsx(WorkspaceBar, { workspace: active.workspace, repo: repo, model: activeModel })) : null, _jsx(Box, { flexDirection: "column", flexGrow: 1, children: entries.length ? (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [hiddenEntries > 0 ? (_jsxs(Text, { color: colors.muted, children: [" \u2026 ", hiddenEntries, " earlier messages hidden"] })) : null, visibleEntries.map((entry) => (_jsx(TranscriptRow, { entry: entry }, entry.id)))] })) : (_jsx(EmptyState, { mode: mode, workspace: active.workspace, repo: repo })) }), changesTask ? (_jsx(ChangesPanel, { workspace: active.workspace, files: changesTask.changedFiles, selected: changesIndex })) : pendingApproval ? (_jsx(ApprovalCard, { pending: pendingApproval })) : credentialModel ? (_jsxs(Box, { borderStyle: "single", borderColor: "cyan", flexDirection: "column", paddingX: 1, children: [_jsxs(Text, { bold: true, children: [providerById(credentialModel.provider).name, " API key"] }), _jsx(Text, { color: "gray", children: "Saved securely in macOS Keychain." }), _jsx(TextInput, { value: credentialInput, onChange: (value) => {
+                            setCredentialInput(value);
+                            setCredentialError(undefined);
+                        }, onSubmit: saveCredential, mask: "\u2022", placeholder: savingCredential ? "Validating…" : "Paste API key", focus: !savingCredential }), credentialError ? _jsx(Text, { color: "red", children: credentialError }) : null, _jsx(Text, { color: "gray", children: "Enter save \u00B7 Esc cancel" })] })) : jevPanel ? (_jsxs(Box, { borderStyle: "single", borderColor: "magenta", flexDirection: "column", paddingX: 1, children: [_jsxs(Text, { bold: true, children: ["Jev safety advisor \u00B7 ", jevEnabled ? "enabled" : "disabled"] }), _jsx(Text, { color: "gray", children: jevKey ? "TypeSafe key saved in macOS Keychain." : "No TypeSafe API key saved." }), jevCredentialMode ? (_jsxs(_Fragment, { children: [_jsx(TextInput, { value: jevCredentialInput, onChange: (value) => {
+                                    setJevCredentialInput(value);
+                                    setJevCredentialError(undefined);
+                                }, onSubmit: saveJevCredential, mask: "\u2022", placeholder: savingJevCredential ? "Validating…" : "Paste TypeSafe API key", focus: !savingJevCredential }), jevCredentialError ? _jsx(Text, { color: "red", children: jevCredentialError }) : null, _jsx(Text, { color: "gray", children: "Enter save \u00B7 Esc cancel" })] })) : (_jsxs(_Fragment, { children: [[
+                                `${jevEnabled ? "Disable" : "Enable"} advisor`,
+                                `Task routing: ${jevFeatures.routing ? "on" : "off"}`,
+                                `Safety context: ${jevFeatures.safety ? "on" : "off"}`,
+                                `Recovery advice: ${jevFeatures.recovery ? "on" : "off"}`,
+                                `Safe autonomy: ${jevFeatures.autonomy ? "on" : "off"}`,
+                                "Add or replace API key",
+                                "Remove API key",
+                            ].map((label, index) => (_jsxs(Text, { color: index === jevIndex ? "magenta" : undefined, children: [index === jevIndex ? "›" : " ", " ", index + 1, ". ", label] }, label))), _jsx(Text, { color: "gray", children: "\u2191/\u2193 choose \u00B7 Enter select \u00B7 Esc close" })] }))] })) : modelPicker ? (_jsxs(Box, { borderStyle: "single", borderColor: "cyan", flexDirection: "column", paddingX: 1, children: [_jsx(Text, { bold: true, children: "Select a model" }), models.map((item, index) => (_jsxs(Text, { color: index === modelIndex ? "cyan" : undefined, children: [index === modelIndex ? "›" : " ", " ", index + 1, ". ", item.label, " \u2014 ", item.model] }, `${item.provider}/${item.model}`))), _jsx(Text, { color: "gray", children: "\u2191/\u2193 choose \u00B7 Enter select \u00B7 Esc cancel" })] })) : (_jsxs(Box, { flexDirection: "column", children: [commandMatches.length ? (_jsxs(Box, { borderStyle: "round", borderColor: colors.accent, flexDirection: "column", marginTop: 1, paddingX: 1, children: [_jsx(Text, { bold: true, color: colors.accent, children: "COMMANDS" }), commandMatches.map((command, index) => (_jsxs(Text, { color: index === commandIndex ? colors.accent : colors.textSoft, bold: index === commandIndex, children: [index === commandIndex ? "›" : " ", " ", command.name.padEnd(10), " ", command.description] }, command.name))), _jsx(Text, { color: colors.muted, children: "\u2191/\u2193 navigate \u00B7 Tab complete \u00B7 Enter run" })] })) : null, _jsxs(Box, { borderStyle: "round", borderColor: mode === "plan" ? colors.warning : colors.accentSoft, marginTop: 1, paddingX: 1, minHeight: 3, alignItems: "center", children: [_jsx(Text, { color: colors.accent, bold: true, children: ">" }), _jsx(Text, { children: " " }), _jsx(TextInput, { value: input, onChange: (value) => {
+                                    setInput(value);
+                                    setCommandIndex(0);
+                                }, onSubmit: submit, placeholder: busy === "idle"
+                                    ? mode === "plan"
+                                        ? "Ask Kairo to inspect and plan…"
+                                        : "Ask Kairo to implement…"
+                                    : "Task in progress…", focus: busy === "idle" && !changesTask })] }), _jsxs(Box, { paddingX: 1, justifyContent: "space-between", children: [_jsx(Box, { children: _jsx(Text, { color: colors.muted, children: "enter send \u00B7 / commands" }) }), _jsxs(Text, { color: colors.textSoft, children: [activeModel.provider, "/", activeModel.model] })] }), _jsxs(Box, { paddingX: 1, justifyContent: "space-between", children: [_jsxs(Box, { children: [_jsx(ModeBadge, { mode: mode }), _jsxs(Text, { color: colors.muted, children: [" ", "\u00B7 ", autoModelRouting ? "Auto routing" : "Manual model"] })] }), autoModelRouting || jevEnabled ? (_jsxs(Box, { children: [autoModelRouting ? _jsx(Text, { color: colors.accent, children: "AUTO" }) : null, autoModelRouting && jevEnabled ? _jsx(Text, { color: colors.muted, children: " \u00B7 " }) : null, jevEnabled ? _jsx(Text, { color: colors.jev, children: "JEV" }) : null] })) : null] })] }))] }));
+}
+/** Starts the Ink renderer and keeps the existing CLI composition boundary intact. */
+export async function runTui(props) {
+    const key = await props.credentials.get(props.initialSelection.provider);
+    const jevKey = await props.credentials.get("jev");
+    const app = render(_jsx(KairoTui, { ...props, initialApiKey: key, initialJevKey: jevKey }));
+    await app.waitUntilExit();
+}