claude-flow 2.0.0-alpha.61 → 2.0.0-alpha.63

package/src/config/config-manager.ts

@@ -1,4 +1,3 @@
-import { getErrorMessage } from '../utils/error-handler.js';
 /**
  * Node.js-compatible Configuration management for Claude-Flow
  */
@@ -58,7 +57,13 @@ export interface Config {
   };
   claude?: {
     apiKey?: string;
-    model?: 'claude-3-opus-20240229' | 'claude-3-sonnet-20240229' | 'claude-3-haiku-20240307' | 'claude-2.1' | 'claude-2.0' | 'claude-instant-1.2';
+    model?:
+      | 'claude-3-opus-20240229'
+      | 'claude-3-sonnet-20240229'
+      | 'claude-3-haiku-20240307'
+      | 'claude-2.1'
+      | 'claude-2.0'
+      | 'claude-instant-1.2';
     temperature?: number;
     maxTokens?: number;
     topP?: number;
@@ -206,16 +211,16 @@ export class ConfigManager {
     try {
       const content = await fs.readFile(this.configPath, 'utf8');
       const fileConfig = JSON.parse(content) as Partial<Config>;
-      
+
       // Merge with defaults
       this.config = this.deepMerge(DEFAULT_CONFIG, fileConfig);
-      
+
       // Load environment variables
       this.loadFromEnv();
-      
+
       // Validate
       this.validate(this.config);
-      
+
       return this.config;
     } catch (error) {
       if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
@@ -238,7 +243,7 @@ export class ConfigManager {
   get(path: string): any {
     const keys = path.split('.');
     let current: any = this.config;
-    
+
     for (const key of keys) {
       if (current && typeof current === 'object' && key in current) {
         current = current[key];
@@ -246,7 +251,7 @@ export class ConfigManager {
         return undefined;
       }
     }
-    
+
     return current;
   }
 
@@ -256,7 +261,7 @@ export class ConfigManager {
   set(path: string, value: any): void {
     const keys = path.split('.');
     let current: any = this.config;
-    
+
     for (let i = 0; i < keys.length - 1; i++) {
       const key = keys[i];
       if (!(key in current)) {
@@ -264,10 +269,10 @@ export class ConfigManager {
       }
       current = current[key];
     }
-    
+
     const lastKey = keys[keys.length - 1];
     current[lastKey] = value;
-    
+
     // Validate after setting
     this.validate(this.config);
   }
@@ -290,7 +295,10 @@ export class ConfigManager {
    */
   validate(config: Config): void {
     // Orchestrator validation
-    if (config.orchestrator.maxConcurrentAgents < 1 || config.orchestrator.maxConcurrentAgents > 100) {
+    if (
+      config.orchestrator.maxConcurrentAgents < 1 ||
+      config.orchestrator.maxConcurrentAgents > 100
+    ) {
       throw new ConfigError('orchestrator.maxConcurrentAgents must be between 1 and 100');
     }
     if (config.orchestrator.taskQueueSize < 1 || config.orchestrator.taskQueueSize > 10000) {
@@ -339,19 +347,30 @@ export class ConfigManager {
 
     // ruv-swarm validation
     if (!['mesh', 'hierarchical', 'ring', 'star'].includes(config.ruvSwarm.defaultTopology)) {
-      throw new ConfigError('ruvSwarm.defaultTopology must be one of: mesh, hierarchical, ring, star');
+      throw new ConfigError(
+        'ruvSwarm.defaultTopology must be one of: mesh, hierarchical, ring, star',
+      );
     }
     if (config.ruvSwarm.maxAgents < 1 || config.ruvSwarm.maxAgents > 100) {
       throw new ConfigError('ruvSwarm.maxAgents must be between 1 and 100');
     }
     if (!['balanced', 'specialized', 'adaptive'].includes(config.ruvSwarm.defaultStrategy)) {
-      throw new ConfigError('ruvSwarm.defaultStrategy must be one of: balanced, specialized, adaptive');
+      throw new ConfigError(
+        'ruvSwarm.defaultStrategy must be one of: balanced, specialized, adaptive',
+      );
     }
 
     // Claude API validation
     if (config.claude) {
       if (config.claude.model) {
-        const validModels = ['claude-3-opus-20240229', 'claude-3-sonnet-20240229', 'claude-3-haiku-20240307', 'claude-2.1', 'claude-2.0', 'claude-instant-1.2'];
+        const validModels = [
+          'claude-3-opus-20240229',
+          'claude-3-sonnet-20240229',
+          'claude-3-haiku-20240307',
+          'claude-2.1',
+          'claude-2.0',
+          'claude-instant-1.2',
+        ];
         if (!validModels.includes(config.claude.model)) {
           throw new ConfigError(`claude.model must be one of: ${validModels.join(', ')}`);
         }
@@ -409,7 +428,12 @@ export class ConfigManager {
 
     // Logging settings
     const logLevel = process.env.CLAUDE_FLOW_LOG_LEVEL;
-    if (logLevel === 'debug' || logLevel === 'info' || logLevel === 'warn' || logLevel === 'error') {
+    if (
+      logLevel === 'debug' ||
+      logLevel === 'info' ||
+      logLevel === 'warn' ||
+      logLevel === 'error'
+    ) {
       this.config.logging.level = logLevel;
     }
 
@@ -420,8 +444,12 @@ export class ConfigManager {
     }
 
     const ruvSwarmTopology = process.env.CLAUDE_FLOW_RUV_SWARM_TOPOLOGY;
-    if (ruvSwarmTopology === 'mesh' || ruvSwarmTopology === 'hierarchical' || 
-        ruvSwarmTopology === 'ring' || ruvSwarmTopology === 'star') {
+    if (
+      ruvSwarmTopology === 'mesh' ||
+      ruvSwarmTopology === 'hierarchical' ||
+      ruvSwarmTopology === 'ring' ||
+      ruvSwarmTopology === 'star'
+    ) {
       this.config.ruvSwarm.defaultTopology = ruvSwarmTopology;
     }
 
@@ -434,7 +462,7 @@ export class ConfigManager {
     if (!this.config.claude) {
       this.config.claude = {};
     }
-    
+
     const claudeApiKey = process.env.ANTHROPIC_API_KEY;
     if (claudeApiKey) {
       this.config.claude.apiKey = claudeApiKey;
@@ -506,7 +534,11 @@ export class ConfigManager {
   getFormatParsers(): Record<string, any> {
     return {
       json: { extension: '.json', parse: JSON.parse, stringify: JSON.stringify },
-      yaml: { extension: '.yaml', parse: (content: string) => content, stringify: (obj: any) => JSON.stringify(obj) }
+      yaml: {
+        extension: '.yaml',
+        parse: (content: string) => content,
+        stringify: (obj: any) => JSON.stringify(obj),
+      },
     };
   }
 
@@ -577,31 +609,31 @@ export class ConfigManager {
   getRuvSwarmArgs(): string[] {
     const args: string[] = [];
     const config = this.config.ruvSwarm;
-    
+
     if (!config.enabled) {
       return args;
     }
-    
+
     args.push('--topology', config.defaultTopology);
     args.push('--max-agents', String(config.maxAgents));
     args.push('--strategy', config.defaultStrategy);
-    
+
     if (config.enableHooks) {
       args.push('--enable-hooks');
     }
-    
+
     if (config.enablePersistence) {
       args.push('--enable-persistence');
     }
-    
+
     if (config.enableNeuralTraining) {
       args.push('--enable-training');
     }
-    
+
     if (config.configPath) {
       args.push('--config-path', config.configPath);
     }
-    
+
     return args;
   }
 
@@ -635,7 +667,7 @@ export class ConfigManager {
    */
   private deepMerge(target: Config, source: Partial<Config>): Config {
     const result = this.deepClone(target);
-    
+
     if (source.orchestrator) {
       result.orchestrator = { ...result.orchestrator, ...source.orchestrator };
     }
@@ -660,10 +692,10 @@ export class ConfigManager {
     if (source.claude) {
       result.claude = { ...result.claude, ...source.claude };
     }
-    
+
     return result;
   }
 }
 
 // Export singleton instance
-export const configManager = ConfigManager.getInstance();
+export const configManager = ConfigManager.getInstance();

package/src/config/ruv-swarm-config.ts

@@ -1,7 +1,6 @@
-import { getErrorMessage } from '../utils/error-handler.js';
 /**
  * ruv-swarm configuration management for Claude Code integration
- * 
+ *
  * This module handles configuration settings for ruv-swarm integration,
  * including topology preferences, agent limits, and coordination patterns.
  */
@@ -23,7 +22,7 @@ export interface RuvSwarmConfig {
     autoInit: boolean;
     enableHooks: boolean;
   };
-  
+
   // Agent configuration
   agents: {
     defaultCapabilities: string[];
@@ -31,7 +30,7 @@ export interface RuvSwarmConfig {
     heartbeatInterval: number;
     maxRetries: number;
   };
-  
+
   // Task orchestration
   tasks: {
     defaultStrategy: 'parallel' | 'sequential' | 'adaptive';
@@ -39,7 +38,7 @@ export interface RuvSwarmConfig {
     timeout: number;
     enableMonitoring: boolean;
   };
-  
+
   // Memory and persistence
   memory: {
     enablePersistence: boolean;
@@ -47,7 +46,7 @@ export interface RuvSwarmConfig {
     ttl: number;
     maxSize: number;
   };
-  
+
   // Neural capabilities
   neural: {
     enableTraining: boolean;
@@ -55,7 +54,7 @@ export interface RuvSwarmConfig {
     learningRate: number;
     trainingIterations: number;
   };
-  
+
   // Performance monitoring
   monitoring: {
     enableMetrics: boolean;
@@ -67,7 +66,7 @@ export interface RuvSwarmConfig {
       taskFailureRate: number;
     };
   };
-  
+
   // Integration settings
   integration: {
     enableMCPTools: boolean;
@@ -87,37 +86,37 @@ export const defaultRuvSwarmConfig: RuvSwarmConfig = {
     maxAgents: 8,
     defaultStrategy: 'adaptive',
     autoInit: true,
-    enableHooks: true
+    enableHooks: true,
   },
-  
+
   agents: {
     defaultCapabilities: ['filesystem', 'search', 'memory', 'coordination'],
     spawnTimeout: 30000,
     heartbeatInterval: 5000,
-    maxRetries: 3
+    maxRetries: 3,
   },
-  
+
   tasks: {
     defaultStrategy: 'adaptive',
     defaultPriority: 'medium',
     timeout: 300000, // 5 minutes
-    enableMonitoring: true
+    enableMonitoring: true,
   },
-  
+
   memory: {
     enablePersistence: true,
     compressionLevel: 6,
     ttl: 86400000, // 24 hours
-    maxSize: 100 * 1024 * 1024 // 100MB
+    maxSize: 100 * 1024 * 1024, // 100MB
   },
-  
+
   neural: {
     enableTraining: true,
     patterns: ['convergent', 'divergent', 'lateral', 'systems'],
     learningRate: 0.1,
-    trainingIterations: 10
+    trainingIterations: 10,
   },
-  
+
   monitoring: {
     enableMetrics: true,
     metricsInterval: 10000,
@@ -125,16 +124,16 @@ export const defaultRuvSwarmConfig: RuvSwarmConfig = {
     alertThresholds: {
       cpu: 80,
       memory: 85,
-      taskFailureRate: 20
-    }
+      taskFailureRate: 20,
+    },
   },
-  
+
   integration: {
     enableMCPTools: true,
     enableCLICommands: true,
     enableHooks: true,
-    sessionTimeout: 3600000 // 1 hour
-  }
+    sessionTimeout: 3600000, // 1 hour
+  },
 };
 
 /**
@@ -143,15 +142,15 @@ export const defaultRuvSwarmConfig: RuvSwarmConfig = {
 export class RuvSwarmConfigManager {
   private config: RuvSwarmConfig;
   private configPath: string;
-  
+
   constructor(
     private logger: ILogger,
-    configPath?: string
+    configPath?: string,
   ) {
     this.configPath = configPath || join(process.cwd(), '.claude', 'ruv-swarm-config.json');
     this.config = this.loadConfig();
   }
-  
+
   /**
    * Load configuration from file or use defaults
    */
@@ -160,220 +159,237 @@ export class RuvSwarmConfigManager {
       if (existsSync(this.configPath)) {
         const configData = readFileSync(this.configPath, 'utf-8');
         const userConfig = JSON.parse(configData) as Partial<RuvSwarmConfig>;
-        
+
         // Merge with defaults
         const mergedConfig = deepMerge(defaultRuvSwarmConfig, userConfig);
-        
-        this.logger.debug('Loaded ruv-swarm config from file', { 
+
+        this.logger.debug('Loaded ruv-swarm config from file', {
           path: this.configPath,
-          config: mergedConfig 
+          config: mergedConfig,
         });
-        
+
         return mergedConfig;
       }
     } catch (error) {
-      this.logger.warn('Failed to load ruv-swarm config, using defaults', { 
-        error: error instanceof Error ? (error instanceof Error ? error.message : String(error)) : error 
+      this.logger.warn('Failed to load ruv-swarm config, using defaults', {
+        error:
+          error instanceof Error ? (error instanceof Error ? error.message : String(error)) : error,
       });
     }
-    
+
     this.logger.debug('Using default ruv-swarm config');
     return { ...defaultRuvSwarmConfig };
   }
-  
+
   /**
    * Save configuration to file
    */
   saveConfig(): void {
     try {
       const configDir = join(this.configPath, '..');
-      
+
       // Ensure config directory exists
       if (!existsSync(configDir)) {
         const fs = require('fs');
         fs.mkdirSync(configDir, { recursive: true });
       }
-      
+
       writeFileSync(this.configPath, JSON.stringify(this.config, null, 2), 'utf-8');
-      
+
       this.logger.debug('Saved ruv-swarm config to file', { path: this.configPath });
     } catch (error) {
-      this.logger.error('Failed to save ruv-swarm config', { 
-        error: error instanceof Error ? (error instanceof Error ? error.message : String(error)) : error 
+      this.logger.error('Failed to save ruv-swarm config', {
+        error:
+          error instanceof Error ? (error instanceof Error ? error.message : String(error)) : error,
       });
     }
   }
-  
+
   /**
    * Get current configuration
    */
   getConfig(): RuvSwarmConfig {
     return { ...this.config };
   }
-  
+
   /**
    * Update configuration
    */
   updateConfig(updates: Partial<RuvSwarmConfig>): void {
     this.config = deepMerge(this.config, updates);
     this.saveConfig();
-    
+
     this.logger.info('Updated ruv-swarm config', { updates });
   }
-  
+
   /**
    * Reset configuration to defaults
    */
   resetConfig(): void {
     this.config = { ...defaultRuvSwarmConfig };
     this.saveConfig();
-    
+
     this.logger.info('Reset ruv-swarm config to defaults');
   }
-  
+
   /**
    * Get specific configuration section
    */
-  getSwarmConfig() { return this.config.swarm; }
-  getAgentsConfig() { return this.config.agents; }
-  getTasksConfig() { return this.config.tasks; }
-  getMemoryConfig() { return this.config.memory; }
-  getNeuralConfig() { return this.config.neural; }
-  getMonitoringConfig() { return this.config.monitoring; }
-  getIntegrationConfig() { return this.config.integration; }
-  
+  getSwarmConfig() {
+    return this.config.swarm;
+  }
+  getAgentsConfig() {
+    return this.config.agents;
+  }
+  getTasksConfig() {
+    return this.config.tasks;
+  }
+  getMemoryConfig() {
+    return this.config.memory;
+  }
+  getNeuralConfig() {
+    return this.config.neural;
+  }
+  getMonitoringConfig() {
+    return this.config.monitoring;
+  }
+  getIntegrationConfig() {
+    return this.config.integration;
+  }
+
   /**
    * Update specific configuration section
    */
   updateSwarmConfig(updates: Partial<RuvSwarmConfig['swarm']>): void {
     this.updateConfig({ swarm: { ...this.config.swarm, ...updates } });
   }
-  
+
   updateAgentsConfig(updates: Partial<RuvSwarmConfig['agents']>): void {
     this.updateConfig({ agents: { ...this.config.agents, ...updates } });
   }
-  
+
   updateTasksConfig(updates: Partial<RuvSwarmConfig['tasks']>): void {
     this.updateConfig({ tasks: { ...this.config.tasks, ...updates } });
   }
-  
+
   updateMemoryConfig(updates: Partial<RuvSwarmConfig['memory']>): void {
     this.updateConfig({ memory: { ...this.config.memory, ...updates } });
   }
-  
+
   updateNeuralConfig(updates: Partial<RuvSwarmConfig['neural']>): void {
     this.updateConfig({ neural: { ...this.config.neural, ...updates } });
   }
-  
+
   updateMonitoringConfig(updates: Partial<RuvSwarmConfig['monitoring']>): void {
     this.updateConfig({ monitoring: { ...this.config.monitoring, ...updates } });
   }
-  
+
   updateIntegrationConfig(updates: Partial<RuvSwarmConfig['integration']>): void {
     this.updateConfig({ integration: { ...this.config.integration, ...updates } });
   }
-  
+
   /**
    * Validate configuration
    */
   validateConfig(): { valid: boolean; errors: string[] } {
     const errors: string[] = [];
-    
+
     // Validate swarm settings
     if (this.config.swarm.maxAgents < 1 || this.config.swarm.maxAgents > 100) {
       errors.push('swarm.maxAgents must be between 1 and 100');
     }
-    
+
     // Validate agent settings
     if (this.config.agents.spawnTimeout < 1000) {
       errors.push('agents.spawnTimeout must be at least 1000ms');
     }
-    
+
     if (this.config.agents.heartbeatInterval < 1000) {
       errors.push('agents.heartbeatInterval must be at least 1000ms');
     }
-    
+
     // Validate task settings
     if (this.config.tasks.timeout < 10000) {
       errors.push('tasks.timeout must be at least 10000ms');
     }
-    
+
     // Validate memory settings
-    if (this.config.memory.maxSize < 1024 * 1024) { // 1MB minimum
+    if (this.config.memory.maxSize < 1024 * 1024) {
+      // 1MB minimum
       errors.push('memory.maxSize must be at least 1MB');
     }
-    
+
     if (this.config.memory.compressionLevel < 0 || this.config.memory.compressionLevel > 9) {
       errors.push('memory.compressionLevel must be between 0 and 9');
     }
-    
+
     // Validate neural settings
     if (this.config.neural.learningRate <= 0 || this.config.neural.learningRate > 1) {
       errors.push('neural.learningRate must be between 0 and 1');
     }
-    
+
     if (this.config.neural.trainingIterations < 1) {
       errors.push('neural.trainingIterations must be at least 1');
     }
-    
+
     // Validate monitoring settings
     const { alertThresholds } = this.config.monitoring;
     if (alertThresholds.cpu < 0 || alertThresholds.cpu > 100) {
       errors.push('monitoring.alertThresholds.cpu must be between 0 and 100');
     }
-    
+
     if (alertThresholds.memory < 0 || alertThresholds.memory > 100) {
       errors.push('monitoring.alertThresholds.memory must be between 0 and 100');
     }
-    
+
     if (alertThresholds.taskFailureRate < 0 || alertThresholds.taskFailureRate > 100) {
       errors.push('monitoring.alertThresholds.taskFailureRate must be between 0 and 100');
     }
-    
+
     return {
       valid: errors.length === 0,
-      errors
+      errors,
     };
   }
-  
+
   /**
    * Get configuration as command-line arguments for ruv-swarm
    */
   getCommandArgs(): string[] {
     const args: string[] = [];
-    
+
     // Add swarm configuration
     args.push('--topology', this.config.swarm.defaultTopology);
     args.push('--max-agents', String(this.config.swarm.maxAgents));
     args.push('--strategy', this.config.swarm.defaultStrategy);
-    
+
     if (this.config.swarm.enableHooks) {
       args.push('--enable-hooks');
     }
-    
+
     // Add task configuration
     args.push('--task-strategy', this.config.tasks.defaultStrategy);
     args.push('--task-priority', this.config.tasks.defaultPriority);
     args.push('--task-timeout', String(this.config.tasks.timeout));
-    
+
     if (this.config.tasks.enableMonitoring) {
       args.push('--enable-monitoring');
     }
-    
+
     // Add memory configuration
     if (this.config.memory.enablePersistence) {
       args.push('--enable-persistence');
       args.push('--compression-level', String(this.config.memory.compressionLevel));
       args.push('--memory-ttl', String(this.config.memory.ttl));
     }
-    
+
     // Add neural configuration
     if (this.config.neural.enableTraining) {
       args.push('--enable-training');
       args.push('--learning-rate', String(this.config.neural.learningRate));
       args.push('--training-iterations', String(this.config.neural.trainingIterations));
     }
-    
+
     return args;
   }
 }
@@ -383,7 +399,10 @@ export class RuvSwarmConfigManager {
  */
 let configManagerInstance: RuvSwarmConfigManager | null = null;
 
-export function getRuvSwarmConfigManager(logger: ILogger, configPath?: string): RuvSwarmConfigManager {
+export function getRuvSwarmConfigManager(
+  logger: ILogger,
+  configPath?: string,
+): RuvSwarmConfigManager {
   if (!configManagerInstance) {
     configManagerInstance = new RuvSwarmConfigManager(logger, configPath);
   }
@@ -393,5 +412,5 @@ export function getRuvSwarmConfigManager(logger: ILogger, configPath?: string):
 export default {
   RuvSwarmConfigManager,
   getRuvSwarmConfigManager,
-  defaultRuvSwarmConfig
-};
+  defaultRuvSwarmConfig,
+};