monomind 1.12.0 → 1.13.0

package/.claude/helpers/utils/monograph.cjs

@@ -25,6 +25,30 @@ function _requireMonograph() {
 // Memoized at module scope — opening monograph.db can take 7-10s.
 // Callers MUST NOT close the returned handle.
 var _cachedMonographDb = undefined;
+
+// LRU cache for getMonographSuggestions: avoids re-querying the DB for
+// the same task text within a single hook execution process lifetime.
+// Max 20 entries; evicts the least-recently-used on overflow.
+var _suggestCache = { _map: Object.create(null), _order: [], _max: 20 };
+function _suggestCacheGet(key) {
+  if (key in _suggestCache._map) {
+    // Move to end (most recently used)
+    var idx = _suggestCache._order.indexOf(key);
+    if (idx !== -1) { _suggestCache._order.splice(idx, 1); _suggestCache._order.push(key); }
+    return _suggestCache._map[key];
+  }
+  return undefined;
+}
+function _suggestCacheSet(key, value) {
+  if (!(key in _suggestCache._map)) {
+    if (_suggestCache._order.length >= _suggestCache._max) {
+      var evict = _suggestCache._order.shift();
+      delete _suggestCache._map[evict];
+    }
+    _suggestCache._order.push(key);
+  }
+  _suggestCache._map[key] = value;
+}
 function _openMonographDb() {
   if (_cachedMonographDb !== undefined) return _cachedMonographDb;
   try {
@@ -39,6 +63,10 @@ function _openMonographDb() {
 
 function getMonographSuggestions(taskText, limit) {
   if (!taskText || typeof taskText !== 'string') return [];
+  // Fast path: return cached result for repeated identical queries.
+  var cacheKey = taskText.slice(0, 200) + '|' + (limit || 5);
+  var cached = _suggestCacheGet(cacheKey);
+  if (cached !== undefined) return cached;
   var db = _openMonographDb();
   if (!db) return [];
   try {
@@ -56,7 +84,7 @@ function getMonographSuggestions(taskText, limit) {
     var rows = [];
     try {
       rows = db.prepare(
-        'SELECT n.id, n.name, n.label, n.file_path AS file, ' +
+        'SELECT n.id, n.name, n.label, n.file_path AS file, n.start_line AS startLine, ' +
         'bm25(nodes_fts) AS bm25_score, ' +
         '(SELECT COUNT(*) FROM edges WHERE source_id=n.id OR target_id=n.id) AS deg, ' +
         'CASE n.label WHEN \'File\' THEN 3 WHEN \'Function\' THEN 3 WHEN \'Class\' THEN 3 ' +
@@ -72,7 +100,7 @@ function getMonographSuggestions(taskText, limit) {
       var likeFrag = keys.map(function(){ return 'lower(n.name) LIKE ?'; }).join(' OR ');
       var likeArgs = keys.map(function(k){ return '%' + k + '%'; });
       var stmt = db.prepare(
-        'SELECT n.id, n.name, n.label, n.file_path AS file, ' +
+        'SELECT n.id, n.name, n.label, n.file_path AS file, n.start_line AS startLine, ' +
         '(SELECT COUNT(*) FROM edges WHERE source_id=n.id OR target_id=n.id) AS deg ' +
         'FROM nodes n WHERE (' + likeFrag + ') AND n.file_path IS NOT NULL AND n.file_path != \'\' ' +
         'AND n.label NOT IN (\'Concept\') ' +
@@ -80,7 +108,9 @@ function getMonographSuggestions(taskText, limit) {
       );
       rows = stmt.all.apply(stmt, likeArgs.concat([lim]));
     }
-    return rows || [];
+    var result = rows || [];
+    _suggestCacheSet(cacheKey, result);
+    return result;
   } catch (e) { return []; }
   finally { /* db is shared/cached; do not close */ }
 }
@@ -287,8 +317,13 @@ function injectGodNodesContext(CWD) {
       // Staleness indicator: compare stored commit hash with current HEAD.
       var staleIndicator = '';
       try {
+        // The orchestrator writes 'last_commit_hash'; fall back to legacy keys.
         var lastCommitRow = null;
-        try { lastCommitRow = db.prepare("SELECT value FROM index_meta WHERE key='ua_last_commit'").get(); } catch (_) {}
+        try {
+          lastCommitRow = db.prepare("SELECT value FROM index_meta WHERE key='last_commit_hash'").get() ||
+                          db.prepare("SELECT value FROM index_meta WHERE key='lastCommit'").get() ||
+                          db.prepare("SELECT value FROM index_meta WHERE key='ua_last_commit'").get();
+        } catch (_) {}
         if (lastCommitRow && lastCommitRow.value) {
           var { execFileSync: execSync } = require('child_process');
           var currentHead = '';

package/.claude/helpers/utils/telemetry.cjs

@@ -10,14 +10,14 @@ const CWD = process.env.CLAUDE_PROJECT_DIR || process.cwd();
 function _recordRecentEdit(filePath) {
   if (!filePath) return;
   try {
-    var relPath = path.isAbsolute(filePath) ? path.relative(CWD, filePath) : filePath;
+    var storedPath = filePath;
     var f = path.join(CWD, '.monomind', 'metrics', 'recent-edits.json');
     fs.mkdirSync(path.dirname(f), { recursive: true });
     var d = { edits: [] };
     try { d = JSON.parse(fs.readFileSync(f, 'utf-8')); } catch (_) {}
     if (!Array.isArray(d.edits)) d.edits = [];
-    d.edits = d.edits.filter(function(e) { return e.file !== relPath; });
-    d.edits.unshift({ file: relPath, editedAt: Date.now() });
+    d.edits = d.edits.filter(function(e) { return e.file !== storedPath; });
+    d.edits.unshift({ file: storedPath, editedAt: Date.now() });
     if (d.edits.length > 10) d.edits = d.edits.slice(0, 10);
     fs.writeFileSync(f, JSON.stringify(d));
   } catch (e) { /* non-fatal */ }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "monomind",
-  "version": "1.12.0",
+  "version": "1.13.0",
   "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/doctor.js

@@ -436,6 +436,84 @@ async function checkMonograph() {
         };
     }
 }
+// Check monograph graph freshness (is the graph built? how stale?)
+async function checkMonographFreshness() {
+    try {
+        const cwd = process.cwd();
+        const dbPath = join(cwd, '.monomind', 'monograph.db');
+        const lockPath = join(cwd, '.monomind', 'graph', '.rebuild-lock');
+        const statsPath = join(cwd, '.monomind', 'graph', 'stats.json');
+        // Check if graph exists at all
+        const hasDb = existsSync(dbPath);
+        const hasLock = existsSync(lockPath);
+        const hasStats = existsSync(statsPath);
+        if (!hasDb && !hasStats) {
+            return {
+                name: 'Graph freshness',
+                status: 'warn',
+                message: 'No monograph graph built yet',
+                fix: 'mcp__monomind__monograph_build codeOnly:true  — or run npx monomind@latest hooks graph-status',
+            };
+        }
+        // Determine last build time
+        let buildMs = 0;
+        if (hasDb) {
+            try {
+                buildMs = Math.max(buildMs, statSync(dbPath).mtimeMs);
+            }
+            catch { /* ignore */ }
+        }
+        if (hasLock) {
+            try {
+                buildMs = Math.max(buildMs, statSync(lockPath).mtimeMs);
+            }
+            catch { /* ignore */ }
+        }
+        if (hasStats) {
+            try {
+                buildMs = Math.max(buildMs, statSync(statsPath).mtimeMs);
+            }
+            catch { /* ignore */ }
+        }
+        if (buildMs === 0) {
+            return { name: 'Graph freshness', status: 'warn', message: 'Graph exists but build time unknown' };
+        }
+        // Count commits since last build
+        const buildIso = new Date(buildMs).toISOString();
+        let commitsBehind = 0;
+        try {
+            const out = execSync(`git rev-list --count --since='${buildIso}' HEAD 2>/dev/null`, {
+                encoding: 'utf8', timeout: 2000, cwd,
+            }).trim();
+            commitsBehind = parseInt(out, 10) || 0;
+        }
+        catch { /* git not available or not a git repo */ }
+        const ageMinutes = Math.floor((Date.now() - buildMs) / 60000);
+        const ageStr = ageMinutes < 60 ? `${ageMinutes}m ago` : `${Math.floor(ageMinutes / 60)}h ago`;
+        if (commitsBehind === 0) {
+            return { name: 'Graph freshness', status: 'pass', message: `FRESH — built ${ageStr}, 0 commits behind` };
+        }
+        else if (commitsBehind <= 5) {
+            return {
+                name: 'Graph freshness',
+                status: 'warn',
+                message: `${commitsBehind} commit(s) behind — built ${ageStr}`,
+                fix: 'mcp__monomind__monograph_build codeOnly:true',
+            };
+        }
+        else {
+            return {
+                name: 'Graph freshness',
+                status: 'fail',
+                message: `STALE — ${commitsBehind} commits behind (built ${ageStr})`,
+                fix: 'mcp__monomind__monograph_build codeOnly:true',
+            };
+        }
+    }
+    catch {
+        return { name: 'Graph freshness', status: 'warn', message: 'Could not check graph freshness' };
+    }
+}
 // Check @monoes/memory (optional HNSW vector search package)
 async function checkMonoesMemory() {
     try {
@@ -798,7 +876,7 @@ export const doctorCommand = {
         {
             name: 'component',
             short: 'c',
-            description: 'Check specific component (version, node, npm, config, daemon, memory, api, git, mcp, claude, disk, typescript, monograph, memory-pkg, helpers, agentic-flow, monoes, gates, gitignore)',
+            description: 'Check specific component (version, node, npm, config, daemon, memory, api, git, mcp, claude, disk, typescript, monograph, graph-freshness, memory-pkg, helpers, agentic-flow, monoes, gates, gitignore)',
             type: 'string'
         },
         {
@@ -841,6 +919,7 @@ export const doctorCommand = {
             checkDiskSpace,
             checkBuildTools,
             checkMonograph,
+            checkMonographFreshness,
             checkMonoesMemory,
             checkHelpersFresh,
             checkAgenticFlow,
@@ -863,6 +942,7 @@ export const doctorCommand = {
             'disk': checkDiskSpace,
             'typescript': checkBuildTools,
             'monograph': checkMonograph,
+            'graph-freshness': checkMonographFreshness,
             'memory-pkg': checkMonoesMemory,
             'helpers': checkHelpersFresh,
             'agentic-flow': checkAgenticFlow,
@@ -889,6 +969,14 @@ export const doctorCommand = {
                     const result = settledResult.value;
                     results.push(result);
                     output.writeln(formatCheck(result));
+                    if (result.fix && result.status === 'fail') {
+                        // Always show fix inline for failures — no flag needed
+                        output.writeln(output.dim(`  Fix: ${result.fix}`));
+                    }
+                    else if (result.fix && result.status === 'warn') {
+                        // Show fix inline for warnings too, so users don't need --fix for common issues
+                        output.writeln(output.dim(`  Hint: ${result.fix}`));
+                    }
                     if (result.fix && (result.status === 'fail' || result.status === 'warn')) {
                         fixes.push(`${result.name}: ${result.fix}`);
                     }
@@ -949,9 +1037,13 @@ export const doctorCommand = {
                 output.writeln(output.dim(`  ${fix}`));
             }
         }
-        else if (fixes.length > 0 && !showFix) {
-            output.writeln();
-            output.writeln(output.dim(`Run with --fix to see ${fixes.length} suggested fix${fixes.length > 1 ? 'es' : ''}`));
+        else if (!showFix) {
+            // Only nudge about --fix for warnings (failures already showed their fix inline)
+            const warnFixes = results.filter(r => r.status === 'warn' && r.fix).length;
+            if (warnFixes > 0) {
+                output.writeln();
+                output.writeln(output.dim(`Run with --fix to see ${warnFixes} suggested fix${warnFixes > 1 ? 'es' : ''} for warnings`));
+            }
         }
         // Overall result
         if (failed > 0) {