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

package/src/cli/init/claude-config.ts

@@ -1,18 +1,17 @@
-import { getErrorMessage } from '../../utils/error-handler.js';
 // init/claude-config.ts - Claude configuration creation
 import type { InitOptions } from './index.js';
 
 export async function createClaudeConfig(options: InitOptions): Promise<void> {
   const fs = await import('fs/promises');
   const path = await import('path');
-  
+
   // Create base configuration
   const claudeConfig = {
-    version: "1.0.71",
+    version: '1.0.71',
     project: {
       name: path.basename(process.cwd()),
-      type: "claude-flow",
-      created: new Date().toISOString()
+      type: 'claude-flow',
+      created: new Date().toISOString(),
     },
     features: {
       swarm: true,
@@ -21,37 +20,37 @@ export async function createClaudeConfig(options: InitOptions): Promise<void> {
       terminal: true,
       mcp: true,
       batchTools: true,
-      orchestration: true
+      orchestration: true,
     },
     batchTools: {
       enabled: true,
       maxConcurrentTasks: 10,
       memoryCoordination: true,
       taskOrchestration: true,
-      parallelExecution: true
+      parallelExecution: true,
     },
     swarmConfig: {
-      defaultStrategy: "auto",
-      defaultMode: "centralized", 
+      defaultStrategy: 'auto',
+      defaultMode: 'centralized',
       defaultMaxAgents: 5,
       defaultTimeout: 60,
       enableMonitoring: true,
       enableParallel: true,
-      outputFormats: ["json", "sqlite", "csv", "html"],
-      defaultOutputDir: "./reports"
+      outputFormats: ['json', 'sqlite', 'csv', 'html'],
+      defaultOutputDir: './reports',
     },
     coordination: {
       todoIntegration: true,
       memorySharing: true,
       crossAgentCommunication: true,
       taskDependencyTracking: true,
-      progressMonitoring: true
-    }
+      progressMonitoring: true,
+    },
   };
-  
+
   await fs.writeFile('.claude/config.json', JSON.stringify(claudeConfig, null, 2));
   console.log('  ✅ Created .claude/config.json with batch tools configuration');
-  
+
   // Create additional configuration files
   await createBatchToolsConfig();
   await createSwarmConfig();
@@ -60,185 +59,190 @@ export async function createClaudeConfig(options: InitOptions): Promise<void> {
 
 async function createBatchToolsConfig(): Promise<void> {
   const fs = await import('fs/promises');
-  
+
   const batchConfig = {
-    version: "1.0.71",
-    description: "Batch tools configuration for Claude Code orchestration",
+    version: '1.0.71',
+    description: 'Batch tools configuration for Claude Code orchestration',
     tools: {
       todoWrite: {
         enabled: true,
-        features: ["task_breakdown", "dependency_tracking", "priority_management", "progress_monitoring"],
+        features: [
+          'task_breakdown',
+          'dependency_tracking',
+          'priority_management',
+          'progress_monitoring',
+        ],
         maxTasks: 50,
-        defaultPriority: "medium"
+        defaultPriority: 'medium',
       },
       todoRead: {
         enabled: true,
-        features: ["progress_tracking", "status_monitoring", "task_filtering"],
+        features: ['progress_tracking', 'status_monitoring', 'task_filtering'],
         autoRefresh: true,
-        refreshInterval: 30
+        refreshInterval: 30,
       },
       task: {
         enabled: true,
-        features: ["parallel_execution", "agent_coordination", "load_balancing"],
+        features: ['parallel_execution', 'agent_coordination', 'load_balancing'],
         maxConcurrentTasks: 10,
         timeoutDefault: 300,
-        retryAttempts: 3
+        retryAttempts: 3,
       },
       memory: {
         enabled: true,
-        features: ["cross_agent_sharing", "persistent_storage", "knowledge_coordination"],
+        features: ['cross_agent_sharing', 'persistent_storage', 'knowledge_coordination'],
         maxEntries: 1000,
         compressionEnabled: true,
-        encryptionEnabled: false
+        encryptionEnabled: false,
       },
       fileOperations: {
         batchRead: {
           enabled: true,
           maxConcurrentReads: 10,
-          timeoutPerFile: 30
+          timeoutPerFile: 30,
         },
         batchWrite: {
           enabled: true,
           maxConcurrentWrites: 5,
-          backupEnabled: true
+          backupEnabled: true,
         },
         batchEdit: {
           enabled: true,
           maxConcurrentEdits: 5,
-          validationEnabled: true
-        }
+          validationEnabled: true,
+        },
       },
       search: {
         batchGlob: {
           enabled: true,
           maxConcurrentSearches: 5,
-          cacheResults: true
+          cacheResults: true,
         },
         batchGrep: {
           enabled: true,
           maxConcurrentSearches: 5,
-          regexOptimization: true
-        }
-      }
+          regexOptimization: true,
+        },
+      },
     },
     performance: {
       monitoring: {
         enabled: true,
         metricsCollection: true,
-        performanceAlerts: true
+        performanceAlerts: true,
       },
       optimization: {
         resourcePooling: true,
         intelligentBatching: true,
-        loadBalancing: true
-      }
-    }
+        loadBalancing: true,
+      },
+    },
   };
