mocode-ai 1.7.10 → 1.7.11

package/dist/session/retention.js

@@ -12,6 +12,7 @@
 import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, statSync, unlinkSync, writeFileSync, } from 'node:fs';
 import path from 'node:path';
 import { gzipSync, gunzipSync } from 'node:zlib';
+import { COMPACTED_DIRNAME, isCompactedAssetName } from './compact-archive.js';
 import { TextSearchIndex } from '../context/text-search.js';
 import { config } from '../config/index.js';
 import { runReflection, snapshotTranscript } from '../memory/index.js';
@@ -174,15 +175,45 @@ export function planRetention(sessionsRoot, policy = DEFAULT_RETENTION_POLICY, n
     return { items, bytesReclaimable: items.reduce((s, i) => s + i.sizeBytes, 0) };
 }
 // ── 执行 ─────────────────────────────────────────────────────────────────
-/** 归档单个会话:读 session.json → gzip → 写 index → 删原目录。失败抛错由调用方统一处理。 */
+/** 收集 <id>/compacted/ 下白名单资产为 relPath → utf8;无/读失败返空对象。 */
+function readCompactedAssets(sessionsRoot, id) {
+    const dir = path.join(sessionsRoot, id, COMPACTED_DIRNAME);
+    const assets = {};
+    let names;
+    try {
+        names = readdirSync(dir, { withFileTypes: true })
+            .filter((e) => e.isFile())
+            .map((e) => e.name);
+    }
+    catch {
+        return assets;
+    }
+    for (const name of names) {
+        if (!isCompactedAssetName(name))
+            continue;
+        try {
+            assets[`${COMPACTED_DIRNAME}/${name}`] = readFileSync(path.join(dir, name), 'utf8');
+        }
+        catch {
+            // 单个资产读失败不拖垮归档。
+        }
+    }
+    return assets;
+}
+/** 归档单个会话:读 session.json(+compacted 资产)→ gzip → 写 index → 删原目录。失败抛错由调用方统一处理。 */
 function archiveSession(sessionsRoot, id, now) {
     const paths = retentionPaths(sessionsRoot);
     const dir = path.join(sessionsRoot, id);
     const sessionPath = path.join(dir, 'session.json');
     const record = JSON.parse(readFileSync(sessionPath, 'utf8'));
+    // 把压缩归档资产(seg/index/截断原文 blob)内嵌进 gz,避免 rmSync 目录时永久丢失
+    // ——否则 30 天后 resume,历史回捞链整体消失。purge 时随 gz 一起删。
+    const assets = readCompactedAssets(sessionsRoot, id);
+    if (Object.keys(assets).length > 0)
+        record.compactedAssets = assets;
     mkdirSync(paths.archiveDir, { recursive: true });
     const gzPath = path.join(paths.archiveDir, `${id}.json.gz`);
-    writeFileSync(gzPath + '.tmp', gzipSync(readFileSync(sessionPath)));
+    writeFileSync(gzPath + '.tmp', gzipSync(Buffer.from(JSON.stringify(record), 'utf8')));
     renameSync(gzPath + '.tmp', gzPath);
     upsertArchiveIndex(paths.indexPath, {
         id: record.id,

package/dist/session/store.js

@@ -3,8 +3,9 @@ import { AsyncLocalStorage } from 'node:async_hooks';
 import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, statSync, unlinkSync, writeFileSync, } from 'node:fs';
 import { gzipSync } from 'node:zlib';
 import path from 'node:path';
-import { MAX_TRACE_BYTES, MAX_TRACE_ROTATIONS } from '../tools/constants.js';
+import { MAX_TRACE_BYTES, MAX_TRACE_ROTATIONS, MAX_COMPACTED_ARCHIVE_BYTES } from '../tools/constants.js';
 import { loadArchivedSession, readArchiveIndex, retentionPaths } from './retention.js';
+import { COMPACTED_DIRNAME, isCompactedAssetName, parseSegmentMeta, renderArchiveIndex, renderCompactedSegment, resultBlobFileName, RESULT_BLOB_FILE_RE, SEGMENT_FILE_RE, } from './compact-archive.js';
 import { config, getActiveModel } from '../config/index.js';
 import { getWorkspaceRoot } from '../workspace/index.js';
 import { isToolRouteGroupName } from '../config/profiles.js';
@@ -46,6 +47,14 @@ function firstUserOf(history) {
     }
     return '';
 }
+/** compacted/ 总量上限:MOCODE_MAX_COMPACTED_BYTES 覆盖(供测试/小盘),非法值回退默认。 */
+function envMaxCompactedBytes() {
+    const raw = process.env.MOCODE_MAX_COMPACTED_BYTES;
+    if (!raw)
+        return MAX_COMPACTED_ARCHIVE_BYTES;
+    const n = Number(raw);
+    return Number.isFinite(n) && n >= 0 ? n : MAX_COMPACTED_ARCHIVE_BYTES;
+}
 /**
  * Runtime-local session persistence and identity.
  *
@@ -240,6 +249,175 @@ export class SessionStore {
             }
         }
     }
+    /**
+     * 压缩归档:把本次压缩丢弃的旧区消息渲染成 `compacted/seg-NNN.md`,
+     * 并重建 `compacted/index.md`。best-effort——这是压缩的增值能力,不是用户数据主副本
+     * (session.json 仍是主副本),任何失败静默降级,绝不阻塞压缩。
+     *
+     * 编号:扫描已有 seg-NNN.md 取 max+1(外部删除/重命名后仍单调)。
+     * 淘汰:全部 seg 总量超 MAX_COMPACTED_ARCHIVE_BYTES 时,从最老段硬删并重建 index。
+     * 目录缓存失真时与 appendTrace 同模式:清缓存重试一次。
+     *
+     * @returns 段相对路径(供摘要写指针);失败返 null。
+     */
+    archiveCompactedMessages(sessionId, messages) {
+        if (!sessionId || messages.length === 0)
+            return null;
+        const dir = path.join(this.sessionsRoot, sessionId, COMPACTED_DIRNAME);
+        const budget = envMaxCompactedBytes();
+        for (let attempt = 0; attempt < 2; attempt++) {
+            try {
+                this.ensureDir(dir);
+                const seq = this.nextSegmentSeq(dir);
+                const { markdown, meta } = renderCompactedSegment(seq, messages);
+                writeFileSync(path.join(dir, meta.file), markdown, 'utf8');
+                this.pruneCompacted(dir, budget);
+                // 新增了一个 seg,index 必须重建才能列全(prune 是否删旧段不影响这一点;
+                // result blob 不走这里,故不需要每次写 blob 都重建)。
+                this.rebuildCompactedIndex(sessionId, dir);
+                return `.mocode/sessions/${sessionId}/${COMPACTED_DIRNAME}/${meta.file}`;
+            }
+            catch {
+                this.invalidateEnsuredDir(dir);
+                if (attempt === 1)
+                    return null;
+            }
+        }
+        return null;
+    }
+    /**
+     * push-time 截断兜底:工具完整结果在进 history 前被 capToolResultForHistory 裁掉时,
+     * 把**完整原文**另存为 `compacted/result-<toolCallId>.txt`,供事后 grep/read_file 回捞。
+     * best-effort,写失败静默(绝不阻塞工具回灌);纳入与段相同的总量预算淘汰。
+     *
+     * @returns 全文相对路径(供 history 截断内容留指针);失败返 null。
+     */
+    archiveToolResult(sessionId, toolCallId, fullOutput) {
+        if (!sessionId || !toolCallId || !fullOutput)
+            return null;
+        const dir = path.join(this.sessionsRoot, sessionId, COMPACTED_DIRNAME);
+        const fileName = resultBlobFileName(toolCallId);
+        for (let attempt = 0; attempt < 2; attempt++) {
+            try {
+                this.ensureDir(dir);
+                writeFileSync(path.join(dir, fileName), fullOutput, 'utf8');
+                this.pruneCompacted(dir, envMaxCompactedBytes());
+                return `.mocode/sessions/${sessionId}/${COMPACTED_DIRNAME}/${fileName}`;
+            }
+            catch {
+                this.invalidateEnsuredDir(dir);
+                if (attempt === 1)
+                    return null;
+            }
+        }
+        return null;
+    }
+    /**
+     * resume 归档会话时,把 gz 内嵌的 compacted 资产(seg/index/截断原文 blob)写回磁盘,
+     * 恢复历史回捞链。best-effort:任何坏条目跳过。防 zip-slip:只接受 compacted/ 下
+     * 白名单单层文件名。
+     */
+    restoreCompactedAssets(id, record) {
+        const assets = record.compactedAssets;
+        if (!assets || typeof assets !== 'object')
+            return;
+        const dir = path.join(this.sessionsRoot, id, COMPACTED_DIRNAME);
+        for (const [relPath, content] of Object.entries(assets)) {
+            if (typeof content !== 'string')
+                continue;
+            const base = relPath.startsWith(`${COMPACTED_DIRNAME}/`) ? relPath.slice(COMPACTED_DIRNAME.length + 1) : null;
+            if (!base || base.includes('/') || base.includes('\\') || !isCompactedAssetName(base))
+                continue;
+            try {
+                this.ensureDir(dir);
+                writeFileSync(path.join(dir, base), content, 'utf8');
+            }
+            catch {
+                this.invalidateEnsuredDir(dir);
+            }
+        }
+    }
+    /** 扫描 seg-NNN.md 取下一个编号;损坏文件名跳过。 */
+    nextSegmentSeq(dir) {
+        let max = 0;
+        for (const name of this.listDirNames(dir)) {
+            const m = SEGMENT_FILE_RE.exec(name);
+            if (m)
+                max = Math.max(max, Number(m[1]));
+        }
+        return max + 1;
+    }
+    /**
+     * compacted/ 全目录(seg 段 + result blob)统一字节预算淘汰:
+     * 超 MAX_COMPACTED_ARCHIVE_BYTES 时从最老文件(mtime,再按名)硬删。
+     * 唯一豁免 = 编号最大的那个 seg(始终保住最近一代压缩的完整回捞入口);
+     * index.md 不占删除候选(段变更后重建)。
+     *
+     * @returns 是否有 seg 被删(调用方据此重建 index)。
+     */
+    pruneCompacted(dir, budget) {
+        if (!(budget > 0))
+            return false;
+        const newestSeq = this.listDirNames(dir).reduce((max, name) => {
+            const m = SEGMENT_FILE_RE.exec(name);
+            return m ? Math.max(max, Number(m[1])) : max;
+        }, 0);
+        const candidates = this.listDirNames(dir)
+            .filter((name) => SEGMENT_FILE_RE.test(name) || RESULT_BLOB_FILE_RE.test(name))
+            .map((name) => {
+            const m = SEGMENT_FILE_RE.exec(name);
+            const st = statSync(path.join(dir, name));
+            return { name, size: st.size, mtimeMs: st.mtimeMs, seq: m ? Number(m[1]) : null };
+        })
+            // 最老在前:blob 与跨类型文件按 mtime;同刻按名,保证确定性。
+            .sort((a, b) => a.mtimeMs - b.mtimeMs || (a.name < b.name ? -1 : 1));
+        let total = candidates.reduce((s, e) => s + e.size, 0);
+        let removedSeg = false;
+        for (const e of candidates) {
+            if (total <= budget)
+                break;
+            if (e.seq !== null && e.seq === newestSeq)
+                continue; // 永不删最新段
+            try {
+                unlinkSync(path.join(dir, e.name));
+            }
+            catch {
+                break; // 删不动就停止淘汰,避免死循环
+            }
+            total -= e.size;
+            if (e.seq !== null)
+                removedSeg = true;
+        }
+        return removedSeg;
+    }
+    /** 仅凭现存 seg 文件重建 index.md(段被外部增删后也一致)。 */
+    rebuildCompactedIndex(sessionId, dir) {
+        const metas = [];
+        for (const name of this.listDirNames(dir)) {
+            if (!SEGMENT_FILE_RE.test(name))
+                continue;
+            try {
+                const meta = parseSegmentMeta(readFileSync(path.join(dir, name), 'utf8'));
+                if (meta)
+                    metas.push(meta);
+            }
+            catch {
+                // 单个段损坏不拖垮索引。
+            }
+        }
+        const relativeDir = `.mocode/sessions/${sessionId}/compacted`;
+        writeFileSync(path.join(dir, 'index.md'), renderArchiveIndex(metas, relativeDir), 'utf8');
+    }
+    listDirNames(dir) {
+        try {
+            return readdirSync(dir, { withFileTypes: true })
+                .filter((e) => e.isFile())
+                .map((e) => e.name);
+        }
+        catch {
+            return [];
+        }
+    }
     /** 读取 <id>/usage.jsonl 全部记录;文件不存在或损坏行跳过。 */
     readUsage(id) {
         const file = path.join(this.sessionsRoot, id, 'usage.jsonl');
@@ -308,14 +486,20 @@ export class SessionStore {
             }
         }
     }
