claude-flow-novice 2.0.4 → 2.0.5

package/dist/src/cli/simple-commands/init/claude-commands/slash-commands.js

@@ -1,50 +1,57 @@
 // slash-commands.js - Create Claude Code slash commands
-import { createSparcSlashCommand, createMainSparcCommand } from "./sparc-commands.js";
-import { createClaudeFlowCommands } from "./claude-flow-commands.js";
-import { copyTemplates } from "../template-copier.js";
-import { promises as fs } from "fs";
-import { join } from "path";
+
+import { createSparcSlashCommand, createMainSparcCommand } from './sparc-commands.js';
+import { createClaudeFlowCommands } from './claude-flow-commands.js';
+import { copyTemplates } from '../template-copier.js';
+import { promises as fs } from 'fs';
+import { join } from 'path';
+
 // Create Claude Code slash commands for SPARC modes
 export async function createClaudeSlashCommands(workingDir) {
+  try {
+    console.log('\n📝 Creating Claude Code slash commands...');
+
+    // Use template copier for SPARC slash commands
+    const slashCommandOptions = {
+      sparc: true,
+      force: true,
+      dryRun: false,
+    };
+
+    // Check if .roomodes exists for dynamic generation
+    const roomodesPath = `${workingDir}/.roomodes`;
     try {
-        console.log('\n📝 Creating Claude Code slash commands...');
-        // Use template copier for SPARC slash commands
-        const slashCommandOptions = {
-            sparc: true,
-            force: true,
-            dryRun: false
-        };
-        // Check if .roomodes exists for dynamic generation
-        const roomodesPath = `${workingDir}/.roomodes`;
-        try {
-            const roomodesContent = await fs.readFile(roomodesPath, 'utf8');
-            const roomodes = JSON.parse(roomodesContent);
-            // Create slash commands for each SPARC mode
-            for (const mode of roomodes.customModes){
-                const commandPath = join(workingDir, '.claude', 'commands', 'sparc', `${mode.slug}.md`);
-                const commandContent = createSparcSlashCommand(mode);
-                await fs.mkdir(join(workingDir, '.claude', 'commands', 'sparc'), {
-                    recursive: true
-                });
-                await fs.writeFile(commandPath, commandContent);
-                console.log(`  ✓ Created slash command: /sparc-${mode.slug}`);
-            }
-            // Create main SPARC command
-            const mainSparcCommand = createMainSparcCommand(roomodes.customModes);
-            await fs.writeFile(join(workingDir, '.claude', 'commands', 'sparc.md'), mainSparcCommand);
-            console.log('  ✓ Created main slash command: /sparc');
-        } catch (err) {
-            // Fallback to template copier if .roomodes doesn't exist
-            console.log('  🔄 Using template copier for SPARC commands...');
-            const copyResults = await copyTemplates(workingDir, slashCommandOptions);
-            if (!copyResults.success) {
-                console.log(`  ⚠️  Template copier failed: ${copyResults.errors.join(', ')}`);
-            }
-        }
-        // Create claude-flow-novice specific commands
-        await createClaudeFlowCommands(workingDir);
+      const roomodesContent = await fs.readFile(roomodesPath, 'utf8');
+      const roomodes = JSON.parse(roomodesContent);
+
+      // Create slash commands for each SPARC mode
+      for (const mode of roomodes.customModes) {
+        const commandPath = join(workingDir, '.claude', 'commands', 'sparc', `${mode.slug}.md`);
+        const commandContent = createSparcSlashCommand(mode);
+
+        await fs.mkdir(join(workingDir, '.claude', 'commands', 'sparc'), { recursive: true });
+        await fs.writeFile(commandPath, commandContent);
+        console.log(`  ✓ Created slash command: /sparc-${mode.slug}`);
+      }
+
+      // Create main SPARC command
+      const mainSparcCommand = createMainSparcCommand(roomodes.customModes);
+      await fs.writeFile(join(workingDir, '.claude', 'commands', 'sparc.md'), mainSparcCommand);
+      console.log('  ✓ Created main slash command: /sparc');
     } catch (err) {
+      // Fallback to template copier if .roomodes doesn't exist
+      console.log('  🔄 Using template copier for SPARC commands...');
+      const copyResults = await copyTemplates(workingDir, slashCommandOptions);
+
+      if (!copyResults.success) {
+        console.log(`  ⚠️  Template copier failed: ${copyResults.errors.join(', ')}`);
+      }
+    }
+
+    // Create claude-flow-novice specific commands
+    await createClaudeFlowCommands(workingDir);
+  } catch (err) {
     // Legacy slash command creation - silently skip if it fails
     // SPARC slash commands are already created successfully
-    }
+  }
 }

