claude-flow-novice 2.18.5 → 2.18.6

package/.claude/skills/cfn-parameterized-queries/test-implementation.sh

@@ -0,0 +1,237 @@
+#!/bin/bash
+# Implementation test for cfn-parameterized-queries skill
+set -euo pipefail
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m' # No Color
+
+SKILL_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+# Test results
+PASSED=0
+FAILED=0
+
+# Test helper functions
+assert() {
+    local condition="$1"
+    local message="$2"
+    
+    if eval "$condition"; then
+        echo -e "${GREEN}✓${NC} $message"
+        ((PASSED++))
+        return 0
+    else
+        echo -e "${RED}✗${NC} $message"
+        ((FAILED++))
+        return 1
+    fi
+}
+
+# Test 1: Check if implementation file exists
+test_implementation_exists() {
+    echo "Test 1: Checking implementation file..."
+    assert "[[ -f '$SKILL_DIR/parameterized-queries.sh' ]]" "Implementation file exists"
+}
+
+# Test 2: Check if file is executable
+test_file_permissions() {
+    echo -e "\nTest 2: Checking file permissions..."
+    assert "[[ -x '$SKILL_DIR/parameterized-queries.sh' ]]" "File is executable"
+}
+
+# Test 3: Check for SQL injection patterns
+test_no_sql_injection() {
+    echo -e "\nTest 3: Checking for SQL injection vulnerabilities..."
+    
+    # Check for dangerous patterns
+    local file="$SKILL_DIR/parameterized-queries.sh"
+    local violations=0
+    
+    # Check for variable interpolation in SQL
+    if grep -E '\$[a-zA-Z_][a-zA-Z0-9_]*[^a-zA-Z0-9_]' "$file" | grep -E "(SELECT|INSERT|UPDATE|DELETE).*\".*\$" > /dev/null; then
+        echo -e "${RED}✗${NC} Found potential SQL variable interpolation"
+        ((violations++))
+    fi
+    
+    # Check for string concatenation in SQL
+    if grep -E '(SELECT|INSERT|UPDATE|DELETE).*\".*\+.*\"' "$file" > /dev/null; then
+        echo -e "${RED}✗${NC} Found SQL string concatenation"
+        ((violations++))
+    fi
+    
+    # Check for eval with SQL
+    if grep -E 'eval.*SELECT|INSERT|UPDATE|DELETE' "$file" > /dev/null; then
+        echo -e "${RED}✗${NC} Found eval with SQL"
+        ((violations++))
+    fi
+    
+    assert "[[ $violations -eq 0 ]]" "No SQL injection patterns found"
+}
+
+# Test 4: Check parameter binding implementation
+test_parameter_binding() {
+    echo -e "\nTest 4: Checking parameter binding implementation..."
+    
+    local file="$SKILL_DIR/parameterized-queries.sh"
+    
+    # Check for proper parameter binding with ?
+    assert "grep -q 'sqlite3.*\?.*;' '$file'" "Uses ? parameter placeholders"
+    
+    # Check for here-document parameter passing
+    assert "grep -q 'printf.*%s.*sqlite3' '$file'" "Uses here-document for parameters"
+    
+    # Check for no direct variable interpolation
+    assert "! grep -E 'sqlite3.*\".*\$.*\".*\;' '$file'" "No direct variable interpolation in SQL"
+}
+
+# Test 5: Check identifier validation
+test_identifier_validation() {
+    echo -e "\nTest 5: Checking identifier validation..."
+    
+    local file="$SKILL_DIR/parameterized-queries.sh"
+    
+    # Check validation function exists
+    assert "grep -q 'validate_sql_identifier()' '$file'" "Identifier validation function exists"
+    
+    # Check regex pattern for validation
+    assert "grep -q '\^\[a-zA-Z_\]\[a-zA-Z0-9_\]*' '$file'" "Proper identifier validation regex"
+    
+    # Check table name validation
+    assert "grep -q 'validate_table_name' '$file'" "Table name validation exists"
+    
+    # Check column name validation
+    assert "grep -q 'validate_column_name' '$file'" "Column name validation exists"
+}
+
+# Test 6: Check required functions
+test_required_functions() {
+    echo -e "\nTest 6: Checking required functions..."
+    
+    local file="$SKILL_DIR/parameterized-queries.sh"
+    
+    local functions=(
+        "execute_select_one"
+        "execute_select_many"
+        "execute_insert"
+        "execute_update"
+        "execute_delete"
+        "execute_exists"
+        "get_by_id"
+        "count_records"
+        "begin_transaction"
+        "commit_transaction"
+        "rollback_transaction"
+    )
+    
+    for func in "${functions[@]}"; do
+        assert "grep -q '^$func()' '$file'" "Function $func exists"
+    done
+}
+
+# Test 7: Check error handling
+test_error_handling() {
+    echo -e "\nTest 7: Checking error handling..."
+    
+    local file="$SKILL_DIR/parameterized-queries.sh"
+    
+    # Check for set -euo pipefail
+    assert "grep -q 'set -euo pipefail' '$file'" "Uses strict error handling"
+    
+    # Check for database file existence check
+    assert "grep -q '\[\[ ! -f.*db_path' '$file'" "Checks database file existence"
+    
+    # Check for error messages to stderr
+    assert "grep -q '>&2' '$file'" "Sends errors to stderr"
+}
+
+# Test 8: Check documentation quality
+test_documentation() {
+    echo -e "\nTest 8: Checking documentation..."
+    
+    local doc_file="$SKILL_DIR/SKILL.md"
+    
+    # Check if documentation exists
+    assert "[[ -f '$doc_file' ]]" "Documentation file exists"
+    
+    # Check for security section
+    assert "grep -q '## Security' '$doc_file'" "Has security section"
+    
+    # Check for API reference
+    assert "grep -q '## API Reference' '$doc_file'" "Has API reference"
+    
+    # Check for usage examples
+    assert "grep -q '## Usage Examples' '$doc_file'" "Has usage examples"
+}
+
+# Test 9: Run actual functionality test
+test_functionality() {
+    echo -e "\nTest 9: Testing basic functionality..."
+    
+    # Create test database
+    local test_db="/tmp/test-sql-$$.sqlite"
+    trap "rm -f '$test_db'" EXIT
+    
+    # Create table
+    sqlite3 "$test_db" "CREATE TABLE test (id INTEGER PRIMARY KEY, name TEXT);"
+    
+    # Source the skill
+    source "$SKILL_DIR/parameterized-queries.sh"
+    
+    # Test insert
+    execute_insert "$test_db" "test" --columns "name" --values "Test Name" > /dev/null
+    assert "[[ $? -eq 0 ]]" "Insert operation works"
+    
+    # Test select
+    local result
+    result=$(execute_select_one "$test_db" "SELECT name FROM test WHERE id = ?;" "1")
+    assert "[[ '$result' == 'Test Name' ]]" "Select operation works"
+    
+    # Test update
+    execute_update "$test_db" "test" "name" "Updated Name" "id" "1"
+    assert "[[ $? -eq 0 ]]" "Update operation works"
+    
+    # Test delete
+    execute_delete "$test_db" "test" "id" "1"
+    assert "[[ $? -eq 0 ]]" "Delete operation works"
+    
+    # Clean up
+    rm -f "$test_db"
+    trap - EXIT
+}
+
+# Run all tests
+main() {
+    echo "Running implementation tests for cfn-parameterized-queries skill..."
+    echo "============================================================"
+    
+    test_implementation_exists
+    test_file_permissions
+    test_no_sql_injection
+    test_parameter_binding
+    test_identifier_validation
+    test_required_functions
+    test_error_handling
+    test_documentation
+    test_functionality
+    
+    echo -e "\n============================================================"
+    echo -e "Test Results: ${GREEN}$PASSED${NC} passed, ${RED}$FAILED${NC} failed"
+    
+    if [[ $FAILED -eq 0 ]]; then
+        echo -e "\n${GREEN}✓ All tests passed!${NC}"
+        echo -e "${GREEN}✓ Skill is production ready${NC}"
+        exit 0
+    else
+        echo -e "\n${RED}✗ Some tests failed${NC}"
+        echo -e "${RED}✗ Skill needs fixes before production use${NC}"
+        exit 1
+    fi
+}
+
+# Execute if run directly
+if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then
+    main "$@"
+fi

