shipwright-cli 3.1.0 → 3.3.0

package/scripts/lib/causal-graph.sh

@@ -0,0 +1,455 @@
+#!/usr/bin/env bash
+# Module guard - prevent double-sourcing
+[[ -n "${_CAUSAL_GRAPH_LOADED:-}" ]] && return 0
+_CAUSAL_GRAPH_LOADED=1
+
+# ╔═══════════════════════════════════════════════════════════════════════════╗
+# ║  shipwright causal-graph — Causal Dependency Graph for Root-Cause        ║
+# ║  Builds entity-relationship graph from pipeline context                  ║
+# ║  Traces failure chains: test → function → variable → config             ║
+# ║  Enables causal debugging instead of blind pattern matching              ║
+# ╚═══════════════════════════════════════════════════════════════════════════╝
+
+# 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"; }
+fi
+
+# ─── Configuration ───────────────────────────────────────────────────────────
+
+CAUSAL_GRAPH_FILE="${CAUSAL_GRAPH_FILE:-.claude/causal-graph.json}"
+CAUSAL_MAX_DEPTH="${CAUSAL_MAX_DEPTH:-5}"
+
+# ─── Node ID Generation ─────────────────────────────────────────────────────
+
+_causal_node_id() {
+    local type="$1" name="$2"
+    printf '%s:%s' "$type" "$name"
+}
+
+# ─── Build Graph ─────────────────────────────────────────────────────────────
+# Build entity-relationship graph from current pipeline state.
+# Analyzes: changed files, functions defined/called, test files, configs.
+
+causal_build_graph() {
+    local project_dir="${1:-.}"
+    local base_ref="${2:-HEAD~1}"
+
+    info "Building causal dependency graph..."
+
+    # Get changed files
+    local changed_files
+    changed_files=$(git -C "$project_dir" diff --name-only "$base_ref" 2>/dev/null || true)
+
+    if [[ -z "$changed_files" ]]; then
+        changed_files=$(git -C "$project_dir" diff --cached --name-only 2>/dev/null || true)
+    fi
+
+    if [[ -z "$changed_files" ]]; then
+        warn "No changed files detected — building minimal graph"
+    fi
+
+    local nodes=""
+    local edges=""
+    local node_count=0
+    local edge_count=0
+
+    # ─── Pass 1: Create file nodes ───────────────────────────────────────
+    while IFS= read -r file; do
+        [[ -z "$file" ]] && continue
+        [[ ! -f "${project_dir}/${file}" ]] && continue
+
+        local file_type="source"
+        if echo "$file" | grep -qiE '(test|spec)'; then
+            file_type="test"
+        elif echo "$file" | grep -qiE '(config|\.json$|\.ya?ml$|\.toml$|\.env)'; then
+            file_type="config"
+        fi
+
+        local node
+        node=$(printf '{"id":"file:%s","type":"file","subtype":"%s","name":"%s"}' \
+            "$file" "$file_type" "$file")
+
+        if [[ -n "$nodes" ]]; then
+            nodes="${nodes},${node}"
+        else
+            nodes="${node}"
+        fi
+        node_count=$((node_count + 1))
+    done <<< "$changed_files"
+
+    # ─── Pass 2: Extract functions from changed files ────────────────────
+    while IFS= read -r file; do
+        [[ -z "$file" ]] && continue
+        [[ ! -f "${project_dir}/${file}" ]] && continue
+
+        local ext="${file##*.}"
+        local func_pattern=""
+
+        case "$ext" in
+            sh|bash)
+                func_pattern='^\s*[a-zA-Z_][a-zA-Z0-9_]*\s*\(\)'
+                ;;
+            ts|js|tsx|jsx)
+                func_pattern='(function\s+[a-zA-Z_]\w*|const\s+[a-zA-Z_]\w*\s*=\s*(async\s+)?\(|export\s+(async\s+)?function)'
+                ;;
+            py)
+                func_pattern='^\s*def\s+[a-zA-Z_]\w*'
+                ;;
+            go)
+                func_pattern='^\s*func\s+[a-zA-Z_]\w*'
+                ;;
+            rs)
+                func_pattern='^\s*(pub\s+)?fn\s+[a-zA-Z_]\w*'
+                ;;
+            *)
+                continue
+                ;;
+        esac
+
+        local funcs
+        funcs=$(grep -oE "$func_pattern" "${project_dir}/${file}" 2>/dev/null | \
+            sed 's/.*function\s\+//' | sed 's/.*def\s\+//' | sed 's/.*func\s\+//' | \
+            sed 's/.*fn\s\+//' | sed 's/.*const\s\+//' | \
+            sed 's/\s*[=(].*//' | tr -d '(){}' | sort -u | head -20 || true)
+
+        while IFS= read -r func; do
+            [[ -z "$func" ]] && continue
+            func=$(echo "$func" | tr -d ' ')
+            [[ -z "$func" ]] && continue
+
+            local node
+            node=$(printf '{"id":"func:%s:%s","type":"function","name":"%s","file":"%s"}' \
+                "$file" "$func" "$func" "$file")
+            nodes="${nodes},${node}"
+            node_count=$((node_count + 1))
+
+            # Edge: file contains function
+            local edge
+            edge=$(printf '{"from":"file:%s","to":"func:%s:%s","type":"defines"}' \
+                "$file" "$file" "$func")
+            if [[ -n "$edges" ]]; then
+                edges="${edges},${edge}"
+            else
+                edges="${edge}"
+            fi
+            edge_count=$((edge_count + 1))
+        done <<< "$funcs"
+
+    done <<< "$changed_files"
+
+    # ─── Pass 3: Find cross-file dependencies ───────────────────────────
+    while IFS= read -r file; do
+        [[ -z "$file" ]] && continue
+        [[ ! -f "${project_dir}/${file}" ]] && continue
+
+        # Find imports/requires/sources from this file
+        local imports
+        imports=$(grep -oE "(import|require|source|from)\s+['\"]([^'\"]+)['\"]" "${project_dir}/${file}" 2>/dev/null | \
+            sed "s/.*['\"]//;s/['\"].*//" | head -20 || true)
+
+        while IFS= read -r imp; do
+            [[ -z "$imp" ]] && continue
+
+            # Check if imported file is in our changed set
+            local match
+            match=$(echo "$changed_files" | grep -F "$imp" | head -1 || true)
+
+            if [[ -n "$match" ]]; then
+                local edge
+                edge=$(printf '{"from":"file:%s","to":"file:%s","type":"imports"}' "$file" "$match")
+                if [[ -n "$edges" ]]; then
+                    edges="${edges},${edge}"
+                else
+                    edges="${edge}"
+                fi
+                edge_count=$((edge_count + 1))
+            fi
+        done <<< "$imports"
+
+    done <<< "$changed_files"
+
+    # ─── Pass 4: Find test → source relationships ───────────────────────
+    while IFS= read -r file; do
+        [[ -z "$file" ]] && continue
+        if ! echo "$file" | grep -qiE '(test|spec)'; then
+            continue
+        fi
+        [[ ! -f "${project_dir}/${file}" ]] && continue
+
+        # Test files typically import/source the file they test
+        local tested_files
+        tested_files=$(grep -oE "(import|require|source)\s+['\"]([^'\"]+)['\"]" "${project_dir}/${file}" 2>/dev/null | \
+            sed "s/.*['\"]//;s/['\"].*//" | head -10 || true)
+
+        while IFS= read -r tf; do
+            [[ -z "$tf" ]] && continue
+            local match
+            match=$(echo "$changed_files" | grep -F "$tf" | head -1 || true)
+            if [[ -n "$match" ]]; then
+                local edge
+                edge=$(printf '{"from":"file:%s","to":"file:%s","type":"tests"}' "$file" "$match")
+                if [[ -n "$edges" ]]; then
+                    edges="${edges},${edge}"
+                else
+                    edges="${edge}"
+                fi
+                edge_count=$((edge_count + 1))
+            fi
+        done <<< "$tested_files"
+    done <<< "$changed_files"
+
+    # ─── Write Graph ─────────────────────────────────────────────────────
+    mkdir -p "$(dirname "$CAUSAL_GRAPH_FILE")"
+
+    local tmp_file
+    tmp_file=$(mktemp 2>/dev/null || echo "${CAUSAL_GRAPH_FILE}.raw")
+    cat > "$tmp_file" <<EOF
+{
+  "built_at": "$(now_iso)",
+  "base_ref": "${base_ref}",
+  "node_count": ${node_count},
+  "edge_count": ${edge_count},
+  "nodes": [${nodes}],
+  "edges": [${edges}]
+}
+EOF
+
+    # Pretty-print if jq available, then atomic move
+    if command -v jq >/dev/null 2>&1; then
+        if jq '.' "$tmp_file" > "${CAUSAL_GRAPH_FILE}.pp" 2>/dev/null; then
+            mv "${CAUSAL_GRAPH_FILE}.pp" "$CAUSAL_GRAPH_FILE"
+        else
+            mv "$tmp_file" "$CAUSAL_GRAPH_FILE"
+        fi
+    else
+        mv "$tmp_file" "$CAUSAL_GRAPH_FILE"
+    fi
+    rm -f "$tmp_file" "${CAUSAL_GRAPH_FILE}.pp" "${CAUSAL_GRAPH_FILE}.raw" 2>/dev/null || true
+
+    success "Causal graph: ${node_count} nodes, ${edge_count} edges"
+
+    if type emit_event >/dev/null 2>&1; then
+        emit_event "causal_graph_built" \
+            "nodes=${node_count}" \
+            "edges=${edge_count}" \
+            "base_ref=${base_ref}"
+    fi
+
+    return 0
+}
+
+# ─── Trace Failure ───────────────────────────────────────────────────────────
+# Given a failing test file, trace the causal chain to identify root cause.
+# Returns JSON with the causal chain and suggested root cause.
+
+causal_trace_failure() {
+    local failing_test="${1:-}"
+    local project_dir="${2:-.}"
+
+    if [[ -z "$failing_test" ]]; then
+        error "causal_trace_failure requires a failing test file path"
+        return 1
+    fi
+
+    if [[ ! -f "$CAUSAL_GRAPH_FILE" ]]; then
+        warn "No causal graph — building now..."
+        causal_build_graph "$project_dir"
+    fi
+
+    if ! command -v jq >/dev/null 2>&1; then
+        error "jq required for causal tracing"
+        return 1
+    fi
+
+    info "Tracing causal chain for: ${failing_test}"
+
+    local chain=""
+    local current="file:${failing_test}"
+    local visited=""
+    local depth=0
+
+    # BFS through graph following edges from test → source → dependencies
+    while [[ "$depth" -lt "$CAUSAL_MAX_DEPTH" ]]; do
+        # Find all edges FROM current node
+        local targets
+        targets=$(jq -r --arg from "$current" \
+            '.edges[] | select(.from == $from) | "\(.to)|\(.type)"' \
+            "$CAUSAL_GRAPH_FILE" 2>/dev/null || true)
+
+        if [[ -z "$targets" ]]; then
+            break
+        fi
+
+        while IFS='|' read -r target edge_type; do
+            [[ -z "$target" ]] && continue
+
+            # Skip already visited
+            if echo "$visited" | grep -qF "$target" 2>/dev/null; then
+                continue
+            fi
+            visited="${visited} ${target}"
+
+            local node_info
+            node_info=$(jq -c --arg id "$target" '.nodes[] | select(.id == $id)' \
+                "$CAUSAL_GRAPH_FILE" 2>/dev/null || echo "{}")
+
+            local entry
+            entry=$(printf '{"node":"%s","edge_type":"%s","depth":%d,"info":%s}' \
+                "$target" "$edge_type" "$depth" "${node_info:-\"{}\"}")
+
+            if [[ -n "$chain" ]]; then
+                chain="${chain},${entry}"
+            else
+                chain="${entry}"
+            fi
+
+            # Follow the chain deeper for source files
+            if echo "$target" | grep -q "^file:"; then
+                current="$target"
+            fi
+        done <<< "$targets"
+
+        depth=$((depth + 1))
+    done
+
+    # Identify likely root cause (deepest source file in chain)
+    local root_cause=""
+    if [[ -n "$chain" ]]; then
+        root_cause=$(echo "[${chain}]" | jq -r \
+            '[.[] | select(.edge_type != "tests")] | last | .node // "unknown"' 2>/dev/null || echo "unknown")
+    fi
+
+    # Build trace result
+    local trace_file="${CAUSAL_GRAPH_FILE%.json}-trace.json"
+    cat > "$trace_file" <<EOF
+{
+  "traced_at": "$(now_iso)",
+  "failing_test": "${failing_test}",
+  "root_cause": "${root_cause}",
+  "chain_depth": ${depth},
+  "chain": [${chain}]
+}
+EOF
+
+    if [[ "$root_cause" != "unknown" && -n "$root_cause" ]]; then
+        success "Root cause identified: ${root_cause}"
+    else
+        warn "Could not determine root cause from graph (may need deeper analysis)"
+    fi
+
+    if type emit_event >/dev/null 2>&1; then
+        emit_event "causal_trace_completed" \
+            "test=${failing_test}" \
+            "root_cause=${root_cause}" \
+            "depth=${depth}"
+    fi
+
+    echo "$trace_file"
+    return 0
+}
+
+# ─── Find Dependencies ──────────────────────────────────────────────────────
+# Find all entities affected by a change to a given file/function.
+
+causal_find_dependencies() {
+    local node_id="${1:-}"
+
+    if [[ -z "$node_id" ]]; then
+        error "causal_find_dependencies requires a node ID (e.g., file:src/foo.ts)"
+        return 1
+    fi
+
+    if [[ ! -f "$CAUSAL_GRAPH_FILE" ]]; then
+        warn "No causal graph available"
+        return 1
+    fi
+
+    # Find all nodes that depend on this one (reverse edge traversal)
+    local dependents
+    dependents=$(jq -r --arg to "$node_id" \
+        '.edges[] | select(.to == $to) | .from' \
+        "$CAUSAL_GRAPH_FILE" 2>/dev/null || true)
+
+    if [[ -z "$dependents" ]]; then
+        info "No dependents found for ${node_id}"
+        return 0
+    fi
+
+    echo "Dependents of ${node_id}:"
+    echo "$dependents" | while IFS= read -r dep; do
+        local dep_info
+        dep_info=$(jq -r --arg id "$dep" '.nodes[] | select(.id == $id) | "\(.type): \(.name)"' \
+            "$CAUSAL_GRAPH_FILE" 2>/dev/null || echo "$dep")
+        echo "  - ${dep_info}"
+    done
+
+    return 0
+}
+
+# ─── Suggest Fix ─────────────────────────────────────────────────────────────
+# Given a causal trace, suggest what to fix based on the root cause type.
+
+causal_suggest_fix() {
+    local trace_file="${1:-}"
+
+    if [[ ! -f "$trace_file" ]]; then
+        error "Trace file not found: ${trace_file}"
+        return 1
+    fi
+
+    local root_cause
+    root_cause=$(jq -r '.root_cause // "unknown"' "$trace_file" 2>/dev/null)
+
+    if [[ "$root_cause" == "unknown" ]]; then
+        echo "Unable to suggest fix — root cause not identified"
+        return 1
+    fi
+
+    # Extract file type from root cause
+    local cause_file
+    cause_file=$(echo "$root_cause" | sed 's/^file://')
+
+    echo "Suggested fix approach:"
+    echo "  Root cause: ${cause_file}"
+
+    if echo "$cause_file" | grep -qiE '(config|\.json$|\.ya?ml$|\.env)'; then
+        echo "  Type: Configuration issue"
+        echo "  Action: Check config values, defaults, and schema validation"
+    elif echo "$cause_file" | grep -qiE '(test|spec)'; then
+        echo "  Type: Test issue (test itself may be wrong)"
+        echo "  Action: Review test assertions and expected values"
+    else
+        echo "  Type: Source code issue"
+        echo "  Action: Review recent changes to ${cause_file}"
+        echo "  Hint: Check git diff for this file and verify logic correctness"
+    fi
+
+    # Show the causal chain for context
+    echo ""
+    echo "Causal chain:"
+    jq -r '.chain[] | "  \(.edge_type): \(.node)"' "$trace_file" 2>/dev/null
+
+    return 0
+}
+
+# ─── Graph Status ────────────────────────────────────────────────────────────
+
+causal_status() {
+    if [[ -f "$CAUSAL_GRAPH_FILE" ]]; then
+        local node_count edge_count built_at
+        node_count=$(jq -r '.node_count // 0' "$CAUSAL_GRAPH_FILE" 2>/dev/null || echo "0")
+        edge_count=$(jq -r '.edge_count // 0' "$CAUSAL_GRAPH_FILE" 2>/dev/null || echo "0")
+        built_at=$(jq -r '.built_at // "unknown"' "$CAUSAL_GRAPH_FILE" 2>/dev/null || echo "unknown")
+        echo "causal_graph=active nodes=${node_count} edges=${edge_count} built=${built_at}"
+    else
+        echo "causal_graph=none"
+    fi
+}

