@monoes/monomindcli 1.12.0 → 1.14.0

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

@@ -99,17 +99,33 @@ const [,, command, ...args] = process.argv;
 // Read stdin — Claude Code sends hook data as JSON via stdin
 // Uses a timeout to prevent hanging when stdin is in an ambiguous state
 // (not TTY, not a proper pipe) which happens with Claude Code hook invocations.
+// Hard cap at 1 MiB: a legitimate hook payload (tool name + input) is at most
+// a few KB; anything larger is either a bug or an adversarial OOM attempt.
+const MAX_STDIN_BYTES = 1 * 1024 * 1024; // 1 MiB
 async function readStdin() {
   if (process.stdin.isTTY) return '';
   return new Promise((resolve) => {
     let data = '';
+    let byteCount = 0;
+    let truncated = false;
     const timer = setTimeout(() => {
       process.stdin.removeAllListeners();
       process.stdin.pause();
       resolve(data);
     }, 500);
     process.stdin.setEncoding('utf8');
-    process.stdin.on('data', (chunk) => { data += chunk; });
+    process.stdin.on('data', (chunk) => {
+      if (truncated) return;
+      byteCount += Buffer.byteLength(chunk, 'utf8');
+      if (byteCount > MAX_STDIN_BYTES) {
+        truncated = true;
+        process.stdin.pause();
+        clearTimeout(timer);
+        resolve(''); // discard oversized input to prevent OOM
+        return;
+      }
+      data += chunk;
+    });
     process.stdin.on('end', () => { clearTimeout(timer); resolve(data); });
     process.stdin.on('error', () => { clearTimeout(timer); resolve(data); });
     process.stdin.resume();
@@ -288,6 +304,46 @@ const handlers = {
     var tool = hCtx.toolName || '';
     if (tool === 'Grep') _recordGraphTelemetry('grep_call');
     else if (tool === 'Glob') _recordGraphTelemetry('glob_call');
+
+    // Monograph symbol hint: when the Grep pattern looks like a plain symbol name
+    // (no regex metacharacters), look it up directly in the graph index and print
+    // the file:line so the LLM may skip or narrow the Grep.
+    // Session-level cache prevents repeated identical DB lookups across Grep bursts.
+    try {
+      var grepPattern = (typeof toolInput === 'object' && toolInput !== null)
+        ? (toolInput.pattern || toolInput.query || '')
+        : '';
+      // Only attempt lookup for clean identifiers — skip regexes and paths
+      var isCleanSymbol = grepPattern.length >= 3 && grepPattern.length <= 80
+        && /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(grepPattern);
+      if (isCleanSymbol) {
+        if (!hCtx._preSearchCache) hCtx._preSearchCache = {};
+        var cacheKey = 'presearch:' + grepPattern;
+        if (!(cacheKey in hCtx._preSearchCache)) {
+          var db = _openMonographDb();
+          var hint = null;
+          if (db) {
+            try {
+              var row = db.prepare(
+                'SELECT n.name, n.label, n.file_path, n.start_line FROM nodes n ' +
+                'WHERE n.name = ? AND n.label NOT IN (\'Concept\',\'Community\',\'Folder\') ' +
+                'AND n.file_path IS NOT NULL LIMIT 1'
+              ).get(grepPattern);
+              if (row) {
+                hint = row.file_path + (row.start_line != null ? ':' + row.start_line : '');
+              }
+            } catch (e) { /* non-fatal */ }
+          }
+          hCtx._preSearchCache[cacheKey] = hint;
+        }
+        var cachedHint = hCtx._preSearchCache[cacheKey];
+        if (cachedHint) {
+          // Use the correct MCP tool name — monograph_context does not exist;
+          // the callable tool is mcp__monomind__monograph_query
+          console.log('[MONOGRAPH_HINT] ' + grepPattern + ' found at ' + cachedHint + ' — use mcp__monomind__monograph_query instead of Grep for better results');
+        }
+      }
+    } catch (e) { /* non-fatal — telemetry always proceeds */ }
   },
 
   'post-graph-tool': () => {

package/.claude/helpers/intelligence.cjs

@@ -1,92 +1,164 @@
 'use strict';
 /**
  * Intelligence context module for hook-handler.cjs
- * Provides context injection, trajectory logging, and feedback recording.
+ * Provides context injection, trajectory logging, feedback recording,
+ * edit tracking, consolidation, and stats.
+ *
+ * Data directory: $CLAUDE_PROJECT_DIR/.monomind/data/
+ *   auto-memory-store.json      — persisted memory entries
+ *   ranked-context.json         — ranked view written by init()
+ *   pending-insights.jsonl      — pending entries to consolidate
+ *   intelligence-outcomes.jsonl — feedback records
  */
 
 const path = require('path');
 const fs = require('fs');
 
+// Resolve base dir at require-time so tests can inject CLAUDE_PROJECT_DIR
+// per fresh require() call.
 const CWD = process.env.CLAUDE_PROJECT_DIR || process.cwd();
-const INTEL_DIR = path.join(CWD, '.monomind', 'intelligence');
-const PATTERNS_FILE = path.join(INTEL_DIR, 'patterns.json');
-const TRAJECTORY_FILE = path.join(INTEL_DIR, 'trajectory.json');
+const DATA_DIR = path.join(CWD, '.monomind', 'data');
+const STORE_FILE = path.join(DATA_DIR, 'auto-memory-store.json');
+const RANKED_FILE = path.join(DATA_DIR, 'ranked-context.json');
+const PENDING_FILE = path.join(DATA_DIR, 'pending-insights.jsonl');
+const OUTCOMES_FILE = path.join(DATA_DIR, 'intelligence-outcomes.jsonl');
 
-var _initialized = false;
-var _patterns = [];
-var _trajectory = [];
+const MAX_FILE_SIZE = 10 * 1024 * 1024; // 10 MiB guard
+const RING_BUFFER_MAX = 50;
 
-function ensureDir() {
-  try { fs.mkdirSync(INTEL_DIR, { recursive: true }); } catch (_) {}
+var _entries = [];        // deduplicated memory entries loaded from store
+var _recentEdits = [];    // ring buffer of recently edited paths
+
+function ensureDataDir() {
+  try { fs.mkdirSync(DATA_DIR, { recursive: true }); } catch (_) {}
 }
 
-var MAX_PATTERNS_SIZE = 10 * 1024 * 1024; // 10 MiB guard
+function safeReadJson(filePath) {
+  try {
+    if (!fs.existsSync(filePath)) return null;
+    var st = fs.statSync(filePath);
+    if (st.size > MAX_FILE_SIZE) return null;
+    return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+  } catch (_) { return null; }
+}
 
-function loadPatterns() {
+function safeReadLines(filePath) {
   try {
-    if (fs.existsSync(PATTERNS_FILE)) {
-      var st = fs.statSync(PATTERNS_FILE);
-      if (st.size > MAX_PATTERNS_SIZE) { _patterns = []; return; }
-      _patterns = JSON.parse(fs.readFileSync(PATTERNS_FILE, 'utf-8'));
-    }
-  } catch (_) { _patterns = []; }
+    if (!fs.existsSync(filePath)) return [];
+    var st = fs.statSync(filePath);
+    if (st.size > MAX_FILE_SIZE) return [];
+    return fs.readFileSync(filePath, 'utf-8')
+      .split('\n')
+      .filter(function(l) { return l.trim().length > 0; });
+  } catch (_) { return []; }
 }
 
+// ── init ───────────────────────────────────────────────────────────────────────
+
 function init() {
-  if (_initialized) return { ok: true, patternCount: _patterns.length };
-  ensureDir();
-  loadPatterns();
-  _initialized = true;
-  return { ok: true, patternCount: _patterns.length };
+  ensureDataDir();
+
+  // Load entries from store, deduplicate by id
+  var raw = safeReadJson(STORE_FILE);
+  var arr = Array.isArray(raw) ? raw : [];
+  var seen = new Set();
+  _entries = arr.filter(function(e) {
+    var key = e && e.id ? String(e.id) : null;
+    if (!key) return true;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+
+  // Write ranked-context.json (sorted by confidence desc) with version envelope
+  var ranked = _entries.slice().sort(function(a, b) {
+    return (b.confidence || 0) - (a.confidence || 0);
+  });
+  try {
+    fs.writeFileSync(RANKED_FILE, JSON.stringify({ version: 1, entries: ranked }, null, 2), 'utf-8');
+  } catch (_) {}
+
+  return { nodes: _entries.length, edges: 0 };
 }
 
+// ── getContext ─────────────────────────────────────────────────────────────────
+
 function getContext(prompt) {
-  if (!prompt || typeof prompt !== 'string') return null;
-  if (!_initialized) init();
-  // Match patterns against prompt
-  var matches = _patterns.filter(function(p) {
-    return p.keywords && p.keywords.some(function(kw) {
-      return prompt.toLowerCase().includes(kw.toLowerCase());
-    });
+  if (!prompt || typeof prompt !== 'string' || prompt.trim() === '') return null;
+  if (_entries.length === 0) return null;
+
+  var promptWords = prompt.toLowerCase().split(/\W+/).filter(Boolean);
+  var promptSet = new Set(promptWords);
+
+  var matches = _entries.filter(function(e) {
+    var content = ((e.content || '') + ' ' + (e.summary || '')).toLowerCase();
+    var words = content.split(/\W+/).filter(Boolean);
+    return words.some(function(w) { return promptSet.has(w); });
   });
+
   if (matches.length === 0) return null;
+
   var top = matches[0];
-  return '[INTELLIGENCE] Pattern match: ' + (top.name || top.id || 'pattern') +
-         (top.suggestion ? ' — ' + top.suggestion : '');
+  return '[INTELLIGENCE] ' + (top.summary || top.content || top.id || 'context match');
 }
 
-function logTrajectory(step) {
-  ensureDir();
-  _trajectory.push(Object.assign({ ts: new Date().toISOString() }, step || {}));
-  // Flush every 10 steps to avoid excessive writes
-  if (_trajectory.length % 10 === 0) {
-    try {
-      fs.writeFileSync(TRAJECTORY_FILE, JSON.stringify(_trajectory.slice(-200), null, 2), 'utf-8');
-    } catch (_) {}
+// ── recordEdit ────────────────────────────────────────────────────────────────
+
+function recordEdit(filePath) {
+  _recentEdits.push({ path: String(filePath || ''), ts: Date.now() });
+  if (_recentEdits.length > RING_BUFFER_MAX) {
+    _recentEdits = _recentEdits.slice(-RING_BUFFER_MAX);
   }
 }
 
+// ── consolidate ───────────────────────────────────────────────────────────────
+
+function consolidate() {
+  ensureDataDir();
+  var lines = safeReadLines(PENDING_FILE);
+  var count = lines.length;
+
+  // Clear the pending file
+  try { fs.writeFileSync(PENDING_FILE, '', 'utf-8'); } catch (_) {}
+
+  return { entries: count, edges: 0, newEntries: count };
+}
+
+// ── feedback ──────────────────────────────────────────────────────────────────
+
 function feedback(success) {
-  // Record outcome for last trajectory step
-  if (_trajectory.length > 0) {
-    _trajectory[_trajectory.length - 1].outcome = success ? 'success' : 'failure';
-  }
-  // Persist
-  ensureDir();
-  try {
-    fs.writeFileSync(TRAJECTORY_FILE, JSON.stringify(_trajectory.slice(-200), null, 2), 'utf-8');
-  } catch (_) {}
+  ensureDataDir();
+  var record = JSON.stringify({
+    ts: Date.now(),
+    success: !!success,
+    context: null,
+    recentEdits: _recentEdits.slice(),
+  }) + '\n';
+  try { fs.appendFileSync(OUTCOMES_FILE, record, 'utf-8'); } catch (_) {}
+}
+
+// ── stats ─────────────────────────────────────────────────────────────────────
+
+function stats(asJson) {
+  var result = {
+    entries: _entries.length,
+    recentEdits: _recentEdits.length,
+    pending: safeReadLines(PENDING_FILE).length,
+  };
+  if (asJson) return JSON.stringify(result);
+  return result;
+}
+
+// ── legacy ────────────────────────────────────────────────────────────────────
+
+function logTrajectory(step) {
+  // no-op stub for backward compatibility
+  void step;
 }
 
 function storePattern(pattern) {
-  ensureDir();
-  loadPatterns();
-  var safeId = String(pattern.id || '').slice(0, 256);
-  _patterns = _patterns.filter(function(p) { return p.id !== safeId; });
-  _patterns.push(Object.assign({ storedAt: new Date().toISOString() }, pattern, { id: safeId }));
-  try {
-    fs.writeFileSync(PATTERNS_FILE, JSON.stringify(_patterns.slice(-500), null, 2), 'utf-8');
-  } catch (_) {}
+  // no-op stub for backward compatibility
+  void pattern;
 }
 
-module.exports = { init, getContext, logTrajectory, feedback, storePattern };
+module.exports = { init, getContext, recordEdit, consolidate, feedback, stats, logTrajectory, storePattern };