metame-cli 1.4.19 → 1.4.21

package/scripts/memory-nightly-reflect.js

@@ -0,0 +1,299 @@
+#!/usr/bin/env node
+
+/**
+ * memory-nightly-reflect.js — Nightly Hot-Fact Distillation
+ *
+ * Reads "hot zone" facts from memory.db (search_count >= 3, last 7 days),
+ * calls Haiku to distill high-level patterns, and writes results to:
+ *   - ~/.metame/memory/decisions/YYYY-MM-DD-nightly-reflect.md  (strategic/architectural)
+ *   - ~/.metame/memory/lessons/YYYY-MM-DD-nightly-reflect.md    (operational SOPs)
+ *
+ * Designed to run nightly at 01:00 via daemon.yaml scheduler (require_idle).
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const HOME = os.homedir();
+const METAME_DIR = path.join(HOME, '.metame');
+const DB_PATH = path.join(METAME_DIR, 'memory.db');
+const LOCK_FILE = path.join(METAME_DIR, 'memory-nightly-reflect.lock');
+const REFLECT_LOG_FILE = path.join(METAME_DIR, 'memory_reflect_log.jsonl');
+
+const MEMORY_DIR = path.join(HOME, '.metame', 'memory');
+const DECISIONS_DIR = path.join(MEMORY_DIR, 'decisions');
+const LESSONS_DIR = path.join(MEMORY_DIR, 'lessons');
+
+// Hot zone thresholds
+const MIN_SEARCH_COUNT = 3;
+const WINDOW_DAYS = 7;
+const MAX_FACTS = 20;
+const LOCK_TIMEOUT_MS = 10 * 60 * 1000; // 10 minutes
+
+// Ensure output directories exist at startup
+[MEMORY_DIR, DECISIONS_DIR, LESSONS_DIR].forEach(d => fs.mkdirSync(d, { recursive: true }));
+
+/**
+ * Load callHaiku + buildDistillEnv from deployed path, fallback to scripts dir.
+ */
+function loadHelper(name) {
+  const candidates = [
+    path.join(HOME, '.metame', name),
+    path.join(__dirname, name),
+  ];
+  for (const p of candidates) {
+    try { return require(p); } catch {}
+  }
+  throw new Error(`Cannot load ${name}`);
+}
+
+/**
+ * Acquire atomic lock using O_EXCL — prevents concurrent runs.
+ */
+function acquireLock() {
+  try {
+    const fd = fs.openSync(LOCK_FILE, 'wx');
+    fs.writeSync(fd, process.pid.toString());
+    fs.closeSync(fd);
+    return true;
+  } catch (e) {
+    if (e.code === 'EEXIST') {
+      try {
+        const lockAge = Date.now() - fs.statSync(LOCK_FILE).mtimeMs;
+        if (lockAge < LOCK_TIMEOUT_MS) {
+          console.log('[NIGHTLY-REFLECT] Already running (lock held), skipping.');
+          return false;
+        }
+        // Stale lock — remove and re-acquire
+        fs.unlinkSync(LOCK_FILE);
+        const fd = fs.openSync(LOCK_FILE, 'wx');
+        fs.writeSync(fd, process.pid.toString());
+        fs.closeSync(fd);
+        return true;
+      } catch {
+        console.log('[NIGHTLY-REFLECT] Could not acquire lock, skipping.');
+        return false;
+      }
+    }
+    throw e;
+  }
+}
+
+/**
+ * Release the atomic lock.
+ */
+function releaseLock() {
+  try { fs.unlinkSync(LOCK_FILE); } catch { /* non-fatal */ }
+}
+
+/**
+ * Append a run record to the audit log.
+ */
+function writeReflectLog(record) {
+  const line = JSON.stringify({ ts: new Date().toISOString(), ...record }) + '\n';
+  try {
+    fs.mkdirSync(path.dirname(REFLECT_LOG_FILE), { recursive: true });
+    fs.appendFileSync(REFLECT_LOG_FILE, line, 'utf8');
+  } catch (e) {
+    console.log(`[NIGHTLY-REFLECT] Warning: could not write reflect log: ${e.message}`);
+  }
+}
+
+/**
+ * Query hot zone facts from memory.db.
+ * Returns array of plain objects.
+ */
+function queryHotFacts(db) {
+  const stmt = db.prepare(`
+    SELECT entity, relation, value, confidence, search_count, created_at
+    FROM facts
+    WHERE search_count >= ${MIN_SEARCH_COUNT}
+      AND created_at >= datetime('now', '-${WINDOW_DAYS} days')
+      AND superseded_by IS NULL
+      AND (conflict_status IS NULL OR conflict_status = 'OK')
+      AND relation != 'project_milestone'
+    ORDER BY search_count DESC, created_at DESC
+    LIMIT ${MAX_FACTS}
+  `);
+  return stmt.all();
+}
+
+/**
+ * Write a reflect Markdown file with frontmatter.
+ */
+function writeReflectFile(filePath, entries, factsCount, sourceType) {
+  const today = new Date().toISOString().slice(0, 10);
+  const sections = entries
+    .map(e => `## ${e.title}\n\n${e.content}`)
+    .join('\n\n---\n\n');
+
+  const content = `---
+date: ${today}
+source: nightly-reflect
+type: ${sourceType}
+facts_analyzed: ${factsCount}
+---
+
+${sections}
+`;
+  fs.writeFileSync(filePath, content, 'utf8');
+}
+
+/**
+ * Main nightly reflect run.
+ */
+async function run() {
+  console.log('[NIGHTLY-REFLECT] Starting nightly reflect run...');
+
+  if (!fs.existsSync(DB_PATH)) {
+    console.log('[NIGHTLY-REFLECT] memory.db not found, skipping.');
+    return;
+  }
+
+  if (!acquireLock()) return;
+
+  const today = new Date().toISOString().slice(0, 10);
+  const decisionFile = path.join(DECISIONS_DIR, `${today}-nightly-reflect.md`);
+  const lessonFile = path.join(LESSONS_DIR, `${today}-nightly-reflect.md`);
+
+  // Prevent duplicate runs for the same day
+  if (fs.existsSync(decisionFile) || fs.existsSync(lessonFile)) {
+    console.log('[NIGHTLY-REFLECT] Already ran today, skipping.');
+    releaseLock();
+    return;
+  }
+
+  let db;
+  try {
+    const { DatabaseSync } = require('node:sqlite');
+    db = new DatabaseSync(DB_PATH);
+    db.exec('PRAGMA journal_mode = WAL');
+    db.exec('PRAGMA busy_timeout = 5000');
+
+    const hotFacts = queryHotFacts(db);
+    console.log(`[NIGHTLY-REFLECT] Found ${hotFacts.length} hot-zone facts.`);
+
+    if (hotFacts.length < 3) {
+      console.log('[NIGHTLY-REFLECT] Insufficient hot facts (< 3), skipping distillation.');
+      writeReflectLog({ status: 'skipped', reason: 'insufficient_facts', facts_found: hotFacts.length });
+      releaseLock();
+      return;
+    }
+
+    // Load Haiku helper from providers.js (callHaiku lives there)
+    let callHaiku, buildDistillEnv;
+    try {
+      ({ callHaiku, buildDistillEnv } = loadHelper('providers.js'));
+    } catch (e) {
+      throw new Error(`Cannot load Haiku helper from providers.js: ${e.message}`);
+    }
+
+    let distillEnv = {};
+    try { distillEnv = buildDistillEnv(); } catch {}
+
+    const factsJson = JSON.stringify(
+      hotFacts.map(f => ({
+        entity: f.entity,
+        relation: f.relation,
+        value: f.value,
+        confidence: f.confidence,
+        search_count: f.search_count,
+      })),
+      null,
+      2
+    );
+
+    const prompt = `You are extracting high-level patterns from an AI assistant's recent memory facts.
+
+Recent high-frequency facts (JSON):
+${factsJson}
+
+Analyze and output a JSON object:
+{
+  "decisions": [{"title": "中文标题", "content": "## 背景\\n...\\n## 结论\\n..."}],
+  "lessons": [{"title": "中文标题", "content": "## 问题\\n...\\n## 操作手册\\n1. ..."}]
+}
+
+Rules:
+- decisions: strategic/architectural insights (why we chose X over Y)
+- lessons: operational SOPs (how to do X correctly)
+- Each array can be empty if no pattern found
+- content in 中文, 100-250 chars each
+- Output ONLY the JSON object`;
+
+    console.log('[NIGHTLY-REFLECT] Calling Haiku for distillation...');
+    let raw;
+    try {
+      raw = await Promise.race([
+        callHaiku(prompt, distillEnv, 90000),
+        new Promise((_, reject) => setTimeout(() => reject(new Error('timeout')), 95000)),
+      ]);
+    } catch (e) {
+      console.log(`[NIGHTLY-REFLECT] Haiku call failed: ${e.message}`);
+      writeReflectLog({ status: 'error', reason: 'haiku_failed', error: e.message, facts_found: hotFacts.length });
+      return;
+    }
+
+    // Parse Haiku response
+    let parsed;
+    try {
+      const cleaned = raw.replace(/```json\n?/g, '').replace(/```\n?/g, '').trim();
+      parsed = JSON.parse(cleaned);
+    } catch (e) {
+      console.log(`[NIGHTLY-REFLECT] Failed to parse Haiku output: ${e.message}`);
+      writeReflectLog({ status: 'error', reason: 'parse_failed', facts_found: hotFacts.length });
+      return;
+    }
+
+    const decisions = Array.isArray(parsed.decisions) ? parsed.decisions.filter(d => d.title && d.content) : [];
+    const lessons = Array.isArray(parsed.lessons) ? parsed.lessons.filter(l => l.title && l.content) : [];
+
+    console.log(`[NIGHTLY-REFLECT] Distilled: ${decisions.length} decision(s), ${lessons.length} lesson(s).`);
+
+    // Write decisions file (even if empty array — record the run)
+    if (decisions.length > 0) {
+      writeReflectFile(decisionFile, decisions, hotFacts.length, 'decisions');
+      console.log(`[NIGHTLY-REFLECT] Decisions written: ${decisionFile}`);
+    }
+
+    // Write lessons file
+    if (lessons.length > 0) {
+      writeReflectFile(lessonFile, lessons, hotFacts.length, 'lessons');
+      console.log(`[NIGHTLY-REFLECT] Lessons written: ${lessonFile}`);
+    }
+
+    // Write audit log
+    writeReflectLog({
+      status: 'success',
+      facts_analyzed: hotFacts.length,
+      decisions_written: decisions.length,
+      lessons_written: lessons.length,
+      decision_file: decisions.length > 0 ? decisionFile : null,
+      lesson_file: lessons.length > 0 ? lessonFile : null,
+    });
+
+    console.log('[NIGHTLY-REFLECT] Run complete.');
+
+  } catch (e) {
+    console.error(`[NIGHTLY-REFLECT] Fatal error: ${e.message}`);
+    writeReflectLog({ status: 'error', reason: 'fatal', error: e.message });
+    process.exitCode = 1;
+  } finally {
+    try { if (db) db.close(); } catch { /* non-fatal */ }
+    releaseLock();
+  }
+}
+
+if (require.main === module) {
+  run().then(() => {
+    console.log('✅ nightly-reflect complete');
+  }).catch(e => {
+    console.error(`[NIGHTLY-REFLECT] Fatal: ${e.message}`);
+    process.exit(1);
+  });
+}
+
+module.exports = { run };

