mocode-ai 1.2.1 → 1.2.2

package/dist/rollback/index.js

@@ -1,5 +1,6 @@
 import { createHash } from 'node:crypto';
-import { chmodSync, existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, readlinkSync, rmdirSync, rmSync, symlinkSync, unlinkSync, writeFileSync, } from 'node:fs';
+import { chmodSync, existsSync, lstatSync, mkdirSync, readFileSync, readlinkSync, rmdirSync, rmSync, symlinkSync, unlinkSync, writeFileSync, } from 'node:fs';
+import * as fsp from 'node:fs/promises';
 import path from 'node:path';
 import { config } from '../config/index.js';
 import { truncateDisplay } from '../ui/render.js';
@@ -50,8 +51,19 @@ function readState(full) {
     }
     return { kind: 'missing' };
 }
+/**
+ * 状态等价判定。两侧都捕获了内容时按内容比(与旧行为一致,精确);
+ * 任一侧内容未捕获(超预算的大文件)时退化为 stamp 比较——size+mtimeNs 变了就算变。
+ */
 function sameState(a, b) {
-    return a.kind === b.kind && a.data === b.data && a.mode === b.mode;
+    if (a.kind !== b.kind || a.mode !== b.mode)
+        return false;
+    if (a.data !== undefined && b.data !== undefined)
+        return a.data === b.data;
+    if (a.data === undefined && b.data === undefined && a.stamp === undefined && b.stamp === undefined) {
+        return true; // directory / missing:kind+mode 已足够
+    }
+    return a.stamp === b.stamp;
 }
 function stateFingerprint(state) {
     return createHash('sha256')
@@ -82,6 +94,8 @@ function snapshotFromState(rel, state, sequence, op, createdParents = [], after)
         ops: [op],
         createdParents: createdParents.length > 0 ? createdParents : undefined,
         afterFingerprint: after ? stateFingerprint(after) : undefined,
+        // 文件但没有内容 = 工作区扫描时超出捕获预算,只能报告"变了",不能拿它覆盖磁盘。
+        contentUnavailable: state.kind === 'file' && state.data === undefined ? true : undefined,
     };
 }
 /** 同轮同路径只保留最早的 before；后续实际改动仅合并工具名。 */
@@ -163,55 +177,172 @@ export function endPathMutation(capture, op) {
     if (changed)
         mutationVersion += 1;
 }
-// 构建产物 / 临时 / 缓存目录：可再生运行时状态，扫描它们既昂贵（dist/ 含大量 .js bundle，
-// 全量 readFileSync 会同步卡死事件循环，表现为 run_command 期间滚轮划不动、spinner 冻结），
-// 也易把后台 daemon / 打包器的写入误判成模型改动。回滚本就只应覆盖源码，构建产物可再生。
+// 构建产物 / 依赖树 / 缓存 / 运行时状态目录：可再生，扫描它们既昂贵也易把后台 daemon、
+// 打包器、mocode 自身(会话日志 / dev-server 日志 / 截图)的写入误判成模型改动。
+// 回滚本就只应覆盖源码。
 const EXCLUDED_WORKSPACE_DIRS = new Set([
-    '.git', '.codegraph', 'node_modules',
-    'dist', 'build', 'out', 'coverage', '.tmp', 'tmp',
-    '.output', '.next', '.vite', '.turbo', '.svelte-kit',
+    // VCS / 索引 / mocode 自身运行时状态(会话、trace、dev-server 日志、记忆、截图每轮都在写,
+    // 既无回滚意义,又会被误判成模型改动)
+    '.git', '.hg', '.svn', '.codegraph', '.mocode',
+    // 依赖树与包管理器缓存
+    'node_modules', 'vendor', 'bower_components', '.yarn', '.pnpm-store', '.venv', 'venv', 'pods',
+    // 构建产物
+    'dist', 'build', 'out', 'target', 'coverage', '.output', '.next', '.nuxt', '.vite',
+    '.turbo', '.svelte-kit', '.angular', '.astro', '.docusaurus', '.dart_tool', '.terraform',
+    // 临时与缓存
+    '.tmp', 'tmp', '.cache', '.parcel-cache', '.nyc_output', '__pycache__',
+    '.pytest_cache', '.mypy_cache', '.ruff_cache', '.gradle',
 ]);
