minimal-agent 0.8.2 → 0.10.0

package/src/ui/liveViewport.js

@@ -63,7 +63,11 @@ export function charWidth(cp) {
         return 2;
     }
     // Emoji / 符号 / dingbat：终端普遍全角渲染（含 💭 与 spinner ✶✷✸✹✺）。上界=2，算宽无害。
-    if ((cp >= 0x2600 && cp <= 0x27bf) || // Misc Symbols + Dingbats（含 ✶✷✸✹✺）
+    // 0x2300/0x2500 两段是蜂群树引入的 ⎿ ├ └ │ ─（figures.ts）——ambiguous-width，
+    // CJK 终端可能按全角渲染，按「宁宽不窄」哲学一并按 2 计（INV-1 记账依赖此上界）。
+    if ((cp >= 0x2300 && cp <= 0x23ff) || // Misc Technical（含 ⎿ U+23BF）
+        (cp >= 0x2500 && cp <= 0x25ff) || // Box Drawing / Block Elements / Geometric（├ └ │ ─ ▾ ▶）
+        (cp >= 0x2600 && cp <= 0x27bf) || // Misc Symbols + Dingbats（含 ✶✷✸✹✺）
         (cp >= 0x2b00 && cp <= 0x2bff) || // Misc Symbols and Arrows
         (cp >= 0xfe00 && cp <= 0xfe0f) || // Variation Selectors（VS16 强制全角）
         (cp >= 0x1f000 && cp <= 0x1faff) // Emoji 主区（含 💭）

package/src/ui/markdown.js

@@ -0,0 +1,206 @@
+/**
+ * ============================================================
+ *  src/ui/markdown.ts —— assistant 最终答案的 markdown → 终端展示行
+ * ------------------------------------------------------------
+ *  借鉴 Claude Code 的管线（marked lexer 分词 + 自研 token→ANSI 格式化），
+ *  按 minimal-agent 减法原则收敛。核心裁决：
+ *
+ *  ★ 代码块「零装饰」（复制即用的全部保障）：
+ *    `code` token 的每一行 = 原文逐字节输出——无边框、无背景、无缩进、无前缀、
+ *    不按宽度重排；渲染层配 wrap='end'（Ink 原样输出，不注入换行），超宽交给
+ *    终端软换行（现代终端复制时还原为整行）。任何"美化"都会污染复制。
+ *
+ *  ★ 删除线主动禁用：模型常用 ~xxx~ 表示"约等于"，渲染成删除线是灾难
+ *    （捐赠方同款裁决），del token 原样输出 raw。
+ *
+ *  ★ 只在 <Static> commit 时调用（write-once，每条消息一生解析一次，
+ *    <1ms 无重解析压力）；live 流式区不跑 markdown。
+ *
+ *  已知取舍：
+ *    - dim 与 bold 的 SGR 关闭码同为 22，嵌套会提前关闭外层——本文件不在
+ *      bold 内嵌 dim（捐赠方同样接受此约束）。
+ *    - 超过终端宽度的 code 行交终端软换行显示（视觉上折行、复制仍是整行）；
+ *      TODO：后续可为超宽 code 提供 /show 式展开。
+ *    - 表格第一期不做 flexbox 对齐，token.raw 原样透传（终端裸文本可读）；
+ *      TODO：需要时参照捐赠方 MarkdownTable 组件。
+ * ============================================================
+ */
+import { lexer } from 'marked';
+import { figures } from './figures.js';
+// ---------------- ANSI 内联样式（手写 SGR，不引 chalk） ----------------
+// Ink 的 Text 渲染管线（wrap-ansi / cli-truncate）是 ANSI-aware 的，
+// 字符串内嵌 SGR 与 wrap='end' 兼容（捐赠方同款做法）。
+const sgr = (open, close) => (s) => `\x1b[${open}m${s}\x1b[${close}m`;
+const bold = sgr(1, 22);
+const italic = sgr(3, 23);
+const underline = sgr(4, 24);
+const dim = sgr(2, 22);
+const cyan = sgr(36, 39);
+/**
+ * 快判：文本里没有任何 markdown 语法特征 → 跳过 lexer，直接按 \n 切 prose
+ * （旧行为快路径；也避免纯中文叙述被 lexer 意外重排）。
+ */
+export function looksLikeMarkdown(text) {
+    return (/(^|\n)\s{0,3}(#{1,6}\s|```|>\s|[-*+]\s|\d+\.\s|(-{3,}|\*{3,})\s*(\n|$))/.test(text) || // 块级：标题/围栏/引用/列表/hr
+        /`[^`\n]+`|\*\*[^*\n]+\*\*|\[[^\]\n]+\]\([^)\n]+\)/.test(text) // 行内：codespan/加粗/链接
+    );
+}
+/**
+ * marked tokenizer 对 codespan/escape/text 做 HTML 实体转义
+ * （`a && b` → 'a &amp;&amp; b'）——终端不是 HTML，必须还原。
+ * 注意 &amp; 最后替换（否则 &amp;lt; 会被二次解码）。
+ */
+export function unescapeEntities(text) {
+    return text
+        .replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>')
+        .replace(/&quot;/g, '"')
+        .replace(/&#39;/g, "'")
+        .replace(/&amp;/g, '&');
+}
+/** 行内 tokens → 单条含 ANSI 的字符串。 */
+export function formatInlineTokens(tokens) {
+    let out = '';
+    for (const token of tokens) {
+        switch (token.type) {
+            case 'strong':
+                out += bold(formatInlineTokens(token.tokens));
+                break;
+            case 'em':
+                out += italic(formatInlineTokens(token.tokens));
+                break;
+            case 'codespan':
+                out += cyan(unescapeEntities(token.text));
+                break;
+            case 'del':
+                // 删除线禁用：~xxx~ 常是"约等于"，原样输出
+                out += token.raw;
+                break;
+            case 'link': {
+                const link = token;
+                const label = link.tokens ? formatInlineTokens(link.tokens) : link.text;
+                out += label === link.href ? label : `${label} ${dim(`(${link.href})`)}`;
+                break;
+            }
+            case 'image':
+                out += `[图: ${token.text}]`;
+                break;
+            case 'br':
+                out += '\n';
+                break;
+            case 'escape':
+                out += unescapeEntities(token.text);
+                break;
+            case 'text': {
+                const t = token;
+                out += t.tokens ? formatInlineTokens(t.tokens) : unescapeEntities(t.text);
+                break;
+            }
+            default:
+                out += 'raw' in token ? token.raw : '';
+                break;
+        }
+    }
+    return out;
+}
+/** 把（可能含 ANSI 的）多行字符串切成 prose 行。 */
+function proseLines(text) {
+    return text.split('\n').map((line) => ({ text: line, kind: 'prose' }));
+}
+/** 单个块级 token → 展示行（导出供单测逐 token 断言）。 */
+export function formatBlockToken(token) {
+    switch (token.type) {
+        case 'code': {
+            // ★ 复制安全核心路径：代码行 = token.text 逐字节，围栏行单独标 kind
+            const code = token;
+            return [
+                { text: `\`\`\`${code.lang ?? ''}`, kind: 'fence' },
+                ...code.text.split('\n').map((line) => ({ text: line, kind: 'code' })),
+                { text: '```', kind: 'fence' },
+            ];
+        }
+        case 'heading': {
+            const heading = token;
+            const inner = formatInlineTokens(heading.tokens);
+            return [{ text: heading.depth === 1 ? bold(underline(inner)) : bold(inner), kind: 'prose' }];
+        }
+        case 'paragraph':
+            return proseLines(formatInlineTokens(token.tokens));
+        case 'list': {
+            const list = token;
+            const lines = [];
+            const start = typeof list.start === 'number' ? list.start : 1;
+            list.items.forEach((item, i) => {
+                const bullet = list.ordered ? `${start + i}. ` : '- ';
+                const pad = ' '.repeat(bullet.length);
+                let firstLineDone = false;
+                for (const sub of item.tokens) {
+                    if (sub.type === 'code') {
+                        // 列表内代码块：零装饰优先于列表对齐（不缩进，保住复制安全）
+                        lines.push(...formatBlockToken(sub));
+                        continue;
+                    }
+                    if (sub.type === 'list') {
+                        // 嵌套列表：整体缩进对齐父 bullet（不走 firstLine 逻辑，避免双重缩进）
+                        lines.push(...formatBlockToken(sub).map((l) => l.kind === 'prose' ? { ...l, text: `${pad}${l.text}` } : l));
+                        continue;
+                    }
+                    const subLines = proseLines(sub.type === 'text' || sub.type === 'paragraph'
+                        ? formatInlineTokens(sub.tokens ?? [sub])
+                        : 'raw' in sub
+                            ? sub.raw
+                            : '');
+                    for (const l of subLines) {
+                        if (l.kind !== 'prose') {
+                            lines.push(l);
+                        }
+                        else if (!firstLineDone) {
+                            lines.push({ text: `${bullet}${l.text}`, kind: 'prose' });
+                            firstLineDone = true;
+                        }
+                        else {
+                            lines.push({ text: `${pad}${l.text}`, kind: 'prose' });
+                        }
+                    }
+                }
+                if (!firstLineDone)
+                    lines.push({ text: bullet.trimEnd(), kind: 'prose' });
+            });
+            return lines;
+        }
+        case 'blockquote': {
+            const quote = token;
+            const inner = quote.tokens.flatMap(formatBlockToken);
+            // 引用竖条只加在 prose 行；引用内代码块保持零装饰
+            return inner.map((l) => l.kind === 'prose' ? { ...l, text: `${dim(`${figures.quote} `)}${l.text}` } : l);
+        }
+        case 'space':
+            return [{ text: '', kind: 'prose' }];
+        case 'hr':
+            return [{ text: dim(figures.hr.repeat(20)), kind: 'prose' }];
+        case 'table':
+            // TODO：flexbox 对齐表格（捐赠方 MarkdownTable 模式）；第一期原样透传
+            return proseLines(token.raw.trimEnd());
+        default:
+            return 'raw' in token
+                ? proseLines(token.raw.replace(/\n+$/, ''))
+                : [];
+    }
+}
+/**
+ * 主入口：assistant 正文 → 展示行。
+ * 纯文本走快路径（与旧渲染逐行一致）；lexer 意外抛错时兜底回退原文
+ * （模型输出任意性防御——格式化是锦上添花，绝不能让渲染崩掉消息）。
+ */
+export function renderMarkdownLines(src) {
+    if (src.length === 0)
+        return [];
+    if (!looksLikeMarkdown(src))
+        return proseLines(src);
+    try {
+        return lexer(src).flatMap(formatBlockToken);
+    }
+    catch {
+        return proseLines(src);
+    }
+}

