claude-flow-novice 2.15.10 → 2.16.0

package/claude-assets/skills/cfn-docker-redis-coordination/README.md

@@ -1,294 +0,0 @@
-# CFN Docker Redis Coordination - TypeScript Migration
-
-## Overview
-
-This is the TypeScript migration of the `coordinate.sh` bash script (649 lines) for type-safe Redis-based coordination in the CFN Loop orchestration system.
-
-**Migration Status: Complete**
-- Source: `./.claude/skills/cfn-docker-redis-coordination/coordinate.sh` (649 lines of bash)
-- Target: `./.claude/skills/cfn-docker-redis-coordination/src/` (TypeScript)
-- Test Suite: 97 comprehensive tests with Jest
-- Coverage: 76.64% statements, 73.19% branches
-
-## Architecture
-
-### Core Components
-
-1. **RedisCoordinator** (`src/coordinator.ts`)
-   - Type-safe Redis client wrapper using ioredis
-   - Methods for task initialization, agent registration, status tracking
-   - Consensus collection and loop synchronization
-   - Comprehensive error handling with typed errors
-
-2. **Types** (`src/types.ts`)
-   - Complete type definitions for all coordination primitives
-   - Execution modes (MVP, Standard, Enterprise)
-   - Error types with error codes
-   - Validation helpers for security constraints
-
-3. **Configuration**
-   - TypeScript strict mode enabled
-   - Comprehensive Jest test configuration
-   - Security constraints for task IDs, agent IDs, and data sizes
-
-### Key Features
-
-- **Type-Safe**: No `any` types, full TypeScript strict mode
-- **Dependency Injection**: Logger and Redis client are injected for testability
-- **Security**: Input validation, CWE prevention (CWE-22, CWE-78, CWE-400)
-- **Error Handling**: Typed error codes and metadata tracking
-- **Mode Support**: MVP, Standard, and Enterprise execution modes
-- **Comprehensive Tests**: 97 test cases covering happy paths and edge cases
-
-## API Overview
-
-### Initialization
-
-```typescript
-const config: CoordinatorConfig = {
-  redis: { host: 'localhost', port: 6379, db: 0 },
-  taskId: 'my-task-001',
-  defaultTimeout: 30,
-  defaultTTL: 3600,
-  mode: 'standard'
-};
-
-const coordinator = new RedisCoordinator(config, logger, redisClient);
-await coordinator.initTask({ branch: 'main', iteration: 1 });
-```
-
-### Agent Management
-
-```typescript
-// Register agent
-await coordinator.registerAgent('agent-001', 'backend-developer', 'container-123');
-
-// Update status
-await coordinator.updateStatus('agent-001', 'running', 1);
-
-// Signal completion with confidence
-await coordinator.signalComplete('agent-001', 0.85, 1);
-```
-
-### Loop Coordination
-
-```typescript
-// Wait for all agents to complete
-const result = await coordinator.waitLoop({
-  taskId: 'my-task-001',
-  loopNumber: 3,
-  agentCount: 5,
-  timeout: 60
-});
-
-// Collect consensus from validators
-const consensus = await coordinator.collectConsensus({
-  taskId: 'my-task-001',
-  loopNumber: 2,
-  requiredConsensus: 0.90,
-  timeout: 30
-});
-```
-
-## Security Constraints
-
-- **Task ID**: 256 char max, alphanumeric + hyphens/underscores only
-- **Agent ID**: 256 char max, alphanumeric + hyphens/underscores only
-- **Context Values**: 1MB max per value (prevents memory attacks)
-- **Confidence**: 0.0 to 1.0 (validated with type guard)
-- **Timeout**: 1 to 3600 seconds
-- **Iterations**: Up to 100 per task
-
-## Test Coverage
-
-### Test Breakdown (97 tests)
-
-1. **Constructor** (3 tests)
-   - Valid configuration
-   - Invalid task ID validation
-   - Task ID length validation
-
-2. **Task Initialization** (4 tests)
-   - With and without context
-   - TTL enforcement
-   - Large context rejection
-
-3. **Context Management** (3 tests)
-   - Store/retrieve context
-   - Numeric and boolean values
-   - Large value rejection
-
-4. **Agent Registration** (6 tests)
-   - Basic registration
-   - With/without container ID
-   - Agent type tracking
-   - Status history tracking
-   - TTL enforcement
-
-5. **Status Updates** (5 tests)
-   - All agent statuses
-   - Status history tracking
-   - Invalid status rejection
-   - Zero and large iteration numbers
-
-6. **Completion Signaling** (7 tests)
-   - Confidence edge cases (0.0, 0.5, 1.0)
-   - Invalid confidence rejection
-   - Confidence storage and retrieval
-   - Agent status updates
-
-7. **Loop Waiting** (8 tests)
-   - Successful completion
-   - Timeout scenarios
-   - Task-specific tracking
-   - Parameter validation
-
-8. **Consensus Collection** (9 tests)
-   - Consensus threshold validation
-   - Decision generation (PROCEED/COMPLETE/ABORT)
-   - Single and multiple validators
-   - Consensus metadata storage
-
-9. **Error Handling** (8 tests)
-   - Redis connection failures
-   - Storage errors
-   - Graceful error logging
-   - Error type validation
-
-10. **Validation Tests** (11 tests)
-    - Confidence validation
-    - Agent ID validation
-    - Mode-specific configuration
-    - Security constraint validation
-
-11. **Additional Coverage** (19 tests)
-    - Empty agent lists
-    - Multiple status updates
-    - Consensus metadata
-    - Fractional confidence values
-    - Error recovery scenarios
-
-### Coverage Analysis
-
-**Covered:**
-- All public API methods
-- All validation logic
-- Error handling and recovery
-- Mode-specific behavior
-- Consensus calculation
-- Status tracking
-
-**Uncovered (Infrastructure):**
-- Private Redis client wrapper (89-199)
-  - Covered indirectly through integration
-  - Would require real Redis instance to test directly
-  - Tested via mock injection in all public methods
-- Some internal error handling paths
-
-## Building and Testing
-
-### Build
-```bash
-npm run build
-# Output: dist/ with compiled JavaScript and declaration files
-```
-
-### Run Tests
-```bash
-npm test
-# Or with coverage:
-npm run test:coverage
-```
-
-### Watch Mode
-```bash
-npm run test:watch
-```
-
-### Type Checking
-```bash
-npx tsc --noEmit
-```
-
-## Performance Characteristics
-
-- **Agent Completion Checking**: O(n) where n = unique agents in task
-- **Consensus Collection**: O(m) where m = validators
-- **Loop Wait**: Polls every 5 seconds with configurable timeout
-- **Memory**: Minimal - delegates to Redis for persistence
-
-## Comparison with Bash Version
-
-| Aspect | Bash | TypeScript |
-|--------|------|-----------|
-| Lines | 649 | ~850 (src + tests) |
-| Type Safety | None | Full strict mode |
-| Testing | Manual | 97 automated tests |
-| Error Handling | String-based | Typed errors |
-| Dependency Injection | No | Yes (Logger, Redis) |
-| Configuration Validation | Limited | Comprehensive |
-| Security Constraints | Basic | CWE-aware |
-| Refactoring Safety | Low | High (TypeScript) |
-
-## Future Improvements
-
-1. **Coverage Enhancement**
-   - Extract Redis wrapper to separate testable module
-   - Add integration tests with real Redis instance
-   - Target 90%+ coverage with integration tests
-
-2. **Performance Optimization**
-   - Implement exponential backoff for polling
-   - Add batch operations for multiple agents
-   - Cache agent state locally
-
-3. **Features**
-   - Add metrics/statistics collection
-   - Implement circuit breaker for Redis connection
-   - Add WebSocket support for real-time updates
-
-## Migration Notes
-
-### From Bash to TypeScript
-
-1. **Function Mapping**
-   - `init_task()` → `initTask()`
-   - `register_agent()` → `registerAgent()`
-   - `signal_complete()` → `signalComplete()`
-   - `wait_loop()` → `waitLoop()`
-   - `collect_consensus()` → `collectConsensus()`
-
-2. **Key Differences**
-   - Async/await instead of synchronous bash
-   - Typed error codes instead of bash exit codes
-   - Dependency injection for testability
-   - Promise-based instead of shell exit codes
-
-3. **Breaking Changes**
-   - Function results are now Promise-based
-   - Error handling uses typed exceptions
-   - Return values are typed objects, not JSON strings
-
-## Dependencies
-
-- **ioredis** (^5.3.2): Redis client for Node.js
-- **TypeScript** (^5.3.3): Language and compiler
-- **Jest** (^29.7.0): Testing framework
-- **ts-jest** (^29.1.1): TypeScript support for Jest
-
-## License
-
-MIT
-
-## Author
-
-CFN Team
-
----
-
-**Note**: This TypeScript implementation maintains 100% functional parity with the bash version while providing:
-- Type safety and compile-time error checking
-- Comprehensive automated test coverage
-- Better error handling and debugging
-- Dependency injection for testability
-- Clear API contracts and documentation

