claude-flow 1.0.2 → 1.0.4

package/README.md

@@ -177,7 +177,19 @@ npx claude-flow task create code "Implement authentication" --priority 9
 npx claude-flow task list --verbose
 ```
 
-### 5. **Monitor System Status**
+### 5. **Spawn Claude Instances** 🆕
+```bash
+# Spawn Claude with specific configuration
+npx claude-flow claude spawn "implement user authentication" --research --parallel
+
+# Run with custom tools
+npx claude-flow claude spawn "fix payment bug" --tools "View,Edit,Bash" --no-permissions
+
+# Execute batch workflow
+npx claude-flow claude batch examples/claude-workflow.json --dry-run
+```
+
+### 6. **Monitor System Status**
 ```bash
 # Check system health
 npx claude-flow status
@@ -343,8 +355,28 @@ npx claude-flow mcp <subcommand>
 #### `monitor` - Real-time Monitoring
 ```bash
 npx claude-flow monitor [options]
-  --interval <ms>           Update interval (default: 5000)
-  --metrics                 Show performance metrics
+  -i, --interval <seconds>  Update interval (default: 2)
+  -c, --compact             Compact view mode
+  -f, --focus <component>   Focus on specific component
+```
+
+#### `claude` - Spawn Claude Instances 🆕
+```bash
+npx claude-flow claude <subcommand>
+  spawn <task>              Spawn Claude with specific configuration
+    -t, --tools <tools>     Allowed tools (comma-separated)
+    --no-permissions        Use --dangerously-skip-permissions flag
+    -c, --config <file>     MCP config file path
+    -m, --mode <mode>       Development mode (full/backend-only/frontend-only/api-only)
+    --parallel              Enable parallel execution with BatchTool
+    --research              Enable web research with WebFetchTool
+    --coverage <n>          Test coverage target percentage (default: 80)
+    --commit <freq>         Commit frequency (phase/feature/manual)
+    -v, --verbose           Enable verbose output
+    -d, --dry-run           Show what would be executed without running
+    
+  batch <workflow-file>     Execute multiple Claude instances from workflow
+    --dry-run               Show what would be executed without running
 ```
 
 #### `config` - Configuration Management

package/package.json

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

package/src/cli/cli-core.ts

@@ -8,7 +8,7 @@ import { red, green, yellow, blue, bold, cyan } from "https://deno.land/std@0.22
 import { ensureDir } from "https://deno.land/std@0.224.0/fs/mod.ts";
 import { join } from "https://deno.land/std@0.224.0/path/mod.ts";
 
