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

Enterprise-grade AI agent orchestration with ruv-swarm integration (Alpha Release)

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",
    project: {
      name: path.basename(process.cwd()),
      type: "claude-flow",
      created: new Date().toISOString()
    },
    features: {
      swarm: true,
      sparc: options.sparc || false,
      memory: true,
      terminal: true,
      mcp: true,
      batchTools: true,
      orchestration: true
    },
    batchTools: {
      enabled: true,
      maxConcurrentTasks: 10,
      memoryCoordination: true,
      taskOrchestration: true,
      parallelExecution: true
    },
    swarmConfig: {
      defaultStrategy: "auto",
      defaultMode: "centralized", 
      defaultMaxAgents: 5,
      defaultTimeout: 60,
      enableMonitoring: true,
      enableParallel: true,
      outputFormats: ["json", "sqlite", "csv", "html"],
      defaultOutputDir: "./reports"
    },
    coordination: {
      todoIntegration: true,
      memorySharing: true,
      crossAgentCommunication: true,
      taskDependencyTracking: 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();
  await createCoordinationConfig();
}

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",
    tools: {
      todoWrite: {
        enabled: true,
        features: ["task_breakdown", "dependency_tracking", "priority_management", "progress_monitoring"],
        maxTasks: 50,
        defaultPriority: "medium"
      },
      todoRead: {
        enabled: true,
        features: ["progress_tracking", "status_monitoring", "task_filtering"],
        autoRefresh: true,
        refreshInterval: 30
      },
      task: {
        enabled: true,
        features: ["parallel_execution", "agent_coordination", "load_balancing"],
        maxConcurrentTasks: 10,
        timeoutDefault: 300,
        retryAttempts: 3
      },
      memory: {
        enabled: true,
        features: ["cross_agent_sharing", "persistent_storage", "knowledge_coordination"],
        maxEntries: 1000,
        compressionEnabled: true,
        encryptionEnabled: false
      },
      fileOperations: {
        batchRead: {
          enabled: true,
          maxConcurrentReads: 10,
          timeoutPerFile: 30
        },
        batchWrite: {
          enabled: true,
          maxConcurrentWrites: 5,
          backupEnabled: true
        },
        batchEdit: {
          enabled: true,
          maxConcurrentEdits: 5,
          validationEnabled: true
        }
      },
      search: {
        batchGlob: {
          enabled: true,
          maxConcurrentSearches: 5,
          cacheResults: true
        },
        batchGrep: {
          enabled: true,
          maxConcurrentSearches: 5,
          regexOptimization: true
        }
      }
    },
    performance: {
      monitoring: {
        enabled: true,
        metricsCollection: true,
        performanceAlerts: true
      },
      optimization: {
        resourcePooling: true,
        intelligentBatching: 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",
    strategies: {
      research: {
        description: "Multi-agent research coordination",
        defaultMode: "distributed",
        defaultAgents: 6,
        phases: ["planning", "execution", "synthesis", "reporting"],
        tools: ["WebSearch", "WebFetch", "Memory", "TodoWrite", "Task"],
        coordination: "memory_based"
      },
      development: {
        description: "Coordinated software development",
        defaultMode: "hierarchical", 
        defaultAgents: 8,
        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",
        defaultAgents: 10,
        phases: ["collection", "processing", "analysis", "visualization"],
        tools: ["Read", "Bash", "Memory", "TodoWrite", "Task"],
        coordination: "peer_to_peer"
      },
      testing: {
        description: "Comprehensive testing coordination",
        defaultMode: "distributed",
        defaultAgents: 12,
        phases: ["planning", "execution", "validation", "reporting"],
        tools: ["Read", "Write", "Bash", "TodoWrite", "Task"],
        coordination: "distributed_validation"
      },
      optimization: {
        description: "Performance optimization coordination",
        defaultMode: "hybrid",
        defaultAgents: 6,
        phases: ["profiling", "analysis", "optimization", "validation"],
        tools: ["Read", "Edit", "Bash", "Memory", "TodoWrite"],
        coordination: "adaptive_hybrid"
      },
      maintenance: {
        description: "System maintenance coordination",
        defaultMode: "centralized",
        defaultAgents: 4,
        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"
      },
      distributed: {
        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"
      },
      mesh: {
        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"
      }
    }
  };
  
  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",
    coordination: {
      taskManagement: {
        todoIntegration: {
          enabled: true,
          autoBreakdown: true,
          dependencyTracking: true,
          progressMonitoring: true,
          priorityManagement: true
        },
        taskDistribution: {
          algorithm: "intelligent_balancing",
          loadBalancing: true,
          skillMatching: true,
          resourceOptimization: true
        }
      },
      communication: {
        memorySharing: {
          enabled: true,
          crossAgentAccess: true,
          knowledgeSync: true,
          conflictResolution: "timestamp_priority"
        },
        coordination: {
          realTimeUpdates: true,
          statusBroadcasting: true,
          emergencySignaling: true
        }
      },
      monitoring: {
        progressTracking: {
          enabled: true,
          realTimeUpdates: true,
          milestoneTracking: true,
          performanceMetrics: true
        },
        healthMonitoring: {
          agentHealth: true,
          taskHealth: true,
          systemHealth: true,
          alerting: true
        }
      }
    },
    optimization: {
      resourceManagement: {
        pooling: true,
        allocation: "dynamic",
        recycling: true,
        monitoring: true
      },
      performance: {
        batchOptimization: true,
        parallelExecution: true,
        caching: true,
        compression: true
      }
    }
  };
  
  await fs.writeFile('.claude/configs/coordination.json', JSON.stringify(coordinationConfig, null, 2));
  console.log('  ✅ Created coordination configuration');
}