claude-flow-novice 2.0.3 → 2.0.4

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

@@ -1,57 +1,50 @@
 // 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 {
-      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');
+        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);
     } 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,14 +1,9 @@
 // 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}
 ---
@@ -22,20 +17,14 @@ ${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
 
@@ -102,55 +91,48 @@ 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,175 +1,169 @@
 // 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' },
-    ];
-
-    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}`);
+ */ 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'
             }
-          } else {
-            results.skippedFiles.push(file.target);
-            if (!options.dryRun) {
-              console.log(`  ⏭️  Skipped ${file.target} (already exists)`);
+        ];
+        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}`);
+                }
             }
-          }
-        } 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}`);
     }
-
-    results.success = results.errors.length === 0;
-  } catch (err) {
-    results.success = false;
-    results.errors.push(`Failed to copy revised templates: ${err.message}`);
-  }
-
-  return results;
+    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}`);
+ */ 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}`);
+                }
             }
-          } 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);
+ */ 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(', ')}`
+        };
     }
-  }
-
-  if (missingCategories.length > 0) {
     return {
-      valid: false,
-      error: `Missing required template categories: ${missingCategories.join(', ')}`,
+        valid: true
     };
-  }
-
-  return { valid: true };
 }