claude-flow-novice 2.10.9 → 2.11.0

package/claude-assets/commands/analysis/token-usage.md

@@ -1,25 +0,0 @@
-# token-usage
-
-Analyze token usage patterns and optimize for efficiency.
-
-## Usage
-```bash
-npx claude-flow-novice analysis token-usage [options]
-```
-
-## Options
-- `--period <time>` - Analysis period (1h, 24h, 7d, 30d)
-- `--by-agent` - Break down by agent
-- `--by-operation` - Break down by operation type
-
-## Examples
-```bash
-# Last 24 hours token usage
-npx claude-flow-novice analysis token-usage --period 24h
-
-# By agent breakdown
-npx claude-flow-novice analysis token-usage --by-agent
-
-# Export detailed report
-npx claude-flow-novice analysis token-usage --period 7d --export tokens.csv
-```

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

@@ -1,9 +0,0 @@
-# Automation Commands
-
-Commands for automation operations in Claude Flow.
-
-## Available Commands
-
-- [auto-agent](./auto-agent.md)
-- [smart-spawn](./smart-spawn.md)
-- [workflow-select](./workflow-select.md)

package/claude-assets/commands/automation/auto-agent.md

@@ -1,122 +0,0 @@
-# auto agent
-
-Automatically spawn and manage agents based on task requirements.
-
-## Usage
-
-```bash
-npx claude-flow-novice auto agent [options]
-```
-
-## Options
-
-- `--task, -t <description>` - Task description for agent analysis
-- `--max-agents, -m <number>` - Maximum agents to spawn (default: auto)
-- `--min-agents <number>` - Minimum agents required (default: 1)
-- `--strategy, -s <type>` - Selection strategy: optimal, minimal, balanced
-- `--no-spawn` - Analyze only, don't spawn agents
-
-## Examples
-
-### Basic auto-spawning
-
-```bash
-npx claude-flow-novice auto agent --task "Build a REST API with authentication"
-```
-
-### Constrained spawning
-
-```bash
-npx claude-flow-novice auto agent -t "Debug performance issue" --max-agents 3
-```
-
-### Analysis only
-
-```bash
-npx claude-flow-novice auto agent -t "Refactor codebase" --no-spawn
-```
-
-### Minimal strategy
-
-```bash
-npx claude-flow-novice auto agent -t "Fix bug in login" -s minimal
-```
-
-## How It Works
-
-1. **Task Analysis**
-
-   - Parses task description
-   - Identifies required skills
-   - Estimates complexity
-   - Determines parallelization opportunities
-
-2. **Agent Selection**
-
-   - Matches skills to agent types
-   - Considers task dependencies
-   - Optimizes for efficiency
-   - Respects constraints
-
-3. **Topology Selection**
-
-   - Chooses optimal swarm structure
-   - Configures communication patterns
-   - Sets up coordination rules
-   - Enables monitoring
-
-4. **Automatic Spawning**
-   - Creates selected agents
-   - Assigns specific roles
-   - Distributes subtasks
-   - Initiates coordination
-
-## Agent Types Selected
-
-- **Architect**: System design, architecture decisions
-- **Coder**: Implementation, code generation
-- **Tester**: Test creation, quality assurance
-- **Analyst**: Performance, optimization
-- **Researcher**: Documentation, best practices
-- **Coordinator**: Task management, progress tracking
-
-## Strategies
-
-### Optimal
-
-- Maximum efficiency
-- May spawn more agents
-- Best for complex tasks
-- Highest resource usage
-
-### Minimal
-
-- Minimum viable agents
-- Conservative approach
-- Good for simple tasks
-- Lowest resource usage
-
-### Balanced
-
-- Middle ground
-- Adaptive to complexity
-- Default strategy
-- Good performance/resource ratio
-
-## Integration with Claude Code
-
-```javascript
-// In Claude Code after auto-spawning
-mcp__claude-flow__auto_agent {
-  task: "Build authentication system",
-  strategy: "balanced",
-  maxAgents: 6
-}
-```
-
-## See Also
-
-- `agent spawn` - Manual agent creation
-- `swarm init` - Initialize swarm manually
-- `smart spawn` - Intelligent agent spawning
-- `workflow select` - Choose predefined workflows

package/claude-assets/commands/automation/self-healing.md

