@aigentic/claude-flow 3.7.0-alpha.69

package/.claude/helpers/health-monitor.sh

@@ -0,0 +1,108 @@
+#!/bin/bash
+# RuFlo V3 - Health Monitor Worker
+# Checks disk space, memory pressure, process health
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="$(cd "$SCRIPT_DIR/../.." && pwd)"
+METRICS_DIR="$PROJECT_ROOT/.claude-flow/metrics"
+HEALTH_FILE="$METRICS_DIR/health.json"
+LAST_RUN_FILE="$METRICS_DIR/.health-last-run"
+
+mkdir -p "$METRICS_DIR"
+
+should_run() {
+  if [ ! -f "$LAST_RUN_FILE" ]; then return 0; fi
+  local last_run=$(cat "$LAST_RUN_FILE" 2>/dev/null || echo "0")
+  local now=$(date +%s)
+  [ $((now - last_run)) -ge 300 ]  # 5 minutes
+}
+
+check_health() {
+  echo "[$(date +%H:%M:%S)] Running health check..."
+
+  # Disk usage
+  local disk_usage=$(df -h "$PROJECT_ROOT" 2>/dev/null | awk 'NR==2 {print $5}' | tr -d '%')
+  local disk_free=$(df -h "$PROJECT_ROOT" 2>/dev/null | awk 'NR==2 {print $4}')
+
+  # Memory usage
+  local mem_total=$(free -m 2>/dev/null | awk '/Mem:/ {print $2}' || echo "0")
+  local mem_used=$(free -m 2>/dev/null | awk '/Mem:/ {print $3}' || echo "0")
+  local mem_pct=$((mem_used * 100 / (mem_total + 1)))
+
+  # Process counts
+  local node_procs=$(pgrep -c node 2>/dev/null || echo "0")
+  local agentic_procs=$(ps aux 2>/dev/null | grep -c "agentic-flow" | grep -v grep || echo "0")
+
+  # CPU load
+  local load_avg=$(cat /proc/loadavg 2>/dev/null | awk '{print $1}' || echo "0")
+
+  # File descriptor usage
+  local fd_used=$(ls /proc/$$/fd 2>/dev/null | wc -l || echo "0")
+
+  # Determine health status
+  local status="healthy"
+  local warnings=""
+
+  if [ "$disk_usage" -gt 90 ]; then
+    status="critical"
+    warnings="$warnings disk_full"
+  elif [ "$disk_usage" -gt 80 ]; then
+    status="warning"
+    warnings="$warnings disk_high"
+  fi
+
+  if [ "$mem_pct" -gt 90 ]; then
+    status="critical"
+    warnings="$warnings memory_full"
+  elif [ "$mem_pct" -gt 80 ]; then
+    [ "$status" != "critical" ] && status="warning"
+    warnings="$warnings memory_high"
+  fi
+
+  # Write health metrics
+  cat > "$HEALTH_FILE" << EOF
+{
+  "status": "$status",
+  "timestamp": "$(date -Iseconds)",
+  "disk": {
+    "usage_pct": $disk_usage,
+    "free": "$disk_free"
+  },
+  "memory": {
+    "total_mb": $mem_total,
+    "used_mb": $mem_used,
+    "usage_pct": $mem_pct
+  },
+  "processes": {
+    "node": $node_procs,
+    "agentic_flow": $agentic_procs
+  },
+  "load_avg": $load_avg,
+  "fd_used": $fd_used,
+  "warnings": "$(echo $warnings | xargs)"
+}
+EOF
+
+  echo "[$(date +%H:%M:%S)] ✓ Health: $status | Disk: ${disk_usage}% | Memory: ${mem_pct}% | Load: $load_avg"
+
+  date +%s > "$LAST_RUN_FILE"
+
+  # Return non-zero if unhealthy
+  [ "$status" = "healthy" ] && return 0 || return 1
+}
+
+case "${1:-check}" in
+  "run") check_health ;;
+  "check") should_run && check_health || echo "[$(date +%H:%M:%S)] Skipping (throttled)" ;;
+  "force") rm -f "$LAST_RUN_FILE"; check_health ;;
+  "status")
+    if [ -f "$HEALTH_FILE" ]; then
+      jq -r '"Status: \(.status) | Disk: \(.disk.usage_pct)% | Memory: \(.memory.usage_pct)% | Load: \(.load_avg)"' "$HEALTH_FILE"
+    else
+      echo "No health data available"
+    fi
+    ;;
+  *) echo "Usage: $0 [run|check|force|status]" ;;
+esac

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

