claude-flow-novice 2.10.5 → 2.10.7

package/claude-assets/commands/cfn/list-agents-rebuild.md

@@ -0,0 +1,205 @@
+---
+name: list-agents-rebuild
+description: "Regenerate available agents list from .claude/agents/cfn-dev-team/ folder discovery"
+argument-hint: "[--output=path] [--format=markdown]"
+allowed-tools: ["Bash", "Read", "Write"]
+---
+
+# Rebuild Available Agents List - Dynamic Discovery
+
+Regenerate `src/cli/hybrid-routing/AVAILABLE-AGENTS.md` from live agent discovery system.
+
+## Architecture Clarification
+
+**Source of Truth**: `.claude/agents/cfn-dev-team/` folder (50+ agent .md files)
+**Live Discovery**: `HybridWorkerSpawner.loadAgentDefinitions()` method
+**Documentation Snapshot**: `src/cli/hybrid-routing/AVAILABLE-AGENTS.md` (generated file)
+
+**When coordinators spawn agents**:
+1. Load agents dynamically from `.claude/agents/cfn-dev-team/` folder
+2. Parse YAML frontmatter from each .md file
+3. Extract keywords, system prompts, categories
+4. In-memory cache for performance
+5. Select agents via keyword matching or coordinator override
+
+**AVAILABLE-AGENTS.md purpose**:
+- Human-readable reference
+- Documentation for users/coordinators
+- Snapshot of available agents at generation time
+- **NOT** used by the spawning system (system reads .claude/agents/cfn-dev-team/ directly)
+
+---
+
+## Execution
+
+```bash
+# Regenerate agent list
+npx claude-flow-spawn --agents-by-category > src/cli/hybrid-routing/AVAILABLE-AGENTS.md.tmp
+
+# Parse and format into markdown document
+node << 'EOF'
+const fs = require('fs');
+const path = require('path');
+
+// Read raw output
+const rawOutput = fs.readFileSync('src/cli/hybrid-routing/AVAILABLE-AGENTS.md.tmp', 'utf8');
+
+// Parse output (extract agent data)
+const lines = rawOutput.split('\n');
+let markdown = '';
+
+// Generate markdown header
+markdown += '# Available Specialized Agents\n\n';
+markdown += '**Hybrid Routing System - Dynamic Agent Discovery**\n\n';
+markdown += '**Generated**: ' + new Date().toISOString().split('T')[0] + '\n';
+markdown += '**Source**: `.claude/agents/cfn-dev-team/` folder (live discovery)\n';
+markdown += '**Purpose**: Documentation snapshot - coordinators read from `.claude/agents/cfn-dev-team/` directly\n\n';
+
+// Add architecture note
+markdown += '## Architecture\n\n';
+markdown += '**Source of Truth**: `.claude/agents/cfn-dev-team/` folder\n';
+markdown += '- Coordinators use `HybridWorkerSpawner.loadAgentDefinitions()`\n';
+markdown += '- Recursive scanning with YAML frontmatter parsing\n';
+markdown += '- In-memory caching after first load\n';
+markdown += '- This file is documentation only (not used by spawning system)\n\n';
+
+// Parse discovery statistics
+const discoveredMatch = rawOutput.match(/Discovered (\d+) agent files/);
+const loadedMatch = rawOutput.match(/Loaded (\d+) agents/);
+const skippedMatch = rawOutput.match(/\((\d+) skipped\)/);
+const categoriesMatch = rawOutput.match(/(\d+) categories/);
+
+if (discoveredMatch && loadedMatch) {
+  markdown += '## Discovery Statistics\n\n';
+  markdown += '```\n';
+  markdown += `🔍 Discovered ${discoveredMatch[1]} agent files in .claude/agents/cfn-dev-team/\n`;
+  markdown += `✅ Loaded ${loadedMatch[1]} agents (${skippedMatch ? skippedMatch[1] : '?'} skipped)\n`;
+  markdown += `📋 ${categoriesMatch ? categoriesMatch[1] : '?'} categories\n`;
+  markdown += '```\n\n';
+}
+
+// Parse agent categories and create tables
+markdown += '## Agents by Category\n\n';
+
+let currentCategory = null;
+let agents = [];
+
+for (let i = 0; i < lines.length; i++) {
+  const line = lines[i];
+
+  // Detect category header
+  const categoryMatch = line.match(/^📁 ([A-Z-]+) \((\d+) agents?\)/);
+  if (categoryMatch) {
+    // Write previous category
+    if (currentCategory && agents.length > 0) {
+      markdown += createCategorySection(currentCategory, agents);
+      agents = [];
+    }
+
+    currentCategory = {
+      name: categoryMatch[1],
+      count: categoryMatch[2]
+    };
+    continue;
+  }
+
+  // Detect agent entry
+  const agentMatch = line.match(/^\s+•\s+([a-z-]+)/);
+  if (agentMatch) {
+    const agentType = agentMatch[1];
+    const nextLine = lines[i + 1] || '';
+    const keywords = nextLine.trim();
+
+    agents.push({ type: agentType, keywords });
+    i++; // Skip next line (already processed)
+  }
+}
+
+// Write last category
+if (currentCategory && agents.length > 0) {
+  markdown += createCategorySection(currentCategory, agents);
+}
+
+// Add usage section
+markdown += '\n---\n\n';
+markdown += '## Usage\n\n';
+markdown += '### CLI Commands\n\n';
+markdown += '```bash\n';
+markdown += '# List all agents (flat view)\n';
+markdown += 'npx claude-flow-spawn --list-agents\n\n';
+markdown += '# List agents by category\n';
+markdown += 'npx claude-flow-spawn --agents-by-category\n\n';
+markdown += '# Regenerate this documentation file\n';
+markdown += '/list-agents-rebuild\n';
+markdown += '```\n\n';
+
+markdown += '### Coordinator Usage\n\n';
+markdown += '```bash\n';
+markdown += '# Automatic selection (keyword-based)\n';
+markdown += 'npx claude-flow-spawn "Build auth" --max-agents=3\n\n';
+markdown += '# Coordinator override (manual agent types)\n';
+markdown += 'npx claude-flow-spawn "Task" \\\n';
+markdown += '  --agents=architect,coder,tester\n\n';
+markdown += '# Full override (custom agents + subtasks)\n';
+markdown += 'npx claude-flow-spawn "Task" \\\n';
+markdown += '  --agents=coder,security-specialist \\\n';
+markdown += '  --subtasks="Subtask 1|Subtask 2"\n';
+markdown += '```\n\n';
+
+// Add notes
+markdown += '---\n\n';
+markdown += '## Notes\n\n';
+markdown += '- **Live Discovery**: Coordinators read from `.claude/agents/cfn-dev-team/` folder directly\n';
+markdown += '- **This File**: Documentation snapshot for human reference\n';
+markdown += '- **Regenerate**: Run `/list-agents-rebuild` to update this documentation\n';
+markdown += '- **Agent Files**: Add/modify agents in `.claude/agents/cfn-dev-team/` folder (auto-discovered)\n';
+markdown += '- **Caching**: Agent definitions cached after first load (lazy loading)\n';
+markdown += '- **Missing Keywords**: Some agents without keywords can be used via coordinator override\n\n';
+
+// Write final markdown
+fs.writeFileSync('src/cli/hybrid-routing/AVAILABLE-AGENTS.md', markdown, 'utf8');
+
+console.log('✅ AVAILABLE-AGENTS.md regenerated successfully');
+
+// Helper function
+function createCategorySection(category, agents) {
+  let section = `### 📁 ${category.name} (${category.count} agents)\n\n`;
+  section += '| Agent Type | Keywords |\n';
+  section += '|------------|----------|\n';
+
+  for (const agent of agents) {
+    const keywords = agent.keywords || '*(No keywords available)*';
+    section += `| **${agent.type}** | ${keywords} |\n`;
+  }
+
+  section += '\n---\n\n';
+  return section;
+}
+EOF
+
+# Cleanup temp file
+rm src/cli/hybrid-routing/AVAILABLE-AGENTS.md.tmp
+
+echo ""
+echo "📋 Agent list regenerated: src/cli/hybrid-routing/AVAILABLE-AGENTS.md"
+echo ""
+echo "Architecture:"
+echo "  • Source: .claude/agents/cfn-dev-team/ folder (50+ agent .md files)"
+echo "  • Coordinators: Load agents dynamically via HybridWorkerSpawner"
+echo "  • This file: Documentation snapshot for human reference"
+```
+
+---
+
+## Output
+
+```
+✅ AVAILABLE-AGENTS.md regenerated successfully
+
+📋 Agent list regenerated: src/cli/hybrid-routing/AVAILABLE-AGENTS.md
+
+Architecture:
+  • Source: .claude/agents/cfn-dev-team/ folder (50+ agent .md files)
+  • Coordinators: Load agents dynamically via HybridWorkerSpawner
+  • This file: Documentation snapshot for human reference
+```

package/claude-assets/commands/cfn/metrics-summary.md

@@ -0,0 +1,58 @@
+# Metrics Summary
+
+Display aggregated metrics statistics with configurable time frame and manage metrics tracking.
+
+## Usage
+
+```bash
+# Display metrics summary
+/metrics-summary [--minutes=60] [--provider=all] [--model=all]
+
+# Manage tracking
+/metrics-summary --enable    # Enable metrics tracking
+/metrics-summary --disable   # Disable metrics tracking
+/metrics-summary --status    # Check tracking status
+```
+
+## Parameters
+
+### Display Metrics
+- `--minutes` - Time frame in minutes (default: 60 = last hour)
+  - Examples: 60 (1 hour), 1440 (24 hours), 10080 (7 days)
+- `--provider` - Filter by provider: `all`, `anthropic`, `z.ai` (default: all)
+- `--model` - Filter by model name (default: all)
+
+### Manage Tracking
+- `--enable` - Enable metrics tracking
+- `--disable` - Disable metrics tracking
+- `--status` - Check current tracking status
+
+## Examples
+
+```bash
+# Last hour stats (all providers)
+/metrics-summary
+
+# Last 24 hours
+/metrics-summary --minutes=1440
+
+# Last hour Z.ai only
+/metrics-summary --minutes=60 --provider=z.ai
+
+# Last 7 days GLM-4.6 only
+/metrics-summary --minutes=10080 --model=glm-4.6
+
+# Enable/disable tracking
+/metrics-summary --enable
+/metrics-summary --disable
+/metrics-summary --status
+```
+
+## Output
+
+- **API Requests**: Total count by provider
+- **Token Usage**: Input/Output/Total by provider and model
+- **Error Rate**: Success vs error percentage
+- **Cost Breakdown**: Estimated costs by provider (if pricing available)
+- **Top Models**: Most used models in time frame
+- **Performance**: Average API duration by provider

package/claude-assets/commands/cfn/neural.md

@@ -0,0 +1,39 @@
+---
+description: "Neural network training and management"
+argument-hint: "<action> [parameters]"
+allowed-tools: ["mcp__claude-flow-novice__memory_usage", "mcp__claude-flow-novice__performance_report"]
+---
+
+# Neural Network Training & Management
+
+Manage neural networks, training, and cognitive patterns for AI agents.
+
+**Action**: $ARGUMENTS
+
+**Available Neural Actions**:
+- `status` - Check neural network status
+- `train <pattern> <iterations>` - Train neural patterns
+- `patterns` - Analyze cognitive patterns
+- `predict "<input>"` - Make neural predictions
+- `compress <model>` - Compress neural models
+- `explain <prediction>` - Explain neural decisions
+
+**Neural Capabilities**:
+
+## Training Patterns
+- **Coordination**: Agent coordination patterns
+- **Optimization**: Performance optimization patterns
+- **Prediction**: Task completion prediction
+
+## Cognitive Patterns
+- **Convergent**: Focused problem-solving
+- **Divergent**: Creative exploration
+- **Lateral**: Cross-domain thinking
+- **Systems**: Holistic system analysis
+
+## Model Management
+- **WASM SIMD**: Accelerated neural processing
+- **Ensemble**: Multiple model coordination
+- **Transfer**: Cross-domain learning
+
+Execute neural network operations with real-time feedback and performance monitoring.

package/claude-assets/commands/cfn/parse-epic.md

@@ -0,0 +1,357 @@
+---
+description: "Parse natural language epic documents to structured JSON configuration"
+argument-hint: "<epic-directory> [--output <file>] [--validate]"
+allowed-tools: ["Read", "Write", "Bash", "Glob", "Grep"]
+---
+
+# Parse Epic - Natural Language to Structured JSON
+
+Convert natural language epic markdown documents into structured JSON configuration for CFN Loop execution.
+
+**Input**: Natural language epic directory with markdown files
+**Output**: Structured JSON configuration with phases, sprints, dependencies
+
+## Usage
+
+```bash
+# Basic parsing
+/parse-epic planning/example-epic
+
+# With custom output file
+/parse-epic planning/my-epic --output epic-config.json
+
+# With validation
+/parse-epic planning/auth-epic --validate
+
+# Full options
+/parse-epic planning/example-epic --output custom-epic.json --validate
+```
+
+## Command Arguments
+
+- `<epic-directory>`: **Required** - Path to epic directory containing markdown files
+- `--output <file>`: Optional - Custom output JSON file (default: `<epic-name>-config.json`)
+- `--validate`: Optional - Validate parsed configuration against schema
+
+## Epic Directory Structure
+
+```
+planning/example-epic/
+├── OVERVIEW.md              # Epic description, goals, scope
+├── phase-1-authentication.md    # Phase 1 details
+├── phase-2-authorization.md     # Phase 2 details
+├── phase-3-session-mgmt.md      # Phase 3 details
+└── dependencies.md          # Cross-phase dependencies (optional)
+```
+
+## Markdown Format
+
+### OVERVIEW.md
+```markdown
+# Auth System Epic
+
+**Goal**: Build complete authentication and authorization system
+
+## Scope
+
+### In Scope
+- JWT-based authentication
+- Role-based access control (RBAC)
+- Session management
+- Password security (bcrypt)
+
+### Out of Scope
+- OAuth/social login
+- Multi-factor authentication
+- Biometric authentication
+
+## Risk Profile
+public-facing-medium-risk
+
+## Estimated Timeline
+3 phases, 8 sprints total
+```
+
+### Phase Markdown (phase-1-authentication.md)
+```markdown
+# Phase 1: User Authentication
+
+**Phase ID**: 1
+**Dependencies**: None
+
+## Deliverables
+- Login API endpoint (POST /auth/login)
+- JWT token generation
+- Password validation
+- bcrypt password hashing
+
+## Sprints
+
+### Sprint 1.1: Core Login API
+- POST /auth/login endpoint
+- JWT token generation
+- Basic password validation
+**Estimated Agents**: 3
+
+### Sprint 1.2: Password Security
+- bcrypt password hashing
+- Salt generation
+- Hash verification
+**Estimated Agents**: 2
+
+## Success Criteria
+- All login tests passing
+- Security audit complete
+- API documentation updated
+```
+
+## Output JSON Structure
+
+The parser generates a structured JSON configuration:
+
+```json
+{
+  "epic_name": "auth-system",
+  "epic_goal": "Build complete authentication and authorization system",
+  "scope": {
+    "in_scope": [
+      "JWT-based authentication",
+      "Role-based access control (RBAC)",
+      "Session management",
+      "Password security (bcrypt)"
+    ],
+    "out_of_scope": [
+      "OAuth/social login",
+      "Multi-factor authentication",
+      "Biometric authentication"
+    ],
+    "risk_profile": "public-facing-medium-risk"
+  },
+  "phases": [
+    {
+      "phase_id": "1",
+      "phase_name": "User Authentication",
+      "dependencies": [],
+      "deliverables": [
+        "Login API endpoint (POST /auth/login)",
+        "JWT token generation",
+        "Password validation",
+        "bcrypt password hashing"
+      ],
+      "sprints": [
+        {
+          "sprint_id": "1.1",
+          "sprint_name": "Core Login API",
+          "deliverables": [
+            "POST /auth/login endpoint",
+            "JWT token generation",
+            "Basic password validation"
+          ],
+          "estimated_agents": 3
+        },
+        {
+          "sprint_id": "1.2",
+          "sprint_name": "Password Security",
+          "deliverables": [
+            "bcrypt password hashing",
+            "Salt generation",
+            "Hash verification"
+          ],
+          "estimated_agents": 2
+        }
+      ],
+      "success_criteria": [
+        "All login tests passing",
+        "Security audit complete",
+        "API documentation updated"
+      ]
+    }
+  ],
+  "decision_authority_config": {
+    "auto_approve_threshold": 0.90,
+    "auto_relaunch_max_iteration": 10,
+    "escalation_criteria": [
+      "security vulnerability",
+      "data loss risk"
+    ]
+  }
+}
+```
+
+## Validation
+
+When using `--validate`, the parser checks:
+- ✅ Valid phase IDs and naming
+- ✅ Dependency resolution (no circular dependencies)
+- ✅ Sprint numbering consistency (1.1, 1.2, etc.)
+- ✅ Deliverables are non-empty
+- ✅ Scope boundaries are defined
+- ✅ Risk profile is valid (internal-only-low-risk, public-facing-medium-risk, critical-high-risk)
+- ✅ Success criteria are specified
+
+**Validation Errors:**
+```
+❌ Validation Failed:
+- Phase 2 dependency on Phase 5 (does not exist)
+- Sprint 1.3 missing deliverables
+- Risk profile "high" invalid (use: internal-only-low-risk, public-facing-medium-risk, critical-high-risk)
+```
+
+## Integration with CFN Loop
+
+After parsing, use the JSON configuration with CFN Loop commands:
+
+```bash
+# 1. Parse epic to JSON
+/parse-epic planning/auth-epic --output auth-config.json --validate
+
+# 2. Execute epic using parsed configuration
+/cfn-loop-epic "$(cat auth-config.json)"
+
+# Or manually reference phases
+/cfn-loop-sprints "Phase 1: User Authentication (from auth-config.json)"
+```
+
+## Automatic Scope Storage
+
+The parser automatically stores scope boundaries in memory for Product Owner access:
+
+```javascript
+// Automatically executed during parsing
+mcp__claude-flow-novice__memory_usage({
+  action: "store",
+  namespace: "scope-control",
+  key: "project-boundaries",
+  value: JSON.stringify({
+    primary_goal: epicConfig.epic_goal,
+    in_scope: epicConfig.scope.in_scope,
+    out_of_scope: epicConfig.scope.out_of_scope,
+    risk_profile: epicConfig.scope.risk_profile,
+    decision_authority_config: epicConfig.decision_authority_config
+  })
+})
+```
+
+## Example Workflows
+
+### Workflow 1: Parse and Execute Epic
+```bash
+# Step 1: Create epic markdown files in planning/auth-epic/
+# Step 2: Parse to JSON
+/parse-epic planning/auth-epic --output auth-config.json --validate
+
+# Step 3: Execute epic (automatic phase orchestration)
+/cfn-loop-epic "$(cat auth-config.json)"
+```
+
+### Workflow 2: Parse and Execute Single Phase
+```bash
+# Step 1: Parse epic
+/parse-epic planning/my-epic --validate
+
+# Step 2: Extract specific phase (manual)
+# Read my-epic-config.json, copy Phase 1 details
+
+# Step 3: Execute single phase
+/cfn-loop-sprints "Phase 1 content from parsed JSON"
+```
+
+### Workflow 3: Validate Epic Structure
+```bash
+# Validate epic structure before execution
+/parse-epic planning/complex-epic --validate
+
+# Review validation output
+# Fix any errors in markdown files
+# Re-run validation until clean
+```
+
+## Output Files
+
+**Generated Files:**
+- `<epic-name>-config.json` - Structured epic configuration
+- `<epic-name>-validation-report.json` - Validation results (if --validate)
+
+**Example Output:**
+```bash
+🔍 Epic Parser - Natural Language to Structured JSON
+
+📂 Epic directory: planning/auth-epic
+📄 Overview file: OVERVIEW.md
+
+✅ Parsed successfully:
+   - Epic: auth-system
+   - Phases: 3
+   - Total Sprints: 8
+   - Scope boundaries: ✓
+   - Dependencies: ✓
+
+📄 Output: auth-config.json
+✅ Validation: PASSED
+
+Ready for CFN Loop execution!
+```
+
+## Error Handling
+
+**Common Errors:**
+
+1. **Missing OVERVIEW.md**
+   ```
+   ❌ Epic directory must contain OVERVIEW.md
+   ```
+
+2. **Invalid Phase Dependencies**
+   ```
+   ❌ Phase 3 depends on Phase 5 (not found)
+   ```
+
+3. **Circular Dependencies**
+   ```
+   ❌ Circular dependency detected: Phase 1 → Phase 2 → Phase 1
+   ```
+
+4. **Invalid Sprint Numbering**
+   ```
+   ❌ Sprint 1.5 follows 1.2 (expected 1.3)
+   ```
+
+## Advanced Features
+
+### Custom Risk Profiles
+```markdown
+## Risk Profile
+custom-high-security-critical
+
+## Decision Authority
+- Auto-approve threshold: 0.95
+- Max iteration: 5
+- Escalation: security-team-approval-required
+```
+
+### Cross-Phase Dependencies
+Create `dependencies.md`:
+```markdown
+# Epic Dependencies
+
+- Phase 2 requires Phase 1 (authentication must complete first)
+- Phase 3 requires Phase 1, Phase 2 (session needs auth + authorization)
+- Phase 4 requires Phase 3 (admin panel needs sessions)
+```
+
+### Sprint Estimation
+```markdown
+### Sprint 2.3: Complex Authorization Logic
+**Estimated Agents**: 8
+**Complexity**: High
+**Rationale**: Multi-tenant RBAC with custom permission system
+```
+
+## Tips for Epic Creation
+
+1. **Start with OVERVIEW.md** - Define clear scope boundaries
+2. **One phase per file** - Keep phase definitions modular
+3. **Explicit dependencies** - Document all cross-phase requirements
+4. **Realistic sprint sizing** - 2-5 deliverables per sprint
+5. **Validate early** - Use `--validate` during epic creation
+6. **Clear success criteria** - Define measurable phase completion criteria

package/claude-assets/commands/cfn/performance.md

@@ -0,0 +1,41 @@
+---
+description: "Performance monitoring and optimization"
+argument-hint: "<action> [component]"
+allowed-tools: ["mcp__claude-flow-novice__performance_report", "mcp__claude-flow-novice__bottleneck_analyze", "mcp__claude-flow-novice__health_check"]
+---
+
+# Performance Monitoring & Optimization
+
+Monitor system performance, identify bottlenecks, and optimize operations.
+
+**Action**: $ARGUMENTS
+
+**Available Performance Actions**:
+- `report` - Generate comprehensive performance report
+- `benchmark [type]` - Run performance benchmarks
+- `bottleneck [component]` - Identify performance bottlenecks
+- `tokens` - Analyze token consumption patterns
+- `trends` - Show performance trends over time
+- `optimize` - Auto-optimize system performance
+
+**Performance Metrics**:
+
+## System Performance
+- **Memory Usage**: RAM and cache utilization
+- **CPU Performance**: Processing efficiency
+- **I/O Operations**: File and network operations
+- **Agent Coordination**: Swarm performance metrics
+
+## Optimization Areas
+- **Token Efficiency**: Reduce token consumption
+- **Parallel Execution**: Multi-agent coordination
+- **Cache Management**: Memory optimization
+- **Resource Allocation**: Dynamic scaling
+
+## Monitoring Features
+- **Real-time Metrics**: Live performance data
+- **Trend Analysis**: Historical performance patterns
+- **Bottleneck Detection**: Automated issue identification
+- **SLA Monitoring**: Service level tracking
+
+Execute performance analysis and provide actionable optimization recommendations.