odd-flow 1.0.0

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,234 @@
+#!/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(() => {
+      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() {
+  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.
+  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': () => {
+    if (session) {
+      var existing = session.restore && session.restore();
+      if (!existing) {
+        session.start && session.start();
+      }
+    } else {
+      console.log('[OK] Session restored: 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 */ }
+    }
+  },
+
+  'session-end': () => {
+    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 {
+      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 {
+      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,207 @@
+#!/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');
+
+function ensureDir(dir) {
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+}
+
+function readJSON(p) {
+  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; });
+}
+
+function bootstrapFromMemoryFiles() {
+  var entries = [];
+  var candidates = [
+    path.join(os.homedir(), ".claude", "projects"),
+    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 = 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');
+    }
+  },
+};