Skip to content

Evenfire is an intelligence layer platform for running LLM agents that take real actions, on your infrastructure

TypeScript
16.5 KB
Raw Blame
#!/usr/bin/env bash
set -euo pipefail

BASE_REF="${REPO_INTAKE_BASE_REF:-origin/dev}"
MEASURE=false
HISTORICAL=false
# Measurement mode uses the development base unless a historical comparison
# is explicitly requested. It never changes the normal T2 intake policy.
if [[ "${1:-}" == "--measure" ]]; then
  MEASURE=true
  BASE_REF=origin/dev
  shift
  if [[ "${1:-}" == "--historical-base" ]]; then
    [[ $# -ge 2 && -n "$2" && "$2" != -* ]] || { echo 'ERROR: historical base required' >&2; exit 2; }
    HISTORICAL=true
    BASE_REF="$2"
    shift 2
  fi
  [[ "${1:-}" == "--" && $# -ge 2 ]] || { echo 'Usage: repo-intake-packet.sh --measure [--historical-base REF] -- COMMAND [ARG...]' >&2; exit 2; }
  shift
elif (( $# )); then
  echo 'ERROR: unknown repo intake arguments' >&2
  exit 2
fi
SCRIPT_ROOT="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")/../.." && pwd -P)"
BLOCKERS=()
WARNINGS=()
TOUCHED_AREAS=()

die() { printf 'ERROR: %s\n' "$*" >&2; exit 1; }
section() { printf '\n== %s ==\n' "$1"; }
kv() { printf '%-30s %s\n' "$1:" "$2"; }
join() { if (( $# )); then local IFS=", "; printf '%s' "$*"; else printf 'none'; fi; }
join_touched() { if (( ${#TOUCHED_AREAS[@]} )); then join "${TOUCHED_AREAS[@]}"; else printf 'none'; fi; }
join_blockers() { if (( ${#BLOCKERS[@]} )); then join "${BLOCKERS[@]}"; else printf 'none'; fi; }
join_warnings() { if (( ${#WARNINGS[@]} )); then join "${WARNINGS[@]}"; else printf 'none'; fi; }

abs_dir() {
  [[ -d "${1:-}" ]] || return 1
  (cd "$1" && pwd -P)
}

resolve_ref() {
  git rev-parse --verify --quiet "$1^{commit}" 2>/dev/null ||
    git rev-parse --verify --quiet "refs/remotes/$1^{commit}" 2>/dev/null ||
    true
}

short_ref() { git rev-parse --short=8 "$1" 2>/dev/null || printf 'unknown'; }
ahead_behind() { git rev-list --left-right --count "$1...$2" 2>/dev/null || printf 'n/a n/a\n'; }

area_for_path() {
  case "$1" in
    control-api/*) printf 'control-api' ;;
    external-rest-api/*) printf 'external-rest-api' ;;
    rpc-proxy/*) printf 'rpc-proxy' ;;
    mcp-host/*) printf 'mcp-host' ;;
    host-context-controller/*) printf 'host-context-controller' ;;
    workflow-recipes/*) printf 'workflow-recipes' ;;
    packages/workflow-sdk/*) printf 'packages/workflow-sdk' ;;
    workflow-approval-request-reader/*) printf 'workflow-approval-request-reader' ;;
    control-ui/*) printf 'control-ui' ;;
    desktop-app/*) printf 'desktop-app' ;;
    profile-ui/*) printf 'profile-ui' ;;
    mcp-servers/*) printf 'mcp-servers' ;;
    tests/e2e/*) printf 'tests/e2e' ;;
    scripts/minikube/*) printf 'scripts/minikube' ;;
    scripts/e2e/*) printf 'scripts/e2e' ;;
    scripts/dev/*) printf 'scripts/dev' ;;
    scripts/tests/*) printf 'scripts/tests' ;;
    deploy/*) printf 'deploy' ;;
    charts/*) printf 'charts' ;;
    docs/*) printf 'docs' ;;
    AGENTS.md|CLAUDE.md|Makefile) printf 'repo-rules' ;;
    package.json|package-lock.json) printf 'repo-package' ;;
    *) printf '' ;;
  esac
}

add_area() {
  local area="$1" existing
  [[ -n "${area}" ]] || return 0
  if (( ${#TOUCHED_AREAS[@]} == 0 )); then
    TOUCHED_AREAS+=("${area}")
    return
  fi
  for existing in "${TOUCHED_AREAS[@]}"; do
    [[ "${existing}" == "${area}" ]] && return
  done
  TOUCHED_AREAS+=("${area}")
}

collect_touched_areas() {
  local path area
  while IFS= read -r path; do
    [[ -n "${path}" ]] || continue
    area="$(area_for_path "${path}")"
    add_area "${area}"
  done < <(
    {
      git diff --name-only HEAD 2>/dev/null || true
      git ls-files --others --exclude-standard 2>/dev/null || true
    } | sort -u
  )
}

count_status() {
  local line xy x y status_out
  STATUS_TOTAL=0
  STATUS_STAGED=0
  STATUS_UNSTAGED=0
  STATUS_UNTRACKED=0
  STATUS_CONFLICTS=0
  # Zero counts from an unreadable status would look like a clean tree; the
  # measurement gate blocks on STATUS_READABLE=false.
  STATUS_READABLE=true
  if ! status_out="$(git status --porcelain=v1 -uall 2>/dev/null)"; then
    STATUS_READABLE=false
    return 0
  fi

  while IFS= read -r line; do
    [[ -n "${line}" ]] || continue
    STATUS_TOTAL=$((STATUS_TOTAL + 1))
    xy="${line:0:2}"
    if [[ "${xy}" == "??" ]]; then
      STATUS_UNTRACKED=$((STATUS_UNTRACKED + 1))
      continue
    fi

    x="${line:0:1}"
    y="${line:1:1}"
    [[ "${x}" != " " ]] && STATUS_STAGED=$((STATUS_STAGED + 1))
    [[ "${y}" != " " ]] && STATUS_UNSTAGED=$((STATUS_UNSTAGED + 1))
    case "${xy}" in
      DD|AU|UD|UA|DU|AA|UU) STATUS_CONFLICTS=$((STATUS_CONFLICTS + 1)) ;;
    esac
  done <<< "${status_out}"
}

resolve_primary_checkout() {
  local configured="${REPO_INTAKE_PRIMARY_CHECKOUT:-${CLERUM_PRIMARY_CHECKOUT:-}}"
  local common_dir common_abs=""

  if [[ -n "${configured}" ]]; then
    if abs_dir "${configured}" >/dev/null; then
      abs_dir "${configured}"
      return
    fi
    WARNINGS+=("configured_primary_checkout_missing")
  fi

  common_dir="$(git rev-parse --git-common-dir 2>/dev/null || true)"
  if [[ "${common_dir}" = /* ]]; then
    common_abs="${common_dir}"
  elif [[ -d "${common_dir}" ]]; then
    common_abs="$(cd "${common_dir}" && pwd -P)"
  fi

  if [[ -n "${common_abs}" && "${common_abs}" == */.git ]]; then
    printf '%s\n' "${common_abs%/.git}"
  else
    printf '%s\n' "${REPO_ROOT}"
  fi
}

record_value() {
  awk -F= -v wanted="$2" '$1 == wanted { sub(/^[^=]*=/, ""); print; exit }' <<<"$1"
}

REPO_ROOT="$(git rev-parse --show-toplevel 2>/dev/null || true)"
[[ -n "${REPO_ROOT}" ]] || die "not inside a git repository"
REPO_ROOT="$(cd "${REPO_ROOT}" && pwd -P)"
cd "${REPO_ROOT}"

BRANCH="$(git branch --show-current 2>/dev/null || true)"
DETACHED="no"
PROFILE_BRANCH="${BRANCH}"
if [[ -z "${PROFILE_BRANCH}" ]]; then
  DETACHED="yes"
  PROFILE_BRANCH="detached-$(short_ref HEAD)"
fi

HEAD_FULL="$(git rev-parse --verify HEAD 2>/dev/null || true)"
[[ -n "${HEAD_FULL}" ]] || die "unable to resolve HEAD"
HEAD_SHORT="$(short_ref HEAD)"

UPSTREAM="$(git rev-parse --abbrev-ref --symbolic-full-name '@{upstream}' 2>/dev/null || true)"
[[ -n "${UPSTREAM}" ]] || UPSTREAM="none"

BASE_COMMIT="$(resolve_ref "${BASE_REF}")"
BASE_PRESENT="no"
BASE_SHORT="missing"
BASE_AHEAD="n/a"
BASE_BEHIND="n/a"
BASE_STATUS="missing"
if [[ -n "${BASE_COMMIT}" ]]; then
  BASE_PRESENT="yes"
  BASE_SHORT="$(short_ref "${BASE_COMMIT}")"
  read -r BASE_AHEAD BASE_BEHIND <<<"$(ahead_behind HEAD "${BASE_COMMIT}")"
  if [[ "${BASE_BEHIND}" != "n/a" && "${BASE_BEHIND}" -gt 0 ]]; then
    BASE_STATUS="stale_missing_${BASE_BEHIND}_base_commits"
    BLOCKERS+=("branch_missing_${BASE_REF}_commits")
  elif [[ "${BASE_AHEAD}" != "n/a" && "${BASE_AHEAD}" -gt 0 ]]; then
    BASE_STATUS="contains_base_with_${BASE_AHEAD}_local_commits"
  elif [[ "${BASE_AHEAD}" == "0" && "${BASE_BEHIND}" == "0" ]]; then
    BASE_STATUS="at_base"
  else
    BASE_STATUS="unknown"
    BLOCKERS+=("base_comparison_failed")
  fi
else
  BLOCKERS+=("missing_${BASE_REF}")
fi

if [[ "${MEASURE}" == true ]]; then
  [[ "${DETACHED}" == no || "${HISTORICAL}" == true ]] || BLOCKERS+=("detached_measurement")
  count_status
  [[ "${STATUS_READABLE}" == true ]] || BLOCKERS+=("status_unreadable")
  (( STATUS_CONFLICTS == 0 )) || BLOCKERS+=("unresolved_conflicts")
  kv "measurement_head" "${HEAD_FULL}"
  kv "measurement_base_ref" "${BASE_REF}"
  kv "measurement_base_commit" "${BASE_COMMIT:-missing}"
  kv "measurement_base_status" "${BASE_STATUS}"
  kv "measurement_dirty_count" "${STATUS_TOTAL}"
  kv "measurement_ref_source" "local_git_refs_no_fetch"
  if (( ${#BLOCKERS[@]} )); then
    kv "measurement_readiness" "blocked"
    kv "blockers" "$(join_blockers)"
    exit 2
  fi
  if [[ "${HISTORICAL}" == true ]]; then
    kv "measurement_readiness" "historical_non_certifying"
  else
    kv "measurement_readiness" "base_check_passed_not_a_lane_verdict"
  fi
  exec "$@"
fi

UPSTREAM_AHEAD="n/a"
UPSTREAM_BEHIND="n/a"
if [[ "${UPSTREAM}" != "none" ]]; then
  read -r UPSTREAM_AHEAD UPSTREAM_BEHIND <<<"$(ahead_behind HEAD "${UPSTREAM}")"
fi

count_status
if (( STATUS_CONFLICTS > 0 )); then
  BLOCKERS+=("unresolved_conflicts")
elif (( STATUS_TOTAL > 0 )); then
  WARNINGS+=("dirty_worktree_review_required")
fi
collect_touched_areas

WORKTREE_PORCELAIN="$(git worktree list --porcelain --expire now 2>/dev/null || true)"
WORKTREE_COUNT="$(printf '%s\n' "${WORKTREE_PORCELAIN}" | grep -c '^worktree ' || true)"
PRUNABLE_COUNT="$(printf '%s\n' "${WORKTREE_PORCELAIN}" | grep -c '^prunable' || true)"

PRIMARY_CHECKOUT="$(resolve_primary_checkout)"
LOCAL_PROFILE_HELPER="${REPO_ROOT}/scripts/minikube-profiles/branch.mk"
PRIMARY_PROFILE_HELPER="${PRIMARY_CHECKOUT}/scripts/minikube-profiles/branch.mk"
LOCAL_HELPER_EXISTS="no"
PRIMARY_HELPER_EXISTS="no"
PROFILE_HELPER_EXISTS="no"
PROFILE_HELPER_COMMAND="unavailable"
PROFILE_OWNER_SCRIPT="${SCRIPT_ROOT}/scripts/minikube/profile-owner.sh"
PROFILE_OWNER_AVAILABLE="no"

[[ -f "${LOCAL_PROFILE_HELPER}" ]] && LOCAL_HELPER_EXISTS="yes"
[[ -f "${PRIMARY_PROFILE_HELPER}" ]] && PRIMARY_HELPER_EXISTS="yes"
if [[ "${LOCAL_HELPER_EXISTS}" == "yes" ]]; then
  PROFILE_HELPER_EXISTS="yes"
  PROFILE_HELPER_COMMAND="make -f ${LOCAL_PROFILE_HELPER} branch-profile-info"
elif [[ "${PRIMARY_HELPER_EXISTS}" == "yes" ]]; then
  PROFILE_HELPER_EXISTS="yes"
  PROFILE_HELPER_COMMAND="make -f ${PRIMARY_PROFILE_HELPER} branch-profile-info"
else
  BLOCKERS+=("missing_branch_profile_helper")
fi

if [[ -x "${PROFILE_OWNER_SCRIPT}" ]]; then
  PROFILE_OWNER_AVAILABLE="yes"
else
  BLOCKERS+=("missing_profile_owner_resolver")
fi

PROFILE_ROOT="${REPO_INTAKE_PROFILE_ROOT:-${CLERUM_PROFILE_CACHE_ROOT:-${HOME}/.cache/clerum/minikube-profiles}}"
EXPLICIT_PROFILE="${REPO_INTAKE_PROFILE:-${MINIKUBE_PROFILE:-}}"
EXPLICIT_PROFILE_ENV="${REPO_INTAKE_PROFILE_ENV:-${T2_PROFILE_ENV:-}}"
EXPLICIT_PORTS_ENV="${REPO_INTAKE_PORTS_ENV:-${CLERUM_PROFILE_PORTS_ENV:-${T2_PORTS_ENV:-}}}"
PROFILE_SELECTION_EXPLICIT="no"
if [[ -n "${EXPLICIT_PROFILE}" || -n "${EXPLICIT_PROFILE_ENV}" || -n "${EXPLICIT_PORTS_ENV}" ]]; then
  PROFILE_SELECTION_EXPLICIT="yes"
fi

EXPECTED_PROFILE="unavailable"
NEW_PROFILE_CANDIDATE="unavailable"
PROFILE_OWNER_ID="unavailable"
PROFILE_WORKTREE_ID="unavailable"
PROFILE_IDENTITY_OUTPUT=""
if [[ "${PROFILE_OWNER_AVAILABLE}" == "yes" ]]; then
  identity_status=0
  PROFILE_IDENTITY_OUTPUT="$("${PROFILE_OWNER_SCRIPT}" identity \
    --repo-dir "${REPO_ROOT}" --branch "${PROFILE_BRANCH}" \
    --created-head "${HEAD_FULL}" 2>&1)" || identity_status=$?
  if (( identity_status == 0 )); then
    EXPECTED_PROFILE="$(record_value "${PROFILE_IDENTITY_OUTPUT}" PROFILE)"
    NEW_PROFILE_CANDIDATE="${EXPECTED_PROFILE}"
    PROFILE_OWNER_ID="$(record_value "${PROFILE_IDENTITY_OUTPUT}" OWNER_ID)"
    PROFILE_WORKTREE_ID="$(record_value "${PROFILE_IDENTITY_OUTPUT}" WORKTREE_ID)"
  else
    BLOCKERS+=("profile_identity_resolution_failed")
  fi
fi

PROFILE_CACHE_STATE="absent"
PROFILE_CACHE_REPO_MATCH="n/a"
PROFILE_CACHE_BRANCH_MATCH="n/a"
PROFILE_CACHE_OWNER_MATCH="n/a"
PROFILE_CACHE_SHA_MATCH="not_applicable"
PROFILE_CACHE_SCHEMA="n/a"
PROFILE_CACHE_CREATION_HEAD="n/a"
RESOLVED_PROFILE="none"
RESOLVED_PROFILE_ENV="none"
RESOLVED_PORTS_ENV="none"
PROFILE_RESOLUTION_CODE="not_attempted"

if [[ "${PROFILE_OWNER_AVAILABLE}" == "yes" ]]; then
  resolve_args=(resolve --repo-dir "${REPO_ROOT}" --branch "${PROFILE_BRANCH}" --profile-root "${PROFILE_ROOT}")
  [[ -z "${EXPLICIT_PROFILE}" ]] || resolve_args+=(--profile "${EXPLICIT_PROFILE}")
  [[ -z "${EXPLICIT_PROFILE_ENV}" ]] || resolve_args+=(--profile-env "${EXPLICIT_PROFILE_ENV}")
  [[ -z "${EXPLICIT_PORTS_ENV}" ]] || resolve_args+=(--ports-env "${EXPLICIT_PORTS_ENV}")
  resolution_status=0
  PROFILE_RESOLUTION_OUTPUT="$("${PROFILE_OWNER_SCRIPT}" "${resolve_args[@]}" 2>&1)" || resolution_status=$?
  if (( resolution_status == 0 )); then
    PROFILE_RESOLUTION_CODE="resolved"
    PROFILE_CACHE_STATE="present"
    PROFILE_CACHE_REPO_MATCH="yes"
    PROFILE_CACHE_BRANCH_MATCH="yes"
    PROFILE_CACHE_OWNER_MATCH="yes"
    PROFILE_CACHE_SCHEMA="$(record_value "${PROFILE_RESOLUTION_OUTPUT}" PROFILE_SCHEMA_VERSION)"
    PROFILE_CACHE_CREATION_HEAD="$(record_value "${PROFILE_RESOLUTION_OUTPUT}" CREATED_HEAD)"
    RESOLVED_PROFILE="$(record_value "${PROFILE_RESOLUTION_OUTPUT}" PROFILE)"
    EXPECTED_PROFILE="${RESOLVED_PROFILE}"
    RESOLVED_PROFILE_ENV="$(record_value "${PROFILE_RESOLUTION_OUTPUT}" PROFILE_ENV)"
    RESOLVED_PORTS_ENV="$(record_value "${PROFILE_RESOLUTION_OUTPUT}" PORTS_ENV)"
  else
    PROFILE_RESOLUTION_CODE="${PROFILE_RESOLUTION_OUTPUT%%:*}"
    case "${PROFILE_RESOLUTION_CODE}" in
      PROFILE_NOT_FOUND)
        if [[ "${PROFILE_SELECTION_EXPLICIT}" == "yes" ]]; then
          PROFILE_CACHE_STATE="invalid"
          BLOCKERS+=("selected_profile_not_found")
        else
          WARNINGS+=("profile_cache_not_initialized")
        fi ;;
      PROFILE_SELECTION_AMBIGUOUS)
        PROFILE_CACHE_STATE="ambiguous"
        BLOCKERS+=("profile_selection_ambiguous") ;;
      PROFILE_PORTS_MISSING)
        PROFILE_CACHE_STATE="invalid"
        BLOCKERS+=("profile_ports_missing") ;;
      PROFILE_PORTS_INVALID)
        PROFILE_CACHE_STATE="invalid"
        BLOCKERS+=("profile_ports_invalid") ;;
      PROFILE_METADATA_MISSING)
        PROFILE_CACHE_STATE="invalid"
        BLOCKERS+=("profile_metadata_missing") ;;
      PROFILE_METADATA_INVALID)
        PROFILE_CACHE_STATE="invalid"
        BLOCKERS+=("profile_metadata_invalid") ;;
      PROFILE_OWNERSHIP_MISMATCH)
        PROFILE_CACHE_STATE="invalid"
        PROFILE_CACHE_REPO_MATCH="no"
        PROFILE_CACHE_BRANCH_MATCH="no"
        PROFILE_CACHE_OWNER_MATCH="no"
        BLOCKERS+=("profile_cache_ownership_mismatch") ;;
      *)
        PROFILE_CACHE_STATE="invalid"
        BLOCKERS+=("profile_metadata_invalid") ;;
    esac
  fi
fi

[[ "${DETACHED}" == "yes" ]] && WARNINGS+=("detached_worktree_confirm_scope")
if [[ "${PROFILE_HELPER_EXISTS}" == "yes" && "${PROFILE_CACHE_STATE}" == "absent" ]]; then
  WARNINGS+=("run_branch_profile_helper_before_t2")
fi

READINESS="ready"
if (( ${#BLOCKERS[@]} > 0 )); then
  READINESS="blocked"
elif (( ${#WARNINGS[@]} > 0 )); then
  READINESS="caution"
fi

section "Repo"
for row in \
  "repo_root|${REPO_ROOT}" \
  "primary_checkout|${PRIMARY_CHECKOUT}" \
  "branch|${BRANCH:-detached}" \
  "detached|${DETACHED}" \
  "head|${HEAD_SHORT}" \
  "upstream|${UPSTREAM}" \
  "upstream_ahead_behind|${UPSTREAM_AHEAD}/${UPSTREAM_BEHIND}" \
  "expected_base|${BASE_REF}" \
  "base_present|${BASE_PRESENT}" \
  "base_head|${BASE_SHORT}" \
  "base_ahead_behind|${BASE_AHEAD}/${BASE_BEHIND}" \
  "base_status|${BASE_STATUS}"; do
  kv "${row%%|*}" "${row#*|}"
done

section "Working Tree"
kv "dirty_summary" "total=${STATUS_TOTAL} staged=${STATUS_STAGED} unstaged=${STATUS_UNSTAGED} untracked=${STATUS_UNTRACKED} conflicts=${STATUS_CONFLICTS}"
kv "touched_areas" "$(join_touched)"
kv "worktree_count" "${WORKTREE_COUNT}"
kv "prunable_count" "${PRUNABLE_COUNT}"

section "Branch Profile"
for row in \
  "profile_helper_local|${LOCAL_HELPER_EXISTS}" \
  "profile_helper_primary|${PRIMARY_HELPER_EXISTS}" \
  "profile_helper_exists|${PROFILE_HELPER_EXISTS}" \
  "profile_helper_command|${PROFILE_HELPER_COMMAND}" \
  "profile_owner_resolver|${PROFILE_OWNER_AVAILABLE}" \
  "profile_selection_explicit|${PROFILE_SELECTION_EXPLICIT}" \
  "expected_profile|${EXPECTED_PROFILE}" \
  "new_profile_candidate|${NEW_PROFILE_CANDIDATE}" \
  "resolved_profile|${RESOLVED_PROFILE}" \
  "profile_cache_state|${PROFILE_CACHE_STATE}" \
  "profile_cache_schema|${PROFILE_CACHE_SCHEMA}" \
  "profile_cache_creation_head|${PROFILE_CACHE_CREATION_HEAD}" \
  "profile_cache_repo_match|${PROFILE_CACHE_REPO_MATCH}" \
  "profile_cache_branch_match|${PROFILE_CACHE_BRANCH_MATCH}" \
  "profile_cache_owner_match|${PROFILE_CACHE_OWNER_MATCH}" \
  "profile_cache_sha_match|${PROFILE_CACHE_SHA_MATCH}" \
  "profile_owner_id|${PROFILE_OWNER_ID}" \
  "profile_worktree_id|${PROFILE_WORKTREE_ID}" \
  "profile_env|${RESOLVED_PROFILE_ENV}" \
  "ports_env|${RESOLVED_PORTS_ENV}" \
  "profile_resolution|${PROFILE_RESOLUTION_CODE}"; do
  kv "${row%%|*}" "${row#*|}"
done

section "Validation Tiers"
kv "T0_intake" "complete: repo packet generated"
if (( ${#TOUCHED_AREAS[@]} > 0 )); then
  kv "T1_focus" "run focused checks for: $(join_touched)"
else
  kv "T1_focus" "choose package-scoped checks after edits"
fi
if [[ "${READINESS}" == "blocked" ]]; then
  kv "T2_local_runtime" "blocked until blockers are resolved"
else
  kv "T2_local_runtime" "allowed only after T1 passes and profile ownership is confirmed"
fi
kv "T3_live_dev_prod" "requires explicit user authorization and target context"

section "Gate Decision"
kv "t2_readiness" "${READINESS}"
kv "blockers" "$(join_blockers)"
kv "warnings" "$(join_warnings)"
kv "profile_ports_command" "${PROFILE_HELPER_COMMAND}"
kv "trust_boundary_check" "required before accepting E2E evidence"

[[ "${READINESS}" == "blocked" ]] && exit 2
exit 0