mocode-ai 0.6.6 → 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/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/search.js

@@ -1,68 +1,134 @@
-const GREP_RE = /^(.*?):(\d+):(.*)$/;
+const LEGACY_GREP_RE = /^(.*?):(\d+):(.*)$/;
+const STRUCTURED_HEADER_RE = /^(.*): (\d+) 处匹配,行号 \[([0-9,\s]+)\]$/;
+const STRUCTURED_BODY_RE = /^\s{2}L\d+:/;
+const STRUCTURED_FOLDED_RE = /^\s{2}\(body 已折叠/;
+function isAgedCold(input) {
+    return input.phase === 'sweep' && input.isCold === true && (input.age ?? 0) >= 2;
+}
+/** Current grep output already has lossless file headers; Cold drops body previews only. */
+function collapseStructuredGrep(output) {
+    const lines = output.split('\n');
+    const out = [];
+    let files = 0;
+    let inFile = false;
+    for (const line of lines) {
+        if (STRUCTURED_HEADER_RE.test(line)) {
+            files++;
+            inFile = true;
+            out.push(line);
+            continue;
+        }
+        if (inFile && (STRUCTURED_BODY_RE.test(line) || STRUCTURED_FOLDED_RE.test(line))) {
+            continue;
+        }
+        inFile = false;
+        out.push(line);
+    }
+    return files > 0 ? { text: out.join('\n'), files } : null;
+}
+function encodeLegacyGrep(output) {
+    const lines = output.split('\n');
+    const matches = [];
+    const tail = [];
+    let inTail = false;
+    for (const line of lines) {
+        if (!line)
+            continue;
+        if (inTail) {
+            tail.push(line);
+            continue;
+        }
+        const match = LEGACY_GREP_RE.exec(line);
+        if (match) {
+            matches.push({ file: match[1], line: match[2], content: match[3] });
+        }
+        else {
+            inTail = true;
+            tail.push(line);
+        }
+    }
+    if (matches.length === 0)
+        return null;
+    const groups = new Map();
+    const order = [];
+    for (const match of matches) {
+        if (!groups.has(match.file)) {
+            groups.set(match.file, []);
+            order.push(match.file);
+        }
+        groups.get(match.file).push({ line: match.line, content: match.content });
+    }
+    const out = [`# ${matches.length} matches · ${order.length} files · search-encoded`];
+    for (const file of order) {
+        out.push(`${file}:`);
+        for (const item of groups.get(file))
+            out.push(`  ${item.line}:${item.content}`);
+    }
+    if (tail.length)
+        out.push(...tail);
+    return { text: out.join('\n'), matches: matches.length, files: order.length };
+}
+function collapseLegacyBodies(text) {
+    if (!text.startsWith('# ') || !text.includes('search-encoded'))
+        return text;
+    return text
+        .split('\n')
+        .filter((line) => !/^\s{2}\d+:/.test(line))
+        .join('\n');
+}
 export const searchEncoder = {
     kind: 'search',
-    encode({ output }) {
-        const lines = output.split('\n');
-        const matches = [];
-        const tail = [];
-        let inTail = false;
-        for (const l of lines) {
-            if (!l)
-                continue;
-            if (inTail) {
-                tail.push(l);
-                continue;
-            }
-            const m = GREP_RE.exec(l);
-            if (m) {
-                matches.push({ file: m[1], line: m[2], content: m[3] });
-            }
-            else {
-                // 首个非 grep 行起视作 tail(grep 上限标记 / 无匹配串 / web_search 非 grep 结构)
-                inTail = true;
-                tail.push(l);
-            }
-        }
-        if (matches.length === 0) {
-            // 非 grep 格式(web_search 等)→ 不动其已格式化结构
+    encode(input) {
+        const structured = collapseStructuredGrep(input.output);
+        if (structured) {
+            const text = isAgedCold(input) ? structured.text : input.output;
             return {
-                text: output,
+                text,
                 meta: {
                     kind: 'search',
-                    originalLen: output.length,
-                    encodedLen: output.length,
-                    note: 'no file:line matches → passthrough',
+                    originalLen: input.output.length,
+                    encodedLen: text.length,
+                    note: isAgedCold(input)
+                        ? `${structured.files} files · Cold body previews removed`
+                        : `${structured.files} structured grep files · passthrough`,
                 },
             };
         }
-        const groups = new Map();
-        const order = [];
-        for (const m of matches) {
-            if (!groups.has(m.file)) {
-                groups.set(m.file, []);
-                order.push(m.file);
-            }
-            groups.get(m.file).push({ line: m.line, content: m.content });
+        // A previous pass may already have transformed legacy file:line output.
+        if (input.output.startsWith('# ') && input.output.includes('search-encoded')) {
+            const text = isAgedCold(input) ? collapseLegacyBodies(input.output) : input.output;
+            return {
+                text,
+                meta: {
+                    kind: 'search',
+                    originalLen: input.output.length,
+                    encodedLen: text.length,
+                    note: isAgedCold(input) ? 'Cold legacy bodies removed' : 'already encoded',
+                },
+            };
         }
-        const out = [
-            `# ${matches.length} matches · ${order.length} files · search-encoded`,
-        ];
-        for (const file of order) {
-            out.push(`${file}:`);
-            for (const { line, content } of groups.get(file)) {
-                out.push(`  ${line}:${content}`);
-            }
+        const legacy = encodeLegacyGrep(input.output);
+        if (!legacy) {
+            return {
+                text: input.output,
+                meta: {
+                    kind: 'search',
+                    originalLen: input.output.length,
+                    encodedLen: input.output.length,
+                    note: 'no recognized grep structure → passthrough',
+                },
+            };
         }
-        if (tail.length)
-            out.push(...tail);
-        const text = out.join('\n');
+        const text = isAgedCold(input)
+            ? collapseLegacyBodies(legacy.text)
+            : legacy.text;
         return {
             text,
             meta: {
                 kind: 'search',
-                originalLen: output.length,
+                originalLen: input.output.length,
                 encodedLen: text.length,
-                note: `${matches.length} matches / ${order.length} files`,
+                note: `${legacy.matches} matches / ${legacy.files} files${isAgedCold(input) ? ' · Cold bodies removed' : ''}`,
             },
         };
     },

package/dist/context/index.js

@@ -8,4 +8,4 @@ export { optimizeToolResult } from './pipeline.js';
 export { classify, knownToolKinds } from './classifier.js';
 export { registerEncoder, registerAll, getEncoder, registeredKinds, } from './registry.js';
 // ── Context Budget Scheduler ───────────────────────────────────────────────
-export { evaluateBudget, scheduleActions, formatReport, quickEstimate, userTurnBoundary, BUDGET_LAYERS, BUDGET_RATIO, HOT_TURN_WINDOW, TOOL_OLD_AGE, } from './budget.js';
+export { evaluateBudget, scheduleActions, formatReport, quickEstimate, userTurnBoundary, BUDGET_LAYERS, DEFAULT_BUDGET_POLICY, BUDGET_RATIO, HOT_TURN_WINDOW, TOOL_OLD_AGE, } from './budget.js';

package/dist/context/pipeline.js

@@ -58,7 +58,7 @@ function budgetFor(name) {
  * @param argsRaw 工具 arguments 原始 JSON 字符串(tc.arguments,可空;未传则 args=null)
  * @returns 进 history 的 content 字符串(永不抛错)
  */
-export function optimizeToolResult(name, output, argsRaw) {
+export function optimizeToolResult(name, output, argsRaw, context = {}) {
     boot();
     // 总开关关闭:完全走老路径,零行为变化(Phase 1 默认 true,但保留紧急回退开关)。
     if (!config.contextOptimize) {
@@ -73,6 +73,10 @@ export function optimizeToolResult(name, output, argsRaw) {
             output,
             args,
             budget: budgetFor(name),
+            age: context.age ?? 0,
+            isCold: context.isCold ?? false,
+            isFirstRead: context.isFirstRead,
+            phase: context.phase ?? 'push',
         });
         // 末尾长度裁剪兜底(同改造前):encoder 已更短则 no-op;use_skill/memory_search 的放宽 cap 由此保留。
         return capToolResultForHistory(name, text);