claude-flow 2.0.0-alpha.60 → 2.0.0-alpha.62

package/src/cli/__tests__/command-registry.test.js

@@ -3,14 +3,14 @@
  */
 
 import { jest } from '@jest/globals';
-import { 
-  commandRegistry, 
-  registerCoreCommands, 
-  executeCommand, 
-  hasCommand, 
-  showCommandHelp, 
-  showAllCommands, 
-  listCommands 
+import {
+  commandRegistry,
+  registerCoreCommands,
+  executeCommand,
+  hasCommand,
+  showCommandHelp,
+  showAllCommands,
+  listCommands,
 } from '../command-registry.js';
 
 // Mock all command modules
@@ -89,22 +89,34 @@ describe('Command Registry', () => {
   describe('registerCoreCommands', () => {
     test('should register all core commands', () => {
       registerCoreCommands();
-      
+
       const expectedCommands = [
-        'init', 'start', 'memory', 'sparc', 'agent', 
-        'task', 'config', 'status', 'mcp', 'monitor',
-        'swarm', 'batch-manager', 'github', 'docker',
-        'ruv-swarm', 'config-integration'
+        'init',
+        'start',
+        'memory',
+        'sparc',
+        'agent',
+        'task',
+        'config',
+        'status',
+        'mcp',
+        'monitor',
+        'swarm',
+        'batch-manager',
+        'github',
+        'docker',
+        'ruv-swarm',
+        'config-integration',
       ];
-      
-      expectedCommands.forEach(cmd => {
+
+      expectedCommands.forEach((cmd) => {
         expect(commandRegistry.has(cmd)).toBe(true);
       });
     });
 
     test('should register commands with correct metadata', () => {
       registerCoreCommands();
-      
+
       const initCmd = commandRegistry.get('init');
       expect(initCmd).toHaveProperty('handler');
       expect(initCmd).toHaveProperty('description');
@@ -139,23 +151,21 @@ describe('Command Registry', () => {
 
     test('should execute command handler with arguments', async () => {
       const { initCommand } = await import('../simple-commands/init.js');
-      
+
       await executeCommand('init', ['--sparc'], { force: true });
-      
+
       expect(initCommand).toHaveBeenCalledWith(['--sparc'], { force: true });
     });
 
     test('should throw error for unknown command', async () => {
-      await expect(executeCommand('unknown', [], {}))
-        .rejects.toThrow('Unknown command: unknown');
+      await expect(executeCommand('unknown', [], {})).rejects.toThrow('Unknown command: unknown');
     });
 
     test('should handle command execution errors', async () => {
       const { swarmCommand } = await import('../simple-commands/swarm.js');
       swarmCommand.mockRejectedValue(new Error('Command failed'));
-      
-      await expect(executeCommand('swarm', ['test'], {}))
-        .rejects.toThrow('Command failed');
+
+      await expect(executeCommand('swarm', ['test'], {})).rejects.toThrow('Command failed');
     });
   });
 
@@ -166,7 +176,7 @@ describe('Command Registry', () => {
 
     test('should display help for existing command', () => {
       showCommandHelp('init');
-      
+
       const output = consoleLogSpy.mock.calls.flat().join('\n');
       expect(output).toContain('init');
       expect(output).toContain('Initialize Claude Code integration');
@@ -176,9 +186,9 @@ describe('Command Registry', () => {
 
     test('should show error for unknown command', () => {
       showCommandHelp('unknown');
-      
+
       expect(consoleErrorSpy).toHaveBeenCalledWith(
-        expect.stringContaining('Unknown command: unknown')
+        expect.stringContaining('Unknown command: unknown'),
       );
     });
   });
@@ -187,15 +197,15 @@ describe('Command Registry', () => {
     test('should display all registered commands grouped by category', () => {
       registerCoreCommands();
       showAllCommands();
-      
+
       const output = consoleLogSpy.mock.calls.flat().join('\n');
-      
+
       // Check for categories
       expect(output).toContain('SWARM INTELLIGENCE COMMANDS');
       expect(output).toContain('WORKFLOW AUTOMATION');
       expect(output).toContain('DEVELOPMENT & TESTING');
       expect(output).toContain('INFRASTRUCTURE');
-      
+
       // Check for specific commands
       expect(output).toContain('swarm');
       expect(output).toContain('agent');
@@ -209,7 +219,7 @@ describe('Command Registry', () => {
     test('should return array of all command names', () => {
       registerCoreCommands();
       const commands = listCommands();
-      
+
       expect(Array.isArray(commands)).toBe(true);
       expect(commands).toContain('init');
       expect(commands).toContain('swarm');
@@ -220,8 +230,8 @@ describe('Command Registry', () => {
     test('should return empty array when no commands registered', () => {
       commandRegistry.clear();
       const commands = listCommands();
-      
+
       expect(commands).toEqual([]);
     });
   });
-});
+});

package/src/cli/__tests__/simple-cli.test.js

@@ -48,13 +48,15 @@ describe('Claude-Flow CLI', () => {
   describe('Help output', () => {
     test('should show help when no arguments provided', async () => {
       process.argv = ['node', 'claude-flow'];
-      
-      const { executeCommand, hasCommand, showAllCommands } = await import('../command-registry.js');
+
+      const { executeCommand, hasCommand, showAllCommands } = await import(
+        '../command-registry.js'
+      );
       hasCommand.mockReturnValue(false);
-      
+
       // Import after mocks are set up
       await import('../simple-cli.js');
-      
+
       expect(consoleLogSpy).toHaveBeenCalled();
       const output = consoleLogSpy.mock.calls.join('\n');
       expect(output).toContain('Claude-Flow v2.0.0');
@@ -64,12 +66,12 @@ describe('Claude-Flow CLI', () => {
 
     test('should show help for --help flag', async () => {
       process.argv = ['node', 'claude-flow', '--help'];
-      
+
       const { hasCommand } = await import('../command-registry.js');
       hasCommand.mockReturnValue(false);
-      
+
       await import('../simple-cli.js');
-      
+
       expect(consoleLogSpy).toHaveBeenCalled();
       const output = consoleLogSpy.mock.calls.join('\n');
       expect(output).toContain('Claude-Flow v2.0.0');
@@ -77,9 +79,9 @@ describe('Claude-Flow CLI', () => {
 
     test('should show version for --version flag', async () => {
       process.argv = ['node', 'claude-flow', '--version'];
-      
+
       await import('../simple-cli.js');
-      
+
       expect(consoleLogSpy).toHaveBeenCalledWith('2.0.0');
       expect(process.exit).toHaveBeenCalledWith(0);
     });
@@ -88,48 +90,51 @@ describe('Claude-Flow CLI', () => {
   describe('Command execution', () => {
     test('should execute valid command', async () => {
       process.argv = ['node', 'claude-flow', 'init', '--sparc'];
-      
+
       const { executeCommand, hasCommand } = await import('../command-registry.js');
       hasCommand.mockReturnValue(true);
       executeCommand.mockResolvedValue(undefined);
-      
+
       await import('../simple-cli.js');
-      
+
       expect(hasCommand).toHaveBeenCalledWith('init');
       expect(executeCommand).toHaveBeenCalledWith('init', ['--sparc'], {});
     });
 
     test('should handle command with multiple arguments', async () => {
-      process.argv = ['node', 'claude-flow', 'swarm', 'Build a REST API', '--strategy', 'development'];
-      
+      process.argv = [
+        'node',
+        'claude-flow',
+        'swarm',
+        'Build a REST API',
+        '--strategy',
+        'development',
+      ];
+
       const { executeCommand, hasCommand } = await import('../command-registry.js');
       hasCommand.mockReturnValue(true);
       executeCommand.mockResolvedValue(undefined);
-      
+
       await import('../simple-cli.js');
-      
+
       expect(hasCommand).toHaveBeenCalledWith('swarm');
-      expect(executeCommand).toHaveBeenCalledWith(
-        'swarm', 
-        ['Build a REST API'], 
-        { strategy: 'development' }
-      );
+      expect(executeCommand).toHaveBeenCalledWith('swarm', ['Build a REST API'], {
+        strategy: 'development',
+      });
     });
 
     test('should show error for unknown command', async () => {
       process.argv = ['node', 'claude-flow', 'invalid-command'];
-      
+
       const { hasCommand, listCommands } = await import('../command-registry.js');
       hasCommand.mockReturnValue(false);
-      
+
       await import('../simple-cli.js');
-      
+
       expect(consoleErrorSpy).toHaveBeenCalledWith(
-        expect.stringContaining('Unknown command: invalid-command')
-      );
-      expect(consoleLogSpy).toHaveBeenCalledWith(
-        expect.stringContaining('Available commands:')
+        expect.stringContaining('Unknown command: invalid-command'),
       );
+      expect(consoleLogSpy).toHaveBeenCalledWith(expect.stringContaining('Available commands:'));
     });
   });
 
@@ -158,31 +163,31 @@ describe('Claude-Flow CLI', () => {
   describe('Error handling', () => {
     test('should handle command execution errors gracefully', async () => {
       process.argv = ['node', 'claude-flow', 'init'];
-      
+
       const { executeCommand, hasCommand } = await import('../command-registry.js');
       hasCommand.mockReturnValue(true);
       executeCommand.mockRejectedValue(new Error('Test error'));
-      
+
       await import('../simple-cli.js');
-      
+
       expect(consoleErrorSpy).toHaveBeenCalledWith(
-        expect.stringContaining('Error executing command:')
+        expect.stringContaining('Error executing command:'),
       );
       expect(process.exit).toHaveBeenCalledWith(1);
     });
 
     test('should handle missing required arguments', async () => {
       process.argv = ['node', 'claude-flow', 'agent'];
-      
+
       const { executeCommand, hasCommand } = await import('../command-registry.js');
       hasCommand.mockReturnValue(true);
       executeCommand.mockRejectedValue(new Error('Missing required argument'));
-      
+
       await import('../simple-cli.js');
-      
+
       expect(consoleErrorSpy).toHaveBeenCalledWith(
-        expect.stringContaining('Missing required argument')
+        expect.stringContaining('Missing required argument'),
       );
     });
   });
-});
+});

package/src/cli/__tests__/utils.test.js

@@ -3,7 +3,7 @@
  */
 
 import { jest } from '@jest/globals';
-import { 
+import {
   parseFlags,
   formatBytes,
   truncateString,
@@ -18,7 +18,7 @@ import {
   chunk,
   isValidJson,
   isValidUrl,
-  formatTimestamp
+  formatTimestamp,
 } from '../utils.js';
 
 // Mock console for testing output functions
@@ -138,7 +138,7 @@ describe('Utils', () => {
     test('should generate unique IDs', () => {
       const id1 = generateId();
       const id2 = generateId();
-      
+
       expect(id1).not.toBe(id2);
       expect(id1.length).toBeGreaterThan(0);
       expect(typeof id1).toBe('string');
@@ -160,7 +160,7 @@ describe('Utils', () => {
       });
 
       const result = await retry(fn, 3, 10);
-      
+
       expect(result).toBe('success');
       expect(fn).toHaveBeenCalledTimes(3);
     });
@@ -180,7 +180,7 @@ describe('Utils', () => {
       const start = Date.now();
       await sleep(50);
       const end = Date.now();
-      
+
       expect(end - start).toBeGreaterThanOrEqual(45); // Allow some margin
     });
   });
@@ -189,7 +189,7 @@ describe('Utils', () => {
     test('should split array into chunks', () => {
       const array = [1, 2, 3, 4, 5, 6, 7];
       const result = chunk(array, 3);
-      
+
       expect(result).toEqual([[1, 2, 3], [4, 5, 6], [7]]);
     });
 
@@ -237,7 +237,7 @@ describe('Utils', () => {
     test('should format timestamp to readable string', () => {
       const timestamp = 1234567890000; // Fixed timestamp
       const result = formatTimestamp(timestamp);
-      
+
       expect(typeof result).toBe('string');
       expect(result.length).toBeGreaterThan(0);
     });
@@ -245,9 +245,9 @@ describe('Utils', () => {
     test('should handle current timestamp', () => {
       const now = Date.now();
       const result = formatTimestamp(now);
-      
+
       expect(typeof result).toBe('string');
       expect(result).toContain('2025'); // Should contain current year
     });
   });
-});
+});

package/src/cli/agents/README.md

@@ -5,14 +5,18 @@ A comprehensive agent type system with specialized capabilities, neural pattern
 ## Agent Types Implemented
 
 ### 1. Researcher Agent (`researcher.ts`)
+
 **Specialization**: Information gathering and research
+
 - **Capabilities**: Web search, data collection, analysis, documentation
 - **Domains**: Research, market analysis, fact-checking, literature review
 - **Tools**: Web search, document analyzer, data extractor, citation generator
 - **Use Cases**: Market research, competitive intelligence, academic research
 
 ### 2. Coder Agent (`coder.ts`)
+
 **Specialization**: Software development and code generation
+
 - **Capabilities**: Code generation, review, testing, debugging
 - **Languages**: TypeScript, JavaScript, Python, Rust, Go, Java, C++, C#, PHP, Ruby
 - **Frameworks**: Deno, Node, React, Vue, Django, Spring, Rails
@@ -20,7 +24,9 @@ A comprehensive agent type system with specialized capabilities, neural pattern
 - **Use Cases**: Full-stack development, API creation, code refactoring
 
 ### 3. Analyst Agent (`analyst.ts`)
+
 **Specialization**: Data analysis and performance optimization
+
 - **Capabilities**: Statistical analysis, data visualization, predictive modeling
 - **Languages**: Python, R, SQL, TypeScript, Julia, Scala
 - **Frameworks**: Pandas, NumPy, Matplotlib, Plotly, TensorFlow, PyTorch
@@ -28,21 +34,27 @@ A comprehensive agent type system with specialized capabilities, neural pattern
 - **Use Cases**: Business intelligence, performance analysis, anomaly detection
 
 ### 4. Architect Agent (`architect.ts`)
+
 **Specialization**: System design and architecture
+
 - **Capabilities**: System design, architecture review, API design
 - **Domains**: Cloud architecture, microservices, security design, scalability
 - **Tools**: Architecture diagrams, system modeler, design patterns
 - **Use Cases**: System design, technical specifications, cloud architecture
 
 ### 5. Tester Agent (`tester.ts`)
+
 **Specialization**: Testing and quality assurance
+
 - **Capabilities**: Unit testing, integration testing, E2E testing, security testing
 - **Frameworks**: Jest, Cypress, Playwright, Selenium, PyTest
 - **Tools**: Test runner, coverage analyzer, browser automation
 - **Use Cases**: Test automation, quality assurance, performance testing
 
 ### 6. Coordinator Agent (`coordinator.ts`)
+
 **Specialization**: Task orchestration and project management
+
 - **Capabilities**: Task orchestration, resource allocation, progress tracking
 - **Domains**: Project management, workflow orchestration, team coordination
 - **Tools**: Task manager, workflow orchestrator, communication hub
@@ -51,12 +63,14 @@ A comprehensive agent type system with specialized capabilities, neural pattern
 ## Agent Capability System
 
 ### Capabilities Interface (`capabilities.ts`)
+
 - **Capability Registry**: Comprehensive catalog of agent skills
 - **Task Requirements**: Smart matching of tasks to agent capabilities
 - **Agent Selection**: Advanced algorithms for optimal agent assignment
 - **Semantic Matching**: Intelligent capability inference and matching
 
 ### Key Features
+
 - **Smart Agent Selection**: Automatically finds the best agent for each task
 - **Capability Matching**: Evaluates agent skills against task requirements
 - **Confidence Scoring**: Provides confidence levels for agent assignments
@@ -65,7 +79,9 @@ A comprehensive agent type system with specialized capabilities, neural pattern
 ## Agent Lifecycle Management
 
 ### Base Agent Class (`base-agent.ts`)
+
 All specialized agents inherit from a robust base class providing:
+
 - **Lifecycle Management**: Initialize, run, shutdown sequences
 - **Health Monitoring**: Real-time health tracking and reporting
 - **Memory Integration**: Persistent state and coordination data
@@ -73,6 +89,7 @@ All specialized agents inherit from a robust base class providing:
 - **Error Handling**: Comprehensive error tracking and recovery
 
 ### Agent Factory (`index.ts`)
+
 - **Dynamic Agent Creation**: Create agents based on type specifications
 - **Balanced Swarms**: Automatically create balanced agent teams
 - **Lifecycle Management**: Centralized agent lifecycle coordination
@@ -81,6 +98,7 @@ All specialized agents inherit from a robust base class providing:
 ## Agent Manager Integration
 
 ### Enhanced Agent Manager (`agent-manager.ts`)
+
 - **Pool Management**: Automatic agent pool creation and scaling
 - **Health Monitoring**: Real-time agent health checks and alerts
 - **Performance Metrics**: Comprehensive agent performance tracking
@@ -88,6 +106,7 @@ All specialized agents inherit from a robust base class providing:
 - **Auto-scaling**: Intelligent agent pool scaling based on demand
 
 ### Agent Registry (`agent-registry.ts`)
+
 - **Persistent Storage**: Agent state persistence across sessions
 - **Query System**: Advanced agent search and filtering
 - **Statistics**: Comprehensive agent usage and performance statistics
@@ -96,6 +115,7 @@ All specialized agents inherit from a robust base class providing:
 ## Neural Pattern Support
 
 Each agent type includes neural pattern integration:
+
 - **Learning Capabilities**: Agents can learn from successful task executions
 - **Adaptation**: Dynamic adaptation to changing requirements
 - **Pattern Recognition**: Recognition of recurring task patterns
@@ -104,6 +124,7 @@ Each agent type includes neural pattern integration:
 ## Memory Integration
 
 All agents integrate with the distributed memory system:
+
 - **Task Progress**: Real-time task progress and status storage
 - **Results Storage**: Persistent storage of task results and outputs
 - **Coordination Data**: Cross-agent communication and coordination
@@ -112,6 +133,7 @@ All agents integrate with the distributed memory system:
 ## Configuration and Environment
 
 Each agent supports comprehensive configuration:
+
 - **Autonomy Levels**: Configurable agent independence and decision-making
 - **Resource Limits**: Memory, CPU, and execution time constraints
 - **Permissions**: Fine-grained permission and access control
@@ -121,6 +143,7 @@ Each agent supports comprehensive configuration:
 ## Usage Examples
 
 ### Creating Specialized Agents
+
 ```typescript
 import { AgentFactory, createAgentFactory } from './agents/index.js';
 
@@ -130,12 +153,13 @@ const factory = createAgentFactory(logger, eventBus, memory);
 // Create specific agent types
 const researcher = factory.createAgent('researcher');
 const coder = factory.createAgent('coder', {
-  preferences: { codeStyle: 'functional' }
+  preferences: { codeStyle: 'functional' },
 });
 const analyst = factory.createAgent('analyst');
 ```
 
 ### Creating Balanced Swarms
+
 ```typescript
 // Create a balanced development team
 const devTeam = factory.createBalancedSwarm(6, 'development');
@@ -147,6 +171,7 @@ const researchTeam = factory.createBalancedSwarm(5, 'research');
 ```
 
 ### Smart Task Assignment
+
 ```typescript
 import { AgentCapabilitySystem } from './agents/capabilities.js';
 
@@ -158,8 +183,8 @@ const task = {
   description: 'Scrape product data from e-commerce sites',
   parameters: {
     languages: ['python'],
-    complexity: 'medium'
-  }
+    complexity: 'medium',
+  },
 };
 
 const matches = capabilitySystem.findBestAgents(task, availableAgents);
@@ -178,6 +203,7 @@ const bestAgent = matches[0].agent; // Highest scoring agent
 ## Integration with Claude Flow v2.0.0
 
 The agent system is fully integrated with:
+
 - **Swarm Coordination**: Works with ruv-swarm MCP tools
 - **Memory System**: Integrates with distributed memory
 - **Event Bus**: Participates in system-wide event coordination
@@ -206,4 +232,4 @@ The agent system is fully integrated with:
 - `agent-registry.ts` - Agent registration and persistent storage
 - `index.ts` - Agent factory and system exports
 
-This comprehensive agent system provides the foundation for sophisticated multi-agent workflows in Claude Flow v2.0.0, enabling intelligent task distribution, specialized expertise, and coordinated problem-solving.
+This comprehensive agent system provides the foundation for sophisticated multi-agent workflows in Claude Flow v2.0.0, enabling intelligent task distribution, specialized expertise, and coordinated problem-solving.