codemini-cli 0.3.5 → 0.3.7

package/src/core/agent-loop.js

@@ -2,15 +2,22 @@ import os from 'node:os';
 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';
 
+/**
+ * 安全解析 JSON 字符串。
+ * 解析失败时返回带 _raw 和 _invalid_json 标记的对象，
+ * 调用方可据此决定是回退到原始文本还是报告错误。
+ */
 function safeJsonParse(raw) {
   if (!raw || typeof raw !== 'string') return {};
   try {
     return JSON.parse(raw);
-  } catch {
+  } catch (parseError) {
     return {
       _raw: String(raw),
-      _invalid_json: true
+      _invalid_json: true,
+      _parseError: parseError.message
     };
   }
 }
@@ -29,6 +36,41 @@ function parseInlineRangePath(value) {
   return { path: maybePath, start_line: start, end_line: end };
 }
 
+function buildDeleteApprovalDetails(source, rawPath) {
+  const existing =
+    source?.approval && typeof source.approval === 'object' && !Array.isArray(source.approval)
+      ? source.approval
+      : {};
+  const approvalPath = String(existing.path || rawPath || '').trim();
+  const approvalName = String(existing.name || (approvalPath ? path.basename(approvalPath) : '') || '').trim();
+  const approvalType = String(existing.type || '').trim();
+
+  const approval = {};
+  if (approvalPath) approval.path = approvalPath;
+  if (approvalName) approval.name = approvalName;
+  if (approvalType) approval.type = approvalType;
+  return Object.keys(approval).length > 0 ? approval : undefined;
+}
+
+function buildDeleteCancellationResult(args) {
+  const approval =
+    args?.approval && typeof args.approval === 'object' && !Array.isArray(args.approval)
+      ? args.approval
+      : undefined;
+  const pathValue = String(approval?.path || args?.path || '').trim();
+  const nameValue = String(approval?.name || (pathValue ? path.basename(pathValue) : '') || '').trim();
+  const typeValue = String(approval?.type || '').trim();
+  return {
+    ok: false,
+    ...(pathValue ? { path: pathValue } : {}),
+    ...(nameValue ? { name: nameValue } : {}),
+    ...(typeValue ? { type: typeValue } : {}),
+    deleted: false,
+    cancelled: true,
+    reason: 'User denied deletion approval'
+  };
+}
+
 function normalizeToolArguments(toolName, args, rawArguments) {
   const rawText = typeof rawArguments === 'string' ? rawArguments.trim() : '';
   const primitive =
@@ -102,6 +144,14 @@ function normalizeToolArguments(toolName, args, rawArguments) {
     return source;
   }
 
+  if (toolName === 'delete') {
+    const value = String(source.path || source.file_path || source.file || source.target || source.directory || source.dir || stringValue || '').trim();
+    if (value) source.path = value;
+    const approval = buildDeleteApprovalDetails(source, source.path);
+    if (approval) source.approval = approval;
+    return source;
+  }
+
   return source;
 }
 
