@phren/agent 0.1.3 → 0.1.5

package/dist/tools/glob.js

@@ -3,12 +3,36 @@ import * as path from "path";
 import { validatePath } from "../permissions/sandbox.js";
 /** Simple glob matching without external dependencies. Supports * and ** patterns. */
 function matchGlob(pattern, filePath) {
-    const regex = pattern
-        .replace(/[.+^${}()|[\]\\]/g, "\\$&")
-        .replace(/\*\*/g, "{{GLOBSTAR}}")
-        .replace(/\*/g, "[^/]*")
-        .replace(/{{GLOBSTAR}}/g, ".*");
-    return new RegExp(`^${regex}$`).test(filePath);
+    // Normalize path separators
+    const p = pattern.replace(/\\/g, "/");
+    const f = filePath.replace(/\\/g, "/");
+    // Build regex: escape special chars, then convert glob tokens
+    let regex = "";
+    let i = 0;
+    while (i < p.length) {
+        if (p[i] === "*" && p[i + 1] === "*") {
+            // ** matches any depth of directories
+            regex += ".*";
+            i += 2;
+            if (p[i] === "/")
+                i++; // skip trailing /
+        }
+        else if (p[i] === "*") {
+            // * matches anything except /
+            regex += "[^/]*";
+            i++;
+        }
+        else if (p[i] === "?") {
+            regex += "[^/]";
+            i++;
+        }
+        else {
+            // Escape regex special chars
+            regex += p[i].replace(/[.+^${}()|[\]\\]/g, "\\$&");
+            i++;
+        }
+    }
+    return new RegExp(`^${regex}$`).test(f);
 }
 function walkDir(dir, base, results, maxResults) {
     if (results.length >= maxResults)

package/dist/tui/ansi.js

@@ -0,0 +1,48 @@
+// ── ANSI helpers ─────────────────────────────────────────────────────────────
+export const ESC = "\x1b[";
+export const s = {
+    reset: `${ESC}0m`,
+    bold: (t) => `${ESC}1m${t}${ESC}0m`,
+    dim: (t) => `${ESC}2m${t}${ESC}0m`,
+    italic: (t) => `${ESC}3m${t}${ESC}0m`,
+    cyan: (t) => `${ESC}36m${t}${ESC}0m`,
+    green: (t) => `${ESC}32m${t}${ESC}0m`,
+    yellow: (t) => `${ESC}33m${t}${ESC}0m`,
+    red: (t) => `${ESC}31m${t}${ESC}0m`,
+    blue: (t) => `${ESC}34m${t}${ESC}0m`,
+    magenta: (t) => `${ESC}35m${t}${ESC}0m`,
+    gray: (t) => `${ESC}90m${t}${ESC}0m`,
+    invert: (t) => `${ESC}7m${t}${ESC}0m`,
+    // Gradient-style brand text
+    brand: (t) => `${ESC}1;35m${t}${ESC}0m`,
+};
+export function cols() {
+    return process.stdout.columns || 80;
+}
+export function stripAnsi(t) {
+    return t.replace(/\x1b\[[0-9;?]*[ -/]*[@-~]/g, "");
+}
+// ── Permission mode helpers ─────────────────────────────────────────────────
+export const PERMISSION_MODES = ["suggest", "auto-confirm", "full-auto"];
+export function nextPermissionMode(current) {
+    const idx = PERMISSION_MODES.indexOf(current);
+    return PERMISSION_MODES[(idx + 1) % PERMISSION_MODES.length];
+}
+export const PERMISSION_LABELS = {
+    "suggest": "suggest",
+    "auto-confirm": "auto",
+    "full-auto": "full-auto",
+};
+export const PERMISSION_ICONS = {
+    "suggest": "○",
+    "auto-confirm": "◐",
+    "full-auto": "●",
+};
+export const PERMISSION_COLORS = {
+    "suggest": s.cyan,
+    "auto-confirm": s.green,
+    "full-auto": s.yellow,
+};
+export function permTag(mode) {
+    return PERMISSION_COLORS[mode](`${PERMISSION_ICONS[mode]} ${mode}`);
+}

package/dist/tui/components/AgentMessage.js

@@ -0,0 +1,5 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+export function AgentMessage({ text }) {
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { color: "magenta", children: ["◆", " ", _jsx(Text, { children: text })] }), _jsx(Text, { children: "" })] }));
+}

