moflo 4.8.11 → 4.8.12

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

@@ -1,341 +1,83 @@
 #!/usr/bin/env node
-/**
- * Claude Flow Hook Handler (Cross-Platform)
- * Dispatches hook events to the appropriate helper modules.
- */
-
-const path = require('path');
-const fs = require('fs');
-
-const helpersDir = __dirname;
-
-function safeRequire(modulePath) {
-  try {
-    if (fs.existsSync(modulePath)) {
-      const origLog = console.log;
-      const origError = console.error;
-      console.log = () => {};
-      console.error = () => {};
-      try {
-        const mod = require(modulePath);
-        return mod;
-      } finally {
-        console.log = origLog;
-        console.error = origError;
-      }
-    }
-  } catch (e) {
-    // silently fail
-  }
-  return null;
-}
-
-const router = safeRequire(path.join(helpersDir, 'router.cjs'));
-const session = safeRequire(path.join(helpersDir, 'session.cjs'));
-const memory = safeRequire(path.join(helpersDir, 'memory.cjs'));
-const intelligence = safeRequire(path.join(helpersDir, 'intelligence.cjs'));
-
-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.
-async function readStdin() {
-  if (process.stdin.isTTY) return '';
-  return new Promise((resolve) => {
-    let data = '';
-    const timer = setTimeout(() => {
+'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', (chunk) => { data += chunk; });
-    process.stdin.on('end', () => { clearTimeout(timer); resolve(data); });
-    process.stdin.on('error', () => { clearTimeout(timer); resolve(data); });
+    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();
   });
 }
 
-async function main() {
-  let stdinData = '';
-  try { stdinData = await readStdin(); } catch (e) { /* ignore stdin errors */ }
+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 */ }
+}
 