package/dist/src/cli/simple-commands/init/claude-commands/sparc-commands.js

@@ -1,9 +1,14 @@
 // sparc-commands.js - SPARC-specific slash commands
+
 // Create SPARC mode slash command
 export function createSparcSlashCommand(mode) {
-    // Extract the full description without truncation
-    const fullDescription = mode.roleDefinition.length > 100 ? `${mode.roleDefinition.substring(0, 97)}...` : mode.roleDefinition;
-    return `---
+  // Extract the full description without truncation
+  const fullDescription =
+    mode.roleDefinition.length > 100
+      ? `${mode.roleDefinition.substring(0, 97)}...`
+      : mode.roleDefinition;
+
+  return `---
 name: sparc-${mode.slug}
 description: ${mode.name} - ${fullDescription}
 ---
@@ -17,14 +22,20 @@ ${mode.roleDefinition}
 ${mode.customInstructions}
 
 ## Available Tools
-${Array.isArray(mode.groups) ? mode.groups.map((g)=>{
-        if (typeof g === 'string') {
+${
+  Array.isArray(mode.groups)
+    ? mode.groups
+        .map((g) => {
+          if (typeof g === 'string') {
             return `- **${g}**: ${getToolDescription(g)}`;
-        } else if (Array.isArray(g)) {
+          } else if (Array.isArray(g)) {
             return `- **${g[0]}**: ${g[1]?.description || getToolDescription(g[0])} ${g[1]?.fileRegex ? `(Files matching: ${g[1].fileRegex})` : ''}`;
-        }
-        return `- ${JSON.stringify(g)}`;
-    }).join('\n') : 'None'}
+          }
+          return `- ${JSON.stringify(g)}`;
+        })
+        .join('\n')
+    : 'None'
+}
 
 ## Usage
 
@@ -91,48 +102,55 @@ npx claude-flow-novice memory query "${mode.slug}" --limit 5
 \`\`\`
 `;
 }
+
 // Helper function to get tool descriptions
 function getToolDescription(tool) {
-    const toolDescriptions = {
-        read: 'File reading and viewing',
-        edit: 'File modification and creation',
-        browser: 'Web browsing capabilities',
-        mcp: 'Model Context Protocol tools',
-        command: 'Command execution'
-    };
-    return toolDescriptions[tool] || 'Tool access';
+  const toolDescriptions = {
+    read: 'File reading and viewing',
+    edit: 'File modification and creation',
+    browser: 'Web browsing capabilities',
+    mcp: 'Model Context Protocol tools',
+    command: 'Command execution',
+  };
+  return toolDescriptions[tool] || 'Tool access';
 }
+
 // Helper function to get example tasks
 function getExampleTask(slug) {
-    const examples = {
-        architect: 'design microservices architecture',
-        code: 'implement REST API endpoints',
-        tdd: 'create user authentication tests',
-        debug: 'fix memory leak in service',
-        'security-review': 'audit API security',
-        'docs-writer': 'create API documentation',
-        integration: 'connect payment service',
-        'post-deployment-monitoring-mode': 'monitor production metrics',
-        'refinement-optimization-mode': 'optimize database queries',
-        devops: 'deploy to AWS Lambda',
-        'supabase-admin': 'create user authentication schema',
-        'spec-pseudocode': 'define payment flow requirements',
-        mcp: 'integrate with external API',
-        swarm: 'build complete feature with tests',
-        sparc: 'orchestrate authentication system',
-        ask: 'help me choose the right mode',
-        tutorial: 'guide me through SPARC methodology'
-    };
-    return examples[slug] || 'implement feature';
+  const examples = {
+    architect: 'design microservices architecture',
+    code: 'implement REST API endpoints',
+    tdd: 'create user authentication tests',
+    debug: 'fix memory leak in service',
+    'security-review': 'audit API security',
+    'docs-writer': 'create API documentation',
+    integration: 'connect payment service',
+    'post-deployment-monitoring-mode': 'monitor production metrics',
+    'refinement-optimization-mode': 'optimize database queries',
+    devops: 'deploy to AWS Lambda',
+    'supabase-admin': 'create user authentication schema',
+    'spec-pseudocode': 'define payment flow requirements',
+    mcp: 'integrate with external API',
+    swarm: 'build complete feature with tests',
+    sparc: 'orchestrate authentication system',
+    ask: 'help me choose the right mode',
+    tutorial: 'guide me through SPARC methodology',
+  };
+  return examples[slug] || 'implement feature';
 }
