autonomous-coding-toolkit 1.0.0

package/scripts/lib/run-plan-state.sh

@@ -0,0 +1,142 @@
+#!/usr/bin/env bash
+# run-plan-state.sh — Track batch progress in a JSON state file
+#
+# State file: <worktree>/.run-plan-state.json
+# Requires: jq
+#
+# Functions:
+#   init_state <worktree> <plan_file> <mode>           -> create state file
+#   read_state_field <worktree> <field>                 -> read top-level field
+#   complete_batch <worktree> <batch_num> <test_count> [duration]  -> mark batch done
+#   get_previous_test_count <worktree>                  -> last completed batch's test count (0 if none, -1 if missing)
+#   set_quality_gate <worktree> <batch_num> <passed> <test_count> -> record quality gate result
+
+_state_file() {
+    echo "$1/.run-plan-state.json"
+}
+
+init_state() {
+    local worktree="$1" plan_file="$2" mode="$3"
+    local sf
+    sf=$(_state_file "$worktree")
+    local now
+    now=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
+
+    jq -n \
+        --arg plan_file "$plan_file" \
+        --arg mode "$mode" \
+        --arg started_at "$now" \
+        '{
+            plan_file: $plan_file,
+            mode: $mode,
+            current_batch: 1,
+            completed_batches: [],
+            test_counts: {},
+            durations: {},
+            costs: {},
+            total_cost_usd: 0,
+            started_at: $started_at,
+            last_quality_gate: null
+        }' > "$sf"
+}
+
+read_state_field() {
+    local worktree="$1" field="$2"
+    local sf
+    sf=$(_state_file "$worktree")
+    jq -c -r --arg f "$field" '.[$f]' "$sf"
+}
+
+complete_batch() {
+    local worktree="$1" batch_num="$2" test_count="$3" duration="${4:-0}"
+    local sf tmp
+    sf=$(_state_file "$worktree")
+    tmp=$(mktemp)
+
+    # batch_num may be non-numeric (e.g. 'final'), so use --arg and convert in jq.
+    # current_batch is only meaningful for numeric batch sequences — it tracks
+    # the next expected numeric batch. Non-numeric batches (like 'final') are
+    # recorded in completed_batches and test_counts but do not advance current_batch.
+    if [[ "$batch_num" =~ ^[0-9]+$ ]]; then
+        jq \
+            --argjson batch "$batch_num" \
+            --argjson tc "$test_count" \
+            --argjson dur "$duration" \
+            '
+            .completed_batches += [$batch] |
+            .current_batch = ($batch + 1) |
+            .test_counts[($batch | tostring)] = $tc |
+            .durations[($batch | tostring)] = $dur
+            ' "$sf" > "$tmp" && mv "$tmp" "$sf"
+    else
+        jq \
+            --arg batch "$batch_num" \
+            --argjson tc "$test_count" \
+            --argjson dur "$duration" \
+            '
+            .completed_batches += [$batch] |
+            .test_counts[$batch] = $tc |
+            .durations[$batch] = $dur
+            ' "$sf" > "$tmp" && mv "$tmp" "$sf"
+    fi
+}
+
+get_previous_test_count() {
+    local worktree="$1"
+    local sf
+    sf=$(_state_file "$worktree")
+
+    jq -r '
+        if (.completed_batches | length) == 0 then "0"
+        else (.test_counts[(.completed_batches | last | tostring)] // -1) | tostring
+        end
+    ' "$sf"
+}
+
+set_quality_gate() {
+    local worktree="$1" batch_num="$2" passed="$3" test_count="$4"
+    local sf tmp now
+    sf=$(_state_file "$worktree")
+    tmp=$(mktemp)
+    now=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
+
+    # Normalize passed to a JSON boolean so --argjson never receives an
+    # unexpected value (#8). Callers pass "true"/"false" conventionally, but
+    # "1"/"0" or "yes"/"no" would crash jq with --argjson.
+    if [[ "$passed" == "true" || "$passed" == "1" || "$passed" == "yes" ]]; then
+        passed="true"
+    else
+        passed="false"
+    fi
+
+    # batch_num may be non-numeric (e.g. 'final'), so use --arg and convert in jq
+    if [[ "$batch_num" =~ ^[0-9]+$ ]]; then
+        jq \
+            --argjson batch "$batch_num" \
+            --argjson passed "$passed" \
+            --argjson tc "$test_count" \
+            --arg ts "$now" \
+            '
+            .last_quality_gate = {
+                batch: $batch,
+                passed: $passed,
+                test_count: $tc,
+                timestamp: $ts
+            }
+            ' "$sf" > "$tmp" && mv "$tmp" "$sf"
+    else
+        jq \
+            --arg batch "$batch_num" \
+            --argjson passed "$passed" \
+            --argjson tc "$test_count" \
+            --arg ts "$now" \
+            '
+            .last_quality_gate = {
+                batch: $batch,
+                passed: $passed,
+                test_count: $tc,
+                timestamp: $ts
+            }
+            ' "$sf" > "$tmp" && mv "$tmp" "$sf"
+    fi
+}

package/scripts/lib/run-plan-team.sh

@@ -0,0 +1,199 @@
+#!/usr/bin/env bash
+# run-plan-team.sh — Team mode execution with parallel batch groups
+#
+# Analyzes plan dependency graph and executes batches in parallel groups.
+# Each group's batches have all dependencies satisfied by prior groups.
+# Headless version uses parallel `claude -p` processes.
+#
+# Requires sourced: run-plan-parser.sh, run-plan-routing.sh, run-plan-prompt.sh,
+#   run-plan-quality-gate.sh, run-plan-state.sh, run-plan-context.sh, run-plan-scoring.sh
+#
+# Functions:
+#   compute_parallel_groups <dep_graph_json> <start_batch> <end_batch> -> JSON [[1],[2,3],[4]]
+#   run_mode_team  (uses globals: PLAN_FILE, WORKTREE, etc.)
+
+# --- Compute parallel execution groups from dependency graph ---
+# Takes a JSON dependency graph and batch range, returns JSON array of arrays.
+# Each inner array is a group of batches that can run in parallel.
+compute_parallel_groups() {
+    local dep_graph="$1" start_batch="$2" end_batch="$3"
+
+    # Collect all batch numbers in range
+    local batches=()
+    for ((b = start_batch; b <= end_batch; b++)); do
+        batches+=("$b")
+    done
+
+    local completed=""
+    local groups="["
+    local first_group=true
+    local remaining=${#batches[@]}
+
+    while [[ "$remaining" -gt 0 ]]; do
+        local group="["
+        local first_in_group=true
+        local new_completed=""
+        local group_size=0
+
+        for b in "${batches[@]}"; do
+            # Skip already completed
+            [[ "$completed" == *"|$b|"* ]] && continue
+
+            # Check if all deps are satisfied (completed or outside range)
+            local deps
+            deps=$(echo "$dep_graph" | jq -r ".\"$b\"[]" 2>/dev/null || true)
+            local all_met=true
+            while IFS= read -r dep; do
+                [[ -z "$dep" ]] && continue
+                local dep_num=$((dep + 0))
+                # Deps outside our batch range are treated as satisfied
+                if [[ "$dep_num" -ge "$start_batch" && "$dep_num" -le "$end_batch" ]]; then
+                    if [[ "$completed" != *"|$dep|"* ]]; then
+                        all_met=false
+                        break
+                    fi
+                fi
+            done <<< "$deps"
+
+            if [[ "$all_met" == true ]]; then
+                [[ "$first_in_group" != true ]] && group+=","
+                group+="$b"
+                first_in_group=false
+                new_completed+="|$b|"
+                group_size=$((group_size + 1))
+                remaining=$((remaining - 1))
+            fi
+        done
+
+        group+="]"
+        completed+="$new_completed"
+
+        if [[ "$group_size" -gt 0 ]]; then
+            [[ "$first_group" != true ]] && groups+=","
+            groups+="$group"
+            first_group=false
+        else
+            break  # No progress — circular dependency or error
+        fi
+    done
+
+    groups+="]"
+    echo "$groups"
+}
+
+# --- Team mode execution (headless parallel) ---
+run_mode_team() {
+    # WARNING: Team mode uses a shared worktree. Concurrent git operations
+    # (add, commit, stash) from parallel claude processes may conflict and
+    # corrupt the staging area. Each batch in a group runs against the same
+    # filesystem; the batches within a group are independent by design
+    # (no shared files per the dependency graph), but git state is global.
+    # For full isolation, run batches sequentially (headless mode) or ensure
+    # batches in each parallel group touch strictly non-overlapping files.
+    echo "WARNING: Team mode uses a shared worktree. Concurrent git operations may conflict." >&2
+
+    local dep_graph
+    dep_graph=$(build_dependency_graph "$PLAN_FILE")
+
+    local groups
+    groups=$(compute_parallel_groups "$dep_graph" "$START_BATCH" "$END_BATCH")
+    local group_count
+    group_count=$(echo "$groups" | jq 'length')
+
+    mkdir -p "$WORKTREE/logs"
+
+    # Initialize state if not resuming
+    if [[ "$RESUME" != true ]]; then
+        init_state "$WORKTREE" "$PLAN_FILE" "$MODE"
+        if [[ "$START_BATCH" -gt 1 ]]; then
+            for ((b = 1; b < START_BATCH; b++)); do
+                complete_batch "$WORKTREE" "$b" 0
+            done
+        fi
+    fi
+
+    log_routing_decision "$WORKTREE" "MODE" "team mode selected ($group_count groups)"
+
+    for ((g = 0; g < group_count; g++)); do
+        local group_batches
+        group_batches=$(echo "$groups" | jq -r ".[$g][]")
+        local batch_count
+        batch_count=$(echo "$group_batches" | wc -l)
+
+        echo ""
+        echo "================================================================"
+        echo "  Group $((g+1))/$group_count: batches $(echo "$group_batches" | tr '\n' ',' | sed 's/,$//')"
+        echo "  ($batch_count batches in parallel)"
+        echo "================================================================"
+
+        local pids=()
+        local batch_logs=()
+        local batch_list=()
+
+        for batch in $group_batches; do
+            local title
+            title=$(get_batch_title "$PLAN_FILE" "$batch")
+            local model
+            model=$(classify_batch_model "$PLAN_FILE" "$batch")
+            local log_file="$WORKTREE/logs/batch-${batch}-team.log"
+            batch_logs+=("$log_file")
+            batch_list+=("$batch")
+
+            local prev_test_count
+            prev_test_count=$(get_previous_test_count "$WORKTREE")
+
+            local prompt
+            prompt=$(build_batch_prompt "$PLAN_FILE" "$batch" "$WORKTREE" "$PYTHON" "$QUALITY_GATE_CMD" "$prev_test_count")
+
+            log_routing_decision "$WORKTREE" "PARALLEL" "batch $batch ($title) [$model] in group $((g+1))"
+
+            echo "  Starting batch $batch: $title ($model)..."
+            CLAUDECODE='' claude -p "$prompt" \
+                --model "$model" \
+                --allowedTools "Bash,Read,Write,Edit,Grep,Glob" \
+                --permission-mode bypassPermissions \
+                > "$log_file" 2>&1 &
+            pids+=($!)
+        done
+
+        # Wait for all batches in group
+        local all_passed=true
+        for i in "${!pids[@]}"; do
+            local pid=${pids[$i]}
+            local batch=${batch_list[$i]}
+            wait "$pid" || true
+
+            # Run quality gate
+            local gate_exit=0
+            run_quality_gate "$WORKTREE" "$QUALITY_GATE_CMD" "$batch" "0" || gate_exit=$?
+            if [[ $gate_exit -eq 0 ]]; then
+                echo "  Batch $batch PASSED"
+                log_routing_decision "$WORKTREE" "GATE_PASS" "batch $batch passed quality gate"
+            else
+                echo "  Batch $batch FAILED quality gate"
+                log_routing_decision "$WORKTREE" "GATE_FAIL" "batch $batch failed quality gate"
+                all_passed=false
+            fi
+        done
+
+        if [[ "$all_passed" != true ]]; then
+            echo ""
+            echo "Group $((g+1)) had failures. Stopping."
+            exit 1
+        fi
+    done
+
+    echo ""
+    echo "================================================================"
+    echo "  All groups complete ($group_count groups, batches $START_BATCH → $END_BATCH)"
+    echo "================================================================"
+
+    if [[ "$VERIFY" == true ]]; then
+        echo ""
+        echo "Running final verification..."
+        run_quality_gate "$WORKTREE" "$QUALITY_GATE_CMD" "final" || {
+            echo "FINAL VERIFICATION FAILED"
+            exit 1
+        }
+    fi
+}

package/scripts/lib/telegram.sh

@@ -0,0 +1,54 @@
+#!/usr/bin/env bash
+# telegram.sh — Shared Telegram notification helpers
+#
+# Functions:
+#   _load_telegram_env [env_file]  -> load TELEGRAM_BOT_TOKEN and TELEGRAM_CHAT_ID
+#   _send_telegram <message>       -> send via Telegram Bot API
+
+_load_telegram_env() {
+    local env_file="${1:-${ACT_ENV_FILE:-$HOME/.env}}"
+
+    if [[ ! -f "$env_file" ]]; then
+        echo "WARNING: env file not found: $env_file" >&2
+        return 1
+    fi
+
+    # Extract values and strip surrounding single or double quotes (#7).
+    # .env files may store values as TELEGRAM_BOT_TOKEN="abc123" or
+    # TELEGRAM_BOT_TOKEN='abc123' — the cut captures the raw quoted string.
+    TELEGRAM_BOT_TOKEN=$(grep -E '^(export )?TELEGRAM_BOT_TOKEN=' "$env_file" | head -1 | sed 's/^export //' | cut -d= -f2- | sed "s/^['\"]//; s/['\"]$//")
+    TELEGRAM_CHAT_ID=$(grep -E '^(export )?TELEGRAM_CHAT_ID=' "$env_file" | head -1 | sed 's/^export //' | cut -d= -f2- | sed "s/^['\"]//; s/['\"]$//")
+
+    if [[ -z "${TELEGRAM_BOT_TOKEN:-}" || -z "${TELEGRAM_CHAT_ID:-}" ]]; then
+        echo "WARNING: TELEGRAM_BOT_TOKEN or TELEGRAM_CHAT_ID not found in $env_file" >&2
+        return 1
+    fi
+
+    export TELEGRAM_BOT_TOKEN TELEGRAM_CHAT_ID
+}
+
+_send_telegram() {
+    local message="$1"
+
+    if [[ -z "${TELEGRAM_BOT_TOKEN:-}" || -z "${TELEGRAM_CHAT_ID:-}" ]]; then
+        echo "WARNING: Telegram credentials not set — skipping notification" >&2
+        return 0
+    fi
+
+    local url="https://api.telegram.org/bot${TELEGRAM_BOT_TOKEN}/sendMessage"
+
+    local http_code
+    http_code=$(curl -s -o /dev/null -w "%{http_code}" -X POST "$url" \
+        -d chat_id="$TELEGRAM_CHAT_ID" \
+        -d text="$message" \
+        -d parse_mode="Markdown" \
+        --max-time 10 2>/dev/null) || {
+        echo "WARNING: Failed to send Telegram notification (curl error)" >&2
+        return 1
+    }
+
+    if [[ "$http_code" != "200" ]]; then
+        echo "WARNING: Telegram API returned HTTP $http_code" >&2
+        return 1
+    fi
+}

package/scripts/lib/thompson-sampling.sh

@@ -0,0 +1,176 @@
+#!/usr/bin/env bash
+# thompson-sampling.sh — Thompson Sampling for MAB strategy routing
+#
+# Functions:
+#   thompson_sample <wins> <losses>          — Beta approximation, returns float [0,1]
+#   thompson_route <batch_type> <perf_file>  — Returns "superpowers"|"ralph"|"mab"
+#   init_strategy_perf <file>                — Creates JSON with 4 batch types + calibration
+#   update_strategy_perf <file> <batch_type> <winner_strategy>  — Increments counters
+#
+# Routing logic:
+#   - Missing file or < 5 points per strategy → "mab" (compete)
+#   - integration batch type → always "mab" (most variable)
+#   - Win rate spread < 15% → "mab" (too close to call)
+#   - Clear winner (≥70%, 10+ points) → return strategy name
+#   - Otherwise → Thompson sample both, return higher sample
+
+# Thompson sample from Beta(alpha, beta) using Box-Muller approximation.
+# For Beta(a,b) with a,b > 1, a good approximation is:
+#   mean = a/(a+b), variance = ab/((a+b)^2*(a+b+1))
+#   sample ≈ mean + sqrt(variance) * normal_noise
+# Clamped to [0.01, 0.99] to avoid degenerate values.
+#
+# Args: <wins> <losses>
+# Output: float in [0,1]
+thompson_sample() {
+    local wins="${1:-0}" losses="${2:-0}"
+    local alpha=$((wins + 1))
+    local beta=$((losses + 1))
+
+    # Use central limit theorem for a pseudo-normal: sum 12 uniform [0,1), subtract 6 → approx N(0,1).
+    # Seed with bash $RANDOM + PID — PROCINFO["pid"] is gawk-only, mawk silently ignores it,
+    # producing identical samples within the same second (kills Thompson Sampling).
+    local noise
+    noise=$(awk -v seed="$((RANDOM + $$))" 'BEGIN {
+        srand(systime() * 1000 + seed);
+        s = 0;
+        for (i = 0; i < 12; i++) s += rand();
+        printf "%.6f", s - 6;
+    }' 2>/dev/null || echo "0")
+
+    # Compute Beta sample approximation
+    bc -l <<EOF
+scale=6
+a = $alpha
+b = $beta
+mean = a / (a + b)
+var = (a * b) / ((a + b) * (a + b) * (a + b + 1))
+sd = sqrt(var)
+sample = mean + sd * $noise
+if (sample < 0.01) sample = 0.01
+if (sample > 0.99) sample = 0.99
+sample
+EOF
+}
+
+# Route a batch type to a strategy or "mab" (compete).
+#
+# Args: <batch_type> <perf_file>
+# Output: "superpowers" | "ralph" | "mab"
+thompson_route() {
+    local batch_type="$1"
+    local perf_file="$2"
+
+    # Missing file → compete
+    if [[ ! -f "$perf_file" ]]; then
+        echo "mab"
+        return
+    fi
+
+    # Integration → always compete (most variable)
+    if [[ "$batch_type" == "integration" ]]; then
+        echo "mab"
+        return
+    fi
+
+    # Read strategy data
+    local sp_wins sp_losses ralph_wins ralph_losses
+    sp_wins=$(jq -r --arg bt "$batch_type" '.[$bt].superpowers.wins // 0' "$perf_file" 2>/dev/null || echo "0")
+    sp_losses=$(jq -r --arg bt "$batch_type" '.[$bt].superpowers.losses // 0' "$perf_file" 2>/dev/null || echo "0")
+    ralph_wins=$(jq -r --arg bt "$batch_type" '.[$bt].ralph.wins // 0' "$perf_file" 2>/dev/null || echo "0")
+    ralph_losses=$(jq -r --arg bt "$batch_type" '.[$bt].ralph.losses // 0' "$perf_file" 2>/dev/null || echo "0")
+
+    local sp_total=$((sp_wins + sp_losses))
+    local ralph_total=$((ralph_wins + ralph_losses))
+
+    # < 5 data points per strategy → compete
+    if [[ "$sp_total" -lt 5 || "$ralph_total" -lt 5 ]]; then
+        echo "mab"
+        return
+    fi
+
+    # Compute win rates
+    local sp_rate ralph_rate spread
+    sp_rate=$(echo "scale=2; $sp_wins * 100 / $sp_total" | bc -l)
+    ralph_rate=$(echo "scale=2; $ralph_wins * 100 / $ralph_total" | bc -l)
+
+    # Spread check (< 15% → too close)
+    spread=$(echo "scale=2; x=$sp_rate - $ralph_rate; if (x < 0) -x else x" | bc -l)
+    local spread_too_close
+    spread_too_close=$(echo "$spread < 15" | bc -l)
+    if [[ "$spread_too_close" == "1" ]]; then
+        echo "mab"
+        return
+    fi
+
+    # Clear winner check (≥70%, 10+ points)
+    local sp_clear ralph_clear
+    sp_clear=$(echo "$sp_rate >= 70" | bc -l)
+    ralph_clear=$(echo "$ralph_rate >= 70" | bc -l)
+
+    if [[ "$sp_clear" == "1" && "$sp_total" -ge 10 ]]; then
+        echo "superpowers"
+        return
+    fi
+    if [[ "$ralph_clear" == "1" && "$ralph_total" -ge 10 ]]; then
+        echo "ralph"
+        return
+    fi
+
+    # Thompson sample both — higher sample wins
+    local sp_sample ralph_sample
+    sp_sample=$(thompson_sample "$sp_wins" "$sp_losses")
+    ralph_sample=$(thompson_sample "$ralph_wins" "$ralph_losses")
+
+    local sp_higher
+    sp_higher=$(echo "$sp_sample > $ralph_sample" | bc -l)
+    if [[ "$sp_higher" == "1" ]]; then
+        echo "superpowers"
+    else
+        echo "ralph"
+    fi
+}
+
+# Initialize strategy performance file with zero counters.
+#
+# Args: <file>
+init_strategy_perf() {
+    local file="$1"
+    mkdir -p "$(dirname "$file")"
+    cat > "$file" <<'JSON'
+{
+  "new-file": {"superpowers": {"wins": 0, "losses": 0}, "ralph": {"wins": 0, "losses": 0}},
+  "refactoring": {"superpowers": {"wins": 0, "losses": 0}, "ralph": {"wins": 0, "losses": 0}},
+  "integration": {"superpowers": {"wins": 0, "losses": 0}, "ralph": {"wins": 0, "losses": 0}},
+  "test-only": {"superpowers": {"wins": 0, "losses": 0}, "ralph": {"wins": 0, "losses": 0}},
+  "calibration_count": 0,
+  "calibration_complete": false
+}
+JSON
+}
+
+# Update strategy performance after a MAB run.
+# Winner gets +1 win, loser gets +1 loss.
+#
+# Args: <file> <batch_type> <winner_strategy>
+update_strategy_perf() {
+    local file="$1" batch_type="$2" winner="$3"
+
+    if [[ ! -f "$file" ]]; then
+        init_strategy_perf "$file"
+    fi
+
+    local loser
+    if [[ "$winner" == "superpowers" ]]; then
+        loser="ralph"
+    else
+        loser="superpowers"
+    fi
+
+    local tmp
+    tmp=$(mktemp)
+    jq --arg bt "$batch_type" --arg w "$winner" --arg l "$loser" '
+        .[$bt][$w].wins += 1 |
+        .[$bt][$l].losses += 1
+    ' "$file" > "$tmp" && mv "$tmp" "$file"
+}

package/scripts/license-check.sh

@@ -0,0 +1,74 @@
+#!/usr/bin/env bash
+# license-check.sh — Check dependencies for license compatibility
+#
+# Usage: license-check.sh [--project-root <dir>]
+# Flags GPL/AGPL in MIT-licensed projects.
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "$SCRIPT_DIR/lib/common.sh"
+
+PROJECT_ROOT="."
+
+while [[ $# -gt 0 ]]; do
+    case "$1" in
+        --project-root) PROJECT_ROOT="$2"; shift 2 ;;
+        -h|--help)
+            echo "license-check.sh — Check dependency licenses"
+            echo "Usage: license-check.sh [--project-root <dir>]"
+            echo "Flags GPL/AGPL in MIT-licensed projects."
+            exit 0 ;;
+        *) echo "Unknown: $1" >&2; exit 1 ;;
+    esac
+done
+
+cd "$PROJECT_ROOT"
+project_type=$(detect_project_type ".")
+
+echo "=== License Check ==="
+violations=0
+
+case "$project_type" in
+    python)
+        if [[ -d ".venv" ]] && command -v pip-licenses >/dev/null 2>&1; then
+            echo "Checking Python dependencies..."
+            gpl_deps=$(.venv/bin/python -m pip-licenses --format=csv 2>/dev/null | grep -iE 'GPL|AGPL' | grep -v 'LGPL' || true)
+            if [[ -n "$gpl_deps" ]]; then
+                echo "WARNING: GPL/AGPL dependencies found:"
+                echo "$gpl_deps" | sed 's/^/  /'
+                violations=$((violations + 1))
+            else
+                echo "  No GPL/AGPL dependencies"
+            fi
+        else
+            echo "  pip-licenses not available — skipping"
+        fi
+        ;;
+    node)
+        if command -v npx >/dev/null 2>&1; then
+            echo "Checking Node dependencies..."
+            gpl_deps=$(npx license-checker --csv 2>/dev/null | grep -iE 'GPL|AGPL' | grep -v 'LGPL' || true)
+            if [[ -n "$gpl_deps" ]]; then
+                echo "WARNING: GPL/AGPL dependencies found:"
+                echo "$gpl_deps" | head -10 | sed 's/^/  /'
+                violations=$((violations + 1))
+            else
+                echo "  No GPL/AGPL dependencies"
+            fi
+        else
+            echo "  license-checker not available — skipping"
+        fi
+        ;;
+    *)
+        echo "  No license check for project type: $project_type"
+        ;;
+esac
+
+if [[ $violations -gt 0 ]]; then
+    echo ""
+    echo "license-check: $violations issue(s) found"
+    exit 1
+fi
+
+echo "license-check: CLEAN"
+exit 0