-  
+
   await fs.writeFile('.claude/configs/batch-tools.json', JSON.stringify(batchConfig, null, 2));
   console.log('  ✅ Created batch tools configuration');
 }
 
 async function createSwarmConfig(): Promise<void> {
   const fs = await import('fs/promises');
-  
+
   const swarmConfig = {
-    version: "1.0.71",
-    description: "Swarm orchestration configuration for Claude-Flow",
+    version: '1.0.71',
+    description: 'Swarm orchestration configuration for Claude-Flow',
     strategies: {
       research: {
-        description: "Multi-agent research coordination",
-        defaultMode: "distributed",
+        description: 'Multi-agent research coordination',
+        defaultMode: 'distributed',
         defaultAgents: 6,
-        phases: ["planning", "execution", "synthesis", "reporting"],
-        tools: ["WebSearch", "WebFetch", "Memory", "TodoWrite", "Task"],
-        coordination: "memory_based"
+        phases: ['planning', 'execution', 'synthesis', 'reporting'],
+        tools: ['WebSearch', 'WebFetch', 'Memory', 'TodoWrite', 'Task'],
+        coordination: 'memory_based',
       },
       development: {
-        description: "Coordinated software development",
-        defaultMode: "hierarchical", 
+        description: 'Coordinated software development',
+        defaultMode: 'hierarchical',
         defaultAgents: 8,
-        phases: ["architecture", "implementation", "testing", "integration"],
-        tools: ["Read", "Write", "Edit", "Bash", "Memory", "TodoWrite", "Task"],
-        coordination: "hierarchical_teams"
+        phases: ['architecture', 'implementation', 'testing', 'integration'],
+        tools: ['Read', 'Write', 'Edit', 'Bash', 'Memory', 'TodoWrite', 'Task'],
+        coordination: 'hierarchical_teams',
       },
       analysis: {
-        description: "Data analysis and insights generation",
-        defaultMode: "mesh",
+        description: 'Data analysis and insights generation',
+        defaultMode: 'mesh',
         defaultAgents: 10,
-        phases: ["collection", "processing", "analysis", "visualization"],
-        tools: ["Read", "Bash", "Memory", "TodoWrite", "Task"],
-        coordination: "peer_to_peer"
+        phases: ['collection', 'processing', 'analysis', 'visualization'],
+        tools: ['Read', 'Bash', 'Memory', 'TodoWrite', 'Task'],
+        coordination: 'peer_to_peer',
       },
       testing: {
-        description: "Comprehensive testing coordination",
-        defaultMode: "distributed",
+        description: 'Comprehensive testing coordination',
+        defaultMode: 'distributed',
         defaultAgents: 12,
-        phases: ["planning", "execution", "validation", "reporting"],
-        tools: ["Read", "Write", "Bash", "TodoWrite", "Task"],
-        coordination: "distributed_validation"
+        phases: ['planning', 'execution', 'validation', 'reporting'],
+        tools: ['Read', 'Write', 'Bash', 'TodoWrite', 'Task'],
+        coordination: 'distributed_validation',
       },
       optimization: {
-        description: "Performance optimization coordination",
-        defaultMode: "hybrid",
+        description: 'Performance optimization coordination',
+        defaultMode: 'hybrid',
         defaultAgents: 6,
-        phases: ["profiling", "analysis", "optimization", "validation"],
-        tools: ["Read", "Edit", "Bash", "Memory", "TodoWrite"],
-        coordination: "adaptive_hybrid"
+        phases: ['profiling', 'analysis', 'optimization', 'validation'],
+        tools: ['Read', 'Edit', 'Bash', 'Memory', 'TodoWrite'],
+        coordination: 'adaptive_hybrid',
       },
       maintenance: {
-        description: "System maintenance coordination",
-        defaultMode: "centralized",
+        description: 'System maintenance coordination',
+        defaultMode: 'centralized',
         defaultAgents: 4,
-        phases: ["assessment", "planning", "execution", "verification"],
-        tools: ["Read", "Write", "Bash", "TodoWrite", "Memory"],
-        coordination: "centralized_safety"
-      }
+        phases: ['assessment', 'planning', 'execution', 'verification'],
+        tools: ['Read', 'Write', 'Bash', 'TodoWrite', 'Memory'],
+        coordination: 'centralized_safety',
+      },
     },
     coordinationModes: {
       centralized: {
-        description: "Single coordinator manages all agents",
-        useCases: ["maintenance", "safety_critical", "simple_tasks"],
-        coordination: "master_slave",
-        communication: "hub_spoke"
+        description: 'Single coordinator manages all agents',
+        useCases: ['maintenance', 'safety_critical', 'simple_tasks'],
+        coordination: 'master_slave',
+        communication: 'hub_spoke',
       },
       distributed: {
-        description: "Multiple coordinators manage agent groups", 
-        useCases: ["research", "testing", "large_scale"],
-        coordination: "multi_master",
-        communication: "federated"
+        description: 'Multiple coordinators manage agent groups',
+        useCases: ['research', 'testing', 'large_scale'],
+        coordination: 'multi_master',
+        communication: 'federated',
       },
       hierarchical: {
-        description: "Tree-like organization with team leads",
-        useCases: ["development", "structured_workflows", "large_teams"],
-        coordination: "tree_structure",
-        communication: "hierarchical_reporting"
+        description: 'Tree-like organization with team leads',
+        useCases: ['development', 'structured_workflows', 'large_teams'],
+        coordination: 'tree_structure',
+        communication: 'hierarchical_reporting',
       },
       mesh: {
-        description: "Peer-to-peer agent communication",
-        useCases: ["analysis", "dynamic_tasks", "adaptive_workflows"],
-        coordination: "peer_to_peer",
-        communication: "mesh_network"
+        description: 'Peer-to-peer agent communication',
+        useCases: ['analysis', 'dynamic_tasks', 'adaptive_workflows'],
+        coordination: 'peer_to_peer',
+        communication: 'mesh_network',
       },
       hybrid: {
-        description: "Adaptive coordination based on task phase",
-        useCases: ["optimization", "complex_workflows", "multi_phase"],
-        coordination: "adaptive_mixed",
-        communication: "dynamic_topology"
-      }
-    }
+        description: 'Adaptive coordination based on task phase',
+        useCases: ['optimization', 'complex_workflows', 'multi_phase'],
+        coordination: 'adaptive_mixed',
+        communication: 'dynamic_topology',
+      },
+    },
   };
