monomind 1.16.6 → 1.16.8

package/packages/@monomind/cli/.claude/helpers/graphify-freshen.cjs

@@ -0,0 +1,115 @@
+'use strict';
+// Runs at SessionStart — rebuilds the knowledge graph using @monoes/monograph in the background.
+// Fire-and-forget: spawns detached child, logs start, exits immediately without blocking session.
+const path = require('path');
+const fs = require('fs');
+const { spawn } = require('child_process');
+const { pathToFileURL } = require('url');
+
+const projectDir = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+const graphDir = path.join(projectDir, '.monomind', 'graph');
+fs.mkdirSync(graphDir, { recursive: true });
+
+const logPath = path.join(graphDir, 'build.log');
+let logFd;
+try { logFd = fs.openSync(logPath, 'a'); } catch { logFd = 'ignore'; }
+
+// Resolve the monograph entry point — searches several common layouts
+function resolveMonographEntry(dir) {
+  // pnpm virtual store — the reliable pre-built copy not affected by workspace symlinks
+  const pnpmStore = (() => {
+    try {
+      const storeBase = path.join(dir, 'node_modules', '.pnpm');
+      if (!fs.existsSync(storeBase)) return null;
+      const entries = fs.readdirSync(storeBase).filter(e => e.startsWith('@monoes+monograph@'));
+      for (const e of entries.sort().reverse()) { // newest version first
+        const p = path.join(storeBase, e, 'node_modules', '@monoes', 'monograph', 'dist', 'src', 'index.js');
+        if (fs.existsSync(p)) return p;
+      }
+    } catch {}
+    return null;
+  })();
+
+  // Global npm installation (covers `npm install -g @monomind/cli` and homebrew installs)
+  const globalNpmMonograph = (() => {
+    try {
+      const { execSync } = require('child_process');
+      const globalRoot = execSync('npm root -g', { encoding: 'utf-8', timeout: 5000 }).trim();
+      const p = path.join(globalRoot, '@monoes', 'monograph', 'dist', 'src', 'index.js');
+      return p;
+    } catch { return null; }
+  })();
+
+  const candidates = [
+    // pnpm store version (most reliable — pre-built, isolated from workspace source changes)
+    pnpmStore,
+    // Global npm / homebrew install of @monomind/cli (most common for npx/global users)
+    globalNpmMonograph,
+    // Monorepo: monomind root is the monograph package
+    path.join(dir, 'dist', 'src', 'index.js'),
+    // Monorepo: monograph lives under packages/@monomind/monograph (pnpm workspace)
+    path.join(dir, 'packages', '@monomind', 'monograph', 'dist', 'src', 'index.js'),
+    // Installed as a flat dependency
+    path.join(dir, 'node_modules', '@monoes', 'monograph', 'dist', 'src', 'index.js'),
+    path.join(dir, 'node_modules', '@monomind', 'monograph', 'dist', 'src', 'index.js'),
+  ].filter(Boolean);
+  for (const c of candidates) {
+    if (fs.existsSync(c)) return c;
+  }
+  return null;
+}
+
+const entryPoint = resolveMonographEntry(projectDir);
+if (!entryPoint) {
+  console.error('[graph] @monoes/monograph not found — skipping build');
+  process.exit(0);
+}
+
+// Skip if another build is already in progress (avoids SQLite BUSY on concurrent init + session-start)
+const lockPath = path.join(graphDir, 'build.lock');
+const now = Date.now();
+try {
+  const stat = fs.statSync(lockPath);
+  // Stale lock older than 5 minutes — remove it and proceed
+  if (now - stat.mtimeMs < 5 * 60 * 1000) {
+    console.log('[graph] build already in progress — skipping');
+    process.exit(0);
+  }
+  fs.unlinkSync(lockPath);
+} catch { /* lock does not exist — proceed */ }
+
+// Write lock file; the build process removes it on completion
+try { fs.writeFileSync(lockPath, String(process.pid)); } catch { /* non-fatal */ }
+
+// Spawn a detached node process to run buildAsync from @monoes/monograph (ESM).
+// After the build, VACUUM the DB if it has >50% bloat (reclaim space from
+// delete/insert churn; opens are ~5x faster on a tight DB).
+const dbPathStr = JSON.stringify(path.join(projectDir, '.monomind', 'monograph.db'));
+const script = `
+import { buildAsync } from ${JSON.stringify(pathToFileURL(entryPoint).href)};
+import { unlinkSync, statSync } from 'fs';
+import { execSync } from 'child_process';
+try {
+  await buildAsync(${JSON.stringify(projectDir)});
+  // Vacuum if bloat ratio is high — keeps openDb fast over time.
+  try {
+    const dbPath = ${dbPathStr};
+    const fileMB = statSync(dbPath).size / 1024 / 1024;
+    const liveMB = parseInt(
+      execSync('sqlite3 "' + dbPath + '" "SELECT SUM(pgsize)/1024/1024 FROM dbstat;"',
+        { encoding: 'utf-8' }).trim(), 10);
+    if (fileMB > 100 && liveMB / fileMB < 0.5) {
+      execSync('sqlite3 "' + dbPath + '" "VACUUM;"', { timeout: 120000 });
+    }
+  } catch (_) {}
+} finally {
+  try { unlinkSync(${JSON.stringify(lockPath)}); } catch {}
+}`;
+const child = spawn(process.execPath, ['--input-type=module', '--eval', script], {
+  detached: true,
+  stdio: ['ignore', logFd, logFd],
+  cwd: projectDir,
+});
+child.unref();
+
+console.log('[graph] background build started for ' + projectDir);