package/dist/tui/components/App.js

@@ -0,0 +1,68 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useState, useCallback } from "react";
+import { Static, Box, Text, useApp } from "ink";
+import { Banner } from "./Banner.js";
+import { ToolCall } from "./ToolCall.js";
+import { ThinkingIndicator } from "./ThinkingIndicator.js";
+import { SteerQueue } from "./SteerQueue.js";
+import { InputArea, PermissionsLine } from "./InputArea.js";
+import { useKeyboardShortcuts } from "../hooks/useKeyboardShortcuts.js";
+export function App({ state, completedMessages, streamingText, completedToolCalls, thinking, thinkStartTime, thinkElapsed, steerQueue, running, showBanner, inputHistory, onSubmit, onPermissionCycle, onCancelTurn, onExit, }) {
+    const { exit } = useApp();
+    const [inputValue, setInputValue] = useState("");
+    const [bashMode, setBashMode] = useState(false);
+    const [historyIndex, setHistoryIndex] = useState(-1);
+    const [ctrlCCount, setCtrlCCount] = useState(0);
+    const handleSubmit = useCallback((value) => {
+        setInputValue("");
+        setHistoryIndex(-1);
+        if (value === "")
+            return;
+        // ! at start of empty input toggles bash mode
+        if (value === "!" && !bashMode) {
+            setBashMode(true);
+            return;
+        }
+        onSubmit(bashMode ? `!${value}` : value);
+        setBashMode(false);
+    }, [bashMode, onSubmit]);
+    useKeyboardShortcuts({
+        isRunning: running,
+        inputValue,
+        bashMode,
+        inputHistory,
+        historyIndex,
+        ctrlCCount,
+        onSetInput: setInputValue,
+        onSetBashMode: setBashMode,
+        onSetHistoryIndex: setHistoryIndex,
+        onSetCtrlCCount: setCtrlCCount,
+        onExit: () => { onExit(); exit(); },
+        onCyclePermissions: onPermissionCycle,
+        onCancelTurn,
+    });
+    // Build Static items — banner first, then completed messages
+    const staticItems = [];
+    if (showBanner) {
+        staticItems.push({ id: "banner", kind: "banner" });
+    }
+    for (const msg of completedMessages) {
+        staticItems.push(msg);
+    }
+    return (_jsxs(_Fragment, { children: [_jsx(Static, { items: staticItems, children: (item) => {
+                    if (item.kind === "banner") {
+                        return (_jsx(Box, { flexDirection: "column", children: _jsx(Banner, { version: state.version }) }, "banner"));
+                    }
+                    if (item.kind === "user") {
+                        return (_jsx(Box, { flexDirection: "column", marginTop: 1, children: _jsxs(Text, { bold: true, children: ["\u276f", " ", item.text] }) }, item.id));
+                    }
+                    if (item.kind === "assistant") {
+                        const aMsg = item;
+                        return (_jsxs(Box, { flexDirection: "column", marginTop: 1, paddingLeft: 2, children: [aMsg.text ? (_jsxs(Box, { children: [_jsxs(Text, { color: "magenta", children: ["\u25c6", " "] }), _jsx(Text, { children: aMsg.text })] })) : null, aMsg.toolCalls?.map((tc, i) => (_jsx(ToolCall, { ...tc }, i)))] }, item.id));
+                    }
+                    if (item.kind === "status") {
+                        return _jsx(Text, { dimColor: true, children: item.text }, item.id);
+                    }
+                    return null;
+                } }), _jsxs(Box, { flexDirection: "column", children: [completedToolCalls.map((tc, i) => (_jsx(ToolCall, { ...tc }, `tc-${i}`))), streamingText !== "" && (_jsxs(Box, { paddingLeft: 2, children: [_jsxs(Text, { color: "magenta", children: ["\u25c6", " "] }), _jsx(Text, { children: streamingText })] })), thinking && _jsx(ThinkingIndicator, { startTime: thinkStartTime }), thinkElapsed !== null && (_jsxs(Text, { dimColor: true, children: ["  ", "\u25c6", " thought for ", thinkElapsed, "s"] })), ctrlCCount > 0 && !running && (_jsxs(Text, { dimColor: true, children: ["  ", "Press Ctrl+C again to exit."] })), _jsx(SteerQueue, { items: steerQueue }), _jsx(InputArea, { value: inputValue, onChange: setInputValue, onSubmit: handleSubmit, bashMode: bashMode, focus: !running }), _jsx(PermissionsLine, { mode: state.permMode })] })] }));
+}

