min-agent 0.2.1 → 0.4.0

package/dist/tui/caret-pos.js

@@ -0,0 +1,177 @@
+import { displayWidth, wrapByWidth, clustersOf } 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 { text: g, width: w } of clustersOf(row.text)) {
+        if (width + w > target) {
+            return row.startIndex + idx + (target - width < w / 2 ? 0 : Array.from(g).length);
+        }
+        width += w;
+        idx += Array.from(g).length;
+    }
+    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 };
+}
+/** Move the caret one visual row up (`-1`) or down (`1`), keeping the display column. */
+export function moveCaretVertical(value, caretIndex, direction, maxWidth) {
+    const rows = visualRows(value, maxWidth);
+    let rowIndex = 0;
+    let offset = 0;
+    for (let i = 0; i < rows.length; i++) {
+        const row = rows[i];
+        const end = row.startIndex + Array.from(row.text).length;
+        if (caretIndex >= row.startIndex && caretIndex <= end) {
+            rowIndex = i;
+            offset = caretIndex - row.startIndex;
+            break;
+        }
+        if (i === rows.length - 1) {
+            rowIndex = i;
+            offset = Array.from(row.text).length;
+        }
+    }
+    const next = rowIndex + direction;
+    if (next < 0 || next >= rows.length)
+        return caretIndex;
+    const col = displayWidth(Array.from(rows[rowIndex].text).slice(0, offset).join(""));
+    return caretIndexFromClick(rows, next, col, 0);
+}
+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 };
+}
+const HOME_END_RE = /\x1b\[(?:[HF]|[1478]~)/g;
+const MAX_HOME_END_PREFIX = 8;
+export function scanHomeEndKeys(buffer, chunk) {
+    const buf = buffer + chunk;
+    const actions = [];
+    let lastConsumedEnd = 0;
+    HOME_END_RE.lastIndex = 0;
+    let m;
+    while ((m = HOME_END_RE.exec(buf))) {
+        lastConsumedEnd = m.index + m[0].length;
+        const seq = m[0];
+        actions.push(seq.endsWith("H") || seq.endsWith("1~") || seq.endsWith("7~") ? { kind: "home" } : { kind: "end" });
+    }
+    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_HOME_END_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 = 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/click-count.js

@@ -0,0 +1,13 @@
+export const DOUBLE_CLICK_MS = 400;
+export const DOUBLE_CLICK_COL_SLOP = 2;
+export function createClickCounter() {
+    return { row: -1, col: -1, at: Number.NEGATIVE_INFINITY, count: 0 };
+}
+export function noteClick(c, ev) {
+    const same = ev.row === c.row && Math.abs(ev.col - c.col) <= DOUBLE_CLICK_COL_SLOP && ev.at - c.at <= DOUBLE_CLICK_MS;
+    c.count = same ? c.count + 1 : 1;
+    c.row = ev.row;
+    c.col = ev.col;
+    c.at = ev.at;
+    return c.count;
+}

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,49 @@
+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))) {
+        const origin = machine.pending;
+        if (row === origin.row && col === origin.col && machine.selection == null)
+            return null;
+        machine.selection = { anchor: origin, 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;
+        machine.selection = null;
+        if (active && (active.anchor.row !== active.cur.row || active.anchor.col !== active.cur.col)) {
+            return { type: "copy", selection: active };
+        }
+        if (pending)
+            return { type: "click", row: pending.row, col: pending.col };
+    }
+    return null;
+}

package/dist/tui/hydrate.js

@@ -0,0 +1,129 @@
+import { summarizeToolCall, summarizeToolResult, toolResultText } from "../tool-display.js";
+import { extractXmlSearch } from "../xml-search.js";
+function isRecord(v) {
+    return typeof v === "object" && v !== null;
+}
+function textFromContent(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    const parts = [];
+    for (const part of content) {
+        if (isRecord(part) && part.type === "text" && typeof part.text === "string")
+            parts.push(part.text);
+    }
+    return parts.join("");
+}
+function hasMediaPart(content) {
+    if (!Array.isArray(content))
+        return false;
+    return content.some((part) => isRecord(part) && (part.type === "image" || part.type === "file"));
+}
+function unwrapToolOutput(output) {
+    if (!isRecord(output))
+        return output;
+    if ((output.type === "text" || output.type === "json") && "value" in output)
+        return output.value;
+    return output;
+}
+function userText(content) {
+    const text = textFromContent(content).trim();
+    if (text)
+        return textFromContent(content);
+    if (hasMediaPart(content))
+        return "[📎 图片]";
+    return null;
+}
+export function lastUserText(messages) {
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const msg = messages[i];
+        if (msg?.role !== "user")
+            continue;
+        const text = textFromContent(msg.content).trim();
+        if (text)
+            return textFromContent(msg.content);
+    }
+    return null;
+}
+export function hydrateMessages(messages) {
+    const out = [];
+    for (let i = 0; i < messages.length; i++) {
+        const msg = messages[i];
+        if (msg.role === "assistant") {
+            out.push(...hydrateAssistant(msg, i));
+            continue;
+        }
+        const mapped = mapMessage(msg, i);
+        if (mapped)
+            out.push(mapped);
+    }
+    return out;
+}
+function hydrateAssistant(msg, index) {
+    const content = textFromContent(msg.content);
+    if (!content)
+        return [];
+    const { slices } = extractXmlSearch(content);
+    if (slices.every((sl) => sl.type === "display")) {
+        return [{ id: `hyd-${index}-assistant`, role: "assistant", content, timestamp: 0 }];
+    }
+    const out = [];
+    let part = 0;
+    for (const sl of slices) {
+        if (sl.type === "display") {
+            if (!sl.text.trim())
+                continue;
+            out.push({ id: `hyd-${index}-assistant-${part++}`, role: "assistant", content: sl.text, timestamp: 0 });
+            continue;
+        }
+        const query = sl.block.query;
+        const result = sl.block.kind === "results" ? sl.block.body : sl.block.query;
+        const input = { query };
+        out.push({
+            id: `hyd-${index}-search-${part++}`,
+            role: "tool",
+            content: summarizeToolCall("search_web", input),
+            toolName: "search_web",
+            toolCallId: `xml-search-hyd-${index}-${part}`,
+            toolResult: result,
+            toolResultSummary: summarizeToolResult("search_web", result),
+            timestamp: 0,
+        });
+    }
+    return out;
+}
+function mapMessage(msg, index) {
+    if (msg.role === "user") {
+        const content = userText(msg.content);
+        if (content == null)
+            return null;
+        return { id: `hyd-${index}-user`, role: "user", content, timestamp: 0 };
+    }
+    if (msg.role === "tool") {
+        if (!Array.isArray(msg.content))
+            return null;
+        for (const part of msg.content) {
+            if (!isRecord(part) || part.type !== "tool-result")
+                continue;
+            const toolName = typeof part.toolName === "string" ? part.toolName : "";
+            if (!toolName)
+                continue;
+            const output = unwrapToolOutput(part.output);
+            const result = toolResultText(output);
+            const toolCallId = typeof part.toolCallId === "string" ? part.toolCallId : undefined;
+            return {
+                id: `hyd-${index}-tool`,
+                role: "tool",
+                content: toolName,
+                toolName,
+                toolCallId,
+                toolResult: result,
+                toolResultSummary: summarizeToolResult(toolName, output),
+                timestamp: 0,
+            };
+        }
+        return null;
+    }
+    return null;
+}