codemini-cli 0.3.8 → 0.4.0

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

@@ -45,6 +45,33 @@ User: add a notes file
 Assistant: create the file directly
 Tool: write({"file":"${cwd}/notes.txt","text":"todo\\n"})
 
+6. Save a high-signal observation to memory
+When you notice a reusable pattern, a user correction, a repeated failure, or a stable preference — save it to persistent memory. Choose scope carefully:
+- scope "user" for personal preferences (language, reply style, interaction habits)
+- scope "global" for cross-project lessons (environment quirks, general tool workflows)
+- scope "project" for project-specific knowledge (architecture conventions, local config, test commands, file locations)
+
+Examples:
+Tool: save_memory({"content":"User prefers tab size 2 for all JSON files","scope":"user","kind":"preference"})
+Tool: save_memory({"content":"This project uses vitest, not jest — run tests with npx vitest run","scope":"project","kind":"pattern"})
+Tool: save_memory({"content":"WSL2 bash exec prefix does not support cd as a command","scope":"global","kind":"correction"})
+
+7. Run a dream loop consolidation pass
+When you want to review and consolidate inbox entries into long-term memory.
+Tool: dream_consolidate({})
+
+8. Read a live web page by URL
+User: summarize https://example.com/docs
+Assistant: load the web fetch tool and read the page directly
+Tool: tool_search({"query":"web_fetch"})
+Tool: web_fetch({"url":"https://example.com/docs"})
+
+9. Search the web
+User: search the web for latest pnpm release
+Assistant: load the web search tool and run a targeted search
+Tool: tool_search({"query":"web_search"})
+Tool: web_search({"query":"latest pnpm release","max_results":5})
+
 Prefer these direct tool shapes over multi-step metadata reads or shell fallbacks.
 Prefer explicit absolute file_path values when the current working directory is known.`;
 }

package/src/core/dream-audit.js

@@ -0,0 +1,93 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { getDreamAuditDir } from './paths.js';
+
+function nowStamp() {
+  return new Date().toISOString().replace(/[:.]/g, '-');
+}
+
+function renderReport(report) {
+  const lines = [
+    `# Dream Consolidation Report`,
+    `Date: ${report.timestamp}`,
+    ``
+  ];
+
+  if (report.filesRead?.length) {
+    lines.push('## Files Read');
+    for (const f of report.filesRead) lines.push(`- ${f}`);
+    lines.push('');
+  }
+
+  if (report.candidatesGenerated) {
+    lines.push(`## Candidates Generated: ${report.candidatesGenerated}`);
+    lines.push('');
+  }
+
+  if (report.promotions?.length) {
+    lines.push('## Promotions');
+    for (const p of report.promotions) {
+      lines.push(`- [${p.lifecycle}] ${p.summary} (scope: ${p.scope})`);
+      if (p.rationale) lines.push(`  Rationale: ${p.rationale}`);
+    }
+    lines.push('');
+  }
+
+  if (report.rejections?.length) {
+    lines.push('## Rejections');
+    for (const r of report.rejections) {
+      lines.push(`- ${r.summary}`);
+      if (r.reason) lines.push(`  Reason: ${r.reason}`);
+    }
+    lines.push('');
+  }
+
+  if (report.archives?.length) {
+    lines.push('## Archives');
+    for (const a of report.archives) {
+      lines.push(`- ${a.summary} (reason: ${a.reason || 'expired'})`);
+    }
+    lines.push('');
+  }
+
+  if (report.filesChanged?.length) {
+    lines.push('## Files Changed');
+    for (const fc of report.filesChanged) lines.push(`- ${fc.file}: ${fc.why}`);
+    lines.push('');
+  }
+
+  if (report.disagreements?.length) {
+    lines.push('## Reviewer Disagreements');
+    for (const d of report.disagreements) {
+      lines.push(`- ${d.item}: main=${d.mainVerdict}, reviewer=${d.reviewerVerdict}, resolved=${d.resolution}`);
+    }
+    lines.push('');
+  }
+
+  return lines.join('\n');
+}
+
+export async function writeDreamAuditReport(report) {
+  const dir = getDreamAuditDir();
+  await fs.mkdir(dir, { recursive: true });
+  const stamp = nowStamp();
+  const filePath = path.join(dir, `dream-${stamp}.md`);
+  const content = renderReport(report);
+  await fs.writeFile(filePath, content, 'utf8');
+  return filePath;
+}
+
+export async function listDreamAuditReports() {
+  const dir = getDreamAuditDir();
+  let entries;
+  try {
+    entries = await fs.readdir(dir);
+  } catch {
+    return [];
+  }
+  return entries
+    .filter((e) => e.startsWith('dream-') && e.endsWith('.md'))
+    .sort()
+    .reverse()
+    .map((e) => path.join(dir, e));
+}

