min-agent 0.2.1 → 0.4.0

package/dist/tui/selection.js

@@ -0,0 +1,226 @@
+import { clustersOf, 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[")) {
+            if (inSel && token === RESET) {
+                if (col < end)
+                    out += token + INVERSE_ON;
+                else {
+                    out += INVERSE_OFF + token;
+                    inSel = false;
+                }
+                continue;
+            }
+            out += token;
+            continue;
+        }
+        for (const { text: g, width: w } of clustersOf(token)) {
+            const cellStart = col;
+            const cellEnd = col + w;
+            const selected = cellEnd > start && cellStart < end;
+            if (selected && !inSel) {
+                out += INVERSE_ON;
+                inSel = true;
+            }
+            else if (!selected && inSel) {
+                out += INVERSE_OFF;
+                inSel = false;
+            }
+            out += g;
+            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 { text: g, width: w } of clustersOf(cachedStrip(line))) {
+        const cellEnd = col + w;
+        if (cellEnd > start && col < end)
+            out += g;
+        col = cellEnd;
+        if (col >= end)
+            break;
+    }
+    return out;
+}
+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 textFromSelection(rows, kinds, ranges) {
+    const parts = [];
+    for (let i = 0; i < ranges.length; i++) {
+        const range = ranges[i];
+        const row = rows[i];
+        if (!range || !row)
+            continue;
+        parts.push(stripCopyDecorations(extractText(row, range.start, range.end), kinds[i] ?? "plain"));
+    }
+    while (parts.length > 0 && parts[parts.length - 1] === "")
+        parts.pop();
+    return parts.join("\n");
+}
+export function stripCopyDecorations(line, kind) {
+    if (kind === "user-head" && line.startsWith("> "))
+        return line.slice(2);
+    if (kind === "tool-head")
+        return line.replace(/^⚡ .*?[▸▾] /, "");
+    if (kind === "tool-body" && line.startsWith("  "))
+        return line.slice(2);
+    return line;
+}
+/** Visible prefix rendered in its own Ink Text (user `> `, tool `⚡ name ▸ `). */
+export function visualPrefix(line, role) {
+    if (role === "user" && line.startsWith("> "))
+        return "> ";
+    if (role === "tool") {
+        const m = line.match(/^⚡ .*?[▸▾] /);
+        return m ? m[0] : "";
+    }
+    return "";
+}
+/** Split a display-column range across a prefix of `at` cells. */
+export function splitRangeAt(range, at) {
+    const head = range.start < at && range.end > 0 ? { start: range.start, end: Math.min(at, range.end) } : null;
+    const tail = range.end > at ? { start: Math.max(0, range.start - at), end: range.end - at } : null;
+    return {
+        head: head && head.end > head.start ? head : null,
+        tail: tail && tail.end > tail.start ? tail : null,
+    };
+}
+export function wordRangeAt(line, col) {
+    const cells = [];
+    let x = 0;
+    for (const { text: g, width: w } of clustersOf(line)) {
+        cells.push({ ch: g, start: x, end: x + w });
+        x += w;
+    }
+    const hit = cells.find((c) => col >= c.start && col < c.end);
+    if (!hit || /\s/.test(hit.ch))
+        return { start: col, end: col };
+    let left = cells.indexOf(hit);
+    let right = left;
+    while (left > 0 && !/\s/.test(cells[left - 1].ch))
+        left--;
+    while (right < cells.length - 1 && !/\s/.test(cells[right + 1].ch))
+        right++;
+    return { start: cells[left].start, end: cells[right].end };
+}
+/**
+ * Map a 1-based SGR mouse position to a cell in `rows`.
+ * `padLeft` is the Ink paddingLeft of every message row (first text cell is
+ * terminal column padLeft+1).
+ */
+export function mouseToCell(rows, termRow, termCol, padLeft = 1) {
+    const maxRow = Math.max(0, rows.length - 1);
+    return {
+        row: Math.min(maxRow, Math.max(0, termRow - 1)),
+        col: Math.max(0, termCol - 1 - padLeft),
+    };
+}
+/**
+ * Distribute viewport ranges onto each message part's shown-line index.
+ * The resulting arrays are sparse: missing indices mean that shown line is
+ * not highlighted. Callers must not require `arr.length === shown.length`.
+ */
+export function alignPartSelections(ranges, partMeta) {
+    const map = new Map();
+    for (let i = 0; i < ranges.length; i++) {
+        const meta = partMeta[i];
+        const range = ranges[i];
+        if (!meta || !range || range.end <= range.start)
+            continue;
+        let arr = map.get(meta.part);
+        if (!arr) {
+            arr = [];
+            map.set(meta.part, arr);
+        }
+        arr[meta.shown] = range;
+    }
+    return map;
+}
+/**
+ * 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 of the cell under the
+ * pointer). Both endpoints are inclusive: dragging onto a character selects
+ * it. Dragging down selects the anchor through end-of-line, full middle rows,
+ * then start through current; dragging up is symmetric.
+ */
+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) + 1;
+        }
+        else if (r === anchor.row) {
+            if (anchor.row < current.row) {
+                start = anchor.col;
+                end = width;
+            }
+            else {
+                start = 0;
+                end = anchor.col + 1;
+            }
+        }
+        else if (r === current.row) {
+            if (anchor.row < current.row) {
+                start = 0;
+                end = current.col + 1;
+            }
+            else {
+                start = current.col;
+                end = width;
+            }
+        }
+        else {
+            start = 0;
+            end = width;
+        }
+        start = Math.max(0, start);
+        if (end > start)
+            result[r] = { start, end };
+    }
+    return result;
+}

