# integration

> set -euo pipefail

- Author: Test User
- Repository: masharratt/claude-flow-novice
- Version: 20260115120224
- Stars: 14
- Forks: 0
- Last Updated: 2026-02-07
- Source: https://github.com/masharratt/claude-flow-novice
- Web: https://mule.run/skillshub/@@masharratt/claude-flow-novice~integration:20260115120224

---

#!/bin/bash

# cfn-task-intelligence.sh
# Task Intelligence Integration Layer for CFN Loop Orchestration

set -euo pipefail

# Configuration
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
DB_PATH="${SCRIPT_DIR}/../cfn-memory-persistence/task_intelligence.db"
LOG_FILE="${SCRIPT_DIR}/task_intelligence.log"

# Initialize database
init_database() {
    mkdir -p "$(dirname "$DB_PATH")"
    sqlite3 "$DB_PATH" <<EOF
CREATE TABLE IF NOT EXISTS task_classifications (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    task_hash TEXT UNIQUE,
    description TEXT,
    category TEXT,
    subcategories TEXT,
    recommended_agents TEXT,
    confidence REAL,
    created_at DATETIME DEFAULT CURRENT_TIMESTAMP
);

CREATE TABLE IF NOT EXISTS complexity_estimates (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    task_hash TEXT,
    estimated_iterations INTEGER,
    confidence REAL,
    factors TEXT,
    mode TEXT,
    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
    FOREIGN KEY (task_hash) REFERENCES task_classifications(task_hash)
);

CREATE TABLE IF NOT EXISTS specialist_recommendations (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    loop3_agents TEXT,
    feedback_themes TEXT,
    recurring_count INTEGER,
    recommended_specialist TEXT,
    reasoning TEXT,
    created_at DATETIME DEFAULT CURRENT_TIMESTAMP
);

CREATE TABLE IF NOT EXISTS execution_outcomes (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    task_hash TEXT,
    actual_iterations INTEGER,
    success BOOLEAN,
    agents_used TEXT,
    specialists_added TEXT,
    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
    FOREIGN KEY (task_hash) REFERENCES task_classifications(task_hash)
);
EOF
}

# Logging function
log() {
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $*" | tee -a "$LOG_FILE"
}

# Generate task hash
generate_task_hash() {
    local description="$1"
    echo -n "$description" | sha256sum | cut -d' ' -f1
}

# Classify task
classify_task() {
    local description="$1"
    local task_hash
    task_hash=$(generate_task_hash "$description")
    
    # Check cache first
    local cached_result
    cached_result=$(sqlite3 "$DB_PATH" "SELECT category, subcategories, recommended_agents, confidence FROM task_classifications WHERE task_hash='$task_hash'" 2>/dev/null || echo "")
    
    if [[ -n "$cached_result" ]]; then
        IFS='|' read -r category subcategories agents confidence <<< "$cached_result"
        echo "{\"category\":\"$category\",\"subcategories\":[$subcategories],\"recommended_agents\":[$agents],\"confidence\":$confidence}"
        return
    fi
    
    # Classification logic
    local category="general"
    local subcategories="[]"
    local agents="[]"
    local confidence=0.5
    
    if [[ "$description" =~ (frontend|ui|ux|interface|component) ]]; then
        category="frontend"
        subcategories='["ui","state-management"]'
        agents='["frontend-developer","ui-ux-designer"]'
        confidence=0.85
    elif [[ "$description" =~ (backend|api|server|database|service) ]]; then
        category="backend"
        subcategories='["api","data-layer"]'
        agents='["backend-developer","database-administrator"]'
        confidence=0.82
    elif [[ "$description" =~ (security|auth|authentication|authorization|encryption) ]]; then
        category="security"
        subcategories='["authentication","authorization"]'
        agents='["security-specialist","backend-developer"]'
        confidence=0.88
    elif [[ "$description" =~ (performance|optimization|speed|latency|cache) ]]; then
        category="performance"
        subcategories='["optimization","monitoring"]'
        agents='["performance-engineer","backend-developer"]'
        confidence=0.80
    elif [[ "$description" =~ (test|testing|quality|assurance|qa) ]]; then
        category="testing"
        subcategories='["unit-testing","integration-testing"]'
        agents='["qa-engineer","test-automation-specialist"]'
        confidence=0.83
    fi
    
    # Cache result
    sqlite3 "$DB_PATH" "INSERT OR REPLACE INTO task_classifications (task_hash, description, category, subcategories, recommended_agents, confidence) VALUES ('$task_hash', '$(echo "$description" | sed "s/'/''/g")', '$category', '$subcategories', '$agents', $confidence)"
    
    echo "{\"category\":\"$category\",\"subcategories\":$subcategories,\"recommended_agents\":$agents,\"confidence\":$confidence}"
}