-    load(id) {
+    load(id, opts) {
         const currentPath = this.sessionPath(id);
         const legacyPath = path.join(this.sessionsRoot, `${id}.json`);
         const source = existsSync(currentPath) ? currentPath : legacyPath;
         // 活会话与 legacy 单文件都没有:回退从归档 gz 取回(30-90 天的会话仍可 resume)。
         if (!existsSync(source)) {
             const archived = loadArchivedSession(this.sessionsRoot, id);
-            return archived ?? null;
+            if (!archived)
+                return null;
+            // 仅 resume 显式要求时把 gz 内嵌的 compacted 资产写回磁盘(load 也被会话列表等
+            // 只读路径调用,不能在那些场景产生写盘副作用)。
+            if (opts?.restoreAssets)
+                this.restoreCompactedAssets(id, archived);
+            return archived;
         }
         try {
             const rec = JSON.parse(readFileSync(source, 'utf8'));

package/dist/tools/builtins/grep.js

@@ -160,7 +160,8 @@ export const grepTool = {
     name: 'grep',
     description: 'Search file contents by regex (recursive; powered by ripgrep: respects .gitignore, skips binaries).\n' +
         'Output: per-file header "<path>: N matches, lines [l1, l2, ...]" plus rendered lines with ORIGINAL INDENTATION kept.\n' +
-        'Pass context=2..5 to include neighbouring lines inline (like ripgrep -C) instead of following each hit with a read_file round-trip. Hard wall 120s; narrow the glob if a tree contains network mounts. Use read_file when you need a whole region or exact edit text.',
+        'Pass context=2..5 to include neighbouring lines inline (like ripgrep -C) instead of following each hit with a read_file round-trip. Hard wall 120s; narrow the glob if a tree contains network mounts. Use read_file when you need a whole region or exact edit text.\n' +
+        'Note: .mocode/ is gitignored; to search session data (e.g. .mocode/sessions/<id>/compacted archived history) you MUST narrow glob to that path, e.g. glob=".mocode/sessions/**".',
     parameters: {
         type: 'object',
         properties: {
@@ -200,7 +201,9 @@ export const grepTool = {
             controller.abort();
         }, GREP_TIMEOUT_MS);
         try {
-            const result = await runRipgrep({ pattern, glob, context }, controller.signal);
+            // glob 显式限定到 .mocode(gitignore 内)时放开 VCS ignore,否则 rg 零文件退出。
+            const noIgnoreVcs = glob === '.mocode/**' || glob.startsWith('.mocode/');
+            const result = await runRipgrep({ pattern, glob, context, noIgnoreVcs }, controller.signal);
             switch (result.status) {
                 case 'regex_error':
                     return `错误:非法正则 ${pattern}: ${result.message}`;

package/dist/tools/builtins/memory-graph.js

@@ -1,4 +1,5 @@
 import { addTriple, graphStats, neighborsOf, pathBetween } from '../../memory/graph.js';
+import { formatRecallStats } from '../../memory/recall-stats.js';
 // ---------- memory_graph ----------
 // 知识图谱维护工具:邻居遍历(1-3 跳,可 relation 过滤)、两点最短路径、手工加三元组、看图统计。
 // 关键词搜索已并入 memory_search(条目 + 图谱事实一次返回),本工具不再提供 search。
@@ -55,6 +56,7 @@ export const memoryGraphTool = {
                 `实体 ${s.entities} 条边(active ${s.edgesActive} / 已失效 ${s.edgesInvalid})`,
                 `project: ${s.byScope.project.entities} 实体, ${s.byScope.project.edges} 边`,
                 `global:  ${s.byScope.global.entities} 实体, ${s.byScope.global.edges} 边`,
+                formatRecallStats(),
             ].join('\n');
         }
         if (action === 'neighbors') {

package/dist/tools/builtins/memory-search.js

@@ -1,13 +1,14 @@
 import { searchEntries } from '../../memory/store.js';
-import { searchGraph } from '../../memory/graph.js';
+import { searchGraphFacts } from '../../memory/graph.js';
+import { recordRecallSearch } from '../../memory/recall-stats.js';
 // ---------- memory_search ----------
 // 唯一记忆搜索入口:关键词搜记忆正文(多词子串匹配,name 权重最高)+ 知识图谱事实段
-// (命中实体的 active 边)。命中条目即 bump recallCount(遗忘衰减依据)。
-// 结果走 capToolResultForHistory 的放宽上限(同 use_skill,保正文完整)。
+// (CJK 分词加权、边级相关度 + 一跳邻接,跨 global/project 两 scope)。命中条目即 bump
+// recallCount(遗忘衰减依据)。结果走 capToolResultForHistory 的放宽上限(同 use_skill)。
 const GRAPH_FACTS_LIMIT = 10;
 export const memorySearchTool = {
     name: 'memory_search',
-    description: 'Search memory entries by keyword (substring match), returning full body. Also surfaces knowledge-graph facts (active edges) for entities matching the query.',
+    description: 'Search memory entries by keyword (substring match), returning full body. Also surfaces knowledge-graph facts (active edges across project + global), ranked by CJK-aware term overlap on entity names/aliases/relation/fact, plus one-hop neighbor edges for context.',
     parameters: {
         type: 'object',
         properties: {
@@ -37,23 +38,28 @@ export const memorySearchTool = {
         const entryText = r
             .map((e) => `# [${e.id}] ${e.name} (${e.type}, recalled ${e.recallCount})\nsummary: ${e.summary}\n\n${e.body}`)
             .join('\n\n---\n\n');
-        // 知识图谱事实段:命中实体的 active 边(容错:图坏了不连累条目搜索)。
+        // 知识图谱事实段:边级相关度检索(容错:图坏了不连累条目搜索)。
         let graphText = '';
+        let graphHit = false;
         try {
-            const g = searchGraph(query, 8);
-            if (g.edges.length > 0) {
-                const lines = g.edges
-                    .slice(0, GRAPH_FACTS_LIMIT)
-                    .map((e) => `${e.src} --[${e.relation}]--> ${e.dst}${e.fact ? ` (${e.fact})` : ''}`);
-                const more = g.edges.length > GRAPH_FACTS_LIMIT
-                    ? `\n…(共 ${g.edges.length} 条,其余用 memory_graph action=neighbors 展开)`
-                    : '';
-                graphText = `\n\n## 知识图谱事实\n${lines.join('\n')}${more}`;
+            const hits = searchGraphFacts(query, { scope: 'all', limit: GRAPH_FACTS_LIMIT, neighbors: 4 });
+            graphHit = hits.length > 0;
+            if (graphHit) {
+                const lines = hits.map((h) => {
+                    const src = h.srcEntity?.name ?? h.edge.src;
+                    const dst = h.dstEntity?.name ?? h.edge.dst;
+                    const fact = h.edge.fact ? ` (${h.edge.fact})` : '';
+                    const tag = h.viaNeighbor ? ' [neighbor]' : '';
+                    const scopeTag = h.edge.scope === 'global' ? '[global]' : '[project]';
+                    return `${scopeTag} ${src} --[${h.edge.relation}]--> ${dst}${fact}${tag}`;
+                });
+                graphText = `\n\n## 知识图谱事实\n${lines.join('\n')}`;
             }
         }
         catch {
             // 静默:图谱段是增强,失败只降级为纯条目结果
         }
+        recordRecallSearch(graphHit); // 埋点:pull 召回使用情况(写盘失败静默)
         if (!entryText && !graphText)
             return `(无匹配记忆:query="${query}")`;
         if (!entryText)

package/dist/tools/constants.js

@@ -29,6 +29,10 @@ export const MAX_OLD_TOOL_STUB = 600;
 export const MAX_TRACE_BYTES = 512 * 1024;
 /** 保留的历史 trace 轮转份数(trace.1 .. trace.N),更老的硬删。 */
 export const MAX_TRACE_ROTATIONS = 3;
+/** compacted/ 压缩归档目录总量上限(字节):旧区原文逐段累积,超了从最老 seg 淘汰。
+ *  段大小与窗口正相关(200k 窗口单段约几百 KB),10MiB 约覆盖十几~几十次压缩。
+ *  可用 MOCODE_MAX_COMPACTED_BYTES 覆盖(测试/小盘用)。 */
+export const MAX_COMPACTED_ARCHIVE_BYTES = 10 * 1024 * 1024;
 /** rollback snapshots 压缩前滚动窗口:无论是否 compact,仅保留最近 N 个 user turn 的快照。 */
 export const MAX_SNAPSHOT_TURNS = 50;
 // ── 上下文压缩摘要(见 session/compact.ts defaultSummarize)────────────────

package/dist/tools/ripgrep-client.js

@@ -69,6 +69,9 @@ export function runRipgrep(params, signal) {
     // --no-require-git:rg 默认只在 git 仓库内才读 .gitignore;加上后非 git 项目的 .gitignore
     // 同样生效(实测不加时 ignored/ 会被扫到)。
     const args = ['--json', '--hidden', '--no-require-git', '--path-separator', '/'];
+    // glob 显式指向 gitignore 内的 .mocode(回捞压缩归档等)时放开 VCS ignore。
+    if (params.noIgnoreVcs)
+        args.push('--no-ignore-vcs');
     if (params.context > 0)
         args.push('-C', String(params.context));
     if (params.glob && params.glob !== '**/*')
@@ -169,7 +172,14 @@ export function runRipgrep(params, signal) {
                 handleLine(buffer.trim());
             // exit 2 + stderr = 正则/参数错误;无命中事件时按 regex_error 上报。
             if (code === 2 && byPath.size === 0 && stderr.trim()) {
-                finish({ status: 'regex_error', message: stderr.trim() });
+                const message = stderr.trim();
+                // 过滤器把所有文件排除(典型:glob 指向 .gitignore 内的 .mocode 却没放开 ignore)
+                // 不是正则错误——按无匹配处理,避免误导模型去改 pattern。
+                if (/No files were searched/i.test(message)) {
+                    finish({ status: 'no-match', scanned, truncated });
+                    return;
+                }
+                finish({ status: 'regex_error', message });
                 return;
             }
             if (byPath.size === 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mocode-ai",
-  "version": "1.7.10",
+  "version": "1.7.11",
   "description": "终端编码 agent:LLM + tool-call 循环 + 流式输出(含思考)+ 27 个工具,接任意 OpenAI 兼容后端。",
   "type": "module",
   "bin": {