claude-flow-novice 2.15.2 → 2.15.4

package/claude-assets/skills/workflow-codification/generate-skill-update.sh

@@ -0,0 +1,525 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# generate-skill-update.sh - Generate skill update proposals from edge cases
+# Creates test cases, proposes logic modifications, updates documentation
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+DB_PATH="${DB_PATH:-${SCRIPT_DIR}/workflow-codification.db}"
+PROPOSALS_DIR="${PROPOSALS_DIR:-${SCRIPT_DIR}/proposals}"
+
+# Initialize proposals directory
+init_proposals_dir() {
+    mkdir -p "$PROPOSALS_DIR"
+}
+
+# Parse semantic version
+parse_version() {
+    local version="$1"
+    local part="$2"  # major, minor, patch
+
+    local major minor patch
+    IFS='.' read -r major minor patch <<< "$version"
+
+    case "$part" in
+        major) echo "$major" ;;
+        minor) echo "$minor" ;;
+        patch) echo "$patch" ;;
+        *) echo "0" ;;
+    esac
+}
+
+# Increment semantic version
+increment_version() {
+    local version="$1"
+    local increment_type="${2:-patch}"  # major, minor, patch
+
+    local major minor patch
+    major=$(parse_version "$version" "major")
+    minor=$(parse_version "$version" "minor")
+    patch=$(parse_version "$version" "patch")
+
+    case "$increment_type" in
+        major)
+            echo "$((major + 1)).0.0"
+            ;;
+        minor)
+            echo "${major}.$((minor + 1)).0"
+            ;;
+        patch)
+            echo "${major}.${minor}.$((patch + 1))"
+            ;;
+        *)
+            echo "$version"
+            ;;
+    esac
+}
+
+# Get edge case details
+get_edge_case() {
+    local edge_case_hash="$1"
+
+    sqlite3 -json "$DB_PATH" <<EOF
+SELECT * FROM edge_cases WHERE edge_case_hash = '$edge_case_hash';
+EOF
+}
+
+# Generate test case
+generate_test_case() {
+    local skill_name="$1"
+    local edge_case_hash="$2"
+    local input_params="$3"
+    local expected_output="$4"
+    local actual_output="$5"
+    local error_message="$6"
+
+    cat <<TESTCASE
+# Test Case: Edge Case $edge_case_hash
+
+## Description
+Regression test for edge case identified in production execution.
+
+## Input Parameters
+\`\`\`
+$input_params
+\`\`\`
+
+## Expected Output
+\`\`\`
+$expected_output
+\`\`\`
+
+## Actual Output (Failure)
+\`\`\`
+$actual_output
+\`\`\`
+
+## Error Message
+\`\`\`
+$error_message
+\`\`\`
+
+## Test Implementation
+
+\`\`\`bash
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Test: $skill_name - Edge Case $edge_case_hash
+
+SCRIPT_DIR="\$(cd "\$(dirname "\${BASH_SOURCE[0]}")" && pwd)"
+SKILL_PATH="\${SCRIPT_DIR}/../${skill_name}.sh"
+
+# Execute skill with edge case parameters
+output=\$("\$SKILL_PATH" $input_params 2>&1) || exit_code=\$?
+
+# Verify expected behavior
+if [[ \$exit_code -eq 0 ]]; then
+    if [[ "\$output" == "$expected_output" ]]; then
+        echo "PASS: Edge case handled correctly"
+        exit 0
+    else
+        echo "FAIL: Output mismatch"
+        echo "Expected: $expected_output"
+        echo "Actual: \$output"
+        exit 1
+    fi
+else
+    echo "FAIL: Unexpected exit code \$exit_code"
+    exit 1
+fi
+\`\`\`
+
+## Validation Criteria
+- Exit code: 0 (success)
+- Output matches expected value
+- No error messages
+- Execution time < 1000ms
+TESTCASE
+}
+
+# Analyze edge case pattern
+analyze_edge_case_pattern() {
+    local skill_name="$1"
+    local exit_code="$2"
+    local input_params="$3"
+    local error_message="$4"
+
+    local pattern_analysis=""
+
+    # Pattern detection logic
+    if [[ "$error_message" =~ "timeout" ]]; then
+        pattern_analysis="Timeout issue detected. Consider increasing timeout threshold or implementing retry logic."
+    elif [[ "$error_message" =~ "connection" ]]; then
+        pattern_analysis="Connection failure detected. Implement connection retry with exponential backoff."
+    elif [[ "$error_message" =~ "not found" ]]; then
+        pattern_analysis="Resource not found. Add existence check before operation."
+    elif [[ "$error_message" =~ "permission" ]]; then
+        pattern_analysis="Permission error. Validate permissions before execution or provide clear error message."
+    elif [[ "$exit_code" -eq 127 ]]; then
+        pattern_analysis="Command not found. Add dependency validation at script initialization."
+    elif [[ "$exit_code" -eq 1 ]]; then
+        pattern_analysis="General failure. Review error handling and add specific error messages."
+    else
+        pattern_analysis="Unknown pattern. Manual review required."
+    fi
+
+    echo "$pattern_analysis"
+}
+
+# Generate logic modification proposal
+generate_logic_proposal() {
+    local skill_name="$1"
+    local pattern_analysis="$2"
+    local input_params="$3"
+    local error_message="$4"
+
+    cat <<PROPOSAL
+# Logic Modification Proposal
+
+## Analysis
+$pattern_analysis
+
+## Proposed Changes
+
+### 1. Input Validation Enhancement
+\`\`\`bash
+# Add parameter validation
+validate_input() {
+    local params=\$1
+
+    # Extract and validate parameters
+    # Example: Check for required fields, type validation, range checks
+
+    if [[ ! \$params =~ valid_pattern ]]; then
+        echo "Error: Invalid input parameters" >&2
+        return 1
+    fi
+
+    return 0
+}
+\`\`\`
+
+### 2. Error Handling Improvement
+\`\`\`bash
+# Enhanced error handling
+execute_with_retry() {
+    local max_retries=3
+    local retry_delay=2
+    local attempt=1
+
+    while [[ \$attempt -le \$max_retries ]]; do
+        if command_that_might_fail; then
+            return 0
+        else
+            echo "Attempt \$attempt failed, retrying in \${retry_delay}s..." >&2
+            sleep \$retry_delay
+            ((attempt++))
+        fi
+    done
+
+    echo "Error: Maximum retries exceeded" >&2
+    return 1
+}
+\`\`\`
+
+### 3. Edge Case Handling
+\`\`\`bash
+# Specific handling for edge case
+handle_edge_case() {
+    local input=\$1
+
+    # Check for edge case condition
+    if [[ condition_that_triggered_edge_case ]]; then
+        # Apply specific handling logic
+        echo "Edge case detected, applying special handling" >&2
+
+        # Execute alternative logic path
+        alternative_execution_path
+
+        return \$?
+    fi
+
+    # Normal execution path
+    return 0
+}
+\`\`\`
+
+## Implementation Priority
+1. High: Input validation (prevents invalid state)
+2. Medium: Error handling (improves resilience)
+3. Low: Edge case handling (addresses specific scenario)
+
+## Backward Compatibility
+- All changes maintain existing API contract
+- New parameters are optional with sensible defaults
+- Error messages provide clear migration guidance
+PROPOSAL
+}
+
+# Generate documentation update
+generate_documentation_update() {
+    local skill_name="$1"
+    local old_version="$2"
+    local new_version="$3"
+    local edge_case_hash="$4"
+
+    cat <<DOCS
+# Documentation Update: $skill_name v$new_version
+
+## Changelog
+
+### Version $new_version ($(date +%Y-%m-%d))
+
+**Fixed:**
+- Resolved edge case $edge_case_hash
+- Enhanced input validation
+- Improved error handling and messaging
+
+**Changed:**
+- Updated parameter validation logic
+- Added retry mechanism for transient failures
+
+**Added:**
+- New edge case handling for specific input patterns
+- Comprehensive test coverage for edge cases
+
+## Migration Guide
+
+### Upgrading from v$old_version to v$new_version
+
+No breaking changes. This is a backward-compatible patch release.
+
+**Recommended Actions:**
+1. Update skill reference to v$new_version
+2. Review new error messages in integration code
+3. Validate that existing parameters still work as expected
+
+**New Features:**
+- Enhanced error messages provide more context
+- Automatic retry for transient failures (configurable)
+- Stricter input validation (prevents invalid states)
+
+## Updated Examples
+
+\`\`\`bash
+# Example: Basic usage (unchanged)
+$skill_name.sh --param1 value1 --param2 value2
+
+# Example: New retry behavior (automatic)
+# Transient failures now retry up to 3 times with exponential backoff
+
+# Example: Enhanced error messages
+# Old: "Error: Operation failed"
+# New: "Error: Connection timeout after 30s (attempt 3/3)"
+\`\`\`
+
+## Testing Recommendations
+
+1. Regression testing: Verify existing workflows still function
+2. Edge case testing: Test with previously failing inputs
+3. Performance testing: Validate retry logic doesn't impact latency
+DOCS
+}
+
+# Generate complete proposal
+generate_proposal() {
+    local skill_name="$1"
+    local edge_case_hash="$2"
+    local occurrence_count="$3"
+
+    # Get edge case details
+    local edge_case_json
+    edge_case_json=$(get_edge_case "$edge_case_hash")
+
+    # Parse JSON (simplified - in production use jq)
+    local skill_version exit_code input_params expected_output actual_output error_message
+    skill_version=$(echo "$edge_case_json" | grep -o '"skill_version":"[^"]*"' | cut -d'"' -f4)
+    exit_code=$(echo "$edge_case_json" | grep -o '"exit_code":[0-9]*' | cut -d':' -f2)
+    input_params=$(echo "$edge_case_json" | grep -o '"input_params":"[^"]*"' | cut -d'"' -f4)
+    expected_output=$(echo "$edge_case_json" | grep -o '"expected_output":"[^"]*"' | cut -d'"' -f4)
+    actual_output=$(echo "$edge_case_json" | grep -o '"actual_output":"[^"]*"' | cut -d'"' -f4)
+    error_message=$(echo "$edge_case_json" | grep -o '"error_message":"[^"]*"' | cut -d'"' -f4)
+
+    # Increment version
+    local new_version
+    new_version=$(increment_version "$skill_version" "patch")
+
+    # Analyze pattern
+    local pattern_analysis
+    pattern_analysis=$(analyze_edge_case_pattern "$skill_name" "$exit_code" "$input_params" "$error_message")
+
+    # Create proposal directory
+    local proposal_dir="${PROPOSALS_DIR}/${skill_name}_${edge_case_hash:0:8}_v${new_version}"
+    mkdir -p "$proposal_dir"
+
+    # Generate proposal components
+    generate_test_case "$skill_name" "$edge_case_hash" "$input_params" "$expected_output" \
+        "$actual_output" "$error_message" > "${proposal_dir}/test_case.md"
+
+    generate_logic_proposal "$skill_name" "$pattern_analysis" "$input_params" \
+        "$error_message" > "${proposal_dir}/logic_proposal.md"
+
+    generate_documentation_update "$skill_name" "$skill_version" "$new_version" \
+        "$edge_case_hash" > "${proposal_dir}/documentation_update.md"
+
+    # Create summary
+    cat > "${proposal_dir}/PROPOSAL_SUMMARY.md" <<SUMMARY
+# Skill Update Proposal: $skill_name v$new_version
+
+## Overview
+Edge case $edge_case_hash occurred $occurrence_count times, triggering automatic proposal generation.
+
+**Current Version:** $skill_version
+**Proposed Version:** $new_version
+**Generated:** $(date +"%Y-%m-%d %H:%M:%S")
+
+## Edge Case Details
+- **Exit Code:** $exit_code
+- **Input Parameters:** $input_params
+- **Error Message:** $error_message
+- **Occurrence Count:** $occurrence_count
+
+## Pattern Analysis
+$pattern_analysis
+
+## Proposal Components
+
+1. **Test Case** (\`test_case.md\`)
+   - Regression test for edge case
+   - Executable test script
+   - Validation criteria
+
+2. **Logic Proposal** (\`logic_proposal.md\`)
+   - Input validation enhancements
+   - Error handling improvements
+   - Edge case handling logic
+
+3. **Documentation Update** (\`documentation_update.md\`)
+   - Changelog entry
+   - Migration guide
+   - Updated examples
+
+## Next Steps
+
+1. **Review** proposal components
+2. **Implement** proposed changes in skill script
+3. **Test** using provided test case
+4. **Update** skill documentation
+5. **Deploy** new version
+6. **Mark** edge case as resolved
+
+## Approval Checklist
+
+- [ ] Test case passes with proposed changes
+- [ ] Backward compatibility maintained
+- [ ] Documentation updated
+- [ ] Version incremented correctly
+- [ ] Edge case marked as resolved in database
+
+## Commands
+
+\`\`\`bash
+# Mark edge case as resolved
+track-edge-case.sh --action update-status \\
+  --edge-case-hash "$edge_case_hash" \\
+  --status "proposal_generated"
+
+# After implementation
+track-edge-case.sh --action update-status \\
+  --edge-case-hash "$edge_case_hash" \\
+  --status "resolved"
+\`\`\`
+SUMMARY
+
+    echo "Generated skill update proposal: $proposal_dir"
+    echo "Review PROPOSAL_SUMMARY.md for details"
+
+    # Update edge case status
+    sqlite3 "$DB_PATH" <<EOF
+UPDATE edge_cases
+SET status = 'proposal_generated'
+WHERE edge_case_hash = '$edge_case_hash';
+EOF
+}
+
+# Main execution
+main() {
+    # Initialize
+    init_proposals_dir
+
+    # Parse arguments
+    local skill_name=""
+    local edge_case_hash=""
+    local occurrence_count=""
+
+    while [[ $# -gt 0 ]]; do
+        case $1 in
+            --skill-name)
+                skill_name="$2"
+                shift 2
+                ;;
+            --edge-case-hash)
+                edge_case_hash="$2"
+                shift 2
+                ;;
+            --occurrence-count)
+                occurrence_count="$2"
+                shift 2
+                ;;
+            --help)
+                cat <<HELP
+Usage: generate-skill-update.sh [OPTIONS]
+
+Options:
+  --skill-name STRING         Skill name (required)
+  --edge-case-hash STRING     Edge case hash (required)
+  --occurrence-count INTEGER  Edge case occurrence count (required)
+
+Environment Variables:
+  DB_PATH                     Path to SQLite database (default: ./workflow-codification.db)
+  PROPOSALS_DIR               Path to proposals directory (default: ./proposals)
+
+Description:
+  Generates comprehensive skill update proposal based on recurring edge case:
+  - Test case (regression test)
+  - Logic modification proposal
+  - Documentation updates
+  - Version increment (semantic versioning)
+
+Output:
+  Creates proposal directory: proposals/{skill_name}_{hash}_v{version}/
+  - PROPOSAL_SUMMARY.md
+  - test_case.md
+  - logic_proposal.md
+  - documentation_update.md
+
+Example:
+  generate-skill-update.sh \\
+    --skill-name "cfn-coordination" \\
+    --edge-case-hash "abc123..." \\
+    --occurrence-count 5
+HELP
+                exit 0
+                ;;
+            *)
+                echo "Unknown argument: $1" >&2
+                exit 1
+                ;;
+        esac
+    done
+
+    # Validate arguments
+    if [[ -z "$skill_name" || -z "$edge_case_hash" || -z "$occurrence_count" ]]; then
+        echo "Error: --skill-name, --edge-case-hash, and --occurrence-count are required" >&2
+        exit 1
+    fi
+
+    # Generate proposal
+    generate_proposal "$skill_name" "$edge_case_hash" "$occurrence_count"
+}
+
+# Execute main if not sourced
+if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then
+    main "$@"
+fi