claude-flow-novice 2.10.4 → 2.10.6

package/claude-assets/commands/register-all-commands.js

@@ -0,0 +1,320 @@
+#!/usr/bin/env node
+
+/**
+ * Register All Slash Commands
+ * 
+ * Central registry for all claude-flow slash commands
+ */
+
+import { ClaudeMdSlashCommand } from './claude-md.js';
+import { SparcCommand } from './sparc.js';
+import { SwarmCommand } from './swarm.js';
+import { HooksCommand } from './hooks.js';
+import { NeuralCommand } from './neural.js';
+import { PerformanceCommand } from './performance.js';
+import { GitHubCommand } from './github.js';
+import { WorkflowCommand } from './workflow.js';
+import { executeClaudeSoulCommand } from './claude-soul.js';
+import { CfnOptimizeAgentsCommand } from '../../src/slash-commands/cfn-optimize-agents.js';
+
+/**
+ * Command Registry Class
+ */
+export class SlashCommandRegistry {
+  constructor() {
+    this.commands = new Map();
+    this.aliases = new Map();
+    this.initializeCommands();
+  }
+
+  /**
+   * Initialize all available commands
+   */
+  initializeCommands() {
+    // Core SPARC methodology command
+    this.register(new SparcCommand());
+
+    // Swarm management commands
+    this.register(new SwarmCommand());
+    this.addAlias('swarm', 's');
+
+    // Hooks automation commands
+    this.register(new HooksCommand());
+    this.addAlias('hooks', 'h');
+
+    // Neural network commands
+    this.register(new NeuralCommand());
+    this.addAlias('neural', 'n');
+
+    // Performance monitoring commands
+    this.register(new PerformanceCommand());
+    this.addAlias('performance', 'perf');
+    this.addAlias('performance', 'p');
+
+    // GitHub integration commands
+    this.register(new GitHubCommand());
+    this.addAlias('github', 'gh');
+    this.addAlias('github', 'git');
+
+    // Workflow automation commands
+    this.register(new WorkflowCommand());
+    this.addAlias('workflow', 'wf');
+    this.addAlias('workflow', 'w');
+
+    // CFN Loop optimization commands
+    this.register(new CfnOptimizeAgentsCommand());
+    this.addAlias('cfn-optimize-agents', 'cfn-opt');
+    this.addAlias('cfn-optimize-agents', 'optimize-agents');
+
+    // Legacy function-based commands
+    this.registerLegacyCommand('claude-md', {
+      description: 'Generate CLAUDE.md configuration file',
+      usage: '/claude-md [--preview] [--force] [--no-backup]',
+      execute: async (args, context) => {
+        const command = new ClaudeMdSlashCommand();
+        const options = {
+          preview: args.includes('--preview'),
+          force: args.includes('--force'),
+          backup: !args.includes('--no-backup')
+        };
+        return await command.execute(options);
+      }
+    });
+
+    this.registerLegacyCommand('claude-soul', {
+      description: 'Generate claude-soul.md project essence document',
+      usage: '/claude-soul [--preview] [--force] [--no-backup]',
+      execute: async (args, context) => {
+        const options = {
+          preview: args.includes('--preview'),
+          force: args.includes('--force'),
+          backup: !args.includes('--no-backup')
+        };
+        return await executeClaudeSoulCommand(options);
+      }
+    });
+  }
+
+  /**
+   * Register a command
+   * @param {SlashCommand} command - Command instance
+   */
+  register(command) {
+    this.commands.set(command.name, command);
+    console.log(`✅ Registered /${command.name} command`);
+  }
+
+  /**
+   * Register legacy function-based command
+   * @param {string} name - Command name
+   * @param {Object} config - Command configuration
+   */
+  registerLegacyCommand(name, config) {
+    this.commands.set(name, {
+      name: name,
+      description: config.description,
+      usage: config.usage,
+      execute: config.execute,
+      getHelp: () => ({
+        name: name,
+        description: config.description,
+        usage: config.usage,
+        examples: config.examples || []
+      })
+    });
+    console.log(`✅ Registered /${name} legacy command`);
+  }
+
+  /**
+   * Add alias for a command
+   * @param {string} commandName - Original command name
+   * @param {string} alias - Alias name
+   */
+  addAlias(commandName, alias) {
+    this.aliases.set(alias, commandName);
+  }
+
+  /**
+   * Execute a slash command
+   * @param {string} input - Full command input (e.g., "/swarm init mesh")
+   * @param {Object} context - Execution context
+   */
+  async execute(input, context = {}) {
+    if (!input.startsWith('/')) {
+      return {
+        success: false,
+        error: 'Commands must start with /'
+      };
+    }
+
+    const parts = input.slice(1).split(' ');
+    const commandName = parts[0];
+    const args = parts.slice(1);
+
+    // Resolve aliases
+    const resolvedName = this.aliases.get(commandName) || commandName;
+    const command = this.commands.get(resolvedName);
+
+    if (!command) {
+      return {
+        success: false,
+        error: `Unknown command: ${commandName}`,
+        suggestions: this.getSuggestions(commandName)
+      };
+    }
+
+    try {
+      const result = await command.execute(args, context);
+      return {
+        success: true,
+        command: resolvedName,
+        result: result
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: `Command execution failed: ${error.message}`,
+        command: resolvedName
+      };
+    }
+  }
+
+  /**
+   * Get command suggestions for unknown commands
+   * @param {string} input - Input command
+   */
+  getSuggestions(input) {
+    const commands = Array.from(this.commands.keys());
+    const aliases = Array.from(this.aliases.keys());
+    const allCommands = [...commands, ...aliases];
+
+    return allCommands
+      .filter(cmd => cmd.includes(input) || input.includes(cmd))
+      .slice(0, 5);
+  }
+
+  /**
+   * List all available commands
+   */
+  listCommands() {
+    const commands = [];
+    
+    for (const [name, command] of this.commands) {
+      commands.push({
+        name: name,
+        description: command.description,
+        usage: command.usage || command.getUsage?.() || `/${name} [options]`,
+        aliases: Array.from(this.aliases.entries())
+          .filter(([alias, target]) => target === name)
+          .map(([alias]) => alias)
+      });
+    }
+
+    return commands.sort((a, b) => a.name.localeCompare(b.name));
+  }
+
+  /**
+   * Get help for a specific command
+   * @param {string} commandName - Command name
+   */
+  getHelp(commandName) {
+    const resolvedName = this.aliases.get(commandName) || commandName;
+    const command = this.commands.get(resolvedName);
+
+    if (!command) {
+      return {
+        success: false,
+        error: `Unknown command: ${commandName}`
+      };
+    }
+
+    return {
+      success: true,
+      help: command.getHelp ? command.getHelp() : {
+        name: command.name,
+        description: command.description,
+        usage: command.usage
+      }
+    };
+  }
+
+  /**
+   * Generate help text for all commands
+   */
+  generateHelpText() {
+    const commands = this.listCommands();
+    
+    let helpText = `
+🚀 **CLAUDE-FLOW SLASH COMMANDS**
+
+`;
+    
+    helpText += `**Available Commands:**
+
+`;
+    
+    for (const cmd of commands) {
+      helpText += `**/${cmd.name}** - ${cmd.description}\n`;
+      helpText += `  Usage: ${cmd.usage}\n`;
+      if (cmd.aliases.length > 0) {
+        helpText += `  Aliases: ${cmd.aliases.map(a => `/${a}`).join(', ')}\n`;
+      }
+      helpText += `\n`;
+    }
+
+    helpText += `
+**Examples:**
+`;
+    helpText += `- \`/swarm init mesh 8\` - Initialize mesh swarm with 8 agents\n`;
+    helpText += `- \`/hooks enable\` - Enable automation hooks\n`;
+    helpText += `- \`/neural train coordination 50\` - Train neural coordination patterns\n`;
+    helpText += `- \`/performance report\` - Generate performance report\n`;
+    helpText += `- \`/github analyze owner/repo\` - Analyze GitHub repository\n`;
+    helpText += `- \`/workflow create "Build Pipeline"\` - Create automated workflow\n`;
+    helpText += `- \`/sparc spec "Build API"\` - Run SPARC specification phase\n`;
+
+    helpText += `
+**For detailed help on any command:** \`/help <command>\`\n`;
+    
+    return helpText;
+  }
+}
+
+/**
+ * Global registry instance
+ */
+export const globalRegistry = new SlashCommandRegistry();
+
+/**
+ * Execute slash command with global registry
+ * @param {string} input - Command input
+ * @param {Object} context - Execution context
+ */
+export async function executeSlashCommand(input, context = {}) {
+  return await globalRegistry.execute(input, context);
+}
+
+/**
+ * Get all available commands
+ */
+export function getAllCommands() {
+  return globalRegistry.listCommands();
+}
+
+/**
+ * Get help for specific command
+ * @param {string} commandName - Command name
+ */
+export function getCommandHelp(commandName) {
+  return globalRegistry.getHelp(commandName);
+}
+
+/**
+ * Register additional command
+ * @param {SlashCommand} command - Command to register
+ */
+export function registerCommand(command) {
+  return globalRegistry.register(command);
+}
+
+export default SlashCommandRegistry;

