claude-flow 1.0.21 → 1.0.23

package/src/cli/commands/index.ts

@@ -7,6 +7,7 @@ import { MemoryManager } from "../../memory/manager.ts";
 import { EventBus } from "../../core/event-bus.ts";
 import { Logger } from "../../core/logger.ts";
 import { JsonPersistenceManager } from "../../core/json-persistence.ts";
+import { swarmAction } from "./swarm.ts";
 
 let orchestrator: Orchestrator | null = null;
 let configManager: ConfigManager | null = null;
@@ -705,8 +706,96 @@ export function setupCommands(cli: CLI): void {
               tools += ",WebFetchTool";
             }
             
-            // Build Claude command
-            const claudeCmd = ["claude", `"${task}"`];
+            const instanceId = `claude-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+            
+            // Build enhanced task with Claude-Flow guidance
+            let enhancedTask = `# Claude-Flow Enhanced Task
+
+## Your Task
+${task}
+
+## Claude-Flow System Context
+
+You are running within the Claude-Flow orchestration system, which provides powerful features for complex task management:
+
+### Available Features
+
+1. **Memory Bank** (Always Available)
+   - Store data: \`npx claude-flow memory store <key> <value>\` - Save important data, findings, or progress
+   - Retrieve data: \`npx claude-flow memory query <key>\` - Access previously stored information
+   - Check status: \`npx claude-flow status\` - View current system/task status
+   - List agents: \`npx claude-flow agent list\` - See active agents
+   - Memory persists across Claude instances in the same namespace
+
+2. **Tool Access**
+   - You have access to these tools: ${tools}`;
+
+            if (ctx.flags.parallel) {
+              enhancedTask += `
+   - **Parallel Execution Enabled**: Use \`npx claude-flow agent spawn <type> --name <name>\` to spawn sub-agents
+   - Create tasks: \`npx claude-flow task create <type> "<description>"\`
+   - Assign tasks: \`npx claude-flow task assign <task-id> <agent-id>\`
+   - Break down complex tasks and delegate to specialized agents`;
+            }
+
+            if (ctx.flags.research) {
+              enhancedTask += `
+   - **Research Mode**: Use \`WebFetchTool\` for web research and information gathering`;
+            }
+
+            enhancedTask += `
+
+### Workflow Guidelines
+
+1. **Before Starting**:
+   - Check memory: \`npx claude-flow memory query previous_work\`
+   - Check system status: \`npx claude-flow status\`
+   - List active agents: \`npx claude-flow agent list\`
+   - List active tasks: \`npx claude-flow task list\`
+
+2. **During Execution**:
+   - Store findings: \`npx claude-flow memory store findings "your data here"\`
+   - Save checkpoints: \`npx claude-flow memory store progress_${task.replace(/\s+/g, '_')} "current status"\`
+   ${ctx.flags.parallel ? '- Spawn agents: `npx claude-flow agent spawn researcher --name "research-agent"`' : ''}
+   ${ctx.flags.parallel ? '- Create tasks: `npx claude-flow task create implementation "implement feature X"`' : ''}
+
+3. **Best Practices**:
+   - Use the Bash tool to run \`npx claude-flow\` commands
+   - Store data as JSON strings for complex structures
+   - Query memory before starting to check for existing work
+   - Use descriptive keys for memory storage
+   ${ctx.flags.parallel ? '- Coordinate with other agents through shared memory' : ''}
+   ${ctx.flags.research ? '- Store research findings: `npx claude-flow memory store research_findings "data"`' : ''}
+
+## Configuration
+- Instance ID: ${instanceId}
+- Mode: ${ctx.flags.mode || 'full'}
+- Coverage Target: ${ctx.flags.coverage || 80}%
+- Commit Strategy: ${ctx.flags.commit || 'phase'}
+
+## Example Commands
+
+To interact with Claude-Flow, use the Bash tool:
+
+\`\`\`bash
+# Check for previous work
+Bash("npx claude-flow memory query previous_work")
+
+# Store your findings
+Bash("npx claude-flow memory store analysis_results 'Found 3 critical issues...'")
+
+# Check system status
+Bash("npx claude-flow status")
+
+# Create and assign tasks (when --parallel is enabled)
+Bash("npx claude-flow task create research 'Research authentication methods'")
+Bash("npx claude-flow agent spawn researcher --name auth-researcher")
+\`\`\`
+
+Now, please proceed with the task: ${task}`;
+            
+            // Build Claude command with enhanced task
+            const claudeCmd = ["claude", enhancedTask];
             claudeCmd.push("--allowedTools", tools);
             
             if (ctx.flags.noPermissions || ctx.flags["skip-permissions"]) {
@@ -721,22 +810,35 @@ export function setupCommands(cli: CLI): void {
               claudeCmd.push("--verbose");
             }
             
-            const instanceId = `claude-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
-            
             if (ctx.flags.dryRun || ctx.flags["dry-run"] || ctx.flags.d) {
               warning("DRY RUN - Would execute:");
-              console.log(`Command: ${claudeCmd.join(" ")}`);
+              console.log(`Command: claude "<enhanced task with guidance>" --allowedTools ${tools}`);
               console.log(`Instance ID: ${instanceId}`);
-              console.log(`Task: ${task}`);
+              console.log(`Original Task: ${task}`);
               console.log(`Tools: ${tools}`);
               console.log(`Mode: ${ctx.flags.mode || "full"}`);
+              console.log(`Coverage: ${ctx.flags.coverage || 80}%`);
+              console.log(`Commit: ${ctx.flags.commit || "phase"}`);
+              console.log(`\nEnhanced Features:`);
+              console.log(`  - Memory Bank enabled via: npx claude-flow memory commands`);
+              console.log(`  - Coordination ${ctx.flags.parallel ? 'enabled' : 'disabled'}`);
+              console.log(`  - Access Claude-Flow features through Bash tool`);
               return;
             }
             
             success(`Spawning Claude instance: ${instanceId}`);
-            console.log(`📝 Task: ${task}`);
+            console.log(`📝 Original Task: ${task}`);
             console.log(`🔧 Tools: ${tools}`);
             console.log(`⚙️  Mode: ${ctx.flags.mode || "full"}`);
+            console.log(`📊 Coverage: ${ctx.flags.coverage || 80}%`);
+            console.log(`💾 Commit: ${ctx.flags.commit || "phase"}`);
+            console.log(`✨ Enhanced with Claude-Flow guidance for memory and coordination`);
+            console.log('');
+            console.log('📋 Task will be enhanced with:');
+            console.log('  - Memory Bank instructions (store/retrieve)');
+            console.log('  - Coordination capabilities (swarm management)');
+            console.log('  - Best practices for multi-agent workflows');
+            console.log('');
             
             // Execute Claude command
             const command = new Deno.Command("claude", {
@@ -747,6 +849,11 @@ export function setupCommands(cli: CLI): void {
                 CLAUDE_FLOW_MODE: ctx.flags.mode as string || "full",
                 CLAUDE_FLOW_COVERAGE: (ctx.flags.coverage || 80).toString(),
                 CLAUDE_FLOW_COMMIT: ctx.flags.commit as string || "phase",
+                // Add Claude-Flow specific features
+                CLAUDE_FLOW_MEMORY_ENABLED: 'true',
+                CLAUDE_FLOW_MEMORY_NAMESPACE: 'default',
+                CLAUDE_FLOW_COORDINATION_ENABLED: ctx.flags.parallel ? 'true' : 'false',
+                CLAUDE_FLOW_FEATURES: 'memory,coordination,swarm',
               },
               stdin: "inherit",
               stdout: "inherit",
@@ -993,6 +1100,181 @@ export function setupCommands(cli: CLI): void {
     },
   });
 
+  // Swarm command
+  cli.command({
+    name: "swarm",
+    description: "Create self-orchestrating Claude agent swarms",
+    options: [
+      {
+        name: "strategy",
+        short: "s",
+        description: "Orchestration strategy (auto, research, development, analysis)",
+        type: "string",
+        default: "auto",
+      },
+      {
+        name: "max-agents",
+        description: "Maximum number of agents to spawn",
+        type: "number",
+        default: 5,
+      },
+      {
+        name: "max-depth",
+        description: "Maximum delegation depth",
+        type: "number",
+        default: 3,
+      },
+      {
+        name: "research",
+        description: "Enable research capabilities for all agents",
+        type: "boolean",
+      },
+      {
+        name: "parallel",
+        description: "Enable parallel execution",
+        type: "boolean",
+      },
+      {
+        name: "memory-namespace",
+        description: "Shared memory namespace",
+        type: "string",
+        default: "swarm",
+      },
+      {
+        name: "timeout",
+        description: "Swarm timeout in minutes",
+        type: "number",
+        default: 60,
+      },
+      {
+        name: "review",
+        description: "Enable peer review between agents",
+        type: "boolean",
+      },
+      {
+        name: "coordinator",
+        description: "Spawn dedicated coordinator agent",
+        type: "boolean",
+      },
+      {
+        name: "config",
+        short: "c",
+        description: "MCP config file",
+        type: "string",
+      },
+      {
+        name: "verbose",
+        short: "v",
+        description: "Enable verbose output",
+        type: "boolean",
+      },
+      {
+        name: "dry-run",
+        short: "d",
+        description: "Preview swarm configuration",
+        type: "boolean",
+      },
+      {
+        name: "vscode",
+        description: "Use VS Code terminal integration",
+        type: "boolean",
+      },
+      {
+        name: "monitor",
+        description: "Enable real-time monitoring",
+        type: "boolean",
+      },
+      {
+        name: "ui",
+        description: "Use blessed terminal UI (avoids TTY issues)",
+        type: "boolean",
+      },
+    ],
+    action: swarmAction,
+  });
+
+  // Swarm UI command (convenience wrapper)
+  cli.command({
+    name: "swarm-ui",
+    description: "Create self-orchestrating Claude agent swarms with blessed UI",
+    options: [
+      {
+        name: "strategy",
+        short: "s",
+        description: "Orchestration strategy (auto, research, development, analysis)",
+        type: "string",
+        default: "auto",
+      },
+      {
+        name: "max-agents",
+        description: "Maximum number of agents to spawn",
+        type: "number",
+        default: 5,
+      },
+      {
+        name: "max-depth",
+        description: "Maximum delegation depth",
+        type: "number",
+        default: 3,
+      },
+      {
+        name: "research",
+        description: "Enable research capabilities for all agents",
+        type: "boolean",
+      },
+      {
+        name: "parallel",
+        description: "Enable parallel execution",
+        type: "boolean",
+      },
+      {
+        name: "memory-namespace",
+        description: "Shared memory namespace",
+        type: "string",
+        default: "swarm",
+      },
+      {
+        name: "timeout",
+        description: "Swarm timeout in minutes",
+        type: "number",
+        default: 60,
+      },
+      {
+        name: "review",
+        description: "Enable peer review between agents",
+        type: "boolean",
+      },
+      {
+        name: "coordinator",
+        description: "Spawn dedicated coordinator agent",
+        type: "boolean",
+      },
+      {
+        name: "config",
+        short: "c",
+        description: "MCP config file",
+        type: "string",
+      },
+      {
+        name: "verbose",
+        short: "v",
+        description: "Enable verbose output",
+        type: "boolean",
+      },
+      {
+        name: "dry-run",
+        short: "d",
+        description: "Preview swarm configuration",
+        type: "boolean",
+      },
+    ],
+    action: async (ctx: CommandContext) => {
+      // Force UI mode
+      ctx.flags.ui = true;
+      await swarmAction(ctx);
+    },
+  });
+
   // Help command
   cli.command({
     name: "help",
@@ -1027,6 +1309,46 @@ export function setupCommands(cli: CLI): void {
         console.log(`  ${blue("claude-flow claude batch")} workflow.json --dry-run`);
         console.log();
         console.log("For more information, see: https://github.com/ruvnet/claude-code-flow/docs/11-claude-spawning.md");
+      } else if (command === "swarm" || command === "swarm-ui") {
+        console.log(bold(blue("Claude Swarm Mode")));
+        console.log();
+        console.log("Create self-orchestrating Claude agent swarms to tackle complex objectives.");
+        console.log();
+        console.log(bold("Usage:"));
+        console.log("  claude-flow swarm <objective> [options]");
+        console.log("  claude-flow swarm-ui <objective> [options]  # Uses blessed UI (avoids TTY issues)");
+        console.log();
+        console.log(bold("Options:"));
+        console.log("  -s, --strategy <s>         Orchestration strategy (auto, research, development, analysis)");
+        console.log("  --max-agents <n>           Maximum number of agents (default: 5)");
+        console.log("  --max-depth <n>            Maximum delegation depth (default: 3)");
+        console.log("  --research                 Enable research capabilities for all agents");
+        console.log("  --parallel                 Enable parallel execution");
+        console.log("  --memory-namespace <ns>    Shared memory namespace (default: swarm)");
+        console.log("  --timeout <minutes>        Swarm timeout in minutes (default: 60)");
+        console.log("  --review                   Enable peer review between agents");
+        console.log("  --coordinator              Spawn dedicated coordinator agent");
+        console.log("  -c, --config <file>        MCP config file");
+        console.log("  -v, --verbose              Enable verbose output");
+        console.log("  -d, --dry-run              Preview swarm configuration");
+        console.log("  --vscode                   Use VS Code terminal integration");
+        console.log("  --monitor                  Enable real-time monitoring");
+        console.log("  --ui                       Use blessed terminal UI (avoids TTY issues)");
+        console.log();
+        console.log(bold("Examples:"));
+        console.log(`  ${blue("claude-flow swarm")} "Build a REST API"`);
+        console.log(`  ${blue("claude-flow swarm-ui")} "Build a REST API"  # Avoids TTY issues`);
+        console.log(`  ${blue("claude-flow swarm")} "Research cloud architecture" --strategy research --research`);
+        console.log(`  ${blue("claude-flow swarm")} "Migrate app to microservices" --coordinator --review --ui`);
+        console.log();
+        console.log(bold("TTY Issues?"));
+        console.log("If you encounter 'Raw mode is not supported' errors, use:");
+        console.log(`  - ${blue("claude-flow swarm-ui")} <objective>  # Recommended`);
+        console.log(`  - ${blue("claude-flow swarm")} <objective> --ui`);
+        console.log();
+        console.log("For more information, see:");
+        console.log("  - https://github.com/ruvnet/claude-code-flow/docs/12-swarm.md");
+        console.log("  - https://github.com/ruvnet/claude-code-flow/SWARM_TTY_SOLUTION.md");
       } else {
         // Show general help
         cli.showHelp();

package/src/cli/commands/swarm-spawn.ts

@@ -0,0 +1,79 @@
+/**
+ * Swarm spawning utilities
+ */
+
+interface Agent {
+  id: string;
+  type: string;
+  status: string;
+  name: string;
+  task: string;
+  parentId?: string;
+  terminalId?: string;
+}
+
+interface SwarmState {
+  swarmId: string;
+  objective: string;
+  agents: Map<string, Agent>;
+  startTime: number;
+}
+
+const swarmStates = new Map<string, SwarmState>();
+
+export function initializeSwarm(swarmId: string, objective: string): void {
+  swarmStates.set(swarmId, {
+    swarmId: swarmId,
+    objective,
+    agents: new Map<string, Agent>(),
+    startTime: Date.now(),
+  });
+}
+
+export async function spawnSwarmAgent(swarmId: string, agentType: string, task: string): Promise<string> {
+  const swarm = swarmStates.get(swarmId);
+  if (!swarm) {
+    throw new Error(`Swarm ${swarmId} not found`);
+  }
+  
+  const agentId = `${swarmId}-agent-${Date.now()}`;
+  swarm.agents.push({
+    id: agentId,
+    type: agentType,
+    status: 'active',
+  });
+  
+  // In a real implementation, this would spawn actual Claude instances
+  console.log(`[SWARM] Spawned ${agentType} agent: ${agentId}`);
+  console.log(`[SWARM] Task: ${task}`);
+  
+  return agentId;
+}
+
+export async function monitorSwarm(swarmId: string): Promise<void> {
+  const swarm = swarmStates.get(swarmId);
+  if (!swarm) {
+    throw new Error(`Swarm ${swarmId} not found`);
+  }
+  
+  // Simple monitoring loop
+  let running = true;
+  const interval = setInterval(() => {
+    if (!running) {
+      clearInterval(interval);
+      return;
+    }
+    
+    console.log(`[MONITOR] Swarm ${swarmId} - Agents: ${swarm.agents.length}`);
+    console.log(`[MONITOR] Active: ${swarm.agents.filter(a => a.status === 'active').length}`);
+  }, 5000);
+  
+  // Stop monitoring after timeout
+  setTimeout(() => {
+    running = false;
+  }, 60 * 60 * 1000); // 1 hour
+}
+
+export function getSwarmState(swarmId: string): SwarmState | undefined {
+  return swarmStates.get(swarmId);
+}