claude-flow-novice 1.3.0 → 1.3.2

package/src/cli/simple-commands/stream-processor.js

@@ -0,0 +1,340 @@
+/**
+ * Stream processor for Claude stream-json output
+ * Provides real-time status updates and progress tracking
+ */
+
+import { Transform } from 'stream';
+
+export class StreamJsonProcessor extends Transform {
+  constructor(options = {}) {
+    super({ objectMode: false });
+    this.buffer = '';
+    this.agentId = options.agentId;
+    this.agentName = options.agentName || 'Agent';
+    this.agentIcon = options.agentIcon || '🤖';
+    this.taskId = options.taskId || 'unknown';
+    this.startTime = Date.now();
+    this.eventCount = 0;
+    this.lastUpdate = Date.now();
+    this.options = options;
+    this.display = options.display; // Reference to concurrent display
+  }
+
+  _transform(chunk, encoding, callback) {
+    this.buffer += chunk.toString();
+    const lines = this.buffer.split('\n');
+    this.buffer = lines.pop() || '';
+
+    for (const line of lines) {
+      if (line.trim()) {
+        try {
+          const event = JSON.parse(line);
+          this.processEvent(event);
+        } catch (e) {
+          // Not JSON, pass through if in verbose mode
+          if (this.options.verbose) {
+            console.log(`[${this.agentName}] ${line}`);
+          }
+        }
+      }
+    }
+
+    // Update progress display periodically
+    if (Date.now() - this.lastUpdate > 1000) {
+      this.updateProgress();
+      this.lastUpdate = Date.now();
+    }
+
+    callback();
+  }
+
+  _flush(callback) {
+    if (this.buffer.trim()) {
+      try {
+        const event = JSON.parse(this.buffer);
+        this.processEvent(event);
+      } catch (e) {
+        // Ignore
+      }
+    }
+    this.showFinalStatus();
+    callback();
+  }
+
+  processEvent(event) {
+    this.eventCount++;
+
+    // If we have a concurrent display, update it instead of console logging
+    if (this.display) {
+      this.updateDisplay(event);
+      return;
+    }
+
+    // Handle quiet mode - show important actions and commands
+    if (this.options.verbose === false && this.options.logLevel === 'quiet') {
+      switch (event.type) {
+        case 'system':
+          if (event.subtype === 'init') {
+            console.log(`🤖 ${this.agentName} - Started`);
+          }
+          break;
+        case 'assistant':
+          // In quiet mode, still show bash commands and key actions
+          if (event.message?.content?.length > 0) {
+            const content = event.message.content[0];
+            if (content.type === 'tool_use' && content.name === 'Bash' && content.input?.command) {
+              const command = content.input.command;
+              if (command.length > 60) {
+                console.log(`  🔧 ${command.substring(0, 57)}...`);
+              } else {
+                console.log(`  🔧 ${command}`);
+              }
+            } else if (
+              content.type === 'tool_use' &&
+              ['WebSearch', 'Read', 'Write'].includes(content.name)
+            ) {
+              const toolName = content.name.replace(/([A-Z])/g, ' $1').trim();
+              if (content.input) {
+                const firstKey = Object.keys(content.input)[0];
+                const firstValue = content.input[firstKey];
+                if (typeof firstValue === 'string' && firstValue.length < 40) {
+                  console.log(`  🔧 ${toolName}: ${firstValue}`);
+                } else {
+                  console.log(`  🔧 ${toolName}`);
+                }
+              }
+            }
+          }
+          break;
+        case 'result':
+          if (event.subtype === 'success') {
+            console.log(
+              `✅ ${this.agentName} - Completed (${this.formatDuration(event.duration_ms)})`,
+            );
+          } else if (event.is_error) {
+            console.log(`❌ ${this.agentName} - Failed: ${event.error || 'Unknown error'}`);
+          }
+          break;
+      }
+      return;
+    }
+
+    // Use clean, concise formatting for non-interactive mode
+    switch (event.type) {
+      case 'system':
+        if (event.subtype === 'init') {
+          console.log(
+            `\n🤖 ${this.agentName} - Started (Session: ${event.session_id?.substring(0, 8) || 'unknown'})`,
+          );
+        }
+        break;
+
+      case 'assistant':
+        if (event.message?.content?.length > 0) {
+          const content = event.message.content[0];
+          if (content.type === 'text') {
+            // Show only the first meaningful line, skip verbose details
+            const lines = content.text.split('\n').filter((line) => line.trim());
+            if (lines.length > 0) {
+              const firstLine = lines[0].trim();
+              if (firstLine.length > 100) {
+                console.log(`💭 ${firstLine.substring(0, 97)}...`);
+              } else {
+                console.log(`💭 ${firstLine}`);
+              }
+            }
+          } else if (content.type === 'tool_use') {
+            // Show tool use with actual command/input when available
+            const toolName = content.name.replace(/([A-Z])/g, ' $1').trim();
+
+            // For Bash tool, show the actual command
+            if (content.name === 'Bash' && content.input?.command) {
+              const command = content.input.command;
+              if (command.length > 80) {
+                console.log(`🔧 Bash: ${command.substring(0, 77)}...`);
+              } else {
+                console.log(`🔧 Bash: ${command}`);
+              }
+            }
+            // For other tools, show key parameters
+            else if (content.input && Object.keys(content.input).length > 0) {
+              const firstKey = Object.keys(content.input)[0];
+              const firstValue = content.input[firstKey];
+
+              if (typeof firstValue === 'string' && firstValue.length < 60) {
+                console.log(`🔧 ${toolName}: ${firstValue}`);
+              } else if (typeof firstValue === 'string') {
+                console.log(`🔧 ${toolName}: ${firstValue.substring(0, 57)}...`);
+              } else {
+                console.log(`🔧 ${toolName}`);
+              }
+            } else {
+              console.log(`🔧 ${toolName}`);
+            }
+          }
+        }
+        break;
+
+      case 'user':
+        // Tool results - show only success/failure
+        if (event.message?.content?.[0]?.type === 'tool_result') {
+          const result = event.message.content[0];
+          if (!result.is_error) {
+            console.log(`  ✅ Tool completed`);
+          } else {
+            console.log(`  ❌ Tool failed: ${result.error || 'Unknown error'}`);
+          }
+        }
+        break;
+
+      case 'result':
+        if (event.subtype === 'success') {
+          console.log(
+            `\n✅ ${this.agentName} - Completed (${this.formatDuration(event.duration_ms)})`,
+          );
+          if (event.total_cost_usd) {
+            console.log(`   💰 Cost: $${event.total_cost_usd.toFixed(4)}`);
+          }
+        } else if (event.is_error) {
+          console.log(`\n❌ ${this.agentName} - Failed: ${event.error || 'Unknown error'}`);
+        }
+        break;
+
+      default:
+        // Only show important events in verbose mode
+        if (this.options.verbose && ['tool_call', 'error', 'warning'].includes(event.type)) {
+          console.log(
+            `ℹ️  [${event.type}] ${event.message || JSON.stringify(event).substring(0, 80)}...`,
+          );
+        }
+    }
+  }
+
+  /**
+   * Update the concurrent display instead of console
+   */
+  updateDisplay(event) {
+    switch (event.type) {
+      case 'system':
+        if (event.subtype === 'init') {
+          this.display.updateAgent(this.agentId, { status: 'active' });
+          this.display.addActivity(this.agentId, 'Initialized');
+        }
+        break;
+
+      case 'assistant':
+        if (event.message?.content?.length > 0) {
+          const content = event.message.content[0];
+          if (content.type === 'text') {
+            const preview = content.text.substring(0, 80);
+            this.display.addActivity(this.agentId, preview);
+          } else if (content.type === 'tool_use') {
+            this.display.addActivity(this.agentId, `Using ${content.name}`, content.name);
+          }
+        }
+        break;
+
+      case 'user':
+        // Tool results
+        if (event.message?.content?.[0]?.type === 'tool_result') {
+          const result = event.message.content[0];
+          if (!result.is_error) {
+            this.display.addActivity(this.agentId, 'Tool completed', null);
+          }
+        }
+        break;
+
+      case 'result':
+        if (event.subtype === 'success') {
+          this.display.updateAgent(this.agentId, {
+            status: 'completed',
+            progress: 100,
+          });
+          this.display.addActivity(this.agentId, 'Task completed successfully');
+        } else if (event.is_error) {
+          this.display.updateAgent(this.agentId, {
+            status: 'failed',
+          });
+          this.display.addActivity(this.agentId, `Failed: ${event.error || 'Unknown error'}`);
+        }
+        break;
+    }
+  }
+
+  updateProgress() {
+    // Don't show progress updates in interactive-style mode - events handle the display
+  }
+
+  showFinalStatus() {
+    const elapsed = this.formatDuration(Date.now() - this.startTime);
+    if (this.eventCount > 0) {
+      console.log(`\n📊 ${this.agentName} - Processed ${this.eventCount} events in ${elapsed}`);
+    }
+  }
+
+  getSpinner() {
+    const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+    return frames[Math.floor(Date.now() / 100) % frames.length];
+  }
+
+  getProgressBar(elapsed, expected) {
+    const progress = Math.min(elapsed / expected, 1);
+    const filled = Math.floor(progress * 10);
+    const empty = 10 - filled;
+    return '[' + '█'.repeat(filled) + '░'.repeat(empty) + ']';
+  }
+
+  formatDuration(ms) {
+    const seconds = Math.floor(ms / 1000);
+    const minutes = Math.floor(seconds / 60);
+    if (minutes > 0) {
+      return `${minutes}m ${seconds % 60}s`;
+    }
+    return `${seconds}s`;
+  }
+
+  formatToolParams(input) {
+    if (!input || typeof input !== 'object' || Object.keys(input).length === 0) {
+      return '';
+    }
+
+    // Format key parameters for display
+    const keys = Object.keys(input);
+    if (keys.length === 1) {
+      const key = keys[0];
+      const value = input[key];
+      if (typeof value === 'string' && value.length < 30) {
+        return `(${key}: "${value}")`;
+      } else if (typeof value === 'number' || typeof value === 'boolean') {
+        return `(${key}: ${value})`;
+      }
+    } else if (keys.length <= 3) {
+      const params = keys
+        .map((key) => {
+          const value = input[key];
+          if (typeof value === 'string' && value.length < 20) {
+            return `${key}: "${value}"`;
+          } else if (typeof value === 'number' || typeof value === 'boolean') {
+            return `${key}: ${value}`;
+          } else {
+            return `${key}: ...`;
+          }
+        })
+        .join(', ');
+      return `(${params})`;
+    }
+
+    return '(...)';
+  }
+}
+
+/**
+ * Create a stream processor for an agent
+ */
+export function createStreamProcessor(agentName, agentIcon, options = {}) {
+  return new StreamJsonProcessor({
+    agentName,
+    agentIcon,
+    ...options,
+  });
+}

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

