moflo 4.8.9 → 4.8.11

package/bin/gate.cjs

@@ -0,0 +1,138 @@
+#!/usr/bin/env node
+'use strict';
+var fs = require('fs');
+var path = require('path');
+
+var PROJECT_DIR = (process.env.CLAUDE_PROJECT_DIR || process.cwd()).replace(/^\/([a-z])\//i, '$1:/');
+var STATE_FILE = path.join(PROJECT_DIR, '.claude', 'workflow-state.json');
+
+function readState() {
+  try {
+    if (fs.existsSync(STATE_FILE)) return JSON.parse(fs.readFileSync(STATE_FILE, 'utf-8'));
+  } catch (e) { /* reset on corruption */ }
+  return { tasksCreated: false, taskCount: 0, memorySearched: false, memoryRequired: true, interactionCount: 0, sessionStart: null, lastBlockedAt: null };
+}
+
+function writeState(s) {
+  try {
+    var dir = path.dirname(STATE_FILE);
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(STATE_FILE, JSON.stringify(s, null, 2));
+  } catch (e) { /* non-fatal */ }
+}
+
+// Load moflo.yaml gate config (defaults: all enabled)
+function loadGateConfig() {
+  var defaults = { memory_first: true, task_create_first: true, context_tracking: true };
+  try {
+    var yamlPath = path.join(PROJECT_DIR, 'moflo.yaml');
+    if (fs.existsSync(yamlPath)) {
+      var content = fs.readFileSync(yamlPath, 'utf-8');
+      if (/memory_first:\s*false/i.test(content)) defaults.memory_first = false;
+      if (/task_create_first:\s*false/i.test(content)) defaults.task_create_first = false;
+      if (/context_tracking:\s*false/i.test(content)) defaults.context_tracking = false;
+    }
+  } catch (e) { /* use defaults */ }
+  return defaults;
+}
+
+var config = loadGateConfig();
+var command = process.argv[2];
+
+var EXEMPT = ['.claude/', '.claude\\', 'CLAUDE.md', 'MEMORY.md', 'workflow-state', 'node_modules'];
+var DANGEROUS = ['rm -rf /', 'format c:', 'del /s /q c:\\', ':(){:|:&};:', 'mkfs.', '> /dev/sda'];
+var DIRECTIVE_RE = /^(yes|no|yeah|yep|nope|sure|ok|okay|correct|right|exactly|perfect)\b/i;
+var TASK_RE = /\b(fix|bug|error|implement|add|create|build|write|refactor|debug|test|feature|issue|security|optimi)\b/i;
+
+switch (command) {
+  case 'check-before-agent': {
+    var s = readState();
+    // Hard gate: memory must be searched
+    if (config.memory_first && s.memoryRequired && !s.memorySearched) {
+      process.stderr.write('BLOCKED: Search memory (mcp__moflo__memory_search) before spawning agents.\n');
+      process.exit(2);
+    }
+    // Soft gate: TaskCreate recommended but not blocking
+    // (TaskCreate PostToolUse doesn't fire in Claude Code, so we can't track it reliably)
+    if (config.task_create_first && !s.tasksCreated) {
+      process.stdout.write('REMINDER: Use TaskCreate before spawning agents. Task tool is blocked until then.\n');
+    }
+    break;
+  }
+  case 'check-before-scan': {
+    if (!config.memory_first) break;
+    var s = readState();
+    if (s.memorySearched || !s.memoryRequired) break;
+    var target = (process.env.TOOL_INPUT_pattern || '') + ' ' + (process.env.TOOL_INPUT_path || '');
+    if (EXEMPT.some(function(p) { return target.indexOf(p) >= 0; })) break;
+    process.stderr.write('BLOCKED: Search memory before exploring files. Use mcp__moflo__memory_search.\n');
+    process.exit(2);
+  }
+  case 'check-before-read': {
+    if (!config.memory_first) break;
+    var s = readState();
+    if (s.memorySearched || !s.memoryRequired) break;
+    var fp = process.env.TOOL_INPUT_file_path || '';
+    if (fp.indexOf('.claude/guidance/') < 0 && fp.indexOf('.claude\\guidance\\') < 0) break;
+    process.stderr.write('BLOCKED: Search memory before reading guidance files. Use mcp__moflo__memory_search.\n');
+    process.exit(2);
+  }
+  case 'record-task-created': {
+    var s = readState();
+    s.tasksCreated = true;
+    s.taskCount = (s.taskCount || 0) + 1;
+    writeState(s);
+    break;
+  }
+  case 'record-memory-searched': {
+    var s = readState();
+    s.memorySearched = true;
+    writeState(s);
+    break;
+  }
+  case 'check-bash-memory': {
+    var cmd = process.env.TOOL_INPUT_command || '';
+    if (/semantic-search|memory search|memory retrieve|memory-search/.test(cmd)) {
+      var s = readState();
+      s.memorySearched = true;
+      writeState(s);
+    }
+    break;
+  }
+  case 'check-dangerous-command': {
+    var cmd = (process.env.TOOL_INPUT_command || '').toLowerCase();
+    for (var i = 0; i < DANGEROUS.length; i++) {
+      if (cmd.indexOf(DANGEROUS[i]) >= 0) {
+        console.log('[BLOCKED] Dangerous command: ' + DANGEROUS[i]);
+        process.exit(2);
+      }
+    }
+    break;
+  }
+  case 'prompt-reminder': {
+    var s = readState();
+    s.memorySearched = false;
+    var prompt = process.env.CLAUDE_USER_PROMPT || '';
+    s.memoryRequired = prompt.length >= 4 && !DIRECTIVE_RE.test(prompt) && (TASK_RE.test(prompt) || prompt.length > 80);
+    s.interactionCount = (s.interactionCount || 0) + 1;
+    writeState(s);
+    if (!s.tasksCreated) console.log('REMINDER: Use TaskCreate before spawning agents. Task tool is blocked until then.');
+    if (config.context_tracking) {
+      var ic = s.interactionCount;
+      if (ic > 30) console.log('Context: CRITICAL. Commit, store learnings, suggest new session.');
+      else if (ic > 20) console.log('Context: DEPLETED. Checkpoint progress. Recommend /compact or fresh session.');
+      else if (ic > 10) console.log('Context: MODERATE. Re-state goal before architectural decisions. Use agents for >300 LOC.');
+    }
+    break;
+  }
+  case 'compact-guidance': {
+    console.log('Pre-Compact: Check CLAUDE.md for rules. Use memory search to recover context after compact.');
+    break;
+  }
+  case 'session-reset': {
+    writeState({ tasksCreated: false, taskCount: 0, memorySearched: false, memoryRequired: true, interactionCount: 0, sessionStart: new Date().toISOString(), lastBlockedAt: null });
+    break;
+  }
+  default:
+    break;
+}

package/bin/hook-handler.cjs

@@ -0,0 +1,83 @@
+#!/usr/bin/env node
+'use strict';
+var fs = require('fs');
+var path = require('path');
+
+var PROJECT_DIR = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+var METRICS_FILE = path.join(PROJECT_DIR, '.claude-flow', 'metrics', 'learning.json');
+var command = process.argv[2];
+
+// Read stdin (Claude Code sends hook data as JSON)
+function readStdin() {
+  if (process.stdin.isTTY) return Promise.resolve('');
+  return new Promise(function(resolve) {
+    var data = '';
+    var timer = setTimeout(function() {
+      process.stdin.removeAllListeners();
+      process.stdin.pause();
+      resolve(data);
+    }, 500);
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', function(chunk) { data += chunk; });
+    process.stdin.on('end', function() { clearTimeout(timer); resolve(data); });
+    process.stdin.on('error', function() { clearTimeout(timer); resolve(data); });
+    process.stdin.resume();
+  });
+}
+
+function bumpMetric(key) {
+  try {
+    var metrics = {};
+    if (fs.existsSync(METRICS_FILE)) metrics = JSON.parse(fs.readFileSync(METRICS_FILE, 'utf-8'));
+    metrics[key] = (metrics[key] || 0) + 1;
+    metrics.lastUpdated = new Date().toISOString();
+    var dir = path.dirname(METRICS_FILE);
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(METRICS_FILE, JSON.stringify(metrics, null, 2));
+  } catch (e) { /* non-fatal */ }
+}
+
+readStdin().then(function(stdinData) {
+  var hookInput = {};
+  if (stdinData && stdinData.trim()) {
+    try { hookInput = JSON.parse(stdinData); } catch (e) { /* ignore */ }
+  }
+
+  switch (command) {
+    case 'route': {
+      var prompt = hookInput.prompt || hookInput.command || process.env.PROMPT || '';
+      if (prompt) console.log('[INFO] Routing: ' + prompt.substring(0, 80));
+      else console.log('[INFO] Ready');
+      break;
+    }
+    case 'pre-edit':
+    case 'post-edit':
+      bumpMetric('edits');
+      console.log('[OK] Edit recorded');
+      break;
+    case 'pre-task':
+      bumpMetric('tasks');
+      console.log('[OK] Task started');
+      break;
+    case 'post-task':
+      bumpMetric('tasksCompleted');
+      console.log('[OK] Task completed');
+      break;
+    case 'session-end': {
+      // Kill tracked background processes via shared sync helper
+      try {
+        var cleanup = require('./lib/registry-cleanup.cjs');
+        var killed = cleanup.killTrackedSync(PROJECT_DIR);
+        if (killed > 0) console.log('[CLEANUP] Killed ' + killed + ' background process(es)');
+      } catch (e) { /* non-fatal: cleanup module not available */ }
+      console.log('[OK] Session ended');
+      break;
+    }
+    case 'notification':
+      // Silent — just acknowledge
+      break;
+    default:
+      if (command) console.log('[OK] Hook: ' + command);
+      break;
+  }
+});

package/bin/hooks.mjs

@@ -23,11 +23,13 @@ import { spawn } from 'child_process';
 import { existsSync, appendFileSync, readFileSync, writeFileSync, mkdirSync, statSync } from 'fs';
 import { resolve, dirname } from 'path';
 import { fileURLToPath } from 'url';
+import { createProcessManager } from './lib/process-manager.mjs';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 const projectRoot = resolve(__dirname, '../..');
 const logFile = resolve(projectRoot, '.swarm/hooks.log');
+const pm = createProcessManager(projectRoot);
 
 // Parse command line args
 const args = process.argv.slice(2);
@@ -263,6 +265,8 @@ async function main() {
         runIndexGuidanceBackground();
         // Generate structural code map in background
         runCodeMapBackground();
+        // Index test files in background
+        runTestIndexBackground();
         // Run pretrain in background to extract patterns from repository
         runBackgroundPretrain();
         // Force HNSW rebuild to ensure all processes use identical fresh index
@@ -318,6 +322,12 @@ async function main() {
       }
 
       case 'session-end': {
+        // Kill all tracked background processes before ending session
+        const killResult = pm.killAll();
+        if (killResult.killed > 0) {
+          log('info', `Killed ${killResult.killed} background process(es) on session end`);
+        }
+
         // Run ReasoningBank and MicroLoRA training in background on session end
         log('info', 'Session ending - starting background learning...');
 
@@ -397,19 +407,15 @@ async function runIndexGuidance(specificFile = null) {
   return 0;
 }
 
-// Spawn a background process that's truly windowless on Windows
+// Spawn a background process via the shared ProcessManager (dedup + PID tracking).
 function spawnWindowless(cmd, args, description) {
-  const proc = spawn(cmd, args, {
-    cwd: projectRoot,
-    stdio: 'ignore',
-    detached: true,
-    shell: false,
-    windowsHide: true
-  });
-
-  proc.unref();
-  log('info', `Started ${description} (PID: ${proc.pid})`);
-  return proc;
+  const result = pm.spawn(cmd, args, description);
+  if (result.skipped) {
+    log('info', `Skipped ${description} (already running, PID: ${result.pid})`);
+  } else if (result.pid) {
+    log('info', `Started ${description} (PID: ${result.pid})`);
+  }
+  return result;
 }
 
 // Resolve a moflo npm bin script, falling back to local .claude/scripts/ copy
@@ -431,6 +437,22 @@ function resolveBinOrLocal(binName, localScript) {
 
 // Run the guidance indexer in background (non-blocking - used for session start and file changes)
 function runIndexGuidanceBackground(specificFile = null) {
+  // Check auto_index.guidance flag in moflo.yaml (default: true)
+  // Only gate full indexing on session-start; per-file calls from post-edit always run
+  if (!specificFile) {
+    const yamlPath = resolve(projectRoot, 'moflo.yaml');
+    if (existsSync(yamlPath)) {
+      try {
+        const content = readFileSync(yamlPath, 'utf-8');
+        const match = content.match(/auto_index:\s*\n(?:.*\n)*?\s+guidance:\s*(true|false)/);
+        if (match && match[1] === 'false') {
+          log('info', 'Guidance indexing disabled (auto_index.guidance: false)');
+          return;
+        }
+      } catch { /* ignore, proceed with indexing */ }
+    }
+  }
+
   const indexScript = resolveBinOrLocal('flo-index', 'index-guidance.mjs');
 
   if (!indexScript) {
@@ -447,6 +469,19 @@ function runIndexGuidanceBackground(specificFile = null) {
 
 // Run structural code map generator in background (non-blocking)
 function runCodeMapBackground() {
+  // Check auto_index.code_map flag in moflo.yaml (default: true)
+  const yamlPath = resolve(projectRoot, 'moflo.yaml');
+  if (existsSync(yamlPath)) {
+    try {
+      const content = readFileSync(yamlPath, 'utf-8');
+      const match = content.match(/auto_index:\s*\n(?:.*\n)*?\s+code_map:\s*(true|false)/);
+      if (match && match[1] === 'false') {
+        log('info', 'Code map generation disabled (auto_index.code_map: false)');
+        return;
+      }
+    } catch { /* ignore, proceed with indexing */ }
+  }
+
   const codeMapScript = resolveBinOrLocal('flo-codemap', 'generate-code-map.mjs');
 
   if (!codeMapScript) {
@@ -457,6 +492,31 @@ function runCodeMapBackground() {
   spawnWindowless('node', [codeMapScript], 'background code map generation');
 }
 
+// Run test file indexer in background (non-blocking)
+function runTestIndexBackground() {
+  // Check auto_index.tests flag in moflo.yaml (default: true)
+  const yamlPath = resolve(projectRoot, 'moflo.yaml');
+  if (existsSync(yamlPath)) {
+    try {
+      const content = readFileSync(yamlPath, 'utf-8');
+      const match = content.match(/auto_index:\s*\n(?:.*\n)*?\s+tests:\s*(true|false)/);
+      if (match && match[1] === 'false') {
+        log('info', 'Test indexing disabled (auto_index.tests: false)');
+        return;
+      }
+    } catch { /* ignore, proceed with indexing */ }
+  }
+
+  const testIndexScript = resolveBinOrLocal('flo-testmap', 'index-tests.mjs');
+
+  if (!testIndexScript) {
+    log('info', 'Test indexer not found (checked npm bin + .claude/scripts/)');
+    return;
+  }
+
+  spawnWindowless('node', [testIndexScript], 'background test indexing');
+}
+
 // Run ReasoningBank + MicroLoRA training + EWC++ consolidation in background (non-blocking)
 function runBackgroundTraining() {
   const localCli = getLocalCliPath();

package/bin/index-guidance.mjs

@@ -100,11 +100,16 @@ function loadGuidanceDirs() {
 
   // 2. Include moflo's own bundled guidance (ships with the package)
   //    Only when running inside a consumer project (not moflo itself)
-  const bundledGuidanceDir = resolve(mofloRoot, '.claude/guidance');
+  //    Shipped guidance lives in .claude/guidance/shipped/ — internal/ is excluded from npm
+  const bundledShippedDir = resolve(mofloRoot, '.claude/guidance/shipped');
+  const bundledGuidanceDir = existsSync(bundledShippedDir)
+    ? bundledShippedDir
+    : resolve(mofloRoot, '.claude/guidance');
   const projectGuidanceDir = resolve(projectRoot, '.claude/guidance');
   if (
     existsSync(bundledGuidanceDir) &&
-    resolve(bundledGuidanceDir) !== resolve(projectGuidanceDir)
+    resolve(bundledGuidanceDir) !== resolve(projectGuidanceDir) &&
+    resolve(bundledGuidanceDir) !== resolve(projectGuidanceDir, 'shipped')
   ) {
     dirs.push({ path: bundledGuidanceDir, prefix: 'moflo-bundled', absolute: true });
   }
@@ -689,9 +694,11 @@ function indexDirectory(db, dirConfig) {
 
 /**
  * Remove stale entries for files that no longer exist on disk.
- * Runs after indexing to keep the memory DB clean.
+ * Uses the set of docKeys seen during the current indexing run to determine
+ * which entries are stale, rather than reconstructing file paths from keys
+ * (which breaks for files in subdirectories).
  */
-function cleanStaleEntries(db) {
+function cleanStaleEntries(db, currentDocKeys) {
   const docsStmt = db.prepare(
     `SELECT DISTINCT key FROM memory_entries WHERE namespace = ? AND key LIKE 'doc-%'`
   );
@@ -702,36 +709,19 @@ function cleanStaleEntries(db) {
 
   let staleCount = 0;
 
-  // Build a lookup of all indexed directory configs for stale detection
-  const prefixToDirMap = {};
-  for (const dirConfig of GUIDANCE_DIRS) {
-    const dirPath = dirConfig.absolute ? dirConfig.path : resolve(projectRoot, dirConfig.path);
-    prefixToDirMap[dirConfig.prefix] = dirPath;
-  }
-
   for (const { key } of docs) {
-    // Convert key back to file path by matching doc-{prefix}-{filename}
-    let filePath;
-    for (const [prefix, dirPath] of Object.entries(prefixToDirMap)) {
-      const docPrefix = `doc-${prefix}-`;
-      if (key.startsWith(docPrefix)) {
-        filePath = resolve(dirPath, key.replace(docPrefix, '') + '.md');
-        break;
-      }
-    }
-    if (!filePath) continue; // Unknown prefix, skip
-
-    if (!existsSync(filePath)) {
-      const chunkPrefix = key.replace('doc-', 'chunk-');
-      const countBefore = db.exec(`SELECT COUNT(*) as cnt FROM memory_entries WHERE namespace = '${NAMESPACE}'`)[0]?.values[0][0] || 0;
-      db.run(`DELETE FROM memory_entries WHERE namespace = ? AND key LIKE ?`, [NAMESPACE, `${chunkPrefix}%`]);
-      db.run(`DELETE FROM memory_entries WHERE namespace = ? AND key = ?`, [NAMESPACE, key]);
-      const countAfter = db.exec(`SELECT COUNT(*) as cnt FROM memory_entries WHERE namespace = '${NAMESPACE}'`)[0]?.values[0][0] || 0;
-      const removed = countBefore - countAfter;
-      if (removed > 0) {
-        log(`  Removed ${removed} stale entries for deleted file: ${key}`);
-        staleCount += removed;
-      }
+    // If this doc key was seen during the current indexing run, it's not stale
+    if (currentDocKeys.has(key)) continue;
+
+    const chunkPrefix = key.replace('doc-', 'chunk-');
+    const countBefore = db.exec(`SELECT COUNT(*) as cnt FROM memory_entries WHERE namespace = '${NAMESPACE}'`)[0]?.values[0][0] || 0;
+    db.run(`DELETE FROM memory_entries WHERE namespace = ? AND key LIKE ?`, [NAMESPACE, `${chunkPrefix}%`]);
+    db.run(`DELETE FROM memory_entries WHERE namespace = ? AND key = ?`, [NAMESPACE, key]);
+    const countAfter = db.exec(`SELECT COUNT(*) as cnt FROM memory_entries WHERE namespace = '${NAMESPACE}'`)[0]?.values[0][0] || 0;
+    const removed = countBefore - countAfter;
+    if (removed > 0) {
+      log(`  Removed ${removed} stale entries for deleted file: ${key}`);
+      staleCount += removed;
     }
   }
 
@@ -769,6 +759,7 @@ let docsIndexed = 0;
 let chunksIndexed = 0;
 let unchanged = 0;
 let errors = 0;
+const currentDocKeys = new Set();
 
 if (specificFile) {
   // Index single file
@@ -801,6 +792,9 @@ if (specificFile) {
     const results = indexDirectory(db, dir);
 
     for (const result of results) {
+      if (result.status === 'indexed' || result.status === 'unchanged') {
+        currentDocKeys.add(result.docKey);
+      }
       if (result.status === 'indexed') {
         log(`  ✅ ${result.docKey} (${result.chunks} chunks)`);
         docsIndexed++;
@@ -819,7 +813,7 @@ if (specificFile) {
 let staleRemoved = 0;
 if (!specificFile) {
   log('Cleaning stale entries for deleted files...');
-  staleRemoved = cleanStaleEntries(db);
+  staleRemoved = cleanStaleEntries(db, currentDocKeys);
   if (staleRemoved === 0) {
     log('  No stale entries found');
   }