package/dist/tui/components/Banner.js

@@ -0,0 +1,44 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import * as os from "os";
+import { createRequire } from "module";
+const _require = createRequire(import.meta.url);
+let cachedArt = null;
+let artLoaded = false;
+function getArtLines() {
+    if (artLoaded)
+        return cachedArt ?? [];
+    artLoaded = true;
+    try {
+        const mod = _require("@phren/cli/phren-art");
+        cachedArt = mod.PHREN_ART.filter((l) => l.trim());
+        return cachedArt;
+    }
+    catch {
+        return [];
+    }
+}
+function stripAnsi(t) {
+    return t.replace(/\x1b\[[0-9;?]*[ -/]*[@-~]/g, "");
+}
+export function Banner({ version }) {
+    const cwd = process.cwd().replace(os.homedir(), "~");
+    const artLines = getArtLines();
+    const maxArtWidth = 26;
+    const infoLines = [
+        { key: "title", node: _jsx(Text, { bold: true, color: "magenta", children: "◆ phren" }) },
+        { key: "version", node: _jsx(Text, { dimColor: true, children: "  v" + version }) },
+        { key: "cwd", node: _jsx(Text, { dimColor: true, children: cwd }) },
+    ];
+    if (artLines.length > 0) {
+        const rowCount = Math.max(artLines.length, infoLines.length);
+        return (_jsxs(Box, { flexDirection: "column", children: [Array.from({ length: rowCount }, (_, i) => {
+                    const artLine = i < artLines.length ? artLines[i] : "";
+                    const artVisible = stripAnsi(artLine).length;
+                    const padding = Math.max(0, maxArtWidth - artVisible);
+                    const info = i < infoLines.length ? infoLines[i] : null;
+                    return (_jsxs(Box, { flexDirection: "row", children: [_jsx(Text, { children: artLine + " ".repeat(padding) }), info ? info.node : _jsx(Text, { children: "" })] }, i));
+                }), _jsx(Text, { children: "" })] }));
+    }
+    return (_jsxs(Box, { flexDirection: "column", paddingLeft: 2, children: [_jsxs(Box, { children: [infoLines[0].node, infoLines[1].node] }), infoLines[2].node, _jsx(Text, { children: "" })] }));
+}

package/dist/tui/components/ChatMessage.js

@@ -0,0 +1,23 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { formatToolInput, formatDuration } from "../tool-render.js";
+const COMPACT_LINES = 3;
+export function ChatMessage({ role, text, toolCalls }) {
+    if (role === "user") {
+        return (_jsxs(Box, { flexDirection: "column", marginBottom: 0, children: [_jsx(Text, { bold: true, children: "You: " }), _jsx(Text, { children: text })] }));
+    }
+    if (role === "system") {
+        return (_jsx(Box, { marginBottom: 0, children: _jsx(Text, { dimColor: true, children: text }) }));
+    }
+    return (_jsxs(Box, { flexDirection: "column", marginBottom: 0, children: [_jsx(Text, { children: text }), toolCalls?.map((tc, i) => (_jsx(ToolCallLine, { ...tc }, i)))] }));
+}
+function ToolCallLine({ name, input, output, isError, durationMs }) {
+    const preview = formatToolInput(name, input);
+    const dur = formatDuration(durationMs);
+    const icon = isError ? "✗" : "→";
+    const iconColor = isError ? "red" : "green";
+    const allLines = output.split("\n").filter(Boolean);
+    const shown = allLines.slice(0, COMPACT_LINES);
+    const overflow = allLines.length - COMPACT_LINES;
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { children: ["  ", _jsx(Text, { color: iconColor, children: icon }), " ", _jsx(Text, { bold: true, children: name }), " ", _jsx(Text, { color: "gray", children: preview }), "  ", _jsx(Text, { dimColor: true, children: dur })] }), shown.map((line, j) => (_jsxs(Text, { dimColor: true, children: ["    ", line.slice(0, (process.stdout.columns || 80) - 6)] }, j))), overflow > 0 && _jsxs(Text, { dimColor: true, children: ["    ", "... +", overflow, " lines"] })] }));
+}

