claude-flow-novice 2.10.9 → 2.11.0

package/.claude/commands/README.md

@@ -0,0 +1,157 @@
+# CLAUDE.md Slash Command System
+
+## 🎯 Simple, Focused CLAUDE.md Generation
+
+A lightweight slash command system for generating CLAUDE.md files with NPX protection.
+
+## 📋 Features
+
+### ✅ **Simple Slash Command**
+```bash
+/claude-md                    # Generate CLAUDE.md for current project
+/claude-md --preview         # Show what would be generated
+/claude-md --force           # Overwrite without confirmation
+/claude-md --detect          # Auto-detect project and show recommendations
+/claude-md --no-backup       # Skip backup creation
+```
+
+### 🛡️ **NPX Protection System**
+- **Problem**: NPX installs overwrite customized CLAUDE.md files
+- **Solution**: Generate `claude-copy-to-main.md` when existing CLAUDE.md detected
+- **Benefit**: User customizations are never lost
+
+### 🔄 **Integration Flow**
+
+**Normal Usage (Slash Command):**
+1. User runs `/claude-md`
+2. System detects project type
+3. Generates appropriate CLAUDE.md
+4. Creates backup if file exists
+
+**NPX Install Protection:**
+1. NPX installs claude-flow-novice
+2. `postinstall` script runs
+3. Detects existing CLAUDE.md
+4. Creates `claude-copy-to-main.md` instead
+5. User manually merges desired changes
+
+## 🏗️ Architecture
+
+### **Files:**
+- `claude-md.js` - Core slash command implementation
+- `register-claude-md.js` - Slash command registration
+- `../npx/claude-md-protection.js` - NPX protection logic
+- `../../scripts/post-install-claude-md.js` - Post-install hook
+
+### **Integration Points:**
+- **Existing Generator**: Uses `../language/claude-md-generator.js`
+- **Language Detection**: Uses `../language/language-detector.js`
+- **Preferences**: Reads `.claude-flow-novice/preferences/generation.json`
+- **Package.json**: `postinstall` script triggers protection
+
+## 🎮 Usage Examples
+
+### **Basic Generation:**
+```bash
+# Generate CLAUDE.md for current project
+/claude-md
+
+# Output:
+# 🚀 Generating CLAUDE.md...
+# ✅ CLAUDE.md generated successfully
+```
+
+### **Preview Mode:**
+```bash
+# See what would be generated
+/claude-md --preview
+
+# Output:
+# 📄 CLAUDE.md Preview:
+# ══════════════════════════════════════════════════
+# # Claude Code Configuration - JavaScript Project
+# ...
+# ══════════════════════════════════════════════════
+# 📊 Total length: 2,847 characters
+```
+
+### **NPX Protection:**
+```bash
+# When NPX detects existing CLAUDE.md
+npm install claude-flow-novice
+
+# Output:
+# 🛡️ NPX Protection Activated
+# 📄 Generated: claude-copy-to-main.md
+# 💡 Your existing CLAUDE.md is protected from overwrite
+# 🔄 Review and merge changes manually as needed
+```
+
+## 🧠 Smart Detection
+
+### **Project Type Detection:**
+- Analyzes `package.json`, file patterns, and directory structure
+- Detects frameworks (React, Express, Django, etc.)
+- Suggests appropriate CLAUDE.md configurations
+
+### **Confidence Levels:**
+- **High (>70%)**: Automatic generation recommended
+- **Medium (30-70%)**: Generate with user confirmation
+- **Low (<30%)**: Manual review suggested
+
+## 🔧 Configuration
+
+### **Generation Preferences:**
+`.claude-flow-novice/preferences/generation.json`:
+```json
+{
+  "autoGenerate": true,
+  "includeFrameworkSpecific": true,
+  "includeBestPractices": true,
+  "backupExisting": true,
+  "confidenceThreshold": 0.3
+}
+```
+
+### **NPX Detection:**
+- Environment variables (`NPX_INSTALL=true`)
+- Temporary directory patterns (`/.npm/_npx/`)
+- Package.json analysis (fresh installs)
+
+## 🎯 Design Principles
+
+### **Keep It Simple:**
+- Single focused command
+- Minimal configuration
+- Clear user feedback
+- No feature bloat
+
+### **Protect User Work:**
+- Never overwrite without permission
+- Always offer backup options
+- Provide clear merge instructions
+- Preserve customizations
+
+### **Smart Defaults:**
+- Auto-detect project type
+- Use appropriate templates
+- Respect user preferences
+- Fail safely
+
+## 🚀 Future Enhancements
+
+### **Potential Improvements (If Needed):**
+- Interactive confirmation prompts
+- Template customization options
+- Multi-project detection
+- Advanced merge assistance
+
+### **Not Planned (Avoiding Bloat):**
+- SQLite analysis integration
+- Multi-file scaffolding
+- Complex workflow automation
+- Enterprise features
+
+---
+
+**Simple, focused, and protective - exactly what CLAUDE.md generation should be!** 🎯