-export const VERSION = "1.0.1";
+export const VERSION = "1.0.3";
 
 interface CommandContext {
   args: string[];

package/src/cli/commands/claude.ts

@@ -0,0 +1,175 @@
+/**
+ * Claude instance management commands
+ */
+
+import { Command } from '@cliffy/command';
+import { colors } from '@cliffy/ansi/colors';
+import { spawn } from 'node:child_process';
+import { generateId } from '../../utils/helpers.ts';
+
+export const claudeCommand = new Command()
+  .description('Manage Claude instances')
+  .action(() => {
+    claudeCommand.showHelp();
+  })
+  .command('spawn', new Command()
+    .description('Spawn a new Claude instance with specific configuration')
+    .arguments('<task:string>')
+    .option('-t, --tools <tools:string>', 'Allowed tools (comma-separated)', { 
+      default: 'View,Edit,Replace,GlobTool,GrepTool,LS,Bash' 
+    })
+    .option('--no-permissions', 'Use --dangerously-skip-permissions flag')
+    .option('-c, --config <config:string>', 'MCP config file path')
+    .option('-m, --mode <mode:string>', 'Development mode (full, backend-only, frontend-only, api-only)', {
+      default: 'full'
+    })
+    .option('--parallel', 'Enable parallel execution with BatchTool')
+    .option('--research', 'Enable web research with WebFetchTool')
+    .option('--coverage <coverage:number>', 'Test coverage target', { default: 80 })
+    .option('--commit <frequency:string>', 'Commit frequency (phase, feature, manual)', {
+      default: 'phase'
+    })
+    .option('-v, --verbose', 'Enable verbose output')
+    .option('--dry-run', 'Show what would be executed without running')
+    .action(async (options: any, task: string) => {
+      try {
+        const instanceId = generateId('claude');
+        
+        // Build allowed tools list
+        let tools = options.tools;
+        if (options.parallel && !tools.includes('BatchTool')) {
+          tools += ',BatchTool,dispatch_agent';
+        }
+        if (options.research && !tools.includes('WebFetchTool')) {
+          tools += ',WebFetchTool';
+        }
+        
+        // Build Claude command
+        const claudeArgs = [task];
+        claudeArgs.push('--allowedTools', tools);
+        
+        if (options.noPermissions) {
+          claudeArgs.push('--dangerously-skip-permissions');
+        }
+        
+        if (options.config) {
+          claudeArgs.push('--mcp-config', options.config);
+        }
+        
+        if (options.verbose) {
+          claudeArgs.push('--verbose');
+        }
+        
+        if (options.dryRun) {
+          console.log(colors.yellow('DRY RUN - Would execute:'));
+          console.log(colors.gray(`claude ${claudeArgs.join(' ')}`));
+          console.log('\nConfiguration:');
+          console.log(`  Instance ID: ${instanceId}`);
+          console.log(`  Task: ${task}`);
+          console.log(`  Tools: ${tools}`);
+          console.log(`  Mode: ${options.mode}`);
+          console.log(`  Coverage: ${options.coverage}%`);
+          console.log(`  Commit: ${options.commit}`);
+          return;
+        }
+        
+        console.log(colors.green(`Spawning Claude instance: ${instanceId}`));
+        console.log(colors.gray(`Task: ${task}`));
+        console.log(colors.gray(`Tools: ${tools}`));
+        
+        // Spawn Claude process
+        const claude = spawn('claude', claudeArgs, {
+          stdio: 'inherit',
+          env: {
+            ...process.env,
+            CLAUDE_INSTANCE_ID: instanceId,
+            CLAUDE_FLOW_MODE: options.mode,
+            CLAUDE_FLOW_COVERAGE: options.coverage.toString(),
+            CLAUDE_FLOW_COMMIT: options.commit,
+          }
+        });
+        
+        claude.on('error', (err) => {
+          console.error(colors.red('Failed to spawn Claude:'), err.message);
+        });
+        
+        claude.on('exit', (code) => {
+          if (code === 0) {
+            console.log(colors.green(`Claude instance ${instanceId} completed successfully`));
+          } else {
+            console.log(colors.red(`Claude instance ${instanceId} exited with code ${code}`));
+          }
+        });
+        
+      } catch (error) {
+        console.error(colors.red('Failed to spawn Claude:'), (error as Error).message);
+      }
+    }),
+  )
+  .command('batch', new Command()
+    .description('Spawn multiple Claude instances from workflow')
+    .arguments('<workflow-file:string>')
+    .option('--dry-run', 'Show what would be executed without running')
+    .action(async (options: any, workflowFile: string) => {
+      try {
+        const content = await Deno.readTextFile(workflowFile);
+        const workflow = JSON.parse(content);
+        
+        console.log(colors.green('Loading workflow:'), workflow.name || 'Unnamed');
+        console.log(colors.gray(`Tasks: ${workflow.tasks?.length || 0}`));
+        
+        if (!workflow.tasks || workflow.tasks.length === 0) {
+          console.log(colors.yellow('No tasks found in workflow'));
+          return;
+        }
+        
+        for (const task of workflow.tasks) {
+          const claudeArgs = [task.description || task.name];
+          
+          // Add tools
+          if (task.tools) {
+            claudeArgs.push('--allowedTools', Array.isArray(task.tools) ? task.tools.join(',') : task.tools);
+          }
+          
+          // Add flags
+          if (task.skipPermissions) {
+            claudeArgs.push('--dangerously-skip-permissions');
+          }
+          
+          if (task.config) {
+            claudeArgs.push('--mcp-config', task.config);
+          }
+          
+          if (options.dryRun) {
+            console.log(colors.yellow(`\nDRY RUN - Task: ${task.name || task.id}`));
+            console.log(colors.gray(`claude ${claudeArgs.join(' ')}`));
+          } else {
+            console.log(colors.blue(`\nSpawning Claude for task: ${task.name || task.id}`));
+            
+            const claude = spawn('claude', claudeArgs, {
+              stdio: 'inherit',
+              env: {
+                ...process.env,
+                CLAUDE_TASK_ID: task.id || generateId('task'),
+                CLAUDE_TASK_TYPE: task.type || 'general',
+              }
+            });
+            
+            // Wait for completion if sequential
+            if (!workflow.parallel) {
+              await new Promise((resolve) => {
+                claude.on('exit', resolve);
+              });
+            }
+          }
+        }
+        
+        if (!options.dryRun && workflow.parallel) {
+          console.log(colors.green('\nAll Claude instances spawned in parallel mode'));
+        }
+        
+      } catch (error) {
+        console.error(colors.red('Failed to process workflow:'), (error as Error).message);
+      }
+    }),
+  );

package/src/cli/commands/index.ts

@@ -1,6 +1,6 @@
 import { CLI, success, error, warning, info, VERSION } from "../cli-core.ts";
 import type { Command, CommandContext } from "../cli-core.ts";
-import { bold, blue } from "https://deno.land/std@0.224.0/fmt/colors.ts";
+import { bold, blue, yellow } from "https://deno.land/std@0.224.0/fmt/colors.ts";
 import { Orchestrator } from "../../core/orchestrator-fixed.ts";
 import { ConfigManager } from "../../core/config.ts";
 import { MemoryManager } from "../../memory/manager.ts";
@@ -607,12 +607,430 @@ export function setupCommands(cli: CLI): void {
     },
   });
 