package/dist/tui/components/InputArea.js

@@ -0,0 +1,23 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text, useStdout } from "ink";
+import TextInput from "ink-text-input";
+import { PERMISSION_LABELS, PERMISSION_ICONS } from "../ansi.js";
+export function InputArea({ value, onChange, onSubmit, bashMode, focus }) {
+    const { stdout } = useStdout();
+    const columns = stdout?.columns || 80;
+    const sep = "\u2500".repeat(columns);
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { dimColor: true, children: sep }), _jsxs(Box, { children: [bashMode
+                        ? _jsx(Text, { color: "yellow", children: "! " })
+                        : _jsxs(Text, { dimColor: true, children: ["\u25b8", " "] }), _jsx(TextInput, { value: value, onChange: onChange, onSubmit: onSubmit, focus: focus, showCursor: true })] }), _jsx(Text, { dimColor: true, children: sep })] }));
+}
+const PERM_COLOR_MAP = {
+    "suggest": "cyan",
+    "auto-confirm": "green",
+    "full-auto": "yellow",
+};
+export function PermissionsLine({ mode }) {
+    const icon = PERMISSION_ICONS[mode];
+    const label = PERMISSION_LABELS[mode];
+    const color = PERM_COLOR_MAP[mode];
+    return (_jsxs(Text, { children: ["  ", _jsxs(Text, { color: color, children: [icon, " ", label, " permissions"] }), " ", _jsxs(Text, { dimColor: true, children: ["(shift+tab toggle ", "\u00b7", " esc to interrupt)"] })] }));
+}

package/dist/tui/components/Separator.js

@@ -0,0 +1,7 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Text, useStdout } from "ink";
+export function Separator() {
+    const { stdout } = useStdout();
+    const columns = stdout?.columns || 80;
+    return _jsx(Text, { dimColor: true, children: "\u2500".repeat(columns) });
+}

package/dist/tui/components/StatusBar.js

@@ -0,0 +1,25 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Text, useStdout } from "ink";
+import { PERMISSION_LABELS } from "../ansi.js";
+export function StatusBar({ provider, project, turns, cost, permMode, agentCount }) {
+    const { stdout } = useStdout();
+    const width = stdout?.columns || 80;
+    const modeLabel = permMode ? PERMISSION_LABELS[permMode] : "";
+    const agentTag = agentCount && agentCount > 0 ? `A${agentCount}` : "";
+    const leftParts = [" \u25c6 phren", provider];
+    if (project)
+        leftParts.push(project);
+    const left = leftParts.join(" \u00b7 ");
+    const rightParts = [];
+    if (modeLabel)
+        rightParts.push(modeLabel);
+    if (agentTag)
+        rightParts.push(agentTag);
+    if (cost)
+        rightParts.push(cost);
+    rightParts.push(`T${turns}`);
+    const right = rightParts.join("  ") + " ";
+    const pad = Math.max(0, width - left.length - right.length);
+    const fullLine = left + " ".repeat(pad) + right;
+    return _jsx(Text, { inverse: true, children: fullLine });
+}

package/dist/tui/components/SteerQueue.js

@@ -0,0 +1,7 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+export function SteerQueue({ items }) {
+    if (items.length === 0)
+        return null;
+    return (_jsx(Box, { flexDirection: "column", children: items.map((item, i) => (_jsxs(Text, { color: "yellow", children: ["  ", "\u21B3 steer: ", item.slice(0, 60)] }, i))) }));
+}

package/dist/tui/components/StreamingText.js

@@ -0,0 +1,5 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Text } from "ink";
+export function StreamingText({ text }) {
+    return _jsx(Text, { children: text });
+}

package/dist/tui/components/ThinkingIndicator.js