package/claude-assets/skills/cfn-docker-redis-coordination/SKILL.md

@@ -1,435 +0,0 @@
-# CFN Docker Redis Coordination Skill
-
-**Purpose:** Provide Redis-based coordination, state management, and communication for container-based CFN Loop execution with swarm recovery capabilities.
-
-## Overview
-
-This skill manages all Redis-based coordination activities for docker-based agents, including task context storage, agent state management, completion signaling, consensus collection, and swarm recovery.
-
-## Architecture
-
-```bash
-CFN Docker Coordinator
-    ↓ (context storage)
-Redis (State Management)
-    ↓ (pub/sub messaging)
-Agent Containers
-    ↓ (completion signals)
-Consensus Collection
-    ↓ (decision flow)
-Product Owner Decision
-```
-
-## Core Functions
-
-### 1. Task Context Management
-Store and retrieve task context for swarm recovery:
-
-```bash
-# Store task context
-cfn-docker-redis-coordination store-context \
-  --task-id task-authentication \
-  --context-file task-context.json \
-  --ttl 3600
-
-# Retrieve task context
-cfn-docker-redis-coordination get-context \
-  --task-id task-authentication \
-  --agent-id agent-frontend-001
-```
-
-### 2. Agent Registration and Status
-Track agent lifecycle and status:
-
-```bash
-# Register agent
-cfn-docker-redis-coordination register-agent \
-  --agent-id agent-frontend-001 \
-  --agent-type react-frontend-engineer \
-  --container-id abc123 \
-  --task-id task-authentication
-
-# Update agent status
-cfn-docker-redis-coordination update-status \
-  --agent-id agent-frontend-001 \
-  --status running \
-  --iteration 1
-```
-
-### 3. Completion Signaling
-Handle agent completion and confidence reporting:
-
-```bash
-# Signal completion
-cfn-docker-redis-coordination signal-complete \
-  --agent-id agent-frontend-001 \
-  --task-id task-authentication \
-  --confidence 0.85 \
-  --iteration 1
-```
-
-### 4. Consensus Collection
-Collect and analyze consensus from validators:
-
-```bash
-# Collect Loop 2 consensus
-cfn-docker-redis-coordination collect-consensus \
-  --task-id task-authentication \
-  --loop-number 2 \
-  --required-consensus 0.90 \
-  --timeout 300
-```
-
-### 5. Swarm Recovery
-Enable recovery from interruptions with state persistence:
-
-```bash
-# Recover swarm state
-cfn-docker-redis-coordination recover-swarm \
-  --task-id task-authentication \
-  --restart-failed-agents
-```
-
-## Redis Data Structure
-
-### Task Context Storage
-```redis
-# Task context (JSON)
-HSET "cfn_docker:task:{task_id}:context" \
-  "epic_goal" "Implement user authentication" \
-  "deliverables" '["auth-service.js","login-form.html"]' \
-  "acceptance_criteria" '["Users can register","Login works","Passwords encrypted"]' \
-  "in_scope" '["authentication","security"]' \
-  "out_of_scope" '["user profiles","social login"]'
-
-# Context metadata
-HSET "cfn_docker:task:{task_id}:meta" \
-  "created_at" "2025-01-15T10:00:00Z" \
-  "ttl" "3600" \
-  "created_by" "cfn-docker-v3-coordinator"
-```
-
-### Agent State Management
-```redis
-# Agent registration
-HSET "cfn_docker:agent:{agent_id}" \
-  "agent_type" "react-frontend-engineer" \
-  "container_id" "abc123" \
-  "task_id" "task-authentication" \
-  "status" "running" \
-  "iteration" "1" \
-  "created_at" "2025-01-15T10:05:00Z"
-
-# Agent status history
-LPUSH "cfn_docker:agent:{agent_id}:status_history" \
-  '{"status":"spawning","timestamp":"2025-01-15T10:05:00Z"}' \
-  '{"status":"running","timestamp":"2025-01-15T10:06:00Z"}'
-```
-
-### Completion Signaling
-```redis
-# Agent completion signal
-LPUSH "cfn_docker:task:{task_id}:agent:{agent_id}:done" "complete"
-
-# Confidence reporting
-HSET "cfn_docker:task:{task_id}:confidence:{agent_id}" \
-  "confidence" "0.85" \
-  "iteration" "1" \
-  "reported_at" "2025-01-15T10:30:00Z" \
-  "agent_type" "react-frontend-engineer"
-```
-
-### Consensus Tracking
-```redis
-# Loop 2 consensus collection
-HSET "cfn_docker:task:{task_id}:loop2:consensus" \
-  "total_validators" "3" \
-  "responses_received" "3" \
-  "average_confidence" "0.92" \
-  "consensus_reached" "true" \
-  "decision" "PROCEED"
-
-# Individual validator responses
-HSET "cfn_docker:task:{task_id}:loop2:validator:{validator_id}" \
-  "confidence" "0.90" \
-  "feedback" "Implementation meets requirements" \
-  "suggested_changes" "None" \
-  "iteration" "1"
-```
-
-## Usage Patterns
-
-### Task Initialization
-```bash
-# Initialize coordination for new task
-cfn-docker-redis-coordination init-task \
-  --task-id task-authentication \
-  --context-file task-context.json \
-  --loop-count 5 \
-  --consensus-threshold 0.90
-```
-
-### Agent Lifecycle Management
-```bash
-# Register multiple agents
-for agent in frontend backend security; do
-  cfn-docker-redis-coordination register-agent \
-    --agent-id "agent-${agent}-001" \
-    --agent-type "${agent}-developer" \
-    --task-id task-authentication
-done
-
-# Monitor agent status
-cfn-docker-redis-coordination monitor-agents \
-  --task-id task-authentication \
-  --wait-for-complete
-```
-
-### Loop Orchestration Support
-```bash
-# Wait for Loop 3 completion
-cfn-docker-redis-coordination wait-loop \
-  --task-id task-authentication \
-  --loop-number 3 \
-  --agent-count 3 \
-  --timeout 600
-
-# Collect Loop 2 consensus
-cfn-docker-redis-coordination collect-consensus \
-  --task-id task-authentication \
-  --loop-number 2 \
-  --required-consensus 0.90
-```
-
-### Swarm Recovery
-```bash
-# Check for recoverable tasks
-cfn-docker-redis-coordination list-recoverable-tasks
-
-# Recover specific task
-cfn-docker-redis-coordination recover-task \
-  --task-id task-authentication \
-  --restart-incomplete-agents
-```
-
-## Integration Points
-
-### With CFN Docker Agent Spawning
-```bash
-# Agent spawning calls coordination
-AGENT_ID=$(cfn-docker-agent-spawn --agent-type ${AGENT_TYPE} --task-id ${TASK_ID})
-cfn-docker-redis-coordination register-agent \
-  --agent-id ${AGENT_ID} \
-  --agent-type ${AGENT_TYPE} \
-  --task-id ${TASK_ID}
-```
-
-### With CFN Docker Loop Orchestration
-```bash
-# Loop orchestration uses coordination for state
-cfn-docker-loop-orchestration execute-loop3 \
-  --task-id ${TASK_ID} \
-  --agent-count 3 \
-  --coordination redis
-```
-
-### With CFN Docker Skill Selection
-```bash
-# Store MCP selection in Redis
-MCP_CONFIG=$(cfn-docker-skill-mcp-selector select --agent-type ${AGENT_TYPE})
-cfn-docker-redis-coordination store \
-  --key "agent:${AGENT_ID}:mcp-config" \
-  --value "${MCP_CONFIG}"
-```
-
-## Error Handling and Recovery
-
-### Connection Resilience
-```bash
-# Redis connection retry
-cfn-docker-redis-coordination connect \
-  --host redis \
-  --port 6379 \
-  --retry-attempts 5 \
-  --retry-delay 5
-```
-
-### Data Integrity
-```bash
-# Validate stored data
-cfn-docker-redis-coordination validate \
-  --task-id task-authentication \
-  --repair-corrupted
-```
-
-### Timeout Management
-```bash
-# Handle operation timeouts
-cfn-docker-redis-coordination timeout-handler \
-  --task-id task-authentication \
-  --agent-timeout 600 \
-  --consensus-timeout 300
-```
-
-## Performance Optimization
-
-### Connection Pooling
-- Use Redis connection pools for high-frequency operations
-- Implement connection reuse across operations
-- Configure appropriate pool sizes based on load
-
-### Data Expiration
-- Set TTLs on all temporary data
-- Use automatic cleanup for expired data
-- Implement manual cleanup for large datasets
-
-### Memory Management
-- Use Redis memory optimization techniques
-- Compress large JSON objects
-- Implement data partitioning for large tasks
-
-### Batch Operations
-```bash
-# Batch agent registration
-cfn-docker-redis-coordination batch-register \
-  --agent-list agents.json \
-  --task-id task-authentication
-
-# Batch status updates
-cfn-docker-redis-coordination batch-update-status \
-  --status-list status-updates.json
-```
-
-## Monitoring and Observability
-
-### Health Checks
-```bash
-# Redis health check
-cfn-docker-redis-coordination health-check \
-  --test-connection \
-  --test-memory \
-  --test-latency
-
-# Task health monitoring
-cfn-docker-redis-coordination monitor-task \
-  --task-id task-authentication \
-  --alert-stalled-agents
-```
-
-### Metrics Collection
-```bash
-# Performance metrics
-cfn-docker-redis-coordination metrics \
-  --task-id task-authentication \
-  --include-memory \
-  --include-latency \
-  --include-throughput
-
-# Agent performance tracking
-cfn-docker-redis-coordination agent-metrics \
-  --task-id task-authentication \
-  --agent-id agent-frontend-001
-```
-
-### Audit Logging
-```bash
-# Enable audit logging
-cfn-docker-redis-coordination audit-enable \
-  --log-level info \
-  --include-operations \
-  --include-data-changes
-```
-
-## Security Considerations
-
-### Access Control
-- Implement Redis authentication (AUTH command)
-- Use ACLs for fine-grained access control
-- Network isolation with Redis in private networks
-
-### Data Encryption
-- Enable Redis TLS for encrypted communication
-- Encrypt sensitive data at rest
-- Use secure key management for tokens
-
-### Data Sanitization
-- Sanitize all data before storage
-- Validate data formats and sizes
-- Prevent Redis injection attacks
-
-## Best Practices
-
-### Data Structure Design
-- Use consistent key naming conventions
-- Implement proper data versioning
-- Use appropriate Redis data types for different use cases
-
-### Performance Optimization
-- Monitor Redis memory usage
-- Implement appropriate eviction policies
-- Use Redis clustering for large-scale deployments
-
-### Operational Excellence
-- Implement comprehensive monitoring
-- Set up automated alerts for anomalies
-- Regular backup and recovery testing
-
-## Troubleshooting
-
-### Common Issues
-1. **Connection Failures**: Check Redis server status and network connectivity
-2. **Memory Issues**: Monitor Redis memory usage and implement proper eviction policies
-3. **Data Corruption**: Implement data validation and repair mechanisms
-4. **Performance Issues**: Optimize queries and use appropriate indexing
-
-### Debug Commands
-```bash
-# Debug connection issues
-cfn-docker-redis-coordination debug-connection \
-  --host redis \
-  --port 6379 \
-  --verbose
-
-# Debug data issues
-cfn-docker-redis-coordination debug-data \
-  --task-id task-authentication \
-  --check-integrity \
-  --show-structure
-
-# Debug performance
-cfn-docker-redis-coordination debug-performance \
-  --task-id task-authentication \
-  --monitor-latency \
-  --show-memory-usage
-```
-
-## Configuration
-
-### Environment Variables
-```bash
-# Redis connection
-CFN_DOCKER_REDIS_HOST=localhost
-CFN_DOCKER_REDIS_PORT=6379
-CFN_DOCKER_REDIS_PASSWORD=
-CFN_DOCKER_REDIS_DB=0
-
-# Timeouts and limits
-CFN_DOCKER_REDIS_TIMEOUT=30
-CFN_DOCKER_REDIS_MAX_RETRIES=5
-CFN_DOCKER_REDIS_POOL_SIZE=10
-
-# Data management
-CFN_DOCKER_REDIS_DEFAULT_TTL=3600
-CFN_DOCKER_REDIS_MAX_MEMORY=1gb
-CFN_DOCKER_REDIS_EVICTION_POLICY=allkeys-lru
-```
-
-### Redis Configuration
-```conf
-# redis.conf recommendations for CFN Docker
-maxmemory 1gb
-maxmemory-policy allkeys-lru
-save 900 1
-save 300 10
-save 60 10000
-```