claude-flow-novice 2.10.5 → 2.10.6

package/claude-assets/skills/cfn-standardized-error-handling/test-error-handling.sh

@@ -0,0 +1,166 @@
+#!/bin/bash
+
+# Enhanced Test Script for Standardized Error Handling
+# Version 2.0 - Comprehensive Error Scenario Testing
+
+# Directories and Script Paths
+SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+ERROR_CAPTURE_SCRIPT="${SCRIPT_DIR}/capture-agent-error.sh"
+RETRY_SCRIPT="${SCRIPT_DIR}/should-retry.sh"
+
+# Colored Output
+GREEN='\033[0;32m'
+RED='\033[0;31m'
+NC='\033[0m' # No Color
+
+# Test Utility Functions
+assert_equals() {
+    local expected="$1"
+    local actual="$2"
+    local test_name="$3"
+
+    if [ "$actual" = "$expected" ]; then
+        echo -e "${GREEN}✅ $test_name passed${NC}"
+        return 0
+    else
+        echo -e "${RED}❌ $test_name failed${NC}"
+        echo "  Expected: $expected"
+        echo "  Actual:   $actual"
+        return 1
+    }
+}
+
+# Error Categorization Tests
+test_timeout_error_categorization() {
+    local task_id="task-timeout-001"
+    local agent_id="agent-timeout"
+    local error_output="Operation timed out after 120 seconds"
+
+    local result=$(bash "$ERROR_CAPTURE_SCRIPT" "backend-dev" "$task_id" "$agent_id" 124 "$error_output")
+    assert_equals "TIMEOUT" "$result" "Timeout Error Categorization"
+
+    # Check retry recommendation
+    local retry_result=$(bash "$RETRY_SCRIPT" "TIMEOUT" "$task_id")
+    assert_equals "RETRY_WITH_EXTENDED_TIMEOUT" "$retry_result" "Timeout Retry Recommendation"
+}
+
+test_crash_error_categorization() {
+    local task_id="task-crash-002"
+    local agent_id="agent-crash"
+    local error_output="Segmentation fault in module X"
+
+    local result=$(bash "$ERROR_CAPTURE_SCRIPT" "devops" "$task_id" "$agent_id" 139 "$error_output")
+    assert_equals "CRASH" "$result" "Crash Error Categorization"
+
+    # Check retry recommendation
+    local retry_result=$(bash "$RETRY_SCRIPT" "CRASH" "$task_id")
+    assert_equals "RETRY_WITH_ISOLATION" "$retry_result" "Crash Retry Recommendation"
+}
+
+test_dependency_failure_categorization() {
+    local task_id="task-dep-003"
+    local agent_id="agent-dep"
+    local error_output="MODULE_NOT_FOUND: react-dom/server"
+
+    local result=$(bash "$ERROR_CAPTURE_SCRIPT" "frontend-dev" "$task_id" "$agent_id" 1 "$error_output")
+    assert_equals "DEPENDENCY_FAILURE" "$result" "Dependency Failure Categorization"
+
+    # Check retry recommendation
+    local retry_result=$(bash "$RETRY_SCRIPT" "DEPENDENCY_FAILURE" "$task_id")
+    assert_equals "RETRY_WITH_DEPENDENCY_RESET" "$retry_result" "Dependency Failure Retry Recommendation"
+}
+
+test_no_deliverables_categorization() {
+    local task_id="task-nodeliver-004"
+    local agent_id="agent-nodeliver"
+    local error_output=""
+
+    local result=$(bash "$ERROR_CAPTURE_SCRIPT" "researcher" "$task_id" "$agent_id" 0 "$error_output")
+    assert_equals "NO_DELIVERABLES" "$result" "No Deliverables Categorization"
+
+    # Check retry recommendation
+    local retry_result=$(bash "$RETRY_SCRIPT" "NO_DELIVERABLES" "$task_id")
+    assert_equals "RETRY_WITH_CLARIFICATION" "$retry_result" "No Deliverables Retry Recommendation"
+}
+
+test_invalid_output_categorization() {
+    local task_id="task-invalid-005"
+    local agent_id="agent-invalid"
+    local error_output="Unparseable or malformed output"
+
+    local result=$(bash "$ERROR_CAPTURE_SCRIPT" "backend-dev" "$task_id" "$agent_id" 1 "$error_output")
+    assert_equals "INVALID_OUTPUT" "$result" "Invalid Output Categorization"
+
+    # Check retry recommendation
+    local retry_result=$(bash "$RETRY_SCRIPT" "INVALID_OUTPUT" "$task_id")
+    assert_equals "RETRY_WITH_VALIDATION" "$retry_result" "Invalid Output Retry Recommendation"
+}
+
+# JSON Error Report Validation Test
+test_json_error_report() {
+    local task_id="task-json-006"
+    local agent_id="agent-json"
+    local error_output="Complex error scenario with multiple components"
+
+    local result=$(bash "$ERROR_CAPTURE_SCRIPT" "devops" "$task_id" "$agent_id" 2 "$error_output")
+    local json_report=$(bash "$ERROR_CAPTURE_SCRIPT" "devops" "$task_id" "$agent_id" 2 "$error_output" --json)
+
+    # Validate JSON structure (requires jq)
+    local json_valid=$(echo "$json_report" | jq empty 2>/dev/null && echo "valid" || echo "invalid")
+    assert_equals "valid" "$json_valid" "JSON Error Report Validation"
+
+    # Additional JSON structure checks could be added here
+}
+
+# Performance and Edge Case Test
+test_error_handling_performance() {
+    local start_time=$(date +%s.%N)
+
+    # Run multiple error scenarios quickly
+    for _ in {1..10}; do
+        bash "$ERROR_CAPTURE_SCRIPT" "backend-dev" "perf-task-$RANDOM" "agent-perf" 1 "Test performance"
+    done
+
+    local end_time=$(date +%s.%N)
+    local duration=$(echo "$end_time - $start_time" | bc)
+
+    # Check if total execution time is reasonable (under 2 seconds for 10 runs)
+    local max_duration=2.0
+    local passed=$(echo "$duration < $max_duration" | bc)
+
+    assert_equals "1" "$passed" "Error Handling Performance Test"
+}
+
+# Main Test Runner
+run_error_handling_test_suite() {
+    echo "Starting Comprehensive Error Handling Test Suite..."
+
+    # Track test results
+    local total_tests=6
+    local passed_tests=0
+
+    # Run each test and count successes
+    test_timeout_error_categorization && ((passed_tests++))
+    test_crash_error_categorization && ((passed_tests++))
+    test_dependency_failure_categorization && ((passed_tests++))
+    test_no_deliverables_categorization && ((passed_tests++))
+    test_invalid_output_categorization && ((passed_tests++))
+    test_json_error_report && ((passed_tests++))
+    test_error_handling_performance && ((passed_tests++))
+
+    local confidence=$(echo "scale=2; ($passed_tests / $total_tests)" | bc)
+
+    echo -e "\n${GREEN}Test Suite Summary:${NC}"
+    echo "Total Tests: $total_tests"
+    echo "Passed Tests: $passed_tests"
+    echo "Confidence: $confidence"
+
+    # Return non-zero if not all tests pass
+    [ "$passed_tests" -eq "$total_tests" ]
+}
+
+# Execute the test suite
+run_error_handling_test_suite
+exit_code=$?
+
+exit $exit_code

