codemini-cli 0.3.8 → 0.4.0

package/src/commands/chat.js

@@ -78,57 +78,61 @@ export async function handleChat(args) {
     systemPrompt
   });
 
-  if (parsed.prompt) {
-    const result = await runtime.submit(parsed.prompt);
-    if (result.text) console.log(result.text);
-    return;
-  }
+  try {
+    if (parsed.prompt) {
+      const result = await runtime.submit(parsed.prompt);
+      if (result.text) console.log(result.text);
+      return;
+    }
 
-  if (parsed.plain || !process.stdout.isTTY) {
-    await runPlainLoop(runtime);
-    return;
-  }
+    if (parsed.plain || !process.stdout.isTTY) {
+      await runPlainLoop(runtime);
+      return;
+    }
 
-  const React = (await import('react')).default;
-  const { render } = await import('ink');
-  const { ChatApp } = await import('../tui/chat-app.js');
+    const React = (await import('react')).default;
+    const { render } = await import('ink');
+    const { ChatApp } = await import('../tui/chat-app.js');
 
-  const instance = render(
-    React.createElement(ChatApp, {
-      runtime,
-      sessionId: session.id,
-      model: parsed.model || config.model.name,
-      sdkProvider: config.sdk?.provider || 'openai-compatible',
-      language: config.ui?.language || 'zh',
-      shellName: config.shell?.default || 'powershell',
-      safeMode: config.policy?.safe_mode !== false,
-      version: pkg.version
-    })
-  );
+    const instance = render(
+      React.createElement(ChatApp, {
+        runtime,
+        sessionId: session.id,
+        model: parsed.model || config.model.name,
+        sdkProvider: config.sdk?.provider || 'openai-compatible',
+        language: config.ui?.language || 'zh',
+        shellName: config.shell?.default || 'powershell',
+        safeMode: config.policy?.safe_mode !== false,
+        version: pkg.version
+      })
+    );
 
-  // Patch Ink's renderInteractiveFrame to never use clearTerminal.
-  // Ink calls clearTerminal (ESC[2J + ESC[H]) when the output frame exceeds
-  // the terminal viewport height, which resets the scroll position to the top
-  // and prevents the user from scrolling freely during streaming.
-  // By always using incremental logUpdate updates instead, old content scrolls
-  // into the terminal's scrollback naturally and the user can scroll freely.
-  const origRenderFrame = instance.renderInteractiveFrame;
-  instance.renderInteractiveFrame = function (output, outputHeight, staticOutput) {
-    const hasStaticOutput = staticOutput !== '';
-    const outputToRender = output + '\n';
+    // Patch Ink's renderInteractiveFrame to never use clearTerminal.
+    // Ink calls clearTerminal (ESC[2J + ESC[H]) when the output frame exceeds
+    // the terminal viewport height, which resets the scroll position to the top
+    // and prevents the user from scrolling freely during streaming.
+    // By always using incremental logUpdate updates instead, old content scrolls
+    // into the terminal's scrollback naturally and the user can scroll freely.
+    const origRenderFrame = instance.renderInteractiveFrame;
+    instance.renderInteractiveFrame = function (output, outputHeight, staticOutput) {
+      const hasStaticOutput = staticOutput !== '';
+      const outputToRender = output + '\n';
 
-    if (hasStaticOutput) {
-      this.fullStaticOutput += staticOutput;
-      this.log.clear();
-      this.options.stdout.write(staticOutput);
-      this.log(outputToRender);
-    } else if (output !== this.lastOutput || this.log.isCursorDirty()) {
-      this.throttledLog(outputToRender);
-    }
-    this.lastOutput = output;
-    this.lastOutputToRender = outputToRender;
-    this.lastOutputHeight = outputHeight;
-  };
+      if (hasStaticOutput) {
+        this.fullStaticOutput += staticOutput;
+        this.log.clear();
+        this.options.stdout.write(staticOutput);
+        this.log(outputToRender);
+      } else if (output !== this.lastOutput || this.log.isCursorDirty()) {
+        this.throttledLog(outputToRender);
+      }
+      this.lastOutput = output;
+      this.lastOutputToRender = outputToRender;
+      this.lastOutputHeight = outputHeight;
+    };
 
-  await instance.waitUntilExit();
+    await instance.waitUntilExit();
+  } finally {
+    await runtime.dispose?.();
+  }
 }

