claude-flow-novice 2.8.1 → 2.9.1

package/.claude/commands/analysis/COMMAND_COMPLIANCE_REPORT.md

@@ -1,54 +0,0 @@
-# Analysis Commands Compliance Report
-
-## Overview
-Reviewed all command files in `.claude/commands/analysis/` directory to ensure proper usage of:
-- `mcp__claude-flow__*` tools (preferred)
-- `npx claude-flow` commands (as fallback)
-- No direct implementation calls
-
-## Files Reviewed
-
-### 1. token-efficiency.md
-**Status**: ✅ Updated
-**Changes Made**:
-- Replaced `npx ruv-swarm hook session-end --export-metrics` with proper MCP tool call
-- Updated to: `Tool: mcp__claude-flow__token_usage` with appropriate parameters
-- Maintained result format and context
-
-**Before**:
-```bash
-npx ruv-swarm hook session-end --export-metrics
-```
-
-**After**:
-```
-Tool: mcp__claude-flow__token_usage
-Parameters: {"operation": "session", "timeframe": "24h"}
-```
-
-### 2. performance-bottlenecks.md
-**Status**: ✅ Compliant (No changes needed)
-**Reason**: Already uses proper `mcp__claude-flow__task_results` tool format
-
-## Summary
-
-- **Total files reviewed**: 2
-- **Files updated**: 1
-- **Files already compliant**: 1
-- **Compliance rate after updates**: 100%
-
-## Compliance Patterns Enforced
-
-1. **MCP Tool Usage**: All direct tool calls now use `mcp__claude-flow__*` format
-2. **Parameter Format**: JSON parameters properly structured
-3. **Command Context**: Preserved original functionality and expected results
-4. **Documentation**: Maintained clarity and examples
-
-## Recommendations
-
-1. All analysis commands now follow the proper pattern
-2. No direct bash commands or implementation calls remain
-3. Token usage analysis properly integrated with MCP tools
-4. Performance analysis already using correct tool format
-
-The analysis directory is now fully compliant with the Claude Flow command standards.

package/.claude/commands/analysis/README.md

@@ -1,9 +0,0 @@
-# Analysis Commands
-
-Commands for analysis operations in Claude Flow.
-
-## Available Commands
-
-- [bottleneck-detect](./bottleneck-detect.md)
-- [token-usage](./token-usage.md)
-- [performance-report](./performance-report.md)

package/.claude/commands/analysis/bottleneck-detect.md

@@ -1,162 +0,0 @@
-# bottleneck detect
-
-Analyze performance bottlenecks in swarm operations and suggest optimizations.
-
-## Usage
-
-```bash
-npx claude-flow-novice bottleneck detect [options]
-```
-
-## Options
-
-- `--swarm-id, -s <id>` - Analyze specific swarm (default: current)
-- `--time-range, -t <range>` - Analysis period: 1h, 24h, 7d, all (default: 1h)
-- `--threshold <percent>` - Bottleneck threshold percentage (default: 20)
-- `--export, -e <file>` - Export analysis to file
-- `--fix` - Apply automatic optimizations
-
-## Examples
-
-### Basic bottleneck detection
-
-```bash
-npx claude-flow-novice bottleneck detect
-```
-
-### Analyze specific swarm
-
-```bash
-npx claude-flow-novice bottleneck detect --swarm-id swarm-123
-```
-
-### Last 24 hours with export
-
-```bash
-npx claude-flow-novice bottleneck detect -t 24h -e bottlenecks.json
-```
-
-### Auto-fix detected issues
-
-```bash
-npx claude-flow-novice bottleneck detect --fix --threshold 15
-```
-
-## Metrics Analyzed
-
-### Communication Bottlenecks
-
-- Message queue delays
-- Agent response times
-- Coordination overhead
-- Memory access patterns
-
-### Processing Bottlenecks
-
-- Task completion times
-- Agent utilization rates
-- Parallel execution efficiency
-- Resource contention
-
-### Memory Bottlenecks
-
-- Cache hit rates
-- Memory access patterns
-- Storage I/O performance
-- Neural pattern loading
-
-### Network Bottlenecks
-
-- API call latency
-- MCP communication delays
-- External service timeouts
-- Concurrent request limits
-
-## Output Format
-
-```
-🔍 Bottleneck Analysis Report
-━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-📊 Summary
-├── Time Range: Last 1 hour
-├── Agents Analyzed: 6
-├── Tasks Processed: 42
-└── Critical Issues: 2
-
-🚨 Critical Bottlenecks
-1. Agent Communication (35% impact)
-   └── coordinator → coder-1 messages delayed by 2.3s avg
-
-2. Memory Access (28% impact)
-   └── Neural pattern loading taking 1.8s per access
-
-⚠️ Warning Bottlenecks
-1. Task Queue (18% impact)
-   └── 5 tasks waiting > 10s for assignment
-
-💡 Recommendations
-1. Switch to hierarchical topology (est. 40% improvement)
-2. Enable memory caching (est. 25% improvement)
-3. Increase agent concurrency to 8 (est. 20% improvement)
-
-✅ Quick Fixes Available
-Run with --fix to apply:
-- Enable smart caching
-- Optimize message routing
-- Adjust agent priorities
-```
-
-## Automatic Fixes
-
-When using `--fix`, the following optimizations may be applied:
-
-1. **Topology Optimization**
-
-   - Switch to more efficient topology
-   - Adjust communication patterns
-   - Reduce coordination overhead
-
-2. **Caching Enhancement**
-
-   - Enable memory caching
-   - Optimize cache strategies
-   - Preload common patterns
-
-3. **Concurrency Tuning**
-
-   - Adjust agent counts
-   - Optimize parallel execution
-   - Balance workload distribution
-
-4. **Priority Adjustment**
-   - Reorder task queues
-   - Prioritize critical paths
-   - Reduce wait times
-
-## Performance Impact
-
-Typical improvements after bottleneck resolution:
-
-- **Communication**: 30-50% faster message delivery
-- **Processing**: 20-40% reduced task completion time
-- **Memory**: 40-60% fewer cache misses
-- **Overall**: 25-45% performance improvement
-
-## Integration with Claude Code
-
-```javascript
-// Check for bottlenecks in Claude Code
-mcp__claude-flow__bottleneck_detect {
-  timeRange: "1h",
-  threshold: 20,
-  autoFix: false
-}
-```
-
-## See Also
-
-- `performance report` - Detailed performance analysis
-- `token usage` - Token optimization analysis
-- `swarm monitor` - Real-time monitoring
-- `cache manage` - Cache optimization

