shipwright-cli 3.0.0 → 3.1.0

package/scripts/lib/decide-autonomy.sh

@@ -0,0 +1,295 @@
+# decide-autonomy.sh — Tier enforcement & rate limiting for the decision engine
+# Source from sw-decide.sh. Requires helpers.sh, policy.sh.
+[[ -n "${_DECIDE_AUTONOMY_LOADED:-}" ]] && return 0
+_DECIDE_AUTONOMY_LOADED=1
+
+# ─── State ────────────────────────────────────────────────────────────────────
+DECISIONS_DIR="${HOME}/.shipwright/decisions"
+HALT_FILE="${DECISIONS_DIR}/halt.json"
+LAST_DECISION_FILE="${DECISIONS_DIR}/last-decision.json"
+OUTCOMES_FILE="${DECISIONS_DIR}/outcomes.jsonl"
+
+_ensure_decisions_dir() {
+    mkdir -p "$DECISIONS_DIR"
+}
+
+_daily_log_file() {
+    echo "${DECISIONS_DIR}/daily-log-$(date -u +%Y-%m-%d).jsonl"
+}
+
+# ─── Tier Configuration ──────────────────────────────────────────────────────
+
+TIERS_DATA=""
+CATEGORY_RULES=""
+TIER_LIMITS=""
+
+autonomy_load_tiers() {
+    local tiers_path="${TIERS_FILE:-}"
+    if [[ -z "$tiers_path" ]]; then
+        # Try repo-relative, then policy
+        local repo_dir="${_REPO_DIR:-$(git rev-parse --show-toplevel 2>/dev/null || echo '.')}"
+        tiers_path="${repo_dir}/config/decision-tiers.json"
+        if [[ ! -f "$tiers_path" ]]; then
+            tiers_path=$(policy_get ".decision.tiers_file" "config/decision-tiers.json")
+            [[ "$tiers_path" != /* ]] && tiers_path="${repo_dir}/${tiers_path}"
+        fi
+    fi
+
+    if [[ ! -f "$tiers_path" ]]; then
+        return 1
+    fi
+
+    TIERS_FILE="$tiers_path"
+    TIERS_DATA=$(cat "$tiers_path")
+    CATEGORY_RULES=$(echo "$TIERS_DATA" | jq -c '.category_rules // {}')
+    TIER_LIMITS=$(echo "$TIERS_DATA" | jq -c '.limits // {}')
+    return 0
+}
+
+# ─── Tier Resolution ─────────────────────────────────────────────────────────
+
+autonomy_resolve_tier() {
+    local category="$1"
+    if [[ -z "$CATEGORY_RULES" ]]; then
+        echo "draft"
+        return
+    fi
+    local tier
+    tier=$(echo "$CATEGORY_RULES" | jq -r --arg cat "$category" '.[$cat].tier // "draft"')
+    echo "${tier:-draft}"
+}
+
+autonomy_get_labels() {
+    local tier="$1"
+    if [[ -z "$TIERS_DATA" ]]; then
+        echo ""
+        return
+    fi
+    echo "$TIERS_DATA" | jq -r --arg t "$tier" '.tiers[$t].labels // [] | join(",")'
+}
+
+autonomy_get_template() {
+    local tier="$1"
+    if [[ -z "$TIERS_DATA" ]]; then
+        echo "standard"
+        return
+    fi
+    local tmpl
+    tmpl=$(echo "$TIERS_DATA" | jq -r --arg t "$tier" '.tiers[$t].pipeline_template // "standard"')
+    [[ "$tmpl" == "null" ]] && tmpl=""
+    echo "$tmpl"
+}
+
+# ─── Budget Checks ───────────────────────────────────────────────────────────
+
+autonomy_check_budget() {
+    local tier="$1"
+    _ensure_decisions_dir
+
+    local daily_log
+    daily_log=$(_daily_log_file)
+
+    # Count today's issues created
+    local today_count=0
+    if [[ -f "$daily_log" ]]; then
+        today_count=$(jq -s '[.[] | select(.action == "issue_created" or .action == "draft_written")] | length' "$daily_log" 2>/dev/null || echo "0")
+    fi
+
+    local max_issues
+    max_issues=$(echo "${TIER_LIMITS:-{}}" | jq -r '.max_issues_per_day // 15')
+
+    if [[ "$today_count" -ge "$max_issues" ]]; then
+        return 1
+    fi
+
+    # Check cost budget
+    local max_cost
+    max_cost=$(echo "${TIER_LIMITS:-{}}" | jq -r '.max_cost_per_day_usd // 25')
+    local today_cost=0
+    if [[ -f "$daily_log" ]]; then
+        today_cost=$(jq -s '[.[] | .estimated_cost_usd // 0] | add // 0' "$daily_log" 2>/dev/null || echo "0")
+    fi
+
+    # Only check cost for auto tier (propose/draft are cheap)
+    if [[ "$tier" == "auto" ]]; then
+        local cost_exceeded
+        cost_exceeded=$(echo "$today_cost $max_cost" | awk '{print ($1 >= $2) ? "true" : "false"}')
+        if [[ "$cost_exceeded" == "true" ]]; then
+            return 1
+        fi
+    fi
+
+    return 0
+}
+
+# ─── Rate Limiting ────────────────────────────────────────────────────────────
+
+autonomy_check_rate_limit() {
+    [[ ! -f "$LAST_DECISION_FILE" ]] && return 0
+
+    local last_epoch
+    last_epoch=$(jq -r '.epoch // 0' "$LAST_DECISION_FILE" 2>/dev/null || echo "0")
+    local now_e
+    now_e=$(now_epoch)
+
+    local cooldown
+    cooldown=$(echo "${TIER_LIMITS:-{}}" | jq -r '.cooldown_seconds // 300')
+
+    local elapsed=$((now_e - last_epoch))
+    if [[ "$elapsed" -lt "$cooldown" ]]; then
+        return 1
+    fi
+    return 0
+}
+
+# ─── Halt Management ─────────────────────────────────────────────────────────
+
+autonomy_check_halt() {
+    [[ -f "$HALT_FILE" ]] && return 1
+    return 0
+}
+
+autonomy_halt() {
+    _ensure_decisions_dir
+    local reason="${1:-manual halt}"
+    local tmp
+    tmp=$(mktemp)
+    jq -n --arg reason "$reason" --arg ts "$(now_iso)" --argjson epoch "$(now_epoch)" \
+        '{halted: true, reason: $reason, halted_at: $ts, epoch: $epoch}' > "$tmp" && mv "$tmp" "$HALT_FILE"
+    emit_event "decision.halted" "reason=$reason"
+}
+
+autonomy_resume() {
+    if [[ -f "$HALT_FILE" ]]; then
+        rm -f "$HALT_FILE"
+        emit_event "decision.resumed"
+    fi
+}
+
+# ─── Consecutive Failure Tracking ─────────────────────────────────────────────
+
+autonomy_check_consecutive_failures() {
+    _ensure_decisions_dir
+    local daily_log
+    daily_log=$(_daily_log_file)
+    [[ ! -f "$daily_log" ]] && return 0
+
+    local max_consecutive
+    max_consecutive=$(echo "${TIER_LIMITS:-{}}" | jq -r '.halt_after_consecutive_failures // 3')
+
+    # Get the last N decisions and check if all failed
+    local recent
+    recent=$(jq -s --argjson n "$max_consecutive" '. | reverse | .[:$n]' "$daily_log" 2>/dev/null || echo '[]')
+    local count
+    count=$(echo "$recent" | jq 'length' 2>/dev/null || echo "0")
+    [[ "$count" -lt "$max_consecutive" ]] && return 0
+
+    local all_failed
+    all_failed=$(echo "$recent" | jq --argjson n "$max_consecutive" \
+        '[.[] | select(.outcome == "failure")] | length == $n' 2>/dev/null || echo "false")
+
+    if [[ "$all_failed" == "true" ]]; then
+        autonomy_halt "Halted: ${max_consecutive} consecutive failures"
+        return 1
+    fi
+    return 0
+}
+
+# ─── Risk Ceiling ─────────────────────────────────────────────────────────────
+
+autonomy_check_risk_ceiling() {
+    local category="$1"
+    local risk_score="$2"
+    [[ -z "$CATEGORY_RULES" ]] && return 0
+
+    local ceiling
+    ceiling=$(echo "$CATEGORY_RULES" | jq -r --arg cat "$category" '.[$cat].risk_ceiling // 100')
+
+    if [[ "$risk_score" -gt "$ceiling" ]]; then
+        return 1
+    fi
+    return 0
+}
+
+# ─── Decision Recording ──────────────────────────────────────────────────────
+
+autonomy_record_decision() {
+    local decision_json="$1"
+    _ensure_decisions_dir
+
+    local daily_log
+    daily_log=$(_daily_log_file)
+
+    # Append to daily log (atomic via tmp + append)
+    echo "$decision_json" >> "$daily_log"
+
+    # Update last-decision pointer
+    local tmp
+    tmp=$(mktemp)
+    echo "$decision_json" | jq '. + {epoch: (now | floor)}' > "$tmp" && mv "$tmp" "$LAST_DECISION_FILE"
+
+    # Rotate old daily logs (keep 30 days)
+    find "$DECISIONS_DIR" -name "daily-log-*.jsonl" -mtime +30 -delete 2>/dev/null || true
+}
+
+autonomy_record_outcome() {
+    local decision_id="$1"
+    local result="$2"
+    local detail="${3:-}"
+    _ensure_decisions_dir
+
+    local outcome
+    outcome=$(jq -n \
+        --arg id "$decision_id" \
+        --arg result "$result" \
+        --arg detail "$detail" \
+        --arg ts "$(now_iso)" \
+        '{decision_id: $id, result: $result, detail: $detail, recorded_at: $ts}')
+
+    echo "$outcome" >> "$OUTCOMES_FILE"
+
+    # Update daily log entry with outcome
+    local daily_log
+    daily_log=$(_daily_log_file)
+    if [[ -f "$daily_log" ]]; then
+        local tmp
+        tmp=$(mktemp)
+        jq --arg id "$decision_id" --arg res "$result" \
+            'if .id == $id then . + {outcome: $res} else . end' \
+            "$daily_log" > "$tmp" && mv "$tmp" "$daily_log" || rm -f "$tmp"
+    fi
+}
+
+# ─── Daily Summary ────────────────────────────────────────────────────────────
+
+autonomy_daily_summary() {
+    _ensure_decisions_dir
+    local daily_log
+    daily_log=$(_daily_log_file)
+
+    if [[ ! -f "$daily_log" ]]; then
+        jq -n '{date: (now | strftime("%Y-%m-%d")), total: 0, auto: 0, propose: 0, draft: 0, budget_remaining: {issues: 15, cost_usd: 25}}'
+        return
+    fi
+
+    local max_issues max_cost
+    max_issues=$(echo "${TIER_LIMITS:-{}}" | jq -r '.max_issues_per_day // 15')
+    max_cost=$(echo "${TIER_LIMITS:-{}}" | jq -r '.max_cost_per_day_usd // 25')
+
+    jq -s --argjson mi "$max_issues" --arg mc "$max_cost" '
+        {
+            date: (now | strftime("%Y-%m-%d")),
+            total: length,
+            auto: [.[] | select(.tier == "auto")] | length,
+            propose: [.[] | select(.tier == "propose")] | length,
+            draft: [.[] | select(.tier == "draft")] | length,
+            successes: [.[] | select(.outcome == "success")] | length,
+            failures: [.[] | select(.outcome == "failure")] | length,
+            budget_remaining: {
+                issues: ($mi - length),
+                cost_usd: ($mc - ([.[] | .estimated_cost_usd // 0] | add // 0))
+            },
+            halted: false
+        }
+    ' "$daily_log" 2>/dev/null || echo '{}'
+}

package/scripts/lib/decide-scoring.sh

@@ -0,0 +1,228 @@
+# decide-scoring.sh — Value scoring for the decision engine
+# Source from sw-decide.sh. Requires helpers.sh.
+[[ -n "${_DECIDE_SCORING_LOADED:-}" ]] && return 0
+_DECIDE_SCORING_LOADED=1
+
+# ─── State ────────────────────────────────────────────────────────────────────
+WEIGHTS_FILE="${HOME}/.shipwright/decisions/weights.json"
+
+# Default weights
+_W_IMPACT=30
+_W_URGENCY=25
+_W_EFFORT=20
+_W_CONFIDENCE=15
+_W_RISK=10
+
+# ─── Weight Management ───────────────────────────────────────────────────────
+
+scoring_load_weights() {
+    if [[ -f "$WEIGHTS_FILE" ]]; then
+        _W_IMPACT=$(jq -r '.impact // 30' "$WEIGHTS_FILE" 2>/dev/null || echo "30")
+        _W_URGENCY=$(jq -r '.urgency // 25' "$WEIGHTS_FILE" 2>/dev/null || echo "25")
+        _W_EFFORT=$(jq -r '.effort // 20' "$WEIGHTS_FILE" 2>/dev/null || echo "20")
+        _W_CONFIDENCE=$(jq -r '.confidence // 15' "$WEIGHTS_FILE" 2>/dev/null || echo "15")
+        _W_RISK=$(jq -r '.risk // 10' "$WEIGHTS_FILE" 2>/dev/null || echo "10")
+    fi
+
+    # Also try loading from tiers config
+    if [[ -n "${TIERS_FILE:-}" && -f "${TIERS_FILE:-}" ]]; then
+        local cfg_impact
+        cfg_impact=$(jq -r '.scoring_weights.impact // empty' "$TIERS_FILE" 2>/dev/null || true)
+        if [[ -n "$cfg_impact" ]]; then
+            _W_IMPACT=$(echo "$cfg_impact" | awk '{printf "%.0f", $1 * 100}')
+            _W_URGENCY=$(jq -r '.scoring_weights.urgency' "$TIERS_FILE" | awk '{printf "%.0f", $1 * 100}')
+            _W_EFFORT=$(jq -r '.scoring_weights.effort' "$TIERS_FILE" | awk '{printf "%.0f", $1 * 100}')
+            _W_CONFIDENCE=$(jq -r '.scoring_weights.confidence' "$TIERS_FILE" | awk '{printf "%.0f", $1 * 100}')
+            _W_RISK=$(jq -r '.scoring_weights.risk' "$TIERS_FILE" | awk '{printf "%.0f", $1 * 100}')
+        fi
+    fi
+}
+
+scoring_save_weights() {
+    mkdir -p "$(dirname "$WEIGHTS_FILE")"
+    local tmp
+    tmp=$(mktemp)
+    jq -n \
+        --argjson i "$_W_IMPACT" \
+        --argjson u "$_W_URGENCY" \
+        --argjson e "$_W_EFFORT" \
+        --argjson c "$_W_CONFIDENCE" \
+        --argjson r "$_W_RISK" \
+        --arg ts "$(now_iso)" \
+        '{impact:$i, urgency:$u, effort:$e, confidence:$c, risk:$r, updated_at:$ts}' \
+        > "$tmp" && mv "$tmp" "$WEIGHTS_FILE"
+}
+
+# ─── Dimension Scorers ────────────────────────────────────────────────────────
+# Each returns 0-100
+
+_score_impact() {
+    local candidate="$1"
+    local signal category risk_score
+    signal=$(echo "$candidate" | jq -r '.signal // "unknown"')
+    category=$(echo "$candidate" | jq -r '.category // "unknown"')
+    risk_score=$(echo "$candidate" | jq -r '.risk_score // 50')
+
+    case "$signal" in
+        security)
+            local severity
+            severity=$(echo "$candidate" | jq -r '.evidence.severity // "medium"')
+            case "$severity" in
+                critical) echo 90 ;; high) echo 70 ;; medium) echo 50 ;; *) echo 30 ;;
+            esac ;;
+        deps)
+            local diff
+            diff=$(echo "$candidate" | jq -r '.evidence.major_versions_behind // 1')
+            if [[ "${diff:-1}" -ge 3 ]]; then echo 70
+            elif [[ "${diff:-1}" -ge 2 ]]; then echo 55
+            else echo 35; fi ;;
+        coverage)  echo 45 ;;
+        docs)      echo 30 ;;
+        dead_code) echo 25 ;;
+        performance)
+            local pct
+            pct=$(echo "$candidate" | jq -r '.evidence.regression_pct // 0')
+            if [[ "${pct:-0}" -ge 50 ]]; then echo 75
+            elif [[ "${pct:-0}" -ge 30 ]]; then echo 60
+            else echo 40; fi ;;
+        failures)  echo 55 ;;
+        dora)      echo 60 ;;
+        architecture) echo 50 ;;
+        intelligence) echo 45 ;;
+        *) echo 40 ;;
+    esac
+}
+
+_score_urgency() {
+    local candidate="$1"
+    local signal
+    signal=$(echo "$candidate" | jq -r '.signal // "unknown"')
+
+    case "$signal" in
+        security)
+            local severity
+            severity=$(echo "$candidate" | jq -r '.evidence.severity // "medium"')
+            case "$severity" in
+                critical) echo 95 ;; high) echo 75 ;; *) echo 45 ;;
+            esac ;;
+        performance) echo 60 ;;
+        dora)        echo 55 ;;
+        failures)    echo 65 ;;
+        deps)        echo 35 ;;
+        coverage)    echo 30 ;;
+        docs)        echo 20 ;;
+        dead_code)   echo 15 ;;
+        *)           echo 40 ;;
+    esac
+}
+
+_score_effort() {
+    # Inverted: easy = high score, hard = low score
+    local candidate="$1"
+    local category
+    category=$(echo "$candidate" | jq -r '.category // "unknown"')
+
+    case "$category" in
+        deps_patch)             echo 90 ;;
+        deps_minor)             echo 75 ;;
+        doc_sync)               echo 85 ;;
+        dead_code)              echo 70 ;;
+        test_coverage)          echo 60 ;;
+        security_patch)         echo 65 ;;
+        deps_major)             echo 40 ;;
+        security_critical)      echo 45 ;;
+        performance_regression) echo 35 ;;
+        recurring_failure)      echo 30 ;;
+        refactor_hotspot)       echo 25 ;;
+        architecture_drift)     echo 20 ;;
+        dora_regression)        echo 30 ;;
+        *)                      echo 50 ;;
+    esac
+}
+
+_score_confidence() {
+    local candidate="$1"
+    local raw_conf
+    raw_conf=$(echo "$candidate" | jq -r '.confidence // "0.80"')
+    # Convert 0.0-1.0 to 0-100
+    echo "$raw_conf" | awk '{printf "%.0f", $1 * 100}'
+}
+
+_score_risk() {
+    local candidate="$1"
+    local risk_score
+    risk_score=$(echo "$candidate" | jq -r '.risk_score // 50')
+    echo "$risk_score"
+}
+
+# ─── Main Scorer ──────────────────────────────────────────────────────────────
+
+score_candidate() {
+    local candidate="$1"
+
+    local impact urgency effort confidence risk
+    impact=$(_score_impact "$candidate")
+    urgency=$(_score_urgency "$candidate")
+    effort=$(_score_effort "$candidate")
+    confidence=$(_score_confidence "$candidate")
+    risk=$(_score_risk "$candidate")
+
+    # Formula: value = (impact * w1) + (urgency * w2) + (effort * w3) + (confidence * w4) - (risk * w5)
+    # All weights are integers summing to 100, scores are 0-100
+    local value
+    value=$(( (impact * _W_IMPACT + urgency * _W_URGENCY + effort * _W_EFFORT + confidence * _W_CONFIDENCE - risk * _W_RISK) / 100 ))
+
+    # Clamp to 0-100
+    [[ "$value" -lt 0 ]] && value=0
+    [[ "$value" -gt 100 ]] && value=100
+
+    echo "$candidate" | jq \
+        --argjson vs "$value" \
+        --argjson imp "$impact" \
+        --argjson urg "$urgency" \
+        --argjson eff "$effort" \
+        --argjson conf "$confidence" \
+        --argjson rsk "$risk" \
+        '. + {value_score: $vs, scores: {impact: $imp, urgency: $urg, effort: $eff, confidence: $conf, risk: $rsk}}'
+}
+
+# ─── Outcome Learning ────────────────────────────────────────────────────────
+# EMA (exponential moving average) weight adjustment based on decision outcomes
+
+scoring_update_weights() {
+    local outcome="$1"
+    local result
+    result=$(echo "$outcome" | jq -r '.result // "unknown"')
+    local alpha=20  # EMA factor (out of 100): 20% new, 80% old
+
+    # Adjust weights based on which dimension was most predictive
+    # Success: boost the dominant scoring dimension; Failure: dampen it
+    local signal
+    signal=$(echo "$outcome" | jq -r '.signal // "unknown"')
+
+    case "$result" in
+        success)
+            case "$signal" in
+                security)     _W_URGENCY=$(( (_W_URGENCY * (100 - alpha) + 30 * alpha) / 100 )) ;;
+                deps)         _W_EFFORT=$(( (_W_EFFORT * (100 - alpha) + 25 * alpha) / 100 )) ;;
+                performance)  _W_IMPACT=$(( (_W_IMPACT * (100 - alpha) + 35 * alpha) / 100 )) ;;
+                failures)     _W_URGENCY=$(( (_W_URGENCY * (100 - alpha) + 30 * alpha) / 100 )) ;;
+                *)            ;; # No adjustment for generic signals
+            esac ;;
+        failure)
+            # On failure, slightly increase risk weight
+            _W_RISK=$(( (_W_RISK * (100 - alpha) + 15 * alpha) / 100 )) ;;
+    esac
+
+    # Normalize weights to sum to 100
+    local total=$(( _W_IMPACT + _W_URGENCY + _W_EFFORT + _W_CONFIDENCE + _W_RISK ))
+    if [[ "$total" -gt 0 && "$total" -ne 100 ]]; then
+        _W_IMPACT=$(( _W_IMPACT * 100 / total ))
+        _W_URGENCY=$(( _W_URGENCY * 100 / total ))
+        _W_EFFORT=$(( _W_EFFORT * 100 / total ))
+        _W_CONFIDENCE=$(( _W_CONFIDENCE * 100 / total ))
+        _W_RISK=$((100 - _W_IMPACT - _W_URGENCY - _W_EFFORT - _W_CONFIDENCE))
+    fi
+
+    scoring_save_weights
+}