mocode-ai 0.1.0

package/dist/rollback/index.js

@@ -0,0 +1,219 @@
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync, } from 'node:fs';
+import path from 'node:path';
+import { config } from '../config/index.js';
+import { truncateDisplay } from '../ui/render.js';
+let turnIdCounter = 0;
+let currentTurnId = 0;
+let turns = [];
+let snapshots = [];
+const MUTATION_TOOLS = new Set(['write_file', 'edit_file']);
+/** 把任意 content 拍平成字符串(OpenAI 可能是 string / 多模态数组)。 */
+function toText(content) {
+    if (content == null)
+        return '';
+    if (typeof content === 'string')
+        return content;
+    try {
+        return JSON.stringify(content);
+    }
+    catch {
+        return String(content);
+    }
+}
+/** 规整成 cwd 相对路径(快照存相对,跨 /resume 同项目可识别;resolve 已归一 ./ 和 ..)。 */
+function toRel(p) {
+    try {
+        const rel = path.relative(process.cwd(), path.resolve(p));
+        return rel === '' ? p : rel;
+    }
+    catch {
+        return p;
+    }
+}
+/** agent:runAgent 入口调——开新轮次。firstLine 已由调用方截断到 40。 */
+export function beginTurn(firstLine) {
+    turnIdCounter += 1;
+    currentTurnId = turnIdCounter;
+    turns.push({ turnId: currentTurnId, firstLine });
+}
+/** tools/registry:write_file/edit_file 执行前调——记 before 快照(在 tool.execute 之前读)。 */
+export function recordMutation(p) {
+    const rel = toRel(p);
+    let before;
+    try {
+        before = readFileSync(path.resolve(p), 'utf8');
+    }
+    catch {
+        before = null; // 文件不存在(新建)
+    }
+    snapshots.push({ turnId: currentTurnId, path: rel, before });
+}
+/** 列出当前可回滚的轮次(1-based 序号由调用方显示)。 */
+export function listTurns() {
+    return turns.slice();
+}
+/** history 里第 (n+1) 条 user 消息的下标(= 截断点);无则 history.length。 */
+function 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;
+}
+/**
+ * 规划回滚到第 n 轮(1-based):算截断点 + 被删轮次里涉及的文件改动(按 path 去重)。
+ * 调用方据 changes 逐 path 问保留 / 撤销;snapshotAvailable=false 的项无法撤销。
+ */
+export function planRollback(n, history) {
+    const cutoffTurnId = turns[n - 1]?.turnId ?? 0;
+    const cutoffIndex = findCutoffIndex(n, history);
+    const order = [];
+    const map = new Map();
+    for (let i = cutoffIndex; i < history.length; i++) {
+        const tcs = history[i].tool_calls;
+        if (!Array.isArray(tcs))
+            continue;
+        for (const tc of tcs) {
+            const name = tc?.function?.name ?? '';
+            if (!MUTATION_TOOLS.has(name))
+                continue;
+            const argRaw = tc?.function?.arguments ?? '';
+            let p = '';
+            try {
+                p = String(JSON.parse(argRaw).path ?? '');
+            }
+            catch {
+                p = '';
+            }
+            if (!p)
+                continue;
+            const rel = toRel(p);
+            let fc = map.get(rel);
+            if (!fc) {
+                fc = { path: rel, ops: [], snapshotAvailable: false };
+                map.set(rel, fc);
+                order.push(rel);
+            }
+            fc.ops.push(name);
+        }
+    }
+    const changes = order.map((rel) => {
+        const fc = map.get(rel);
+        fc.snapshotAvailable = snapshots.some((s) => s.turnId > cutoffTurnId && s.path === rel);
+        return fc;
+    });
+    return { n, cutoffIndex, cutoffTurnId, changes };
+}
+/**
+ * 执行回滚:原地截断 history 到 cutoffIndex + 按选择恢复文件 + 裁剪 turns/snapshots。
+ * revertPaths 为选「撤销」的相对路径集合。返回删除消息数 + 撤销文件列表。
+ */
+export function applyRollback(plan, history, revertPaths) {
+    const deletedMsgs = history.length - plan.cutoffIndex;
+    history.length = plan.cutoffIndex; // 原地截断(保 history[0] system + 可能的 index-1 摘要)
+    const revertedFiles = [];
+    for (const rel of revertPaths) {
+        // turnId > cutoff 的最小 turnId 快照 = 所选轮末状态
+        let pick = null;
+        for (const s of snapshots) {
+            if (s.path !== rel)
+                continue;
+            if (s.turnId <= plan.cutoffTurnId)
+                continue;
+            if (!pick || s.turnId < pick.turnId)
+                pick = s;
+        }
+        if (!pick)
+            continue; // 无快照(不应发生:repl 已据 snapshotAvailable 过滤)
+        const full = path.resolve(rel);
+        try {
+            if (pick.before === null) {
+                unlinkSync(full);
+            }
+            else {
+                writeFileSync(full, pick.before, 'utf8');
+            }
+            revertedFiles.push(rel);
+        }
+        catch {
+            // 恢复失败不阻断回滚(文件可能被外部删 / 锁)
+        }
+    }
+    // 裁剪:保 turnId ≤ cutoff(删掉被回滚掉的轮次及其快照)
+    turns = turns.filter((t) => t.turnId <= plan.cutoffTurnId);
+    snapshots = snapshots.filter((s) => s.turnId <= plan.cutoffTurnId);
+    return { deletedMsgs, revertedFiles };
+}
+/** compact 摘要成功后调:按存活轮次数裁剪(M = 新 history 里 user 消息数)。 */
+export function pruneAfterCompaction(history) {
+    const m = history.filter((msg) => msg.role === 'user').length;
+    turns = m >= turns.length ? turns : turns.slice(-m);
+    const alive = new Set(turns.map((t) => t.turnId));
+    snapshots = snapshots.filter((s) => alive.has(s.turnId));
+}
+/** /clear 调:清空全部状态。 */
+export function resetState() {
+    turns = [];
+    snapshots = [];
+    turnIdCounter = 0;
+    currentTurnId = 0;
+}
+/**
+ * 无 snapshots 文件时(/resume 旧会话)从 history 重建 turns(扫 user 消息,1..M,
+ * 无快照 → 那些轮次的文件改动不可撤销)。turnIdCounter = M,后续新轮次从 M+1 续。
+ */
+export function rebuildFromHistory(history) {
+    const out = [];
+    for (let i = 0; i < history.length; i++) {
+        if (history[i].role !== 'user')
+            continue;
+        const first = toText(history[i].content).split('\n')[0] ?? '';
+        out.push({ turnId: out.length + 1, firstLine: truncateDisplay(first, 40) });
+    }
+    turns = out;
+    snapshots = [];
+    turnIdCounter = out.length;
+    currentTurnId = 0;
+}
+function snapshotsPath(id) {
+    return path.join(config.sessionDir, `${id}.snapshots.json`);
+}
+/** 随 saveSession 调:把 turns + snapshots 落盘(turns 为空则跳过,不写空文件)。 */
+export function persistSnapshots(id) {
+    if (turns.length === 0)
+        return;
+    try {
+        mkdirSync(config.sessionDir, { recursive: true });
+        writeFileSync(snapshotsPath(id), JSON.stringify({ version: 1, turns, snapshots }), 'utf8');
+    }
+    catch {
+        // 落盘失败不阻断(回滚仅失去跨重启能力)
+    }
+}
+/**
+ * /resume / --resume 加载会话后调:读回 turns + snapshots。成功返 true(状态已覆盖);
+ * 失败 / 无文件返 false,调用方应改调 rebuildFromHistory(history) 兜底。
+ */
+export function loadSnapshots(id) {
+    const p = snapshotsPath(id);
+    if (!existsSync(p))
+        return false;
+    try {
+        const rec = JSON.parse(readFileSync(p, 'utf8'));
+        if (!rec || !Array.isArray(rec.turns) || !Array.isArray(rec.snapshots)) {
+            return false;
+        }
+        turns = rec.turns;
+        snapshots = rec.snapshots;
+        turnIdCounter = turns.reduce((mx, t) => Math.max(mx, t.turnId), 0);
+        currentTurnId = 0;
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/session/compact.js

@@ -0,0 +1,277 @@
+import { chat, estimateMessagesTokens, estimateToolSchemaTokens, estimateTokens, } from '../llm/index.js';
+import { config } from '../config/index.js';
+import { MAX_HISTORY_RESULT, MAX_OLD_TOOL_STUB, MAX_SKILL_RESULT } from '../tools/constants.js';
+import { ui } from '../ui/theme.js';
+import { Spinner } from '../ui/spinner.js';
+import * as layout from '../ui/layout.js';
+import { pruneAfterCompaction } from '../rollback/index.js';
+/** 跨模块共享的上下文状态:agent 写 lastUsage,compact 写 lastEstimate,repl 的 /context 读。 */
+export const contextState = {
+    lastEstimate: 0,
+};
+/** 中截:text 太长时保 head + 标记 + tail,总长 ≤ max。 */
+export function truncateMid(text, max) {
+    if (text.length <= max)
+        return text;
+    const removed = text.length - max;
+    const marker = `…[已截断 ${removed} 字符]…`;
+    let remain = max - marker.length;
+    if (remain <= 0)
+        return marker.slice(0, Math.max(0, max));
+    const head = Math.ceil(remain * 0.6);
+    const tail = remain - head;
+    const out = text.slice(0, head) + marker + text.slice(text.length - tail);
+    return out.length > max ? out.slice(0, max) : out;
+}
+/**
+ * push-time 第一层:工具结果进 history 前裁到 MAX_HISTORY_RESULT。
+ * 显示层(summarizeToolResult)仍用原 output,不受影响。
+ */
+export function capToolResultForHistory(name, output) {
+    if (name === 'use_skill') {
+        // skill 正文是指令,须尽量完整;超长才截断。用尾截(保头部指令、弃尾部),
+        // 不用 truncateMid 的中截——中截会劈断指令流、丢失开头步骤。
+        if (output.length <= MAX_SKILL_RESULT)
+            return output;
+        const removed = output.length - MAX_SKILL_RESULT;
+        const marker = `…[skill 正文过长,已截断尾部 ${removed} 字符]…`;
+        const remain = MAX_SKILL_RESULT - marker.length;
+        if (remain <= 0)
+            return marker.slice(0, MAX_SKILL_RESULT);
+        return output.slice(0, remain) + marker;
+    }
+    if (output.length <= MAX_HISTORY_RESULT)
+        return output;
+    return truncateMid(output, MAX_HISTORY_RESULT);
+}
+// ── 内部:消息内容拍平 / group 划分 ──────────────────────────────────────
+function toText(content) {
+    if (content == null)
+        return '';
+    if (typeof content === 'string')
+        return content;
+    try {
+        return JSON.stringify(content);
+    }
+    catch {
+        return String(content);
+    }
+}
+/** 从尾向头划分 group;history[0](system)排除。连续 tool 归到前导 assistant。 */
+function groupFromEnd(history) {
+    const groups = [];
+    let i = history.length - 1;
+    while (i >= 1) {
+        const m = history[i];
+        if (m.role === 'tool') {
+            const tools = [];
+            while (i >= 1 && history[i].role === 'tool') {
+                tools.unshift(history[i]);
+                i--;
+            }
+            if (i >= 1 &&
+                history[i].role === 'assistant' &&
+                history[i].tool_calls) {
+                groups.unshift({ assistant: history[i], tools });
+                i--;
+            }
+            else {
+                // 孤儿 tool(正常不应出现):各自成组,不丢
+                for (const t of tools)
+                    groups.unshift({ assistant: null, tools: [t] });
+            }
+        }
+        else {
+            groups.unshift({ assistant: m, tools: [] });
+            i--;
+        }
+    }
+    return groups;
+}
+function groupTokens(g) {
+    let t = 0;
+    if (g.assistant) {
+        const body = toText(g.assistant.content);
+        const tcs = g.assistant.tool_calls;
+        let extra = body;
+        if (tcs)
+            for (const tc of tcs)
+                extra += tc?.function?.arguments ?? '';
+        t += 4 + estimateTokens(extra);
+    }
+    for (const tool of g.tools) {
+        t += 6 + estimateTokens(toText(tool.content));
+    }
+    return t;
+}
+function flattenGroups(groups) {
+    const out = [];
+    for (const g of groups) {
+        if (g.assistant)
+            out.push(g.assistant);
+        for (const t of g.tools)
+            out.push(t);
+    }
+    return out;
+}
+// ── 默认摘要器:复用 chat(),空 handlers 不打印 ──────────────────────────
+async function defaultSummarize(older, focus) {
+    let transcript = older
+        .map((m) => {
+        const role = m.role;
+        let line = `${role}: ${toText(m.content)}`;
+        const tcs = m.tool_calls;
+        if (tcs) {
+            for (const tc of tcs) {
+                line += `\n  [tool_call ${tc?.function?.name}] ${tc?.function?.arguments ?? ''}`;
+            }
+        }
+        return line;
+    })
+        .join('\n');
+    // 防摘要提示本身溢出:超 60% 窗口就先中截到 50%
+    if (estimateTokens(transcript) >
+        Math.floor(config.contextWindowTokens * 0.6)) {
+        transcript = truncateMid(transcript, Math.floor(config.contextWindowTokens * 0.5));
+    }
+    const sysMsg = {
+        role: 'system',
+        content: '你是会话摘要器。只输出摘要正文,不超过 300 字,保留:用户核心请求、已读写/改动的文件及关键变更、执行过的关键命令及结果要点、已做决策、当前任务进度与下一步、未决问题。不要复述全部细节。',
+    };
+    const userMsg = {
+        role: 'user',
+        content: focus
+            ? `请将以下会话历史压缩成摘要,重点保留与「${focus}」相关的事实/决策/文件改动:\n\n${transcript}\n\n摘要:`
+            : `请将以下会话历史压缩成摘要:\n\n${transcript}\n\n摘要:`,
+    };
+    const spinner = new Spinner((msg, frame) => layout.setStatus(msg, frame ?? undefined));
+    spinner.start('压缩中');
+    try {
+        const r = await chat([sysMsg, userMsg], {}); // 空 handlers:不打印、不外显流式
+        // 推理模型可能只返 reasoning_content(content 为 null),或幻觉出 tool_calls → 视为失败
+        if (r.toolCalls.length > 0 || !r.content)
+            return null;
+        return r.content;
+    }
+    finally {
+        spinner.stop();
+    }
+}
+// ── 对外:compactHistory / maybeCompact ───────────────────────────────────
+/**
+ * 压缩 history(原地)。手动 /compact 与自动 maybeCompact 都走这里。
+ * 不检查阈值——调用方(maybeCompact)决定是否调;/compact 直接调以强制压缩。
+ */
+export async function compactHistory(history, opts) {
+    const schemaTokens = estimateToolSchemaTokens();
+    const estimateBefore = estimateMessagesTokens(history) + schemaTokens;
+    contextState.lastEstimate = estimateBefore;
+    const groups = groupFromEnd(history);
+    // 保近期:从尾向前累积直到预算花完(至少保 1 组),永不劈开 group。
+    const keepBudget = Math.floor(opts.window * 0.4);
+    const kept = [];
+    let keptTokens = 0;
+    for (let k = groups.length - 1; k >= 0; k--) {
+        const g = groups[k];
+        if (kept.length >= 1 && keptTokens + groupTokens(g) > keepBudget)
+            break;
+        kept.unshift(g);
+        keptTokens += groupTokens(g);
+    }
+    const oldGroups = groups.slice(0, groups.length - kept.length);
+    const noop = {
+        compacted: false,
+        summarized: false,
+        estimateBefore,
+        estimateAfter: estimateBefore,
+        reason: 'noop',
+    };
+    if (oldGroups.length === 0) {
+        // 没有旧区可压缩
+        if (estimateBefore >= opts.threshold * opts.window) {
+            layout.contentWrite(`  ${ui.yellow}●${ui.reset} ${ui.yellow}上下文已超阈但无可压缩项,建议 /clear 或缩短输入。${ui.reset}\n`);
+            return { ...noop, reason: 'too-large' };
+        }
+        return noop;
+    }
+    // 第一层:微压缩——旧区 tool 结果原地截短(保 tool_call_id,无 LLM 调用)
+    let microcompactDone = false;
+    for (const g of oldGroups) {
+        for (const t of g.tools) {
+            const c = t.content;
+            if (typeof c === 'string' && c.length > MAX_OLD_TOOL_STUB) {
+                t.content = truncateMid(c, MAX_OLD_TOOL_STUB);
+                microcompactDone = true;
+            }
+        }
+    }
+    // 第二层:摘要——把旧区(微压缩后)压成一条 system 摘要
+    const older = flattenGroups(oldGroups);
+    const summarizeFn = opts.summarize ?? defaultSummarize;
+    let summary = null;
+    try {
+        summary = await summarizeFn(older, opts.focus);
+    }
+    catch {
+        summary = null; // 摘要失败 → 回退仅微压缩,不崩
+    }
+    if (summary) {
+        const summaryMsg = {
+            role: 'system',
+            content: `# 会话摘要\n${summary}`,
+        };
+        // 原地重建:[systemPrompt, summaryMsg, ...kept]
+        const systemMsg = history[0];
+        const rebuilt = [systemMsg, summaryMsg, ...flattenGroups(kept)];
+        history.length = 0;
+        history.push(...rebuilt);
+        pruneAfterCompaction(history); // 摘要删了旧轮次 → 按存活轮次裁剪回滚日志
+        const estimateAfter = estimateMessagesTokens(history) + schemaTokens;
+        contextState.lastEstimate = estimateAfter;
+        contextState.lastUsage = undefined; // 压缩后旧 usage 失效,/context 改用估算
+        layout.contentWrite(`  ${ui.brightMagenta}●${ui.reset} ${ui.cyan}压缩上下文${ui.reset}  ${ui.dim}${estimateBefore} → ${estimateAfter} tokens${ui.reset}\n`);
+        // 抖动保护:压缩后仍超阈 → 提示 /clear,不死循环
+        if (estimateAfter >= opts.threshold * opts.window) {
+            layout.contentWrite(`  ${ui.yellow}●${ui.reset} ${ui.yellow}压缩后仍超阈,可能存在超大单条;建议 /clear。${ui.reset}\n`);
+        }
+        return {
+            compacted: true,
+            summarized: true,
+            estimateBefore,
+            estimateAfter,
+            reason: 'summarize',
+        };
+    }
+    // 摘要失败:回退仅微压缩(tool content 已原地改),结构不动
+    const estimateAfter = estimateMessagesTokens(history) + schemaTokens;
+    contextState.lastEstimate = estimateAfter;
+    contextState.lastUsage = undefined; // 结构虽未变,但 token 数已变,旧 usage 失效
+    if (microcompactDone) {
+        layout.contentWrite(`  ${ui.brightMagenta}●${ui.reset} ${ui.cyan}微压缩旧工具结果${ui.reset}  ${ui.dim}${estimateBefore} → ${estimateAfter} tokens${ui.reset}\n`);
+        return {
+            compacted: true,
+            summarized: false,
+            estimateBefore,
+            estimateAfter,
+            reason: 'microcompact',
+        };
+    }
+    return noop;
+}
+/**
+ * 自动压缩门槛:agent 每步调 chat() 前调用。
+ * 用全量启发式估算(始终可用、安全侧、无 stale-usage 问题);超阈则压缩。
+ */
+export async function maybeCompact(history) {
+    const schemaTokens = estimateToolSchemaTokens();
+    const est = estimateMessagesTokens(history) + schemaTokens;
+    contextState.lastEstimate = est;
+    if (!config.autoCompact)
+        return;
+    if (est < config.compactThreshold * config.contextWindowTokens)
+        return;
+    await compactHistory(history, {
+        window: config.contextWindowTokens,
+        threshold: config.compactThreshold,
+    });
+}

package/dist/session/index.js

@@ -0,0 +1,8 @@
+/**
+ * session/ 入口:上下文压缩 + 会话落盘。
+ *  - compact.ts:三层压缩(push-time 上限 / 微压缩 / 摘要)+ 自动门槛
+ *  - persist.ts:history 序列化到磁盘 + --resume / /resume
+ * 依赖方向:session → {llm(摘要复用 chat), config, ui};llm 不反向依赖 session。
+ */
+export { compactHistory, maybeCompact, capToolResultForHistory, truncateMid, contextState, } from './compact.js';
+export { newSessionId, saveSession, loadSession, listSessions, sessionDir, } from './persist.js';

package/dist/session/persist.js

@@ -0,0 +1,109 @@
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync, } from 'node:fs';
+import path from 'node:path';
+import { config } from '../config/index.js';
+import { truncateDisplay } from '../ui/render.js';
+/** 会话目录(确保存在)。 */
+export function sessionDir() {
+    mkdirSync(config.sessionDir, { recursive: true });
+    return config.sessionDir;
+}
+/** 新会话 id:YYYYMMDD-HHmmss(运行时 Date 可用)。 */
+export function newSessionId() {
+    const d = new Date();
+    const p = (n) => String(n).padStart(2, '0');
+    return `${d.getFullYear()}${p(d.getMonth() + 1)}${p(d.getDate())}-${p(d.getHours())}${p(d.getMinutes())}${p(d.getSeconds())}`;
+}
+/** id(YYYYMMDD-HHmmss)→ ISO 字符串,稳定可排序。解析失败回退原 id。 */
+function idToIso(id) {
+    const m = /^(\d{4})(\d{2})(\d{2})-(\d{2})(\d{2})(\d{2})$/.exec(id);
+    if (!m)
+        return id;
+    return `${m[1]}-${m[2]}-${m[3]}T${m[4]}:${m[5]}:${m[6]}`;
+}
+function toText(content) {
+    if (content == null)
+        return '';
+    if (typeof content === 'string')
+        return content;
+    try {
+        return JSON.stringify(content);
+    }
+    catch {
+        return String(content);
+    }
+}
+function firstUserOf(history) {
+    for (const m of history) {
+        if (m.role === 'user') {
+            const text = toText(m.content).replace(/\n/g, ' ').trim();
+            return truncateDisplay(text, 40);
+        }
+    }
+    return '';
+}
+function sessionPath(id) {
+    return path.join(config.sessionDir, `${id}.json`);
+}
+/** 保存会话到磁盘(history.length<=1 时跳过写盘,只返 meta)。 */
+export function saveSession(history, id) {
+    const meta = {
+        id,
+        createdAt: idToIso(id),
+        model: config.model,
+        firstUser: history.length > 1 ? firstUserOf(history) : '',
+    };
+    if (history.length <= 1)
+        return meta; // 仅 system,不落盘
+    sessionDir();
+    const record = { ...meta, history };
+    writeFileSync(sessionPath(id), JSON.stringify(record), 'utf8');
+    return meta;
+}
+/** 加载会话;不存在 / 损坏返 null(不抛)。 */
+export function loadSession(id) {
+    const p = sessionPath(id);
+    if (!existsSync(p))
+        return null;
+    try {
+        const raw = readFileSync(p, 'utf8');
+        const rec = JSON.parse(raw);
+        if (!rec || !Array.isArray(rec.history))
+            return null;
+        return {
+            id: rec.id,
+            createdAt: rec.createdAt ?? idToIso(rec.id ?? id),
+            model: rec.model ?? '',
+            firstUser: rec.firstUser ?? '',
+            history: rec.history,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/** 列出所有会话,按 createdAt 降序。损坏文件跳过。 */
+export function listSessions() {
+    if (!existsSync(config.sessionDir))
+        return [];
+    const out = [];
+    for (const f of readdirSync(config.sessionDir)) {
+        if (!f.endsWith('.json'))
+            continue;
+        try {
+            const rec = JSON.parse(readFileSync(path.join(config.sessionDir, f), 'utf8'));
+            if (rec && typeof rec.id === 'string') {
+                out.push({
+                    id: rec.id,
+                    createdAt: rec.createdAt ?? idToIso(rec.id),
+                    model: rec.model ?? '',
+                    firstUser: rec.firstUser ?? '',
+                });
+            }
+        }
+        catch {
+            // 跳过损坏文件
+        }
+    }
+    out.sort((a, b) => (a.createdAt < b.createdAt ? 1 : -1));
+    return out;
+}