claude-flow 3.0.0-alpha.10 → 3.0.0-alpha.11

package/src/init/executor.ts

@@ -1,762 +0,0 @@
-/**
- * Init Executor
- * Main execution logic for V3 initialization
- */
-
-import * as fs from 'fs';
-import * as path from 'path';
-import { fileURLToPath } from 'url';
-import { dirname } from 'path';
-
-// ESM-compatible __dirname
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-import type { InitOptions, InitResult, PlatformInfo } from './types.js';
-import { detectPlatform } from './types.js';
-import { generateSettingsJson } from './settings-generator.js';
-import { generateMCPJson } from './mcp-generator.js';
-import { generateStatuslineScript, generateStatuslineHook } from './statusline-generator.js';
-import {
-  generatePreCommitHook,
-  generatePostCommitHook,
-  generateSessionManager,
-  generateAgentRouter,
-  generateMemoryHelper,
-} from './helpers-generator.js';
-import { generateClaudeMd, generateMinimalClaudeMd } from './claudemd-generator.js';
-
-/**
- * Skills to copy based on configuration
- */
-const SKILLS_MAP: Record<string, string[]> = {
-  core: [
-    'swarm-orchestration',
-    'swarm-advanced',
-    'sparc-methodology',
-    'hooks-automation',
-    'pair-programming',
-    'verification-quality',
-    'stream-chain',
-    'skill-builder',
-  ],
-  agentdb: [
-    'agentdb-advanced',
-    'agentdb-learning',
-    'agentdb-memory-patterns',
-    'agentdb-optimization',
-    'agentdb-vector-search',
-    'reasoningbank-agentdb',
-    'reasoningbank-intelligence',
-  ],
-  github: [
-    'github-code-review',
-    'github-multi-repo',
-    'github-project-management',
-    'github-release-management',
-    'github-workflow-automation',
-  ],
-  flowNexus: [
-    'flow-nexus-neural',
-    'flow-nexus-platform',
-    'flow-nexus-swarm',
-  ],
-  v3: [
-    'v3-cli-modernization',
-    'v3-core-implementation',
-    'v3-ddd-architecture',
-    'v3-integration-deep',
-    'v3-mcp-optimization',
-    'v3-memory-unification',
-    'v3-performance-optimization',
-    'v3-security-overhaul',
-    'v3-swarm-coordination',
-  ],
-};
-
-/**
- * Commands to copy based on configuration
- */
-const COMMANDS_MAP: Record<string, string[]> = {
-  core: ['claude-flow-help.md', 'claude-flow-swarm.md', 'claude-flow-memory.md'],
-  analysis: ['analysis'],
-  automation: ['automation'],
-  github: ['github'],
-  hooks: ['hooks'],
-  monitoring: ['monitoring'],
-  optimization: ['optimization'],
-  sparc: ['sparc'],
-};
-
-/**
- * Agents to copy based on configuration
- */
-const AGENTS_MAP: Record<string, string[]> = {
-  core: ['core'],
-  consensus: ['consensus'],
-  github: ['github'],
-  hiveMind: ['hive-mind'],
-  sparc: ['sparc'],
-  swarm: ['swarm'],
-};
-
-/**
- * Directory structure to create
- */
-const DIRECTORIES = {
-  claude: [
-    '.claude',
-    '.claude/skills',
-    '.claude/commands',
-    '.claude/agents',
-    '.claude/helpers',
-  ],
-  runtime: [
-    '.claude-flow',
-    '.claude-flow/data',
-    '.claude-flow/logs',
-    '.claude-flow/sessions',
-    '.claude-flow/hooks',
-    '.claude-flow/agents',
-    '.claude-flow/workflows',
-  ],
-};
-
-/**
- * Execute initialization
- */
-export async function executeInit(options: InitOptions): Promise<InitResult> {
-  // Detect platform
-  const platform = detectPlatform();
-
-  const result: InitResult = {
-    success: true,
-    platform,
-    created: {
-      directories: [],
-      files: [],
-    },
-    skipped: [],
-    errors: [],
-    summary: {
-      skillsCount: 0,
-      commandsCount: 0,
-      agentsCount: 0,
-      hooksEnabled: 0,
-    },
-  };
-
-  const targetDir = options.targetDir;
-
-  try {
-    // Create directory structure
-    await createDirectories(targetDir, options, result);
-
-    // Generate and write settings.json
-    if (options.components.settings) {
-      await writeSettings(targetDir, options, result);
-    }
-
-    // Generate and write .mcp.json
-    if (options.components.mcp) {
-      await writeMCPConfig(targetDir, options, result);
-    }
-
-    // Copy skills
-    if (options.components.skills) {
-      await copySkills(targetDir, options, result);
-    }
-
-    // Copy commands
-    if (options.components.commands) {
-      await copyCommands(targetDir, options, result);
-    }
-
-    // Copy agents
-    if (options.components.agents) {
-      await copyAgents(targetDir, options, result);
-    }
-
-    // Generate helpers
-    if (options.components.helpers) {
-      await writeHelpers(targetDir, options, result);
-    }
-
-    // Generate statusline
-    if (options.components.statusline) {
-      await writeStatusline(targetDir, options, result);
-    }
-
-    // Generate runtime config
-    if (options.components.runtime) {
-      await writeRuntimeConfig(targetDir, options, result);
-    }
-
-    // Generate CLAUDE.md
-    if (options.components.claudeMd) {
-      await writeClaudeMd(targetDir, options, result);
-    }
-
-    // Count enabled hooks
-    result.summary.hooksEnabled = countEnabledHooks(options);
-
-  } catch (error) {
-    result.success = false;
-    result.errors.push(error instanceof Error ? error.message : String(error));
-  }
-
-  return result;
-}
-
-/**
- * Create directory structure
- */
-async function createDirectories(
-  targetDir: string,
-  options: InitOptions,
-  result: InitResult
-): Promise<void> {
-  const dirs = [
-    ...DIRECTORIES.claude,
-    ...(options.components.runtime ? DIRECTORIES.runtime : []),
-  ];
-
-  for (const dir of dirs) {
-    const fullPath = path.join(targetDir, dir);
-    if (!fs.existsSync(fullPath)) {
-      fs.mkdirSync(fullPath, { recursive: true });
-      result.created.directories.push(dir);
-    }
-  }
-}
-
-/**
- * Write settings.json
- */
-async function writeSettings(
-  targetDir: string,
-  options: InitOptions,
-  result: InitResult
-): Promise<void> {
-  const settingsPath = path.join(targetDir, '.claude', 'settings.json');
-
-  if (fs.existsSync(settingsPath) && !options.force) {
-    result.skipped.push('.claude/settings.json');
-    return;
-  }
-
-  const content = generateSettingsJson(options);
-  fs.writeFileSync(settingsPath, content, 'utf-8');
-  result.created.files.push('.claude/settings.json');
-}
-
-/**
- * Write .mcp.json
- */
-async function writeMCPConfig(
-  targetDir: string,
-  options: InitOptions,
-  result: InitResult
-): Promise<void> {
-  const mcpPath = path.join(targetDir, '.mcp.json');
-
-  if (fs.existsSync(mcpPath) && !options.force) {
-    result.skipped.push('.mcp.json');
-    return;
-  }
-
-  const content = generateMCPJson(options);
-  fs.writeFileSync(mcpPath, content, 'utf-8');
-  result.created.files.push('.mcp.json');
-}
-
-/**
- * Copy skills from source
- */
-async function copySkills(
-  targetDir: string,
-  options: InitOptions,
-  result: InitResult
-): Promise<void> {
-  const skillsConfig = options.skills;
-  const targetSkillsDir = path.join(targetDir, '.claude', 'skills');
-
-  // Determine which skills to copy
-  const skillsToCopy: string[] = [];
-
-  if (skillsConfig.all) {
-    // Copy all available skills
-    Object.values(SKILLS_MAP).forEach(skills => skillsToCopy.push(...skills));
-  } else {
-    if (skillsConfig.core) skillsToCopy.push(...SKILLS_MAP.core);
-    if (skillsConfig.agentdb) skillsToCopy.push(...SKILLS_MAP.agentdb);
-    if (skillsConfig.github) skillsToCopy.push(...SKILLS_MAP.github);
-    if (skillsConfig.flowNexus) skillsToCopy.push(...SKILLS_MAP.flowNexus);
-    if (skillsConfig.v3) skillsToCopy.push(...SKILLS_MAP.v3);
-  }
-
-  // Find source skills directory
-  const sourceSkillsDir = findSourceDir('skills', options.sourceBaseDir);
-  if (!sourceSkillsDir) {
-    result.errors.push('Could not find source skills directory');
-    return;
-  }
-
-  // Copy each skill
-  for (const skillName of [...new Set(skillsToCopy)]) {
-    const sourcePath = path.join(sourceSkillsDir, skillName);
-    const targetPath = path.join(targetSkillsDir, skillName);
-
-    if (fs.existsSync(sourcePath)) {
-      if (!fs.existsSync(targetPath) || options.force) {
-        copyDirRecursive(sourcePath, targetPath);
-        result.created.files.push(`.claude/skills/${skillName}`);
-        result.summary.skillsCount++;
-      } else {
-        result.skipped.push(`.claude/skills/${skillName}`);
-      }
-    }
-  }
-}
-
-/**
- * Copy commands from source
- */
-async function copyCommands(
-  targetDir: string,
-  options: InitOptions,
-  result: InitResult
-): Promise<void> {
-  const commandsConfig = options.commands;
-  const targetCommandsDir = path.join(targetDir, '.claude', 'commands');
-
-  // Determine which commands to copy
-  const commandsToCopy: string[] = [];
-
-  if (commandsConfig.all) {
-    Object.values(COMMANDS_MAP).forEach(cmds => commandsToCopy.push(...cmds));
-  } else {
-    if (commandsConfig.core) commandsToCopy.push(...COMMANDS_MAP.core);
-    if (commandsConfig.analysis) commandsToCopy.push(...COMMANDS_MAP.analysis);
-    if (commandsConfig.automation) commandsToCopy.push(...COMMANDS_MAP.automation);
-    if (commandsConfig.github) commandsToCopy.push(...COMMANDS_MAP.github);
-    if (commandsConfig.hooks) commandsToCopy.push(...COMMANDS_MAP.hooks);
-    if (commandsConfig.monitoring) commandsToCopy.push(...COMMANDS_MAP.monitoring);
-    if (commandsConfig.optimization) commandsToCopy.push(...COMMANDS_MAP.optimization);
-    if (commandsConfig.sparc) commandsToCopy.push(...COMMANDS_MAP.sparc);
-  }
-
-  // Find source commands directory
-  const sourceCommandsDir = findSourceDir('commands', options.sourceBaseDir);
-  if (!sourceCommandsDir) {
-    result.errors.push('Could not find source commands directory');
-    return;
-  }
-
-  // Copy each command/directory
-  for (const cmdName of [...new Set(commandsToCopy)]) {
-    const sourcePath = path.join(sourceCommandsDir, cmdName);
-    const targetPath = path.join(targetCommandsDir, cmdName);
-
-    if (fs.existsSync(sourcePath)) {
-      if (!fs.existsSync(targetPath) || options.force) {
-        if (fs.statSync(sourcePath).isDirectory()) {
-          copyDirRecursive(sourcePath, targetPath);
-        } else {
-          fs.copyFileSync(sourcePath, targetPath);
-        }
-        result.created.files.push(`.claude/commands/${cmdName}`);
-        result.summary.commandsCount++;
-      } else {
-        result.skipped.push(`.claude/commands/${cmdName}`);
-      }
-    }
-  }
-}
-
-/**
- * Copy agents from source
- */
-async function copyAgents(
-  targetDir: string,
-  options: InitOptions,
-  result: InitResult
-): Promise<void> {
-  const agentsConfig = options.agents;
-  const targetAgentsDir = path.join(targetDir, '.claude', 'agents');
-
-  // Determine which agents to copy
-  const agentsToCopy: string[] = [];
-
-  if (agentsConfig.all) {
-    Object.values(AGENTS_MAP).forEach(agents => agentsToCopy.push(...agents));
-  } else {
-    if (agentsConfig.core) agentsToCopy.push(...AGENTS_MAP.core);
-    if (agentsConfig.consensus) agentsToCopy.push(...AGENTS_MAP.consensus);
-    if (agentsConfig.github) agentsToCopy.push(...AGENTS_MAP.github);
-    if (agentsConfig.hiveMind) agentsToCopy.push(...AGENTS_MAP.hiveMind);
-    if (agentsConfig.sparc) agentsToCopy.push(...AGENTS_MAP.sparc);
-    if (agentsConfig.swarm) agentsToCopy.push(...AGENTS_MAP.swarm);
-  }
-
-  // Find source agents directory
-  const sourceAgentsDir = findSourceDir('agents', options.sourceBaseDir);
-  if (!sourceAgentsDir) {
-    result.errors.push('Could not find source agents directory');
-    return;
-  }
-
-  // Copy each agent category
-  for (const agentCategory of [...new Set(agentsToCopy)]) {
-    const sourcePath = path.join(sourceAgentsDir, agentCategory);
-    const targetPath = path.join(targetAgentsDir, agentCategory);
-
-    if (fs.existsSync(sourcePath)) {
-      if (!fs.existsSync(targetPath) || options.force) {
-        copyDirRecursive(sourcePath, targetPath);
-        // Count agent files
-        const agentFiles = countFiles(sourcePath, '.md');
-        result.summary.agentsCount += agentFiles;
-        result.created.files.push(`.claude/agents/${agentCategory}`);
-      } else {
-        result.skipped.push(`.claude/agents/${agentCategory}`);
-      }
-    }
-  }
-}
-
-/**
- * Write helper scripts
- */
-async function writeHelpers(
-  targetDir: string,
-  options: InitOptions,
-  result: InitResult
-): Promise<void> {
-  const helpersDir = path.join(targetDir, '.claude', 'helpers');
-  const sourceBaseDir = options.sourceBaseDir;
-
-  // Try to copy existing helpers from source first
-  if (sourceBaseDir) {
-    const sourceHelpersDir = path.join(sourceBaseDir, '.claude', 'helpers');
-    if (fs.existsSync(sourceHelpersDir)) {
-      const helperFiles = fs.readdirSync(sourceHelpersDir);
-      for (const file of helperFiles) {
-        const sourcePath = path.join(sourceHelpersDir, file);
-        const destPath = path.join(helpersDir, file);
-
-        // Skip directories and only copy files
-        if (!fs.statSync(sourcePath).isFile()) continue;
-
-        if (!fs.existsSync(destPath) || options.force) {
-          fs.copyFileSync(sourcePath, destPath);
-
-          // Make shell scripts executable
-          if (file.endsWith('.sh')) {
-            fs.chmodSync(destPath, '755');
-          }
-
-          result.created.files.push(`.claude/helpers/${file}`);
-        } else {
-          result.skipped.push(`.claude/helpers/${file}`);
-        }
-      }
-      return; // Skip generating if we copied from source
-    }
-  }
-
-  // Fall back to generating helpers if source not available
-  const helpers: Record<string, string> = {
-    'pre-commit': generatePreCommitHook(),
-    'post-commit': generatePostCommitHook(),
-    'session.js': generateSessionManager(),
-    'router.js': generateAgentRouter(),
-    'memory.js': generateMemoryHelper(),
-  };
-
-  for (const [name, content] of Object.entries(helpers)) {
-    const filePath = path.join(helpersDir, name);
-
-    if (!fs.existsSync(filePath) || options.force) {
-      fs.writeFileSync(filePath, content, 'utf-8');
-
-      // Make shell scripts executable
-      if (!name.endsWith('.js')) {
-        fs.chmodSync(filePath, '755');
-      }
-
-      result.created.files.push(`.claude/helpers/${name}`);
-    } else {
-      result.skipped.push(`.claude/helpers/${name}`);
-    }
-  }
-}
-
-/**
- * Write statusline configuration
- */
-async function writeStatusline(
-  targetDir: string,
-  options: InitOptions,
-  result: InitResult
-): Promise<void> {
-  const claudeDir = path.join(targetDir, '.claude');
-  const helpersDir = path.join(targetDir, '.claude', 'helpers');
-
-  // Try to copy existing advanced statusline files from source
-  const sourceBaseDir = options.sourceBaseDir;
-  const advancedStatuslineFiles = [
-    { src: 'statusline.sh', dest: 'statusline.sh', dir: claudeDir },
-    { src: 'statusline.mjs', dest: 'statusline.mjs', dir: claudeDir },
-  ];
-
-  let copiedAdvanced = false;
-  if (sourceBaseDir) {
-    for (const file of advancedStatuslineFiles) {
-      const sourcePath = path.join(sourceBaseDir, '.claude', file.src);
-      const destPath = path.join(file.dir, file.dest);
-
-      if (fs.existsSync(sourcePath)) {
-        if (!fs.existsSync(destPath) || options.force) {
-          fs.copyFileSync(sourcePath, destPath);
-          // Make shell scripts executable
-          if (file.src.endsWith('.sh')) {
-            fs.chmodSync(destPath, '755');
-          }
-          result.created.files.push(`.claude/${file.dest}`);
-          copiedAdvanced = true;
-        } else {
-          result.skipped.push(`.claude/${file.dest}`);
-        }
-      }
-    }
-  }
-
-  // Fall back to generating simple statusline if advanced files not available
-  if (!copiedAdvanced) {
-    const statuslineScript = generateStatuslineScript(options);
-    const statuslineHook = generateStatuslineHook(options);
-
-    const files: Record<string, string> = {
-      'statusline.js': statuslineScript,
-      'statusline-hook.sh': statuslineHook,
-    };
-
-    for (const [name, content] of Object.entries(files)) {
-      const filePath = path.join(helpersDir, name);
-
-      if (!fs.existsSync(filePath) || options.force) {
-        fs.writeFileSync(filePath, content, 'utf-8');
-        result.created.files.push(`.claude/helpers/${name}`);
-      } else {
-        result.skipped.push(`.claude/helpers/${name}`);
-      }
-    }
-  }
-}
-
-/**
- * Write runtime configuration (.claude-flow/)
- */
-async function writeRuntimeConfig(
-  targetDir: string,
-  options: InitOptions,
-  result: InitResult
-): Promise<void> {
-  const configPath = path.join(targetDir, '.claude-flow', 'config.yaml');
-
-  if (fs.existsSync(configPath) && !options.force) {
-    result.skipped.push('.claude-flow/config.yaml');
-    return;
-  }
-
-  const config = `# Claude Flow V3 Runtime Configuration
-# Generated: ${new Date().toISOString()}
-
-version: "3.0.0"
-
-swarm:
-  topology: ${options.runtime.topology}
-  maxAgents: ${options.runtime.maxAgents}
-  autoScale: true
-  coordinationStrategy: consensus
-
-memory:
-  backend: ${options.runtime.memoryBackend}
-  enableHNSW: ${options.runtime.enableHNSW}
-  persistPath: .claude-flow/data
-  cacheSize: 100
-
-neural:
-  enabled: ${options.runtime.enableNeural}
-  modelPath: .claude-flow/neural
-
-hooks:
-  enabled: true
-  autoExecute: true
-
-mcp:
-  autoStart: ${options.mcp.autoStart}
-  port: ${options.mcp.port}
-`;
-
-  fs.writeFileSync(configPath, config, 'utf-8');
-  result.created.files.push('.claude-flow/config.yaml');
-
-  // Write .gitignore
-  const gitignorePath = path.join(targetDir, '.claude-flow', '.gitignore');
-  const gitignore = `# Claude Flow runtime files
-data/
-logs/
-sessions/
-neural/
-*.log
-*.tmp
-`;
-
-  if (!fs.existsSync(gitignorePath) || options.force) {
-    fs.writeFileSync(gitignorePath, gitignore, 'utf-8');
-    result.created.files.push('.claude-flow/.gitignore');
-  }
-}
-
-/**
- * Write CLAUDE.md with swarm guidance
- */
-async function writeClaudeMd(
-  targetDir: string,
-  options: InitOptions,
-  result: InitResult
-): Promise<void> {
-  const claudeMdPath = path.join(targetDir, 'CLAUDE.md');
-
-  if (fs.existsSync(claudeMdPath) && !options.force) {
-    result.skipped.push('CLAUDE.md');
-    return;
-  }
-
-  // Use minimal version for minimal init, full version otherwise
-  const isMinimal = !options.components.commands && !options.components.agents;
-  const content = isMinimal ? generateMinimalClaudeMd(options) : generateClaudeMd(options);
-
-  fs.writeFileSync(claudeMdPath, content, 'utf-8');
-  result.created.files.push('CLAUDE.md');
-}
-
-/**
- * Find source directory for skills/commands/agents
- */
-function findSourceDir(type: 'skills' | 'commands' | 'agents', sourceBaseDir?: string): string | null {
-  // Build list of possible paths to check
-  const possiblePaths: string[] = [];
-
-  // If explicit source base directory is provided, use it first
-  if (sourceBaseDir) {
-    possiblePaths.push(path.join(sourceBaseDir, '.claude', type));
-  }
-
-  // From dist/src/init -> go up to project root
-  // __dirname is typically /path/to/v3/@claude-flow/cli/dist/src/init
-  const distPath = __dirname;
-
-  // Try to find the project root by looking for .claude directory
-  let currentDir = distPath;
-  for (let i = 0; i < 10; i++) {
-    const parentDir = path.dirname(currentDir);
-    const dotClaudePath = path.join(parentDir, '.claude', type);
-    if (fs.existsSync(dotClaudePath)) {
-      possiblePaths.push(dotClaudePath);
-    }
-    currentDir = parentDir;
-  }
-
-  // Also check relative to process.cwd() for development
-  const cwdBased = [
-    path.join(process.cwd(), '.claude', type),
-    path.join(process.cwd(), '..', '.claude', type),
-    path.join(process.cwd(), '..', '..', '.claude', type),
-  ];
-  possiblePaths.push(...cwdBased);
-
-  // Check v2 directory for agents
-  if (type === 'agents') {
-    possiblePaths.push(
-      path.join(process.cwd(), 'v2', '.claude', type),
-      path.join(process.cwd(), '..', 'v2', '.claude', type),
-    );
-  }
-
-  // Plugin directory
-  possiblePaths.push(
-    path.join(process.cwd(), 'plugin', type),
-    path.join(process.cwd(), '..', 'plugin', type),
-  );
-
-  for (const p of possiblePaths) {
-    if (fs.existsSync(p)) {
-      return p;
-    }
-  }
-
-  return null;
-}
-
-/**
- * Copy directory recursively
- */
-function copyDirRecursive(src: string, dest: string): void {
-  fs.mkdirSync(dest, { recursive: true });
-
-  const entries = fs.readdirSync(src, { withFileTypes: true });
-
-  for (const entry of entries) {
-    const srcPath = path.join(src, entry.name);
-    const destPath = path.join(dest, entry.name);
-
-    if (entry.isDirectory()) {
-      copyDirRecursive(srcPath, destPath);
-    } else {
-      fs.copyFileSync(srcPath, destPath);
-    }
-  }
-}
-
-/**
- * Count files with extension in directory
- */
-function countFiles(dir: string, ext: string): number {
-  let count = 0;
-
-  const entries = fs.readdirSync(dir, { withFileTypes: true });
-
-  for (const entry of entries) {
-    const fullPath = path.join(dir, entry.name);
-
-    if (entry.isDirectory()) {
-      count += countFiles(fullPath, ext);
-    } else if (entry.name.endsWith(ext)) {
-      count++;
-    }
-  }
-
-  return count;
-}
-
-/**
- * Count enabled hooks
- */
-function countEnabledHooks(options: InitOptions): number {
-  const hooks = options.hooks;
-  let count = 0;
-
-  if (hooks.preToolUse) count++;
-  if (hooks.postToolUse) count++;
-  if (hooks.userPromptSubmit) count++;
-  if (hooks.sessionStart) count++;
-  if (hooks.stop) count++;
-  if (hooks.notification) count++;
-  if (hooks.permissionRequest) count++;
-
-  return count;
-}
-
-export default executeInit;