package/claude-assets/commands/register-claude-md.js

@@ -0,0 +1,82 @@
+/**
+ * Slash Command Registration for /claude-md
+ *
+ * Simple registration that integrates with existing slash command system
+ */
+
+import { executeClaudeMdCommand } from './claude-md.js';
+
+/**
+ * Register the /claude-md slash command
+ */
+export function registerClaudeMdCommand(slashCommandRegistry) {
+  slashCommandRegistry.register('claude-md', {
+    description: 'Generate or update CLAUDE.md file for current project',
+    usage: '/claude-md [--preview] [--force] [--no-backup] [--detect]',
+    options: [
+      { name: '--preview', description: 'Show what would be generated without writing file' },
+      { name: '--force', description: 'Overwrite existing CLAUDE.md without confirmation' },
+      { name: '--no-backup', description: 'Skip creating backup of existing file' },
+      { name: '--detect', description: 'Auto-detect project type and show recommendations' }
+    ],
+    examples: [
+      '/claude-md',
+      '/claude-md --preview',
+      '/claude-md --force',
+      '/claude-md --detect'
+    ],
+    async execute(args, context) {
+      try {
+        // Parse slash command arguments
+        const options = {
+          preview: args.includes('--preview'),
+          force: args.includes('--force'),
+          backup: !args.includes('--no-backup'),
+          detect: args.includes('--detect'),
+          isNpxInstall: false // Slash commands are manual, not NPX
+        };
+
+        console.log('🎯 Executing /claude-md slash command...');
+
+        const result = await executeClaudeMdCommand(options);
+
+        // Format response for slash command system
+        if (result.success) {
+          return {
+            success: true,
+            message: result.message || 'CLAUDE.md operation completed successfully',
+            data: {
+              action: result.action,
+              file: result.file,
+              length: result.length
+            }
+          };
+        } else {
+          return {
+            success: false,
+            error: result.error || 'CLAUDE.md operation failed',
+            action: result.action
+          };
+        }
+
+      } catch (error) {
+        console.error('❌ Slash command execution failed:', error.message);
+        return {
+          success: false,
+          error: `Slash command failed: ${error.message}`
+        };
+      }
+    }
+  });
+
+  console.log('✅ /claude-md slash command registered');
+}
+
+/**
+ * Auto-registration if this module is imported
+ */
+export default function autoRegister(registry) {
+  if (registry) {
+    registerClaudeMdCommand(registry);
+  }
+}

