klyro 0.1.2 → 0.1.3

package/dist/agent/runtime.d.ts

@@ -61,6 +61,14 @@ export interface RunOptions {
      */
     onEvent?: (ev: RuntimeEvent) => void;
 }
+/** A single plan step emitted by the agent. */
+export interface PlanStep {
+    id: string;
+    title: string;
+    status: 'pending' | 'in_progress' | 'done' | 'failed' | 'skipped';
+    /** Optional files the step will touch (for L6 diff). */
+    files?: string[];
+}
 /** High-level event stream the runtime emits. Safe for UI consumption. */
 export type RuntimeEvent = {
     kind: 'step_start';
@@ -106,6 +114,17 @@ export type RuntimeEvent = {
     text: string;
 } | {
     kind: 'aborted';
+} | {
+    kind: 'plan_update';
+    plan: PlanStep[];
+} | {
+    kind: 'file_changed';
+    path: string;
+    op: 'created' | 'modified' | 'deleted';
+} | {
+    kind: 'verification_failed';
+    step: string;
+    reason: string;
 };
 export interface RunResult {
     status: 'complete' | 'max_steps' | 'aborted' | 'no_final';

package/dist/agent/runtime.js

@@ -190,6 +190,11 @@ export async function run(opts, deps) {
                 telemetry.recordError(`${code}: ${call.name}`);
             }
             emit?.({ kind: 'tool_result', id: call.id, name: call.name, output, isError: !obs.ok, latencyMs });
+            if (obs.ok) {
+                const fileChanged = inferFileChanged(call.name, call.input, obs.value);
+                if (fileChanged)
+                    emit?.({ kind: 'file_changed', path: fileChanged.path, op: fileChanged.op });
+            }
         }
         emit?.({ kind: 'step_end', step: steps });
     }
@@ -207,6 +212,28 @@ function redactOutput(v) {
         return v; // structured outputs are not redacted wholesale
     return v;
 }
