@mrace07/kairo 0.1.0

package/dist/interface/cli/index.js

@@ -0,0 +1,238 @@
+#!/usr/bin/env node
+import { resolve } from "node:path";
+import { realpath } from "node:fs/promises";
+import { stdin, stdout } from "node:process";
+import { createInterface } from "node:readline/promises";
+import { defaultConfig, loadConfig, setConfig, } from "../../infrastructure/configuration/config.js";
+import { MacOSKeychainStore } from "../../infrastructure/security/macos-keychain-store.js";
+import { createProvider, isProviderId, providerById, providerRegistry, } from "../../infrastructure/providers/provider-registry.js";
+import { SqliteSessionStore } from "../../infrastructure/persistence/sqlite-session-store.js";
+import { WorkspaceTools, definitions } from "../../infrastructure/tools/workspace-tools.js";
+import { RepositoryAwareness } from "../../infrastructure/repository/repository-awareness.js";
+import { CodingAgent } from "../../application/coding-agent.js";
+import { runRepl } from "./repl.js";
+import { runEvaluationSuite, runJevEvaluationSuite } from "../../application/evaluation-harness.js";
+import { runLiveEvaluationSuite } from "../../application/live-evaluation.js";
+import { runSelfEvaluationSuite } from "../../application/self-evaluation.js";
+import { formatEvaluationReport, formatJevEvaluationReport, formatEvaluationHistory, formatEvaluationRun, formatLiveEvaluationReport, formatSelfEvaluationReport, } from "./evaluation-report.js";
+import { compareWithBaseline } from "../../application/evaluation-comparison.js";
+import { formatBaseline, formatComparison } from "./evaluation-comparison-report.js";
+import { terminalSetupIO } from "./provider-setup.js";
+/** Prints the supported command-line shapes when arguments are invalid. */
+function usage() {
+    console.log("Usage: kairo [workspace] | kairo eval [--json] | kairo eval jev [--json] | kairo eval live [--json] | kairo eval self [--trials <1-5>] [--json] | kairo eval history [--json] | kairo eval show <run-id> [--json] | kairo eval baseline set <run-id> [--json] | kairo eval baseline show [--json] | kairo eval compare <run-id> [--json] | kairo auth login|logout [gemini|groq|mistral] | kairo auth status | kairo config get provider|model | kairo config set model <value> | kairo sessions list | kairo resume <id>");
+}
+/** Collects a masked secret using the same terminal behavior as first-run setup. */
+async function promptSecret(question) {
+    const rl = createInterface({ input: stdin, output: stdout });
+    try {
+        return await terminalSetupIO(rl).secret(question);
+    }
+    finally {
+        rl.close();
+    }
+}
+/** Parses CLI commands, wires concrete adapters, and starts the workspace REPL. */
+async function main() {
+    const args = process.argv.slice(2);
+    const credentials = new MacOSKeychainStore();
+    if (args[0] === "eval") {
+        if (args[1] === "baseline" || args[1] === "compare") {
+            const positional = args.filter((arg) => arg !== "--json");
+            const isSet = positional[1] === "baseline" && positional[2] === "set" && positional.length === 4;
+            const isShow = positional[1] === "baseline" && positional[2] === "show" && positional.length === 3;
+            const isCompare = positional[1] === "compare" && positional.length === 3;
+            if (!isSet && !isShow && !isCompare)
+                throw new Error("Usage: kairo eval baseline set <run-id> | kairo eval baseline show | kairo eval compare <run-id> [--json]");
+            const store = await SqliteSessionStore.open();
+            try {
+                if (isCompare) {
+                    const comparison = compareWithBaseline(store, positional[2]);
+                    if (!comparison)
+                        throw new Error("No self-evaluation baseline selected. Use kairo eval baseline set <run-id>.");
+                    console.log(args.includes("--json")
+                        ? JSON.stringify(comparison, null, 2)
+                        : formatComparison(comparison));
+                }
+                else {
+                    const run = isSet
+                        ? store.setEvaluationBaseline(positional[3])
+                        : store.evaluationBaseline();
+                    const result = run ? { run, attempts: store.evaluationAttempts(run.id) } : null;
+                    console.log(args.includes("--json")
+                        ? JSON.stringify(result, null, 2)
+                        : result
+                            ? formatBaseline(result.run, result.attempts)
+                            : "No self-evaluation baseline selected.");
+                }
+            }
+            finally {
+                store.close();
+            }
+            return;
+        }
+        if (args[1] === "history") {
+            const store = await SqliteSessionStore.open();
+            try {
+                const runs = store.evaluationRuns();
+                console.log(args.includes("--json") ? JSON.stringify(runs, null, 2) : formatEvaluationHistory(runs));
+            }
+            finally {
+                store.close();
+            }
+            return;
+        }
+        if (args[1] === "show") {
+            const runId = args[2];
+            if (!runId)
+                throw new Error("Provide a run ID: `kairo eval show <run-id>`.");
+            const store = await SqliteSessionStore.open();
+            try {
+                const run = store.evaluationRun(runId);
+                if (!run)
+                    throw new Error(`Evaluation run not found: ${runId}`);
+                const attempts = store.evaluationAttempts(run.id);
+                console.log(args.includes("--json")
+                    ? JSON.stringify({ run, attempts }, null, 2)
+                    : formatEvaluationRun(run, attempts));
+            }
+            finally {
+                store.close();
+            }
+            return;
+        }
+        if (args[1] === "live") {
+            const key = await credentials.get("gemini");
+            if (!key)
+                throw new Error("No Gemini credential. Run `kairo auth login gemini` or set GEMINI_API_KEY.");
+            const configured = await loadConfig();
+            const geminiModel = configured.provider === "gemini" ? configured.model : defaultConfig.model;
+            const results = await runLiveEvaluationSuite({
+                onProgress: (text) => process.stderr.write(text),
+                apiKey: key,
+                model: geminiModel,
+            });
+            console.log(args[2] === "--json"
+                ? JSON.stringify(results, null, 2)
+                : formatLiveEvaluationReport(results));
+            process.exitCode = results.every((result) => result.passed) ? 0 : 1;
+            return;
+        }
+        if (args[1] === "jev") {
+            const report = await runJevEvaluationSuite();
+            console.log(args.includes("--json")
+                ? JSON.stringify(report, null, 2)
+                : formatJevEvaluationReport(report));
+            return;
+        }
+        if (args[1] === "self") {
+            const config = await loadConfig();
+            const key = await credentials.get(config.provider);
+            if (!key)
+                throw new Error(`No ${config.provider} credential. Run \`kairo auth login ${config.provider}\` or set ${providerById(config.provider).environmentVariable}.`);
+            const trialIndex = args.indexOf("--trials");
+            const trials = trialIndex === -1 ? 1 : Number(args[trialIndex + 1]);
+            const store = await SqliteSessionStore.open();
+            try {
+                const evaluation = await runSelfEvaluationSuite({
+                    apiKey: key,
+                    provider: config.provider,
+                    model: config.model,
+                    evaluationStore: store,
+                    onProgress: (text) => process.stderr.write(text),
+                    trials,
+                });
+                const comparison = compareWithBaseline(store, evaluation.run.id);
+                console.log(args.includes("--json")
+                    ? JSON.stringify({ ...evaluation, ...(comparison ? { comparison } : {}) }, null, 2)
+                    : [
+                        formatSelfEvaluationReport(evaluation.results, evaluation.run.id),
+                        comparison ? formatComparison(comparison) : "",
+                    ]
+                        .filter(Boolean)
+                        .join("\n"));
+                process.exitCode = evaluation.results.every((result) => result.passed) ? 0 : 1;
+            }
+            finally {
+                store.close();
+            }
+            return;
+        }
+        const results = await runEvaluationSuite();
+        console.log(args[1] === "--json" ? JSON.stringify(results, null, 2) : formatEvaluationReport(results));
+        process.exitCode = results.every((result) => result.passed) ? 0 : 1;
+        return;
+    }
+    if (args[0] === "auth") {
+        const configuredProvider = (await loadConfig()).provider;
+        const requested = args[2]?.toLowerCase();
+        if (requested && !isProviderId(requested))
+            throw new Error(`Unsupported provider: ${requested}`);
+        const provider = requested ?? configuredProvider;
+        const descriptor = providerById(provider);
+        if (args[1] === "login") {
+            const key = await promptSecret(`${descriptor.name} API key (saved in macOS Keychain): `);
+            if (!key.trim())
+                throw new Error("API key cannot be empty.");
+            await descriptor.validate(key.trim());
+            await credentials.save(provider, key);
+            console.log(`${descriptor.name} credential saved.`);
+            return;
+        }
+        if (args[1] === "logout") {
+            await credentials.clear(provider);
+            console.log(`${descriptor.name} credential removed.`);
+            return;
+        }
+        if (args[1] === "status") {
+            for (const item of providerRegistry) {
+                const available = await credentials.get(item.id);
+                const source = process.env[item.environmentVariable]
+                    ? item.environmentVariable
+                    : "macOS Keychain";
+                console.log(`${item.name}: ${available ? `credential available from ${source}` : "not logged in"}.`);
+            }
+            return;
+        }
+        usage();
+        process.exitCode = 1;
+        return;
+    }
+    if (args[0] === "config") {
+        if (args[1] === "get" && (args[2] === "model" || args[2] === "provider")) {
+            console.log((await loadConfig())[args[2]]);
+            return;
+        }
+        if (args[1] === "set" && args[2] === "model" && args[3]) {
+            await setConfig("model", args[3]);
+            console.log("Model saved.");
+            return;
+        }
+        usage();
+        process.exitCode = 1;
+        return;
+    }
+    const store = await SqliteSessionStore.open();
+    if (args[0] === "sessions" && args[1] === "list") {
+        for (const item of store.list())
+            console.log(`${item.id}\t${item.workspace}\t${new Date(item.updatedAt).toISOString()}`);
+        store.close();
+        return;
+    }
+    const resumeId = args[0] === "resume" ? args[1] : undefined;
+    const session = resumeId ? store.get(resumeId) : undefined;
+    if (resumeId && !session)
+        throw new Error(`Session not found: ${resumeId}`);
+    const workspace = session?.workspace || (await realpath(resolve(args[0] || process.cwd())));
+    const config = await loadConfig();
+    const tools = await WorkspaceTools.create(workspace);
+    const active = session || store.create(workspace);
+    const repositoryAwareness = new RepositoryAwareness(store);
+    await repositoryAwareness.ensureFresh(active.id, tools.root);
+    await runRepl((approval, selection, apiKey, jev, jevFeatures) => new CodingAgent(createProvider(selection, apiKey, definitions), store, tools, approval, definitions, selection, jev, jevFeatures, repositoryAwareness), store, active, config, credentials);
+    store.close();
+}
+main().catch((error) => {
+    console.error(`kairo: ${error.message}`);
+    process.exitCode = 1;
+});