package/claude-assets/commands/register-claude-soul.js

@@ -0,0 +1,80 @@
+/**
+ * Slash Command Registration for /claude-soul
+ *
+ * Register the claude-soul.md generation command
+ */
+
+import { executeClaudeSoulCommand } from './claude-soul.js';
+
+/**
+ * Register the /claude-soul slash command
+ */
+export function registerClaudeSoulCommand(slashCommandRegistry) {
+  slashCommandRegistry.register('claude-soul', {
+    description: 'Generate claude-soul.md - project essence and philosophy document',
+    usage: '/claude-soul [--preview] [--force] [--no-backup]',
+    options: [
+      { name: '--preview', description: 'Show what would be generated without writing file' },
+      { name: '--force', description: 'Overwrite existing claude-soul.md without confirmation' },
+      { name: '--no-backup', description: 'Skip creating backup of existing file' }
+    ],
+    examples: [
+      '/claude-soul',
+      '/claude-soul --preview',
+      '/claude-soul --force',
+      '/claude-soul --no-backup'
+    ],
+    async execute(args, context) {
+      try {
+        // Parse slash command arguments
+        const options = {
+          preview: args.includes('--preview'),
+          force: args.includes('--force'),
+          backup: !args.includes('--no-backup')
+        };
+
+        console.log('🎯 Executing /claude-soul slash command...');
+
+        const result = await executeClaudeSoulCommand(options);
+
+        // Format response for slash command system
+        if (result.success) {
+          return {
+            success: true,
+            message: result.message || 'claude-soul.md operation completed successfully',
+            data: {
+              action: result.action,
+              file: result.file,
+              length: result.length,
+              lineCount: result.lineCount
+            }
+          };
+        } else {
+          return {
+            success: false,
+            error: result.error || 'claude-soul.md operation failed',
+            action: result.action
+          };
+        }
+
+      } catch (error) {
+        console.error('❌ Slash command execution failed:', error.message);
+        return {
+          success: false,
+          error: `Slash command failed: ${error.message}`
+        };
+      }
+    }
+  });
+
+  console.log('✅ /claude-soul slash command registered');
+}
+
+/**
+ * Auto-registration if this module is imported
+ */
+export default function autoRegister(registry) {
+  if (registry) {
+    registerClaudeSoulCommand(registry);
+  }
+}