+/**
+ * Best-effort inference of "this tool call changed a file" for the
+ * file_changed event. Returns null when we don't have a clear answer.
+ *
+ * Today: write_file, edit_file, write_file (truncate via empty content).
+ * Tomorrow: shell_exec that ran `rm` or `git mv` would need to grep
+ * the output, but that's out of scope.
+ */
+function inferFileChanged(toolName, input, output) {
+    const inPath = typeof input.path === 'string' ? input.path : null;
+    if (!inPath)
+        return null;
+    if (toolName === 'write_file' || toolName === 'edit_file') {
+        // Distinguish create vs modify by the output shape: write_file returns
+        // { path, bytesWritten }; edit_file returns { path, replacements, diff }.
+        // Both are "modified" semantically; we don't have the pre-state easily
+        // from inside the runtime. A more precise implementation would stat the
+        // file before/after the call. For now: treat both as 'modified'.
+        return { path: inPath, op: 'modified' };
+    }
+    return null;
+}
 export function defaultSystemPrompt(ctx) {
     const base = [
         'You are Klyro, an autonomous coding harness. You solve the user\'s task by',

package/dist/cli/repl.js

@@ -14,6 +14,8 @@ import { builtinRegistry } from '../tools/registry.js';
 import { builtinRules, DEFAULT_POLICY_CONFIG, PolicyEngine } from '../policy/engine.js';
 import { buildLevel6Context } from '../context/level6.js';
 import { DenyAllApprovalPrompt, StdinApprovalPrompt } from '../policy/approval.js';
+import { TuiApprovalBridge } from '../tui/approval.js';
+import { parseUnifiedDiff } from '../tui/diff-parser.js';
 function readEnv(name, fallback) {
     const v = process.env[name];
     return v && v.length > 0 ? v : fallback;
@@ -30,7 +32,6 @@ export async function startRepl(opts = {}) {
     const registry = builtinRegistry();
     const policy = new PolicyEngine(builtinRules(), DEFAULT_POLICY_CONFIG);
     const adapter = httpChatAdapter({ baseURL: baseUrl, apiKey, timeoutMs: 60_000 });
-    const approval = opts.nonInteractive ? new DenyAllApprovalPrompt() : new StdinApprovalPrompt();
     const ctxBlock = await buildLevel6Context({ cwd });
     const ctxPrefix = ctxBlock.formatted ? `\n\n<context>\n${ctxBlock.formatted}\n</context>` : '';
     const systemPromptFn = (_ctx) => {
@@ -40,13 +41,22 @@ export async function startRepl(opts = {}) {
     };
     const ac = new AbortController();
     process.on('SIGINT', () => ac.abort());
+    // When the TUI is mounted, use the inline Ink prompt. Otherwise
+    // fall back to stdin readline. The bridge is shared between the
+    // App and the runtime so the modal can resolve the runtime's ask().
+    const tuiBridge = new TuiApprovalBridge();
+    const approval = opts.nonInteractive
+        ? new DenyAllApprovalPrompt()
+        : (process.stdin.isTTY ? tuiBridge : new StdinApprovalPrompt());
     let inflight = null;
     let transcriptRef = [];
     let lastStatus = null;
     const app = render(React.createElement(App, {
         initialModel: model,
         maxSteps: opts.maxSteps ?? 30,
+        cwd,
         initialStatus: { status: 'idle' },
+        approvalBridge: tuiBridge,
         onPrompt: async (text) => {
             inflight = runWithBridge(text);
             await inflight;
@@ -97,7 +107,7 @@ export async function startRepl(opts = {}) {
                             name: ev.name,
                             id_call: ev.id,
                             args: JSON.stringify(ev.input, null, 2),
-                            collapsed: true,
+                            status: 'running',
                         });
                         activeCallId = null;
                         activeCallName = null;
@@ -122,12 +132,30 @@ export async function startRepl(opts = {}) {
                             result: typeof ev.output === 'string' ? ev.output : JSON.stringify(ev.output, null, 2),
                             isError: ev.isError,
                             latencyMs: ev.latencyMs,
-                            collapsed: true,
+                            status: ev.isError ? 'error' : 'done',
                         });
                     }
                     else if (ev.kind === 'usage') {
                         appG.__klyroAppStatus?.({ usageInput: ev.input, usageOutput: ev.output });
                     }
+                    else if (ev.kind === 'plan_update') {
+                        appG.__klyroAppPlan?.(ev.plan);
+                    }
+                    else if (ev.kind === 'file_changed') {
+                        appG.__klyroAppAppend?.({
+                            id: `fc-${ev.path}-${Date.now()}`,
+                            kind: 'file_changed',
+                            path: ev.path,
+                            op: ev.op,
+                        });
+                    }
+                    else if (ev.kind === 'verification_failed') {
+                        appG.__klyroAppAppend?.({
+                            id: `vf-${ev.step}-${Date.now()}`,
+                            kind: 'error',
+                            message: `verification failed at ${ev.step}: ${ev.reason}`,
+                        });
+                    }
                     else if (ev.kind === 'aborted') {
                         appG.__klyroAppStatus?.({ status: 'aborted' });
                     }
@@ -169,8 +197,27 @@ export async function startRepl(opts = {}) {
                 }
                 return;
             }
+            case 'diff': {
+                const r = await registry.execute('git_diff', {}, { cwd, env: process.env, nonInteractive: true });
+                if (!r.ok) {
+                    appG.__klyroAppAppend?.({
+                        id: `diff-err-${Date.now()}`,
+                        kind: 'error',
+                        message: `git_diff failed: ${r.error.message ?? r.error.code}`,
+                    });
+                    return;
+                }
+                const out = r.value;
+                const hunks = parseUnifiedDiff(out.diff);
+                appG.__klyroAppAppend?.({
+                    id: `diff-${Date.now()}`,
+                    kind: 'diff',
+                    hunks,
+                    summary: `${out.patchedFiles.length} file(s) changed${out.stat ? ' — ' + out.stat.split('\n').pop() : ''}`,
+                });
+                return;
+            }
             case 'compact':
-            case 'diff':
             case 'model':
                 appG.__klyroAppAppend?.({
                     id: `stub-${Date.now()}`,

package/dist/cli/slash/parser.d.ts

@@ -6,6 +6,7 @@
  *   /compact           — ask the agent to compact its own context
  *   /model <id>        — switch the active model mid-session
  *   /diff              — show working-tree diff (git diff)
+ *   /plan              — toggle the plan view (if a plan is loaded)
  *   /status            — show session status (model, steps, usage)
  *   /quit              — exit the REPL
  *   /help              — list available commands
@@ -22,6 +23,8 @@ export type SlashCommand = {
     model: string;
 } | {
     kind: 'diff';
+} | {
+    kind: 'plan';
 } | {
     kind: 'status';
 } | {

package/dist/cli/slash/parser.js

@@ -6,6 +6,7 @@
  *   /compact           — ask the agent to compact its own context
  *   /model <id>        — switch the active model mid-session
  *   /diff              — show working-tree diff (git diff)
+ *   /plan              — toggle the plan view (if a plan is loaded)
  *   /status            — show session status (model, steps, usage)
  *   /quit              — exit the REPL
  *   /help              — list available commands
@@ -13,7 +14,7 @@
  * Anything not starting with "/" is a regular prompt and yields
  * { kind: 'prompt', text }.
  */
-const KNOWN = ['clear', 'compact', 'model', 'diff', 'status', 'quit', 'help'];
+const KNOWN = ['clear', 'compact', 'model', 'diff', 'plan', 'status', 'quit', 'help'];
 export function parse(input) {
     const trimmed = input.trim();
     if (!trimmed.startsWith('/')) {
@@ -26,6 +27,7 @@ export function parse(input) {
         case 'clear': return { kind: 'clear' };
         case 'compact': return { kind: 'compact' };
         case 'diff': return { kind: 'diff' };
+        case 'plan': return { kind: 'plan' };
         case 'status': return { kind: 'status' };
         case 'quit':
         case 'exit':
@@ -38,8 +40,7 @@ export function parse(input) {
                 return { kind: 'unknown', raw: trimmed };
             return { kind: 'model', model: rest };
         }
-        default:
-            return { kind: 'unknown', raw: trimmed };
+        default: return { kind: 'unknown', raw: trimmed };
     }
 }
 export function listCommands() {

package/dist/tui/app.d.ts

@@ -13,9 +13,12 @@
 import React from 'react';
 import { type StatusSnapshot } from './status.js';
 import { type TranscriptItem } from './transcript.js';
+import { TuiApprovalBridge } from './approval.js';
 export interface AppProps {
     initialModel: string;
     maxSteps: number;
+    /** Working directory to display in the header. */
+    cwd: string;
     /** Called when the user submits a non-slash prompt. */
     onPrompt: (text: string) => void | Promise<void>;
     /** Called when the user types a slash command. */
@@ -23,5 +26,7 @@ export interface AppProps {
     /** Initial state (e.g. when resuming a session). */
     initialTranscript?: TranscriptItem[];
     initialStatus?: Partial<StatusSnapshot>;
+    /** Optional approval bridge — when set, the modal prompts inline. */
+    approvalBridge?: TuiApprovalBridge;
 }
 export declare function App(props: AppProps): React.JSX.Element;

package/dist/tui/app.js

@@ -15,6 +15,9 @@ import { useState, useCallback, useEffect } from 'react';
 import { Box, Text, useInput } from 'ink';
 import { StatusLine } from './status.js';
 import { Transcript } from './transcript.js';
+import { Header } from './header.js';
+import { ApprovalModal, TuiApprovalBridge } from './approval.js';
+import { PlanView } from './plan.js';
 import { parse as parseSlash } from '../cli/slash/parser.js';
 let _itemCounter = 0;
 function nextId(prefix) {
@@ -24,6 +27,10 @@ function nextId(prefix) {
 export function App(props) {
     const [transcript, setTranscript] = useState(props.initialTranscript ?? []);
     const [input, setInput] = useState('');
+    const [bridge] = useState(() => props.approvalBridge ?? new TuiApprovalBridge());
+    const [awaitingApproval, setAwaitingApproval] = useState(false);
+    const [plan, setPlan] = useState([]);
+    const [planExpanded, setPlanExpanded] = useState(false);
     const [status, setStatus] = useState({
         model: props.initialModel,
         step: 0,
@@ -34,19 +41,28 @@ export function App(props) {
         status: 'idle',
         ...props.initialStatus,
     });
+    // Track bridge state to disable the input box while a prompt is up.
+    useEffect(() => {
+        return bridge.subscribe((p) => setAwaitingApproval(p !== null));
+    }, [bridge]);
     const append = useCallback((item) => {
         setTranscript((prev) => [...prev, item]);
     }, []);
     useEffect(() => {
         globalThis.__klyroAppAppend = append;
         globalThis.__klyroAppStatus = (s) => setStatus((prev) => ({ ...prev, ...s }));
+        globalThis.__klyroAppPlan = (p) => {
+            setPlan(p);
+            setPlanExpanded(true);
+        };
         return () => {
             delete globalThis.__klyroAppAppend;
             delete globalThis.__klyroAppStatus;
+            delete globalThis.__klyroAppPlan;
         };
     }, [append]);
     useInput((inputStr, key) => {
-        if (status.status === 'running')
+        if (status.status === 'running' || awaitingApproval)
             return;
         if (key.return) {
             const value = input.trim();
@@ -58,6 +74,11 @@ export function App(props) {
             if (cmd.kind === 'prompt') {
                 void props.onPrompt(cmd.text);
             }
+            else if (cmd.kind === 'plan') {
+                // Local UI command — toggle the plan view inline.
+                if (plan.length > 0)
+                    setPlanExpanded((v) => !v);
+            }
             else {
                 void props.onSlash(cmd);
             }
@@ -75,5 +96,5 @@ export function App(props) {
             setInput((v) => v + inputStr);
         }
     });
-    return (_jsxs(Box, { flexDirection: "column", width: "100%", height: "100%", children: [_jsx(StatusLine, { snapshot: status }), _jsx(Transcript, { items: transcript }), _jsxs(Box, { borderStyle: "single", borderColor: "gray", paddingX: 1, children: [_jsx(Text, { color: "gray", children: '> ' }), _jsx(Text, { children: input }), status.status === 'running' ? _jsx(Text, { color: "cyan", children: " \u258D" }) : _jsx(Text, { children: "\u258D" })] })] }));
+    return (_jsxs(Box, { flexDirection: "column", width: "100%", height: "100%", children: [_jsx(Header, { cwd: props.cwd, model: status.model, step: status.step, maxSteps: status.maxSteps }), _jsx(StatusLine, { snapshot: status }), plan.length > 0 ? (_jsx(PlanView, { steps: plan, expanded: planExpanded, onToggle: () => setPlanExpanded((v) => !v) })) : null, _jsx(Transcript, { items: transcript }), awaitingApproval ? _jsx(ApprovalModal, { bridge: bridge }) : null, _jsxs(Box, { borderStyle: "single", borderColor: awaitingApproval ? 'yellow' : 'gray', paddingX: 1, children: [_jsx(Text, { color: "gray", children: awaitingApproval ? '! ' : '> ' }), _jsx(Text, { children: awaitingApproval ? '(awaiting approval — see above)' : input }), status.status === 'running' ? _jsx(Text, { color: "cyan", children: " \u258D" }) : _jsx(Text, { children: "\u258D" })] })] }));
 }

package/dist/tui/app.test.js

@@ -4,7 +4,7 @@ import { render } from 'ink-testing-library';
 import { App } from './app.js';
 describe('App', () => {
     it('shows the empty-state hint and the status line', () => {
-        const { lastFrame } = render(_jsx(App, { initialModel: "mock", maxSteps: 10, onPrompt: async () => { }, onSlash: async () => { } }));
+        const { lastFrame } = render(_jsx(App, { initialModel: "mock", maxSteps: 10, cwd: "/test", onPrompt: async () => { }, onSlash: async () => { } }));
         const out = lastFrame();
         expect(out).toContain('mock');
         expect(out).toMatch(/Type a prompt/);
@@ -13,12 +13,12 @@ describe('App', () => {
         const items = [
             { id: '1', kind: 'text', text: 'seed', role: 'user' },
         ];
-        const { lastFrame } = render(_jsx(App, { initialModel: "m", maxSteps: 10, onPrompt: async () => { }, onSlash: async () => { }, initialTranscript: items }));
+        const { lastFrame } = render(_jsx(App, { initialModel: "m", maxSteps: 10, cwd: "/test", onPrompt: async () => { }, onSlash: async () => { }, initialTranscript: items }));
         expect(lastFrame()).toContain('> seed');
     });
     it('honors initialStatus overrides', () => {
         const overrides = { step: 5, repairs: 3, status: 'running' };
-        const { lastFrame } = render(_jsx(App, { initialModel: "m", maxSteps: 10, onPrompt: async () => { }, onSlash: async () => { }, initialStatus: overrides }));
+        const { lastFrame } = render(_jsx(App, { initialModel: "m", maxSteps: 10, cwd: "/test", onPrompt: async () => { }, onSlash: async () => { }, initialStatus: overrides }));
         const out = lastFrame();
         expect(out).toContain('5');
         expect(out).toContain('10');
@@ -27,7 +27,7 @@ describe('App', () => {
     });
     it('installs and tears down the global bridge hooks', () => {
         const g = globalThis;
-        const { unmount } = render(_jsx(App, { initialModel: "m", maxSteps: 10, onPrompt: async () => { }, onSlash: async () => { } }));
+        const { unmount } = render(_jsx(App, { initialModel: "m", maxSteps: 10, cwd: "/test", onPrompt: async () => { }, onSlash: async () => { } }));
         expect(g.__klyroAppAppend).toBeTypeOf('function');
         expect(g.__klyroAppStatus).toBeTypeOf('function');
         unmount();
@@ -36,7 +36,7 @@ describe('App', () => {
     });
     it('submits a non-slash prompt via onPrompt', async () => {
         const onPrompt = vi.fn(async () => { });
-        const { stdin } = render(_jsx(App, { initialModel: "m", maxSteps: 10, onPrompt: onPrompt, onSlash: async () => { } }));
+        const { stdin } = render(_jsx(App, { initialModel: "m", maxSteps: 10, cwd: "/test", onPrompt: onPrompt, onSlash: async () => { } }));
         stdin.write('hello world');
         await new Promise((r) => setTimeout(r, 20));
         stdin.write('\x0d');
@@ -45,7 +45,7 @@ describe('App', () => {
     });
     it('routes a slash command to onSlash', async () => {
         const onSlash = vi.fn(async () => { });
-        const { stdin } = render(_jsx(App, { initialModel: "m", maxSteps: 10, onPrompt: async () => { }, onSlash: onSlash }));
+        const { stdin } = render(_jsx(App, { initialModel: "m", maxSteps: 10, cwd: "/test", onPrompt: async () => { }, onSlash: onSlash }));
         stdin.write('/help');
         await new Promise((r) => setTimeout(r, 20));
         stdin.write('\x0d');
@@ -56,7 +56,7 @@ describe('App', () => {
     });
     it('ignores Enter while status is running', async () => {
         const onPrompt = vi.fn(async () => { });
-        const { stdin } = render(_jsx(App, { initialModel: "m", maxSteps: 10, onPrompt: onPrompt, onSlash: async () => { }, initialStatus: { status: 'running' } }));
+        const { stdin } = render(_jsx(App, { initialModel: "m", maxSteps: 10, cwd: "/test", onPrompt: onPrompt, onSlash: async () => { }, initialStatus: { status: 'running' } }));
         stdin.write('hello');
         await new Promise((r) => setTimeout(r, 20));
         stdin.write('\x0d');
@@ -65,7 +65,7 @@ describe('App', () => {
     });
     it('routes /quit to onSlash as a quit command', async () => {
         const onSlash = vi.fn(async () => { });
-        const { stdin } = render(_jsx(App, { initialModel: "m", maxSteps: 10, onPrompt: async () => { }, onSlash: onSlash }));
+        const { stdin } = render(_jsx(App, { initialModel: "m", maxSteps: 10, cwd: "/test", onPrompt: async () => { }, onSlash: onSlash }));
         stdin.write('/quit');
         await new Promise((r) => setTimeout(r, 20));
         stdin.write('\x0d');

package/dist/tui/approval.d.ts

@@ -0,0 +1,42 @@
+/**
+ * TUI approval prompt — a TUI-native replacement for StdinApprovalPrompt.
+ *
+ * Why not just keep StdinApprovalPrompt and use readline?
+ *   Ink owns stdin via useInput. If readline is also attached to stdin,
+ *   their events race and the user sees garbled or missing input.
+ *
+ * The runtime calls `ask(req)` from inside the agent loop and awaits the
+ * choice. This module sits between them:
+ *
+ *   1. The Ink App registers a resolver via setResolver() in useEffect.
+ *   2. When the runtime calls ask(), we stash the request and return
+ *      a Promise.
+ *   3. The App polls getPending() on every render to show a modal.
+ *   4. The App's useInput handler sees a pending prompt and routes
+ *      y/n/a to the resolver.
+ *
+ * Non-TTY mode (no Ink mounted) keeps using StdinApprovalPrompt; this
+ * module is only used when the TUI is active.
+ */
+import React from 'react';
+import type { ApprovalChoice, ApprovalRequest } from '../policy/approval.js';
+import type { ApprovalPrompt } from '../policy/approval.js';
+interface PendingPrompt {
+    req: ApprovalRequest;
+    resolve: (choice: ApprovalChoice) => void;
+}
+declare class TuiApprovalBridge implements ApprovalPrompt {
+    private pending;
+    private listener;
+    ask(req: ApprovalRequest): Promise<ApprovalChoice>;
+    /** Called by the App's useInput to consume the pending prompt. */
+    resolve(choice: ApprovalChoice): boolean;
+    getPending(): ApprovalRequest | null;
+    /** Used by useSyncExternalStore-ish wiring in <ApprovalModal/>. */
+    subscribe(listener: (p: PendingPrompt | null) => void): () => void;
+}
+export { TuiApprovalBridge };
+/** Mounted inside the Ink App. Renders a modal when a prompt is pending. */
+export declare function ApprovalModal({ bridge }: {
+    bridge: TuiApprovalBridge;
+}): React.JSX.Element | null;

package/dist/tui/approval.js

@@ -0,0 +1,76 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+/**
+ * TUI approval prompt — a TUI-native replacement for StdinApprovalPrompt.
+ *
+ * Why not just keep StdinApprovalPrompt and use readline?
+ *   Ink owns stdin via useInput. If readline is also attached to stdin,
+ *   their events race and the user sees garbled or missing input.
+ *
+ * The runtime calls `ask(req)` from inside the agent loop and awaits the
+ * choice. This module sits between them:
+ *
+ *   1. The Ink App registers a resolver via setResolver() in useEffect.
+ *   2. When the runtime calls ask(), we stash the request and return
+ *      a Promise.
+ *   3. The App polls getPending() on every render to show a modal.
+ *   4. The App's useInput handler sees a pending prompt and routes
+ *      y/n/a to the resolver.
+ *
+ * Non-TTY mode (no Ink mounted) keeps using StdinApprovalPrompt; this
+ * module is only used when the TUI is active.
+ */
+import { useEffect, useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+class TuiApprovalBridge {
+    pending = null;
+    listener = null;
+    ask(req) {
+        return new Promise((resolve) => {
+            this.pending = { req, resolve };
+            this.listener?.(this.pending);
+        });
+    }
+    /** Called by the App's useInput to consume the pending prompt. */
+    resolve(choice) {
+        if (!this.pending)
+            return false;
+        const p = this.pending;
+        this.pending = null;
+        this.listener?.(null);
+        p.resolve(choice);
+        return true;
+    }
+    getPending() {
+        return this.pending?.req ?? null;
+    }
+    /** Used by useSyncExternalStore-ish wiring in <ApprovalModal/>. */
+    subscribe(listener) {
+        this.listener = listener;
+        return () => { this.listener = null; };
+    }
+}
+export { TuiApprovalBridge };
+/** Mounted inside the Ink App. Renders a modal when a prompt is pending. */
+export function ApprovalModal({ bridge }) {
+    const [pending, setPending] = useState(bridge.getPending());
+    useEffect(() => {
+        return bridge.subscribe((p) => setPending(p?.req ?? null));
+    }, [bridge]);
+    useInput((inputStr, key) => {
+        if (!pending)
+            return;
+        const c = inputStr.toLowerCase();
+        if (c === 'y' || c === 'a' || c === 'd' || c === 'n') {
+            const choice = (c === 'y' || c === 'a') ? (c === 'a' ? 'always' : 'allow') : 'deny';
+            bridge.resolve(choice);
+            return;
+        }
+        if (key.return) {
+            bridge.resolve('deny');
+            return;
+        }
+    });
+    if (!pending)
+        return null;
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "double", borderColor: "yellow", paddingX: 1, marginY: 1, children: [_jsxs(Text, { color: "yellow", bold: true, children: ["\u26A0 approval needed \u2014 ", pending.toolName] }), _jsxs(Text, { color: "gray", children: ["  reason: ", pending.reason] }), pending.summary ? _jsxs(Text, { children: ["  ", pending.summary] }) : null, _jsxs(Box, { marginTop: 1, children: [_jsx(Text, { color: "green", children: "[y] allow" }), _jsx(Text, { color: "gray", children: "  " }), _jsx(Text, { color: "green", children: "[a] always allow" }), _jsx(Text, { color: "gray", children: "  " }), _jsx(Text, { color: "red", children: "[d] deny" }), _jsx(Text, { color: "gray", children: "  (Enter = deny)" })] })] }));
+}

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

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

package/dist/tui/approval.test.js

@@ -0,0 +1,93 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { describe, it, expect, vi } from 'vitest';
+import { render } from 'ink-testing-library';
+import { TuiApprovalBridge, ApprovalModal } from './approval.js';
+describe('TuiApprovalBridge', () => {
+    it('returns a pending prompt until resolve() is called', async () => {
+        const bridge = new TuiApprovalBridge();
+        expect(bridge.getPending()).toBeNull();
+        const choicePromise = bridge.ask({ toolName: 'shell_exec', reason: 'risky', summary: 'rm -rf' });
+        const req = bridge.getPending();
+        expect(req?.toolName).toBe('shell_exec');
+        bridge.resolve('deny');
+        await expect(choicePromise).resolves.toBe('deny');
+        expect(bridge.getPending()).toBeNull();
+    });
+    it('resolve() is a no-op when no prompt is pending', () => {
+        const bridge = new TuiApprovalBridge();
+        expect(bridge.resolve('allow')).toBe(false);
+    });
+    it('subscribers are notified on pending change', () => {
+        const bridge = new TuiApprovalBridge();
+        const fn = vi.fn();
+        bridge.subscribe(fn);
+        const promise = bridge.ask({ toolName: 'x', reason: 'r', summary: 's' });
+        expect(fn).toHaveBeenCalledTimes(1);
+        bridge.resolve('allow');
+        expect(fn).toHaveBeenCalledTimes(2);
+        return promise;
+    });
+});
+describe('ApprovalModal', () => {
+    function setup() {
+        const bridge = new TuiApprovalBridge();
+        const { lastFrame, stdin } = render(_jsx(ApprovalModal, { bridge: bridge }));
+        return { bridge, lastFrame, stdin };
+    }
+    it('renders nothing when no prompt is pending', () => {
+        const { lastFrame } = setup();
+        expect(lastFrame()).toBe('');
+    });
+    it('renders the modal when a prompt is pending', async () => {
+        const { lastFrame, bridge } = setup();
+        const promise = bridge.ask({ toolName: 'shell_exec', reason: 'destructive', summary: 'rm -rf /' });
+        await new Promise((r) => setTimeout(r, 5));
+        const out = lastFrame();
+        expect(out).toContain('approval needed');
+        expect(out).toContain('shell_exec');
+        expect(out).toContain('destructive');
+        expect(out).toContain('rm -rf /');
+        expect(out).toContain('allow');
+        expect(out).toContain('deny');
+        bridge.resolve('deny');
+        await promise;
+    });
+    it('"y" resolves to allow', async () => {
+        const { bridge, stdin } = setup();
+        const promise = bridge.ask({ toolName: 'x', reason: 'r', summary: 's' });
+        await new Promise((r) => setTimeout(r, 50));
+        stdin.write('y');
+        await new Promise((r) => setTimeout(r, 50));
+        await expect(promise).resolves.toBe('allow');
+    });
+    it('"a" resolves to always', async () => {
+        const { bridge, stdin } = setup();
+        const promise = bridge.ask({ toolName: 'x', reason: 'r', summary: 's' });
+        await new Promise((r) => setTimeout(r, 50));
+        stdin.write('a');
+        await new Promise((r) => setTimeout(r, 50));
+        await expect(promise).resolves.toBe('always');
+    });
+    it('"n" and "d" resolve to deny', async () => {
+        const { bridge: b1, stdin: s1 } = setup();
+        const p1 = b1.ask({ toolName: 'x', reason: 'r', summary: 's' });
+        await new Promise((r) => setTimeout(r, 50));
+        s1.write('n');
+        await new Promise((r) => setTimeout(r, 50));
+        await expect(p1).resolves.toBe('deny');
+        const { bridge: b2, stdin: s2 } = setup();
+        const p2 = b2.ask({ toolName: 'x', reason: 'r', summary: 's' });
+        await new Promise((r) => setTimeout(r, 50));
+        s2.write('d');
+        await new Promise((r) => setTimeout(r, 50));
+        await expect(p2).resolves.toBe('deny');
+    });
+    it('Enter resolves to deny', async () => {
+        const { bridge, stdin } = setup();
+        const promise = bridge.ask({ toolName: 'x', reason: 'r', summary: 's' });
+        await new Promise((r) => setTimeout(r, 50));
+        stdin.write('\x0d');
+        await new Promise((r) => setTimeout(r, 50));
+        await expect(promise).resolves.toBe('deny');
+    });
+});

package/dist/tui/diff-parser.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Tiny unified-diff parser.
+ *
+ * Handles the subset of `git diff` output that the runtime cares about:
+ *   - `diff --git a/x b/x` headers
+ *   - `+++ b/path` / `--- a/path` path lines
+ *   - `@@ ... @@` hunk headers
+ *   - `+`, `-`, ` ` (context) lines
+ *
+ * Skips:
+ *   - `index ...` lines
+ *   - `Binary files ... differ` lines
+ *   - "no newline at end of file" markers
+ *
+ * Returns one DiffHunk per file. Lines are preserved in order.
+ */
+import type { DiffHunk } from './diff.js';
+export declare function parseUnifiedDiff(raw: string): DiffHunk[];