@@ -1,106 +0,0 @@
-# Self-Healing Workflows
-
-## Purpose
-Automatically detect and recover from errors without interrupting your flow.
-
-## Self-Healing Features
-
-### 1. Error Detection
-Monitors for:
-- Failed commands
-- Syntax errors
-- Missing dependencies
-- Broken tests
-
-### 2. Automatic Recovery
-
-**Missing Dependencies:**
-```
-Error: Cannot find module 'express'
-→ Automatically runs: npm install express
-→ Retries original command
-```
-
-**Syntax Errors:**
-```
-Error: Unexpected token
-→ Analyzes error location
-→ Suggests fix through analyzer agent
-→ Applies fix with confirmation
-```
-
-**Test Failures:**
-```
-Test failed: "user authentication"
-→ Spawns debugger agent
-→ Analyzes failure cause
-→ Implements fix
-→ Re-runs tests
-```
-
-### 3. Learning from Failures
-Each recovery improves future prevention:
-- Patterns saved to knowledge base
-- Similar errors prevented proactively
-- Recovery strategies optimized
-
-**Pattern Storage:**
-```javascript
-// Store error patterns
-mcp__claude-flow__memory_usage({
-  "action": "store",
-  "key": "error-pattern-" + Date.now(),
-  "value": JSON.stringify(errorData),
-  "namespace": "error-patterns",
-  "ttl": 2592000 // 30 days
-})
-
-// Analyze patterns
-mcp__claude-flow__neural_patterns({
-  "action": "analyze",
-  "operation": "error-recovery",
-  "outcome": "success"
-})
-```
-
-## Self-Healing Integration
-
-### MCP Tool Coordination
-```javascript
-// Initialize self-healing swarm
-mcp__claude-flow__swarm_init({
-  "topology": "star",
-  "maxAgents": 4,
-  "strategy": "adaptive"
-})
-
-// Spawn recovery agents
-mcp__claude-flow__agent_spawn({
-  "type": "monitor",
-  "name": "Error Monitor",
-  "capabilities": ["error-detection", "recovery"]
-})
-
-// Orchestrate recovery
-mcp__claude-flow__task_orchestrate({
-  "task": "recover from error",
-  "strategy": "sequential",
-  "priority": "critical"
-})
-```
-
-### Fallback Hook Configuration
-```json
-{
-  "PostToolUse": [{
-    "matcher": "^Bash$",
-    "command": "npx claude-flow-novice hook post-bash --exit-code '${tool.result.exitCode}' --auto-recover"
-  }]
-}
-```
-
-## Benefits
-- 🛡️ Resilient workflows
-- 🔄 Automatic recovery
-- 📚 Learns from errors
-- ⏱️ Saves debugging time

package/claude-assets/commands/automation/session-memory.md

@@ -1,90 +0,0 @@
-# Cross-Session Memory
-
-## Purpose
-Maintain context and learnings across Claude Code sessions for continuous improvement.
-
-## Memory Features
-
-### 1. Automatic State Persistence
-At session end, automatically saves:
-- Active agents and specializations
-- Task history and patterns
-- Performance metrics
-- Neural network weights
-- Knowledge base updates
-
-### 2. Session Restoration
-```javascript
-// Using MCP tools for memory operations
-mcp__claude-flow__memory_usage({
-  "action": "retrieve",
-  "key": "session-state",
-  "namespace": "sessions"
-})
-
-// Restore swarm state
-mcp__claude-flow__context_restore({
-  "snapshotId": "sess-123"
-})
-```
-
-**Fallback with npx:**
-```bash
-npx claude-flow-novice hook session-restore --session-id "sess-123"
-```
-
-### 3. Memory Types
-
-**Project Memory:**
-- File relationships
-- Common edit patterns
-- Testing approaches
-- Build configurations
-
-**Agent Memory:**
-- Specialization levels
-- Task success rates
-- Optimization strategies
-- Error patterns
-
-**Performance Memory:**
-- Bottleneck history
-- Optimization results
-- Token usage patterns
-- Efficiency trends
-
-### 4. Privacy & Control
-```javascript
-// List memory contents
-mcp__claude-flow__memory_usage({
-  "action": "list",
-  "namespace": "sessions"
-})
-
-// Delete specific memory
-mcp__claude-flow__memory_usage({
-  "action": "delete",
-  "key": "session-123",
-  "namespace": "sessions"
-})
-
-// Backup memory
-mcp__claude-flow__memory_backup({
-  "path": "./backups/memory-backup.json"
-})
-```
-
-**Manual control:**
-```bash
-# View stored memory
-ls .claude-flow/memory/
-
-# Disable memory
-export CLAUDE_FLOW_MEMORY_PERSIST=false
-```
-
-## Benefits
-- 🧠 Contextual awareness
-- 📈 Cumulative learning
-- ⚡ Faster task completion
-- 🎯 Personalized optimization

