@oneie/claude 0.6.0 → 0.7.0

package/scripts/do-prove.sh

@@ -1,34 +1,214 @@
 #!/usr/bin/env bash
 # do-prove.sh — PROVE (pure). Promise-check moved to do-reconcile.sh (design canon).
-# Auto-detects surface from changed files → emits the proof action to run.
-# Usage:  do-prove.sh <changed-path>...   |   git diff --name-only | do-prove.sh
+# Auto-detects surface from changed files, then RUNS the proof for frontend surfaces
+# (chrome-headless-shell page check via chrome.mjs, curl fallback against prod).
+#
+# Usage:
+#   do-prove.sh [--route <path>]... [<changed-path>|<cycle-slug>]...
+#   git diff --name-only | do-prove.sh
+#
+# Arg contract:
+#   - Positional args that exist as files/dirs are treated as changed paths.
+#   - Positional args that do NOT exist on disk (e.g. a cycle slug) are ignored
+#     for surface detection; changed paths then come from `git diff --name-only HEAD`.
+#   - --route <path> (repeatable) forces frontend surface + names the route(s) to prove.
+#   - stdin (non-tty) supplies changed paths when no positional paths are given.
+#
+# Env:
+#   PROVE_BASE_URL   dev base for browser check (default http://localhost:4321)
+#   PROVE_PROD_URL   prod fallback base       (default https://one.ie)
+#   PROVE_CHECK_CMD  optional check command for non-frontend surfaces; if set and
+#                    it fails, do-prove.sh exits nonzero.
+#
+# Exit codes: 0 = pass or skipped (no reachable environment) · 1 = a reachable
+# page failed (HTTP >= 500 / status 0 / console+JS errors) or declared check failed.
 set -euo pipefail
 
+ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
+BASE_URL="${PROVE_BASE_URL:-http://localhost:4321}"
+PROD_URL="${PROVE_PROD_URL:-https://one.ie}"
+BROWSER_CHECK="$ROOT/.claude/scripts/chrome.mjs"
+
+routes=()
 paths=()
-if [ "$#" -gt 0 ]; then
-  paths=("$@")
-else
-  while IFS= read -r l; do [ -n "$l" ] && paths+=("$l"); done
+while [ "$#" -gt 0 ]; do
+  case "$1" in
+    --route)
+      [ "$#" -ge 2 ] || { echo "PROVE: --route requires a value"; exit 1; }
+      routes+=("$2"); shift 2 ;;
+    *)
+      # A real path (exists on disk relative to root or cwd) counts as a changed
+      # path; anything else (a cycle slug) is noted and ignored for detection.
+      if [ -e "$1" ] || [ -e "$ROOT/$1" ]; then
+        paths+=("$1")
+      else
+        echo "PROVE: note — '$1' is not a path (cycle slug?); using git diff for surface detection"
+      fi
+      shift ;;
+  esac
+done
+
+# stdin (piped) paths
+if [ "${#paths[@]}" -eq 0 ] && [ ! -t 0 ]; then
+  while IFS= read -r l; do [ -n "$l" ] && paths+=("$l"); done || true
+fi
+
+# git fallback
+if [ "${#paths[@]}" -eq 0 ]; then
+  while IFS= read -r l; do [ -n "$l" ] && paths+=("$l"); done \
+    < <(git -C "$ROOT" diff --name-only HEAD 2>/dev/null || true)
+fi
+
+if [ "${#paths[@]}" -eq 0 ] && [ "${#routes[@]}" -eq 0 ]; then
+  echo "PROVE: no changes"; exit 0
 fi
-[ "${#paths[@]}" -eq 0 ] && { echo "PROVE: no changes"; exit 0; }
 
 # Surface detection — substrate wins (upstream), then api, then frontend, else backend
 surface=backend