package/src/core/dream-consolidate.js

@@ -0,0 +1,157 @@
+import { listMemories, listInbox, archiveEntry, promoteMemory } from './memory-store.js';
+import { writeDreamAuditReport } from './dream-audit.js';
+import { evaluateInboxBatch } from './dream-evaluator.js';
+
+const LONGTERM_TYPES = new Set(['preference', 'pattern', 'win', 'decision']);
+const OPERATIONAL_TYPES = new Set(['correction', 'failure', 'gap', 'observation']);
+
+function normalizeText(value) {
+  return String(value || '').trim().toLowerCase();
+}
+
+function chooseLifecycle(type) {
+  const value = normalizeText(type);
+  if (LONGTERM_TYPES.has(value)) return 'longterm';
+  if (OPERATIONAL_TYPES.has(value)) return 'operational';
+  return 'operational';
+}
+
+function memoryContainsSummary(memory, summaryKey) {
+  const content = normalizeText(memory?.content);
+  const summary = normalizeText(memory?.summary);
+  return content.includes(summaryKey) || summary.includes(summaryKey);
+}
+
+export async function runDreamConsolidation({
+  dryRun = false,
+  scope = null,
+  workspaceRoot = process.cwd(),
+  config = {},
+  writeAudit = true
+} = {}) {
+  const scopeFilter = scope || null;
+  const inbox = await listInbox({ scope: scopeFilter });
+  if (inbox.length === 0) {
+    return { ok: true, dryRun, message: 'No inbox entries to consolidate.', promotions: [], rejections: [], archives: [] };
+  }
+
+  const [globalMemories, userMemories, projectMemories] = await Promise.all([
+    listMemories({ scope: 'global', workspaceRoot }),
+    listMemories({ scope: 'user', workspaceRoot }),
+    listMemories({ scope: 'project', workspaceRoot })
+  ]);
+  const knownMemories = [...globalMemories, ...userMemories, ...projectMemories];
+
+  const promotions = [];
+  const rejections = [];
+  const archives = [];
+  const filesRead = ['memory/inbox/*', 'memory/global.json', 'memory/user.json', 'memory/project/*.json'];
+  const filesChanged = [];
+
+  /* ── Phase 1: 规则预过滤（快速剔除明显垃圾） ─────────────────── */
+  const candidates = [];
+  const seen = new Map();
+
+  for (const entry of inbox) {
+    const summaryKey = normalizeText(entry.summary);
+    if (!summaryKey) {
+      if (!dryRun) await archiveEntry(entry, 'invalid-summary', 'Summary is empty after normalization');
+      archives.push({ summary: String(entry.summary || ''), reason: 'invalid-summary' });
+      continue;
+    }
+
+    if (seen.has(summaryKey)) {
+      if (!dryRun) await archiveEntry(entry, 'duplicate', `Duplicate of ${seen.get(summaryKey)}`);
+      archives.push({ summary: entry.summary, reason: 'duplicate' });
+      continue;
+    }
+    seen.set(summaryKey, entry.id);
+
+    const alreadyKnown = knownMemories.some((memory) => memoryContainsSummary(memory, summaryKey));
+    if (alreadyKnown) {
+      if (!dryRun) await archiveEntry(entry, 'already-known', 'Already present in memory');
+      rejections.push({ summary: entry.summary, reason: 'already-known' });
+      continue;
+    }
+
+    candidates.push(entry);
+  }
+
+  if (candidates.length === 0) {
+    const report = { timestamp: new Date().toISOString(), filesRead, filesChanged: [], candidatesGenerated: inbox.length, promotions, rejections, archives };
+    if (!dryRun && writeAudit) {
+      const reportPath = await writeDreamAuditReport(report);
+      report.auditReport = reportPath;
+    }
+    return { ok: true, dryRun, ...report };
+  }
+
+  /* ── Phase 2: LLM 批量评估（质量门控 + scope 分类 + 内容提炼） ── */
+  const llmResults = dryRun
+    ? candidates.map((e) => ({ id: e.id, action: 'keep', scope: 'global', kind: e.type || 'observation', content: e.details || e.summary, summary: e.summary, confidence: 0.9 }))
+    : await evaluateInboxBatch({ entries: candidates, config, workspaceRoot });
+
+  const resultMap = new Map(llmResults.map((r) => [r.id, r]));
+
+  /* ── Phase 3: 按评估结果 promote 或 archive ─────────────────── */
+  for (const entry of candidates) {
+    const evaluation = resultMap.get(entry.id);
+
+    if (!evaluation || evaluation.action === 'discard') {
+      const reason = evaluation?.reason || 'LLM discarded';
+      if (!dryRun) await archiveEntry(entry, 'discarded-by-evaluator', reason);
+      rejections.push({ summary: entry.summary, reason: `evaluator-discard: ${reason}` });
+      continue;
+    }
+
+    const promoteScope = evaluation.scope || 'global';
+    const lifecycle = chooseLifecycle(evaluation.kind);
+    const enrichedEntry = {
+      ...entry,
+      /* 用 LLM 提炼后的内容覆盖原始报错 */
+      summary: evaluation.summary || entry.summary,
+      details: evaluation.content || entry.details || entry.summary,
+      type: evaluation.kind || entry.type || 'observation'
+    };
+
+    if (!dryRun) {
+      try {
+        await promoteMemory({
+          entry: enrichedEntry,
+          scope: promoteScope,
+          lifecycle,
+          workspaceRoot,
+          config,
+          confidence: evaluation.confidence || 0.8
+        });
+        filesChanged.push({ file: `memory/${promoteScope}.json`, why: `Promoted "${enrichedEntry.summary}" as ${lifecycle} (${promoteScope})` });
+        promotions.push({ summary: enrichedEntry.summary, scope: promoteScope, lifecycle, rationale: evaluation.kind, confidence: evaluation.confidence });
+      } catch (error) {
+        const reason = String(error?.message || error || 'promotion failed').slice(0, 180);
+        await archiveEntry(entry, 'promotion-failed', reason);
+        rejections.push({ summary: entry.summary, reason: `promotion-failed: ${reason}` });
+        archives.push({ summary: entry.summary, reason: 'promotion-failed' });
+      }
+      continue;
+    }
+
+    promotions.push({ summary: enrichedEntry.summary, scope: promoteScope, lifecycle, rationale: evaluation.kind, confidence: evaluation.confidence, dryRun: true });
+  }
+
+  const report = {
+    timestamp: new Date().toISOString(),
+    filesRead,
+    filesChanged,
+    candidatesGenerated: inbox.length,
+    promotions,
+    rejections,
+    archives
+  };
+
+  if (!dryRun && writeAudit) {
+    const reportPath = await writeDreamAuditReport(report);
+    report.auditReport = reportPath;
+  }
+
+  return { ok: true, dryRun, ...report };
+}