package/dist/interface/cli/provider-setup.d.ts

@@ -0,0 +1,16 @@
+import type { createInterface } from "node:readline/promises";
+import type { ModelSelection } from "../../domain/models.js";
+import type { CredentialStore } from "../../domain/ports.js";
+export interface ProviderSetupIO {
+    question(prompt: string): Promise<string>;
+    secret(prompt: string): Promise<string>;
+    write(message: string): void;
+}
+export interface ProviderSetupOptions {
+    /** Startup retains the displayed selection; in-session switching permits cancellation. */
+    allowCancel?: boolean;
+}
+/** Wraps the shared REPL readline interface and disables terminal echo for secrets. */
+export declare function terminalSetupIO(rl: ReturnType<typeof createInterface>, write?: (message: string) => void): ProviderSetupIO;
+/** Collects and validates a provider/model selection, saving a missing credential by provider. */
+export declare function configureProvider(io: ProviderSetupIO, credentials: CredentialStore, current?: ModelSelection, options?: ProviderSetupOptions): Promise<ModelSelection | undefined>;

package/dist/interface/cli/provider-setup.js

@@ -0,0 +1,86 @@
+import { execFileSync } from "node:child_process";
+import { providerById, providerRegistry, } from "../../infrastructure/providers/provider-registry.js";
+/** Wraps the shared REPL readline interface and disables terminal echo for secrets. */
+export function terminalSetupIO(rl, write = (message) => process.stdout.write(message)) {
+    return {
+        question: (prompt) => rl.question(prompt),
+        async secret(prompt) {
+            if (!process.stdin.isTTY)
+                return rl.question(prompt);
+            execFileSync("/bin/stty", ["-echo"], { stdio: ["inherit", "ignore", "ignore"] });
+            try {
+                return await rl.question(prompt);
+            }
+            finally {
+                execFileSync("/bin/stty", ["echo"], { stdio: ["inherit", "ignore", "ignore"] });
+                write("\n");
+            }
+        },
+        write,
+    };
+}
+/** Prompts until the user selects a registered provider or cancels an optional switch. */
+async function chooseProvider(io, current, allowCancel = true) {
+    io.write(`\nProviders:\n${providerRegistry
+        .map((provider, index) => `  ${index + 1}. ${provider.name}`)
+        .join("\n")}\n`);
+    for (;;) {
+        const prompt = current
+            ? allowCancel
+                ? `Provider [${current.provider}] (blank to cancel): `
+                : `Provider [${current.provider}] (blank to keep): `
+            : "Provider: ";
+        const answer = (await io.question(prompt)).trim();
+        if (!answer && current)
+            return allowCancel ? undefined : current.provider;
+        const byNumber = providerRegistry[Number(answer) - 1];
+        const byId = providerRegistry.find((provider) => provider.id === answer.toLowerCase());
+        const selected = byNumber ?? byId;
+        if (selected)
+            return selected.id;
+        io.write("Choose a listed provider by number or name.\n");
+    }
+}
+/** Offers tested models first while retaining a custom-model escape hatch. */
+async function chooseModel(io, providerId, current) {
+    const provider = providerById(providerId);
+    io.write(`\n${provider.name} models:\n${provider.models
+        .map((model, index) => `  ${index + 1}. ${model.label}${model.recommended ? " (recommended)" : ""} — ${model.id}`)
+        .join("\n")}\n  ${provider.models.length + 1}. Custom model ID\n`);
+    for (;;) {
+        const currentModel = current?.provider === providerId ? current.model : undefined;
+        const prompt = currentModel ? `Model [${currentModel}] (blank to keep): ` : "Model: ";
+        const answer = (await io.question(prompt)).trim();
+        if (!answer && currentModel)
+            return currentModel;
+        const index = Number(answer) - 1;
+        if (provider.models[index])
+            return provider.models[index].id;
+        if (index === provider.models.length) {
+            const custom = (await io.question("Custom model ID: ")).trim();
+            if (custom)
+                return custom;
+            io.write("Model ID cannot be empty.\n");
+            continue;
+        }
+        io.write("Choose a listed model.\n");
+    }
+}
+/** Collects and validates a provider/model selection, saving a missing credential by provider. */
+export async function configureProvider(io, credentials, current, options = {}) {
+    const allowCancel = options.allowCancel ?? true;
+    const provider = await chooseProvider(io, current, allowCancel);
+    if (!provider)
+        return undefined;
+    const model = await chooseModel(io, provider, current);
+    const descriptor = providerById(provider);
+    let key = await credentials.get(provider);
+    if (!key) {
+        key = (await io.secret(`Enter ${descriptor.name} API key (saved in macOS Keychain): `)).trim();
+        if (!key)
+            throw new Error("API key cannot be empty.");
+        await descriptor.validate(key);
+        await credentials.save(provider, key);
+    }
+    return { provider, model };
+}

