min-agent 0.2.1 → 0.4.0

package/dist/tui/index.js

@@ -1,6 +1,9 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { render } from "ink";
 import { App } from "./App.js";
+import { createCaretAwareStdout, setCaretPosition } from "./caret.js";
+import { mergeToolChild } from "./tool-children.js";
+import { normalizeQuestionOptions, normalizeQuestionPrompt } from "../question-format.js";
 /**
  * TUI renderer — manages the Ink app lifecycle and provides
  * imperative methods to update state from the agent loop.
@@ -10,84 +13,239 @@ export class TuiRenderer {
     rerender = null;
     inkInstance = null;
     callbacks;
-    constructor(callbacks, model) {
+    pendingDelta = "";
+    deltaTimer = null;
+    pendingThinking = "";
+    thinkingTimer = null;
+    copyNoticeTimer = null;
+    constructor(callbacks, model, sessionId) {
         this.state = {
             messages: [],
             isRunning: false,
             model,
+            sessionId,
         };
         this.callbacks = callbacks;
     }
+    appElement() {
+        return (_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, onSessionPick: this.callbacks.onSessionPick, onSessionCancel: this.callbacks.onSessionCancel, onToggleSelectionMode: this.callbacks.onToggleSelectionMode, onExitSelectionMode: this.callbacks.onExitSelectionMode, onExit: this.callbacks.onExit, onCopyNotice: (text) => this.showCopyNotice(text) }));
+    }
     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(this.appElement(), { 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
-        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.state = { ...this.state, ...partial };
+        if (this.inkInstance)
+            this.inkInstance.rerender(this.appElement());
     }
     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;
         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 {
+        else if (accumulated.trim() !== "") {
             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) {
-        this.update({ confirmMessage: message });
+        this.update({ confirmMessage: message, selectionMode: false });
     }
     hideConfirm() {
         this.update({ confirmMessage: undefined });
     }
-    setTokenInfo(input, output, contextWindow) {
-        this.update({ tokenInfo: { input, output, contextWindow } });
+    showQuestion(prompt, options) {
+        const choices = normalizeQuestionOptions(options);
+        this.update({
+            question: {
+                prompt: normalizeQuestionPrompt(prompt),
+                ...(choices.length > 0 ? { options: choices } : {}),
+            },
+            selectionMode: false,
+        });
+    }
+    hideQuestion() {
+        this.update({ question: undefined });
+    }
+    showModelPicker() {
+        this.update({ modelPicker: true, selectionMode: false });
+    }
+    hideModelPicker() {
+        this.update({ modelPicker: false });
+    }
+    showSessionPicker() {
+        this.update({ sessionPicker: true, selectionMode: false });
+    }
+    hideSessionPicker() {
+        this.update({ sessionPicker: false });
+    }
+    setSessionId(id) {
+        this.update({ sessionId: id });
+    }
+    setSelectionMode(on) {
+        this.update({ selectionMode: on });
+    }
+    toggleSelectionMode() {
+        this.update({ selectionMode: !this.state.selectionMode });
+    }
+    appendToolChild(parentToolCallId, child) {
+        this.state.messages = mergeToolChild(this.state.messages, parentToolCallId, child);
+        this.update({});
+    }
+    setModel(model) {
+        this.update({ model });
+    }
+    setTokenInfo(info) {
+        this.update({ tokenInfo: info });
+    }
+    /** 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,125 @@
+import { existsSync, mkdirSync, readFileSync, renameSync } from "fs";
+import path from "path";
+import { getConfigDir } from "../config.js";
+import { atomicWriteFileSync } from "../tools/atomic-file.js";
+export const HISTORY_LIMIT = 1000;
+function historyFile() {
+    return path.join(getConfigDir(), "input-history.json");
+}
+export function createHistory(entries = []) {
+    return { entries, index: -1, draft: "" };
+}
+export function parseHistoryFile(raw) {
+    let data;
+    try {
+        data = JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+    if (typeof data !== "object" || data === null || Array.isArray(data))
+        return null;
+    const entries = data.entries;
+    if (!Array.isArray(entries) || entries.some((e) => typeof e !== "string"))
+        return null;
+    return entries;
+}
+export function serializeHistoryFile(entries) {
+    return JSON.stringify({ entries }, null, 2);
+}
+export function loadInputHistoryFrom(file) {
+    if (!existsSync(file))
+        return [];
+    let raw;
+    try {
+        raw = readFileSync(file, "utf-8");
+    }
+    catch {
+        return [];
+    }
+    const parsed = parseHistoryFile(raw);
+    if (parsed)
+        return parsed;
+    try {
+        renameSync(file, `${file}.corrupt-${Date.now()}`);
+    }
+    catch { }
+    return [];
+}
+export function saveInputHistoryTo(file, entries) {
+    try {
+        mkdirSync(path.dirname(file), { recursive: true });
+        atomicWriteFileSync(file, serializeHistoryFile(entries));
+    }
+    catch { }
+}
+export function loadInputHistory() {
+    return loadInputHistoryFrom(historyFile());
+}
+export function saveInputHistory(entries) {
+    saveInputHistoryTo(historyFile(), entries);
+}
+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, skip) {
+    const count = state.entries.length;
+    if (count === 0)
+        return { text: state.draft, state };
+    const last = count - 1;
+    const usable = (i) => i >= 0 && i <= last && !skip?.(state.entries[i]);
+    const current = state.index === -1 ? -1 : Math.max(0, Math.min(last, state.index));
+    if (direction === 1) {
+        const start = current === -1 ? last : current - 1;
+        for (let i = start; i >= 0; i--) {
+            if (usable(i))
+                return { text: state.entries[i], state: { ...state, index: i } };
+        }
+        if (current !== -1)
+            return { text: state.entries[current], state };
+        return { text: state.draft, state };
+    }
+    if (current === -1)
+        return { text: state.draft, state };
+    for (let i = current + 1; i <= last; i++) {
+        if (usable(i))
+            return { text: state.entries[i], state: { ...state, index: i } };
+    }
+    return { text: state.draft, state: { ...state, index: -1 } };
+}
+export function resetHistory(state, text) {
+    if (state.index === -1 && state.draft === text)
+        return state;
+    return { entries: state.entries, index: -1, draft: text };
+}
+export function isCtrlC(input, key) {
+    return (key.ctrl === true && input === "c") || input === "\x03";
+}
+export const EXIT_CTRL_C_WINDOW_MS = 2000;
+export function clearInputOnCtrlC(state, value, armedAt = null, now = 0) {
+    if (value === "") {
+        if (armedAt !== null && now - armedAt <= EXIT_CTRL_C_WINDOW_MS) {
+            return { state, value: "", exit: true, armedAt: null };
+        }
+        return { state, value: "", exit: false, armedAt: now };
+    }
+    const next = value.trim() ? pushInput(state, value) : { entries: state.entries, index: -1, draft: "" };
+    return { state: next, value: "", exit: false, armedAt: null };
+}

package/dist/tui/layout.js

@@ -0,0 +1,88 @@
+export const BOX_CHROME = 4;
+export const GUTTER_WIDTH = 2;
+export const TEXT_START_COLUMN = 5;
+export const STATUS_BAR_ROWS = 2;
+export const INPUT_BAR_ROWS = 3;
+export const MIN_MESSAGE_ROWS = 2;
+/** Ink paddingLeft on every message row. */
+export const MESSAGE_PAD_LEFT = 1;
+/**
+ * Cells reserved at the right of a message row. Filling the last terminal
+ * column wraps the cursor; East-Asian-ambiguous glyphs (`→`, `▸`) may also
+ * occupy one more cell than `displayWidth` reports.
+ */
+export const COL_WRAP_GUARD = 2;
+/** Pinned chrome of ConfirmBar: borders + title + gap + [y]/[N] prompt. */
+export const CONFIRM_CHROME_ROWS = 5;
+/** Pinned chrome of QuestionBar: borders + gap + input + hint. */
+export const QUESTION_CHROME_ROWS = 5;
+/**
+ * Ink's log-update writes the frame plus a trailing newline. A root box that
+ * uses the full terminal height therefore places the input bar's bottom
+ * border on the last row, which that extra newline clips.
+ */
+export const LAST_ROW_GUARD = 1;
+export function frameRows(terminalRows) {
+    if (terminalRows <= 0)
+        return 0;
+    return Math.max(1, terminalRows - LAST_ROW_GUARD);
+}
+export function innerTextWidth(columns) {
+    return Math.max(1, columns - 5);
+}
+export function messageTextWidth(columns) {
+    return Math.max(1, columns - MESSAGE_PAD_LEFT - COL_WRAP_GUARD);
+}
+export function inputTextWidth(columns) {
+    return Math.max(8, columns - BOX_CHROME - GUTTER_WIDTH);
+}
+export function computeMessageMaxHeight(frameRowCount, footerRows, spinnerRows) {
+    if (frameRowCount <= 0)
+        return undefined;
+    return Math.max(MIN_MESSAGE_ROWS, frameRowCount - footerRows - STATUS_BAR_ROWS - spinnerRows);
+}
+/**
+ * Max rows a confirm/question footer may occupy while leaving the status bar
+ * and a two-row peek of the conversation. `minChrome` is the pinned action
+ * chrome (title + prompt) that must stay on screen.
+ */
+export function footerMaxRows(frameRowCount, minChrome) {
+    if (frameRowCount <= 0)
+        return Number.POSITIVE_INFINITY;
+    return Math.max(minChrome, frameRowCount - STATUS_BAR_ROWS - MIN_MESSAGE_ROWS);
+}
+/** Rows a line window actually paints: content plus one indicator per hidden side. */
+export function lineWindowPaintRows(window) {
+    return window.lines.length + (window.above > 0 ? 1 : 0) + (window.below > 0 ? 1 : 0);
+}
+/**
+ * Visible slice of wrapped lines for a max-height body. Hidden sides take an
+ * indicator row each, subtracted from the content budget so the painted
+ * window never exceeds `maxHeight`.
+ */
+export function sliceLineWindow(lines, maxHeight, top) {
+    if (maxHeight <= 0) {
+        return { start: 0, lines: [], above: 0, below: lines.length };
+    }
+    if (lines.length <= maxHeight) {
+        return { start: 0, lines, above: 0, below: 0 };
+    }
+    let above = 0;
+    let below = 0;
+    let start = 0;
+    let viewH = maxHeight;
+    for (let pass = 0; pass < 3; pass++) {
+        const chrome = (above > 0 ? 1 : 0) + (below > 0 ? 1 : 0);
+        viewH = Math.max(1, maxHeight - chrome);
+        const maxTop = Math.max(0, lines.length - viewH);
+        start = Math.max(0, Math.min(top, maxTop));
+        above = start;
+        below = Math.max(0, lines.length - (start + viewH));
+    }
+    return {
+        start,
+        lines: lines.slice(start, start + viewH),
+        above,
+        below,
+    };
+}

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/prompt-queue.js

@@ -0,0 +1,24 @@
+export function createPromptQueue() {
+    let tail = Promise.resolve();
+    let generation = 0;
+    let size = 0;
+    const settle = () => undefined;
+    return {
+        run(job, onCancelled) {
+            const gen = generation;
+            size++;
+            const start = () => (gen !== generation ? Promise.resolve(onCancelled()) : job());
+            const result = tail.then(start, start);
+            tail = result.then(settle, settle);
+            return result.finally(() => {
+                size--;
+            });
+        },
+        cancelAll() {
+            generation++;
+        },
+        get size() {
+            return size;
+        },
+    };
+}