+  // Claude command
+  cli.command({
+    name: "claude",
+    description: "Spawn Claude instances with specific configurations",
+    aliases: ["cl"],
+    options: [
+      {
+        name: "tools",
+        short: "t",
+        description: "Allowed tools (comma-separated)",
+        type: "string",
+        default: "View,Edit,Replace,GlobTool,GrepTool,LS,Bash",
+      },
+      {
+        name: "no-permissions",
+        description: "Use --dangerously-skip-permissions flag",
+        type: "boolean",
+      },
+      {
+        name: "config",
+        short: "c",
+        description: "MCP config file path",
+        type: "string",
+      },
+      {
+        name: "mode",
+        short: "m",
+        description: "Development mode (full, backend-only, frontend-only, api-only)",
+        type: "string",
+        default: "full",
+      },
+      {
+        name: "parallel",
+        description: "Enable parallel execution with BatchTool",
+        type: "boolean",
+      },
+      {
+        name: "research",
+        description: "Enable web research with WebFetchTool",
+        type: "boolean",
+      },
+      {
+        name: "coverage",
+        description: "Test coverage target percentage",
+        type: "number",
+        default: 80,
+      },
+      {
+        name: "commit",
+        description: "Commit frequency (phase, feature, manual)",
+        type: "string",
+        default: "phase",
+      },
+      {
+        name: "verbose",
+        short: "v",
+        description: "Enable verbose output",
+        type: "boolean",
+      },
+      {
+        name: "dry-run",
+        short: "d",
+        description: "Show what would be executed without running",
+        type: "boolean",
+      },
+    ],
+    action: async (ctx: CommandContext) => {
+      const subcommand = ctx.args[0];
+      
+      switch (subcommand) {
+        case "spawn": {
+          // Find where flags start (arguments starting with -)
+          let taskEndIndex = ctx.args.length;
+          for (let i = 1; i < ctx.args.length; i++) {
+            if (ctx.args[i].startsWith("-")) {
+              taskEndIndex = i;
+              break;
+            }
+          }
+          
+          const task = ctx.args.slice(1, taskEndIndex).join(" ");
+          if (!task) {
+            error("Usage: claude spawn <task description>");
+            break;
+          }
+          
+          try {
+            // Build allowed tools list
+            let tools = ctx.flags.tools as string || "View,Edit,Replace,GlobTool,GrepTool,LS,Bash";
+            
+            if (ctx.flags.parallel) {
+              tools += ",BatchTool,dispatch_agent";
+            }
+            
+            if (ctx.flags.research) {
+              tools += ",WebFetchTool";
+            }
+            
+            // Build Claude command
+            const claudeCmd = ["claude", `"${task}"`];
+            claudeCmd.push("--allowedTools", tools);
+            
+            if (ctx.flags.noPermissions || ctx.flags["skip-permissions"]) {
+              claudeCmd.push("--dangerously-skip-permissions");
+            }
+            
+            if (ctx.flags.config) {
+              claudeCmd.push("--mcp-config", ctx.flags.config as string);
+            }
+            
+            if (ctx.flags.verbose) {
+              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(`Instance ID: ${instanceId}`);
+              console.log(`Task: ${task}`);
+              console.log(`Tools: ${tools}`);
+              console.log(`Mode: ${ctx.flags.mode || "full"}`);
+              return;
+            }
+            
+            success(`Spawning Claude instance: ${instanceId}`);
+            console.log(`📝 Task: ${task}`);
+            console.log(`🔧 Tools: ${tools}`);
+            console.log(`⚙️  Mode: ${ctx.flags.mode || "full"}`);
+            
+            // Execute Claude command
+            const command = new Deno.Command("claude", {
+              args: claudeCmd.slice(1).map(arg => arg.replace(/^"|"$/g, '')),
+              env: {
+                ...Deno.env.toObject(),
+                CLAUDE_INSTANCE_ID: instanceId,
+                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",
+              },
+              stdin: "inherit",
+              stdout: "inherit",
+              stderr: "inherit",
+            });
+            
+            const child = command.spawn();
+            const status = await child.status;
+            
+            if (status.success) {
+              success(`Claude instance ${instanceId} completed successfully`);
+            } else {
+              error(`Claude instance ${instanceId} exited with code ${status.code}`);
+            }
+            
+          } catch (err) {
+            error(`Failed to spawn Claude: ${(err as Error).message}`);
+          }
+          break;
+        }
+        
+        case "batch": {
+          const workflowFile = ctx.args[1];
+          if (!workflowFile) {
+            error("Usage: claude batch <workflow-file>");
+            break;
+          }
+          
+          try {
+            const content = await Deno.readTextFile(workflowFile);
+            const workflow = JSON.parse(content);
+            
+            success(`Loading workflow: ${workflow.name || "Unnamed"}`);
+            console.log(`📋 Tasks: ${workflow.tasks?.length || 0}`);
+            
+            if (!workflow.tasks || workflow.tasks.length === 0) {
+              warning("No tasks found in workflow");
+              return;
+            }
+            
+            const promises = [];
+            
+            for (const task of workflow.tasks) {
+              const claudeCmd = ["claude", `"${task.description || task.name}"`];
+              
+              // Add tools
+              if (task.tools) {
+                const toolsList = Array.isArray(task.tools) ? task.tools.join(",") : task.tools;
+                claudeCmd.push("--allowedTools", toolsList);
+              }
+              
+              // Add flags
+              if (task.skipPermissions || task.dangerouslySkipPermissions) {
+                claudeCmd.push("--dangerously-skip-permissions");
+              }
+              
+              if (task.config) {
+                claudeCmd.push("--mcp-config", task.config);
+              }
+              
+              const taskId = task.id || `task-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+              
+              if (ctx.flags.dryRun || ctx.flags["dry-run"]) {
+                console.log(`\n${yellow("DRY RUN")} - Task: ${task.name || taskId}`);
+                console.log(`Command: ${claudeCmd.join(" ")}`);
+                continue;
+              }
+              
+              console.log(`\n🚀 Spawning Claude for task: ${task.name || taskId}`);
+              
+              const command = new Deno.Command("claude", {
+                args: claudeCmd.slice(1).map(arg => arg.replace(/^"|"$/g, '')),
+                env: {
+                  ...Deno.env.toObject(),
+                  CLAUDE_TASK_ID: taskId,
+                  CLAUDE_TASK_TYPE: task.type || "general",
+                },
+                stdin: "inherit",
+                stdout: "inherit", 
+                stderr: "inherit",
+              });
+              
+              const child = command.spawn();
+              
+              if (workflow.parallel) {
+                promises.push(child.status);
+              } else {
+                // Wait for completion if sequential
+                const status = await child.status;
+                if (!status.success) {
+                  error(`Task ${taskId} failed with code ${status.code}`);
+                }
+              }
+            }
+            
+            if (workflow.parallel && promises.length > 0) {
+              success("All Claude instances spawned in parallel mode");
+              const results = await Promise.all(promises);
+              const failed = results.filter(s => !s.success).length;
+              if (failed > 0) {
+                warning(`${failed} tasks failed`);
+              } else {
+                success("All tasks completed successfully");
+              }
+            }
+            
+          } catch (err) {
+            error(`Failed to process workflow: ${(err as Error).message}`);
+          }
+          break;
+        }
+        
+        default: {
+          console.log("Available subcommands: spawn, batch");
+          console.log("\nExamples:");
+          console.log("  claude-flow claude spawn \"implement user authentication\" --research --parallel");
+          console.log("  claude-flow claude spawn \"fix bug in payment system\" --no-permissions");
+          console.log("  claude-flow claude batch workflow.json --dry-run");
+          break;
+        }
+      }
+    },
+  });
+
+  // Monitor command
+  cli.command({
+    name: "monitor",
+    description: "Live monitoring dashboard",
+    options: [
+      {
+        name: "interval",
+        short: "i",
+        description: "Update interval in seconds",
+        type: "number",
+        default: 2,
+      },
+      {
+        name: "compact",
+        short: "c",
+        description: "Compact view mode",
+        type: "boolean",
+      },
+      {
+        name: "focus",
+        short: "f",
+        description: "Focus on specific component",
+        type: "string",
+      },
+    ],
+    action: async (ctx: CommandContext) => {
+      try {
+        const persist = await getPersistence();
+        const stats = await persist.getStats();
+        
+        // Check if orchestrator is running
+        const isRunning = await Deno.stat("orchestrator.log").then(() => true).catch(() => false);
+        
+        if (!isRunning) {
+          warning("Orchestrator is not running. Start it first with 'claude-flow start'");
+          return;
+        }
+        
+        info("Starting live monitoring dashboard...");
+        console.log("Press Ctrl+C to exit");
+        
+        // Simple monitoring loop
+        const interval = (ctx.flags.interval as number || ctx.flags.i as number || 2) * 1000;
+        const isCompact = ctx.flags.compact as boolean || ctx.flags.c as boolean || false;
+        let running = true;
+        
+        const cleanup = () => {
+          running = false;
+          console.log("\nMonitor stopped");
+          Deno.exit(0);
+        };
+        
+        Deno.addSignalListener("SIGINT", cleanup);
+        Deno.addSignalListener("SIGTERM", cleanup);
+        
+        // Hide cursor
+        Deno.stdout.writeSync(new TextEncoder().encode('\x1b[?25l'));
+        
+        while (running) {
+          try {
+            // Clear screen
+            console.clear();
+            
+            // Get latest stats
+            const currentStats = await persist.getStats();
+            const agents = await persist.getActiveAgents();
+            const tasks = await persist.getActiveTasks();
+            
+            // Header
+            success("Claude-Flow Live Monitor");
+            console.log("═".repeat(50));
+            
+            // System overview
+            console.log("\n📊 System Overview:");
+            console.log(`   🟢 Status: ${isRunning ? 'Running' : 'Stopped'}`);
+            console.log(`   🤖 Agents: ${currentStats.activeAgents} active (${currentStats.totalAgents} total)`);
+            console.log(`   📋 Tasks: ${currentStats.pendingTasks} pending (${currentStats.totalTasks} total)`);
+            console.log(`   ✅ Completed: ${currentStats.completedTasks} tasks`);
+            
+            // Active agents
+            if (agents.length > 0 && !isCompact) {
+              console.log("\n🤖 Active Agents:");
+              for (const agent of agents.slice(0, 5)) {
+                console.log(`   • ${agent.id.substring(0, 20)}... (${agent.type}) - ${agent.status}`);
+              }
+              if (agents.length > 5) {
+                console.log(`   ... and ${agents.length - 5} more`);
+              }
+            }
+            
+            // Active tasks
+            if (tasks.length > 0 && !isCompact) {
+              console.log("\n📋 Active Tasks:");
+              for (const task of tasks.slice(0, 5)) {
+                const assignedTo = task.assignedAgent ? `→ ${task.assignedAgent.substring(0, 15)}...` : '(unassigned)';
+                console.log(`   • ${task.id.substring(0, 20)}... (${task.type}) - ${task.status} ${assignedTo}`);
+              }
+              if (tasks.length > 5) {
+                console.log(`   ... and ${tasks.length - 5} more`);
+              }
+            }
+            
+            // Footer
+            console.log("\n" + "─".repeat(50));
+            console.log(`Last updated: ${new Date().toLocaleTimeString()} • Interval: ${interval/1000}s`);
+            
+            await new Promise(resolve => setTimeout(resolve, interval));
+          } catch (err) {
+            error(`Monitor error: ${(err as Error).message}`);
+            await new Promise(resolve => setTimeout(resolve, interval));
+          }
+        }
+        
+        // Show cursor
+        Deno.stdout.writeSync(new TextEncoder().encode('\x1b[?25h'));
+        
+      } catch (err) {
+        error(`Failed to start monitor: ${(err as Error).message}`);
+      }
+    },
+  });
+
   // Help command
   cli.command({
     name: "help",
     description: "Show help information",
-    action: () => {
-      // The CLI will show help automatically
+    action: (ctx: CommandContext) => {
+      const command = ctx.args[0];
+      
+      if (command === "claude") {
+        console.log(bold(blue("Claude Instance Management")));
+        console.log();
+        console.log("Spawn and manage Claude Code instances with specific configurations.");
+        console.log();
+        console.log(bold("Subcommands:"));
+        console.log("  spawn <task>    Spawn Claude with specific configuration");
+        console.log("  batch <file>    Execute multiple Claude instances from workflow");
+        console.log();
+        console.log(bold("Spawn Options:"));
+        console.log("  -t, --tools <tools>        Allowed tools (comma-separated)");
+        console.log("  --no-permissions           Use --dangerously-skip-permissions flag");
+        console.log("  -c, --config <file>        MCP config file path");
+        console.log("  -m, --mode <mode>          Development mode (full/backend-only/frontend-only/api-only)");
+        console.log("  --parallel                 Enable parallel execution with BatchTool");
+        console.log("  --research                 Enable web research with WebFetchTool");
+        console.log("  --coverage <n>             Test coverage target percentage (default: 80)");
+        console.log("  --commit <freq>            Commit frequency (phase/feature/manual)");
+        console.log("  -v, --verbose              Enable verbose output");
+        console.log("  -d, --dry-run              Show what would be executed without running");
+        console.log();
+        console.log(bold("Examples:"));
+        console.log(`  ${blue("claude-flow claude spawn")} "implement user authentication" --research --parallel`);
+        console.log(`  ${blue("claude-flow claude spawn")} "fix payment bug" --tools "View,Edit,Bash" --no-permissions`);
+        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 {
+        // Show general help
+        cli.showHelp();
+      }
     },
   });
 }