claude-flow 2.0.0-alpha.62 → 2.0.0-alpha.64

package/src/cli/simple-commands/init/template-copier.js

@@ -0,0 +1,583 @@
+// template-copier.js - Copy template files instead of generating them dynamically
+
+import { Deno, existsSync } from '../../node-compat.js';
+import { promises as fs } from 'fs';
+import { dirname, join, relative } from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+/**
+ * Copy template files from the templates directory to the target directory
+ * @param {string} targetDir - The directory to copy templates to
+ * @param {Object} options - Options for template copying
+ * @param {boolean} options.sparc - Whether to include SPARC templates
+ * @param {boolean} options.enhanced - Whether to use enhanced templates
+ * @param {boolean} options.minimal - Whether to use minimal templates
+ * @param {boolean} options.optimized - Whether to use optimized templates
+ * @param {boolean} options.dryRun - Whether to perform a dry run
+ * @param {boolean} options.force - Whether to overwrite existing files
+ * @param {string[]} options.selectedModes - Selected SPARC modes to copy
+ * @returns {Promise<{success: boolean, copiedFiles: string[], errors: string[]}>}
+ */
+export async function copyTemplates(targetDir, options = {}) {
+  const results = {
+    success: true,
+    copiedFiles: [],
+    errors: [],
+  };
+
+  try {
+    const templatesDir = join(__dirname, 'templates');
+    
+    // Determine which template variants to use
+    const templateVariant = options.optimized ? 'optimized' : 
+                          options.enhanced ? 'enhanced' :
+                          options.minimal ? 'minimal' : 
+                          options.sparc ? 'sparc' : 'full';
+
+    // Core files to copy
+    const coreFiles = [
+      { 
+        source: 'CLAUDE.md', 
+        destination: 'CLAUDE.md',
+        useVariant: true 
+      },
+      { 
+        source: 'memory-bank.md', 
+        destination: 'memory-bank.md',
+        useVariant: true 
+      },
+      { 
+        source: 'coordination.md', 
+        destination: 'coordination.md',
+        useVariant: true 
+      },
+    ];
+
+    // Copy core files
+    for (const file of coreFiles) {
+      const sourceFile = file.useVariant && existsSync(join(templatesDir, `${file.source}.${templateVariant}`)) 
+        ? `${file.source}.${templateVariant}`
+        : file.source;
+      
+      const sourcePath = join(templatesDir, sourceFile);
+      const destPath = join(targetDir, file.destination);
+      
+      if (await copyFile(sourcePath, destPath, options)) {
+        results.copiedFiles.push(file.destination);
+      } else if (!options.dryRun) {
+        results.errors.push(`Failed to copy ${file.destination}`);
+      }
+    }
+
+    // Copy .claude directory structure
+    if (options.enhanced || !options.minimal) {
+      const claudeDir = join(targetDir, '.claude');
+      
+      // Copy settings.json
+      const settingsSource = options.enhanced ? 'settings.json.enhanced' : 'settings.json';
+      const settingsPath = join(templatesDir, settingsSource);
+      const settingsDest = join(claudeDir, 'settings.json');
+      
+      if (!options.dryRun) {
+        await fs.mkdir(claudeDir, { recursive: true });
+      }
+      
+      if (await copyFile(settingsPath, settingsDest, options)) {
+        results.copiedFiles.push('.claude/settings.json');
+      }
+
+      // Copy command templates
+      if (options.sparc || options.enhanced) {
+        await copyCommandTemplates(templatesDir, targetDir, options, results);
+      }
+
+      // Copy helper scripts (enhanced mode only)
+      if (options.enhanced) {
+        await copyHelperScripts(templatesDir, targetDir, options, results);
+      }
+    }
+
+    // Copy SPARC-specific files
+    if (options.sparc) {
+      await copySparcTemplates(templatesDir, targetDir, options, results);
+    }
+
+    // Copy wrapper scripts
+    await copyWrapperScripts(templatesDir, targetDir, options, results);
+
+    // Create directory structure
+    await createDirectoryStructure(targetDir, options);
+
+    // Create README files for memory directories
+    await createMemoryReadmeFiles(targetDir, options, results);
+
+  } catch (err) {
+    results.success = false;
+    results.errors.push(`Template copy failed: ${err.message}`);
+  }
+
+  return results;
+}
+
+/**
+ * Copy a single file with options
+ */
+async function copyFile(source, destination, options) {
+  try {
+    // Check if source exists
+    if (!existsSync(source)) {
+      // Try reading from templates directory as fallback
+      const templateContent = await getTemplateContent(source);
+      if (templateContent) {
+        if (!options.dryRun) {
+          await fs.writeFile(destination, templateContent);
+        }
+        console.log(`  ${options.dryRun ? '[DRY RUN] Would create' : '✓ Created'} ${relative(process.cwd(), destination)}`);
+        return true;
+      }
+      console.log(`  ⚠️  Template not found: ${relative(process.cwd(), source)}`);
+      return false;
+    }
+
+    // Check if destination exists and handle force flag
+    if (existsSync(destination) && !options.force) {
+      console.log(`  ⚠️  File already exists: ${relative(process.cwd(), destination)} (use --force to overwrite)`);
+      return false;
+    }
+
+    if (!options.dryRun) {
+      // Ensure destination directory exists
+      await fs.mkdir(dirname(destination), { recursive: true });
+      
+      // Copy the file
+      const content = await fs.readFile(source, 'utf8');
+      await fs.writeFile(destination, content);
+      
+      // Preserve file permissions for executable scripts
+      if (source.endsWith('.sh') || source.includes('claude-flow')) {
+        await fs.chmod(destination, 0o755);
+      }
+    }
+
+    console.log(`  ${options.dryRun ? '[DRY RUN] Would copy' : '✓ Copied'} ${relative(process.cwd(), destination)}`);
+    return true;
+  } catch (err) {
+    console.log(`  ❌ Failed to copy ${relative(process.cwd(), destination)}: ${err.message}`);
+    return false;
+  }
+}
+
+/**
+ * Copy command templates
+ */
+async function copyCommandTemplates(templatesDir, targetDir, options, results) {
+  const commandsSourceDir = join(templatesDir, 'commands');
+  const commandsDestDir = join(targetDir, '.claude', 'commands');
+
+  if (!existsSync(commandsSourceDir)) {
+    // Use generated command templates as fallback
+    return await generateCommandTemplates(targetDir, options, results);
+  }
+
+  try {
+    if (!options.dryRun) {
+      await fs.mkdir(commandsDestDir, { recursive: true });
+    }
+
+    // Copy command categories
+    const categories = await fs.readdir(commandsSourceDir);
+    
+    for (const category of categories) {
+      const categoryPath = join(commandsSourceDir, category);
+      const stat = await fs.stat(categoryPath);
+      
+      if (stat.isDirectory()) {
+        const destCategoryPath = join(commandsDestDir, category);
+        
+        if (!options.dryRun) {
+          await fs.mkdir(destCategoryPath, { recursive: true });
+        }
+
+        // Copy files in category
+        const files = await fs.readdir(categoryPath);
+        for (const file of files) {
+          const sourcePath = join(categoryPath, file);
+          const destPath = join(destCategoryPath, file);
+          
+          if (await copyFile(sourcePath, destPath, options)) {
+            results.copiedFiles.push(join('.claude', 'commands', category, file));
+          }
+        }
+      }
+    }
+  } catch (err) {
+    results.errors.push(`Failed to copy command templates: ${err.message}`);
+  }
+}
+
+/**
+ * Copy SPARC templates
+ */
+async function copySparcTemplates(templatesDir, targetDir, options, results) {
+  const sparcDir = join(targetDir, '.claude', 'commands', 'sparc');
+  
+  try {
+    if (!options.dryRun) {
+      await fs.mkdir(sparcDir, { recursive: true });
+    }
+
+    // Get SPARC mode templates
+    const { createSparcModeTemplates, createSparcModesOverview } = await import('./templates/sparc-modes.js');
+    const sparcTemplates = createSparcModeTemplates();
+    
+    // Filter templates if selectedModes is specified
+    const templatesToCreate = options.selectedModes 
+      ? Object.entries(sparcTemplates).filter(([filename]) => {
+          const mode = filename.replace('.md', '');
+          return options.selectedModes.includes(mode);
+        })
+      : Object.entries(sparcTemplates);
+
+    // Write SPARC mode files
+    for (const [filename, content] of templatesToCreate) {
+      const destPath = join(sparcDir, filename);
+      
+      if (!options.dryRun) {
+        await fs.writeFile(destPath, content);
+      }
+      
+      console.log(`  ${options.dryRun ? '[DRY RUN] Would create' : '✓ Created'} .claude/commands/sparc/${filename}`);
+      results.copiedFiles.push(join('.claude', 'commands', 'sparc', filename));
+    }
+
+    // Create sparc-modes.md overview
+    const overviewPath = join(sparcDir, 'sparc-modes.md');
+    if (!options.dryRun) {
+      await fs.writeFile(overviewPath, createSparcModesOverview());
+    }
+    console.log(`  ${options.dryRun ? '[DRY RUN] Would create' : '✓ Created'} .claude/commands/sparc/sparc-modes.md`);
+    results.copiedFiles.push('.claude/commands/sparc/sparc-modes.md');
+
+    // Copy swarm templates
+    await copySwarmTemplates(templatesDir, targetDir, options, results);
+
+  } catch (err) {
+    results.errors.push(`Failed to copy SPARC templates: ${err.message}`);
+  }
+}
+
+/**
+ * Copy swarm strategy templates
+ */
+async function copySwarmTemplates(templatesDir, targetDir, options, results) {
+  const swarmDir = join(targetDir, '.claude', 'commands', 'swarm');
+  
+  try {
+    if (!options.dryRun) {
+      await fs.mkdir(swarmDir, { recursive: true });
+    }
+
+    // Get swarm strategy templates
+    const { createSwarmStrategyTemplates } = await import('./templates/sparc-modes.js');
+    const swarmTemplates = createSwarmStrategyTemplates();
+
+    // Write swarm strategy files
+    for (const [filename, content] of Object.entries(swarmTemplates)) {
+      const destPath = join(swarmDir, filename);
+      
+      if (!options.dryRun) {
+        await fs.writeFile(destPath, content);
+      }
+      
+      console.log(`  ${options.dryRun ? '[DRY RUN] Would create' : '✓ Created'} .claude/commands/swarm/${filename}`);
+      results.copiedFiles.push(join('.claude', 'commands', 'swarm', filename));
+    }
+  } catch (err) {
+    results.errors.push(`Failed to copy swarm templates: ${err.message}`);
+  }
+}
+
+/**
+ * Copy helper scripts (enhanced mode)
+ */
+async function copyHelperScripts(templatesDir, targetDir, options, results) {
+  const helpersDir = join(targetDir, '.claude', 'helpers');
+  
+  try {
+    if (!options.dryRun) {
+      await fs.mkdir(helpersDir, { recursive: true });
+    }
+
+    const helpers = ['setup-mcp.sh', 'quick-start.sh', 'github-setup.sh'];
+    const { createHelperScript } = await import('./templates/enhanced-templates.js');
+    
+    for (const helper of helpers) {
+      const content = createHelperScript(helper);
+      if (content) {
+        const destPath = join(helpersDir, helper);
+        
+        if (!options.dryRun) {
+          await fs.writeFile(destPath, content);
+          await fs.chmod(destPath, 0o755);
+        }
+        
+        console.log(`  ${options.dryRun ? '[DRY RUN] Would create' : '✓ Created'} .claude/helpers/${helper}`);
+        results.copiedFiles.push(join('.claude', 'helpers', helper));
+      }
+    }
+  } catch (err) {
+    results.errors.push(`Failed to copy helper scripts: ${err.message}`);
+  }
+}
+
+/**
+ * Copy wrapper scripts
+ */
+async function copyWrapperScripts(templatesDir, targetDir, options, results) {
+  try {
+    // Unix wrapper
+    const unixWrapperPath = join(targetDir, 'claude-flow');
+    const unixWrapperSource = join(templatesDir, 'claude-flow-universal');
+    
+    if (await copyFile(unixWrapperSource, unixWrapperPath, options)) {
+      if (!options.dryRun) {
+        await fs.chmod(unixWrapperPath, 0o755);
+      }
+      results.copiedFiles.push('claude-flow');
+    }
+
+    // Windows batch wrapper
+    const batchWrapperPath = join(targetDir, 'claude-flow.bat');
+    const batchWrapperSource = join(templatesDir, 'claude-flow.bat');
+    
+    if (await copyFile(batchWrapperSource, batchWrapperPath, options)) {
+      results.copiedFiles.push('claude-flow.bat');
+    }
+
+    // PowerShell wrapper
+    const psWrapperPath = join(targetDir, 'claude-flow.ps1');
+    const psWrapperSource = join(templatesDir, 'claude-flow.ps1');
+    
+    if (await copyFile(psWrapperSource, psWrapperPath, options)) {
+      results.copiedFiles.push('claude-flow.ps1');
+    }
+  } catch (err) {
+    results.errors.push(`Failed to copy wrapper scripts: ${err.message}`);
+  }
+}
+
+/**
+ * Create directory structure
+ */
+async function createDirectoryStructure(targetDir, options) {
+  const directories = [
+    'memory',
+    'memory/agents',
+    'memory/sessions',
+    'coordination',
+    'coordination/memory_bank',
+    'coordination/subtasks',
+    'coordination/orchestration',
+    '.claude',
+    '.claude/commands',
+    '.claude/logs',
+    '.swarm', // For memory persistence
+  ];
+
+  if (options.sparc) {
+    directories.push(
+      '.claude/commands/sparc',
+      '.claude/commands/swarm'
+    );
+  }
+
+  for (const dir of directories) {
+    const dirPath = join(targetDir, dir);
+    try {
+      if (!options.dryRun) {
+        await fs.mkdir(dirPath, { recursive: true });
+      }
+      console.log(`  ${options.dryRun ? '[DRY RUN] Would create' : '✓ Created'} ${dir}/ directory`);
+    } catch (err) {
+      if (err.code !== 'EEXIST') {
+        console.log(`  ❌ Failed to create ${dir}/: ${err.message}`);
+      }
+    }
+  }
+}
+
+/**
+ * Create README files for memory directories
+ */
+async function createMemoryReadmeFiles(targetDir, options, results) {
+  const { createAgentsReadme, createSessionsReadme } = await import('./templates/readme-files.js');
+  
+  const readmeFiles = [
+    { path: 'memory/agents/README.md', content: createAgentsReadme() },
+    { path: 'memory/sessions/README.md', content: createSessionsReadme() },
+  ];
+
+  for (const { path, content } of readmeFiles) {
+    const fullPath = join(targetDir, path);
+    
+    try {
+      if (!options.dryRun) {
+        await fs.mkdir(dirname(fullPath), { recursive: true });
+        await fs.writeFile(fullPath, content);
+      }
+      console.log(`  ${options.dryRun ? '[DRY RUN] Would create' : '✓ Created'} ${path}`);
+      results.copiedFiles.push(path);
+    } catch (err) {
+      results.errors.push(`Failed to create ${path}: ${err.message}`);
+    }
+  }
+
+  // Initialize persistence database
+  const dbPath = join(targetDir, 'memory', 'claude-flow-data.json');
+  const initialData = {
+    agents: [],
+    tasks: [],
+    lastUpdated: Date.now(),
+  };
+
+  try {
+    if (!options.dryRun) {
+      await fs.writeFile(dbPath, JSON.stringify(initialData, null, 2));
+    }
+    console.log(`  ${options.dryRun ? '[DRY RUN] Would create' : '✓ Created'} memory/claude-flow-data.json (persistence database)`);
+    results.copiedFiles.push('memory/claude-flow-data.json');
+  } catch (err) {
+    results.errors.push(`Failed to create persistence database: ${err.message}`);
+  }
+}
+
+/**
+ * Get template content as fallback (for backwards compatibility)
+ */
+async function getTemplateContent(templatePath) {
+  const filename = templatePath.split('/').pop();
+  
+  // Map template files to their generator functions
+  const templateGenerators = {
+    'CLAUDE.md': async () => {
+      const { createFullClaudeMd } = await import('./templates/claude-md.js');
+      return createFullClaudeMd();
+    },
+    'CLAUDE.md.sparc': async () => {
+      const { createSparcClaudeMd } = await import('./templates/claude-md.js');
+      return createSparcClaudeMd();
+    },
+    'CLAUDE.md.minimal': async () => {
+      const { createMinimalClaudeMd } = await import('./templates/claude-md.js');
+      return createMinimalClaudeMd();
+    },
+    'CLAUDE.md.optimized': async () => {
+      const { createOptimizedSparcClaudeMd } = await import('./templates/claude-md.js');
+      return createOptimizedSparcClaudeMd();
+    },
+    'CLAUDE.md.enhanced': async () => {
+      const { createEnhancedClaudeMd } = await import('./templates/enhanced-templates.js');
+      return createEnhancedClaudeMd();
+    },
+    'memory-bank.md': async () => {
+      const { createFullMemoryBankMd } = await import('./templates/memory-bank-md.js');
+      return createFullMemoryBankMd();
+    },
+    'memory-bank.md.minimal': async () => {
+      const { createMinimalMemoryBankMd } = await import('./templates/memory-bank-md.js');
+      return createMinimalMemoryBankMd();
+    },
+    'memory-bank.md.optimized': async () => {
+      const { createOptimizedMemoryBankMd } = await import('./templates/memory-bank-md.js');
+      return createOptimizedMemoryBankMd();
+    },
+    'coordination.md': async () => {
+      const { createFullCoordinationMd } = await import('./templates/coordination-md.js');
+      return createFullCoordinationMd();
+    },
+    'coordination.md.minimal': async () => {
+      const { createMinimalCoordinationMd } = await import('./templates/coordination-md.js');
+      return createMinimalCoordinationMd();
+    },
+    'coordination.md.optimized': async () => {
+      const { createOptimizedCoordinationMd } = await import('./templates/coordination-md.js');
+      return createOptimizedCoordinationMd();
+    },
+    'settings.json': async () => {
+      return await fs.readFile(join(__dirname, 'templates', 'settings.json'), 'utf8');
+    },
+    'settings.json.enhanced': async () => {
+      const { createEnhancedSettingsJson } = await import('./templates/enhanced-templates.js');
+      return createEnhancedSettingsJson();
+    },
+    'claude-flow-universal': async () => {
+      return await fs.readFile(join(__dirname, 'templates', 'claude-flow-universal'), 'utf8');
+    },
+    'claude-flow.bat': async () => {
+      return await fs.readFile(join(__dirname, 'templates', 'claude-flow.bat'), 'utf8');
+    },
+    'claude-flow.ps1': async () => {
+      return await fs.readFile(join(__dirname, 'templates', 'claude-flow.ps1'), 'utf8');
+    },
+  };
+
+  const generator = templateGenerators[filename] || templateGenerators[filename.replace(/\.(sparc|minimal|optimized|enhanced)$/, '')];
+  
+  if (generator) {
+    try {
+      return await generator();
+    } catch (err) {
+      console.log(`  ⚠️  Failed to generate template content for ${filename}: ${err.message}`);
+      return null;
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Generate command templates as fallback
+ */
+async function generateCommandTemplates(targetDir, options, results) {
+  const { COMMAND_STRUCTURE, createCommandDoc } = await import('./templates/enhanced-templates.js');
+  
+  for (const [category, commands] of Object.entries(COMMAND_STRUCTURE)) {
+    const categoryDir = join(targetDir, '.claude', 'commands', category);
+    
+    try {
+      if (!options.dryRun) {
+        await fs.mkdir(categoryDir, { recursive: true });
+        
+        // Create category README
+        const categoryReadme = `# ${category.charAt(0).toUpperCase() + category.slice(1)} Commands
+
+Commands for ${category} operations in Claude Flow.
+
+## Available Commands
+
+${commands.map(cmd => `- [${cmd}](./${cmd}.md)`).join('\n')}
+`;
+        await fs.writeFile(join(categoryDir, 'README.md'), categoryReadme);
+      }
+
+      // Create individual command docs
+      for (const command of commands) {
+        const doc = createCommandDoc(category, command);
+        if (doc) {
+          const docPath = join(categoryDir, `${command}.md`);
+          if (!options.dryRun) {
+            await fs.writeFile(docPath, doc);
+          }
+          results.copiedFiles.push(join('.claude', 'commands', category, `${command}.md`));
+        }
+      }
+
+      console.log(`  ${options.dryRun ? '[DRY RUN] Would create' : '✓ Created'} ${commands.length} ${category} command docs`);
+    } catch (err) {
+      results.errors.push(`Failed to generate ${category} command templates: ${err.message}`);
+    }
+  }
+}

package/src/cli/simple-commands/init/templates/claude-flow-universal

@@ -53,7 +53,7 @@
 
     // 3. NPX with latest alpha version (prioritized over global)
     async () => {
-      return spawn('npx', ['claude-flow@2.0.0-alpha.27', ...process.argv.slice(2)], {
+      return spawn('npx', ['claude-flow@alpha', ...process.argv.slice(2)], {
         stdio: 'inherit',
       });
     },

package/src/cli/simple-commands/init/templates/coordination.md

@@ -0,0 +1,16 @@
+# Coordination
+
+## Task Orchestration
+This file coordinates tasks and workflows across the project.
+
+## Active Tasks
+<!-- Track active development tasks -->
+
+## Workflows
+<!-- Define project workflows -->
+
+## Dependencies
+<!-- Track task dependencies -->
+
+## Progress Tracking
+<!-- Monitor task progress -->

package/src/cli/simple-commands/init/templates/memory-bank.md

@@ -0,0 +1,16 @@
+# Memory Bank
+
+## Overview
+This file serves as a persistent memory bank for important project context that should be retained across sessions.
+
+## Project Context
+<!-- Add project-specific information here -->
+
+## Key Decisions
+<!-- Document important decisions and their rationale -->
+
+## Code Patterns
+<!-- Document established patterns and conventions -->
+
+## Session History
+<!-- Track significant session outcomes -->

package/src/cli/simple-commands/init/templates/settings.json.enhanced

@@ -0,0 +1,35 @@
+{
+  "hooks": {
+    "pre-task": ".claude/commands/hooks/pre-task.md",
+    "post-task": ".claude/commands/hooks/post-task.md",
+    "pre-edit": ".claude/commands/hooks/pre-edit.md",
+    "post-edit": ".claude/commands/hooks/post-edit.md",
+    "session-start": ".claude/commands/hooks/session-start.md",
+    "session-end": ".claude/commands/hooks/session-end.md"
+  },
+  "permissions": {
+    "allow": ["mcp__ruv-swarm", "mcp__claude-flow"],
+    "autoApprove": {
+      "mcp__ruv-swarm": ["*"],
+      "mcp__claude-flow": ["*"]
+    }
+  },
+  "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"
+    }
+  },
+  "features": {
+    "hooks": true,
+    "mcpIntegration": true,
+    "autoCompletion": true,
+    "commandPalette": true
+  }
+}