@@ -307,7 +357,7 @@ export function checkReadDedup(filePath, startLine, endLine, mtimeMs) {
 
 const READ_ONLY_TOOLS = new Set([
   'read', 'grep', 'glob', 'list',
-  'ast_query', 'read_ast_node', 'generate_diff',
+  'ast_query', 'read_ast_node',
   'list_background_tasks', 'get_background_task'
 ]);
 
@@ -322,6 +372,12 @@ export function summarizeToolResult(result) {
   if (typeof result === 'object') {
     const obj = result;
     if (Array.isArray(obj)) return `array(${obj.length})`;
+    if ('deleted' in obj && 'path' in obj) {
+      const kind = trimInline(obj.type || 'item', 16);
+      const target = trimInline(obj.path || '', 96);
+      if (obj.deleted) return target ? `deleted ${kind} ${target}` : `deleted ${kind}`;
+      if (obj.cancelled) return target ? `cancelled delete ${target}` : 'cancelled delete';
+    }
     if ('path' in obj && 'action' in obj) {
       const p = String(obj.path || '');
       const action = String(obj.action || 'write');
@@ -354,11 +410,12 @@ export function summarizeToolResult(result) {
           : start;
       const rangeText = start > 0 && end >= start ? ` lines ${start}-${end}` : '';
       const totalText = total > 0 ? ` of ${total}` : '';
+      const enclosingText = obj.enclosing_symbol ? ` in ${obj.enclosing_symbol}` : '';
       const errorText = obj.error ? ` (${trimInline(obj.error, 64)})` : '';
       const truncatedText = obj.truncated ? ' [truncated]' : '';
       return phase === 'metadata'
         ? `metadata for ${p}${rangeText}${totalText}${errorText}`
-        : `content from ${p}${rangeText}${totalText}${truncatedText}`;
+        : `content from ${p}${rangeText}${totalText}${enclosingText}${truncatedText}`;
     }
     if ('stdout' in obj || 'stderr' in obj || 'code' in obj) {
       const stdout = trimInline(obj.stdout || '', 96);
@@ -405,12 +462,7 @@ export function summarizeToolResult(result) {
   return String(result);
 }
 
-export function trimInline(value, maxLen = 72) {
-  const s = String(value || '').replace(/\s+/g, ' ').trim();
-  if (!s) return '';
-  if (s.length <= maxLen) return s;
-  return `${s.slice(0, maxLen - 3)}...`;
-}
+export const trimInline = _trimInline;
 
 function normalizeAssistantText(value) {
   return String(value || '').trim();
@@ -503,12 +555,12 @@ function createAnalysisGuardState(userPrompt) {
 }
 
 function topLevelPath(value) {
-  const normalized = String(value || '').replace(/\\/g, '/').replace(/^\.\/+/, '').trim();
+  const normalized = normalizePath(value).trim();
   return normalized.split('/')[0] || '';
 }
 
 function isRelevantSourcePath(filePath, state) {
-  const normalized = String(filePath || '').replace(/\\/g, '/').trim();
+  const normalized = normalizePath(filePath).trim();
   if (!normalized) return false;
   if (state.candidateFiles.has(normalized) || state.entryCandidates.has(normalized)) return true;
   for (const root of state.sourceRoots) {
@@ -519,20 +571,17 @@ function isRelevantSourcePath(filePath, state) {
 
 function blockedExplorationReason(toolName, args, state) {
   if (!state.active) return '';
-  if (!state.indexQueried && toolName !== 'query_project_index') {
-    return 'Use query_project_index before broad repository exploration so the next reads stay focused on relevant source files.';
-  }
 
-  const target = String(args?.path || args?.pattern || args?.query || '').replace(/\\/g, '/').trim();
+  // Always note when query_project_index is used, but never force it
+  if (toolName === 'query_project_index') return '';
+
+  const target = normalizePath(String(args?.path || args?.pattern || args?.query || '')).trim();
   const top = topLevelPath(target);
   if (!top) return '';
 
   if (['skills', 'souls', 'templates', '.codemini', '.codemini-project'].includes(top)) {
     return `Skip ${top}/ for broad repository analysis unless the user explicitly asks for it. Inspect relevant source files first.`;
   }
-  if (top === 'tests' && state.relevantSourceReads.size < 2) {
-    return 'Inspect the next relevant source files before reading tests. Broad analysis should be grounded in production code first.';
-  }
   return '';
 }
 
@@ -603,13 +652,13 @@ function formatToolDisplayName(name, args) {
     const target = trimInline(args?.path || args?.file || '.', 96) || '.';
     return `edit(${target})`;
   }
+  if (name === 'delete') {
+    const target = trimInline(args?.path || args?.target || '.', 96) || '.';
+    return `delete(${target})`;
+  }
   if (name === 'update_todos') {
     return 'update_todos';
   }
-  if (name === 'patch') {
-    const target = trimInline(args?.path || args?.file || args?.patch || '', 96) || '.';
-    return `patch(${target})`;
-  }
   if (name === 'list_background_tasks') {
     return name;
   }
@@ -617,10 +666,6 @@ function formatToolDisplayName(name, args) {
     const taskId = trimInline(args?.task_id || args?.taskId || '', 96);
     return taskId ? `${name}(${taskId})` : name;
   }
-  if (name === 'read' || name === 'write' || name === 'run' || name === 'grep' || name === 'glob' || name === 'list' || name === 'edit' || name === 'patch' || name === 'generate_diff') {
-    const target = trimInline(args?.path || args?.query || args?.symbol || '', 96);
-    return target ? `${name}(${target})` : name;
-  }
   return name;
 }
 
@@ -654,7 +699,9 @@ export async function runAgentLoop({
   requestToolApproval,
   toolResultMaxChars = 12000,
   toolFormatters = {},
-  deferredDefinitions = {}
+  deferredDefinitions = {},
+  signal,
+  skipAnalysisNudge = false
 }) {
   const messages = [];
   if (systemPrompt) {
@@ -677,13 +724,25 @@ export async function runAgentLoop({
   const activeTools = [...toolDefinitions];
 
   for (let step = 0; step < maxSteps; step += 1) {
+    // 检查是否已被用户中止
+    if (signal?.aborted) {
+      if (onEvent) onEvent({ type: 'aborted', step: step + 1 });
+      break;
+    }
     if (onEvent) onEvent({ type: 'step:start', step: step + 1 });
     const completion = await requestCompletion({
       model,
       messages,
-      tools: activeTools
+      tools: activeTools,
+      signal
     });
 
+    // 流式请求完成后再次检查中止状态
+    if (signal?.aborted) {
+      if (onEvent) onEvent({ type: 'aborted', step: step + 1 });
+      break;
+    }
+
     if (completion?.incomplete) {
       continue;
     }
@@ -718,7 +777,7 @@ export async function runAgentLoop({
     }
 
     if (toolCalls.length === 0) {
-      if (needsMoreAnalysisEvidence(analysisGuard) && pendingSummaryNudges < 2) {
+      if (!skipAnalysisNudge && needsMoreAnalysisEvidence(analysisGuard) && pendingSummaryNudges < 2) {
         pendingSummaryNudges += 1;
         messages.push({
           role: 'user',
@@ -727,7 +786,7 @@ export async function runAgentLoop({
         });
         continue;
       }
-      if (shouldAskForConcreteFinalAnswer(assistantText, messages.slice(0, -1)) && pendingSummaryNudges < 2) {
+      if (!skipAnalysisNudge && shouldAskForConcreteFinalAnswer(assistantText, messages.slice(0, -1)) && pendingSummaryNudges < 2) {
         pendingSummaryNudges += 1;
         messages.push({
           role: 'user',
@@ -770,19 +829,44 @@ export async function runAgentLoop({
     const approvalResults = new Map();
     for (const { call, toolName, displayName, args } of callsWithMeta) {
       let approved = true;
-      if (executionMode === 'normal' && !alwaysAllowSet.has(toolName)) {
+      let approvalArgs = args;
+      let preflightErrorContent = '';
+      const needsApproval = toolName === 'delete' || (executionMode === 'normal' && !alwaysAllowSet.has(toolName));
+      if (needsApproval) {
         approved = false;
+        const handler = toolHandlers[toolName];
+        if (toolName === 'delete' && typeof handler?.prepareApproval === 'function') {
+          try {
+            const approval = await handler.prepareApproval(args);
+            const normalizedApproval = buildDeleteApprovalDetails({ approval }, args?.path);
+            if (normalizedApproval) {
+              approvalArgs = { ...args, approval: normalizedApproval };
+            }
+          } catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            preflightErrorContent = clipToolResult({ error: message }, toolResultMaxChars);
+          }
+        }
+        if (preflightErrorContent) {
+          approvalResults.set(call.id, {
+            approved: false,
+            args: approvalArgs,
+            errorContent: preflightErrorContent
+          });
+          continue;
+        }
         if (typeof requestToolApproval === 'function') {
           const decision = await requestToolApproval({
             id: call.id,
             name: toolName,
             displayName,
-            arguments: args
+            arguments: approvalArgs,
+            approvalDetails: toolName === 'delete' ? approvalArgs.approval : undefined
           });
           approved = Boolean(decision?.approved);
         }
       }
-      approvalResults.set(call.id, approved);
+      approvalResults.set(call.id, { approved, args: approvalArgs });
     }
 
     // Collect results keyed by call.id, then write to messages in original order
@@ -791,28 +875,45 @@ export async function runAgentLoop({
     // Helper to execute a single tool call
     async function executeOne({ call, args, toolName, displayName, isReadOnly }) {
       const startedAt = Date.now();
+      const approvalState = approvalResults.get(call.id) || { approved: true, args };
+      const effectiveArgs = approvalState.args || args;
+
+      if (approvalState.errorContent) {
+        if (onEvent) {
+          onEvent({ type: 'tool:error', name: displayName, id: call.id, arguments: effectiveArgs, durationMs: 0, summary: trimInline(approvalState.errorContent, 120) });
+        }
+        return {
+          callId: call.id,
+          content: approvalState.errorContent,
+          error: true
+        };
+      }
 
-      if (!approvalResults.get(call.id)) {
-        if (onEvent) onEvent({ type: 'tool:blocked', name: displayName, id: call.id, arguments: args });
+      if (!approvalState.approved) {
+        if (onEvent) onEvent({ type: 'tool:blocked', name: displayName, id: call.id, arguments: effectiveArgs });
+        const blockedPayload =
+          toolName === 'delete'
+            ? buildDeleteCancellationResult(effectiveArgs)
+            : { blocked: true, reason: 'Tool call requires approval in normal mode' };
         return {
           callId: call.id,
-          content: JSON.stringify({ blocked: true, reason: 'Tool call requires approval in normal mode' }),
+          content: JSON.stringify(blockedPayload),
           blocked: true
         };
       }
 
-      if (onEvent) onEvent({ type: 'tool:start', name: displayName, id: call.id, arguments: args });
+      if (onEvent) onEvent({ type: 'tool:start', name: displayName, id: call.id, arguments: effectiveArgs });
       const handler = toolHandlers[toolName];
       if (!handler) {
         throw new Error(`Unknown tool: ${call.name}`);
       }
 
-      const blockedReason = blockedExplorationReason(toolName, args, analysisGuard);
+      const blockedReason = blockedExplorationReason(toolName, effectiveArgs, analysisGuard);
       if (blockedReason) {
         analysisGuard.blockedExplorations += 1;
         const content = clipToolResult({ error: blockedReason }, toolResultMaxChars);
         if (onEvent) {
-          onEvent({ type: 'tool:error', name: displayName, id: call.id, arguments: args, durationMs: 0, summary: trimInline(blockedReason, 120) });
+          onEvent({ type: 'tool:error', name: displayName, id: call.id, arguments: effectiveArgs, durationMs: 0, summary: trimInline(blockedReason, 120) });
         }
         return {
           callId: call.id,
@@ -823,12 +924,12 @@ export async function runAgentLoop({
 
       let toolResult;
       try {
-        toolResult = await handler(args);
+        toolResult = await handler(effectiveArgs);
       } catch (error) {
         const durationMs = Date.now() - startedAt;
         const message = error instanceof Error ? error.message : String(error);
         if (onEvent) {
-          onEvent({ type: 'tool:error', name: displayName, id: call.id, arguments: args, durationMs, summary: trimInline(message, 120) });
+          onEvent({ type: 'tool:error', name: displayName, id: call.id, arguments: effectiveArgs, durationMs, summary: trimInline(message, 120) });
         }
         return {
           callId: call.id,
@@ -839,12 +940,12 @@ export async function runAgentLoop({
 
       const durationMs = Date.now() - startedAt;
       if (onEvent) {
-        onEvent({ type: 'tool:end', name: displayName, id: call.id, arguments: args, durationMs, summary: summarizeToolResult(toolResult) });
+        onEvent({ type: 'tool:end', name: displayName, id: call.id, arguments: effectiveArgs, durationMs, summary: summarizeToolResult(toolResult) });
       }
 
       // P1b: Use per-tool formatter if available, else fallback
-      let formatted = formatToolResult(toolResult, toolName, args, toolFormatters, toolResultMaxChars);
-      noteAnalysisEvidence(analysisGuard, toolName, args, toolResult);
+      let formatted = formatToolResult(toolResult, toolName, effectiveArgs, toolFormatters, toolResultMaxChars);
+      noteAnalysisEvidence(analysisGuard, toolName, effectiveArgs, toolResult);
 
       // P2: If tool_search loaded deferred tools, inject their schemas into activeTools
       if (toolName === 'tool_search' && toolResult && Array.isArray(toolResult.schemas)) {
@@ -863,8 +964,8 @@ export async function runAgentLoop({
     }
 
     // Separate read-only and write calls, preserving order
-    const readOnlyCalls = callsWithMeta.filter((c) => c.isReadOnly && approvalResults.get(c.call.id));
-    const writeCalls = callsWithMeta.filter((c) => !c.isReadOnly || !approvalResults.get(c.call.id));
+    const readOnlyCalls = callsWithMeta.filter((c) => c.isReadOnly && approvalResults.get(c.call.id)?.approved);
+    const writeCalls = callsWithMeta.filter((c) => !c.isReadOnly || !approvalResults.get(c.call.id)?.approved);
 
     // Execute read-only calls in parallel
     if (readOnlyCalls.length > 0) {
@@ -908,6 +1009,17 @@ export async function runAgentLoop({
     }
   }
 
+  // 如果被用户中止，返回已有内容并标记
+  if (signal?.aborted) {
+    const fallback = lastAssistantText || '';
+    return {
+      text: fallback,
+      messages,
+      steps: maxSteps,
+      aborted: true
+    };
+  }
+
   const fallback = lastAssistantText || 'Stopped before final response.';
   return {
     text: `${fallback}\n\n[stopped] Reached max tool steps (${maxSteps}). Try a narrower prompt or increase execution.max_steps.`,

package/src/core/ast.js

@@ -153,6 +153,46 @@ function exactNodeForTarget(rootNode, target) {
   return null;
 }
 
+/**
+ * Find the enclosing named structural symbol (function, class, method, etc.)
+ * for a given line range in already-parsed content. Returns null if not found
+ * or if the language is unsupported.
+ */
+export async function findEnclosingSymbol(content, filePath, line) {
+  const ext = path.extname(String(filePath || '')).toLowerCase();
+  const language = EXTENSION_LANGUAGE_MAP[ext];
+  if (!language) return null;
+  let parser = null;
+  let tree = null;
+  try {
+    const parsed = await parseContent(content, language);
+    parser = parsed.parser;
+    tree = parsed.tree;
+    const row = Math.max(0, Number(line || 1) - 1);
+    const node = tree.rootNode.descendantForPosition({ row, column: 0 });
+    let current = node;
+    while (current) {
+      if (current.type === 'program' || !current.parent) break;
+      const nameChild = current.childForFieldName('name');
+      if (nameChild) {
+        return {
+          name: nameChild.text,
+          kind: current.type,
+          start_line: current.startPosition.row + 1,
+          end_line: current.endPosition.row + 1
+        };
+      }
+      current = current.parent;
+    }
+    return null;
+  } catch {
+    return null;
+  } finally {
+    if (tree) tree.delete();
+    if (parser) parser.delete();
+  }
+}
+
 export async function queryAst(root, args) {
   const relativePath = String(args?.path || '').trim();
   const querySource = String(args?.query || '').trim();