package/.claude/commands/analysis/performance-bottlenecks.md

@@ -1,59 +0,0 @@
-# Performance Bottleneck Analysis
-
-## Purpose
-Identify and resolve performance bottlenecks in your development workflow.
-
-## Automated Analysis
-
-### 1. Real-time Detection
-The post-task hook automatically analyzes:
-- Execution time vs. complexity
-- Agent utilization rates
-- Resource constraints
-- Operation patterns
-
-### 2. Common Bottlenecks
-
-**Time Bottlenecks:**
-- Tasks taking > 5 minutes
-- Sequential operations that could parallelize
-- Redundant file operations
-
-**Coordination Bottlenecks:**
-- Single agent for complex tasks
-- Unbalanced agent workloads
-- Poor topology selection
-
-**Resource Bottlenecks:**
-- High operation count (> 100)
-- Memory constraints
-- I/O limitations
-
-### 3. Improvement Suggestions
-
-```
-Tool: mcp__claude-flow__task_results
-Parameters: {"taskId": "task-123", "format": "detailed"}
-
-Result includes:
-{
-  "bottlenecks": [
-    {
-      "type": "coordination",
-      "severity": "high",
-      "description": "Single agent used for complex task",
-      "recommendation": "Spawn specialized agents for parallel work"
-    }
-  ],
-  "improvements": [
-    {
-      "area": "execution_time",
-      "suggestion": "Use parallel task execution",
-      "expectedImprovement": "30-50% time reduction"
-    }
-  ]
-}
-```
-
-## Continuous Optimization
-The system learns from each task to prevent future bottlenecks!

package/.claude/commands/analysis/performance-report.md

@@ -1,25 +0,0 @@
-# performance-report
-
-Generate comprehensive performance reports for swarm operations.
-
-## Usage
-```bash
-npx claude-flow-novice analysis performance-report [options]
-```
-
-## Options
-- `--format <type>` - Report format (json, html, markdown)
-- `--include-metrics` - Include detailed metrics
-- `--compare <id>` - Compare with previous swarm
-
-## Examples
-```bash
-# Generate HTML report
-npx claude-flow-novice analysis performance-report --format html
-
-# Compare swarms
-npx claude-flow-novice analysis performance-report --compare swarm-123
-
-# Full metrics report
-npx claude-flow-novice analysis performance-report --include-metrics --format markdown
-```

package/.claude/commands/analysis/token-efficiency.md

@@ -1,45 +0,0 @@
-# Token Usage Optimization
-
-## Purpose
-Reduce token consumption while maintaining quality through intelligent coordination.
-
-## Optimization Strategies
-
-### 1. Smart Caching
-- Search results cached for 5 minutes
-- File content cached during session
-- Pattern recognition reduces redundant searches
-
-### 2. Efficient Coordination
-- Agents share context automatically
-- Avoid duplicate file reads
-- Batch related operations
-
-### 3. Measurement & Tracking
-
-```bash
-# Check token savings after session
-Tool: mcp__claude-flow__token_usage
-Parameters: {"operation": "session", "timeframe": "24h"}
-
-# Result shows:
-{
-  "metrics": {
-    "tokensSaved": 15420,
-    "operations": 45,
-    "efficiency": "343 tokens/operation"
-  }
-}
-```
-
-## Best Practices
-1. **Use Task tool** for complex searches
-2. **Enable caching** in pre-search hooks
-3. **Batch operations** when possible
-4. **Review session summaries** for insights
-
-## Token Reduction Results
-- 📉 32.3% average token reduction
-- 🎯 More focused operations
-- 🔄 Intelligent result reuse
-- 📊 Cumulative improvements

package/.claude/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/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/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/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/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