package/src/commands/doctor.js

@@ -1,5 +1,6 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
+import { spawnSync } from 'node:child_process';
 import { getConfigFilePath, getSessionsDir, getSkillsDir } from '../core/paths.js';
 import { loadConfig } from '../core/config-store.js';
 
@@ -34,8 +35,20 @@ async function checkGateway(config) {
   }
 }
 
-export async function handleDoctor() {
-  const config = await loadConfig();
+async function commandExists(command) {
+  const probe = process.platform === 'win32' ? 'where' : 'which';
+  const result = spawnSync(probe, [command], { stdio: 'ignore' });
+  return result.status === 0;
+}
+
+export async function handleDoctor({
+  loadConfigFn = loadConfig,
+  checkPathWritableFn = checkPathWritable,
+  checkGatewayFn = checkGateway,
+  commandExistsFn = commandExists,
+  writeLine = (line) => console.log(line)
+} = {}) {
+  const config = await loadConfigFn();
   const checks = [];
 
   checks.push({
@@ -52,32 +65,39 @@ export async function handleDoctor() {
 
   checks.push({
     name: 'Config file writable',
-    ok: await checkPathWritable(path.dirname(getConfigFilePath())),
+    ok: await checkPathWritableFn(path.dirname(getConfigFilePath())),
     detail: getConfigFilePath()
   });
 
   checks.push({
     name: 'Sessions dir writable',
-    ok: await checkPathWritable(getSessionsDir()),
+    ok: await checkPathWritableFn(getSessionsDir()),
     detail: getSessionsDir()
   });
 
   checks.push({
     name: 'Skills dir writable',
-    ok: await checkPathWritable(getSkillsDir()),
+    ok: await checkPathWritableFn(getSkillsDir()),
     detail: getSkillsDir()
   });
 
-  const gateway = await checkGateway(config);
+  const gateway = await checkGatewayFn(config);
   checks.push({
     name: 'Gateway connectivity',
     ok: gateway.ok,
     detail: gateway.reason
   });
 
+  const hasFff = await commandExistsFn('fff-mcp');
+  checks.push({
+    name: 'FFF MCP availability',
+    ok: hasFff,
+    detail: hasFff ? 'found fff-mcp' : 'fff-mcp not found in PATH'
+  });
+
   for (const check of checks) {
     const mark = check.ok ? 'OK' : 'FAIL';
-    console.log(`[${mark}] ${check.name}: ${check.detail}`);
+    writeLine(`[${mark}] ${check.name}: ${check.detail}`);
   }
 
   const failed = checks.filter((c) => !c.ok).length;

package/src/commands/run.js

@@ -85,25 +85,29 @@ async function runHarness({ role, task, config, systemPrompt, model, maxSteps })
   if (!HARNESS_ROLES.includes(role)) {
     throw new Error(`Unknown harness role: ${role}. Available: ${HARNESS_ROLES.join(', ')}`);
   }
-  const { definitions, handlers, formatters, deferredDefinitions } = getBuiltinTools({
+  const { definitions, handlers, formatters, deferredDefinitions, dispose } = getBuiltinTools({
     workspaceRoot: process.cwd(),
     config
   });
-  const filtered = filterToolsForRole(definitions, handlers, deferredDefinitions, role);
-  const rolePrompt = getSubAgentRolePrompt(role);
+  try {
+    const filtered = filterToolsForRole(definitions, handlers, deferredDefinitions, role);
+    const rolePrompt = getSubAgentRolePrompt(role);
 
-  const result = await runAgentLoop({
-    systemPrompt: `${systemPrompt}\n${rolePrompt}`,
-    userPrompt: task,
-    model: model || config.model.name,
-    toolDefinitions: filtered.definitions,
-    toolHandlers: filtered.handlers,
-    toolFormatters: formatters,
-    deferredDefinitions: filtered.deferredDefinitions,
-    maxSteps,
-    requestCompletion: makeCompletionFn(config)
-  });
-  return result;
+    const result = await runAgentLoop({
+      systemPrompt: `${systemPrompt}\n${rolePrompt}`,
+      userPrompt: task,
+      model: model || config.model.name,
+      toolDefinitions: filtered.definitions,
+      toolHandlers: filtered.handlers,
+      toolFormatters: formatters,
+      deferredDefinitions: filtered.deferredDefinitions,
+      maxSteps,
+      requestCompletion: makeCompletionFn(config)
+    });
+    return result;
+  } finally {
+    await dispose?.();
+  }
 }
 
 function extractJsonBlock(text) {
@@ -263,21 +267,25 @@ export async function handleRun(args) {
     return;
   }
 
-  const { definitions, handlers, formatters, deferredDefinitions } = getBuiltinTools({
+  const { definitions, handlers, formatters, deferredDefinitions, dispose } = getBuiltinTools({
     workspaceRoot: process.cwd(),
     config
   });
-  const result = await runAgentLoop({
-    systemPrompt,
-    userPrompt: parsed.task,
-    model: parsed.model || config.model.name,
-    toolDefinitions: definitions,
-    toolHandlers: handlers,
-    toolFormatters: formatters,
-    deferredDefinitions,
-    maxSteps: parsed.maxSteps,
-    requestCompletion: makeCompletionFn(config)
-  });
+  try {
+    const result = await runAgentLoop({
+      systemPrompt,
+      userPrompt: parsed.task,
+      model: parsed.model || config.model.name,
+      toolDefinitions: definitions,
+      toolHandlers: handlers,
+      toolFormatters: formatters,
+      deferredDefinitions,
+      maxSteps: parsed.maxSteps,
+      requestCompletion: makeCompletionFn(config)
+    });
 
-  console.log(result.text);
+    console.log(result.text);
+  } finally {
+    await dispose?.();
+  }
 }

package/src/core/agent-loop.js

@@ -3,6 +3,9 @@ import path from 'node:path';
 import fs from 'node:fs/promises';
 import { BoundedCache } from './bounded-cache.js';
 import { trimInline as _trimInline, normalizePath } from './string-utils.js';
+import { captureToInbox, listInbox } from './memory-store.js';
+import { requiresApprovalEvaluation } from './command-risk.js';
+import { getToolOutputSanitizeOptions, sanitizeTextForModel } from './tool-output.js';
 
 /**
  * 安全解析 JSON 字符串。
@@ -161,7 +164,7 @@ function emptyToolResultMarker(toolName) {
 }
 
 function clipToolResult(result, maxChars = 12000) {
-  const raw = typeof result === 'string' ? result : JSON.stringify(result);
+  const raw = sanitizeTextForModel(typeof result === 'string' ? result : JSON.stringify(result));
   if (!maxChars || raw.length <= maxChars) return raw;
   return `${raw.slice(0, maxChars)}\n... [tool result truncated ${raw.length - maxChars} chars]`;
 }
@@ -169,8 +172,9 @@ function clipToolResult(result, maxChars = 12000) {
 function compactToolResult(result, toolName, args, maxChars = 12000) {
   if (result === null || result === undefined) return 'no output';
   if (typeof result === 'string') {
-    if (result.length <= maxChars) return result;
-    return `${result.slice(0, maxChars)}\n... [tool result truncated ${result.length - maxChars} chars, original: ${result.length}]`;
+    const sanitized = sanitizeTextForModel(result);
+    if (sanitized.length <= maxChars) return sanitized;
+    return `${sanitized.slice(0, maxChars)}\n... [tool result truncated ${sanitized.length - maxChars} chars, original: ${sanitized.length}]`;
   }
   if (typeof result !== 'object') return String(result);
 
@@ -361,12 +365,103 @@ export function checkReadDedup(filePath, startLine, endLine, mtimeMs) {
 const READ_ONLY_TOOLS = new Set([
   'read', 'grep', 'glob', 'list',
   'ast_query', 'read_ast_node',
+  'web_fetch', 'web_search',
   'list_background_tasks', 'get_background_task',
   'read_plan'
 ]);
 
+// ─── Auto-capture tool errors to dream loop inbox ────────────────────
+
+const DREAM_AUTO_CAPTURE_TOOLS = new Set([
+  'edit', 'write', 'run', 'delete'
+]);
+
+const DREAM_AUTO_CAPTURE_COOLDOWN_MS = 60_000;
+const lastAutoCaptureByTool = new Map();
+
+function shouldAutoCaptureError(toolName, message) {
+  if (!DREAM_AUTO_CAPTURE_TOOLS.has(toolName)) return false;
+  const now = Date.now();
+  const lastTime = lastAutoCaptureByTool.get(toolName) || 0;
+  if (now - lastTime < DREAM_AUTO_CAPTURE_COOLDOWN_MS) return false;
+  const noisePatterns = [
+    /file already exists/i,
+    /no such file/i,
+    /not found$/i,
+    /already exists$/i,
+    /cancelled/i,
+    /aborted/i,
+    /blocked by (?:safe mode|policy|dangerous command)/i,
+    /exit 127/i,
+    /command not found/i,
+    /permission denied/i,
+    /args\?\s/i,
+    /Raw tool arguments/i,
+    /edit requires/i,
+    /write requires/i,
+    /requires file/i,
+    /path.*outside workspace/i,
+    /escapes workspace/i
+  ];
+  if (noisePatterns.some((p) => p.test(message))) return false;
+  lastAutoCaptureByTool.set(toolName, now);
+  return true;
+}
+
+function fireAndForgetCapture(toolName, message, args) {
+  const summary = `[${toolName}] ${String(message).slice(0, 120)}`;
+  const details = args
+    ? `Tool: ${toolName}\nError: ${message}\nArgs: ${JSON.stringify(args).slice(0, 300)}`
+    : `Tool: ${toolName}\nError: ${message}`;
+  captureToInbox({
+    scope: 'auto',
+    type: 'failure',
+    summary,
+    details,
+    source: 'auto-capture'
+  }).catch(() => {});
+}
+
+async function checkAutoDreamThreshold(config) {
+  const threshold = Number(config?.memory?.auto_dream_threshold || 10);
+  if (threshold <= 0) return false;
+  try {
+    const entries = await listInbox();
+    return entries.length >= threshold;
+  } catch {
+    return false;
+  }
+}
+
 // ─── Exported helpers ────────────────────────────────────────────────
 
+function extractFileChange(toolName, result) {
+  if (!result || typeof result !== 'object') return null;
+  const FILE_TOOLS = new Set(['edit', 'write', 'delete']);
+  if (!FILE_TOOLS.has(toolName)) return null;
+
+  /* delete */
+  if ('deleted' in result && result.deleted) {
+    return { path: String(result.path || ''), action: 'delete', linesAdded: 0, linesRemoved: 0 };
+  }
+
+  /* edit / write */
+  if ('path' in result && 'action' in result) {
+    const action = String(result.action || '');
+    const isCreate = action === 'create';
+    const added = Number(result.lines_added || 0);
+    const removed = Number(result.lines_removed || 0);
+    return {
+      path: String(result.path || ''),
+      action: isCreate ? 'create' : 'edit',
+      linesAdded: added,
+      linesRemoved: removed
+    };
+  }
+
+  return null;
+}
+
 export function summarizeToolResult(result) {
   if (result === null || result === undefined) return 'no output';
   if (typeof result === 'string') {
@@ -586,7 +681,7 @@ function blockedExplorationReason(toolName, args, state) {
   const top = topLevelPath(target);
   if (!top) return '';
 
-  if (['skills', 'souls', 'templates', '.codemini', '.codemini-project'].includes(top)) {
+  if (['skills', 'souls', 'templates', '.codemini', '.codemini-global'].includes(top)) {
     return `Skip ${top}/ for broad repository analysis unless the user explicitly asks for it. Inspect relevant source files first.`;
   }
   return '';
@@ -682,14 +777,17 @@ function formatToolDisplayName(name, args) {
 // ─── Format a single tool result using per-tool formatter or fallback ──
 
 function formatToolResult(toolResult, toolName, args, toolFormatters, toolResultMaxChars) {
+  const sanitizeOptions = getToolOutputSanitizeOptions(toolName);
   if (toolFormatters && typeof toolFormatters[toolName] === 'function') {
     const formatted = toolFormatters[toolName](toolResult, args);
     if (typeof formatted === 'string') {
-      return formatted.trim() ? formatted : emptyToolResultMarker(toolName);
+      const sanitized = sanitizeTextForModel(formatted, sanitizeOptions);
+      return sanitized.trim() ? sanitized : emptyToolResultMarker(toolName);
     }
   }
   const fallback = compactToolResult(toolResult, toolName, args, toolResultMaxChars);
-  return String(fallback || '').trim() ? fallback : emptyToolResultMarker(toolName);
+  const sanitizedFallback = sanitizeTextForModel(fallback, sanitizeOptions);
+  return String(sanitizedFallback || '').trim() ? sanitizedFallback : emptyToolResultMarker(toolName);
 }
 
 // ─── Main agent loop ────────────────────────────────────────────────
@@ -711,7 +809,8 @@ export async function runAgentLoop({
   toolFormatters = {},
   deferredDefinitions = {},
   signal,
-  skipAnalysisNudge = false
+  skipAnalysisNudge = false,
+  config = {}
 }) {
   const messages = [];
   if (systemPrompt) {
@@ -729,10 +828,36 @@ export async function runAgentLoop({
   let pendingSummaryNudges = 0;
   const analysisGuard = createAnalysisGuardState(userPrompt);
   const alwaysAllowSet = new Set((Array.isArray(alwaysAllowTools) ? alwaysAllowTools : []).map((t) => String(t)));
+  let autoDreamChecked = false;
 
   // Mutable tool list — grows as tool_search loads deferred tools
   const activeTools = [...toolDefinitions];
 
+  async function maybeRunAutoDream() {
+    if (autoDreamChecked) return;
+    autoDreamChecked = true;
+    if (executionMode === 'plan') return;
+    const autoDreamResult = await checkAutoDreamThreshold(config);
+    if (!autoDreamResult) return;
+    const dreamTool = toolHandlers['dream_consolidate'];
+    if (typeof dreamTool !== 'function') return;
+    if (onEvent) onEvent({ type: 'dream:auto', message: 'inbox threshold reached' });
+    try {
+      const report = await dreamTool({});
+      if (onEvent) {
+        onEvent({ type: 'dream:complete', report });
+      }
+    } catch (error) {
+      if (onEvent) {
+        onEvent({
+          type: 'dream:complete',
+          report: { ok: false, error: String(error?.message || error || 'unknown dream error') }
+        });
+      }
+      // Auto-dream is best-effort; don't block the loop
+    }
+  }
+
   for (let step = 0; step < maxSteps; step += 1) {
     // 检查是否已被用户中止
     if (signal?.aborted) {
@@ -806,6 +931,7 @@ export async function runAgentLoop({
         continue;
       }
       finalText = assistantText;
+      await maybeRunAutoDream();
       return { text: finalText, messages, steps: step + 1 };
     }
 
@@ -822,6 +948,7 @@ export async function runAgentLoop({
       ]
         .filter(Boolean)
         .join('\n');
+      await maybeRunAutoDream();
       return { text: finalText.trim(), messages, steps: step + 1 };
     }
 
@@ -841,7 +968,11 @@ export async function runAgentLoop({
       let approved = true;
       let approvalArgs = args;
       let preflightErrorContent = '';
-      const needsApproval = toolName === 'delete' || (executionMode === 'normal' && !alwaysAllowSet.has(toolName));
+      const isSafeModeRun = toolName === 'run'
+        && config?.policy?.safe_mode !== false
+        && requiresApprovalEvaluation(args?.command || '', config?.shell?.default);
+      const needsApproval = toolName === 'delete' || isSafeModeRun
+        || (executionMode === 'normal' && !alwaysAllowSet.has(toolName));
       if (needsApproval) {
         approved = false;
         const handler = toolHandlers[toolName];
@@ -857,6 +988,31 @@ export async function runAgentLoop({
             preflightErrorContent = clipToolResult({ error: message }, toolResultMaxChars);
           }
         }
+        /* Run tool: safe mode LLM-based command evaluation */
+        if (toolName === 'run' && isSafeModeRun && !preflightErrorContent) {
+          try {
+            const { evaluateCommandWithLLM } = await import('./command-evaluator.js');
+            const evaluation = await evaluateCommandWithLLM({
+              command: args?.command || '',
+              config,
+              workspaceRoot: config?.workspaceRoot || process.cwd()
+            });
+            approvalArgs = { ...args, _risk: evaluation.risk, _evaluation: evaluation };
+            /* LLM says low-risk + allow → auto-approve, skip confirmation panel */
+            if (evaluation.risk === 'low' && evaluation.recommendation === 'allow') {
+              approvalResults.set(call.id, { approved: true, args: approvalArgs });
+              continue;
+            }
+          } catch (_) {
+            approvalArgs = { ...args, _risk: 'high', _evaluation: null };
+          }
+          if (typeof handler?.prepareApproval === 'function') {
+            try {
+              const approval = await handler.prepareApproval(approvalArgs);
+              approvalArgs = { ...approvalArgs, approval };
+            } catch (_) { /* skip */ }
+          }
+        }
         if (preflightErrorContent) {
           approvalResults.set(call.id, {
             approved: false,
@@ -871,7 +1027,8 @@ export async function runAgentLoop({
             name: toolName,
             displayName,
             arguments: approvalArgs,
-            approvalDetails: toolName === 'delete' ? approvalArgs.approval : undefined
+            approvalDetails: toolName === 'delete' ? approvalArgs.approval
+              : (toolName === 'run' ? approvalArgs.approval : undefined)
           });
           approved = Boolean(decision?.approved);
         }
@@ -941,6 +1098,9 @@ export async function runAgentLoop({
         if (onEvent) {
           onEvent({ type: 'tool:error', name: displayName, id: call.id, arguments: effectiveArgs, durationMs, summary: trimInline(message, 120) });
         }
+        if (shouldAutoCaptureError(toolName, message)) {
+          fireAndForgetCapture(toolName, message, effectiveArgs);
+        }
         return {
           callId: call.id,
           content: clipToolResult({ error: message }, toolResultMaxChars),
@@ -949,8 +1109,28 @@ export async function runAgentLoop({
       }
 
       const durationMs = Date.now() - startedAt;
+      /* 提取文件改动统计 */
+      const fileChange = extractFileChange(toolName, toolResult);
       if (onEvent) {
-        onEvent({ type: 'tool:end', name: displayName, id: call.id, arguments: effectiveArgs, durationMs, summary: summarizeToolResult(toolResult) });
+        onEvent({ type: 'tool:end', name: displayName, id: call.id, arguments: effectiveArgs, durationMs, summary: summarizeToolResult(toolResult), fileChange });
+      }
+
+      // Auto-capture non-throwing tool failures (e.g. shell non-zero exit)
+      if (toolResult && typeof toolResult === 'object') {
+        const exitCode = toolResult.code ?? toolResult.exitCode;
+        const stderr = String(toolResult.stderr || '');
+        if (typeof exitCode === 'number' && exitCode !== 0 && stderr) {
+          const failMsg = `exit ${exitCode}: ${stderr.slice(0, 120)}`;
+          if (shouldAutoCaptureError(toolName, failMsg)) {
+            fireAndForgetCapture(toolName, failMsg, effectiveArgs);
+          }
+        }
+        if (toolResult.error) {
+          const errMsg = String(toolResult.error).slice(0, 120);
+          if (shouldAutoCaptureError(toolName, errMsg)) {
+            fireAndForgetCapture(toolName, errMsg, effectiveArgs);
+          }
+        }
       }
 
       // P1b: Use per-tool formatter if available, else fallback
@@ -1031,6 +1211,7 @@ export async function runAgentLoop({
   }
 
   const fallback = lastAssistantText || 'Stopped before final response.';
+  await maybeRunAutoDream();
   return {
     text: `${fallback}\n\n[stopped] Reached max tool steps (${maxSteps}). Try a narrower prompt or increase execution.max_steps.`,
     messages,