claude-flow-novice 2.10.4 → 2.10.6

package/claude-assets/commands/cfn/write-plan.md

@@ -0,0 +1,104 @@
+# Write Plan Command
+
+## Overview
+The `write-plan` command helps create structured, test-driven implementation plans for claude-flow-novice projects, leveraging our CFN Loop workflow and adaptive context strategies.
+
+## Core Principles
+
+### 1. Test-Driven Development (TDD)
+- Always start with failure scenarios (Red phase)
+- Implement minimal code to pass tests (Green phase)
+- Refactor for quality and maintainability (Refactor phase)
+
+### 2. CFN Loop Integration
+Utilize the CFN Loop workflow for complex implementations:
+- **Loop 3 (Implementation)**: Create detailed implementation plan
+- **Loop 2 (Validation)**: Comprehensive test and review
+- **Product Owner Decision**: Strategic go/no-go checkpoint
+
+## Plan Structure Template
+
+```markdown
+# [Feature/Task Name]
+
+## Objectives
+- Clear, measurable implementation goals
+- Specific deliverables
+
+## Context Injection
+- Epic Context
+- Sprint Context
+- Specific Deliverables
+
+## Coordination Strategy
+- Coordinator: `cost-savings-cfn-loop-coordinator`
+- Agents: Specify roles (backend-dev, researcher, etc.)
+- Iteration Strategy
+
+## Phase 1: Test and Specification
+### Deliverables
+- [ ] Test script (tests/test-[feature].sh)
+- [ ] Specification document
+
+### Test Cases
+- Failure scenarios
+- Edge cases
+- Performance expectations
+
+## Phase 2: Minimal Implementation
+### Deliverables
+- [ ] Minimal working implementation
+- [ ] Initial test coverage
+
+## Phase 3: Refactoring and Optimization
+### Deliverables
+- [ ] Improved code quality
+- [ ] Enhanced test coverage
+- [ ] Performance optimization
+
+## Redis Coordination Checkpoints
+- Entry point validation
+- Iteration confidence reporting
+- Context extraction verification
+
+## Success Criteria
+- Test coverage ≥ 90%
+- Complexity score < 15
+- Meets architectural guidelines
+
+## Potential Blockers
+- Identify potential implementation challenges
+- Pre-emptive mitigation strategies
+
+## Iteration Strategy
+- Maximum iterations: 10
+- Confidence threshold: ≥ 0.90
+- Adaptive agent spawning based on feedback
+```
+
+## Usage Guidelines
+
+### Spawning Plan Creation
+```bash
+/write-plan "Implement JWT Authentication" \
+  --epic-context '{"goal":"Secure API access"}' \
+  --sprint-context '{"sprint":"Authentication MVP"}' \
+  --agents "backend-dev,security-specialist"
+```
+
+### Example Workflow
+1. Generate initial plan
+2. Review with team via Redis pub/sub
+3. Refine plan based on feedback
+4. Execute using `cost-savings-cfn-loop-coordinator`
+
+## Best Practices
+- Keep tasks small and focused
+- Prioritize testability
+- Leverage adaptive context injection
+- Use explicit deliverable tracking
+
+## Notes
+- This is a living document
+- Continuously update based on team feedback
+- Align with claude-flow-novice adaptive context strategies

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

