mocode-ai 1.2.5 → 1.2.7

package/dist/context/index.js

@@ -3,7 +3,7 @@
 // scheduler is the only automatic rewrite coordinator at real pressure.
 export { optimizeToolResult } from './pipeline.js';
 export { classify, knownToolKinds } from './classifier.js';
-export { recordArtifact, invalidateArtifacts, rehydrateArtifacts, refreshArtifactFreshness, pruneStaleArtifacts, collectArtifactRefs, formatArtifactTokenSources, } from './artifacts.js';
+export { recordArtifact, invalidateArtifacts, rehydrateArtifacts, refreshArtifactFreshness, pruneStaleArtifacts, collectArtifactRefs, formatArtifactTokenSources, knownEditTargets, } from './artifacts.js';
 export { registerEncoder, registerAll, getEncoder, registeredKinds, } from './registry.js';
 // ── Context Budget Scheduler ───────────────────────────────────────────────
 export { evaluateBudget, scheduleActions, formatReport, quickEstimate, userTurnBoundary, BUDGET_LAYERS, DEFAULT_BUDGET_POLICY, BUDGET_RATIO, HOT_TURN_WINDOW, } from './budget.js';

package/dist/host/stdio.js

@@ -33,7 +33,12 @@ async function initializeRuntime() {
         await initializeAllMcp();
         registerToolsExtension('mcp', getMcpTools());
         refreshChatTools();
-        emit('runtime_ready', { projectRoot: process.cwd(), warnings: getMcpWarnings() });
+        emit('runtime_ready', {
+            projectRoot: process.cwd(),
+            provider: config.provider,
+            promptCache: config.provider === 'anthropic' && config.anthropicPromptCache,
+            warnings: getMcpWarnings(),
+        });
     })();
     return initialized;
 }
