claude-flow 2.0.0-alpha.7 → 2.0.0-alpha.71

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

@@ -8,37 +8,10 @@ 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, 
-  createMinimalClaudeMd,
-  createOptimizedSparcClaudeMd 
-} from './templates/claude-md.js';
-import { 
-  createFullMemoryBankMd, 
-  createMinimalMemoryBankMd,
-  createOptimizedMemoryBankMd 
-} from './templates/memory-bank-md.js';
-import { 
-  createFullCoordinationMd, 
-  createMinimalCoordinationMd,
-  createOptimizedCoordinationMd 
-} from './templates/coordination-md.js';
-import { 
-  createAgentsReadme, 
-  createSessionsReadme 
-} from './templates/readme-files.js';
-import { 
-  createSparcModeTemplates, 
-  createSparcModesOverview,
-  createSwarmStrategyTemplates 
-} from './templates/sparc-modes.js';
+import { copyTemplates } from './template-copier.js';
+import { copyRevisedTemplates, validateTemplatesExist } from './copy-revised-templates.js';
 import { showInitHelp } from './help.js';
-import { 
-  batchInitCommand, 
-  batchInitFromConfig, 
-  validateBatchOptions 
-} from './batch-init.js';
+import { batchInitCommand, batchInitFromConfig, validateBatchOptions } from './batch-init.js';
 import { ValidationSystem, runFullValidation } from './validation/index.js';
 import { RollbackSystem, createAtomicOperation } from './rollback/index.js';
 import {
@@ -47,8 +20,24 @@ import {
   createWrapperScript,
   createCommandDoc,
   createHelperScript,
-  COMMAND_STRUCTURE
+  COMMAND_STRUCTURE,
 } from './templates/enhanced-templates.js';
+import { getIsolatedNpxEnv } from '../../../utils/npx-isolated-cache.js';
+import { updateGitignore, needsGitignoreUpdate } from './gitignore-updater.js';
+import {
+  createFullClaudeMd,
+  createSparcClaudeMd,
+  createMinimalClaudeMd,
+} from './templates/claude-md.js';
+import {
+  createFullMemoryBankMd,
+  createMinimalMemoryBankMd,
+} from './templates/memory-bank-md.js';
+import {
+  createFullCoordinationMd,
+  createMinimalCoordinationMd,
+} from './templates/coordination-md.js';
+import { createAgentsReadme, createSessionsReadme } from './templates/readme-files.js';
 
 /**
  * Check if Claude Code CLI is installed
@@ -67,20 +56,20 @@ function isClaudeCodeInstalled() {
  */
 async function setupMcpServers(dryRun = false) {
   console.log('\n🔌 Setting up MCP servers for Claude Code...');
-  
+
   const servers = [
     {
       name: 'claude-flow',
-      command: 'claude-flow mcp start',
-      description: 'Claude Flow MCP server with swarm orchestration'
+      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'
-    }
+      description: 'ruv-swarm MCP server for enhanced coordination',
+    },
   ];
-  
+
   for (const server of servers) {
     try {
       if (!dryRun) {
@@ -92,10 +81,12 @@ async function setupMcpServers(dryRun = false) {
       }
     } 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}`);
+      console.log(
+        `     You can add it manually with: claude mcp add ${server.name} ${server.command}`,
+      );
     }
   }
-  
+
   if (!dryRun) {
     console.log('\n  📋 Verifying MCP servers...');
     try {
@@ -112,68 +103,68 @@ export async function initCommand(subArgs, flags) {
     showInitHelp();
     return;
   }
-  
+
   // Default to enhanced Claude Flow v2 init
   // Use --basic flag for old behavior
   if (!flags.basic && !flags.minimal && !flags.sparc) {
-    return await enhancedClaudeFlowInit(flags);
+    return await enhancedClaudeFlowInit(flags, subArgs);
   }
-  
+
   // Check for validation and rollback commands
   if (subArgs.includes('--validate') || subArgs.includes('--validate-only')) {
     return handleValidationCommand(subArgs, flags);
   }
-  
+
   if (subArgs.includes('--rollback')) {
     return handleRollbackCommand(subArgs, flags);
   }
-  
+
   if (subArgs.includes('--list-backups')) {
     return handleListBackups(subArgs, flags);
   }
-  
+
   // Check for batch operations
   const batchInitFlag = flags['batch-init'] || subArgs.includes('--batch-init');
   const configFlag = flags.config || subArgs.includes('--config');
-  
+
   if (batchInitFlag || configFlag) {
     return handleBatchInit(subArgs, flags);
   }
-  
+
   // Check if enhanced initialization is requested
   const useEnhanced = subArgs.includes('--enhanced') || subArgs.includes('--safe');
-  
+
   if (useEnhanced) {
     return enhancedInitCommand(subArgs, flags);
   }
-  
+
   // Parse init options
   const initForce = subArgs.includes('--force') || subArgs.includes('-f') || flags.force;
   const initMinimal = subArgs.includes('--minimal') || subArgs.includes('-m') || flags.minimal;
-  const initSparc = subArgs.includes('--sparc') || subArgs.includes('-s') || flags.sparc;
+  const initSparc = true; // SPARC is now included by default
   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
-  
+
   // Get the actual working directory (where the command was run from)
   // 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
   try {
     process.chdir(workingDir);
   } catch (err) {
     printWarning(`Could not change to directory ${workingDir}: ${err.message}`);
   }
-  
+
   try {
     printSuccess('Initializing Claude Code integration files...');
-    
+
     // Check if files already exist in the working directory
     const files = ['CLAUDE.md', 'memory-bank.md', 'coordination.md'];
     const existingFiles = [];
-    
+
     for (const file of files) {
       try {
         await Deno.stat(`${workingDir}/${file}`);
@@ -182,233 +173,120 @@ export async function initCommand(subArgs, flags) {
         // File doesn't exist, which is what we want
       }
     }
-    
+
     if (existingFiles.length > 0 && !initForce) {
       printWarning(`The following files already exist: ${existingFiles.join(', ')}`);
       console.log('Use --force to overwrite existing files');
       return;
     }
-    
-    // Create CLAUDE.md
-    const claudeMd = initOptimized ? await createOptimizedSparcClaudeMd() :
-                     initSparc ? createSparcClaudeMd() : 
-                     initMinimal ? createMinimalClaudeMd() : createFullClaudeMd();
-    
-    if (!initDryRun) {
-      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)' : ''}`);
-    }
-    
-    // Create memory-bank.md
-    const memoryBankMd = initOptimized ? await createOptimizedMemoryBankMd() :
-                         initMinimal ? createMinimalMemoryBankMd() : createFullMemoryBankMd();
-    if (!initDryRun) {
-      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)' : ''));
-    }
-    
-    // Create coordination.md
-    const coordinationMd = initOptimized ? await createOptimizedCoordinationMd() :
-                           initMinimal ? createMinimalCoordinationMd() : createFullCoordinationMd();
-    if (!initDryRun) {
-      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)' : ''));
-    }
-    
-    // Create directory structure
-    const directories = [
-      'memory',
-      'memory/agents',
-      'memory/sessions',
-      'coordination',
-      'coordination/memory_bank',
-      'coordination/subtasks',
-      'coordination/orchestration',
-      '.claude',
-      '.claude/commands',
-      '.claude/commands/sparc',
-      '.claude/commands/swarm',
-      '.claude/logs'
-    ];
-    
-    for (const dir of directories) {
-      try {
-        if (!initDryRun) {
-          await Deno.mkdir(dir, { recursive: true });
-          console.log(`  ✓ Created ${dir}/ directory`);
-        } else {
-          console.log(`  [DRY RUN] Would create ${dir}/ directory`);
-        }
-      } catch (err) {
-        if (err.code !== 'EEXIST') {
-          throw err;
-        }
-      }
-    }
-    
-    // Create SPARC command files if --sparc flag is used
-    if (initSparc && !initDryRun) {
-      try {
-        const sparcTargetDir = `${workingDir}/.claude/commands/sparc`;
-        
-        // Get SPARC mode templates
-        const sparcTemplates = createSparcModeTemplates();
-        
-        console.log('  📁 Creating SPARC command files...');
-        
-        for (const [filename, content] of Object.entries(sparcTemplates)) {
-          try {
-            await Deno.writeTextFile(`${sparcTargetDir}/${filename}`, content);
-            console.log(`    ✓ Created ${filename}`);
-          } catch (err) {
-            console.log(`    ⚠️  Could not create ${filename}: ${err.message}`);
-          }
-        }
-        
-        // Also create sparc-modes.md overview file
-        const sparcModesOverview = createSparcModesOverview();
-        await Deno.writeTextFile(`${sparcTargetDir}/sparc-modes.md`, sparcModesOverview);
-        console.log(`    ✓ Created sparc-modes.md`);
-        
-        console.log('  ✅ SPARC command files created successfully');
-      } catch (err) {
-        console.log(`  ⚠️  Could not create SPARC files: ${err.message}`);
-      }
-      
-      // Also create swarm strategy files
-      try {
-        const swarmTargetDir = `${workingDir}/.claude/commands/swarm`;
-        
-        // Get swarm strategy templates
-        const swarmTemplates = createSwarmStrategyTemplates();
-        
-        console.log('  📁 Creating swarm strategy files...');
-        
-        for (const [filename, content] of Object.entries(swarmTemplates)) {
-          try {
-            await Deno.writeTextFile(`${swarmTargetDir}/${filename}`, content);
-            console.log(`    ✓ Created ${filename}`);
-          } catch (err) {
-            console.log(`    ⚠️  Could not create ${filename}: ${err.message}`);
-          }
+
+    // Use template copier to copy all template files
+    const templateOptions = {
+      sparc: initSparc,
+      minimal: initMinimal,
+      optimized: initOptimized,
+      dryRun: initDryRun,
+      force: initForce,
+      selectedModes: selectedModes,
+    };
+
+    // First try to copy revised templates from repository
+    const validation = validateTemplatesExist();
+    if (validation.valid) {
+      console.log('  📁 Copying revised template files...');
+      const revisedResults = await copyRevisedTemplates(workingDir, {
+        force: initForce,
+        dryRun: initDryRun,
+        verbose: true,
+        sparc: initSparc
+      });
+
+      if (revisedResults.success) {
+        console.log(`  ✅ Copied ${revisedResults.copiedFiles.length} template files`);
+        if (revisedResults.skippedFiles.length > 0) {
+          console.log(`  ⏭️  Skipped ${revisedResults.skippedFiles.length} existing files`);
         }
-        
-        console.log('  ✅ Swarm strategy files created successfully');
-      } catch (err) {
-        console.log(`  ⚠️  Could not create swarm files: ${err.message}`);
-      }
-      
-      // Create .claude/config.json
-      try {
-        const configContent = {
-          "version": "1.0",
-          "sparc": {
-            "enabled": true,
-            "modes": ["orchestrator", "coder", "researcher", "tdd", "architect", "reviewer", "debugger", "tester", "analyzer", "optimizer", "documenter", "designer", "innovator", "swarm-coordinator", "memory-manager", "batch-executor", "workflow-manager"]
-          },
-          "swarm": {
-            "enabled": true,
-            "strategies": ["research", "development", "analysis", "testing", "optimization", "maintenance"]
-          }
-        };
-        
-        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}`);
+      } else {
+        console.log('  ⚠️  Some template files could not be copied:');
+        revisedResults.errors.forEach(err => console.log(`    - ${err}`));
       }
-    }
-    
-    // Create placeholder files for memory directories
-    const agentsReadme = createAgentsReadme();
-    if (!initDryRun) {
-      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');
-    }
-    
-    const sessionsReadme = createSessionsReadme();
-    if (!initDryRun) {
-      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');
-    }
-    
-    // Initialize persistence database
-    const initialData = {
-      agents: [],
-      tasks: [],
-      lastUpdated: Date.now()
-    };
-    if (!initDryRun) {
-      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)');
+      // Fall back to generated templates
+      console.log('  ⚠️  Revised templates not available, using generated templates');
+      const copyResults = await copyTemplates(workingDir, templateOptions);
+
+      if (!copyResults.success) {
+        printError('Failed to copy templates:');
+        copyResults.errors.forEach(err => console.log(`  ❌ ${err}`));
+        return;
+      }
     }
-    
+
+    // Directory structure is created by template copier
+
+    // SPARC files are created by template copier when --sparc flag is used
+
+    // Memory README files and persistence database are created by template copier
+
     // Create local claude-flow executable wrapper
     if (!initDryRun) {
       await createLocalExecutable(workingDir);
     } else {
       console.log('  [DRY RUN] Would create local claude-flow executable wrapper');
     }
-    
+
     // SPARC initialization
     if (initSparc) {
       console.log('\n🚀 Initializing SPARC development environment...');
-      
+
       if (initDryRun) {
         console.log('  [DRY RUN] Would run: npx -y create-sparc init --force');
         console.log('  [DRY RUN] Would create SPARC environment with all modes');
-        console.log('  [DRY RUN] Would create Claude slash commands' + (initOptimized ? ' (Batchtools-optimized)' : ''));
+        console.log(
+          '  [DRY RUN] Would create Claude slash commands' +
+            (initOptimized ? ' (Batchtools-optimized)' : ''),
+        );
         if (selectedModes) {
-          console.log(`  [DRY RUN] Would create commands for selected modes: ${selectedModes.join(', ')}`);
+          console.log(
+            `  [DRY RUN] Would create commands for selected modes: ${selectedModes.join(', ')}`,
+          );
         }
       } else {
         // Check if create-sparc exists and run it
         let sparcInitialized = false;
         try {
+          // Use isolated NPX cache to prevent concurrent conflicts
           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(),
+            env: getIsolatedNpxEnv({
               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;
           } else {
             printWarning('create-sparc failed, creating basic SPARC structure manually...');
-            
+
             // Fallback: create basic SPARC structure manually
             await createSparcStructureManually();
             sparcInitialized = true; // Manual creation still counts as initialized
           }
         } catch (err) {
           printWarning('create-sparc not available, creating basic SPARC structure manually...');
-          
+
           // Fallback: create basic SPARC structure manually
           await createSparcStructureManually();
           sparcInitialized = true; // Manual creation still counts as initialized
         }
-        
+
         // Always create Claude slash commands after SPARC initialization
         if (sparcInitialized) {
           try {
@@ -423,17 +301,23 @@ export async function initCommand(subArgs, flags) {
         }
       }
     }
-    
+
     if (initDryRun) {
-      printSuccess('🔍 Dry run completed! Here\'s what would be created:');
+      printSuccess("🔍 Dry run completed! Here's what would be created:");
       console.log('\n📋 Summary of planned initialization:');
-      console.log(`  • Configuration: ${initOptimized ? 'Batchtools-optimized SPARC' : initSparc ? 'SPARC-enhanced' : 'Standard'}`);
-      console.log(`  • Template type: ${initOptimized ? 'Optimized for parallel processing' : 'Standard'}`);
+      console.log(
+        `  • Configuration: ${initOptimized ? 'Batchtools-optimized SPARC' : initSparc ? 'SPARC-enhanced' : 'Standard'}`,
+      );
+      console.log(
+        `  • Template type: ${initOptimized ? 'Optimized for parallel processing' : 'Standard'}`,
+      );
       console.log('  • Core files: CLAUDE.md, memory-bank.md, coordination.md');
       console.log('  • Directory structure: memory/, coordination/, .claude/');
       console.log('  • Local executable: ./claude-flow');
       if (initSparc) {
-        console.log(`  • Claude Code slash commands: ${selectedModes ? selectedModes.length : 'All'} SPARC mode commands`);
+        console.log(
+          `  • Claude Code slash commands: ${selectedModes ? selectedModes.length : 'All'} SPARC mode commands`,
+        );
         console.log('  • SPARC environment with all development modes');
       }
       if (initOptimized) {
@@ -443,76 +327,95 @@ export async function initCommand(subArgs, flags) {
       console.log('\n🚀 To proceed with initialization, run the same command without --dry-run');
     } else {
       printSuccess('🎉 Claude Code integration files initialized successfully!');
-      
+
       if (initOptimized) {
         console.log('\n⚡ Batchtools Optimization Enabled!');
         console.log('  • Parallel processing capabilities activated');
         console.log('  • Performance improvements: 250-500% faster operations');
         console.log('  • Smart batching and concurrent operations available');
       }
-      
+
       console.log('\n📋 What was created:');
-      console.log(`  ✅ CLAUDE.md (${initOptimized ? 'Batchtools-optimized' : initSparc ? 'SPARC-enhanced' : 'Standard configuration'})`);
-      console.log(`  ✅ memory-bank.md (${initOptimized ? 'With parallel processing' : 'Standard memory system'})`);
-      console.log(`  ✅ coordination.md (${initOptimized ? 'Enhanced with batchtools' : 'Standard coordination'})`);
+      console.log(
+        `  ✅ CLAUDE.md (${initOptimized ? 'Batchtools-optimized' : initSparc ? 'SPARC-enhanced' : 'Standard configuration'})`,
+      );
+      console.log(
+        `  ✅ memory-bank.md (${initOptimized ? 'With parallel processing' : 'Standard memory system'})`,
+      );
+      console.log(
+        `  ✅ coordination.md (${initOptimized ? 'Enhanced with batchtools' : 'Standard coordination'})`,
+      );
       console.log('  ✅ Directory structure with memory/ and coordination/');
       console.log('  ✅ Local executable at ./claude-flow');
       console.log('  ✅ Persistence database at memory/claude-flow-data.json');
-      
+
       if (initSparc) {
         const modeCount = selectedModes ? selectedModes.length : '20+';
         console.log(`  ✅ Claude Code slash commands (${modeCount} SPARC modes)`);
         console.log('  ✅ Complete SPARC development environment');
       }
-      
+
       console.log('\n🚀 Next steps:');
       console.log('1. Review and customize the generated files for your project');
-      console.log('2. Run \'./claude-flow start\' to begin the orchestration system');
-      console.log('3. Use \'./claude-flow\' instead of \'npx claude-flow\' for all commands');
-      console.log('4. Use \'claude --dangerously-skip-permissions\' for unattended operation');
-      
+      console.log("2. Run './claude-flow start' to begin the orchestration system");
+      console.log("3. Use './claude-flow' instead of 'npx claude-flow' for all commands");
+      console.log("4. Use 'claude --dangerously-skip-permissions' for unattended operation");
+
       if (initSparc) {
-        console.log('5. Use Claude Code slash commands: /sparc, /sparc-architect, /sparc-tdd, etc.');
-        console.log('6. Explore SPARC modes with \'./claude-flow sparc modes\'');
+        console.log(
+          '5. Use Claude Code slash commands: /sparc, /sparc-architect, /sparc-tdd, etc.',
+        );
+        console.log("6. Explore SPARC modes with './claude-flow sparc modes'");
         console.log('7. Try TDD workflow with \'./claude-flow sparc tdd "your task"\'');
-        
+
         if (initOptimized) {
           console.log('8. Use batchtools commands: /batchtools, /performance for optimization');
           console.log('9. Enable parallel processing with --parallel flags');
-          console.log('10. Monitor performance with \'./claude-flow performance monitor\'');
+          console.log("10. Monitor performance with './claude-flow performance monitor'");
         }
       }
-      
+
+      // Update .gitignore
+      const gitignoreResult = await updateGitignore(workingDir, initForce, initDryRun);
+      if (gitignoreResult.success) {
+        if (!initDryRun) {
+          console.log(`  ✅ ${gitignoreResult.message}`);
+        } else {
+          console.log(`  ${gitignoreResult.message}`);
+        }
+      } else {
+        console.log(`  ⚠️  ${gitignoreResult.message}`);
+      }
+
       console.log('\n💡 Tips:');
-      console.log('  • Type \'/\' in Claude Code to see all available slash commands');
-      console.log('  • Use \'./claude-flow status\' to check system health');
-      console.log('  • Store important context with \'./claude-flow memory store\'');
-      
+      console.log("  • Type '/' in Claude Code to see all available slash commands");
+      console.log("  • Use './claude-flow status' to check system health");
+      console.log("  • Store important context with './claude-flow memory store'");
+
       if (initOptimized) {
         console.log('  • Use --parallel flags for concurrent operations');
         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
+
+      // Check for Claude Code and set up MCP servers (always enabled by default)
       if (!initDryRun && isClaudeCodeInstalled()) {
         console.log('\n🔍 Claude Code CLI detected!');
-        const setupMcp = !subArgs.includes('--skip-mcp');
-        
-        if (setupMcp) {
+        const skipMcp = subArgs && subArgs.includes && subArgs.includes('--skip-mcp');
+
+        if (!skipMcp) {
           await setupMcpServers(initDryRun);
         } else {
           console.log('  ℹ️  Skipping MCP setup (--skip-mcp flag used)');
         }
       } else if (!initDryRun && !isClaudeCodeInstalled()) {
         console.log('\n⚠️  Claude Code CLI not detected!');
-        console.log('  📥 Install with: npm install -g @anthropics/claude-code');
+        console.log('  📥 Install with: npm install -g @anthropic-ai/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) {
     printError(`Failed to initialize files: ${err.message}`);
   }
@@ -530,17 +433,19 @@ async function handleBatchInit(subArgs, flags) {
       maxConcurrency: flags['max-concurrent'] || 5,
       progressTracking: true,
       template: flags.template,
-      environments: flags.environments ? flags.environments.split(',').map(env => env.trim()) : ['dev']
+      environments: flags.environments
+        ? flags.environments.split(',').map((env) => env.trim())
+        : ['dev'],
     };
-    
+
     // Validate options
     const validationErrors = validateBatchOptions(options);
     if (validationErrors.length > 0) {
       printError('Batch options validation failed:');
-      validationErrors.forEach(error => console.error(`  - ${error}`));
+      validationErrors.forEach((error) => console.error(`  - ${error}`));
       return;
     }
-    
+
     // Config file mode
     if (flags.config) {
       const configFile = flags.config;
@@ -551,24 +456,24 @@ async function handleBatchInit(subArgs, flags) {
       }
       return;
     }
-    
-    // Batch init mode  
+
+    // Batch init mode
     if (flags['batch-init']) {
       const projectsString = flags['batch-init'];
-      const projects = projectsString.split(',').map(project => project.trim());
-      
+      const projects = projectsString.split(',').map((project) => project.trim());
+
       if (projects.length === 0) {
         printError('No projects specified for batch initialization');
         return;
       }
-      
+
       printSuccess(`Initializing ${projects.length} projects in batch mode`);
       const results = await batchInitCommand(projects, options);
-      
+
       if (results) {
-        const successful = results.filter(r => r.success).length;
-        const failed = results.filter(r => !r.success).length;
-        
+        const successful = results.filter((r) => r.success).length;
+        const failed = results.filter((r) => !r.success).length;
+
         if (failed === 0) {
           printSuccess(`All ${successful} projects initialized successfully`);
         } else {
@@ -577,9 +482,8 @@ async function handleBatchInit(subArgs, flags) {
       }
       return;
     }
-    
+
     printError('No batch operation specified. Use --batch-init <projects> or --config <file>');
-    
   } catch (err) {
     printError(`Batch initialization failed: ${err.message}`);
   }
@@ -590,43 +494,47 @@ 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 = Deno.env.get('PWD') || Deno.cwd();
-  
+
   // Initialize systems
   const rollbackSystem = new RollbackSystem(workingDir);
   const validationSystem = new ValidationSystem(workingDir);
-  
+
   let atomicOp = null;
-  
+
   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:');
-        preValidation.errors.forEach(error => console.error(`  ❌ ${error}`));
+        preValidation.errors.forEach((error) => console.error(`  ❌ ${error}`));
         return;
       }
-      
+
       if (preValidation.warnings.length > 0) {
         printWarning('Pre-initialization warnings:');
-        preValidation.warnings.forEach(warning => console.warn(`  ⚠️  ${warning}`));
+        preValidation.warnings.forEach((warning) => console.warn(`  ⚠️  ${warning}`));
       }
-      
+
       printSuccess('Pre-initialization validation passed');
     }
 
@@ -640,10 +548,10 @@ async function enhancedInitCommand(subArgs, flags) {
     if (!options.skipBackup) {
       console.log('\n💾 Phase 2: Creating backup...');
       const backupResult = await rollbackSystem.createPreInitBackup();
-      
+
       if (!backupResult.success) {
         printError('Backup creation failed:');
-        backupResult.errors.forEach(error => console.error(`  ❌ ${error}`));
+        backupResult.errors.forEach((error) => console.error(`  ❌ ${error}`));
         return;
       }
     }
@@ -651,7 +559,7 @@ async function enhancedInitCommand(subArgs, flags) {
     // Phase 3: Initialize with atomic operations
     console.log('\n🔧 Phase 3: Atomic initialization...');
     atomicOp = createAtomicOperation(rollbackSystem, 'enhanced-init');
-    
+
     const atomicBegin = await atomicOp.begin();
     if (!atomicBegin) {
       printError('Failed to begin atomic operation');
@@ -659,16 +567,16 @@ async function enhancedInitCommand(subArgs, flags) {
     }
 
     // Perform initialization steps with checkpoints
-    await performInitializationWithCheckpoints(rollbackSystem, options, workingDir);
+    await performInitializationWithCheckpoints(rollbackSystem, options, workingDir, dryRun);
 
     // Phase 4: Post-initialization validation
     console.log('\n✅ Phase 4: Post-initialization validation...');
     const postValidation = await validationSystem.validatePostInit();
-    
+
     if (!postValidation.success) {
       printError('Post-initialization validation failed:');
-      postValidation.errors.forEach(error => console.error(`  ❌ ${error}`));
-      
+      postValidation.errors.forEach((error) => console.error(`  ❌ ${error}`));
+
       // Attempt automatic rollback
       console.log('\n🔄 Attempting automatic rollback...');
       await atomicOp.rollback();
@@ -679,39 +587,38 @@ async function enhancedInitCommand(subArgs, flags) {
     // Phase 5: Configuration validation
     console.log('\n🔧 Phase 5: Configuration validation...');
     const configValidation = await validationSystem.validateConfiguration();
-    
+
     if (configValidation.warnings.length > 0) {
       printWarning('Configuration warnings:');
-      configValidation.warnings.forEach(warning => console.warn(`  ⚠️  ${warning}`));
+      configValidation.warnings.forEach((warning) => console.warn(`  ⚠️  ${warning}`));
     }
 
     // Phase 6: Health checks
     console.log('\n🏥 Phase 6: System health checks...');
     const healthChecks = await validationSystem.runHealthChecks();
-    
+
     if (healthChecks.warnings.length > 0) {
       printWarning('Health check warnings:');
-      healthChecks.warnings.forEach(warning => console.warn(`  ⚠️  ${warning}`));
+      healthChecks.warnings.forEach((warning) => console.warn(`  ⚠️  ${warning}`));
     }
 
     // Commit atomic operation
     await atomicOp.commit();
-    
+
     // Generate and display validation report
-    const fullValidation = await runFullValidation(workingDir, { 
+    const fullValidation = await runFullValidation(workingDir, {
       postInit: true,
-      skipPreInit: options.skipPreValidation 
+      skipPreInit: options.skipPreValidation,
     });
-    
+
     console.log('\n📊 Validation Report:');
     console.log(fullValidation.report);
 
     printSuccess('🎉 Enhanced initialization completed successfully!');
     console.log('\n✨ Your SPARC environment is fully validated and ready to use');
-    
   } catch (error) {
     printError(`Enhanced initialization failed: ${error.message}`);
-    
+
     // Attempt rollback if atomic operation is active
     if (atomicOp && !atomicOp.completed) {
       console.log('\n🔄 Performing emergency rollback...');
@@ -730,29 +637,28 @@ async function enhancedInitCommand(subArgs, flags) {
  */
 async function handleValidationCommand(subArgs, flags) {
   const workingDir = Deno.env.get('PWD') || Deno.cwd();
-  
+
   console.log('🔍 Running validation checks...');
-  
+
   const options = {
     skipPreInit: subArgs.includes('--skip-pre-init'),
     skipConfig: subArgs.includes('--skip-config'),
     skipModeTest: subArgs.includes('--skip-mode-test'),
-    postInit: !subArgs.includes('--pre-init-only')
+    postInit: !subArgs.includes('--pre-init-only'),
   };
-  
+
   try {
     const validationResults = await runFullValidation(workingDir, options);
-    
+
     console.log('\n📊 Validation Results:');
     console.log(validationResults.report);
-    
+
     if (validationResults.success) {
       printSuccess('✅ All validation checks passed');
     } else {
       printError('❌ Some validation checks failed');
       process.exit(1);
     }
-    
   } catch (error) {
     printError(`Validation failed: ${error.message}`);
     process.exit(1);
@@ -765,59 +671,59 @@ async function handleValidationCommand(subArgs, flags) {
 async function handleRollbackCommand(subArgs, flags) {
   const workingDir = Deno.env.get('PWD') || Deno.cwd();
   const rollbackSystem = new RollbackSystem(workingDir);
-  
+
   try {
     // Check for specific rollback options
     if (subArgs.includes('--full')) {
       console.log('🔄 Performing full rollback...');
       const result = await rollbackSystem.performFullRollback();
-      
+
       if (result.success) {
         printSuccess('Full rollback completed successfully');
       } else {
         printError('Full rollback failed:');
-        result.errors.forEach(error => console.error(`  ❌ ${error}`));
+        result.errors.forEach((error) => console.error(`  ❌ ${error}`));
       }
-      
     } else if (subArgs.includes('--partial')) {
-      const phaseIndex = subArgs.findIndex(arg => arg === '--phase');
+      const phaseIndex = subArgs.findIndex((arg) => arg === '--phase');
       if (phaseIndex !== -1 && subArgs[phaseIndex + 1]) {
         const phase = subArgs[phaseIndex + 1];
         console.log(`🔄 Performing partial rollback for phase: ${phase}`);
-        
+
         const result = await rollbackSystem.performPartialRollback(phase);
-        
+
         if (result.success) {
           printSuccess(`Partial rollback completed for phase: ${phase}`);
         } else {
           printError(`Partial rollback failed for phase: ${phase}`);
-          result.errors.forEach(error => console.error(`  ❌ ${error}`));
+          result.errors.forEach((error) => console.error(`  ❌ ${error}`));
         }
       } else {
         printError('Partial rollback requires --phase <phase-name>');
       }
-      
     } else {
       // Interactive rollback point selection
       const rollbackPoints = await rollbackSystem.listRollbackPoints();
-      
+
       if (rollbackPoints.rollbackPoints.length === 0) {
         printWarning('No rollback points available');
         return;
       }
-      
+
       console.log('\n📋 Available rollback points:');
       rollbackPoints.rollbackPoints.forEach((point, index) => {
         const date = new Date(point.timestamp).toLocaleString();
         console.log(`  ${index + 1}. ${point.type} - ${date}`);
       });
-      
+
       // For now, rollback to the most recent point
       const latest = rollbackPoints.rollbackPoints[0];
       if (latest) {
-        console.log(`\n🔄 Rolling back to: ${latest.type} (${new Date(latest.timestamp).toLocaleString()})`);
+        console.log(
+          `\n🔄 Rolling back to: ${latest.type} (${new Date(latest.timestamp).toLocaleString()})`,
+        );
         const result = await rollbackSystem.performFullRollback(latest.backupId);
-        
+
         if (result.success) {
           printSuccess('Rollback completed successfully');
         } else {
@@ -825,7 +731,6 @@ async function handleRollbackCommand(subArgs, flags) {
         }
       }
     }
-    
   } catch (error) {
     printError(`Rollback operation failed: ${error.message}`);
   }
@@ -837,12 +742,12 @@ async function handleRollbackCommand(subArgs, flags) {
 async function handleListBackups(subArgs, flags) {
   const workingDir = Deno.env.get('PWD') || Deno.cwd();
   const rollbackSystem = new RollbackSystem(workingDir);
-  
+
   try {
     const rollbackPoints = await rollbackSystem.listRollbackPoints();
-    
+
     console.log('\n📋 Rollback Points and Backups:');
-    
+
     if (rollbackPoints.rollbackPoints.length === 0) {
       console.log('  No rollback points available');
     } else {
@@ -852,7 +757,7 @@ async function handleListBackups(subArgs, flags) {
         console.log(`  ${index + 1}. ${point.type} - ${date} (${point.backupId || 'No backup'})`);
       });
     }
-    
+
     if (rollbackPoints.checkpoints.length > 0) {
       console.log('\n📍 Checkpoints:');
       rollbackPoints.checkpoints.slice(-5).forEach((checkpoint, index) => {
@@ -860,7 +765,6 @@ async function handleListBackups(subArgs, flags) {
         console.log(`  ${index + 1}. ${checkpoint.phase} - ${date} (${checkpoint.status})`);
       });
     }
-    
   } catch (error) {
     printError(`Failed to list backups: ${error.message}`);
   }
@@ -869,31 +773,36 @@ async function handleListBackups(subArgs, flags) {
 /**
  * Perform initialization with checkpoints
  */
-async function performInitializationWithCheckpoints(rollbackSystem, options, workingDir) {
+async function performInitializationWithCheckpoints(
+  rollbackSystem,
+  options,
+  workingDir,
+  dryRun = false,
+) {
   const phases = [
-    { name: 'file-creation', action: () => createInitialFiles(options, workingDir) },
-    { name: 'directory-structure', action: () => createDirectoryStructure(workingDir) },
-    { name: 'memory-setup', action: () => setupMemorySystem(workingDir) },
-    { name: 'coordination-setup', action: () => setupCoordinationSystem(workingDir) },
-    { name: 'executable-creation', action: () => createLocalExecutable(workingDir) }
+    { name: 'file-creation', action: () => createInitialFiles(options, workingDir, dryRun) },
+    { name: 'directory-structure', action: () => createDirectoryStructure(workingDir, dryRun) },
+    { name: 'memory-setup', action: () => setupMemorySystem(workingDir, dryRun) },
+    { name: 'coordination-setup', action: () => setupCoordinationSystem(workingDir, dryRun) },
+    { name: 'executable-creation', action: () => createLocalExecutable(workingDir, dryRun) },
   ];
-  
+
   if (options.sparc) {
     phases.push(
       { name: 'sparc-init', action: () => createSparcStructureManually() },
-      { name: 'claude-commands', action: () => createClaudeSlashCommands(workingDir) }
+      { name: 'claude-commands', action: () => createClaudeSlashCommands(workingDir) },
     );
   }
-  
+
   for (const phase of phases) {
     console.log(`  🔧 ${phase.name}...`);
-    
+
     // Create checkpoint before phase
     await rollbackSystem.createCheckpoint(phase.name, {
       timestamp: Date.now(),
-      phase: phase.name
+      phase: phase.name,
     });
-    
+
     try {
       await phase.action();
       console.log(`  ✅ ${phase.name} completed`);
@@ -905,39 +814,60 @@ async function performInitializationWithCheckpoints(rollbackSystem, options, wor
 }
 
 // Helper functions for atomic initialization
-async function createInitialFiles(options, workingDir) {
-  const claudeMd = options.sparc ? createSparcClaudeMd() : 
-                   options.minimal ? createMinimalClaudeMd() : createFullClaudeMd();
-  await Deno.writeTextFile(`${workingDir}/CLAUDE.md`, claudeMd);
+async function createInitialFiles(options, workingDir, dryRun = false) {
+  if (!dryRun) {
+    const claudeMd = options.sparc
+      ? createSparcClaudeMd()
+      : options.minimal
+        ? createMinimalClaudeMd()
+        : createFullClaudeMd();
+    await Deno.writeTextFile(`${workingDir}/CLAUDE.md`, claudeMd);
 
-  const memoryBankMd = options.minimal ? createMinimalMemoryBankMd() : createFullMemoryBankMd();
-  await Deno.writeTextFile(`${workingDir}/memory-bank.md`, memoryBankMd);
+    const memoryBankMd = options.minimal ? createMinimalMemoryBankMd() : createFullMemoryBankMd();
+    await Deno.writeTextFile(`${workingDir}/memory-bank.md`, memoryBankMd);
 
-  const coordinationMd = options.minimal ? createMinimalCoordinationMd() : createFullCoordinationMd();
-  await Deno.writeTextFile(`${workingDir}/coordination.md`, coordinationMd);
+    const coordinationMd = options.minimal
+      ? createMinimalCoordinationMd()
+      : createFullCoordinationMd();
+    await Deno.writeTextFile(`${workingDir}/coordination.md`, coordinationMd);
+  }
 }
 
-async function createDirectoryStructure(workingDir) {
+async function createDirectoryStructure(workingDir, dryRun = false) {
   const directories = [
-    'memory', 'memory/agents', 'memory/sessions',
-    'coordination', 'coordination/memory_bank', 'coordination/subtasks', 'coordination/orchestration',
-    '.claude', '.claude/commands', '.claude/logs'
+    'memory',
+    'memory/agents',
+    'memory/sessions',
+    'coordination',
+    'coordination/memory_bank',
+    'coordination/subtasks',
+    'coordination/orchestration',
+    '.claude',
+    '.claude/commands',
+    '.claude/logs',
   ];
-  
-  for (const dir of directories) {
-    await Deno.mkdir(`${workingDir}/${dir}`, { recursive: true });
+
+  if (!dryRun) {
+    for (const dir of directories) {
+      await Deno.mkdir(`${workingDir}/${dir}`, { recursive: true });
+    }
   }
 }
 
-async function setupMemorySystem(workingDir) {
-  const initialData = { agents: [], tasks: [], lastUpdated: Date.now() };
-  await Deno.writeTextFile(`${workingDir}/memory/claude-flow-data.json`, JSON.stringify(initialData, null, 2));
-  
-  await Deno.writeTextFile(`${workingDir}/memory/agents/README.md`, createAgentsReadme());
-  await Deno.writeTextFile(`${workingDir}/memory/sessions/README.md`, createSessionsReadme());
+async function setupMemorySystem(workingDir, dryRun = false) {
+  if (!dryRun) {
+    const initialData = { agents: [], tasks: [], lastUpdated: Date.now() };
+    await Deno.writeTextFile(
+      `${workingDir}/memory/claude-flow-data.json`,
+      JSON.stringify(initialData, null, 2),
+    );
+
+    await Deno.writeTextFile(`${workingDir}/memory/agents/README.md`, createAgentsReadme());
+    await Deno.writeTextFile(`${workingDir}/memory/sessions/README.md`, createSessionsReadme());
+  }
 }
 
-async function setupCoordinationSystem(workingDir) {
+async function setupCoordinationSystem(workingDir, dryRun = false) {
   // Coordination system is already set up by createDirectoryStructure
   // This is a placeholder for future coordination setup logic
 }
@@ -945,34 +875,43 @@ 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;
-  
+
   try {
     // Check existing files
     const existingFiles = [];
-    const filesToCheck = ['CLAUDE.md', '.claude/settings.json'];
-    
+    const filesToCheck = [
+      'CLAUDE.md',
+      '.claude/settings.json',
+      '.mcp.json',
+      'claude-flow.config.json',
+    ];
+
     for (const file of filesToCheck) {
       if (existsSync(`${workingDir}/${file}`)) {
         existingFiles.push(file);
       }
     }
-    
+
     if (existingFiles.length > 0 && !force) {
       printWarning(`The following files already exist: ${existingFiles.join(', ')}`);
       console.log('Use --force to overwrite existing files');
       return;
     }
-    
+
     // Create CLAUDE.md
     if (!dryRun) {
       await Deno.writeTextFile(`${workingDir}/CLAUDE.md`, createEnhancedClaudeMd());
@@ -980,7 +919,7 @@ async function enhancedClaudeFlowInit(flags) {
     } else {
       console.log('[DRY RUN] Would create CLAUDE.md (Claude Flow v2.0.0)');
     }
-    
+
     // Create .claude directory structure
     const claudeDir = `${workingDir}/.claude`;
     if (!dryRun) {
@@ -991,7 +930,7 @@ async function enhancedClaudeFlowInit(flags) {
     } else {
       console.log('[DRY RUN] Would create .claude directory structure');
     }
-    
+
     // Create settings.json
     if (!dryRun) {
       await Deno.writeTextFile(`${claudeDir}/settings.json`, createEnhancedSettingsJson());
@@ -999,14 +938,89 @@ async function enhancedClaudeFlowInit(flags) {
     } 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 .mcp.json at project root for MCP server configuration
+    const mcpConfig = {
+      mcpServers: {
+        'claude-flow': {
+          command: 'npx',
+          args: ['claude-flow@alpha', 'mcp', 'start'],
+          type: 'stdio',
+        },
+        'ruv-swarm': {
+          command: 'npx',
+          args: ['ruv-swarm@latest', 'mcp', 'start'],
+          type: 'stdio',
+        },
+      },
+    };
+
+    if (!dryRun) {
+      await Deno.writeTextFile(`${workingDir}/.mcp.json`, JSON.stringify(mcpConfig, null, 2));
+      printSuccess('✓ Created .mcp.json at project root for MCP server configuration');
+    } else {
+      console.log('[DRY RUN] Would create .mcp.json at project root for MCP server configuration');
+    }
+
+    // Create claude-flow.config.json for Claude Flow specific settings
+    const claudeFlowConfig = {
+      features: {
+        autoTopologySelection: true,
+        parallelExecution: true,
+        neuralTraining: true,
+        bottleneckAnalysis: true,
+        smartAutoSpawning: true,
+        selfHealingWorkflows: true,
+        crossSessionMemory: true,
+        githubIntegration: true,
+      },
+      performance: {
+        maxAgents: 10,
+        defaultTopology: 'hierarchical',
+        executionStrategy: 'parallel',
+        tokenOptimization: true,
+        cacheEnabled: true,
+        telemetryLevel: 'detailed',
+      },
+    };
+
+    if (!dryRun) {
+      await Deno.writeTextFile(
+        `${workingDir}/claude-flow.config.json`,
+        JSON.stringify(claudeFlowConfig, null, 2),
+      );
+      printSuccess('✓ Created claude-flow.config.json for Claude Flow settings');
+    } else {
+      console.log('[DRY RUN] Would create claude-flow.config.json for Claude Flow settings');
+    }
+
     // Create command documentation
     for (const [category, commands] of Object.entries(COMMAND_STRUCTURE)) {
       const categoryDir = `${claudeDir}/commands/${category}`;
-      
+
       if (!dryRun) {
         await Deno.mkdir(categoryDir, { recursive: true });
-        
+
         // Create category README
         const categoryReadme = `# ${category.charAt(0).toUpperCase() + category.slice(1)} Commands
 
@@ -1014,10 +1028,10 @@ Commands for ${category} operations in Claude Flow.
 
 ## Available Commands
 
-${commands.map(cmd => `- [${cmd}](./${cmd}.md)`).join('\n')}
+${commands.map((cmd) => `- [${cmd}](./${cmd}.md)`).join('\n')}
 `;
         await Deno.writeTextFile(`${categoryDir}/README.md`, categoryReadme);
-        
+
         // Create individual command docs
         for (const command of commands) {
           const doc = createCommandDoc(category, command);
@@ -1025,31 +1039,31 @@ ${commands.map(cmd => `- [${cmd}](./${cmd}.md)`).join('\n')}
             await Deno.writeTextFile(`${categoryDir}/${command}.md`, doc);
           }
         }
-        
+
         console.log(`  ✓ Created ${commands.length} ${category} command docs`);
       } else {
         console.log(`[DRY RUN] Would create ${commands.length} ${category} command docs`);
       }
     }
-    
+
     // Create wrapper scripts
     if (!dryRun) {
-      // Unix wrapper
+      // Unix wrapper - now uses universal ES module compatible wrapper
       const unixWrapper = createWrapperScript('unix');
       await Deno.writeTextFile(`${workingDir}/claude-flow`, unixWrapper);
       await fs.chmod(`${workingDir}/claude-flow`, 0o755);
-      
+
       // Windows wrapper
       await Deno.writeTextFile(`${workingDir}/claude-flow.bat`, createWrapperScript('windows'));
-      
+
       // PowerShell wrapper
       await Deno.writeTextFile(`${workingDir}/claude-flow.ps1`, createWrapperScript('powershell'));
-      
+
       printSuccess('✓ Created platform-specific wrapper scripts');
     } else {
       console.log('[DRY RUN] Would create wrapper scripts');
     }
-    
+
     // Create helper scripts
     const helpers = ['setup-mcp.sh', 'quick-start.sh', 'github-setup.sh'];
     for (const helper of helpers) {
@@ -1061,66 +1075,211 @@ ${commands.map(cmd => `- [${cmd}](./${cmd}.md)`).join('\n')}
         }
       }
     }
-    
+
     if (!dryRun) {
       printSuccess(`✓ Created ${helpers.length} helper scripts`);
     } else {
       console.log(`[DRY RUN] Would create ${helpers.length} helper scripts`);
     }
-    
+
     // Create standard directories from original init
     const standardDirs = [
       'memory',
-      'memory/agents', 
+      'memory/agents',
       'memory/sessions',
       'coordination',
       'coordination/memory_bank',
       'coordination/subtasks',
-      'coordination/orchestration'
+      'coordination/orchestration',
+      '.swarm', // Add .swarm directory for shared memory
+      '.hive-mind', // Add .hive-mind directory for hive-mind system
     ];
-    
+
     for (const dir of standardDirs) {
       if (!dryRun) {
         await fs.mkdir(`${workingDir}/${dir}`, { recursive: true });
       }
     }
-    
+
     if (!dryRun) {
       printSuccess('✓ Created standard directory structure');
-      
+
       // Initialize memory system
       const initialData = { agents: [], tasks: [], lastUpdated: Date.now() };
-      await fs.writeFile(`${workingDir}/memory/claude-flow-data.json`, JSON.stringify(initialData, null, 2));
-      
+      await fs.writeFile(
+        `${workingDir}/memory/claude-flow-data.json`,
+        JSON.stringify(initialData, null, 2),
+      );
+
       // Create README files
       await fs.writeFile(`${workingDir}/memory/agents/README.md`, createAgentsReadme());
       await fs.writeFile(`${workingDir}/memory/sessions/README.md`, createSessionsReadme());
-      
+
       printSuccess('✓ Initialized memory system');
+
+      // Initialize memory database with fallback support
+      try {
+        // Import and initialize FallbackMemoryStore to create the database
+        const { FallbackMemoryStore } = await import('../../../memory/fallback-store.js');
+        const memoryStore = new FallbackMemoryStore();
+        await memoryStore.initialize();
+
+        if (memoryStore.isUsingFallback()) {
+          printSuccess('✓ Initialized memory system (in-memory fallback for npx compatibility)');
+          console.log(
+            '  💡 For persistent storage, install locally: npm install claude-flow@alpha',
+          );
+        } else {
+          printSuccess('✓ Initialized memory database (.swarm/memory.db)');
+        }
+
+        memoryStore.close();
+      } catch (err) {
+        console.log(`  ⚠️  Could not initialize memory system: ${err.message}`);
+        console.log('     Memory will be initialized on first use');
+      }
+
+      // Initialize hive-mind configuration
+      try {
+        const hiveMindConfig = {
+          version: '2.0.0',
+          initialized: new Date().toISOString(),
+          defaults: {
+            queenType: 'strategic',
+            maxWorkers: 8,
+            consensusAlgorithm: 'majority',
+            memorySize: 100,
+            autoScale: true,
+            encryption: false,
+          },
+          mcpTools: {
+            enabled: true,
+            parallel: true,
+            timeout: 60000,
+          },
+        };
+
+        await fs.writeFile(
+          `${workingDir}/.hive-mind/config.json`,
+          JSON.stringify(hiveMindConfig, null, 2),
+        );
+        
+        // Initialize hive.db
+        try {
+          const Database = (await import('better-sqlite3')).default;
+          const hivePath = `${workingDir}/.hive-mind/hive.db`;
+          const hiveDb = new Database(hivePath);
+          
+          // Create initial tables
+          hiveDb.exec(`
+            CREATE TABLE IF NOT EXISTS swarms (
+              id TEXT PRIMARY KEY,
+              name TEXT NOT NULL,
+              objective TEXT,
+              status TEXT DEFAULT 'active',
+              queen_type TEXT DEFAULT 'strategic',
+              created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+              updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+            );
+            
+            CREATE TABLE IF NOT EXISTS agents (
+              id TEXT PRIMARY KEY,
+              swarm_id TEXT,
+              name TEXT NOT NULL,
+              type TEXT NOT NULL,
+              role TEXT,
+              capabilities TEXT,
+              status TEXT DEFAULT 'active',
+              performance_score REAL DEFAULT 0.5,
+              created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+              FOREIGN KEY (swarm_id) REFERENCES swarms (id)
+            );
+            
+            CREATE TABLE IF NOT EXISTS messages (
+              id TEXT PRIMARY KEY,
+              swarm_id TEXT,
+              agent_id TEXT,
+              content TEXT NOT NULL,
+              type TEXT DEFAULT 'task',
+              timestamp DATETIME DEFAULT CURRENT_TIMESTAMP,
+              FOREIGN KEY (swarm_id) REFERENCES swarms (id),
+              FOREIGN KEY (agent_id) REFERENCES agents (id)
+            );
+          `);
+          
+          hiveDb.close();
+          printSuccess('✓ Initialized hive-mind database (.hive-mind/hive.db)');
+        } catch (dbErr) {
+          console.log(`  ⚠️  Could not initialize hive-mind database: ${dbErr.message}`);
+        }
+        
+        printSuccess('✓ Initialized hive-mind system');
+      } catch (err) {
+        console.log(`  ⚠️  Could not initialize hive-mind system: ${err.message}`);
+      }
     }
-    
-    // Check for Claude Code and set up MCP servers
+
+    // Update .gitignore with Claude Flow entries
+    const gitignoreResult = await updateGitignore(workingDir, force, dryRun);
+    if (gitignoreResult.success) {
+      if (!dryRun) {
+        printSuccess(`✓ ${gitignoreResult.message}`);
+      } else {
+        console.log(gitignoreResult.message);
+      }
+    } else {
+      console.log(`  ⚠️  ${gitignoreResult.message}`);
+    }
+
+    // SPARC initialization (now included by default)
+    console.log('\n🚀 Initializing SPARC development environment...');
+    let sparcInitialized = false;
+    try {
+      // Run create-sparc
+      console.log('  🔄 Running: npx -y create-sparc init --force');
+      execSync('npx -y create-sparc init --force', {
+        cwd: workingDir,
+        stdio: 'inherit',
+      });
+      sparcInitialized = true;
+      printSuccess('✅ SPARC environment initialized successfully');
+    } catch (err) {
+      console.log(`  ⚠️  Could not run create-sparc: ${err.message}`);
+      console.log('     SPARC features will be limited to basic functionality');
+    }
+
+    // Create Claude slash commands for SPARC
+    if (sparcInitialized && !dryRun) {
+      console.log('\n📝 Creating Claude Code slash commands...');
+      await createClaudeSlashCommands(workingDir);
+    }
+
+    // Check for Claude Code and set up MCP servers (always enabled by default)
     if (!dryRun && isClaudeCodeInstalled()) {
       console.log('\n🔍 Claude Code CLI detected!');
-      const setupMcp = !flags['skip-mcp'] && !subArgs.includes('--skip-mcp');
-      
-      if (setupMcp) {
+      const skipMcp =
+        (options && options['skip-mcp']) ||
+        (subArgs && subArgs.includes && subArgs.includes('--skip-mcp'));
+
+      if (!skipMcp) {
         await setupMcpServers(dryRun);
       } else {
-        console.log('  ℹ️  Skipping MCP setup (use --skip-mcp to disable)');
+        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');
+        console.log('     claude mcp add claude-flow npx claude-flow@alpha mcp start');
+        console.log('     claude mcp add ruv-swarm npx ruv-swarm@latest mcp start');
+        console.log('\n  💡 MCP servers are defined in .mcp.json (project scope)');
       }
     } 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('     npm install -g @anthropic-ai/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');
+      console.log('     claude mcp add claude-flow npx claude-flow@alpha mcp start');
+      console.log('     claude mcp add ruv-swarm npx ruv-swarm@latest mcp start');
+      console.log('\n  💡 MCP servers are defined in .mcp.json (project scope)');
     }
-    
+
     // Final instructions
     console.log('\n🎉 Claude Flow v2.0.0 initialization complete!');
     console.log('\n📚 Quick Start:');
@@ -1129,7 +1288,7 @@ ${commands.map(cmd => `- [${cmd}](./${cmd}.md)`).join('\n')}
       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('1. Install Claude Code: npm install -g @anthropic-ai/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');
@@ -1138,8 +1297,7 @@ ${commands.map(cmd => `- [${cmd}](./${cmd}.md)`).join('\n')}
     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}`);
   }
-}
+}