-  
+
   await fs.writeFile('.claude/configs/swarm.json', JSON.stringify(swarmConfig, null, 2));
   console.log('  ✅ Created swarm orchestration configuration');
 }
 
 async function createCoordinationConfig(): Promise<void> {
   const fs = await import('fs/promises');
-  
+
   const coordinationConfig = {
-    version: "1.0.71",
-    description: "Agent coordination and orchestration configuration",
+    version: '1.0.71',
+    description: 'Agent coordination and orchestration configuration',
     coordination: {
       taskManagement: {
         todoIntegration: {
@@ -246,59 +250,62 @@ async function createCoordinationConfig(): Promise<void> {
           autoBreakdown: true,
           dependencyTracking: true,
           progressMonitoring: true,
-          priorityManagement: true
+          priorityManagement: true,
         },
         taskDistribution: {
-          algorithm: "intelligent_balancing",
+          algorithm: 'intelligent_balancing',
           loadBalancing: true,
           skillMatching: true,
-          resourceOptimization: true
-        }
+          resourceOptimization: true,
+        },
       },
       communication: {
         memorySharing: {
           enabled: true,
           crossAgentAccess: true,
           knowledgeSync: true,
-          conflictResolution: "timestamp_priority"
+          conflictResolution: 'timestamp_priority',
         },
         coordination: {
           realTimeUpdates: true,
           statusBroadcasting: true,
-          emergencySignaling: true
-        }
+          emergencySignaling: true,
+        },
       },
       monitoring: {
         progressTracking: {
           enabled: true,
           realTimeUpdates: true,
           milestoneTracking: true,
-          performanceMetrics: true
+          performanceMetrics: true,
         },
         healthMonitoring: {
           agentHealth: true,
           taskHealth: true,
           systemHealth: true,
-          alerting: true
-        }
-      }
+          alerting: true,
+        },
+      },
     },
     optimization: {
       resourceManagement: {
         pooling: true,
-        allocation: "dynamic",
+        allocation: 'dynamic',
         recycling: true,
-        monitoring: true
+        monitoring: true,
       },
       performance: {
         batchOptimization: true,
         parallelExecution: true,
         caching: true,
-        compression: true
-      }
-    }
+        compression: true,
+      },
+    },
   };
-  
-  await fs.writeFile('.claude/configs/coordination.json', JSON.stringify(coordinationConfig, null, 2));
+
+  await fs.writeFile(
+    '.claude/configs/coordination.json',
+    JSON.stringify(coordinationConfig, null, 2),
+  );
   console.log('  ✅ Created coordination configuration');