package/src/ui/textBuffer.js

@@ -79,13 +79,6 @@ export function bufDeleteBefore(s) {
     cps.splice(s.cursor - 1, 1);
     return { text: fromCps(cps), cursor: s.cursor - 1 };
 }
-export function bufDeleteAt(s) {
-    const cps = toCps(s.text);
-    if (s.cursor >= cps.length)
-        return s;
-    cps.splice(s.cursor, 1);
-    return { text: fromCps(cps), cursor: s.cursor };
-}
 /**
  * Ctrl+W / M-DEL：先吃光标左侧的非词字符（空格 / 标点），再吃前一个词。
  * 例：光标贴在 "world" 后 → 删 'world'，留 "hello   "。

package/src/ui/theme.js

@@ -0,0 +1,32 @@
+/**
+ * ============================================================
+ *  src/ui/theme.ts —— TUI 语义色板（单一出处）
+ * ------------------------------------------------------------
+ *  借鉴 Claude Code 的语义化主题键思想（utils/theme.ts），按 minimal-agent
+ *  减法原则收敛为 7 个键：组件里写"这段文字是什么角色"（theme.subtle），
+ *  不写"这段文字是什么颜色"（'gray'）——改配色只动这一个文件。
+ *
+ *  值是 Ink <Text color=...> 的合法取值；undefined = 终端默认前景色。
+ *  事实调色板（与重构前完全一致，机械替换零行为变化）：
+ *    - 层次靠三级区分：subtle+dimColor（次要：思维链/工具/进度）
+ *      ↔ answer 默认亮色（主角：最终答案）↔ user/plugin bold（状态行）。
+ * ============================================================
+ */
+export const theme = {
+    /** 用户输入 / banner / 状态行 spinner / 输入框边框 */
+    user: 'cyan',
+    /** 最终答案正文 —— undefined = 终端默认亮色（答案是主角，不染色） */
+    answer: undefined,
+    /** ⏺ 答案锚点（配 bold） */
+    anchor: 'green',
+    /** 次要信息：思维链 / 工具结果 / turn 横线 / live 过程区（配 dimColor） */
+    subtle: 'gray',
+    /** 暂态提示 / tool_calls 摘要 / 中断提示 */
+    warning: 'yellow',
+    /** 永久错误 */
+    error: 'red',
+    /** 健康/正常状态（StatusLine 用量比率等） */
+    ok: 'green',
+    /** compacting 状态 / 插件进度 / reverse-search */
+    plugin: 'magenta',
+};

