min-agent 0.2.1 → 0.3.0

package/dist/tui/QuestionBar.js

@@ -0,0 +1,104 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { useState } from "react";
+import { Box, Text, useInput } from "ink";
+import { wrapByWidth } from "./text-width.js";
+import { innerTextWidth } from "./layout.js";
+import { theme } from "./theme.js";
+/**
+ * Terminal rows the question bar occupies, mirroring the JSX layout below.
+ * Needed by App to bound the message area so the frame never exceeds the
+ * terminal height while the prompt is up.
+ */
+export function questionBarRows(prompt, options, columns) {
+    const textWidth = innerTextWidth(columns);
+    let rows = 0;
+    for (const line of prompt.split("\n"))
+        rows += wrapByWidth(line, textWidth).length;
+    if (options)
+        for (const o of options)
+            for (const l of o.split("\n"))
+                rows += wrapByWidth(l, textWidth).length;
+    return rows + 7; /* borders2 + title1 + marginTop1 + hint1 + inputRow1 + margin1 */
+}
+/** Free-form question prompt: type an answer (or a number to pick an option), Enter to submit, Esc to cancel. */
+export function QuestionBar({ prompt, options, onAnswer }) {
+    const [value, setValue] = useState("");
+    const [caret, setCaret] = useState(0);
+    useInput((input, key) => {
+        if (key.escape) {
+            onAnswer(null);
+            return;
+        }
+        if (key.return) {
+            if (/^\d+$/.test(value.trim()) && options?.length) {
+                const n = parseInt(value.trim(), 10);
+                if (n >= 1 && n <= options.length) {
+                    onAnswer(options[n - 1]);
+                    return;
+                }
+            }
+            onAnswer(value.trim());
+            return;
+        }
+        if (key.leftArrow) {
+            setCaret((c) => Math.max(0, c - 1));
+            return;
+        }
+        if (key.rightArrow) {
+            setCaret((c) => Math.min(Array.from(value).length, c + 1));
+            return;
+        }
+        if (key.backspace || key.delete) {
+            if (key.backspace) {
+                if (caret === 0)
+                    return;
+                const chars = Array.from(value);
+                chars.splice(caret - 1, 1);
+                setValue(chars.join(""));
+                setCaret((c) => c - 1);
+            }
+            else {
+                const chars = Array.from(value);
+                if (caret >= chars.length)
+                    return;
+                chars.splice(caret, 1);
+                setValue(chars.join(""));
+            }
+            return;
+        }
+        if (key.ctrl && input === "a") {
+            setCaret(0);
+            return;
+        }
+        if (key.ctrl && input === "e") {
+            setCaret(Array.from(value).length);
+            return;
+        }
+        if (key.ctrl && input === "u") {
+            setValue("");
+            setCaret(0);
+            return;
+        }
+        if (key.ctrl && input === "k") {
+            const chars = Array.from(value);
+            chars.splice(caret);
+            setValue(chars.join(""));
+            return;
+        }
+        if (key.ctrl || key.meta)
+            return;
+        if (key.upArrow || key.downArrow || key.tab)
+            return;
+        if (input) {
+            const clean = input.replace(/[\r\n]+$/, "");
+            if (!clean)
+                return;
+            const chars = Array.from(value);
+            const ins = Array.from(clean);
+            chars.splice(caret, 0, ...ins);
+            setValue(chars.join(""));
+            setCaret((c) => c + ins.length);
+        }
+    });
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: theme.questionBorder, paddingX: 1, children: [_jsx(Box, { children: _jsxs(Text, { bold: true, color: theme.questionBorder, children: ["\u2753 ", prompt] }) }), options && options.length > 0 && (_jsx(Box, { paddingLeft: 1, flexDirection: "column", children: options.map((opt, i) => (_jsx(Box, { children: _jsxs(Text, { color: theme.muted, children: ["   ", i + 1, ". ", opt] }) }, i))) })), _jsxs(Box, { marginTop: 1, children: [_jsx(Text, { bold: true, color: theme.questionBorder, children: "\u2192 " }), _jsx(Text, { children: Array.from(value).slice(0, caret).join("") }), _jsx(Text, { color: theme.muted, inverse: true, children: " " }), _jsx(Text, { children: Array.from(value).slice(caret).join("") })] }), _jsx(Box, { children: _jsx(Text, { color: theme.muted, dimColor: true, wrap: "truncate-end", children: "Enter \u63D0\u4EA4 \u00B7 Esc \u53D6\u6D88 \u00B7 \u2190\u2192 \u5149\u6807 \u00B7 \u6570\u5B57\u9009\u9009\u9879" }) })] }));
+}

