claude-flow 1.1.0 → 1.1.1

package/bin/claude-flow

@@ -0,0 +1,18 @@
+#!/usr/bin/env bash
+
+# Claude-Flow CLI wrapper
+# This script runs the Claude-Flow CLI using Deno
+
+# Get the directory where this script is located
+SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+PROJECT_ROOT="$( cd "$SCRIPT_DIR/.." && pwd )"
+
+# Check if first argument is "swarm"
+if [ "$1" = "swarm" ]; then
+    # Use the swarm demo script
+    shift  # Remove "swarm" from arguments
+    exec deno run --allow-all "$PROJECT_ROOT/swarm-demo.ts" "$@"
+else
+    # Use the main CLI
+    exec deno run --allow-all --no-check "$PROJECT_ROOT/src/cli/main.ts" "$@"
+fi

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-flow",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "description": "Advanced AI agent orchestration system for Claude Code",
   "main": "src/cli/main.ts",
   "bin": {
@@ -38,6 +38,7 @@
     "bin/claude-flow",
     "src/",
     "scripts/install.js",
+    "swarm-demo.ts",
     "README.md",
     "LICENSE",
     "deno.json"

package/swarm-demo.ts

@@ -0,0 +1,242 @@
+#!/usr/bin/env -S deno run --allow-all
+
+// Simplified swarm demo that bypasses the Cliffy import issues
+
+const args = Deno.args;
+
+// Parse command line arguments
+let objective = "";
+let dryRun = false;
+let maxAgents = 5;
+let strategy = "auto";
+let coordinator = false;
+let research = false;
+let parallel = false;
+let review = false;
+let verbose = false;
+
+// Simple argument parsing
+for (let i = 0; i < args.length; i++) {
+  const arg = args[i];
+  
+  if (arg.startsWith("--")) {
+    switch (arg) {
+      case "--dry-run":
+      case "-d":
+        dryRun = true;
+        break;
+      case "--coordinator":
+        coordinator = true;
+        break;
+      case "--research":
+        research = true;
+        break;
+      case "--parallel":
+        parallel = true;
+        break;
+      case "--review":
+        review = true;
+        break;
+      case "--verbose":
+      case "-v":
+        verbose = true;
+        break;
+      case "--max-agents":
+        maxAgents = parseInt(args[++i]) || 5;
+        break;
+      case "--strategy":
+      case "-s":
+        strategy = args[++i] || "auto";
+        break;
+    }
+  } else if (!objective) {
+    objective = arg;
+  }
+}
+
+if (!objective) {
+  console.log("Usage: ./swarm-demo.ts <objective> [options]");
+  console.log("\nOptions:");
+  console.log("  --dry-run, -d         Preview swarm configuration");
+  console.log("  --max-agents <n>      Maximum number of agents (default: 5)");
+  console.log("  --strategy <s>        Strategy: auto, research, development, analysis");
+  console.log("  --coordinator         Spawn dedicated coordinator");
+  console.log("  --research            Enable research capabilities");
+  console.log("  --parallel            Enable parallel execution");
+  console.log("  --review              Enable peer review");
+  console.log("  --verbose, -v         Verbose output");
+  Deno.exit(1);
+}
+
+// Generate swarm ID
+const swarmId = `swarm-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+
+console.log(`🐝 Initializing Claude Swarm: ${swarmId}`);
+console.log(`📋 Objective: ${objective}`);
+
+// Build orchestration prompt
+const strategies = {
+  auto: 'Automatically determine the best approach',
+  research: 'Focus on research and information gathering',
+  development: 'Focus on implementation and coding',
+  analysis: 'Focus on analysis and insights'
+};
+
+const orchestrationPrompt = `
+# Claude Swarm Orchestration Task
+
+You are the Master Orchestrator for a Claude agent swarm. Your objective is to coordinate multiple specialized agents to achieve the following goal:
+
+**OBJECTIVE**: ${objective}
+
+## Orchestration Parameters:
+- Strategy: ${strategies[strategy as keyof typeof strategies] || strategies.auto}
+- Maximum Agents: ${maxAgents}
+- Maximum Delegation Depth: 3
+- Parallel Execution: ${parallel ? 'Enabled' : 'Disabled'}
+- Peer Review: ${review ? 'Enabled' : 'Disabled'}
+- Research Capabilities: ${research ? 'Enabled' : 'Disabled'}
+
+## Your Responsibilities:
+
+1. **Task Decomposition**: Break down the objective into subtasks
+2. **Agent Spawning**: Create specialized agents for each subtask
+3. **Resource Allocation**: Assign appropriate tools and permissions
+4. **Coordination**: Manage dependencies and communication
+5. **Quality Control**: ${review ? 'Implement peer review processes' : 'Monitor task quality'}
+6. **Progress Tracking**: Monitor and report on swarm progress
+
+## Available Agent Types:
+- **Researcher**: Information gathering, web research, analysis
+- **Developer**: Code implementation, testing, debugging
+- **Analyst**: Data analysis, pattern recognition, insights
+- **Reviewer**: Code review, quality assurance, validation
+- **Coordinator**: Sub-task coordination, dependency management
+
+## Swarm Execution Process:
+
+1. Analyze the objective and create a detailed execution plan
+2. Identify required agent types and their responsibilities
+3. Spawn agents with appropriate configurations
+4. Create tasks and assign them to agents
+5. Monitor progress and adjust as needed
+6. ${review ? 'Implement peer review cycles between agents' : 'Validate outputs'}
+7. Synthesize results and report completion
+
+Begin by analyzing the objective and presenting your execution plan.
+`;
+
+if (dryRun) {
+  console.log("\n" + "=".repeat(50));
+  console.log("DRY RUN - Swarm Configuration:");
+  console.log("=".repeat(50));
+  console.log(`Swarm ID: ${swarmId}`);
+  console.log(`Objective: ${objective}`);
+  console.log(`Strategy: ${strategy}`);
+  console.log(`Max Agents: ${maxAgents}`);
+  console.log(`Max Depth: 3`);
+  console.log(`Research: ${research}`);
+  console.log(`Parallel: ${parallel}`);
+  console.log(`Review Mode: ${review}`);
+  console.log(`Coordinator: ${coordinator}`);
+  
+  if (verbose) {
+    console.log("\nOrchestration Prompt Preview:");
+    console.log("-".repeat(50));
+    console.log(orchestrationPrompt);
+  }
+  
+  console.log("\n✅ Configuration validated. Remove --dry-run to execute.");
+  Deno.exit(0);
+}
+
+// Build tools list
+const tools = [
+  "View",
+  "Edit", 
+  "Replace",
+  "GlobTool",
+  "GrepTool",
+  "LS",
+  "Bash",
+  "dispatch_agent"
+];
+
+if (research) {
+  tools.push("WebFetchTool");
+}
+
+if (parallel) {
+  tools.push("BatchTool");
+}
+
+console.log(`\n🎯 Spawning Master Orchestrator...`);
+console.log(`🔧 Tools: ${tools.join(", ")}`);
+
+// Build Claude command
+const claudeCmd = [
+  "claude",
+  orchestrationPrompt,
+  "--allowedTools", tools.join(",")
+];
+
+// Check if Claude CLI exists
+try {
+  const checkCmd = new Deno.Command("which", { args: ["claude"] });
+  const { success } = await checkCmd.output();
+  
+  if (!success) {
+    console.error("\n❌ Error: Claude CLI not found. Please install Claude CLI first.");
+    console.log("\nTo install Claude CLI:");
+    console.log("1. Visit: https://claude.ai/");
+    console.log("2. Install the Claude desktop app");
+    console.log("3. Ensure 'claude' command is in your PATH");
+    Deno.exit(1);
+  }
+} catch (err) {
+  console.error("\n❌ Error checking for Claude CLI:", err);
+  Deno.exit(1);
+}
+
+console.log("\n🚀 Launching orchestrator with Claude...");
+
+// Execute Claude with orchestration prompt
+const command = new Deno.Command("claude", {
+  args: claudeCmd.slice(1),
+  env: {
+    ...Deno.env.toObject(),
+    CLAUDE_SWARM_ID: swarmId,
+    CLAUDE_SWARM_MODE: "orchestrator",
+    CLAUDE_SWARM_OBJECTIVE: objective,
+    CLAUDE_SWARM_STRATEGY: strategy,
+    CLAUDE_SWARM_MAX_AGENTS: maxAgents.toString(),
+    CLAUDE_SWARM_MAX_DEPTH: "3",
+    CLAUDE_SWARM_MEMORY_NS: "swarm",
+  },
+  stdin: "piped",
+  stdout: "inherit",
+  stderr: "inherit",
+});
+
+try {
+  const process = command.spawn();
+  
+  // Send the prompt via stdin
+  const writer = process.stdin.getWriter();
+  await writer.write(new TextEncoder().encode(orchestrationPrompt));
+  await writer.close();
+  
+  console.log("✅ Master Orchestrator spawned successfully");
+  console.log("🚀 Swarm is now active and self-orchestrating...\n");
+  
+  const status = await process.status;
+  
+  if (status.success) {
+    console.log("\n✅ Swarm completed successfully");
+  } else {
+    console.error(`\n❌ Swarm exited with code ${status.code}`);
+  }
+} catch (err) {
+  console.error("\n❌ Error spawning Claude orchestrator:", err);
+  Deno.exit(1);
+}