package/dist/interface/cli/repl.d.ts

@@ -0,0 +1,7 @@
+import type { ModelSelection } from "../../domain/models.js";
+import type { ApprovalPolicy, CredentialStore } from "../../domain/ports.js";
+import { CodingAgent } from "../../application/coding-agent.js";
+import { SqliteSessionStore, type Session } from "../../infrastructure/persistence/sqlite-session-store.js";
+import type { KairoConfig } from "../../infrastructure/configuration/config.js";
+/** Keeps the CLI entrypoint stable while the interaction layer is implemented by Ink. */
+export declare function runRepl(createAgent: (approval: ApprovalPolicy, selection: ModelSelection, apiKey: string, jev?: import("../../infrastructure/providers/jev-safety-advisor.js").JevDecisionProvider, jevFeatures?: import("../../domain/ports.js").JevFeatures) => CodingAgent, store: SqliteSessionStore, session: Session, initialConfig: KairoConfig, credentials: CredentialStore): Promise<void>;

package/dist/interface/cli/repl.js

@@ -0,0 +1,19 @@
+import { runTui } from "./tui.js";
+/** Keeps the CLI entrypoint stable while the interaction layer is implemented by Ink. */
+export async function runRepl(createAgent, store, session, initialConfig, credentials) {
+    await runTui({
+        createAgent,
+        store,
+        session,
+        initialSelection: initialConfig,
+        initialJevEnabled: initialConfig.jevEnabled,
+        initialJevFeatures: {
+            routing: initialConfig.jevRoutingEnabled,
+            safety: initialConfig.jevSafetyEnabled,
+            recovery: initialConfig.jevRecoveryEnabled,
+            autonomy: initialConfig.jevAutonomyEnabled,
+        },
+        initialAutoModelRoutingEnabled: initialConfig.autoModelRoutingEnabled,
+        credentials,
+    });
+}

