shipwright-cli 3.2.0 → 3.3.0

package/scripts/sw-memory.sh

@@ -6,7 +6,7 @@
 set -euo pipefail
 trap 'echo "ERROR: $BASH_SOURCE:$LINENO exited with status $?" >&2' ERR
 
-VERSION="3.2.0"
+VERSION="3.3.0"
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 REPO_DIR="${REPO_DIR:-$(cd "$SCRIPT_DIR/.." && pwd)}"
 
@@ -29,7 +29,8 @@ fi
 if [[ "$(type -t emit_event 2>/dev/null)" != "function" ]]; then
   emit_event() {
     local event_type="$1"; shift; mkdir -p "${HOME}/.shipwright"
-    local payload="{\"ts\":\"$(date -u +%Y-%m-%dT%H:%M:%SZ)\",\"type\":\"$event_type\""
+    local payload
+    payload="{\"ts\":\"$(date -u +%Y-%m-%dT%H:%M:%SZ)\",\"type\":\"$event_type\""
     while [[ $# -gt 0 ]]; do local key="${1%%=*}" val="${1#*=}"; payload="${payload},\"${key}\":\"${val}\""; shift; done
     echo "${payload}}" >> "${HOME}/.shipwright/events.jsonl"
   }
@@ -42,6 +43,10 @@ fi
 # shellcheck source=sw-intelligence.sh
 [[ -f "$SCRIPT_DIR/sw-intelligence.sh" ]] && source "$SCRIPT_DIR/sw-intelligence.sh"
 
+# ─── Memory Effectiveness Tracker ──────────────────────────────────────────
+# shellcheck source=lib/memory-effectiveness.sh
+[[ -f "$SCRIPT_DIR/lib/memory-effectiveness.sh" ]] && source "$SCRIPT_DIR/lib/memory-effectiveness.sh"
+
 # ─── Memory Storage Paths ──────────────────────────────────────────────────
 MEMORY_ROOT="${HOME}/.shipwright/memory"
 GLOBAL_MEMORY="${MEMORY_ROOT}/global.json"
@@ -217,6 +222,7 @@ memory_semantic_search() {
 
 # Inject relevant memories into agent prompts (goal-based)
 memory_inject_goal_context() {
+    # shellcheck disable=SC2034
     local goal="$1" repo_hash="${2:-}" max_tokens="${3:-2000}"
 
     local memories
@@ -330,6 +336,7 @@ memory_capture_pipeline() {
             # Record review patterns to global memory for cross-repo learning
             local tmp_global
             tmp_global=$(mktemp)
+    # shellcheck disable=SC2064
             trap "rm -f '$tmp_global'" RETURN
             jq --arg repo "$repo" \
                --arg ts "$captured_at" \
@@ -395,6 +402,7 @@ memory_capture_failure() {
         fi
         local tmp_file
         tmp_file=$(mktemp "${failures_file}.tmp.XXXXXX")
+    # shellcheck disable=SC2064
         trap "rm -f '$tmp_file'" EXIT
 
         if [[ "$existing_idx" != "-1" && "$existing_idx" != "null" ]]; then
@@ -471,6 +479,7 @@ memory_record_fix_outcome() {
         fi
         local tmp_file
         tmp_file=$(mktemp "${failures_file}.tmp.XXXXXX")
+    # shellcheck disable=SC2064
         trap "rm -f '$tmp_file'" EXIT
 
         jq --argjson idx "$match_idx" \
@@ -637,6 +646,7 @@ _memory_aggregate_global() {
         # Add to global, cap at 100 entries
         local tmp_global
         tmp_global=$(mktemp "${global_file}.tmp.XXXXXX")
+    # shellcheck disable=SC2064
         trap "rm -f '$tmp_global'" RETURN
         jq --arg p "$pattern" \
            --arg ts "$(now_iso)" \
@@ -789,6 +799,7 @@ Return JSON only, no markdown fences, no explanation."
     # Update the most recent failure entry with root_cause, fix, category
     local tmp_file
     tmp_file=$(mktemp)
+    # shellcheck disable=SC2064
     trap "rm -f '$tmp_file'" RETURN
     jq --arg rc "$root_cause" \
        --arg fix "$fix" \
@@ -819,6 +830,7 @@ memory_capture_pattern() {
 
     local tmp_file
     tmp_file=$(mktemp)
+    # shellcheck disable=SC2064
     trap "rm -f '$tmp_file'" RETURN
 
     case "$pattern_type" in
@@ -1337,6 +1349,7 @@ memory_update_metrics() {
     # Update baseline using atomic write
     local tmp_file
     tmp_file=$(mktemp)
+    # shellcheck disable=SC2064
     trap "rm -f '$tmp_file'" RETURN
     jq --arg m "$metric_name" \
        --argjson v "$value" \
@@ -1361,6 +1374,7 @@ memory_capture_decision() {
 
     local tmp_file
     tmp_file=$(mktemp)
+    # shellcheck disable=SC2064
     trap "rm -f '$tmp_file'" RETURN
     jq --arg type "$dec_type" \
        --arg summary "$summary" \
@@ -1702,6 +1716,7 @@ memory_import() {
     # Extract and write each section
     local tmp_file
     tmp_file=$(mktemp)
+    # shellcheck disable=SC2064
     trap "rm -f '$tmp_file'" RETURN
 
     jq '.patterns // {}' "$import_file" > "$tmp_file" && mv "$tmp_file" "$mem_dir/patterns.json"
@@ -1787,6 +1802,219 @@ memory_stats() {
     echo ""
 }
 
+# ─── A/B Testing Framework ─────────────────────────────────────────────────
+# Test memory system effectiveness by randomly assigning control vs treatment.
+#   - Control: pipeline runs without memory injection
+#   - Treatment: pipeline runs with memory injection
+# Emits events to track metrics: iterations, cost, test_failures, completion_status
+
+AB_RESULTS_DIR="${HOME}/.shipwright/memory"
+AB_RESULTS_FILE="${AB_RESULTS_DIR}/ab-results.jsonl"
+
+# Assign control or treatment for this pipeline run
+#   Returns: "control" or "treatment"
+memory_ab_assign_group() {
+    local ab_ratio="${1:-0.2}"  # Read from daemon-config intelligence.ab_test_ratio
+
+    # Validate ratio is between 0 and 1
+    if ! echo "$ab_ratio" | grep -qE '^0(\.[0-9]+)?$|^1(\.0+)?$'; then
+        ab_ratio="0.2"
+    fi
+
+    # Generate random 0-100
+    local rand=$((RANDOM % 100))
+    local threshold=$(echo "$ab_ratio * 100" | bc 2>/dev/null || echo "20")
+    threshold=${threshold%.*}  # Remove decimal
+
+    if [[ "$rand" -lt "$threshold" ]]; then
+        echo "control"
+    else
+        echo "treatment"
+    fi
+}
+
+# Record A/B test assignment at pipeline start
+#   $1: pipeline_id
+#   $2: group (control|treatment)
+memory_ab_record_assignment() {
+    local pipeline_id="$1"
+    local group="${2:-}"
+
+    [[ -z "$pipeline_id" || -z "$group" ]] && return 1
+
+    # Emit event for tracking
+    emit_event "memory.ab_assigned" \
+        "pipeline_id=$pipeline_id" \
+        "group=$group" \
+        "timestamp=$(now_iso)"
+
+    return 0
+}
+
+# Record A/B test result after pipeline completion
+#   $1: pipeline_id
+#   $2: group (control|treatment)
+#   $3: iterations (number of build iterations)
+#   $4: cost (estimated token cost)
+#   $5: test_failures (number of test failures)
+#   $6: completion_status (success|failure)
+memory_ab_record_result() {
+    local pipeline_id="$1"
+    local group="$2"
+    local iterations="$3"
+    local cost="$4"
+    local test_failures="$5"
+    local completion_status="$6"
+
+    [[ -z "$pipeline_id" || -z "$group" ]] && return 1
+
+    mkdir -p "$AB_RESULTS_DIR"
+
+    # Record result as JSONL
+    local result_json
+    result_json=$(jq -n \
+        --arg pipeline_id "$pipeline_id" \
+        --arg group "$group" \
+        --arg timestamp "$(now_iso)" \
+        --arg iterations "$iterations" \
+        --arg cost "$cost" \
+        --arg test_failures "$test_failures" \
+        --arg completion_status "$completion_status" \
+        '{
+            pipeline_id: $pipeline_id,
+            group: $group,
+            timestamp: $timestamp,
+            iterations: ($iterations | tonumber? // 0),
+            cost: ($cost | tonumber? // 0),
+            test_failures: ($test_failures | tonumber? // 0),
+            completion_status: $completion_status
+        }')
+
+    echo "$result_json" >> "$AB_RESULTS_FILE"
+
+    # Emit event
+    emit_event "memory.ab_result" \
+        "pipeline_id=$pipeline_id" \
+        "group=$group" \
+        "iterations=$iterations" \
+        "cost=$cost" \
+        "test_failures=$test_failures" \
+        "completion_status=$completion_status"
+
+    return 0
+}
+
+# Generate A/B test report comparing control vs treatment
+cmd_memory_ab_report() {
+    if [[ ! -f "$AB_RESULTS_FILE" ]]; then
+        warn "No A/B test results found at $AB_RESULTS_FILE"
+        return 1
+    fi
+
+    if ! command -v jq >/dev/null 2>&1; then
+        error "jq required for A/B report generation"
+        return 1
+    fi
+
+    info "Memory A/B Test Report"
+    echo ""
+
+    local control_count treatment_count
+    control_count=$(grep -c '"control"' "$AB_RESULTS_FILE" 2>/dev/null || echo "0")
+    treatment_count=$(grep -c '"treatment"' "$AB_RESULTS_FILE" 2>/dev/null || echo "0")
+
+    echo -e "${BOLD}Sample Sizes${RESET}"
+    printf "  Control:   %3d pipelines\n" "$control_count"
+    printf "  Treatment: %3d pipelines\n" "$treatment_count"
+    echo ""
+
+    # Calculate metrics for control group
+    local control_data
+    control_data=$(grep '"control"' "$AB_RESULTS_FILE" 2>/dev/null | jq -s '
+        if length == 0 then
+            {count: 0, avg_iterations: 0, avg_cost: 0, success_rate: 0}
+        else
+            {
+                count: length,
+                avg_iterations: ([.[].iterations // 0] | add / length | floor),
+                avg_cost: ([.[].cost // 0] | add / length | floor),
+                success_rate: (([.[] | select(.completion_status == "success")] | length) / length * 100 | floor)
+            }
+        end
+    ' || echo '{"count": 0, "avg_iterations": 0, "avg_cost": 0, "success_rate": 0}')
+
+    # Calculate metrics for treatment group
+    local treatment_data
+    treatment_data=$(grep '"treatment"' "$AB_RESULTS_FILE" 2>/dev/null | jq -s '
+        if length == 0 then
+            {count: 0, avg_iterations: 0, avg_cost: 0, success_rate: 0}
+        else
+            {
+                count: length,
+                avg_iterations: ([.[].iterations // 0] | add / length | floor),
+                avg_cost: ([.[].cost // 0] | add / length | floor),
+                success_rate: (([.[] | select(.completion_status == "success")] | length) / length * 100 | floor)
+            }
+        end
+    ' || echo '{"count": 0, "avg_iterations": 0, "avg_cost": 0, "success_rate": 0}')
+
+    # Extract values
+    local c_iterations t_iterations c_cost t_cost c_success t_success
+    c_iterations=$(echo "$control_data" | jq -r '.avg_iterations // 0')
+    t_iterations=$(echo "$treatment_data" | jq -r '.avg_iterations // 0')
+    c_cost=$(echo "$control_data" | jq -r '.avg_cost // 0')
+    t_cost=$(echo "$treatment_data" | jq -r '.avg_cost // 0')
+    c_success=$(echo "$control_data" | jq -r '.success_rate // 0')
+    t_success=$(echo "$treatment_data" | jq -r '.success_rate // 0')
+
+    # Calculate deltas
+    local iter_delta cost_delta success_delta
+    iter_delta=$((c_iterations - t_iterations))
+    cost_delta=$((c_cost - t_cost))
+    success_delta=$((t_success - c_success))
+
+    # Direction indicators
+    local iter_dir cost_dir success_dir
+    [[ $iter_delta -gt 0 ]] && iter_dir="${GREEN}↓${RESET}" || iter_dir="${RED}↑${RESET}"
+    [[ $cost_delta -gt 0 ]] && cost_dir="${GREEN}↓${RESET}" || cost_dir="${RED}↑${RESET}"
+    [[ $success_delta -gt 0 ]] && success_dir="${GREEN}↑${RESET}" || success_dir="${RED}↓${RESET}"
+
+    echo -e "${BOLD}Metrics${RESET}"
+    echo ""
+    printf "  %-28s %10s %10s %10s\n" "Metric" "Control" "Treatment" "Delta"
+    printf "  %s\n" "$(printf '%.0s-' {1..60})"
+    printf "  %-28s %10d %10d %10s %s\n" "Avg Iterations" "$c_iterations" "$t_iterations" "$iter_delta" "$iter_dir"
+    printf "  %-28s %10d %10d %10s %s\n" "Avg Cost (tokens)" "$c_cost" "$t_cost" "$cost_delta" "$cost_dir"
+    printf "  %-28s %10d%% %10d%% %10s %s\n" "Success Rate" "$c_success" "$t_success" "$success_delta" "$success_dir"
+    echo ""
+
+    # Summary
+    echo -e "${BOLD}Summary${RESET}"
+    if [[ $iter_delta -gt 0 ]]; then
+        success "Memory injection reduces iterations by ${iter_delta} (${GREEN}$(echo "scale=1; $iter_delta * 100 / $c_iterations" | bc)% improvement${RESET})"
+    elif [[ $iter_delta -lt 0 ]]; then
+        warn "Memory injection increases iterations by $((iter_delta * -1)) (regression)"
+    else
+        info "No significant difference in iteration count"
+    fi
+
+    if [[ $cost_delta -gt 0 ]]; then
+        success "Memory injection reduces cost by ${cost_delta} tokens (${GREEN}$(echo "scale=1; $cost_delta * 100 / $c_cost" | bc)% savings${RESET})"
+    elif [[ $cost_delta -lt 0 ]]; then
+        warn "Memory injection increases cost by $((cost_delta * -1)) tokens (regression)"
+    fi
+
+    if [[ $success_delta -gt 0 ]]; then
+        success "Memory injection improves success rate by ${success_delta}pp (${GREEN}$(echo "scale=1; $success_delta" | bc)% better${RESET})"
+    elif [[ $success_delta -lt 0 ]]; then
+        warn "Memory injection reduces success rate by $((success_delta * -1))pp (regression)"
+    fi
+
+    echo ""
+    echo -e "${PURPLE}${BOLD}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${RESET}"
+    echo ""
+}
+
 # ─── Help ──────────────────────────────────────────────────────────────────
 
 show_help() {
@@ -1813,6 +2041,7 @@ show_help() {
     echo -e "  ${CYAN}decision${RESET} <type> <summary>       Record a design decision"
     echo -e "  ${CYAN}analyze-failure${RESET} <log> <stage>    Analyze failure root cause via AI"
     echo -e "  ${CYAN}fix-outcome${RESET} <pattern> <applied> <resolved>  Record fix effectiveness"
+    echo -e "  ${CYAN}ab-report${RESET}                      Compare control vs treatment in A/B tests"
     echo ""
     echo -e "${BOLD}EXAMPLES${RESET}"
     echo -e "  ${DIM}shipwright memory show${RESET}                            # View repo memory"
@@ -1824,6 +2053,122 @@ show_help() {
     echo -e "  ${DIM}shipwright memory inject build${RESET}                    # Get context for build stage"
 }
 
+# ─── Weighted Search (RL integration) ──────────────────────────────────────
+
+# Search memory with recency + success weighting.
+# Args: $1=query, $2=memory_dir (optional), $3=max_results (default 5)
+# Returns JSON array of results with recency_weight applied.
+memory_search_weighted() {
+    local query="${1:-}"
+    local memory_dir="${2:-}"
+    local max_results="${3:-5}"
+
+    if [[ -z "$memory_dir" ]] && type repo_memory_dir >/dev/null 2>&1; then
+        memory_dir="$(repo_memory_dir)"
+    fi
+    memory_dir="${memory_dir:-$HOME/.shipwright/memory}"
+
+    if [[ ! -d "$memory_dir" ]]; then
+        echo "[]"
+        return 0
+    fi
+
+    # Get base ranked results
+    local base_results
+    base_results="$(memory_ranked_search "$query" "$memory_dir" "$max_results" 2>/dev/null || echo "[]")"
+
+    if [[ "$base_results" == "[]" ]] || [[ -z "$base_results" ]]; then
+        echo "[]"
+        return 0
+    fi
+
+    # Apply recency weighting: boost results from files modified recently
+    local now_epoch
+    now_epoch="$(date +%s)"
+
+    echo "$base_results" | jq --argjson now "$now_epoch" '
+        [.[] | . + {
+            recency_weight: (
+                if .timestamp then
+                    (($now - (.timestamp // $now)) / 86400) as $age |
+                    if $age <= 7 then 1.5
+                    elif $age <= 30 then 1.0
+                    elif $age <= 90 then 0.7
+                    else 0.4 end
+                else 0.8 end
+            )
+        }] |
+        [.[] | .combined_score = ((.relevance // 50) * .recency_weight)] |
+        sort_by(-.combined_score)
+    ' 2>/dev/null || echo "$base_results"
+}
+
+# Reduce weight of memory entries older than threshold.
+# Args: $1=days_threshold (default 30), $2=memory_dir (optional)
+memory_decay_old() {
+    local days_threshold="${1:-30}"
+    local memory_dir="${2:-}"
+
+    if [[ -z "$memory_dir" ]] && type repo_memory_dir >/dev/null 2>&1; then
+        memory_dir="$(repo_memory_dir)"
+    fi
+    memory_dir="${memory_dir:-$HOME/.shipwright/memory}"
+
+    if [[ ! -d "$memory_dir" ]]; then
+        return 0
+    fi
+
+    local now_epoch decayed_count
+    now_epoch="$(date +%s)"
+    decayed_count=0
+    local threshold_epoch
+    threshold_epoch=$(( now_epoch - (days_threshold * 86400) ))
+
+    # Process failure patterns file if it exists
+    local failures_file="${memory_dir}/failures.json"
+    if [[ -f "$failures_file" ]]; then
+        local tmp
+        tmp="$(mktemp 2>/dev/null || echo "${TMPDIR:-/tmp}/mem-decay-$$.tmp")"
+        jq --argjson threshold "$threshold_epoch" --argjson half "$days_threshold" '
+            if type == "array" then
+                [.[] | if (.timestamp // 0) < $threshold then
+                    .weight = ((.weight // 1) * 0.5 | if . < 0.1 then 0.1 else . end)
+                else . end]
+            else . end
+        ' "$failures_file" > "$tmp" 2>/dev/null
+        if [[ -s "$tmp" ]]; then
+            mv "$tmp" "$failures_file"
+            decayed_count=$((decayed_count + 1))
+        else
+            rm -f "$tmp"
+        fi
+    fi
+
+    # Process decisions file if it exists
+    local decisions_file="${memory_dir}/decisions.json"
+    if [[ -f "$decisions_file" ]]; then
+        local tmp
+        tmp="$(mktemp 2>/dev/null || echo "${TMPDIR:-/tmp}/mem-decay2-$$.tmp")"
+        jq --argjson threshold "$threshold_epoch" '
+            if type == "array" then
+                [.[] | if (.timestamp // 0) < $threshold then
+                    .weight = ((.weight // 1) * 0.5 | if . < 0.1 then 0.1 else . end)
+                else . end]
+            else . end
+        ' "$decisions_file" > "$tmp" 2>/dev/null
+        if [[ -s "$tmp" ]]; then
+            mv "$tmp" "$decisions_file"
+            decayed_count=$((decayed_count + 1))
+        else
+            rm -f "$tmp"
+        fi
+    fi
+
+    if [[ "$decayed_count" -gt 0 ]]; then
+        emit_event "memory.decay_applied" "files=$decayed_count" "threshold_days=$days_threshold"
+    fi
+}
+
 # ─── Command Router ─────────────────────────────────────────────────────────
 
 if [[ "${BASH_SOURCE[0]}" == "$0" ]]; then
@@ -1873,6 +2218,15 @@ if [[ "${BASH_SOURCE[0]}" == "$0" ]]; then
         fix-outcome)
             memory_record_fix_outcome "$@"
             ;;
+        search-weighted)
+            memory_search_weighted "$@"
+            ;;
+        decay)
+            memory_decay_old "$@"
+            ;;
+        ab-report)
+            cmd_memory_ab_report "$@"
+            ;;
         help|--help|-h)
             show_help
             ;;

package/scripts/sw-mission-control.sh

@@ -7,8 +7,10 @@
 set -euo pipefail
 trap 'echo "ERROR: $BASH_SOURCE:$LINENO exited with status $?" >&2' ERR
 
-VERSION="3.2.0"
+# shellcheck disable=SC2034
+VERSION="3.3.0"
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+# shellcheck disable=SC2034
 REPO_DIR="$(cd "$SCRIPT_DIR/.." && pwd)"
 
 # ─── Cross-platform compatibility ──────────────────────────────────────────
@@ -30,6 +32,7 @@ fi
 if [[ "$(type -t emit_event 2>/dev/null)" != "function" ]]; then
   emit_event() {
     local event_type="$1"; shift; mkdir -p "${HOME}/.shipwright"
+    # shellcheck disable=SC2155
     local payload="{\"ts\":\"$(date -u +%Y-%m-%dT%H:%M:%SZ)\",\"type\":\"$event_type\""
     while [[ $# -gt 0 ]]; do local key="${1%%=*}" val="${1#*=}"; payload="${payload},\"${key}\":\"${val}\""; shift; done
     echo "${payload}}" >> "${HOME}/.shipwright/events.jsonl"
@@ -100,6 +103,7 @@ get_recent_alerts() {
         tail -"$limit" | while IFS= read -r line; do
         local ts
         local type
+        # shellcheck disable=SC2034
         local msg
 
         ts=$(echo "$line" | jq -r '.ts // ""' 2>/dev/null || echo "")
@@ -167,6 +171,7 @@ show_overview() {
             2>/dev/null | while IFS= read -r line; do
             local issue
             local title
+            # shellcheck disable=SC2034
             local worktree
 
             issue=$(echo "$line" | jq -r '.[0]' 2>/dev/null || echo "")