package/scripts/memory-write.js

@@ -0,0 +1,192 @@
+#!/usr/bin/env node
+/**
+ * memory-write.js — Active memory injection CLI
+ *
+ * Usage:
+ *   node memory-write.js "entity" "relation" "value"
+ *   node memory-write.js "entity" "relation" "value" --confidence high --project metame --tags "tag1,tag2"
+ *   node memory-write.js --help
+ *
+ * Reuses memory.js saveFacts() and acquire/release pattern. Zero new dependencies.
+ */
+
+'use strict';
+
+const path = require('path');
+const os = require('os');
+
+// ── Legal relation types ──────────────────────────────────────────────────────
+const VALID_RELATIONS = new Set([
+  'tech_decision',
+  'bug_lesson',
+  'arch_convention',
+  'config_fact',
+  'config_change',
+  'user_pref',
+  'workflow_rule',
+  'project_milestone',
+]);
+
+// ── Entity whitelist (no dot required for these) ──────────────────────────────
+const ENTITY_WHITELIST = new Set(['王总', 'system', 'user', 'MetaMe']);
+
+// ── Help text ─────────────────────────────────────────────────────────────────
+const HELP = `
+memory-write.js — 主动写入事实到 memory.db
+
+用法:
+  node memory-write.js <entity> <relation> <value> [options]
+
+参数:
+  entity      知识主体，须含点号（如 MetaMe.daemon）或在白名单（王总/system/user/MetaMe）
+  relation    关系类型，合法值：
+                ${[...VALID_RELATIONS].join(', ')}
+  value       事实内容，20-300 字符
+
+选项:
+  --confidence <level>   high | medium | low  （默认 medium）
+  --project <key>        项目标识（默认从 cwd 推断，推断不到则 '*'）
+  --tags <tag1,tag2>     最多 3 个标签，逗号分隔
+  --help                 显示此帮助
+
+示例:
+  node memory-write.js "MetaMe.daemon" "bug_lesson" "修复X前必须先Y，否则Z会挂"
+  node memory-write.js "MetaMe.bridge" "tech_decision" "飞书回调走 3000 端口，nginx 转发" --confidence high --project metame
+`.trim();
+
+// ── Project inference ─────────────────────────────────────────────────────────
+function inferProject(cwd) {
+  if (!cwd) return '*';
+  const known = { 'MetaMe': 'metame', 'metame-desktop': 'desktop' };
+  for (const [dir, key] of Object.entries(known)) {
+    if (cwd.includes(dir)) return key;
+  }
+  return '*';
+}
+
+// ── Argv parser (zero deps) ───────────────────────────────────────────────────
+function parseArgs(argv) {
+  const positional = [];
+  const opts = {};
+  let i = 0;
+  while (i < argv.length) {
+    const a = argv[i];
+    if (a === '--help' || a === '-h') { opts.help = true; i++; continue; }
+    if (a.startsWith('--')) {
+      const key = a.slice(2);
+      const val = argv[i + 1] && !argv[i + 1].startsWith('--') ? argv[i + 1] : null;
+      if (val !== null) { opts[key] = val; i += 2; } else { opts[key] = true; i++; }
+    } else {
+      positional.push(a);
+      i++;
+    }
+  }
+  return { positional, opts };
+}
+
+// ── Validation ────────────────────────────────────────────────────────────────
+function validateEntity(entity) {
+  if (!entity) return 'entity 不能为空';
+  if (ENTITY_WHITELIST.has(entity)) return null;
+  if (!entity.includes('.')) return `entity 格式不合法：须含点号（如 MetaMe.daemon）或为白名单值（${[...ENTITY_WHITELIST].join('/')}）`;
+  return null;
+}
+
+function validateRelation(relation) {
+  if (!relation) return 'relation 不能为空';
+  if (!VALID_RELATIONS.has(relation)) {
+    return `relation 不合法："${relation}"\n合法值: ${[...VALID_RELATIONS].join(', ')}`;
+  }
+  return null;
+}
+
+function validateValue(value) {
+  if (!value) return 'value 不能为空';
+  if (value.length < 20) return `value 太短（${value.length} 字符），最少 20 字符`;
+  if (value.length > 300) return `value 太长（${value.length} 字符），最多 300 字符`;
+  return null;
+}
+
+function validateConfidence(conf) {
+  const valid = ['high', 'medium', 'low'];
+  if (!valid.includes(conf)) return `confidence 不合法："${conf}"，合法值: high | medium | low`;
+  return null;
+}
+
+// ── Resolve memory.js (supports both dev and deployed paths) ──────────────────
+function resolveMemory() {
+  const candidates = [
+    path.join(os.homedir(), '.metame', 'memory.js'),
+    path.join(__dirname, 'memory.js'),
+  ];
+  for (const p of candidates) {
+    try { require.resolve(p); return p; } catch { }
+  }
+  return null;
+}
+
+// ── Main ──────────────────────────────────────────────────────────────────────
+function main() {
+  const { positional, opts } = parseArgs(process.argv.slice(2));
+
+  if (opts.help) {
+    console.log(HELP);
+    process.exit(0);
+  }
+
+  const [entity, relation, value] = positional;
+  const confidence = opts.confidence || 'medium';
+  const project = opts.project || process.env.METAME_PROJECT || inferProject(process.cwd());
+  const tagsRaw = opts.tags || '';
+  const tags = tagsRaw ? tagsRaw.split(',').map(t => t.trim()).filter(Boolean).slice(0, 3) : [];
+
+  // Validate
+  const errors = [
+    validateEntity(entity),
+    validateRelation(relation),
+    validateValue(value),
+    opts.confidence ? validateConfidence(confidence) : null,
+  ].filter(Boolean);
+
+  if (errors.length) {
+    for (const e of errors) console.error('错误: ' + e);
+    console.error('\n运行 node memory-write.js --help 查看用法');
+    process.exit(1);
+  }
+
+  // Resolve memory module
+  const memoryPath = resolveMemory();
+  if (!memoryPath) {
+    console.error('错误: 找不到 memory.js，请确认 MetaMe 已部署');
+    process.exit(1);
+  }
+
+  const memory = require(memoryPath);
+  const sessionId = 'manual-' + Date.now();
+
+  if (typeof memory.acquire === 'function') memory.acquire();
+  try {
+    const result = memory.saveFacts(sessionId, project, [
+      { entity, relation, value, confidence, tags, source_type: 'manual' },
+    ]);
+
+    if (result.saved > 0) {
+      const preview = value.slice(0, 30) + (value.length > 30 ? '...' : '');
+      console.log(`✓ 已保存 [${relation}] ${entity}: "${preview}"`);
+      if (result.superseded > 0) {
+        console.log(`  (已将 ${result.superseded} 条旧记录标记为 superseded)`);
+      }
+    } else {
+      // skipped: duplicate or validation filtered by saveFacts
+      console.log(`⚠ 未保存（可能是重复内容）。已跳过: ${result.skipped}`);
+      process.exit(1);
+    }
+  } catch (err) {
+    console.error('错误: 写入失败 —', err.message);
+    process.exit(1);
+  } finally {
+    try { if (typeof memory.release === 'function') memory.release(); } catch { }
+  }
+}
+
+main();