codemini-cli 0.3.1 → 0.3.3

package/src/core/provider/anthropic.js

@@ -0,0 +1,388 @@
+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 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;
+    }
+
+    const contentBlocks = [];
+    const text = extractTextContent(message.content);
+    if (text) {
+      contentBlocks.push({ type: 'text', text });
+    }
+
+    if (message.role === 'assistant' && 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)
+        });
+      }
+    }
+
+    out.push({
+      role: message.role,
+      content: contentBlocks
+    });
+  }
+
+  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 extractAssistantResult(data, messages) {
+  const content = Array.isArray(data?.content) ? data.content : [];
+  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
+  };
+}
+
+function createHeaders(apiKey) {
+  return {
+    'content-type': 'application/json',
+    'x-api-key': apiKey,
+    'anthropic-version': '2023-06-01'
+  };
+}
+
+function buildMessagesUrl(baseUrl) {
+  return `${String(baseUrl || '').replace(/\/$/, '')}/v1/messages`;
+}
+
+async function parseJsonResponse(response) {
+  if (!response.ok) {
+    const text = await response.text().catch(() => '');
+    throw new Error(`Anthropic gateway error ${response.status}: ${text || response.statusText}`);
+  }
+  return response.json();
+}
+
+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) {
+  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 = [];
+  if (text) content.push({ type: 'text', text });
+  for (const toolCall of toolCalls) {
+    content.push({
+      type: 'tool_use',
+      id: toolCall.id,
+      name: toolCall.name,
+      input: tryParseJsonObject(toolCall.arguments)
+    });
+  }
+
+  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
+  };
+}
+
+async function* iterateSseEvents(stream) {
+  const decoder = new TextDecoder();
+  let buffer = '';
+
+  for await (const chunk of stream) {
+    buffer += decoder.decode(chunk, { stream: true });
+    while (buffer.includes('\n\n')) {
+      const boundary = buffer.indexOf('\n\n');
+      const rawEvent = buffer.slice(0, boundary);
+      buffer = buffer.slice(boundary + 2);
+      const lines = rawEvent.split('\n');
+      let event = 'message';
+      const dataLines = [];
+      for (const line of lines) {
+        if (line.startsWith('event:')) {
+          event = line.slice(6).trim();
+        } else if (line.startsWith('data:')) {
+          dataLines.push(line.slice(5).trimStart());
+        }
+      }
+      const dataText = dataLines.join('\n');
+      if (!dataText || dataText === '[DONE]') continue;
+      yield {
+        event,
+        data: JSON.parse(dataText)
+      };
+    }
+  }
+}
+
+export async function createChatCompletion({
+  baseUrl,
+  apiKey,
+  model,
+  messages,
+  temperature = 0.2,
+  tools,
+  timeoutMs = 90000,
+  maxTokens = 4096
+}) {
+  const payload = buildPayload({ model, temperature, messages, tools, maxTokens });
+  const response = await fetch(buildMessagesUrl(baseUrl), {
+    method: 'POST',
+    headers: createHeaders(apiKey),
+    body: JSON.stringify(payload),
+    signal: AbortSignal.timeout(timeoutMs)
+  });
+  const data = await parseJsonResponse(response);
+  return extractAssistantResult(data, messages);
+}
+
+export async function createChatCompletionStream({
+  baseUrl,
+  apiKey,
+  model,
+  messages,
+  temperature = 0.2,
+  tools,
+  onTextDelta,
+  onToolCallDelta,
+  timeoutMs = 90000,
+  maxTokens = 4096
+}) {
+  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)
+  });
+
+  if (!response.ok || !response.body) {
+    const text = await response.text().catch(() => '');
+    throw new Error(`Anthropic gateway error ${response.status}: ${text || response.statusText}`);
+  }
+
+  let text = '';
+  let usage = null;
+  const toolCallsByIndex = new Map();
+
+  for await (const chunk of iterateSseEvents(response.body)) {
+    usage = mergeUsage(usage, chunk?.data?.usage);
+    usage = mergeUsage(usage, chunk?.data?.message?.usage);
+
+    if (chunk.event === 'content_block_start') {
+      const index = Number(chunk?.data?.index ?? 0);
+      const contentBlock = chunk?.data?.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);
+      }
+      continue;
+    }
+
+    if (chunk.event !== 'content_block_delta') {
+      continue;
+    }
+
+    const index = Number(chunk?.data?.index ?? 0);
+    const delta = chunk?.data?.delta || {};
+    if (delta.type === 'text_delta' && delta.text) {
+      text += delta.text;
+      if (onTextDelta) onTextDelta(delta.text);
+      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);
+      if (onToolCallDelta) {
+        onToolCallDelta({
+          index,
+          id: current.id || `tc-${index + 1}`,
+          name: current.name,
+          arguments: current.arguments || '{}'
+        });
+      }
+    }
+  }
+
+  return buildFinalStreamResult(text, toolCallsByIndex, usage, messages);
+}

