mocode-ai 1.4.2 → 1.4.3

package/dist/rollback/store.js

@@ -0,0 +1,593 @@
+import { createHash } from 'node:crypto';
+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 { toText } from '../context/utils.js';
+import { truncateDisplay } from '../ui/render.js';
+const EXCLUDED_WORKSPACE_DIRS = Object.freeze([
+    '.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',
+]);
+const CAPTURE_FILE_LIMIT = 1024 * 1024;
+const CAPTURE_TOTAL_LIMIT = 32 * 1024 * 1024;
+const CAPTURE_ENTRY_LIMIT = 20000;
+const SCAN_CONCURRENCY = 16;
+const YIELD_EVERY = 64;
+const YIELD_BYTES = 1024 * 1024;
+const FRESH_WINDOW_MS = 2000;
+/**
+ * 一个完整、实例隔离的回滚事务存储。每个 runtime 可持有独立实例，使轮次、序号、
+ * 快照、mutation generation 和扫描缓存互不干扰。
+ */
+export class RollbackStore {
+    turnIdCounter = 0;
+    currentTurnId = 0;
+    sequenceCounter = 0;
+    mutationVersion = 0;
+    turns = [];
+    snapshots = [];
+    contentCache = new Map();
+    workspaceRootProvider;
+    sessionsRootProvider;
+    constructor(workspaceRoot = () => process.cwd(), sessionsRoot = () => config.sessionDir) {
+        this.workspaceRootProvider = this.rootProvider(workspaceRoot);
+        this.sessionsRootProvider = this.rootProvider(sessionsRoot);
+    }
+    rootProvider(source) {
+        if (typeof source === 'string') {
+            const fixed = path.resolve(source);
+            return () => fixed;
+        }
+        return () => path.resolve(source());
+    }
+    rootDir() {
+        return this.workspaceRootProvider();
+    }
+    sessionsDir() {
+        return this.sessionsRootProvider();
+    }
+    yieldToEventLoop() {
+        return new Promise((resolve) => setImmediate(resolve));
+    }
+    isInside(parent, child) {
+        const rel = path.relative(parent, child);
+        return rel === '' || (!rel.startsWith('..') && !path.isAbsolute(rel));
+    }
+    toRel(root, value) {
+        try {
+            const rel = path.relative(root, path.resolve(root, value));
+            return rel === '' ? '.' : rel;
+        }
+        catch {
+            return value;
+        }
+    }
+    safeFullPath(root, rel) {
+        const full = path.resolve(root, rel);
+        return full !== root && this.isInside(root, full) ? full : null;
+    }
+    readState(full) {
+        try {
+            const stat = lstatSync(full);
+            const mode = stat.mode & 0o777;
+            if (stat.isSymbolicLink())
+                return { kind: 'symlink', data: readlinkSync(full), mode };
+            if (stat.isDirectory())
+                return { kind: 'directory', mode };
+            if (stat.isFile())
+                return { kind: 'file', data: readFileSync(full).toString('base64'), mode };
+        }
+        catch {
+            // 不存在或不可读均按 missing；工具若最终也不可读，不会产生伪变化。
+        }
+        return { kind: 'missing' };
+    }
+    sameState(a, b) {
+        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;
+        return a.stamp === b.stamp;
+    }
+    stateFingerprint(state) {
+        return createHash('sha256')
+            .update(JSON.stringify([state.kind, state.data ?? null, state.mode ?? null]))
+            .digest('hex');
+    }
+    stateFromSnapshot(snapshot) {
+        if (snapshot.kind)
+            return { kind: snapshot.kind, data: snapshot.before ?? undefined, mode: snapshot.mode };
+        if (snapshot.before === null)
+            return { kind: 'missing' };
+        return { kind: 'file', data: Buffer.from(snapshot.before, 'utf8').toString('base64') };
+    }
+    snapshotFromState(turnId, rel, state, sequence, op, createdParents = [], after) {
+        return {
+            turnId,
+            path: rel,
+            before: state.data ?? null,
+            kind: state.kind,
+            encoding: state.kind === 'file' ? 'base64' : undefined,
+            mode: state.mode,
+            sequence,
+            ops: [op],
+            createdParents: createdParents.length > 0 ? createdParents : undefined,
+            afterFingerprint: after ? this.stateFingerprint(after) : undefined,
+            contentUnavailable: state.kind === 'file' && state.data === undefined ? true : undefined,
+        };
+    }
+    addSnapshot(next) {
+        if (next.turnId <= 0)
+            return;
+        const existingIndex = this.snapshots.findIndex((item) => item.turnId === next.turnId && item.path === next.path);
+        if (existingIndex < 0) {
+            this.snapshots.push(next);
+            return;
+        }
+        const existing = this.snapshots[existingIndex];
+        const existingSequence = existing.sequence ?? Number.MAX_SAFE_INTEGER;
+        const nextSequence = next.sequence ?? Number.MAX_SAFE_INTEGER;
+        const ops = new Set([...(existing.ops ?? []), ...(next.ops ?? [])]);
+        const latestAfterFingerprint = nextSequence >= existingSequence ? next.afterFingerprint : existing.afterFingerprint;
+        if (nextSequence < existingSequence) {
+            this.snapshots[existingIndex] = { ...next, ops: [...ops], afterFingerprint: latestAfterFingerprint };
+        }
+        else {
+            existing.ops = [...ops];
+            existing.afterFingerprint = latestAfterFingerprint;
+        }
+    }
+    missingParents(root, full) {
+        const result = [];
+        let current = path.dirname(full);
+        while (current !== root && this.isInside(root, current)) {
+            if (existsSync(current))
+                break;
+            result.push(this.toRel(root, current));
+            current = path.dirname(current);
+        }
+        return result;
+    }
+    beginTurn(firstLine) {
+        this.turnIdCounter += 1;
+        this.currentTurnId = this.turnIdCounter;
+        this.turns.push({ turnId: this.currentTurnId, firstLine });
+        return this.currentTurnId;
+    }
+    getCurrentTurnId() {
+        return this.currentTurnId;
+    }
+    beginPathMutation(value) {
+        const workspaceRoot = this.rootDir();
+        const full = path.resolve(workspaceRoot, value);
+        return {
+            path: this.toRel(workspaceRoot, full),
+            before: this.readState(full),
+            sequence: ++this.sequenceCounter,
+            createdParents: this.missingParents(workspaceRoot, full),
+            turnId: this.currentTurnId,
+            workspaceRoot,
+        };
+    }
+    endPathMutation(capture, op) {
+        const full = this.safeFullPath(capture.workspaceRoot, capture.path);
+        if (!full)
+            return;
+        let changed = false;
+        const after = this.readState(full);
+        if (!this.sameState(capture.before, after)) {
+            changed = true;
+            this.addSnapshot(this.snapshotFromState(capture.turnId, capture.path, capture.before, capture.sequence, op, capture.createdParents, after));
+        }
+        for (const parentRel of capture.createdParents) {
+            const parent = this.safeFullPath(capture.workspaceRoot, parentRel);
+            if (!parent)
+                continue;
+            const parentState = this.readState(parent);
+            if (parentState.kind !== 'missing') {
+                changed = true;
+                this.addSnapshot(this.snapshotFromState(capture.turnId, parentRel, { kind: 'missing' }, capture.sequence, op, [], parentState));
+            }
+        }
+        if (changed)
+            this.mutationVersion += 1;
+    }
+    isWorkspaceExcluded(full, sessionsRoot) {
+        const base = path.basename(full).toLowerCase();
+        if (EXCLUDED_WORKSPACE_DIRS.includes(base))
+            return true;
+        return this.isInside(sessionsRoot, full);
+    }
+    async scanWorkspace(workspaceRoot, sessionsRoot) {
+        const entries = new Map();
+        const nextCache = new Map();
+        const paths = [];
+        const walk = async (dir) => {
+            if (paths.length >= CAPTURE_ENTRY_LIMIT)
+                return;
+            let children;
+            try {
+                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 (this.isWorkspaceExcluded(full, sessionsRoot))
+                    continue;
+                paths.push(full);
+                if (child.isDirectory())
+                    await walk(full);
+            }
+        };
+        await walk(workspaceRoot);
+        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 this.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 : this.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')
+                    entries.set(this.toRel(workspaceRoot, full), state);
+            }
+        };
+        await Promise.all(Array.from({ length: Math.min(SCAN_CONCURRENCY, Math.max(1, paths.length)) }, worker));
+        this.contentCache = nextCache;
+        return entries;
+    }
+    async beginWorkspaceMutation() {
+        const turnId = this.currentTurnId;
+        const sequence = ++this.sequenceCounter;
+        const workspaceRoot = this.rootDir();
+        const sessionsRoot = this.sessionsDir();
+        const entries = await this.scanWorkspace(workspaceRoot, sessionsRoot);
+        return {
+            sequence,
+            entries,
+            turnId,
+            workspaceRoot,
+            sessionsRoot,
+        };
+    }
+    async endWorkspaceMutation(capture, op) {
+        const after = await this.scanWorkspace(capture.workspaceRoot, capture.sessionsRoot);
+        const paths = new Set([...capture.entries.keys(), ...after.keys()]);
+        let changed = false;
+        for (const rel of paths) {
+            const beforeState = capture.entries.get(rel) ?? { kind: 'missing' };
+            const afterState = after.get(rel) ?? { kind: 'missing' };
+            if (this.sameState(beforeState, afterState))
+                continue;
+            changed = true;
+            this.addSnapshot(this.snapshotFromState(capture.turnId, rel, beforeState, capture.sequence, op, [], afterState));
+        }
+        if (changed)
+            this.mutationVersion += 1;
+    }
+    getCurrentTurnMutationState() {
+        const order = [];
+        const byPath = new Map();
+        for (const snapshot of this.snapshots) {
+            if (snapshot.turnId !== this.currentTurnId)
+                continue;
+            let change = byPath.get(snapshot.path);
+            if (!change) {
+                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);
+            }
+        }
+        return { version: this.mutationVersion, changedFiles: order.map((item) => byPath.get(item)) };
+    }
+    listTurns() {
+        return this.turns.slice();
+    }
+    findCutoffIndex(n, history) {
+        let seen = 0;
+        for (let i = 0; i < history.length; i++) {
+            if (history[i].role === 'user') {
+                seen += 1;
+                if (seen === n + 1)
+                    return i;
+            }
+        }
+        return history.length;
+    }
+    planRollback(n, history) {
+        const cutoffTurnId = this.turns[n - 1]?.turnId ?? 0;
+        const cutoffIndex = this.findCutoffIndex(n, history);
+        const order = [];
+        const map = new Map();
+        const ensure = (rel) => {
+            let change = map.get(rel);
+            if (!change) {
+                change = { path: rel, ops: [], snapshotAvailable: true };
+                map.set(rel, change);
+                order.push(rel);
+            }
+            return change;
+        };
+        for (const snapshot of this.snapshots) {
+            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);
+            }
+        }
+        return { n, cutoffIndex, cutoffTurnId, changes: order.map((rel) => map.get(rel)) };
+    }
+    depth(rel) {
+        return rel.split(/[\\/]+/).length;
+    }
+    restoreSnapshot(root, snapshot) {
+        const full = this.safeFullPath(root, snapshot.path);
+        if (!full || snapshot.contentUnavailable)
+            return false;
+        const state = this.stateFromSnapshot(snapshot);
+        try {
+            if (state.kind === 'missing') {
+                const current = this.readState(full);
+                if (current.kind === 'directory')
+                    rmdirSync(full);
+                else
+                    rmSync(full, { recursive: false, force: true });
+                for (const parentRel of snapshot.createdParents ?? []) {
+                    const parent = this.safeFullPath(root, parentRel);
+                    if (!parent)
+                        continue;
+                    try {
+                        rmdirSync(parent);
+                    }
+                    catch {
+                        // 仅删除本轮创建且当前为空的父目录；非空/已不存在均保持。
+                    }
+                }
+                return true;
+            }
+            if (state.kind === 'directory') {
+                const current = this.readState(full);
+                if (current.kind !== 'missing' && current.kind !== 'directory')
+                    rmSync(full, { recursive: true, force: true });
+                mkdirSync(full, { recursive: true });
+            }
+            else {
+                mkdirSync(path.dirname(full), { recursive: true });
+                rmSync(full, { recursive: true, force: true });
+                if (state.kind === 'file')
+                    writeFileSync(full, Buffer.from(state.data ?? '', 'base64'));
+                else
+                    symlinkSync(state.data ?? '', full);
+            }
+            if (state.mode !== undefined && state.kind !== 'symlink')
+                chmodSync(full, state.mode);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    applyRollback(plan, history, revertPaths) {
+        const deletedMsgs = history.length - plan.cutoffIndex;
+        history.length = plan.cutoffIndex;
+        const picks = new Map();
+        const latest = new Map();
+        for (const snapshot of this.snapshots) {
+            if (snapshot.turnId <= plan.cutoffTurnId || !revertPaths.has(snapshot.path))
+                continue;
+            const latestSnapshot = latest.get(snapshot.path);
+            if (!latestSnapshot ||
+                snapshot.turnId > latestSnapshot.turnId ||
+                (snapshot.turnId === latestSnapshot.turnId && (snapshot.sequence ?? -1) > (latestSnapshot.sequence ?? -1))) {
+                latest.set(snapshot.path, snapshot);
+            }
+            const existing = picks.get(snapshot.path);
+            if (!existing ||
+                snapshot.turnId < existing.turnId ||
+                (snapshot.turnId === existing.turnId &&
+                    (snapshot.sequence ?? Number.MAX_SAFE_INTEGER) < (existing.sequence ?? Number.MAX_SAFE_INTEGER))) {
+                picks.set(snapshot.path, snapshot);
+            }
+        }
+        const root = this.rootDir();
+        const selected = [];
+        const conflictedFiles = [];
+        for (const snapshot of picks.values()) {
+            const expected = latest.get(snapshot.path)?.afterFingerprint;
+            const full = this.safeFullPath(root, snapshot.path);
+            if (expected && (!full || this.stateFingerprint(this.readState(full)) !== expected))
+                conflictedFiles.push(snapshot.path);
+            else
+                selected.push(snapshot);
+        }
+        const removals = selected
+            .filter((item) => this.stateFromSnapshot(item).kind === 'missing')
+            .sort((a, b) => this.depth(b.path) - this.depth(a.path));
+        const restores = selected
+            .filter((item) => this.stateFromSnapshot(item).kind !== 'missing')
+            .sort((a, b) => this.depth(a.path) - this.depth(b.path));
+        const revertedFiles = [];
+        for (const snapshot of [...removals, ...restores]) {
+            if (this.restoreSnapshot(root, snapshot))
+                revertedFiles.push(snapshot.path);
+            else if (!conflictedFiles.includes(snapshot.path))
+                conflictedFiles.push(snapshot.path);
+        }
+        this.turns = this.turns.filter((turn) => turn.turnId <= plan.cutoffTurnId);
+        this.snapshots = this.snapshots.filter((snapshot) => snapshot.turnId <= plan.cutoffTurnId);
+        this.currentTurnId = this.turns.at(-1)?.turnId ?? 0;
+        return { deletedMsgs, revertedFiles, conflictedFiles };
+    }
+    pruneAfterCompaction(history) {
+        const count = history.filter((message) => message.role === 'user').length;
+        this.turns = count >= this.turns.length ? this.turns : this.turns.slice(-count);
+        const alive = new Set(this.turns.map((turn) => turn.turnId));
+        this.snapshots = this.snapshots.filter((snapshot) => alive.has(snapshot.turnId));
+    }
+    resetState() {
+        this.turns = [];
+        this.snapshots = [];
+        this.turnIdCounter = 0;
+        this.currentTurnId = 0;
+        this.sequenceCounter = 0;
+        this.contentCache = new Map();
+    }
+    rebuildFromHistory(history) {
+        const rebuilt = [];
+        for (const message of history) {
+            if (message.role !== 'user')
+                continue;
+            const first = toText(message.content).split('\n')[0] ?? '';
+            rebuilt.push({ turnId: rebuilt.length + 1, firstLine: truncateDisplay(first, 40) });
+        }
+        this.turns = rebuilt;
+        this.snapshots = [];
+        this.turnIdCounter = rebuilt.length;
+        this.currentTurnId = 0;
+        this.sequenceCounter = 0;
+    }
+    snapshotsPath(id) {
+        const sessionsRoot = this.sessionsDir();
+        const current = path.join(sessionsRoot, id, 'snapshots.json');
+        if (existsSync(current))
+            return current;
+        return path.join(sessionsRoot, `${id}.snapshots.json`);
+    }
+    persistSnapshots(id) {
+        const sessionsRoot = this.sessionsDir();
+        const dir = path.join(sessionsRoot, id);
+        const current = path.join(dir, 'snapshots.json');
+        const legacy = path.join(sessionsRoot, `${id}.snapshots.json`);
+        try {
+            if (this.turns.length === 0) {
+                if (existsSync(current))
+                    unlinkSync(current);
+                if (existsSync(legacy))
+                    unlinkSync(legacy);
+                return;
+            }
+            mkdirSync(dir, { recursive: true });
+            writeFileSync(current, JSON.stringify({ version: 2, turns: this.turns, snapshots: this.snapshots }), 'utf8');
+            if (existsSync(legacy))
+                unlinkSync(legacy);
+        }
+        catch {
+            // 落盘失败不阻断会话；只失去跨重启回滚能力。
+        }
+    }
+    loadSnapshots(id) {
+        const snapshotFile = this.snapshotsPath(id);
+        if (!existsSync(snapshotFile))
+            return false;
+        try {
+            const record = JSON.parse(readFileSync(snapshotFile, 'utf8'));
+            if (!record || !Array.isArray(record.turns) || !Array.isArray(record.snapshots))
+                return false;
+            this.turns = record.turns;
+            this.snapshots = record.snapshots;
+            this.turnIdCounter = this.turns.reduce((max, turn) => Math.max(max, turn.turnId), 0);
+            this.sequenceCounter = this.snapshots.reduce((max, snapshot) => Math.max(max, snapshot.sequence ?? 0), 0);
+            this.currentTurnId = 0;
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}

package/dist/runtime/index.js

@@ -0,0 +1 @@
+export { Runtime, createRuntime, defaultRuntime, getActiveRuntime } from './runtime.js';