claude-flow-novice 2.0.3 → 2.0.4

package/dist/src/mcp/mcp-config-manager.js

@@ -1,1362 +1,1214 @@
-// Bulletproof MCP Configuration Manager
-// Handles Claude Code MCP configuration with comprehensive error handling
-// Automatically detects and fixes broken configurations with rollback capability
-// Provides enhanced user experience and backwards compatibility
-
-import { promises as fs } from 'fs';
-import path from 'path';
-import os from 'os';
-import { execSync, spawn } from 'child_process';
-import { existsSync } from 'fs';
-import { printSuccess, printWarning, printError } from '../cli/utils.js';
-
-export class McpConfigurationManager {
-  constructor(options = {}) {
-    this.localConfigPath = this.findClaudeConfigPath();
-    this.projectConfigPath = path.join(process.cwd(), '.mcp.json');
-    this.verbose = options.verbose || false;
-    this.autoFix = options.autoFix !== false; // Default to true for bulletproof operation
-    this.dryRun = options.dryRun || false;
-    this.backupPaths = new Map();
-    this.operationLog = [];
-    this.errorRecovery = [];
-    this.rollbackStack = [];
-  }
-
-  /**
+// Bulletproof MCP Configuration Manager
+// Handles Claude Code MCP configuration with comprehensive error handling
+// Automatically detects and fixes broken configurations with rollback capability
+// Provides enhanced user experience and backwards compatibility
+import { promises as fs } from "fs";
+import path from "path";
+import os from "os";
+import { execSync, spawn } from "child_process";
+import { existsSync } from "fs";
+export class McpConfigurationManager {
+    /**
    * Find Claude Code configuration path with comprehensive search
-   */
-  findClaudeConfigPath() {
-    const homeDir = os.homedir();
-    const primaryPath = path.join(homeDir, '.claude.json');
-
-    if (existsSync(primaryPath)) {
-      return primaryPath;
-    }
-
-    // Search alternative locations
-    const alternativePaths = [
-      path.join(homeDir, '.config', 'claude.json'),
-      path.join(homeDir, '.claude', 'config.json'),
-      path.join(homeDir, 'AppData', 'Local', 'Claude', 'config.json'), // Windows
-      path.join(homeDir, 'Library', 'Application Support', 'Claude', 'config.json'), // macOS
-    ];
-
-    for (const altPath of alternativePaths) {
-      if (existsSync(altPath)) {
-        this.log(`📍 Found Claude config at alternative location: ${altPath}`);
-        return altPath;
-      }
-    }
-
-    // Return primary path even if it doesn't exist (for creation)
-    return primaryPath;
-  }
-
-  /**
+   */ findClaudeConfigPath() {
+        const homeDir = os.homedir();
+        const primaryPath = path.join(homeDir, '.claude.json');
+        if (existsSync(primaryPath)) {
+            return primaryPath;
+        }
+        // Search alternative locations
+        const alternativePaths = [
+            path.join(homeDir, '.config', 'claude.json'),
+            path.join(homeDir, '.claude', 'config.json'),
+            path.join(homeDir, 'AppData', 'Local', 'Claude', 'config.json'),
+            path.join(homeDir, 'Library', 'Application Support', 'Claude', 'config.json')
+        ];
+        for (const altPath of alternativePaths){
+            if (existsSync(altPath)) {
+                this.log(`📍 Found Claude config at alternative location: ${altPath}`);
+                return altPath;
+            }
+        }
+        // Return primary path even if it doesn't exist (for creation)
+        return primaryPath;
+    }
+    /**
    * Enhanced logging with operation tracking
-   */
-  log(message, level = 'info') {
-    const timestamp = new Date().toISOString();
-    const logEntry = { timestamp, level, message };
-    this.operationLog.push(logEntry);
-
-    if (this.verbose || level === 'error' || level === 'warn') {
-      const prefix = {
-        info: '  ℹ️',
-        warn: '  ⚠️',
-        error: '  ❌',
-        success: '  ✅',
-        debug: '  🔍'
-      }[level] || '  ·';
-
-      console.log(`${prefix} ${message}`);
-    }
-  }
-
-  /**
+   */ log(message, level = 'info') {
+        const timestamp = new Date().toISOString();
+        const logEntry = {
+            timestamp,
+            level,
+            message
+        };
+        this.operationLog.push(logEntry);
+        if (this.verbose || level === 'error' || level === 'warn') {
+            const prefix = {
+                info: '  ℹ️',
+                warn: '  ⚠️',
+                error: '  ❌',
+                success: '  ✅',
+                debug: '  🔍'
+            }[level] || '  ·';
+            console.log(`${prefix} ${message}`);
+        }
+    }
+    /**
    * Add operation to rollback stack
-   */
-  addRollbackOperation(operation) {
-    this.rollbackStack.push({
-      ...operation,
-      timestamp: new Date().toISOString()
-    });
-  }
-
-  /**
+   */ addRollbackOperation(operation) {
+        this.rollbackStack.push({
+            ...operation,
+            timestamp: new Date().toISOString()
+        });
+    }
+    /**
    * Check if Claude Code CLI is available
-   */
-  isClaudeCodeInstalled() {
-    try {
-      execSync('which claude', { stdio: 'ignore' });
-      return true;
-    } catch {
-      try {
-        execSync('claude --version', { stdio: 'ignore' });
-        return true;
-      } catch {
-        return false;
-      }
-    }
-  }
-
-  /**
+   */ isClaudeCodeInstalled() {
+        try {
+            execSync('which claude', {
+                stdio: 'ignore'
+            });
+            return true;
+        } catch  {
+            try {
+                execSync('claude --version', {
+                    stdio: 'ignore'
+                });
+                return true;
+            } catch  {
+                return false;
+            }
+        }
+    }
+    /**
    * Create backup with enhanced error handling
-   */
-  async createConfigBackup(configPath, label = 'auto') {
-    if (!existsSync(configPath)) {
-      this.log(`No config file to backup at: ${configPath}`, 'debug');
-      return null;
-    }
-
-    try {
-      const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
-      const backupPath = `${configPath}.backup-${label}-${timestamp}`;
-
-      if (!this.dryRun) {
-        await fs.copyFile(configPath, backupPath);
-      }
-
-      this.backupPaths.set(configPath, backupPath);
-      this.addRollbackOperation({
-        type: 'restore-backup',
-        source: backupPath,
-        target: configPath,
-        action: async () => {
-          if (existsSync(backupPath)) {
-            await fs.copyFile(backupPath, configPath);
-            this.log(`🔄 Restored ${configPath} from backup`, 'success');
-          }
-        }
-      });
-
-      this.log(`💾 Created backup: ${backupPath}`, 'success');
-      return backupPath;
-    } catch (error) {
-      this.log(`⚠️ Could not create backup: ${error.message}`, 'warn');
-      return null;
-    }
-  }
-
-  /**
+   */ async createConfigBackup(configPath, label = 'auto') {
+        if (!existsSync(configPath)) {
+            this.log(`No config file to backup at: ${configPath}`, 'debug');
+            return null;
+        }
+        try {
+            const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+            const backupPath = `${configPath}.backup-${label}-${timestamp}`;
+            if (!this.dryRun) {
+                await fs.copyFile(configPath, backupPath);
+            }
+            this.backupPaths.set(configPath, backupPath);
+            this.addRollbackOperation({
+                type: 'restore-backup',
+                source: backupPath,
+                target: configPath,
+                action: async ()=>{
+                    if (existsSync(backupPath)) {
+                        await fs.copyFile(backupPath, configPath);
+                        this.log(`🔄 Restored ${configPath} from backup`, 'success');
+                    }
+                }
+            });
+            this.log(`💾 Created backup: ${backupPath}`, 'success');
+            return backupPath;
+        } catch (error) {
+            this.log(`⚠️ Could not create backup: ${error.message}`, 'warn');
+            return null;
+        }
+    }
+    /**
    * Enhanced configuration state detection with comprehensive analysis
-   */
-  async detectConfigurationState() {
-    const state = {
-      hasLocalConfig: false,
-      hasProjectConfig: false,
-      localServers: [],
-      projectServers: [],
-      conflictingServers: [],
-      brokenPaths: [],
-      recommendations: [],
-      claudeCodeInstalled: this.isClaudeCodeInstalled(),
-      configPaths: {
-        local: this.localConfigPath,
-        project: this.projectConfigPath
-      },
-      healthScore: 100,
-      criticalIssues: [],
-      warnings: []
-    };
-
-    try {
-      this.log('🔍 Analyzing MCP configuration state...', 'info');
-
-      // Check local configuration with enhanced validation
-      if (await this.fileExists(this.localConfigPath)) {
-        state.hasLocalConfig = true;
-        const localConfig = await this.readLocalConfig();
-        if (localConfig) {
-          state.localServers = this.extractMcpServers(localConfig);
-          this.log(`📋 Found ${state.localServers.length} local MCP servers`, 'info');
-        } else {
-          state.warnings.push('Local config file exists but is invalid/corrupted');
-          state.healthScore -= 20;
-        }
-      }
-
-      // Check project configuration
-      if (await this.fileExists(this.projectConfigPath)) {
-        state.hasProjectConfig = true;
-        const projectConfig = await this.readProjectConfig();
-        if (projectConfig) {
-          state.projectServers = this.extractMcpServers(projectConfig);
-          this.log(`📋 Found ${state.projectServers.length} project MCP servers`, 'info');
-        } else {
-          state.warnings.push('Project config file exists but is invalid/corrupted');
-          state.healthScore -= 10;
-        }
-      }
-
-      // Enhanced analysis
-      state.conflictingServers = this.findConflictingServers(state.localServers, state.projectServers);
-      state.brokenPaths = await this.findBrokenServerPaths([...state.localServers, ...state.projectServers]);
-      state.recommendations = this.generateRecommendations(state);
-
-      // Calculate health score
-      if (state.conflictingServers.length > 0) {
-        state.healthScore -= (state.conflictingServers.length * 15);
-        state.warnings.push(`${state.conflictingServers.length} conflicting server configurations`);
-      }
-
-      if (state.brokenPaths.length > 0) {
-        state.healthScore -= (state.brokenPaths.length * 25);
-        state.criticalIssues.push(`${state.brokenPaths.length} broken server paths detected`);
-      }
-
-      if (!state.claudeCodeInstalled) {
-        state.healthScore -= 30;
-        state.warnings.push('Claude Code CLI not installed');
-      }
-
-      this.log(`📊 Configuration health score: ${state.healthScore}/100`,
-                state.healthScore >= 80 ? 'success' : state.healthScore >= 60 ? 'warn' : 'error');
-
-      return state;
-    } catch (error) {
-      this.log(`❌ Failed to detect configuration state: ${error.message}`, 'error');
-      throw new Error(`Failed to detect configuration state: ${error.message}`);
-    }
-  }
-
-  /**
+   */ async detectConfigurationState() {
+        const state = {
+            hasLocalConfig: false,
+            hasProjectConfig: false,
+            localServers: [],
+            projectServers: [],
+            conflictingServers: [],
+            brokenPaths: [],
+            recommendations: [],
+            claudeCodeInstalled: this.isClaudeCodeInstalled(),
+            configPaths: {
+                local: this.localConfigPath,
+                project: this.projectConfigPath
+            },
+            healthScore: 100,
+            criticalIssues: [],
+            warnings: []
+        };
+        try {
+            this.log('🔍 Analyzing MCP configuration state...', 'info');
+            // Check local configuration with enhanced validation
+            if (await this.fileExists(this.localConfigPath)) {
+                state.hasLocalConfig = true;
+                const localConfig = await this.readLocalConfig();
+                if (localConfig) {
+                    state.localServers = this.extractMcpServers(localConfig);
+                    this.log(`📋 Found ${state.localServers.length} local MCP servers`, 'info');
+                } else {
+                    state.warnings.push('Local config file exists but is invalid/corrupted');
+                    state.healthScore -= 20;
+                }
+            }
+            // Check project configuration
+            if (await this.fileExists(this.projectConfigPath)) {
+                state.hasProjectConfig = true;
+                const projectConfig = await this.readProjectConfig();
+                if (projectConfig) {
+                    state.projectServers = this.extractMcpServers(projectConfig);
+                    this.log(`📋 Found ${state.projectServers.length} project MCP servers`, 'info');
+                } else {
+                    state.warnings.push('Project config file exists but is invalid/corrupted');
+                    state.healthScore -= 10;
+                }
+            }
+            // Enhanced analysis
+            state.conflictingServers = this.findConflictingServers(state.localServers, state.projectServers);
+            state.brokenPaths = await this.findBrokenServerPaths([
+                ...state.localServers,
+                ...state.projectServers
+            ]);
+            state.recommendations = this.generateRecommendations(state);
+            // Calculate health score
+            if (state.conflictingServers.length > 0) {
+                state.healthScore -= state.conflictingServers.length * 15;
+                state.warnings.push(`${state.conflictingServers.length} conflicting server configurations`);
+            }
+            if (state.brokenPaths.length > 0) {
+                state.healthScore -= state.brokenPaths.length * 25;
+                state.criticalIssues.push(`${state.brokenPaths.length} broken server paths detected`);
+            }
+            if (!state.claudeCodeInstalled) {
+                state.healthScore -= 30;
+                state.warnings.push('Claude Code CLI not installed');
+            }
+            this.log(`📊 Configuration health score: ${state.healthScore}/100`, state.healthScore >= 80 ? 'success' : state.healthScore >= 60 ? 'warn' : 'error');
+            return state;
+        } catch (error) {
+            this.log(`❌ Failed to detect configuration state: ${error.message}`, 'error');
+            throw new Error(`Failed to detect configuration state: ${error.message}`);
+        }
+    }
+    /**
    * Perform pre-initialization audit
-   */
-  async performPreInitAudit() {
-    const state = await this.detectConfigurationState();
-    const audit = {
-      hasIssues: false,
-      autoFixable: [],
-      requiresConfirmation: [],
-      blocking: [],
-      warnings: []
-    };
-
-    // Check for broken local servers
-    for (const brokenServer of state.brokenPaths) {
-      if (brokenServer.serverName === 'claude-flow-novice') {
-        audit.hasIssues = true;
-        audit.autoFixable.push({
-          type: 'remove-broken-local-server',
-          description: `Remove broken local MCP server: ${brokenServer.serverName}`,
-          serverName: brokenServer.serverName,
-          reason: brokenServer.reason,
-          action: () => this.removeLocalServer(brokenServer.serverName)
-        });
-      }
-    }
-
-    // Check for conflicting servers
-    for (const conflict of state.conflictingServers) {
-      if (conflict.serverName === 'claude-flow-novice') {
-        audit.hasIssues = true;
-        audit.requiresConfirmation.push({
-          type: 'conflicting-server',
-          description: `Server '${conflict.serverName}' exists in both local and project configs`,
-          recommendation: 'Remove from local config to use project configuration',
-          action: () => this.removeLocalServer(conflict.serverName)
-        });
-      }
-    }
-
-    // Check if local config takes precedence over project config
-    if (state.hasLocalConfig && state.hasProjectConfig) {
-      const claudeFlowInLocal = state.localServers.some(s => s.name === 'claude-flow-novice');
-      const claudeFlowInProject = state.projectServers.some(s => s.name === 'claude-flow-novice');
-
-      if (claudeFlowInLocal && claudeFlowInProject) {
-        audit.warnings.push({
-          type: 'precedence-warning',
-          description: 'Local MCP config will override project config',
-          recommendation: 'Consider removing from local config for project-specific setup'
-        });
-      }
-    }
-
-    return audit;
-  }
-
-  /**
+   */ async performPreInitAudit() {
+        const state = await this.detectConfigurationState();
+        const audit = {
+            hasIssues: false,
+            autoFixable: [],
+            requiresConfirmation: [],
+            blocking: [],
+            warnings: []
+        };
+        // Check for broken local servers
+        for (const brokenServer of state.brokenPaths){
+            if (brokenServer.serverName === 'claude-flow-novice') {
+                audit.hasIssues = true;
+                audit.autoFixable.push({
+                    type: 'remove-broken-local-server',
+                    description: `Remove broken local MCP server: ${brokenServer.serverName}`,
+                    serverName: brokenServer.serverName,
+                    reason: brokenServer.reason,
+                    action: ()=>this.removeLocalServer(brokenServer.serverName)
+                });
+            }
+        }
+        // Check for conflicting servers
+        for (const conflict of state.conflictingServers){
+            if (conflict.serverName === 'claude-flow-novice') {
+                audit.hasIssues = true;
+                audit.requiresConfirmation.push({
+                    type: 'conflicting-server',
+                    description: `Server '${conflict.serverName}' exists in both local and project configs`,
+                    recommendation: 'Remove from local config to use project configuration',
+                    action: ()=>this.removeLocalServer(conflict.serverName)
+                });
+            }
+        }
+        // Check if local config takes precedence over project config
+        if (state.hasLocalConfig && state.hasProjectConfig) {
+            const claudeFlowInLocal = state.localServers.some((s)=>s.name === 'claude-flow-novice');
+            const claudeFlowInProject = state.projectServers.some((s)=>s.name === 'claude-flow-novice');
+            if (claudeFlowInLocal && claudeFlowInProject) {
+                audit.warnings.push({
+                    type: 'precedence-warning',
+                    description: 'Local MCP config will override project config',
+                    recommendation: 'Consider removing from local config for project-specific setup'
+                });
+            }
+        }
+        return audit;
+    }
+    /**
    * Bulletproof MCP setup with comprehensive error handling and rollback
-   */
-  async executeBulletproofSetup(serverConfig, ux = null) {
-    this.log('🔧 Executing bulletproof MCP setup...', 'info');
-    const startTime = Date.now();
-
-    try {
-      // Phase 1: System validation and pre-audit
-      this.log('🔍 Phase 1: System validation and pre-audit...', 'info');
-      if (ux) ux.displaySetupProgress('pre-audit');
-
-      if (!this.isClaudeCodeInstalled()) {
-        const error = new Error('Claude Code CLI not installed');
-        error.recovery = [
-          'Install Claude Code: npm install -g @anthropic-ai/claude-code',
-          'Verify installation: claude --version',
-          'Re-run setup after installation'
-        ];
-        throw error;
-      }
-
-      const audit = await this.performPreInitAudit();
-      const state = await this.detectConfigurationState();
-
-      // Display comprehensive analysis
-      if (ux && this.verbose) {
-        ux.displayConfigurationAnalysis({ ...state, hasIssues: audit.hasIssues });
-      }
-
-      // Phase 2: Create safety backups
-      this.log('💾 Phase 2: Creating safety backups...', 'info');
-      if (ux) ux.displaySetupProgress('backup');
-
-      if (state.hasLocalConfig) {
-        await this.createConfigBackup(this.localConfigPath, 'pre-bulletproof');
-      }
-      if (state.hasProjectConfig) {
-        await this.createConfigBackup(this.projectConfigPath, 'pre-bulletproof');
-      }
-
-      // Phase 3: Issue remediation
-      if (audit.hasIssues || state.brokenPaths.length > 0) {
-        this.log('🔧 Phase 3: Remediating configuration issues...', 'info');
-        if (ux) ux.displaySetupProgress('cleanup');
-
-        const remediationResult = await this.performAutomatedRemediation(audit, state, ux);
-        if (!remediationResult.success) {
-          throw new Error(`Remediation failed: ${remediationResult.error}`);
-        }
-      } else {
-        this.log('✅ No configuration issues detected', 'success');
-      }
-
-      // Phase 4: Ensure optimal project configuration
-      this.log('⚙️ Phase 4: Ensuring optimal project configuration...', 'info');
-      if (ux) ux.displaySetupProgress('project-config');
-      await this.ensureProjectConfiguration(serverConfig);
-
-      // Phase 5: Comprehensive verification
-      this.log('✅ Phase 5: Comprehensive verification...', 'info');
-      if (ux) ux.displaySetupProgress('verification');
-      const verificationResult = await this.performComprehensiveVerification();
-
-      if (!verificationResult.success) {
-        this.log('⚠️ Verification failed, attempting rollback...', 'warn');
-        await this.performRollback();
-        throw new Error(`Setup verification failed: ${verificationResult.error}`);
-      }
-
-      // Phase 6: Success and cleanup
-      const duration = Date.now() - startTime;
-      this.log(`🎉 Bulletproof MCP setup completed successfully in ${duration}ms`, 'success');
-      if (ux) ux.displaySetupProgress('complete');
-
-      return {
-        success: true,
-        duration,
-        details: {
-          issuesFixed: audit.autoFixable.length + audit.requiresConfirmation.length,
-          backupsCreated: this.backupPaths.size,
-          healthScore: state.healthScore,
-          verificationPassed: verificationResult.success,
-          operationsPerformed: this.operationLog.length
-        },
-        summary: this.generateSetupSummary()
-      };
-
-    } catch (error) {
-      this.log(`❌ Bulletproof setup failed: ${error.message}`, 'error');
-
-      // Enhanced error recovery
-      const recoveryResult = await this.handleSetupFailure(error, ux);
-
-      return {
-        success: false,
-        error: error.message,
-        recovery: recoveryResult,
-        logs: this.operationLog,
-        rollbackAvailable: this.rollbackStack.length > 0
-      };
-    }
-  }
-
-  /**
+   */ async executeBulletproofSetup(serverConfig, ux = null) {
+        this.log('🔧 Executing bulletproof MCP setup...', 'info');
+        const startTime = Date.now();
+        try {
+            // Phase 1: System validation and pre-audit
+            this.log('🔍 Phase 1: System validation and pre-audit...', 'info');
+            if (ux) ux.displaySetupProgress('pre-audit');
+            if (!this.isClaudeCodeInstalled()) {
+                const error = new Error('Claude Code CLI not installed');
+                error.recovery = [
+                    'Install Claude Code: npm install -g @anthropic-ai/claude-code',
+                    'Verify installation: claude --version',
+                    'Re-run setup after installation'
+                ];
+                throw error;
+            }
+            const audit = await this.performPreInitAudit();
+            const state = await this.detectConfigurationState();
+            // Display comprehensive analysis
+            if (ux && this.verbose) {
+                ux.displayConfigurationAnalysis({
+                    ...state,
+                    hasIssues: audit.hasIssues
+                });
+            }
+            // Phase 2: Create safety backups
+            this.log('💾 Phase 2: Creating safety backups...', 'info');
+            if (ux) ux.displaySetupProgress('backup');
+            if (state.hasLocalConfig) {
+                await this.createConfigBackup(this.localConfigPath, 'pre-bulletproof');
+            }
+            if (state.hasProjectConfig) {
+                await this.createConfigBackup(this.projectConfigPath, 'pre-bulletproof');
+            }
+            // Phase 3: Issue remediation
+            if (audit.hasIssues || state.brokenPaths.length > 0) {
+                this.log('🔧 Phase 3: Remediating configuration issues...', 'info');
+                if (ux) ux.displaySetupProgress('cleanup');
+                const remediationResult = await this.performAutomatedRemediation(audit, state, ux);
+                if (!remediationResult.success) {
+                    throw new Error(`Remediation failed: ${remediationResult.error}`);
+                }
+            } else {
+                this.log('✅ No configuration issues detected', 'success');
+            }
+            // Phase 4: Ensure optimal project configuration
+            this.log('⚙️ Phase 4: Ensuring optimal project configuration...', 'info');
+            if (ux) ux.displaySetupProgress('project-config');
+            await this.ensureProjectConfiguration(serverConfig);
+            // Phase 5: Comprehensive verification
+            this.log('✅ Phase 5: Comprehensive verification...', 'info');
+            if (ux) ux.displaySetupProgress('verification');
+            const verificationResult = await this.performComprehensiveVerification();
+            if (!verificationResult.success) {
+                this.log('⚠️ Verification failed, attempting rollback...', 'warn');
+                await this.performRollback();
+                throw new Error(`Setup verification failed: ${verificationResult.error}`);
+            }
+            // Phase 6: Success and cleanup
+            const duration = Date.now() - startTime;
+            this.log(`🎉 Bulletproof MCP setup completed successfully in ${duration}ms`, 'success');
+            if (ux) ux.displaySetupProgress('complete');
+            return {
+                success: true,
+                duration,
+                details: {
+                    issuesFixed: audit.autoFixable.length + audit.requiresConfirmation.length,
+                    backupsCreated: this.backupPaths.size,
+                    healthScore: state.healthScore,
+                    verificationPassed: verificationResult.success,
+                    operationsPerformed: this.operationLog.length
+                },
+                summary: this.generateSetupSummary()
+            };
+        } catch (error) {
+            this.log(`❌ Bulletproof setup failed: ${error.message}`, 'error');
+            // Enhanced error recovery
+            const recoveryResult = await this.handleSetupFailure(error, ux);
+            return {
+                success: false,
+                error: error.message,
+                recovery: recoveryResult,
+                logs: this.operationLog,
+                rollbackAvailable: this.rollbackStack.length > 0
+            };
+        }
+    }
+    /**
    * Ensure project configuration is correct
-   */
-  async ensureProjectConfiguration(serverConfig) {
-    const defaultConfig = {
-      mcpServers: {
-        'claude-flow-novice': {
-          command: 'npx',
-          args: ['claude-flow-novice', 'mcp', 'start'],
-          env: {
-            NODE_ENV: 'production',
-            CLAUDE_FLOW_NOVICE_MODE: 'novice'
-          }
-        }
-      }
-    };
-
-    const configToUse = serverConfig || defaultConfig;
-
-    if (!this.dryRun) {
-      await fs.writeFile(
-        this.projectConfigPath,
-        JSON.stringify(configToUse, null, 2)
-      );
-      this.log('✅ Created/updated .mcp.json configuration');
-    } else {
-      this.log('[DRY RUN] Would create/update .mcp.json configuration');
-    }
-  }
-
-  /**
+   */ async ensureProjectConfiguration(serverConfig) {
+        const defaultConfig = {
+            mcpServers: {
+                'claude-flow-novice': {
+                    command: 'npx',
+                    args: [
+                        'claude-flow-novice',
+                        'mcp',
+                        'start'
+                    ],
+                    env: {
+                        NODE_ENV: 'production',
+                        CLAUDE_FLOW_NOVICE_MODE: 'novice'
+                    }
+                }
+            }
+        };
+        const configToUse = serverConfig || defaultConfig;
+        if (!this.dryRun) {
+            await fs.writeFile(this.projectConfigPath, JSON.stringify(configToUse, null, 2));
+            this.log('✅ Created/updated .mcp.json configuration');
+        } else {
+            this.log('[DRY RUN] Would create/update .mcp.json configuration');
+        }
+    }
+    /**
    * Remove a server from local configuration
-   */
-  async removeLocalServer(serverName) {
-    try {
-      // Use Claude CLI to remove server cleanly
-      execSync(`claude mcp remove ${serverName} -s local`, {
-        stdio: this.verbose ? 'inherit' : 'pipe'
-      });
-      this.log(`✅ Removed ${serverName} from local configuration`);
-    } catch (error) {
-      // Fallback: manual removal
-      await this.manuallyRemoveFromLocalConfig(serverName);
-    }
-  }
-
-  /**
+   */ async removeLocalServer(serverName) {
+        try {
+            // Use Claude CLI to remove server cleanly
+            execSync(`claude mcp remove ${serverName} -s local`, {
+                stdio: this.verbose ? 'inherit' : 'pipe'
+            });
+            this.log(`✅ Removed ${serverName} from local configuration`);
+        } catch (error) {
+            // Fallback: manual removal
+            await this.manuallyRemoveFromLocalConfig(serverName);
+        }
+    }
+    /**
    * Manually remove server from local config (fallback)
-   */
-  async manuallyRemoveFromLocalConfig(serverName) {
-    try {
-      const localConfig = await this.readLocalConfig();
-      if (localConfig?.mcpServers?.[serverName]) {
-        delete localConfig.mcpServers[serverName];
-
-        // Create backup
-        await this.createConfigBackup(this.localConfigPath);
-
-        // Write updated config
-        await fs.writeFile(
-          this.localConfigPath,
-          JSON.stringify(localConfig, null, 2)
-        );
-
-        this.log(`✅ Manually removed ${serverName} from local configuration`);
-      }
-    } catch (error) {
-      throw new Error(`Failed to manually remove server: ${error.message}`);
-    }
-  }
-
-  /**
+   */ async manuallyRemoveFromLocalConfig(serverName) {
+        try {
+            const localConfig = await this.readLocalConfig();
+            if (localConfig?.mcpServers?.[serverName]) {
+                delete localConfig.mcpServers[serverName];
+                // Create backup
+                await this.createConfigBackup(this.localConfigPath);
+                // Write updated config
+                await fs.writeFile(this.localConfigPath, JSON.stringify(localConfig, null, 2));
+                this.log(`✅ Manually removed ${serverName} from local configuration`);
+            }
+        } catch (error) {
+            throw new Error(`Failed to manually remove server: ${error.message}`);
+        }
+    }
+    /**
    * Verify the setup is working
-   */
-  async verifySetup() {
-    try {
-      // Check if Claude CLI can list servers
-      const output = execSync('claude mcp list', {
-        encoding: 'utf8',
-        stdio: 'pipe'
-      });
-
-      // Check if our server is properly configured
-      if (output.includes('claude-flow-novice')) {
-        this.log('✅ MCP server verification successful');
-      } else {
-        this.log('⚠️  MCP server not visible in claude mcp list');
-      }
-    } catch (error) {
-      this.log('⚠️  Could not verify MCP setup (Claude CLI may not be installed)');
-    }
-  }
-
-  /**
+   */ async verifySetup() {
+        try {
+            // Check if Claude CLI can list servers
+            const output = execSync('claude mcp list', {
+                encoding: 'utf8',
+                stdio: 'pipe'
+            });
+            // Check if our server is properly configured
+            if (output.includes('claude-flow-novice')) {
+                this.log('✅ MCP server verification successful');
+            } else {
+                this.log('⚠️  MCP server not visible in claude mcp list');
+            }
+        } catch (error) {
+            this.log('⚠️  Could not verify MCP setup (Claude CLI may not be installed)');
+        }
+    }
+    /**
    * Create configuration backup
-   */
-  async createConfigBackup(configPath) {
-    const backupPath = `${configPath}.backup-${Date.now()}`;
-    try {
-      await fs.copyFile(configPath, backupPath);
-      this.log(`💾 Created backup: ${backupPath}`);
-    } catch (error) {
-      this.log(`⚠️  Could not create backup: ${error.message}`);
-    }
-  }
-
-  /**
+   */ async createConfigBackup(configPath) {
+        const backupPath = `${configPath}.backup-${Date.now()}`;
+        try {
+            await fs.copyFile(configPath, backupPath);
+            this.log(`💾 Created backup: ${backupPath}`);
+        } catch (error) {
+            this.log(`⚠️  Could not create backup: ${error.message}`);
+        }
+    }
+    /**
    * Helper methods
-   */
-  async fileExists(filePath) {
-    try {
-      await fs.access(filePath);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-
-  async readLocalConfig() {
-    try {
-      const content = await fs.readFile(this.localConfigPath, 'utf8');
-      return JSON.parse(content);
-    } catch {
-      return null;
-    }
-  }
-
-  async readProjectConfig() {
-    try {
-      const content = await fs.readFile(this.projectConfigPath, 'utf8');
-      return JSON.parse(content);
-    } catch {
-      return null;
-    }
-  }
-
-  extractMcpServers(config) {
-    if (!config?.mcpServers) return [];
-
-    return Object.entries(config.mcpServers).map(([name, serverConfig]) => ({
-      name,
-      ...serverConfig
-    }));
-  }
-
-  findConflictingServers(localServers, projectServers) {
-    const conflicts = [];
-    const localNames = new Set(localServers.map(s => s.name));
-
-    for (const projectServer of projectServers) {
-      if (localNames.has(projectServer.name)) {
-        conflicts.push({
-          serverName: projectServer.name,
-          localConfig: localServers.find(s => s.name === projectServer.name),
-          projectConfig: projectServer
-        });
-      }
-    }
-
-    return conflicts;
-  }
-
-  /**
+   */ async fileExists(filePath) {
+        try {
+            await fs.access(filePath);
+            return true;
+        } catch  {
+            return false;
+        }
+    }
+    async readLocalConfig() {
+        try {
+            const content = await fs.readFile(this.localConfigPath, 'utf8');
+            return JSON.parse(content);
+        } catch  {
+            return null;
+        }
+    }
+    async readProjectConfig() {
+        try {
+            const content = await fs.readFile(this.projectConfigPath, 'utf8');
+            return JSON.parse(content);
+        } catch  {
+            return null;
+        }
+    }
+    extractMcpServers(config) {
+        if (!config?.mcpServers) return [];
+        return Object.entries(config.mcpServers).map(([name, serverConfig])=>({
+                name,
+                ...serverConfig
+            }));
+    }
+    findConflictingServers(localServers, projectServers) {
+        const conflicts = [];
+        const localNames = new Set(localServers.map((s)=>s.name));
+        for (const projectServer of projectServers){
+            if (localNames.has(projectServer.name)) {
+                conflicts.push({
+                    serverName: projectServer.name,
+                    localConfig: localServers.find((s)=>s.name === projectServer.name),
+                    projectConfig: projectServer
+                });
+            }
+        }
+        return conflicts;
+    }
+    /**
    * Enhanced broken path detection with comprehensive validation
-   */
-  async findBrokenServerPaths(servers) {
-    const broken = [];
-    this.log(`🔍 Checking ${servers.length} servers for broken paths...`, 'debug');
-
-    for (const server of servers) {
-      const issues = await this.checkServerPath(server);
-      if (issues.length > 0) {
-        broken.push({
-          serverName: server.name,
-          command: server.command,
-          args: server.args,
-          issues,
-          severity: this.calculateIssueSeverity(issues)
-        });
-        this.log(`🔍 Found issues with '${server.name}': ${issues.join(', ')}`, 'warn');
-      }
-    }
-
-    return broken;
-  }
-
-  /**
+   */ async findBrokenServerPaths(servers) {
+        const broken = [];
+        this.log(`🔍 Checking ${servers.length} servers for broken paths...`, 'debug');
+        for (const server of servers){
+            const issues = await this.checkServerPath(server);
+            if (issues.length > 0) {
+                broken.push({
+                    serverName: server.name,
+                    command: server.command,
+                    args: server.args,
+                    issues,
+                    severity: this.calculateIssueSeverity(issues)
+                });
+                this.log(`🔍 Found issues with '${server.name}': ${issues.join(', ')}`, 'warn');
+            }
+        }
+        return broken;
+    }
+    /**
    * Comprehensive server path validation
-   */
-  async checkServerPath(server) {
-    const issues = [];
-
-    // Check for .claude-flow-novice directory references (common broken pattern)
-    if (server.command && server.command.includes('.claude-flow-novice')) {
-      issues.push('Command points to non-existent .claude-flow-novice directory');
-    }
-
-    if (server.args && server.args.some(arg => arg.includes('.claude-flow-novice'))) {
-      issues.push('Arguments reference non-existent .claude-flow-novice directory');
-    }
-
-    // Check if command executable exists (when not using npx)
-    if (server.command && server.command !== 'npx' && server.command !== 'node') {
-      try {
-        execSync(`which ${server.command}`, { stdio: 'ignore' });
-      } catch {
-        issues.push(`Command '${server.command}' not found in PATH`);
-      }
-    }
-
-    // Check if node script files exist
-    if (server.command === 'node' && server.args && server.args[0]) {
-      const scriptPath = path.resolve(server.args[0]);
-      if (!existsSync(scriptPath)) {
-        issues.push(`Script file '${server.args[0]}' does not exist`);
-      }
-    }
-
-    // Check for invalid configuration patterns
-    if (!server.command) {
-      issues.push('Missing command field');
-    }
-
-    if (server.command === 'node' && (!server.args || server.args.length === 0)) {
-      issues.push('Node command specified but no script path provided');
-    }
-
-    // Check for outdated patterns
-    if (server.name === 'claude-flow-novice' && server.command === 'node') {
-      issues.push('Using outdated node-based configuration (should use npx)');
-    }
-
-    return issues;
-  }
-
-  /**
+   */ async checkServerPath(server) {
+        const issues = [];
+        // Check for .claude-flow-novice directory references (common broken pattern)
+        if (server.command && server.command.includes('.claude-flow-novice')) {
+            issues.push('Command points to non-existent .claude-flow-novice directory');
+        }
+        if (server.args && server.args.some((arg)=>arg.includes('.claude-flow-novice'))) {
+            issues.push('Arguments reference non-existent .claude-flow-novice directory');
+        }
+        // Check if command executable exists (when not using npx)
+        if (server.command && server.command !== 'npx' && server.command !== 'node') {
+            try {
+                execSync(`which ${server.command}`, {
+                    stdio: 'ignore'
+                });
+            } catch  {
+                issues.push(`Command '${server.command}' not found in PATH`);
+            }
+        }
+        // Check if node script files exist
+        if (server.command === 'node' && server.args && server.args[0]) {
+            const scriptPath = path.resolve(server.args[0]);
+            if (!existsSync(scriptPath)) {
+                issues.push(`Script file '${server.args[0]}' does not exist`);
+            }
+        }
+        // Check for invalid configuration patterns
+        if (!server.command) {
+            issues.push('Missing command field');
+        }
+        if (server.command === 'node' && (!server.args || server.args.length === 0)) {
+            issues.push('Node command specified but no script path provided');
+        }
+        // Check for outdated patterns
+        if (server.name === 'claude-flow-novice' && server.command === 'node') {
+            issues.push('Using outdated node-based configuration (should use npx)');
+        }
+        return issues;
+    }
+    /**
    * Calculate issue severity for prioritization
-   */
-  calculateIssueSeverity(issues) {
-    let severity = 'low';
-
-    for (const issue of issues) {
-      if (issue.includes('not found') || issue.includes('does not exist')) {
-        severity = 'critical';
-        break;
-      } else if (issue.includes('.claude-flow-novice') || issue.includes('outdated')) {
-        severity = 'high';
-      } else if (severity === 'low') {
-        severity = 'medium';
-      }
-    }
-
-    return severity;
-  }
-
-  generateRecommendations(state) {
-    const recommendations = [];
-
-    if (state.brokenPaths.length > 0) {
-      recommendations.push({
-        type: 'fix-broken-paths',
-        priority: 'high',
-        description: 'Remove broken MCP server configurations',
-        action: 'Run with --auto-fix to automatically clean up'
-      });
-    }
-
-    if (state.conflictingServers.length > 0) {
-      recommendations.push({
-        type: 'resolve-conflicts',
-        priority: 'medium',
-        description: 'Resolve configuration conflicts between local and project scopes',
-        action: 'Remove from local config to use project-specific settings'
-      });
-    }
-
-    return recommendations;
-  }
-
-  /**
+   */ calculateIssueSeverity(issues) {
+        let severity = 'low';
+        for (const issue of issues){
+            if (issue.includes('not found') || issue.includes('does not exist')) {
+                severity = 'critical';
+                break;
+            } else if (issue.includes('.claude-flow-novice') || issue.includes('outdated')) {
+                severity = 'high';
+            } else if (severity === 'low') {
+                severity = 'medium';
+            }
+        }
+        return severity;
+    }
+    generateRecommendations(state) {
+        const recommendations = [];
+        if (state.brokenPaths.length > 0) {
+            recommendations.push({
+                type: 'fix-broken-paths',
+                priority: 'high',
+                description: 'Remove broken MCP server configurations',
+                action: 'Run with --auto-fix to automatically clean up'
+            });
+        }
+        if (state.conflictingServers.length > 0) {
+            recommendations.push({
+                type: 'resolve-conflicts',
+                priority: 'medium',
+                description: 'Resolve configuration conflicts between local and project scopes',
+                action: 'Remove from local config to use project-specific settings'
+            });
+        }
+        return recommendations;
+    }
+    /**
    * Perform automated remediation of issues
-   */
-  async performAutomatedRemediation(audit, state, ux) {
-    const remediationResults = [];
-
-    try {
-      // Fix critical issues first (broken paths)
-      for (const brokenServer of state.brokenPaths) {
-        if (brokenServer.severity === 'critical') {
-          const result = await this.fixBrokenServer(brokenServer);
-          remediationResults.push(result);
-        }
-      }
-
-      // Auto-fix identified issues
-      for (const fix of audit.autoFixable) {
-        try {
-          if (!this.dryRun) {
-            await fix.action();
-            remediationResults.push({ success: true, description: fix.description });
-            this.log(`✅ Fixed: ${fix.description}`, 'success');
-          } else {
-            this.log(`[DRY RUN] Would fix: ${fix.description}`, 'info');
-          }
-        } catch (error) {
-          const failureResult = { success: false, description: fix.description, error: error.message };
-          remediationResults.push(failureResult);
-          this.log(`❌ Failed to fix: ${fix.description} - ${error.message}`, 'error');
-        }
-      }
-
-      // Handle issues requiring confirmation
-      for (const fix of audit.requiresConfirmation) {
-        if (this.autoFix) {
-          try {
-            if (!this.dryRun) {
-              await fix.action();
-              remediationResults.push({ success: true, description: fix.description });
-              this.log(`✅ Auto-fixed: ${fix.description}`, 'success');
-            }
-          } catch (error) {
-            remediationResults.push({ success: false, description: fix.description, error: error.message });
-            this.log(`❌ Failed to auto-fix: ${fix.description} - ${error.message}`, 'error');
-          }
-        } else if (ux) {
-          const confirmed = await ux.promptForConfirmation(fix.description, true);
-          if (confirmed && !this.dryRun) {
-            await fix.action();
-            remediationResults.push({ success: true, description: fix.description });
-            this.log(`✅ User-confirmed fix: ${fix.description}`, 'success');
-          }
-        }
-      }
-
-      const successCount = remediationResults.filter(r => r.success).length;
-      const failureCount = remediationResults.filter(r => !r.success).length;
-
-      return {
-        success: failureCount === 0,
-        successCount,
-        failureCount,
-        results: remediationResults
-      };
-
-    } catch (error) {
-      return {
-        success: false,
-        error: error.message,
-        results: remediationResults
-      };
-    }
-  }
-
-  /**
+   */ async performAutomatedRemediation(audit, state, ux) {
+        const remediationResults = [];
+        try {
+            // Fix critical issues first (broken paths)
+            for (const brokenServer of state.brokenPaths){
+                if (brokenServer.severity === 'critical') {
+                    const result = await this.fixBrokenServer(brokenServer);
+                    remediationResults.push(result);
+                }
+            }
+            // Auto-fix identified issues
+            for (const fix of audit.autoFixable){
+                try {
+                    if (!this.dryRun) {
+                        await fix.action();
+                        remediationResults.push({
+                            success: true,
+                            description: fix.description
+                        });
+                        this.log(`✅ Fixed: ${fix.description}`, 'success');
+                    } else {
+                        this.log(`[DRY RUN] Would fix: ${fix.description}`, 'info');
+                    }
+                } catch (error) {
+                    const failureResult = {
+                        success: false,
+                        description: fix.description,
+                        error: error.message
+                    };
+                    remediationResults.push(failureResult);
+                    this.log(`❌ Failed to fix: ${fix.description} - ${error.message}`, 'error');
+                }
+            }
+            // Handle issues requiring confirmation
+            for (const fix of audit.requiresConfirmation){
+                if (this.autoFix) {
+                    try {
+                        if (!this.dryRun) {
+                            await fix.action();
+                            remediationResults.push({
+                                success: true,
+                                description: fix.description
+                            });
+                            this.log(`✅ Auto-fixed: ${fix.description}`, 'success');
+                        }
+                    } catch (error) {
+                        remediationResults.push({
+                            success: false,
+                            description: fix.description,
+                            error: error.message
+                        });
+                        this.log(`❌ Failed to auto-fix: ${fix.description} - ${error.message}`, 'error');
+                    }
+                } else if (ux) {
+                    const confirmed = await ux.promptForConfirmation(fix.description, true);
+                    if (confirmed && !this.dryRun) {
+                        await fix.action();
+                        remediationResults.push({
+                            success: true,
+                            description: fix.description
+                        });
+                        this.log(`✅ User-confirmed fix: ${fix.description}`, 'success');
+                    }
+                }
+            }
+            const successCount = remediationResults.filter((r)=>r.success).length;
+            const failureCount = remediationResults.filter((r)=>!r.success).length;
+            return {
+                success: failureCount === 0,
+                successCount,
+                failureCount,
+                results: remediationResults
+            };
+        } catch (error) {
+            return {
+                success: false,
+                error: error.message,
+                results: remediationResults
+            };
+        }
+    }
+    /**
    * Fix broken server configuration
-   */
-  async fixBrokenServer(brokenServer) {
-    const { serverName, issues, severity } = brokenServer;
-
-    try {
-      if (serverName === 'claude-flow-novice') {
-        // Remove broken local configuration
-        await this.removeLocalServer(serverName);
-        return {
-          success: true,
-          description: `Removed broken claude-flow-novice configuration`,
-          action: 'removed-broken-local'
-        };
-      } else {
-        // For other servers, just remove if critically broken
-        if (severity === 'critical') {
-          await this.removeLocalServer(serverName);
-          return {
-            success: true,
-            description: `Removed critically broken server: ${serverName}`,
-            action: 'removed-broken-server'
-          };
-        }
-      }
-
-      return { success: true, description: `Server ${serverName} issues noted but not critical` };
-    } catch (error) {
-      return {
-        success: false,
-        description: `Failed to fix server ${serverName}`,
-        error: error.message
-      };
-    }
-  }
-
-  /**
+   */ async fixBrokenServer(brokenServer) {
+        const { serverName, issues, severity } = brokenServer;
+        try {
+            if (serverName === 'claude-flow-novice') {
+                // Remove broken local configuration
+                await this.removeLocalServer(serverName);
+                return {
+                    success: true,
+                    description: `Removed broken claude-flow-novice configuration`,
+                    action: 'removed-broken-local'
+                };
+            } else {
+                // For other servers, just remove if critically broken
+                if (severity === 'critical') {
+                    await this.removeLocalServer(serverName);
+                    return {
+                        success: true,
+                        description: `Removed critically broken server: ${serverName}`,
+                        action: 'removed-broken-server'
+                    };
+                }
+            }
+            return {
+                success: true,
+                description: `Server ${serverName} issues noted but not critical`
+            };
+        } catch (error) {
+            return {
+                success: false,
+                description: `Failed to fix server ${serverName}`,
+                error: error.message
+            };
+        }
+    }
+    /**
    * Comprehensive verification with detailed testing
-   */
-  async performComprehensiveVerification() {
-    const verificationResults = {
-      success: true,
-      tests: [],
-      warnings: [],
-      errors: []
-    };
-
-    try {
-      this.log('🧪 Running comprehensive verification tests...', 'info');
-
-      // Test 1: Claude CLI availability
-      const cliTest = await this.testClaudeCli();
-      verificationResults.tests.push(cliTest);
-      if (!cliTest.passed) {
-        verificationResults.success = false;
-        verificationResults.errors.push('Claude CLI not available');
-      }
-
-      // Test 2: MCP server listing
-      if (cliTest.passed) {
-        const listTest = await this.testMcpListing();
-        verificationResults.tests.push(listTest);
-        if (!listTest.passed) {
-          verificationResults.warnings.push('MCP server listing issues detected');
-        }
-      }
-
-      // Test 3: Project configuration validation
-      const configTest = await this.testProjectConfiguration();
-      verificationResults.tests.push(configTest);
-      if (!configTest.passed) {
-        verificationResults.success = false;
-        verificationResults.errors.push('Project configuration invalid');
-      }
-
-      // Test 4: Connection test (if possible)
-      if (cliTest.passed && !this.dryRun) {
-        const connectionTest = await this.testMcpConnection();
-        verificationResults.tests.push(connectionTest);
-        if (!connectionTest.passed) {
-          verificationResults.warnings.push('MCP connection test failed');
-        }
-      }
-
-      // Test 5: File permissions and accessibility
-      const permissionTest = await this.testFilePermissions();
-      verificationResults.tests.push(permissionTest);
-      if (!permissionTest.passed) {
-        verificationResults.warnings.push('File permission issues detected');
-      }
-
-      const passedTests = verificationResults.tests.filter(t => t.passed).length;
-      const totalTests = verificationResults.tests.length;
-
-      this.log(`📊 Verification complete: ${passedTests}/${totalTests} tests passed`,
-                passedTests === totalTests ? 'success' : 'warn');
-
-      return verificationResults;
-
-    } catch (error) {
-      verificationResults.success = false;
-      verificationResults.errors.push(`Verification failed: ${error.message}`);
-      this.log(`❌ Verification failed: ${error.message}`, 'error');
-      return verificationResults;
-    }
-  }
-
-  async testClaudeCli() {
-    try {
-      const output = execSync('claude --version', { encoding: 'utf8', stdio: 'pipe' });
-      return {
-        name: 'Claude CLI Availability',
-        passed: true,
-        details: `Version: ${output.trim()}`
-      };
-    } catch (error) {
-      return {
-        name: 'Claude CLI Availability',
-        passed: false,
-        details: `Not available: ${error.message}`
-      };
-    }
-  }
-
-  async testMcpListing() {
-    try {
-      const output = execSync('claude mcp list', { encoding: 'utf8', stdio: 'pipe', timeout: 10000 });
-      const hasClaudeFlowNovice = output.includes('claude-flow-novice');
-      return {
-        name: 'MCP Server Listing',
-        passed: hasClaudeFlowNovice,
-        details: hasClaudeFlowNovice ? 'claude-flow-novice found in listing' : 'claude-flow-novice not in listing'
-      };
-    } catch (error) {
-      return {
-        name: 'MCP Server Listing',
-        passed: false,
-        details: `Failed to list servers: ${error.message}`
-      };
-    }
-  }
-
-  async testProjectConfiguration() {
-    try {
-      if (!existsSync(this.projectConfigPath)) {
-        return {
-          name: 'Project Configuration',
-          passed: false,
-          details: 'Project .mcp.json file does not exist'
-        };
-      }
-
-      const config = await this.readProjectConfig();
-      if (!config || !config.mcpServers || !config.mcpServers['claude-flow-novice']) {
-        return {
-          name: 'Project Configuration',
-          passed: false,
-          details: 'claude-flow-novice not properly configured in project config'
-        };
-      }
-
-      return {
-        name: 'Project Configuration',
-        passed: true,
-        details: 'Project configuration valid'
-      };
-    } catch (error) {
-      return {
-        name: 'Project Configuration',
-        passed: false,
-        details: `Configuration test failed: ${error.message}`
-      };
-    }
-  }
-
-  async testMcpConnection() {
-    try {
-      const result = await this.runCommandWithTimeout('claude', ['mcp', 'list'], 5000);
-      const connected = result.success && result.stdout.includes('✓ Connected');
-      return {
-        name: 'MCP Connection Test',
-        passed: connected,
-        details: connected ? 'Connection successful' : 'Connection test inconclusive'
-      };
-    } catch (error) {
-      return {
-        name: 'MCP Connection Test',
-        passed: false,
-        details: `Connection test failed: ${error.message}`
-      };
-    }
-  }
-
-  async testFilePermissions() {
-    const tests = [];
-
-    // Test local config permissions
-    try {
-      if (existsSync(this.localConfigPath)) {
-        await fs.access(this.localConfigPath, fs.constants.R_OK | fs.constants.W_OK);
-        tests.push({ file: 'local config', accessible: true });
-      }
-    } catch {
-      tests.push({ file: 'local config', accessible: false });
-    }
-
-    // Test project config permissions
-    try {
-      if (existsSync(this.projectConfigPath)) {
-        await fs.access(this.projectConfigPath, fs.constants.R_OK | fs.constants.W_OK);
-        tests.push({ file: 'project config', accessible: true });
-      }
-    } catch {
-      tests.push({ file: 'project config', accessible: false });
-    }
-
-    const allAccessible = tests.every(t => t.accessible);
-    return {
-      name: 'File Permissions',
-      passed: allAccessible,
-      details: `${tests.filter(t => t.accessible).length}/${tests.length} files accessible`
-    };
-  }
-
-  /**
+   */ async performComprehensiveVerification() {
+        const verificationResults = {
+            success: true,
+            tests: [],
+            warnings: [],
+            errors: []
+        };
+        try {
+            this.log('🧪 Running comprehensive verification tests...', 'info');
+            // Test 1: Claude CLI availability
+            const cliTest = await this.testClaudeCli();
+            verificationResults.tests.push(cliTest);
+            if (!cliTest.passed) {
+                verificationResults.success = false;
+                verificationResults.errors.push('Claude CLI not available');
+            }
+            // Test 2: MCP server listing
+            if (cliTest.passed) {
+                const listTest = await this.testMcpListing();
+                verificationResults.tests.push(listTest);
+                if (!listTest.passed) {
+                    verificationResults.warnings.push('MCP server listing issues detected');
+                }
+            }
+            // Test 3: Project configuration validation
+            const configTest = await this.testProjectConfiguration();
+            verificationResults.tests.push(configTest);
+            if (!configTest.passed) {
+                verificationResults.success = false;
+                verificationResults.errors.push('Project configuration invalid');
+            }
+            // Test 4: Connection test (if possible)
+            if (cliTest.passed && !this.dryRun) {
+                const connectionTest = await this.testMcpConnection();
+                verificationResults.tests.push(connectionTest);
+                if (!connectionTest.passed) {
+                    verificationResults.warnings.push('MCP connection test failed');
+                }
+            }
+            // Test 5: File permissions and accessibility
+            const permissionTest = await this.testFilePermissions();
+            verificationResults.tests.push(permissionTest);
+            if (!permissionTest.passed) {
+                verificationResults.warnings.push('File permission issues detected');
+            }
+            const passedTests = verificationResults.tests.filter((t)=>t.passed).length;
+            const totalTests = verificationResults.tests.length;
+            this.log(`📊 Verification complete: ${passedTests}/${totalTests} tests passed`, passedTests === totalTests ? 'success' : 'warn');
+            return verificationResults;
+        } catch (error) {
+            verificationResults.success = false;
+            verificationResults.errors.push(`Verification failed: ${error.message}`);
+            this.log(`❌ Verification failed: ${error.message}`, 'error');
+            return verificationResults;
+        }
+    }
+    async testClaudeCli() {
+        try {
+            const output = execSync('claude --version', {
+                encoding: 'utf8',
+                stdio: 'pipe'
+            });
+            return {
+                name: 'Claude CLI Availability',
+                passed: true,
+                details: `Version: ${output.trim()}`
+            };
+        } catch (error) {
+            return {
+                name: 'Claude CLI Availability',
+                passed: false,
+                details: `Not available: ${error.message}`
+            };
+        }
+    }
+    async testMcpListing() {
+        try {
+            const output = execSync('claude mcp list', {
+                encoding: 'utf8',
+                stdio: 'pipe',
+                timeout: 10000
+            });
+            const hasClaudeFlowNovice = output.includes('claude-flow-novice');
+            return {
+                name: 'MCP Server Listing',
+                passed: hasClaudeFlowNovice,
+                details: hasClaudeFlowNovice ? 'claude-flow-novice found in listing' : 'claude-flow-novice not in listing'
+            };
+        } catch (error) {
+            return {
+                name: 'MCP Server Listing',
+                passed: false,
+                details: `Failed to list servers: ${error.message}`
+            };
+        }
+    }
+    async testProjectConfiguration() {
+        try {
+            if (!existsSync(this.projectConfigPath)) {
+                return {
+                    name: 'Project Configuration',
+                    passed: false,
+                    details: 'Project .mcp.json file does not exist'
+                };
+            }
+            const config = await this.readProjectConfig();
+            if (!config || !config.mcpServers || !config.mcpServers['claude-flow-novice']) {
+                return {
+                    name: 'Project Configuration',
+                    passed: false,
+                    details: 'claude-flow-novice not properly configured in project config'
+                };
+            }
+            return {
+                name: 'Project Configuration',
+                passed: true,
+                details: 'Project configuration valid'
+            };
+        } catch (error) {
+            return {
+                name: 'Project Configuration',
+                passed: false,
+                details: `Configuration test failed: ${error.message}`
+            };
+        }
+    }
+    async testMcpConnection() {
+        try {
+            const result = await this.runCommandWithTimeout('claude', [
+                'mcp',
+                'list'
+            ], 5000);
+            const connected = result.success && result.stdout.includes('✓ Connected');
+            return {
+                name: 'MCP Connection Test',
+                passed: connected,
+                details: connected ? 'Connection successful' : 'Connection test inconclusive'
+            };
+        } catch (error) {
+            return {
+                name: 'MCP Connection Test',
+                passed: false,
+                details: `Connection test failed: ${error.message}`
+            };
+        }
+    }
+    async testFilePermissions() {
+        const tests = [];
+        // Test local config permissions
+        try {
+            if (existsSync(this.localConfigPath)) {
+                await fs.access(this.localConfigPath, fs.constants.R_OK | fs.constants.W_OK);
+                tests.push({
+                    file: 'local config',
+                    accessible: true
+                });
+            }
+        } catch  {
+            tests.push({
+                file: 'local config',
+                accessible: false
+            });
+        }
+        // Test project config permissions
+        try {
+            if (existsSync(this.projectConfigPath)) {
+                await fs.access(this.projectConfigPath, fs.constants.R_OK | fs.constants.W_OK);
+                tests.push({
+                    file: 'project config',
+                    accessible: true
+                });
+            }
+        } catch  {
+            tests.push({
+                file: 'project config',
+                accessible: false
+            });
+        }
+        const allAccessible = tests.every((t)=>t.accessible);
+        return {
+            name: 'File Permissions',
+            passed: allAccessible,
+            details: `${tests.filter((t)=>t.accessible).length}/${tests.length} files accessible`
+        };
+    }
+    /**
    * Run command with timeout
-   */
-  runCommandWithTimeout(command, args, timeout = 30000) {
-    return new Promise((resolve, reject) => {
-      const child = spawn(command, args, { stdio: 'pipe' });
-      let stdout = '';
-      let stderr = '';
-
-      const timer = setTimeout(() => {
-        child.kill('SIGTERM');
-        reject(new Error(`Command timed out after ${timeout}ms`));
-      }, timeout);
-
-      child.stdout.on('data', (data) => {
-        stdout += data.toString();
-      });
-
-      child.stderr.on('data', (data) => {
-        stderr += data.toString();
-      });
-
-      child.on('close', (code) => {
-        clearTimeout(timer);
-        resolve({
-          success: code === 0,
-          code,
-          stdout,
-          stderr
-        });
-      });
-
-      child.on('error', (error) => {
-        clearTimeout(timer);
-        reject(error);
-      });
-    });
-  }
-
-  /**
+   */ runCommandWithTimeout(command, args, timeout = 30000) {
+        return new Promise((resolve, reject)=>{
+            const child = spawn(command, args, {
+                stdio: 'pipe'
+            });
+            let stdout = '';
+            let stderr = '';
+            const timer = setTimeout(()=>{
+                child.kill('SIGTERM');
+                reject(new Error(`Command timed out after ${timeout}ms`));
+            }, timeout);
+            child.stdout.on('data', (data)=>{
+                stdout += data.toString();
+            });
+            child.stderr.on('data', (data)=>{
+                stderr += data.toString();
+            });
+            child.on('close', (code)=>{
+                clearTimeout(timer);
+                resolve({
+                    success: code === 0,
+                    code,
+                    stdout,
+                    stderr
+                });
+            });
+            child.on('error', (error)=>{
+                clearTimeout(timer);
+                reject(error);
+            });
+        });
+    }
+    /**
    * Perform complete rollback of all operations
-   */
-  async performRollback() {
-    this.log('🔄 Performing rollback of all operations...', 'warn');
-    let rollbackCount = 0;
-
-    // Execute rollback operations in reverse order
-    for (let i = this.rollbackStack.length - 1; i >= 0; i--) {
-      const operation = this.rollbackStack[i];
-      try {
-        if (!this.dryRun) {
-          await operation.action();
-        }
-        rollbackCount++;
-        this.log(`🔄 Rolled back: ${operation.type}`, 'info');
-      } catch (error) {
-        this.log(`❌ Rollback failed for ${operation.type}: ${error.message}`, 'error');
-      }
-    }
-
-    this.log(`🔄 Rollback completed: ${rollbackCount} operations reversed`, 'info');
-    return { success: rollbackCount > 0, operationsRolledBack: rollbackCount };
-  }
-
-  /**
+   */ async performRollback() {
+        this.log('🔄 Performing rollback of all operations...', 'warn');
+        let rollbackCount = 0;
+        // Execute rollback operations in reverse order
+        for(let i = this.rollbackStack.length - 1; i >= 0; i--){
+            const operation = this.rollbackStack[i];
+            try {
+                if (!this.dryRun) {
+                    await operation.action();
+                }
+                rollbackCount++;
+                this.log(`🔄 Rolled back: ${operation.type}`, 'info');
+            } catch (error) {
+                this.log(`❌ Rollback failed for ${operation.type}: ${error.message}`, 'error');
+            }
+        }
+        this.log(`🔄 Rollback completed: ${rollbackCount} operations reversed`, 'info');
+        return {
+            success: rollbackCount > 0,
+            operationsRolledBack: rollbackCount
+        };
+    }
+    /**
    * Handle setup failure with comprehensive recovery
-   */
-  async handleSetupFailure(error, ux) {
-    this.log(`❌ Setup failed: ${error.message}`, 'error');
-
-    const recovery = {
-      rollbackPerformed: false,
-      backupsAvailable: this.backupPaths.size > 0,
-      errorAnalysis: this.analyzeError(error),
-      recommendedActions: []
-    };
-
-    // Attempt automatic rollback if we have operations to roll back
-    if (this.rollbackStack.length > 0) {
-      try {
-        const rollbackResult = await this.performRollback();
-        recovery.rollbackPerformed = rollbackResult.success;
-        recovery.operationsRolledBack = rollbackResult.operationsRolledBack;
-      } catch (rollbackError) {
-        this.log(`❌ Rollback also failed: ${rollbackError.message}`, 'error');
-        recovery.rollbackError = rollbackError.message;
-      }
-    }
-
-    // Generate recovery recommendations
-    recovery.recommendedActions = this.generateRecoveryActions(error, recovery);
-
-    // Display recovery information if UX is available
-    if (ux) {
-      ux.displayErrorRecovery(error, recovery);
-    } else {
-      this.displayBasicRecovery(error, recovery);
-    }
-
-    return recovery;
-  }
-
-  /**
+   */ async handleSetupFailure(error, ux) {
+        this.log(`❌ Setup failed: ${error.message}`, 'error');
+        const recovery = {
+            rollbackPerformed: false,
+            backupsAvailable: this.backupPaths.size > 0,
+            errorAnalysis: this.analyzeError(error),
+            recommendedActions: []
+        };
+        // Attempt automatic rollback if we have operations to roll back
+        if (this.rollbackStack.length > 0) {
+            try {
+                const rollbackResult = await this.performRollback();
+                recovery.rollbackPerformed = rollbackResult.success;
+                recovery.operationsRolledBack = rollbackResult.operationsRolledBack;
+            } catch (rollbackError) {
+                this.log(`❌ Rollback also failed: ${rollbackError.message}`, 'error');
+                recovery.rollbackError = rollbackError.message;
+            }
+        }
+        // Generate recovery recommendations
+        recovery.recommendedActions = this.generateRecoveryActions(error, recovery);
+        // Display recovery information if UX is available
+        if (ux) {
+            ux.displayErrorRecovery(error, recovery);
+        } else {
+            this.displayBasicRecovery(error, recovery);
+        }
+        return recovery;
+    }
+    /**
    * Analyze error for better recovery recommendations
-   */
-  analyzeError(error) {
-    const analysis = {
-      type: 'unknown',
-      severity: 'medium',
-      recoverable: true,
-      category: 'general'
-    };
-
-    const message = error.message.toLowerCase();
-
-    if (message.includes('permission denied') || message.includes('eacces')) {
-      analysis.type = 'permission';
-      analysis.severity = 'high';
-      analysis.category = 'filesystem';
-    } else if (message.includes('not found') || message.includes('enoent')) {
-      analysis.type = 'missing-file';
-      analysis.severity = 'high';
-      analysis.category = 'filesystem';
-    } else if (message.includes('claude') && message.includes('not installed')) {
-      analysis.type = 'missing-dependency';
-      analysis.severity = 'critical';
-      analysis.category = 'environment';
-      analysis.recoverable = false;
-    } else if (message.includes('timeout') || message.includes('timed out')) {
-      analysis.type = 'timeout';
-      analysis.severity = 'medium';
-      analysis.category = 'network';
-    } else if (message.includes('json') || message.includes('parse')) {
-      analysis.type = 'config-corruption';
-      analysis.severity = 'high';
-      analysis.category = 'configuration';
-    }
-
-    return analysis;
-  }
-
-  /**
+   */ analyzeError(error) {
+        const analysis = {
+            type: 'unknown',
+            severity: 'medium',
+            recoverable: true,
+            category: 'general'
+        };
+        const message = error.message.toLowerCase();
+        if (message.includes('permission denied') || message.includes('eacces')) {
+            analysis.type = 'permission';
+            analysis.severity = 'high';
+            analysis.category = 'filesystem';
+        } else if (message.includes('not found') || message.includes('enoent')) {
+            analysis.type = 'missing-file';
+            analysis.severity = 'high';
+            analysis.category = 'filesystem';
+        } else if (message.includes('claude') && message.includes('not installed')) {
+            analysis.type = 'missing-dependency';
+            analysis.severity = 'critical';
+            analysis.category = 'environment';
+            analysis.recoverable = false;
+        } else if (message.includes('timeout') || message.includes('timed out')) {
+            analysis.type = 'timeout';
+            analysis.severity = 'medium';
+            analysis.category = 'network';
+        } else if (message.includes('json') || message.includes('parse')) {
+            analysis.type = 'config-corruption';
+            analysis.severity = 'high';
+            analysis.category = 'configuration';
+        }
+        return analysis;
+    }
+    /**
    * Generate specific recovery actions based on error analysis
-   */
-  generateRecoveryActions(error, recovery) {
-    const actions = [];
-    const analysis = recovery.errorAnalysis;
-
-    switch (analysis.type) {
-      case 'permission':
-        actions.push('Check file permissions on configuration files');
-        actions.push('Run with appropriate user privileges');
-        actions.push('Ensure home directory is accessible');
-        break;
-
-      case 'missing-file':
-        actions.push('Verify Claude Code installation');
-        actions.push('Check if configuration files exist');
-        actions.push('Re-run initialization if needed');
-        break;
-
-      case 'missing-dependency':
-        actions.push('Install Claude Code: npm install -g @anthropic-ai/claude-code');
-        actions.push('Verify installation: claude --version');
-        actions.push('Re-run setup after installation');
-        break;
-
-      case 'timeout':
-        actions.push('Check network connectivity');
-        actions.push('Retry with increased timeout');
-        actions.push('Check if Claude Code service is running');
-        break;
-
-      case 'config-corruption':
-        if (recovery.backupsAvailable) {
-          actions.push('Restore from automatic backup');
-          actions.push('Validate configuration file syntax');
-        }
-        actions.push('Remove corrupted configuration and reinitialize');
-        break;
-
-      default:
-        actions.push('Check the error log for specific details');
-        actions.push('Try running with --verbose for more information');
-        if (recovery.backupsAvailable) {
-          actions.push('Restore from backup if needed');
-        }
-        actions.push('Contact support if the issue persists');
-    }
-
-    return actions;
-  }
-
-  /**
+   */ generateRecoveryActions(error, recovery) {
+        const actions = [];
+        const analysis = recovery.errorAnalysis;
+        switch(analysis.type){
+            case 'permission':
+                actions.push('Check file permissions on configuration files');
+                actions.push('Run with appropriate user privileges');
+                actions.push('Ensure home directory is accessible');
+                break;
+            case 'missing-file':
+                actions.push('Verify Claude Code installation');
+                actions.push('Check if configuration files exist');
+                actions.push('Re-run initialization if needed');
+                break;
+            case 'missing-dependency':
+                actions.push('Install Claude Code: npm install -g @anthropic-ai/claude-code');
+                actions.push('Verify installation: claude --version');
+                actions.push('Re-run setup after installation');
+                break;
+            case 'timeout':
+                actions.push('Check network connectivity');
+                actions.push('Retry with increased timeout');
+                actions.push('Check if Claude Code service is running');
+                break;
+            case 'config-corruption':
+                if (recovery.backupsAvailable) {
+                    actions.push('Restore from automatic backup');
+                    actions.push('Validate configuration file syntax');
+                }
+                actions.push('Remove corrupted configuration and reinitialize');
+                break;
+            default:
+                actions.push('Check the error log for specific details');
+                actions.push('Try running with --verbose for more information');
+                if (recovery.backupsAvailable) {
+                    actions.push('Restore from backup if needed');
+                }
+                actions.push('Contact support if the issue persists');
+        }
+        return actions;
+    }
+    /**
    * Display basic recovery information when UX module isn't available
-   */
-  displayBasicRecovery(error, recovery) {
-    console.log('\n❌ Setup Failed - Recovery Information:');
-    console.log(`   Error: ${error.message}`);
-    console.log(`   Type: ${recovery.errorAnalysis.type}`);
-    console.log(`   Severity: ${recovery.errorAnalysis.severity}`);
-
-    if (recovery.rollbackPerformed) {
-      console.log(`\n🔄 Automatic rollback completed (${recovery.operationsRolledBack} operations)`);
-    }
-
-    if (recovery.backupsAvailable) {
-      console.log(`\n💾 Backups available for manual recovery`);
-    }
-
-    console.log('\n🛠️ Recommended actions:');
-    recovery.recommendedActions.forEach((action, i) => {
-      console.log(`   ${i + 1}. ${action}`);
-    });
-  }
-
-  /**
+   */ displayBasicRecovery(error, recovery) {
+        console.log('\n❌ Setup Failed - Recovery Information:');
+        console.log(`   Error: ${error.message}`);
+        console.log(`   Type: ${recovery.errorAnalysis.type}`);
+        console.log(`   Severity: ${recovery.errorAnalysis.severity}`);
+        if (recovery.rollbackPerformed) {
+            console.log(`\n🔄 Automatic rollback completed (${recovery.operationsRolledBack} operations)`);
+        }
+        if (recovery.backupsAvailable) {
+            console.log(`\n💾 Backups available for manual recovery`);
+        }
+        console.log('\n🛠️ Recommended actions:');
+        recovery.recommendedActions.forEach((action, i)=>{
+            console.log(`   ${i + 1}. ${action}`);
+        });
+    }
+    /**
    * Generate comprehensive setup summary
-   */
-  generateSetupSummary() {
-    return {
-      operationsPerformed: this.operationLog.length,
-      backupsCreated: this.backupPaths.size,
-      rollbackOperationsAvailable: this.rollbackStack.length,
-      configurationPaths: {
-        local: this.localConfigPath,
-        project: this.projectConfigPath
-      },
-      timestamp: new Date().toISOString()
-    };
-  }
-}
-
+   */ generateSetupSummary() {
+        return {
+            operationsPerformed: this.operationLog.length,
+            backupsCreated: this.backupPaths.size,
+            rollbackOperationsAvailable: this.rollbackStack.length,
+            configurationPaths: {
+                local: this.localConfigPath,
+                project: this.projectConfigPath
+            },
+            timestamp: new Date().toISOString()
+        };
+    }
+    constructor(options = {}){
+        this.localConfigPath = this.findClaudeConfigPath();
+        this.projectConfigPath = path.join(process.cwd(), '.mcp.json');
+        this.verbose = options.verbose || false;
+        this.autoFix = options.autoFix !== false; // Default to true for bulletproof operation
+        this.dryRun = options.dryRun || false;
+        this.backupPaths = new Map();
+        this.operationLog = [];
+        this.errorRecovery = [];
+        this.rollbackStack = [];
+    }
+}
 /**
  * Enhanced MCP initialization with bulletproof error handling and recovery
- */
-export async function enhancedMcpInit(options = {}) {
-  const manager = new McpConfigurationManager({
-    verbose: options.verbose || false,
-    autoFix: options.autoFix !== false, // Default to true for bulletproof operation
-    dryRun: options.dryRun || false
-  });
-
-  console.log('🔍 Starting enhanced MCP initialization...', options.dryRun ? ' (DRY RUN)' : '');
-
-  try {
-    // Initialize UX module if available and requested
-    let ux = null;
-    if (options.enhancedUx !== false) {
-      try {
-        const { McpUserExperience } = await import('../cli/mcp-user-experience.js');
-        ux = new McpUserExperience({
-          verbose: options.verbose,
-          interactive: options.interactive !== false
-        });
-
-        // Show educational content for first-time users
-        if (options.showEducation) {
-          ux.displayMcpEducation();
-        }
-      } catch (uxError) {
-        manager.log(`⚠️ UX module not available, using basic output: ${uxError.message}`, 'warn');
-      }
-    }
-
-    // Comprehensive state detection
-    const state = await manager.detectConfigurationState();
-
-    // Display state information
-    if (options.verbose || state.healthScore < 80) {
-      console.log('\n📋 MCP Configuration Analysis:');
-      console.log(`  Health Score: ${state.healthScore}/100 ${state.healthScore >= 80 ? '✅' : state.healthScore >= 60 ? '⚠️' : '❌'}`);
-      console.log(`  Claude Code: ${state.claudeCodeInstalled ? '✅ Installed' : '❌ Not installed'}`);
-      console.log(`  Local config: ${state.hasLocalConfig ? '✅ Found' : '❌ Not found'}`);
-      console.log(`  Project config: ${state.hasProjectConfig ? '✅ Found' : '❌ Not found'}`);
-      console.log(`  Servers: ${state.localServers.length} local, ${state.projectServers.length} project`);
-      console.log(`  Issues: ${state.conflictingServers.length} conflicts, ${state.brokenPaths.length} broken paths`);
-
-      if (state.criticalIssues.length > 0) {
-        console.log('\n❌ Critical Issues:');
-        state.criticalIssues.forEach(issue => console.log(`    • ${issue}`));
-      }
-
-      if (state.warnings.length > 0) {
-        console.log('\n⚠️ Warnings:');
-        state.warnings.forEach(warning => console.log(`    • ${warning}`));
-      }
-    }
-
-    // Execute bulletproof setup
-    const result = await manager.executeBulletproofSetup(options.serverConfig, ux);
-
-    // Enhanced success reporting
-    if (result.success) {
-      console.log('\n🎉 Enhanced MCP initialization completed successfully!');
-      console.log(`   Duration: ${result.duration}ms`);
-      console.log(`   Issues Fixed: ${result.details.issuesFixed}`);
-      console.log(`   Health Score: ${result.details.healthScore}/100`);
-      console.log(`   Operations: ${result.details.operationsPerformed}`);
-
-      if (result.details.backupsCreated > 0) {
-        console.log(`   Backups Created: ${result.details.backupsCreated}`);
-      }
-
-      // Show success summary if UX is available
-      if (ux) {
-        ux.displaySuccessSummary(result.details);
-      }
-    } else {
-      console.log('\n❌ Enhanced MCP initialization failed');
-      if (result.rollbackAvailable) {
-        console.log('   🔄 Rollback operations are available');
-      }
-    }
-
-    return result;
-
-  } catch (error) {
-    console.log(`\n❌ Enhanced MCP init failed: ${error.message}`);
-
-    // Provide error context
-    if (error.recovery) {
-      console.log('\n🛠️ Recovery suggestions:');
-      error.recovery.forEach((suggestion, i) => {
-        console.log(`   ${i + 1}. ${suggestion}`);
-      });
-    }
-
-    return {
-      success: false,
-      error: error.message,
-      recovery: error.recovery || [],
-      logs: manager.operationLog
-    };
-  }
-}
-
+ */ export async function enhancedMcpInit(options = {}) {
+    const manager = new McpConfigurationManager({
+        verbose: options.verbose || false,
+        autoFix: options.autoFix !== false,
+        dryRun: options.dryRun || false
+    });
+    console.log('🔍 Starting enhanced MCP initialization...', options.dryRun ? ' (DRY RUN)' : '');
+    try {
+        // Initialize UX module if available and requested
+        let ux = null;
+        if (options.enhancedUx !== false) {
+            try {
+                const { McpUserExperience } = await import("../cli/mcp-user-experience.js");
+                ux = new McpUserExperience({
+                    verbose: options.verbose,
+                    interactive: options.interactive !== false
+                });
+                // Show educational content for first-time users
+                if (options.showEducation) {
+                    ux.displayMcpEducation();
+                }
+            } catch (uxError) {
+                manager.log(`⚠️ UX module not available, using basic output: ${uxError.message}`, 'warn');
+            }
+        }
+        // Comprehensive state detection
+        const state = await manager.detectConfigurationState();
+        // Display state information
+        if (options.verbose || state.healthScore < 80) {
+            console.log('\n📋 MCP Configuration Analysis:');
+            console.log(`  Health Score: ${state.healthScore}/100 ${state.healthScore >= 80 ? '✅' : state.healthScore >= 60 ? '⚠️' : '❌'}`);
+            console.log(`  Claude Code: ${state.claudeCodeInstalled ? '✅ Installed' : '❌ Not installed'}`);
+            console.log(`  Local config: ${state.hasLocalConfig ? '✅ Found' : '❌ Not found'}`);
+            console.log(`  Project config: ${state.hasProjectConfig ? '✅ Found' : '❌ Not found'}`);
+            console.log(`  Servers: ${state.localServers.length} local, ${state.projectServers.length} project`);
+            console.log(`  Issues: ${state.conflictingServers.length} conflicts, ${state.brokenPaths.length} broken paths`);
+            if (state.criticalIssues.length > 0) {
+                console.log('\n❌ Critical Issues:');
+                state.criticalIssues.forEach((issue)=>console.log(`    • ${issue}`));
+            }
+            if (state.warnings.length > 0) {
+                console.log('\n⚠️ Warnings:');
+                state.warnings.forEach((warning)=>console.log(`    • ${warning}`));
+            }
+        }
+        // Execute bulletproof setup
+        const result = await manager.executeBulletproofSetup(options.serverConfig, ux);
+        // Enhanced success reporting
+        if (result.success) {
+            console.log('\n🎉 Enhanced MCP initialization completed successfully!');
+            console.log(`   Duration: ${result.duration}ms`);
+            console.log(`   Issues Fixed: ${result.details.issuesFixed}`);
+            console.log(`   Health Score: ${result.details.healthScore}/100`);
+            console.log(`   Operations: ${result.details.operationsPerformed}`);
+            if (result.details.backupsCreated > 0) {
+                console.log(`   Backups Created: ${result.details.backupsCreated}`);
+            }
+            // Show success summary if UX is available
+            if (ux) {
+                ux.displaySuccessSummary(result.details);
+            }
+        } else {
+            console.log('\n❌ Enhanced MCP initialization failed');
+            if (result.rollbackAvailable) {
+                console.log('   🔄 Rollback operations are available');
+            }
+        }
+        return result;
+    } catch (error) {
+        console.log(`\n❌ Enhanced MCP init failed: ${error.message}`);
+        // Provide error context
+        if (error.recovery) {
+            console.log('\n🛠️ Recovery suggestions:');
+            error.recovery.forEach((suggestion, i)=>{
+                console.log(`   ${i + 1}. ${suggestion}`);
+            });
+        }
+        return {
+            success: false,
+            error: error.message,
+            recovery: error.recovery || [],
+            logs: manager.operationLog
+        };
+    }
+}
 /**
  * Quick MCP health check for troubleshooting
- */
-export async function quickMcpHealthCheck(options = {}) {
-  const manager = new McpConfigurationManager({
-    verbose: options.verbose || false,
-    dryRun: true // Health check is always read-only
-  });
-
-  console.log('🏥 Quick MCP health check...');
-
-  try {
-    const state = await manager.detectConfigurationState();
-    const verification = await manager.performComprehensiveVerification();
-
-    console.log('\n📊 Health Report:');
-    console.log(`  Overall Health: ${state.healthScore}/100 ${state.healthScore >= 80 ? '✅' : state.healthScore >= 60 ? '⚠️' : '❌'}`);
-    console.log(`  Claude Code: ${state.claudeCodeInstalled ? '✅' : '❌'}`);
-    console.log(`  Configuration: ${state.hasLocalConfig || state.hasProjectConfig ? '✅' : '❌'}`);
-    console.log(`  Verification: ${verification.tests.filter(t => t.passed).length}/${verification.tests.length} tests passed`);
-
-    if (state.brokenPaths.length > 0) {
-      console.log('\n❌ Broken Configurations:');
-      state.brokenPaths.forEach(broken => {
-        console.log(`    • ${broken.serverName}: ${broken.issues.join(', ')}`);
-      });
-    }
-
-    if (state.conflictingServers.length > 0) {
-      console.log('\n⚠️ Configuration Conflicts:');
-      state.conflictingServers.forEach(conflict => {
-        console.log(`    • ${conflict.serverName}: Local vs Project configuration`);
-      });
-    }
-
-    console.log('\n🛠️ Recommendations:');
-    if (state.recommendations.length > 0) {
-      state.recommendations.forEach(rec => {
-        console.log(`    • ${rec.description}`);
-      });
-    } else {
-      console.log('    • No immediate action required');
-    }
-
-    return {
-      healthy: state.healthScore >= 80 && verification.success,
-      healthScore: state.healthScore,
-      state,
-      verification,
-      needsAttention: state.healthScore < 80 || state.brokenPaths.length > 0
-    };
-
-  } catch (error) {
-    console.log(`\n❌ Health check failed: ${error.message}`);
-    return {
-      healthy: false,
-      error: error.message,
-      needsAttention: true
-    };
-  }
-}
-
-export default McpConfigurationManager;
+ */ export async function quickMcpHealthCheck(options = {}) {
+    const manager = new McpConfigurationManager({
+        verbose: options.verbose || false,
+        dryRun: true // Health check is always read-only
+    });
+    console.log('🏥 Quick MCP health check...');
+    try {
+        const state = await manager.detectConfigurationState();
+        const verification = await manager.performComprehensiveVerification();
+        console.log('\n📊 Health Report:');
+        console.log(`  Overall Health: ${state.healthScore}/100 ${state.healthScore >= 80 ? '✅' : state.healthScore >= 60 ? '⚠️' : '❌'}`);
+        console.log(`  Claude Code: ${state.claudeCodeInstalled ? '✅' : '❌'}`);
+        console.log(`  Configuration: ${state.hasLocalConfig || state.hasProjectConfig ? '✅' : '❌'}`);
+        console.log(`  Verification: ${verification.tests.filter((t)=>t.passed).length}/${verification.tests.length} tests passed`);
+        if (state.brokenPaths.length > 0) {
+            console.log('\n❌ Broken Configurations:');
+            state.brokenPaths.forEach((broken)=>{
+                console.log(`    • ${broken.serverName}: ${broken.issues.join(', ')}`);
+            });
+        }
+        if (state.conflictingServers.length > 0) {
+            console.log('\n⚠️ Configuration Conflicts:');
+            state.conflictingServers.forEach((conflict)=>{
+                console.log(`    • ${conflict.serverName}: Local vs Project configuration`);
+            });
+        }
+        console.log('\n🛠️ Recommendations:');
+        if (state.recommendations.length > 0) {
+            state.recommendations.forEach((rec)=>{
+                console.log(`    • ${rec.description}`);
+            });
+        } else {
+            console.log('    • No immediate action required');
+        }
+        return {
+            healthy: state.healthScore >= 80 && verification.success,
+            healthScore: state.healthScore,
+            state,
+            verification,
+            needsAttention: state.healthScore < 80 || state.brokenPaths.length > 0
+        };
+    } catch (error) {
+        console.log(`\n❌ Health check failed: ${error.message}`);
+        return {
+            healthy: false,
+            error: error.message,
+            needsAttention: true
+        };
+    }
+}
+export default McpConfigurationManager;