package/dist/tui/StatusBar.js

@@ -1,16 +1,24 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 import { Box, Text } from "ink";
-export function StatusBar({ state }) {
+import { displayWidth } from "./text-width.js";
+export function StatusBar({ state, columns = 80 }) {
     const model = state.model || "unknown";
     const tokens = state.tokenInfo;
-    let bar = "";
-    let barColor = "green";
-    if (tokens && tokens.contextWindow > 0) {
-        const pct = Math.round((tokens.input / tokens.contextWindow) * 100);
-        const filled = Math.round(pct / 10);
-        const empty = 10 - filled;
-        bar = `${tokens.input}/${tokens.contextWindow} ${"█".repeat(filled)}${"░".repeat(empty)} ${pct}%`;
-        barColor = pct >= 80 ? "red" : pct >= 50 ? "yellow" : "green";
-    }
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { dimColor: true, children: "─".repeat(60) }), _jsxs(Box, { children: [_jsx(Text, { children: " \uD83E\uDD16 min-agent" }), _jsxs(Text, { color: "gray", children: [" (", model, ")"] }), bar && (_jsxs(_Fragment, { children: [_jsx(Text, { children: "  " }), _jsx(Text, { color: barColor, children: bar })] }))] })] }));
+    const fmtK = (n) => `${(n / 1000).toFixed(1)}k`;
+    const ctxPct = tokens && tokens.contextWindow > 0 ? Math.round((tokens.input / tokens.contextWindow) * 100) : null;
+    const tokensLabel = tokens && (tokens.input > 0 || tokens.output > 0)
+        ? [
+            tokens.input > 0 ? `${fmtK(tokens.input)} in` : null,
+            tokens.output > 0 ? `${fmtK(tokens.output)} out` : null,
+            ctxPct != null ? `${ctxPct}%` : null,
+        ].filter(Boolean).join(" · ")
+        : "";
+    // Transient copy feedback rides on the separator row itself (right end) so
+    // it never adds a row and the layout does not jump while it is visible.
+    const sepWidth = Math.max(8, columns - 2);
+    const notice = state.copyNotice ? `✓ ${state.copyNotice}` : null;
+    const noticeWidth = notice ? displayWidth(notice) : 0;
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { dimColor: true, wrap: "truncate-end", children: notice
+                    ? `${"─".repeat(Math.max(0, sepWidth - noticeWidth - 2))}  ${notice}`
+                    : "─".repeat(sepWidth) }), _jsxs(Box, { children: [_jsx(Text, { children: " \uD83E\uDD16 min-agent" }), _jsxs(Text, { color: "gray", wrap: "truncate-end", children: [" (", model, ")"] }), tokensLabel && (_jsxs(_Fragment, { children: [_jsx(Text, { children: "  " }), _jsx(Text, { color: "gray", wrap: "truncate-end", children: tokensLabel })] }))] })] }));
 }

package/dist/tui/agent-runner.js

