@wundr.io/cli 1.0.0 → 1.0.3

package/dist/commands/claude-setup.js

@@ -1,15 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ClaudeSetupCommands = void 0;
+exports.createClaudeSetupCommand = createClaudeSetupCommand;
 const tslib_1 = require("tslib");
-const chalk_1 = tslib_1.__importDefault(require("chalk"));
-const ora_1 = tslib_1.__importDefault(require("ora"));
 const child_process_1 = require("child_process");
-const path = tslib_1.__importStar(require("path"));
 const fs = tslib_1.__importStar(require("fs"));
+const path = tslib_1.__importStar(require("path"));
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const commander_1 = require("commander");
+const ora_1 = tslib_1.__importDefault(require("ora"));
 /**
  * Claude Setup Commands
  * Comprehensive setup for Claude Code, Claude Flow, 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.
  */
 class ClaudeSetupCommands {
     program;
@@ -25,26 +33,41 @@ class ClaudeSetupCommands {
             .addHelpText('after', chalk_1.default.gray(`
 Examples:
   ${chalk_1.default.green('wundr claude-setup')}              Interactive Claude setup
+  ${chalk_1.default.green('wundr claude-setup install')}      Complete ecosystem installation
   ${chalk_1.default.green('wundr claude-setup mcp')}          Install all MCP tools
   ${chalk_1.default.green('wundr claude-setup agents')}       Configure all 54 agents
   ${chalk_1.default.green('wundr claude-setup optimize')}     Setup hardware-adaptive optimizations
   ${chalk_1.default.green('wundr claude-setup validate')}     Validate Claude installation
+  ${chalk_1.default.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')
+            .option('--skip-flow', 'Skip Claude Flow setup')
+            .option('-g, --global', 'Install tools globally')
             .action(async (options) => {
             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 Claude Flow setup')
+            .option('-t, --template <name>', 'Use specific project template (typescript, react, nodejs, monorepo)')
+            .action(async (projectPath = '.', options) => {
+            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)')
+            .option('--tool <tool>', 'Install specific tool (firecrawl, context7, playwright, browser, sequentialthinking, claude-flow)')
             .action(async (options) => {
             await this.installMcpTools(options);
         });
@@ -81,7 +104,18 @@ Examples:
             .action(async (options) => {
             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) => {
+            await this.generateClaudeConfig(repoPath);
+        });
     }
+    /**
+     * Complete setup - combines both implementations' main flows
+     */
     async runCompleteSetup(options) {
         const spinner = (0, ora_1.default)();
         console.log(chalk_1.default.cyan.bold('\n🤖 Claude Ecosystem Setup\n'));
@@ -101,17 +135,21 @@ Examples:
                 await this.installChrome();
                 spinner.succeed('Chrome installed');
             }
-            // Step 3: Install MCP tools (if not skipped)
+            // Step 3: Claude Flow setup
+            if (!options.skipFlow) {
+                await this.setupClaudeFlow(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_1.default.green.bold('\n✅ Claude ecosystem setup complete!\n'));
             this.printNextSteps();
@@ -122,14 +160,140 @@ Examples:
             process.exit(1);
         }
     }
+    /**
+     * Project setup - from /src/cli/commands/claude-setup.ts
+     */
+    async runProjectSetup(projectPath, options) {
+        const spinner = (0, ora_1.default)('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 Promise.resolve().then(() => tslib_1.__importStar(require('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...');
+                    (0, child_process_1.execSync)('git init', { cwd: repoPath });
+                    spinner.succeed('Git repository initialized');
+                }
+                else {
+                    console.log(chalk_1.default.yellow('Continuing without git...'));
+                }
+            }
+            // Step 1: Claude Flow setup
+            if (!options.skipFlow) {
+                await this.setupClaudeFlow(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 Claude Flow 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_1.default.red('❌ Setup failed:'));
+            console.error(chalk_1.default.red(error instanceof Error ? error.message : String(error)));
+            process.exit(1);
+        }
+    }
+    /**
+     * Setup Claude Flow - from /src/cli/commands/claude-setup.ts
+     */
+    async setupClaudeFlow(spinner, repoPath, global) {
+        spinner.text = 'Setting up Claude Flow...';
+        try {
+            // Check if Claude Flow is already installed
+            (0, child_process_1.execSync)('npx claude-flow --version', { stdio: 'ignore' });
+            spinner.text = 'Claude Flow already available, configuring...';
+        }
+        catch {
+            spinner.text = 'Installing Claude Flow...';
+            if (global) {
+                (0, child_process_1.execSync)('npm install -g claude-flow@alpha', { stdio: 'inherit' });
+            }
+            else {
+                // Add to package.json dev dependencies if it exists
+                if (fs.existsSync(path.join(repoPath, 'package.json'))) {
+                    (0, child_process_1.execSync)('npm install --save-dev claude-flow@alpha', { cwd: repoPath, stdio: 'inherit' });
+                }
+            }
+        }
+        // Add MCP server configuration
+        spinner.text = 'Configuring Claude MCP server...';
+        try {
+            (0, child_process_1.execSync)('claude mcp add claude-flow npx claude-flow@alpha mcp start', {
+                cwd: repoPath,
+                stdio: 'pipe',
+            });
+        }
+        catch {
+            // MCP configuration might fail if Claude Desktop isn't installed
+            console.log(chalk_1.default.yellow('\n⚠️  Could not configure MCP server automatically.'));
+            console.log(chalk_1.default.yellow('Please run manually: claude mcp add claude-flow npx claude-flow@alpha mcp start'));
+        }
+        spinner.text = 'Claude Flow setup completed';
+    }
+    /**
+     * Setup MCP Tools directory - from /src/cli/commands/claude-setup.ts
+     */
+    async setupMCPToolsDirectory(spinner, repoPath) {
+        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);
+            (0, child_process_1.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
+     */
     async installMcpTools(options) {
         const spinner = (0, ora_1.default)();
         const scriptPath = path.join(__dirname, '../../../../scripts/install-mcp-tools.sh');
-        if (!fs.existsSync(scriptPath)) {
-            console.error(chalk_1.default.red('❌ MCP tools installation script not found'));
-            console.log(chalk_1.default.yellow('Please ensure the script exists at: ' + scriptPath));
-            return;
-        }
         console.log(chalk_1.default.cyan('\n📦 Installing MCP Tools...\n'));
         if (options.tool) {
             // Install specific tool
@@ -141,6 +305,7 @@ Examples:
                     playwright: 'npx claude mcp add playwright npx @playwright/mcp-server',
                     browser: 'npx claude mcp add browser npx @browser/mcp-server',
                     sequentialthinking: 'npm install -g @modelcontextprotocol/server-sequentialthinking',
+                    'claude-flow': 'claude mcp add claude-flow npx claude-flow@alpha mcp start',
                 };
                 const command = installCommands[options.tool];
                 if (command) {
@@ -149,6 +314,7 @@ Examples:
                 }
                 else {
                     spinner.fail(`Unknown tool: ${options.tool}`);
+                    console.log(chalk_1.default.yellow(`Available tools: ${Object.keys(installCommands).join(', ')}`));
                 }
             }
             catch (error) {
@@ -157,25 +323,44 @@ Examples:
             }
         }
         else {
-            // Install all tools using the script
-            console.log(chalk_1.default.gray('Running comprehensive MCP tools installation...'));
-            const install = (0, child_process_1.spawn)('bash', [scriptPath], {
-                stdio: 'inherit',
-                shell: true,
-            });
-            return new Promise((resolve, reject) => {
-                install.on('close', code => {
-                    if (code === 0) {
-                        console.log(chalk_1.default.green('\n✅ All MCP tools installed successfully'));
-                        resolve();
+            // Try to install all tools using the script if it exists
+            if (fs.existsSync(scriptPath)) {
+                console.log(chalk_1.default.gray('Running comprehensive MCP tools installation...'));
+                const install = (0, child_process_1.spawn)('bash', [scriptPath], {
+                    stdio: 'inherit',
+                    shell: true,
+                });
+                return new Promise((resolve, reject) => {
+                    install.on('close', code => {
+                        if (code === 0) {
+                            console.log(chalk_1.default.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_1.default.gray('Installing core MCP tools...'));
+                const coreTools = ['claude-flow', 'sequentialthinking'];
+                for (const tool of coreTools) {
+                    try {
+                        await this.installMcpTools({ tool });
                     }
-                    else {
-                        reject(new Error(`Installation failed with code ${code}`));
+                    catch {
+                        console.log(chalk_1.default.yellow(`⚠️ Could not install ${tool}`));
                     }
-                });
-            });
+                }
+                console.log(chalk_1.default.green('\n✅ Core MCP tools installed'));
+            }
         }
     }
+    /**
+     * Configure Claude Flow agents
+     */
     async configureAgents(options) {
         const spinner = (0, ora_1.default)();
         if (options.list) {
@@ -187,7 +372,7 @@ Examples:
             ? 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 {
             fs.mkdirSync(agentsDir, { recursive: true });
@@ -202,6 +387,9 @@ Examples:
             console.error(error);
         }
     }
+    /**
+     * Validate Claude installation
+     */
     async validateInstallation(options) {
         console.log(chalk_1.default.cyan('\n🔍 Validating Claude Installation...\n'));
         const checks = [
@@ -234,9 +422,12 @@ Examples:
             console.log(chalk_1.default.yellow('\n⚠️ Some checks failed. Run with --fix to attempt repairs.'));
         }
     }
+    /**
+     * Install Chrome extension instructions
+     */
     async installChromeExtension() {
         console.log(chalk_1.default.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_1.default.white('Extension location: ' + extensionDir));
         console.log(chalk_1.default.yellow('\nTo install:'));
@@ -246,17 +437,21 @@ Examples:
         console.log(`4. Select: ${extensionDir}`);
         console.log('\n✅ The extension will then be active!');
     }
+    /**
+     * Setup hardware-adaptive optimizations
+     */
     async setupOptimizations(options) {
         const spinner = (0, ora_1.default)();
         console.log(chalk_1.default.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, '../../../computer-setup/resources/scripts');
             // Check if optimization scripts already exist
             const scriptsExist = fs.existsSync(scriptsDir);
             if (scriptsExist && !options.force) {
-                const { overwrite } = await (await Promise.resolve().then(() => tslib_1.__importStar(require('inquirer')))).default.prompt([
+                const inquirer = await Promise.resolve().then(() => tslib_1.__importStar(require('inquirer')));
+                const { overwrite } = await inquirer.default.prompt([
                     {
                         type: 'confirm',
                         name: 'overwrite',
@@ -336,6 +531,215 @@ Examples:
             throw error;
         }
     }
+    /**
+     * Generate CLAUDE.md configuration
+     */
+    async generateClaudeConfig(repoPath) {
+        const spinner = (0, ora_1.default)('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_1.default.green(`\n✅ CLAUDE.md created at: ${path.join(resolvedPath, 'CLAUDE.md')}`));
+        }
+        catch (error) {
+            spinner.fail('Failed to generate CLAUDE.md');
+            console.error(chalk_1.default.red(error instanceof Error ? error.message : String(error)));
+        }
+    }
+    /**
+     * Generate CLAUDE.md for a specific path
+     */
+    async generateClaudeConfigForPath(spinner, repoPath) {
+        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 Promise.resolve(`${generatorPath}`).then(s => tslib_1.__importStar(require(s)));
+            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
+     */
+    generateBasicClaudeConfig(repoPath) {
+        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
+Claude Flow is configured for enhanced AI coordination.
+Run \`npx claude-flow sparc modes\` to see available modes.
+`;
+    }
+    /**
+     * Setup project template - from /src/cli/commands/claude-setup.ts
+     */
+    async setupProjectTemplate(spinner, repoPath, templateName) {
+        spinner.text = `Applying ${templateName} template...`;
+        const templates = {
+            '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`;
+    }
+    setupTypeScriptTemplate(repoPath) {
+        // 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');
+        }
+    }
+    setupReactTemplate(repoPath) {
+        // 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 });
+        }
+    }
+    setupNodeTemplate(repoPath) {
+        // 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 });
+        }
+    }
+    setupMonorepoTemplate(repoPath) {
+        // 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
+     */
+    async initializeSwarm(spinner, repoPath) {
+        spinner.text = 'Initializing Claude Flow swarm...';
+        try {
+            // Initialize basic swarm configuration
+            (0, child_process_1.execSync)('npx claude-flow@alpha init', {
+                cwd: repoPath,
+                stdio: 'pipe',
+            });
+        }
+        catch {
+            // Swarm init might fail if not properly configured
+            console.log(chalk_1.default.yellow('\n⚠️  Could not initialize swarm automatically.'));
+            console.log(chalk_1.default.yellow('You can initialize manually later with: npx claude-flow init'));
+        }
+        spinner.text = 'Swarm initialization completed';
+    }
+    /**
+     * Validate project setup - from /src/cli/commands/claude-setup.ts
+     */
+    async validateProjectSetup(spinner, repoPath) {
+        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
+     */
     async addOptimizationToShell(homeDir) {
         const shellConfigs = [
             path.join(homeDir, '.zshrc'),
@@ -399,6 +803,9 @@ alias claude-orchestrate='node $HOME/.claude/scripts/orchestrator.js'
             }
         }
     }
+    /**
+     * Install Chrome browser
+     */
     async installChrome() {
         if (process.platform === 'darwin') {
             (0, child_process_1.execSync)('curl -L -o ~/Downloads/googlechrome.dmg "https://dl.google.com/chrome/mac/stable/GGRO/googlechrome.dmg"');
@@ -411,8 +818,11 @@ alias claude-orchestrate='node $HOME/.claude/scripts/orchestrator.js'
             console.log(chalk_1.default.yellow('Chrome installation is only automated for macOS'));
         }
     }
-    async setupClaudeConfig() {
-        const homeDir = process.env.HOME || process.env.USERPROFILE || '';
+    /**
+     * Setup Claude settings.json
+     */
+    async setupClaudeSettings() {
+        const homeDir = process.env['HOME'] || process.env['USERPROFILE'] || '';
         const configPath = path.join(homeDir, '.claude', 'settings.json');
         const config = {
             claudeCodeOptions: {
@@ -435,6 +845,7 @@ alias claude-orchestrate='node $HOME/.claude/scripts/orchestrator.js'
         fs.mkdirSync(path.dirname(configPath), { recursive: true });
         fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
     }
+    // ==================== Helper Methods ====================
     isClaudeInstalled() {
         try {
             (0, child_process_1.execSync)('claude --version', { stdio: 'ignore' });
@@ -460,22 +871,24 @@ alias claude-orchestrate='node $HOME/.claude/scripts/orchestrator.js'
         return true; // Assume installed on other platforms
     }
     claudeDirExists() {
-        const homeDir = process.env.HOME || process.env.USERPROFILE || '';
+        const homeDir = process.env['HOME'] || process.env['USERPROFILE'] || '';
         return fs.existsSync(path.join(homeDir, '.claude'));
     }
     agentsConfigured() {
-        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))
+        if (!fs.existsSync(agentsDir)) {
             return false;
+        }
         const files = fs.readdirSync(agentsDir);
         return files.length > 0;
     }
     mcpServersConfigured() {
-        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))
+        if (!fs.existsSync(settingsPath)) {
             return false;
+        }
         try {
             const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
             return settings.claudeCodeOptions?.enabledMcpjsonServers?.length > 0;
@@ -498,18 +911,61 @@ alias claude-orchestrate='node $HOME/.claude/scripts/orchestrator.js'
                 'hierarchical-coordinator',
                 'mesh-coordinator',
                 'adaptive-coordinator',
+                'collective-intelligence-coordinator',
+                'swarm-memory-manager',
+            ],
+            'Consensus & Distributed': [
+                'byzantine-coordinator',
+                'raft-manager',
+                'gossip-coordinator',
+                'consensus-builder',
+                'crdt-synchronizer',
+                'quorum-manager',
+                'security-manager',
             ],
-            'GitHub Integration': [
+            '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)) {
@@ -517,16 +973,18 @@ alias claude-orchestrate='node $HOME/.claude/scripts/orchestrator.js'
             agents.forEach(agent => console.log(`  • ${agent}`));
             console.log();
         }
+        console.log(chalk_1.default.gray('Total: 54 agents available'));
     }
     getProfileAgents(profile) {
         const profileAgents = {
-            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',
@@ -535,11 +993,13 @@ 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']);
     }
     generateAgentConfig(agentName) {
         return {
@@ -555,16 +1015,59 @@ alias claude-orchestrate='node $HOME/.claude/scripts/orchestrator.js'
             },
         };
     }
+    /**
+     * Display final instructions for project setup
+     */
+    displayProjectFinalInstructions(repoPath, options) {
+        console.log(chalk_1.default.green('\n🎉 Claude Code Setup Complete!'));
+        console.log(chalk_1.default.blue('================================'));
+        console.log(chalk_1.default.yellow('\n📋 What was set up:'));
+        console.log('✅ CLAUDE.md configuration generated');
+        if (!options.skipFlow) {
+            console.log('✅ Claude Flow installed and configured');
+        }
+        if (!options.skipMcp) {
+            console.log('✅ MCP Tools directory created');
+        }
+        console.log('✅ Project structure validated');
+        console.log(chalk_1.default.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 Claude Flow: npx claude-flow sparc modes');
+        }
+        console.log('5. Start coding with optimized Claude Code integration!');
+        console.log(chalk_1.default.yellow('\n📚 Resources:'));
+        console.log('• Claude Flow: https://github.com/ruvnet/claude-flow');
+        console.log('• MCP Documentation: https://modelcontextprotocol.io/docs');
+        console.log('• Wundr Documentation: ./docs/');
+        console.log(chalk_1.default.green('\n✨ Happy coding with Claude!'));
+    }
+    /**
+     * Print next steps after complete setup
+     */
     printNextSteps() {
         console.log(chalk_1.default.cyan('📋 Next Steps:'));
         console.log('1. Configure API keys for MCP tools (if needed)');
         console.log('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"');
     }
 }
 exports.ClaudeSetupCommands = ClaudeSetupCommands;
+/**
+ * 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)
+ */
+function createClaudeSetupCommand() {
+    const program = new commander_1.Command();
+    new ClaudeSetupCommands(program);
+    return program.commands.find(cmd => cmd.name() === 'claude-setup') || program;
+}
 const createClaudeSetupCommands = (program) => new ClaudeSetupCommands(program);
 exports.default = createClaudeSetupCommands;
 //# sourceMappingURL=claude-setup.js.map