codemini-cli 0.3.4 → 0.3.6

package/src/core/command-policy.js

@@ -1,6 +1,26 @@
 import path from 'node:path';
 import { getEffectivePolicy } from './shell-profile.js';
 
+const SHELL_KEYWORDS = new Set([
+  'if',
+  'then',
+  'elif',
+  'else',
+  'fi',
+  'for',
+  'while',
+  'until',
+  'do',
+  'done',
+  'case',
+  'esac',
+  'in',
+  'function',
+  'time',
+  '{',
+  '}'
+]);
+
 function firstToken(command) {
   const m = String(command || '').trim().match(/^"([^"]+)"|^'([^']+)'|^(\S+)/);
   const raw = (m && (m[1] || m[2] || m[3])) || '';
@@ -51,6 +71,11 @@ function splitCommandSegments(command) {
       continue;
     }
 
+    if (ch === '&' && text[i - 1] === '>') {
+      current += ch;
+      continue;
+    }
+
     if (ch === '|' || ch === ';' || ch === '&') {
       if (current.trim()) segments.push(current.trim());
       current = '';
@@ -157,6 +182,30 @@ function suggestionForToken(token, config) {
   return 'Prefer structured tools like read, edit, write, grep, glob, and list first. If you need shell fallback, use allowed shell commands for search and local context such as rg, find, grep, sed, cat, or ls.';
 }
 
+function validateCdSegment(command, workspaceRoot) {
+  const tokens = tokenizeTopLevel(command);
+  if (tokens.length === 1) {
+    return { allowed: false, reason: 'cd requires a target path in safe mode' };
+  }
+  if (tokens.length !== 2) {
+    return { allowed: false, reason: 'cd only supports a single target path in safe mode' };
+  }
+
+  const rawTarget = String(tokens[1] || '').trim();
+  if (!rawTarget || rawTarget.startsWith('-')) {
+    return { allowed: false, reason: 'cd target is not allowed in safe mode' };
+  }
+
+  const resolvedRoot = path.resolve(workspaceRoot);
+  const resolvedTarget = path.resolve(resolvedRoot, rawTarget);
+  const relative = path.relative(resolvedRoot, resolvedTarget);
+  if (relative.startsWith('..') || path.isAbsolute(relative)) {
+    return { allowed: false, reason: `cd escapes workspace: ${rawTarget}` };
+  }
+
+  return { allowed: true };
+}
+
 export function evaluateCommandPolicy(command, config, workspaceRoot = process.cwd()) {
   const policy = getEffectivePolicy(config);
   const cmd = String(command || '').trim();
@@ -181,6 +230,13 @@ export function evaluateCommandPolicy(command, config, workspaceRoot = process.c
   const inspectedTokens = collectCommandTokens(cmd);
   const allowlist = Array.isArray(policy.command_allowlist) ? policy.command_allowlist : [];
   for (const item of inspectedTokens) {
+    if (SHELL_KEYWORDS.has(item.token)) continue;
+    if (item.token === 'cd') {
+      const cdCheck = validateCdSegment(item.raw, workspaceRoot);
+      if (!cdCheck.allowed) {
+        return { allowed: false, reason: cdCheck.reason, suggestion: suggestionForToken(item.token, config) };
+      }
+    }
     if (includesAny(item.token, policy.blocked_commands)) {
       return { allowed: false, reason: `blocked command: ${item.token}`, suggestion: suggestionForToken(item.token, config) };
     }

package/src/core/config-store.js

@@ -44,8 +44,6 @@ const DEFAULT_CONFIG = {
       'edit',
       'write',
       'run',
-      'patch',
-      'generate_diff',
       'list_background_tasks',
       'get_background_task',
       'stop_background_task'
@@ -151,7 +149,6 @@ function normalizePolicyLists(config) {
       'edit',
       'write',
       'run',
-      'generate_diff',
       'list_background_tasks',
       'get_background_task',
       'stop_background_task',

package/src/core/crypto-utils.js

@@ -1,12 +1,16 @@
 /**
  * 共享加密工具函数。
- * 统一 sha1 / sha256 的实现，避免在各模块中重复定义。
+ * 统一使用 sha256 作为默认哈希算法，避免在各模块中重复定义。
  */
 
 import crypto from 'node:crypto';
 
+/**
+ * 向后兼容别名，内部已迁移到 sha256。
+ * @deprecated 请使用 sha256() 替代。
+ */
 export function sha1(input) {
-  return crypto.createHash('sha1').update(String(input || '')).digest('hex');
+  return sha256(input);
 }
 
 export function sha256(input) {

package/src/core/memory-store.js

@@ -1,6 +1,6 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
-import { sha1 } from './crypto-utils.js';
+import { sha256 } from './crypto-utils.js';
 import { getMemoryDir, getProjectMemoryDir } from './paths.js';
 import { assertSafeMemoryContent, normalizeMemoryText, summarizeMemoryContent } from './memory-policy.js';
 
@@ -23,7 +23,7 @@ export function getProjectMemoryKey(workspaceRoot = process.cwd(), projectAlias
   if (alias) return slugify(alias);
   const root = path.resolve(workspaceRoot || process.cwd());
   const base = path.basename(root);
-  return `${slugify(base)}-${sha1(root).slice(0, 10)}`;
+  return `${slugify(base)}-${sha256(root).slice(0, 10)}`;
 }
 
 function ensureScope(scope) {
@@ -63,7 +63,7 @@ function normalizeMemoryItem(item, scope, projectKey = '') {
   const now = nowIso();
   const content = normalizeMemoryText(item?.content || '');
   return {
-    id: String(item?.id || `mem_${sha1(`${scope}:${projectKey}:${content}:${now}:${Math.random()}`).slice(0, 12)}`),
+    id: String(item?.id || `mem_${sha256(`${scope}:${projectKey}:${content}:${now}:${Math.random()}`).slice(0, 12)}`),
     scope,
     projectKey: projectKey || undefined,
     kind: String(item?.kind || 'note').trim() || 'note',

package/src/core/project-index.js

@@ -2,8 +2,9 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import { getFileIndexPath, getProjectIndexDir, getProjectMapPath, getProjectWorkspaceDir } from './paths.js';
 import { INDEX_SKIP_DIRS as SKIP_DIRS, SOURCE_EXTENSIONS, EXTENSION_LANGUAGE_MAP } from './constants.js';
-import { sha1 } from './crypto-utils.js';
+import { sha256 } from './crypto-utils.js';
 import { BoundedCache } from './bounded-cache.js';
+import { trimInline, normalizeRelativePath, escapeRegex } from './string-utils.js';
 
 const PROJECT_MARKER_FILES = new Set([
   'package.json',
@@ -31,11 +32,7 @@ function clipList(values, max = 32) {
 }
 
 function rel(cwd, filePath) {
-  return path.relative(cwd, filePath).replace(/\\/g, '/');
-}
-
-function normalizeRelativePath(value) {
-  return String(value || '').replace(/\\/g, '/').replace(/^\.\/+/, '').replace(/^\/+/, '');
+  return normalizeRelativePath(path.relative(cwd, filePath));
 }
 
 async function safeStat(filePath) {
@@ -58,13 +55,6 @@ function tokenizeQuery(text) {
   return [...new Set(String(text || '').toLowerCase().match(/[a-z0-9_./-]+/g) || [])].filter(Boolean);
 }
 
-function trimInline(value, max = 240) {
-  const text = String(value || '').replace(/\s+/g, ' ').trim();
-  if (!text) return '';
-  if (text.length <= max) return text;
-  return `${text.slice(0, max - 3)}...`;
-}
-
 function trimMultiline(value, max = 1800) {
   const text = String(value || '').trim();
   if (!text) return '';
@@ -77,10 +67,6 @@ async function writeJson(filePath, value) {
   await fs.writeFile(filePath, `${JSON.stringify(value, null, 2)}\n`, 'utf8');
 }
 
-function escapeRegex(value) {
-  return String(value || '').replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-
 function gitignorePatternToRegex(pattern) {
   const normalized = normalizeRelativePath(pattern);
   let regexBody = '';
@@ -282,7 +268,7 @@ function buildFileEntry(relativePath, content, stat) {
   return {
     file: relativePath,
     language: LANGUAGE_BY_EXT[ext] || 'text',
-    hash: sha1(content),
+    hash: sha256(content),
     size: Number(stat?.size || content.length || 0),
     mtimeMs: Number(stat?.mtimeMs || 0),
     imports,

package/src/core/provider/anthropic.js

@@ -318,14 +318,27 @@ export async function createChatCompletionStream({
   onTextDelta,
   onToolCallDelta,
   timeoutMs = 90000,
-  maxTokens = 4096
+  maxTokens = 4096,
+  signal: externalSignal
 }) {
+  // 合并超时信号与外部中止信号
+  const timeoutSignal = AbortSignal.timeout(timeoutMs);
+  const controller = new AbortController();
+  const onAbort = () => controller.abort();
+  timeoutSignal.addEventListener('abort', onAbort, { once: true });
+  if (externalSignal) {
+    if (externalSignal.aborted) {
+      controller.abort();
+    } else {
+      externalSignal.addEventListener('abort', onAbort, { once: true });
+    }
+  }
   const payload = buildPayload({ model, temperature, messages, tools, stream: true, maxTokens });
   const response = await fetch(buildMessagesUrl(baseUrl), {
     method: 'POST',
     headers: createHeaders(apiKey),
     body: JSON.stringify(payload),
-    signal: AbortSignal.timeout(timeoutMs)
+    signal: controller.signal
   });
 
   if (!response.ok || !response.body) {

package/src/core/provider/anthropic.sdk-backup.js

@@ -0,0 +1,439 @@
+import Anthropic from '@anthropic-ai/sdk';
+
+function extractTextContent(content) {
+  if (typeof content === 'string') return content;
+  if (Array.isArray(content)) {
+    return content
+      .map((part) => {
+        if (typeof part === 'string') return part;
+        if (part?.type === 'text') return part.text || '';
+        return '';
+      })
+      .join('');
+  }
+  return '';
+}
+
+function normalizeIncomingToolCallArguments(argumentsValue) {
+  if (typeof argumentsValue === 'string') return argumentsValue;
+  if (argumentsValue == null) return '{}';
+  try {
+    return JSON.stringify(argumentsValue);
+  } catch {
+    return '{}';
+  }
+}
+
+function tryParseJsonObject(raw) {
+  if (raw && typeof raw === 'object' && !Array.isArray(raw)) {
+    return raw;
+  }
+  if (typeof raw !== 'string') return {};
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+      return parsed;
+    }
+  } catch {}
+  return {};
+}
+
+function normalizeAssistantContentBlocks(message) {
+  if (Array.isArray(message?.content) && message.content.length > 0) {
+    return message.content.map((block) => ({ ...block }));
+  }
+
+  const contentBlocks = [];
+  const text = extractTextContent(message?.content);
+  if (text) {
+    contentBlocks.push({ type: 'text', text });
+  }
+
+  if (Array.isArray(message?.tool_calls)) {
+    for (const toolCall of message.tool_calls) {
+      const name = String(toolCall?.function?.name || toolCall?.name || '').trim();
+      if (!name) continue;
+      contentBlocks.push({
+        type: 'tool_use',
+        id: String(toolCall?.id || ''),
+        name,
+        input: tryParseJsonObject(toolCall?.function?.arguments ?? toolCall?.arguments)
+      });
+    }
+  }
+
+  return contentBlocks;
+}
+
+function normalizeMessages(messages) {
+  const source = Array.isArray(messages) ? messages : [];
+  const systemParts = [];
+  const out = [];
+
+  for (const message of source) {
+    if (!message || typeof message !== 'object') continue;
+    if (message.role === 'system') {
+      const text = extractTextContent(message.content);
+      if (text) systemParts.push(text);
+      continue;
+    }
+
+    if (message.role === 'tool') {
+      out.push({
+        role: 'user',
+        content: [
+          {
+            type: 'tool_result',
+            tool_use_id: String(message.tool_call_id || ''),
+            content: extractTextContent(message.content)
+          }
+        ]
+      });
+      continue;
+    }
+
+    if (message.role === 'assistant') {
+      out.push({
+        role: 'assistant',
+        content: normalizeAssistantContentBlocks(message)
+      });
+      continue;
+    }
+
+    out.push({
+      role: message.role,
+      content: [{ type: 'text', text: extractTextContent(message.content) }]
+    });
+  }
+
+  return {
+    system: systemParts.join('\n\n').trim() || undefined,
+    messages: out
+  };
+}
+
+function normalizeTools(tools) {
+  const source = Array.isArray(tools) ? tools : [];
+  return source
+    .map((tool) => {
+      const fn = tool?.function || {};
+      const name = String(fn.name || '').trim();
+      if (!name) return null;
+      return {
+        name,
+        ...(fn.description ? { description: String(fn.description) } : {}),
+        input_schema: fn.parameters && typeof fn.parameters === 'object' ? fn.parameters : { type: 'object' }
+      };
+    })
+    .filter(Boolean);
+}
+
+function buildPayload({ model, temperature, messages, tools, stream = false, maxTokens = 4096 }) {
+  const normalized = normalizeMessages(messages);
+  const payload = {
+    model,
+    max_tokens: maxTokens,
+    temperature,
+    messages: normalized.messages
+  };
+  if (normalized.system) payload.system = normalized.system;
+  if (stream) payload.stream = true;
+
+  const normalizedTools = normalizeTools(tools);
+  if (normalizedTools.length > 0) {
+    payload.tools = normalizedTools;
+    payload.tool_choice = { type: 'auto' };
+  }
+  return payload;
+}
+
+function hasTrailingToolContext(messages) {
+  const source = Array.isArray(messages) ? messages : [];
+  for (let index = source.length - 1; index >= 0; index -= 1) {
+    const message = source[index];
+    if (!message || typeof message !== 'object') continue;
+    if (message.role === 'tool') return true;
+    if (message.role === 'assistant' || message.role === 'user') return false;
+  }
+  return false;
+}
+
+function buildAssistantMessage(content) {
+  return {
+    role: 'assistant',
+    content
+  };
+}
+
+function extractAssistantResult(data, messages) {
+  const content = Array.isArray(data?.content) ? data.content.map((block) => ({ ...block })) : [];
+  const text = content
+    .filter((block) => block?.type === 'text')
+    .map((block) => block.text || '')
+    .join('');
+  const toolCalls = content
+    .filter((block) => block?.type === 'tool_use')
+    .map((block) => ({
+      id: String(block.id || ''),
+      name: String(block.name || ''),
+      arguments: normalizeIncomingToolCallArguments(block.input)
+    }))
+    .filter((toolCall) => toolCall.name);
+  const normalizedText = String(text || '').trim();
+
+  if (!normalizedText && toolCalls.length === 0) {
+    if (hasTrailingToolContext(messages)) {
+      return {
+        text: '',
+        toolCalls: [],
+        usage: data?.usage || null,
+        incomplete: true,
+        content
+      };
+    }
+    throw new Error('Anthropic gateway returned empty assistant response');
+  }
+
+  return {
+    text,
+    toolCalls,
+    usage: data?.usage || null,
+    content,
+    assistantMessage: buildAssistantMessage(content)
+  };
+}
+
+function mergeUsage(current, next) {
+  if (!next || typeof next !== 'object') return current;
+  return {
+    ...(current || {}),
+    ...next
+  };
+}
+
+function emptyToolCall(index) {
+  return {
+    index,
+    id: '',
+    name: '',
+    arguments: ''
+  };
+}
+
+function buildFinalStreamResult(text, toolCallsByIndex, usage, messages, contentBlocksByIndex) {
+  const toolCalls = Array.from(toolCallsByIndex.entries())
+    .sort((a, b) => a[0] - b[0])
+    .map(([, tc], i) => ({
+      id: tc.id || `tc-${i + 1}`,
+      name: tc.name,
+      arguments: tc.arguments || '{}'
+    }))
+    .filter((tc) => tc.name);
+  const normalizedText = String(text || '').trim();
+  const content = Array.from(contentBlocksByIndex.entries())
+    .sort((a, b) => a[0] - b[0])
+    .map(([, block]) => {
+      if (block.type === 'tool_use') {
+        return {
+          type: 'tool_use',
+          id: block.id,
+          name: block.name,
+          input: tryParseJsonObject(block.arguments)
+        };
+      }
+      if (block.type === 'thinking') {
+        return {
+          type: 'thinking',
+          thinking: block.thinking || '',
+          ...(block.signature ? { signature: block.signature } : {})
+        };
+      }
+      return {
+        type: 'text',
+        text: block.text || ''
+      };
+    })
+    .filter((block) => {
+      if (block.type === 'tool_use') return Boolean(block.name);
+      if (block.type === 'thinking') return Boolean(block.thinking);
+      return Boolean(block.text);
+    });
+
+  if (!normalizedText && toolCalls.length === 0) {
+    if (hasTrailingToolContext(messages)) {
+      return {
+        text: '',
+        toolCalls: [],
+        usage,
+        incomplete: true,
+        content: []
+      };
+    }
+    throw new Error('Anthropic gateway stream returned empty assistant response');
+  }
+
+  return {
+    text,
+    toolCalls,
+    usage,
+    incomplete: false,
+    content,
+    assistantMessage: buildAssistantMessage(content)
+  };
+}
+
+function createClient({ baseUrl, apiKey, timeoutMs = 90000, maxRetries = 2 }) {
+  return new Anthropic({
+    apiKey,
+    baseURL: String(baseUrl || '').replace(/\/$/, ''),
+    timeout: timeoutMs,
+    maxRetries
+  });
+}
+
+function inferEventType(event) {
+  const explicit = String(event?.type || event?.event || '').trim();
+  if (explicit) return explicit;
+  if (event?.content_block && typeof event?.index === 'number') return 'content_block_start';
+  if (event?.delta && typeof event?.index === 'number') return 'content_block_delta';
+  if (event?.message) return 'message_start';
+  if (event?.usage) return 'message_delta';
+  if (event && typeof event === 'object' && Object.keys(event).length === 0) return 'message_stop';
+  return '';
+}
+
+export async function createChatCompletion({
+  baseUrl,
+  apiKey,
+  model,
+  messages,
+  temperature = 0.2,
+  tools,
+  timeoutMs = 90000,
+  maxTokens = 4096,
+  maxRetries = 2
+}) {
+  const client = createClient({ baseUrl, apiKey, timeoutMs, maxRetries });
+  const response = await client.messages.create(buildPayload({ model, temperature, messages, tools, maxTokens }));
+  return extractAssistantResult(response, messages);
+}
+
+export async function createChatCompletionStream({
+  baseUrl,
+  apiKey,
+  model,
+  messages,
+  temperature = 0.2,
+  tools,
+  onTextDelta,
+  onToolCallDelta,
+  timeoutMs = 90000,
+  maxTokens = 4096,
+  maxRetries = 2
+}) {
+  const client = createClient({ baseUrl, apiKey, timeoutMs, maxRetries });
+  const stream = await client.messages.create(buildPayload({ model, temperature, messages, tools, stream: true, maxTokens }));
+
+  let text = '';
+  let usage = null;
+  const toolCallsByIndex = new Map();
+  const contentBlocksByIndex = new Map();
+
+  for await (const event of stream) {
+    const eventType = inferEventType(event);
+    usage = mergeUsage(usage, event?.usage);
+    usage = mergeUsage(usage, event?.message?.usage);
+
+    if (eventType === 'content_block_start') {
+      const index = Number(event?.index ?? 0);
+      const contentBlock = event?.content_block || {};
+      if (contentBlock.type === 'tool_use') {
+        const current = toolCallsByIndex.get(index) || emptyToolCall(index);
+        current.id = String(contentBlock.id || current.id || '');
+        current.name = String(contentBlock.name || current.name || '');
+        const initialInput = contentBlock.input && Object.keys(contentBlock.input).length > 0
+          ? normalizeIncomingToolCallArguments(contentBlock.input)
+          : '';
+        current.arguments = current.arguments || initialInput;
+        toolCallsByIndex.set(index, current);
+        contentBlocksByIndex.set(index, {
+          type: 'tool_use',
+          id: current.id,
+          name: current.name,
+          arguments: current.arguments
+        });
+      } else if (contentBlock.type === 'thinking') {
+        contentBlocksByIndex.set(index, {
+          type: 'thinking',
+          thinking: String(contentBlock.thinking || ''),
+          signature: String(contentBlock.signature || '')
+        });
+      } else {
+        contentBlocksByIndex.set(index, {
+          type: 'text',
+          text: String(contentBlock.text || '')
+        });
+      }
+      continue;
+    }
+
+    if (eventType === 'content_block_delta') {
+      const index = Number(event?.index ?? 0);
+      const delta = event?.delta || {};
+      if (delta.type === 'text_delta' && delta.text) {
+        text += delta.text;
+        const current = contentBlocksByIndex.get(index) || { type: 'text', text: '' };
+        current.text = `${current.text || ''}${delta.text}`;
+        contentBlocksByIndex.set(index, current);
+        if (onTextDelta) onTextDelta(delta.text);
+        continue;
+      }
+
+      if (delta.type === 'thinking_delta' && delta.thinking) {
+        const current = contentBlocksByIndex.get(index) || { type: 'thinking', thinking: '', signature: '' };
+        current.thinking = `${current.thinking || ''}${delta.thinking}`;
+        contentBlocksByIndex.set(index, current);
+        continue;
+      }
+
+      if (delta.type === 'signature_delta') {
+        const current = contentBlocksByIndex.get(index) || { type: 'thinking', thinking: '', signature: '' };
+        current.signature = `${current.signature || ''}${String(delta.signature || '')}`;
+        contentBlocksByIndex.set(index, current);
+        continue;
+      }
+
+      if (delta.type === 'input_json_delta') {
+        const current = toolCallsByIndex.get(index) || emptyToolCall(index);
+        current.arguments = `${current.arguments || ''}${String(delta.partial_json || '')}`;
+        toolCallsByIndex.set(index, current);
+        contentBlocksByIndex.set(index, {
+          type: 'tool_use',
+          id: current.id,
+          name: current.name,
+          arguments: current.arguments
+        });
+        if (onToolCallDelta) {
+          onToolCallDelta({
+            index,
+            id: current.id || `tc-${index + 1}`,
+            name: current.name,
+            arguments: current.arguments || '{}'
+          });
+        }
+      }
+      continue;
+    }
+
+    if (eventType === 'message_delta') {
+      usage = mergeUsage(usage, event?.delta?.usage);
+      continue;
+    }
+
+    if (eventType === 'message_stop') {
+      break;
+    }
+  }
+
+  return buildFinalStreamResult(text, toolCallsByIndex, usage, messages, contentBlocksByIndex);
+}