package/dist/interface/cli/task-trace.d.ts

@@ -0,0 +1,7 @@
+import type { Task, TaskEvent, TaskPlan } from "../../domain/models.js";
+/** Formats durable counters; legacy tasks explicitly report unavailable instrumentation. */
+export declare function formatMetrics(events: TaskEvent[]): string;
+/** Shows the latest 100 events in execution order without rendering untrusted command output. */
+export declare function formatTrace(task: Task, events: TaskEvent[]): string;
+/** Renders the saved plan as a compact terminal artifact for review. */
+export declare function formatPlan(plan: TaskPlan): string;

package/dist/interface/cli/task-trace.js

@@ -0,0 +1,48 @@
+import { taskMetrics } from "../../application/task-metrics.js";
+/** Formats durable counters; legacy tasks explicitly report unavailable instrumentation. */
+export function formatMetrics(events) {
+    if (!events.length)
+        return "No trace recorded for this task (created before tracing was enabled).";
+    const m = taskMetrics(events);
+    return [
+        `Provider retries: ${m.providerRetries}; retry waiting: ${Math.round(m.providerWaitMs)} ms`,
+        `Model: ${m.modelTurns} turns, ${m.modelFailures} failures, ${Math.round(m.modelMs)} ms`,
+        `Tools: ${m.toolRequests} requests, ${m.toolExecutions} executed, ${m.toolFailures} failures, ${Math.round(m.toolMs)} ms`,
+        `Approvals: ${m.approvals} allowed, ${m.denials} denied, ${m.autonomousActions} Jev-autonomous, ${Math.round(m.approvalMs)} ms waiting`,
+        `Repairs: ${m.repairs}${m.repairConverged ? " (converged)" : ""}; command checks: ${m.verificationPasses} passed, ${m.verificationFailures} failed`,
+        `Verification selection: ${m.focusedVerifications} focused, ${m.broadVerifications} broad (${m.verificationSelections} total)`,
+        `Jev: ${m.jevDecisions} decisions (${m.jevRoutes} routing, ${m.jevSafetyChecks} safety, ${m.jevRecoveryChecks} recovery), ${m.jevFailures} fallbacks, ${Math.round(m.jevMs)} ms`,
+        `Unfinished operations: ${m.unfinishedOperations}`,
+    ].join("\n");
+}
+/** Shows the latest 100 events in execution order without rendering untrusted command output. */
+export function formatTrace(task, events) {
+    return [
+        `Task ${task.id}: ${task.status}`,
+        formatMetrics(events),
+        ...(events.length > 100 ? ["Showing latest 100 events."] : []),
+        ...events
+            .slice(-100)
+            .map((event) => [
+            new Date(event.createdAt).toISOString(),
+            event.kind,
+            event.name?.replace(/[\x00-\x1f\x7f-\x9f]/g, ""),
+            event.outcome,
+            event.durationMs === undefined ? "" : `${Math.round(event.durationMs)} ms`,
+            event.exitCode === undefined ? "" : `exit=${event.exitCode}`,
+        ]
+            .filter(Boolean)
+            .join("  ")),
+    ].join("\n");
+}
+/** Renders the saved plan as a compact terminal artifact for review. */
+export function formatPlan(plan) {
+    return [
+        `Goal: ${plan.goal}`,
+        `Assumptions: ${plan.assumptions.length ? plan.assumptions.map((item) => `- ${item}`).join("\n") : "none"}`,
+        `Files:\n${plan.files.length ? plan.files.map((file) => `- ${file.path}: ${file.reason}`).join("\n") : "- No files identified."}`,
+        `Steps:\n${plan.steps.map((step, index) => `${index + 1}. ${step}`).join("\n")}`,
+        `Verification: ${plan.verification.command ? `\`${plan.verification.command}\` — ` : "No command selected — "}${plan.verification.reason}`,
+        `Risks: ${plan.risks.length ? plan.risks.map((item) => `- ${item}`).join("\n") : "none"}`,
+    ].join("\n\n");
+}

package/dist/interface/cli/tui.d.ts

@@ -0,0 +1,147 @@
+import type { ModelSelection, ToolCall } from "../../domain/models.js";
+import type { ApprovalDecision, ApprovalPolicy, CredentialStore, JevFeatures } from "../../domain/ports.js";
+import { CodingAgent } from "../../application/coding-agent.js";
+import { JevDecisionProvider } from "../../infrastructure/providers/jev-safety-advisor.js";
+import { SqliteSessionStore, type Session } from "../../infrastructure/persistence/sqlite-session-store.js";
+export type InteractionMode = "build" | "plan";
+export type TranscriptEntry = {
+    id: number;
+    kind: "user" | "assistant" | "system" | "error";
+    text: string;
+};
+type PendingApproval = {
+    call: ToolCall;
+    description: string;
+    resolve: (decision: ApprovalDecision) => void;
+};
+export type ModelOption = ModelSelection & {
+    label: string;
+};
+export type RepositoryStatus = {
+    branch?: string;
+    changedFiles: number;
+};
+export type ChangedFileReview = {
+    path: string;
+    diff: string;
+    unavailable?: string;
+};
+export type InlineDiffLine = {
+    kind: "context" | "addition" | "deletion";
+    oldLine?: number;
+    newLine?: number;
+    text: string;
+};
+export type InlineDiffHunk = {
+    header: string;
+    lines: InlineDiffLine[];
+};
+export type InlineDiff = {
+    path: string;
+    additions: number;
+    deletions: number;
+    hunks: InlineDiffHunk[];
+};
+export declare const slashCommands: readonly [{
+    readonly name: "/help";
+    readonly description: "Show commands and shortcuts";
+}, {
+    readonly name: "/plan";
+    readonly description: "Toggle read-only planning mode";
+}, {
+    readonly name: "/build";
+    readonly description: "Build the latest saved plan";
+}, {
+    readonly name: "/models";
+    readonly description: "Choose a model";
+}, {
+    readonly name: "/auto";
+    readonly description: "Toggle Jev automatic model routing";
+}, {
+    readonly name: "/jev";
+    readonly description: "Manage the Jev safety advisor";
+}, {
+    readonly name: "/new";
+    readonly description: "Start a new session";
+}, {
+    readonly name: "/resume";
+    readonly description: "Continue a task or open a session";
+    readonly acceptsArgument: true;
+}, {
+    readonly name: "/history";
+    readonly description: "List saved sessions";
+}, {
+    readonly name: "/status";
+    readonly description: "Show the latest task status";
+}, {
+    readonly name: "/trace";
+    readonly description: "Show task trace";
+    readonly acceptsArgument: true;
+}, {
+    readonly name: "/changes";
+    readonly description: "Show changed files";
+}, {
+    readonly name: "/verify";
+    readonly description: "Run a verification command";
+    readonly acceptsArgument: true;
+}, {
+    readonly name: "/compact";
+    readonly description: "Save a context checkpoint";
+}, {
+    readonly name: "/cancel";
+    readonly description: "Cancel the current task";
+}, {
+    readonly name: "/logout";
+    readonly description: "Remove the active provider credential";
+}, {
+    readonly name: "/quit";
+    readonly description: "Exit Kairo";
+}];
+/** Reads only compact repository metadata for the header. */
+export declare function repositoryStatus(workspace: string): RepositoryStatus;
+/**
+ * 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 declare function changedFileReview(workspace: string, path: string): ChangedFileReview;
+/** Finds palette entries while the user is typing a slash-command name. */
+export declare function matchingSlashCommands(input: string): readonly (typeof slashCommands)[number][];
+/** Flattens the supported provider registry into the options shown by `/models`. */
+export declare function modelOptions(): ModelOption[];
+/** Bridges the agent's approval port to the active Ink application. */
+export declare class TuiApproval implements ApprovalPolicy {
+    private readonly request;
+    constructor(request: (pending: PendingApproval) => void);
+    approve(call: ToolCall, description: string): Promise<ApprovalDecision>;
+}
+/** `/plan` is intentionally a live toggle, never a one-shot planning command. */
+export declare function interactionModeAfterCommand(mode: InteractionMode, command: string): InteractionMode;
+/** Reflects a completed Jev planning route in the persistent TUI interaction mode. */
+export declare function interactionModeAfterTask(mode: InteractionMode, taskMode: "implementation" | "planning" | undefined): InteractionMode;
+export declare function ModeBadge({ mode }: {
+    mode: InteractionMode;
+}): React.JSX.Element;
+/** A compact chat row that keeps requests, answers, and operational notices distinct. */
+export declare function TranscriptRow({ entry }: {
+    entry: TranscriptEntry;
+}): React.JSX.Element;
+/** Converts a Git patch into the line-oriented model used by Kairo's terminal review view. */
+export declare function inlineDiff(review: ChangedFileReview): InlineDiff | undefined;
+export declare function BrandMark(): React.JSX.Element;
+export interface KairoTuiProps {
+    createAgent: (approval: ApprovalPolicy, selection: ModelSelection, apiKey: string, jev?: JevDecisionProvider, jevFeatures?: JevFeatures) => CodingAgent;
+    store: SqliteSessionStore;
+    session: Session;
+    initialSelection: ModelSelection;
+    initialApiKey?: string;
+    initialJevKey?: string;
+    initialJevEnabled: boolean;
+    initialJevFeatures: JevFeatures;
+    initialAutoModelRoutingEnabled: boolean;
+    credentials: CredentialStore;
+}
+/** Renders one bounded Kairo session and dispatches terminal commands without readline. */
+export declare function KairoTui(props: KairoTuiProps): React.JSX.Element;
+/** Starts the Ink renderer and keeps the existing CLI composition boundary intact. */
+export declare function runTui(props: Omit<KairoTuiProps, "initialApiKey">): Promise<void>;
+export {};