package/dist/tui/session-switch.js

@@ -0,0 +1,28 @@
+export function prepareSwitch(opts) {
+    if (opts.running)
+        return { ok: false, reason: "running" };
+    if (opts.currentId === opts.targetId)
+        return { ok: false, reason: "current" };
+    if (!opts.exists)
+        return { ok: false, reason: "missing" };
+    return { ok: true };
+}
+export function switchFailMessage(reason) {
+    if (reason === "running")
+        return "请先等待当前回合结束或按 Esc 取消";
+    if (reason === "current")
+        return "已是当前会话";
+    return "会话不存在";
+}
+export function prepareNew(opts) {
+    if (opts.running)
+        return { ok: false, reason: "running" };
+    if (!opts.sessionId && opts.messageCount === 0)
+        return { ok: false, reason: "already_new" };
+    return { ok: true };
+}
+export function newFailMessage(reason) {
+    if (reason === "running")
+        return "请先等待当前回合结束或按 Esc 取消";
+    return "已是新会话";
+}

package/dist/tui/slash-commands.js

@@ -0,0 +1,106 @@
+export const SLASH_COMMANDS = [
+    { name: "new", description: "新建会话（保留当前）" },
+    { name: "compact", description: "压缩上下文" },
+    { name: "model", description: "选择/切换模型" },
+    { name: "models", description: "列出可用模型" },
+    { name: "provider", description: "查看/切换 Provider", argHint: "[name]" },
+    { name: "memory", description: "查看/保存记忆", argHint: "[t] [--project]" },
+    { name: "tokens", description: "显示上下文占用、累计用量与成本" },
+    { name: "budget", description: "查看/设置预算上限", argHint: "[n] [--project]" },
+    { name: "permission", description: "查看/设置确认模式", argHint: "[ask|accept-edits|allow-all] [--project]" },
+    { name: "sandbox", description: "查看/设置隔离", argHint: "[off|workspace|strict] [--project]" },
+    { name: "undo", description: "撤销上一轮" },
+    { name: "redo", description: "重发最后一条消息" },
+    { name: "diff", description: "显示工作区未提交变更" },
+    { name: "plan", description: "切换只读计划模式" },
+    { name: "sessions", description: "列出/切换已保存会话", argHint: "[id]", aliases: ["resume"] },
+    { name: "reload", 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)));
+}
+/** True for submitted input that is a known slash command (including aliases). */
+export function isKnownSlashCommandInput(text, commands = SLASH_COMMANDS) {
+    if (!text.startsWith("/"))
+        return false;
+    const name = text.slice(1).trim().split(/\s/, 1)[0]?.toLowerCase() ?? "";
+    if (!name)
+        return true;
+    return commands.some((c) => c.name === name || (c.aliases ?? []).some((a) => a === name));
+}
+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)} `;
+}