mocode-ai 0.6.5 → 0.6.7

package/dist/context/encoders/code.js

@@ -1,76 +1,202 @@
-/**
- * Code Encoder(read_file):折叠连续空行(≥3 → 1,保留首空行行号前缀)。
- *
- * 输入:read_file 返回的 `     N\t<content>` 行(6 宽右对齐行号 + tab + 内容),可能带尾部
- *  `... (N 行未显示,共 M 行)`。
- * 输出:连续 ≥3 个空行(行号前缀 + 空 content)折叠为 1 个(保留首行前缀,丢后续空行);其余逐字保留。
- *
- * 不变量(离线脚本断言):
- *  - 所有非空 content 行逐字保留(前缀 + 内容不变)→ edit_file 的 old_string 按内容匹配仍可用。
- *  - content 行的行号前缀不变 → LLM 看到的行号与文件一致。
- *  - 仅空行(前缀 + tab + 空 content)被折叠,且仅 ≥3 连续时;≤2 空行原样(常见,不动)。
- *  - 尾部标记 `... (...)` 不匹配行号前缀,原样保留。
- *
- * ⚠️ 残余风险(可接受、可恢复):若 LLM 编辑一个含 ≥3 连续空行的区域,它看到的空行数比文件实际少,
- *   old_string 的空行数可能不匹配 → edit_file 返"未找到" → LLM 重读重试(系统提示已要求编辑前 read_file)。
- *   真实代码极少 ≥3 连续空行(linter 通常强制 ≤2),故实际几乎不触发。出问题可设
- *   MOCODE_CONTEXT_OPTIMIZE=false 全局回退,或调高阈值。
- *
- * 不做长度裁剪(cap 兜底);不动行号前缀;不删 content 行;不改内容(含尾随空白)。
- * 空行判定用前缀感知(前缀 + tab + 空 content),不能用 trim——read_file 空行 `     2\t` trim 后剩 `2`。
- */
+/** read_file line: right-aligned source line number + tab + exact content. */
 const LINE_RE = /^(\s*\d+)\t(.*)$/;
