claude-flow 1.0.46 → 1.0.48

package/bin/claude-flow-swarm

@@ -13,7 +13,19 @@ fi
 
 # Get the directory of this script
 SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
-SWARM_DEMO="$SCRIPT_DIR/../swarm-demo.ts"
 
-# Run the swarm demo with all arguments
-exec "$DENO_PATH" run --allow-all "$SWARM_DEMO" "$@"
+# Try to find swarm implementation in different locations
+if [ -f "$SCRIPT_DIR/../swarm-demo.ts" ]; then
+    # Local development path
+    SWARM_IMPL="$SCRIPT_DIR/../swarm-demo.ts"
+elif [ -f "$SCRIPT_DIR/../src/cli/swarm-standalone.js" ]; then
+    # Installed via npm - use the standalone JavaScript version
+    SWARM_IMPL="$SCRIPT_DIR/../src/cli/swarm-standalone.js"
+else
+    echo "Error: Unable to find swarm implementation files"
+    echo "Please ensure claude-flow is properly installed"
+    exit 1
+fi
+
+# Run the swarm implementation with all arguments
+exec "$DENO_PATH" run --allow-all "$SWARM_IMPL" "$@"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-flow",
-  "version": "1.0.46",
+  "version": "1.0.48",
   "description": "Advanced AI agent orchestration system for Claude Code",
   "main": "src/cli/main.ts",
   "bin": {

package/src/cli/commands/status.ts

@@ -239,7 +239,7 @@ async function getSystemStatus(): Promise<any> {
   // Mock status for now - in production, this would call the orchestrator API
   return {
     overall: 'healthy',
-    version: '1.0.0',
+    version: '1.0.48',
     uptime: Date.now() - (Date.now() - 3600000), // 1 hour ago
     startTime: new Date(Date.now() - 3600000),
     components: {

package/src/cli/main.ts

@@ -6,7 +6,7 @@
 import { CLI } from "./cli-core.ts";
 import { setupCommands } from "./commands/index.ts";
 
-const VERSION = "1.0.43";
+const VERSION = "1.0.48";
 
 async function main() {
   const cli = new CLI("claude-flow", "Advanced AI Agent Orchestration System");

package/src/cli/simple-cli.js

@@ -13,7 +13,7 @@ import {
 } from './command-registry.js';
 import { parseFlags } from './utils.js';
 
-const VERSION = '1.0.43';
+const VERSION = '1.0.48';
 
 function printHelp() {
   console.log(`

package/src/cli/simple-cli.ts

@@ -4,7 +4,7 @@
  * This version avoids import assertion issues while maintaining functionality
  */
 
-const VERSION = '1.0.43';
+const VERSION = '1.0.48';
 
 function printHelp() {
   console.log(`

package/src/cli/simple-commands/status.js

@@ -17,7 +17,7 @@ export async function statusCommand(subArgs, flags) {
 async function getSystemStatus(verbose = false) {
   const status = {
     timestamp: Date.now(),
-    version: '1.0.43',
+    version: '1.0.48',
     orchestrator: {
       running: false,
       uptime: 0,

package/src/cli/simple-commands/swarm.js

@@ -3,9 +3,79 @@
  * Swarm command wrapper for simple CLI
  */
 
+function showSwarmHelp() {
+  console.log(`
+🐝 Claude Flow Advanced Swarm System
+
+USAGE:
+  claude-flow swarm <objective> [options]
+
+EXAMPLES:
+  claude-flow swarm "Build a REST API" --strategy development
+  claude-flow swarm "Research cloud architecture" --strategy research --ui
+  claude-flow swarm "Analyze data trends" --strategy analysis --parallel
+  claude-flow swarm "Optimize performance" --distributed --monitor
+
+STRATEGIES:
+  auto           Automatically determine best approach (default)
+  research       Research and information gathering
+  development    Software development and coding
+  analysis       Data analysis and insights
+  testing        Testing and quality assurance
+  optimization   Performance optimization
+  maintenance    System maintenance
+
+MODES:
+  centralized    Single coordinator (default)
+  distributed    Multiple coordinators
+  hierarchical   Tree structure coordination
+  mesh           Peer-to-peer coordination
+  hybrid         Mixed coordination strategies
+
+KEY FEATURES:
+  🤖 Intelligent agent management with specialized types
+  ⚡ Timeout-free background task execution
+  🧠 Distributed memory sharing between agents
+  🔄 Work stealing and advanced load balancing
+  🛡️  Circuit breaker patterns for fault tolerance
+  📊 Real-time monitoring and comprehensive metrics
+  🎛️  Multiple coordination strategies and algorithms
+  💾 Persistent state with backup and recovery
+  🔒 Security features with encryption options
+  🖥️  Interactive terminal UI for management
+
+OPTIONS:
+  --strategy <type>          Execution strategy (default: auto)
+  --mode <type>              Coordination mode (default: centralized)
+  --max-agents <n>           Maximum agents (default: 5)
+  --timeout <minutes>        Timeout in minutes (default: 60)
+  --parallel                 Enable parallel execution
+  --distributed              Enable distributed coordination
+  --monitor                  Enable real-time monitoring
+  --ui                       Launch terminal UI interface
+  --background               Run in background mode
+  --review                   Enable peer review
+  --testing                  Enable automated testing
+  --encryption               Enable encryption
+  --verbose                  Enable detailed logging
+  --dry-run                  Show configuration without executing
+
+ADVANCED OPTIONS:
+  --quality-threshold <n>    Quality threshold 0-1 (default: 0.8)
+  --memory-namespace <name>  Memory namespace (default: swarm)
+  --agent-selection <type>   Agent selection strategy
+  --task-scheduling <type>   Task scheduling algorithm
+  --load-balancing <type>    Load balancing method
+  --fault-tolerance <type>   Fault tolerance strategy
+
+For complete documentation and examples:
+https://github.com/ruvnet/claude-code-flow/docs/swarm.md
+`);
+}
+
 export async function swarmCommand(args, flags) {
   try {
-    // Import the new comprehensive swarm action
+    // Try to load the TypeScript module directly (works in Deno and local dev)
     const { swarmAction } = await import('../commands/swarm-new.ts');
     
     // Create command context compatible with TypeScript version
@@ -17,6 +87,68 @@ export async function swarmCommand(args, flags) {
     
     await swarmAction(ctx);
   } catch (error) {
+    // If TypeScript import fails (e.g., in node_modules), provide inline implementation
+    if (error.code === 'ERR_MODULE_NOT_FOUND' || error.code === 'ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING') {
+      // Provide a basic swarm implementation that works without TypeScript imports
+      const objective = (args || []).join(' ').trim();
+      
+      if (!objective) {
+        console.error("❌ Usage: swarm <objective>");
+        showSwarmHelp();
+        return;
+      }
+      
+      // Basic swarm execution using child process
+      const { spawn } = await import('child_process');
+      const path = await import('path');
+      const { fileURLToPath } = await import('url');
+      
+      // Get the directory of this file
+      const __filename = fileURLToPath(import.meta.url);
+      const __dirname = path.dirname(__filename);
+      
+      // Try to find the swarm binary
+      const swarmBinPath = path.join(__dirname, '../../../bin/claude-flow-swarm');
+      
+      // Check if the binary exists
+      const fs = await import('fs');
+      if (!fs.existsSync(swarmBinPath)) {
+        console.error('❌ Swarm binary not found. Please ensure claude-flow is properly installed.');
+        showSwarmHelp();
+        return;
+      }
+      
+      // Execute the swarm binary with arguments
+      const swarmArgs = [objective];
+      
+      // Add flags
+      for (const [key, value] of Object.entries(flags || {})) {
+        swarmArgs.push(`--${key}`);
+        if (value !== true) {
+          swarmArgs.push(String(value));
+        }
+      }
+      
+      console.log('🐝 Launching swarm via binary...');
+      
+      const swarmProcess = spawn(swarmBinPath, swarmArgs, {
+        stdio: 'inherit',
+        shell: true
+      });
+      
+      swarmProcess.on('error', (err) => {
+        console.error('❌ Failed to launch swarm:', err.message);
+      });
+      
+      swarmProcess.on('exit', (code) => {
+        if (code !== 0) {
+          console.error(`❌ Swarm exited with code ${code}`);
+        }
+      });
+      
+      return;
+    }
+    
     console.error('Swarm command error:', error);
     
     // Fallback to comprehensive help if there's an import error
@@ -92,14 +224,16 @@ https://github.com/ruvnet/claude-code-flow/docs/swarm.md
 
 // Allow direct execution
 if (import.meta.main) {
-  const args = Deno.args.slice(1); // Skip the command name
+  // When called directly as a script, parse all arguments
+  const args = [];
   const flags = {};
   
-  // Parse basic flags
-  for (let i = 0; i < args.length; i++) {
-    if (args[i].startsWith('--')) {
-      const flagName = args[i].substring(2);
-      const nextArg = args[i + 1];
+  // Parse arguments and flags
+  for (let i = 0; i < Deno.args.length; i++) {
+    const arg = Deno.args[i];
+    if (arg.startsWith('--')) {
+      const flagName = arg.substring(2);
+      const nextArg = Deno.args[i + 1];
       
       if (nextArg && !nextArg.startsWith('--')) {
         flags[flagName] = nextArg;
@@ -107,12 +241,14 @@ if (import.meta.main) {
       } else {
         flags[flagName] = true;
       }
+    } else {
+      args.push(arg);
     }
   }
   
-  // Filter out flags from args to get the objective
-  const objective = args.filter(arg => !arg.startsWith('--') && 
-    !Object.values(flags).includes(arg)).join(' ');
+  // The objective is all non-flag arguments joined
+  const objective = args.join(' ');
   
+  // Execute the swarm command
   await swarmCommand([objective], flags);
 }

package/src/cli/swarm-standalone.js

@@ -0,0 +1,106 @@
+#!/usr/bin/env -S deno run --allow-all
+/**
+ * Standalone swarm executable for npm package
+ * This handles swarm execution when installed via npm
+ */
+
+import { spawn } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+import { existsSync } from 'node:fs';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Parse arguments
+const args = [];
+const flags = {};
+
+for (let i = 0; i < Deno.args.length; i++) {
+  const arg = Deno.args[i];
+  if (arg.startsWith('--')) {
+    const flagName = arg.substring(2);
+    const nextArg = Deno.args[i + 1];
+    
+    if (nextArg && !nextArg.startsWith('--')) {
+      flags[flagName] = nextArg;
+      i++; // Skip the next argument
+    } else {
+      flags[flagName] = true;
+    }
+  } else {
+    args.push(arg);
+  }
+}
+
+const objective = args.join(' ');
+
+if (!objective && !flags.help) {
+  console.error("❌ Usage: swarm <objective>");
+  console.log(`
+🐝 Claude Flow Advanced Swarm System
+
+USAGE:
+  claude-flow swarm <objective> [options]
+
+EXAMPLES:
+  claude-flow swarm "Build a REST API" --strategy development
+  claude-flow swarm "Research cloud architecture" --strategy research --ui
+  claude-flow swarm "Analyze data trends" --strategy analysis --parallel
+  claude-flow swarm "Optimize performance" --distributed --monitor
+
+Run 'claude-flow swarm --help' for full options
+`);
+  Deno.exit(1);
+}
+
+// Try to find the swarm implementation
+const possiblePaths = [
+  join(__dirname, '../../swarm-demo.ts'),
+  join(__dirname, '../../swarm-demo-enhanced.ts'),
+  join(__dirname, '../../../swarm-demo.ts'),
+];
+
+let swarmPath = null;
+for (const path of possiblePaths) {
+  if (existsSync(path)) {
+    swarmPath = path;
+    break;
+  }
+}
+
+if (!swarmPath) {
+  // Fallback to inline implementation
+  console.log('🐝 Launching swarm system...');
+  console.log(`📋 Objective: ${objective}`);
+  console.log(`🎯 Strategy: ${flags.strategy || 'auto'}`);
+  console.log(`🏗️  Mode: ${flags.mode || 'centralized'}`);
+  console.log(`🤖 Max Agents: ${flags['max-agents'] || 5}`);
+  
+  // Import and run the swarm command
+  try {
+    const { swarmCommand } = await import('./simple-commands/swarm.js');
+    await swarmCommand([objective], flags);
+  } catch (error) {
+    console.error('❌ Failed to launch swarm:', error.message);
+    console.error('\nPlease ensure claude-flow is properly installed');
+    Deno.exit(1);
+  }
+} else {
+  // Run the swarm demo directly
+  const swarmArgs = [objective];
+  for (const [key, value] of Object.entries(flags)) {
+    swarmArgs.push(`--${key}`);
+    if (value !== true) {
+      swarmArgs.push(String(value));
+    }
+  }
+  
+  const deno = spawn(Deno.execPath(), ['run', '--allow-all', swarmPath, ...swarmArgs], {
+    stdio: 'inherit'
+  });
+  
+  deno.on('exit', (code) => {
+    Deno.exit(code || 0);
+  });
+}