package/scripts/lib/compat.sh

@@ -281,3 +281,129 @@ compute_md5() {
         md5 -q "$file" 2>/dev/null || md5sum "$file" 2>/dev/null | awk '{print $1}'
     fi
 }
+
+# ─── Intelligent Model Selection ──────────────────────────────────────────
+# _smart_model <purpose> [default]
+# Returns model name from config chain: env var → daemon-config.json → default
+# Purpose: "classification", "detection", "validation", "commit_quality",
+#          "default", or any custom key under model_routing.{purpose}
+_smart_model() {
+    local purpose="${1:-default}" default="${2:-haiku}"
+
+    # 1. Environment override (e.g., SW_MODEL_CLASSIFICATION=sonnet)
+    local env_key
+    env_key="SW_MODEL_$(echo "$purpose" | tr '[:lower:]' '[:upper:]')"
+    local env_val=""
+    eval 'env_val="${'"$env_key"':-}"' 2>/dev/null || true
+    if [[ -n "$env_val" ]]; then
+        echo "$env_val"
+        return
+    fi
+
+    # 2. Daemon config: model_routing.{purpose}
+    local cfg="${DAEMON_CONFIG:-${WORK_DIR:-.}/.claude/daemon-config.json}"
+    if [[ -f "$cfg" ]]; then
+        local cfg_val
+        cfg_val=$(jq -r --arg p "$purpose" '.model_routing[$p] // empty' "$cfg" 2>/dev/null || true)
+        if [[ -n "$cfg_val" && "$cfg_val" != "null" ]]; then
+            echo "$cfg_val"
+            return
+        fi
+    fi
+
+    # 3. User-level config: ~/.shipwright/model-routing.json
+    local user_cfg="${HOME}/.shipwright/model-routing.json"
+    if [[ -f "$user_cfg" ]]; then
+        local user_val
+        user_val=$(jq -r --arg p "$purpose" '.[$p] // empty' "$user_cfg" 2>/dev/null || true)
+        if [[ -n "$user_val" && "$user_val" != "null" ]]; then
+            echo "$user_val"
+            return
+        fi
+    fi
+
+    # 4. Default
+    echo "$default"
+}
+
+# _smart_int <config_key> <default>
+# Read int from daemon-config with env override and default fallback
+_smart_int() {
+    local key="$1" default="$2"
+
+    # Env override: config.key.path → SW_KEY_PATH
+    local env_key
+    env_key="SW_$(echo "$key" | tr '[:lower:].' '[:upper:]_')"
+    local env_val=""
+    eval 'env_val="${'"$env_key"':-}"' 2>/dev/null || true
+    if [[ -n "$env_val" ]]; then
+        echo "$env_val"
+        return
+    fi
+
+    # Daemon config
+    local cfg="${DAEMON_CONFIG:-${WORK_DIR:-.}/.claude/daemon-config.json}"
+    if [[ -f "$cfg" ]]; then
+        local cfg_val
+        cfg_val=$(jq -r --arg k "$key" 'getpath($k | split(".")) // empty' "$cfg" 2>/dev/null || true)
+        if [[ -n "$cfg_val" && "$cfg_val" != "null" ]]; then
+            echo "$cfg_val"
+            return
+        fi
+    fi
+
+    echo "$default"
+}
+
+# _smart_effort <stage>
+# Read effort level from config, with per-stage defaults
+_smart_effort() {
+    local stage="$1"
+
+    # 1. Explicit override
+    if [[ -n "${EFFORT_LEVEL_OVERRIDE:-}" ]]; then
+        echo "$EFFORT_LEVEL_OVERRIDE"
+        return
+    fi
+
+    # 2. Config: effort_levels.{stage}
+    local cfg="${DAEMON_CONFIG:-${WORK_DIR:-.}/.claude/daemon-config.json}"
+    if [[ -f "$cfg" ]]; then
+        local cfg_val
+        cfg_val=$(jq -r --arg s "$stage" '.effort_levels[$s] // empty' "$cfg" 2>/dev/null || true)
+        if [[ -n "$cfg_val" && "$cfg_val" != "null" ]]; then
+            echo "$cfg_val"
+            return
+        fi
+    fi
+
+    # 3. Intelligent defaults (same as before, but now overridable)
+    case "$stage" in
+        intake)              echo "low" ;;
+        plan|design)         echo "high" ;;
+        build|test)          echo "medium" ;;
+        review|compound_quality) echo "high" ;;
+        pr|merge)            echo "low" ;;
+        deploy|validate|monitor) echo "medium" ;;
+        *)                   echo "medium" ;;
+    esac
+}
+
+# _exponential_backoff <attempt> [base_seconds] [max_seconds]
+# Returns sleep duration with jitter for retry loops
+_exponential_backoff() {
+    local attempt="${1:-1}" base="${2:-2}" max="${3:-60}"
+    local delay=$base
+    local i=1
+    while [ "$i" -lt "$attempt" ]; do
+        delay=$((delay * 2))
+        i=$((i + 1))
+    done
+    # Cap at max
+    [ "$delay" -gt "$max" ] && delay=$max
+    # Add jitter: ±25%
+    local jitter=$(( (RANDOM % (delay / 2 + 1)) - delay / 4 ))
+    delay=$((delay + jitter))
+    [ "$delay" -lt 1 ] && delay=1
+    echo "$delay"
+}