swarmdo 1.58.18 → 1.58.23

package/v3/@swarmdo/cli/.claude/helpers/hook-handler.cjs

@@ -2,15 +2,6 @@
 /**
  * Swarmdo Hook Handler (Cross-Platform)
  * Dispatches hook events to the appropriate helper modules.
- *
- * Usage: node hook-handler.cjs <command> [args...]
- *
- * Commands:
- *   route          - Route a task to optimal agent (reads PROMPT from env/stdin)
- *   pre-bash       - Validate command safety before execution
- *   post-edit      - Record edit outcome for learning
- *   session-restore - Restore previous session state
- *   session-end    - End session and persist state
  */
 
 const path = require('path');
@@ -18,9 +9,6 @@ const fs = require('fs');
 
 const helpersDir = __dirname;
 
-// Safe require with stdout suppression - the helper modules have CLI
-// sections that run unconditionally on require(), so we mute console
-// during the require to prevent noisy output.
 function safeRequire(modulePath) {
   try {
     if (fs.existsSync(modulePath)) {
@@ -42,43 +30,52 @@ function safeRequire(modulePath) {
   return null;
 }
 
-const router = safeRequire(path.join(helpersDir, 'router.js'));
-const session = safeRequire(path.join(helpersDir, 'session.js'));
-const memory = safeRequire(path.join(helpersDir, 'memory.js'));
+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 agentBridge = safeRequire(path.join(helpersDir, 'agent-bridge-hook.cjs'));
 
 // ── Intelligence timeout protection (fixes #1530, #1531) ───────────────────
-const INTELLIGENCE_TIMEOUT_MS = 3000;
-// Race the (possibly-async) work against a real timeout. The previous version
-// called fn() and clearTimeout(timer) immediately, so an async fn returned a
-// pending promise that resolved THROUGH the race — the timeout protected
-// nothing. This settles on whichever finishes first, then clears the timer.
+var INTELLIGENCE_TIMEOUT_MS = 3000;
+// Race the (possibly-async) work against a real timeout.
 //
-// LIMITATION: a synchronous blocking fn (the current intelligence.init() does
-// blocking fs reads) cannot be interrupted by any in-process timer — the event
-// loop is blocked. The real guard for that case is the readJSON file-size
-// limit in intelligence.cjs. This util only bounds work that yields (async I/O).
+// The previous implementation called `fn()` and then `clearTimeout(timer)`
+// immediately — but if `fn()` returns a *pending* promise (async work), the
+// timer was cancelled before the work settled and the promise resolved with the
+// still-pending promise, so the timeout protected nothing. This version only
+// settles when the work resolves OR the timeout fires, whichever comes first,
+// and clears the timer afterwards.
+//
+// LIMITATION (be honest): a *synchronous* CPU-bound `fn` (e.g. the current
+// intelligence.init(), which does blocking fs reads) cannot be interrupted by
+// any in-process timer — the event loop is blocked, so the timeout callback
+// can't run until `fn` already returned. The real guard for that case lives in
+// intelligence.cjs (MAX_DATA_FILE_SIZE / MAX_GRAPH_NODES caps). This util only
+// bounds work that yields to the event loop (async I/O, dynamic import, etc.).
 function runWithTimeout(fn, label) {
-  let timer;
-  const timeout = new Promise((resolve) => {
-    timer = setTimeout(() => {
+  var timer;
+  var timeout = new Promise(function(resolve) {
+    timer = setTimeout(function() {
       process.stderr.write("[WARN] " + label + " timed out after " + INTELLIGENCE_TIMEOUT_MS + "ms, skipping\n");
       resolve(null);
     }, INTELLIGENCE_TIMEOUT_MS);
   });
-  const work = Promise.resolve().then(fn).catch(() => null);
-  return Promise.race([work, timeout]).then((result) => {
+  // Promise.resolve().then(fn) turns a synchronous throw into a rejection so it
+  // is handled here rather than escaping the Promise constructor.
+  var work = Promise.resolve().then(fn).catch(function() { return null; });
+  return Promise.race([work, timeout]).then(function(result) {
     clearTimeout(timer);
     return result;
   });
 }
 
 
-// Get the command from argv
 const [,, command, ...args] = process.argv;
 
-// Read stdin with timeout — Claude Code sends hook data as JSON via stdin.
-// Timeout prevents hanging when stdin is not properly closed (common on Windows).
+// 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) => {
@@ -98,11 +95,11 @@ async function readStdin() {
 
 async function main() {
   // Global safety timeout: hooks must NEVER hang (#1530, #1531)
-  const safetyTimer = setTimeout(() => {
+  var safetyTimer = setTimeout(function() {
     process.stderr.write("[WARN] Hook handler global timeout (5s), forcing exit\n");
     process.exit(0);
   }, 5000);
-  safetyTimer.unref(); // don't keep process alive just for this timer
+  safetyTimer.unref();
 
   let stdinData = '';
   try { stdinData = await readStdin(); } catch (e) { /* ignore stdin errors */ }
@@ -112,21 +109,21 @@ async function main() {
     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)
-  const toolInput = hookInput.toolInput || hookInput.tool_input || {};
-  const toolName = hookInput.toolName || hookInput.tool_name || '';
+  var toolInput = hookInput.toolInput || hookInput.tool_input || {};
+  var toolName = hookInput.toolName || hookInput.tool_name || '';
 
-  // Merge stdin data into prompt resolution: prefer stdin fields, then env, then argv.
-  // `toolInput` is an object (e.g. {command:"ls"}) — it's truthy but not a string,
-  // so falling back to it directly bound `prompt` to the object and tripped
-  // `.toLowerCase()` / `.substring()` on every Bash hook (#1944). Use the
-  // `.command` field instead, which is the actual string the hook needs.
-  const prompt = hookInput.prompt || hookInput.command || toolInput.command
-    || process.env.PROMPT || process.env.TOOL_INPUT_command || args.join(' ') || '';
+  // `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': () => {
-    // Inject ranked intelligence context before routing
     if (intelligence && intelligence.getContext) {
       try {
         const ctx = intelligence.getContext(prompt);
@@ -135,33 +132,49 @@ const handlers = {
     }
     if (router && router.routeTask) {
       const result = router.routeTask(prompt);
-      // Format output for Claude Code hook consumption — real data only
-      const output = [
-        `[INFO] Routing task: ${prompt.substring(0, 80) || '(no prompt)'}`,
-        '',
-        '+------------------- Primary Recommendation -------------------+',
-        `| Agent: ${result.agent.padEnd(53)}|`,
-        `| Confidence: ${(result.confidence * 100).toFixed(1)}%${' '.repeat(44)}|`,
-        `| Reason: ${(result.reason || '').substring(0, 53).padEnd(53)}|`,
-        '+--------------------------------------------------------------+',
-      ];
+      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');
     }
+    // Agentic prompts → suggest spawning a swarm, and which roles. Swarmdo
+    // cannot call Claude Code's Agent tool itself, so this advisory is the only
+    // way it can ask. Fully guarded — never breaks the prompt.
+    //
+    // Deliberately does NOT mention `agent bridge register` (#108): the
+    // SubagentStart hook registers every subagent on spawn, so telling the main
+    // agent to register by hand is both wrong and redundant work. This fires on
+    // every agentic prompt, so it is kept to one line — the three lines of
+    // manual-registration instructions it replaced were pure token cost.
+    try {
+      if (router && router.classifyAgentic) {
+        const intent = router.classifyAgentic(prompt);
+        if (intent.requiresAgents) {
+          const roles = intent.roles.join(', ');
+          console.log('');
+          console.log('[SWARMDO] Agentic task — consider spawning agents: ' + roles
+            + '  (auto-registered on spawn; see `swarmdo swarm status`)');
+        }
+      }
+    } catch (e) { /* advisory only — never break the prompt */ }
   },
 
   'pre-bash': () => {
-    // Basic command safety check — prefer stdin command data from Claude Code.
     // 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
-    // (silently exiting 0 and letting the dangerous command through).
-    const cmd = String(hookInput.command || toolInput.command || prompt || '').toLowerCase();
-    const dangerous = ['rm -rf /', 'format c:', 'del /s /q c:\\', ':(){:|:&};:'];
-    for (const d of dangerous) {
-      if (cmd.includes(d)) {
-        console.error(`[BLOCKED] Dangerous command detected: ${d}`);
+    // 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);
       }
     }
@@ -169,14 +182,12 @@ const handlers = {
   },
 
   'post-edit': () => {
-    // Record edit for session metrics
     if (session && session.metric) {
       try { session.metric('edits'); } catch (e) { /* no active session */ }
     }
-    // Record edit for intelligence consolidation — prefer stdin data from Claude Code
     if (intelligence && intelligence.recordEdit) {
       try {
-        const file = hookInput.file_path || toolInput.file_path
+        var file = hookInput.file_path || toolInput.file_path
           || process.env.TOOL_INPUT_file_path || args[0] || '';
         intelligence.recordEdit(file);
       } catch (e) { /* non-fatal */ }
@@ -186,43 +197,31 @@ const handlers = {
 
   'session-restore': async () => {
     if (session) {
-      // Try restore first, fall back to start
-      const existing = session.restore && session.restore();
+      var existing = session.restore && session.restore();
       if (!existing) {
         session.start && session.start();
       }
     } else {
-      // Minimal session restore output
-      const sessionId = `session-${Date.now()}`;
-      console.log(`[INFO] Restoring session: %SESSION_ID%`);
-      console.log('');
-      console.log(`[OK] Session restored from %SESSION_ID%`);
-      console.log(`New session ID: ${sessionId}`);
-      console.log('');
-      console.log('Restored State');
-      console.log('+----------------+-------+');
-      console.log('| Item           | Count |');
-      console.log('+----------------+-------+');
-      console.log('| Tasks          |     0 |');
-      console.log('| Agents         |     0 |');
-      console.log('| Memory Entries |     0 |');
-      console.log('+----------------+-------+');
+      console.log('[OK] Session restored: session-' + Date.now());
     }
-    // Initialize intelligence graph after session restore (with timeout — #1530)
+    // Initialize intelligence (with timeout — #1530)
     if (intelligence && intelligence.init) {
-      const initResult = await runWithTimeout(() => intelligence.init(), '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`);
+        console.log('[INTELLIGENCE] Loaded ' + initResult.nodes + ' patterns, ' + initResult.edges + ' edges');
       }
     }
   },
 
   'session-end': async () => {
-    // Consolidate intelligence before ending session (with timeout — #1530)
+    // Consolidate intelligence (with timeout — #1530)
     if (intelligence && intelligence.consolidate) {
-      const consResult = await runWithTimeout(() => intelligence.consolidate(), 'intelligence.consolidate()');
+      var consResult = await runWithTimeout(function() { return intelligence.consolidate(); }, 'intelligence.consolidate()');
       if (consResult && consResult.entries > 0) {
-        console.log(`[INTELLIGENCE] Consolidated: ${consResult.entries} entries, ${consResult.edges} edges${consResult.newEntries > 0 ? `, ${consResult.newEntries} new` : ''}, PageRank recomputed`);
+        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) {
@@ -236,17 +235,15 @@ const handlers = {
     if (session && session.metric) {
       try { session.metric('tasks'); } catch (e) { /* no active session */ }
     }
-    // Route the task if router is available
     if (router && router.routeTask && prompt) {
-      const result = router.routeTask(prompt);
-      console.log(`[INFO] Task routed to: ${result.agent} (confidence: ${result.confidence})`);
+      var result = router.routeTask(prompt);
+      console.log('[INFO] Task routed to: ' + result.agent + ' (confidence: ' + result.confidence + ')');
     } else {
       console.log('[OK] Task started');
     }
   },
 
   'post-task': () => {
-    // Implicit success feedback for intelligence
     if (intelligence && intelligence.feedback) {
       try {
         intelligence.feedback(true);
@@ -255,6 +252,50 @@ const handlers = {
     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');
+  },
+
+  // SubagentStart — bind the spawned Claude Code subagent into Swarmdo's
+  // canonical registry so `swarmdo agent list` and the statusline's
+  // `🐝 Swarms N   🤖 Agents M` reflect agents that actually exist (#108).
+  // Registering also auto-forms the swarm, so both counters move.
+  'agent-register': () => {
+    if (!agentBridge) return;
+    if (!agentBridge.isSubagentEvent(hookInput)) return; // main-thread call
+    var ok = agentBridge.register(hookInput);
+    console.log(ok
+      ? '[OK] Bridged subagent ' + (hookInput.agent_type || 'agent') + ' into Swarmdo'
+      : '[WARN] Could not bridge subagent (no installed CLI found)');
+  },
+
+  // SubagentStop — mark the bound record terminated so the Agents count
+  // decrements. Same deterministic id the register side derived (#108).
+  'agent-terminate': () => {
+    if (!agentBridge) return;
+    if (!agentBridge.isSubagentEvent(hookInput)) return;
+    agentBridge.terminate(hookInput);
+  },
+
   'stats': () => {
     if (intelligence && intelligence.stats) {
       intelligence.stats(args.includes('--json'));
@@ -264,27 +305,29 @@ const handlers = {
   },
 };
 
-  // Execute the handler
-  if (command && handlers[command]) {
+if (command && handlers[command]) {
     try {
       await Promise.resolve(handlers[command]());
     } catch (e) {
-      // Hooks should never crash Claude Code - fail silently
-      console.log(`[WARN] Hook ${command} encountered an error: ${e.message}`);
+      console.log('[WARN] Hook ' + command + ' encountered an error: ' + e.message);
     }
   } else if (command) {
-    // Unknown command - pass through without error
-    console.log(`[OK] Hook: ${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|stats>');
+    console.log('Usage: hook-handler.cjs <route|pre-bash|post-edit|session-restore|session-end|pre-task|post-task|agent-register|agent-terminate|compact-manual|compact-auto|status|stats>');
   }
 }
 
-// Hooks must ALWAYS exit 0 — Claude Code treats non-zero as "hook error"
-// and skips all subsequent hooks for the event.
-process.exitCode = 0;
-main().catch((e) => {
-  try { console.log(`[WARN] Hook handler error: ${e.message}`); } catch (_) {}
-}).finally(() => {
-  process.exit(0);
-});
+// Only dispatch hooks when run directly (node hook-handler.cjs ...). When
+// require()'d by a test, just expose the internals so they can be unit-tested
+// without triggering stdin reads / process.exit.
+if (require.main === module) {
+  main().catch(function(e) {
+    console.log('[WARN] Hook handler error: ' + e.message);
+  }).finally(function() {
+    // Ensure clean exit for Claude Code hooks
+    process.exit(0);
+  });
+}
+
+module.exports = { runWithTimeout: runWithTimeout, INTELLIGENCE_TIMEOUT_MS: INTELLIGENCE_TIMEOUT_MS };