package/packages/@monomind/cli/.claude/helpers/handlers/adr-draft-handler.cjs

@@ -0,0 +1,78 @@
+'use strict';
+// Extracted from hook-handler.cjs — handles 'adr-draft' command.
+// Drafts an ADR from accumulated decision markers in .monomind/decisions.jsonl.
+// Receives hCtx from dispatcher. See route-handler.cjs for hCtx field docs.
+
+const path = require('path');
+const fs = require('fs');
+
+module.exports = {
+  handle: function(hCtx) {
+    var CWD = hCtx.CWD;
+
+    var jsonl = path.join(CWD, '.monomind', 'decisions.jsonl');
+    if (!fs.existsSync(jsonl)) {
+      console.log('[ADR] No decisions recorded yet. Type prompts containing markers like "let\'s go with X", "we chose Y", "decision: Z" to populate the log.');
+      return;
+    }
+    var MAX_JSONL = 512 * 1024; // 512 KiB
+    try { if (fs.statSync(jsonl).size > MAX_JSONL) { console.error('[ADR] decisions.jsonl exceeds 512 KiB — skipping to prevent OOM'); return; } } catch (_) { return; }
+    var lines = fs.readFileSync(jsonl, 'utf-8').trim().split('\n').filter(Boolean);
+    if (lines.length === 0) {
+      console.log('[ADR] decisions.jsonl is empty.');
+      return;
+    }
+    // Group decisions captured in the last 7 days.
+    var cutoff = Date.now() - 7 * 24 * 60 * 60 * 1000;
+    var MAX_RECORDS = 200;
+    var recent = lines
+      .map(function(l) { try { return JSON.parse(l); } catch (_) { return null; } })
+      .filter(function(d) { return d && d.ts >= cutoff; })
+      .slice(0, MAX_RECORDS);
+    if (recent.length === 0) {
+      console.log('[ADR] No decisions in the last 7 days. Older entries: ' + lines.length + '.');
+      return;
+    }
+
+    var adrsDir = path.resolve(CWD, 'docs', 'adrs');
+    if (!adrsDir.startsWith(path.resolve(CWD) + path.sep) && adrsDir !== path.resolve(CWD)) {
+      console.error('[ADR] adrsDir resolved outside CWD — aborting'); return;
+    }
+    try { fs.mkdirSync(adrsDir, { recursive: true }); } catch (_) {}
+    // Use lstatSync to avoid following symlinks when listing existing ADRs
+    var existing = [];
+    try {
+      existing = fs.readdirSync(adrsDir).filter(function(f) {
+        if (!/^ADR-\d{4}/.test(f)) return false;
+        try { var st = fs.lstatSync(path.join(adrsDir, f)); return st.isFile(); } catch (_) { return false; }
+      });
+    } catch (_) {}
+    var nextNum = existing.length + 1;
+    var num = String(nextNum).padStart(4, '0');
+    var stamp = new Date().toISOString().slice(0, 10);
+    var fname = 'ADR-' + num + '-' + stamp + '-session-decisions.md';
+    var outPath = path.join(adrsDir, fname);
+
+    var body = '# ADR-' + num + ': Session decisions (' + stamp + ')\n\n' +
+               '**Status:** Proposed\n**Date:** ' + stamp + '\n\n' +
+               '## Context\n\n' +
+               'During recent sessions, the following decision markers were captured ' +
+               'from user prompts. Each excerpt is the surrounding sentence at the time.\n\n' +
+               '## Decisions\n\n';
+    for (var i = 0; i < recent.length; i++) {
+      var d = recent[i];
+      var date = new Date(d.ts).toISOString().slice(0, 16).replace('T', ' ');
+      body += '### ' + (i + 1) + '. ' + date + '\n\n';
+      var excerpts = Array.isArray(d.excerpts) ? d.excerpts.slice(0, 20) : [];
+      for (var j = 0; j < excerpts.length; j++) {
+        body += '> ' + String(excerpts[j]).slice(0, 500).trim() + '\n\n';
+      }
+      if (d.prompt) body += '_Prompt:_ ' + d.prompt.slice(0, 200) + (d.prompt.length > 200 ? '…' : '') + '\n\n';
+    }
+    body += '## Consequences\n\n_(fill in after review)_\n\n' +
+            '## Status\n\nProposed — awaiting human review and refinement.\n';
+    fs.writeFileSync(outPath, body);
+    console.log('[ADR_DRAFT] Wrote ' + recent.length + ' decision(s) to ' + outPath);
+    console.log('  Edit the file to fill in Context and Consequences, then change Status to Accepted/Rejected.');
+  },
+};

