claude-flow-novice 2.6.0 → 2.9.0

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

@@ -1,320 +0,0 @@
-#!/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/commands/register-claude-md.js

@@ -1,82 +0,0 @@
-/**
- * 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/commands/register-claude-soul.js

@@ -1,80 +0,0 @@
-/**
- * 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/commands/sparc/analyzer.md

@@ -1,52 +0,0 @@
-# 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/commands/sparc/architect.md

@@ -1,53 +0,0 @@
-# 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/commands/sparc/batch-executor.md

@@ -1,54 +0,0 @@
-# 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/commands/sparc/coder.md

@@ -1,54 +0,0 @@
-# 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