monomind 1.10.27 → 1.10.29

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

@@ -199,13 +199,14 @@ function _injectCompactGraphMap() {
       }
 
       // 2. Fill remaining slots (up to 8 total) with god nodes (high centrality).
-      var slotsLeft = 8 - anchors.length;
-      if (slotsLeft > 0) {
+      // Exclude node_modules paths (external typings like `Path [Interface]` skew rankings).
+      if (anchors.length < 8) {
         var gods = db.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.label NOT IN ('Concept') AND n.file_path IS NOT NULL AND n.file_path != '' " +
+          "AND n.file_path NOT LIKE '%/node_modules/%' AND n.file_path NOT LIKE '%node_modules%' " +
           "AND n.name NOT LIKE '(%' AND n.name NOT LIKE '%=>%' AND length(n.name) >= 3 " +
           "ORDER BY deg DESC LIMIT 15"
         ).all();
@@ -1731,13 +1732,37 @@ const handlers = {
               "FROM nodes n " +
               "WHERE n.label NOT IN ('Concept') " +
               "AND n.file_path IS NOT NULL AND n.file_path != '' " +
+              "AND n.file_path NOT LIKE '%/node_modules/%' AND n.file_path NOT LIKE '%node_modules%' " +
               "ORDER BY deg DESC LIMIT 12"
             ).all();
+
+            // Check graph staleness: compare stored commit hash with current HEAD.
+            var mgStaleIndicator = '';
+            try {
+              var mgLastCommitRow = null;
+              try { mgLastCommitRow = mgDb.prepare("SELECT value FROM index_meta WHERE key='ua_last_commit'").get(); } catch (_) {}
+              if (mgLastCommitRow && mgLastCommitRow.value) {
+                var { execFileSync: mgExec } = require('child_process');
+                var currentHead = '';
+                try { currentHead = mgExec('git', ['rev-parse', 'HEAD'], { cwd: CWD, encoding: 'utf-8' }).trim(); } catch (_) {}
+                if (currentHead && currentHead !== mgLastCommitRow.value) {
+                  var commitsBehind = 0;
+                  try {
+                    var revList = mgExec('git', ['rev-list', '--count', mgLastCommitRow.value + '..' + currentHead], { cwd: CWD, encoding: 'utf-8' }).trim();
+                    commitsBehind = parseInt(revList, 10) || 0;
+                  } catch (_) {}
+                  if (commitsBehind > 0) {
+                    mgStaleIndicator = ' [⚡ graph ' + commitsBehind + ' commit' + (commitsBehind === 1 ? '' : 's') + ' behind — run: npx monomind monograph build]';
+                  }
+                }
+              }
+            } catch (_) {}
+
             if (mgGodNodes.length > 0) {
               var mgGodStr = mgGodNodes.slice(0, 8).map(function(n) {
                 return n.name + ' (' + n.label + ', ' + n.deg + ' links)';
               }).join(', ');
-              console.log('[MONOGRAPH_CONTEXT] ' + mgNodeCount + ' nodes · ' + mgEdgeCount + ' edges. Key nodes: ' + mgGodStr);
+              console.log('[MONOGRAPH_CONTEXT] ' + mgNodeCount + ' nodes · ' + mgEdgeCount + ' edges. Key nodes: ' + mgGodStr + mgStaleIndicator);
               // Write god nodes into knowledge chunks so semantic search finds them
               var mgKnowledgeDir = path.join(CWD, '.monomind', 'knowledge');
               var mgChunksFile = path.join(mgKnowledgeDir, 'chunks.jsonl');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "monomind",
-  "version": "1.10.27",
+  "version": "1.10.29",
   "description": "Monomind - Enterprise AI agent orchestration for Claude Code. Deploy 60+ specialized agents in coordinated swarms with self-learning, fault-tolerant consensus, vector memory, and MCP integration",
   "main": "dist/index.js",
   "type": "module",

package/packages/@monomind/cli/dist/src/commands/init.js

@@ -689,8 +689,29 @@ const upgradeCommand = {
             output.writeln();
             let succeeded = 0;
             let failed = 0;
+            // Try to read control URL for dashboard progress events (best-effort)
+            let controlUrl = 'http://localhost:4242';
+            try {
+                const ctrlCfg = JSON.parse(fs.readFileSync(path.join(process.cwd(), '.monomind', 'control.json'), 'utf-8'));
+                if (ctrlCfg.url)
+                    controlUrl = ctrlCfg.url;
+            }
+            catch { }
+            const emitUpgradeProgress = async (projDir, status, current, total) => {
+                try {
+                    const { default: http } = await import('http');
+                    const payload = JSON.stringify({ type: 'upgrade:progress', project: projDir, status, current, total, ts: Date.now() });
+                    const url = new URL(controlUrl + '/api/mastermind/event');
+                    const req = http.request({ hostname: url.hostname, port: parseInt(url.port || '4242'), path: url.pathname, method: 'POST', headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(payload) } });
+                    req.write(payload);
+                    req.end();
+                    req.on('error', () => { });
+                }
+                catch { }
+            };
             for (const projDir of projects) {
-                const spinner = output.createSpinner({ text: projDir });
+                const projIdx = projects.indexOf(projDir) + 1;
+                const spinner = output.createSpinner({ text: `[${projIdx}/${projects.length}] ${projDir}` });
                 spinner.start();
                 try {
                     const res = addMissing
@@ -699,15 +720,18 @@ const upgradeCommand = {
                     if (res.success) {
                         spinner.succeed(projDir + ' (' + res.updated.length + ' updated)');
                         succeeded++;
+                        emitUpgradeProgress(projDir, 'success', projIdx, projects.length);
                     }
                     else {
                         spinner.fail(projDir + ' — ' + (res.errors[0] || 'unknown error'));
                         failed++;
+                        emitUpgradeProgress(projDir, 'failed', projIdx, projects.length);
                     }
                 }
                 catch (e) {
                     spinner.fail(projDir + ' — ' + (e instanceof Error ? e.message : String(e)));
                     failed++;
+                    emitUpgradeProgress(projDir, 'failed', projIdx, projects.length);
                 }
             }
             output.writeln();

package/packages/@monomind/cli/dist/src/init/executor.js

@@ -342,6 +342,8 @@ export async function executeInit(options) {
         await startDaemonBackground(targetDir, result);
         // Run doctor auto-fix (non-blocking, best-effort)
         await runDoctorFix(targetDir, result);
+        // Register this project in ~/.monomind-projects.json so upgrade --all finds it
+        _registerMonomindProject(targetDir);
     }
     catch (error) {
         result.success = false;
@@ -2168,13 +2170,39 @@ function countEnabledHooks(options) {
         count++;
     return count;
 }
+/**
+ * Register a project directory in ~/.monomind-projects.json so that
+ * `monomind init upgrade --all` can find it without doing a directory scan.
+ * Best-effort: failures are silently swallowed.
+ */
+function _registerMonomindProject(dir) {
+    try {
+        const esmReq = createRequire(import.meta.url);
+        const os = esmReq('os');
+        const registryPath = path.join(os.homedir(), '.monomind-projects.json');
+        let reg = { projects: [] };
+        try {
+            reg = JSON.parse(fs.readFileSync(registryPath, 'utf-8'));
+        }
+        catch { }
+        if (!Array.isArray(reg.projects))
+            reg.projects = [];
+        const abs = path.resolve(dir);
+        if (!reg.projects.includes(abs)) {
+            reg.projects.push(abs);
+            fs.writeFileSync(registryPath, JSON.stringify(reg, null, 2), 'utf-8');
+        }
+    }
+    catch { /* non-fatal */ }
+}
 /**
  * Scan common locations for directories that have monomind installed
  * (presence of .claude/helpers/hook-handler.cjs is the definitive signal).
  * Searches up to maxDepth directory levels below each search root.
  */
 export function findMonomindProjects(maxDepth = 3) {
-    const os = require('os');
+    const esmReq = createRequire(import.meta.url);
+    const os = esmReq('os');
     const home = os.homedir();
     const searchRoots = [
         path.join(home, 'Desktop'),

package/packages/@monomind/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@monoes/monomindcli",
-  "version": "1.10.27",
+  "version": "1.10.29",
   "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",

package/packages/@monomind/cli/scripts/understand-analyze.mjs

@@ -654,32 +654,65 @@ async function main() {
       mg.closeDb(db);
       process.exit(1);
     }
-    const updateNode = db.prepare(`UPDATE nodes SET properties = ? WHERE id = ?`);
+    // Resolve each analysis item to a DB integer node id.
+    // graph.json nodes have id='file:<path>' (synthetic); the real PK is an integer.
+    // Accept: analysis.dbId (integer), analysis.filePath, or derive path from analysis.id.
+    const lookupByPath = db.prepare(`SELECT id, properties FROM nodes WHERE file_path=? OR file_path=? LIMIT 1`);
+    const lookupById   = db.prepare(`SELECT id, properties FROM nodes WHERE id=? LIMIT 1`);
+    const updateNode   = db.prepare(`UPDATE nodes SET properties = ? WHERE id = ?`);
     let written = 0;
     const tx = db.transaction(() => {
       for (const analysis of analyses) {
-        if (!analysis || !analysis.id) continue;
-        const existing = (() => {
-          try { const row = db.prepare('SELECT properties FROM nodes WHERE id=?').get(analysis.id); return row?.properties ? JSON.parse(row.properties) : {}; } catch { return {}; }
-        })();
+        if (!analysis) continue;
+        let nodeRow = null;
+        // 1. Prefer explicit integer dbId (added by newer graph.json emitter)
+        if (analysis.dbId != null) {
+          nodeRow = lookupById.get(analysis.dbId);
+        }
+        // 2. Fall back to filePath from graph.json node
+        if (!nodeRow && analysis.filePath) {
+          const rel = analysis.filePath.startsWith('/') ? relative(projectDir, analysis.filePath) : analysis.filePath;
+          nodeRow = lookupByPath.get(analysis.filePath, rel);
+        }
+        // 3. Derive path from synthetic id ('file:<path>')
+        if (!nodeRow && analysis.id && String(analysis.id).startsWith('file:')) {
+          const derivedPath = String(analysis.id).slice(5);
+          const rel = derivedPath.startsWith('/') ? relative(projectDir, derivedPath) : derivedPath;
+          nodeRow = lookupByPath.get(derivedPath, rel);
+        }
+        if (!nodeRow) continue;
+        const existing = (() => { try { return nodeRow.properties ? JSON.parse(nodeRow.properties) : {}; } catch { return {}; } })();
         const merged = {
           ...existing,
-          ...(analysis.fileSummary   ? { summary:             analysis.fileSummary }            : {}),
-          ...(analysis.tags          ? { tags:                 analysis.tags }                   : {}),
-          ...(analysis.complexity    ? { complexity:           analysis.complexity }              : {}),
-          ...(analysis.functionSummaries ? { functionSummaries: analysis.functionSummaries }     : {}),
-          ...(analysis.classSummaries    ? { classSummaries:    analysis.classSummaries }        : {}),
+          ...(analysis.fileSummary       ? { summary:             analysis.fileSummary }            : {}),
+          ...(analysis.tags              ? { tags:                 analysis.tags }                   : {}),
+          ...(analysis.complexity        ? { complexity:           analysis.complexity }              : {}),
+          ...(analysis.functionSummaries ? { functionSummaries:    analysis.functionSummaries }     : {}),
+          ...(analysis.classSummaries    ? { classSummaries:       analysis.classSummaries }        : {}),
           ua_analyzed_at: new Date().toISOString(),
         };
-        updateNode.run(JSON.stringify(merged), analysis.id);
+        updateNode.run(JSON.stringify(merged), nodeRow.id);
         written++;
       }
     });
     tx();
     // Rebuild FTS so summaries are immediately searchable
     try { db.prepare(`INSERT INTO nodes_fts(nodes_fts) VALUES('rebuild')`).run(); } catch {}
-    mg.closeDb(db);
+
+    // Validate write-back: count nodes that now have a readable summary in properties
+    let enrichedCount = 0;
+    try {
+      const row = db.prepare(
+        `SELECT COUNT(*) AS c FROM nodes WHERE json_extract(properties, '$.summary') IS NOT NULL AND length(json_extract(properties, '$.summary')) > 5`
+      ).get();
+      enrichedCount = row ? row.c : 0;
+    } catch (_) {}
     console.log(`[understand] Imported ${written} analyses from stdin. FTS rebuilt.`);
+    console.log(`[understand] Validation: ${enrichedCount} node(s) now have LLM summaries readable via json_extract.`);
+    if (written > 0 && enrichedCount < written) {
+      console.warn(`[understand] WARNING: only ${enrichedCount} of ${written} imported analyses are queryable. Some properties may not have committed — check if properties column is TEXT.`);
+    }
+    mg.closeDb(db);
     return;
   }
 
@@ -1001,6 +1034,7 @@ function buildGraphJson(dir, fileNodes, analysisMap, layers) {
     const a = analysisMap[n.file_path] || {};
     return {
       id: 'file:' + (n.file_path || n.name),
+      dbId: n.id,          // integer PK — use this in --import-analyses-stdin payloads
       type: 'file',
       name: n.name,
       filePath: n.file_path,