package/packages/@monomind/cli/.claude/helpers/handlers/agent-start-handler.cjs

@@ -0,0 +1,108 @@
+'use strict';
+// Extracted from hook-handler.cjs — handles 'agent-start' (SubagentStart) hook event.
+// Receives hCtx from dispatcher. See route-handler.cjs for hCtx field docs.
+
+const path = require('path');
+const fs = require('fs');
+
+module.exports = {
+  handle: function(hCtx) {
+    var hookInput = hCtx.hookInput;
+    var CWD = hCtx.CWD;
+    var _openMonographDb = hCtx._openMonographDb;
+    var getMonographSuggestions = hCtx.getMonographSuggestions;
+
+    // Register this agent so the statusline can count active agents.
+    const regDir = path.join(CWD, '.monomind', 'agents', 'registrations');
+    try {
+      fs.mkdirSync(regDir, { recursive: true });
+      const id = Date.now() + '-' + Math.random().toString(36).slice(2, 6);
+      const regFile = path.join(regDir, 'agent-' + id + '.json');
+      fs.writeFileSync(regFile, JSON.stringify({
+        agentId: id,
+        startedAt: new Date().toISOString(),
+        pid: process.pid,
+      }));
+      // Refresh swarm-activity.json within the 5-min staleness window.
+      const activityDir = path.join(CWD, '.monomind', 'metrics');
+      fs.mkdirSync(activityDir, { recursive: true });
+      const activityPath = path.join(activityDir, 'swarm-activity.json');
+      const MAX_AGENTS = 1000;
+      const active = Math.min(fs.readdirSync(regDir).filter(f => f.endsWith('.json')).length, MAX_AGENTS);
+      // Preserve lastActive (peak) so statusline shows non-zero after completion.
+      let prevLastActive = 0;
+      try {
+        const MAX_ACTIVITY = 64 * 1024; // 64 KiB
+        var actStat = fs.statSync(activityPath);
+        if (actStat.size <= MAX_ACTIVITY) {
+          prevLastActive = (JSON.parse(fs.readFileSync(activityPath, 'utf-8'))?.swarm?.lastActive) || 0;
+        }
+      } catch { /* ignore */ }
+      fs.writeFileSync(activityPath, JSON.stringify({
+        timestamp: new Date().toISOString(),
+        swarm: {
+          active: active > 0,
+          agent_count: active,
+          coordination_active: active > 0,
+          lastActive: Math.max(active, prevLastActive),
+        },
+      }));
+
+      // Write last-dispatch.json so the route handler can suppress redundant
+      // suggestions on the next turn when the same agent type is recommended.
+      const MAX_TYPE_LEN = 128;
+      const MAX_DESC_LEN = 500;
+      const agentType = String(hookInput.subagent_type || hookInput.agentType || hookInput.agent_type || hookInput.agentSlug || 'unknown').slice(0, MAX_TYPE_LEN);
+      const agentDesc = String(hookInput.description || hookInput.prompt_description || '').slice(0, MAX_DESC_LEN);
+      fs.writeFileSync(
+        path.join(CWD, '.monomind', 'last-dispatch.json'),
+        JSON.stringify({
+          agentType: agentType,
+          description: agentDesc.substring(0, 120),
+          dispatchedAt: new Date().toISOString(),
+        }),
+        'utf-8'
+      );
+    } catch (e) { /* non-fatal — never block a subagent from starting */ }
+
+    // Subagent context inheritance — inject graph god nodes + parent's last
+    // pre-resolved suggestions so the spawned agent inherits spatial map.
+    try {
+      var subDb = _openMonographDb();
+      if (subDb) {
+        try {
+          var godRows = subDb.prepare(
+            "SELECT n.name, n.label, n.file_path AS file, " +
+            "(SELECT COUNT(*) FROM edges WHERE source_id=n.id OR target_id=n.id) AS deg " +
+            "FROM nodes n " +
+            "WHERE n.label NOT IN ('Concept') AND n.file_path IS NOT NULL AND n.file_path != '' " +
+            "ORDER BY deg DESC LIMIT 5"
+          ).all();
+          if (godRows.length > 0) {
+            console.log('[MONOGRAPH_SUBAGENT_CTX] Graph map inherited from parent:');
+            for (var gi = 0; gi < godRows.length; gi++) {
+              var gr = godRows[gi];
+              console.log('  · ' + gr.name + ' [' + gr.label + '] — ' + (gr.file || '') + ' (deg ' + gr.deg + ')');
+            }
+            try {
+              var subAgentDesc = hookInput.description || hookInput.prompt_description || '';
+              if (subAgentDesc && subAgentDesc.length > 8) {
+                var subHints = getMonographSuggestions(subAgentDesc, 3);
+                if (subHints.length > 0) {
+                  console.log('  Top files for this subagent task:');
+                  for (var si2 = 0; si2 < subHints.length; si2++) {
+                    var sh = subHints[si2];
+                    console.log('    · ' + sh.name + ' [' + sh.label + '] — ' + (sh.file || ''));
+                  }
+                }
+              }
+            } catch (_) {}
+            console.log('  Use mcp__monomind__monograph_suggest / monograph_query in this subagent before grepping.');
+          }
+        } catch (e) { /* non-fatal */ }
+      }
+    } catch (e) { /* non-fatal */ }
+
+    console.log('[OK] Agent registered');
+  },
+};

package/packages/@monomind/cli/.claude/helpers/handlers/budget-status-handler.cjs

@@ -0,0 +1,14 @@
+'use strict';
+// Extracted from hook-handler.cjs — handles 'budget-status' command.
+
+module.exports = {
+  handle: function(hCtx) {
+    var _getBudgetStatus = hCtx._getBudgetStatus;
+    var b = _getBudgetStatus();
+    if (!b) { console.log('No budget data yet — token tracking not initialized.'); return; }
+    console.log('Today:   $' + b.todayCost.toFixed(2) + ' / $' + b.dailyLimit  + ' (' + b.dailyPct  + '%)' + (b.autoTuned ? ' [auto-tuned]' : ''));
+    console.log('Month:   $' + b.monthCost.toFixed(2) + ' / $' + b.monthlyLimit + ' (' + b.monthlyPct + '%)');
+    console.log('Status:  ' + (b.breached ? 'BREACHED' : b.spike ? 'SPIKE' : b.alert ? 'ALERT' : 'OK'));
+    console.log('Edit .monomind/budget.json to adjust. Delete to re-tune.');
+  },
+};