@@ -0,0 +1,26 @@
+import { jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useEffect, useMemo } from "react";
+import { Text } from "ink";
+// Phren's own thinking verbs — memory-oriented, not generic
+const THINKING_VERBS = [
+    "thinking", "reasoning", "recalling", "connecting", "processing",
+];
+export function ThinkingIndicator({ startTime }) {
+    const [frame, setFrame] = useState(0);
+    // Pick a random verb once per mount
+    const verb = useMemo(() => THINKING_VERBS[Math.floor(Math.random() * THINKING_VERBS.length)], []);
+    useEffect(() => {
+        const timer = setInterval(() => {
+            setFrame((f) => f + 1);
+        }, 50);
+        return () => clearInterval(timer);
+    }, []);
+    const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
+    // Gentle sine-wave interpolation between phren purple and cyan
+    const t = (Math.sin(frame * 0.08) + 1) / 2;
+    const r = Math.round(155 * (1 - t) + 40 * t);
+    const g = Math.round(140 * (1 - t) + 211 * t);
+    const b = Math.round(250 * (1 - t) + 242 * t);
+    const hex = `#${r.toString(16).padStart(2, "0")}${g.toString(16).padStart(2, "0")}${b.toString(16).padStart(2, "0")}`;
+    return (_jsxs(Text, { children: ["  ", _jsxs(Text, { color: hex, children: ["\u25c6", " ", verb] }), " ", _jsxs(Text, { dimColor: true, children: [elapsed, "s"] })] }));
+}

package/dist/tui/components/ToolCall.js

@@ -0,0 +1,11 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { formatToolInput, formatDuration, COMPACT_LINES } from "../tool-render.js";
+export function ToolCall({ name, input, output, isError, durationMs }) {
+    const preview = formatToolInput(name, input);
+    const dur = formatDuration(durationMs);
+    const allLines = output.split("\n").filter(Boolean);
+    const shown = allLines.slice(0, COMPACT_LINES);
+    const overflow = allLines.length - COMPACT_LINES;
+    return (_jsxs(Box, { flexDirection: "column", paddingLeft: 2, children: [_jsxs(Box, { children: [_jsxs(Text, { color: isError ? "red" : "green", children: [isError ? "\u2717" : "\u2192", " "] }), _jsx(Text, { bold: true, children: name }), _jsxs(Text, { color: "gray", children: [" ", preview] }), _jsxs(Text, { dimColor: true, children: ["  ", dur] })] }), shown.map((line, i) => (_jsx(Text, { dimColor: true, children: "    " + line.slice(0, 120) }, i))), overflow > 0 && (_jsx(Text, { dimColor: true, children: "    ... +" + overflow + " lines" }))] }));
+}

package/dist/tui/components/UserMessage.js

@@ -0,0 +1,5 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+export function UserMessage({ text }) {
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { bold: true, children: ["❯", " ", text] }), _jsx(Text, { children: "" })] }));
+}

package/dist/tui/hooks/useKeyboardShortcuts.js

