claude-flow-novice 1.1.8 → 1.1.9

package/src/slash-commands/register-all-commands.js

@@ -0,0 +1,314 @@
+#!/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';
+
+/**
+ * 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');
+
+    // 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/src/slash-commands/sparc.js

@@ -0,0 +1,110 @@
+#!/usr/bin/env node
+
+/**
+ * SPARC Methodology Slash Command
+ * Usage: /sparc <mode> <task>
+ */
+
+import { SlashCommand } from '../core/slash-command.js';
+
+export class SparcCommand extends SlashCommand {
+  constructor() {
+    super('sparc', 'Execute SPARC methodology phases');
+  }
+
+  async execute(args, context) {
+    const [mode, ...taskArgs] = args;
+    const task = taskArgs.join(' ');
+
+    const modes = {
+      'spec': 'Specification - Requirements analysis and user story definition',
+      'pseudo': 'Pseudocode - Algorithm design and logic flow',
+      'arch': 'Architecture - System design and component structure',
+      'refine': 'Refinement - Iterative improvement and optimization',
+      'complete': 'Completion - Final implementation and testing'
+    };
+
+    if (!mode || !modes[mode]) {
+      return {
+        success: false,
+        error: `Invalid mode. Available modes: ${Object.keys(modes).join(', ')}`,
+        usage: '/sparc <mode> <task_description>'
+      };
+    }
+
+    if (!task) {
+      return {
+        success: false,
+        error: 'Task description required',
+        usage: `/sparc ${mode} <task_description>`
+      };
+    }
+
+    console.log(`🎯 SPARC ${mode.toUpperCase()}: ${task}`);
+
+    const sparcPrompt = `
+🎯 **SPARC Methodology - ${modes[mode]}**
+
+**Task**: ${task}
+
+**Phase**: ${mode.toUpperCase()}
+**Description**: ${modes[mode]}
+
+**Instructions for ${mode.toUpperCase()} phase**:
+${this.getPhaseInstructions(mode)}
+
+**Execute this SPARC phase now**:
+`;
+
+    return {
+      success: true,
+      prompt: sparcPrompt,
+      mode: `sparc-${mode}`,
+      task: task,
+      timestamp: new Date().toISOString()
+    };
+  }
+
+  getPhaseInstructions(mode) {
+    const instructions = {
+      'spec': `
+- Define clear requirements and acceptance criteria
+- Create user stories and use cases
+- Identify constraints and assumptions
+- Specify input/output requirements
+- Document functional and non-functional requirements`,
+
+      'pseudo': `
+- Break down the problem into logical steps
+- Write high-level algorithm pseudocode
+- Define data structures and flow
+- Identify key functions and modules
+- Plan error handling and edge cases`,
+
+      'arch': `
+- Design system architecture and components
+- Define interfaces and APIs
+- Choose appropriate patterns and technologies
+- Plan data flow and storage
+- Consider scalability and maintainability`,
+
+      'refine': `
+- Review and improve the design
+- Optimize algorithms and data structures
+- Refactor for clarity and efficiency
+- Add comprehensive error handling
+- Enhance documentation and comments`,
+
+      'complete': `
+- Implement the final solution
+- Write comprehensive tests
+- Perform integration testing
+- Document usage and deployment
+- Prepare for production deployment`
+    };
+
+    return instructions[mode] || 'Execute the specified SPARC phase';
+  }
+}
+
+export default SparcCommand;