@wundr.io/cli 1.0.1 → 1.0.2-dev.20260530174250.ef0ec927

package/src/commands/claude-setup.ts

@@ -1,13 +1,53 @@
-import { Command } from 'commander';
-import chalk from 'chalk';
-import ora from 'ora';
 import { execSync, spawn } from 'child_process';
-import * as path from 'path';
 import * as fs from 'fs';
+import * as path from 'path';
+
+import chalk from 'chalk';
+import { Command } from 'commander';
+import ora from 'ora';
+
+import type { Ora } from 'ora';
+
+// Type for ora spinner
+type OraSpinner = Ora;
+
+// Type definitions
+interface SetupOptions {
+  global?: boolean;
+  skipMcp?: boolean;
+  skipFlow?: boolean;
+  skipChrome?: boolean;
+  skipAgents?: boolean;
+  template?: string;
+}
+
+interface McpOptions {
+  tool?: string;
+}
+
+interface AgentOptions {
+  list?: boolean;
+  enable?: string;
+  profile?: string;
+}
+
+interface ValidateOptions {
+  fix?: boolean;
+}
+
+interface OptimizeOptions {
+  force?: boolean;
+}
 
 /**
  * Claude Setup Commands
- * Comprehensive setup for Claude Code, Claude Flow, and MCP tools
+ * Comprehensive setup for Claude Code, Ruflo, and MCP tools
+ *
+ * Consolidated from:
+ * - /src/cli/commands/claude-setup.ts (374 lines) - function-based approach
+ * - /packages/@wundr/cli/src/commands/claude-setup.ts (697 lines) - class-based approach
+ *
+ * This version preserves ALL functionality from both implementations.
  */
 export class ClaudeSetupCommands {
   constructor(private program: Command) {
@@ -18,50 +58,71 @@ export class ClaudeSetupCommands {
     const claudeSetup = this.program
       .command('claude-setup')
       .alias('cs')
-      .description('Setup Claude Code, Claude Flow, and MCP tools')
+      .description('Setup Claude Code, Ruflo, and MCP tools')
       .addHelpText(
         'after',
         chalk.gray(`
 Examples:
   ${chalk.green('wundr claude-setup')}              Interactive Claude setup
+  ${chalk.green('wundr claude-setup install')}      Complete ecosystem installation
   ${chalk.green('wundr claude-setup mcp')}          Install all MCP tools
   ${chalk.green('wundr claude-setup agents')}       Configure all 54 agents
   ${chalk.green('wundr claude-setup optimize')}     Setup hardware-adaptive optimizations
   ${chalk.green('wundr claude-setup validate')}     Validate Claude installation
+  ${chalk.green('wundr claude-setup project')}      Setup project with templates
       `)
       );
 
-    // Main setup command
+    // Main setup command (default)
     claudeSetup
       .command('install', { isDefault: true })
       .description('Complete Claude ecosystem installation')
       .option('--skip-chrome', 'Skip Chrome installation')
       .option('--skip-mcp', 'Skip MCP tools installation')
       .option('--skip-agents', 'Skip agent configuration')
-      .action(async options => {
+      .option('--skip-flow', 'Skip Ruflo setup')
+      .option('-g, --global', 'Install tools globally')
+      .action(async (options: SetupOptions) => {
         await this.runCompleteSetup(options);
       });
 
+    // Project setup with templates (from /src/cli/commands/claude-setup.ts)
+    claudeSetup
+      .command('project [path]')
+      .description(
+        'Setup Claude Code in a project directory with optional template'
+      )
+      .option('-g, --global', 'Install tools globally')
+      .option('--skip-mcp', 'Skip MCP tools installation')
+      .option('--skip-flow', 'Skip Ruflo setup')
+      .option(
+        '-t, --template <name>',
+        'Use specific project template (typescript, react, nodejs, monorepo)'
+      )
+      .action(async (projectPath: string = '.', options: SetupOptions) => {
+        await this.runProjectSetup(projectPath, options);
+      });
+
     // MCP tools installation
     claudeSetup
       .command('mcp')
       .description('Install and configure MCP tools')
       .option(
         '--tool <tool>',
-        'Install specific tool (firecrawl, context7, playwright, browser, sequentialthinking)'
+        'Install specific tool (firecrawl, context7, playwright, browser, sequentialthinking, ruflo)'
       )
-      .action(async options => {
+      .action(async (options: McpOptions) => {
         await this.installMcpTools(options);
       });
 
     // Agent configuration
     claudeSetup
       .command('agents')
-      .description('Configure Claude Flow agents')
+      .description('Configure Ruflo agents')
       .option('--list', 'List available agents')
       .option('--enable <agents>', 'Enable specific agents (comma-separated)')
       .option('--profile <profile>', 'Use profile-specific agents')
-      .action(async options => {
+      .action(async (options: AgentOptions) => {
         await this.configureAgents(options);
       });
 
@@ -70,7 +131,7 @@ Examples:
       .command('validate')
       .description('Validate Claude installation')
       .option('--fix', 'Attempt to fix issues')
-      .action(async options => {
+      .action(async (options: ValidateOptions) => {
         await this.validateInstallation(options);
       });
 
@@ -87,12 +148,28 @@ Examples:
       .command('optimize')
       .description('Setup hardware-adaptive Claude Code optimizations')
       .option('--force', 'Force reinstallation of optimization scripts')
-      .action(async options => {
+      .action(async (options: OptimizeOptions) => {
         await this.setupOptimizations(options);
       });
+
+    // Generate CLAUDE.md
+    claudeSetup
+      .command('config')
+      .description('Generate or update CLAUDE.md configuration')
+      .argument(
+        '[path]',
+        'Path to repository (defaults to current directory)',
+        '.'
+      )
+      .action(async (repoPath: string) => {
+        await this.generateClaudeConfig(repoPath);
+      });
   }
 
-  private async runCompleteSetup(options: any): Promise<void> {
+  /**
+   * Complete setup - combines both implementations' main flows
+   */
+  private async runCompleteSetup(options: SetupOptions): Promise<void> {
     const spinner = ora();
     console.log(chalk.cyan.bold('\n🤖 Claude Ecosystem Setup\n'));
 
@@ -113,19 +190,24 @@ Examples:
         spinner.succeed('Chrome installed');
       }
 
-      // Step 3: Install MCP tools (if not skipped)
+      // Step 3: Ruflo setup
+      if (!options.skipFlow) {
+        await this.setupRuflo(spinner, process.cwd(), options.global);
+      }
+
+      // Step 4: Install MCP tools (if not skipped)
       if (!options.skipMcp) {
         await this.installMcpTools({});
       }
 
-      // Step 4: Configure agents (if not skipped)
+      // Step 5: Configure agents (if not skipped)
       if (!options.skipAgents) {
         await this.configureAgents({ profile: 'fullstack' });
       }
 
-      // Step 5: Setup Claude configuration
+      // Step 6: Setup Claude configuration
       spinner.start('Configuring Claude settings...');
-      await this.setupClaudeConfig();
+      await this.setupClaudeSettings();
       spinner.succeed('Claude configured');
 
       console.log(chalk.green.bold('\n✅ Claude ecosystem setup complete!\n'));
@@ -137,21 +219,190 @@ Examples:
     }
   }
 
-  private async installMcpTools(options: any): Promise<void> {
+  /**
+   * Project setup - from /src/cli/commands/claude-setup.ts
+   */
+  private async runProjectSetup(
+    projectPath: string,
+    options: SetupOptions
+  ): Promise<void> {
+    const spinner = ora('Starting Claude Code project setup...').start();
+
+    try {
+      const repoPath = path.resolve(projectPath);
+
+      // Verify git repository
+      if (!fs.existsSync(path.join(repoPath, '.git'))) {
+        spinner.stop();
+        const inquirer = await import('inquirer');
+        const { shouldInitGit } = await inquirer.default.prompt([
+          {
+            type: 'confirm',
+            name: 'shouldInitGit',
+            message: 'Not a git repository. Initialize git?',
+            default: true,
+          },
+        ]);
+
+        if (shouldInitGit) {
+          spinner.start('Initializing git repository...');
+          execSync('git init', { cwd: repoPath });
+          spinner.succeed('Git repository initialized');
+        } else {
+          console.log(chalk.yellow('Continuing without git...'));
+        }
+      }
+
+      // Step 1: Ruflo setup
+      if (!options.skipFlow) {
+        await this.setupRuflo(spinner, repoPath, options.global);
+      }
+
+      // Step 2: MCP Tools setup
+      if (!options.skipMcp) {
+        await this.setupMCPToolsDirectory(spinner, repoPath);
+      }
+
+      // Step 3: Generate CLAUDE.md
+      await this.generateClaudeConfigForPath(spinner, repoPath);
+
+      // Step 4: Setup project template if specified
+      if (options.template) {
+        await this.setupProjectTemplate(spinner, repoPath, options.template);
+      }
+
+      // Step 5: Initialize swarm if Ruflo is available
+      if (!options.skipFlow) {
+        await this.initializeSwarm(spinner, repoPath);
+      }
+
+      // Step 6: Validation
+      await this.validateProjectSetup(spinner, repoPath);
+
+      spinner.succeed('Claude Code project setup completed successfully!');
+
+      // Final instructions
+      this.displayProjectFinalInstructions(repoPath, options);
+    } catch (error) {
+      spinner.stop();
+      console.error(chalk.red('❌ Setup failed:'));
+      console.error(
+        chalk.red(error instanceof Error ? error.message : String(error))
+      );
+      process.exit(1);
+    }
+  }
+
+  /**
+   * Setup Ruflo - from /src/cli/commands/claude-setup.ts
+   */
+  private async setupRuflo(
+    spinner: OraSpinner,
+    repoPath: string,
+    global?: boolean
+  ): Promise<void> {
+    spinner.text = 'Setting up Ruflo...';
+
+    try {
+      // Check if Ruflo is already installed
+      execSync('npx ruflo@latest --version', { stdio: 'ignore' });
+      spinner.text = 'Ruflo already available, configuring...';
+    } catch {
+      spinner.text = 'Installing Ruflo...';
+
+      if (global) {
+        execSync('npm install -g ruflo@latest', { stdio: 'inherit' });
+      } else {
+        // Add to package.json dev dependencies if it exists
+        if (fs.existsSync(path.join(repoPath, 'package.json'))) {
+          execSync('npm install --save-dev ruflo@latest', {
+            cwd: repoPath,
+            stdio: 'inherit',
+          });
+        }
+      }
+    }
+
+    // Add MCP server configuration
+    spinner.text = 'Configuring Claude MCP server...';
+    try {
+      execSync('claude mcp add ruflo npx ruflo@latest mcp start', {
+        cwd: repoPath,
+        stdio: 'pipe',
+      });
+    } catch {
+      // MCP configuration might fail if Claude Desktop isn't installed
+      console.log(
+        chalk.yellow('\n⚠️  Could not configure MCP server automatically.')
+      );
+      console.log(
+        chalk.yellow(
+          'Please run manually: claude mcp add ruflo npx ruflo@latest mcp start'
+        )
+      );
+    }
+
+    spinner.text = 'Ruflo setup completed';
+  }
+
+  /**
+   * Setup MCP Tools directory - from /src/cli/commands/claude-setup.ts
+   */
+  private async setupMCPToolsDirectory(
+    spinner: OraSpinner,
+    repoPath: string
+  ): Promise<void> {
+    spinner.text = 'Setting up MCP Tools directory...';
+
+    const mcpToolsPath = path.join(repoPath, 'mcp-tools');
+
+    // Create mcp-tools directory if it doesn't exist
+    if (!fs.existsSync(mcpToolsPath)) {
+      fs.mkdirSync(mcpToolsPath, { recursive: true });
+
+      // Create basic install script
+      const installScript = `#!/bin/bash
+# MCP Tools Installation Script
+echo "Installing Wundr MCP Tools..."
+
+# Add your MCP tool installations here
+echo "✅ MCP Tools installation template created"
+echo "Customize this script with your specific MCP tools"
+`;
+
+      fs.writeFileSync(path.join(mcpToolsPath, 'install.sh'), installScript);
+      execSync(`chmod +x ${path.join(mcpToolsPath, 'install.sh')}`);
+
+      // Create package.json for MCP tools
+      const mcpPackageJson = {
+        name: 'mcp-tools',
+        version: '1.0.0',
+        description: 'MCP Tools for Claude Code integration',
+        private: true,
+        scripts: {
+          install: './install.sh',
+        },
+      };
+
+      fs.writeFileSync(
+        path.join(mcpToolsPath, 'package.json'),
+        JSON.stringify(mcpPackageJson, null, 2)
+      );
+    }
+
+    spinner.text = 'MCP Tools directory setup completed';
+  }
+
+  /**
+   * Install MCP tools via script or specific tool
+   */
+  private async installMcpTools(options: McpOptions): Promise<void> {
     const spinner = ora();
     const scriptPath = path.join(
       __dirname,
       '../../../../scripts/install-mcp-tools.sh'
     );
 
-    if (!fs.existsSync(scriptPath)) {
-      console.error(chalk.red('❌ MCP tools installation script not found'));
-      console.log(
-        chalk.yellow('Please ensure the script exists at: ' + scriptPath)
-      );
-      return;
-    }
-
     console.log(chalk.cyan('\n📦 Installing MCP Tools...\n'));
 
     if (options.tool) {
@@ -166,6 +417,7 @@ Examples:
           browser: 'npx claude mcp add browser npx @browser/mcp-server',
           sequentialthinking:
             'npm install -g @modelcontextprotocol/server-sequentialthinking',
+          ruflo: 'claude mcp add ruflo npx ruflo@latest mcp start',
         };
 
         const command = installCommands[options.tool];
@@ -174,38 +426,62 @@ Examples:
           spinner.succeed(`${options.tool} MCP installed`);
         } else {
           spinner.fail(`Unknown tool: ${options.tool}`);
+          console.log(
+            chalk.yellow(
+              `Available tools: ${Object.keys(installCommands).join(', ')}`
+            )
+          );
         }
       } catch (error) {
         spinner.fail(`Failed to install ${options.tool}`);
         console.error(error);
       }
     } else {
-      // Install all tools using the script
-      console.log(
-        chalk.gray('Running comprehensive MCP tools installation...')
-      );
+      // Try to install all tools using the script if it exists
+      if (fs.existsSync(scriptPath)) {
+        console.log(
+          chalk.gray('Running comprehensive MCP tools installation...')
+        );
 
-      const install = spawn('bash', [scriptPath], {
-        stdio: 'inherit',
-        shell: true,
-      });
+        const install = spawn('bash', [scriptPath], {
+          stdio: 'inherit',
+          shell: true,
+        });
 
-      return new Promise((resolve, reject) => {
-        install.on('close', code => {
-          if (code === 0) {
-            console.log(
-              chalk.green('\n✅ All MCP tools installed successfully')
-            );
-            resolve();
-          } else {
-            reject(new Error(`Installation failed with code ${code}`));
-          }
+        return new Promise((resolve, reject) => {
+          install.on('close', code => {
+            if (code === 0) {
+              console.log(
+                chalk.green('\n✅ All MCP tools installed successfully')
+              );
+              resolve();
+            } else {
+              reject(new Error(`Installation failed with code ${code}`));
+            }
+          });
         });
-      });
+      } else {
+        // Fallback: install core tools
+        console.log(chalk.gray('Installing core MCP tools...'));
+
+        const coreTools = ['ruflo', 'sequentialthinking'];
+        for (const tool of coreTools) {
+          try {
+            await this.installMcpTools({ tool });
+          } catch {
+            console.log(chalk.yellow(`⚠️ Could not install ${tool}`));
+          }
+        }
+
+        console.log(chalk.green('\n✅ Core MCP tools installed'));
+      }
     }
   }
 
-  private async configureAgents(options: any): Promise<void> {
+  /**
+   * Configure Ruflo agents
+   */
+  private async configureAgents(options: AgentOptions): Promise<void> {
     const spinner = ora();
 
     if (options.list) {
@@ -213,14 +489,14 @@ Examples:
       return;
     }
 
-    spinner.start('Configuring Claude Flow agents...');
+    spinner.start('Configuring Ruflo agents...');
 
     const agents = options.enable
       ? options.enable.split(',')
       : this.getProfileAgents(options.profile || 'fullstack');
 
     // Create agent configurations
-    const homeDir = process.env.HOME || process.env.USERPROFILE || '';
+    const homeDir = process.env['HOME'] || process.env['USERPROFILE'] || '';
     const agentsDir = path.join(homeDir, '.claude', 'agents');
 
     try {
@@ -241,12 +517,15 @@ Examples:
     }
   }
 
-  private async validateInstallation(options: any): Promise<void> {
+  /**
+   * Validate Claude installation
+   */
+  private async validateInstallation(options: ValidateOptions): Promise<void> {
     console.log(chalk.cyan('\n🔍 Validating Claude Installation...\n'));
 
     const checks = [
       { name: 'Claude CLI', check: () => this.isClaudeInstalled() },
-      { name: 'Claude Flow', check: () => this.isClaudeFlowInstalled() },
+      { name: 'Ruflo', check: () => this.isRufloInstalled() },
       { name: 'Chrome Browser', check: () => this.isChromeInstalled() },
       { name: 'Claude Directory', check: () => this.claudeDirExists() },
       { name: 'Agent Configurations', check: () => this.agentsConfigured() },
@@ -279,10 +558,13 @@ Examples:
     }
   }
 
+  /**
+   * Install Chrome extension instructions
+   */
   private async installChromeExtension(): Promise<void> {
     console.log(chalk.cyan('\n🔌 Browser MCP Chrome Extension Setup\n'));
 
-    const homeDir = process.env.HOME || process.env.USERPROFILE || '';
+    const homeDir = process.env['HOME'] || process.env['USERPROFILE'] || '';
     const extensionDir = path.join(homeDir, '.claude', 'browser-extension');
 
     console.log(chalk.white('Extension location: ' + extensionDir));
@@ -294,14 +576,17 @@ Examples:
     console.log('\n✅ The extension will then be active!');
   }
 
-  private async setupOptimizations(options: any): Promise<void> {
+  /**
+   * Setup hardware-adaptive optimizations
+   */
+  private async setupOptimizations(options: OptimizeOptions): Promise<void> {
     const spinner = ora();
     console.log(
       chalk.cyan.bold('\n⚡ Claude Code Hardware-Adaptive Optimization Setup\n')
     );
 
     try {
-      const homeDir = process.env.HOME || process.env.USERPROFILE || '';
+      const homeDir = process.env['HOME'] || process.env['USERPROFILE'] || '';
       const scriptsDir = path.join(homeDir, '.claude', 'scripts');
       const resourcesDir = path.join(
         __dirname,
@@ -311,9 +596,8 @@ Examples:
       // Check if optimization scripts already exist
       const scriptsExist = fs.existsSync(scriptsDir);
       if (scriptsExist && !options.force) {
-        const { overwrite } = await (
-          await import('inquirer')
-        ).default.prompt([
+        const inquirer = await import('inquirer');
+        const { overwrite } = await inquirer.default.prompt([
           {
             type: 'confirm',
             name: 'overwrite',
@@ -406,7 +690,9 @@ Examples:
         chalk.white('  • claude - Hardware-optimized Claude wrapper')
       );
       console.log(chalk.white('  • claude-stats - Show hardware statistics'));
-      console.log(chalk.white('  • claude-cleanup - Clean up zombie processes'));
+      console.log(
+        chalk.white('  • claude-cleanup - Clean up zombie processes')
+      );
       console.log(
         chalk.white('  • claude-orchestrate - Run multi-task orchestrator')
       );
@@ -425,6 +711,285 @@ Examples:
     }
   }
 
+  /**
+   * Generate CLAUDE.md configuration
+   */
+  private async generateClaudeConfig(repoPath: string): Promise<void> {
+    const spinner = ora('Generating CLAUDE.md configuration...').start();
+
+    try {
+      const resolvedPath = path.resolve(repoPath);
+      await this.generateClaudeConfigForPath(spinner, resolvedPath);
+      spinner.succeed('CLAUDE.md generated successfully');
+      console.log(
+        chalk.green(
+          `\n✅ CLAUDE.md created at: ${path.join(resolvedPath, 'CLAUDE.md')}`
+        )
+      );
+    } catch (error) {
+      spinner.fail('Failed to generate CLAUDE.md');
+      console.error(
+        chalk.red(error instanceof Error ? error.message : String(error))
+      );
+    }
+  }
+
+  /**
+   * Generate CLAUDE.md for a specific path
+   */
+  private async generateClaudeConfigForPath(
+    spinner: OraSpinner,
+    repoPath: string
+  ): Promise<void> {
+    spinner.text = 'Generating CLAUDE.md configuration...';
+
+    try {
+      // Try to use the ClaudeConfigGenerator if available
+      // Use path.resolve to construct the path at runtime to avoid TypeScript rootDir issues
+      const generatorPath = path.resolve(
+        __dirname,
+        '../../../../../src/claude-generator/claude-config-generator.js'
+      );
+      const { ClaudeConfigGenerator } = await import(
+        /* @vite-ignore */ generatorPath
+      );
+      const generator = new ClaudeConfigGenerator(repoPath);
+
+      const claudeContent = await generator.generateClaudeMarkdown();
+      const claudeFilePath = path.join(repoPath, 'CLAUDE.md');
+
+      fs.writeFileSync(claudeFilePath, claudeContent, 'utf-8');
+    } catch {
+      // Fallback: Create a basic CLAUDE.md
+      spinner.text = 'Creating basic CLAUDE.md...';
+      const basicContent = this.generateBasicClaudeConfig(repoPath);
+      fs.writeFileSync(path.join(repoPath, 'CLAUDE.md'), basicContent, 'utf-8');
+    }
+
+    spinner.text = 'CLAUDE.md generated successfully';
+  }
+
+  /**
+   * Generate basic CLAUDE.md content as fallback
+   */
+  private generateBasicClaudeConfig(repoPath: string): string {
+    const projectName = path.basename(repoPath);
+    return `# Claude Code Configuration - ${projectName}
+
+## Project Overview
+This project uses Claude Code for AI-assisted development.
+
+## Commands
+- \`npm run build\` - Build the project
+- \`npm run test\` - Run tests
+- \`npm run lint\` - Run linting
+
+## Code Style
+- Follow existing patterns in the codebase
+- Write clear, descriptive commit messages
+- Add tests for new features
+
+## MCP Tools
+Ruflo is configured for enhanced AI coordination.
+Run \`npx ruflo@latest sparc modes\` to see available modes.
+`;
+  }
+
+  /**
+   * Setup project template - from /src/cli/commands/claude-setup.ts
+   */
+  private async setupProjectTemplate(
+    spinner: OraSpinner,
+    repoPath: string,
+    templateName: string
+  ): Promise<void> {
+    spinner.text = `Applying ${templateName} template...`;
+
+    const templates: Record<string, () => void> = {
+      typescript: () => this.setupTypeScriptTemplate(repoPath),
+      react: () => this.setupReactTemplate(repoPath),
+      nodejs: () => this.setupNodeTemplate(repoPath),
+      monorepo: () => this.setupMonorepoTemplate(repoPath),
+    };
+
+    const setupFunction = templates[templateName];
+    if (!setupFunction) {
+      throw new Error(
+        `Unknown template: ${templateName}. Available: ${Object.keys(templates).join(', ')}`
+      );
+    }
+
+    setupFunction();
+
+    spinner.text = `${templateName} template applied`;
+  }
+
+  private setupTypeScriptTemplate(repoPath: string): void {
+    // Create basic TypeScript configuration if not exists
+    const tsconfigPath = path.join(repoPath, 'tsconfig.json');
+    if (!fs.existsSync(tsconfigPath)) {
+      const tsconfig = {
+        compilerOptions: {
+          target: 'ES2020',
+          module: 'ESNext',
+          moduleResolution: 'node',
+          strict: true,
+          esModuleInterop: true,
+          skipLibCheck: true,
+          forceConsistentCasingInFileNames: true,
+          declaration: true,
+          outDir: 'dist',
+          rootDir: 'src',
+        },
+        include: ['src/**/*'],
+        exclude: ['node_modules', 'dist'],
+      };
+
+      fs.writeFileSync(tsconfigPath, JSON.stringify(tsconfig, null, 2));
+    }
+
+    // Create src directory
+    const srcPath = path.join(repoPath, 'src');
+    if (!fs.existsSync(srcPath)) {
+      fs.mkdirSync(srcPath, { recursive: true });
+      fs.writeFileSync(
+        path.join(srcPath, 'index.ts'),
+        '// Your TypeScript code here\n'
+      );
+    }
+  }
+
+  private setupReactTemplate(repoPath: string): void {
+    // Ensure React-specific structure
+    const srcPath = path.join(repoPath, 'src');
+    if (!fs.existsSync(srcPath)) {
+      fs.mkdirSync(srcPath, { recursive: true });
+    }
+
+    // Create components directory
+    const componentsPath = path.join(srcPath, 'components');
+    if (!fs.existsSync(componentsPath)) {
+      fs.mkdirSync(componentsPath, { recursive: true });
+    }
+
+    // Create hooks directory
+    const hooksPath = path.join(srcPath, 'hooks');
+    if (!fs.existsSync(hooksPath)) {
+      fs.mkdirSync(hooksPath, { recursive: true });
+    }
+  }
+
+  private setupNodeTemplate(repoPath: string): void {
+    // Create basic Node.js structure
+    const srcPath = path.join(repoPath, 'src');
+    if (!fs.existsSync(srcPath)) {
+      fs.mkdirSync(srcPath, { recursive: true });
+      fs.writeFileSync(
+        path.join(srcPath, 'index.js'),
+        '// Your Node.js code here\n'
+      );
+    }
+
+    // Create routes directory
+    const routesPath = path.join(srcPath, 'routes');
+    if (!fs.existsSync(routesPath)) {
+      fs.mkdirSync(routesPath, { recursive: true });
+    }
+  }
+
+  private setupMonorepoTemplate(repoPath: string): void {
+    // Create packages directory
+    const packagesPath = path.join(repoPath, 'packages');
+    if (!fs.existsSync(packagesPath)) {
+      fs.mkdirSync(packagesPath, { recursive: true });
+    }
+
+    // Create apps directory
+    const appsPath = path.join(repoPath, 'apps');
+    if (!fs.existsSync(appsPath)) {
+      fs.mkdirSync(appsPath, { recursive: true });
+    }
+
+    // Create workspace package.json if not exists
+    const packageJsonPath = path.join(repoPath, 'package.json');
+    if (!fs.existsSync(packageJsonPath)) {
+      const packageJson = {
+        name: 'monorepo-workspace',
+        version: '1.0.0',
+        private: true,
+        workspaces: ['packages/*', 'apps/*'],
+        devDependencies: {
+          turbo: '^2.0.0',
+        },
+      };
+
+      fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
+    }
+  }
+
+  /**
+   * Initialize swarm - from /src/cli/commands/claude-setup.ts
+   */
+  private async initializeSwarm(
+    spinner: OraSpinner,
+    repoPath: string
+  ): Promise<void> {
+    spinner.text = 'Initializing Ruflo swarm...';
+
+    try {
+      // Initialize basic swarm configuration
+      execSync('npx ruflo@latest init', {
+        cwd: repoPath,
+        stdio: 'pipe',
+      });
+    } catch {
+      // Swarm init might fail if not properly configured
+      console.log(
+        chalk.yellow('\n⚠️  Could not initialize swarm automatically.')
+      );
+      console.log(
+        chalk.yellow(
+          'You can initialize manually later with: npx ruflo@latest init'
+        )
+      );
+    }
+
+    spinner.text = 'Swarm initialization completed';
+  }
+
+  /**
+   * Validate project setup - from /src/cli/commands/claude-setup.ts
+   */
+  private async validateProjectSetup(
+    spinner: OraSpinner,
+    repoPath: string
+  ): Promise<void> {
+    spinner.text = 'Validating setup...';
+
+    const validations = [
+      { name: 'CLAUDE.md', path: path.join(repoPath, 'CLAUDE.md') },
+      { name: 'MCP Tools', path: path.join(repoPath, 'mcp-tools') },
+      { name: 'Git repository', path: path.join(repoPath, '.git') },
+    ];
+
+    const results = validations.map(validation => ({
+      ...validation,
+      exists: fs.existsSync(validation.path),
+    }));
+
+    const failures = results.filter(r => !r.exists);
+    if (failures.length > 0) {
+      throw new Error(
+        `Setup validation failed: Missing ${failures.map(f => f.name).join(', ')}`
+      );
+    }
+
+    spinner.text = 'Setup validation passed';
+  }
+
+  /**
+   * Add shell optimization configuration
+   */
   private async addOptimizationToShell(homeDir: string): Promise<void> {
     const shellConfigs = [
       path.join(homeDir, '.zshrc'),
@@ -501,6 +1066,9 @@ alias claude-orchestrate='node $HOME/.claude/scripts/orchestrator.js'
     }
   }
 
+  /**
+   * Install Chrome browser
+   */
   private async installChrome(): Promise<void> {
     if (process.platform === 'darwin') {
       execSync(
@@ -519,14 +1087,17 @@ alias claude-orchestrate='node $HOME/.claude/scripts/orchestrator.js'
     }
   }
 
-  private async setupClaudeConfig(): Promise<void> {
-    const homeDir = process.env.HOME || process.env.USERPROFILE || '';
+  /**
+   * Setup Claude settings.json
+   */
+  private async setupClaudeSettings(): Promise<void> {
+    const homeDir = process.env['HOME'] || process.env['USERPROFILE'] || '';
     const configPath = path.join(homeDir, '.claude', 'settings.json');
 
     const config = {
       claudeCodeOptions: {
         enabledMcpjsonServers: [
-          'claude-flow',
+          'ruflo',
           'firecrawl',
           'context7',
           'playwright',
@@ -546,6 +1117,8 @@ alias claude-orchestrate='node $HOME/.claude/scripts/orchestrator.js'
     fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
   }
 
+  // ==================== Helper Methods ====================
+
   private isClaudeInstalled(): boolean {
     try {
       execSync('claude --version', { stdio: 'ignore' });
@@ -555,9 +1128,9 @@ alias claude-orchestrate='node $HOME/.claude/scripts/orchestrator.js'
     }
   }
 
-  private isClaudeFlowInstalled(): boolean {
+  private isRufloInstalled(): boolean {
     try {
-      execSync('npx claude-flow@alpha --version', { stdio: 'ignore' });
+      execSync('npx ruflo@latest --version', { stdio: 'ignore' });
       return true;
     } catch {
       return false;
@@ -572,24 +1145,28 @@ alias claude-orchestrate='node $HOME/.claude/scripts/orchestrator.js'
   }
 
   private claudeDirExists(): boolean {
-    const homeDir = process.env.HOME || process.env.USERPROFILE || '';
+    const homeDir = process.env['HOME'] || process.env['USERPROFILE'] || '';
     return fs.existsSync(path.join(homeDir, '.claude'));
   }
 
   private agentsConfigured(): boolean {
-    const homeDir = process.env.HOME || process.env.USERPROFILE || '';
+    const homeDir = process.env['HOME'] || process.env['USERPROFILE'] || '';
     const agentsDir = path.join(homeDir, '.claude', 'agents');
-    if (!fs.existsSync(agentsDir)) return false;
+    if (!fs.existsSync(agentsDir)) {
+      return false;
+    }
 
     const files = fs.readdirSync(agentsDir);
     return files.length > 0;
   }
 
   private mcpServersConfigured(): boolean {
-    const homeDir = process.env.HOME || process.env.USERPROFILE || '';
+    const homeDir = process.env['HOME'] || process.env['USERPROFILE'] || '';
     const settingsPath = path.join(homeDir, '.claude', 'settings.json');
 
-    if (!fs.existsSync(settingsPath)) return false;
+    if (!fs.existsSync(settingsPath)) {
+      return false;
+    }
 
     try {
       const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
@@ -600,9 +1177,9 @@ alias claude-orchestrate='node $HOME/.claude/scripts/orchestrator.js'
   }
 
   private listAgents(): void {
-    console.log(chalk.cyan('\n📋 Available Claude Flow Agents:\n'));
+    console.log(chalk.cyan('\n📋 Available Ruflo Agents:\n'));
 
-    const categories = {
+    const categories: Record<string, string[]> = {
       'Core Development': [
         'coder',
         'reviewer',
@@ -614,19 +1191,56 @@ alias claude-orchestrate='node $HOME/.claude/scripts/orchestrator.js'
         'hierarchical-coordinator',
         'mesh-coordinator',
         'adaptive-coordinator',
+        'collective-intelligence-coordinator',
+        'swarm-memory-manager',
       ],
-      'GitHub Integration': [
+      'Consensus & Distributed': [
+        'byzantine-coordinator',
+        'raft-manager',
+        'gossip-coordinator',
+        'consensus-builder',
+        'crdt-synchronizer',
+        'quorum-manager',
+        'security-manager',
+      ],
+      'Performance & Optimization': [
+        'perf-analyzer',
+        'performance-benchmarker',
+        'task-orchestrator',
+        'memory-coordinator',
+        'smart-agent',
+      ],
+      'GitHub & Repository': [
         'github-modes',
         'pr-manager',
+        'code-review-swarm',
         'issue-tracker',
         'release-manager',
+        'workflow-automation',
+        'project-board-sync',
+        'repo-architect',
+        'multi-repo-swarm',
+      ],
+      'SPARC Methodology': [
+        'sparc-coord',
+        'sparc-coder',
+        'specification',
+        'pseudocode',
+        'architecture',
+        'refinement',
       ],
-      Specialized: [
+      'Specialized Development': [
         'backend-dev',
         'mobile-dev',
         'ml-developer',
+        'cicd-engineer',
+        'api-docs',
         'system-architect',
+        'code-analyzer',
+        'base-template-generator',
       ],
+      'Testing & Validation': ['tdd-london-swarm', 'production-validator'],
+      'Migration & Planning': ['migration-planner', 'swarm-init'],
     };
 
     for (const [category, agents] of Object.entries(categories)) {
@@ -634,17 +1248,20 @@ alias claude-orchestrate='node $HOME/.claude/scripts/orchestrator.js'
       agents.forEach(agent => console.log(`  • ${agent}`));
       console.log();
     }
+
+    console.log(chalk.gray('Total: 54 agents available'));
   }
 
   private getProfileAgents(profile: string): string[] {
     const profileAgents: Record<string, string[]> = {
-      frontend: ['coder', 'reviewer', 'tester', 'mobile-dev'],
+      frontend: ['coder', 'reviewer', 'tester', 'mobile-dev', 'ui-designer'],
       backend: [
         'coder',
         'reviewer',
         'tester',
         'backend-dev',
         'system-architect',
+        'api-docs',
       ],
       fullstack: [
         'coder',
@@ -653,21 +1270,29 @@ alias claude-orchestrate='node $HOME/.claude/scripts/orchestrator.js'
         'planner',
         'researcher',
         'system-architect',
+        'backend-dev',
       ],
-      devops: ['planner', 'cicd-engineer', 'perf-analyzer', 'github-modes'],
+      devops: [
+        'planner',
+        'cicd-engineer',
+        'perf-analyzer',
+        'github-modes',
+        'workflow-automation',
+      ],
+      ml: ['ml-developer', 'coder', 'tester', 'perf-analyzer', 'researcher'],
     };
 
     return (
       profileAgents[profile] ||
-      profileAgents.fullstack || ['coder', 'reviewer', 'tester']
+      profileAgents['fullstack'] || ['coder', 'reviewer', 'tester']
     );
   }
 
-  private generateAgentConfig(agentName: string): any {
+  private generateAgentConfig(agentName: string): Record<string, unknown> {
     return {
       name: agentName,
       enabled: true,
-      description: `${agentName} agent for Claude Flow`,
+      description: `${agentName} agent for Ruflo`,
       configuration: {
         maxTokens: 8000,
         temperature: 0.7,
@@ -678,6 +1303,48 @@ alias claude-orchestrate='node $HOME/.claude/scripts/orchestrator.js'
     };
   }
 
+  /**
+   * Display final instructions for project setup
+   */
+  private displayProjectFinalInstructions(
+    repoPath: string,
+    options: SetupOptions
+  ): void {
+    console.log(chalk.green('\n🎉 Claude Code Setup Complete!'));
+    console.log(chalk.blue('================================'));
+
+    console.log(chalk.yellow('\n📋 What was set up:'));
+    console.log('✅ CLAUDE.md configuration generated');
+    if (!options.skipFlow) {
+      console.log('✅ Ruflo installed and configured');
+    }
+    if (!options.skipMcp) {
+      console.log('✅ MCP Tools directory created');
+    }
+    console.log('✅ Project structure validated');
+
+    console.log(chalk.yellow('\n🚀 Next Steps:'));
+    console.log('1. Review and customize CLAUDE.md as needed');
+    console.log('2. Install MCP tools: cd mcp-tools && ./install.sh');
+    console.log('3. Verify Claude Desktop MCP connection');
+
+    if (!options.skipFlow) {
+      console.log('4. Test Ruflo: npx ruflo@latest sparc modes');
+    }
+
+    console.log('5. Start coding with optimized Claude Code integration!');
+
+    console.log(chalk.yellow('\n📚 Resources:'));
+    console.log('• Ruflo: https://github.com/ruvnet/ruflo');
+    console.log('• MCP Documentation: https://modelcontextprotocol.io/docs');
+    console.log('• Wundr Documentation: ./docs/');
+
+    console.log(chalk.green('\n✨ Happy coding with Claude!'));
+  }
+
+  /**
+   * Print next steps after complete setup
+   */
   private printNextSteps(): void {
     console.log(chalk.cyan('📋 Next Steps:'));
     console.log('1. Configure API keys for MCP tools (if needed)');
@@ -685,13 +1352,26 @@ alias claude-orchestrate='node $HOME/.claude/scripts/orchestrator.js'
       '2. Install Browser MCP Chrome extension: wundr claude-setup extension'
     );
     console.log('3. Restart Claude Desktop to load new configurations');
-    console.log('4. Initialize a project: wundr claude-init');
+    console.log('4. Initialize a project: wundr claude-setup project');
     console.log(
-      '5. Start coding with Claude Flow: npx claude-flow@alpha sparc tdd "feature"'
+      '5. Start coding with Ruflo: npx ruflo@latest sparc tdd "feature"'
     );
   }
 }
 
-const createClaudeSetupCommands = (program: Command) =>
+/**
+ * Factory function for backwards compatibility with function-based approach
+ * This allows both import patterns to work:
+ * - import claudeSetupCommand from './claude-setup' (class-based)
+ * - import { createClaudeSetupCommand } from './claude-setup' (function-based)
+ */
+export function createClaudeSetupCommand(): Command {
+  const program = new Command();
   new ClaudeSetupCommands(program);
+  return program.commands.find(cmd => cmd.name() === 'claude-setup') || program;
+}
+
+const createClaudeSetupCommands = (program: Command): ClaudeSetupCommands =>
+  new ClaudeSetupCommands(program);
+
 export default createClaudeSetupCommands;