package/src/utils/debugLog.js

@@ -18,10 +18,6 @@
  */
 import { appendFileSync } from 'node:fs';
 const LOG_PATH = process.env.MINIMAL_AGENT_DEBUG_LOG;
-/** 调试日志是否开启（供调用方决定要不要算开销较大的 data）。 */
-export function isDebugLogOn() {
-    return !!LOG_PATH;
-}
 /**
  * 追加一行调试日志：`<ISO 时间> [tag] msg {data}`。
  * 未开启（无 MINIMAL_AGENT_DEBUG_LOG）时立即返回。

package/src/utils/resourcePaths.js

@@ -30,9 +30,9 @@ import { findPackageRoot } from './packageRoot.js';
  * @param metaUrl  调用方 import.meta.url（用于定位 packageRoot）
  * @returns        存在的搜索路径数组；都不存在则返回空数组
  */
-export function getResourceSearchPaths(name, metaUrl) {
+export function getResourceSearchPaths(name, metaUrl, workingDir = getWorkingDir()) {
     const paths = [];
-    const cwdPath = resolve(join(getWorkingDir(), name));
+    const cwdPath = resolve(join(workingDir, name));
     if (existsSync(cwdPath)) {
         paths.push(cwdPath);
     }

package/src/utils/stripThink.js

@@ -0,0 +1,50 @@
+/**
+ * ============================================================
+ *  src/utils/stripThink.ts —— 剥离模型直出的 <think> 思维链块
+ * ------------------------------------------------------------
+ *  自 plugins/workflow-runner/src/agentCommon.ts 迁入内核：Agent 子任务工具
+ *  （src/tools/agent/）提取子 agent 报告时同样需要净化,而内核不能 import
+ *  插件（三层解耦红线）,故共享件上移、插件侧改经 plugin-sdk re-export。
+ * ============================================================
+ */
+/**
+ * 展示层切分：把 content 里模型直出的 <think> 段与正文分离。
+ * MessageList 用它把内联思维链并入 💭 块（gray dim 折叠展示），正文只显示
+ * 净化后的部分——**纯函数不 mutate 入参，history 字节零改动**（KV 缓存约束：
+ * 内核有意在 client.ts 保留内联 think 进 content，展示层各取所需）。
+ *   - 闭合块（可多个、跨行、大小写不敏感）→ 依序拼进 thought
+ *   - 剥完仍以未闭合 <think> 开头 → 余下全部视为 thought，answer=''
+ *   - 无 <think> → { thought: '', answer: text }（answer 与原文逐字节相同，
+ *     快路径：调用方可据此走旧渲染逻辑）
+ */
+export function splitThinkBlocks(text) {
+    if (!/<think>/i.test(text))
+        return { thought: '', answer: text };
+    const thoughts = [];
+    const answer = text.replace(/<think>([\s\S]*?)<\/think>/gi, (_m, inner) => {
+        const t = inner.trim();
+        if (t)
+            thoughts.push(t);
+        return '';
+    });
+    // 剥完闭合块后仍以未闭合 <think> 开头 → 余下整段都是思考
+    const unclosed = /^\s*<think>/i.exec(answer);
+    if (unclosed) {
+        const rest = answer.replace(/^\s*<think>/i, '').trim();
+        if (rest)
+            thoughts.push(rest);
+        return { thought: thoughts.join('\n'), answer: '' };
+    }
+    return { thought: thoughts.join('\n'), answer };
+}
+/**
+ * 剥离模型直出的思维链标签块（MiniMax 等把 <think>…</think> 写进 content，
+ * 不走 reasoning_content 通道）。不剥离的话 capture 变量 / goal_supplement
+ * 补充要求 / preview / 子 agent 报告全带思考噪音——曾真实发生：
+ * supplements.json 首条是 240 字符英文 think 片段，随目标锚注入了后续每一步。
+ * 现为 splitThinkBlocks 的薄封装（单一事实来源），语义与旧实现逐 case 等价：
+ * 删除闭合块、未闭合开头整段判思考返回空串、结果 trim。
+ */
+export function stripThinkBlocks(text) {
+    return splitThinkBlocks(text).answer.trim();
+}