@@ -0,0 +1,89 @@
+import { useInput } from "ink";
+const SLASH_COMMANDS = [
+    "/help", "/turns", "/clear", "/cwd", "/files", "/cost", "/plan", "/undo",
+    "/context", "/model", "/provider", "/preset", "/session", "/history",
+    "/compact", "/diff", "/git", "/mem", "/ask", "/spawn", "/agents",
+    "/mode", "/exit", "/quit",
+];
+export function useKeyboardShortcuts(opts) {
+    useInput((input, key) => {
+        // Reset Ctrl+C count on any non-Ctrl+C keypress
+        if (!(input === "c" && key.ctrl)) {
+            if (opts.ctrlCCount > 0)
+                opts.onSetCtrlCCount(0);
+        }
+        // Ctrl+D -- exit cleanly
+        if (key.ctrl && input === "d") {
+            opts.onExit();
+            return;
+        }
+        // Shift+Tab -- cycle permission mode
+        if (key.shift && key.tab) {
+            opts.onCyclePermissions();
+            return;
+        }
+        // Ctrl+C -- progressive: cancel turn / clear input / warn / quit
+        if (key.ctrl && input === "c") {
+            if (opts.isRunning) {
+                opts.onCancelTurn();
+                return;
+            }
+            if (opts.inputValue) {
+                opts.onSetInput("");
+                opts.onSetCtrlCCount(0);
+                return;
+            }
+            if (opts.ctrlCCount >= 1) {
+                opts.onExit();
+                return;
+            }
+            opts.onSetCtrlCCount(opts.ctrlCCount + 1);
+            return;
+        }
+        // Escape -- exit bash mode or clear input
+        if (key.escape) {
+            if (opts.bashMode) {
+                opts.onSetBashMode(false);
+                opts.onSetInput("");
+            }
+            else if (opts.inputValue) {
+                opts.onSetInput("");
+            }
+            return;
+        }
+        // Up arrow -- recall older history
+        if (key.upArrow && !opts.isRunning) {
+            const history = opts.inputHistory;
+            if (history.length === 0)
+                return;
+            const newIndex = Math.min(opts.historyIndex + 1, history.length - 1);
+            opts.onSetHistoryIndex(newIndex);
+            opts.onSetInput(history[history.length - 1 - newIndex]);
+            return;
+        }
+        // Down arrow -- recall newer history
+        if (key.downArrow && !opts.isRunning) {
+            const history = opts.inputHistory;
+            if (opts.historyIndex <= 0) {
+                opts.onSetHistoryIndex(-1);
+                opts.onSetInput("");
+                return;
+            }
+            const newIndex = opts.historyIndex - 1;
+            opts.onSetHistoryIndex(newIndex);
+            opts.onSetInput(history[history.length - 1 - newIndex]);
+            return;
+        }
+        // Tab -- slash command completion when input starts with /
+        if (key.tab && !key.shift && !opts.isRunning) {
+            const val = opts.inputValue;
+            if (val.startsWith("/") && val.length > 1) {
+                const matches = SLASH_COMMANDS.filter(c => c.startsWith(val));
+                if (matches.length === 1) {
+                    opts.onSetInput(matches[0]);
+                }
+            }
+            return;
+        }
+    });
+}

package/dist/tui/hooks/useSlashCommands.js

@@ -0,0 +1,52 @@
+/**
+ * Slash command handling for the Ink TUI.
+ * Captures stderr output from handleCommand and returns it as display text.
+ */
+import { handleCommand } from "../../commands.js";
+export function useSlashCommands(opts) {
+    return {
+        /** Try to handle input as a slash command. Returns true if handled. */
+        tryHandleCommand(input) {
+            if (!input.startsWith("/"))
+                return false;
+            // Capture stderr writes during command execution
+            const captured = [];
+            const origWrite = process.stderr.write;
+            process.stderr.write = ((chunk) => {
+                captured.push(typeof chunk === "string" ? chunk : Buffer.from(chunk).toString());
+                return true;
+            });
+            try {
+                const result = handleCommand(input, opts.commandContext);
+                if (result instanceof Promise) {
+                    // Async command — restore stderr, then capture async output
+                    process.stderr.write = origWrite;
+                    result.then(() => {
+                        // For async commands, stderr was already restored so output went to real stderr.
+                        // Future improvement: capture async output too.
+                    });
+                    flush();
+                    return true;
+                }
+                if (result === true) {
+                    flush();
+                    return true;
+                }
+                // Not a recognized command (result === false)
+                flush();
+                return true; // Still starts with /, so don't send to agent
+            }
+            finally {
+                process.stderr.write = origWrite;
+            }
+            function flush() {
+                if (captured.length > 0) {
+                    // Strip ANSI dim/reset codes for cleaner display in Ink
+                    const text = captured.join("").replace(/\n$/, "");
+                    if (text)
+                        opts.onOutput(text);
+                }
+            }
+        },
+    };
+}

package/dist/tui/index.js

@@ -0,0 +1,5 @@
+export { ESC, s, cols, stripAnsi } from "./ansi.js";
+export { PERMISSION_MODES, nextPermissionMode, PERMISSION_LABELS, PERMISSION_ICONS, PERMISSION_COLORS, permTag } from "./ansi.js";
+export { COMPACT_LINES, formatDuration, formatToolInput, renderToolCall } from "./tool-render.js";
+export { loadMenuModule, renderMenu, enterMenuMode, exitMenuMode, handleMenuKeypress } from "./menu-mode.js";
+export { startInkTui } from "./ink-entry.js";