+/** 单文件内容捕获上限：更大的文件只留 stamp(可检测变化,不可恢复),避免把巨型二进制读进内存。 */
+const CAPTURE_FILE_LIMIT = 1024 * 1024;
+/** 单次扫描的内容总预算：超出后剩余文件只留 stamp。 */
+const CAPTURE_TOTAL_LIMIT = 32 * 1024 * 1024;
+/** 条目上限：超大工作区不做无边界遍历(超出部分不参与变更检测)。 */
+const CAPTURE_ENTRY_LIMIT = 20000;
+/** 并发文件操作数：冷缓存(尤其 Windows 杀软逐文件扫描)下 I/O 重叠远快于串行。 */
+const SCAN_CONCURRENCY = 16;
+/** 让出事件循环的节奏:每 N 个条目,或每累计编码 M 字节(base64 是纯 CPU,大文件靠字节数兜底)。 */
+const YIELD_EVERY = 64;
+const YIELD_BYTES = 1024 * 1024;
+/**
+ * 刚被写过的文件不信缓存,强制重读内容。
+ * 原因:stamp 依赖 mtime 精度。NTFS/ext4/APFS 是 100ns~ns 级,但 exFAT / 部分网络盘只有 1~2s,
+ * 那里一条"同尺寸原地改写"可能与快照前共享同一时间戳,只比 stamp 会漏掉真实变化。
+ * 只对最近 2s 内改动的文件付重读代价(通常正是命令刚碰过的那几个),开销可忽略。
+ */
+const FRESH_WINDOW_MS = 2000;
+/** path → 上次扫描捕获的内容。stamp(size+mtimeNs)未变即复用，未改动的文件不重复读盘。 */
+let contentCache = new Map();
+let cachedSessionDir = '';
+let resolvedSessionDir = '';
+function sessionDirAbs() {
+    if (config.sessionDir !== cachedSessionDir) {
+        cachedSessionDir = config.sessionDir;
+        resolvedSessionDir = path.resolve(config.sessionDir);
+    }
+    return resolvedSessionDir;
+}
 function isWorkspaceExcluded(full) {
     const base = path.basename(full).toLowerCase();
     // Git 元数据必须永久排除以保护 index；依赖树/代码索引/构建产物/临时目录是可再生运行时状态。
     if (EXCLUDED_WORKSPACE_DIRS.has(base))
         return true;
-    const sessionDir = path.resolve(config.sessionDir);
-    return isInside(sessionDir, full);
+    return isInside(sessionDirAbs(), full);
 }
