metame-cli 1.4.15 → 1.4.18

package/scripts/reliability-core.test.js

@@ -0,0 +1,268 @@
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { execFileSync, spawn } = require('child_process');
+
+const ROOT = path.resolve(__dirname, '..');
+
+function mkHome(prefix = 'metame-reliability-') {
+  const home = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
+  fs.mkdirSync(path.join(home, '.metame'), { recursive: true });
+  return home;
+}
+
+function runNode(home, code, extraEnv = {}) {
+  return execFileSync(process.execPath, ['-e', code], {
+    cwd: ROOT,
+    env: { ...process.env, HOME: home, ...extraEnv },
+    encoding: 'utf8',
+    timeout: 30000,
+  });
+}
+
+function installFakeClaude(home, body) {
+  const bin = path.join(home, 'bin');
+  fs.mkdirSync(bin, { recursive: true });
+  const cli = path.join(bin, 'claude');
+  fs.writeFileSync(cli, `#!/bin/sh\n${body}\n`, 'utf8');
+  fs.chmodSync(cli, 0o755);
+  return { PATH: `${bin}:${process.env.PATH}` };
+}
+
+function sendSignal(home, prompt, extraEnv = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(process.execPath, [path.join(ROOT, 'scripts', 'signal-capture.js')], {
+      cwd: ROOT,
+      env: { ...process.env, HOME: home, ...extraEnv },
+      stdio: ['pipe', 'ignore', 'ignore'],
+    });
+    const timer = setTimeout(() => {
+      try { child.kill('SIGKILL'); } catch {}
+      reject(new Error('signal-capture timed out'));
+    }, 10000);
+    child.on('error', reject);
+    child.on('close', (code) => {
+      clearTimeout(timer);
+      if (code === 0) resolve();
+      else reject(new Error(`signal-capture exited with ${code}`));
+    });
+    child.stdin.end(JSON.stringify({
+      prompt,
+      session_id: `s-${Math.random().toString(36).slice(2, 10)}`,
+      cwd: '/tmp',
+    }));
+  });
+}
+
+test('signal-capture preserves all entries under concurrent writes', async () => {
+  const home = mkHome();
+  const count = 40;
+  await Promise.all(
+    Array.from({ length: count }, (_, i) => sendSignal(home, `请记住以后规则${i}`))
+  );
+
+  const buffer = path.join(home, '.metame', 'raw_signals.jsonl');
+  const lines = fs.readFileSync(buffer, 'utf8').split('\n').filter(Boolean);
+  assert.equal(lines.length, count);
+  const prompts = new Set(lines.map((l) => JSON.parse(l).prompt));
+  assert.equal(prompts.size, count);
+});
+
+test('distill keeps raw_signals when model returns malformed output', () => {
+  const home = mkHome();
+  const env = installFakeClaude(home, 'echo "MALFORMED_OUTPUT"');
+  const buffer = path.join(home, '.metame', 'raw_signals.jsonl');
+
+  fs.writeFileSync(
+    buffer,
+    JSON.stringify({
+      ts: new Date().toISOString(),
+      prompt: '请记住以后都用中文并保持简洁',
+      confidence: 'high',
+      type: 'directive',
+      session: 'sess-1',
+      cwd: '/tmp',
+    }) + '\n',
+    'utf8'
+  );
+
+  runNode(home, `
+    const { distill } = require('./scripts/distill');
+    (async () => {
+      const r = await distill();
+      console.log(JSON.stringify(r));
+    })().then(() => process.exit(0)).catch(() => process.exit(1));
+  `, env);
+
+  const lines = fs.readFileSync(buffer, 'utf8').split('\n').filter(Boolean);
+  assert.equal(lines.length, 1);
+  assert.match(JSON.parse(lines[0]).prompt, /以后都用中文/);
+});
+
+test('memory-extract does not mark session extracted when extraction fails', () => {
+  const home = mkHome();
+  const env = installFakeClaude(home, 'echo "downstream failure" 1>&2; exit 1');
+  const projDir = path.join(home, '.claude', 'projects', 'demo');
+  fs.mkdirSync(projDir, { recursive: true });
+  const sessionId = 'session-retry-me';
+  const sessionPath = path.join(projDir, `${sessionId}.jsonl`);
+
+  const rows = [];
+  for (let i = 0; i < 24; i++) {
+    rows.push(JSON.stringify({
+      type: 'user',
+      timestamp: new Date(Date.now() + i * 1000).toISOString(),
+      cwd: '/tmp/demo',
+      message: { content: `这是一条用于memory extract回归测试的用户消息 ${i}，需要保留重试能力。` },
+    }));
+    rows.push(JSON.stringify({
+      type: 'assistant',
+      timestamp: new Date(Date.now() + i * 1000 + 500).toISOString(),
+      message: { content: [{ type: 'text', text: 'ack' }] },
+    }));
+  }
+  fs.writeFileSync(sessionPath, rows.join('\n') + '\n', 'utf8');
+
+  runNode(home, `
+    const me = require('./scripts/memory-extract');
+    (async () => {
+      await me.run();
+      const sa = require('./scripts/session-analytics');
+      const remain = sa.findAllUnextractedSessions(50).map(s => s.session_id);
+      console.log(JSON.stringify(remain));
+    })().then(() => process.exit(0)).catch(() => process.exit(1));
+  `, env);
+
+  const remain = JSON.parse(
+    runNode(home, `
+      const sa = require('./scripts/session-analytics');
+      console.log(JSON.stringify(sa.findAllUnextractedSessions(50).map(s => s.session_id)));
+    `).trim()
+  );
+  assert.ok(remain.includes(sessionId));
+});
+
+test('skill-evolution keeps signals when haiku output is malformed', () => {
+  const home = mkHome();
+  const env = installFakeClaude(home, 'echo "NOT_JSON_BLOCK"');
+  const skillDir = path.join(home, '.claude', 'skills', 'demo-skill');
+  fs.mkdirSync(skillDir, { recursive: true });
+  fs.writeFileSync(path.join(skillDir, 'SKILL.md'), '# Demo Skill\n\nA sample skill.', 'utf8');
+
+  const sigFile = path.join(home, '.metame', 'skill_signals.jsonl');
+  const signals = [
+    { ts: new Date().toISOString(), prompt: '请求1', outcome: 'error', skills_invoked: ['demo-skill'], has_tool_failure: true, error: 'x' },
+    { ts: new Date().toISOString(), prompt: '请求2', outcome: 'error', skills_invoked: ['demo-skill'], has_tool_failure: true, error: 'y' },
+    { ts: new Date().toISOString(), prompt: '请求3', outcome: 'error', skills_invoked: ['demo-skill'], has_tool_failure: true, error: 'z' },
+  ];
+  fs.writeFileSync(sigFile, signals.map(s => JSON.stringify(s)).join('\n') + '\n', 'utf8');
+
+  runNode(home, `
+    const se = require('./scripts/skill-evolution');
+    (async () => {
+      await se.distillSkills();
+    })().then(() => process.exit(0)).catch(() => process.exit(1));
+  `, env);
+
+  const lines = fs.readFileSync(sigFile, 'utf8').split('\n').filter(Boolean);
+  assert.equal(lines.length, 3);
+});
+
+test('signal-capture: overflow entries are drained and merged on next lock acquisition', async () => {
+  const home = mkHome();
+  const bufferFile = path.join(home, '.metame', 'raw_signals.jsonl');
+  const overflowFile = path.join(home, '.metame', 'raw_signals.overflow.jsonl');
+
+  const makeEntry = (i) => JSON.stringify({
+    ts: new Date().toISOString(), prompt: `以后记住规则${i}`, confidence: 'high',
+    type: 'directive', session: null, cwd: '/tmp',
+  });
+
+  // Pre-populate main buffer (3 entries) and overflow (2 entries)
+  fs.writeFileSync(bufferFile, [0, 1, 2].map(makeEntry).join('\n') + '\n', 'utf8');
+  fs.writeFileSync(overflowFile, [100, 101].map(makeEntry).join('\n') + '\n', 'utf8');
+
+  // One normal signal — should drain overflow inside the lock
+  await sendSignal(home, '以后回复请保持简洁风格');
+
+  const lines = fs.readFileSync(bufferFile, 'utf8').split('\n').filter(Boolean);
+  // 3 existing + 2 overflow + 1 new = 6
+  assert.equal(lines.length, 6);
+  assert.equal(fs.existsSync(overflowFile), false, 'overflow file should be removed after drain');
+});
+
+test('signal-capture: overflow drain respects MAX_BUFFER_LINES cap', async () => {
+  const home = mkHome();
+  const MAX = 300;
+  const bufferFile = path.join(home, '.metame', 'raw_signals.jsonl');
+  const overflowFile = path.join(home, '.metame', 'raw_signals.overflow.jsonl');
+
+  const makeEntry = (i) => JSON.stringify({
+    ts: new Date().toISOString(), prompt: `以后偏好配置${i}`, confidence: 'normal',
+    type: 'implicit', session: null, cwd: '/tmp',
+  });
+
+  // Fill main buffer to 297, overflow to 5 — combined 302 + 1 new → must cap to 300
+  fs.writeFileSync(bufferFile, Array.from({ length: 297 }, (_, i) => makeEntry(i)).join('\n') + '\n', 'utf8');
+  fs.writeFileSync(overflowFile, Array.from({ length: 5 }, (_, i) => makeEntry(i + 1000)).join('\n') + '\n', 'utf8');
+
+  await sendSignal(home, '以后总是用英文写注释');
+
+  const lines = fs.readFileSync(bufferFile, 'utf8').split('\n').filter(Boolean);
+  assert.ok(lines.length <= MAX, `buffer must not exceed MAX_BUFFER_LINES (got ${lines.length})`);
+  assert.equal(lines.length, MAX);
+  assert.equal(fs.existsSync(overflowFile), false, 'overflow file should be removed after drain');
+});
+
+test('skill-evolution: overflow entries are drained and merged on next appendSkillSignal', () => {
+  const home = mkHome();
+  const sigFile = path.join(home, '.metame', 'skill_signals.jsonl');
+  const overflowFile = path.join(home, '.metame', 'skill_signals.overflow.jsonl');
+
+  const makeSignal = (i) => JSON.stringify({
+    ts: new Date().toISOString(), prompt: `prompt-${i}`, outcome: 'success',
+    skills_invoked: ['demo-skill'], has_tool_failure: false, error: null,
+    output_excerpt: '', tools_used: [], files_modified: [], cwd: '/tmp',
+  });
+
+  fs.writeFileSync(sigFile, [0, 1, 2].map(makeSignal).join('\n') + '\n', 'utf8');
+  fs.writeFileSync(overflowFile, [100, 101].map(makeSignal).join('\n') + '\n', 'utf8');
+
+  runNode(home, `
+    const se = require('./scripts/skill-evolution');
+    const sig = {
+      ts: new Date().toISOString(), prompt: 'new-signal', outcome: 'success',
+      skills_invoked: ['demo-skill'], has_tool_failure: false, error: null,
+      output_excerpt: '', tools_used: [], files_modified: [], cwd: '/tmp',
+    };
+    se.appendSkillSignal(sig);
+    process.exit(0);
+  `);
+
+  const lines = fs.readFileSync(sigFile, 'utf8').split('\n').filter(Boolean);
+  // 3 existing + 2 overflow + 1 new = 6
+  assert.equal(lines.length, 6);
+  assert.equal(fs.existsSync(overflowFile), false, 'overflow file should be removed after drain');
+});
+
+test('writeBrainFileSafe throws when lock cannot be acquired', () => {
+  const home = mkHome();
+  fs.writeFileSync(path.join(home, '.metame', 'brain.lock'), '99999', 'utf8');
+
+  const out = runNode(home, `
+    const { writeBrainFileSafe } = require('./scripts/utils');
+    (async () => {
+      try {
+        await writeBrainFileSafe('x: 1\\n', process.env.HOME + '/profile.yaml');
+        console.log('WROTE');
+      } catch (e) {
+        console.log('THREW');
+      }
+    })().then(() => process.exit(0)).catch(() => process.exit(1));
+  `).trim();
+
+  assert.equal(out, 'THREW');
+  assert.equal(fs.existsSync(path.join(home, 'profile.yaml')), false);
+});

