shipwright-cli 3.1.0 → 3.3.0

package/scripts/lib/process-reward.sh

@@ -0,0 +1,493 @@
+#!/usr/bin/env bash
+# Module guard - prevent double-sourcing
+[[ -n "${_PROCESS_REWARD_LOADED:-}" ]] && return 0
+_PROCESS_REWARD_LOADED=1
+
+# ╔═══════════════════════════════════════════════════════════════════════════╗
+# ║  shipwright process-reward — Per-Step Iteration Scoring (Phase 3)       ║
+# ║  Score each loop iteration on 5 dimensions for dense learning signals   ║
+# ║  Weights: test_progress 30%, code_quality 25%, convergence 20%,         ║
+# ║           architecture 15%, security 10%                                ║
+# ╚═══════════════════════════════════════════════════════════════════════════╝
+
+# shellcheck disable=SC2034
+VERSION="3.3.0"
+
+# ─── Output Helpers ──────────────────────────────────────────────────────────
+[[ "$(type -t info 2>/dev/null)" == "function" ]]    || info()    { echo -e "\033[38;2;0;212;255m\033[1m▸\033[0m $*"; }
+[[ "$(type -t success 2>/dev/null)" == "function" ]] || success() { echo -e "\033[38;2;74;222;128m\033[1m✓\033[0m $*"; }
+[[ "$(type -t warn 2>/dev/null)" == "function" ]]    || warn()    { echo -e "\033[38;2;250;204;21m\033[1m⚠\033[0m $*"; }
+[[ "$(type -t error 2>/dev/null)" == "function" ]]   || error()   { echo -e "\033[38;2;248;113;113m\033[1m✗\033[0m $*" >&2; }
+if [[ "$(type -t now_iso 2>/dev/null)" != "function" ]]; then
+  now_iso()   { date -u +"%Y-%m-%dT%H:%M:%SZ"; }
+  now_epoch() { date +%s; }
+fi
+[[ "$(type -t emit_event 2>/dev/null)" == "function" ]] || emit_event() { true; }
+
+# ─── Configuration ───────────────────────────────────────────────────────────
+
+PROCESS_REWARD_FILE="${PROCESS_REWARD_FILE:-.claude/pipeline-artifacts/process-rewards.jsonl}"
+
+# Dimension weights (must sum to 100)
+REWARD_WEIGHT_TEST="${REWARD_WEIGHT_TEST:-30}"
+REWARD_WEIGHT_CODE="${REWARD_WEIGHT_CODE:-25}"
+REWARD_WEIGHT_CONVERGENCE="${REWARD_WEIGHT_CONVERGENCE:-20}"
+REWARD_WEIGHT_ARCH="${REWARD_WEIGHT_ARCH:-15}"
+REWARD_WEIGHT_SECURITY="${REWARD_WEIGHT_SECURITY:-10}"
+
+# ─── Dimension Scorers ──────────────────────────────────────────────────────
+
+# Score test progress (0-100)
+# Inputs: test_passed (true/false/""), test_output, previous test state
+_reward_score_test_progress() {
+    local test_passed="${1:-}"
+    local test_output="${2:-}"
+    local prev_passed="${3:-}"
+    local score=50  # neutral default
+
+    # No test command — return neutral
+    if [[ -z "$test_passed" ]]; then
+        echo "$score"
+        return 0
+    fi
+
+    if [[ "$test_passed" == "true" ]]; then
+        score=90
+        # Bonus if previously failing
+        if [[ "$prev_passed" == "false" ]]; then
+            score=100
+        fi
+    elif [[ "$test_passed" == "false" ]]; then
+        score=20
+        # Check if test count improved (partial progress)
+        local pass_count=0
+        if [[ -n "$test_output" ]]; then
+            pass_count=$(echo "$test_output" | grep -ciE '(pass|passed|ok|✓)' || true)
+            pass_count="${pass_count:-0}"
+        fi
+        if [[ "$pass_count" -gt 0 ]]; then
+            # Some tests passing — partial credit
+            score=40
+        fi
+        # Previously also failing — at least not regressing
+        if [[ "$prev_passed" == "false" ]]; then
+            score=$(( score + 5 ))
+        fi
+    fi
+
+    echo "$score"
+}
+
+# Score code quality (0-100)
+# Checks: diff size, duplication, complexity indicators
+_reward_score_code_quality() {
+    local project_root="${1:-.}"
+    local score=70  # default: decent
+
+    # Check recent diff for quality signals
+    local diff_text
+    diff_text=$(git -C "$project_root" diff HEAD~1 --unified=0 2>/dev/null || true)
+
+    if [[ -z "$diff_text" ]]; then
+        echo "$score"
+        return 0
+    fi
+
+    # Count additions and deletions
+    local additions deletions
+    additions=$(echo "$diff_text" | grep -c '^+[^+]' || true)
+    additions="${additions:-0}"
+    deletions=$(echo "$diff_text" | grep -c '^-[^-]' || true)
+    deletions="${deletions:-0}"
+
+    # Penalize very large diffs (>500 lines added = likely unfocused)
+    if [[ "$additions" -gt 500 ]]; then
+        score=$(( score - 15 ))
+    elif [[ "$additions" -gt 200 ]]; then
+        score=$(( score - 5 ))
+    fi
+
+    # Reward cleanup (more deletions than additions)
+    if [[ "$deletions" -gt "$additions" ]] && [[ "$additions" -gt 0 ]]; then
+        score=$(( score + 10 ))
+    fi
+
+    # Check for TODO/FIXME/HACK in new code
+    local hack_count
+    hack_count=$(echo "$diff_text" | grep -c '^+.*\(TODO\|FIXME\|HACK\|XXX\)' || true)
+    hack_count="${hack_count:-0}"
+    if [[ "$hack_count" -gt 3 ]]; then
+        score=$(( score - 10 ))
+    elif [[ "$hack_count" -gt 0 ]]; then
+        score=$(( score - 5 ))
+    fi
+
+    # Check for debug/console statements left in
+    local debug_count
+    debug_count=$(echo "$diff_text" | grep -c '^+.*\(console\.log\|debugger\|print(\|echo "DEBUG\)' || true)
+    debug_count="${debug_count:-0}"
+    if [[ "$debug_count" -gt 0 ]]; then
+        score=$(( score - 10 ))
+    fi
+
+    # Clamp 0-100
+    [[ "$score" -lt 0 ]] && score=0
+    [[ "$score" -gt 100 ]] && score=100
+
+    echo "$score"
+}
+
+# Score convergence (0-100)
+# Is the diff getting smaller? Are we approaching the goal?
+_reward_score_convergence() {
+    local iteration="${1:-1}"
+    local project_root="${2:-.}"
+    local reward_file="${3:-$PROCESS_REWARD_FILE}"
+    local score=50  # neutral default
+
+    # First iteration — no history to compare
+    if [[ "$iteration" -le 1 ]]; then
+        echo "60"
+        return 0
+    fi
+
+    # Get current diff stat
+    local current_diff_lines
+    current_diff_lines=$(git -C "$project_root" diff HEAD~1 --stat 2>/dev/null | tail -1 | grep -oE '[0-9]+ insertion|[0-9]+ deletion' | grep -oE '[0-9]+' | head -2 | paste -sd+ - | bc 2>/dev/null || echo "0")
+    current_diff_lines="${current_diff_lines:-0}"
+
+    # Get previous iteration's convergence score from reward history
+    local prev_convergence
+    prev_convergence=$(tail -1 "$reward_file" 2>/dev/null | jq -r '.scores.convergence // 50' 2>/dev/null || echo "50")
+
+    # Smaller diffs = more convergent (likely finishing touches)
+    if [[ "$current_diff_lines" -lt 20 ]]; then
+        score=85
+    elif [[ "$current_diff_lines" -lt 50 ]]; then
+        score=70
+    elif [[ "$current_diff_lines" -lt 100 ]]; then
+        score=55
+    elif [[ "$current_diff_lines" -lt 300 ]]; then
+        score=40
+    else
+        score=25
+    fi
+
+    # Bonus for sustained convergence trend
+    if [[ "$prev_convergence" -ge 70 ]] && [[ "$score" -ge 70 ]]; then
+        score=$(( score + 10 ))
+    fi
+
+    # Clamp 0-100
+    [[ "$score" -gt 100 ]] && score=100
+
+    echo "$score"
+}
+
+# Score architecture adherence (0-100)
+# Check naming, file placement, patterns
+_reward_score_architecture() {
+    local project_root="${1:-.}"
+    local score=80  # default: good
+
+    # Get list of files changed in last commit
+    local changed_files
+    changed_files=$(git -C "$project_root" diff --name-only HEAD~1 2>/dev/null || true)
+
+    if [[ -z "$changed_files" ]]; then
+        echo "$score"
+        return 0
+    fi
+
+    # Check for test files alongside source (good practice)
+    local has_test=false
+    if echo "$changed_files" | grep -qE '(test|spec|_test\.)'; then
+        has_test=true
+        score=$(( score + 10 ))
+    fi
+
+    # Penalize changes to too many directories (unfocused)
+    local dir_count
+    dir_count=$(echo "$changed_files" | sed 's|/[^/]*$||' | sort -u | wc -l | tr -d ' ')
+    dir_count="${dir_count:-0}"
+    if [[ "$dir_count" -gt 10 ]]; then
+        score=$(( score - 15 ))
+    elif [[ "$dir_count" -gt 5 ]]; then
+        score=$(( score - 5 ))
+    fi
+
+    # Check architecture rules file if it exists
+    local repo_hash
+    repo_hash=$(echo -n "$project_root" | shasum -a 256 2>/dev/null | cut -c1-12 || echo "unknown")
+    local arch_file="${HOME}/.shipwright/memory/${repo_hash}/architecture.json"
+    if [[ -f "$arch_file" ]]; then
+        # Check if any rules are violated (simple heuristic: file in wrong layer)
+        local violations
+        violations=$(jq -r '.rules[]? // empty' "$arch_file" 2>/dev/null | wc -l | tr -d ' ')
+        # Having rules is good — we can only check heuristically here
+        score=$(( score + 5 ))
+    fi
+
+    # Clamp 0-100
+    [[ "$score" -lt 0 ]] && score=0
+    [[ "$score" -gt 100 ]] && score=100
+
+    echo "$score"
+}
+
+# Score security (0-100)
+# Grep for obvious issues in new code
+_reward_score_security() {
+    local project_root="${1:-.}"
+    local score=90  # default: no issues
+
+    local diff_text
+    diff_text=$(git -C "$project_root" diff HEAD~1 2>/dev/null || true)
+
+    if [[ -z "$diff_text" ]]; then
+        echo "$score"
+        return 0
+    fi
+
+    # Only check added lines
+    local added_lines
+    added_lines=$(echo "$diff_text" | grep '^+[^+]' || true)
+
+    if [[ -z "$added_lines" ]]; then
+        echo "$score"
+        return 0
+    fi
+
+    # Check for hardcoded secrets patterns
+    local secret_count
+    secret_count=$(echo "$added_lines" | grep -ciE '(password\s*=\s*["\x27][^"\x27]+|api_key\s*=\s*["\x27]|secret\s*=\s*["\x27][^"\x27]+|token\s*=\s*["\x27][A-Za-z0-9])' || true)
+    secret_count="${secret_count:-0}"
+    if [[ "$secret_count" -gt 0 ]]; then
+        score=$(( score - 30 ))
+    fi
+
+    # Check for eval/exec usage
+    local eval_count
+    eval_count=$(echo "$added_lines" | grep -cE '(^|\s)(eval|exec)\s' || true)
+    eval_count="${eval_count:-0}"
+    if [[ "$eval_count" -gt 0 ]]; then
+        score=$(( score - 15 ))
+    fi
+
+    # Check for SQL injection patterns (string concat in queries)
+    local sql_count
+    sql_count=$(echo "$added_lines" | grep -ciE '(query\(.*\+|execute\(.*\+|sql.*\+.*\$)' || true)
+    sql_count="${sql_count:-0}"
+    if [[ "$sql_count" -gt 0 ]]; then
+        score=$(( score - 20 ))
+    fi
+
+    # Check for command injection patterns
+    local cmd_count
+    cmd_count=$(echo "$added_lines" | grep -cE 'system\(\s*\$|`\$|exec\(\s*\$' || true)
+    cmd_count="${cmd_count:-0}"
+    if [[ "$cmd_count" -gt 0 ]]; then
+        score=$(( score - 20 ))
+    fi
+
+    # Clamp 0-100
+    [[ "$score" -lt 0 ]] && score=0
+    [[ "$score" -gt 100 ]] && score=100
+
+    echo "$score"
+}
+
+# ─── Core Functions ──────────────────────────────────────────────────────────
+
+# Score a completed iteration on all 5 dimensions
+# Returns JSON: {"composite":N, "scores":{"test_progress":N,...}}
+process_reward_score_iteration() {
+    local iteration="${1:-1}"
+    local test_passed="${2:-}"
+    local test_output="${3:-}"
+    local prev_test_passed="${4:-}"
+    local project_root="${5:-.}"
+
+    local test_score code_score conv_score arch_score sec_score
+
+    test_score=$(_reward_score_test_progress "$test_passed" "$test_output" "$prev_test_passed")
+    code_score=$(_reward_score_code_quality "$project_root")
+    conv_score=$(_reward_score_convergence "$iteration" "$project_root" "$PROCESS_REWARD_FILE")
+    arch_score=$(_reward_score_architecture "$project_root")
+    sec_score=$(_reward_score_security "$project_root")
+
+    # Weighted composite (integer math — multiply by weight then divide by 100)
+    local composite
+    composite=$(( (test_score * REWARD_WEIGHT_TEST + code_score * REWARD_WEIGHT_CODE + conv_score * REWARD_WEIGHT_CONVERGENCE + arch_score * REWARD_WEIGHT_ARCH + sec_score * REWARD_WEIGHT_SECURITY) / 100 ))
+
+    # Clamp
+    [[ "$composite" -lt 0 ]] && composite=0
+    [[ "$composite" -gt 100 ]] && composite=100
+
+    # Return as JSON
+    printf '{"composite":%d,"scores":{"test_progress":%d,"code_quality":%d,"convergence":%d,"architecture":%d,"security":%d}}' \
+        "$composite" "$test_score" "$code_score" "$conv_score" "$arch_score" "$sec_score"
+}
+
+# Record iteration reward data to JSONL file
+process_reward_record() {
+    local iteration="${1:-1}"
+    local scores_json="${2:-"{}"}"
+    local action_taken="${3:-unknown}"
+    local outcome="${4:-unknown}"
+
+    # Ensure directory exists
+    local reward_dir
+    reward_dir=$(dirname "$PROCESS_REWARD_FILE")
+    mkdir -p "$reward_dir" 2>/dev/null || true
+
+    local timestamp
+    timestamp=$(now_iso)
+
+    # Build record using jq for safe JSON construction
+    local record
+    record=$(jq -c -n \
+        --arg ts "$timestamp" \
+        --argjson iter "$iteration" \
+        --argjson scores "$scores_json" \
+        --arg action "$action_taken" \
+        --arg outcome "$outcome" \
+        '{timestamp: $ts, iteration: $iter, scores: $scores, action: $action, outcome: $outcome}' 2>/dev/null)
+
+    if [[ -z "$record" ]]; then
+        warn "process-reward: failed to build JSON record"
+        return 1
+    fi
+
+    # Atomic write via temp file + mv
+    local tmp_file
+    tmp_file=$(mktemp 2>/dev/null || echo "${TMPDIR:-/tmp}/process-reward-$$.tmp")
+    if [[ -f "$PROCESS_REWARD_FILE" ]]; then
+        cat "$PROCESS_REWARD_FILE" > "$tmp_file"
+    fi
+    echo "$record" >> "$tmp_file"
+    mv "$tmp_file" "$PROCESS_REWARD_FILE"
+
+    emit_event "process_reward.recorded" "iteration=$iteration" "composite=$(echo "$scores_json" | jq -r '.composite // 0' 2>/dev/null || echo 0)"
+}
+
+# Suggest next action based on reward trajectory (last 3 iterations)
+process_reward_suggest_action() {
+    local reward_file="${1:-$PROCESS_REWARD_FILE}"
+
+    if [[ ! -f "$reward_file" ]]; then
+        echo "No reward history yet — proceed with the goal."
+        return 0
+    fi
+
+    local line_count
+    line_count=$(wc -l < "$reward_file" 2>/dev/null | tr -d ' ')
+    line_count="${line_count:-0}"
+
+    if [[ "$line_count" -lt 2 ]]; then
+        echo "Not enough history for suggestions — keep working on the goal."
+        return 0
+    fi
+
+    # Get last 3 records
+    local recent
+    recent=$(tail -3 "$reward_file")
+
+    # Extract composite scores
+    local composites
+    composites=$(echo "$recent" | jq -r '.scores.composite // .composite // 0' 2>/dev/null || true)
+
+    # Extract dimension scores from latest
+    local latest
+    latest=$(echo "$recent" | tail -1)
+    local test_score code_score conv_score
+    test_score=$(echo "$latest" | jq -r '.scores.test_progress // 50' 2>/dev/null || echo "50")
+    code_score=$(echo "$latest" | jq -r '.scores.code_quality // 50' 2>/dev/null || echo "50")
+    conv_score=$(echo "$latest" | jq -r '.scores.convergence // 50' 2>/dev/null || echo "50")
+
+    # Check for declining trend
+    local first_score last_score
+    first_score=$(echo "$composites" | head -1)
+    first_score="${first_score:-50}"
+    last_score=$(echo "$composites" | tail -1)
+    last_score="${last_score:-50}"
+
+    # Decision logic
+    if [[ "$test_score" -le 30 ]]; then
+        echo "Tests are failing badly (score: ${test_score}/100). Focus on making tests pass before anything else."
+        return 0
+    fi
+
+    if [[ "$code_score" -le 40 ]]; then
+        echo "Code quality is low (score: ${code_score}/100). Refactor and clean up before adding more features."
+        return 0
+    fi
+
+    if [[ "$conv_score" -le 30 ]]; then
+        echo "Changes are diverging, not converging (score: ${conv_score}/100). Make smaller, more focused changes."
+        return 0
+    fi
+
+    if [[ "$last_score" -lt "$first_score" ]] && [[ $(( first_score - last_score )) -ge 10 ]]; then
+        echo "Reward trajectory is declining (${first_score} -> ${last_score}). Try a different approach — current strategy is making things worse."
+        return 0
+    fi
+
+    if [[ "$last_score" -ge 80 ]]; then
+        echo "Strong progress (score: ${last_score}/100). Keep the current approach — you're converging well."
+        return 0
+    fi
+
+    echo "Moderate progress (score: ${last_score}/100). Continue working toward the goal."
+}
+
+# Format reward history as markdown for injection into iteration prompts
+process_reward_inject_context() {
+    local reward_file="${1:-$PROCESS_REWARD_FILE}"
+    local max_entries="${2:-5}"
+
+    if [[ ! -f "$reward_file" ]]; then
+        return 0
+    fi
+
+    local line_count
+    line_count=$(wc -l < "$reward_file" 2>/dev/null | tr -d ' ')
+    line_count="${line_count:-0}"
+
+    if [[ "$line_count" -eq 0 ]]; then
+        return 0
+    fi
+
+    local recent
+    recent=$(tail -"$max_entries" "$reward_file")
+
+    local output="## Iteration Rewards (Process Reward Model)
+| Iter | Composite | Test | Quality | Converge | Arch | Security |
+|------|-----------|------|---------|----------|------|----------|"
+
+    local line
+    while IFS= read -r line; do
+        [[ -z "$line" ]] && continue
+        local iter comp ts cs cvs as ss
+        iter=$(echo "$line" | jq -r '.iteration // "?"' 2>/dev/null || echo "?")
+        comp=$(echo "$line" | jq -r '.scores.composite // .composite // "?"' 2>/dev/null || echo "?")
+        ts=$(echo "$line" | jq -r '.scores.test_progress // "?"' 2>/dev/null || echo "?")
+        cs=$(echo "$line" | jq -r '.scores.code_quality // "?"' 2>/dev/null || echo "?")
+        cvs=$(echo "$line" | jq -r '.scores.convergence // "?"' 2>/dev/null || echo "?")
+        as=$(echo "$line" | jq -r '.scores.architecture // "?"' 2>/dev/null || echo "?")
+        ss=$(echo "$line" | jq -r '.scores.security // "?"' 2>/dev/null || echo "?")
+        output="${output}
+| ${iter} | ${comp} | ${ts} | ${cs} | ${cvs} | ${as} | ${ss} |"
+    done <<< "$recent"
+
+    # Add suggestion
+    local suggestion
+    suggestion=$(process_reward_suggest_action "$reward_file")
+    if [[ -n "$suggestion" ]]; then
+        output="${output}
+
+**Reward signal:** ${suggestion}"
+    fi
+
+    echo "$output"
+}