package/claude-assets/commands/sparc/analyzer.md

@@ -0,0 +1,52 @@
+# SPARC Analyzer Mode
+
+## Purpose
+Deep code and data analysis with batch processing capabilities.
+
+## Activation
+
+### Option 1: Using MCP Tools (Preferred in Claude Code)
+```javascript
+mcp__claude-flow__sparc_mode {
+  mode: "analyzer",
+  task_description: "analyze codebase performance",
+  options: {
+    parallel: true,
+    detailed: true
+  }
+}
+```
+
+### Option 2: Using NPX CLI (Fallback when MCP not available)
+```bash
+# Use when running from terminal or MCP tools unavailable
+npx claude-flow-novice sparc run analyzer "analyze codebase performance"
+
+# For alpha features
+npx claude-flow@alpha sparc run analyzer "analyze codebase performance"
+```
+
+### Option 3: Local Installation
+```bash
+# If claude-flow-novice is installed locally
+./claude-flow-novice sparc run analyzer "analyze codebase performance"
+```
+
+## Core Capabilities
+- Code analysis with parallel file processing
+- Data pattern recognition
+- Performance profiling
+- Memory usage analysis
+- Dependency mapping
+
+## Batch Operations
+- Parallel file analysis using concurrent Read operations
+- Batch pattern matching with Grep tool
+- Simultaneous metric collection
+- Aggregated reporting
+
+## Output Format
+- Detailed analysis reports
+- Performance metrics
+- Improvement recommendations
+- Visualizations when applicable

package/claude-assets/commands/sparc/architect.md