package/.claude/skills/cfn-planning/SKILL.md

@@ -0,0 +1,55 @@
+---
+name: cfn-planning
+description: Epic decomposition, coordinator planning, and scope management
+version: 1.0.0
+tags: [mega-skill, epic, planning, scope, decomposition]
+status: production
+---
+
+# Planning Skill (Mega-Skill)
+
+**Version:** 1.0.0
+**Purpose:** Epic decomposition, coordinator planning, and scope management
+**Status:** Production
+**Consolidates:** cfn-epic-decomposer, cfn-multi-coordinator-planning, cfn-scope-simplifier
+
+---
+
+## Overview
+
+This mega-skill provides planning capabilities:
+- **Epic** - Epic decomposition into sprints/tasks
+- **Coordinator** - Multi-coordinator planning and orchestration
+- **Scope** - Scope simplification and boundary management
+
+---
+
+## Directory Structure
+
+```
+planning/
+├── SKILL.md
+├── lib/
+│   ├── epic/             # From cfn-epic-decomposer
+│   ├── coordinator/      # From cfn-multi-coordinator-planning
+│   └── scope/            # From cfn-scope-simplifier
+└── cli/
+```
+
+---
+
+## Migration Paths
+
+| Old Path | New Path |
+|----------|----------|
+| cfn-epic-decomposer/ | planning/lib/epic/ |
+| cfn-multi-coordinator-planning/ | planning/lib/coordinator/ |
+| cfn-scope-simplifier/ | planning/lib/scope/ |
+
+---
+
+## Version History
+
+### 1.0.0 (2025-12-02)
+- Consolidated 3 planning skills into mega-skill
+