+
 // Create main SPARC command
 export function createMainSparcCommand(modes) {
-    const modeList = modes.map((m)=>`- \`/sparc-${m.slug}\` - ${m.name}`).join('\n');
-    // Find the sparc orchestrator mode for its full description
-    const sparcMode = modes.find((m)=>m.slug === 'sparc');
-    const sparcDescription = sparcMode ? sparcMode.roleDefinition : 'SPARC orchestrator for complex workflows';
-    const sparcInstructions = sparcMode ? sparcMode.customInstructions : '';
-    return `---
+  const modeList = modes.map((m) => `- \`/sparc-${m.slug}\` - ${m.name}`).join('\n');
+
+  // Find the sparc orchestrator mode for its full description
+  const sparcMode = modes.find((m) => m.slug === 'sparc');
+  const sparcDescription = sparcMode
+    ? sparcMode.roleDefinition
+    : 'SPARC orchestrator for complex workflows';
+  const sparcInstructions = sparcMode ? sparcMode.customInstructions : '';
+
+  return `---
 name: sparc
 description: Execute SPARC methodology workflows with Claude-Flow
 ---

package/dist/src/cli/simple-commands/init/copy-revised-templates.js

@@ -1,169 +1,175 @@
 // copy-revised-templates.js - Copy the revised template files from repository
-import fs from "fs";
-import path from "path";
-import { fileURLToPath } from "url";
+
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
+
 // Source directory for revised templates (repository root .claude/commands)
 const REPO_TEMPLATES_DIR = path.join(__dirname, '../../../../.claude/commands');
+
 /**
  * Copy revised template files from repository to target project
- */ export async function copyRevisedTemplates(targetDir, options = {}) {
-    const results = {
-        success: true,
-        copiedFiles: [],
-        skippedFiles: [],
-        errors: []
-    };
-    const targetCommandsDir = path.join(targetDir, '.claude/commands');
-    try {
-        // Ensure target directory exists
-        await fs.promises.mkdir(targetCommandsDir, {
-            recursive: true
-        });
-        // Copy all template files recursively
-        await copyDirectoryRecursive(REPO_TEMPLATES_DIR, targetCommandsDir, options, results);
-        // Copy additional .claude files if they exist
-        const additionalFiles = [
-            {
-                source: '../config.json',
-                target: '.claude/config.json'
-            },
-            {
-                source: '../settings.json',
-                target: '.claude/settings.json'
+ */
+export async function copyRevisedTemplates(targetDir, options = {}) {
+  const results = {
+    success: true,
+    copiedFiles: [],
+    skippedFiles: [],
+    errors: [],
+  };
+
+  const targetCommandsDir = path.join(targetDir, '.claude/commands');
+
+  try {
+    // Ensure target directory exists
+    await fs.promises.mkdir(targetCommandsDir, { recursive: true });
+
+    // Copy all template files recursively
+    await copyDirectoryRecursive(REPO_TEMPLATES_DIR, targetCommandsDir, options, results);
+
+    // Copy additional .claude files if they exist
+    const additionalFiles = [
+      { source: '../config.json', target: '.claude/config.json' },
+      { source: '../settings.json', target: '.claude/settings.json' },
+    ];
+
+    for (const file of additionalFiles) {
+      const sourcePath = path.join(REPO_TEMPLATES_DIR, file.source);
+      const targetPath = path.join(targetDir, file.target);
+
+      if (fs.existsSync(sourcePath)) {
+        try {
+          const targetDirPath = path.dirname(targetPath);
+          await fs.promises.mkdir(targetDirPath, { recursive: true });
+
+          if (!fs.existsSync(targetPath) || options.force) {
+            await fs.promises.copyFile(sourcePath, targetPath);
+            results.copiedFiles.push(file.target);
+            if (!options.dryRun) {
+              console.log(`  ✓ Copied ${file.target}`);
             }
-        ];
-        for (const file of additionalFiles){
-            const sourcePath = path.join(REPO_TEMPLATES_DIR, file.source);
-            const targetPath = path.join(targetDir, file.target);
-            if (fs.existsSync(sourcePath)) {
-                try {
-                    const targetDirPath = path.dirname(targetPath);
-                    await fs.promises.mkdir(targetDirPath, {
-                        recursive: true
-                    });
-                    if (!fs.existsSync(targetPath) || options.force) {
-                        await fs.promises.copyFile(sourcePath, targetPath);
-                        results.copiedFiles.push(file.target);
-                        if (!options.dryRun) {
-                            console.log(`  ✓ Copied ${file.target}`);
-                        }
-                    } else {
-                        results.skippedFiles.push(file.target);
-                        if (!options.dryRun) {
-                            console.log(`  ⏭️  Skipped ${file.target} (already exists)`);
-                        }
-                    }
-                } catch (err) {
-                    results.errors.push(`Failed to copy ${file.target}: ${err.message}`);
-                }
+          } else {
+            results.skippedFiles.push(file.target);
+            if (!options.dryRun) {
+              console.log(`  ⏭️  Skipped ${file.target} (already exists)`);
             }
+          }
+        } catch (err) {
+          results.errors.push(`Failed to copy ${file.target}: ${err.message}`);
         }
-        results.success = results.errors.length === 0;
-    } catch (err) {
-        results.success = false;
-        results.errors.push(`Failed to copy revised templates: ${err.message}`);
+      }
     }
-    return results;
+
+    results.success = results.errors.length === 0;
+  } catch (err) {
+    results.success = false;
+    results.errors.push(`Failed to copy revised templates: ${err.message}`);
+  }
+
+  return results;
 }
+
 /**
  * Recursively copy directory contents
- */ async function copyDirectoryRecursive(sourceDir, targetDir, options, results) {
-    try {
-        const entries = await fs.promises.readdir(sourceDir, {
-            withFileTypes: true
-        });
-        for (const entry of entries){
-            const sourcePath = path.join(sourceDir, entry.name);
-            const targetPath = path.join(targetDir, entry.name);
-            if (entry.isDirectory()) {
-                // Create directory and recurse
-                await fs.promises.mkdir(targetPath, {
-                    recursive: true
-                });
-                await copyDirectoryRecursive(sourcePath, targetPath, options, results);
-            } else if (entry.isFile() && entry.name.endsWith('.md')) {
-                // Copy markdown files
-                try {
-                    if (!fs.existsSync(targetPath) || options.force) {
-                        if (!options.dryRun) {
-                            await fs.promises.copyFile(sourcePath, targetPath);
-                        }
-                        const relativePath = path.relative(targetDir, targetPath);
-                        results.copiedFiles.push(relativePath);
-                        if (!options.dryRun && options.verbose) {
-                            console.log(`  ✓ Copied ${relativePath}`);
-                        }
-                    } else {
-                        const relativePath = path.relative(targetDir, targetPath);
-                        results.skippedFiles.push(relativePath);
-                        if (!options.dryRun && options.verbose) {
-                            console.log(`  ⏭️  Skipped ${relativePath} (already exists)`);
-                        }
-                    }
-                } catch (err) {
-                    results.errors.push(`Failed to copy ${entry.name}: ${err.message}`);
-                }
+ */
+async function copyDirectoryRecursive(sourceDir, targetDir, options, results) {
+  try {
+    const entries = await fs.promises.readdir(sourceDir, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const sourcePath = path.join(sourceDir, entry.name);
+      const targetPath = path.join(targetDir, entry.name);
+
+      if (entry.isDirectory()) {
+        // Create directory and recurse
+        await fs.promises.mkdir(targetPath, { recursive: true });
+        await copyDirectoryRecursive(sourcePath, targetPath, options, results);
+      } else if (entry.isFile() && entry.name.endsWith('.md')) {
+        // Copy markdown files
+        try {
+          if (!fs.existsSync(targetPath) || options.force) {
+            if (!options.dryRun) {
+              await fs.promises.copyFile(sourcePath, targetPath);
+            }
+            const relativePath = path.relative(targetDir, targetPath);
+            results.copiedFiles.push(relativePath);
+            if (!options.dryRun && options.verbose) {
+              console.log(`  ✓ Copied ${relativePath}`);
             }
+          } else {
+            const relativePath = path.relative(targetDir, targetPath);
+            results.skippedFiles.push(relativePath);
+            if (!options.dryRun && options.verbose) {
+              console.log(`  ⏭️  Skipped ${relativePath} (already exists)`);
+            }
+          }
+        } catch (err) {
+          results.errors.push(`Failed to copy ${entry.name}: ${err.message}`);
         }
-    } catch (err) {
-        results.errors.push(`Failed to read directory ${sourceDir}: ${err.message}`);
+      }
     }
+  } catch (err) {
+    results.errors.push(`Failed to read directory ${sourceDir}: ${err.message}`);
+  }
 }
+
 /**
  * Copy only specific categories
- */ export async function copyRevisedTemplatesByCategory(targetDir, categories, options = {}) {
-    const results = {
-        success: true,
-        copiedFiles: [],
-        skippedFiles: [],
-        errors: []
-    };
-    for (const category of categories){
-        const sourceCategoryDir = path.join(REPO_TEMPLATES_DIR, category);
-        const targetCategoryDir = path.join(targetDir, '.claude/commands', category);
-        if (fs.existsSync(sourceCategoryDir)) {
-            await fs.promises.mkdir(targetCategoryDir, {
-                recursive: true
-            });
-            await copyDirectoryRecursive(sourceCategoryDir, targetCategoryDir, options, results);
-        } else {
-            results.errors.push(`Category '${category}' not found in templates`);
-        }
+ */
+export async function copyRevisedTemplatesByCategory(targetDir, categories, options = {}) {
+  const results = {
+    success: true,
+    copiedFiles: [],
+    skippedFiles: [],
+    errors: [],
+  };
+
+  for (const category of categories) {
+    const sourceCategoryDir = path.join(REPO_TEMPLATES_DIR, category);
+    const targetCategoryDir = path.join(targetDir, '.claude/commands', category);
+
+    if (fs.existsSync(sourceCategoryDir)) {
+      await fs.promises.mkdir(targetCategoryDir, { recursive: true });
+      await copyDirectoryRecursive(sourceCategoryDir, targetCategoryDir, options, results);
+    } else {
+      results.errors.push(`Category '${category}' not found in templates`);
     }
-    results.success = results.errors.length === 0;
-    return results;
+  }
+
+  results.success = results.errors.length === 0;
+  return results;
 }
+
 /**
  * Validate that source templates exist
- */ export function validateTemplatesExist() {
-    if (!fs.existsSync(REPO_TEMPLATES_DIR)) {
-        return {
-            valid: false,
-            error: `Template directory not found: ${REPO_TEMPLATES_DIR}`
-        };
-    }
-    const requiredCategories = [
-        'analysis',
-        'github',
-        'sparc',
-        'coordination'
-    ];
-    const missingCategories = [];
-    for (const category of requiredCategories){
-        const categoryPath = path.join(REPO_TEMPLATES_DIR, category);
-        if (!fs.existsSync(categoryPath)) {
-            missingCategories.push(category);
-        }
-    }
-    if (missingCategories.length > 0) {
-        return {
-            valid: false,
-            error: `Missing required template categories: ${missingCategories.join(', ')}`
-        };
+ */
+export function validateTemplatesExist() {
+  if (!fs.existsSync(REPO_TEMPLATES_DIR)) {
+    return {
+      valid: false,
+      error: `Template directory not found: ${REPO_TEMPLATES_DIR}`,
+    };
+  }
+
+  const requiredCategories = ['analysis', 'github', 'sparc', 'coordination'];
+  const missingCategories = [];
+
+  for (const category of requiredCategories) {
+    const categoryPath = path.join(REPO_TEMPLATES_DIR, category);
+    if (!fs.existsSync(categoryPath)) {
+      missingCategories.push(category);
     }
+  }
+
+  if (missingCategories.length > 0) {
     return {
-        valid: true
+      valid: false,
+      error: `Missing required template categories: ${missingCategories.join(', ')}`,
     };
+  }
+
+  return { valid: true };
 }