steve
ac6ce06cdd
Build & push image / build-and-push (push) Successful in 33s
Makes gadfly a consumer of executus (run.Executor compaction/bounding/budget/critic + fanout) and fixes the large-PR token burn in size-gated layers: paginated get_diff, downshift above GADFLY_HUGE_DIFF_BYTES, and a swarm-wide GADFLY_PR_BUDGET_SECS backstop. Small PRs untouched; advisory-only and the static binary preserved. Dogfood swarm reviewed it (6 models, 21 real findings graded + folded in). Co-authored-by: Steve Dudenhoeffer <steve@stevedudenhoeffer.com> Co-committed-by: Steve Dudenhoeffer <steve@stevedudenhoeffer.com>
427 lines
22 KiB
Bash
427 lines
22 KiB
Bash
#!/usr/bin/env bash
|
||
# Gadfly container entrypoint.
|
||
#
|
||
# This is the brains that used to live in the Gitea Actions workflow YAML. A
|
||
# consuming repo only commits a ~15-line stub workflow that runs this image and
|
||
# passes the event context as env; ALL the gating, cloning, model-looping and
|
||
# comment I/O happens here, so the stub stays dumb (act_runner has weak YAML
|
||
# expression support — keep logic in the image, not the workflow).
|
||
#
|
||
# What it does:
|
||
# 1. Decides whether this event should trigger a review (draft skip, comment
|
||
# trigger phrase + allowed-user gate, PR detection). Non-triggers exit 0.
|
||
# 2. Acknowledges a comment trigger with a 👀 reaction.
|
||
# 3. Shallow-clones the PR's head branch (the agentic reviewer reads the
|
||
# checked-out tree to VERIFY findings, not just the diff).
|
||
# 4. Runs the gadfly reviewer once per configured model via run.sh, which
|
||
# upserts one labeled PR comment per model.
|
||
#
|
||
# Advisory only: it never blocks a merge. Config/usage errors exit non-zero;
|
||
# everything review-related is posted as a comment, never a failed check.
|
||
#
|
||
# Env (set by the consumer's stub workflow from the github.* context):
|
||
# GITEA_API https://HOST/api/v1/repos/OWNER/REPO (required)
|
||
# GITEA_TOKEN built-in Actions token (posts comments) (required)
|
||
# OLLAMA_CLOUD_API_KEY Ollama Cloud key; empty => "not configured" notice
|
||
# EVENT_NAME pull_request | issue_comment | workflow_dispatch (required)
|
||
# PR pull request number (required)
|
||
# PR_BRANCH head branch (github.head_ref); empty => fetched from API
|
||
# IS_DRAFT 'true' on a draft PR => skipped
|
||
# COMMENT_BODY comment text (issue_comment only)
|
||
# COMMENT_ID comment id, for the 👀 reaction (issue_comment only)
|
||
# ACTOR github.actor (the user who triggered)
|
||
# Optional config:
|
||
# GADFLY_MODELS comma-separated model ids/specs (alias: OLLAMA_REVIEW_MODELS)
|
||
# GADFLY_PROVIDER majordomo provider for bare model ids (default ollama-cloud;
|
||
# e.g. "ollama" local, "openai", "anthropic", "google")
|
||
# GADFLY_BASE_URL override backend endpoint (OpenAI/Ollama-compatible servers)
|
||
# GADFLY_API_KEY provider key (else provider's standard env: OPENAI_API_KEY, …)
|
||
# CLAUDE_CODE_OAUTH_TOKEN auth for the claude-code engine (GADFLY_MODELS entry
|
||
# "claude-code"/"claude-code/<model>"); Pro/Max subscription
|
||
# token from `claude setup-token`. Else ANTHROPIC_API_KEY.
|
||
# GADFLY_TRIGGER_PHRASE comment phrase that triggers a re-review (default "@gadfly review")
|
||
# GADFLY_ALLOWED_USERS comma-separated usernames allowed to comment-trigger;
|
||
# empty => fall back to "is a repo collaborator"
|
||
# GADFLY_FINDINGS_URL optional gadfly-reports store base URL; set to POST the run +
|
||
# findings for model-quality tracking (off when empty)
|
||
# GADFLY_FINDINGS_TOKEN optional bearer token for the gadfly-reports store
|
||
# GADFLY_CONSOLIDATE cross-model consensus comment: "auto" (default; on for >=2
|
||
# models), "1" force on, "0" force off (one comment per model)
|
||
# GADFLY_INLINE_REVIEW when consolidating, also post a COMMENT-state PR review with
|
||
# inline comments on changed lines (default on; "0" disables)
|
||
set -uo pipefail
|
||
|
||
# One model by default: the specialist suite already provides breadth, so a
|
||
# multi-model default would multiply cost (models × specialists × 2 passes).
|
||
DEFAULT_MODELS="qwen3-coder:480b-cloud"
|
||
TRIGGER_PHRASE="${GADFLY_TRIGGER_PHRASE:-@gadfly review}"
|
||
SCRIPTS_DIR="/app/scripts"
|
||
WORKDIR="${WORKDIR:-/tmp/gadfly}"
|
||
|
||
log() { echo "[gadfly] $*" >&2; }
|
||
die() { log "ERROR: $*"; exit 1; }
|
||
|
||
: "${GITEA_API:?GITEA_API required}"
|
||
: "${GITEA_TOKEN:?GITEA_TOKEN required}"
|
||
: "${PR:?PR required}"
|
||
: "${EVENT_NAME:?EVENT_NAME required}"
|
||
|
||
API() { curl -fsS --connect-timeout 20 --max-time 30 -H "Authorization: token ${GITEA_TOKEN}" "$@"; }
|
||
|
||
# upsert_comment_body MARKER BODY — create or update (by leading MARKER) a single
|
||
# PR comment. Mirrors run.sh's per-model upsert; used for the consensus comment
|
||
# and the per-model fallback when consolidation is on.
|
||
upsert_comment_body() {
|
||
local marker="$1" body="$2" post_body existing_id="" page=1 cmts
|
||
post_body="$(jq -n --arg b "$body" '{body:$b}')"
|
||
while [ "$page" -le 10 ]; do
|
||
cmts="$(API "${GITEA_API}/issues/${PR}/comments?limit=50&page=${page}" || echo '[]')"
|
||
[ "$(echo "$cmts" | jq 'length')" = "0" ] && break
|
||
existing_id="$(echo "$cmts" | jq -r --arg m "$marker" \
|
||
'.[] | select(.body != null and (.body | startswith($m))) | .id' | head -n1)"
|
||
[ -n "$existing_id" ] && break
|
||
page=$((page+1))
|
||
done
|
||
if [ -n "$existing_id" ]; then
|
||
curl -sS --connect-timeout 20 --max-time 30 -X PATCH -H "Authorization: token ${GITEA_TOKEN}" \
|
||
-H "Content-Type: application/json" "${GITEA_API}/issues/comments/${existing_id}" -d "$post_body" >/dev/null
|
||
else
|
||
curl -sS --connect-timeout 20 --max-time 30 -X POST -H "Authorization: token ${GITEA_TOKEN}" \
|
||
-H "Content-Type: application/json" "${GITEA_API}/issues/${PR}/comments" -d "$post_body" >/dev/null
|
||
fi
|
||
}
|
||
|
||
# --- is the commenter allowed to trigger a re-review? ----------------------
|
||
actor_allowed() {
|
||
local actor="$1"
|
||
[ -z "$actor" ] && return 1
|
||
if [ -n "${GADFLY_ALLOWED_USERS:-}" ]; then
|
||
local IFS=','
|
||
for u in $GADFLY_ALLOWED_USERS; do
|
||
[ "$(echo "$u" | tr -d '[:space:]')" = "$actor" ] && return 0
|
||
done
|
||
return 1
|
||
fi
|
||
# No explicit allow-list: allow anyone with collaborator (write) access.
|
||
local code
|
||
code="$(curl -s -o /dev/null -w '%{http_code}' --connect-timeout 20 --max-time 30 \
|
||
-H "Authorization: token ${GITEA_TOKEN}" "${GITEA_API}/collaborators/${actor}")"
|
||
[ "$code" = "204" ]
|
||
}
|
||
|
||
# --- trigger gating --------------------------------------------------------
|
||
case "$EVENT_NAME" in
|
||
workflow_dispatch)
|
||
log "manual dispatch for PR #${PR}" ;;
|
||
pull_request)
|
||
if [ "${IS_DRAFT:-false}" = "true" ]; then
|
||
log "PR #${PR} is a draft; skipping"; exit 0
|
||
fi
|
||
log "new/updated PR #${PR}" ;;
|
||
issue_comment)
|
||
case "${COMMENT_BODY:-}" in
|
||
*"$TRIGGER_PHRASE"*) : ;;
|
||
*) log "comment does not contain trigger phrase ${TRIGGER_PHRASE}; skipping"; exit 0 ;;
|
||
esac
|
||
if ! actor_allowed "${ACTOR:-}"; then
|
||
log "actor '${ACTOR:-}' not allowed to trigger; skipping"; exit 0
|
||
fi
|
||
# Must be a comment on a PR, not a plain issue.
|
||
if ! API "${GITEA_API}/pulls/${PR}" >/dev/null 2>&1; then
|
||
log "issue #${PR} is not a pull request; skipping"; exit 0
|
||
fi
|
||
# Acknowledge with 👀.
|
||
if [ -n "${COMMENT_ID:-}" ]; then
|
||
curl -s -X POST -H "Authorization: token ${GITEA_TOKEN}" -H "Content-Type: application/json" \
|
||
"${GITEA_API}/issues/comments/${COMMENT_ID}/reactions" -d '{"content":"eyes"}' >/dev/null 2>&1 || true
|
||
fi
|
||
log "comment-triggered review for PR #${PR} by ${ACTOR:-?}" ;;
|
||
*)
|
||
log "event '${EVENT_NAME}' not handled; skipping"; exit 0 ;;
|
||
esac
|
||
|
||
# --- resolve head branch ---------------------------------------------------
|
||
BRANCH="${PR_BRANCH:-}"
|
||
if [ -z "$BRANCH" ]; then
|
||
BRANCH="$(API "${GITEA_API}/pulls/${PR}" | jq -r '.head.ref // ""')"
|
||
fi
|
||
[ -z "$BRANCH" ] && die "could not determine PR #${PR} head branch"
|
||
|
||
# --- clone the PR's checked-out tree (shallow) -----------------------------
|
||
HOST="${GITEA_API%%/api/v1/*}" # https://host
|
||
REPO_PATH="${GITEA_API##*/api/v1/repos/}" # owner/repo
|
||
CLONE_URL="https://token:${GITEA_TOKEN}@${HOST#https://}/${REPO_PATH}.git"
|
||
REPO_DIR="${WORKDIR}/repo"
|
||
rm -rf "$REPO_DIR"; mkdir -p "$WORKDIR"
|
||
log "cloning ${REPO_PATH} @ ${BRANCH}"
|
||
git clone --depth=1 --branch "$BRANCH" "$CLONE_URL" "$REPO_DIR" 2>/dev/null \
|
||
|| die "clone of ${REPO_PATH}@${BRANCH} failed"
|
||
|
||
# --- findings telemetry (optional) -----------------------------------------
|
||
# Plumb the run context to the binary (inherited through run.sh and the gadfly
|
||
# process env). The binary's emit is OFF unless GADFLY_FINDINGS_URL is set; when
|
||
# set it POSTs the run + its findings to a gadfly-reports store. GADFLY_FINDINGS_URL /
|
||
# GADFLY_FINDINGS_TOKEN come from the consumer's stub env and are re-exported so
|
||
# they reach the binary even if unset (empty => disabled).
|
||
export GADFLY_REPO="$REPO_PATH"
|
||
export GADFLY_PR="$PR"
|
||
export GADFLY_FINDINGS_URL="${GADFLY_FINDINGS_URL:-}"
|
||
export GADFLY_FINDINGS_TOKEN="${GADFLY_FINDINGS_TOKEN:-}"
|
||
|
||
# --- review once per model, with per-provider concurrency -------------------
|
||
# GADFLY_MODELS is the provider-agnostic name; OLLAMA_REVIEW_MODELS is a
|
||
# back-compat alias. GADFLY_PROVIDER / GADFLY_BASE_URL / GADFLY_API_KEY and any
|
||
# provider key envs (OPENAI_API_KEY, …) are inherited by run.sh and the binary.
|
||
#
|
||
# Concurrency: each PROVIDER is its own lane and lanes run in PARALLEL, so a fast
|
||
# cloud provider isn't stuck behind a slow local box. Within a lane, at most
|
||
# `cap` models run at once. cap = GADFLY_PROVIDER_CONCURRENCY's "provider=N"
|
||
# entry, else GADFLY_CONCURRENCY (default 1). A model's provider is the spec's
|
||
# first path segment ("m1pro/qwen3.6:35b-mlx" -> m1pro), or GADFLY_PROVIDER /
|
||
# ollama-cloud for a bare id. Default (cap 1) keeps a single-provider pool fully
|
||
# sequential, exactly as before.
|
||
MODELS="${GADFLY_MODELS:-${OLLAMA_REVIEW_MODELS:-$DEFAULT_MODELS}}"
|
||
DEFAULT_CONC="${GADFLY_CONCURRENCY:-1}"
|
||
|
||
# --- huge-PR downshift ------------------------------------------------------
|
||
# A very large diff is what burns the model budget: every review step re-sends
|
||
# it, multiplied across models × lenses × passes × steps (this is what nuked a
|
||
# whole Ollama Cloud block on one giant PR). entrypoint is the only process that
|
||
# spans the whole fleet, so the fleet-wide size decision lives here: size the PR
|
||
# diff ONCE, and above GADFLY_HUGE_DIFF_BYTES collapse to a single cheap model +
|
||
# a focused lens subset, fewer steps, no recheck, and a smaller embedded diff.
|
||
# A finished shallow review beats a budget-nuking one. All knobs override; set
|
||
# GADFLY_HUGE_DIFF_BYTES=0 to disable. Small PRs are never touched.
|
||
HUGE_PR=0
|
||
HUGE_DIFF_BYTES="${GADFLY_HUGE_DIFF_BYTES:-600000}"
|
||
if [ "$HUGE_DIFF_BYTES" -gt 0 ] 2>/dev/null; then
|
||
PR_DIFF_BYTES="$(API "${GITEA_API}/pulls/${PR}.diff" 2>/dev/null | wc -c | tr -d '[:space:]')"
|
||
[ -z "$PR_DIFF_BYTES" ] && PR_DIFF_BYTES=0
|
||
if [ "$PR_DIFF_BYTES" -gt "$HUGE_DIFF_BYTES" ] 2>/dev/null; then
|
||
HUGE_PR=1
|
||
log "huge PR: diff ${PR_DIFF_BYTES}B > ${HUGE_DIFF_BYTES}B — downshifting the fleet (advisory)"
|
||
MODELS="${GADFLY_HUGE_DIFF_MODELS:-${MODELS%%,*}}" # first model only by default
|
||
export GADFLY_SPECIALISTS="${GADFLY_HUGE_DIFF_SPECIALISTS:-security,correctness,error-handling}"
|
||
export GADFLY_MAX_STEPS="${GADFLY_HUGE_DIFF_MAX_STEPS:-12}"
|
||
export GADFLY_RECHECK_MAX_STEPS="${GADFLY_HUGE_DIFF_RECHECK_MAX_STEPS:-8}"
|
||
export GADFLY_RECHECK="${GADFLY_HUGE_DIFF_RECHECK:-0}" # skip recheck on huge PRs
|
||
# The Go-visible name directly (run.sh prefers GADFLY_MAX_DIFF_CHARS over its
|
||
# own MAX_DIFF_CHARS), so the cap is honored without relying on run.sh's alias.
|
||
export GADFLY_MAX_DIFF_CHARS="${GADFLY_HUGE_DIFF_MAX_DIFF_CHARS:-20000}"
|
||
# Surfaced on each posted comment so the shallower review is self-explaining.
|
||
export GADFLY_NOTICE="⚠️ Large PR (${PR_DIFF_BYTES} bytes): Gadfly downshifted to a focused, single-model review to stay within budget — coverage is intentionally shallower. Consider splitting the PR for a deeper review."
|
||
fi
|
||
fi
|
||
|
||
provider_of() { case "$1" in */*) echo "${1%%/*}";; *) echo "${GADFLY_PROVIDER:-ollama-cloud}";; esac; }
|
||
|
||
# Per-model status file path for the live board. The model id can contain '/'
|
||
# and ':' (e.g. m1/qwen3:14b), so sanitize to a flat filename; the JSON inside
|
||
# carries the real model/provider, so this just needs to be unique per model.
|
||
STATUS_DIR="${WORKDIR}/status"
|
||
status_file_for() { echo "${STATUS_DIR}/$(echo "$1" | tr -c '[:alnum:]._-' '_').json"; }
|
||
|
||
provider_cap() { # provider -> concurrency (override map "p=N,...", else default)
|
||
local p="$1" item k v
|
||
IFS=',' read -ra _caps <<< "${GADFLY_PROVIDER_CONCURRENCY:-}"
|
||
for item in "${_caps[@]}"; do
|
||
k="$(echo "${item%%=*}" | tr -d '[:space:]')"
|
||
v="$(echo "${item#*=}" | tr -d '[:space:]')"
|
||
if [ "$k" = "$p" ] && [ -n "$v" ]; then echo "$v"; return; fi
|
||
done
|
||
echo "$DEFAULT_CONC"
|
||
}
|
||
|
||
review_one() {
|
||
local sf="" ff=""
|
||
[ "${GADFLY_STATUS_BOARD:-1}" != "0" ] && sf="$(status_file_for "$1")"
|
||
[ "$CONSOLIDATE" = "1" ] && ff="$(findings_file_for "$1")"
|
||
PROVIDER=ollama MODEL="$1" GADFLY_BIN="/usr/local/bin/gadfly" GADFLY_REPO_DIR="$REPO_DIR" \
|
||
GADFLY_STATUS_FILE="$sf" GADFLY_FINDINGS_OUT="$ff" GADFLY_CONSOLIDATE="$CONSOLIDATE" \
|
||
bash "${SCRIPTS_DIR}/run.sh" || log "model $1 failed (continuing)"
|
||
# If the binary never wrote real status (run.sh skipped it: empty diff, no key,
|
||
# binary missing), the pre-seed stays {started:0, done:false} and the board
|
||
# would show this model "waiting to start" forever and never reach N/N. Mark
|
||
# such a never-started file done so the board can complete. The binary stamps a
|
||
# nonzero `started`, so that reliably distinguishes "ran" from "skipped".
|
||
if [ -n "$sf" ] && [ -f "$sf" ] && [ "$(jq -r '.started // 0' "$sf" 2>/dev/null)" = "0" ]; then
|
||
tmp="$(jq '.done = true' "$sf" 2>/dev/null)" && printf '%s' "$tmp" > "$sf"
|
||
fi
|
||
}
|
||
|
||
# Normalize the model list (trim, drop blanks) into MODEL_LIST.
|
||
IFS=',' read -ra _raw <<< "$MODELS" || true
|
||
MODEL_LIST=()
|
||
for raw in "${_raw[@]}"; do m="$(echo "$raw" | tr -d '[:space:]')"; [ -n "$m" ] && MODEL_LIST+=("$m"); done
|
||
|
||
# --- cross-model consolidation decision ------------------------------------
|
||
# With >=2 models, post ONE consensus comment (findings clustered + ranked by
|
||
# cross-model agreement) instead of N per-model walls of prose. Each model writes
|
||
# its findings to FINDINGS_DIR; a final pass (the binary in GADFLY_CONSOLIDATE_DIR
|
||
# mode) renders the consensus comment. GADFLY_CONSOLIDATE: "auto" (default; on for
|
||
# >=2 models), "1" force on, "0" force off (keep per-model comments).
|
||
FINDINGS_DIR="${WORKDIR}/findings"
|
||
CONSOLIDATE=0
|
||
case "${GADFLY_CONSOLIDATE:-auto}" in
|
||
1) CONSOLIDATE=1 ;;
|
||
0) CONSOLIDATE=0 ;;
|
||
*) [ "${#MODEL_LIST[@]}" -ge 2 ] && CONSOLIDATE=1 ;;
|
||
esac
|
||
# A model spec can contain '/' and ':' (e.g. claude-code/opus, qwen3:14b), so
|
||
# sanitize to a flat filename — but append a checksum of the raw spec so two
|
||
# specs that sanitize the same (foo:bar vs foo/bar -> foo_bar) don't collide onto
|
||
# one file and silently drop a model from the consensus.
|
||
findings_file_for() {
|
||
local safe sum
|
||
safe="$(echo "$1" | tr -c '[:alnum:]._-' '_')"
|
||
sum="$(printf '%s' "$1" | cksum | cut -d' ' -f1)"
|
||
echo "${FINDINGS_DIR}/${safe}-${sum}.json"
|
||
}
|
||
if [ "$CONSOLIDATE" = "1" ]; then
|
||
rm -rf "$FINDINGS_DIR"; mkdir -p "$FINDINGS_DIR"
|
||
log "consolidation ON: ${#MODEL_LIST[@]} models -> one consensus comment"
|
||
fi
|
||
|
||
# Distinct providers, in first-seen order (no associative arrays — portable).
|
||
PROVIDERS=""
|
||
for m in "${MODEL_LIST[@]}"; do
|
||
p="$(provider_of "$m")"
|
||
case " $PROVIDERS " in *" $p "*) ;; *) PROVIDERS="${PROVIDERS}${PROVIDERS:+ }$p" ;; esac
|
||
done
|
||
|
||
run_lane() { # $1=provider: run its models, at most `cap` at a time
|
||
local p="$1" cap inflight=0 m
|
||
cap="$(provider_cap "$p")"; [ "$cap" -ge 1 ] 2>/dev/null || cap=1
|
||
local mine=()
|
||
for m in "${MODEL_LIST[@]}"; do [ "$(provider_of "$m")" = "$p" ] && mine+=("$m"); done
|
||
log "lane ${p}: cap ${cap}; models: ${mine[*]}"
|
||
for m in "${mine[@]}"; do
|
||
review_one "$m" &
|
||
inflight=$((inflight+1))
|
||
if [ "$inflight" -ge "$cap" ]; then wait -n 2>/dev/null || wait; inflight=$((inflight-1)); fi
|
||
done
|
||
wait
|
||
}
|
||
|
||
# --- live status board (optional, default on) ------------------------------
|
||
# Each model process publishes per-lens progress to STATUS_DIR/<model>.json; a
|
||
# background renderer (status-board.sh) upserts ONE consolidated PR comment so
|
||
# progress across all models/lenses is visible at a glance — and a watcher can
|
||
# tell when the whole swarm is finished. Advisory/best-effort; the per-model
|
||
# findings still land in each model's own comment. Disable with
|
||
# GADFLY_STATUS_BOARD=0.
|
||
BOARD_PID=""
|
||
if [ "${GADFLY_STATUS_BOARD:-1}" != "0" ]; then
|
||
rm -rf "$STATUS_DIR"; mkdir -p "$STATUS_DIR"
|
||
# Pre-seed every model as queued so the board shows the full swarm from t=0,
|
||
# even models still waiting on their provider lane's concurrency cap. Each
|
||
# binary overwrites its own file with real per-lens detail once it starts.
|
||
for m in "${MODEL_LIST[@]}"; do
|
||
jq -n --arg model "$m" --arg provider "$(provider_of "$m")" \
|
||
'{model:$model, provider:$provider, started:0, updated:0, done:false, lenses:[]}' \
|
||
> "$(status_file_for "$m")" 2>/dev/null || true
|
||
done
|
||
GITEA_API="$GITEA_API" GITEA_TOKEN="$GITEA_TOKEN" PR="$PR" GADFLY_STATUS_DIR="$STATUS_DIR" \
|
||
bash "${SCRIPTS_DIR}/status-board.sh" &
|
||
BOARD_PID=$!
|
||
log "status board started (pid ${BOARD_PID})"
|
||
fi
|
||
|
||
# --- swarm-wide hard backstop ----------------------------------------------
|
||
# A wall-clock ceiling across the WHOLE fleet, so a pathological PR can never
|
||
# drain the usage block however the models behave. entrypoint is the only
|
||
# process spanning every model, so a single "never exceed X" guard lives here.
|
||
# On expiry it stops the review subtrees (the binary + run.sh); whatever partial
|
||
# findings were gathered are still posted and the job never fails (advisory).
|
||
# GADFLY_PR_BUDGET_SECS=0 (default) disables it.
|
||
KILLER_PID=""
|
||
rm -f "${WORKDIR}/.budget_killed" "${WORKDIR}/.disarmed" 2>/dev/null || true
|
||
if [ "${GADFLY_PR_BUDGET_SECS:-0}" -gt 0 ] 2>/dev/null; then
|
||
(
|
||
sleep "${GADFLY_PR_BUDGET_SECS}"
|
||
log "PR wall-clock budget (${GADFLY_PR_BUDGET_SECS}s) reached — stopping the review fleet (advisory; partial findings still posted)"
|
||
: > "${WORKDIR}/.budget_killed"
|
||
pkill -TERM -f '/usr/local/bin/gadfly' 2>/dev/null || true
|
||
pkill -TERM -f "${SCRIPTS_DIR}/run.sh" 2>/dev/null || true
|
||
sleep 5
|
||
# Guard the delayed SIGKILL on the disarm marker: once the lanes finished and
|
||
# the watchdog was disarmed, the consolidation gadfly pass runs next, and a
|
||
# name-based KILL here must NOT catch it.
|
||
[ -f "${WORKDIR}/.disarmed" ] || pkill -KILL -f '/usr/local/bin/gadfly' 2>/dev/null || true
|
||
) &
|
||
KILLER_PID=$!
|
||
log "PR budget watchdog armed (${GADFLY_PR_BUDGET_SECS}s, pid ${KILLER_PID})"
|
||
fi
|
||
|
||
log "providers: ${PROVIDERS:-none}"
|
||
# Each provider lane runs in parallel; cap is enforced within each lane. Track
|
||
# the lane PIDs so we wait ONLY for the review work — not the status board,
|
||
# which intentionally runs until we signal it below.
|
||
LANE_PIDS=()
|
||
for p in $PROVIDERS; do
|
||
run_lane "$p" &
|
||
LANE_PIDS+=("$!")
|
||
done
|
||
[ "${#LANE_PIDS[@]}" -gt 0 ] && wait "${LANE_PIDS[@]}"
|
||
|
||
# Reviews finished (or the watchdog killed them): disarm the watchdog so its
|
||
# delayed SIGKILL can't catch the consolidation pass that runs next. Drop the
|
||
# disarm marker FIRST so even a racing watchdog that already reached its KILL line
|
||
# skips it (the kill below also tears the watchdog subshell down during its sleep).
|
||
if [ -n "$KILLER_PID" ]; then
|
||
: > "${WORKDIR}/.disarmed"
|
||
kill "$KILLER_PID" 2>/dev/null || true
|
||
fi
|
||
|
||
# If the backstop fired, note it on the consensus comment (per-model comments
|
||
# were already posted during the run; a killed model surfaces as a failed lane).
|
||
if [ -f "${WORKDIR}/.budget_killed" ]; then
|
||
export GADFLY_NOTICE="${GADFLY_NOTICE:+${GADFLY_NOTICE} }⏱️ This review was stopped early by the per-PR time budget (GADFLY_PR_BUDGET_SECS); findings are partial."
|
||
fi
|
||
|
||
# Reviews are done: signal the board to render the final state once and exit.
|
||
if [ -n "$BOARD_PID" ]; then
|
||
touch "${STATUS_DIR}/.done" 2>/dev/null || true
|
||
wait "$BOARD_PID" 2>/dev/null || true
|
||
fi
|
||
|
||
# --- cross-model consensus comment -----------------------------------------
|
||
# Render ONE consensus comment from the per-model findings the swarm wrote. This
|
||
# is advisory and best-effort: if the consolidation pass produces nothing, fall
|
||
# back to posting each model's review as its own comment (the per-model comments
|
||
# were suppressed during the run), so a consolidation hiccup never loses output.
|
||
if [ "$CONSOLIDATE" = "1" ]; then
|
||
n_files="$(ls -1 "${FINDINGS_DIR}"/*.json 2>/dev/null | wc -l | tr -d '[:space:]')"
|
||
log "consolidating findings from ${n_files} model(s)"
|
||
# Fetch the PR diff so the consolidator can also post an inline PR review,
|
||
# anchoring findings to changed lines (GADFLY_DIFF_FILE). GITEA_API/GITEA_TOKEN/
|
||
# GADFLY_PR are already in the binary's environment. Best-effort: an empty diff
|
||
# just means no inline review.
|
||
DIFF_FILE="${WORKDIR}/pr.diff"
|
||
API "${GITEA_API}/pulls/${PR}.diff" > "$DIFF_FILE" 2>/dev/null || true
|
||
CONSENSUS="$(GADFLY_CONSOLIDATE_DIR="$FINDINGS_DIR" GADFLY_DIFF_FILE="$DIFF_FILE" \
|
||
/usr/local/bin/gadfly 2>"${WORKDIR}/consolidate.err" || true)"
|
||
if [ -n "$CONSENSUS" ]; then
|
||
NOTICE_BLOCK=""
|
||
[ -n "${GADFLY_NOTICE:-}" ] && NOTICE_BLOCK="> ${GADFLY_NOTICE}"$'\n\n'
|
||
BODY="$(printf '%s%s\n\n<sub>Automated adversarial review by Gadfly — consensus across the model swarm. Advisory only — does not block merge.</sub>' "$NOTICE_BLOCK" "$CONSENSUS")"
|
||
upsert_comment_body "<!-- gadfly-consensus -->" "$BODY"
|
||
log "consensus comment posted"
|
||
else
|
||
log "consolidation produced no output; falling back to per-model comments"
|
||
log "$(tail -c 500 "${WORKDIR}/consolidate.err" 2>/dev/null)"
|
||
for f in "${FINDINGS_DIR}"/*.json; do
|
||
[ -f "$f" ] || continue
|
||
m="$(jq -r '.model // ""' "$f" 2>/dev/null)"
|
||
[ -z "$m" ] && continue
|
||
prov="$(jq -r '.provider // ""' "$f" 2>/dev/null)"
|
||
md="$(jq -r '.markdown // ""' "$f" 2>/dev/null)"
|
||
marker="<!-- gadfly-review:ollama:${m} -->"
|
||
body="$(printf '%s\n### 🪰 Gadfly review — `%s` (%s)\n\n%s\n\n<sub>Automated adversarial review by Gadfly. Advisory only — does not block merge.</sub>' \
|
||
"$marker" "$m" "$prov" "$md")"
|
||
upsert_comment_body "$marker" "$body"
|
||
done
|
||
fi
|
||
fi
|
||
log "done"
|