package/src/core/provider/index.js

@@ -0,0 +1,37 @@
+import {
+  createChatCompletion as createOpenAICompatibleChatCompletion,
+  createChatCompletionStream as createOpenAICompatibleChatCompletionStream
+} from './openai-compatible.js';
+import {
+  createChatCompletion as createAnthropicChatCompletion,
+  createChatCompletionStream as createAnthropicChatCompletionStream
+} from './anthropic.js';
+
+function normalizeSdkProvider(value) {
+  const raw = String(value || '').trim().toLowerCase();
+  if (raw === 'anthropic') return 'anthropic';
+  return 'openai-compatible';
+}
+
+export function getSdkProvider(configOrValue) {
+  if (configOrValue && typeof configOrValue === 'object' && !Array.isArray(configOrValue)) {
+    return normalizeSdkProvider(configOrValue?.sdk?.provider);
+  }
+  return normalizeSdkProvider(configOrValue);
+}
+
+export async function createChatCompletion(options) {
+  const provider = getSdkProvider(options?.sdkProvider);
+  if (provider === 'anthropic') {
+    return createAnthropicChatCompletion(options);
+  }
+  return createOpenAICompatibleChatCompletion(options);
+}
+
+export async function createChatCompletionStream(options) {
+  const provider = getSdkProvider(options?.sdkProvider);
+  if (provider === 'anthropic') {
+    return createAnthropicChatCompletionStream(options);
+  }
+  return createOpenAICompatibleChatCompletionStream(options);
+}

package/src/core/session-store.js

@@ -1,6 +1,7 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import { getSessionsDir } from './paths.js';
+import { normalizeTodos } from './todo-state.js';
 
 const ALLOWED_ROLES = new Set(['system', 'user', 'assistant', 'tool']);
 
@@ -86,6 +87,9 @@ function sanitizeSession(session, fallbackId = '') {
     }
   }
 
+  const todos = normalizeTodos(session?.todos);
+  if (todos.length > 0) out.todos = todos;
+
   return out;
 }
 

package/src/core/shell-profile.js