package/claude-assets/commands/automation/smart-agents.md

@@ -1,73 +0,0 @@
-# Smart Agent Auto-Spawning
-
-## Purpose
-Automatically spawn the right agents at the right time without manual intervention.
-
-## Auto-Spawning Triggers
-
-### 1. File Type Detection
-When editing files, agents auto-spawn:
-- **JavaScript/TypeScript**: Coder agent
-- **Markdown**: Researcher agent
-- **JSON/YAML**: Analyst agent
-- **Multiple files**: Coordinator agent
-
-### 2. Task Complexity
-```
-Simple task: "Fix typo"
-→ Single coordinator agent
-
-Complex task: "Implement OAuth with Google"
-→ Architect + Coder + Tester + Researcher
-```
-
-### 3. Dynamic Scaling
-The system monitors workload and spawns additional agents when:
-- Task queue grows
-- Complexity increases
-- Parallel opportunities exist
-
-**Status Monitoring:**
-```javascript
-// Check swarm health
-mcp__claude-flow__swarm_status({
-  "swarmId": "current"
-})
-
-// Monitor agent performance
-mcp__claude-flow__agent_metrics({
-  "agentId": "agent-123"
-})
-```
-
-## Configuration
-
-### MCP Tool Integration
-Uses Claude Flow MCP tools for agent coordination:
-```javascript
-// Initialize swarm with appropriate topology
-mcp__claude-flow__swarm_init({
-  "topology": "mesh",
-  "maxAgents": 8,
-  "strategy": "auto"
-})
-
-// Spawn agents based on file type
-mcp__claude-flow__agent_spawn({
-  "type": "coder",
-  "name": "JavaScript Handler",
-  "capabilities": ["javascript", "typescript"]
-})
-```
-
-### Fallback Configuration
-If MCP tools are unavailable:
-```bash
-npx claude-flow-novice hook pre-task --auto-spawn-agents
-```
-
-## Benefits
-- 🤖 Zero manual agent management
-- 🎯 Perfect agent selection
-- 📈 Dynamic scaling
-- 💾 Resource efficiency

package/claude-assets/commands/automation/smart-spawn.md

@@ -1,25 +0,0 @@
-# smart-spawn
-
-Intelligently spawn agents based on workload analysis.
-
-## Usage
-```bash
-npx claude-flow-novice automation smart-spawn [options]
-```
-
-## Options
-- `--analyze` - Analyze before spawning
-- `--threshold <n>` - Spawn threshold
-- `--topology <type>` - Preferred topology
-
-## Examples
-```bash
-# Smart spawn with analysis
-npx claude-flow-novice automation smart-spawn --analyze
-
-# Set spawn threshold
-npx claude-flow-novice automation smart-spawn --threshold 5
-
-# Force topology
-npx claude-flow-novice automation smart-spawn --topology hierarchical
-```

package/claude-assets/commands/automation/workflow-select.md

@@ -1,25 +0,0 @@
-# workflow-select
-
-Automatically select optimal workflow based on task type.
-
-## Usage
-```bash
-npx claude-flow-novice automation workflow-select [options]
-```
-
-## Options
-- `--task <description>` - Task description
-- `--constraints <list>` - Workflow constraints
-- `--preview` - Preview without executing
-
-## Examples
-```bash
-# Select workflow for task
-npx claude-flow-novice automation workflow-select --task "Deploy to production"
-
-# With constraints
-npx claude-flow-novice automation workflow-select --constraints "no-downtime,rollback"
-
-# Preview mode
-npx claude-flow-novice automation workflow-select --task "Database migration" --preview
-```

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

@@ -1,237 +0,0 @@
-#!/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);
-}