package/scripts/session-analytics.js

@@ -11,43 +11,105 @@
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
+const { deriveProjectInfo } = require('./utils');
 
 const HOME = os.homedir();
 const PROJECTS_ROOT = path.join(HOME, '.claude', 'projects');
 const STATE_FILE = path.join(HOME, '.metame', 'analytics_state.json');
-const MAX_STATE_ENTRIES = 200;
+const STATE_DB = path.join(HOME, '.metame', 'analytics_state.db');
 const MAX_FILE_SIZE = 100 * 1024 * 1024; // 100MB
 const MIN_FILE_SIZE = 1024;               // 1KB
+let _stateDb = null;
+let _stmtIsProcessed = null;
+let _stmtMarkProcessed = null;
 
 /**
- * Load analytics state (set of already-analyzed session IDs).
+ * Initialize analytics state DB.
  */
-function loadState() {
+function getStateDb() {
+  if (_stateDb) return _stateDb;
+  const dir = path.dirname(STATE_DB);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+
+  const { DatabaseSync } = require('node:sqlite');
+  _stateDb = new DatabaseSync(STATE_DB);
+  _stateDb.exec('PRAGMA journal_mode = WAL');
+  _stateDb.exec('PRAGMA busy_timeout = 3000');
+  _stateDb.exec(`
+    CREATE TABLE IF NOT EXISTS processed_sessions (
+      kind         TEXT NOT NULL,
+      session_id   TEXT NOT NULL,
+      processed_at INTEGER NOT NULL,
+      PRIMARY KEY (kind, session_id)
+    )
+  `);
+  _stateDb.exec('CREATE INDEX IF NOT EXISTS idx_processed_kind_ts ON processed_sessions(kind, processed_at)');
+  _stateDb.exec('CREATE TABLE IF NOT EXISTS state_meta (key TEXT PRIMARY KEY, value TEXT)');
+  migrateLegacyStateOnce(_stateDb);
+  return _stateDb;
+}
+
+/**
+ * One-time migration from legacy JSON state file.
+ */
+function migrateLegacyStateOnce(db) {
   try {
+    const migrated = db.prepare("SELECT value FROM state_meta WHERE key = 'legacy_json_migrated'").get();
+    if (migrated && migrated.value === '1') return;
+
     if (fs.existsSync(STATE_FILE)) {
-      return JSON.parse(fs.readFileSync(STATE_FILE, 'utf8'));
+      let raw = null;
+      try { raw = JSON.parse(fs.readFileSync(STATE_FILE, 'utf8')); } catch { raw = null; }
+      if (raw && typeof raw === 'object') {
+        const insert = db.prepare(`
+          INSERT INTO processed_sessions (kind, session_id, processed_at)
+          VALUES (?, ?, ?)
+          ON CONFLICT(kind, session_id) DO UPDATE SET processed_at = excluded.processed_at
+        `);
+        const tx = db.transaction(() => {
+          for (const [sid, ts] of Object.entries(raw.analyzed || {})) {
+            insert.run('analyzed', sid, Number(ts) || Date.now());
+          }
+          for (const [sid, ts] of Object.entries(raw.facts_analyzed || {})) {
+            insert.run('facts_analyzed', sid, Number(ts) || Date.now());
+          }
+        });
+        tx();
+      }
     }
-  } catch { /* corrupt state — start fresh */ }
-  return { analyzed: {} };
+
+    db.prepare("INSERT OR REPLACE INTO state_meta (key, value) VALUES ('legacy_json_migrated', '1')").run();
+  } catch {
+    // non-fatal
+  }
+}
+
+function isProcessed(kind, sessionId) {
+  if (!kind || !sessionId) return false;
+  const db = getStateDb();
+  if (!_stmtIsProcessed) {
+    _stmtIsProcessed = db.prepare(
+      'SELECT 1 AS ok FROM processed_sessions WHERE kind = ? AND session_id = ? LIMIT 1'
+    );
+  }
+  const row = _stmtIsProcessed.get(kind, sessionId);
+  return !!(row && row.ok === 1);
 }
 
 /**
- * Save analytics state.
+ * Mark a session as processed in DB.
  */
