codemini-cli 0.3.0 → 0.3.2

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: '',
@@ -63,6 +66,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 +131,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 || {};
@@ -147,6 +165,18 @@ function normalizePolicyLists(config) {
   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/constants.js

@@ -0,0 +1,171 @@
+/**
+ * 项目级共享常量。
+ * 所有需要在多个模块间复用的目录集、扩展名集、语言映射等统一在此定义。
+ */
+
+// ─── 工具遍历跳过的目录（glob / list / grep 等）─────────────────────
+export const TOOL_SKIP_DIRS = new Set([
+  '.git',
+  'node_modules',
+  '.codemini',
+  '.codemini-global',
+  'dist',
+  'coverage'
+]);
+
+// ─── 项目索引跳过的目录（更宽，包含构建产物和临时目录）──────────────
+export const INDEX_SKIP_DIRS = new Set([
+  '.git',
+  'node_modules',
+  '.codemini',
+  '.codemini-project',
+  '.codemini-global',
+  'dist',
+  'coverage',
+  'sessions',
+  'tmp',
+  'temp',
+  '.cache',
+  '.turbo',
+  '.next',
+  'build',
+  'out',
+  'logs',
+  'artifacts'
+]);
+
+// ─── 文本扩展名 ──────────────────────────────────────────────────────
+export const TEXT_EXTENSIONS = new Set([
+  '.js',
+  '.jsx',
+  '.ts',
+  '.tsx',
+  '.json',
+  '.md',
+  '.mjs',
+  '.cjs',
+  '.py',
+  '.rb',
+  '.go',
+  '.rs',
+  '.java',
+  '.cs',
+  '.css',
+  '.scss',
+  '.html',
+  '.yml',
+  '.yaml',
+  '.sh',
+  '.ps1',
+  '.c',
+  '.h',
+  '.cpp',
+  '.cc',
+  '.cxx',
+  '.hpp',
+  '.hh',
+  '.bash',
+  '.php'
+]);
+
+// ─── 源码扩展名（用于项目索引）──────────────────────────────────────
+export const SOURCE_EXTENSIONS = new Set([
+  '.js', '.jsx', '.mjs', '.cjs', '.ts', '.tsx', '.py', '.go',
+  '.c', '.h', '.cpp', '.cc', '.cxx', '.hpp', '.hh',
+  '.sh', '.bash', '.java', '.rs', '.cs', '.php', '.rb'
+]);
+
+// ─── 需要写入守卫的代码扩展名 ───────────────────────────────────────
+export const CODE_WRITE_GUARD_EXTENSIONS = new Set([
+  '.js',
+  '.jsx',
+  '.ts',
+  '.tsx',
+  '.mjs',
+  '.cjs',
+  '.py',
+  '.rb',
+  '.go',
+  '.rs',
+  '.java',
+  '.cs',
+  '.css',
+  '.scss',
+  '.html',
+  '.sh',
+  '.ps1'
+]);
+
+// ─── 扩展名 -> 语言（标准化） ────────────────────────────────────────
+export const EXTENSION_LANGUAGE_MAP = {
+  '.js': 'js',
+  '.jsx': 'js',
+  '.mjs': 'js',
+  '.cjs': 'js',
+  '.ts': 'ts',
+  '.tsx': 'tsx',
+  '.py': 'python',
+  '.go': 'go',
+  '.c': 'c',
+  '.h': 'c',
+  '.cpp': 'cpp',
+  '.cc': 'cpp',
+  '.cxx': 'cpp',
+  '.hpp': 'cpp',
+  '.hh': 'cpp',
+  '.java': 'java',
+  '.rs': 'rust',
+  '.cs': 'csharp',
+  '.php': 'php',
+  '.rb': 'ruby',
+  '.sh': 'bash',
+  '.bash': 'bash'
+};
+
+// ─── 语言别名 -> 标准语言名 ──────────────────────────────────────────
+export const LANGUAGE_ALIASES = {
+  javascript: 'js',
+  js: 'js',
+  jsx: 'js',
+  typescript: 'ts',
+  ts: 'ts',
+  tsx: 'tsx',
+  python: 'python',
+  py: 'python',
+  go: 'go',
+  c: 'c',
+  cpp: 'cpp',
+  'c++': 'cpp',
+  bash: 'bash',
+  sh: 'bash',
+  shell: 'bash',
+  java: 'java',
+  rust: 'rust',
+  rs: 'rust',
+  csharp: 'csharp',
+  'c#': 'csharp',
+  cs: 'csharp',
+  php: 'php',
+  ruby: 'ruby',
+  rb: 'ruby'
+};
+
+// ─── 工具 schema 用的语言 -> 文件类型列表 ─────────────────────────────
+export const LANGUAGE_FILE_TYPES = {
+  js: ['js', 'jsx', 'mjs', 'cjs'],
+  ts: ['ts', 'tsx'],
+  py: ['py'],
+  python: ['py'],
+  md: ['md'],
+  json: ['json'],
+  css: ['css', 'scss'],
+  html: ['html'],
+  java: ['java'],
+  csharp: ['cs'],
+  cs: ['cs'],
+  go: ['go'],
+  rust: ['rs'],
+  ruby: ['rb'],
+  shell: ['sh', 'ps1'],
+  yaml: ['yml', 'yaml']
+};

package/src/core/crypto-utils.js

@@ -0,0 +1,18 @@
+/**
+ * 共享加密工具函数。
+ * 统一 sha1 / sha256 的实现，避免在各模块中重复定义。
+ */
+
+import crypto from 'node:crypto';
+
+export function sha1(input) {
+  return crypto.createHash('sha1').update(String(input || '')).digest('hex');
+}
+
+export function sha256(input) {
+  return crypto.createHash('sha256').update(String(input || '')).digest('hex');
+}
+
+export function sha256Prefixed(input) {
+  return `sha256:${sha256(input)}`;
+}

package/src/core/memory-policy.js

@@ -0,0 +1,27 @@
+const SECRET_PATTERNS = [
+  /\b(api[_-]?key|token|secret|password|passwd|bearer)\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');
+}

package/src/core/project-index.js

@@ -1,27 +1,10 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
-import crypto from 'node:crypto';
 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 { BoundedCache } from './bounded-cache.js';
 
-const SKIP_DIRS = new Set([
-  '.git',
-  'node_modules',
-  '.codemini',
-  '.codemini-project',
-  '.codemini-global',
-  'dist',
-  'coverage',
-  'sessions',
-  'tmp',
-  'temp',
-  '.cache',
-  '.turbo',
-  '.next',
-  'build',
-  'out',
-  'logs',
-  'artifacts'
-]);
 const PROJECT_MARKER_FILES = new Set([
   'package.json',
   'tsconfig.json',
@@ -37,22 +20,11 @@ const PROJECT_MARKER_FILES = new Set([
   'Makefile',
   '.gitignore'
 ]);
-const SOURCE_EXTENSIONS = new Set([
-  '.js', '.jsx', '.mjs', '.cjs', '.ts', '.tsx', '.py', '.go', '.c', '.h', '.cpp', '.cc', '.cxx', '.hpp', '.hh',
-  '.sh', '.bash', '.java', '.rs', '.cs', '.php', '.rb'
-]);
-const LANGUAGE_BY_EXT = {
-  '.js': 'js', '.jsx': 'jsx', '.mjs': 'js', '.cjs': 'js', '.ts': 'ts', '.tsx': 'tsx', '.py': 'python',
-  '.go': 'go', '.c': 'c', '.h': 'c', '.cpp': 'cpp', '.cc': 'cpp', '.cxx': 'cpp', '.hpp': 'cpp', '.hh': 'cpp',
-  '.sh': 'bash', '.bash': 'bash', '.java': 'java', '.rs': 'rust', '.cs': 'csharp', '.php': 'php', '.rb': 'ruby'
-};
 
-const initCache = new Map();
-const PROJECT_CONTEXT_MAX_FILES = 6;
+const LANGUAGE_BY_EXT = EXTENSION_LANGUAGE_MAP;
 
-function sha1(input) {
-  return crypto.createHash('sha1').update(String(input || '')).digest('hex');
-}
+const initCache = new BoundedCache({ maxSize: 32, ttlMs: 10 * 60 * 1000 });
+const PROJECT_CONTEXT_MAX_FILES = 6;
 
 function clipList(values, max = 32) {
   return [...new Set((Array.isArray(values) ? values : []).filter(Boolean))].slice(0, max);