@@ -0,0 +1,253 @@
+/**
+ * Simple Swarm Executor - Provides basic swarm functionality without TypeScript dependencies
+ */
+
+import { promises as fs } from 'fs';
+import path from 'path';
+
+// Simple ID generator to avoid build dependencies
+function generateId(prefix = 'id') {
+  const timestamp = Date.now().toString(36);
+  const random = Math.random().toString(36).substring(2, 9);
+  return `${prefix}_${timestamp}_${random}`;
+}
+
+// Simple SwarmCoordinator implementation
+export class SwarmCoordinator {
+  constructor(config) {
+    this.config = config;
+    this.id = config.name || generateId('swarm');
+    this.agents = [];
+    this.tasks = [];
+    this.status = 'initializing';
+    this.startTime = Date.now();
+  }
+
+  async initialize() {
+    console.log(`\n🚀 Swarm initialized: ${this.id}`);
+    console.log(`📋 Description: ${this.config.description}`);
+    console.log(`🎯 Strategy: ${this.config.strategy}`);
+    console.log(`🏗️  Mode: ${this.config.mode}`);
+    console.log(`🤖 Max Agents: ${this.config.maxAgents}`);
+
+    this.status = 'active';
+
+    // Create swarm directory
+    const swarmDir = `./swarm-runs/${this.id}`;
+    await fs.mkdir(swarmDir, { recursive: true });
+
+    // Save configuration
+    await fs.writeFile(path.join(swarmDir, 'config.json'), JSON.stringify(this.config, null, 2));
+
+    return this;
+  }
+
+  async addAgent(type, name) {
+    const agent = {
+      id: generateId('agent'),
+      type,
+      name: name || `${type}-${this.agents.length + 1}`,
+      status: 'active',
+      tasks: [],
+    };
+
+    this.agents.push(agent);
+    console.log(`  🤖 Agent spawned: ${agent.name} (${agent.type})`);
+
+    return agent;
+  }
+
+  async executeTask(task) {
+    const taskObj = {
+      id: generateId('task'),
+      description: task,
+      status: 'in_progress',
+      startTime: Date.now(),
+    };
+
+    this.tasks.push(taskObj);
+    console.log(`\n📌 Executing task: ${task}`);
+
+    // Simulate task execution with progress
+    console.log(`  ⏳ Processing...`);
+
+    // Simulate different types of tasks
+    if (task.toLowerCase().includes('api')) {
+      await this.createAPIProject();
+    } else if (task.toLowerCase().includes('test')) {
+      await this.runTests();
+    } else {
+      await this.genericTaskExecution(task);
+    }
+
+    taskObj.status = 'completed';
+    taskObj.endTime = Date.now();
+
+    console.log(`  ✅ Task completed in ${(taskObj.endTime - taskObj.startTime) / 1000}s`);
+
+    return taskObj;
+  }
+
+  async createAPIProject() {
+    console.log(`  🏗️  Creating API project structure...`);
+
+    const projectDir = './api-project';
+    await fs.mkdir(projectDir, { recursive: true });
+
+    // Create basic Express server
+    const serverCode = `const express = require('express');
+const app = express();
+const port = process.env.PORT || 3000;
+
+app.use(express.json());
+
+app.get('/health', (req, res) => {
+  res.json({ status: 'healthy', swarm: '${this.id}' });
+});
+
+app.get('/api/items', (req, res) => {
+  res.json({ items: [], count: 0 });
+});
+
+app.listen(port, () => {
+  console.log(\`API server running on port \${port}\`);
+});
+
+module.exports = app;
+`;
+
+    await fs.writeFile(path.join(projectDir, 'server.js'), serverCode);
+
+    // Create package.json
+    const packageJson = {
+      name: 'api-project',
+      version: '1.0.0',
+      description: 'API created by Claude Flow Swarm',
+      main: 'server.js',
+      scripts: {
+        start: 'node server.js',
+        dev: 'nodemon server.js',
+      },
+      dependencies: {
+        express: '^4.18.2',
+      },
+      devDependencies: {
+        nodemon: '^3.0.1',
+      },
+    };
+
+    await fs.writeFile(path.join(projectDir, 'package.json'), JSON.stringify(packageJson, null, 2));
+
+    console.log(`  ✅ Created API project in ${projectDir}`);
+  }
+
+  async runTests() {
+    console.log(`  🧪 Running tests...`);
+    console.log(`  ✅ All tests passed (0 tests)`);
+  }
+
+  async genericTaskExecution(task) {
+    console.log(`  🔄 Executing: ${task}`);
+
+    // Simulate work being done
+    await new Promise((resolve) => setTimeout(resolve, 1000));
+
+    console.log(`  ✅ Generic task completed`);
+  }
+
+  async getStatus() {
+    return {
+      id: this.id,
+      status: this.status,
+      agents: this.agents.length,
+      tasks: {
+        total: this.tasks.length,
+        completed: this.tasks.filter((t) => t.status === 'completed').length,
+        in_progress: this.tasks.filter((t) => t.status === 'in_progress').length,
+      },
+      runtime: Math.floor((Date.now() - this.startTime) / 1000),
+    };
+  }
+
+  async complete() {
+    this.status = 'completed';
+
+    const summary = await this.getStatus();
+    console.log(`\n✅ Swarm completed successfully!`);
+    console.log(`📊 Summary:`);
+    console.log(`  • Swarm ID: ${summary.id}`);
+    console.log(`  • Total Agents: ${summary.agents}`);
+    console.log(`  • Tasks Completed: ${summary.tasks.completed}`);
+    console.log(`  • Runtime: ${summary.runtime}s`);
+
+    // Save summary
+    const swarmDir = `./swarm-runs/${this.id}`;
+    await fs.writeFile(path.join(swarmDir, 'summary.json'), JSON.stringify(summary, null, 2));
+
+    return summary;
+  }
+}
+
+// Main execution function
+export async function executeSwarm(objective, flags = {}) {
+  try {
+    // Parse configuration from flags
+    const config = {
+      name: generateId('swarm'),
+      description: objective,
+      mode: flags.mode || 'centralized',
+      strategy: flags.strategy || 'auto',
+      maxAgents: parseInt(flags['max-agents']) || 5,
+      maxTasks: parseInt(flags['max-tasks']) || 100,
+      timeout: (parseInt(flags.timeout) || 60) * 60 * 1000,
+      taskTimeoutMinutes: parseInt(flags['task-timeout-minutes']) || 59,
+      qualityThreshold: parseFloat(flags['quality-threshold']) || 0.8,
+      reviewRequired: flags.review || false,
+      testingRequired: flags.testing || false,
+      monitoring: {
+        enabled: flags.monitor || false,
+      },
+      memory: {
+        namespace: flags['memory-namespace'] || 'swarm',
+        persistent: flags.persistence !== false,
+      },
+      security: {
+        encryptionEnabled: flags.encryption || false,
+      },
+    };
+
+    // Initialize swarm coordinator
+    const coordinator = new SwarmCoordinator(config);
+    await coordinator.initialize();
+
+    // Spawn agents based on strategy
+    if (config.strategy === 'development' || config.strategy === 'auto') {
+      await coordinator.addAgent('architect', 'System Architect');
+      await coordinator.addAgent('coder', 'Backend Developer');
+      await coordinator.addAgent('coder', 'Frontend Developer');
+      await coordinator.addAgent('tester', 'QA Engineer');
+      await coordinator.addAgent('reviewer', 'Code Reviewer');
+    } else if (config.strategy === 'research') {
+      await coordinator.addAgent('researcher', 'Lead Researcher');
+      await coordinator.addAgent('analyst', 'Data Analyst');
+      await coordinator.addAgent('researcher', 'Research Assistant');
+    } else if (config.strategy === 'testing') {
+      await coordinator.addAgent('tester', 'Test Lead');
+      await coordinator.addAgent('tester', 'Integration Tester');
+      await coordinator.addAgent('tester', 'Performance Tester');
+    }
+
+    // Execute the main objective
+    await coordinator.executeTask(objective);
+
+    // Complete and return summary
+    const summary = await coordinator.complete();
+
+    return { success: true, summary };
+  } catch (error) {
+    console.error(`❌ Swarm execution failed: ${error.message}`);
+    return { success: false, error: error.message };
+  }
+}
+
+// Exports are already declared inline above