@@ -123,30 +123,46 @@ export function getShellSystemPrompt(value) {
 # Using your tools
 
 ALWAYS prefer dedicated tools over raw shell commands:
+- The visible default tool list is intentionally small. If a needed capability is not currently listed, do not assume it is unavailable — call tool_search to load additional tools first
 - Use query_project_index first for broad repository understanding. It combines project-map metadata with indexed file symbols so you can narrow candidates before reading source files
 - Use read to inspect files — NEVER use cat, head, or tail via run. read returns content directly by default; demo-style shapes like {file_path:"src/app.ts"}, {path:"src/app.ts:10-40"}, or {file_path:"src/app.ts", offset:10, limit:30} are accepted
 - Use grep to search file contents — NEVER use grep or rg via run
-- Use glob to find files by pattern — NEVER use find via run
+- Use list for directory-by-directory filesystem discovery. If you specifically need pattern-based file lookup like src/**/*.ts, load glob with tool_search instead of falling back to run
 - Use edit to modify existing files — this is the DEFAULT path for code changes. Demo-style aliases like {file_path:"src/app.ts", old_string:"foo", new_string:"bar"} are accepted
 - Use write only for creating new files or complete rewrites (set full_file_rewrite=true for existing code files). Aliases like {file:"notes.txt", text:"..."} are accepted
-- Use patch to apply unified diffs
-- Use run for one-shot shell commands: install, build, test, or other finite tasks
-- For long-running processes (dev servers, watchers), use start_service instead of run
-
-For structural code edits (functions, classes, methods), use the AST-first workflow:
-ast_query → read_ast_node → edit with ast_target and kind=replace_block.
+- Use update_todos to manage the session todo checklist for complex work. Provide the full current list each time and usually keep exactly one item in_progress
+- Use run for shell commands. For long-running processes (dev servers, watchers), set run_in_background=true when you know you do not need the final result immediately. Long-running commands may also be backgrounded automatically
+
+Use update_todos with these rules:
+- MUST use it before major tool work when the task has 3 or more meaningful steps, multiple files or phases, explicit verification work, debugging with multiple hypotheses, or any non-trivial implementation likely to span several tool calls
+- Do NOT use it for single-step trivial edits, one-off command execution, or purely informational/chat responses
+- The input must be the full current checklist, not a partial patch
+- Keep exactly one item in_progress while work is actively underway unless the user explicitly asks for parallel execution
+- Mark items completed immediately after finishing them, and add newly discovered follow-up work as new checklist items
+- If tests fail, verification is incomplete, or a blocker remains, do not mark the affected item completed
+- Before giving a completion-style final answer for a complex task, update_todos so the checklist is either fully completed or clearly shows the remaining blocker
+
+Some tools are loaded on demand through tool_search. Common examples:
+- glob for pattern-based file lookup
+- ast_query and read_ast_node for AST-scoped edits
+- generate_diff and patch for explicit diff workflows
+- list_background_tasks, get_background_task, and stop_background_task for managing long-running background commands
+- remember_user, remember_global, remember_project, list_memory, search_memory, and forget_memory for persistent memory operations
+
+For structural code edits (functions, classes, methods), load the AST tools and use the AST-first workflow:
+tool_search("ast_query") → ast_query → read_ast_node → edit with ast_target and kind=replace_block.
 Fall back to plain grep/read/edit only when AST is not appropriate.
 
-For services: use start_service to launch, list_services/get_service_status/get_service_logs to monitor, stop_service to stop.
-
-Some tools are loaded on demand. If a needed tool is not listed, call tool_search first to load it.
+For background commands: use run to launch. If you need management tools that are not currently visible, load list_background_tasks/get_background_task/stop_background_task with tool_search. Prefer reading the returned output_file with read instead of asking for a separate logs tool.
 
 Common tool call patterns:
 - Query the project index first: {query:"login auth flow", path:"src", max_results:5}
+- Load a deferred tool when needed: {query:"glob"} or {query:"all"}
 - Read a file: {path:"src/app.ts"} or {file_path:"src/app.ts", offset:20, limit:40}
 - Read a specific range inline: {path:"src/app.ts:20-60"}
 - Search text: {pattern:"loginUser", path:"src"} or {query:"loginUser", directory:"src"}
-- Find files: {pattern:"src/**/*.ts"} or {query:"src/**/*.ts"}
+- List a directory first: {path:"src"}
+- After loading glob, find files by pattern: {pattern:"src/**/*.ts"} or {query:"src/**/*.ts"}
 - Edit exact text: {file_path:"src/app.ts", old_string:"foo", new_string:"bar"}
 - Edit with shorthand: {path:"src/app.ts", old_text:"foo", content:"bar"}
 - Write a new file: {file:"notes.txt", text:"..."} or {path:"src/page.tsx", content:"..."}
@@ -159,17 +175,13 @@ Common tool call patterns:
 - The user shares your workspace with you; prefer inspecting the project yourself before asking them to paste files that should be discoverable
 - Before substantial tool work, send a short progress update to the user about what you are about to inspect or do
 - Do not jump straight into tools without a brief user-facing note when the task is actionable
-- Search or read before editing unless the exact target is already known
-- For broad or ambiguous requests, query_project_index before large globs or reading many files
-- Do not read files one by one after a wide glob when query_project_index can narrow the candidates first
+- For tasks with 3 or more meaningful steps, proactively create and maintain a todo checklist with update_todos
+- For complex tasks, create the todo checklist before the first major implementation or verification tool call
 - If a command or tool is blocked or fails, inspect the error and retry with allowed commands or tools
 - For AST-scoped edits, if edit rejects due to missing or stale ast_target, fix arguments and retry
 - Do not claim filesystem access is impossible unless search/read tools also fail
-- Prefer editing existing files over creating new ones
 - Do not add comments, docstrings, or type annotations to code you did not change
 - Do not add features or refactor code beyond what was asked
-- When a tool result is large, keep only the useful summary in your reply and read the saved output only if it is needed
-- Keep tool results compact in context: prefer short conclusions over re-pasting raw output
 
 # Plan mode
 

package/src/core/todo-state.js

@@ -0,0 +1,19 @@
+export function normalizeTodoStatus(value) {
+  const status = String(value || 'pending').trim().toLowerCase();
+  return ['pending', 'in_progress', 'completed'].includes(status) ? status : 'pending';
+}
+
+export function normalizeTodos(value) {
+  if (!Array.isArray(value)) return [];
+  return value
+    .map((item) => ({
+      content: String(item?.content || '').trim(),
+      activeForm: String(item?.activeForm || '').trim(),
+      status: normalizeTodoStatus(item?.status)
+    }))
+    .filter((item) => item.content && item.activeForm);
+}
+
+export function countActiveTodos(todos) {
+  return normalizeTodos(todos).filter((item) => item.status !== 'completed').length;
+}