-function saveState(state) {
-  // Cap entries for both tracking keys
-  for (const key of ['analyzed', 'facts_analyzed']) {
-    if (!state[key]) continue;
-    const keys = Object.keys(state[key]);
-    if (keys.length > MAX_STATE_ENTRIES) {
-      const sorted = keys.sort((a, b) => (state[key][a] || 0) - (state[key][b] || 0));
-      const toRemove = sorted.slice(0, keys.length - MAX_STATE_ENTRIES);
-      for (const k of toRemove) delete state[key][k];
-    }
+function markProcessed(kind, sessionId) {
+  if (!sessionId) return;
+  const db = getStateDb();
+  if (!_stmtMarkProcessed) {
+    _stmtMarkProcessed = db.prepare(`
+      INSERT INTO processed_sessions (kind, session_id, processed_at)
+      VALUES (?, ?, ?)
+      ON CONFLICT(kind, session_id) DO UPDATE SET processed_at = excluded.processed_at
+    `);
   }
-  const dir = path.dirname(STATE_FILE);
-  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-  fs.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2), 'utf8');
+  _stmtMarkProcessed.run(kind, sessionId, Date.now());
 }
 
 /**
@@ -55,7 +117,6 @@ function saveState(state) {
  * Returns { path, session_id, mtime } or null.
  */
 function findLatestUnanalyzedSession() {
-  const state = loadState();
   let best = null;
 
   try {
@@ -72,7 +133,7 @@ function findLatestUnanalyzedSession() {
       for (const file of files) {
         if (!file.endsWith('.jsonl')) continue;
         const sessionId = file.replace('.jsonl', '');
-        if (state.analyzed[sessionId]) continue;
+        if (isProcessed('analyzed', sessionId)) continue;
 
         const fullPath = path.join(fullDir, file);
         let fstat;
@@ -114,6 +175,8 @@ function extractSkeleton(jsonlPath) {
     message_count: 0,
     duration_min: 0,
     project: null,
+    project_id: null,
+    project_path: null,
     branch: null,
     file_dirs: new Set(),
     intent: null,
@@ -145,7 +208,10 @@ function extractSkeleton(jsonlPath) {
     if (type === 'user') {
       // Extract project and branch from first occurrence
       if (!skeleton.project && entry.cwd) {
-        skeleton.project = path.basename(entry.cwd);
+        const info = deriveProjectInfo(entry.cwd);
+        skeleton.project = info.project;
+        skeleton.project_id = info.project_id;
+        skeleton.project_path = info.project_path;
       }
       if (!skeleton.branch && entry.gitBranch) {
         skeleton.branch = entry.gitBranch;
@@ -387,7 +453,6 @@ function formatForPrompt(skeleton) {
  * Returns array of { path, session_id, mtime }. Capped at `limit`.
  */
 function findAllUnanalyzedSessions(limit = 30) {
-  const state = loadState();
   const results = [];
 
   try {
@@ -404,7 +469,7 @@ function findAllUnanalyzedSessions(limit = 30) {
       for (const file of files) {
         if (!file.endsWith('.jsonl')) continue;
         const sessionId = file.replace('.jsonl', '');
-        if (state.analyzed[sessionId]) continue;
+        if (isProcessed('analyzed', sessionId)) continue;
 
         const fullPath = path.join(fullDir, file);
         let fstat;
@@ -428,9 +493,7 @@ function findAllUnanalyzedSessions(limit = 30) {
  * Mark a session as analyzed (cognitive distill / pattern detection).
  */
 function markAnalyzed(sessionId) {
-  const state = loadState();
-  state.analyzed[sessionId] = Date.now();
-  saveState(state);
+  markProcessed('analyzed', sessionId);
 }
 
 /**
@@ -438,8 +501,6 @@ function markAnalyzed(sessionId) {
  * Uses a separate `facts_analyzed` key so distill and memory-extract don't interfere.
  */
 function findAllUnextractedSessions(limit = 30) {
-  const state = loadState();
-  const factsAnalyzed = state.facts_analyzed || {};
   const results = [];
 
   try {
@@ -456,7 +517,7 @@ function findAllUnextractedSessions(limit = 30) {
       for (const file of files) {
         if (!file.endsWith('.jsonl')) continue;
         const sessionId = file.replace('.jsonl', '');
-        if (factsAnalyzed[sessionId]) continue;
+        if (isProcessed('facts_analyzed', sessionId)) continue;
 
         const fullPath = path.join(fullDir, file);
         let fstat;
@@ -479,10 +540,36 @@ function findAllUnextractedSessions(limit = 30) {
  * Mark a session as facts-extracted (used by memory-extract, independent of markAnalyzed).
  */
 function markFactsExtracted(sessionId) {
-  const state = loadState();
-  if (!state.facts_analyzed) state.facts_analyzed = {};
-  state.facts_analyzed[sessionId] = Date.now();
-  saveState(state); // saveState() caps both analyzed and facts_analyzed
+  markProcessed('facts_analyzed', sessionId);
+}
+
+/**
+ * Find a session jsonl by its session id.
+ * Returns { path, session_id, mtime } or null.
+ */
+function findSessionById(sessionId) {
+  const sid = String(sessionId || '').trim();
+  if (!sid) return null;
+
+  try {
+    const projectDirs = fs.readdirSync(PROJECTS_ROOT);
+    for (const dir of projectDirs) {
+      const fullDir = path.join(PROJECTS_ROOT, dir);
+      let stat;
+      try { stat = fs.statSync(fullDir); } catch { continue; }
+      if (!stat.isDirectory()) continue;
+
+      const fullPath = path.join(fullDir, `${sid}.jsonl`);
+      let fstat;
+      try { fstat = fs.statSync(fullPath); } catch { continue; }
+      if (fstat.size > MAX_FILE_SIZE || fstat.size < MIN_FILE_SIZE) continue;
+      return { path: fullPath, session_id: sid, mtime: fstat.mtimeMs };
+    }
+  } catch {
+    return null;
+  }
+
+  return null;
 }
 
 /**
@@ -579,6 +666,7 @@ function summarizeSession(skeleton, jsonlPath) {
 
 module.exports = {
   findLatestUnanalyzedSession,
+  findSessionById,
   findAllUnanalyzedSessions,
   findAllUnextractedSessions,
   extractSkeleton,