min-agent 0.2.0 → 0.3.0

package/dist/tui/index.js

@@ -1,6 +1,7 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { render } from "ink";
 import { App } from "./App.js";
+import { createCaretAwareStdout, setCaretPosition } from "./caret.js";
 /**
  * TUI renderer — manages the Ink app lifecycle and provides
  * imperative methods to update state from the agent loop.
@@ -10,6 +11,11 @@ export class TuiRenderer {
     rerender = null;
     inkInstance = null;
     callbacks;
+    pendingDelta = "";
+    deltaTimer = null;
+    pendingThinking = "";
+    thinkingTimer = null;
+    copyNoticeTimer = null;
     constructor(callbacks, model) {
         this.state = {
             messages: [],
@@ -19,63 +25,142 @@ export class TuiRenderer {
         this.callbacks = callbacks;
     }
     start() {
-        this.inkInstance = render(_jsx(App, { initialState: this.state, onSubmit: this.callbacks.onSubmit, onConfirm: this.callbacks.onConfirm, onExit: this.callbacks.onExit }), { exitOnCtrlC: false });
-        // Position cursor at bottom-left for IME
-        const rows = process.stdout.rows ?? 24;
-        process.stdout.write(`\x1b[${rows};3H`);
+        this.inkInstance = render(_jsx(App, { initialState: this.state, onSubmit: this.callbacks.onSubmit, onConfirm: this.callbacks.onConfirm, onQuestionAnswer: this.callbacks.onQuestionAnswer, onModelPick: this.callbacks.onModelPick, onModelCancel: this.callbacks.onModelCancel, onExit: this.callbacks.onExit, onCopyNotice: (text) => this.showCopyNotice(text) }), { exitOnCtrlC: false, stdout: createCaretAwareStdout(process.stdout) });
     }
-    /** Update state and trigger re-render */
+    /** Update state and trigger re-render — always replaces the reference so React sees a new prop. */
     update(partial) {
-        Object.assign(this.state, partial);
-        // Ink re-renders automatically when we call render again
+        this.state = { ...this.state, ...partial };
         if (this.inkInstance) {
-            this.inkInstance.rerender(_jsx(App, { initialState: this.state, onSubmit: this.callbacks.onSubmit, onConfirm: this.callbacks.onConfirm, onExit: this.callbacks.onExit }));
-            // Move terminal cursor to bottom-left (input bar area) for IME positioning
-            const rows = process.stdout.rows ?? 24;
-            process.stdout.write(`\x1b[${rows};3H`);
+            this.inkInstance.rerender(_jsx(App, { initialState: this.state, onSubmit: this.callbacks.onSubmit, onConfirm: this.callbacks.onConfirm, onQuestionAnswer: this.callbacks.onQuestionAnswer, onModelPick: this.callbacks.onModelPick, onModelCancel: this.callbacks.onModelCancel, onExit: this.callbacks.onExit, onCopyNotice: (text) => this.showCopyNotice(text) }));
         }
     }
     addMessage(msg) {
+        this.flushPendingDeltas();
+        this.flushPendingThinking();
         this.state.messages = [...this.state.messages, msg];
         this.update({});
     }