@@ -0,0 +1,103 @@
+export function createAgentRunner(deps) {
+    let abortController = null;
+    const getController = () => abortController;
+    const abort = (tui) => {
+        if (!abortController)
+            return false;
+        import("../tools/bash.js").then((m) => m.killActiveProcesses()).catch(() => { });
+        abortController.abort();
+        abortController = null;
+        tui.setRunning(false);
+        tui.addMessage({ id: `sys-${Date.now()}`, role: "system", content: "(已取消)", timestamp: Date.now() });
+        return true;
+    };
+    const run = async () => {
+        const turnStart = deps.messages.length;
+        const uiStart = deps.tui.messageCount();
+        let compactedDuringRun = false;
+        abortController = new AbortController();
+        deps.tui.setRunning(true, "思考中...");
+        const { summarizeToolCall, summarizeToolResult, toolResultText } = await import("../tool-display.js");
+        const { getContextWindow } = await import("../context-window.js");
+        const { getModelPrice, estimateCost, formatCost } = await import("../pricing.js");
+        const { runOnce, runOnceWithSystem } = await import("../agent.js");
+        const { clearStack, pushTurn } = await import("./undo-stack.js");
+        const callbacks = {
+            onAssistantDisplayDelta: (delta) => deps.tui.appendToLast(delta),
+            onThinkingDelta: (delta) => {
+                deps.tui.setRunning(true, "推理中...");
+                deps.tui.appendToThinking(delta);
+            },
+            onToolCall: (toolName, input, toolCallId) => {
+                deps.tui.setRunning(true, `执行 ${toolName}...`);
+                deps.tui.addMessage({
+                    id: `tool-${toolCallId || `${Date.now()}-${Math.random().toString(36).slice(2, 6)}`}`,
+                    role: "tool",
+                    content: summarizeToolCall(toolName, input),
+                    toolName,
+                    toolCallId,
+                    timestamp: Date.now(),
+                });
+            },
+            onToolResult: (toolName, output, meta) => {
+                deps.tui.setRunning(true, "思考中...");
+                deps.tui.setToolResult(meta.toolCallId, toolName, summarizeToolResult(toolName, output, meta.isError), toolResultText(output), meta.isError);
+            },
+            onStreamError: (msg) => {
+                deps.tui.addMessage({ id: `err-${Date.now()}`, role: "system", content: `错误: ${msg}`, timestamp: Date.now() });
+            },
+            onCompaction: () => {
+                compactedDuringRun = true;
+                deps.setUndoStack(clearStack(deps.getUndoStack()));
+            },
+            onRunFinish: async (info) => {
+                abortController = null;
+                deps.tui.setRunning(false);
+                if (info.aborted)
+                    return;
+                if (info.budgetExceeded)
+                    deps.tui.addMessage({ id: `budget-${Date.now()}`, role: "system", content: "⚠ 已达到预算上限。/budget 查看或调高", timestamp: Date.now() });
+                if (info.usage) {
+                    const input = info.usage.inputTokens ?? 0;
+                    const output = info.usage.outputTokens ?? 0;
+                    const total = input + output;
+                    const ctxWindow = await getContextWindow(deps.getModel());
+                    const pct = ctxWindow > 0 ? Math.round((input / ctxWindow) * 100) : 0;
+                    deps.tui.setTokenInfo(input, output, ctxWindow);
+                    const price = await getModelPrice(deps.getModel() ?? "");
+                    const cost = estimateCost({ inputTokens: input, outputTokens: output }, price);
+                    deps.tui.addMessage({ id: `done-${Date.now()}`, role: "system", content: `Done in ${info.stepCount} step(s) | Tokens: ${input} in / ${output} out / ${total} total | Context: ${pct}%${cost != null ? ` | 约 ${formatCost(cost)}` : ""}`, timestamp: Date.now() });
+                }
+                if (info.maxStepsReached)
+                    deps.tui.addMessage({ id: `maxsteps-${Date.now()}`, role: "system", content: "⚠ 达到本轮 30 步上限，发送消息继续", timestamp: Date.now() });
+            },
+        };
+        try {
+            const runOptions = {
+                providerName: deps.getProvider(),
+                ...(deps.getPlanMode() ? { planMode: true } : {}),
+            };
+            if (deps.mode === "code" && deps.codeSystemPrompt) {
+                await runOnceWithSystem(deps.messages, deps.codeSystemPrompt, deps.getModel(), abortController?.signal, callbacks, deps.tracker, runOptions);
+            }
+            else {
+                const { loadInstructions } = await import("../instructions.js");
+                const instructions = await loadInstructions();
+                await runOnce(deps.messages, instructions, deps.getModel(), abortController?.signal, callbacks, deps.tracker, runOptions);
+            }
+        }
+        catch (err) {
+            if (!abortController)
+                return;
+            const msg = err instanceof Error ? err.message : String(err);
+            callbacks.onStreamError(msg);
+        }
+        finally {
+            if (!compactedDuringRun)
+                deps.setUndoStack(pushTurn(deps.getUndoStack(), turnStart, deps.messages.length, uiStart));
+            abortController = null;
+            deps.tui.setRunning(false);
+        }
+    };
+    return { run, abort, getController };
+}

