@monoes/monomindcli 1.10.7 → 1.10.8

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

@@ -296,57 +296,82 @@ function _autoIndexKnowledge(knowledgeDir) {
     } catch (e) {}
   }
 
-  // Inject monograph graph summary as a knowledge chunk
+  // Inject monograph graph summary as a knowledge chunk.
+  // Reads from .monomind/monograph.db (SQLite, source of truth) and falls
+  // back to the legacy .monomind/graph/{stats,graph}.json pair only when
+  // present (older installs).
   try {
-    var statsPath = path.join(CWD, '.monomind', 'graph', 'stats.json');
-    var graphPath = path.join(CWD, '.monomind', 'graph', 'graph.json');
-    if (fs.existsSync(statsPath) && fs.existsSync(graphPath)) {
-      var stats = JSON.parse(fs.readFileSync(statsPath, 'utf-8'));
-      var graphStat = fs.statSync(graphPath);
-      // Only read graph if under 10MB
-      if (graphStat.size < 10 * 1024 * 1024) {
-        var graph = JSON.parse(fs.readFileSync(graphPath, 'utf-8'));
-        var rawNodes = Array.isArray(graph.nodes) ? graph.nodes : [];
-        var rawEdges = Array.isArray(graph.edges) ? graph.edges : (Array.isArray(graph.links) ? graph.links : []);
-        // Top 15 nodes by degree (god nodes)
-        var degree = {};
-        rawNodes.forEach(function(n) { degree[n.id] = 0; });
-        rawEdges.forEach(function(e) {
-          if (degree[e.source] !== undefined) degree[e.source]++;
-          if (degree[e.target] !== undefined) degree[e.target]++;
-        });
-        var topNodes = rawNodes
-          .filter(function(n) { return n.sourceFile && n.sourceFile !== ''; })
-          .sort(function(a, b) { return (degree[b.id] || 0) - (degree[a.id] || 0); })
-          .slice(0, 15);
-        // Community summary — group by type
-        var typeCounts = {};
-        rawNodes.forEach(function(n) { var t = n.type || n.label || 'unknown'; typeCounts[t] = (typeCounts[t] || 0) + 1; });
-        var topTypes = Object.entries(typeCounts).sort(function(a,b){return b[1]-a[1];}).slice(0,8).map(function(e){return e[0]+':'+e[1];}).join(', ');
-        var builtDate = stats.builtAt ? new Date(stats.builtAt).toISOString().slice(0,10) : 'unknown';
-        var summaryText = [
-          'MONOGRAPH KNOWLEDGE GRAPH SUMMARY',
-          'Built: ' + builtDate + ' | Nodes: ' + (stats.nodes || rawNodes.length) + ' | Edges: ' + (stats.edges || rawEdges.length) + ' | Files: ' + (stats.files || 0),
-          '',
-          'TOP GOD NODES (highest connectivity):',
-          topNodes.map(function(n) {
-            return '  ' + (n.name || n.id) + ' [' + (n.type || n.label || '?') + '] — ' + (n.sourceFile || '') + ' (degree: ' + (degree[n.id] || 0) + ')';
-          }).join('\n'),
-          '',
-          'NODE TYPE DISTRIBUTION: ' + topTypes,
-          '',
-          'Use mcp__monomind__monograph_suggest to find files relevant to your task.',
-          'Use mcp__monomind__monograph_query to search for symbols.',
-          'Use mcp__monomind__monograph_god_nodes for architecture overview.',
-        ].join('\n');
-        var chunkId = crypto.createHash('md5').update('monograph-graph-summary').digest('hex').slice(0, 16);
-        newLines.push(JSON.stringify({
-          chunkId: chunkId,
-          namespace: 'knowledge:shared',
-          text: summaryText,
-          metadata: { label: 'monograph-graph-summary', builtAt: stats.builtAt }
-        }));
-      }
+    var mgDbPath2 = path.join(CWD, '.monomind', 'monograph.db');
+    var legacyStats2 = path.join(CWD, '.monomind', 'graph', 'stats.json');
+    var legacyGraph2 = path.join(CWD, '.monomind', 'graph', 'graph.json');
+
+    var summaryText = null;
+    var summaryMeta = {};
+
+    if (fs.existsSync(mgDbPath2)) {
+      try {
+        var mgMod2 = _requireMonograph();
+        if (mgMod2 && mgMod2.openDb) {
+          var sumDb = mgMod2.openDb(mgDbPath2);
+          try {
+            var nodeC = sumDb.prepare('SELECT COUNT(*) AS c FROM nodes').get().c;
+            var edgeC = sumDb.prepare('SELECT COUNT(*) AS c FROM edges').get().c;
+            var topNodes2 = sumDb.prepare(
+              'SELECT n.name, n.label, n.file_path, ' +
+              '(SELECT COUNT(*) FROM edges WHERE source_id=n.id OR target_id=n.id) AS deg ' +
+              'FROM nodes n WHERE n.file_path IS NOT NULL AND n.file_path != "" ORDER BY deg DESC LIMIT 15'
+            ).all();
+            var typeRows = sumDb.prepare(
+              'SELECT label, COUNT(*) AS c FROM nodes GROUP BY label ORDER BY c DESC LIMIT 8'
+            ).all();
+            var typeStr = typeRows.map(function(r) { return r.label + ':' + r.c; }).join(', ');
+            summaryText = [
+              'MONOGRAPH KNOWLEDGE GRAPH SUMMARY',
+              'Source: monograph.db | Nodes: ' + nodeC + ' | Edges: ' + edgeC,
+              '',
+              'TOP GOD NODES (highest connectivity — start exploration here):',
+              topNodes2.map(function(n) {
+                return '  ' + n.name + ' [' + n.label + '] — ' + (n.file_path || '') + ' (degree: ' + n.deg + ')';
+              }).join('\n'),
+              '',
+              'NODE TYPE DISTRIBUTION: ' + typeStr,
+              '',
+              'Before grepping or globbing, prefer:',
+              '  mcp__monomind__monograph_suggest({ task: "<your task>" }) — ranked relevant files',
+              '  mcp__monomind__monograph_query({ q: "<symbol|keyword>" }) — BM25 search with file:line',
+              '  mcp__monomind__monograph_impact({ name: "<file>" }) — upstream + downstream blast radius',
+            ].join('\n');
+            summaryMeta = { label: 'monograph-graph-summary', source: 'monograph.db', nodes: nodeC, edges: edgeC };
+          } finally {
+            try { sumDb.close(); } catch (_) {}
+          }
+        }
+      } catch (e) { /* fall through to legacy */ }
+    }
+
+    if (!summaryText && fs.existsSync(legacyStats2) && fs.existsSync(legacyGraph2)) {
+      try {
+        var lStats = JSON.parse(fs.readFileSync(legacyStats2, 'utf-8'));
+        var lGraphStat = fs.statSync(legacyGraph2);
+        if (lGraphStat.size < 10 * 1024 * 1024) {
+          var lGraph = JSON.parse(fs.readFileSync(legacyGraph2, 'utf-8'));
+          var lNodes = Array.isArray(lGraph.nodes) ? lGraph.nodes : [];
+          summaryText = 'MONOGRAPH KNOWLEDGE GRAPH SUMMARY (legacy JSON)\n' +
+            'Nodes: ' + (lStats.nodes || lNodes.length) + ' | Edges: ' + (lStats.edges || 0) + '\n' +
+            'Use mcp__monomind__monograph_suggest to find files relevant to your task.';
+          summaryMeta = { label: 'monograph-graph-summary', source: 'legacy-json', builtAt: lStats.builtAt };
+        }
+      } catch (e) { /* ignore */ }
+    }
+
+    if (summaryText) {
+      var chunkId = crypto.createHash('md5').update('monograph-graph-summary').digest('hex').slice(0, 16);
+      newLines.push(JSON.stringify({
+        chunkId: chunkId,
+        namespace: 'knowledge:shared',
+        text: summaryText,
+        metadata: summaryMeta
+      }));
     }
   } catch (e) { /* graph not available yet, skip */ }
 
@@ -639,14 +664,34 @@ const handlers = {
 
       console.log(output.join('\n'));
 
-      // Inject monograph hint for complex tasks
+      // Inject monograph hint for complex tasks.
+      // Source of truth is .monomind/monograph.db (SQLite). Legacy stats.json
+      // is no longer written by the build, so it is checked only as a fallback.
       try {
-        var graphStatsPath = path.join(CWD, '.monomind', 'graph', 'stats.json');
-        if (fs.existsSync(graphStatsPath)) {
-          var gStats = JSON.parse(fs.readFileSync(graphStatsPath, 'utf-8'));
-          if (gStats.nodes > 100) {
-            console.log('\n[MONOGRAPH] ' + gStats.nodes + ' nodes indexed. For this task, call mcp__monomind__monograph_suggest first.');
-          }
+        var monographDb = path.join(CWD, '.monomind', 'monograph.db');
+        var legacyStats = path.join(CWD, '.monomind', 'graph', 'stats.json');
+        var nodeCount = 0;
+        if (fs.existsSync(monographDb)) {
+          try {
+            var mgMod = _requireMonograph();
+            if (mgMod && mgMod.openDb) {
+              var hintDb = mgMod.openDb(monographDb);
+              try {
+                nodeCount = hintDb.prepare('SELECT COUNT(*) AS c FROM nodes').get().c;
+              } finally {
+                try { hintDb.close(); } catch (_) {}
+              }
+            }
+          } catch (e) { /* ignore — fall back to legacy */ }
+        }
+        if (nodeCount === 0 && fs.existsSync(legacyStats)) {
+          try {
+            var gStats = JSON.parse(fs.readFileSync(legacyStats, 'utf-8'));
+            nodeCount = gStats.nodes || 0;
+          } catch (e) { /* ignore */ }
+        }
+        if (nodeCount > 100) {
+          console.log('\n[MONOGRAPH] ' + nodeCount + ' nodes indexed. For this task, call mcp__monomind__monograph_suggest first to find the right files without grepping.');
         }
       } catch(e) {}
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@monoes/monomindcli",
-  "version": "1.10.7",
+  "version": "1.10.8",
   "type": "module",
   "description": "Monomind CLI - Enterprise AI agent orchestration with 60+ specialized agents, swarm coordination, MCP server, self-learning hooks, and vector memory for Claude Code",
   "main": "dist/src/index.js",