-function isBlankCodeLine(l) {
-    const m = LINE_RE.exec(l);
-    return m ? m[2] === '' : false;
+const JS_LIKE_PATH_RE = /\.(?:[cm]?js|jsx|ts|tsx)$/i;
+function parseLine(raw) {
+    const match = LINE_RE.exec(raw);
+    if (!match)
+        return null;
+    return { raw, line: Number(match[1].trim()), content: match[2] };
 }
-export const codeEncoder = {
-    kind: 'code',
-    encode({ output }) {
-        const lines = output.split('\n');
-        const out = [];
-        let i = 0;
-        let collapsedRuns = 0;
-        while (i < lines.length) {
-            if (isBlankCodeLine(lines[i])) {
-                let j = i;
-                while (j < lines.length && isBlankCodeLine(lines[j]))
-                    j++;
-                const run = j - i;
-                if (run >= 3) {
-                    out.push(lines[i]); // 保留首空行(含其行号前缀)
-                    collapsedRuns++;
-                }
-                else {
-                    for (let k = 0; k < run; k++)
-                        out.push(lines[i]);
-                }
-                i = j;
+function collapseBlankCodeRuns(output) {
+    const lines = output.split('\n');
+    const out = [];
+    let collapsed = 0;
+    let i = 0;
+    while (i < lines.length) {
+        if (parseLine(lines[i])?.content === '') {
+            let j = i;
+            while (j < lines.length && parseLine(lines[j])?.content === '')
+                j++;
+            if (j - i >= 3) {
+                out.push(lines[i]);
+                collapsed++;
             }
             else {
-                out.push(lines[i]);
+                for (let k = i; k < j; k++)
+                    out.push(lines[k]);
+            }
+            i = j;
+            continue;
+        }
+        out.push(lines[i++]);
+    }
+    return { text: out.join('\n'), collapsed };
+}
+function isJsLikePath(args) {
+    return typeof args?.path === 'string' && JS_LIKE_PATH_RE.test(args.path);
+}
+function isSingleLineImport(content) {
+    const line = content.trim();
+    return /^import\b/.test(line) && /(?:['"][^'"]+['"]\s*;?|;)$/.test(line);
+}
+function collapseImportBlocks(text) {
+    const lines = text.split('\n');
+    const out = [];
+    let collapsed = 0;
+    let i = 0;
+    while (i < lines.length) {
+        const first = parseLine(lines[i]);
+        if (!first || !isSingleLineImport(first.content)) {
+            out.push(lines[i++]);
+            continue;
+        }
+        let j = i + 1;
+        while (j < lines.length) {
+            const next = parseLine(lines[j]);
+            if (!next || !isSingleLineImport(next.content))
+                break;
+            j++;
+        }
+        const run = j - i;
+        if (run >= 4) {
+            const last = parseLine(lines[j - 1]);
+            out.push(lines[i]);
+            out.push(`… ${run - 2} import lines folded (source lines ${first.line + 1}–${last.line - 1}; cold read)`);
+            out.push(lines[j - 1]);
+            collapsed++;
+        }
+        else {
+            for (let k = i; k < j; k++)
+                out.push(lines[k]);
+        }
+        i = j;
+    }
+    const result = out.join('\n');
+    return result.length < text.length
+        ? { text: result, collapsed }
+        : { text, collapsed: 0 };
+}
+function braceDelta(line, state) {
+    let delta = 0;
+    for (let i = 0; i < line.length; i++) {
+        const ch = line[i];
+        const next = line[i + 1];
+        if (state.blockComment) {
+            if (ch === '*' && next === '/') {
+                state.blockComment = false;
                 i++;
             }
+            continue;
+        }
+        if (state.quote) {
+            if (state.escaped) {
+                state.escaped = false;
+            }
+            else if (ch === '\\') {
+                state.escaped = true;
+            }
+            else if (ch === state.quote) {
+                state.quote = null;
+            }
+            continue;
+        }
+        if (ch === '/' && next === '/')
+            break;
+        if (ch === '/' && next === '*') {
+            state.blockComment = true;
+            i++;
+            continue;
+        }
+        if (ch === "'" || ch === '"' || ch === '`') {
+            state.quote = ch;
+            state.escaped = false;
+            continue;
+        }
+        if (ch === '{')
+            delta++;
+        else if (ch === '}')
+            delta--;
+    }
+    state.escaped = false;
+    return delta;
+}
+function isFunctionStart(content) {
+    return (/^\s*(?:export\s+)?(?:default\s+)?(?:async\s+)?function(?:\s+[\w$]+)?\s*\(/.test(content) ||
+        /^\s*(?:export\s+)?(?:const|let|var)\s+[\w$]+\s*=.*=>\s*\{\s*$/.test(content) ||
+        /^\s*(?:(?:public|private|protected|static|abstract|override|async|get|set)\s+)*(?:constructor|[\w$]+)\s*\([^;]*\)\s*(?::[^={]+)?\s*\{\s*$/.test(content));
+}
+function collapseFunctionBodies(text) {
+    const lines = text.split('\n');
+    const out = [];
+    let collapsed = 0;
+    let i = 0;
+    while (i < lines.length) {
+        const start = parseLine(lines[i]);
+        if (!start || !isFunctionStart(start.content)) {
+            out.push(lines[i++]);
+            continue;
         }
-        if (collapsedRuns === 0) {
-            return {
-                text: output,
-                meta: {
-                    kind: 'code',
-                    originalLen: output.length,
-                    encodedLen: output.length,
-                    note: 'no ≥3 blank runs → passthrough',
-                },
-            };
+        const state = { quote: null, escaped: false, blockComment: false };
+        let depth = braceDelta(start.content, state);
+        if (depth <= 0) {
+            out.push(lines[i++]);
+            continue;
+        }
+        let j = i + 1;
+        for (; j < lines.length && depth > 0; j++) {
+            const current = parseLine(lines[j]);
+            if (!current)
+                break;
+            depth += braceDelta(current.content, state);
+        }
+        const endIndex = j - 1;
+        const end = parseLine(lines[endIndex] ?? '');
+        const bodyLines = endIndex - i - 1;
+        if (depth === 0 && end && bodyLines >= 8) {
+            out.push(lines[i]);
+            out.push(`… ${bodyLines} function-body lines folded (source lines ${start.line + 1}–${end.line - 1}; cold read)`);
+            out.push(lines[endIndex]);
+            collapsed++;
+            i = j;
+        }
+        else {
+            out.push(lines[i++]);
+        }
+    }
+    const result = out.join('\n');
+    return result.length < text.length
+        ? { text: result, collapsed }
+        : { text, collapsed: 0 };
+}
+export const codeEncoder = {
+    kind: 'code',
+    encode(input) {
+        const blankResult = collapseBlankCodeRuns(input.output);
+        let text = blankResult.text;
+        const notes = [];
+        if (blankResult.collapsed)
+            notes.push(`collapsed ${blankResult.collapsed} blank runs`);
+        if (input.phase === 'sweep' &&
+            input.isCold === true &&
+            (input.age ?? 0) >= 2 &&
+            input.isFirstRead === false &&
+            isJsLikePath(input.args)) {
+            const imports = collapseImportBlocks(text);
+            text = imports.text;
+            if (imports.collapsed)
+                notes.push(`folded ${imports.collapsed} import blocks`);
+            const functions = collapseFunctionBodies(text);
+            text = functions.text;
+            if (functions.collapsed)
+                notes.push(`folded ${functions.collapsed} function bodies`);
         }
-        const text = out.join('\n');
         return {
             text,
             meta: {
                 kind: 'code',
-                originalLen: output.length,
+                originalLen: input.output.length,
                 encodedLen: text.length,
-                note: `collapsed ${collapsedRuns} blank runs (≥3 → 1)`,
+                note: notes.join(', ') || 'no change',
             },
         };
     },

package/dist/context/encoders/command.js

@@ -0,0 +1,201 @@
+import { stripAnsi } from './_util.js';
+const PAREN_DIAGNOSTIC = /^(.*)\((\d+),(\d+)\):\s*(error|warning|warn|fatal|note)\b\s*:?\s*(.*)$/i;
+const COL_DIAGNOSTIC = /^(.*):(\d+):(\d+):\s*(error|warning|warn|fatal|note)\b\s*:?\s*(.*)$/i;
+const LINE_DIAGNOSTIC = /^(.*):(\d+):\s*(error|warning|warn|fatal|note)\b\s*:?\s*(.*)$/i;
+const PASS_LINE = /^\s*(?:PASS\b|PASSED\b|✓|✔|✅|ok\b)/i;
+const FAIL_LINE = /^\s*(?:FAIL\b|FAILED\b|ERROR\b|✗|×|❌|not ok\b|●)/i;
+const TEST_SUMMARY = /^\s*(?:Test Suites?|Tests?|Ran\s+\d+|=+\s|\d+\s+(?:passed|failed|errors?))/i;
+const IMPORTANT_LINE = /\b(?:error|failed|failure|fatal|exception|panic)\b|not ok|[✗×❌]/i;
+const TEST_COMMAND = /\b(?:test|vitest|jest|pytest|mocha|ava|tap|cargo\s+test|go\s+test|dotnet\s+test)\b/i;
+function parseDiagnostic(line) {
+    const m = PAREN_DIAGNOSTIC.exec(line) ?? COL_DIAGNOSTIC.exec(line);
+    if (m) {
+        return { file: m[1], line: m[2], column: m[3], severity: m[4], message: m[5], continuation: [] };
+    }
+    const lineOnly = LINE_DIAGNOSTIC.exec(line);
+    if (!lineOnly)
+        return null;
+    return {
+        file: lineOnly[1],
+        line: lineOnly[2],
+        severity: lineOnly[3],
+        message: lineOnly[4],
+        continuation: [],
+    };
+}
+function splitStatus(text) {
+    const lines = text.split('\n');
+    const status = /^\[(?:退出码 [^\]]+|已中断|超时,已终止)\]$/.test(lines[0] ?? '')
+        ? lines.shift()
+        : null;
+    return { status, lines };
+}
+function formatDiagnostics(lines) {
+    const diagnostics = [];
+    const other = [];
+    let current = null;
+    for (const line of lines) {
+        const diagnostic = parseDiagnostic(line);
+        if (diagnostic) {
+            diagnostics.push(diagnostic);
+            current = diagnostic;
+        }
+        else if (current && (/^\s+/.test(line) || /^[\^~|]/.test(line))) {
+            current.continuation.push(line);
+        }
+        else {
+            current = null;
+            other.push(line);
+        }
+    }
+    if (diagnostics.length === 0)
+        return null;
+    const groups = new Map();
+    for (const diagnostic of diagnostics) {
+        const group = groups.get(diagnostic.file) ?? [];
+        group.push(diagnostic);
+        groups.set(diagnostic.file, group);
+    }
+    const errors = diagnostics.filter((d) => /^(?:error|fatal)$/i.test(d.severity)).length;
+    const warnings = diagnostics.filter((d) => /^(?:warning|warn)$/i.test(d.severity)).length;
+    const out = [`# Build diagnostics · ${diagnostics.length} issues · ${groups.size} files · command-encoded`];
+    if (errors || warnings)
+        out.push(`# ${errors} errors · ${warnings} warnings`);
+    for (const [file, items] of groups) {
+        out.push(`${file}:`);
+        for (const item of items) {
+            const location = item.column ? `${item.line}:${item.column}` : item.line;
+            out.push(`  ${location}: ${item.severity}${item.message ? `: ${item.message}` : ''}`);
+            for (const continuation of item.continuation)
+                out.push(`    ${continuation}`);
+        }
+    }
+    if (other.some((line) => line.length > 0))
+        out.push('# Other output', ...other);
+    return { text: out.join('\n'), count: diagnostics.length };
+}
+function formatTests(lines, command) {
+    const blocks = [];
+    const other = [];
+    let current = null;
+    let markers = 0;
+    for (const line of lines) {
+        const kind = FAIL_LINE.test(line) ? 'fail' : PASS_LINE.test(line) ? 'pass' : null;
+        if (kind) {
+            current = { kind, lines: [line] };
+            blocks.push(current);
+            markers++;
+        }
+        else if (current && line.length > 0 && /^\s+/.test(line) && !TEST_SUMMARY.test(line)) {
+            current.lines.push(line);
+        }
+        else {
+            current = null;
+            other.push(line);
+        }
+    }
+    if (markers === 0 || (markers < 2 && !TEST_COMMAND.test(command)))
+        return null;
+    const failed = blocks.filter((block) => block.kind === 'fail');
+    const passed = blocks.filter((block) => block.kind === 'pass');
+    const out = [`# Test results · ${passed.length} passed · ${failed.length} failed · command-encoded`];
+    if (failed.length) {
+        out.push(`# Failed tests (${failed.length})`);
+        for (const block of failed)
+            out.push(...block.lines);
+    }
+    if (passed.length) {
+        out.push(`# Passed tests (${passed.length})`);
+        for (const block of passed)
+            out.push(...block.lines);
+    }
+    if (other.some((line) => line.length > 0))
+        out.push('# Test summary / other output', ...other);
+    return { text: out.join('\n'), count: markers };
+}
+function collapseDuplicateLines(text) {
+    const lines = text.split('\n');
+    const out = [];
+    let runs = 0;
+    for (let i = 0; i < lines.length;) {
+        let end = i + 1;
+        while (end < lines.length && lines[end] === lines[i])
+            end++;
+        const count = end - i;
+        if (count >= 3) {
+            out.push(`${lines[i]}  [×${count}]`);
+            runs++;
+        }
+        else {
+            for (let j = i; j < end; j++)
+                out.push(lines[j]);
+        }
+        i = end;
+    }
+    return { text: out.join('\n'), runs };
+}
+function errorTail(text, max) {
+    if (max <= 0)
+        return '';
+    const lines = text.split('\n');
+    let important = -1;
+    for (let i = lines.length - 1; i >= 0; i--) {
+        if (IMPORTANT_LINE.test(lines[i])) {
+            important = i;
+            break;
+        }
+    }
+    if (important < 0)
+        return text.slice(-max);
+    const fromError = lines.slice(Math.max(0, important - 1)).join('\n');
+    if (fromError.length <= max)
+        return fromError;
+    const joiner = '\n…[错误详情中段省略]…\n';
+    const errorHead = Math.max(0, Math.floor((max - joiner.length) * 0.65));
+    const finalTail = Math.max(0, max - joiner.length - errorHead);
+    return fromError.slice(0, errorHead) + joiner + fromError.slice(-finalTail);
+}
+function truncateCommand(text, budget) {
+    if (!budget || text.length <= budget)
+        return { text, truncated: false };
+    const marker = '\n…[command 输出已结构化截断；保留开头与错误尾部]…\n';
+    const available = budget - marker.length;
+    if (available <= 0)
+        return { text: marker.slice(0, budget), truncated: true };
+    const headSize = Math.floor(available * 0.45);
+    const tailSize = available - headSize;
+    return {
+        text: text.slice(0, headSize) + marker + errorTail(text, tailSize),
+        truncated: true,
+    };
+}
+/** run_command 专用 encoder：构建诊断分文件、测试结果分 pass/fail，并按错误尾部优先截断。 */
+export const commandEncoder = {
+    kind: 'log',
+    encode({ output, args, budget }) {
+        const stripped = stripAnsi(output).replace(/\r\n?/g, '\n');
+        const { status, lines } = splitStatus(stripped);
+        const command = typeof args?.command === 'string' ? args.command : '';
+        const diagnostics = formatDiagnostics(lines);
+        const tests = diagnostics ? null : formatTests(lines, command);
+        const structured = diagnostics?.text ?? tests?.text ?? lines.join('\n');
+        const withStatus = status ? `${status}\n${structured}` : structured;
+        const collapsed = collapseDuplicateLines(withStatus);
+        const fitted = truncateCommand(collapsed.text, budget);
+        const mode = diagnostics ? `build:${diagnostics.count}` : tests ? `tests:${tests.count}` : 'generic';
+        const notes = [mode, 'ANSI stripped'];
+        if (collapsed.runs)
+            notes.push(`${collapsed.runs} dup runs collapsed`);
+        if (fitted.truncated)
+            notes.push('head+error-tail truncated');
+        return {
+            text: fitted.text,
+            meta: {
+                kind: 'log',
+                originalLen: output.length,
+                encodedLen: fitted.text.length,
+                note: notes.join(', '),
+            },
+        };
+    },
+};

package/dist/context/encoders/graph.js

@@ -1,30 +1,80 @@
 import { stripAnsi, collapseBlankRuns } from './_util.js';
-/**
- * Graph Encoder(codegraph):去 ANSI + 折叠连续空行(≥3 → 1)。
- *
- * 输入:codegraph CLI 返回的 `[退出码 N]\n<源码 + 调用路径>`(可能含 ANSI 颜色、多余空行)。
- * 输出:去 ANSI + 空行折叠;结构(调用路径块、源码段)不动。
- *
- * 不变量:退出码行保留;源码与调用路径文本逐字保留(仅去颜色码 + 折叠空行);不删内容行。
- * 保守:不重构调用路径 / 不去重源码(codegraph CLI 输出格式未稳定,需先采样真实输出定不变量,留后续)。
- */
+function isAgedCold(input) {
+    return input.phase === 'sweep' && input.isCold === true && (input.age ?? 0) >= 2;
+}
+function normalizeBlock(block) {
+    return block
+        .replace(/\r\n/g, '\n')
+        .split('\n')
+        .map((line) => line.trimEnd())
+        .join('\n')
+        .trim();
+}
+function dedupeFencedBlocks(text) {
+    const seen = new Set();
+    let removed = 0;
+    const result = text.replace(/```[^\n]*\n[\s\S]*?\n```/g, (block) => {
+        const key = normalizeBlock(block);
+        if (key.length < 120 || !seen.has(key)) {
+            seen.add(key);
+            return block;
+        }
+        removed++;
+        return '… duplicate source block omitted (cold graph)';
+    });
+    return { text: result, removed };
+}
+function looksLikeSourceBlock(block) {
+    const lines = block.split('\n');
+    const sourceLines = lines.filter((line) => /^\s*\d+\t/.test(line) ||
+        /^\s*(?:L)?\d+[:|]\s/.test(line) ||
+        /^.*:\d+(?::\d+)?:\s/.test(line)).length;
+    return block.length >= 120 && sourceLines >= 3;
+}
+function dedupeParagraphSourceBlocks(text) {
+    const parts = text.split(/(\n{2,})/);
+    const seen = new Set();
+    let removed = 0;
+    for (let i = 0; i < parts.length; i += 2) {
+        const block = parts[i];
+        if (!looksLikeSourceBlock(block))
+            continue;
+        const key = normalizeBlock(block);
+        if (seen.has(key)) {
+            parts[i] = '… duplicate source block omitted (cold graph)';
+            removed++;
+        }
+        else {
+            seen.add(key);
+        }
+    }
+    return { text: parts.join(''), removed };
+}
 export const graphEncoder = {
     kind: 'graph',
-    encode({ output }) {
-        const stripped = stripAnsi(output);
-        const text = collapseBlankRuns(stripped, 3);
-        const hadAnsi = /\x1b/.test(output);
-        const hadBlanks = text !== stripped;
-        const note = [hadAnsi ? 'ANSI stripped' : '', hadBlanks ? 'blank runs collapsed' : '']
-            .filter(Boolean)
-            .join(', ') || 'no change';
+    encode(input) {
+        const stripped = stripAnsi(input.output);
+        let text = stripped;
+        let duplicates = 0;
+        if (isAgedCold(input)) {
+            const fenced = dedupeFencedBlocks(text);
+            const paragraphs = dedupeParagraphSourceBlocks(fenced.text);
+            text = paragraphs.text;
+            duplicates = fenced.removed + paragraphs.removed;
+        }
+        text = collapseBlankRuns(text, 3);
+        const notes = [
+            /\x1b/.test(input.output) ? 'ANSI stripped' : '',
+            text !== stripped && duplicates === 0 ? 'blank runs collapsed' : '',
+            duplicates > 0 ? `${duplicates} duplicate source blocks omitted` : '',
+        ].filter(Boolean);
         return {
             text,
             meta: {
                 kind: 'graph',
-                originalLen: output.length,
+                originalLen: input.output.length,
                 encodedLen: text.length,
-                note,
+                note: notes.join(', ') || 'no change',
             },
         };
     },

package/dist/context/encoders/index.js

@@ -11,7 +11,7 @@
 import { passthroughEncoder } from './passthrough.js';
 import { treeEncoder } from './tree.js';
 import { searchEncoder } from './search.js';
-import { logEncoder } from './log.js';
+import { commandEncoder } from './command.js';
 import { tableEncoder } from './table.js';
 import { memoryEncoder } from './memory.js';
 import { codeEncoder } from './code.js';
@@ -22,7 +22,7 @@ export const builtinEncoders = [
     passthroughEncoder,
     treeEncoder,
     searchEncoder,
-    logEncoder,
+    commandEncoder,
     tableEncoder,
     memoryEncoder,
     codeEncoder,

package/dist/context/encoders/log.js

@@ -1,52 +1,2 @@
-/**
- * Log Encoder(run_command):去 ANSI 颜色码 + 折叠连续重复行(≥3 → 单行 + [×N])。
- *
- * 输入:run_command 返回的 `[退出码 N]\n<合并 stdout+stderr>`,可能含 ANSI(tsc --pretty / 测试框架)、
- *  重复行(构建 / 编译日志)、尾部 `...(输出已截断)`、`[已中断]` / `[超时,已终止]` 前缀。
- * 输出:去 ANSI CSI 序列 + 连续重复行折叠;行顺序不变(退出码头恒在首、错误行与尾部原位保留)。
- *
- * 不变量(离线脚本断言):退出码行 `[退出码 N]` / `[已中断]` / `[超时,已终止]` 保留;
- *  重复行以 `[×N]` 标注计数(语义不丢——LLM 仍知该行重复 N 次);ANSI 去除语义无损(颜色码不含信息)。
- * 不做长度裁剪(由 pipeline 末尾 capToolResultForHistory 兜底 head+标记+tail,与改造前一致)。
- * run ≤2 原样保留(常见输出不必标注,避免噪音);run ≥3 才折叠(真正的大规模重复才省)。
- */
-const ANSI_RE = /\x1b\[[0-9;]*[A-Za-z]/g;
-export const logEncoder = {
-    kind: 'log',
-    encode({ output }) {
-        // 去 ANSI CSI 序列(颜色 / 光标 / 清屏等),保留所有可见文本。
-        const stripped = output.replace(ANSI_RE, '');
-        const lines = stripped.split('\n');
-        // 折叠连续重复行:run ≥3 → 单行 + [×N];run ≤2 原样。
-        const out = [];
-        let i = 0;
-        let collapsedRuns = 0;
-        while (i < lines.length) {
-            let j = i;
-            while (j < lines.length && lines[j] === lines[i])
-                j++;
-            const run = j - i;
-            if (run >= 3) {
-                out.push(`${lines[i]}  [×${run}]`);
-                collapsedRuns++;
-            }
-            else {
-                for (let k = 0; k < run; k++)
-                    out.push(lines[i]);
-            }
-            i = j;
-        }
-        const text = out.join('\n');
-        return {
-            text,
-            meta: {
-                kind: 'log',
-                originalLen: output.length,
-                encodedLen: text.length,
-                note: collapsedRuns > 0
-                    ? `ANSI stripped, ${collapsedRuns} dup runs collapsed`
-                    : 'ANSI stripped',
-            },
-        };
-    },
-};
+/** @deprecated 使用 commandEncoder；保留别名避免破坏已有直接导入。 */
+export { commandEncoder as logEncoder } from './command.js';