@monoes/monomindcli 1.6.8 → 1.7.0

package/.claude/helpers/graphify-freshen.cjs

@@ -1,118 +1,33 @@
 'use strict';
-// Runs at SessionStart — rebuilds the knowledge graph for the current project in the background.
+// Runs at SessionStart — rebuilds the knowledge graph using graphify (Python) 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, execSync } = require('child_process');
 
 const projectDir = process.env.CLAUDE_PROJECT_DIR || process.cwd();
 const graphDir = path.join(projectDir, '.monomind', 'graph');
-const statsFile = path.join(graphDir, 'stats.json');
 
-// Locate @monomind/graph — check local, global npm, bundled-graph, pnpm
-function findGraphPkg(base) {
-  const candidates = [
-    path.join(base, 'node_modules', '@monomind', 'graph', 'dist', 'src', 'index.js'),
-    path.join(base, 'packages', '@monomind', 'cli', 'node_modules', '@monomind', 'graph', 'dist', 'src', 'index.js'),
-    path.join(base, 'packages', '@monomind', 'graph', 'dist', 'src', 'index.js'),
-  ];
-  // Check global npm install paths (monomind umbrella ships bundled-graph)
-  try {
-    const globalRoot = require('child_process').execSync('npm root -g', { encoding: 'utf-8' }).trim();
-    candidates.push(
-      path.join(globalRoot, 'monomind', 'packages', '@monomind', 'cli', 'bundled-graph', 'dist', 'src', 'index.js'),
-      path.join(globalRoot, 'monomind', 'node_modules', '@monoes', 'monomindcli', 'bundled-graph', 'dist', 'src', 'index.js'),
-    );
-  } catch {}
-  for (const c of candidates) {
-    if (fs.existsSync(c)) return c;
-  }
-  // pnpm: glob for @monomind+graph in .pnpm
-  const pnpmDir = path.join(base, 'node_modules', '.pnpm');
-  if (fs.existsSync(pnpmDir)) {
-    for (const entry of fs.readdirSync(pnpmDir)) {
-      if (entry.startsWith('@monomind+graph')) {
-        const p = path.join(pnpmDir, entry, 'node_modules', '@monomind', 'graph', 'dist', 'src', 'index.js');
-        if (fs.existsSync(p)) return p;
-      }
-    }
-  }
-  return null;
-}
-
-const graphPkg = findGraphPkg(projectDir);
-
-if (!graphPkg) {
-  console.log('[graph] skip: @monomind/graph not found');
+// Check if graphify CLI is available
+try {
+  execSync('graphify --help', { encoding: 'utf-8', stdio: 'ignore' });
+} catch {
+  console.log('[graph] skip: graphify not installed (run: uv tool install graphifyy)');
   process.exit(0);
 }
 
 fs.mkdirSync(graphDir, { recursive: true });
 
-// Locate the enricher script — works for both monorepo layout and npm-install layout
-const enricherCandidates = [
-  path.join(projectDir, 'packages', '@monomind', 'cli', 'dist', 'src', 'graph', 'enrich.mjs'),
-  path.join(projectDir, 'node_modules', '@monomind', 'cli', 'dist', 'src', 'graph', 'enrich.mjs'),
-];
-const enricherPath = enricherCandidates.find(p => fs.existsSync(p)) ?? null;
-const hasEnricher = enricherPath !== null;
-
-const { spawn } = require('child_process');
-const script = [
-  `import { buildGraph } from ${JSON.stringify('file://' + graphPkg)};`,
-  `import fs from 'fs';`,
-  `import path from 'path';`,
-  `const projectDir = ${JSON.stringify(projectDir)};`,
-  `const graphDir = ${JSON.stringify(graphDir)};`,
-  `const statsFile = ${JSON.stringify(statsFile)};`,
-  `buildGraph(projectDir, { codeOnly: true, outputDir: graphDir })`,
-  `.then(async r => {`,
-  `  fs.writeFileSync(statsFile, JSON.stringify({ nodes: r.analysis?.stats?.nodes, edges: r.analysis?.stats?.edges, files: r.filesProcessed, builtAt: Date.now() }));`,
-  `  console.log('[graph] built: ' + r.filesProcessed + ' files, ' + (r.analysis?.stats?.nodes ?? '?') + ' nodes');`,
-  hasEnricher ? [
-    `  try {`,
-    `    const { enrichGraph } = await import(${JSON.stringify('file://' + enricherPath)});`,
-    `    const er = await enrichGraph(projectDir, { graphDir });`,
-    `    console.log('[graph] enriched: ' + er.metrics.enrichedNodes + '/' + er.metrics.totalNodes + ' nodes');`,
-    `  } catch (ee) { console.error('[graph] enrichment failed:', ee.message); }`,
-  ].join('\n') : '',
-  // Normalize graph.json: add snake_case field aliases expected by the MCP tools
-  `  try {`,
-  `    const graphPath = path.join(graphDir, 'graph.json');`,
-  `    const raw = JSON.parse(fs.readFileSync(graphPath, 'utf-8'));`,
-  `    if (Array.isArray(raw.nodes)) {`,
-  `      for (const n of raw.nodes) {`,
-  `        n.source_file = n.sourceFile || '';`,
-  `        n.source_location = n.sourceLocation || '';`,
-  `        n.file_type = n.fileType || '';`,
-  `        // Zero out degree for external symbols so they don't dominate god_nodes results`,
-  `        if (!n.source_file) n.degree = 0;`,
-  `      }`,
-  `      fs.writeFileSync(graphPath, JSON.stringify(raw));`,
-  `      console.log('[graph] normalized: added MCP field aliases to ' + raw.nodes.length + ' nodes');`,
-  `    }`,
-  `  } catch (ne) { console.error('[graph] normalize failed:', ne.message); }`,
-  // Ensure .monomind/graph symlink exists so the MCP server can locate the graph
-  `  try {`,
-  `    const monomindDir = path.join(projectDir, '.monomind');`,
-  `    fs.mkdirSync(monomindDir, { recursive: true });`,
-  `    const symlinkTarget = path.join(monomindDir, 'graph');`,
-  `    let exists = false;`,
-  `    try { fs.lstatSync(symlinkTarget); exists = true; } catch {}`,
-  `    if (!exists) { fs.symlinkSync(graphDir, symlinkTarget); console.log('[graph] created .monomind/graph symlink'); }`,
-  `  } catch (se) { console.error('[graph] symlink setup failed:', se.message); }`,
-  `})`,
-  `.catch(e => console.error('[graph] build failed:', e.message));`,
-].join('\n');
-
 const logPath = path.join(graphDir, 'build.log');
 let logFd;
 try { logFd = fs.openSync(logPath, 'a'); } catch { logFd = 'ignore'; }
-const child = spawn(process.execPath, ['--input-type=module'], {
+
+// graphify update <path> — re-extracts code files and rebuilds graph.json
+const child = spawn('graphify', ['update', projectDir], {
   detached: true,
-  stdio: ['pipe', logFd, logFd],
+  stdio: ['ignore', logFd, logFd],
+  cwd: projectDir,
 });
-child.stdin.write(script);
-child.stdin.end();
 child.unref();
 
 console.log('[graph] background build started for ' + projectDir);

package/.claude/helpers/hook-handler.cjs

@@ -961,6 +961,22 @@ const handlers = {
       }
     } catch (e) { /* non-fatal */ }
 
+    // ── Monomind Control UI Status ────────────────────────────────────────
+    try {
+      var http = require('http');
+      var controlPort = 4242;
+      var req = http.get('http://localhost:' + controlPort + '/', function(res) {
+        if (res.statusCode === 200) {
+          console.log('[CONTROL_UI] UP — http://localhost:' + controlPort);
+        }
+        res.resume();
+      });
+      req.on('error', function() {
+        console.log('[CONTROL_UI] offline — run: npx monomind mcp start');
+      });
+      req.setTimeout(800, function() { req.destroy(); });
+    } catch (e) { /* non-fatal */ }
+
     // ── Worker Queue Resume (SR-003) ────────────────────────────────────
     try {
       var dispatchDir = path.join(CWD, '.monomind', 'worker-dispatch');

package/.claude/helpers/statusline.cjs

@@ -104,6 +104,18 @@ function safeStat(filePath) {
   return null;
 }
 
+// Project identifier — github owner/repo from git remote, else folder name
+function getProjectName() {
+  try {
+    const remote = safeExec('git remote get-url origin 2>/dev/null', 2000).trim();
+    if (remote) {
+      const m = remote.match(/[/:]([\w.-]+)\/([\w.-]+?)(?:\.git)?$/);
+      if (m) return `${m[1]}/${m[2]}`;
+    }
+  } catch { /* ignore */ }
+  return path.basename(CWD);
+}
+
 // Shared settings cache — read once, used by multiple functions
 let _settingsCache = undefined;
 function getSettings() {
@@ -565,37 +577,56 @@ function getAgentDBStats() {
   let namespaces = 0;
   let hasHnsw = false;
 
-  // 0. PRIMARY: Count drawers from Memory Palace (this is where memories actually live)
+  // Count all memory entries across sources (sum, not max)
+  // 0. Palace drawers
   const drawersPath = path.join(CWD, '.monomind', 'palace', 'drawers.jsonl');
   const drawersStat = safeStat(drawersPath);
   if (drawersStat) {
     dbSizeKB += drawersStat.size / 1024;
     try {
-      const lines = fs.readFileSync(drawersPath, 'utf-8').split('\n').filter(Boolean);
-      if (lines.length > vectorCount) vectorCount = lines.length;
+      vectorCount += fs.readFileSync(drawersPath, 'utf-8').split('\n').filter(Boolean).length;
+    } catch { /* ignore */ }
+  }
+
+  // 1. Palace closets
+  const closetsPath = path.join(CWD, '.monomind', 'palace', 'closets.jsonl');
+  const closetsStat = safeStat(closetsPath);
+  if (closetsStat) {
+    dbSizeKB += closetsStat.size / 1024;
+    try {
+      vectorCount += fs.readFileSync(closetsPath, 'utf-8').split('\n').filter(Boolean).length;
     } catch { /* ignore */ }
   }
 
-  // 1. Count real entries from auto-memory-store.json (intelligence layer)
+  // 2. Knowledge chunks
+  const chunksPath = path.join(CWD, '.monomind', 'knowledge', 'chunks.jsonl');
+  const chunksStat = safeStat(chunksPath);
+  if (chunksStat) {
+    dbSizeKB += chunksStat.size / 1024;
+    try {
+      vectorCount += fs.readFileSync(chunksPath, 'utf-8').split('\n').filter(Boolean).length;
+    } catch { /* ignore */ }
+  }
+
+  // 3. Auto-memory store (intelligence layer)
   const storePath = path.join(CWD, '.monomind', 'data', 'auto-memory-store.json');
   const storeStat = safeStat(storePath);
   if (storeStat) {
     dbSizeKB += storeStat.size / 1024;
     try {
       const store = JSON.parse(fs.readFileSync(storePath, 'utf-8'));
-      const storeCount = Array.isArray(store) ? store.length : (store?.entries?.length || 0);
-      if (storeCount > vectorCount) vectorCount = storeCount;
-    } catch { /* fall back to size estimate */ }
+      vectorCount += Array.isArray(store) ? store.length : (store?.entries?.length || 0);
+    } catch { /* ignore */ }
   }
 
-  // 2. Count entries from ranked-context.json
+  // 4. Ranked context
   const rankedPath = path.join(CWD, '.monomind', 'data', 'ranked-context.json');
   try {
     const ranked = readJSON(rankedPath);
-    if (ranked?.entries?.length > vectorCount) vectorCount = ranked.entries.length;
+    if (ranked?.entries?.length) vectorCount += ranked.entries.length;
   } catch { /* ignore */ }
 
-  // 3. Add DB file sizes
+  // 5. DB file sizes
   const dbFiles = [
     path.join(CWD, 'data', 'memory.db'),
     path.join(CWD, '.monomind', 'memory.db'),
@@ -603,31 +634,17 @@ function getAgentDBStats() {
   ];
   for (const f of dbFiles) {
     const stat = safeStat(f);
-    if (stat) {
-      dbSizeKB += stat.size / 1024;
-      namespaces++;
-    }
+    if (stat) { dbSizeKB += stat.size / 1024; namespaces++; }
   }
 
-  // 4. Check for graph data
-  const graphPath = path.join(CWD, 'data', 'memory.graph');
-  const graphStat = safeStat(graphPath);
-  if (graphStat) dbSizeKB += graphStat.size / 1024;
-
-  // 5. HNSW index
+  // 6. HNSW index
   const hnswPaths = [
     path.join(CWD, '.swarm', 'hnsw.index'),
     path.join(CWD, '.monomind', 'hnsw.index'),
   ];
   for (const p of hnswPaths) {
-    const stat = safeStat(p);
-    if (stat) {
-      hasHnsw = true;
-      break;
-    }
+    if (safeStat(p)) { hasHnsw = true; break; }
   }
-
-  // HNSW is available if memory package is present
   if (!hasHnsw) {
     const memPkgPaths = [
       path.join(CWD, 'packages', '@monomind', 'memory', 'dist'),
@@ -641,6 +658,26 @@ function getAgentDBStats() {
   return { vectorCount, dbSizeKB: Math.floor(dbSizeKB), namespaces, hasHnsw };
 }
 
+// Graphify knowledge graph stats
+function getGraphifyStats() {
+  const statsPath = path.join(CWD, '.monomind', 'graph', 'stats.json');
+  const graphPath = path.join(CWD, '.monomind', 'graph', 'graph.json');
+  try {
+    const s = readJSON(statsPath);
+    if (s && s.nodes !== undefined) return { nodes: s.nodes, edges: s.edges || 0, exists: true };
+  } catch { /* ignore */ }
+  try {
+    const stat = safeStat(graphPath);
+    if (stat && stat.size < 10 * 1024 * 1024) {
+      const g = JSON.parse(fs.readFileSync(graphPath, 'utf-8'));
+      const nodes = Array.isArray(g.nodes) ? g.nodes.length : 0;
+      const edges = (Array.isArray(g.edges) ? g.edges : (Array.isArray(g.links) ? g.links : [])).length;
+      return { nodes, edges, exists: true };
+    }
+  } catch { /* ignore */ }
+  return { nodes: 0, edges: 0, exists: false };
+}
+
 // Memory Palace stats — drawers.jsonl + kg.json (the real persistent memory)
 function getMemoryPalaceStats() {
   const palaceDir = path.join(CWD, '.monomind', 'palace');
@@ -907,9 +944,10 @@ function generateStatusline() {
   const tokens    = getTokenStats();
   const parts     = [];
 
-  // Brand + swarm dot
+  // Brand + project + swarm dot
   const swarmDot = swarm.coordinationActive ? `${x.green}●${x.reset}` : `${x.slate}○${x.reset}`;
-  parts.push(`${x.bold}${x.purple}▊ Monomind${x.reset} ${swarmDot}`);
+  const projName = getProjectName();
+  parts.push(`${x.bold}${x.purple}▊ MonoMind${x.reset} ${x.teal}${projName}${x.reset} ${swarmDot}`);
 
   // Git branch + changes (compact)
   if (git.gitBranch) {
@@ -958,12 +996,18 @@ function generateStatusline() {
     parts.push(`${x.purple}🧠 ${autoMemCompact.count}m${x.reset}${typeSuffix}`);
   }
 
-  // Knowledge chunks (Task 28) — show when populated
+  // Knowledge chunks — show when populated
   if (knowledge.chunks > 0) {
     parts.push(`${x.teal}📚 ${knowledge.chunks}k${x.reset}`);
   }
 
-  // Triggers (Task 32) — show when populated
+  // Graphify code graph
+  const gfCompact = getGraphifyStats();
+  if (gfCompact.exists) {
+    parts.push(`${x.sky}🔗 ${gfCompact.nodes}n ${gfCompact.edges}e${x.reset}`);
+  }
+
+  // Triggers — show when populated
   if (triggers.triggers > 0) {
     parts.push(`${x.mint}🎯 ${triggers.triggers}t${x.reset}`);
   }
@@ -997,7 +1041,7 @@ function generateDashboard() {
   const security    = getSecurityStatus();
   const swarm       = getSwarmStatus();
   const system      = getSystemMetrics();
-  const adrs        = getADRStatus();
+  // adrs removed — internal dev metric
   const hooks       = getHooksStatus();
   const agentdb     = getAgentDBStats();
   const tests       = getTestStats();
@@ -1015,7 +1059,8 @@ function generateDashboard() {
 
   // ── Header: brand + git + model + session ────────────────────
   const swarmDot = swarm.coordinationActive ? `${x.green}● LIVE${x.reset}` : `${x.slate}○ IDLE${x.reset}`;
-  let hdr = `${x.bold}${x.purple}▊ Monomind ${VERSION}${x.reset}  ${swarmDot}  ${x.teal}${x.bold}${git.name}${x.reset}`;
+  const projName = getProjectName();
+  let hdr = `${x.bold}${x.purple}▊ MonoMind${x.reset} ${x.dim}${VERSION}${x.reset}  ${swarmDot}  ${x.teal}${x.bold}${projName}${x.reset}`;
 
   if (git.gitBranch) {
     hdr += `  ${DIV}  ${x.sky}⎇ ${x.bold}${git.gitBranch}${x.reset}`;
@@ -1036,30 +1081,29 @@ function generateDashboard() {
   lines.push(hdr);
   lines.push(SEP);
 
-  // ── Row 1: Intelligence & Learning ───────────────────────────
-  const intellCol = pctColor(system.intelligencePct);
-  const intellBar = blockBar(system.intelligencePct, 100, 6);
-
-  // Knowledge (Task 28)
+  // ── Row 1: Knowledge & Graphify ──────────────────────────────
   const knowStr = knowledge.chunks > 0
     ? `${x.teal}📚 ${x.bold}${knowledge.chunks}${x.reset}${x.slate} chunks${x.reset}`
     : `${x.slate}📚 no chunks${x.reset}`;
 
-  // Skills (Task 45)
   const skillStr = knowledge.skills > 0
     ? `  ${x.mint}✦ ${knowledge.skills} skills${x.reset}`
     : '';
 
-  // Patterns
   const patStr = progress.patternsLearned > 0
     ? `${x.gold}${progress.patternsLearned >= 1000 ? (progress.patternsLearned / 1000).toFixed(1) + 'k' : progress.patternsLearned} patterns${x.reset}`
     : `${x.slate}0 patterns${x.reset}`;
 
+  const gf = getGraphifyStats();
+  const gfStr = gf.exists
+    ? `${x.sky}🔗 ${x.bold}${gf.nodes}${x.reset}${x.slate} nodes · ${x.reset}${x.sky}${x.bold}${gf.edges}${x.reset}${x.slate} edges${x.reset}`
+    : `${x.slate}🔗 no graph${x.reset}`;
+
   lines.push(
     `${x.purple}💡  INTEL${x.reset}    ` +
-    `${intellCol}${intellBar} ${x.bold}${system.intelligencePct}%${x.reset}   ${DIV}   ` +
     `${knowStr}${skillStr}   ${DIV}   ` +
-    patStr
+    `${patStr}   ${DIV}   ` +
+    gfStr
   );
   lines.push(SEP);
 
@@ -1112,26 +1156,14 @@ function generateDashboard() {
   );
   lines.push(SEP);
 
-  // ── Row 3: Architecture & Security ───────────────────────────
-  const adrCol = adrs.count > 0
-    ? (adrs.implemented >= adrs.count ? x.green : x.gold)
-    : x.slate;
-  const adrStr = adrs.count > 0
-    ? `${adrCol}${x.bold}${adrs.implemented}${x.reset}${x.slate}/${x.reset}${x.white}${adrs.count}${x.reset} ADRs`
-    : `${x.slate}no ADRs${x.reset}`;
-
-  const dddCol = pctColor(progress.dddProgress);
-  const dddBar = blockBar(progress.dddProgress, 100, 5);
-
+  // ── Row 3: Security ──────────────────────────────────────────
   const cveStatus = security.totalCves === 0
     ? (security.status === 'NONE' ? `${x.slate}not scanned${x.reset}` : `${x.green}✔ clean${x.reset}`)
     : `${x.coral}${security.cvesFixed}/${security.totalCves} fixed${x.reset}`;
 
   lines.push(
-    `${x.purple}🧩  ARCH${x.reset}     ` +
-    `${adrStr}   ${DIV}   ` +
-    `DDD ${dddBar} ${dddCol}${x.bold}${progress.dddProgress}%${x.reset}   ${DIV}   ` +
-    `🛡️  ${sec.col}${sec.label}${x.reset}   ${DIV}   ` +
+    `${x.purple}🛡️  SECURITY${x.reset}  ` +
+    `${sec.col}${sec.label}${x.reset}   ${DIV}   ` +
     `CVE ${cveStatus}`
   );
   lines.push(SEP);
@@ -1190,13 +1222,6 @@ function generateDashboard() {
     siStr = `${x.slate}📄 no shared instructions${x.reset}`;
   }
 
-  // Domains
-  const domCol = progress.domainsCompleted >= 4 ? x.green
-               : progress.domainsCompleted >= 2 ? x.gold
-               : progress.domainsCompleted >= 1 ? x.orange
-               : x.slate;
-  const domBar = blockBar(progress.domainsCompleted, progress.totalDomains);
-
   let monthStr = '';
   if (tokens) {
     const mFmt = tokens.monthCost >= 100 ? `$${tokens.monthCost.toFixed(2)}` : tokens.monthCost >= 1 ? `$${tokens.monthCost.toFixed(3)}` : `$${tokens.monthCost.toFixed(4)}`;
@@ -1205,7 +1230,6 @@ function generateDashboard() {
   lines.push(
     `${x.slate}📋  CONTEXT${x.reset}  ` +
     `${siStr}   ${DIV}   ` +
-    `${x.teal}🏗 ${domBar} ${domCol}${x.bold}${progress.domainsCompleted}${x.reset}${x.slate}/${x.reset}${x.white}${progress.totalDomains}${x.reset} domains   ${DIV}   ` +
     `${x.dim}💾 ${system.memoryMB} MB RAM${x.reset}` +
     monthStr
   );