package/.claude/hooks/cfn-invoke-post-edit.sh

@@ -14,7 +14,7 @@
 set -euo pipefail
 
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-CONFIG_FILE="$SCRIPT_DIR/post-edit.config.json"
+CONFIG_FILE="$SCRIPT_DIR/cfn-post-edit.config.json"
 
 # Parse arguments
 FILE_PATH=""

package/.claude/skills/cfn-backlog-management/SKILL.md

@@ -0,0 +1,199 @@
+---
+skill_id: cfn-backlog-management
+name: CFN Backlog Management
+version: 1.0.0
+category: coordination
+tags: [backlog, documentation, sprint-planning, technical-debt]
+dependencies: []
+---
+
+# CFN Backlog Management Skill
+
+## Purpose
+Systematically capture and track backlogged items during CFN sprints to prevent work from being forgotten. Provides centralized documentation of deferred tasks with context, rationale, and proposed solutions.
+
+## Problem Solved
+During CFN Loop execution, agents frequently identify improvements, optimizations, or edge cases that should be addressed but are out of scope for the current sprint. Without systematic capture, these items are lost in chat history or forgotten entirely.
+
+## When to Use
+- **During CFN sprints** when identifying work that should be deferred
+- **After consensus** when validators identify future improvements
+- **During retrospectives** when documenting technical debt
+- **Architecture reviews** when noting long-term refactoring needs
+
+## Interface
+
+### Primary Script: `add-backlog-item.sh`
+
+**Required Parameters:**
+- `--item`: Brief description of backlogged work (1-2 sentences)
+- `--why`: Rationale for deferring (why not now?)
+- `--solution`: Proposed implementation approach
+
+**Optional Parameters:**
+- `--sprint`: Sprint identifier (default: auto-detected from context)
+- `--priority`: P0-P3 (default: P2)
+- `--tags`: Comma-separated tags (e.g., "optimization,redis,testing")
+- `--category`: Feature/Bug/Technical-Debt/Optimization (default: Technical-Debt)
+
+**Usage:**
+```bash
+./.claude/skills/cfn-backlog-management/add-backlog-item.sh \
+  --sprint "Sprint 10" \
+  --item "Implement Redis connection pooling for multi-agent coordination" \
+  --why "Current single-connection model causes bottlenecks with 10+ agents, but Sprint 10 scope limited to 3-agent validation" \
+  --solution "Use ioredis library with configurable pool size (min: 5, max: 20). Add pool metrics to monitoring dashboard" \
+  --priority "P2" \
+  --tags "optimization,redis,performance" \
+  --category "Optimization"
+```
+
+### Output Location
+All backlog items are appended to: `readme/BACKLOG.md`
+
+## Backlog File Structure
+
+```markdown
+# Claude Flow Novice - Backlog
+
+Last Updated: 2025-10-31
+
+## Active Items
+
+### P0 - Critical
+[Items requiring immediate attention in next sprint]
+
+### P1 - High Priority
+[Items to address within 2-3 sprints]
+
+### P2 - Medium Priority
+[Items to address when capacity allows]
+
+### P3 - Low Priority / Nice-to-Have
+[Items for future consideration]
+
+## Completed Items
+[Moved here when implemented, with resolution sprint noted]
+
+---
+
+## Item Template
+
+**[PRIORITY] - [Item Title]**
+- **Sprint Backlogged**: Sprint X
+- **Category**: Feature/Bug/Technical-Debt/Optimization
+- **Description**: What needs to be done
+- **Rationale**: Why it was deferred
+- **Proposed Solution**: How to implement
+- **Tags**: `tag1`, `tag2`, `tag3`
+- **Status**: Backlogged | In Progress | Completed
+- **Date Added**: YYYY-MM-DD
+```
+
+## Validation Rules
+
+The skill enforces:
+1. **All required fields present** (item, why, solution)
+2. **Item description clarity** (≥10 characters, ≤500 characters)
+3. **Rationale specificity** (must explain deferral reason, not just "out of scope")
+4. **Solution actionability** (must include concrete implementation approach)
+5. **No duplicates** (checks existing BACKLOG.md for similar items)
+
+## Integration with CFN Loops
+
+### Loop 2 Validators
+When validators identify improvements outside current scope:
+```bash
+# In validator agent
+./.claude/skills/cfn-backlog-management/add-backlog-item.sh \
+  --item "Add integration tests for Redis failure scenarios" \
+  --why "Current sprint validates happy path only; failure testing requires additional test infrastructure" \
+  --solution "Create test-redis-failures.sh with Docker-based Redis crash simulation" \
+  --tags "testing,redis,edge-cases"
+```
+
+### Product Owner Decision
+When Product Owner defers work for future sprint:
+```bash
+# In product-owner agent
+./.claude/skills/cfn-backlog-management/add-backlog-item.sh \
+  --item "Migrate coordination from Redis to etcd for production scale" \
+  --why "Redis sufficient for current 10-agent limit; etcd needed for 100+ agent deployments" \
+  --solution "Abstract coordination layer behind interface, implement etcd adapter" \
+  --priority "P3" \
+  --category "Technical-Debt"
+```
+
+### Coordinator Context
+Coordinators can query backlog for related items before spawning agents:
+```bash
+# Check if backlog contains relevant context
+grep -i "redis pooling" readme/BACKLOG.md
+# Use results to inform agent context injection
+```
+
+## Query Interface
+
+**Search by tag:**
+```bash
+grep -A 10 "Tags:.*redis" readme/BACKLOG.md
+```
+
+**Filter by priority:**
+```bash
+sed -n '/^### P1/,/^### P2/p' readme/BACKLOG.md
+```
+
+**List all optimization items:**
+```bash
+grep -B 2 "Category: Optimization" readme/BACKLOG.md
+```
+
+## Maintenance
+
+**Weekly Review**: Product Owner reviews P0-P1 items for sprint planning
+**Monthly Cleanup**: Archive completed items, reassess P3 priorities
+**Quarterly Audit**: Remove stale items (>6 months old, no activity)
+
+## Best Practices
+
+1. **Be specific**: "Add caching" → "Implement Redis LRU cache for agent context with 1h TTL"
+2. **Explain constraints**: "Not enough time" → "Requires 8h estimation work; current sprint has 2h budget"
+3. **Provide actionable solutions**: "Fix later" → "Refactor using Strategy pattern from planning/PATTERNS.md"
+4. **Tag appropriately**: Enables filtering and sprint planning
+5. **Update status**: Move to "Completed" when resolved, note resolution sprint
+
+## Anti-Patterns
+
+❌ **Vague items**: "Improve performance" (What component? How much improvement?)
+❌ **No rationale**: "Backlog this" (Why defer? What's the blocker?)
+❌ **Solution-less**: "Fix Redis issues" (What's the approach? What research is needed?)
+❌ **Duplicate entries**: Check BACKLOG.md before adding
+❌ **Scope creep**: Backlog is for deferred work, not scope expansion
+
+## Example Backlog Item
+
+```markdown
+**[P1] - Implement Adaptive Validator Scaling**
+- **Sprint Backlogged**: Sprint 9 - CFN v3 Implementation
+- **Category**: Optimization
+- **Description**: Dynamically adjust number of Loop 2 validators (2-5) based on task complexity. Currently fixed at 3-4 validators regardless of task size.
+- **Rationale**: Sprint 9 focused on dual-mode architecture validation. Adaptive scaling requires task complexity classifier (NLP or heuristic-based), estimated 12h implementation vs 4h sprint budget.
+- **Proposed Solution**: Create task-classifier skill that analyzes task description (file count, domain keywords, integration points) and returns complexity score (0.0-1.0). Map score to validator count: <0.3 → 2 validators, 0.3-0.7 → 3-4 validators, >0.7 → 5 validators. Reference: CFN_LOOP_TASK_MODE.md section on adaptive validator scaling.
+- **Tags**: `optimization`, `cfn-loop`, `validation`, `adaptive-scaling`
+- **Status**: Backlogged
+- **Date Added**: 2025-10-31
+```
+
+## Success Metrics
+
+- **Backlog utilization**: ≥30% of backlog items addressed within 3 sprints
+- **Item clarity**: 0 items missing required fields
+- **Discovery rate**: ≥50% of technical debt captured vs lost in chat
+- **Sprint planning efficiency**: Backlog queries reduce planning time by 20%
+
+## References
+
+- **STRAT-025**: Explicit Deliverable Tracking (adaptive context)
+- **CFN Loop Documentation**: `.claude/commands/cfn/CFN_LOOP_TASK_MODE.md`
+- **Sprint Execution**: CLAUDE.md Section 6 - Sprint Context Injection

package/.claude/skills/cfn-backlog-management/add-backlog-item.sh

@@ -0,0 +1,210 @@
+#!/bin/bash
+set -e
+
+# cfn-backlog-management/add-backlog-item.sh
+# Adds structured backlog items to readme/BACKLOG.md
+
+# Default values
+PRIORITY="P2"
+CATEGORY="Technical-Debt"
+SPRINT="Unknown"
+TAGS=""
+ITEM=""
+WHY=""
+SOLUTION=""
+
+# Parse arguments
+while [[ $# -gt 0 ]]; do
+  case $1 in
+    --item)
+      ITEM="$2"
+      shift 2
+      ;;
+    --why)
+      WHY="$2"
+      shift 2
+      ;;
+    --solution)
+      SOLUTION="$2"
+      shift 2
+      ;;
+    --sprint)
+      SPRINT="$2"
+      shift 2
+      ;;
+    --priority)
+      PRIORITY="$2"
+      shift 2
+      ;;
+    --tags)
+      TAGS="$2"
+      shift 2
+      ;;
+    --category)
+      CATEGORY="$2"
+      shift 2
+      ;;
+    *)
+      echo "Unknown argument: $1" >&2
+      exit 1
+      ;;
+  esac
+done
+
+# Validation
+if [[ -z "$ITEM" ]]; then
+  echo "Error: --item is required" >&2
+  exit 1
+fi
+
+if [[ -z "$WHY" ]]; then
+  echo "Error: --why is required" >&2
+  exit 1
+fi
+
+if [[ -z "$SOLUTION" ]]; then
+  echo "Error: --solution is required" >&2
+  exit 1
+fi
+
+# Validate item length
+ITEM_LENGTH=${#ITEM}
+if (( ITEM_LENGTH < 10 )); then
+  echo "Error: --item must be at least 10 characters (got $ITEM_LENGTH)" >&2
+  exit 1
+fi
+
+if (( ITEM_LENGTH > 500 )); then
+  echo "Error: --item must be at most 500 characters (got $ITEM_LENGTH)" >&2
+  exit 1
+fi
+
+# Validate priority
+if [[ ! "$PRIORITY" =~ ^P[0-3]$ ]]; then
+  echo "Error: --priority must be P0, P1, P2, or P3 (got: $PRIORITY)" >&2
+  exit 1
+fi
+
+# Validate category
+VALID_CATEGORIES="Feature|Bug|Technical-Debt|Optimization"
+if [[ ! "$CATEGORY" =~ ^($VALID_CATEGORIES)$ ]]; then
+  echo "Error: --category must be one of: Feature, Bug, Technical-Debt, Optimization (got: $CATEGORY)" >&2
+  exit 1
+fi
+
+# Path to backlog file
+BACKLOG_FILE="readme/BACKLOG.md"
+PROJECT_ROOT="/mnt/c/Users/masha/Documents/claude-flow-novice"
+BACKLOG_PATH="$PROJECT_ROOT/$BACKLOG_FILE"
+
+# Create backlog file if it doesn't exist
+if [[ ! -f "$BACKLOG_PATH" ]]; then
+  echo "Creating $BACKLOG_FILE..."
+  mkdir -p "$(dirname "$BACKLOG_PATH")"
+  cat > "$BACKLOG_PATH" <<'EOF'
+# Claude Flow Novice - Backlog
+
+Last Updated: $(date +%Y-%m-%d)
+
+## Active Items
+
+### P0 - Critical
+
+### P1 - High Priority
+
+### P2 - Medium Priority
+
+### P3 - Low Priority / Nice-to-Have
+
+## Completed Items
+
+---
+
+## Item Template
+
+**[PRIORITY] - [Item Title]**
+- **Sprint Backlogged**: Sprint X
+- **Category**: Feature/Bug/Technical-Debt/Optimization
+- **Description**: What needs to be done
+- **Rationale**: Why it was deferred
+- **Proposed Solution**: How to implement
+- **Tags**: `tag1`, `tag2`, `tag3`
+- **Status**: Backlogged
+- **Date Added**: YYYY-MM-DD
+EOF
+fi
+
+# Check for duplicates (simple substring match)
+if grep -qi "$ITEM" "$BACKLOG_PATH" 2>/dev/null; then
+  echo "Warning: Similar item may already exist in backlog" >&2
+  echo "Existing matches:" >&2
+  grep -i "$ITEM" "$BACKLOG_PATH" | head -3 >&2
+  read -p "Continue anyway? (y/n) " -n 1 -r
+  echo
+  if [[ ! $REPLY =~ ^[Yy]$ ]]; then
+    echo "Aborted" >&2
+    exit 1
+  fi
+fi
+
+# Format tags
+FORMATTED_TAGS=""
+if [[ -n "$TAGS" ]]; then
+  IFS=',' read -ra TAG_ARRAY <<< "$TAGS"
+  for tag in "${TAG_ARRAY[@]}"; do
+    FORMATTED_TAGS="${FORMATTED_TAGS}\`${tag}\`, "
+  done
+  FORMATTED_TAGS="${FORMATTED_TAGS%, }"  # Remove trailing comma
+fi
+
+# Generate item title (first 60 chars of description)
+ITEM_TITLE="${ITEM:0:60}"
+if (( ${#ITEM} > 60 )); then
+  ITEM_TITLE="${ITEM_TITLE}..."
+fi
+
+# Current date
+CURRENT_DATE=$(date +%Y-%m-%d)
+
+# Create backlog entry
+BACKLOG_ENTRY=$(cat <<EOF
+
+**[$PRIORITY] - $ITEM_TITLE**
+- **Sprint Backlogged**: $SPRINT
+- **Category**: $CATEGORY
+- **Description**: $ITEM
+- **Rationale**: $WHY
+- **Proposed Solution**: $SOLUTION
+- **Tags**: $FORMATTED_TAGS
+- **Status**: Backlogged
+- **Date Added**: $CURRENT_DATE
+
+EOF
+)
+
+# Insert into appropriate priority section
+SECTION_MARKER="### $PRIORITY"
+
+# Use awk to insert after section marker
+awk -v section="$SECTION_MARKER" -v entry="$BACKLOG_ENTRY" '
+  $0 ~ section {
+    print
+    print entry
+    next
+  }
+  {print}
+' "$BACKLOG_PATH" > "${BACKLOG_PATH}.tmp"
+
+mv "${BACKLOG_PATH}.tmp" "$BACKLOG_PATH"
+
+# Update "Last Updated" timestamp
+sed -i "s/Last Updated: .*/Last Updated: $CURRENT_DATE/" "$BACKLOG_PATH"
+
+echo "✅ Backlog item added successfully"
+echo "   Priority: $PRIORITY"
+echo "   Category: $CATEGORY"
+echo "   Sprint: $SPRINT"
+echo "   Location: $BACKLOG_FILE"
+
+# Output path for scripting
+echo "$BACKLOG_PATH"

package/claude-assets/agents/cfn-dev-team/architecture/base-template-generator.md

@@ -157,36 +157,22 @@ Execute assigned task (template generation, boilerplate code creation, project s
 redis-cli lpush "swarm:${TASK_ID}:${AGENT_ID}:done" "complete"
 ```
 
-### Step 3: Report Confidence Score
+### Step 3: Report Confidence Score and Exit
 ```bash
-./.claude/skills/redis-coordination/invoke-waiting-mode.sh report \
-
-**After reporting, exit cleanly. Do NOT enter waiting mode.**
-
-**Why This Matters:**
-- Orchestrator collects confidence/consensus scores from Redis
-- Enables adaptive agent specialization for next iteration
-- Prevents orchestrator blocking on wait $PID
-- Coordinator spawns appropriate specialist based on feedback type
-
+./.claude/skills/cfn-redis-coordination/invoke-waiting-mode.sh report \
   --task-id "$TASK_ID" \
   --agent-id "$AGENT_ID" \
   --confidence [0.0-1.0] \
   --iteration 1
 ```
 
-### Step 4: Enter Waiting Mode (for potential iteration)
-```bash
-  --task-id "$TASK_ID" \
-  --agent-id "$AGENT_ID" \
-  --context "iteration-complete"
-```
+**After reporting, exit cleanly. Do NOT enter waiting mode.**
 
 **Why This Matters:**
-- Zero-token blocking coordination (BLPOP waits without API calls)
-- Orchestrator collects confidence/consensus scores automatically
-- Supports autonomous iteration based on quality gates
-- Agent woken instantly (<100ms) if iteration needed
+- Orchestrator collects confidence/consensus scores from Redis
+- Enables adaptive agent specialization for next iteration
+- Prevents orchestrator blocking on wait $PID
+- Coordinator spawns appropriate specialist based on feedback type
 
 **Context Variables:**
 - `TASK_ID`: Provided by orchestrator/coordinator