package/claude-assets/skills/cfn-task-classifier/SKILL.md

@@ -0,0 +1,94 @@
+# Task Type Classifier Skill
+
+**Version:** 1.0.0
+**Purpose:** Detect task type from task description for CFN Loop v3
+
+## Overview
+
+Analyzes task description keywords to classify into one of 6 domains:
+- software-development
+- content-creation
+- research
+- design
+- infrastructure
+- data-engineering
+
+## Usage
+
+```bash
+TASK_TYPE=$(./.claude/skills/task-classifier/classify-task.sh "$TASK_DESCRIPTION")
+echo "$TASK_TYPE"  # → "software-development"
+```
+
+## Classification Keywords
+
+### Software Development
+- implement, build, code, develop, create API
+- backend, frontend, full-stack, web app
+- REST, GraphQL, database, authentication
+- bug fix, refactor, optimize code
+
+### Content Creation
+- write, article, blog post, copy, content
+- documentation, guide, tutorial, whitepaper
+- SEO, marketing copy, product description
+- technical writing, user manual
+
+### Research
+- research, analyze, study, investigate
+- data analysis, statistical analysis
+- literature review, market research
+- competitive analysis, feasibility study
+
+### Design
+- design, UI, UX, mockup, wireframe
+- prototype, user interface, user experience
+- visual design, branding, style guide
+- accessibility, responsive design
+
+### Infrastructure
+- deploy, infrastructure, DevOps, cloud
+- Kubernetes, Docker, Terraform, AWS
+- CI/CD, monitoring, logging, scaling
+- networking, security configuration
+
+### Data Engineering
+- ETL, pipeline, data warehouse, data lake
+- streaming, real-time processing, batch
+- data quality, schema, data model
+- Apache Spark, Airflow, data integration
+
+## Algorithm
+
+1. Convert task description to lowercase
+2. Check for keyword matches per category
+3. Return category with most matches
+4. Default to software-development if ambiguous
+
+## Examples
+
+```bash
+classify-task.sh "Implement JWT authentication for REST API"
+# → software-development
+
+classify-task.sh "Write SEO-optimized blog post about AI trends"
+# → content-creation
+
+classify-task.sh "Research market opportunities for SaaS product"
+# → research
+
+classify-task.sh "Design mobile app onboarding flow with wireframes"
+# → design
+
+classify-task.sh "Deploy microservices to Kubernetes cluster"
+# → infrastructure
+
+classify-task.sh "Build ETL pipeline for customer data warehouse"
+# → data-engineering
+```
+
+## Integration
+
+Used by:
+- `.claude/agents/cfn-v3-coordinator.md` - Task analysis
+- `.claude/skills/agent-selector/select-agents.sh` - Agent recommendation