-for p in "${paths[@]}"; do
+for p in "${paths[@]+"${paths[@]}"}"; do
   case "$p" in
     *.tql|schema/*) surface=substrate; break ;;
     */pages/api/*|*/api/*) surface=api ;;
     *.astro|*.tsx) [ "$surface" != "api" ] && surface=frontend ;;
   esac
 done
+# Explicit --route forces a frontend proof
+[ "${#routes[@]}" -gt 0 ] && surface=frontend
+echo "surface: $surface"
 
-case "$surface" in
-  frontend)  proof="/browser (real Chrome: HTTP + JS/console errors + rail before/after + screenshot) + Lighthouse" ;;
-  api)       proof="contract test (vitest+msw) + curl per surface — route + SDK + MCP + CLI (four-surface rule)" ;;
-  backend)   proof="curl against the DEPLOYED runtime (local verify is necessary, not sufficient)" ;;
-  substrate) proof="/sync reconcile (TypeDB↔KV↔D1↔SUI) + TypeQL returns the new shape + types compile downhill" ;;
-esac
+# ---------- non-frontend surfaces ----------
+if [ "$surface" != "frontend" ]; then
+  case "$surface" in
+    api)       proof="contract test (vitest+msw) + curl per surface — route + SDK + MCP + CLI (four-surface rule)" ;;
+    backend)   proof="curl against the DEPLOYED runtime (local verify is necessary, not sufficient)" ;;
+    substrate) proof="/sync reconcile (TypeDB↔KV↔D1↔SUI) + TypeQL returns the new shape + types compile downhill" ;;
+  esac
+  echo "proof:   $proof"
+  if [ -n "${PROVE_CHECK_CMD:-}" ]; then
+    echo "PROVE: running declared check: $PROVE_CHECK_CMD"
+    if bash -c "$PROVE_CHECK_CMD"; then
+      echo "PROVE: pass"; exit 0
+    else
+      echo "PROVE: fail (declared check command failed)"; exit 1
+    fi
+  fi
+  echo "PROVE: pass (no declared check command — proof action stated above)"
+  exit 0
+fi
 
-echo "surface: $surface"
-echo "proof:   $proof"
-echo "PROVE: pass"; exit 0
+# ---------- frontend surface: actually prove the page loads ----------
+
+# Route discovery: --route args > .w2-surface-checklist.json > derive from changed pages
+if [ "${#routes[@]}" -eq 0 ] && [ -f "$ROOT/.w2-surface-checklist.json" ] && command -v jq >/dev/null 2>&1; then
+  while IFS= read -r r; do [ -n "$r" ] && routes+=("$r"); done < <(
+    jq -r '((.surfaces // []) | map(.routes // [])[] | .[]?), ((.routes // [])[]?)' \
+      "$ROOT/.w2-surface-checklist.json" 2>/dev/null | sort -u
+  ) || true
+fi
+if [ "${#routes[@]}" -eq 0 ]; then
+  for p in "${paths[@]+"${paths[@]}"}"; do
+    case "$p" in
+      one.ie/web/src/pages/api/*) ;; # api routes, not pages
+      one.ie/web/src/pages/*)
+        r="${p#one.ie/web/src/pages}"
+        r="${r%.astro}"; r="${r%.md}"; r="${r%.mdx}"; r="${r%.ts}"; r="${r%.tsx}"
+        [ "${r##*/}" = "index" ] && r="${r%index}"
+        r="${r%/}"; [ -z "$r" ] && r="/"
+        # skip dynamic routes — no concrete param to check
+        case "$r" in *\[*\]*) continue ;; esac
+        routes+=("$r") ;;
+    esac
+  done
+fi
+[ "${#routes[@]}" -eq 0 ] && routes=("/")
+
+# De-dupe (portable — macOS bash 3.2 has no mapfile)
+deduped=()
+while IFS= read -r r; do deduped+=("$r"); done < <(printf '%s\n' "${routes[@]}" | awk '!seen[$0]++')
+routes=("${deduped[@]}")
+
+dev_up=0
+if curl -sf -o /dev/null --max-time 4 "$BASE_URL/" 2>/dev/null; then dev_up=1; fi
+
+check_route_curl() { # $1 = base, $2 = route → echoes http code
+  curl -s -o /dev/null --max-time 20 -w '%{http_code}' "$1$2" 2>/dev/null || echo "000"
+}
+
+fail=0
+checked=0
+for route in "${routes[@]}"; do
+  proved=0
+  # No node_modules precondition here on purpose. The old gate was
+  # `[ -d /tmp/node_modules/playwright ]`; that directory had already evaporated,
+  # so every browser PROVE silently degraded to the curl fallback while still
+  # printing "ok". chrome.mjs resolves Playwright itself and exits 1 with
+  # {"error":"playwright_not_found"} when it truly cannot run — which the
+  # unparsable-output branch below already treats as environmental.
+  if [ "$dev_up" -eq 1 ] && [ -f "$BROWSER_CHECK" ]; then
+    out="$(node "$BROWSER_CHECK" "$BASE_URL$route" 2>/dev/null || true)"
+    status="$(printf '%s' "$out" | jq -r '.httpStatus // 0' 2>/dev/null || echo 0)"
+    # Same gated-is-not-broken policy the curl leg below already applies: a
+    # subresource answering 401/403 means the page is signed-out, not broken, and
+    # PROVE runs signed-out by default. Measured 2026-08-02 when the browser leg
+    # came back to life: /pricing, /blog and /chat each failed on nothing but
+    # "Failed to load resource: … 401", which curl had always passed. Everything
+    # else still counts — uncaught JS, real console.error, and subresource
+    # 404/5xx, which are genuine breakage.
+    counted='((.jsErrors // []) + ((.consoleErrors // []) | map(select(test("status of (401|403)") | not))))'
+    errs="$(printf '%s' "$out" | jq -r "$counted | length" 2>/dev/null || echo "")"
+    if [ -n "$status" ] && [ "$status" != "0" ] && [ -n "$errs" ]; then
+      proved=1; checked=$((checked+1))
+      # 404 IS A FAIL here too. The curl leg below learned this on 2026-07-29;
+      # the browser leg never did, so a nonexistent route proved itself green
+      # whenever the page also logged no errors. 401/403 stay ok — gated, not gone.
+      if [ "$status" -ge 500 ] || [ "$status" -eq 404 ] || [ "$errs" -gt 0 ]; then
+        echo "PROVE: FAIL $route — http=$status console/js errors=$errs (dev $BASE_URL)"
+        printf '%s' "$out" | jq -r "$counted[]" 2>/dev/null | head -5 | sed 's/^/PROVE:   error: /'
+        fail=1
+      else
+        echo "PROVE: ok $route — http=$status, 0 console/js errors (dev $BASE_URL)"
+      fi
+    fi
+    # status 0 / unparsable = environmental (browser-check couldn't run) → fall through
+  fi
+  if [ "$proved" -eq 0 ] && [ "$dev_up" -eq 1 ]; then
+    # dev reachable but playwright unavailable → curl the dev route
+    code="$(check_route_curl "$BASE_URL" "$route")"
+    if [ "$code" != "000" ]; then
+      proved=1; checked=$((checked+1))
+      # 404 IS A FAIL. It used to report `ok` — only >=500 failed — so a route
+      # that does not exist proved itself. Measured 2026-07-29: `--route /factory`
+      # returned "ok /factory — http=404" against a dev server running a tree
+      # without the page, and that line was the 17th leg of a promise's proof.
+      # 401/403 stay ok: the route exists and answered, it is merely gated.
+      if [ "$code" -ge 500 ] || [ "$code" -eq 404 ]; then
+        echo "PROVE: FAIL $route — http=$code (dev $BASE_URL, curl)"; fail=1
+      else
+        echo "PROVE: ok $route — http=$code (dev $BASE_URL, curl)"
+      fi
+    fi
+  fi
+  if [ "$proved" -eq 0 ]; then
+    code="$(check_route_curl "$PROD_URL" "$route")"
+    if [ "$code" != "000" ]; then
+      checked=$((checked+1))
+      # Same rule as the dev branch above — a 404 in production is the clearest
+      # possible "not shipped", and it must not read as proven.
+      if [ "$code" -ge 500 ] || [ "$code" -eq 404 ]; then
+        echo "PROVE: FAIL $route — http=$code (prod $PROD_URL)"; fail=1
+      else
+        echo "PROVE: ok $route — http=$code (prod $PROD_URL)"
+      fi
+    else
+      echo "PROVE: unreachable $route — neither $BASE_URL nor $PROD_URL responded"
+    fi
+  fi
+done
+
+if [ "$fail" -eq 1 ]; then
+  echo "PROVE: fail"; exit 1
+fi
+if [ "$checked" -eq 0 ]; then
+  echo "PROVE: skipped (no reachable environment)"; exit 0
+fi
+echo "PROVE: pass ($checked route(s) proven)"; exit 0