@@ -0,0 +1,269 @@
+#!/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'));
+
+// ── Intelligence timeout protection (fixes #1530, #1531) ───────────────────
+var INTELLIGENCE_TIMEOUT_MS = 3000;
+function runWithTimeout(fn, label) {
+  return new Promise(function(resolve) {
+    var timer = setTimeout(function() {
+      process.stderr.write("[WARN] " + label + " timed out after " + INTELLIGENCE_TIMEOUT_MS + "ms, skipping\n");
+      resolve(null);
+    }, INTELLIGENCE_TIMEOUT_MS);
+    try {
+      var result = fn();
+      clearTimeout(timer);
+      resolve(result);
+    } catch (e) {
+      clearTimeout(timer);
+      resolve(null);
+    }
+  });
+}
+
+
+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(() => {
+      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.resume();
+  });
+}
+
+async function main() {
+  // Global safety timeout: hooks must NEVER hang (#1530, #1531)
+  var safetyTimer = setTimeout(function() {
+    process.stderr.write("[WARN] Hook handler global timeout (5s), forcing exit\n");
+    process.exit(0);
+  }, 5000);
+  safetyTimer.unref();
+
+  let stdinData = '';
+  try { stdinData = await readStdin(); } catch (e) { /* ignore stdin errors */ }
+
+  let hookInput = {};
+  if (stdinData.trim()) {
+    try { hookInput = JSON.parse(stdinData); } catch (e) { /* ignore parse errors */ }
+  }
+
+  // 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.
+  // Normalize snake_case/camelCase: Claude Code sends tool_input/tool_name (snake_case)
+  var toolInput = hookInput.toolInput || hookInput.tool_input || {};
+  var toolName = hookInput.toolName || hookInput.tool_name || '';
+
+  // `toolInput` is an object (e.g. {command:"ls"}) — falling back to it
+  // directly bound `prompt` to the object and tripped `.toLowerCase()` /
+  // `.substring()` on every Bash hook (#1944). Use the `.command` field.
+  var prompt = hookInput.prompt || hookInput.command || toolInput.command
+    || 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': () => {
+    // String() wrap is belt-and-suspenders for #2017: even if a future regression
+    // re-binds `prompt` or `hookInput.command` to a non-string, `.toLowerCase()`
+    // can no longer throw a TypeError that the global try/catch would swallow.
+    var cmd = String(hookInput.command || toolInput.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 || 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('[OK] Session restored: session-' + Date.now());
+    }
+    // Initialize intelligence (with timeout — #1530)
+    if (intelligence && intelligence.init) {
+      var initResult = await runWithTimeout(function() { return intelligence.init(); }, 'intelligence.init()');
+      if (initResult && initResult.nodes > 0) {
+        console.log('[INTELLIGENCE] Loaded ' + initResult.nodes + ' patterns, ' + initResult.edges + ' edges');
+      }
+    }
+  },
+
+  'session-end': async () => {
+    // Consolidate intelligence (with timeout — #1530)
+    if (intelligence && intelligence.consolidate) {
+      var consResult = await runWithTimeout(function() { return intelligence.consolidate(); }, 'intelligence.consolidate()');
+      if (consResult && consResult.entries > 0) {
+        var msg = '[INTELLIGENCE] Consolidated: ' + consResult.entries + ' entries, ' + consResult.edges + ' edges';
+        if (consResult.newEntries > 0) msg += ', ' + consResult.newEntries + ' new';
+        msg += ', PageRank recomputed';
+        console.log(msg);
+      }
+    }
+    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 {
+      console.log('[OK] Task started');
+    }
+  },
+
+  'post-task': () => {
+    if (intelligence && intelligence.feedback) {
+      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 Promise.resolve(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>');
+  }
+}
+
+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/intelligence.cjs

@@ -0,0 +1,230 @@
+#!/usr/bin/env node
+/**
+ * Intelligence Layer Stub (ADR-050)
+ * Minimal fallback — full version is copied from package source.
+ * Provides: init, getContext, recordEdit, feedback, consolidate
+ */
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const DATA_DIR = path.join(process.cwd(), '.claude-flow', 'data');
+const STORE_PATH = path.join(DATA_DIR, 'auto-memory-store.json');
+const RANKED_PATH = path.join(DATA_DIR, 'ranked-context.json');
+const PENDING_PATH = path.join(DATA_DIR, 'pending-insights.jsonl');
+const SESSION_DIR = path.join(process.cwd(), '.claude-flow', 'sessions');
+const SESSION_FILE = path.join(SESSION_DIR, 'current.json');
+
+// ── Safety limits (fixes #1530, #1531) ─────────────────────────────────────
+var MAX_DATA_FILE_SIZE = 10 * 1024 * 1024; // 10 MB — skip files larger than this
+var MAX_GRAPH_NODES = 5000;                 // skip PageRank if graph exceeds this
+
+function ensureDir(dir) {
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+}
+
+function readJSON(p) {
+  // Safety: skip files exceeding MAX_DATA_FILE_SIZE (#1531)
+  try { var stat = fs.statSync(p); if (stat.size > MAX_DATA_FILE_SIZE) { process.stderr.write("[INTELLIGENCE] WARN: Skipping " + path.basename(p) + " (" + Math.round(stat.size / 1048576) + "MB exceeds 10MB limit)\n"); return null; } } catch(e) { /* file may not exist */ }
+  try { return fs.existsSync(p) ? JSON.parse(fs.readFileSync(p, "utf-8")) : null; }
+  catch { return null; }
+}
+
+function writeJSON(p, data) {
+  ensureDir(path.dirname(p));
+  fs.writeFileSync(p, JSON.stringify(data, null, 2), "utf-8");
+}
+
+function sessionGet(key) {
+  var session = readJSON(SESSION_FILE);
+  if (!session) return null;
+  return key ? (session.context || {})[key] : session.context;
+}
+
+function sessionSet(key, value) {
+  var session = readJSON(SESSION_FILE);
+  if (!session) return;
+  if (!session.context) session.context = {};
+  session.context[key] = value;
+  writeJSON(SESSION_FILE, session);
+}
+
+function tokenize(text) {
+  if (!text) return [];
+  return text.toLowerCase().replace(/[^a-z0-9\s]/g, " ").split(/\s+/).filter(function(w) { return w.length > 2; });
+}
+
+// ── Deduplication helper (fixes #1518) ──────────────────────────────────────
+function deduplicateById(entries) {
+  if (!entries || !Array.isArray(entries)) return entries;
+  var seen = new Map();
+  for (var i = 0; i < entries.length; i++) {
+    var id = entries[i].id || entries[i].key;
+    if (id) {
+      seen.set(id, entries[i]);
+    } else {
+      seen.set('__no_id_' + seen.size, entries[i]);
+    }
+  }
+  return Array.from(seen.values());
+}
+
+function bootstrapFromMemoryFiles() {
+  var entries = [];
+  // Scope to current project only (not all 51+ project dirs)
+  var projectSlug = process.cwd().replace(/^\//, '').replace(/\//g, '-');
+  var candidates = [
+    path.join(os.homedir(), ".claude", "projects", projectSlug, "memory"),
+    path.join(process.cwd(), ".claude-flow", "memory"),
+    path.join(process.cwd(), ".claude", "memory"),
+  ];
+  for (var i = 0; i < candidates.length; i++) {
+    try {
+      if (!fs.existsSync(candidates[i])) continue;
+      var files = [];
+      try {
+        var items = fs.readdirSync(candidates[i], { withFileTypes: true, recursive: true });
+        for (var j = 0; j < items.length; j++) {
+          if (items[j].name === "MEMORY.md") {
+            var parentDir = items[j].parentPath || items[j].path || candidates[i];
+            var fp = path.join(parentDir, items[j].name);
+            files.push(fp);
+          }
+        }
+      } catch (e) { continue; }
+      for (var k = 0; k < files.length; k++) {
+        try {
+          var content = fs.readFileSync(files[k], "utf-8");
+          var sections = content.split(/^##\s+/m).filter(function(s) { return s.trim().length > 20; });
+          for (var s = 0; s < sections.length; s++) {
+            var lines = sections[s].split("\n");
+            var title = lines[0] ? lines[0].trim() : "section-" + s;
+            entries.push({
+              id: "mem-" + entries.length,
+              content: sections[s].substring(0, 500),
+              summary: title.substring(0, 100),
+              category: "memory",
+              confidence: 0.5,
+              sourceFile: files[k],
+              words: tokenize(sections[s].substring(0, 500)),
+            });
+          }
+        } catch (e) { /* skip */ }
+      }
+    } catch (e) { /* skip */ }
+  }
+  return entries;
+}
+
+function loadEntries() {
+  var store = readJSON(STORE_PATH);
+  // Support both formats: flat array or { entries: [...] }
+  var entries = null;
+  if (store) {
+    if (Array.isArray(store) && store.length > 0) {
+      entries = store;
+    } else if (store.entries && store.entries.length > 0) {
+      entries = store.entries;
+    }
+  }
+  if (entries) {
+    return entries.map(function(e, i) {
+      return {
+        id: e.id || ("entry-" + i),
+        content: e.content || e.value || "",
+        summary: e.summary || e.key || "",
+        category: e.category || e.namespace || "default",
+        confidence: e.confidence || 0.5,
+        sourceFile: e.sourceFile || (e.metadata && e.metadata.sourceFile) || "",
+        words: tokenize((e.content || e.value || "") + " " + (e.summary || e.key || "")),
+      };
+    });
+  }
+  return bootstrapFromMemoryFiles();
+}
+
+function matchScore(promptWords, entryWords) {
+  if (!promptWords.length || !entryWords.length) return 0;
+  var entrySet = {};
+  for (var i = 0; i < entryWords.length; i++) entrySet[entryWords[i]] = true;
+  var overlap = 0;
+  for (var j = 0; j < promptWords.length; j++) {
+    if (entrySet[promptWords[j]]) overlap++;
+  }
+  var union = Object.keys(entrySet).length + promptWords.length - overlap;
+  return union > 0 ? overlap / union : 0;
+}
+
+var cachedEntries = null;
+
+module.exports = {
+  init: function() {
+    cachedEntries = deduplicateById(loadEntries());
+    var ranked = cachedEntries.map(function(e) {
+      return { id: e.id, content: e.content, summary: e.summary, category: e.category, confidence: e.confidence, words: e.words };
+    });
+    writeJSON(RANKED_PATH, { version: 1, computedAt: Date.now(), entries: ranked });
+    return { nodes: cachedEntries.length, edges: 0 };
+  },
+
+  getContext: function(prompt) {
+    if (!prompt) return null;
+    var ranked = readJSON(RANKED_PATH);
+    var entries = (ranked && ranked.entries) || (cachedEntries || []);
+    if (!entries.length) return null;
+    var promptWords = tokenize(prompt);
+    if (!promptWords.length) return null;
+    var scored = entries.map(function(e) {
+      return { entry: e, score: matchScore(promptWords, e.words || tokenize(e.content + " " + e.summary)) };
+    }).filter(function(s) { return s.score > 0.05; });
+    scored.sort(function(a, b) { return b.score - a.score; });
+    var top = scored.slice(0, 5);
+    if (!top.length) return null;
+    var prevMatched = sessionGet("lastMatchedPatterns");
+    var matchedIds = top.map(function(s) { return s.entry.id; });
+    sessionSet("lastMatchedPatterns", matchedIds);
+    var lines = ["[INTELLIGENCE] Relevant patterns for this task:"];
+    for (var j = 0; j < top.length; j++) {
+      var e = top[j];
+      var conf = e.entry.confidence || 0.5;
+      var summary = (e.entry.summary || e.entry.content || "").substring(0, 80);
+      lines.push("  * (" + conf.toFixed(2) + ") " + summary);
+    }
+    return lines.join("\n");
+  },
+
+  recordEdit: function(file) {
+    if (!file) return;
+    ensureDir(DATA_DIR);
+    var line = JSON.stringify({ type: "edit", file: file, timestamp: Date.now() }) + "\n";
+    fs.appendFileSync(PENDING_PATH, line, "utf-8");
+  },
+
+  feedback: function(success) {
+    // Stub: no-op in minimal version
+  },
+
+  consolidate: function() {
+    var count = 0;
+    if (fs.existsSync(PENDING_PATH)) {
+      try {
+        var content = fs.readFileSync(PENDING_PATH, "utf-8").trim();
+        count = content ? content.split("\n").length : 0;
+        fs.writeFileSync(PENDING_PATH, "", "utf-8");
+      } catch (e) { /* skip */ }
+    }
+    return { entries: count, edges: 0, newEntries: 0 };
+  },
+
+  stats: function(json) {
+    var ranked = readJSON(RANKED_PATH);
+    var count = ranked && ranked.entries ? ranked.entries.length : 0;
+    if (json) {
+      console.log(JSON.stringify({ entries: count, computedAt: ranked ? ranked.computedAt : null }));
+    } else {
+      console.log('[INTELLIGENCE] Stats: ' + count + ' entries loaded');
+    }
+  },
+};