codemini-cli 0.3.1 → 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/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');
+}