-}
+}

package/src/cli/init/directory-structure.ts

@@ -1,9 +1,8 @@
-import { getErrorMessage } from '../../utils/error-handler.js';
 // init/directory-structure.ts - Directory structure creation
 export async function createDirectoryStructure(): Promise<void> {
   const fs = await import('fs/promises');
   const path = await import('path');
-  
+
   // Define directory structure
   const directories = [
     '.claude',
@@ -20,9 +19,9 @@ export async function createDirectoryStructure(): Promise<void> {
     'coordination/memory_bank',
     'coordination/subtasks',
     'coordination/orchestration',
-    'reports'
+    'reports',
   ];
-  
+
   // Create directories
   for (const dir of directories) {
     try {
@@ -34,29 +33,29 @@ export async function createDirectoryStructure(): Promise<void> {
       }
     }
   }
-  
+
   // Create README files for key directories
   const readmeFiles = {
     'memory/agents/README.md': createAgentsReadme(),
     'memory/sessions/README.md': createSessionsReadme(),
     'coordination/README.md': createCoordinationReadme(),
-    'reports/README.md': createReportsReadme()
+    'reports/README.md': createReportsReadme(),
   };
-  
+
   for (const [filePath, content] of Object.entries(readmeFiles)) {
     await fs.writeFile(filePath, content);
     console.log(`  ✅ Created ${filePath}`);
   }
-  
+
   // Create initial persistence database
   const initialData = {
     agents: [],
     tasks: [],
     swarms: [],
     lastUpdated: Date.now(),
-    version: "1.0.71"
+    version: '1.0.71',
   };
-  
+
   await fs.writeFile('memory/claude-flow-data.json', JSON.stringify(initialData, null, 2));
   console.log('  ✅ Created memory/claude-flow-data.json (persistence database)');
 }
@@ -150,4 +149,4 @@ Reports are generated automatically by swarm operations:
 - \`*.csv\`: Tabular data for analysis
 - \`*.html\`: Human-readable reports
 `;
-}
+}

package/src/cli/init/index.ts

@@ -1,4 +1,3 @@
-import { getErrorMessage } from '../../utils/error-handler.js';
 // init/index.ts - Main init command orchestrator
 import { printSuccess, printError } from '../utils.js';
 import { createDirectoryStructure } from './directory-structure.js';
@@ -16,52 +15,53 @@ export async function initCommand(options: InitOptions = {}) {
   try {
     const fs = await import('fs/promises');
     const path = await import('path');
-    
+
     printSuccess('Initializing Claude-Flow project...');
-    
+
     // Phase 1: Create directory structure
     console.log('\n📁 Phase 1: Creating directory structure...');
     await createDirectoryStructure();
-    
+
     // Phase 2: Create base configuration
     console.log('\n⚙️  Phase 2: Creating configuration...');
     await createClaudeConfig(options);
-    
+
     // Phase 3: Create swarm commands and documentation
     console.log('\n🤖 Phase 3: Creating swarm commands...');
     await createSwarmCommands();
-    
+
     // Phase 4: Create batch tools guides
     console.log('\n🔧 Phase 4: Creating batch tools guides...');
     await createBatchToolsGuide();
-    
+
     // Phase 5: SPARC environment (if requested)
     if (options.sparc) {
       console.log('\n🚀 Phase 5: Creating SPARC environment...');
       await createSparcEnvironment();
     }
-    
+
     // Success summary
     console.log('\n🎉 Project initialized successfully!');
     console.log('   📁 Created .claude/ directory structure');
     console.log('   📋 Created comprehensive swarm command documentation');
     console.log('   🔧 Created batch tools coordination guides');
     console.log('   📖 Created detailed usage examples with orchestration');
-    
+
     console.log('\n   Next steps:');
     console.log('   1. Run "claude-flow swarm --help" to see swarm options');
     console.log('   2. Check .claude/commands/swarm/ for detailed documentation');
     console.log('   3. Review batch tools guide for orchestration patterns');
     console.log('   4. Run "claude-flow help" for all available commands');
-    
+
     if (options.sparc) {
       console.log('   5. Run "claude-flow sparc modes" to see available SPARC modes');
       console.log('   6. Use TodoWrite/TodoRead for task coordination');
       console.log('   7. Use Task tool for parallel agent execution');
     }
-    
   } catch (error) {
-    printError(`Failed to initialize project: ${(error instanceof Error ? error.message : String(error))}`);
+    printError(
+      `Failed to initialize project: ${error instanceof Error ? error.message : String(error)}`,
+    );
     throw error;
   }
-}
+}