claude-flow 3.32.8 → 3.32.10

package/.claude-plugin/scripts/ruflo-hook.cjs

@@ -1,166 +1,166 @@
-#!/usr/bin/env node
-/**
- * ruflo-hook.cjs — cross-platform Node.js port of ruflo-hook.sh (#2132)
- *
- * The bash shim (ruflo-hook.sh) works on Mac/Linux but fails on native
- * Windows (exit 126 — "cannot execute binary file"). This .cjs shim
- * provides identical behaviour via Node.js child_process so Windows users
- * get working hooks without WSL or Git Bash.
- *
- * Mac/Linux continue to use ruflo-hook.sh via the plugin hooks.json files
- * (unchanged). On Windows, ruflo init writes a .claude/settings.json that
- * overrides those entries with node-based equivalents pointing here.
- *
- * Behaviour mirrors ruflo-hook.sh:
- *   1. Reads hook JSON payload from stdin.
- *   2. Prefers a locally installed `ruflo` or `claude-flow` binary.
- *   3. Falls back to `npx --prefer-offline ruflo@latest`.
- *   4. Always exits 0 — hook subcommands are best-effort telemetry.
- *   5. Swallows all stderr — nothing should surface to Claude Code.
- *
- * Usage: node ruflo-hook.cjs <hook-subcommand> [args...]
- *   e.g. node ruflo-hook.cjs post-edit --file "x.ts" --train-patterns
- */
-
-'use strict';
-
-const { spawnSync, execSync } = require('child_process');
-const fs = require('fs');
-const path = require('path');
-
-/** Exit 0 unconditionally — hooks must never block a turn */
-function done() {
-  process.exit(0);
-}
-
-/** Resolve stdin to a JSON object, or null if not parseable */
-function readStdinJson() {
-  try {
-    let buf = '';
-    // Read synchronously — hooks fire synchronously in Claude Code
-    const fd = fs.openSync('/dev/stdin', 'r');
-    const chunk = Buffer.alloc(64 * 1024);
-    let bytesRead;
-    while ((bytesRead = fs.readSync(fd, chunk, 0, chunk.length, null)) > 0) {
-      buf += chunk.slice(0, bytesRead).toString('utf8');
-    }
-    fs.closeSync(fd);
-    return buf.trim() ? JSON.parse(buf) : null;
-  } catch {
-    return null;
-  }
-}
-
-/** Read stdin via process.stdin in sync mode (Windows-safe alternative) */
-function readStdinSync() {
-  try {
-    // On Windows /dev/stdin doesn't exist; use fd 0 directly
-    const chunk = Buffer.alloc(64 * 1024);
-    let buf = '';
-    let bytesRead;
-    while (true) {
-      try {
-        bytesRead = fs.readSync(0 /* STDIN_FILENO */, chunk, 0, chunk.length, null);
-        if (bytesRead === 0) break;
-        buf += chunk.slice(0, bytesRead).toString('utf8');
-      } catch {
-        break;
-      }
-    }
-    return buf.trim() ? JSON.parse(buf) : null;
-  } catch {
-    return null;
-  }
-}
-
-/** Check if a binary is available on PATH */
-function commandExists(cmd) {
-  try {
-    const result = execSync(
-      process.platform === 'win32' ? `where ${cmd}` : `command -v ${cmd}`,
-      { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }
-    );
-    return result.trim().length > 0;
-  } catch {
-    return false;
-  }
-}
-
-/** Build the argv for the ruflo/claude-flow/npx invocation */
-function buildArgs(subcommand, extraArgs) {
-  // The `hooks` word is prepended here, matching ruflo-hook.sh convention.
-  return ['hooks', subcommand, ...extraArgs];
-}
-
-/**
- * Spawn the CLI with the hook subcommand.
- * Passes the raw stdin payload as the child's stdin so the CLI can read
- * the hook event JSON if needed (same as the bash pipe).
- *
- * Returns true on success (exit 0), false otherwise.
- */
-function invokeHook(bin, binArgs, hookArgs, stdinData) {
-  const args = [...binArgs, ...hookArgs];
-
-  // On Windows, shell: true is needed to resolve .cmd shims in node_modules
-  const useShell = process.platform === 'win32';
-
-  const result = spawnSync(bin, args, {
-    shell: useShell,
-    input: stdinData || '',
-    encoding: 'utf8',
-    stdio: ['pipe', 'ignore', 'ignore'],  // swallow all output
-    timeout: 30_000,
-  });
-
-  return result.status === 0;
-}
-
-function main() {
-  const args = process.argv.slice(2);
-  if (args.length === 0) {
-    // No subcommand — no-op, same as bash version
-    done();
-  }
-
-  const [subcommand, ...rest] = args;
-
-  // Read stdin (the hook event payload) — best effort
-  let stdinData = '';
-  try {
-    stdinData = fs.readFileSync(0 /* fd 0 = stdin */, 'utf8');
-  } catch {
-    // stdin may not be available when invoked directly for testing
-    stdinData = '';
-  }
-
-  const hookArgs = buildArgs(subcommand, rest);
-
-  // Priority 1: locally installed ruflo binary
-  if (commandExists('ruflo')) {
-    invokeHook('ruflo', [], hookArgs, stdinData);
-    done();
-  }
-
-  // Priority 2: locally installed claude-flow binary
-  if (commandExists('claude-flow')) {
-    invokeHook('claude-flow', [], hookArgs, stdinData);
-    done();
-  }
-
-  // Priority 3: npx --prefer-offline fallback (avoids cold registry resolve).
-  //
-  // SKIP this when RUFLO_HOOK_SKIP_NPX=1 — used by CI smokes that test
-  // the shim's *control flow* without exercising npm install network paths.
-  // Without the skip, npx can take 30+s on a cold runner (no warm cache,
-  // no offline tarball), exceeding the smoke's 15s timeout and producing
-  // a spurious failure even though the shim itself works correctly.
-  // The bash version doesn't hit this because it backgrounded the work.
-  if (process.env.RUFLO_HOOK_SKIP_NPX !== '1') {
-    invokeHook('npx', ['--prefer-offline', '--yes', 'ruflo@latest'], hookArgs, stdinData);
-  }
-
-  done();
-}
-
-main();
+#!/usr/bin/env node
+/**
+ * ruflo-hook.cjs — cross-platform Node.js port of ruflo-hook.sh (#2132)
+ *
+ * The bash shim (ruflo-hook.sh) works on Mac/Linux but fails on native
+ * Windows (exit 126 — "cannot execute binary file"). This .cjs shim
+ * provides identical behaviour via Node.js child_process so Windows users
+ * get working hooks without WSL or Git Bash.
+ *
+ * Mac/Linux continue to use ruflo-hook.sh via the plugin hooks.json files
+ * (unchanged). On Windows, ruflo init writes a .claude/settings.json that
+ * overrides those entries with node-based equivalents pointing here.
+ *
+ * Behaviour mirrors ruflo-hook.sh:
+ *   1. Reads hook JSON payload from stdin.
+ *   2. Prefers a locally installed `ruflo` or `claude-flow` binary.
+ *   3. Falls back to `npx --prefer-offline ruflo@latest`.
+ *   4. Always exits 0 — hook subcommands are best-effort telemetry.
+ *   5. Swallows all stderr — nothing should surface to Claude Code.
+ *
+ * Usage: node ruflo-hook.cjs <hook-subcommand> [args...]
+ *   e.g. node ruflo-hook.cjs post-edit --file "x.ts" --train-patterns
+ */
+
+'use strict';
+
+const { spawnSync, execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+/** Exit 0 unconditionally — hooks must never block a turn */
+function done() {
+  process.exit(0);
+}
+
+/** Resolve stdin to a JSON object, or null if not parseable */
+function readStdinJson() {
+  try {
+    let buf = '';
+    // Read synchronously — hooks fire synchronously in Claude Code
+    const fd = fs.openSync('/dev/stdin', 'r');
+    const chunk = Buffer.alloc(64 * 1024);
+    let bytesRead;
+    while ((bytesRead = fs.readSync(fd, chunk, 0, chunk.length, null)) > 0) {
+      buf += chunk.slice(0, bytesRead).toString('utf8');
+    }
+    fs.closeSync(fd);
+    return buf.trim() ? JSON.parse(buf) : null;
+  } catch {
+    return null;
+  }
+}
+
+/** Read stdin via process.stdin in sync mode (Windows-safe alternative) */
+function readStdinSync() {
+  try {
+    // On Windows /dev/stdin doesn't exist; use fd 0 directly
+    const chunk = Buffer.alloc(64 * 1024);
+    let buf = '';
+    let bytesRead;
+    while (true) {
+      try {
+        bytesRead = fs.readSync(0 /* STDIN_FILENO */, chunk, 0, chunk.length, null);
+        if (bytesRead === 0) break;
+        buf += chunk.slice(0, bytesRead).toString('utf8');
+      } catch {
+        break;
+      }
+    }
+    return buf.trim() ? JSON.parse(buf) : null;
+  } catch {
+    return null;
+  }
+}
+
+/** Check if a binary is available on PATH */
+function commandExists(cmd) {
+  try {
+    const result = execSync(
+      process.platform === 'win32' ? `where ${cmd}` : `command -v ${cmd}`,
+      { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }
+    );
+    return result.trim().length > 0;
+  } catch {
+    return false;
+  }
+}
+
+/** Build the argv for the ruflo/claude-flow/npx invocation */
+function buildArgs(subcommand, extraArgs) {
+  // The `hooks` word is prepended here, matching ruflo-hook.sh convention.
+  return ['hooks', subcommand, ...extraArgs];
+}
+
+/**
+ * Spawn the CLI with the hook subcommand.
+ * Passes the raw stdin payload as the child's stdin so the CLI can read
+ * the hook event JSON if needed (same as the bash pipe).
+ *
+ * Returns true on success (exit 0), false otherwise.
+ */
+function invokeHook(bin, binArgs, hookArgs, stdinData) {
+  const args = [...binArgs, ...hookArgs];
+
+  // On Windows, shell: true is needed to resolve .cmd shims in node_modules
+  const useShell = process.platform === 'win32';
+
+  const result = spawnSync(bin, args, {
+    shell: useShell,
+    input: stdinData || '',
+    encoding: 'utf8',
+    stdio: ['pipe', 'ignore', 'ignore'],  // swallow all output
+    timeout: 30_000,
+  });
+
+  return result.status === 0;
+}
+
+function main() {
+  const args = process.argv.slice(2);
+  if (args.length === 0) {
+    // No subcommand — no-op, same as bash version
+    done();
+  }
+
+  const [subcommand, ...rest] = args;
+
+  // Read stdin (the hook event payload) — best effort
+  let stdinData = '';
+  try {
+    stdinData = fs.readFileSync(0 /* fd 0 = stdin */, 'utf8');
+  } catch {
+    // stdin may not be available when invoked directly for testing
+    stdinData = '';
+  }
+
+  const hookArgs = buildArgs(subcommand, rest);
+
+  // Priority 1: locally installed ruflo binary
+  if (commandExists('ruflo')) {
+    invokeHook('ruflo', [], hookArgs, stdinData);
+    done();
+  }
+
+  // Priority 2: locally installed claude-flow binary
+  if (commandExists('claude-flow')) {
+    invokeHook('claude-flow', [], hookArgs, stdinData);
+    done();
+  }
+
+  // Priority 3: npx --prefer-offline fallback (avoids cold registry resolve).
+  //
+  // SKIP this when RUFLO_HOOK_SKIP_NPX=1 — used by CI smokes that test
+  // the shim's *control flow* without exercising npm install network paths.
+  // Without the skip, npx can take 30+s on a cold runner (no warm cache,
+  // no offline tarball), exceeding the smoke's 15s timeout and producing
+  // a spurious failure even though the shim itself works correctly.
+  // The bash version doesn't hit this because it backgrounded the work.
+  if (process.env.RUFLO_HOOK_SKIP_NPX !== '1') {
+    invokeHook('npx', ['--prefer-offline', '--yes', 'ruflo@latest'], hookArgs, stdinData);
+  }
+
+  done();
+}
+
+main();

package/.claude-plugin/scripts/ruflo-hook.sh

@@ -1,52 +1,52 @@
-#!/usr/bin/env bash
-# ruflo-hook.sh — resilient invoker for ruflo CLI hook subcommands (#1921).
-#
-# Hooks fire on EVERY PreToolUse / PostToolUse / Stop. A bare
-# `npx <pkg>@alpha hooks …` re-resolves the @alpha dist-tag and re-installs
-# from cold cache on every fire, and when the install crashes (e.g. an
-# arborist `Invalid Version` on npm 10.8.x) the user sees a hook error in
-# Claude Code after every turn. This shim:
-#   1. prefers an already-installed `ruflo` / `claude-flow` binary (no npx,
-#      no install) — the common case for plugin users;
-#   2. falls back to `npx --prefer-offline` so a populated npx cache is
-#      reused instead of a fresh registry resolve;
-#   3. ALWAYS exits 0 — hook subcommands are best-effort telemetry/learning;
-#      a failure must never surface an error or block a turn.
-#
-# stdin (the hook event JSON) is passed through to the CLI unchanged.
-# Usage: ruflo-hook.sh <hook-subcommand> [args…]   (the literal `hooks`
-# word is prepended here, so callers pass e.g. `post-edit -f "$FILE" -s true`).
-
-# Swallow all diagnostics — nothing this script prints should reach the host.
-# stdout is silenced too because Cursor (#2613) imports Claude Code hooks under
-# its stricter `preToolUse` contract that requires valid-JSON stdout and
-# fail-closes on any other text. Claude Code doesn't consume this stdout either,
-# so redirecting it is a pure cleanup with no functional cost.
-exec 1>/dev/null 2>/dev/null
-
-# Bound every hook process. A partially initialized native embedding pool can
-# otherwise keep a logically completed Stop hook alive indefinitely (#2691).
-run() {
-  "$@" &
-  child=$!
-  (
-    sleep 15
-    kill -TERM "$child" 2>/dev/null || true
-    sleep 1
-    kill -KILL "$child" 2>/dev/null || true
-  ) &
-  watchdog=$!
-  wait "$child" 2>/dev/null || true
-  kill "$watchdog" 2>/dev/null || true
-  wait "$watchdog" 2>/dev/null || true
-}
-
-if command -v ruflo >/dev/null 2>&1; then
-  run ruflo hooks "$@"
-elif command -v claude-flow >/dev/null 2>&1; then
-  run claude-flow hooks "$@"
-else
-  run npx --prefer-offline --yes ruflo@latest hooks "$@"
-fi
-
-exit 0
+#!/usr/bin/env bash
+# ruflo-hook.sh — resilient invoker for ruflo CLI hook subcommands (#1921).
+#
+# Hooks fire on EVERY PreToolUse / PostToolUse / Stop. A bare
+# `npx <pkg>@alpha hooks …` re-resolves the @alpha dist-tag and re-installs
+# from cold cache on every fire, and when the install crashes (e.g. an
+# arborist `Invalid Version` on npm 10.8.x) the user sees a hook error in
+# Claude Code after every turn. This shim:
+#   1. prefers an already-installed `ruflo` / `claude-flow` binary (no npx,
+#      no install) — the common case for plugin users;
+#   2. falls back to `npx --prefer-offline` so a populated npx cache is
+#      reused instead of a fresh registry resolve;
+#   3. ALWAYS exits 0 — hook subcommands are best-effort telemetry/learning;
+#      a failure must never surface an error or block a turn.
+#
+# stdin (the hook event JSON) is passed through to the CLI unchanged.
+# Usage: ruflo-hook.sh <hook-subcommand> [args…]   (the literal `hooks`
+# word is prepended here, so callers pass e.g. `post-edit -f "$FILE" -s true`).
+
+# Swallow all diagnostics — nothing this script prints should reach the host.
+# stdout is silenced too because Cursor (#2613) imports Claude Code hooks under
+# its stricter `preToolUse` contract that requires valid-JSON stdout and
+# fail-closes on any other text. Claude Code doesn't consume this stdout either,
+# so redirecting it is a pure cleanup with no functional cost.
+exec 1>/dev/null 2>/dev/null
+
+# Bound every hook process. A partially initialized native embedding pool can
+# otherwise keep a logically completed Stop hook alive indefinitely (#2691).
+run() {
+  "$@" &
+  child=$!
+  (
+    sleep 15
+    kill -TERM "$child" 2>/dev/null || true
+    sleep 1
+    kill -KILL "$child" 2>/dev/null || true
+  ) &
+  watchdog=$!
+  wait "$child" 2>/dev/null || true
+  kill "$watchdog" 2>/dev/null || true
+  wait "$watchdog" 2>/dev/null || true
+}
+
+if command -v ruflo >/dev/null 2>&1; then
+  run ruflo hooks "$@"
+elif command -v claude-flow >/dev/null 2>&1; then
+  run claude-flow hooks "$@"
+else
+  run npx --prefer-offline --yes ruflo@latest hooks "$@"
+fi
+
+exit 0

package/.claude-plugin/scripts/uninstall.sh

@@ -1,36 +1,36 @@
-#!/bin/bash
-# Claude Flow Plugin Uninstallation Script
-
-set -e
-
-RED='\033[0;31m'
-GREEN='\033[0;32m'
-YELLOW='\033[1;33m'
-NC='\033[0m'
-
-info() { echo -e "${GREEN}ℹ${NC} $1"; }
-warning() { echo -e "${YELLOW}⚠${NC} $1"; }
-
-echo -e "${RED}═══════════════════════════════════════════════════${NC}"
-echo -e "${RED}    Claude Flow Plugin Uninstaller${NC}"
-echo -e "${RED}═══════════════════════════════════════════════════${NC}"
-echo ""
-
-warning "This will remove Claude Flow commands, agents, and configuration."
-read -p "Continue? (y/n): " CONFIRM
-
-if [ "$CONFIRM" != "y" ]; then
-    echo "Uninstallation cancelled."
-    exit 0
-fi
-
-info "Removing commands..."
-find ~/.claude/commands -name "*coordination*" -o -name "*sparc*" -o -name "*github*" -o -name "*hive-mind*" 2>/dev/null | xargs rm -f
-
-info "Removing agents..."
-find ~/.claude/agents -name "*coordinator*" -o -name "*swarm*" 2>/dev/null | xargs rm -f
-
-warning "MCP servers NOT removed from settings.json"
-echo "Please manually remove from ~/.claude/settings.json if desired"
-
-echo -e "${GREEN}✓ Uninstallation complete${NC}"
+#!/bin/bash
+# Claude Flow Plugin Uninstallation Script
+
+set -e
+
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m'
+
+info() { echo -e "${GREEN}ℹ${NC} $1"; }
+warning() { echo -e "${YELLOW}⚠${NC} $1"; }
+
+echo -e "${RED}═══════════════════════════════════════════════════${NC}"
+echo -e "${RED}    Claude Flow Plugin Uninstaller${NC}"
+echo -e "${RED}═══════════════════════════════════════════════════${NC}"
+echo ""
+
+warning "This will remove Claude Flow commands, agents, and configuration."
+read -p "Continue? (y/n): " CONFIRM
+
+if [ "$CONFIRM" != "y" ]; then
+    echo "Uninstallation cancelled."
+    exit 0
+fi
+
+info "Removing commands..."
+find ~/.claude/commands -name "*coordination*" -o -name "*sparc*" -o -name "*github*" -o -name "*hive-mind*" 2>/dev/null | xargs rm -f
+
+info "Removing agents..."
+find ~/.claude/agents -name "*coordinator*" -o -name "*swarm*" 2>/dev/null | xargs rm -f
+
+warning "MCP servers NOT removed from settings.json"
+echo "Please manually remove from ~/.claude/settings.json if desired"
+
+echo -e "${GREEN}✓ Uninstallation complete${NC}"