claude-flow 2.0.0-alpha.2 → 2.0.0-alpha.21

package/src/cli/simple-commands/init/index.js

@@ -1,13 +1,13 @@
 // init/index.js - Initialize Claude Code integration files
 import { printSuccess, printError, printWarning } from '../../utils.js';
-import { cwd, exit, existsSync } from '../../node-compat.js';
+import { Deno, cwd, exit, existsSync } from '../../node-compat.js';
 import process from 'process';
-import fs from 'fs/promises';
-import { execSync } from 'child_process';
 import { createLocalExecutable } from './executable-wrapper.js';
 import { createSparcStructureManually } from './sparc-structure.js';
 import { createClaudeSlashCommands } from './claude-commands/slash-commands.js';
 import { createOptimizedClaudeSlashCommands } from './claude-commands/optimized-slash-commands.js';
+import { execSync } from 'child_process';
+import { promises as fs } from 'fs';
 import { 
   createSparcClaudeMd, 
   createFullClaudeMd, 
@@ -33,10 +33,6 @@ import {
   createSparcModesOverview,
   createSwarmStrategyTemplates 
 } from './templates/sparc-modes.js';
-import { 
-  createAllCommandTemplates,
-  createCommandDirectories 
-} from './templates/all-commands.js';
 import { showInitHelp } from './help.js';
 import { 
   batchInitCommand, 
@@ -53,7 +49,62 @@ import {
   createHelperScript,
   COMMAND_STRUCTURE
 } from './templates/enhanced-templates.js';
-import { createGithubEnhancedCommands } from './templates/github-enhanced.js';
+
+/**
+ * Check if Claude Code CLI is installed
+ */
+function isClaudeCodeInstalled() {
+  try {
+    execSync('which claude', { stdio: 'ignore' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Set up MCP servers in Claude Code
+ */
+async function setupMcpServers(dryRun = false) {
+  console.log('\n🔌 Setting up MCP servers for Claude Code...');
+  
+  const servers = [
+    {
+      name: 'claude-flow',
+      command: 'npx claude-flow@alpha mcp start',
+      description: 'Claude Flow MCP server with swarm orchestration (alpha)'
+    },
+    {
+      name: 'ruv-swarm',
+      command: 'npx ruv-swarm mcp start',
+      description: 'ruv-swarm MCP server for enhanced coordination'
+    }
+  ];
+  
+  for (const server of servers) {
+    try {
+      if (!dryRun) {
+        console.log(`  🔄 Adding ${server.name}...`);
+        execSync(`claude mcp add ${server.name} ${server.command}`, { stdio: 'inherit' });
+        console.log(`  ✅ Added ${server.name} - ${server.description}`);
+      } else {
+        console.log(`  [DRY RUN] Would add ${server.name} - ${server.description}`);
+      }
+    } catch (err) {
+      console.log(`  ⚠️  Failed to add ${server.name}: ${err.message}`);
+      console.log(`     You can add it manually with: claude mcp add ${server.name} ${server.command}`);
+    }
+  }
+  
+  if (!dryRun) {
+    console.log('\n  📋 Verifying MCP servers...');
+    try {
+      execSync('claude mcp list', { stdio: 'inherit' });
+    } catch (err) {
+      console.log('  ⚠️  Could not verify MCP servers');
+    }
+  }
+}
 
 export async function initCommand(subArgs, flags) {
   // Show help if requested
@@ -65,8 +116,7 @@ export async function initCommand(subArgs, flags) {
   // Default to enhanced Claude Flow v2 init
   // Use --basic flag for old behavior
   if (!flags.basic && !flags.minimal && !flags.sparc) {
-    console.log('🚀 Initializing Claude Flow v2.0.0 with enhanced features...');
-    return await enhancedClaudeFlowInit(flags);
+    return await enhancedClaudeFlowInit(flags, subArgs);
   }
   
   // Check for validation and rollback commands
@@ -104,14 +154,10 @@ export async function initCommand(subArgs, flags) {
   const initDryRun = subArgs.includes('--dry-run') || subArgs.includes('-d') || flags.dryRun;
   const initOptimized = initSparc && initForce; // Use optimized templates when both flags are present
   const selectedModes = flags.modes ? flags.modes.split(',') : null; // Support selective mode initialization
-  const initClaudeFlow = subArgs.includes('--claude-flow') || flags.claudeFlow;
-  if (initClaudeFlow) {
-    return enhancedClaudeFlowInit(subArgs, flags, initDryRun, initForce);
-  }
   
   // Get the actual working directory (where the command was run from)
-  // Use CLAUDE_WORKING_DIR from our wrapper, fallback to PWD or cwd()
-  const workingDir = process.env.CLAUDE_WORKING_DIR || process.env.PWD || cwd();
+  // Use PWD environment variable which preserves the original directory
+  const workingDir = process.env.PWD || cwd();
   console.log(`📁 Initializing in: ${workingDir}`);
   
   // Change to the working directory to ensure all file operations happen there
@@ -130,7 +176,7 @@ export async function initCommand(subArgs, flags) {
     
     for (const file of files) {
       try {
-        await fs.stat(`${workingDir}/${file}`);
+        await Deno.stat(`${workingDir}/${file}`);
         existingFiles.push(file);
       } catch {
         // File doesn't exist, which is what we want
@@ -149,7 +195,7 @@ export async function initCommand(subArgs, flags) {
                      initMinimal ? createMinimalClaudeMd() : createFullClaudeMd();
     
     if (!initDryRun) {
-      await fs.writeFile('CLAUDE.md', claudeMd);
+      await Deno.writeTextFile('CLAUDE.md', claudeMd);
       console.log(`  ✓ Created CLAUDE.md${initOptimized ? ' (Batchtools-optimized SPARC)' : initSparc ? ' (SPARC-enhanced)' : ''}`);
     } else {
       console.log(`  [DRY RUN] Would create CLAUDE.md${initOptimized ? ' (Batchtools-optimized SPARC)' : initSparc ? ' (SPARC-enhanced)' : ''}`);
@@ -159,7 +205,7 @@ export async function initCommand(subArgs, flags) {
     const memoryBankMd = initOptimized ? await createOptimizedMemoryBankMd() :
                          initMinimal ? createMinimalMemoryBankMd() : createFullMemoryBankMd();
     if (!initDryRun) {
-      await fs.writeFile('memory-bank.md', memoryBankMd);
+      await Deno.writeTextFile('memory-bank.md', memoryBankMd);
       console.log('  ✓ Created memory-bank.md' + (initOptimized ? ' (Optimized for parallel operations)' : ''));
     } else {
       console.log('  [DRY RUN] Would create memory-bank.md' + (initOptimized ? ' (Optimized for parallel operations)' : ''));
@@ -169,7 +215,7 @@ export async function initCommand(subArgs, flags) {
     const coordinationMd = initOptimized ? await createOptimizedCoordinationMd() :
                            initMinimal ? createMinimalCoordinationMd() : createFullCoordinationMd();
     if (!initDryRun) {
-      await fs.writeFile('coordination.md', coordinationMd);
+      await Deno.writeTextFile('coordination.md', coordinationMd);
       console.log('  ✓ Created coordination.md' + (initOptimized ? ' (Enhanced with batchtools)' : ''));
     } else {
       console.log('  [DRY RUN] Would create coordination.md' + (initOptimized ? ' (Enhanced with batchtools)' : ''));
@@ -194,7 +240,7 @@ export async function initCommand(subArgs, flags) {
     for (const dir of directories) {
       try {
         if (!initDryRun) {
-          await fs.mkdir(dir, { recursive: true });
+          await Deno.mkdir(dir, { recursive: true });
           console.log(`  ✓ Created ${dir}/ directory`);
         } else {
           console.log(`  [DRY RUN] Would create ${dir}/ directory`);
@@ -218,7 +264,7 @@ export async function initCommand(subArgs, flags) {
         
         for (const [filename, content] of Object.entries(sparcTemplates)) {
           try {
-            await fs.writeFile(`${sparcTargetDir}/${filename}`, content);
+            await Deno.writeTextFile(`${sparcTargetDir}/${filename}`, content);
             console.log(`    ✓ Created ${filename}`);
           } catch (err) {
             console.log(`    ⚠️  Could not create ${filename}: ${err.message}`);
@@ -227,7 +273,7 @@ export async function initCommand(subArgs, flags) {
         
         // Also create sparc-modes.md overview file
         const sparcModesOverview = createSparcModesOverview();
-        await fs.writeFile(`${sparcTargetDir}/sparc-modes.md`, sparcModesOverview);
+        await Deno.writeTextFile(`${sparcTargetDir}/sparc-modes.md`, sparcModesOverview);
         console.log(`    ✓ Created sparc-modes.md`);
         
         console.log('  ✅ SPARC command files created successfully');
@@ -246,7 +292,7 @@ export async function initCommand(subArgs, flags) {
         
         for (const [filename, content] of Object.entries(swarmTemplates)) {
           try {
-            await fs.writeFile(`${swarmTargetDir}/${filename}`, content);
+            await Deno.writeTextFile(`${swarmTargetDir}/${filename}`, content);
             console.log(`    ✓ Created ${filename}`);
           } catch (err) {
             console.log(`    ⚠️  Could not create ${filename}: ${err.message}`);
@@ -258,47 +304,6 @@ export async function initCommand(subArgs, flags) {
         console.log(`  ⚠️  Could not create swarm files: ${err.message}`);
       }
       
-      // Create GitHub command files with enhanced documentation
-      try {
-        const githubTargetDir = `${workingDir}/.claude/commands/github`;
-        await fs.mkdir(githubTargetDir, { recursive: true });
-        
-        console.log('  📁 Creating GitHub command files...');
-        
-        // Create enhanced GitHub documentation
-        const githubEnhancedDocs = createGithubEnhancedCommands();
-        for (const [filename, content] of Object.entries(githubEnhancedDocs)) {
-          try {
-            await fs.writeFile(`${githubTargetDir}/${filename}`, content);
-            console.log(`    ✓ Created ${filename}`);
-          } catch (err) {
-            console.log(`    ⚠️  Could not create ${filename}: ${err.message}`);
-          }
-        }
-        
-        // Create standard GitHub command docs from existing patterns
-        const githubCommands = [
-          'github-swarm', 'repo-analyze', 'pr-enhance', 'issue-triage', 'code-review',
-          'pr-manager', 'release-manager', 'issue-tracker', 'workflow-automation'
-        ];
-        
-        for (const command of githubCommands) {
-          try {
-            const doc = createCommandDoc('github', command);
-            if (doc && !githubEnhancedDocs[`${command}.md`]) {
-              await fs.writeFile(`${githubTargetDir}/${command}.md`, doc);
-              console.log(`    ✓ Created ${command}.md`);
-            }
-          } catch (err) {
-            console.log(`    ⚠️  Could not create ${command}.md: ${err.message}`);
-          }
-        }
-        
-        console.log('  ✅ GitHub command files created successfully');
-      } catch (err) {
-        console.log(`  ⚠️  Could not create GitHub files: ${err.message}`);
-      }
-      
       // Create .claude/config.json
       try {
         const configContent = {
@@ -313,56 +318,17 @@ export async function initCommand(subArgs, flags) {
           }
         };
         
-        await fs.writeFile(`${workingDir}/.claude/config.json`, JSON.stringify(configContent, null, 2));
+        await Deno.writeTextFile(`${workingDir}/.claude/config.json`, JSON.stringify(configContent, null, 2));
         console.log('  ✓ Created .claude/config.json');
       } catch (err) {
         console.log(`  ⚠️  Could not create config.json: ${err.message}`);
       }
-      
-      // Create ALL command directories and files
-      console.log('  📁 Creating comprehensive command documentation...');
-      
-      try {
-        const allCommands = createAllCommandTemplates();
-        const commandDirs = createCommandDirectories();
-        
-        // Create all command directories
-        for (const dir of commandDirs) {
-          const dirPath = `${workingDir}/.claude/commands/${dir}`;
-          try {
-            await fs.mkdir(dirPath, { recursive: true });
-          } catch (err) {
-            if (err.code !== 'EEXIST') {
-              console.log(`    ⚠️  Could not create ${dir} directory: ${err.message}`);
-            }
-          }
-        }
-        
-        // Create all command files
-        for (const [category, files] of Object.entries(allCommands)) {
-          const categoryDir = `${workingDir}/.claude/commands/${category}`;
-          console.log(`    📝 Creating ${category} commands...`);
-          
-          for (const [filename, content] of Object.entries(files)) {
-            try {
-              await fs.writeFile(`${categoryDir}/${filename}`, content);
-              console.log(`      ✓ Created ${filename}`);
-            } catch (err) {
-              console.log(`      ⚠️  Could not create ${filename}: ${err.message}`);
-            }
-          }
-        }
-        
-        console.log('  ✅ All command documentation created successfully');
-      } catch (err) {
-        console.log(`  ⚠️  Could not create command documentation: ${err.message}`);
-      }
     }
     
     // Create placeholder files for memory directories
     const agentsReadme = createAgentsReadme();
     if (!initDryRun) {
-      await fs.writeFile('memory/agents/README.md', agentsReadme);
+      await Deno.writeTextFile('memory/agents/README.md', agentsReadme);
       console.log('  ✓ Created memory/agents/README.md');
     } else {
       console.log('  [DRY RUN] Would create memory/agents/README.md');
@@ -370,7 +336,7 @@ export async function initCommand(subArgs, flags) {
     
     const sessionsReadme = createSessionsReadme();
     if (!initDryRun) {
-      await fs.writeFile('memory/sessions/README.md', sessionsReadme);
+      await Deno.writeTextFile('memory/sessions/README.md', sessionsReadme);
       console.log('  ✓ Created memory/sessions/README.md');
     } else {
       console.log('  [DRY RUN] Would create memory/sessions/README.md');
@@ -383,7 +349,7 @@ export async function initCommand(subArgs, flags) {
       lastUpdated: Date.now()
     };
     if (!initDryRun) {
-      await fs.writeFile('memory/claude-flow-data.json', JSON.stringify(initialData, null, 2));
+      await Deno.writeTextFile('memory/claude-flow-data.json', JSON.stringify(initialData, null, 2));
       console.log('  ✓ Created memory/claude-flow-data.json (persistence database)');
     } else {
       console.log('  [DRY RUN] Would create memory/claude-flow-data.json (persistence database)');
@@ -411,20 +377,24 @@ export async function initCommand(subArgs, flags) {
         // Check if create-sparc exists and run it
         let sparcInitialized = false;
         try {
-          // Use execSync instead of Deno.Command
-          try {
-            console.log('  🔄 Running: npx -y create-sparc init --force');
-            execSync('npx -y create-sparc init --force', {
-              cwd: workingDir,
-              stdio: 'inherit',
-              env: {
-                ...process.env,
-                PWD: workingDir
-              }
-            });
+          const createSparcCommand = new Deno.Command('npx', {
+            args: ['-y', 'create-sparc', 'init', '--force'],
+            cwd: workingDir, // Use the original working directory
+            stdout: 'inherit',
+            stderr: 'inherit',
+            env: {
+              ...Deno.env.toObject(),
+              PWD: workingDir, // Ensure PWD is set correctly
+            },
+          });
+          
+          console.log('  🔄 Running: npx -y create-sparc init --force');
+          const createSparcResult = await createSparcCommand.output();
+          
+          if (createSparcResult.success) {
             console.log('  ✅ SPARC environment initialized successfully');
             sparcInitialized = true;
-          } catch (execError) {
+          } else {
             printWarning('create-sparc failed, creating basic SPARC structure manually...');
             
             // Fallback: create basic SPARC structure manually
@@ -523,6 +493,24 @@ export async function initCommand(subArgs, flags) {
         console.log('  • Enable batch processing for multiple related tasks');
         console.log('  • Monitor performance with real-time metrics');
       }
+      
+      // Check for Claude Code and set up MCP servers (always enabled by default)
+      if (!dryRun && isClaudeCodeInstalled()) {
+        console.log('\n🔍 Claude Code CLI detected!');
+        const skipMcp = args && args.includes && args.includes('--skip-mcp');
+        
+        if (!skipMcp) {
+          await setupMcpServers(dryRun);
+        } else {
+          console.log('  ℹ️  Skipping MCP setup (--skip-mcp flag used)');
+        }
+      } else if (!dryRun && !isClaudeCodeInstalled()) {
+        console.log('\n⚠️  Claude Code CLI not detected!');
+        console.log('  📥 Install with: npm install -g @anthropics/claude-code');
+        console.log('  📋 Then add MCP servers manually with:');
+        console.log('     claude mcp add claude-flow claude-flow mcp start');
+        console.log('     claude mcp add ruv-swarm npx ruv-swarm mcp start');
+      }
     }
     
   } catch (err) {
@@ -603,8 +591,12 @@ async function handleBatchInit(subArgs, flags) {
 async function enhancedInitCommand(subArgs, flags) {
   console.log('🛡️  Starting enhanced initialization with validation and rollback...');
   
+  // Store parameters to avoid scope issues in async context
+  const args = subArgs || [];
+  const options = flags || {};
+  
   // Get the working directory
-  const workingDir = process.env.PWD || process.cwd();
+  const workingDir = Deno.env.get('PWD') || Deno.cwd();
   
   // Initialize systems
   const rollbackSystem = new RollbackSystem(workingDir);
@@ -614,19 +606,19 @@ async function enhancedInitCommand(subArgs, flags) {
   
   try {
     // Parse options
-    const options = {
-      force: subArgs.includes('--force') || subArgs.includes('-f') || flags.force,
-      minimal: subArgs.includes('--minimal') || subArgs.includes('-m') || flags.minimal,
-      sparc: subArgs.includes('--sparc') || subArgs.includes('-s') || flags.sparc,
-      skipPreValidation: subArgs.includes('--skip-pre-validation'),
-      skipBackup: subArgs.includes('--skip-backup'),
-      validateOnly: subArgs.includes('--validate-only')
+    const initOptions = {
+      force: args.includes('--force') || args.includes('-f') || options.force,
+      minimal: args.includes('--minimal') || args.includes('-m') || options.minimal,
+      sparc: args.includes('--sparc') || args.includes('-s') || options.sparc,
+      skipPreValidation: args.includes('--skip-pre-validation'),
+      skipBackup: args.includes('--skip-backup'),
+      validateOnly: args.includes('--validate-only')
     };
 
     // Phase 1: Pre-initialization validation
-    if (!options.skipPreValidation) {
+    if (!initOptions.skipPreValidation) {
       console.log('\n🔍 Phase 1: Pre-initialization validation...');
-      const preValidation = await validationSystem.validatePreInit(options);
+      const preValidation = await validationSystem.validatePreInit(initOptions);
       
       if (!preValidation.success) {
         printError('Pre-initialization validation failed:');
@@ -741,7 +733,7 @@ async function enhancedInitCommand(subArgs, flags) {
  * Handle validation commands
  */
 async function handleValidationCommand(subArgs, flags) {
-  const workingDir = process.env.PWD || process.cwd();
+  const workingDir = Deno.env.get('PWD') || Deno.cwd();
   
   console.log('🔍 Running validation checks...');
   
@@ -775,7 +767,7 @@ async function handleValidationCommand(subArgs, flags) {
  * Handle rollback commands
  */
 async function handleRollbackCommand(subArgs, flags) {
-  const workingDir = process.env.PWD || process.cwd();
+  const workingDir = Deno.env.get('PWD') || Deno.cwd();
   const rollbackSystem = new RollbackSystem(workingDir);
   
   try {
@@ -847,7 +839,7 @@ async function handleRollbackCommand(subArgs, flags) {
  * Handle list backups command
  */
 async function handleListBackups(subArgs, flags) {
-  const workingDir = process.env.PWD || process.cwd();
+  const workingDir = Deno.env.get('PWD') || Deno.cwd();
   const rollbackSystem = new RollbackSystem(workingDir);
   
   try {
@@ -957,11 +949,17 @@ async function setupCoordinationSystem(workingDir) {
 /**
  * Enhanced Claude Flow v2.0.0 initialization
  */
-async function enhancedClaudeFlowInit(flags) {
+async function enhancedClaudeFlowInit(flags, subArgs = []) {
+  console.log('🚀 Initializing Claude Flow v2.0.0 with enhanced features...');
+  
   const workingDir = process.cwd();
   const force = flags.force || flags.f;
   const dryRun = flags.dryRun || flags['dry-run'] || flags.d;
   
+  // Store parameters to avoid scope issues in async context
+  const args = subArgs || [];
+  const options = flags || {};
+  
   // Import fs module for Node.js
   const fs = await import('fs/promises');
   const { chmod } = fs;
@@ -985,7 +983,7 @@ async function enhancedClaudeFlowInit(flags) {
     
     // Create CLAUDE.md
     if (!dryRun) {
-      await fs.writeFile(`${workingDir}/CLAUDE.md`, createEnhancedClaudeMd());
+      await Deno.writeTextFile(`${workingDir}/CLAUDE.md`, createEnhancedClaudeMd());
       printSuccess('✓ Created CLAUDE.md (Claude Flow v2.0.0)');
     } else {
       console.log('[DRY RUN] Would create CLAUDE.md (Claude Flow v2.0.0)');
@@ -994,9 +992,9 @@ async function enhancedClaudeFlowInit(flags) {
     // Create .claude directory structure
     const claudeDir = `${workingDir}/.claude`;
     if (!dryRun) {
-      await fs.mkdir(claudeDir, { recursive: true });
-      await fs.mkdir(`${claudeDir}/commands`, { recursive: true });
-      await fs.mkdir(`${claudeDir}/helpers`, { recursive: true });
+      await Deno.mkdir(claudeDir, { recursive: true });
+      await Deno.mkdir(`${claudeDir}/commands`, { recursive: true });
+      await Deno.mkdir(`${claudeDir}/helpers`, { recursive: true });
       printSuccess('✓ Created .claude directory structure');
     } else {
       console.log('[DRY RUN] Would create .claude directory structure');
@@ -1004,18 +1002,36 @@ async function enhancedClaudeFlowInit(flags) {
     
     // Create settings.json
     if (!dryRun) {
-      await fs.writeFile(`${claudeDir}/settings.json`, createEnhancedSettingsJson());
+      await Deno.writeTextFile(`${claudeDir}/settings.json`, createEnhancedSettingsJson());
       printSuccess('✓ Created .claude/settings.json with hooks and MCP configuration');
     } else {
       console.log('[DRY RUN] Would create .claude/settings.json');
     }
     
+    // Create settings.local.json with default MCP permissions
+    const settingsLocal = {
+      "permissions": {
+        "allow": [
+          "mcp__ruv-swarm",
+          "mcp__claude-flow"
+        ],
+        "deny": []
+      }
+    };
+    
+    if (!dryRun) {
+      await Deno.writeTextFile(`${claudeDir}/settings.local.json`, JSON.stringify(settingsLocal, null, 2));
+      printSuccess('✓ Created .claude/settings.local.json with default MCP permissions');
+    } else {
+      console.log('[DRY RUN] Would create .claude/settings.local.json with default MCP permissions');
+    }
+    
     // Create command documentation
     for (const [category, commands] of Object.entries(COMMAND_STRUCTURE)) {
       const categoryDir = `${claudeDir}/commands/${category}`;
       
       if (!dryRun) {
-        await fs.mkdir(categoryDir, { recursive: true });
+        await Deno.mkdir(categoryDir, { recursive: true });
         
         // Create category README
         const categoryReadme = `# ${category.charAt(0).toUpperCase() + category.slice(1)} Commands
@@ -1026,22 +1042,13 @@ Commands for ${category} operations in Claude Flow.
 
 ${commands.map(cmd => `- [${cmd}](./${cmd}.md)`).join('\n')}
 `;
-        await fs.writeFile(`${categoryDir}/README.md`, categoryReadme);
+        await Deno.writeTextFile(`${categoryDir}/README.md`, categoryReadme);
         
         // Create individual command docs
         for (const command of commands) {
           const doc = createCommandDoc(category, command);
           if (doc) {
-            await fs.writeFile(`${categoryDir}/${command}.md`, doc);
-          }
-        }
-        
-        // Add enhanced GitHub documentation if this is the github category
-        if (category === 'github') {
-          const enhancedGithubDocs = createGithubEnhancedCommands();
-          for (const [filename, content] of Object.entries(enhancedGithubDocs)) {
-            await fs.writeFile(`${categoryDir}/${filename}`, content);
-            console.log(`    ✓ Created enhanced ${filename}`);
+            await Deno.writeTextFile(`${categoryDir}/${command}.md`, doc);
           }
         }
         
@@ -1053,16 +1060,16 @@ ${commands.map(cmd => `- [${cmd}](./${cmd}.md)`).join('\n')}
     
     // Create wrapper scripts
     if (!dryRun) {
-      // Unix wrapper
+      // Unix wrapper - now uses universal ES module compatible wrapper
       const unixWrapper = createWrapperScript('unix');
-      await fs.writeFile(`${workingDir}/claude-flow`, unixWrapper);
-      await chmod(`${workingDir}/claude-flow`, 0o755);
+      await Deno.writeTextFile(`${workingDir}/claude-flow`, unixWrapper);
+      await fs.chmod(`${workingDir}/claude-flow`, 0o755);
       
       // Windows wrapper
-      await fs.writeFile(`${workingDir}/claude-flow.bat`, createWrapperScript('windows'));
+      await Deno.writeTextFile(`${workingDir}/claude-flow.bat`, createWrapperScript('windows'));
       
       // PowerShell wrapper
-      await fs.writeFile(`${workingDir}/claude-flow.ps1`, createWrapperScript('powershell'));
+      await Deno.writeTextFile(`${workingDir}/claude-flow.ps1`, createWrapperScript('powershell'));
       
       printSuccess('✓ Created platform-specific wrapper scripts');
     } else {
@@ -1075,8 +1082,8 @@ ${commands.map(cmd => `- [${cmd}](./${cmd}.md)`).join('\n')}
       if (!dryRun) {
         const content = createHelperScript(helper);
         if (content) {
-          await fs.writeFile(`${claudeDir}/helpers/${helper}`, content);
-          await chmod(`${claudeDir}/helpers/${helper}`, 0o755);
+          await Deno.writeTextFile(`${claudeDir}/helpers/${helper}`, content);
+          await fs.chmod(`${claudeDir}/helpers/${helper}`, 0o755);
         }
       }
     }
@@ -1118,21 +1125,47 @@ ${commands.map(cmd => `- [${cmd}](./${cmd}.md)`).join('\n')}
       printSuccess('✓ Initialized memory system');
     }
     
+    // Check for Claude Code and set up MCP servers (always enabled by default)
+    if (!dryRun && isClaudeCodeInstalled()) {
+      console.log('\n🔍 Claude Code CLI detected!');
+      const skipMcp = (options && options['skip-mcp']) || (args && args.includes && args.includes('--skip-mcp'));
+      
+      if (!skipMcp) {
+        await setupMcpServers(dryRun);
+      } else {
+        console.log('  ℹ️  Skipping MCP setup (--skip-mcp flag used)');
+        console.log('\n  📋 To add MCP servers manually:');
+        console.log('     claude mcp add claude-flow claude-flow mcp start');
+        console.log('     claude mcp add ruv-swarm npx ruv-swarm mcp start');
+      }
+    } else if (!dryRun && !isClaudeCodeInstalled()) {
+      console.log('\n⚠️  Claude Code CLI not detected!');
+      console.log('\n  📥 To install Claude Code:');
+      console.log('     npm install -g @anthropics/claude-code');
+      console.log('\n  📋 After installing, add MCP servers:');
+      console.log('     claude mcp add claude-flow claude-flow mcp start');
+      console.log('     claude mcp add ruv-swarm npx ruv-swarm mcp start');
+    }
+    
     // Final instructions
-    console.log('\\n🎉 Claude Flow v2.0.0 initialization complete!');
-    console.log('\\n📚 Quick Start:');
-    console.log('1. Add MCP server: claude mcp add claude-flow npx claude-flow mcp start');
-    console.log('2. View available commands: ls .claude/commands/');
-    console.log('3. Run setup helper: .claude/helpers/setup-mcp.sh');
-    console.log('4. Start a swarm: npx claude-flow swarm init');
-    console.log('\\n💡 Tips:');
+    console.log('\n🎉 Claude Flow v2.0.0 initialization complete!');
+    console.log('\n📚 Quick Start:');
+    if (isClaudeCodeInstalled()) {
+      console.log('1. View available commands: ls .claude/commands/');
+      console.log('2. Start a swarm: npx claude-flow swarm init');
+      console.log('3. Use MCP tools in Claude Code for enhanced coordination');
+    } else {
+      console.log('1. Install Claude Code: npm install -g @anthropics/claude-code');
+      console.log('2. Add MCP servers (see instructions above)');
+      console.log('3. View available commands: ls .claude/commands/');
+      console.log('4. Start a swarm: npx claude-flow swarm init');
+    }
+    console.log('\n💡 Tips:');
     console.log('• Check .claude/commands/ for detailed documentation');
     console.log('• Use --help with any command for options');
     console.log('• Enable GitHub integration with .claude/helpers/github-setup.sh');
     
   } catch (err) {
     printError(`Failed to initialize Claude Flow v2.0.0: ${err.message}`);
-    console.error('Full error:', err);
-    throw err;
   }
-}
+}