@@ -0,0 +1,237 @@
+#!/usr/bin/env node
+
+/**
+ * CLAUDE.md Slash Command
+ *
+ * Simple wrapper around the existing CLAUDE.md generator with NPX protection
+ * Keeps it focused and lightweight - no bloat!
+ */
+
+import { ClaudeMdGenerator } from '../language/claude-md-generator.js';
+import { LanguageDetector } from '../language/language-detector.js';
+import fs from 'fs/promises';
+import path from 'path';
+
+export class ClaudeMdSlashCommand {
+  constructor(projectPath = process.cwd()) {
+    this.projectPath = projectPath;
+    this.claudeMdPath = path.join(projectPath, 'CLAUDE.md');
+    this.copyToMainPath = path.join(projectPath, 'claude-copy-to-main.md');
+  }
+
+  /**
+   * Main slash command execution
+   */
+  async execute(options = {}) {
+    const {
+      backup = true,
+      preview = false,
+      force = false,
+      isNpxInstall = false
+    } = options;
+
+    try {
+      console.log('🚀 Generating CLAUDE.md...');
+
+      // Step 1: Detect if this is an NPX install scenario
+      const existingClaudeExists = await this.fileExists(this.claudeMdPath);
+      const shouldUseNpxProtection = isNpxInstall && existingClaudeExists;
+
+      // Step 2: Generate content using existing system
+      const generator = new ClaudeMdGenerator(this.projectPath, {
+        backupExisting: backup && !shouldUseNpxProtection,
+        preserveCustomSections: true
+      });
+
+      const newContent = await generator.generateClaudeMd();
+
+      // Step 3: Handle NPX protection
+      if (shouldUseNpxProtection) {
+        await this.handleNpxProtection(newContent);
+        return {
+          success: true,
+          action: 'npx-protection',
+          file: 'claude-copy-to-main.md',
+          message: 'Generated claude-copy-to-main.md to protect your existing CLAUDE.md'
+        };
+      }
+
+      // Step 4: Handle preview mode
+      if (preview) {
+        return {
+          success: true,
+          action: 'preview',
+          content: newContent,
+          message: 'Preview generated successfully'
+        };
+      }
+
+      // Step 5: Handle force/confirmation for existing files
+      if (existingClaudeExists && !force) {
+        const shouldOverwrite = await this.confirmOverwrite();
+        if (!shouldOverwrite) {
+          return {
+            success: false,
+            action: 'cancelled',
+            message: 'Generation cancelled by user'
+          };
+        }
+      }
+
+      // Step 6: Write the file
+      await fs.writeFile(this.claudeMdPath, newContent, 'utf8');
+
+      console.log('✅ CLAUDE.md generated successfully');
+      return {
+        success: true,
+        action: 'generated',
+        file: 'CLAUDE.md',
+        length: newContent.length
+      };
+
+    } catch (error) {
+      console.error('❌ CLAUDE.md generation failed:', error.message);
+      return {
+        success: false,
+        action: 'error',
+        error: error.message
+      };
+    }
+  }
+
+  /**
+   * NPX Protection: Generate claude-copy-to-main.md instead of overwriting
+   */
+  async handleNpxProtection(newContent) {
+    const protectedContent = this.createProtectedContent(newContent);
+
+    await fs.writeFile(this.copyToMainPath, protectedContent, 'utf8');
+
+    console.log('🛡️ NPX Protection Activated');
+    console.log('📄 Generated: claude-copy-to-main.md');
+    console.log('💡 Your existing CLAUDE.md is protected from overwrite');
+    console.log('🔄 Review and merge changes manually as needed');
+  }
+
+  /**
+   * Create content for the protected file with merge instructions
+   */
+  createProtectedContent(newContent) {
+    return `# 🛡️ NPX-Protected CLAUDE.md Content
+
+## 📋 Merge Instructions
+
+This file was generated because you have an existing CLAUDE.md file.
+To protect your customizations from being overwritten by NPX installs,
+the new content is provided here for manual review and merging.
+
+### 🔄 How to Merge:
+1. Review the content below
+2. Copy sections you want to your main CLAUDE.md
+3. Delete this file when done
+4. Your customizations remain safe!
+
+---
+
+# Generated CLAUDE.md Content
+
+${newContent}
+
+---
+
+## 🗑️ Cleanup
+Delete this file after merging: \`rm claude-copy-to-main.md\`
+`;
+  }
+
+  /**
+   * Simple confirmation prompt for overwriting existing files
+   */
+  async confirmOverwrite() {
+    // In a real implementation, this would use readline or similar
+    // For now, return true (could be enhanced with proper prompting)
+    console.log('⚠️ CLAUDE.md exists. Use --force to overwrite or --preview to see changes.');
+    return false;
+  }
+
+  /**
+   * Check if file exists
+   */
+  async fileExists(filePath) {
+    try {
+      await fs.access(filePath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Show preview of what would be generated
+   */
+  async showPreview() {
+    const result = await this.execute({ preview: true });
+
+    if (result.success) {
+      console.log('📄 CLAUDE.md Preview:');
+      console.log('━'.repeat(50));
+      console.log(result.content.substring(0, 1000) + '...');
+      console.log('━'.repeat(50));
+      console.log(`📊 Total length: ${result.content.length} characters`);
+    }
+
+    return result;
+  }
+
+  /**
+   * Auto-detect project and suggest generation
+   */
+  async autoDetectAndSuggest() {
+    const detector = new LanguageDetector(this.projectPath);
+    const detection = await detector.detectProject();
+
+    console.log('🔍 Project Detection Results:');
+    console.log(`  Type: ${detection.projectType}`);
+    console.log(`  Confidence: ${(detection.confidence * 100).toFixed(1)}%`);
+
+    if (detection.confidence > 0.7) {
+      console.log('💡 High confidence - CLAUDE.md generation recommended');
+      return true;
+    } else {
+      console.log('⚠️ Low confidence - manual review recommended');
+      return false;
+    }
+  }
+}
+
+/**
+ * CLI Interface for slash command
+ */
+export async function executeClaudeMdCommand(args = {}) {
+  const command = new ClaudeMdSlashCommand();
+
+  // Handle different command modes
+  if (args.preview) {
+    return await command.showPreview();
+  }
+
+  if (args.detect) {
+    return await command.autoDetectAndSuggest();
+  }
+
+  // Default: generate CLAUDE.md
+  return await command.execute(args);
+}
+
+// For direct execution
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const args = {
+    preview: process.argv.includes('--preview'),
+    force: process.argv.includes('--force'),
+    backup: !process.argv.includes('--no-backup'),
+    detect: process.argv.includes('--detect'),
+    isNpxInstall: process.env.NPX_INSTALL === 'true'
+  };
+
+  executeClaudeMdCommand(args);
+}

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

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+
+/**
+ * CLAUDE-SOUL.md Slash Command
+ *
+ * Interactive questionnaire to create a project soul document.
+ * Guides users through defining their project's who, what, when, where, why
+ * to provide context for AI agents when they hit roadblocks.
+ * Document size: 250-500 words focusing on project essence and decision context.
+ */
+
+// Import from the main implementation
+import { executeClaudeSoulCommand } from '../../src/slash-commands/claude-soul.js';
+
+// Parse arguments
+const args = {
+  preview: process.argv.includes('--preview'),
+  force: process.argv.includes('--force'),
+  backup: !process.argv.includes('--no-backup'),
+  interactive: !process.argv.includes('--no-interactive'),
+  help: process.argv.includes('--help') || process.argv.includes('-h')
+};
+
+// Execute the command
+executeClaudeSoulCommand(args).catch(error => {
+  console.error('Error:', error.message);
+  process.exit(1);
+});

package/claude-assets/commands/cli-integration.js

@@ -0,0 +1,216 @@
+#!/usr/bin/env node
+
+/**
+ * CLI Integration for Slash Commands
+ * 
+ * Integrates slash commands with the main CLI system
+ */
+
+import { globalRegistry, executeSlashCommand } from './register-all-commands.js';
+import { SlashCommand } from '../core/slash-command.js';
+
+/**
+ * CLI Slash Command Handler
+ */
+export class CliSlashHandler {
+  constructor() {
+    this.registry = globalRegistry;
+  }
+
+  /**
+   * Handle CLI input and execute slash commands
+   * @param {string[]} args - CLI arguments
+   */
+  async handleCliInput(args) {
+    if (args.length === 0) {
+      this.showHelp();
+      return;
+    }
+
+    const command = args[0];
+    
+    // Handle help commands
+    if (command === 'help' || command === '--help' || command === '-h') {
+      if (args.length > 1) {
+        this.showCommandHelp(args[1]);
+      } else {
+        this.showHelp();
+      }
+      return;
+    }
+
+    // Handle list commands
+    if (command === 'list' || command === 'ls') {
+      this.listCommands();
+      return;
+    }
+
+    // Execute slash command
+    const slashCommand = `/${command}`;
+    const slashArgs = args.slice(1);
+    const input = `${slashCommand} ${slashArgs.join(' ')}`.trim();
+
+    try {
+      const result = await executeSlashCommand(input);
+      
+      if (result.success) {
+        if (result.result && result.result.prompt) {
+          console.log(result.result.prompt);
+        } else {
+          console.log('✅ Command executed successfully');
+          if (result.result) {
+            console.log(JSON.stringify(result.result, null, 2));
+          }
+        }
+      } else {
+        console.error(`❌ ${result.error}`);
+        if (result.suggestions && result.suggestions.length > 0) {
+          console.log(`Did you mean: ${result.suggestions.join(', ')}?`);
+        }
+      }
+    } catch (error) {
+      console.error(`❌ CLI Error: ${error.message}`);
+    }
+  }
+
+  /**
+   * Show general help
+   */
+  showHelp() {
+    console.log(this.registry.generateHelpText());
+  }
+
+  /**
+   * Show help for specific command
+   * @param {string} commandName - Command name
+   */
+  showCommandHelp(commandName) {
+    const helpResult = this.registry.getHelp(commandName);
+    
+    if (helpResult.success) {
+      const help = helpResult.help;
+      console.log(`
+🚀 **${help.name.toUpperCase()} COMMAND**
+`);
+      console.log(`**Description:** ${help.description}`);
+      console.log(`**Usage:** ${help.usage}`);
+      
+      if (help.examples && help.examples.length > 0) {
+        console.log(`
+**Examples:**`);
+        help.examples.forEach(example => {
+          console.log(`  ${example}`);
+        });
+      }
+    } else {
+      console.error(`❌ ${helpResult.error}`);
+    }
+  }
+
+  /**
+   * List all available commands
+   */
+  listCommands() {
+    const commands = this.registry.listCommands();
+    
+    console.log('
+🚀 **AVAILABLE SLASH COMMANDS**
+');
+    
+    commands.forEach(cmd => {
+      console.log(`/${cmd.name} - ${cmd.description}`);
+      if (cmd.aliases.length > 0) {
+        console.log(`  Aliases: ${cmd.aliases.map(a => `/${a}`).join(', ')}`);
+      }
+    });
+    
+    console.log(`
+Total: ${commands.length} commands available`);
+  }
+}
+
+/**
+ * Interactive CLI mode
+ */
+export class InteractiveCliMode {
+  constructor() {
+    this.handler = new CliSlashHandler();
+    this.running = false;
+  }
+
+  /**
+   * Start interactive mode
+   */
+  async start() {
+    this.running = true;
+    
+    console.log('🚀 Claude-Flow Interactive Slash Command Mode');
+    console.log('Type commands without the leading "/" or "help" for assistance');
+    console.log('Type "exit" to quit\n');
+
+    // Note: In a real implementation, you would use readline or similar
+    // This is a simplified version for demonstration
+    process.stdin.setEncoding('utf8');
+    
+    process.stdin.on('readable', async () => {
+      const chunk = process.stdin.read();
+      if (chunk !== null) {
+        const input = chunk.trim();
+        
+        if (input === 'exit' || input === 'quit') {
+          this.stop();
+          return;
+        }
+        
+        if (input) {
+          const args = input.split(' ');
+          await this.handler.handleCliInput(args);
+        }
+        
+        if (this.running) {
+          process.stdout.write('claude-flow> ');
+        }
+      }
+    });
+
+    process.stdout.write('claude-flow> ');
+  }
+
+  /**
+   * Stop interactive mode
+   */
+  stop() {
+    this.running = false;
+    console.log('\n👋 Goodbye!');
+    process.exit(0);
+  }
+}
+
+/**
+ * Main CLI entry point
+ * @param {string[]} args - Command line arguments
+ */
+export async function runCliSlashCommands(args = process.argv.slice(2)) {
+  const handler = new CliSlashHandler();
+  
+  // Check for interactive mode
+  if (args.includes('--interactive') || args.includes('-i')) {
+    const interactive = new InteractiveCliMode();
+    await interactive.start();
+    return;
+  }
+  
+  // Handle standard CLI input
+  await handler.handleCliInput(args);
+}
+
+// Auto-run if this script is executed directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+  runCliSlashCommands();
+}
+
+export default {
+  CliSlashHandler,
+  InteractiveCliMode,
+  runCliSlashCommands
+};

package/claude-assets/commands/coordination/README.md

@@ -0,0 +1,9 @@
+# Coordination Commands
+
+Commands for coordination operations in Claude Flow.
+
+## Available Commands
+
+- [swarm-init](./swarm-init.md)
+- [agent-spawn](./agent-spawn.md)
+- [task-orchestrate](./task-orchestrate.md)

package/claude-assets/commands/coordination/agent-spawn.md

@@ -0,0 +1,25 @@
+# agent-spawn
+
+Spawn a new agent in the current swarm.
+
+## Usage
+```bash
+npx cfn-spawn agent spawn [options]
+```
+
+## Options
+- `--type <type>` - Agent type (coder, researcher, analyst, tester, coordinator)
+- `--name <name>` - Custom agent name
+- `--skills <list>` - Specific skills (comma-separated)
+
+## Examples
+```bash
+# Spawn coder agent
+npx cfn-spawn agent spawn --type coder
+
+# With custom name
+npx cfn-spawn agent spawn --type researcher --name "API Expert"
+
+# With specific skills
+npx cfn-spawn agent spawn --type coder --skills "python,fastapi,testing"
+```

package/claude-assets/commands/coordination/coordination-system.md

@@ -0,0 +1,88 @@
+# Agent Coordination System
+
+## Overview
+The Claude-Flow coordination system manages multiple AI agents working together on complex tasks. It provides intelligent task distribution, resource management, and inter-agent communication.
+
+## Agent Types and Capabilities
+- **Researcher**: Web search, information gathering, knowledge synthesis
+- **Coder**: Code analysis, development, debugging, testing
+- **Analyst**: Data processing, pattern recognition, insights generation
+- **Coordinator**: Task planning, resource allocation, workflow management
+- **General**: Multi-purpose agent with balanced capabilities
+
+## Task Management
+- **Priority Levels**: 1 (lowest) to 10 (highest)
+- **Dependencies**: Tasks can depend on completion of other tasks
+- **Parallel Execution**: Independent tasks run concurrently
+- **Load Balancing**: Automatic distribution based on agent capacity
+
+## Coordination Commands
+```bash
+# Agent Management
+npx cfn-spawn agent spawn <type> --name <name> --priority <1-10>
+npx cfn-spawn agent list
+npx cfn-spawn agent info <agent-id>
+npx cfn-spawn agent terminate <agent-id>
+
+# Task Management  
+npx claude-flow-novice task create <type> <description> --priority <1-10> --deps <task-ids>
+npx claude-flow-novice task list --verbose
+npx claude-flow-novice task status <task-id>
+npx claude-flow-novice task cancel <task-id>
+
+# System Monitoring
+npx claude-flow-novice status --verbose
+npx claude-flow-novice monitor --interval 5000
+```
+
+## Workflow Execution
+Workflows are defined in JSON format and can orchestrate complex multi-agent operations:
+```bash
+npx claude-flow-novice workflow examples/research-workflow.json
+npx claude-flow-novice workflow examples/development-config.json --async
+```
+
+## Advanced Features
+- **Circuit Breakers**: Automatic failure handling and recovery
+- **Work Stealing**: Dynamic load redistribution for efficiency
+- **Resource Limits**: Memory and CPU usage constraints
+- **Metrics Collection**: Performance monitoring and optimization
+
+## Configuration
+Coordination settings in `claude-flow.config.json`:
+```json
+{
+  "orchestrator": {
+    "maxConcurrentTasks": 10,
+    "taskTimeout": 300000,
+    "defaultPriority": 5
+  },
+  "agents": {
+    "maxAgents": 20,
+    "defaultCapabilities": ["research", "code", "terminal"],
+    "resourceLimits": {
+      "memory": "1GB",
+      "cpu": "50%"
+    }
+  }
+}
+```
+
+## Communication Patterns
+- **Direct Messaging**: Agent-to-agent communication
+- **Event Broadcasting**: System-wide notifications
+- **Shared Memory**: Common information access
+- **Task Handoff**: Seamless work transfer between agents
+
+## Best Practices
+- Start with general agents and specialize as needed
+- Use descriptive task names and clear requirements
+- Monitor system resources during heavy workloads
+- Implement proper error handling in workflows
+- Regular cleanup of completed tasks and inactive agents
+
+## Troubleshooting
+- Check agent health with `npx claude-flow-novice status`
+- View detailed logs with `npx claude-flow-novice monitor`
+- Restart stuck agents with terminate/spawn cycle
+- Use `--verbose` flags for detailed diagnostic information