@@ -117,6 +122,8 @@ async function run(command) {
             sessionId,
             projectRoot: process.cwd(),
             resumed,
+            provider: config.provider,
+            promptCache: config.provider === 'anthropic' && config.anthropicPromptCache,
             attachments: command.attachments?.map((attachment) => attachment.name) ?? [],
         }, command.id);
         const result = await runAgentCore({
@@ -134,6 +141,8 @@ async function run(command) {
             terminationReason: result.terminationReason,
             changedFiles: result.changedFiles ?? [],
             usage: result.usage,
+            provider: config.provider,
+            promptCache: config.provider === 'anthropic' && config.anthropicPromptCache,
             usagePercent: Math.round(contextUsagePercent() * 100),
             contextWindow: config.contextWindowTokens,
         }, command.id);

package/dist/i18n/index.js

@@ -18,7 +18,7 @@ const zhCN = {
     'commands.memoryOff': '关闭记忆子系统',
     'commands.memoryStatus': '查看当前开关与原理',
     'commands.memoryReflect': '手动触发后台记忆反思',
-    'commands.memoryInit': '扫描项目生成 MOCODE.md 项目记忆',
+    'commands.memoryInit': '扫描项目生成 AGENTS.md 项目记忆',
     'commands.subagent': '子 Agent 开关（默认关闭）',
     'commands.subagentOn': '开启子 Agent',
     'commands.subagentOff': '关闭子 Agent',
@@ -69,7 +69,7 @@ const zhCN = {
     'running.rollback': '回滚',
     'running.chooseTurn': '选择轮次…',
     'running.init': '初始化',
-    'running.generateMemory': '生成 MOCODE.md…',
+    'running.generateMemory': '生成 AGENTS.md…',
     'running.plan': '切 plan',
     'running.auto': '切 auto',
     'running.clear': '清空',
@@ -277,7 +277,7 @@ const en = {
     'commands.memoryOff': 'Disable the memory subsystem',
     'commands.memoryStatus': 'Show current state and behavior',
     'commands.memoryReflect': 'Run background memory reflection',
-    'commands.memoryInit': 'Scan project and generate MOCODE.md',
+    'commands.memoryInit': 'Scan project and generate AGENTS.md',
     'commands.subagent': 'Sub-agent controls (disabled by default)',
     'commands.subagentOn': 'Enable sub-agents',
     'commands.subagentOff': 'Disable sub-agents',
@@ -328,7 +328,7 @@ const en = {
     'running.rollback': 'Rollback',
     'running.chooseTurn': 'Choose a turn…',
     'running.init': 'Initialize',
-    'running.generateMemory': 'Generating MOCODE.md…',
+    'running.generateMemory': 'Generating AGENTS.md…',
     'running.plan': 'Plan mode',
     'running.auto': 'Auto mode',
     'running.clear': 'Clear',

package/dist/llm/index.js

@@ -1,8 +1,9 @@
 import OpenAI from 'openai';
-import { config, isSubAgentEnabled, isFrontendToolsEnabled } from '../config/index.js';
+import { config, getActiveModel, isSubAgentEnabled, isFrontendToolsEnabled } from '../config/index.js';
 import { tools } from '../tools/registry.js';
 import { getPlanDisabledTools, FRONTEND_TOOLS } from '../tools/constants.js';
 import { ThinkTagFilter } from './think-filter.js';
+import { anthropicChatOnce } from './providers/anthropic.js';
 // 强制关闭第三方调试日志泄漏:openai SDK 在 process.env.DEBUG === 'true' 时用裸
 // console.log 把请求/响应直写 stdout,会污染 TUI 输入框(并泄露 headers/URL)。
 // 仅拦截 'true' 这一开关值——保留 namespace 形式的 DEBUG(如 DEBUG=express:*) 调试能力。
@@ -180,7 +181,6 @@ export function refreshChatTools() {
     // MCP 协议没有可靠的副作用注解；plan 模式绝不暴露外部工具，保留只读探查保证。
     planChatTools.splice(0, planChatTools.length, ...next.filter((t) => !t.function.name.startsWith('mcp__') && !getPlanDisabledTools().has(t.function.name)));
 }
-refreshChatTools();
 /**
  * 多 provider 兼容的 cache / reasoning 字段提取。
  * 不同后端报 cached 字段名差异巨大,这里按"最常见的几种"顺序 probe,
@@ -268,6 +268,9 @@ toolsOverride) {
             throw new DOMException('This operation was aborted', 'AbortError');
         }
         try {
+            if (config.provider === 'anthropic') {
+                return await anthropicChatOnce(messages, handlers, signal, toolsOverride ?? chatTools);
+            }
             return await chatOnce(messages, handlers, signal, toolsOverride);
         }
         catch (err) {
@@ -328,6 +331,22 @@ export function normalizeImageDetail(messages) {
 }
 /** 单次流式 LLM 请求(无重试);chat() 的内部实现,可被 __setChatCreateImpl 注入桩以做单测。 */
 async function chatOnce(messages, handlers, signal, toolsOverride) {
+    // 防御:messages 必须至少含一条非空 user 消息,否则 OpenAI/Anthropic 都会 400。
+    // compact force 分支曾把所有 user 丢进摘要 → 重建 history 无 user → 下一轮 400。
+    // 在 transport 边界拦住所有类似回归(compact / 外部注入 / resume 损坏)。
+    const hasNonEmptyUser = messages.some((m) => {
+        if (m.role !== 'user')
+            return false;
+        const c = m.content;
+        if (typeof c === 'string')
+            return c.length > 0;
+        if (Array.isArray(c))
+            return c.some((p) => p.type === 'text' && (p.text?.length ?? 0) > 0);
+        return false;
+    });
+    if (!hasNonEmptyUser) {
+        throw new Error('messages must contain at least one non-empty user message');
+    }
     // signal 透传给 SDK 第二参(RequestOptions);abort 后 for await 抛错,chat 不 catch,透传 runAgent 处理。
     // createImplOverride 的 body 类型故意宽成 Record(测试桩用),生产走 client 分支时由 OpenAI 自己的类型守门。
     const create = createImplOverride
@@ -335,7 +354,7 @@ async function chatOnce(messages, handlers, signal, toolsOverride) {
         : (body, opts) => client.chat.completions.create(body, opts);
     const activeTools = toolsOverride ?? chatTools;
     const stream = await create({
-        model: config.model,
+        model: getActiveModel(),
         messages: normalizeImageDetail(messages),
         tools: activeTools,
         stream: true,

package/dist/llm/providers/anthropic.js

@@ -0,0 +1,370 @@
+import { config, getActiveModel } from '../../config/index.js';
+let fetchImplOverride = null;
+/** 仅供单测注入；生产路径使用 Node 18+ 全局 fetch。 */
+export function __setAnthropicFetchImpl(impl) {
+    fetchImplOverride = impl;
+}
+function parseJsonObject(value) {
+    if (!value.trim())
+        return {};
+    try {
+        const parsed = JSON.parse(value);
+        return parsed && typeof parsed === 'object' && !Array.isArray(parsed)
+            ? parsed
+            : {};
+    }
+    catch {
+        return {};
+    }
+}
+function textBlocks(content) {
+    if (content == null)
+        return [];
+    if (typeof content === 'string')
+        return content ? [{ type: 'text', text: content }] : [];
+    if (!Array.isArray(content))
+        return [{ type: 'text', text: String(content) }];
+    const blocks = [];
+    for (const raw of content) {
+        if (!raw || typeof raw !== 'object')
+            continue;
+        const part = raw;
+        if (part.type === 'text' && typeof part.text === 'string') {
+            blocks.push({ type: 'text', text: part.text });
+            continue;
+        }
+        if (part.type !== 'image_url')
+            continue;
+        const image = part.image_url;
+        if (typeof image?.url !== 'string')
+            continue;
+        const match = /^data:(image\/(?:jpeg|png|gif|webp));base64,(.+)$/s.exec(image.url);
+        if (!match)
+            continue;
+        blocks.push({
+            type: 'image',
+            source: { type: 'base64', media_type: match[1], data: match[2] },
+        });
+    }
+    return blocks;
+}
+function appendMessage(messages, role, blocks, cacheCandidates, cacheable = true) {
+    if (blocks.length === 0)
+        return;
+    const previous = messages[messages.length - 1];
+    if (previous?.role === role)
+        previous.content.push(...blocks);
+    else
+        messages.push({ role, content: [...blocks] });
+    if (cacheable)
+        cacheCandidates.push(...blocks);
+}
+/**
+ * 把会话落盘使用的 OpenAI 兼容消息转换为 Anthropic Messages 内容块。
+ * history 保持旧格式以兼容已有 session；provider 边界负责 tool_use/tool_result 编码。
+ */
+export function encodeAnthropicMessages(input, promptCache = config.anthropicPromptCache) {
+    const system = [];
+    const messages = [];
+    const cacheCandidates = [];
+    let dialogStarted = false;
+    for (const raw of input) {
+        const message = raw;
+        if (message.role === 'system' && !dialogStarted) {
+            system.push(...textBlocks(message.content));
+            continue;
+        }
+        dialogStarted = true;
+        if (message.role === 'system') {
+            const blocks = textBlocks(message.content).map((block) => ({
+                ...block,
+                text: `[System reminder]\n${String(block.text ?? '')}`,
+            }));
+            // 动态尾部 reminder 每步可能变化，不把 cache breakpoint 放在它之后。
+            appendMessage(messages, 'user', blocks, cacheCandidates, false);
+            continue;
+        }
+        if (message.role === 'user') {
+            appendMessage(messages, 'user', textBlocks(message.content), cacheCandidates);
+            continue;
+        }
+        if (message.role === 'assistant') {
+            const blocks = textBlocks(message.content);
+            for (const call of message.tool_calls ?? []) {
+                blocks.push({
+                    type: 'tool_use',
+                    id: call.id ?? '',
+                    name: call.function?.name ?? '',
+                    input: parseJsonObject(call.function?.arguments ?? ''),
+                });
+            }
+            appendMessage(messages, 'assistant', blocks, cacheCandidates);
+            continue;
+        }
+        if (message.role === 'tool') {
+            appendMessage(messages, 'user', [{
+                    type: 'tool_result',
+                    tool_use_id: message.tool_call_id ?? '',
+                    content: typeof message.content === 'string'
+                        ? message.content
+                        : JSON.stringify(message.content ?? ''),
+                }], cacheCandidates);
+        }
+    }
+    if (promptCache) {
+        // 最后一个稳定消息块形成会话前缀断点；动态 session reminder 明确不参与。
+        const last = cacheCandidates[cacheCandidates.length - 1];
+        if (last)
+            last.cache_control = { type: 'ephemeral' };
+        // 没有对话时仍缓存稳定 system prompt。
+        else if (system.length > 0)
+            system[system.length - 1].cache_control = { type: 'ephemeral' };
+    }
+    return { system, messages };
+}
+export function encodeAnthropicTools(tools, promptCache = config.anthropicPromptCache) {
+    const encoded = tools.map((tool) => ({
+        name: tool.function.name,
+        description: tool.function.description,
+        input_schema: tool.function.parameters ?? { type: 'object', properties: {} },
+    }));
+    if (promptCache && encoded.length > 0) {
+        encoded[encoded.length - 1] = {
+            ...encoded[encoded.length - 1],
+            cache_control: { type: 'ephemeral' },
+        };
+    }
+    return encoded;
+}
+function endpoint(baseURL) {
+    const base = baseURL.replace(/\/+$/, '');
+    if (/\/v1$/i.test(base))
+        return `${base}/messages`;
+    if (/\/v1\/messages$/i.test(base))
+        return base;
+    return `${base}/v1/messages`;
+}
+export function buildAnthropicRequest(messages, tools) {
+    const encoded = encodeAnthropicMessages(messages);
+    const anthropicTools = encodeAnthropicTools(tools);
+    return {
+        model: getActiveModel(),
+        max_tokens: config.maxTokens ?? 8192,
+        stream: true,
+        system: encoded.system,
+        messages: encoded.messages,
+        ...(anthropicTools.length > 0 ? { tools: anthropicTools } : {}),
+    };
+}
+class AnthropicHttpError extends Error {
+    status;
+    code;
+    headers;
+    constructor(status, message, headers, code) {
+        super(message);
+        this.name = 'AnthropicAPIError';
+        this.status = status;
+        this.code = code;
+        this.headers = headers;
+    }
+}
+async function throwResponseError(response) {
+    let message = `Anthropic API HTTP ${response.status}`;
+    let code;
+    try {
+        const body = JSON.parse(await response.text());
+        if (typeof body.error?.message === 'string')
+            message = body.error.message;
+        if (typeof body.error?.type === 'string')
+            code = body.error.type;
+    }
+    catch {
+        // 非 JSON 错误页只保留状态码，避免把代理 HTML 大段写进 TUI。
+    }
+    throw new AnthropicHttpError(response.status, message, response.headers, code);
+}
+function decodeSseRecord(record) {
+    let event = '';
+    const data = [];
+    for (const line of record.split(/\r?\n/)) {
+        if (line.startsWith('event:'))
+            event = line.slice(6).trim();
+        else if (line.startsWith('data:'))
+            data.push(line.slice(5).trimStart());
+    }
+    if (data.length === 0)
+        return null;
+    return { event, data: data.join('\n') };
+}
+async function* readSse(response) {
+    if (!response.body)
+        throw new Error('Anthropic 流式响应缺少 body');
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+    while (true) {
+        const { value, done } = await reader.read();
+        buffer += decoder.decode(value, { stream: !done });
+        let match;
+        while ((match = /\r?\n\r?\n/.exec(buffer)) !== null) {
+            const record = buffer.slice(0, match.index);
+            buffer = buffer.slice(match.index + match[0].length);
+            const parsed = decodeSseRecord(record);
+            if (parsed)
+                yield parsed;
+        }
+        if (done)
+            break;
+    }
+    const parsed = decodeSseRecord(buffer);
+    if (parsed)
+        yield parsed;
+}
+function finiteToken(value) {
+    return typeof value === 'number' && Number.isFinite(value) && value >= 0 ? value : 0;
+}
+function usageFromAnthropic(raw) {
+    const direct = finiteToken(raw.input_tokens);
+    const cacheRead = finiteToken(raw.cache_read_input_tokens);
+    const cacheCreation = finiteToken(raw.cache_creation_input_tokens);
+    const output = finiteToken(raw.output_tokens);
+    const prompt = direct + cacheRead + cacheCreation;
+    return {
+        promptTokens: prompt,
+        completionTokens: output,
+        totalTokens: prompt + output,
+        cachedTokens: cacheRead,
+        cacheCreationTokens: cacheCreation,
+        reasoningTokens: 0,
+    };
+}
+function addLiveCount(text, state) {
+    for (const ch of text) {
+        const cp = ch.codePointAt(0) ?? 0;
+        if ((cp >= 0x4e00 && cp <= 0x9fff)
+            || (cp >= 0x3400 && cp <= 0x4dbf)
+            || (cp >= 0x3040 && cp <= 0x30ff)
+            || (cp >= 0xac00 && cp <= 0xd7a3))
+            state.cjk++;
+        else
+            state.other++;
+    }
+}
+/** Anthropic Messages API 单次请求；外层 chat() 继续统一负责重试。 */
+export async function anthropicChatOnce(messages, handlers, signal, tools) {
+    const fetchImpl = fetchImplOverride ?? fetch;
+    const response = await fetchImpl(endpoint(config.baseURL), {
+        method: 'POST',
+        headers: {
+            'content-type': 'application/json',
+            accept: 'text/event-stream',
+            'x-api-key': config.apiKey,
+            'anthropic-version': process.env.ANTHROPIC_VERSION || '2023-06-01',
+        },
+        body: JSON.stringify(buildAnthropicRequest(messages, tools)),
+        signal,
+    });
+    if (!response.ok)
+        await throwResponseError(response);
+    let content = '';
+    let usage;
+    const toolAcc = new Map();
+    const live = { cjk: 0, other: 0 };
+    const reportLive = () => {
+        handlers.onProgress?.({ completionTokens: Math.ceil(live.cjk + live.other / 4) });
+    };
+    for await (const record of readSse(response)) {
+        if (record.data === '[DONE]')
+            continue;
+        let event;
+        try {
+            event = JSON.parse(record.data);
+        }
+        catch {
+            continue;
+        }
+        const type = typeof event.type === 'string' ? event.type : record.event;
+        if (type === 'error') {
+            const error = event.error;
+            const thrown = new Error(typeof error?.message === 'string' ? error.message : 'Anthropic stream error');
+            thrown.name = typeof error?.type === 'string' ? error.type : 'AnthropicStreamError';
+            throw thrown;
+        }
+        if (type === 'message_start') {
+            const message = event.message;
+            if (message?.usage)
+                usage = usageFromAnthropic(message.usage);
+            continue;
+        }
+        if (type === 'content_block_start') {
+            const index = finiteToken(event.index);
+            const block = event.content_block;
+            if (block?.type === 'text' && typeof block.text === 'string' && block.text) {
+                content += block.text;
+                addLiveCount(block.text, live);
+                handlers.onText?.(block.text);
+                reportLive();
+            }
+            else if (block?.type === 'tool_use') {
+                const initialInput = block.input && typeof block.input === 'object'
+                    ? block.input
+                    : undefined;
+                const call = {
+                    id: typeof block.id === 'string' ? block.id : '',
+                    name: typeof block.name === 'string' ? block.name : '',
+                    // 流式 tool_use 通常以 input:{} 开始，真正 JSON 紧随 input_json_delta；
+                    // 只有非空 input 才直接采用，避免累加成 `{}{...}`。
+                    arguments: initialInput && Object.keys(initialInput).length > 0
+                        ? JSON.stringify(initialInput)
+                        : '',
+                };
+                toolAcc.set(index, call);
+                if (call.name)
+                    handlers.onToolCall?.(call.name);
+            }
+            continue;
+        }
+        if (type === 'content_block_delta') {
+            const index = finiteToken(event.index);
+            const delta = event.delta;
+            if (delta?.type === 'text_delta' && typeof delta.text === 'string') {
+                content += delta.text;
+                addLiveCount(delta.text, live);
+                handlers.onText?.(delta.text);
+                reportLive();
+            }
+            else if (delta?.type === 'input_json_delta' && typeof delta.partial_json === 'string') {
+                const call = toolAcc.get(index) ?? { id: '', name: '', arguments: '' };
+                call.arguments += delta.partial_json;
+                toolAcc.set(index, call);
+                addLiveCount(delta.partial_json, live);
+                reportLive();
+            }
+            continue;
+        }
+        if (type === 'message_delta') {
+            const raw = event.usage;
+            if (raw) {
+                const previous = usage ?? usageFromAnthropic({});
+                const output = finiteToken(raw.output_tokens);
+                usage = {
+                    ...previous,
+                    completionTokens: output,
+                    totalTokens: previous.promptTokens + output,
+                };
+            }
+        }
+    }
+    if (usage) {
+        handlers.onProgress?.({
+            completionTokens: usage.completionTokens,
+            promptTokens: usage.promptTokens,
+            cachedTokens: usage.cachedTokens,
+            cacheCreationTokens: usage.cacheCreationTokens,
+        });
+    }
+    const toolCalls = [...toolAcc.entries()]
+        .sort((a, b) => a[0] - b[0])
+        .map(([, call]) => ({ ...call, arguments: call.arguments || '{}' }));
+    return { content: content || null, toolCalls, usage };
+}

package/dist/memory/discover.js

@@ -1,23 +1,23 @@
-// memory 发现子系统:加载项目记忆 MOCODE.md(对标 skills/discover.ts 的叶子模式)。
+// memory 发现子系统:加载项目记忆 AGENTS.md(对标 skills/discover.ts 的叶子模式)。
 // 仅依赖 node 标准库,是叶子模块:不依赖 config/agent/llm/tools/skills,避免环。
 //
-// 约定:纯 MOCODE.md(mocode 是独立工具,有自己的工具集与约定)。
-// 项目级从 cwd 向上逐级找,全局 ~/.mocode/MOCODE.md。全量注入 systemPrompt(超长截断);
+// 约定:纯 AGENTS.md(mocode 是独立工具,有自己的工具集与约定)。
+// 项目级从 cwd 向上逐级找,全局 ~/.mocode/AGENTS.md。全量注入 systemPrompt(超长截断);
 import { existsSync, readFileSync } from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 /**
- * 返回要查找的 MOCODE.md 路径列表,按「远→近」顺序(合并时近的在后,更突出):
- * 全局 ~/.mocode/MOCODE.md → 项目级从根到 cwd 逐级 MOCODE.md。
+ * 返回要查找的 AGENTS.md 路径列表,按「远→近」顺序(合并时近的在后,更突出):
+ * 全局 ~/.mocode/AGENTS.md → 项目级从根到 cwd 逐级 AGENTS.md。
  * 向上遍历 cwd 到根收集 [cwd..root],反转为 [root..cwd](远→近),前拼全局。
  */
 export function resolveMemoryFiles() {
-    const globalPath = path.join(os.homedir(), '.mocode', 'MOCODE.md');
+    const globalPath = path.join(os.homedir(), '.mocode', 'AGENTS.md');
     const projectFiles = [];
     let dir = process.cwd();
     const root = path.parse(dir).root; // win32 'C:\\', POSIX '/'
     for (;;) {
-        projectFiles.push(path.join(dir, 'MOCODE.md'));
+        projectFiles.push(path.join(dir, 'AGENTS.md'));
         if (dir === root || dir === path.dirname(dir))
             break; // 到根:dirname 自身
         dir = path.dirname(dir);
@@ -26,7 +26,7 @@ export function resolveMemoryFiles() {
     return [globalPath, ...projectFiles];
 }
 /**
- * 读取所有存在的 MOCODE.md,返回 { path, content }(content 已 trim)。
+ * 读取所有存在的 AGENTS.md,返回 { path, content }(content 已 trim)。
  * 全程静默容错(不存在 / 读失败 → 跳过,不抛),风格对齐 skills/discover.ts 与 session/persist.ts。
  */
 export function loadMemoryFiles() {

package/dist/memory/index.js

@@ -1,6 +1,7 @@
 // Memory barrel: Tier-2 JSONL store + knowledge-graph layer + background reflection.
-// MOCODE.md is intentionally not loaded here: the system prompt only tells the agent
-// to read the workspace file on demand, keeping its full body out of every request.
+// AGENTS.md is intentionally not loaded here either: config/index.ts
+// (buildAgentsImportSection) auto-imports the workspace-root AGENTS.md body into the
+// system prompt — independent of the memory switch — truncating it when it exceeds the cap.
 export { buildMemoryIndexSection, loadAll, gcMemories, } from './store.js';
 export { addTriple, upsertEntity, findEntity, searchGraph, neighborsOf, pathBetween, graphStats, } from './graph.js';
 export { kickoffReflection, drainMemoryBackground, getLastReflectResult, clearLastReflectResult, snapshotTranscript, formatReflectResult, runReflection, } from './reflect.js';