package/src/core/dream-evaluator.js

@@ -0,0 +1,99 @@
+import { createChatCompletion } from './provider/index.js';
+
+const EVAL_TIMEOUT_MS = 30000;
+
+const SYSTEM_PROMPT = `You are a memory consolidation evaluator for a coding assistant. You receive a batch of inbox items (tool errors, observations, etc.) and decide for each one:
+
+1. **keep or discard** — Does this contain a reusable, durable insight? Discard transient errors, one-off issues, and noise.
+2. **scope** — "global" for cross-project knowledge (e.g., "WSL bash exec does not support cd"), "project" for project-specific context (e.g., "this project uses vitest for testing").
+3. **kind** — One of: pattern, observation, correction, decision, failure
+4. **content** — A refined, actionable sentence describing the insight. NOT the raw error text.
+5. **summary** — A short label (under 80 chars) for quick scanning.
+6. **confidence** — 0.5–1.0 based on how certain and durable the insight is.
+
+Respond with valid JSON only, no markdown fences:
+{"results":[{"id":"<inbox-id>","action":"keep","scope":"global|project","kind":"pattern|observation|correction|decision|failure","content":"...","summary":"...","confidence":0.8},{"id":"<inbox-id>","action":"discard","reason":"..."}]}
+
+Rules:
+- Raw tool error messages are NOT insights by themselves. Only keep if they reveal a reusable lesson.
+- "exit 127", "command not found", "permission denied", "blocked by policy" → always discard (transient/config issues)
+- A repeated pattern across multiple errors → keep as a "pattern" or "correction"
+- Project-specific paths, file names, or commands → scope "project"
+- General coding/environment knowledge → scope "global"
+- If in doubt, discard. Memory is expensive; only promote what future sessions will genuinely benefit from.`;
+
+function parseResults(text) {
+  try {
+    const json = JSON.parse(text);
+    if (!json?.results || !Array.isArray(json.results)) return [];
+    return json.results.map((r) => ({
+      id: String(r.id || ''),
+      action: r.action === 'keep' ? 'keep' : 'discard',
+      scope: r.scope === 'project' ? 'project' : 'global',
+      kind: ['pattern', 'observation', 'correction', 'decision', 'failure'].includes(r.kind) ? r.kind : 'observation',
+      content: String(r.content || '').slice(0, 300),
+      summary: String(r.summary || '').slice(0, 120),
+      confidence: Math.min(1, Math.max(0.5, Number(r.confidence) || 0.7)),
+      reason: String(r.reason || '')
+    }));
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * 用 LLM 批量评估 inbox 条目，决定保留/丢弃、scope、内容提炼。
+ * @param {{ entries: Array, config: object, workspaceRoot?: string }} params
+ * @returns {Promise<Array<{ id, action, scope?, kind?, content?, summary?, confidence?, reason? }>>}
+ */
+export async function evaluateInboxBatch({ entries, config, workspaceRoot }) {
+  if (!entries || entries.length === 0) return [];
+
+  const batch = entries.map((e) => ({
+    id: e.id,
+    type: e.type || '',
+    source: e.source || '',
+    summary: (e.summary || '').slice(0, 150),
+    details: (e.details || '').slice(0, 400)
+  }));
+
+  try {
+    const result = await createChatCompletion({
+      sdkProvider: config?.sdk?.provider,
+      baseUrl: config?.gateway?.base_url,
+      apiKey: config?.gateway?.api_key,
+      model: config?.model?.name,
+      messages: [
+        { role: 'system', content: SYSTEM_PROMPT },
+        {
+          role: 'user',
+          content: `Evaluate these ${batch.length} inbox items. Workspace: ${workspaceRoot || process.cwd()}\n\n${JSON.stringify(batch, null, 2)}`
+        }
+      ],
+      temperature: 0,
+      timeoutMs: EVAL_TIMEOUT_MS
+    });
+
+    const text = result?.text || '';
+    const parsed = parseResults(text);
+    /* 确保每个 entry 都有结果，LLM 没返回的一律 discard */
+    const covered = new Set(parsed.map((r) => r.id));
+    for (const entry of entries) {
+      if (!covered.has(entry.id)) {
+        parsed.push({
+          id: entry.id,
+          action: 'discard',
+          reason: 'LLM did not return a result for this entry'
+        });
+      }
+    }
+    return parsed;
+  } catch {
+    /* LLM 调用失败 → 全部 discard（fail-safe） */
+    return entries.map((e) => ({
+      id: e.id,
+      action: 'discard',
+      reason: 'LLM evaluation failed'
+    }));
+  }
+}