# Estimate complexity
estimate_complexity() {
    local description="$1"
    local task_hash
    task_hash=$(generate_task_hash "$description")
    
    # Check cache
    local cached_result
    cached_result=$(sqlite3 "$DB_PATH" "SELECT estimated_iterations, confidence, factors, mode FROM complexity_estimates WHERE task_hash='$task_hash'" 2>/dev/null || echo "")
    
    if [[ -n "$cached_result" ]]; then
        IFS='|' read -r iterations confidence factors mode <<< "$cached_result"
        echo "{\"estimated_iterations\":$iterations,\"confidence\":$confidence,\"factors\":[$factors],\"mode\":\"$mode\"}"
        return
    fi
    
    # Complexity estimation logic
    local iterations=3
    local confidence=0.7
    local factors="[]"
    local mode="standard"
    
    # Analyze factors
    local factor_list=()
    
    if [[ "$description" =~ (new|novel|first-time|initial) ]]; then
        ((iterations += 2))
        factor_list+=('"new-feature"')
        confidence=$(echo "$confidence - 0.1" | bc)
    fi
    
    if [[ "$description" =~ (cross|multiple|several|different) ]]; then
        ((iterations += 1))
        factor_list+=('"cross-component"')
        confidence=$(echo "$confidence - 0.05" | bc)
    fi
    
    if [[ "$description" =~ (test|testing|validate|verify) ]]; then
        ((iterations += 1))
        factor_list+=('"testing-required"')
    fi
    
    if [[ "$description" =~ (complex|difficult|challenging|advanced) ]]; then
        ((iterations += 2))
        factor_list+=('"high-complexity"')
        confidence=$(echo "$confidence - 0.1" | bc)
    fi
    
    if [[ "$description" =~ (urgent|critical|immediate) ]]; then
        mode="fast-track"
        iterations=$((iterations / 2 + 1))
    fi
    
    # Ensure minimum iterations
    if [[ $iterations -lt 2 ]]; then
        iterations=2
    fi
    
    # Ensure maximum iterations
    if [[ $iterations -gt 10 ]]; then
        iterations=10
    fi
    
    # Format factors
    if [[ ${#factor_list[@]} -gt 0 ]]; then
        factors=$(IFS=,; echo "${factor_list[*]}")
    fi
    
    # Cache result
    sqlite3 "$DB_PATH" "INSERT OR REPLACE INTO complexity_estimates (task_hash, estimated_iterations, confidence, factors, mode) VALUES ('$task_hash', $iterations, $confidence, '[$factors]', '$mode')"
    
    echo "{\"estimated_iterations\":$iterations,\"confidence\":$confidence,\"factors\":[$factors],\"mode\":\"$mode\"}"
}

# Recommend specialist
recommend_specialist() {
    local current_loop3="$1"
    local feedback_themes="$2"
    local recurring_count="$3"
    
    local specialist=""
    local reasoning=""
    local new_agents="$current_loop3"
    
    # Analyze feedback themes
    if [[ "$feedback_themes" =~ (security|auth|authentication|authorization) ]] && [[ $recurring_count -ge 3 ]]; then
        specialist="security-specialist"
        reasoning="Recurring feedback themes: security, authentication. Added as number of occurrences reached required threshold."
        if [[ ! "$current_loop3" =~ security-specialist ]]; then
            new_agents="$current_loop3,security-specialist"
        fi
    elif [[ "$feedback_themes" =~ (performance|optimization|speed|latency) ]] && [[ $recurring_count -ge 3 ]]; then
        specialist="performance-engineer"
        reasoning="Recurring feedback themes: performance, optimization. Added as number of occurrences reached required threshold."
        if [[ ! "$current_loop3" =~ performance-engineer ]]; then
            new_agents="$current_loop3,performance-engineer"
        fi
    elif [[ "$feedback_themes" =~ (test|testing|quality|assurance) ]] && [[ $recurring_count -ge 3 ]]; then
        specialist="qa-engineer"
        reasoning="Recurring feedback themes: testing, quality assurance. Added as number of occurrences reached required threshold."
        if [[ ! "$current_loop3" =~ qa-engineer ]]; then
            new_agents="$current_loop3,qa-engineer"
        fi
    elif [[ "$feedback_themes" =~ (ui|ux|design|interface) ]] && [[ $recurring_count -ge 3 ]]; then
        specialist="ui-ux-designer"
        reasoning="Recurring feedback themes: UI/UX, design. Added as number of occurrences reached required threshold."
        if [[ ! "$current_loop3" =~ ui-ux-designer ]]; then
            new_agents="$current_loop3,ui-ux-designer"
        fi
    fi
    
    # Store recommendation
    sqlite3 "$DB_PATH" "INSERT INTO specialist_recommendations (loop3_agents, feedback_themes, recurring_count, recommended_specialist, reasoning) VALUES ('$current_loop3', '$feedback_themes', $recurring_count, '$specialist', '$(echo "$reasoning" | sed "s/'/''/g")')"
    
    # Format new agents as array
    local agents_array="[\"$(echo "$new_agents" | sed 's/,/","/g')\"]"
    
    echo "{\"add_specialist\":\"$specialist\",\"reasoning\":\"$reasoning\",\"new_loop3_agents\":$agents_array}"
}

# Full analysis
full_analysis() {
    local description="$1"
    
    local classification
    classification=$(classify_task "$description")
    
    local complexity
    complexity=$(estimate_complexity "$description")
    
    echo "{\"classification\":$classification,\"complexity\":$complexity}"
}

# Main execution
main() {
    init_database
    
    local mode=""
    local task_description=""
    local current_loop3=""
    local feedback_themes=""
    local recurring_count=0
    
    # Parse arguments
    while [[ $# -gt 0 ]]; do
        case $1 in
            --mode)
                mode="$2"
                shift 2
                ;;
            --task-description)
                task_description="$2"
                shift 2
                ;;
            --current-loop3)
                current_loop3="$2"
                shift 2
                ;;
            --feedback-themes)
                feedback_themes="$2"
                shift 2
                ;;
            --recurring-count)
                recurring_count="$2"
                shift 2
                ;;
            *)
                log "Unknown option: $1"
                exit 1
                ;;
        esac
    done
    
    # Execute based on mode
    case "$mode" in
        classify)
            if [[ -z "$task_description" ]]; then
                log "Error: --task-description required for classify mode"
                exit 1
            fi
            classify_task "$task_description"
            ;;
        complexity)
            if [[ -z "$task_description" ]]; then
                log "Error: --task-description required for complexity mode"
                exit 1
            fi
            estimate_complexity "$task_description"
            ;;
        specialist)
            if [[ -z "$current_loop3" || -z "$feedback_themes" ]]; then
                log "Error: --current-loop3 and --feedback-themes required for specialist mode"
                exit 1
            fi
            recommend_specialist "$current_loop3" "$feedback_themes" "$recurring_count"
            ;;
        all)
            if [[ -z "$task_description" ]]; then
                log "Error: --task-description required for all mode"
                exit 1
            fi
            full_analysis "$task_description"
            ;;
        *)
            log "Error: Invalid mode. Use classify, complexity, specialist, or all"
            exit 1
            ;;
    esac
}

# Execute main function
main "$@"