package/.claude/skills/cfn-planning/execute.sh

@@ -0,0 +1,159 @@
+#!/bin/bash
+
+# cfn-planning skill execution script
+# Version: 1.0.0
+
+set -euo pipefail
+
+# Skill metadata
+SKILL_NAME="cfn-planning"
+SKILL_VERSION="1.0.0"
+USAGE_DESCRIPTION="Epic decomposition, coordinator planning, and scope management"
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+# Logging functions
+log_info() {
+    echo -e "${BLUE}[INFO]${NC} $1"
+}
+
+log_success() {
+    echo -e "${GREEN}[SUCCESS]${NC} $1"
+}
+
+log_warning() {
+    echo -e "${YELLOW}[WARNING]${NC} $1"
+}
+
+log_error() {
+    echo -e "${RED}[ERROR]${NC} $1"
+}
+
+# Check dependencies
+check_dependencies() {
+    local missing_deps=()
+    
+    # Check for jq
+    if ! command -v jq &> /dev/null; then
+        missing_deps+=("jq")
+    fi
+    
+    # Check for redis-cli
+    if ! command -v redis-cli &> /dev/null; then
+        missing_deps+=("redis-cli")
+    fi
+    
+    if [ ${#missing_deps[@]} -ne 0 ]; then
+        log_error "Missing dependencies: ${missing_deps[*]}"
+        log_error "Please install the missing dependencies and try again."
+        exit 1
+    fi
+}
+
+# Show usage information
+show_usage() {
+    cat << EOF
+$SKILL_NAME v$SKILL_VERSION - $USAGE_DESCRIPTION
+
+Usage: $0 <command> [options]
+
+Commands:
+  epic-decompose     Decompose epics into manageable tasks
+  coordinator-plan   Plan multi-coordinator work
+  scope-simplify     Simplify and manage scope
+
+Examples:
+  $0 epic-decompose --epic-id EPIC-123 --output-file tasks.json
+  $0 coordinator-plan --coordinators 3 --complexity high
+  $0 scope-simplify --input-scope scope.json --simplify-level aggressive
+
+For more information on a specific command, use:
+  $0 <command> --help
+EOF
+}
+
+# Command handlers
+handle_epic_decompose() {
+    log_info "Executing epic decomposition..."
+    if [ -f "lib/epic/decompose-epic.sh" ]; then
+        bash lib/epic/decompose-epic.sh "$@"
+    else
+        log_error "Epic decomposition script not found at lib/epic/decompose-epic.sh"
+        exit 1
+    fi
+}
+
+handle_coordinator_plan() {
+    log_info "Executing coordinator planning..."
+    if [ -f "lib/coordinator/plan-multi-coordinator-work.sh" ]; then
+        bash lib/coordinator/plan-multi-coordinator-work.sh "$@"
+    else
+        log_error "Coordinator planning script not found at lib/coordinator/plan-multi-coordinator-work.sh"
+        exit 1
+    fi
+}
+
+handle_scope_simplify() {
+    log_info "Executing scope simplification..."
+    if [ -f "lib/scope/simplify-scope.sh" ]; then
+        bash lib/scope/simplify-scope.sh "$@"
+    else
+        log_error "Scope simplification script not found at lib/scope/simplify-scope.sh"
+        exit 1
+    fi
+}
+
+# Main execution logic
+main() {
+    # Check dependencies first
+    check_dependencies
+    
+    # Check if no arguments provided
+    if [ $# -eq 0 ]; then
+        show_usage
+        exit 1
+    fi
+    
+    # Parse command
+    case "$1" in
+        "epic-decompose")
+            shift
+            handle_epic_decompose "$@"
+            ;;
+        "coordinator-plan")
+            shift
+            handle_coordinator_plan "$@"
+            ;;
+        "scope-simplify")
+            shift
+            handle_scope_simplify "$@"
+            ;;
+        "--help"|"-h")
+            show_usage
+            exit 0
+            ;;
+        "--version"|"-v")
+            echo "$SKILL_NAME v$SKILL_VERSION"
+            exit 0
+            ;;
+        *)
+            log_error "Unknown command: $1"
+            show_usage
+            exit 1
+            ;;
+    esac
+}
+
+# Delegate to lib/planning/execute.sh if it exists
+if [ -f "lib/planning/execute.sh" ]; then
+    log_info "Delegating to lib/planning/execute.sh for execution..."
+    bash lib/planning/execute.sh "$@"
+else
+    # Execute main function if no delegate script exists
+    main "$@"
+fi