@@ -0,0 +1,53 @@
+# SPARC Architect Mode
+
+## Purpose
+System design with Memory-based coordination for scalable architectures.
+
+## Activation
+
+### Option 1: Using MCP Tools (Preferred in Claude Code)
+```javascript
+mcp__claude-flow__sparc_mode {
+  mode: "architect",
+  task_description: "design microservices architecture",
+  options: {
+    detailed: true,
+    memory_enabled: true
+  }
+}
+```
+
+### Option 2: Using NPX CLI (Fallback when MCP not available)
+```bash
+# Use when running from terminal or MCP tools unavailable
+npx claude-flow-novice sparc run architect "design microservices architecture"
+
+# For alpha features
+npx claude-flow@alpha sparc run architect "design microservices architecture"
+```
+
+### Option 3: Local Installation
+```bash
+# If claude-flow-novice is installed locally
+./claude-flow-novice sparc run architect "design microservices architecture"
+```
+
+## Core Capabilities
+- System architecture design
+- Component interface definition
+- Database schema design
+- API contract specification
+- Infrastructure planning
+
+## Memory Integration
+- Store architecture decisions in Memory
+- Share component specifications across agents
+- Maintain design consistency
+- Track architectural evolution
+
+## Design Patterns
+- Microservices
+- Event-driven architecture
+- Domain-driven design
+- Hexagonal architecture
+- CQRS and Event Sourcing

package/claude-assets/commands/sparc/batch-executor.md

@@ -0,0 +1,54 @@
+# SPARC Batch Executor Mode
+
+## Purpose
+Parallel task execution specialist using batch operations.
+
+## Activation
+
+### Option 1: Using MCP Tools (Preferred in Claude Code)
+```javascript
+mcp__claude-flow__sparc_mode {
+  mode: "batch-executor",
+  task_description: "process multiple files",
+  options: {
+    parallel: true,
+    batch_size: 10
+  }
+}
+```
+
+### Option 2: Using NPX CLI (Fallback when MCP not available)
+```bash
+# Use when running from terminal or MCP tools unavailable
+npx claude-flow-novice sparc run batch-executor "process multiple files"
+
+# For alpha features
+npx claude-flow@alpha sparc run batch-executor "process multiple files"
+```
+
+### Option 3: Local Installation
+```bash
+# If claude-flow-novice is installed locally
+./claude-flow-novice sparc run batch-executor "process multiple files"
+```
+
+## Core Capabilities
+- Parallel file operations
+- Concurrent task execution
+- Resource optimization
+- Load balancing
+- Progress tracking
+
+## Execution Patterns
+- Parallel Read/Write operations
+- Concurrent Edit operations
+- Batch file transformations
+- Distributed processing
+- Pipeline orchestration
+
+## Performance Features
+- Dynamic resource allocation
+- Automatic load balancing
+- Progress monitoring
+- Error recovery
+- Result aggregation

package/claude-assets/commands/sparc/coder.md

@@ -0,0 +1,54 @@
+# SPARC Coder Mode
+
+## Purpose
+Autonomous code generation with batch file operations.
+
+## Activation
+
+### Option 1: Using MCP Tools (Preferred in Claude Code)
+```javascript
+mcp__claude-flow__sparc_mode {
+  mode: "coder",
+  task_description: "implement user authentication",
+  options: {
+    test_driven: true,
+    parallel_edits: true
+  }
+}
+```
+
+### Option 2: Using NPX CLI (Fallback when MCP not available)
+```bash
+# Use when running from terminal or MCP tools unavailable
+npx claude-flow-novice sparc run coder "implement user authentication"
+
+# For alpha features
+npx claude-flow@alpha sparc run coder "implement user authentication"
+```
+
+### Option 3: Local Installation
+```bash
+# If claude-flow-novice is installed locally
+./claude-flow-novice sparc run coder "implement user authentication"
+```
+
+## Core Capabilities
+- Feature implementation
+- Code refactoring
+- Bug fixes
+- API development
+- Algorithm implementation
+
+## Batch Operations
+- Parallel file creation
+- Concurrent code modifications
+- Batch import updates
+- Test file generation
+- Documentation updates
+
+## Code Quality
+- ES2022 standards
+- Type safety with TypeScript
+- Comprehensive error handling
+- Performance optimization
+- Security best practices