package/claude-assets/skills/cfn-task-classifier/USAGE.md

@@ -0,0 +1,248 @@
+# Task Classifier Usage Guide
+
+## Overview
+
+Enhanced task classifier with domain detection and complexity assessment for ACE System Phase 2.4.
+
+## Basic Usage
+
+### Simple Format (Backward Compatible)
+```bash
+./classify-task.sh "Implement JWT authentication"
+# Output: software-development
+```
+
+### JSON Format (New in Phase 2.4)
+```bash
+./classify-task.sh "Implement JWT authentication" --format=json
+```
+
+**Output:**
+```json
+{
+  "task_type": "software-development",
+  "domains": ["backend", "security"],
+  "complexity": "low",
+  "keyword_counts": {
+    "frontend": 0,
+    "backend": 1,
+    "security": 3,
+    "devops": 0,
+    "testing": 0,
+    "database": 0,
+    "documentation": 0
+  },
+  "task_type_counts": {
+    "software": 2,
+    "content": 0,
+    "research": 0,
+    "design": 0,
+    "infrastructure": 0,
+    "data": 0
+  }
+}
+```
+
+## Task Types
+
+1. **software-development** - Coding, API development, bug fixes
+2. **content-creation** - Documentation, articles, marketing copy
+3. **research** - Analysis, investigation, studies
+4. **design** - UI/UX, mockups, prototypes
+5. **infrastructure** - DevOps, deployment, cloud resources
+6. **data-engineering** - ETL pipelines, data warehouses
+
+## Domain Categories
+
+1. **frontend** - React, Vue, Angular, UI/UX, CSS, HTML
+2. **backend** - API, server, Node.js, Python, Java
+3. **security** - Authentication, JWT, OAuth, encryption
+4. **devops** - Docker, Kubernetes, CI/CD, cloud providers
+5. **testing** - Unit tests, integration tests, E2E
+6. **database** - SQL, NoSQL, PostgreSQL, MongoDB, Redis
+7. **documentation** - README, guides, API docs
+8. **general** - Default when no specific domain detected
+
+## Complexity Levels
+
+- **low** - Simple, single-domain tasks (< 10 words)
+- **medium** - Standard tasks (10-30 words, 1-2 domains)
+- **high** - Complex, multi-domain tasks (> 30 words, ≥ 3 domains, or > 2 technical terms)
+
+## Examples
+
+### Single Domain Tasks
+
+**Frontend:**
+```bash
+./classify-task.sh "Design responsive UI components" --format=json
+# domains: ["frontend"], complexity: "low"
+```
+
+**Backend:**
+```bash
+./classify-task.sh "Create REST API endpoints for user management" --format=json
+# domains: ["backend"], complexity: "low"
+```
+
+**Database:**
+```bash
+./classify-task.sh "Migrate PostgreSQL schema and optimize queries" --format=json
+# domains: ["backend", "database"], complexity: "low"
+```
+
+### Multi-Domain Tasks
+
+**Full-Stack:**
+```bash
+./classify-task.sh "Build React frontend with Node.js backend API" --format=json
+# domains: ["frontend", "backend"], complexity: "medium"
+```
+
+**Complete System:**
+```bash
+./classify-task.sh "Architect microservices with Docker, Kubernetes, JWT auth, PostgreSQL, testing suite, and API docs" --format=json
+# domains: ["frontend", "backend", "security", "devops", "testing", "database", "documentation"]
+# complexity: "high"
+```
+
+## Integration with ACE System
+
+### Phase 2.5: Context Retrieval
+
+The domain field enables context retrieval from ACE System indexes:
+
+```bash
+# 1. Classify task
+CLASSIFICATION=$(./classify-task.sh "$TASK_DESC" --format=json)
+
+# 2. Extract domains
+DOMAINS=$(echo "$CLASSIFICATION" | jq -r '.domains[]')
+
+# 3. Query ACE indexes for each domain
+for domain in $DOMAINS; do
+  query_ace_index "$domain" "$TASK_DESC"
+done
+```
+
+### CFN Loop Integration
+
+Pass domain information to coordinators for agent specialization:
+
+```bash
+DOMAINS=$(./classify-task.sh "$TASK" --format=json | jq -r '.domains[]')
+
+if echo "$DOMAINS" | grep -q "security"; then
+  # Include security specialist in Loop 2
+  VALIDATORS="$VALIDATORS security-specialist"
+fi
+```
+
+## API Reference
+
+### Command Line Interface
+
+```
+Usage: classify-task.sh "task description" [--format=FORMAT]
+
+Options:
+  --format=json    Output detailed JSON with domains and complexity
+  --format=simple  Output task type only (default, backward compatible)
+
+Exit Codes:
+  0  Success
+  1  Invalid usage (missing task description)
+```
+
+### JSON Output Schema
+
+```json
+{
+  "task_type": "string",           // One of 6 task types
+  "domains": ["string"],           // Array of 1+ domain categories
+  "complexity": "string",          // low | medium | high
+  "keyword_counts": {              // Domain-specific keyword matches
+    "frontend": number,
+    "backend": number,
+    "security": number,
+    "devops": number,
+    "testing": number,
+    "database": number,
+    "documentation": number
+  },
+  "task_type_counts": {            // Task type keyword matches
+    "software": number,
+    "content": number,
+    "research": number,
+    "design": number,
+    "infrastructure": number,
+    "data": number
+  }
+}
+```
+
+## Customization
+
+### Adjust Domain Threshold
+
+Edit `classify-task.sh` line 185:
+```bash
+DOMAIN_THRESHOLD=1  # Increase to require more keyword matches
+```
+
+### Add Custom Keywords
+
+Add keywords to relevant arrays (lines 76-116):
+```bash
+FRONTEND_KEYWORDS+=(
+  "svelte" "nextjs" "nuxt"  # Add new frontend frameworks
+)
+```
+
+### Modify Complexity Heuristics
+
+Edit complexity logic (lines 221-249):
+```bash
+# Example: Consider tasks with "migrate" keyword as high complexity
+if echo "$TASK_LOWER" | grep -q "migrate"; then
+  COMPLEXITY="high"
+fi
+```
+
+## Testing
+
+Run comprehensive test suite:
+```bash
+bash tests/ace-integration/test-domain-classifier.sh
+```
+
+Or test manually:
+```bash
+./classify-task.sh "Your task description here" --format=json
+```
+
+## Performance
+
+- Average execution time: < 50ms
+- Memory usage: < 5MB
+- No external dependencies (pure bash)
+
+## Troubleshooting
+
+### Issue: Incorrect domain detection
+
+**Solution:** Check keyword arrays for missing terms relevant to your task
+
+### Issue: Complexity always "low"
+
+**Solution:** Verify word count and technical terms in task description
+
+### Issue: JSON parsing errors
+
+**Solution:** Ensure `--format=json` flag is used and output is valid JSON
+
+## See Also
+
+- `docs/PHASE_2_4_DOMAIN_CLASSIFIER.md` - Implementation details
+- `.claude/skills/cfn-ace-system/extract-tags.sh` - Tag extraction (Phase 2.1)
+- `.claude/skills/cfn-ace-system/score-relevance.sh` - Relevance scoring (Phase 2.2)