-function scanWorkspace() {
+const yieldToEventLoop = () => new Promise((resolve) => setImmediate(resolve));
+/**
+ * 工作区快照(run_command / dev_server / MCP 等不透明工具用)。
+ *
+ * **必须是异步且带缓存的**：本函数在每次这类工具调用前后各跑一次，直接坐在用户交互
+ * 路径上。旧实现用 readdirSync + 全量 readFileSync(base64) 同步遍历整棵工作树 ——
+ * 冷文件缓存下 400 个文件实测就要 ~3s(Windows)，几千个文件即数十秒，期间事件循环
+ * 完全阻塞：spinner 冻结、走时停摆、键鼠无响应，用户看到的就是「卡在 执行 run_command」。
+ *
+ * 现在:
+ *  1) fs/promises + 有界并发 + 定期 setImmediate 让出 → 事件循环全程可呼吸;
+ *  2) 内容按 (size, mtimeNs, mode) 缓存复用 → 未改动的文件不再重复读盘,
+ *     一次会话里只有首次扫描付全量代价,之后只读真正变化的文件;
+ *  3) 单文件 / 总量 / 条目数三重预算 → 巨型仓库不会把内存和时间吃穿。
+ */
+async function scanWorkspace() {
     const entries = new Map();
-    const walk = (dir) => {
+    const nextCache = new Map();
+    const paths = [];
+    // 第一趟:只 readdir 收集条目(廉价,不读内容)。目录本身即刻记账,顺序稳定。
+    const walk = async (dir) => {
+        if (paths.length >= CAPTURE_ENTRY_LIMIT)
+            return;
         let children;
         try {
-            children = readdirSync(dir, { withFileTypes: true });
+            children = await fsp.readdir(dir, { withFileTypes: true });
         }
         catch {
             return;
         }
         for (const child of children) {
+            if (paths.length >= CAPTURE_ENTRY_LIMIT)
+                return;
             const full = path.join(dir, child.name);
             if (isWorkspaceExcluded(full))
                 continue;
-            const state = readState(full);
+            paths.push(full);
+            // isDirectory() 对 symlink 为 false —— 与旧实现一致:不跟随软链。
+            if (child.isDirectory())
+                await walk(full);
+        }
+    };
+    await walk(rootDir());
+    // 第二趟:有界并发读状态。budget 由完成顺序消费——两次扫描间某个大文件是否被捕获
+    // 可能不同,sameState 在任一侧缺内容时退化为 stamp 比较,故不会产生伪变化。
+    let budget = CAPTURE_TOTAL_LIMIT;
+    let cursor = 0;
+    let processed = 0;
+    let bytesSinceYield = 0;
+    const worker = async () => {
+        while (cursor < paths.length) {
+            const full = paths[cursor++];
+            if (++processed % YIELD_EVERY === 0 || bytesSinceYield >= YIELD_BYTES) {
+                bytesSinceYield = 0;
+                await yieldToEventLoop();
+            }
+            let state;
+            try {
+                const stat = await fsp.lstat(full, { bigint: true });
+                const mode = Number(stat.mode) & 0o777;
+                if (stat.isSymbolicLink()) {
+                    const target = await fsp.readlink(full);
+                    state = { kind: 'symlink', data: target, stamp: target, mode };
+                }
+                else if (stat.isDirectory()) {
+                    state = { kind: 'directory', mode, stamp: '' };
+                }
+                else if (stat.isFile()) {
+                    const size = Number(stat.size);
+                    const stamp = `${size}:${stat.mtimeNs}`;
+                    // 未来时间戳(时钟偏移)同样按"新鲜"处理 —— 宁可多读一次,不可漏判变化。
+                    const fresh = Date.now() - Number(stat.mtimeNs / 1000000n) < FRESH_WINDOW_MS;
+                    const cached = fresh ? undefined : contentCache.get(full);
+                    if (cached && cached.stamp === stamp && cached.mode === mode) {
+                        budget -= size; // 命中也计预算,保证冷/热缓存下的捕获集合一致
+                        state = { kind: 'file', data: cached.data, stamp, mode };
+                        nextCache.set(full, cached);
+                    }
+                    else if (size <= CAPTURE_FILE_LIMIT && budget - size >= 0) {
+                        budget -= size;
+                        bytesSinceYield += size;
+                        const data = (await fsp.readFile(full)).toString('base64');
+                        state = { kind: 'file', data, stamp, mode };
+                        nextCache.set(full, { stamp, mode, data });
+                    }
+                    else {
+                        // 超大文件 / 预算耗尽:只留指纹,能报告变化但不参与内容恢复。
+                        state = { kind: 'file', stamp, mode };
+                    }
+                }
+                else {
+                    state = { kind: 'missing' };
+                }
+            }
+            catch {
+                state = { kind: 'missing' }; // 不存在或不可读:工具若最终也不可读,不会产生伪变化
+            }
             if (state.kind === 'missing')
                 continue;
-            const rel = toRel(full);
-            entries.set(rel, state);
-            if (state.kind === 'directory')
-                walk(full);
+            entries.set(toRel(full), state);
         }
     };
-    walk(rootDir());
+    await Promise.all(Array.from({ length: Math.min(SCAN_CONCURRENCY, Math.max(1, paths.length)) }, worker));
+    // 缓存整体替换:已删除的文件自然被淘汰,内存上限 ≈ CAPTURE_TOTAL_LIMIT。
+    contentCache = nextCache;
     return entries;
 }
 /** run_command/MCP 前调用。不跟随 symlink，并排除 .git、会话快照、依赖树与代码索引。 */
-export function beginWorkspaceMutation() {
-    return { sequence: ++sequenceCounter, entries: scanWorkspace() };
+export async function beginWorkspaceMutation() {
+    return { sequence: ++sequenceCounter, entries: await scanWorkspace() };
 }
 /** 不透明工具执行后比较整个工作区，把实际变化压入当前轮事务日志。 */
-export function endWorkspaceMutation(capture, op) {
-    const after = scanWorkspace();
+export async function endWorkspaceMutation(capture, op) {
+    const after = await scanWorkspace();
     const paths = new Set([...capture.entries.keys(), ...after.keys()]);
     let changed = false;
     for (const rel of paths) {
@@ -234,10 +365,16 @@ export function getCurrentTurnMutationState() {
             continue;
         let change = byPath.get(snapshot.path);
         if (!change) {
-            change = { path: snapshot.path, ops: [], snapshotAvailable: true };
+            change = {
+                path: snapshot.path,
+                ops: [],
+                snapshotAvailable: snapshot.contentUnavailable !== true,
+            };
             byPath.set(snapshot.path, change);
             order.push(snapshot.path);
         }
+        if (snapshot.contentUnavailable)
+            change.snapshotAvailable = false;
         for (const op of snapshot.ops ?? ['file_change']) {
             if (!change.ops.includes(op))
                 change.ops.push(op);
@@ -281,6 +418,8 @@ export function planRollback(n, history) {
         if (snapshot.turnId <= cutoffTurnId)
             continue;
         const change = ensure(snapshot.path);
+        if (snapshot.contentUnavailable)
+            change.snapshotAvailable = false;
         for (const op of snapshot.ops ?? ['file_change']) {
             if (!change.ops.includes(op))
                 change.ops.push(op);
@@ -300,6 +439,9 @@ function restoreSnapshot(snapshot) {
     const full = safeFullPath(snapshot.path);
     if (!full)
         return false;
+    // 内容未捕获(工作区扫描时超出预算):宁可报冲突,也不能拿空内容覆盖用户文件。
+    if (snapshot.contentUnavailable)
+        return false;
     const state = stateFromSnapshot(snapshot);
     try {
         if (state.kind === 'missing') {
@@ -413,6 +555,7 @@ export function resetState() {
     turnIdCounter = 0;
     currentTurnId = 0;
     sequenceCounter = 0;
+    contentCache = new Map();
 }
 export function rebuildFromHistory(history) {
     const rebuilt = [];

package/dist/tools/registry.js

@@ -148,8 +148,10 @@ async function executeToolOnce(tool, args, signal, opts) {
                 ? beginPathMutation(args.path)
                 : null;
             capturedPath = pathCapture?.path;
+            // 工作区快照是异步的:它遍历整棵工作树,同步实现会在每次 run_command/MCP 调用前后
+            // 阻塞事件循环数秒(TUI 完全冻结)。await 让 spinner / 走时 / 键鼠在扫描期间继续工作。
             const workspaceCapture = capabilities.effect === 'process' || capabilities.effect === 'unknown'
-                ? beginWorkspaceMutation()
+                ? await beginWorkspaceMutation()
                 : null;
             let raw;
             try {
@@ -159,7 +161,7 @@ async function executeToolOnce(tool, args, signal, opts) {
                 if (pathCapture)
                     endPathMutation(pathCapture, tool.name);
                 if (workspaceCapture)
-                    endWorkspaceMutation(workspaceCapture, tool.name);
+                    await endWorkspaceMutation(workspaceCapture, tool.name);
             }
             const mutationAfter = getCurrentTurnMutationState();
             const changedFiles = mutationAfter.version !== mutationBefore.version

package/package.json

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