-  let hookInput = {};
-  if (stdinData.trim()) {
-    try { hookInput = JSON.parse(stdinData); } catch (e) { /* ignore parse errors */ }
+readStdin().then(function(stdinData) {
+  var hookInput = {};
+  if (stdinData && stdinData.trim()) {
+    try { hookInput = JSON.parse(stdinData); } catch (e) { /* ignore */ }
   }
 
-  // Merge stdin data into prompt resolution: prefer stdin fields, then env vars.
-  // NEVER fall back to argv args — shell glob expansion of braces in bash output
-  // creates junk files (#1342). Use env vars or stdin only.
-  const prompt = hookInput.prompt || hookInput.command || hookInput.toolInput
-    || process.env.PROMPT || process.env.TOOL_INPUT_command || '';
-
-const handlers = {
-  'route': () => {
-    if (intelligence && intelligence.getContext) {
-      try {
-        const ctx = intelligence.getContext(prompt);
-        if (ctx) console.log(ctx);
-      } catch (e) { /* non-fatal */ }
-    }
-    if (router && router.routeTask) {
-      const result = router.routeTask(prompt);
-      var output = [];
-      output.push('[INFO] Routing task: ' + (prompt.substring(0, 80) || '(no prompt)'));
-      output.push('');
-      output.push('+------------------- Primary Recommendation -------------------+');
-      output.push('| Agent: ' + result.agent.padEnd(53) + '|');
-      output.push('| Confidence: ' + (result.confidence * 100).toFixed(1) + '%' + ' '.repeat(44) + '|');
-      output.push('| Reason: ' + result.reason.substring(0, 53).padEnd(53) + '|');
-      output.push('+--------------------------------------------------------------+');
-      console.log(output.join('\n'));
-    } else {
-      console.log('[INFO] Router not available, using default routing');
-    }
-  },
-
-  'pre-bash': () => {
-    var cmd = (hookInput.command || prompt).toLowerCase();
-    var dangerous = ['rm -rf /', 'format c:', 'del /s /q c:\\', ':(){:|:&};:'];
-    for (var i = 0; i < dangerous.length; i++) {
-      if (cmd.includes(dangerous[i])) {
-        console.error('[BLOCKED] Dangerous command detected: ' + dangerous[i]);
-        process.exit(1);
-      }
-    }
-    console.log('[OK] Command validated');
-  },
-
-  'post-edit': () => {
-    if (session && session.metric) {
-      try { session.metric('edits'); } catch (e) { /* no active session */ }
-    }
-    if (intelligence && intelligence.recordEdit) {
-      try {
-        var file = hookInput.file_path || (hookInput.toolInput && hookInput.toolInput.file_path)
-          || process.env.TOOL_INPUT_file_path || args[0] || '';
-        intelligence.recordEdit(file);
-      } catch (e) { /* non-fatal */ }
-    }
-    console.log('[OK] Edit recorded');
-  },
-
-  'session-restore': async () => {
-    if (session) {
-      var existing = session.restore && session.restore();
-      if (!existing) {
-        session.start && session.start();
-      }
-    } else {
-      console.log('No session to restore');
-      console.log('Session started: session-' + Date.now());
-    }
-    if (intelligence && intelligence.init) {
-      try {
-        var result = intelligence.init();
-        if (result && result.nodes > 0) {
-          console.log('[INTELLIGENCE] Loaded ' + result.nodes + ' patterns, ' + result.edges + ' edges');
-        }
-      } catch (e) { /* non-fatal */ }
-    }
-
-    // Auto-index guidance, code map, and patterns on session start
-    // Delegates to shared ProcessManager for dedup + PID tracking + cleanup.
-    try {
-      var projectDir = path.resolve(path.dirname(helpersDir), '..');
-
-      // Dynamic import of ESM process-manager from CJS context
-      var pmMod = await import(
-        'file:///' + path.join(projectDir, 'node_modules', 'moflo', 'bin', 'lib', 'process-manager.mjs').replace(/\\/g, '/')
-      ).catch(function() {
-        // Fallback: try local bin/ (for moflo repo itself)
-        return import(
-          'file:///' + path.join(projectDir, 'bin', 'lib', 'process-manager.mjs').replace(/\\/g, '/')
-        );
-      }).catch(function() { return null; });
-
-      if (!pmMod) return; // No process manager available
-
-      var pm = pmMod.createProcessManager(projectDir);
-
-      // Kill stale background processes from previous session
-      pm.killAll();
-
-      // Guard: prevent concurrent session-restores from spawning duplicates
-      if (pm.isLocked()) return;
-      pm.acquireLock();
-
-      // Read moflo.yaml auto_index flags (default: both true)
-      var autoGuidance = true;
-      var autoCodeMap = true;
-      var mofloConfigPath = path.join(projectDir, 'moflo.yaml');
-      var mofloJsonPath = path.join(projectDir, 'moflo.config.json');
-
-      if (fs.existsSync(mofloConfigPath)) {
-        try {
-          var content = fs.readFileSync(mofloConfigPath, 'utf-8');
-          if (/auto_index:\s*\n\s+guidance:\s*false/i.test(content)) autoGuidance = false;
-          if (/auto_index:\s*\n(?:\s+guidance:\s*\w+\n)?\s+code_map:\s*false/i.test(content)) autoCodeMap = false;
-        } catch (e) { /* ignore */ }
-      } else if (fs.existsSync(mofloJsonPath)) {
-        try {
-          var config = JSON.parse(fs.readFileSync(mofloJsonPath, 'utf-8'));
-          var ai = config.auto_index || config.autoIndex || {};
-          if (ai.guidance === false) autoGuidance = false;
-          if (ai.code_map === false || ai.codeMap === false) autoCodeMap = false;
-        } catch (e) { /* ignore */ }
-      }
-
-      // Helper: find a moflo bin script by filename
-      function findMofloScript(scriptName) {
-        var candidates = [
-          path.join(projectDir, 'bin', scriptName),
-          path.join(projectDir, 'node_modules', 'moflo', 'bin', scriptName),
-        ];
-        for (var i = 0; i < candidates.length; i++) {
-          if (fs.existsSync(candidates[i])) return candidates[i];
-        }
-        try {
-          var resolved = require.resolve('moflo/bin/' + scriptName, { paths: [projectDir] });
-          if (fs.existsSync(resolved)) return resolved;
-        } catch (e) { /* not installed */ }
-        return null;
-      }
-
-      // 1. Index guidance docs (with embeddings for semantic search)
-      if (autoGuidance) {
-        var guidanceScript = findMofloScript('index-guidance.mjs');
-        if (guidanceScript) pm.spawn('node', [guidanceScript], 'index-guidance');
-      }
-
-      // 2. Generate code map (structural index of source files)
-      if (autoCodeMap) {
-        var codeMapScript = findMofloScript('generate-code-map.mjs');
-        if (codeMapScript) pm.spawn('node', [codeMapScript], 'generate-code-map');
-      }
-
-      // 3. Start learning service (pattern research on codebase)
-      var learnScript = findMofloScript('../.claude/helpers/learning-service.mjs');
-      if (!learnScript) learnScript = findMofloScript('learning-service.mjs');
-      if (!learnScript) {
-        var localLearn = path.join(projectDir, '.claude', 'helpers', 'learning-service.mjs');
-        if (fs.existsSync(localLearn)) learnScript = localLearn;
-      }
-      if (!learnScript) {
-        var nmLearn = path.join(projectDir, 'node_modules', 'moflo', '.claude', 'helpers', 'learning-service.mjs');
-        if (fs.existsSync(nmLearn)) learnScript = nmLearn;
-      }
-      if (learnScript) pm.spawn('node', [learnScript], 'learning-service');
-
-    } catch (e) { /* non-fatal: session-start indexing is best-effort */ }
-  },
-
-  'session-end': () => {
-    // Kill all tracked background processes using shared sync helper.
-    // Must be SYNCHRONOUS — process.exit(0) fires in finally{} so async would never resolve.
-    var projectDir = path.resolve(path.dirname(helpersDir), '..');
-    try {
-      var cleanup = require(path.join(projectDir, 'node_modules', 'moflo', 'bin', 'lib', 'registry-cleanup.cjs'));
-      var killed = cleanup.killTrackedSync(projectDir);
-      if (killed > 0) console.log('[CLEANUP] Killed ' + killed + ' background process(es)');
-    } catch (e) {
-      // Fallback: try local bin/ (for moflo repo itself)
-      try {
-        var cleanup2 = require(path.join(projectDir, 'bin', 'lib', 'registry-cleanup.cjs'));
-        var killed2 = cleanup2.killTrackedSync(projectDir);
-        if (killed2 > 0) console.log('[CLEANUP] Killed ' + killed2 + ' background process(es)');
-      } catch (e2) { /* non-fatal */ }
-    }
-
-    if (intelligence && intelligence.consolidate) {
-      try {
-        var result = intelligence.consolidate();
-        if (result && result.entries > 0) {
-          var msg = '[INTELLIGENCE] Consolidated: ' + result.entries + ' entries, ' + result.edges + ' edges';
-          if (result.newEntries > 0) msg += ', ' + result.newEntries + ' new';
-          msg += ', PageRank recomputed';
-          console.log(msg);
-        }
-      } catch (e) { /* non-fatal */ }
-    }
-    if (session && session.end) {
-      session.end();
-    } else {
-      console.log('[OK] Session ended');
-    }
-  },
-
-  'pre-task': () => {
-    if (session && session.metric) {
-      try { session.metric('tasks'); } catch (e) { /* no active session */ }
-    }
-    if (router && router.routeTask && prompt) {
-      var result = router.routeTask(prompt);
-      console.log('[INFO] Task routed to: ' + result.agent + ' (confidence: ' + result.confidence + ')');
-    } else {
+  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');
-    }
-  },
-
-  'post-task': () => {
-    if (intelligence && intelligence.feedback) {
+      break;
+    case 'post-task':
+      bumpMetric('tasksCompleted');
+      console.log('[OK] Task completed');
+      break;
+    case 'session-end': {
+      // Kill tracked background processes via shared sync helper
       try {
-        intelligence.feedback(true);
-      } catch (e) { /* non-fatal */ }
-    }
-    console.log('[OK] Task completed');
-  },
-
-  'compact-manual': () => {
-    console.log('PreCompact Guidance:');
-    console.log('IMPORTANT: Review CLAUDE.md in project root for:');
-    console.log('   - Available agents and concurrent usage patterns');
-    console.log('   - Swarm coordination strategies (hierarchical, mesh, adaptive)');
-    console.log('   - Critical concurrent execution rules (1 MESSAGE = ALL OPERATIONS)');
-    console.log('Ready for compact operation');
-  },
-
-  'compact-auto': () => {
-    console.log('Auto-Compact Guidance (Context Window Full):');
-    console.log('CRITICAL: Before compacting, ensure you understand:');
-    console.log('   - All agents available in .claude/agents/ directory');
-    console.log('   - Concurrent execution patterns from CLAUDE.md');
-    console.log('   - Swarm coordination strategies for complex tasks');
-    console.log('Apply GOLDEN RULE: Always batch operations in single messages');
-    console.log('Auto-compact proceeding with full agent context');
-  },
-
-  'status': () => {
-    console.log('[OK] Status check');
-  },
-
-  'stats': () => {
-    if (intelligence && intelligence.stats) {
-      intelligence.stats(args.includes('--json'));
-    } else {
-      console.log('[WARN] Intelligence module not available. Run session-restore first.');
-    }
-  },
-};
-
-if (command && handlers[command]) {
-    try {
-      await handlers[command]();
-    } catch (e) {
-      console.log('[WARN] Hook ' + command + ' encountered an error: ' + e.message);
-    }
-  } else if (command) {
-    console.log('[OK] Hook: ' + command);
-  } else {
-    console.log('Usage: hook-handler.cjs <route|pre-bash|post-edit|session-restore|session-end|pre-task|post-task|compact-manual|compact-auto|status|stats>');
+        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;
   }
-}
-
-main().catch(function(e) {
-  console.log('[WARN] Hook handler error: ' + e.message);
-}).finally(function() {
-  // Ensure clean exit for Claude Code hooks
-  process.exit(0);
 });

package/.claude/helpers/post-commit

@@ -0,0 +1,16 @@
+#!/bin/bash
+# Claude Flow Post-Commit Hook
+# Records commit metrics and trains patterns
+
+COMMIT_HASH=$(git rev-parse HEAD)
+COMMIT_MSG=$(git log -1 --pretty=%B)
+
+echo "📊 Recording commit metrics..."
+
+# Notify claude-flow of commit
+npx moflo hooks notify \
+  --message "Commit: $COMMIT_MSG" \
+  --level info \
+  --metadata '{"hash": "'$COMMIT_HASH'"}' 2>/dev/null || true
+
+echo "✅ Commit recorded"

package/.claude/helpers/pre-commit

@@ -0,0 +1,26 @@
+#!/bin/bash
+# Claude Flow Pre-Commit Hook
+# Validates code quality before commit
+
+set -e
+
+echo "🔍 Running Claude Flow pre-commit checks..."
+
+# Get staged files
+STAGED_FILES=$(git diff --cached --name-only --diff-filter=ACM)
+
+# Run validation for each staged file
+for FILE in $STAGED_FILES; do
+  if [[ "$FILE" =~ \.(ts|js|tsx|jsx)$ ]]; then
+    echo "  Validating: $FILE"
+    npx moflo hooks pre-edit --file "$FILE" --validate-syntax 2>/dev/null || true
+  fi
+done
+
+# Run tests if available
+if [ -f "package.json" ] && grep -q '"test"' package.json; then
+  echo "🧪 Running tests..."
+  npm test --if-present 2>/dev/null || echo "  Tests skipped or failed"
+fi
+
+echo "✅ Pre-commit checks complete"

package/.claude/helpers/prompt-hook.mjs

@@ -0,0 +1,72 @@
+#!/usr/bin/env node
+import { execSync } from 'child_process';
+import { resolve } from 'path';
+
+// Read stdin JSON from Claude Code
+var stdinData = '';
+try {
+  stdinData = await new Promise(function(res) {
+    var data = '';
+    var timeout = setTimeout(function() { res(data); }, 500);
+    process.stdin.setEncoding('utf-8');
+    process.stdin.on('data', function(chunk) { data += chunk; });
+    process.stdin.on('end', function() { clearTimeout(timeout); res(data); });
+    process.stdin.on('error', function() { clearTimeout(timeout); res(''); });
+    if (process.stdin.isTTY) { clearTimeout(timeout); res(''); }
+  });
+} catch (e) { /* no stdin */ }
+
+var hookContext = {};
+try { if (stdinData.trim()) hookContext = JSON.parse(stdinData); } catch (e) {}
+
+var userPrompt = hookContext.user_prompt || hookContext.prompt || '';
+var env = Object.assign({}, process.env, { CLAUDE_USER_PROMPT: userPrompt });
+
+// Run prompt-reminder via gate.cjs
+var projectDir = (env.CLAUDE_PROJECT_DIR || process.cwd()).replace(/^\/([a-z])\//i, '$1:/');
+var gateScript = resolve(projectDir, '.claude/helpers/gate.cjs');
+var output = '';
+try {
+  output = execSync('node "' + gateScript + '" prompt-reminder', {
+    env: env, encoding: 'utf-8', timeout: 3000, stdio: ['pipe', 'pipe', 'pipe']
+  });
+} catch (err) { output = (err && err.stdout) || ''; }
+
+// Classify prompt for namespace hint
+var lower = userPrompt.toLowerCase();
+
+var KNOWLEDGE_ONLY = /\b(knowledge|remember|recall)\b|we (decid|agree|chose|said)/;
+var EXPLICIT_NS = [
+  { pattern: /\b(pattern|convention|best practice|style|coding rule)\b/, ns: 'patterns', label: 'code patterns and conventions' },
+  { pattern: /\b(code.?map|file structure|project structure|directory)\b/, ns: 'code-map', label: 'codebase navigation' },
+];
+var PATTERN_HINTS = [/\b(template|example|similar to|how do we|how should)\b/];
+var DOMAIN_HINTS = [
+  /\b(guidance|guide|docs|documentation|rules|how-to)\b/,
+  /\b(architecture|design|domain|tenant|migrat|schema|deploy)/,
+  /\b(rule|requirement|constraint|compliance)\b/,
+];
+var NAV_PATTERNS = [
+  /\b(find|where|which file|look up|locate|endpoint|route|url|path)\b/,
+  /\b(class|function|method|component|service|entity|module)\b/,
+];
+
+var nsHint = '';
+if (KNOWLEDGE_ONLY.test(lower)) {
+  nsHint = 'Memory namespace hint: use "knowledge" for user-directed project decisions.';
+} else {
+  var found = EXPLICIT_NS.find(function(e) { return e.pattern.test(lower); });
+  if (found) {
+    nsHint = 'Memory namespace hint: use "' + found.ns + '" for ' + found.label + '.';
+  } else if (DOMAIN_HINTS.some(function(p) { return p.test(lower); })) {
+    nsHint = 'Memory namespace hint: search "guidance" and "knowledge" for domain rules and project decisions.';
+  } else if (PATTERN_HINTS.some(function(p) { return p.test(lower); })) {
+    nsHint = 'Memory namespace hint: use "patterns" for code patterns and conventions.';
+  } else if (NAV_PATTERNS.some(function(p) { return p.test(lower); })) {
+    nsHint = 'Memory namespace hint: use "code-map" for codebase navigation.';
+  }
+}
+
+var parts = [output.trim(), nsHint].filter(Boolean);
+if (parts.length) process.stdout.write(parts.join('\n') + '\n');
+process.exit(0);