-    /** Append text to the last assistant message (for streaming) */
+    /** Number of messages currently rendered (used by /undo). */
+    messageCount() {
+        return this.state.messages.length;
+    }
+    /**
+     * Attach a tool result to the row created by the matching tool call. Falls
+     * back to the newest still-pending row of the same tool when the id is
+     * unknown (e.g. a provider that does not echo it back).
+     */
+    setToolResult(toolCallId, toolName, summary, full, isError) {
+        const msgs = [...this.state.messages];
+        let idx = msgs.findIndex((m) => m.role === "tool" && m.toolCallId === toolCallId);
+        if (idx === -1) {
+            for (let i = msgs.length - 1; i >= 0; i--) {
+                const m = msgs[i];
+                if (m.role === "tool" && m.toolName === toolName && m.toolResult === undefined) {
+                    idx = i;
+                    break;
+                }
+            }
+        }
+        if (idx === -1)
+            return;
+        msgs[idx] = { ...msgs[idx], toolResultSummary: summary, toolResult: full, toolIsError: isError };
+        this.state.messages = msgs;
+        this.update({});
+    }
+    /** Keep only the first `count` messages (used by /undo). */
+    truncateMessages(count) {
+        this.state.messages = this.state.messages.slice(0, count);
+        this.update({});
+    }
+    /**
+     * Append text to the last assistant message (for streaming).
+     * Deltas are coalesced (50ms) so a burst of stream tokens renders as a
+     * handful of frames instead of one per token; flushed when the run ends.
+     */
     appendToLast(delta) {
+        this.pendingDelta += delta;
+        if (this.deltaTimer !== null)
+            return;
+        this.deltaTimer = setTimeout(() => {
+            this.deltaTimer = null;
+            this.applyPendingDelta();
+        }, 16);
+    }
+    appendToThinking(delta) {
+        this.pendingThinking += delta;
+        if (this.thinkingTimer !== null)
+            return;
+        this.thinkingTimer = setTimeout(() => {
+            this.thinkingTimer = null;
+            this.applyPendingThinking();
+        }, 16);
+    }
+    applyPendingThinking() {
+        const accumulated = this.pendingThinking;
+        this.pendingThinking = "";
+        if (!accumulated)
+            return;
         const msgs = [...this.state.messages];
         const last = msgs[msgs.length - 1];
-        if (last && last.role === "assistant") {
-            last.content += delta;
+        if (last && last.role === "thinking") {
+            msgs[msgs.length - 1] = { ...last, content: last.content + accumulated };
             this.state.messages = msgs;
             this.update({});
         }
         else {
             this.addMessage({
-                id: `msg-${Date.now()}`,
-                role: "assistant",
-                content: delta,
+                id: `thinking-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
+                role: "thinking",
+                content: accumulated,
                 timestamp: Date.now(),
             });
         }
     }
-    /** Append text to the current thinking message (for streaming thinking) */
-    appendToThinking(delta) {
+    flushPendingThinking() {
+        if (this.thinkingTimer !== null) {
+            clearTimeout(this.thinkingTimer);
+            this.thinkingTimer = null;
+        }
+        this.applyPendingThinking();
+    }
+    applyPendingDelta() {
+        const accumulated = this.pendingDelta;
+        this.pendingDelta = "";
+        if (!accumulated)
+            return;
+        if (accumulated.trim() === "")
+            return;
         const msgs = [...this.state.messages];
         const last = msgs[msgs.length - 1];
-        if (last && last.role === "thinking") {
-            last.content += delta;
+        if (last && last.role === "assistant") {
+            msgs[msgs.length - 1] = { ...last, content: last.content + accumulated };
             this.state.messages = msgs;
             this.update({});
         }
         else {
             this.addMessage({
-                id: `thinking-${Date.now()}`,
-                role: "thinking",
-                content: delta,
+                id: `msg-${Date.now()}`,
+                role: "assistant",
+                content: accumulated,
                 timestamp: Date.now(),
             });
         }
     }
+    /** Apply any coalesced delta immediately (run end, new message, exit). */
+    flushPendingDeltas() {
+        if (this.deltaTimer !== null) {
+            clearTimeout(this.deltaTimer);
+            this.deltaTimer = null;
+        }
+        this.applyPendingDelta();
+    }
     setRunning(running, spinnerText) {
+        if (!running) {
+            this.flushPendingDeltas();
+            this.flushPendingThinking();
+        }
+        if (this.state.isRunning === running && this.state.spinnerText === spinnerText)
+            return;
         this.update({ isRunning: running, spinnerText });
     }
     showConfirm(message) {
@@ -84,10 +169,54 @@ export class TuiRenderer {
     hideConfirm() {
         this.update({ confirmMessage: undefined });
     }
+    showQuestion(prompt, options) {
+        this.update({ question: { prompt, options } });
+    }
+    hideQuestion() {
+        this.update({ question: undefined });
+    }
+    showModelPicker() {
+        this.update({ modelPicker: true });
+    }
+    hideModelPicker() {
+        this.update({ modelPicker: false });
+    }
+    setModel(model) {
+        this.update({ model });
+    }
     setTokenInfo(input, output, contextWindow) {
         this.update({ tokenInfo: { input, output, contextWindow } });
     }
+    /** Flash a transient copy confirmation in the status bar (2.5s). */
+    showCopyNotice(text) {
+        this.update({ copyNotice: text });
+        if (this.copyNoticeTimer !== null)
+            clearTimeout(this.copyNoticeTimer);
+        this.copyNoticeTimer = setTimeout(() => {
+            this.copyNoticeTimer = null;
+            this.update({ copyNotice: undefined });
+        }, 2500);
+    }
     destroy() {
+        this.flushPendingDeltas();
+        this.flushPendingThinking();
+        if (this.copyNoticeTimer !== null) {
+            clearTimeout(this.copyNoticeTimer);
+            this.copyNoticeTimer = null;
+        }
+        if (this.deltaTimer !== null) {
+            clearTimeout(this.deltaTimer);
+            this.deltaTimer = null;
+        }
+        if (this.thinkingTimer !== null) {
+            clearTimeout(this.thinkingTimer);
+            this.thinkingTimer = null;
+        }
+        setCaretPosition(null);
+        try {
+            process.stdout.write("\x1b[?1000l\x1b[?1002l\x1b[?1006l");
+        }
+        catch { }
         this.inkInstance?.unmount();
         this.inkInstance = null;
     }

package/dist/tui/input-history.js

@@ -0,0 +1,44 @@
+export function createHistory() {
+    return { entries: [], index: -1, draft: "" };
+}
+const HISTORY_LIMIT = 500;
+export function pushInput(state, text) {
+    if (!text)
+        return state;
+    if (state.entries.length > 0 && state.entries[state.entries.length - 1] === text)
+        return state;
+    const entries = [...state.entries, text];
+    if (entries.length > HISTORY_LIMIT)
+        entries.splice(0, entries.length - HISTORY_LIMIT);
+    return { entries, index: -1, draft: "" };
+}
+export function searchHistory(state, query) {
+    const q = query.toLowerCase();
+    if (!q)
+        return null;
+    for (let i = state.entries.length - 1; i >= 0; i--) {
+        if (state.entries[i].toLowerCase().includes(q))
+            return state.entries[i];
+    }
+    return null;
+}
+export function browseHistory(state, direction) {
+    const count = state.entries.length;
+    if (count === 0)
+        return { text: state.draft, state };
+    if (direction === 1) {
+        const index = state.index === -1 ? count - 1 : Math.max(0, Math.min(count - 1, state.index - 1));
+        return { text: state.entries[index], state: { ...state, index } };
+    }
+    if (state.index === -1)
+        return { text: state.draft, state };
+    if (state.index >= count - 1)
+        return { text: state.draft, state: { ...state, index: -1 } };
+    const index = state.index + 1;
+    return { text: state.entries[index], state: { ...state, index } };
+}
+export function resetHistory(state, text) {
+    if (state.index === -1 && state.draft === text)
+        return state;
+    return { entries: state.entries, index: -1, draft: text };
+}

package/dist/tui/layout.js

@@ -0,0 +1,17 @@
+export const BOX_CHROME = 4;
+export const GUTTER_WIDTH = 2;
+export const TEXT_START_COLUMN = 5;
+export const STATUS_BAR_ROWS = 2;
+export const SAFETY_MARGIN = 2;
+export const INPUT_BAR_ROWS = 3;
+export function innerTextWidth(columns) {
+    return Math.max(1, columns - 5);
+}
+export function inputTextWidth(columns) {
+    return Math.max(8, columns - BOX_CHROME - GUTTER_WIDTH);
+}
+export function computeMessageMaxHeight(terminalRows, footerRows, spinnerRows) {
+    if (terminalRows <= 0)
+        return undefined;
+    return Math.max(2, terminalRows - footerRows - STATUS_BAR_ROWS - spinnerRows - SAFETY_MARGIN);
+}

package/dist/tui/mouse.js

@@ -0,0 +1,46 @@
+/**
+ * Enable button-event tracking (1000), drag motion while a button is held
+ * (1002) with SGR coordinates (1006). 1002 reports press/release plus motion
+ * events while dragging, which the message list uses for text selection.
+ */
+export const MOUSE_ENABLE = "\x1b[?1000h\x1b[?1002h\x1b[?1006h";
+/** Disable button-event tracking. */
+export const MOUSE_DISABLE = "\x1b[?1000l\x1b[?1002l\x1b[?1006l";
+const SGR_RE = /\x1b\[<(\d+);(\d+);(\d+)([Mm])/;
+export function parseSgrMouse(input) {
+    const match = input.match(SGR_RE);
+    if (!match)
+        return null;
+    return {
+        button: parseInt(match[1], 10),
+        col: parseInt(match[2], 10),
+        row: parseInt(match[3], 10),
+        press: match[4] === "M",
+    };
+}
+/** Wheel-up / wheel-down button codes in xterm button-event tracking (1000/1006). */
+export const WHEEL_UP = 64;
+export const WHEEL_DOWN = 65;
+/** Motion events (drag) add this to the button code (SGR, mode 1002/1003). */
+export const MOTION = 32;
+/** Modifier flags share the button code's low bits; Shift=4, Meta=8, Ctrl=16. Keep Ctrl so drag isn't mis-classified as "plain". */
+export const MOD_MASK = 31;
+/**
+ * Parse the first complete SGR mouse event in a raw stdin buffer, returning
+ * the event and the buffer remainder so the caller can process a stream of
+ * events without re-reading consumed bytes.
+ */
+export function scanSgrMouse(buffer) {
+    const match = buffer.match(SGR_RE);
+    if (!match)
+        return null;
+    return {
+        event: {
+            button: parseInt(match[1], 10),
+            col: parseInt(match[2], 10),
+            row: parseInt(match[3], 10),
+            press: match[4] === "M",
+        },
+        rest: buffer.slice((match.index ?? 0) + match[0].length),
+    };
+}

package/dist/tui/selection.js

@@ -0,0 +1,134 @@
+import { charWidth, displayWidth } from "./text-width.js";
+const RESET = "\x1b[0m";
+const INVERSE_ON = "\x1b[7m";
+const INVERSE_OFF = "\x1b[27m";
+/** Remove SGR color/style codes from a rendered line. */
+export function stripAnsi(line) {
+    return line.replace(/\x1b\[[0-9;]*m/g, "");
+}
+/**
+ * Wrap the cells in [start, end) with inverse video, preserving any styles
+ * already active. A style reset inside the selection would cancel the
+ * highlight, so a fresh INVERSE_ON is re-emitted after it; the closing
+ * INVERSE_OFF restores the caller's original attribute state.
+ */
+export function applySelection(line, start, end) {
+    if (end <= start)
+        return line;
+    let out = "";
+    let col = 0;
+    let inSel = false;
+    for (const token of line.split(/(\x1b\[[0-9;]*m)/g)) {
+        if (token.startsWith("\x1b[")) {
+            // A reset inside the selection would cancel the highlight, so it is
+            // re-applied right after; a reset at/after the selection end closes the
+            // highlight first, keeping the boundary between the two styles.
+            if (inSel && token === RESET) {
+                if (col < end)
+                    out += token + INVERSE_ON;
+                else {
+                    out += INVERSE_OFF + token;
+                    inSel = false;
+                }
+                continue;
+            }
+            out += token;
+            continue;
+        }
+        for (const ch of token) {
+            const cellStart = col;
+            const cellEnd = col + charWidth(ch);
+            const selected = cellEnd > start && cellStart < end;
+            if (selected && !inSel) {
+                out += INVERSE_ON;
+                inSel = true;
+            }
+            else if (!selected && inSel) {
+                out += INVERSE_OFF;
+                inSel = false;
+            }
+            out += ch;
+            col = cellEnd;
+        }
+    }
+    if (inSel)
+        out += INVERSE_OFF;
+    return out;
+}
+/** The plain text of the cells in [start, end) of an ANSI line. */
+export function extractText(line, start, end) {
+    if (end <= start)
+        return "";
+    let out = "";
+    let col = 0;
+    for (const ch of cachedStrip(line)) {
+        const cellEnd = col + charWidth(ch);
+        if (cellEnd > start && col < end)
+            out += ch;
+        col = cellEnd;
+        if (col >= end)
+            break;
+    }
+    return out;
+}
+/**
+ * Flow-style selection over the message area. `rows` mirrors the rendered
+ * rows (null = blank/chrome row, no text); anchor/current are 0-based
+ * (row = index into `rows`, col = display column). Dragging down selects the
+ * anchor to end-of-line, full middle rows, then start to current; dragging up
+ * is symmetric. Returns one range per row (null = nothing selected there).
+ */
+const strippedCache = new Map();
+function cachedStrip(row) {
+    const hit = strippedCache.get(row);
+    if (hit !== undefined)
+        return hit;
+    const s = stripAnsi(row);
+    if (strippedCache.size > 512)
+        strippedCache.clear();
+    strippedCache.set(row, s);
+    return s;
+}
+export function selectionRanges(rows, anchor, current) {
+    const result = rows.map(() => null);
+    const top = Math.min(anchor.row, current.row);
+    const bottom = Math.max(anchor.row, current.row);
+    for (let r = top; r <= bottom; r++) {
+        const line = rows[r];
+        if (r < 0 || r >= rows.length || line === null)
+            continue;
+        const width = displayWidth(cachedStrip(line));
+        let start;
+        let end;
+        if (anchor.row === current.row) {
+            start = Math.min(anchor.col, current.col);
+            end = Math.max(anchor.col, current.col);
+        }
+        else if (r === anchor.row) {
+            if (anchor.row < current.row) {
+                start = anchor.col;
+                end = width;
+            }
+            else {
+                start = 0;
+                end = anchor.col;
+            }
+        }
+        else if (r === current.row) {
+            if (anchor.row < current.row) {
+                start = 0;
+                end = current.col;
+            }
+            else {
+                start = current.col;
+                end = width;
+            }
+        }
+        else {
+            start = 0;
+            end = width;
+        }
+        result[r] = { start: Math.max(0, start), end };
+    }
+    return result;
+}

package/dist/tui/slash-commands.js

@@ -0,0 +1,90 @@
+export const SLASH_COMMANDS = [
+    { name: "clear", description: "清除对话历史" },
+    { name: "compact", description: "压缩上下文" },
+    { name: "model", description: "选择/切换模型" },
+    { name: "models", description: "列出可用模型" },
+    { name: "provider", description: "查看/切换 Provider", argHint: "[name]" },
+    { name: "memory", description: "查看/保存记忆", argHint: "[t]" },
+    { name: "tokens", description: "显示 token 用量与成本" },
+    { name: "budget", description: "查看/设置预算上限", argHint: "[n]" },
+    { name: "undo", description: "撤销上一轮" },
+    { name: "redo", description: "重发最后一条消息" },
+    { name: "diff", description: "显示工作区未提交变更" },
+    { name: "plan", description: "切换只读计划模式" },
+    { name: "sessions", description: "列出已保存会话" },
+    { name: "rename", description: "重命名当前会话", argHint: "<title>" },
+    { name: "attach", description: "附加本地图片", argHint: "<path>", aliases: ["image"] },
+    { name: "mcp", description: "显示 MCP 状态" },
+    { name: "skills", description: "显示/启用/禁用 skills", argHint: "[list|info <name>|enable|disable <name> [--project]]" },
+    { name: "path", description: "显示工作目录", aliases: ["pwd"] },
+    { name: "paste", description: "粘贴剪贴板图片", argHint: "[t]" },
+    { name: "help", description: "显示帮助" },
+    { name: "exit", description: "退出", aliases: ["quit", "q"] },
+];
+export function filterSlashCommands(input, commands = SLASH_COMMANDS) {
+    const q = input.slice(1).trim().toLowerCase();
+    if (q === "")
+        return commands;
+    return commands.filter((c) => c.name.startsWith(q) || (c.aliases ?? []).some((a) => a.startsWith(q)));
+}
+const argProviders = new Map();
+/** Registered by the app at startup so this module stays free of app imports. */
+export function setSlashArgProvider(command, provider) {
+    argProviders.set(command, provider);
+}
+export function clearSlashArgProviders() {
+    argProviders.clear();
+}
+function splitArgs(input) {
+    const out = [];
+    let cur = "";
+    let q = null;
+    for (const ch of input) {
+        if (q) {
+            if (ch === q)
+                q = null;
+            else
+                cur += ch;
+        }
+        else if (ch === '"' || ch === "'")
+            q = ch;
+        else if (/\s/.test(ch)) {
+            if (cur) {
+                out.push(cur);
+                cur = "";
+            }
+        }
+        else
+            cur += ch;
+    }
+    if (cur)
+        out.push(cur);
+    return out;
+}
+/** Null while the command name itself is still being typed (no space yet). */
+export function parseSlashArgs(value) {
+    if (!value.startsWith("/"))
+        return null;
+    const raw = value.slice(1);
+    if (!/\s/.test(raw))
+        return null;
+    const parts = splitArgs(raw.trim());
+    const command = parts[0] ?? "";
+    const rest = parts.slice(1);
+    const partial = /\s$/.test(raw) ? "" : (rest.pop() ?? "");
+    return { command, tokens: rest, partial };
+}
+export function getSlashArgOptions(value) {
+    const ctx = parseSlashArgs(value);
+    if (!ctx)
+        return [];
+    const provider = argProviders.get(ctx.command);
+    if (!provider)
+        return [];
+    const prefix = ctx.partial.toLowerCase();
+    return provider(ctx.tokens, ctx.partial).filter((o) => o.value.toLowerCase().startsWith(prefix));
+}
+/** Replace the token being typed with `option`, leaving a trailing space. */
+export function applySlashArgCompletion(value, option) {
+    return /\s$/.test(value) ? `${value}${option} ` : `${value.replace(/\S+$/, option)} `;
+}