mocode-ai 0.4.4 → 0.4.6

package/dist/config/index.js

@@ -99,7 +99,7 @@ function buildPlanModeSuffix() {
 ## ⛯ PLAN MODE (active now)
 You are in PLAN mode: investigate and design only — do NOT execute or change anything.
 - Your editing / command tools (write_file, edit_file, run_command) have been REMOVED from your tool list. Use only the read-only tools available to you (read_file, glob, grep, codegraph, web_search, web_fetch, use_skill, ask_human) to investigate.
-- Research thoroughly: locate the relevant code, trace call paths, and understand existing patterns and conventions before designing. (Codegraph is the default first action for code exploration — see Workflow in the base prompt.)
+- Research thoroughly: locate the relevant code, trace call paths, and understand existing patterns and conventions before designing. (Codegraph is the default first action for code exploration — see Workflow in the base prompt. But first check whether this conversation already covers it — don't re-explore something already retrieved earlier in this session.)
 - Then produce a clear, actionable implementation plan: files to change (with paths), what to change in each and why, the ordered steps, edge cases to handle, and how to verify (typecheck / tests / build). Be specific enough to execute against.
 - When the plan is complete and ready for review, you MUST call the \`ask_human\` tool to surface the plan to the user for approval — do NOT just output the plan as plain text and STOP. ask_human renders a real interactive selection panel inside the TUI; plain-text approval questions in your reply are hard to see and easy to miss.
 - Pass the \`ask_human\` tool a concise plan summary (goal + files/areas to change + key risks + verification) and these three options so the user can decide in one click:
@@ -115,7 +115,7 @@ You are in PLAN mode: investigate and design only — do NOT execute or change a
 ## ⛯ PLAN MODE (active now)
 You are in PLAN mode: investigate and design only — do NOT execute or change anything.
 - Your editing / command / memory-write tools (write_file, edit_file, run_command, memory_save, memory_update, memory_forget) have been REMOVED from your tool list. Use only the read-only tools available to you (read_file, glob, grep, codegraph, web_search, web_fetch, use_skill, ask_human, memory_search, memory_list) to investigate.
-- Research thoroughly: locate the relevant code, trace call paths, and understand existing patterns and conventions before designing. (Codegraph is the default first action for code exploration — see Workflow in the base prompt.)
+- Research thoroughly: locate the relevant code, trace call paths, and understand existing patterns and conventions before designing. (Codegraph is the default first action for code exploration — see Workflow in the base prompt. But first check whether this conversation already covers it — don't re-explore something already retrieved earlier in this session.)
 - Then produce a clear, actionable implementation plan: files to change (with paths), what to change in each and why, the ordered steps, edge cases to handle, and how to verify (typecheck / tests / build). Be specific enough to execute against.
 - When the plan is complete and ready for review, you MUST call the \`ask_human\` tool to surface the plan to the user for approval — do NOT just output the plan as plain text and STOP. ask_human renders a real interactive selection panel inside the TUI; plain-text approval questions in your reply are hard to see and easy to miss.
 - Pass the \`ask_human\` tool a concise plan summary (goal + files/areas to change + key risks + verification) and these three options so the user can decide in one click:
@@ -145,6 +145,10 @@ ${PLATFORM_NOTE}
 
 ## Step / Turn Economy (read this first — saves LLM calls)
 - **Minimize turns**: each user message costs at least one LLM call, and history grows every step until threshold-triggered compact fires (extra call). If a request contains ≥2 independent sub-goals (e.g. "改 X 然后再优化 Y"), ask the user to split them into separate turns rather than chaining both in one go. State this politely: "这条包含 N 个独立目标,建议拆成 N 次对话,以避免上下文膨胀。"
+- **Answer directly when you already know the answer — do this before the batching rule below**: before planning any tool calls for this turn, first check whether you can answer from the current conversation, an earlier tool result already in context, a file/symbol already read in this session, or general reasoning/knowledge alone. If so, skip tools entirely and answer directly. Only call a tool when the info is genuinely missing, may be stale (the underlying file/state changed since you last read it), or requires verification you cannot do from context. This applies to every tool — codegraph, grep, web_search, run_command — not just read_file.
+  - ✅ already have it: user asks "刚才那个函数在哪个文件" after codegraph_explore returned it two turns ago → answer from that result, no new call.
+  - ✅ pure reasoning: user asks "这个改动会不会影响性能" and the relevant code/logic is already visible in context → reason and answer directly, no need to re-run a profiler or re-read the file "just to be safe".
+  - ❌ wasteful: re-running grep/codegraph for a symbol whose location this same conversation already returned, "just to be sure".
 - **Plan the full turn, then emit it as one batch — this is the single biggest step-saver**: before emitting anything, enumerate every read / edit / command you'll need for this sub-goal, then return them together as one set of tool_calls (reads run in parallel, writes/commands run in the order given). Don't emit one call, observe, then emit the next in a follow-up turn when you could have planned both upfront.
   - ✅ one turn: \`[read_file A, read_file B, edit_file A, run_command 'npm test']\`
   - ❌ four turns: \`[read_file A]\` → \`[read_file B]\` → \`[edit_file A]\` → \`[run_command 'npm test']\`
@@ -160,18 +164,17 @@ ${PLATFORM_NOTE}
 - **Code exploration first action**: before reading files with read_file or searching with grep, check if a .codegraph/ index exists. If it does, use the codegraph tool (explore for questions/features, node for a specific symbol) as your FIRST step — it returns source + call paths in one shot. Only fall back to read_file/grep when codegraph misses, you need just-changed content, or you're editing a known small file. Build the index with \`codegraph init\` if none exists.
 - Small steps: break tasks into verifiable sub-steps. Before each step, think clearly about what to change and why.
 - Verify after change: run typecheck / tests / build via run_command to confirm it works. Never claim done without verification.
+- **Web search when freshness matters**: for tasks involving UI/interaction/copy/visual design, new SDKs or APIs, CVE/version upgrades, or anything likely past your training cutoff, web_search FIRST to ground your work in current material — don't fall back on stale templates (gradient+emoji defaults, "I hope this message finds you well" openers, generic AI-flavored phrasing). Routine coding (bug fixes, refactors, tests, internal docs) doesn't need it.
 
 ## Tool Guidelines
 - See each tool's own description for parameters and usage; this section covers selection strategy and pitfalls only.
 - **If the user gave a precise path or symbol, go directly**: read_file or codegraph node it — don't pre-validate with glob/grep.
-- Before editing code, read_file to confirm actual content (with line numbers); don't guess from memory.
+- Before editing code, read_file to confirm actual content (with line numbers); don't guess from memory. (Skip if you already read this exact content earlier in this session and nothing has changed it since — see Step Economy above.)
 - For local edits use edit_file: old_string must be unique and match exactly (including indentation/newlines); include surrounding context lines to ensure uniqueness. Use write_file for new files or full rewrites.
-- Use glob to find file paths, grep to search content. **Don't use run_command for file-level checks** (existence / listing / type) — those have no clean cmd.exe equivalent and Windows path escaping fails often. Use \`glob\` to list, and just call \`read_file\` to test existence (returns ENOENT as a clean error string). The earlier rule against \`run_command\` for cat/sed/find/grep still applies.
-- run_command runs per platform (cmd on Windows, bash elsewhere); state intent before running commands with side effects (deleting files, installing packages, git push, resets, etc.).
-- Use web_search for information beyond training data (new versions, news, real-time data, latest APIs); don't answer potentially outdated info from memory.
-- Use web_fetch to read a specific URL (a link from search results, or a URL given by the user); it only fetches static HTML — if a JS-rendered page yields no body, switch to web_search (its results include cleaned body text).
+- Use glob to find file paths, grep to search content. **Don't use run_command for file-level checks** (existence / listing / type) — those have no clean cmd.exe equivalent and Windows path escaping fails often. Use \`glob\` to list, and just call \`read_file\` to test existence (returns ENOENT as a clean error string).
+- run_command has side effects on the host — state intent before invoking (delete, install, push, reset, etc.).
 - Call ask_human when you hit a decision point requiring user input (multiple implementation approaches, unclear intent, or needing extra info to proceed) — list options for the user to pick (they can also choose "custom input" to answer freely). Don't call it frequently when the task is clear and you can decide yourself; if the user cancels, switch approach or proceed with available info — don't re-ask the same question.
-- **Trim context when stale**: when an old tool result is dead weight (sub-goal done, no downstream consumer, or superseded by a later read), call drop_context to stub it. Otherwise rely on automatic pruning — don't carry stale reads into new sub-goals.
+- **Trim context when stale**: when an old tool result is dead weight (sub-goal done, no downstream consumer, or superseded by a later read), call drop_context to stub it; otherwise rely on automatic pruning.
 - **Batch writes and commands too, not just reads**: the executor runs ALL returned tool_calls (reads, writes, commands) before the next LLM call. Emit independent edit_file / write_file / run_command in one response when the chain is clear — don't serialize them across turns just because they have side effects. (The read-only batching note in Step Economy applies to writes the same way.)
 - **Chain shell workflows in a single \`run_command\`**: use \`&&\`, \`;\`, \`|\`, \`>\`, heredocs to fold multi-step scripts (\`mkdir -p x && cat > x/file.ts <<'EOF' ... EOF && npm test\`) into one call. Only emit a follow-up turn when the result forces a decision (error, ambiguous output, branching logic).
 
@@ -193,9 +196,8 @@ ${PLATFORM_NOTE}
 ${memorySection}
 
 ## Working notepad (todolist) — for multi-step tasks
-- For tasks spanning **≥2 independent modules** OR when the user asks for stepwise progress ("先计划再执行" / "plan then do" / "按步骤来"), call \`todolist create\` first to write the plan to \`.mocode/plans/<id>.md\`, then \`todolist update\` to mark progress as you go. For single-file edits or quick lookups, skip it.
-- The plan is file-backed (survives context compression; user can see/edit), and the active plan summary is auto-injected into this system prompt each turn. Re-read via \`todolist read\` when unsure of your place.
-- See the \`todolist\` tool description for the full action set (create / read / update / add_step / finish / list / unarchive / delete) and lifecycle.
+- For tasks spanning **≥2 independent modules** OR when the user asks for stepwise progress ("先计划再执行" / "plan then do" / "按步骤来"), call \`todolist create\` first; update as you go. Skip for single-file edits or quick lookups.
+- Plan is file-backed (\`todolist read\` to re-orient). See the tool description for the full action set.
 
 ## Termination & Reporting
 - Stop immediately when no more tools are needed; give conclusions directly.

package/dist/config/presets.js

@@ -0,0 +1,177 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+/**
+ * 多模型预设(`/model save <name>` 保存的命名配置)的纯 I/O 叶子。
+ *
+ * 存储:每个预设一个独立 JSON 文件 `~/.mocode/models/<name>.json`。
+ *   - 选用 per-file 而非单一 index.json:写不需要读-合并-写整本,天然原子(单文件 rename),
+ *     符合 memory/store.ts 的惯例;并发写多个预设互不打架。
+ *   - 路径前缀与 CONFIG_PATH 共享 `~/.mocode/`,保证权限/位置一致。
+ *
+ * 不读 process.env、不触发 config 单例初始化——repl(/model 子命令)与 commands/config.ts
+ * 之外的脚本都能安全 import。错误一律抛(写失败属异常路径,调用方决定怎么提示用户)。
+ *
+ * 命名约束:[a-zA-Z0-9_-]{1,32}。理由:
+ *   - 排除路径分隔符与 .. 防止越权写文件。
+ *   - 与 dotenv key 风格一致,便于未来扩展到同名 env override。
+ *   - 32 位上限防极长名撑爆文件名系统。
+ */
+/** 预设目录:`~/.mocode/models/`(按需创建)。 */
+export const MODELS_DIR = path.join(os.homedir(), '.mocode', 'models');
+const NAME_RE = /^[a-zA-Z0-9_-]{1,32}$/;
+/** 名字是否合法(调用方复用,避免在多处重复同一正则)。 */
+export function isValidPresetName(name) {
+    return NAME_RE.test(name);
+}
+/** 把合法的 name 拼成文件路径;非法 name 抛错(路径穿越防护的第二道)。 */
+function filePathFor(name) {
+    if (!isValidPresetName(name)) {
+        throw new Error(`非法预设名: ${JSON.stringify(name)}(仅允许 [a-zA-Z0-9_-]{1,32})`);
+    }
+    return path.join(MODELS_DIR, `${name}.json`);
+}
+/** 把磁盘上的 raw JSON 解析并校验为 ModelPreset;非法字段抛错。 */
+function parsePreset(raw) {
+    const obj = JSON.parse(raw);
+    const { name, baseURL, apiKey, model, contextWindow } = obj;
+    if (typeof name !== 'string' || !isValidPresetName(name)) {
+        throw new Error('预设文件 name 缺失或非法');
+    }
+    if (typeof baseURL !== 'string' || !baseURL) {
+        throw new Error(`预设 ${name}: baseURL 缺失`);
+    }
+    if (typeof apiKey !== 'string' || !apiKey) {
+        throw new Error(`预设 ${name}: apiKey 缺失`);
+    }
+    if (typeof model !== 'string' || !model) {
+        throw new Error(`预设 ${name}: model 缺失`);
+    }
+    if (typeof contextWindow !== 'number' || !Number.isFinite(contextWindow) || contextWindow <= 0) {
+        throw new Error(`预设 ${name}: contextWindow 必须为正数`);
+    }
+    return { name, baseURL, apiKey, model, contextWindow: Math.floor(contextWindow) };
+}
+/** 读单个预设;不存在抛错。 */
+export function getPreset(name) {
+    const p = filePathFor(name);
+    return parsePreset(fs.readFileSync(p, 'utf8'));
+}
+/** 读单个预设;不存在返回 null(供列表/可选切换场景)。 */
+export function readPreset(name) {
+    try {
+        return getPreset(name);
+    }
+    catch (e) {
+        if (e.code === 'ENOENT')
+            return null;
+        throw e;
+    }
+}
+/** 写/覆盖一个预设(原子:写 tmp 再 rename)。 */
+export function savePreset(preset) {
+    if (!isValidPresetName(preset.name)) {
+        throw new Error(`非法预设名: ${JSON.stringify(preset.name)}`);
+    }
+    fs.mkdirSync(MODELS_DIR, { recursive: true });
+    const dest = filePathFor(preset.name);
+    const tmp = `${dest}.tmp-${process.pid}-${Date.now()}`;
+    fs.writeFileSync(tmp, JSON.stringify(preset, null, 2), 'utf8');
+    fs.renameSync(tmp, dest);
+}
+/** 删除一个预设;不存在返回 false,成功返回 true。 */
+export function deletePreset(name) {
+    try {
+        fs.unlinkSync(filePathFor(name));
+        return true;
+    }
+    catch (e) {
+        if (e.code === 'ENOENT')
+            return false;
+        throw e;
+    }
+}
+/**
+ * 重命名一个预设(原子:link+unlink,跨设备时退化为 copy+unlink)。
+ * 用于 /model rename <old> <new>;不存在的旧名 / 已存在的新名返回 false,具体由调用方决定提示文案。
+ */
+export function renamePreset(oldName, newName) {
+    if (!isValidPresetName(newName)) {
+        throw new Error(`非法新名: ${JSON.stringify(newName)}`);
+    }
+    const oldPath = filePathFor(oldName);
+    const newPath = filePathFor(newName);
+    if (!fs.existsSync(oldPath))
+        return false;
+    if (fs.existsSync(newPath))
+        return false; // 拒绝覆盖,避免静默吞用户数据
+    fs.mkdirSync(MODELS_DIR, { recursive: true });
+    try {
+        fs.renameSync(oldPath, newPath);
+    }
+    catch (e) {
+        if (e.code !== 'EXDEV')
+            throw e;
+        // 跨设备:rename 会抛 EXDEV,改 copy+unlink。
+        fs.copyFileSync(oldPath, newPath);
+        fs.unlinkSync(oldPath);
+    }
+    // 重命名后同步更新文件内的 name 字段(我们写出去时总一致,但允许用户手改过 JSON 后不一致)。
+    const p = parsePreset(fs.readFileSync(newPath, 'utf8'));
+    if (p.name !== newName)
+        savePreset({ ...p, name: newName });
+    return true;
+}
+/** 列出全部预设(按 name 升序);目录不存在返回空数组。 */
+export function listPresets() {
+    if (!fs.existsSync(MODELS_DIR))
+        return [];
+    const out = [];
+    for (const entry of fs.readdirSync(MODELS_DIR)) {
+        if (!entry.endsWith('.json'))
+            continue;
+        const name = entry.slice(0, -'.json'.length);
+        if (!isValidPresetName(name))
+            continue; // 跳过非我们写的杂文件
+        try {
+            out.push(parsePreset(fs.readFileSync(path.join(MODELS_DIR, entry), 'utf8')));
+        }
+        catch {
+            // 单个坏文件不阻断列表;用户用 /model delete 显式清理即可。
+        }
+    }
+    out.sort((a, b) => a.name.localeCompare(b.name));
+    return out;
+}
+/**
+ * 把当前 config 的 LLM 四键(baseURL/apiKey/model/contextWindow)迁为命名预设。
+ * 用于启动时一次性兜底老用户:加 /model 之前就已经在 ~/.mocode/config 写过的配置,
+ * /model list 应该立刻能看到,而不是空。已有同名预设则不重复写。
+ *
+ * 返回新建的预设名;若未配置完整(baseURL/apiKey 缺失)或已有同名则返回 null。
+ * 设计为幂等:重启调用一次也只会生效一次。
+ */
+export function migrateCurrentToPreset(input) {
+    if (!input.baseURL || !input.apiKey || !input.model)
+        return null;
+    if (!Number.isFinite(input.contextWindow) || input.contextWindow <= 0)
+        return null;
+    const existing = listPresets();
+    const dup = existing.find((p) => p.baseURL === input.baseURL &&
+        p.apiKey === input.apiKey &&
+        p.model === input.model &&
+        p.contextWindow === input.contextWindow);
+    if (dup)
+        return null;
+    // 'default' 已被占 → 用户已显式起过预设,无需老数据迁入;返回 null 让调用方跳过即可。
+    if (existing.some((p) => p.name === 'default'))
+        return null;
+    savePreset({
+        name: 'default',
+        baseURL: input.baseURL,
+        apiKey: input.apiKey,
+        model: input.model,
+        contextWindow: input.contextWindow,
+    });
+    return 'default';
+}

package/dist/llm/capabilities.js

@@ -26,6 +26,9 @@ const KNOWN_TEXT_ONLY_PREFIXES = [
     'babbage-',
     'davinci-',
     'gpt-4o-mini-search', // 搜索专用,无视觉入口
+    // MiniMax M2 系列(M2 / M2.1 / M2.5 / M2.7,含各自 -highspeed 变体):纯文本,无视觉输入。
+    // 官方文档明确仅 MiniMax-M3 支持 image/video content parts;M2.x 传 image_url 会被拒。
+    'minimax-m2',
 ];
 const KNOWN_VISION_FAMILIES = [
     'gpt-4o',
@@ -54,6 +57,7 @@ const KNOWN_VISION_FAMILIES = [
     'minicpm-v',
     'glm-4v',
     'yi-vl',
+    'minimax-m3', // 官方文档:仅 M3 支持 image_url/video_url content parts
 ];
 /** 归一化:小写、去空白;用于前缀比较。 */
 function normalize(model) {

package/dist/llm/index.js

@@ -264,11 +264,15 @@ async function chatOnce(messages, handlers, signal, toolsOverride) {
     const create = createImplOverride
         ? createImplOverride
         : (body, opts) => client.chat.completions.create(body, opts);
+    const activeTools = toolsOverride ?? chatTools;
     const stream = await create({
         model: config.model,
         messages,
-        tools: toolsOverride ?? chatTools,
+        tools: activeTools,
         stream: true,
+        // 显式声明允许一次响应携带多个 tool_call(OpenAI 兼容协议标准字段)。
+        // 不设置时依赖各家后端的默认值,某些第三方网关/模型在缺省时会退化为串行单步调用。
+        ...(activeTools.length > 0 ? { parallel_tool_calls: true } : {}),
         ...(config.maxTokens ? { max_tokens: config.maxTokens } : {}),
         ...(config.includeUsage ? { stream_options: { include_usage: true } } : {}),
     }, signal ? { signal } : undefined);

package/dist/memory/reflect.js

@@ -11,7 +11,7 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import path from 'node:path';
 import { chat } from '../llm/index.js';
-import { config } from '../config/index.js';
+import { config, isMemoryEnabled } from '../config/index.js';
 import { saveEntry, updateEntry, forgetEntry, loadAll, gcMemories, } from './store.js';
 // ── 日志(静默容错,裁尾保最近)─────────────────────────────────────────────
 function logPath() {
@@ -224,7 +224,8 @@ export function formatReflectResult(r) {
     return `记忆反思:${parts.join(' ')}${r.error ? ` [${r.error}]` : ''}`;
 }
 /**
- * fire-and-forget 触发反思。已有在飞任务 / autoReflect 关闭 → 跳过。
+ * fire-and-forget 触发反思。已有在飞任务 / autoReflect 关闭 / 记忆子系统总开关关闭 → 跳过。
+ * 记忆关闭时反思毫无意义(没有可存的地方),且会误打日志、误弹摘要,故一并短路。
  * repl 轮末调:与下一轮 agent 并发跑,不阻塞。
  */
 export function kickoffReflection(transcript) {
@@ -232,6 +233,8 @@ export function kickoffReflection(transcript) {
         return;
     if (!config.autoReflect)
         return;
+    if (!isMemoryEnabled())
+        return;
     inflight = (async () => {
         try {
             const r = await runReflection(transcript);