package/dist/tui/caret-pos.js

@@ -0,0 +1,134 @@
+import { charWidth, wrapByWidth } from "./text-width.js";
+/** Split the value into visual rows, tracking each row's character start index (newlines count as one). */
+export function visualRows(value, maxWidth) {
+    const rows = [];
+    let start = 0;
+    const lines = value.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+        for (const row of wrapByWidth(lines[i], maxWidth)) {
+            rows.push({ text: row, startIndex: start });
+            start += Array.from(row).length;
+        }
+        if (i < lines.length - 1)
+            start += 1;
+    }
+    return rows;
+}
+/** Move the caret by one code point; clamps at the start/end of the value. */
+export function moveCaretHorizontal(value, caretIndex, direction) {
+    const len = Array.from(value).length;
+    return Math.min(Math.max(caretIndex + direction, 0), len);
+}
+/**
+ * Map a click column (1-based terminal column) on a visual row to a character
+ * index in the value. Fullwidth characters snap to the nearer boundary.
+ */
+export function caretIndexFromClick(rows, rowIndex, clickColumn, textStartColumn) {
+    const row = rows[rowIndex];
+    if (!row)
+        return 0;
+    const target = clickColumn - textStartColumn;
+    if (target <= 0)
+        return row.startIndex;
+    let width = 0;
+    let idx = 0;
+    for (const char of row.text) {
+        const w = charWidth(char);
+        if (width + w > target) {
+            return row.startIndex + idx + (target - width < w / 2 ? 0 : 1);
+        }
+        width += w;
+        idx++;
+    }
+    return row.startIndex + idx;
+}
+/** Insert text at the caret; returns the new value and caret index. */
+export function insertAt(value, caretIndex, text) {
+    const chars = Array.from(value);
+    chars.splice(caretIndex, 0, ...Array.from(text));
+    return { value: chars.join(""), caretIndex: caretIndex + Array.from(text).length };
+}
+/** Remove the code point before the caret. */
+export function backspaceAt(value, caretIndex) {
+    if (caretIndex <= 0)
+        return { value, caretIndex };
+    const chars = Array.from(value);
+    chars.splice(caretIndex - 1, 1);
+    return { value: chars.join(""), caretIndex: caretIndex - 1 };
+}
+/** Remove the code point at the caret. */
+export function deleteAt(value, caretIndex) {
+    const chars = Array.from(value);
+    if (caretIndex >= chars.length)
+        return { value, caretIndex };
+    chars.splice(caretIndex, 1);
+    return { value: chars.join(""), caretIndex };
+}
+export function moveToLineStart(value, caretIndex) {
+    const chars = Array.from(value);
+    let i = caretIndex - 1;
+    while (i >= 0 && chars[i] !== "\n")
+        i--;
+    return i + 1;
+}
+export function moveToLineEnd(value, caretIndex) {
+    const chars = Array.from(value);
+    let i = caretIndex;
+    while (i < chars.length && chars[i] !== "\n")
+        i++;
+    return i;
+}
+export function deleteToLineStart(value, caretIndex) {
+    const start = moveToLineStart(value, caretIndex);
+    if (start === caretIndex)
+        return { value, caretIndex };
+    const chars = Array.from(value);
+    chars.splice(start, caretIndex - start);
+    return { value: chars.join(""), caretIndex: start };
+}
+export function deleteToLineEnd(value, caretIndex) {
+    const end = moveToLineEnd(value, caretIndex);
+    if (end === caretIndex)
+        return { value, caretIndex };
+    const chars = Array.from(value);
+    chars.splice(caretIndex, end - caretIndex);
+    return { value: chars.join(""), caretIndex };
+}
+export function deleteWordBefore(value, caretIndex) {
+    if (caretIndex <= 0)
+        return { value, caretIndex };
+    const chars = Array.from(value);
+    let i = caretIndex - 1;
+    while (i >= 0 && /\s/.test(chars[i]))
+        i--;
+    while (i >= 0 && !/\s/.test(chars[i]))
+        i--;
+    const start = i + 1;
+    chars.splice(start, caretIndex - start);
+    return { value: chars.join(""), caretIndex: start };
+}
+/** The longest escape sequence this scanner recognises, kept for the cap. */
+const MAX_DELETE_PREFIX = 32;
+/**
+ * Scan raw stdin bytes for Backspace (DEL, 0x7F — what most terminals send
+ * for the Backspace key) and Delete sequences (CSI 3 ~ and its modifier
+ * variants like CSI 3;5 ~ for Ctrl+Delete), which may span chunks. Ink
+ * reports all of them as `key.delete`, so they are distinguished here.
+ */
+export function scanDeleteKeys(buffer, chunk) {
+    const buf = buffer + chunk;
+    const actions = [];
+    const re = /\x1b\[3(?:;\d+)?[~$^]|\x7f/g;
+    let lastConsumedEnd = 0;
+    let m;
+    while ((m = re.exec(buf))) {
+        lastConsumedEnd = m.index + m[0].length;
+        actions.push(m[0] === "\x7f" ? { kind: "backspace" } : { kind: "delete" });
+    }
+    const tail = buf.slice(lastConsumedEnd);
+    const esc = tail.lastIndexOf("\x1b");
+    if (esc === -1)
+        return { buffer: "", actions };
+    const prefix = tail.slice(esc);
+    return { buffer: prefix.length > MAX_DELETE_PREFIX ? "\x1b" : prefix, actions };
+}

package/dist/tui/caret.js

@@ -0,0 +1,69 @@
+/**
+ * Real terminal caret tracking for the TUI.
+ *
+ * Ink draws frames with `log-update`, which hides the hardware cursor and
+ * always leaves it at the end of the frame. That is fine for ASCII typing
+ * (the input bar paints its own `█` block), but an IME draws its preedit text
+ * and candidate window at the *hardware* cursor. With the cursor parked below
+ * the input box, Chinese input appears in the wrong place.
+ *
+ * The fix: after every frame Ink writes, move the hardware cursor onto the cell
+ * where the input bar painted its caret, and undo that move right before the
+ * next frame so Ink's own relative erase bookkeeping stays intact.
+ */
+let caret = null;
+/** Called by the input bar on every render; `null` disables caret tracking. */
+export function setCaretPosition(position) {
+    caret = position;
+}
+/**
+ * Wrap a TTY stream so Ink's writes are followed by a caret move.
+ *
+ * Only the row offset needs undoing: Ink's frames always end at column 1
+ * (either after a trailing newline, or after `clearTerminal` repositions the
+ * cursor absolutely), so `\r` is enough to restore the column.
+ */
+export function createCaretAwareStdout(base) {
+    let pendingRowsUp = 0;
+    const write = (chunk, encoding, callback) => {
+        const isBuf = typeof Buffer !== "undefined" && Buffer.isBuffer(chunk);
+        let chunkStr;
+        if (typeof chunk === "string")
+            chunkStr = chunk;
+        else if (isBuf)
+            chunkStr = chunk.toString(encoding || "utf-8");
+        else if (chunk != null)
+            chunkStr = String(chunk);
+        else
+            return base.write(chunk, encoding, callback);
+        let out = "";
+        if (pendingRowsUp > 0) {
+            out += `\x1b[${pendingRowsUp}B\r`;
+            pendingRowsUp = 0;
+        }
+        out += chunkStr;
+        const position = caret;
+        if (position) {
+            const rowsUp = position.rowsAbove + (chunkStr.endsWith("\n") ? 1 : 0);
+            if (rowsUp > 0) {
+                out += `\x1b[${rowsUp}A\x1b[${position.column}G`;
+                pendingRowsUp = rowsUp;
+            }
+        }
+        const finalChunk = typeof chunk === "string" ? out : Buffer.from(out, encoding || "utf-8");
+        return base.write(finalChunk, encoding, callback);
+    };
+    return new Proxy(base, {
+        get(target, prop) {
+            if (prop === "write")
+                return write;
+            // Read through to the real stream: getters like `columns`/`rows` and
+            // methods like `on`/`off` must run with the stream as `this`.
+            const value = Reflect.get(target, prop, target);
+            return typeof value === "function" ? value.bind(target) : value;
+        },
+        set(target, prop, value) {
+            return Reflect.set(target, prop, value, target);
+        },
+    });
+}

package/dist/tui/diff-view.js

@@ -0,0 +1,61 @@
+import { execFile } from "child_process";
+import { promisify } from "util";
+const MAX_DIFF_CHARS = 8000;
+const execFileAsync = promisify(execFile);
+export async function getWorkingTreeDiff(cwd = process.cwd(), run = defaultRun) {
+    try {
+        await run("git rev-parse --is-inside-work-tree", cwd);
+    }
+    catch {
+        return { ok: false, reason: "not_git", message: "当前目录不是 git 仓库" };
+    }
+    let stat = "";
+    let full = "";
+    try {
+        stat = await run("git diff --stat", cwd);
+        full = await run("git diff", cwd);
+    }
+    catch (err) {
+        return { ok: false, reason: "error", message: err instanceof Error ? err.message : String(err) };
+    }
+    if (!full.trim())
+        return { ok: false, reason: "no_changes", message: "工作区无未提交变更" };
+    const body = full.length > MAX_DIFF_CHARS ? full.slice(0, MAX_DIFF_CHARS) + "\n… [diff 过长，已截断]" : full;
+    return { ok: true, diff: stat ? `${stat}\n\n${body}` : body };
+}
+async function defaultRun(cmd, cwd) {
+    const parts = parseCmd(cmd);
+    const { stdout } = await execFileAsync(parts[0], parts.slice(1), {
+        cwd,
+        encoding: "utf-8",
+        timeout: 10000,
+        maxBuffer: 10 * 1024 * 1024,
+    });
+    return stdout;
+}
+function parseCmd(cmd) {
+    const out = [];
+    let cur = "";
+    let q = null;
+    for (const ch of cmd) {
+        if (q) {
+            if (ch === q)
+                q = null;
+            else
+                cur += ch;
+        }
+        else if (ch === '"' || ch === "'")
+            q = ch;
+        else if (ch === " ") {
+            if (cur) {
+                out.push(cur);
+                cur = "";
+            }
+        }
+        else
+            cur += ch;
+    }
+    if (cur)
+        out.push(cur);
+    return out;
+}

package/dist/tui/drag-state.js

@@ -0,0 +1,44 @@
+import { MOTION, MOD_MASK } from "./mouse.js";
+export function createDragMachine() {
+    return { pending: null, selection: null };
+}
+export function clearDrag(machine) {
+    machine.pending = null;
+    machine.selection = null;
+}
+/**
+ * Advance the drag state machine on one SGR mouse event (wheel events are
+ * filtered by the caller before this runs). `maxHeight` is the full region
+ * allocated to the message list, not just its rendered rows — a press on the
+ * blank gap below a short conversation still starts a drag there, and the
+ * selection math clamps out-of-range rows.
+ *
+ * Terminals disagree on drag motion: xterm sends button + 32 (MOTION), but
+ * Apple Terminal reports it as a plain button-0 press. While a drag is in
+ * progress either form extends the selection instead of resetting it —
+ * otherwise every move would re-anchor and clear the highlight.
+ */
+export function stepDrag(machine, event, maxHeight) {
+    const { button, row, col, press } = event;
+    const plain = (button & MOD_MASK) === 0;
+    const dragging = machine.pending != null;
+    if (plain && dragging && ((button & MOTION) !== 0 || (button === 0 && press))) {
+        machine.selection = { anchor: machine.pending, cur: { row, col } };
+        return { type: "selection", selection: machine.selection };
+    }
+    if (button === 0 && press) {
+        machine.selection = null;
+        machine.pending = row >= 1 && row <= maxHeight ? { row, col } : null;
+        return { type: "selection", selection: null };
+    }
+    if (button === 0 && !press) {
+        const active = machine.selection;
+        const pending = machine.pending;
+        machine.pending = null;
+        if (active)
+            return { type: "copy", selection: active };
+        if (pending)
+            return { type: "click", row };
+    }
+    return null;
+}