monomind 1.16.6 → 1.16.8

package/packages/@monomind/cli/.claude/helpers/auto-memory-hook.mjs

@@ -0,0 +1,413 @@
+#!/usr/bin/env node
+/**
+ * Auto Memory Bridge Hook (ADR-048/049)
+ *
+ * Wires AutoMemoryBridge + LearningBridge + MemoryGraph into Claude Code
+ * session lifecycle. Called by settings.json SessionStart/SessionEnd hooks.
+ *
+ * Usage:
+ *   node auto-memory-hook.mjs import   # SessionStart: import auto memory files into backend
+ *   node auto-memory-hook.mjs sync     # SessionEnd: sync insights back to MEMORY.md
+ *   node auto-memory-hook.mjs status   # Show bridge status
+ */
+
+import { existsSync, mkdirSync, openSync, closeSync, unlinkSync, readFileSync, writeFileSync, renameSync, statSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const PROJECT_ROOT = join(__dirname, '../..');
+const DATA_DIR = join(PROJECT_ROOT, '.monomind', 'data');
+const STORE_PATH = join(DATA_DIR, 'auto-memory-store.json');
+
+// Colors
+const GREEN = '\x1b[0;32m';
+const CYAN = '\x1b[0;36m';
+const DIM = '\x1b[2m';
+const RESET = '\x1b[0m';
+
+const log = (msg) => console.log(`${CYAN}[AutoMemory] ${msg}${RESET}`);
+const success = (msg) => console.log(`${GREEN}[AutoMemory] ✓ ${msg}${RESET}`);
+const dim = (msg) => console.log(`  ${DIM}${msg}${RESET}`);
+
+// Ensure data dir
+if (!existsSync(DATA_DIR)) mkdirSync(DATA_DIR, { recursive: true });
+
+// ============================================================================
+// File-lock helper for concurrent hook coordination
+// Uses O_EXCL exclusive-create as a spin lock.
+// A 10ms synchronous wait (via Atomics.wait) is used between retries to avoid
+// pegging the CPU. Acceptable for low-contention hook processes.
+// ============================================================================
+
+function withFileLock(lockPath, fn, timeoutMs = 5000) {
+  const start = Date.now();
+  const sharedBuf = new Int32Array(new SharedArrayBuffer(4));
+  while (true) {
+    try {
+      // O_EXCL: exclusive create — fails atomically if file already exists
+      const fd = openSync(lockPath, 'wx');
+      closeSync(fd);
+      break; // acquired lock
+    } catch {
+      if (Date.now() - start > timeoutMs) {
+        // Timeout: proceed without lock rather than deadlocking hook processes
+        try { fn(); } catch { /* best effort */ }
+        return;
+      }
+      // Synchronous 10ms sleep via Atomics.wait (avoids busy-spin CPU peg)
+      Atomics.wait(sharedBuf, 0, 0, 10);
+    }
+  }
+  try { fn(); } finally {
+    try { unlinkSync(lockPath); } catch { /* ignore */ }
+  }
+}
+
+// ============================================================================
+// Simple JSON File Backend (implements IMemoryBackend interface)
+// ============================================================================
+
+class JsonFileBackend {
+  constructor(filePath) {
+    this.filePath = filePath;
+    this.entries = new Map();
+  }
+
+  async initialize() {
+    if (existsSync(this.filePath)) {
+      try {
+        const MAX_STORE_BYTES = 50 * 1024 * 1024; // 50 MiB
+        if (statSync(this.filePath).size > MAX_STORE_BYTES) return;
+        const data = JSON.parse(readFileSync(this.filePath, 'utf-8'));
+        if (Array.isArray(data)) {
+          for (const entry of data) this.entries.set(entry.id, entry);
+        }
+      } catch { /* start fresh */ }
+    }
+  }
+
+  async shutdown() { this._persist(); }
+  async store(entry) { this.entries.set(entry.id, entry); this._persist(); }
+  async get(id) { return this.entries.get(id) ?? null; }
+  async getByKey(key, ns) {
+    for (const e of this.entries.values()) {
+      if (e.key === key && (!ns || e.namespace === ns)) return e;
+    }
+    return null;
+  }
+  async update(id, updates) {
+    const e = this.entries.get(id);
+    if (!e) return null;
+    if (updates.metadata) Object.assign(e.metadata, updates.metadata);
+    if (updates.content !== undefined) e.content = updates.content;
+    if (updates.tags) e.tags = updates.tags;
+    e.updatedAt = Date.now();
+    this._persist();
+    return e;
+  }
+  async delete(id) { return this.entries.delete(id); }
+  async query(opts) {
+    let results = [...this.entries.values()];
+    if (opts?.namespace) results = results.filter(e => e.namespace === opts.namespace);
+    if (opts?.type) results = results.filter(e => e.type === opts.type);
+    if (opts?.limit) results = results.slice(0, opts.limit);
+    return results;
+  }
+  async search() { return []; } // No vector search in JSON backend
+  async bulkInsert(entries) { for (const e of entries) this.entries.set(e.id, e); this._persist(); }
+  async bulkDelete(ids) { let n = 0; for (const id of ids) { if (this.entries.delete(id)) n++; } this._persist(); return n; }
+  async count() { return this.entries.size; }
+  async listNamespaces() {
+    const ns = new Set();
+    for (const e of this.entries.values()) ns.add(e.namespace || 'default');
+    return [...ns];
+  }
+  async clearNamespace(ns) {
+    let n = 0;
+    for (const [id, e] of this.entries) {
+      if (e.namespace === ns) { this.entries.delete(id); n++; }
+    }
+    this._persist();
+    return n;
+  }
+  async getStats() {
+    return {
+      totalEntries: this.entries.size,
+      entriesByNamespace: {},
+      entriesByType: { semantic: 0, episodic: 0, procedural: 0, working: 0, cache: 0 },
+      memoryUsage: 0, avgQueryTime: 0, avgSearchTime: 0,
+    };
+  }
+  async healthCheck() {
+    return {
+      status: 'healthy',
+      components: {
+        storage: { status: 'healthy', latency: 0 },
+        index: { status: 'healthy', latency: 0 },
+        cache: { status: 'healthy', latency: 0 },
+      },
+      timestamp: Date.now(), issues: [], recommendations: [],
+    };
+  }
+
+  _persist() {
+    const lockPath = this.filePath + '.lock';
+    withFileLock(lockPath, () => {
+      const data = JSON.stringify([...this.entries.values()], null, 2);
+      const tmpPath = this.filePath + '.tmp';
+      writeFileSync(tmpPath, data, 'utf-8');
+      renameSync(tmpPath, this.filePath);
+    });
+  }
+}
+
+// ============================================================================
+// Resolve memory package path (local dev or npm installed)
+// ============================================================================
+
+async function loadMemoryPackage() {
+  // Strategy 1: Local dev (built dist)
+  const localDist = join(PROJECT_ROOT, 'packages/@monomind/memory/dist/index.js');
+  if (existsSync(localDist)) {
+    try {
+      return await import(`file://${localDist}`);
+    } catch { /* fall through */ }
+  }
+
+  // Strategy 2: Use createRequire for CJS-style resolution (handles nested node_modules
+  // when installed as a transitive dependency via npx monomind / npx monomind)
+  try {
+    const { createRequire } = await import('module');
+    const require = createRequire(join(PROJECT_ROOT, 'package.json'));
+    return require('@monomind/memory');
+  } catch { /* fall through */ }
+
+  // Strategy 3: ESM import (works when @monomind/memory is a direct dependency)
+  try {
+    return await import('@monomind/memory');
+  } catch { /* fall through */ }
+
+  // Strategy 4: Walk up from PROJECT_ROOT looking for @monomind/memory in any node_modules
+  let searchDir = PROJECT_ROOT;
+  const { parse } = await import('path');
+  while (searchDir !== parse(searchDir).root) {
+    const candidate = join(searchDir, 'node_modules', '@monomind', 'memory', 'dist', 'index.js');
+    if (existsSync(candidate)) {
+      try {
+        return await import(`file://${candidate}`);
+      } catch { /* fall through */ }
+    }
+    searchDir = dirname(searchDir);
+  }
+
+  return null;
+}
+
+// ============================================================================
+// Read config from .monomind/config.yaml
+// ============================================================================
+
+function readConfig() {
+  const configPath = join(PROJECT_ROOT, '.monomind', 'config.yaml');
+  const defaults = {
+    learningBridge: { enabled: true, sonaMode: 'balanced', confidenceDecayRate: 0.005, accessBoostAmount: 0.03, consolidationThreshold: 10 },
+    memoryGraph: { enabled: true, pageRankDamping: 0.85, maxNodes: 5000, similarityThreshold: 0.8 },
+    agentScopes: { enabled: true, defaultScope: 'project' },
+  };
+
+  if (!existsSync(configPath)) return defaults;
+
+  try {
+    const MAX_CONFIG_BYTES = 1 * 1024 * 1024; // 1 MiB
+    if (statSync(configPath).size > MAX_CONFIG_BYTES) return defaults;
+    const yaml = readFileSync(configPath, 'utf-8');
+    // Simple YAML parser for the memory section
+    const getBool = (key) => {
+      const match = yaml.match(new RegExp(`${key}:\\s*(true|false)`, 'i'));
+      return match ? match[1] === 'true' : undefined;
+    };
+
+    const lbEnabled = getBool('learningBridge[\\s\\S]*?enabled');
+    if (lbEnabled !== undefined) defaults.learningBridge.enabled = lbEnabled;
+
+    const mgEnabled = getBool('memoryGraph[\\s\\S]*?enabled');
+    if (mgEnabled !== undefined) defaults.memoryGraph.enabled = mgEnabled;
+
+    const asEnabled = getBool('agentScopes[\\s\\S]*?enabled');
+    if (asEnabled !== undefined) defaults.agentScopes.enabled = asEnabled;
+
+    return defaults;
+  } catch {
+    return defaults;
+  }
+}
+
+// ============================================================================
+// Commands
+// ============================================================================
+
+async function doImport() {
+  log('Importing auto memory files into bridge...');
+
+  const memPkg = await loadMemoryPackage();
+  if (!memPkg || !memPkg.AutoMemoryBridge) {
+    dim('Memory package not available — skipping auto memory import');
+    return;
+  }
+
+  const config = readConfig();
+  const backend = new JsonFileBackend(STORE_PATH);
+  await backend.initialize();
+
+  const bridgeConfig = {
+    workingDir: PROJECT_ROOT,
+    syncMode: 'on-session-end',
+  };
+
+  // Wire learning if enabled and available
+  if (config.learningBridge.enabled && memPkg.LearningBridge) {
+    bridgeConfig.learning = {
+      sonaMode: config.learningBridge.sonaMode,
+      confidenceDecayRate: config.learningBridge.confidenceDecayRate,
+      accessBoostAmount: config.learningBridge.accessBoostAmount,
+      consolidationThreshold: config.learningBridge.consolidationThreshold,
+    };
+  }
+
+  // Wire graph if enabled and available
+  if (config.memoryGraph.enabled && memPkg.MemoryGraph) {
+    bridgeConfig.graph = {
+      pageRankDamping: config.memoryGraph.pageRankDamping,
+      maxNodes: config.memoryGraph.maxNodes,
+      similarityThreshold: config.memoryGraph.similarityThreshold,
+    };
+  }
+
+  const bridge = new memPkg.AutoMemoryBridge(backend, bridgeConfig);
+
+  try {
+    const result = await bridge.importFromAutoMemory();
+    success(`Imported ${result.imported} entries (${result.skipped} skipped)`);
+    dim(`├─ Backend entries: ${await backend.count()}`);
+    dim(`├─ Learning: ${config.learningBridge.enabled ? 'active' : 'disabled'}`);
+    dim(`├─ Graph: ${config.memoryGraph.enabled ? 'active' : 'disabled'}`);
+    dim(`└─ Agent scopes: ${config.agentScopes.enabled ? 'active' : 'disabled'}`);
+  } catch (err) {
+    dim(`Import failed (non-critical): ${err.message}`);
+  }
+
+  await backend.shutdown();
+}
+
+async function doSync() {
+  log('Syncing insights to auto memory files...');
+
+  const memPkg = await loadMemoryPackage();
+  if (!memPkg || !memPkg.AutoMemoryBridge) {
+    dim('Memory package not available — skipping sync');
+    return;
+  }
+
+  const config = readConfig();
+  const backend = new JsonFileBackend(STORE_PATH);
+  await backend.initialize();
+
+  const entryCount = await backend.count();
+  if (entryCount === 0) {
+    dim('No entries to sync');
+    await backend.shutdown();
+    return;
+  }
+
+  const bridgeConfig = {
+    workingDir: PROJECT_ROOT,
+    syncMode: 'on-session-end',
+  };
+
+  if (config.learningBridge.enabled && memPkg.LearningBridge) {
+    bridgeConfig.learning = {
+      sonaMode: config.learningBridge.sonaMode,
+      confidenceDecayRate: config.learningBridge.confidenceDecayRate,
+      consolidationThreshold: config.learningBridge.consolidationThreshold,
+    };
+  }
+
+  if (config.memoryGraph.enabled && memPkg.MemoryGraph) {
+    bridgeConfig.graph = {
+      pageRankDamping: config.memoryGraph.pageRankDamping,
+      maxNodes: config.memoryGraph.maxNodes,
+    };
+  }
+
+  const bridge = new memPkg.AutoMemoryBridge(backend, bridgeConfig);
+
+  try {
+    const syncResult = await bridge.syncToAutoMemory();
+    success(`Synced ${syncResult.synced} entries to auto memory`);
+    dim(`├─ Categories updated: ${syncResult.categories?.join(', ') || 'none'}`);
+    dim(`└─ Backend entries: ${entryCount}`);
+
+    // Curate MEMORY.md index with graph-aware ordering
+    await bridge.curateIndex();
+    success('Curated MEMORY.md index');
+  } catch (err) {
+    dim(`Sync failed (non-critical): ${err.message}`);
+  }
+
+  if (bridge.destroy) bridge.destroy();
+  await backend.shutdown();
+}
+
+async function doStatus() {
+  const memPkg = await loadMemoryPackage();
+  const config = readConfig();
+
+  console.log('\n=== Auto Memory Bridge Status ===\n');
+  console.log(`  Package:        ${memPkg ? '✅ Available' : '❌ Not found'}`);
+  console.log(`  Store:          ${existsSync(STORE_PATH) ? '✅ ' + STORE_PATH : '⏸ Not initialized'}`);
+  console.log(`  LearningBridge: ${config.learningBridge.enabled ? '✅ Enabled' : '⏸ Disabled'}`);
+  console.log(`  MemoryGraph:    ${config.memoryGraph.enabled ? '✅ Enabled' : '⏸ Disabled'}`);
+  console.log(`  AgentScopes:    ${config.agentScopes.enabled ? '✅ Enabled' : '⏸ Disabled'}`);
+
+  if (existsSync(STORE_PATH)) {
+    try {
+      const MAX_STORE_BYTES = 50 * 1024 * 1024; // 50 MiB
+      if (statSync(STORE_PATH).size <= MAX_STORE_BYTES) {
+        const data = JSON.parse(readFileSync(STORE_PATH, 'utf-8'));
+        console.log(`  Entries:        ${Array.isArray(data) ? data.length : 0}`);
+      } else {
+        console.log(`  Entries:        (store too large to count)`);
+      }
+    } catch { /* ignore */ }
+  }
+
+  console.log('');
+}
+
+// ============================================================================
+// Main
+// ============================================================================
+
+const command = process.argv[2] || 'status';
+
+// Suppress unhandled rejection warnings from dynamic import() failures
+// which can cause non-zero exit codes even when caught
+process.once('unhandledRejection', () => {});
+
+try {
+  switch (command) {
+    case 'import': await doImport(); break;
+    case 'sync': await doSync(); break;
+    case 'status': await doStatus(); break;
+    default:
+      console.log('Usage: auto-memory-hook.mjs <import|sync|status>');
+      process.exit(1);
+  }
+} catch (err) {
+  // Hooks must never crash Claude Code - fail silently
+  dim(`Error (non-critical): ${err.message}`);
+}
+// Ensure clean exit for Claude Code hooks (exit 0 = success, no stderr = no error)
+process.exit(0);

package/packages/@monomind/cli/.claude/helpers/control-start.cjs

@@ -0,0 +1,155 @@
+#!/usr/bin/env node
+/**
+ * Monomind Control Start
+ * Ensures the Monomind Neural Control Room (web UI) is running.
+ * Called from SessionStart hook — exits immediately after spawning.
+ *
+ * Status written to: .monomind/control.json
+ * Port: 4242 (default, auto-increments on collision)
+ */
+
+/* eslint-disable @typescript-eslint/no-var-requires */
+const fs = require('fs');
+const path = require('path');
+const { spawn } = require('child_process');
+
+const CWD = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+const STATUS_FILE = path.join(CWD, '.monomind', 'control.json');
+const DEFAULT_PORT = 4242;
+
+function readStatus() {
+  try {
+    if (fs.existsSync(STATUS_FILE)) {
+      // Guard against OOM: control.json should never exceed 4 KiB
+      const stat = fs.statSync(STATUS_FILE);
+      if (stat.size > 4 * 1024) return null;
+      return JSON.parse(fs.readFileSync(STATUS_FILE, 'utf-8'));
+    }
+  } catch { /* ignore */ }
+  return null;
+}
+
+function isPidAlive(pid) {
+  // Validate pid is a positive integer — negative or zero pid would signal the process group
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function writeStatus(pid, port) {
+  try {
+    fs.mkdirSync(path.dirname(STATUS_FILE), { recursive: true });
+    fs.writeFileSync(STATUS_FILE, JSON.stringify({
+      pid,
+      port,
+      url: `http://localhost:${port}`,
+      startedAt: new Date().toISOString(),
+    }), 'utf-8');
+  } catch { /* ignore */ }
+}
+
+function findCliPath() {
+  // Try local monorepo server.mjs first (direct — no CLI subcommand needed)
+  const serverMjs = path.join(CWD, 'packages', '@monomind', 'cli', 'dist', 'src', 'ui', 'server.mjs');
+  if (fs.existsSync(serverMjs)) return { cmd: process.execPath, args: [serverMjs], usePort: true };
+
+  // Try local CLI bin as fallback
+  const local = path.join(CWD, 'packages', '@monomind', 'cli', 'bin', 'cli.js');
+  if (fs.existsSync(local)) return { cmd: process.execPath, args: [local], usePort: false };
+
+  // Try global npm install paths for both package names
+  // npm root -g is slow; probe known conventional paths instead
+  const globalCandidates = [];
+  try {
+    const { execSync } = require('child_process');
+    const npmRoot = execSync('npm root -g', { timeout: 3000, encoding: 'utf-8' }).trim();
+    if (npmRoot) {
+      globalCandidates.push(
+        path.join(npmRoot, 'monomind', 'packages', '@monomind', 'cli', 'dist', 'src', 'ui', 'server.mjs'),
+        path.join(npmRoot, '@monoes', 'monomindcli', 'dist', 'src', 'ui', 'server.mjs'),
+        path.join(npmRoot, 'monomind', 'packages', '@monomind', 'cli', 'bin', 'cli.js'),
+        path.join(npmRoot, '@monoes', 'monomindcli', 'bin', 'cli.js'),
+      );
+    }
+  } catch { /* npm root -g failed — skip */ }
+
+  for (const candidate of globalCandidates) {
+    if (fs.existsSync(candidate)) {
+      const usePort = candidate.endsWith('server.mjs');
+      return { cmd: process.execPath, args: [candidate], usePort };
+    }
+  }
+
+  // Try npx monomind as last resort
+  return { cmd: 'npx', args: ['monomind@latest'], usePort: false };
+}
+
+function main() {
+  // If already running, do nothing
+  const status = readStatus();
+  if (status && status.pid && isPidAlive(status.pid)) {
+    process.stdout.write(`[control] already running on port ${status.port} (pid ${status.pid})\n`);
+    process.exit(0);
+  }
+
+  const { cmd, args, usePort } = findCliPath();
+  // server.mjs accepts port as second positional arg; CLI uses 'ui --no-open --port N'
+  const allArgs = usePort
+    ? [...args, String(DEFAULT_PORT)]
+    : [...args, 'ui', '--no-open', '--port', String(DEFAULT_PORT)];
+
+  const child = spawn(cmd, allArgs, {
+    detached: true,
+    stdio: 'ignore',
+    cwd: CWD,
+    env: { ...process.env, CLAUDE_PROJECT_DIR: CWD },
+  });
+
+  child.unref();
+
+  // Write optimistic status with DEFAULT_PORT immediately so dependent scripts
+  // (hooks, boss agents) have something to read while the server starts up.
+  writeStatus(child.pid, DEFAULT_PORT);
+  process.stdout.write(`[control] started Neural Control Room on port ${DEFAULT_PORT} (pid ${child.pid})\n`);
+
+  // If port 4242 was in use, server.mjs auto-increments (up to +10).
+  // Poll a few ports to find where it actually bound and update control.json.
+  const http = require('http');
+  function probePort(p) {
+    return new Promise((resolve) => {
+      const req = http.get({ hostname: 'localhost', port: p, path: '/api/status', timeout: 1000 }, (res) => {
+        res.resume();
+        resolve(res.statusCode < 500);
+      });
+      req.on('error', () => resolve(false));
+      req.on('timeout', () => { req.destroy(); resolve(false); });
+    });
+  }
+
+  // Give the server up to ~3 s to start, then confirm the actual port.
+  async function confirmPort() {
+    for (let attempt = 0; attempt < 6; attempt++) {
+      await new Promise(r => setTimeout(r, 500));
+      for (let delta = 0; delta <= 10; delta++) {
+        const p = DEFAULT_PORT + delta;
+        if (await probePort(p)) {
+          if (p !== DEFAULT_PORT) {
+            writeStatus(child.pid, p);
+            process.stdout.write(`[control] server bound to port ${p} (updated control.json)\n`);
+          }
+          return;
+        }
+      }
+    }
+    // Server didn't respond in time — leave control.json as-is (best-effort)
+    process.stdout.write('[control] server did not respond within 3 s — control.json may have wrong port\n');
+  }
+
+  confirmPort().catch(() => {}).finally(() => process.exit(0));
+}
+
+main();