claude-flow 2.0.0-alpha.78 → 2.0.0-alpha.79

package/src/agents/agent-manager.ts

@@ -388,6 +388,438 @@ export class AgentManager extends EventEmitter {
       },
       startupScript: './scripts/start-analyzer.ts',
     });
+
+    // Requirements Engineer Agent Template
+    this.templates.set('requirements-engineer', {
+      name: 'Requirements Engineer Agent',
+      type: 'requirements-engineer',
+      capabilities: {
+        codeGeneration: false,
+        codeReview: false,
+        testing: false,
+        documentation: true,
+        research: true,
+        analysis: true,
+        webSearch: true,
+        apiIntegration: false,
+        fileSystem: true,
+        terminalAccess: false,
+        languages: [],
+        frameworks: [],
+        domains: ['requirements-engineering', 'user-stories', 'ears-notation'],
+        tools: ['document-writer', 'nlp-processor', 'web-search'],
+        maxConcurrentTasks: 2,
+        maxMemoryUsage: 256 * 1024 * 1024,
+        maxExecutionTime: 300000,
+        reliability: 0.95,
+        speed: 0.8,
+        quality: 0.95,
+      },
+      config: {
+        autonomyLevel: 0.8,
+        learningEnabled: true,
+        adaptationEnabled: true,
+        maxTasksPerHour: 10,
+        maxConcurrentTasks: 2,
+        timeoutThreshold: 300000,
+        reportingInterval: 30000,
+        heartbeatInterval: 10000,
+        permissions: ['file-read', 'file-write'],
+        trustedAgents: [],
+        expertise: { requirements: 0.95, documentation: 0.9, analysis: 0.8 },
+        preferences: { format: 'markdown', style: 'formal' },
+      },
+      environment: {
+        runtime: 'deno',
+        version: '1.40.0',
+        workingDirectory: './agents/requirements-engineer',
+        tempDirectory: './tmp/requirements-engineer',
+        logDirectory: './logs/requirements-engineer',
+        apiEndpoints: {},
+        credentials: {},
+        availableTools: ['document-writer', 'nlp-processor'],
+        toolConfigs: {},
+      },
+      startupScript: './scripts/start-requirements-engineer.ts',
+    });
+
+    // Design Architect Agent Template
+    this.templates.set('design-architect', {
+      name: 'Design Architect Agent',
+      type: 'design-architect',
+      capabilities: {
+        codeGeneration: false,
+        codeReview: true,
+        testing: false,
+        documentation: true,
+        research: true,
+        analysis: true,
+        webSearch: false,
+        apiIntegration: true,
+        fileSystem: true,
+        terminalAccess: false,
+        languages: ['typescript', 'javascript', 'python'],
+        frameworks: [],
+        domains: ['software-architecture', 'system-design', 'data-modeling'],
+        tools: ['diagram-generator', 'code-analyzer', 'api-designer'],
+        maxConcurrentTasks: 1,
+        maxMemoryUsage: 512 * 1024 * 1024,
+        maxExecutionTime: 600000,
+        reliability: 0.9,
+        speed: 0.7,
+        quality: 0.95,
+      },
+      config: {
+        autonomyLevel: 0.7,
+        learningEnabled: true,
+        adaptationEnabled: true,
+        maxTasksPerHour: 5,
+        maxConcurrentTasks: 1,
+        timeoutThreshold: 600000,
+        reportingInterval: 60000,
+        heartbeatInterval: 15000,
+        permissions: ['file-read', 'file-write'],
+        trustedAgents: [],
+        expertise: { architecture: 0.95, design: 0.9, modeling: 0.85 },
+        preferences: { diagramFormat: 'mermaid', detailLevel: 'high' },
+      },
+      environment: {
+        runtime: 'deno',
+        version: '1.40.0',
+        workingDirectory: './agents/design-architect',
+        tempDirectory: './tmp/design-architect',
+        logDirectory: './logs/design-architect',
+        apiEndpoints: {},
+        credentials: {},
+        availableTools: ['diagram-gen', 'code-analyzer'],
+        toolConfigs: {},
+      },
+      startupScript: './scripts/start-design-architect.ts',
+    });
+
+    // Task Planner Agent Template
+    this.templates.set('task-planner', {
+      name: 'Task Planner Agent',
+      type: 'task-planner',
+      capabilities: {
+        codeGeneration: false,
+        codeReview: false,
+        testing: false,
+        documentation: true,
+        research: false,
+        analysis: true,
+        webSearch: false,
+        apiIntegration: false,
+        fileSystem: true,
+        terminalAccess: false,
+        languages: [],
+        frameworks: [],
+        domains: ['project-management', 'task-breakdown', 'agile-planning'],
+        tools: ['task-scheduler', 'dependency-analyzer'],
+        maxConcurrentTasks: 3,
+        maxMemoryUsage: 256 * 1024 * 1024,
+        maxExecutionTime: 300000,
+        reliability: 0.95,
+        speed: 0.85,
+        quality: 0.9,
+      },
+      config: {
+        autonomyLevel: 0.8,
+        learningEnabled: true,
+        adaptationEnabled: true,
+        maxTasksPerHour: 20,
+        maxConcurrentTasks: 3,
+        timeoutThreshold: 300000,
+        reportingInterval: 30000,
+        heartbeatInterval: 10000,
+        permissions: ['file-read', 'file-write'],
+        trustedAgents: [],
+        expertise: { planning: 0.95, 'task-management': 0.9, optimization: 0.8 },
+        preferences: { outputFormat: 'markdown-checkbox', granularity: 'fine' },
+      },
+      environment: {
+        runtime: 'deno',
+        version: '1.40.0',
+        workingDirectory: './agents/task-planner',
+        tempDirectory: './tmp/task-planner',
+        logDirectory: './logs/task-planner',
+        apiEndpoints: {},
+        credentials: {},
+        availableTools: ['task-scheduler', 'dependency-analyzer'],
+        toolConfigs: {},
+      },
+      startupScript: './scripts/start-task-planner.ts',
+    });
+
+    // Developer Agent Template (already exists, but ensure it's aligned)
+    this.templates.set('developer', {
+      name: 'Developer Agent',
+      type: 'developer',
+      capabilities: {
+        codeGeneration: true,
+        codeReview: true,
+        testing: true,
+        documentation: true,
+        research: false,
+        analysis: true,
+        webSearch: false,
+        apiIntegration: true,
+        fileSystem: true,
+        terminalAccess: true,
+        languages: ['typescript', 'javascript', 'python', 'rust'],
+        frameworks: ['deno', 'node', 'react', 'svelte'],
+        domains: ['web-development', 'backend', 'api-design'],
+        tools: ['git', 'editor', 'debugger', 'linter', 'formatter'],
+        maxConcurrentTasks: 3,
+        maxMemoryUsage: 512 * 1024 * 1024,
+        maxExecutionTime: 1200000,
+        reliability: 0.95,
+        speed: 0.7,
+        quality: 0.95,
+      },
+      config: {
+        autonomyLevel: 0.6,
+        learningEnabled: true,
+        adaptationEnabled: true,
+        maxTasksPerHour: 10,
+        maxConcurrentTasks: 3,
+        timeoutThreshold: 1200000,
+        reportingInterval: 60000,
+        heartbeatInterval: 15000,
+        permissions: ['file-read', 'file-write', 'terminal-access', 'git-access'],
+        trustedAgents: [],
+        expertise: { coding: 0.95, testing: 0.8, debugging: 0.9 },
+        preferences: { codeStyle: 'functional', testFramework: 'deno-test' },
+      },
+      environment: {
+        runtime: 'deno',
+        version: '1.40.0',
+        workingDirectory: './agents/developer',
+        tempDirectory: './tmp/developer',
+        logDirectory: './logs/developer',
+        apiEndpoints: {},
+        credentials: {},
+        availableTools: ['git', 'deno', 'editor', 'debugger'],
+        toolConfigs: {},
+      },
+      startupScript: './scripts/start-developer.ts',
+    });
+
+    // System Architect Agent Template  
+    this.templates.set('system-architect', {
+      name: 'System Architect Agent',
+      type: 'system-architect',
+      capabilities: {
+        codeGeneration: false,
+        codeReview: true,
+        testing: false,
+        documentation: true,
+        research: true,
+        analysis: true,
+        webSearch: false,
+        apiIntegration: true,
+        fileSystem: true,
+        terminalAccess: false,
+        languages: ['typescript', 'javascript', 'python'],
+        frameworks: ['microservices', 'distributed-systems'],
+        domains: ['system-architecture', 'scalability', 'performance', 'distributed-systems'],
+        tools: ['architecture-analyzer', 'system-modeler', 'performance-analyzer'],
+        maxConcurrentTasks: 1,
+        maxMemoryUsage: 512 * 1024 * 1024,
+        maxExecutionTime: 900000,
+        reliability: 0.95,
+        speed: 0.7,
+        quality: 0.95,
+      },
+      config: {
+        autonomyLevel: 0.8,
+        learningEnabled: true,
+        adaptationEnabled: true,
+        maxTasksPerHour: 5,
+        maxConcurrentTasks: 1,
+        timeoutThreshold: 900000,
+        reportingInterval: 60000,
+        heartbeatInterval: 15000,
+        permissions: ['file-read', 'file-write'],
+        trustedAgents: [],
+        expertise: { 'system-architecture': 0.95, scalability: 0.9, performance: 0.85 },
+        preferences: { scope: 'system-wide', focusArea: 'architecture' },
+      },
+      environment: {
+        runtime: 'deno',
+        version: '1.40.0',
+        workingDirectory: './agents/system-architect',
+        tempDirectory: './tmp/system-architect',
+        logDirectory: './logs/system-architect',
+        apiEndpoints: {},
+        credentials: {},
+        availableTools: ['architecture-analyzer', 'system-modeler'],
+        toolConfigs: {},
+      },
+      startupScript: './scripts/start-system-architect.ts',
+    });
+
+    // Tester Agent Template
+    this.templates.set('tester', {
+      name: 'Testing Agent',
+      type: 'tester',
+      capabilities: {
+        codeGeneration: false,
+        codeReview: true,
+        testing: true,
+        documentation: true,
+        research: false,
+        analysis: true,
+        webSearch: false,
+        apiIntegration: true,
+        fileSystem: true,
+        terminalAccess: true,
+        languages: ['typescript', 'javascript', 'python'],
+        frameworks: ['deno-test', 'jest', 'vitest', 'cypress'],
+        domains: ['testing', 'quality-assurance', 'test-automation'],
+        tools: ['test-runner', 'coverage-analyzer', 'test-generator'],
+        maxConcurrentTasks: 3,
+        maxMemoryUsage: 256 * 1024 * 1024,
+        maxExecutionTime: 600000,
+        reliability: 0.9,
+        speed: 0.8,
+        quality: 0.9,
+      },
+      config: {
+        autonomyLevel: 0.7,
+        learningEnabled: true,
+        adaptationEnabled: true,
+        maxTasksPerHour: 15,
+        maxConcurrentTasks: 3,
+        timeoutThreshold: 600000,
+        reportingInterval: 45000,
+        heartbeatInterval: 12000,
+        permissions: ['file-read', 'file-write', 'terminal-access'],
+        trustedAgents: [],
+        expertise: { testing: 0.9, 'quality-assurance': 0.85, automation: 0.8 },
+        preferences: { testFramework: 'deno-test', coverage: 'comprehensive' },
+      },
+      environment: {
+        runtime: 'deno',
+        version: '1.40.0',
+        workingDirectory: './agents/tester',
+        tempDirectory: './tmp/tester',
+        logDirectory: './logs/tester',
+        apiEndpoints: {},
+        credentials: {},
+        availableTools: ['test-runner', 'coverage-tool', 'test-gen'],
+        toolConfigs: {},
+      },
+      startupScript: './scripts/start-tester.ts',
+    });
+
+    // Code Reviewer Agent Template
+    this.templates.set('reviewer', {
+      name: 'Code Review Agent',
+      type: 'reviewer',
+      capabilities: {
+        codeGeneration: false,
+        codeReview: true,
+        testing: false,
+        documentation: true,
+        research: false,
+        analysis: true,
+        webSearch: false,
+        apiIntegration: false,
+        fileSystem: true,
+        terminalAccess: false,
+        languages: ['typescript', 'javascript', 'python', 'rust'],
+        frameworks: ['static-analysis', 'code-quality'],
+        domains: ['code-review', 'quality-assurance', 'best-practices'],
+        tools: ['static-analyzer', 'code-quality-checker', 'security-scanner'],
+        maxConcurrentTasks: 2,
+        maxMemoryUsage: 256 * 1024 * 1024,
+        maxExecutionTime: 450000,
+        reliability: 0.95,
+        speed: 0.8,
+        quality: 0.95,
+      },
+      config: {
+        autonomyLevel: 0.8,
+        learningEnabled: true,
+        adaptationEnabled: true,
+        maxTasksPerHour: 12,
+        maxConcurrentTasks: 2,
+        timeoutThreshold: 450000,
+        reportingInterval: 30000,
+        heartbeatInterval: 10000,
+        permissions: ['file-read'],
+        trustedAgents: [],
+        expertise: { 'code-review': 0.95, 'quality-assurance': 0.9, security: 0.8 },
+        preferences: { style: 'thorough', focus: 'quality-and-security' },
+      },
+      environment: {
+        runtime: 'deno',
+        version: '1.40.0',
+        workingDirectory: './agents/reviewer',
+        tempDirectory: './tmp/reviewer',
+        logDirectory: './logs/reviewer',
+        apiEndpoints: {},
+        credentials: {},
+        availableTools: ['static-analyzer', 'quality-checker'],
+        toolConfigs: {},
+      },
+      startupScript: './scripts/start-reviewer.ts',
+    });
+
+    // Steering Author Agent Template
+    this.templates.set('steering-author', {
+      name: 'Steering Author Agent',
+      type: 'steering-author',
+      capabilities: {
+        codeGeneration: false,
+        codeReview: true,
+        testing: false,
+        documentation: true,
+        research: true,
+        analysis: true,
+        webSearch: false,
+        apiIntegration: false,
+        fileSystem: true,
+        terminalAccess: false,
+        languages: [],
+        frameworks: [],
+        domains: ['documentation', 'knowledge-management', 'governance'],
+        tools: ['document-writer', 'content-analyzer'],
+        maxConcurrentTasks: 1,
+        maxMemoryUsage: 256 * 1024 * 1024,
+        maxExecutionTime: 300000,
+        reliability: 0.95,
+        speed: 0.7,
+        quality: 0.98,
+      },
+      config: {
+        autonomyLevel: 0.7,
+        learningEnabled: true,
+        adaptationEnabled: true,
+        maxTasksPerHour: 5,
+        maxConcurrentTasks: 1,
+        timeoutThreshold: 300000,
+        reportingInterval: 30000,
+        heartbeatInterval: 10000,
+        permissions: ['file-read', 'file-write'],
+        trustedAgents: [],
+        expertise: { documentation: 0.98, governance: 0.9, 'content-creation': 0.85 },
+        preferences: { style: 'concise', tone: 'formal' },
+      },
+      environment: {
+        runtime: 'deno',
+        version: '1.40.0',
+        workingDirectory: './agents/steering-author',
+        tempDirectory: './tmp/steering-author',
+        logDirectory: './logs/steering-author',
+        apiEndpoints: {},
+        credentials: {},
+        availableTools: ['document-writer', 'content-analyzer'],
+        toolConfigs: {},
+      },
+      startupScript: './scripts/start-steering-author.ts',
+    });
   }
 
   async initialize(): Promise<void> {

package/src/cli/agents/index.ts

@@ -211,7 +211,12 @@ export class AgentFactory {
    * Get supported agent types
    */
   getSupportedTypes(): AgentType[] {
-    return ['researcher', 'coder', 'analyst', 'architect', 'tester', 'coordinator'];
+    return [
+      'researcher', 'coder', 'analyst', 'architect', 'tester', 'coordinator',
+      'reviewer', 'optimizer', 'documenter', 'monitor', 'specialist',
+      'requirements_analyst', 'design_architect', 'task_planner', 
+      'implementation_coder', 'quality_reviewer', 'steering_documenter'
+    ];
   }
 
   /**
@@ -230,6 +235,15 @@ export class AgentFactory {
       documenter: 'Creates and maintains comprehensive documentation',
       monitor: 'Monitors system health and performance metrics',
       specialist: 'Provides domain-specific expertise and specialized knowledge',
+      requirements_analyst: 'Analyzes requirements and creates user stories with acceptance criteria',
+      design_architect: 'Creates technical designs and system architecture for features',
+      'system-architect': 'High-level system architecture and design patterns',
+      task_planner: 'Plans implementation tasks and orchestrates workflow execution', 
+      'task-planner': 'Plans implementation tasks and orchestrates workflow execution',
+      implementation_coder: 'Implements code based on designs with quality focus',
+      developer: 'General purpose software development and implementation',
+      quality_reviewer: 'Reviews code quality and ensures standards compliance',
+      steering_documenter: 'Maintains governance documentation and project steering'
     };
   }
 

package/src/cli/command-registry.js

@@ -31,6 +31,8 @@ import {
   fixHookVariablesCommand,
   fixHookVariablesCommandConfig,
 } from './simple-commands/fix-hook-variables.js';
+// Maestro commands integrated with clean implementation
+// Note: Maestro TypeScript commands now integrated directly in ./commands/maestro.ts
 // Note: TypeScript imports commented out for Node.js compatibility
 // import { ruvSwarmAction } from './commands/ruv-swarm.ts';
 // import { configIntegrationAction } from './commands/config-integration.ts';
@@ -117,6 +119,28 @@ First-time users should run: npx claude-flow@latest init --sparc`,
     ],
   });
 
+  // Note: Maestro commands are now handled by TypeScript module
+  // See src/cli/commands/maestro.ts for the clean implementation
+  commandRegistry.set('maestro', {
+    handler: () => {
+      console.log('⚠️  Maestro commands have been moved to TypeScript.');
+      console.log('Please use: npx claude-flow maestro help');
+      console.log('Or import from: ./commands/maestro.js after compilation');
+    },
+    description: 'Maestro: Specs-Driven Development with Hive Mind Integration',
+    usage: 'maestro <subcommand> [options]',
+    examples: [
+      'maestro create-spec my-feature --request "Implement user auth"',
+      'maestro generate-design my-feature',
+      'maestro generate-tasks my-feature',
+      'maestro implement-task my-feature 1',
+      'maestro approve-phase my-feature',
+      'maestro status my-feature --detailed',
+      'maestro init-steering api-design',
+      'maestro help',
+    ],
+  });
+
   commandRegistry.set('agent', {
     handler: agentCommand,
     description: 'Manage AI agents and hierarchies',

package/src/cli/commands/hive-mind/spawn.ts

@@ -26,6 +26,15 @@ const AGENT_TYPES: AgentType[] = [
   'documenter',
   'monitor',
   'specialist',
+  'requirements_analyst',
+  'design_architect',
+  'system-architect',
+  'task_planner',
+  'task-planner',
+  'implementation_coder',
+  'developer',
+  'quality_reviewer',
+  'steering_documenter',
 ];
 
 const CAPABILITY_MAP: Record<AgentType, AgentCapability[]> = {
@@ -40,6 +49,15 @@ const CAPABILITY_MAP: Record<AgentType, AgentCapability[]> = {
   documenter: ['documentation_generation', 'api_docs', 'user_guides'],
   monitor: ['system_monitoring', 'health_checks', 'alerting'],
   specialist: ['domain_expertise', 'custom_capabilities', 'problem_solving'],
+  requirements_analyst: ['requirements_analysis', 'user_story_creation', 'acceptance_criteria'],
+  design_architect: ['system_design', 'architecture', 'specs_driven_design'],
+  'system-architect': ['system_design', 'architecture_patterns', 'integration_planning'],
+  task_planner: ['task_management', 'workflow_orchestration'],
+  'task-planner': ['task_management', 'workflow_orchestration'],
+  implementation_coder: ['code_generation', 'implementation', 'debugging'],
+  developer: ['code_generation', 'implementation', 'debugging'],
+  quality_reviewer: ['code_review', 'quality_assurance', 'testing'],
+  steering_documenter: ['documentation_generation', 'governance']
 };
 
 export const spawnCommand = new Command('spawn')