package/.claude/skills/cfn-planning/lib/coordinator/README.md

@@ -0,0 +1,256 @@
+# Multi-Coordinator Planning Skill
+
+**Purpose:** Systematic planning and validation for parallel multi-coordinator execution workflows, designed to prevent Zone B-style execution failures.
+
+## Overview
+
+This skill provides comprehensive pre-flight planning for multi-coordinator execution, addressing the critical failures identified in the Zone B analysis:
+- Redis namespace collision (Echo zone)
+- Protocol compliance breakdown (Alpha/Charlie zones)
+- Orchestration gaps (Delta zone)
+- Consensus on vapor anti-patterns (Bravo zone)
+
+## Quick Start
+
+```bash
+# Create zone configuration
+cat > zone-config.json << 'EOF'
+{
+  "zones": [
+    {
+      "name": "zone-alpha",
+      "task_description": "Implement React authentication component with TypeScript interfaces",
+      "deliverables": [
+        "src/components/AuthForm.tsx",
+        "src/types/auth.ts",
+        "src/hooks/useAuth.ts",
+        "tests/auth.test.ts"
+      ],
+      "agent_types": ["react-frontend-engineer", "reviewer", "tester"],
+      "acceptance_criteria": [
+        "Form validates user input",
+        "Authentication state managed globally",
+        "Component tested with >80% coverage"
+      ],
+      "in_scope": ["React components", "TypeScript interfaces"],
+      "out_of_scope": ["Backend authentication"],
+      "directory": "src/auth"
+    }
+  ]
+}
+EOF
+
+# Execute planning
+./.claude/skills/cfn-multi-coordinator-planning/plan-multi-coordinator-work.sh zone-config.json
+```
+
+## Components
+
+### 1. Main Planning Script
+- **`plan-multi-coordinator-work.sh`** - Orchestrates all planning phases
+
+### 2. Planning Phase Scripts
+- **`validate-task-planning.sh`** - Task configuration validation
+- **`plan-coordinator-resources.sh`** - Resource allocation and namespace planning
+- **`map-dependencies-conflicts.sh`** - Dependency analysis and conflict resolution
+- **`plan-risk-rollout.sh`** - Risk-based rollout strategy
+
+### 3. Testing
+- **`test-multi-coordinator-planning.sh`** - Comprehensive test suite
+
+## Configuration Format
+
+### Zone Configuration Structure
+```json
+{
+  "zones": [
+    {
+      "name": "zone-identifier",
+      "task_description": "Specific implementation task with clear deliverables",
+      "deliverables": [
+        "file/path/to/deliverable.ext"
+      ],
+      "agent_types": ["required-agent-types"],
+      "acceptance_criteria": [
+        "Measurable acceptance criteria"
+      ],
+      "in_scope": ["items in scope"],
+      "out_of_scope": ["items out of scope"],
+      "directory": "working/directory",
+      "risk_factors": ["optional-risk-factors"]
+    }
+  ]
+}
+```
+
+### Validation Requirements
+- **Minimum 3 deliverables** for software tasks
+- **Minimum 2 agent types** (prevents single-agent anti-patterns)
+- **Specific task descriptions** (no generic "implementation" tasks)
+- **Acceptance criteria** required
+- **In-scope/out-of-scope boundaries** required
+
+## Usage Examples
+
+### Basic Planning
+```bash
+./plan-multi-coordinator-work.sh zone-config.json
+```
+
+### Advanced Planning with Custom Parameters
+```bash
+./plan-multi-coordinator-work.sh zone-config.json \
+  --max-zones-per-phase 3 \
+  --output-dir ./plans \
+  --dry-run
+```
+
+### Skip Validation (Not Recommended)
+```bash
+./plan-multi-coordinator-work.sh zone-config.json --skip-validation
+```
+
+## Planning Phases
+
+### Phase 1: Task Validation
+- Deliverable specificity verification
+- Agent type diversity requirements
+- Context completeness scoring
+- Anti-pattern detection
+
+### Phase 2: Resource Allocation
+- Redis namespace reservation and isolation
+- Memory/CPU capacity planning
+- Coordinator limit calculations
+- Working directory allocation
+
+### Phase 3: Dependency Analysis
+- Cross-zone dependency identification
+- Shared resource conflict detection
+- Completion pathway validation
+- Resolution strategy creation
+
+### Phase 4: Risk-Based Rollout
+- Zone complexity ranking
+- Graduated phase rollout
+- Success gate definition
+- Rollback trigger configuration
+
+## Output Files
+
+### Generated Plans
+- `coordinator-resource-plan-*.json` - Resource allocation mapping
+- `dependency-conflict-analysis-*.json` - Dependencies and conflicts analysis
+- `rollout-plan-*.json` - Risk-based rollout strategy
+- `multi-coordinator-planning-summary-*.json` - Execution summary
+
+### Structure
+```json
+{
+  "timestamp": 1699123456,
+  "zone_count": 2,
+  "system_resources": {...},
+  "resource_plans": [...],
+  "phases": [...],
+  "success_criteria": [...],
+  "rollback_triggers": [...]
+}
+```
+
+## Risk Mitigation
+
+### Prevents Zone B Failures
+1. **Namespace Collision Prevention** - Redis DB allocation per zone
+2. **Protocol Compliance** - Agent completion pathway validation
+3. **Orchestration Gaps** - Coordinator lifecycle management
+4. **Anti-Pattern Detection** - Consensus on vapor prevention
+
+### Rollback Strategies
+- Immediate rollback on critical failures
+- Phase-specific rollback triggers
+- Context preservation and recovery
+- Emergency stop and cleanup procedures
+
+## Testing
+
+```bash
+# Run comprehensive test suite
+./test-multi-coordinator-planning.sh
+
+# Test individual components
+./validate-task-planning.sh test-config.json
+./plan-coordinator-resources.sh test-config.json
+./map-dependencies-conflicts.sh test-config.json
+./plan-risk-rollout.sh test-config.json
+```
+
+## Integration with CFN Loop
+
+This skill integrates with the existing CFN Loop ecosystem:
+
+### Pre-Flight Validation
+- Use before `/cfn-loop-cli` multi-coordinator execution
+- Validates coordinator readiness and resource availability
+- Prevents execution failures through comprehensive planning
+
+### CLI Spawning Support
+- Generates CLI-compatible coordinator configurations
+- Supports the recommendation to spawn coordinators via CLI
+- Enables Main Chat monitoring and interjection capabilities
+
+### Redis Coordination
+- Uses existing Redis coordination patterns
+- Integrates with `cfn-redis-coordination` skill
+- Maintains namespace isolation standards
+
+## Best Practices
+
+### Planning Phase
+1. **Always validate configurations** before execution
+2. **Use graduated rollout** for complex multi-zone scenarios
+3. **Monitor resource utilization** during planning
+4. **Test rollback procedures** before production execution
+
+### Configuration
+1. **Be specific** about deliverables and acceptance criteria
+2. **Include risk factors** for accurate complexity assessment
+3. **Define clear scope boundaries** to prevent scope creep
+4. **Use appropriate agent types** for task complexity
+
+### Execution
+1. **Follow the rollout sequence** generated by the planner
+2. **Monitor each phase** before proceeding to the next
+3. **Be prepared to rollback** on trigger activation
+4. **Document lessons learned** for future planning
+
+## Troubleshooting
+
+### Common Issues
+- **Redis connection failures** - Check Redis service status
+- **Resource exhaustion** - Reduce concurrent zones or increase resources
+- **Validation failures** - Review configuration against requirements
+- **Namespace conflicts** - Ensure unique zone names and task IDs
+
+### Debug Mode
+```bash
+# Enable verbose output
+set -x
+./plan-multi-coordinator-work.sh zone-config.json
+set +x
+```
+
+## Dependencies
+
+- **jq** - JSON processing
+- **redis-cli** - Redis connectivity and namespace planning
+- **bc** - Mathematical calculations
+- **Redis server** - Namespace reservation and coordination
+
+## Maintenance
+
+- Regular testing of all planning phases
+- Update validation rules based on new failure patterns
+- Enhance resource planning algorithms
+- Extend rollback trigger configurations
+
+---