codemini-cli 0.3.1 → 0.3.3

package/src/core/checkpoint-store.js

@@ -16,7 +16,7 @@ function makeId(name = '') {
   return `${stamp}-${slug || 'checkpoint'}`;
 }
 
-export async function createCheckpoint({ name, session, config, tasks }, cwd = process.cwd()) {
+export async function createCheckpoint({ name, session, config }, cwd = process.cwd()) {
   const dir = checkpointsDir(cwd);
   await fs.mkdir(dir, { recursive: true });
   const id = makeId(name);
@@ -26,8 +26,7 @@ export async function createCheckpoint({ name, session, config, tasks }, cwd = p
     name: String(name || ''),
     createdAt: new Date().toISOString(),
     session,
-    config,
-    tasks: Array.isArray(tasks) ? tasks : []
+    config
   };
   await fs.writeFile(filePath, `${JSON.stringify(payload, null, 2)}\n`, 'utf8');
   return payload;

package/src/core/command-policy.js

@@ -8,6 +8,138 @@ function firstToken(command) {
   return base.replace(/\.exe$/i, '');
 }
 
+function splitCommandSegments(command) {
+  const text = String(command || '').trim();
+  if (!text) return [];
+  const segments = [];
+  let current = '';
+  let quote = '';
+  let escapeNext = false;
+
+  for (let i = 0; i < text.length; i += 1) {
+    const ch = text[i];
+    const next = text[i + 1];
+
+    if (escapeNext) {
+      current += ch;
+      escapeNext = false;
+      continue;
+    }
+
+    if (ch === '\\' && quote !== '\'') {
+      current += ch;
+      escapeNext = true;
+      continue;
+    }
+
+    if (quote) {
+      current += ch;
+      if (ch === quote) quote = '';
+      continue;
+    }
+
+    if (ch === '"' || ch === '\'') {
+      quote = ch;
+      current += ch;
+      continue;
+    }
+
+    if ((ch === '&' && next === '&') || (ch === '|' && next === '|')) {
+      if (current.trim()) segments.push(current.trim());
+      current = '';
+      i += 1;
+      continue;
+    }
+
+    if (ch === '|' || ch === ';' || ch === '&') {
+      if (current.trim()) segments.push(current.trim());
+      current = '';
+      continue;
+    }
+
+    current += ch;
+  }
+
+  if (current.trim()) segments.push(current.trim());
+  return segments;
+}
+
+function tokenizeTopLevel(command) {
+  const text = String(command || '').trim();
+  if (!text) return [];
+  const tokens = [];
+  let current = '';
+  let quote = '';
+  let escapeNext = false;
+
+  for (let i = 0; i < text.length; i += 1) {
+    const ch = text[i];
+    if (escapeNext) {
+      current += ch;
+      escapeNext = false;
+      continue;
+    }
+    if (ch === '\\' && quote !== '\'') {
+      escapeNext = true;
+      continue;
+    }
+    if (quote) {
+      if (ch === quote) {
+        quote = '';
+      } else {
+        current += ch;
+      }
+      continue;
+    }
+    if (ch === '"' || ch === '\'') {
+      quote = ch;
+      continue;
+    }
+    if (/\s/.test(ch)) {
+      if (current) {
+        tokens.push(current);
+        current = '';
+      }
+      continue;
+    }
+    current += ch;
+  }
+
+  if (current) tokens.push(current);
+  return tokens;
+}
+
+function unwrapShellPayload(command) {
+  const tokens = tokenizeTopLevel(command);
+  const token = firstToken(command);
+  if (!['bash', 'sh', 'zsh', 'powershell', 'pwsh', 'cmd'].includes(token)) return '';
+
+  const index = tokens.findIndex((item, itemIndex) => {
+    if (token === 'cmd') return itemIndex > 0 && /^\/c$/i.test(item);
+    return /^-(?:c|lc|command)$/i.test(item);
+  });
+  if (index < 0 || index + 1 >= tokens.length) return '';
+  return tokens.slice(index + 1).join(' ').trim();
+}
+
+function collectCommandTokens(command) {
+  const cmd = String(command || '').trim();
+  if (!cmd) return [];
+
+  const chained = splitCommandSegments(cmd);
+  if (chained.length > 1) {
+    return chained.flatMap((segment) => collectCommandTokens(segment));
+  }
+
+  const token = firstToken(cmd);
+  const out = token ? [{ token, raw: cmd }] : [];
+  const wrapped = unwrapShellPayload(cmd);
+  if (wrapped && wrapped !== cmd) {
+    out.push(...collectCommandTokens(wrapped));
+  }
+  return out;
+}
+
 function includesAny(haystackLower, patterns = []) {
   return patterns.some((p) => haystackLower.includes(String(p).toLowerCase()));
 }
@@ -46,17 +178,19 @@ export function evaluateCommandPolicy(command, config, workspaceRoot = process.c
   }
 
   const token = firstToken(cmd);
-  if (includesAny(token, policy.blocked_commands)) {
-    return { allowed: false, reason: `blocked command: ${token}`, suggestion: suggestionForToken(token, config) };
-  }
-
+  const inspectedTokens = collectCommandTokens(cmd);
   const allowlist = Array.isArray(policy.command_allowlist) ? policy.command_allowlist : [];
-  if (allowlist.length > 0 && !allowlist.includes(token)) {
-    return {
-      allowed: false,
-      reason: `command not in allowlist: ${token}`,
-      suggestion: suggestionForToken(token, config)
-    };
+  for (const item of inspectedTokens) {
+    if (includesAny(item.token, policy.blocked_commands)) {
+      return { allowed: false, reason: `blocked command: ${item.token}`, suggestion: suggestionForToken(item.token, config) };
+    }
+    if (allowlist.length > 0 && !allowlist.includes(item.token)) {
+      return {
+        allowed: false,
+        reason: `command not in allowlist: ${item.token}`,
+        suggestion: suggestionForToken(item.token, config)
+      };
+    }
   }
 
   const workspaceLower = String(workspaceRoot).toLowerCase().replace(/\//g, '\\');

package/src/core/config-store.js

@@ -13,6 +13,9 @@ function normalizeUiLanguage(value) {
 }
 
 const DEFAULT_CONFIG = {
+  sdk: {
+    provider: 'openai-compatible'
+  },
   gateway: {
     base_url: 'http://127.0.0.1:8000/v1',
     api_key: '',
@@ -43,11 +46,9 @@ const DEFAULT_CONFIG = {
       'run',
       'patch',
       'generate_diff',
-      'start_service',
-      'list_services',
-      'get_service_status',
-      'get_service_logs',
-      'stop_service'
+      'list_background_tasks',
+      'get_background_task',
+      'stop_background_task'
     ],
     max_steps: 16
   },
@@ -63,6 +64,17 @@ const DEFAULT_CONFIG = {
     language: 'zh',
     reply_language: 'zh'
   },
+  memory: {
+    enabled: true,
+    auto_write: true,
+    inject_on_session_start: true,
+    max_items_per_scope: 12,
+    max_prompt_chars: 4000,
+    max_user_chars: 1375,
+    max_global_chars: 2200,
+    max_project_chars: 2200,
+    project_binding: 'path-or-alias'
+  },
   soul: {
     preset: 'default',
     custom_path: ''
@@ -117,6 +129,10 @@ function uniqueStrings(items = []) {
 
 function normalizePolicyLists(config) {
   const next = structuredClone(config);
+  next.sdk = next.sdk || {};
+  next.sdk.provider = ['openai-compatible', 'anthropic'].includes(String(next.sdk.provider || '').toLowerCase())
+    ? String(next.sdk.provider).toLowerCase()
+    : 'openai-compatible';
   next.shell = next.shell || {};
   next.shell.default = normalizeShellName(next.shell.default);
   next.execution = next.execution || {};
@@ -136,17 +152,27 @@ function normalizePolicyLists(config) {
       'write',
       'run',
       'generate_diff',
-      'start_service',
-      'list_services',
-      'get_service_status',
-      'get_service_logs',
-      'stop_service',
+      'list_background_tasks',
+      'get_background_task',
+      'stop_background_task',
       ...rawTools
     ].filter((name) => String(name) !== 'list_files')
   );
   next.ui = next.ui || {};
   next.ui.language = normalizeUiLanguage(next.ui.language);
   next.ui.reply_language = normalizeReplyLanguage(next.ui.reply_language);
+  next.memory = next.memory || {};
+  next.memory.enabled = next.memory.enabled !== false;
+  next.memory.auto_write = next.memory.auto_write !== false;
+  next.memory.inject_on_session_start = next.memory.inject_on_session_start !== false;
+  next.memory.max_items_per_scope = Math.max(1, Number(next.memory.max_items_per_scope || 12));
+  next.memory.max_prompt_chars = Math.max(200, Number(next.memory.max_prompt_chars || 4000));
+  next.memory.max_user_chars = Math.max(80, Number(next.memory.max_user_chars || 1375));
+  next.memory.max_global_chars = Math.max(80, Number(next.memory.max_global_chars || 2200));
+  next.memory.max_project_chars = Math.max(80, Number(next.memory.max_project_chars || 2200));
+  next.memory.project_binding = ['path', 'alias', 'path-or-alias'].includes(String(next.memory.project_binding || ''))
+    ? String(next.memory.project_binding)
+    : 'path-or-alias';
   next.policy = next.policy || {};
   next.policy.command_allowlist = uniqueStrings(
     Array.isArray(next.policy.command_allowlist) ? next.policy.command_allowlist : []

package/src/core/context-compact.js

@@ -19,7 +19,13 @@ export function estimateMessagesTokens(messages) {
   for (const message of messages || []) {
     const roleOverhead = 6;
     const text = textFromContent(message.content);
-    total += roleOverhead + Math.ceil(text.length / 4);
+    let asciiChars = 0;
+    let nonAsciiChars = 0;
+    for (const char of text) {
+      if (char.charCodeAt(0) <= 0x7f) asciiChars += 1;
+      else nonAsciiChars += 1;
+    }
+    total += roleOverhead + Math.ceil(asciiChars / 4) + Math.ceil(nonAsciiChars / 2);
   }
   return total;
 }

package/src/core/default-system-prompt.js

@@ -18,6 +18,11 @@ Assistant: first narrow the search with the project index
 Tool: query_project_index({"query":"auth flow","path":"src","max_results":3})
 Tool: read({"file_path":"${cwd}/src/auth/service.ts"})
 
+If the visible tool list does not include a needed capability, load it with tool_search instead of assuming it does not exist.
+Example:
+Tool: tool_search({"query":"glob"})
+Tool: glob({"pattern":"src/**/*.ts"})
+
 2. Targeted search then exact text edit
 User: rename loginUser to signInUser
 Assistant: first find the exact occurrences
@@ -29,7 +34,13 @@ User: inspect the reducer around line 120
 Assistant: read only the needed range
 Tool: read({"path":"${cwd}/src/store/reducer.ts:110-150"})
 
-4. Create a new file
+4. Track a complex task with todos
+User: update the login flow and verify it
+Assistant: create a focused todo checklist before starting
+Tool: update_todos({"todos":[{"content":"Inspect the current login flow","activeForm":"Inspecting the current login flow","status":"in_progress"},{"content":"Implement the requested login changes","activeForm":"Implementing the requested login changes","status":"pending"},{"content":"Run focused verification for the login flow","activeForm":"Running focused verification for the login flow","status":"pending"}]})
+Assistant: keep the checklist updated as each phase finishes, and do not give a completion-style wrap-up until the checklist is complete or a blocker is recorded
+
+5. Create a new file
 User: add a notes file
 Assistant: create the file directly
 Tool: write({"file":"${cwd}/notes.txt","text":"todo\\n"})

package/src/core/memory-policy.js

@@ -0,0 +1,33 @@
+const SECRET_PATTERNS = [
+  /\b(api[_-]?key|token|secret|password|passwd|bearer)\b/i,
+  /\b(database_url|aws_secret_access_key|aws_access_key_id|openai_api_key|github_token|github_pat|slack_bot_token)\b\s*[:=]\s*\S+/i,
+  /\b(?:postgres(?:ql)?|mysql|mongodb(?:\+srv)?|redis):\/\/[^/\s:@]+:[^@\s]+@/i,
+  /\bAKIA[0-9A-Z]{16}\b/,
+  /\bghp_[a-z0-9]{20,}\b/i,
+  /\bgithub_pat_[a-z0-9_]{20,}\b/i,
+  /\bglpat-[a-z0-9_-]{20,}\b/i,
+  /\bsk-[a-z0-9]{8,}\b/i,
+  /-----BEGIN [A-Z ]+PRIVATE KEY-----/i
+];
+
+export function normalizeMemoryText(value) {
+  return String(value || '').replace(/\s+/g, ' ').trim();
+}
+
+export function isSensitiveMemoryContent(value) {
+  const text = normalizeMemoryText(value);
+  if (!text) return false;
+  return SECRET_PATTERNS.some((pattern) => pattern.test(text));
+}
+
+export function assertSafeMemoryContent(value) {
+  if (isSensitiveMemoryContent(value)) {
+    throw new Error('Refusing to store sensitive or secret-like memory content');
+  }
+}
+
+export function summarizeMemoryContent(value, maxChars = 72) {
+  const text = normalizeMemoryText(value);
+  if (text.length <= maxChars) return text;
+  return `${text.slice(0, Math.max(0, maxChars - 3))}...`;
+}

package/src/core/memory-prompt.js

@@ -0,0 +1,45 @@
+import { listMemories } from './memory-store.js';
+
+function renderScope(title, items = []) {
+  if (!Array.isArray(items) || items.length === 0) return '';
+  const lines = items.map((item) =>
+    [
+      `- [${item.kind}] summary=${JSON.stringify(String(item.summary || item.content || ''))}`,
+      `  exact_text=${JSON.stringify(String(item.content || ''))}`
+    ].join('\n')
+  );
+  return `${title}\n${lines.join('\n')}`;
+}
+
+export async function buildMemorySnapshot({
+  config = {},
+  workspaceRoot = process.cwd()
+}) {
+  if (config?.memory?.enabled === false || config?.memory?.inject_on_session_start === false) return '';
+
+  const [user, globalItems, project] = await Promise.all([
+    listMemories({ scope: 'user', workspaceRoot }),
+    listMemories({ scope: 'global', workspaceRoot }),
+    listMemories({ scope: 'project', workspaceRoot })
+  ]);
+
+  const maxItems = Math.max(1, Number(config?.memory?.max_items_per_scope || 12));
+  const sections = [
+    renderScope('User Memory:', user.slice(0, maxItems)),
+    renderScope('Global Memory:', globalItems.slice(0, maxItems)),
+    renderScope('Project Memory:', project.slice(0, maxItems))
+  ].filter(Boolean);
+
+  if (sections.length === 0) return '';
+
+  const snapshot = [
+    'Persistent Memory:',
+    'Use these durable notes only as stable guidance. Prefer fresh reads when code or files can verify the answer.',
+    'When recalling memory, preserve command names, file paths, identifiers, and punctuation exactly. Do not rewrite exact_text values.',
+    ...sections
+  ].join('\n\n');
+
+  const maxChars = Math.max(200, Number(config?.memory?.max_prompt_chars || 4000));
+  if (snapshot.length <= maxChars) return snapshot;
+  return `${snapshot.slice(0, maxChars - 3)}...`;
+}

package/src/core/memory-store.js

@@ -0,0 +1,181 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { sha1 } from './crypto-utils.js';
+import { getMemoryDir, getProjectMemoryDir } from './paths.js';
+import { assertSafeMemoryContent, normalizeMemoryText, summarizeMemoryContent } from './memory-policy.js';
+
+const ALLOWED_SCOPES = new Set(['user', 'global', 'project']);
+
+function nowIso() {
+  return new Date().toISOString();
+}
+
+function slugify(value) {
+  const text = String(value || '')
+    .toLowerCase()
+    .replace(/[^a-z0-9\u4e00-\u9fa5]+/g, '-')
+    .replace(/^-+|-+$/g, '');
+  return text || 'project';
+}
+
+export function getProjectMemoryKey(workspaceRoot = process.cwd(), projectAlias = '') {
+  const alias = normalizeMemoryText(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)}`;
+}
+
+function ensureScope(scope) {
+  const value = String(scope || '').trim().toLowerCase();
+  if (!ALLOWED_SCOPES.has(value)) {
+    throw new Error(`Unsupported memory scope: ${scope}`);
+  }
+  return value;
+}
+
+async function ensureParent(filePath) {
+  await fs.mkdir(path.dirname(filePath), { recursive: true });
+}
+
+function buildFilePath(scope, workspaceRoot = process.cwd(), projectAlias = '') {
+  if (scope === 'user') return path.join(getMemoryDir(), 'user.json');
+  if (scope === 'global') return path.join(getMemoryDir(), 'global.json');
+  return path.join(getProjectMemoryDir(workspaceRoot), `${getProjectMemoryKey(workspaceRoot, projectAlias)}.json`);
+}
+
+async function readMemoryBucket(filePath) {
+  try {
+    const raw = await fs.readFile(filePath, 'utf8');
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed?.items) ? parsed.items : [];
+  } catch {
+    return [];
+  }
+}
+
+async function writeMemoryBucket(filePath, items) {
+  await ensureParent(filePath);
+  await fs.writeFile(filePath, `${JSON.stringify({ items }, null, 2)}\n`, 'utf8');
+}
+
+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)}`),
+    scope,
+    projectKey: projectKey || undefined,
+    kind: String(item?.kind || 'note').trim() || 'note',
+    content,
+    summary: normalizeMemoryText(item?.summary || summarizeMemoryContent(content)),
+    source: String(item?.source || 'tool').trim() || 'tool',
+    confidence: Number.isFinite(Number(item?.confidence)) ? Number(item.confidence) : 0.9,
+    createdAt: String(item?.createdAt || now),
+    updatedAt: String(item?.updatedAt || now),
+    hits: Number.isFinite(Number(item?.hits)) ? Number(item.hits) : 0,
+    pinned: item?.pinned === true
+  };
+}
+
+function sameMemory(left, right) {
+  const a = normalizeMemoryText(left?.content);
+  const b = normalizeMemoryText(right?.content);
+  if (!a || !b) return false;
+  return a === b;
+}
+
+function measureMemoryChars(item) {
+  return normalizeMemoryText(item?.content).length + normalizeMemoryText(item?.summary).length;
+}
+
+function budgetForScope(scope, config = {}) {
+  if (scope === 'user') return Math.max(80, Number(config?.memory?.max_user_chars || 1375));
+  if (scope === 'global') return Math.max(80, Number(config?.memory?.max_global_chars || 2200));
+  return Math.max(80, Number(config?.memory?.max_project_chars || 2200));
+}
+
+export async function listMemories({ scope, workspaceRoot = process.cwd(), projectAlias = '' }) {
+  const normalizedScope = ensureScope(scope);
+  const filePath = buildFilePath(normalizedScope, workspaceRoot, projectAlias);
+  const projectKey = normalizedScope === 'project' ? getProjectMemoryKey(workspaceRoot, projectAlias) : '';
+  const items = await readMemoryBucket(filePath);
+  return items
+    .map((item) => normalizeMemoryItem(item, normalizedScope, projectKey))
+    .sort((left, right) => String(right.updatedAt).localeCompare(String(left.updatedAt)));
+}
+
+export async function rememberMemory({
+  scope,
+  content,
+  kind = 'note',
+  summary = '',
+  source = 'tool',
+  confidence = 0.9,
+  replaceSimilar = true,
+  pinned = false,
+  workspaceRoot = process.cwd(),
+  projectAlias = '',
+  config = {}
+}) {
+  const normalizedScope = ensureScope(scope);
+  const normalizedContent = normalizeMemoryText(content);
+  if (!normalizedContent) throw new Error('Memory content is required');
+  assertSafeMemoryContent(normalizedContent);
+
+  const filePath = buildFilePath(normalizedScope, workspaceRoot, projectAlias);
+  const projectKey = normalizedScope === 'project' ? getProjectMemoryKey(workspaceRoot, projectAlias) : '';
+  const existing = (await readMemoryBucket(filePath)).map((item) => normalizeMemoryItem(item, normalizedScope, projectKey));
+  const probe = normalizeMemoryItem({ content: normalizedContent, kind, summary, source, confidence, pinned }, normalizedScope, projectKey);
+
+  const replaceIndex = replaceSimilar ? existing.findIndex((item) => sameMemory(item, probe)) : -1;
+  let saved;
+  if (replaceIndex >= 0) {
+    saved = {
+      ...existing[replaceIndex],
+      ...probe,
+      id: existing[replaceIndex].id,
+      createdAt: existing[replaceIndex].createdAt,
+      updatedAt: nowIso()
+    };
+    existing.splice(replaceIndex, 1, saved);
+  } else {
+    saved = probe;
+    existing.unshift(saved);
+  }
+
+  const maxItems = Math.max(1, Number(config?.memory?.max_items_per_scope || 12));
+  const maxChars = budgetForScope(normalizedScope, config);
+  const deduped = [];
+  const seen = new Set();
+  for (const item of existing) {
+    const key = `${item.kind}:${normalizeMemoryText(item.content)}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    deduped.push(item);
+    if (deduped.length >= maxItems) break;
+  }
+  let totalChars = deduped.reduce((sum, item) => sum + measureMemoryChars(item), 0);
+  while (deduped.length > 1 && totalChars > maxChars) {
+    const removed = deduped.pop();
+    totalChars -= measureMemoryChars(removed);
+  }
+  await writeMemoryBucket(filePath, deduped);
+  return saved;
+}
+
+export async function forgetMemory({ scope, id, workspaceRoot = process.cwd(), projectAlias = '' }) {
+  const normalizedScope = ensureScope(scope);
+  const filePath = buildFilePath(normalizedScope, workspaceRoot, projectAlias);
+  const existing = await listMemories({ scope: normalizedScope, workspaceRoot, projectAlias });
+  const kept = existing.filter((item) => item.id !== id);
+  await writeMemoryBucket(filePath, kept);
+  return { removed: existing.length - kept.length };
+}
+
+export async function searchMemories({ scope, query, workspaceRoot = process.cwd(), projectAlias = '' }) {
+  const items = await listMemories({ scope, workspaceRoot, projectAlias });
+  const needle = normalizeMemoryText(query).toLowerCase();
+  if (!needle) return items;
+  return items.filter((item) => item.content.toLowerCase().includes(needle) || item.summary.toLowerCase().includes(needle));
+}

package/src/core/paths.js

@@ -50,6 +50,10 @@ export function getCommandsDir() {
   return path.join(getBaseConfigDir(), 'commands');
 }
 
+export function getMemoryDir() {
+  return path.join(getBaseConfigDir(), 'memory');
+}
+
 export function getInputHistoryFilePath() {
   return path.join(getBaseConfigDir(), 'input-history.json');
 }
@@ -101,3 +105,7 @@ export function getFileIndexPath(cwd = process.cwd()) {
 export function getProjectIndexDir(cwd = process.cwd()) {
   return path.join(cwd, PROJECT_INDEX_DIR);
 }
+
+export function getProjectMemoryDir(cwd = process.cwd()) {
+  return path.join(getProjectIndexDir(cwd), 'memory');
+}