fix: timer leak and http field shadowing in github client

- Add timer.Stop() to the timer.C branch to prevent timer leak on the
  normal path (previously only called in ctx.Done branch)
- Rename struct field 'http' to 'httpClient' to avoid shadowing the
  net/http import

Addresses self-review findings on PR #110.

.github/actions/review/action.yml

@@ -1,200 +0,0 @@
-# This composite action is designed for Gitea Actions runners.
-# Gitea Actions supports GitHub Actions syntax including $GITHUB_OUTPUT,
-# actions/cache, and actions/checkout.
-# Requirements: python3, sha256sum, curl (all present on ubuntu-* runners).
-name: 'AI Code Review'
-description: 'Run AI-powered code review on a pull request using review-bot'
-
-inputs:
-  gitea-url:
-    description: 'Gitea instance URL (defaults to server_url)'
-    required: false
-    default: ''
-  repo:
-    description: 'Repository (owner/name, defaults to current)'
-    required: false
-    default: ''
-  pr-number:
-    description: 'Pull request number (defaults to current PR)'
-    required: false
-    default: ''
-  reviewer-token:
-    description: 'Gitea token for posting the review'
-    required: true
-  reviewer-name:
-    description: 'Display name for the reviewer'
-    required: false
-    default: ''
-  llm-base-url:
-    description: 'OpenAI-compatible LLM API base URL (not required for aicore provider)'
-    required: false
-    default: ''
-  llm-api-key:
-    description: 'LLM API key (not required for aicore provider)'
-    required: false
-    default: ''
-  llm-model:
-    description: 'LLM model name'
-    required: true
-  llm-provider:
-    description: 'LLM API provider: openai, anthropic, or aicore (default openai)'
-    required: false
-    default: 'openai'
-  aicore-client-id:
-    description: 'SAP AI Core client ID (required for aicore provider)'
-    required: false
-    default: ''
-  aicore-client-secret:
-    description: 'SAP AI Core client secret (required for aicore provider)'
-    required: false
-    default: ''
-  aicore-auth-url:
-    description: 'SAP AI Core authentication URL (required for aicore provider)'
-    required: false
-    default: ''
-  aicore-api-url:
-    description: 'SAP AI Core API URL (required for aicore provider)'
-    required: false
-    default: ''
-  aicore-resource-group:
-    description: 'SAP AI Core resource group (default: default)'
-    required: false
-    default: 'default'
-  conventions-file:
-    description: 'Path to conventions file in the repo (e.g. CLAUDE.md)'
-    required: false
-    default: ''
-  patterns-repo:
-    description: 'Comma-separated repos with language patterns (e.g. rodin/elixir-patterns,rodin/phoenix-conventions)'
-    required: false
-    default: ''
-  patterns-files:
-    description: 'Comma-separated file paths or directories to fetch from patterns repos'
-    required: false
-    default: 'README.md'
-  temperature:
-    description: 'LLM temperature (0 = server default)'
-    required: false
-    default: '0'
-  timeout:
-    description: 'LLM request timeout in seconds (default 300)'
-    required: false
-    default: '300'
-  version:
-    description: 'review-bot version to install (e.g. v0.1.0, defaults to latest)'
-    required: false
-    default: 'latest'
-  dry-run:
-    description: 'Print review to stdout instead of posting'
-    required: false
-    default: 'false'
-  update-existing:
-    description: 'Delete previous review from same bot after posting new one. Accepts: true/1/yes or false/0/no (default true)'
-    required: false
-    default: 'true'
-  system-prompt-file:
-    description: 'Local file with additional system prompt instructions (e.g. security review focus)'
-    required: false
-    default: ''
-  persona:
-    description: 'Built-in persona name (security, architect, docs)'
-    required: false
-    default: ''
-  persona-file:
-    description: 'Path to custom persona JSON file'
-    required: false
-    default: ''
-
-runs:
-  using: 'composite'
-  steps:
-    - name: Determine version
-      id: version
-      shell: bash
-      run: |
-        GITEA_URL="${{ inputs.gitea-url || github.server_url }}"
-        REPO="${{ inputs.repo || 'rodin/review-bot' }}"
-        if [ "${{ inputs.version }}" = "latest" ]; then
-          VERSION=$(curl -sSf "${GITEA_URL}/api/v1/repos/${REPO}/releases?limit=1" \
-            | python3 -c "import sys, json; releases = json.load(sys.stdin); print(releases[0]['tag_name'] if releases else '')")
-          if [ -z "$VERSION" ]; then
-            echo "Failed to determine latest version" >&2
-            exit 1
-          fi
-        else
-          VERSION="${{ inputs.version }}"
-        fi
-        echo "version=${VERSION}" >> "$GITHUB_OUTPUT"
-
-    - name: Cache review-bot binary
-      id: cache
-      uses: actions/cache@v4
-      with:
-        path: ${{ runner.temp }}/review-bot
-        key: review-bot-linux-amd64-${{ steps.version.outputs.version }}
-
-    - name: Install review-bot
-      if: steps.cache.outputs.cache-hit != 'true'
-      shell: bash
-      run: |
-        GITEA_URL="${{ inputs.gitea-url || github.server_url }}"
-        REPO="${{ inputs.repo || 'rodin/review-bot' }}"
-        VERSION="${{ steps.version.outputs.version }}"
-        BINARY="review-bot-linux-amd64"
-
-        curl -sSfL "${GITEA_URL}/${REPO}/releases/download/${VERSION}/${BINARY}" \
-          -o "${{ runner.temp }}/review-bot"
-        curl -sSfL "${GITEA_URL}/${REPO}/releases/download/${VERSION}/checksums.txt" \
-          -o "${{ runner.temp }}/checksums.txt"
-
-        # Verify SHA-256 checksum
-        cd "${{ runner.temp }}"
-        EXPECTED=$(grep "${BINARY}" checksums.txt | awk '{print $1}')
-        ACTUAL=$(sha256sum review-bot | awk '{print $1}')
-
-        if [ -z "$EXPECTED" ]; then
-          echo "Error: no checksum found for ${BINARY}" >&2
-          exit 1
-        fi
-        if [ "$EXPECTED" != "$ACTUAL" ]; then
-          echo "Error: checksum mismatch!" >&2
-          echo "  Expected: $EXPECTED" >&2
-          echo "  Actual:   $ACTUAL" >&2
-          exit 1
-        fi
-
-        chmod +x "${{ runner.temp }}/review-bot"
-        echo "Installed review-bot ${VERSION} (checksum verified)"
-
-    - name: Run review
-      shell: bash
-      env:
-        GITHUB_SERVER_URL: ${{ inputs.gitea-url || github.server_url }}
-        GITHUB_REPOSITORY: ${{ inputs.repo || github.repository }}
-        PR_NUMBER: ${{ inputs.pr-number || github.event.pull_request.number }}
-        REVIEWER_TOKEN: ${{ inputs.reviewer-token }}
-        REVIEWER_NAME: ${{ inputs.reviewer-name }}
-        LLM_BASE_URL: ${{ inputs.llm-base-url }}
-        LLM_API_KEY: ${{ inputs.llm-api-key }}
-        LLM_MODEL: ${{ inputs.llm-model }}
-        CONVENTIONS_FILE: ${{ inputs.conventions-file }}
-        PATTERNS_REPO: ${{ inputs.patterns-repo }}
-        PATTERNS_FILES: ${{ inputs.patterns-files }}
-        LLM_TEMPERATURE: ${{ inputs.temperature }}
-        LLM_TIMEOUT: ${{ inputs.timeout }}
-        LLM_PROVIDER: ${{ inputs.llm-provider }}
-        UPDATE_EXISTING: ${{ inputs.update-existing }}
-        SYSTEM_PROMPT_FILE: ${{ inputs.system-prompt-file }}
-        PERSONA: ${{ inputs.persona }}
-        PERSONA_FILE: ${{ inputs.persona-file }}
-        AICORE_CLIENT_ID: ${{ inputs.aicore-client-id }}
-        AICORE_CLIENT_SECRET: ${{ inputs.aicore-client-secret }}
-        AICORE_AUTH_URL: ${{ inputs.aicore-auth-url }}
-        AICORE_API_URL: ${{ inputs.aicore-api-url }}
-        AICORE_RESOURCE_GROUP: ${{ inputs.aicore-resource-group }}
-      run: |
-        ARGS=""
-        if [ "${{ inputs.dry-run }}" = "true" ]; then
-          ARGS="--dry-run"
-        fi
-        ${{ runner.temp }}/review-bot $ARGS

.github/workflows/ci.yml

@@ -1,69 +0,0 @@
-name: CI
-
-on:
-  push:
-    branches: [main]
-  pull_request:
-    types: [opened, synchronize]
-
-jobs:
-  test:
-    runs-on: ubuntu-24.04
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-go@v5
-        with:
-          go-version: '1.26'
-      - run: go test ./...
-      - run: go vet ./...
-      - run: go build -o review-bot ./cmd/review-bot
-
-  # Self-review using native SAP AI Core provider
-  # Models must match SAP AI Core deployments
-  # Available models: gpt-5, anthropic--claude-4.6-sonnet, anthropic--claude-4.6-opus
-  # Removed gpt-4.1, gpt-5-mini, gpt-4.1-mini - not deployed on AI Core
-  review:
-    runs-on: ubuntu-24.04
-    if: github.event_name == 'pull_request'
-    needs: test
-    strategy:
-      matrix:
-        include:
-          - name: sonnet
-            token_secret: SONNET_REVIEW_TOKEN
-            model: anthropic--claude-4.6-sonnet
-          - name: gpt
-            token_secret: GPT_REVIEW_TOKEN
-            model: gpt-5
-          - name: security
-            token_secret: SECURITY_REVIEW_TOKEN
-            model: gpt-5
-            patterns_repo: rodin/security-patterns
-            patterns_files: "."
-            system_prompt_file: SECURITY_REVIEW.md
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-go@v5
-        with:
-          go-version: '1.26'
-      - run: go build -o review-bot ./cmd/review-bot
-      - name: Run ${{ matrix.name }} review
-        env:
-          GITHUB_SERVER_URL: ${{ github.server_url }}
-          GITHUB_REPOSITORY: ${{ github.repository }}
-          PR_NUMBER: ${{ github.event.pull_request.number }}
-          REVIEWER_TOKEN: ${{ secrets[matrix.token_secret] }}
-          REVIEWER_NAME: ${{ matrix.name }}
-          LLM_PROVIDER: aicore
-          LLM_MODEL: ${{ matrix.model }}
-          AICORE_CLIENT_ID: ${{ secrets.AICORE_CLIENT_ID }}
-          AICORE_CLIENT_SECRET: ${{ secrets.AICORE_CLIENT_SECRET }}
-          AICORE_AUTH_URL: ${{ secrets.AICORE_AUTH_URL }}
-          AICORE_API_URL: ${{ secrets.AICORE_API_URL }}
-          AICORE_RESOURCE_GROUP: ${{ secrets.AICORE_RESOURCE_GROUP }}
-          CONVENTIONS_FILE: "CONVENTIONS.md"
-          PATTERNS_REPO: ${{ matrix.patterns_repo || 'rodin/go-patterns' }}
-          PATTERNS_FILES: ${{ matrix.patterns_files || 'README.md,patterns/' }}
-          LLM_TIMEOUT: "600"
-          SYSTEM_PROMPT_FILE: ${{ matrix.system_prompt_file }}
-        run: ./review-bot

.github/workflows/pr-ready-gate.yml

@@ -1,38 +0,0 @@
-name: PR Ready Gate
-
-on:
-  pull_request:
-    types: [synchronize]
-
-jobs:
-  clear-labels:
-    runs-on: ubuntu-24.04
-    # Always run - curl commands are safe if labels don't exist
-    steps:
-      - name: Remove ready and self-reviewed labels, reassign to author
-        env:
-          GITEA_TOKEN: ${{ secrets.RODIN_TOKEN }}
-        run: |
-          PR_NUMBER=${{ github.event.pull_request.number }}
-          AUTHOR=${{ github.event.pull_request.user.login }}
-          READY_LABEL_ID=38
-          SELF_REVIEWED_LABEL_ID=37
-          
-          # Remove ready label if present
-          curl -sS -X DELETE \
-            -H "Authorization: token $GITEA_TOKEN" \
-            "https://gitea.weiker.me/api/v1/repos/${{ github.repository }}/issues/${PR_NUMBER}/labels/${READY_LABEL_ID}" || true
-          
-          # Remove self-reviewed label if present
-          curl -sS -X DELETE \
-            -H "Authorization: token $GITEA_TOKEN" \
-            "https://gitea.weiker.me/api/v1/repos/${{ github.repository }}/issues/${PR_NUMBER}/labels/${SELF_REVIEWED_LABEL_ID}" || true
-          
-          # Reassign to author
-          curl -sS -X PATCH \
-            -H "Authorization: token $GITEA_TOKEN" \
-            -H "Content-Type: application/json" \
-            -d "{\"assignees\": [\"${AUTHOR}\"]}" \
-            "https://gitea.weiker.me/api/v1/repos/${{ github.repository }}/pulls/${PR_NUMBER}"
-          
-          echo "Cleared ready/self-reviewed labels and reassigned PR #${PR_NUMBER} to ${AUTHOR}"

.github/workflows/release.yml

@@ -1,97 +0,0 @@
-name: Release
-
-on:
-  push:
-    tags:
-      - 'v*'
-
-jobs:
-  release:
-    runs-on: ubuntu-24.04
-    steps:
-      - uses: actions/checkout@v4
-
-      - uses: actions/setup-go@v5
-        with:
-          go-version: '1.26'
-
-      - name: Run tests
-        run: |
-          go vet ./...
-          go test ./...
-
-      - name: Build binaries
-        run: |
-          VERSION=${GITHUB_REF_NAME}
-          mkdir -p dist
-
-          GOOS=linux GOARCH=amd64 go build -ldflags "-s -w -X main.version=${VERSION}" -o dist/review-bot-linux-amd64 ./cmd/review-bot
-          GOOS=linux GOARCH=arm64 go build -ldflags "-s -w -X main.version=${VERSION}" -o dist/review-bot-linux-arm64 ./cmd/review-bot
-          GOOS=darwin GOARCH=amd64 go build -ldflags "-s -w -X main.version=${VERSION}" -o dist/review-bot-darwin-amd64 ./cmd/review-bot
-          GOOS=darwin GOARCH=arm64 go build -ldflags "-s -w -X main.version=${VERSION}" -o dist/review-bot-darwin-arm64 ./cmd/review-bot
-
-          cd dist && sha256sum * > checksums.txt
-
-      - name: Create release and upload assets
-        env:
-          GITEA_TOKEN: ${{ secrets.RELEASE_TOKEN }}
-        run: |
-          VERSION=${GITHUB_REF_NAME}
-          GITEA_URL="${{ github.server_url }}"
-          REPO="${{ github.repository }}"
-
-          # Create release (or find existing one for this tag)
-          HTTP_CODE=$(curl -s -o /tmp/release_response.json -w "%{http_code}" -X POST \
-            -H "Authorization: token ${GITEA_TOKEN}" \
-            -H "Content-Type: application/json" \
-            "${GITEA_URL}/api/v1/repos/${REPO}/releases" \
-            -d "{\"tag_name\": \"${VERSION}\", \"name\": \"${VERSION}\", \"body\": \"Release ${VERSION}\", \"draft\": false, \"prerelease\": false}")
-
-          if [ "$HTTP_CODE" = "409" ]; then
-            echo "Release for ${VERSION} already exists, fetching existing..."
-            curl -sSf -o /tmp/release_response.json \
-              -H "Authorization: token ${GITEA_TOKEN}" \
-              "${GITEA_URL}/api/v1/repos/${REPO}/releases/tags/${VERSION}"
-          elif [ "$HTTP_CODE" != "201" ]; then
-            echo "Failed to create release (HTTP ${HTTP_CODE})" >&2
-            cat /tmp/release_response.json >&2
-            exit 1
-          fi
-
-          # Parse release ID (python3 available on ubuntu-24.04 runners)
-          RELEASE_ID=$(python3 -c "import json; print(json.load(open('/tmp/release_response.json'))['id'])")
-
-          if [ -z "$RELEASE_ID" ]; then
-            echo "Failed to parse release ID" >&2
-            cat /tmp/release_response.json >&2
-            exit 1
-          fi
-
-          echo "Release ID: ${RELEASE_ID}"
-
-          # Upload each asset (idempotent: delete existing asset with same name first)
-          for file in dist/*; do
-            filename=$(basename "$file")
-            echo "Uploading ${filename}..."
-
-            # Check if asset already exists and delete it
-            EXISTING_ID=$(export ASSET_NAME="${filename}"; curl -sS \
-              -H "Authorization: token ${GITEA_TOKEN}" \
-              "${GITEA_URL}/api/v1/repos/${REPO}/releases/${RELEASE_ID}/assets" \
-              | python3 -c "import json,sys,os; name=os.environ['ASSET_NAME']; assets=json.load(sys.stdin); print(next((str(a['id']) for a in assets if a['name']==name),''))" 2>/dev/null)
-
-            if [ -n "$EXISTING_ID" ]; then
-              echo "  Asset ${filename} already exists (id=${EXISTING_ID}), deleting..."
-              curl -sSf -X DELETE \
-                -H "Authorization: token ${GITEA_TOKEN}" \
-                "${GITEA_URL}/api/v1/repos/${REPO}/releases/${RELEASE_ID}/assets/${EXISTING_ID}"
-            fi
-
-            curl -sSf -X POST \
-              -H "Authorization: token ${GITEA_TOKEN}" \
-              -H "Content-Type: application/octet-stream" \
-              "${GITEA_URL}/api/v1/repos/${REPO}/releases/${RELEASE_ID}/assets?name=$(printf '%s' "${filename}" | jq -sRr @uri)" \
-              --data-binary "@${file}"
-          done
-
-          echo "Release ${VERSION} created with assets"

CONVENTIONS.md

@@ -9,7 +9,7 @@
 
 | Package | Use Case | Scope |
 |---------|----------|-------|
-| `github.com/goccy/go-yaml` | YAML parsing and AST inspection (subpkgs: `ast`, `parser`) | production |
+| `github.com/goccy/go-yaml` | YAML parsing (persona files, config) | production |
 | `github.com/google/go-cmp` | Test comparisons (`cmp.Diff`) | test only |
 
 **Any import not in this table or the Go standard library is forbidden.**
@@ -21,6 +21,8 @@ To request a new dependency:
 2. Requires explicit approval from Aaron
 3. After merge, a separate PR may use the package
 
+<!-- Deviation from step 1+3 for go-yaml migration: see #91 for rationale. -->
+
 *Enforcement: `scripts/check-deps.sh` parses this table — update only here.*
 
 ## Error Handling

cmd/review-bot/main.go

@@ -2,7 +2,6 @@ package main
 
 import (
 	"context"
-	"errors"
 	"flag"
 	"fmt"
 	"log/slog"
@@ -14,10 +13,8 @@ import (
 
 	"gitea.weiker.me/rodin/review-bot/budget"
 	"gitea.weiker.me/rodin/review-bot/gitea"
-	"gitea.weiker.me/rodin/review-bot/github"
 	"gitea.weiker.me/rodin/review-bot/llm"
 	"gitea.weiker.me/rodin/review-bot/review"
-	"gitea.weiker.me/rodin/review-bot/vcs"
 )
 
 var version = "dev"
@@ -56,15 +53,12 @@ func main() {
 	// Logging flags
 	logFormat := flag.String("log-format", envOrDefault("LOG_FORMAT", "text"), "Log output format: text or json")
 	verbosity := flag.String("verbosity", envOrDefault("LOG_VERBOSITY", "info"), "Log verbosity: debug, info, warn, error")
-	// VCS flags
+	// CLI flags
-	provider := flag.String("provider", envOrDefault("VCS_PROVIDER", "gitea"), "VCS provider: gitea or github")
+	giteaURL := flag.String("gitea-url", envOrDefault("GITEA_URL", ""), "Gitea instance URL")
-	baseURL := flag.String("base-url", envOrDefault("VCS_BASE_URL", ""), "VCS API base URL (for github provider; defaults to https://api.github.com)")
+	repo := flag.String("repo", envOrDefault("GITEA_REPO", ""), "Repository (owner/name)")
-	vcsURL := flag.String("vcs-url", envOrDefault("VCS_URL", envOrDefault("GITEA_URL", envOrDefault("GITHUB_SERVER_URL", ""))), "VCS instance URL (Gitea) [deprecated alias: --gitea-url]")
-	// Keep --gitea-url as backward-compatible alias (flag package doesn't support aliases natively, handle below)
-	repo := flag.String("repo", envOrDefault("VCS_REPO", envOrDefault("GITEA_REPO", envOrDefault("GITHUB_REPOSITORY", ""))), "Repository (owner/name)")
 	prNum := flag.String("pr", envOrDefault("PR_NUMBER", ""), "Pull request number")
 	reviewerName := flag.String("reviewer-name", envOrDefault("REVIEWER_NAME", ""), "Reviewer display name")
-	reviewerToken := flag.String("reviewer-token", envOrDefault("REVIEWER_TOKEN", ""), "VCS token for posting review")
+	reviewerToken := flag.String("reviewer-token", envOrDefault("REVIEWER_TOKEN", ""), "Gitea token for posting review")
 	llmBaseURL := flag.String("llm-base-url", envOrDefault("LLM_BASE_URL", ""), "LLM API base URL")
 	llmAPIKey := flag.String("llm-api-key", envOrDefault("LLM_API_KEY", ""), "LLM API key")
 	llmModel := flag.String("llm-model", envOrDefault("LLM_MODEL", ""), "LLM model name")
@@ -85,18 +79,6 @@ func main() {
 	aicoreAPIURL := flag.String("aicore-api-url", envOrDefault("AICORE_API_URL", ""), "SAP AI Core API URL (for provider=aicore)")
 	aicoreResourceGroup := flag.String("aicore-resource-group", envOrDefault("AICORE_RESOURCE_GROUP", "default"), "SAP AI Core resource group (for provider=aicore)")
 
-	// Register --gitea-url as a backward-compatible alias for --vcs-url.
-	// StringVar shares the *string pointer with vcsURL, so whichever flag is
-	// set last by flag.Parse wins — both point to the same underlying value.
-	// NOTE: If a user passes both --vcs-url and --gitea-url, the last one on
-	// the command line takes effect (standard flag package behavior). This is
-	// acceptable since --gitea-url is deprecated and both serve the same purpose.
-	//
-	// ORDERING: This must remain AFTER vcsURL's flag.String declaration and BEFORE
-	// flag.Parse(). The *vcsURL dereference captures the env-var-resolved default
-	// at registration time; moving flag.Parse() above this line would break it.
-	flag.StringVar(vcsURL, "gitea-url", *vcsURL, "Deprecated: use --vcs-url instead")
-
 	flag.Parse()
 
 	if *versionFlag {
@@ -109,25 +91,12 @@ func main() {
 
 	slog.Info("review-bot starting", "version", version)
 
-	// Validate VCS provider
-	switch *provider {
-	case "gitea", "github":
-		// valid
-	default:
-		fmt.Fprintf(os.Stderr, "Error: invalid --provider %q (valid: gitea, github)\n", *provider)
-		os.Exit(1)
-	}
-
 	// Validate required fields
+	// For aicore provider, llm-base-url and llm-api-key are not required
 	isAICore := llm.Provider(*llmProvider) == llm.ProviderAICore
-	if *repo == "" || *prNum == "" || *reviewerToken == "" || *llmModel == "" {
+	if *giteaURL == "" || *repo == "" || *prNum == "" || *reviewerToken == "" || *llmModel == "" {
 		fmt.Fprintf(os.Stderr, "Error: missing required flags or environment variables\n\n")
-		fmt.Fprintf(os.Stderr, "Required: --repo, --pr, --reviewer-token, --llm-model\n")
+		fmt.Fprintf(os.Stderr, "Required: --gitea-url, --repo, --pr, --reviewer-token, --llm-model\n")
-		os.Exit(1)
-	}
-	// --vcs-url is required only for gitea provider
-	if *provider == "gitea" && *vcsURL == "" {
-		fmt.Fprintf(os.Stderr, "Error: --vcs-url (or --gitea-url) is required for provider=gitea\n")
 		os.Exit(1)
 	}
 	if !isAICore && (*llmBaseURL == "" || *llmAPIKey == "") {
@@ -146,6 +115,8 @@ func main() {
 		os.Exit(1)
 	}
 
+	// NOTE: Persona loading deferred until after Gitea client init to support repo personas
+
 	// Validate reviewer-name: only safe characters allowed in sentinel
 	if err := validateReviewerName(*reviewerName); err != nil {
 		slog.Error("invalid reviewer name", "error", err)
@@ -167,25 +138,8 @@ func main() {
 		os.Exit(1)
 	}
 
-	// Initialize VCS client
+	// Initialize clients
-	var client vcs.Client
+	giteaClient := gitea.NewClient(*giteaURL, *reviewerToken)
-	switch *provider {
-	case "gitea":
-		giteaClient := gitea.NewClient(*vcsURL, *reviewerToken)
-		client = gitea.NewAdapter(giteaClient)
-	case "github":
-		ghBaseURL := *baseURL
-		if ghBaseURL == "" {
-			ghBaseURL = "https://api.github.com"
-		}
-		client = github.NewClient(*reviewerToken, ghBaseURL)
-	default:
-		fmt.Fprintf(os.Stderr, "Error: unhandled provider %q\n", *provider)
-		os.Exit(1)
-	}
-	slog.Info("VCS client initialized", "provider", *provider)
-
-	// Initialize LLM client
 	llmClient := llm.NewClient(*llmBaseURL, *llmAPIKey, *llmModel)
 	if *llmTemp < 0 || *llmTemp > 2 {
 		slog.Error("invalid LLM temperature", "temperature", *llmTemp, "range", "0-2")
@@ -219,13 +173,16 @@ func main() {
 	ctx, cancel := context.WithTimeout(context.Background(), overallTimeout)
 	defer cancel()
 
-	// Load persona if specified
+	// Load persona if specified (after Gitea client init to support repo personas)
 	var persona *review.Persona
 	if *personaName != "" {
 		// Try loading from repo first, then fall back to built-in
-		repoPersonas, err := review.LoadRepoPersonas(ctx, client, owner, repoName)
+		repoPersonas, err := review.LoadRepoPersonas(ctx, newGiteaClientAdapter(giteaClient), owner, repoName)
 		if err != nil {
 			slog.Warn("could not load repo personas", "repo", owner+"/"+repoName, "error", err)
+			// Continue with built-in personas only.
+			// NOTE: repoPersonas is nil here, but map indexing on a nil map is safe in Go
+			// (returns the zero value), so the fallback to built-in below works correctly.
 		}
 		if p, ok := repoPersonas[*personaName]; ok {
 			persona = p
@@ -256,7 +213,7 @@ func main() {
 	slog.Info("reviewing pull request", "pr", prNumber, "repo", fmt.Sprintf("%s/%s", owner, repoName))
 
 	// Step 1: Fetch PR metadata
-	pr, err := client.GetPullRequest(ctx, owner, repoName, prNumber)
+	pr, err := giteaClient.GetPullRequest(ctx, owner, repoName, prNumber)
 	if err != nil {
 		slog.Error("failed to fetch PR", "pr", prNumber, "error", err)
 		os.Exit(1)
@@ -264,7 +221,7 @@ func main() {
 	slog.Info("fetched PR metadata", "pr", prNumber, "title", pr.Title)
 
 	// Step 2: Fetch diff
-	diff, err := client.GetPullRequestDiff(ctx, owner, repoName, prNumber)
+	diff, err := giteaClient.GetPullRequestDiff(ctx, owner, repoName, prNumber)
 	if err != nil {
 		slog.Error("failed to fetch diff", "pr", prNumber, "error", err)
 		os.Exit(1)
@@ -273,21 +230,21 @@ func main() {
 
 	// Step 3: Fetch full file content for modified files
 	fileContext := ""
-	files, err := client.GetPullRequestFiles(ctx, owner, repoName, prNumber)
+	files, err := giteaClient.GetPullRequestFiles(ctx, owner, repoName, prNumber)
 	if err != nil {
 		slog.Warn("could not fetch PR files list", "pr", prNumber, "error", err)
 	} else {
-		fileContext = fetchFileContext(ctx, client, owner, repoName, pr.Head.Ref, files)
+		fileContext = fetchFileContext(ctx, giteaClient, owner, repoName, pr.Head.Ref, files)
 		slog.Debug("fetched file context", "files", len(files))
 	}
 
 	// Step 4: Check CI status
 	ciPassed := true
 	ciDetails := ""
-	if pr.Head.SHA != "" {
+	if pr.Head.Sha != "" {
-		statuses, err := client.GetCommitStatuses(ctx, owner, repoName, pr.Head.SHA)
+		statuses, err := giteaClient.GetCommitStatuses(ctx, owner, repoName, pr.Head.Sha)
 		if err != nil {
-			slog.Warn("could not fetch CI status", "sha", pr.Head.SHA, "error", err)
+			slog.Warn("could not fetch CI status", "sha", pr.Head.Sha, "error", err)
 		} else {
 			ciPassed, ciDetails = evaluateCIStatus(statuses)
 			slog.Info("CI status checked", "passed", ciPassed)
@@ -297,7 +254,7 @@ func main() {
 	// Step 5: Load conventions file if specified
 	conventions := ""
 	if *conventionsFile != "" {
-		content, err := client.GetFileContent(ctx, owner, repoName, *conventionsFile, "")
+		content, err := giteaClient.GetFileContent(ctx, owner, repoName, *conventionsFile)
 		if err != nil {
 			slog.Warn("could not load conventions file", "file", *conventionsFile, "error", err)
 		} else {
@@ -309,7 +266,7 @@ func main() {
 	// Step 6: Load patterns from external repo if specified
 	patterns := ""
 	if *patternsRepo != "" {
-		patterns = fetchPatterns(ctx, client, *patternsRepo, *patternsFiles)
+		patterns = fetchPatterns(ctx, giteaClient, *patternsRepo, *patternsFiles)
 		slog.Debug("loaded patterns", "repo", *patternsRepo, "bytes", len(patterns))
 	}
 
@@ -402,16 +359,15 @@ func main() {
 	}
 
 	// Add commit footer so readers know which commit was evaluated
-	if pr.Head.SHA != "" {
+	if pr.Head.Sha != "" {
-		shortSHA := pr.Head.SHA
+		shortSHA := pr.Head.Sha
 		if len(shortSHA) > 8 {
 			shortSHA = shortSHA[:8]
 		}
 		reviewBody += fmt.Sprintf("\n\n---\n*Evaluated against %s*", shortSHA)
 	}
 
-	// Map verdict to canonical review event
+	event := review.GiteaEvent(result.Verdict)
-	event := verdictToEvent(result.Verdict)
 
 	if *dryRun {
 		fmt.Println("--- DRY RUN ---")
@@ -423,13 +379,14 @@ func main() {
 	sentinel := fmt.Sprintf("<!-- review-bot:%s -->", *reviewerName)
 
 	// Stale check: verify HEAD hasn't moved since we started
-	evaluatedSHA := pr.Head.SHA
+	evaluatedSHA := pr.Head.Sha
 	var currentSHA string
-	currentPR, err := client.GetPullRequest(ctx, owner, repoName, prNumber)
+	currentPR, err := giteaClient.GetPullRequest(ctx, owner, repoName, prNumber)
 	if err != nil {
 		slog.Warn("could not re-fetch PR for stale check", "pr", prNumber, "error", err)
+		// currentSHA stays empty — shouldSkipStaleReview will return false
 	} else {
-		currentSHA = currentPR.Head.SHA
+		currentSHA = currentPR.Head.Sha
 	}
 	if shouldSkipStaleReview(evaluatedSHA, currentSHA) {
 		slog.Warn("HEAD moved during review — skipping stale review",
@@ -439,25 +396,18 @@ func main() {
 		return
 	}
 
-	// Build line→position map for inline comments
+	// Map findings to inline comments for lines present in the diff
-	lineToPosition := vcs.BuildLineToPositionMap(diff)
+	diffRanges := gitea.ParseDiffNewLines(diff)
-	var inlineComments []vcs.ReviewComment
+	var inlineComments []gitea.ReviewComment
 	for _, f := range result.Findings {
-		if f.File == "" || f.Line <= 0 {
+		if f.File != "" && f.Line > 0 && diffRanges.Contains(f.File, f.Line) {
-			continue
+			inlineComments = append(inlineComments, gitea.ReviewComment{
-		}
-		pos, ok := lineToPosition[f.File][f.Line]
-		if !ok {
-			slog.Warn("line not in diff, skipping comment", "file", f.File, "line", f.Line)
-			continue
-		}
-		inlineComments = append(inlineComments, vcs.ReviewComment{
 				Path:        f.File,
-			Position: pos,
+				NewPosition: int64(f.Line),
-			CommitID: pr.Head.SHA,
 				Body:        fmt.Sprintf("**[%s]** %s", f.Severity, f.Finding),
 			})
 		}
+	}
 	if len(inlineComments) > 0 {
 		slog.Debug("attaching inline comments", "count", len(inlineComments))
 	}
@@ -465,9 +415,10 @@ func main() {
 	// --- Review update strategy ---
 	// 1. POST new review first (gets non-stale approval badge on HEAD)
 	// 2. Then supersede old review with link to the new one
-	var oldReviews []vcs.Review
+	// Order matters: post first so we have the new review's URL for the supersede message.
+	var oldReviews []gitea.Review
 	if *reviewerName != "" {
-		existingReviews, err := client.ListReviews(ctx, owner, repoName, prNumber)
+		existingReviews, err := giteaClient.ListReviews(ctx, owner, repoName, prNumber)
 		if err != nil {
 			slog.Warn("could not list existing reviews", "pr", prNumber, "error", err)
 		} else {
@@ -479,109 +430,45 @@ func main() {
 		}
 	}
 
-	// Self-request as reviewer (Gitea-specific; ensures we appear in required-reviewer checks)
+	// Self-request as reviewer (ensures we appear in required-reviewer checks)
-	if giteaAdapter, ok := client.(*gitea.Adapter); ok {
+	authUser, err := giteaClient.GetAuthenticatedUser(ctx)
-		authUser, err := client.GetAuthenticatedUser(ctx)
 	if err != nil {
 		slog.Warn("could not determine authenticated user for reviewer self-request", "error", err)
 	} else if authUser != "" {
-			if err := giteaAdapter.Underlying().RequestReviewer(ctx, owner, repoName, prNumber, authUser); err != nil {
+		if err := giteaClient.RequestReviewer(ctx, owner, repoName, prNumber, authUser); err != nil {
 			slog.Warn("could not self-request as reviewer", "user", authUser, "error", err)
 		} else {
 			slog.Debug("self-requested as reviewer", "user", authUser, "pr", prNumber)
 		}
 	}
-	} else {
-		slog.Debug("RequestReviewer not supported for provider, skipping")
-	}
 
 	// POST new review
 	slog.Info("posting review", "event", event, "pr", prNumber)
-	reviewReq := vcs.ReviewRequest{
+	posted, err := giteaClient.PostReview(ctx, owner, repoName, prNumber, event, reviewBody, inlineComments)
-		Body:     reviewBody,
-		Event:    event,
-		Comments: inlineComments,
-	}
-	posted, err := client.PostReview(ctx, owner, repoName, prNumber, reviewReq)
 	if err != nil {
 		slog.Error("failed to post review", "pr", prNumber, "event", event, "error", err)
 		os.Exit(1)
 	}
 	slog.Info("review posted", "review_id", posted.ID, "user", posted.User.Login, "pr", prNumber)
 
-	// Supersede all old reviews
+	// Supersede all old reviews with link to the new one
 	if len(oldReviews) > 0 {
-		if err := supersedeOldReviews(ctx, client, *provider, *vcsURL, owner, repoName, prNumber, oldReviews, posted.ID, sentinel); err != nil {
+		newReviewURL := fmt.Sprintf("%s/%s/%s/pulls/%d#pullrequestreview-%d", strings.TrimRight(*giteaURL, "/"), owner, repoName, prNumber, posted.ID)
-			slog.Error("failed to supersede old reviews", "error", err)
-			os.Exit(1)
-		}
-	}
-}
-
-// verdictToEvent maps a verdict string from the LLM response to a canonical vcs.ReviewEvent.
-func verdictToEvent(verdict string) vcs.ReviewEvent {
-	switch verdict {
-	case "APPROVE":
-		return vcs.ReviewEventApprove
-	case "REQUEST_CHANGES":
-		return vcs.ReviewEventRequestChanges
-	default:
-		return vcs.ReviewEventComment
-	}
-}
-
-// supersedeOldReviews marks prior reviews as superseded so only the latest review is visible.
-// For GitHub: dismisses old reviews (vcsURL is unused in this path).
-// For Gitea: edits the review body with a link to the new review and resolves inline comments.
-//
-// The vcsURL parameter is only used in the Gitea path to construct review permalink URLs;
-// it is accepted unconditionally to keep the function signature uniform across providers.
-func supersedeOldReviews(ctx context.Context, client vcs.Client, provider, vcsURL, owner, repoName string, prNumber int, oldReviews []vcs.Review, newReviewID int64, sentinel string) error {
-	switch provider {
-	case "github":
-		// Best-effort dismissal: attempt all reviews, join any errors.
-		var errs []error
-		for _, old := range oldReviews {
-			if err := client.DismissReview(ctx, owner, repoName, prNumber, old.ID, "Superseded by new review"); err != nil {
-				slog.Warn("failed to dismiss review", "id", old.ID, "error", err)
-				errs = append(errs, fmt.Errorf("dismiss review %d: %w", old.ID, err))
-			} else {
-				slog.Info("dismissed old review", "review_id", old.ID, "new_review_id", newReviewID, "pr", prNumber)
-			}
-		}
-		return errors.Join(errs...)
-	case "gitea":
-		// Continue to Gitea-specific logic below the switch.
-	default:
-		return fmt.Errorf("supersedeOldReviews: unsupported provider %q", provider)
-	}
-
-	// The type assertion below is guaranteed to succeed: the caller's provider switch
-	// ensures we only reach this point when provider == "gitea", and the gitea provider
-	// always constructs a *gitea.Adapter. The !ok branch guards against future refactors
-	// (e.g. wrapping the adapter in a decorator) that would silently break this path.
-	giteaAdapter, ok := client.(*gitea.Adapter)
-	if !ok {
-		return fmt.Errorf("expected gitea.Adapter for gitea provider, got %T", client)
-	}
-	underlying := giteaAdapter.Underlying()
-
-	newReviewURL := fmt.Sprintf("%s/%s/%s/pulls/%d#pullrequestreview-%d", strings.TrimRight(vcsURL, "/"), owner, repoName, prNumber, newReviewID)
 		for _, oldReview := range oldReviews {
-		cid, err := underlying.GetTimelineReviewCommentIDForReview(ctx, owner, repoName, prNumber, oldReview.ID)
+			cid, err := giteaClient.GetTimelineReviewCommentIDForReview(ctx, owner, repoName, prNumber, oldReview.ID)
 			if err != nil {
 				slog.Warn("could not find comment ID for old review", "review_id", oldReview.ID, "error", err)
 				continue
 			}
 			supersededBody := buildSupersededBody(oldReview.Body, oldReview.CommitID, newReviewURL, sentinel)
-		if err := underlying.EditComment(ctx, owner, repoName, cid, supersededBody); err != nil {
+			if err := giteaClient.EditComment(ctx, owner, repoName, cid, supersededBody); err != nil {
 				slog.Warn("could not mark old review as superseded", "review_id", oldReview.ID, "comment_id", cid, "error", err)
 				continue
 			}
-		slog.Info("marked old review as superseded", "review_id", oldReview.ID, "new_review_id", newReviewID, "pr", prNumber)
+			slog.Info("marked old review as superseded", "review_id", oldReview.ID, "new_review_id", posted.ID, "pr", prNumber)
 
 			// Resolve old review's inline comments
-		oldComments, err := underlying.ListReviewComments(ctx, owner, repoName, prNumber, oldReview.ID)
+			oldComments, err := giteaClient.ListReviewComments(ctx, owner, repoName, prNumber, oldReview.ID)
 			if err != nil {
 				slog.Warn("could not list old review comments for resolution", "review_id", oldReview.ID, "error", err)
 				continue
@@ -591,7 +478,7 @@ func supersedeOldReviews(ctx context.Context, client vcs.Client, provider, vcsUR
 				if c.ID == 0 {
 					continue
 				}
-			if err := underlying.ResolveComment(ctx, owner, repoName, c.ID); err != nil {
+				if err := giteaClient.ResolveComment(ctx, owner, repoName, c.ID); err != nil {
 					slog.Debug("could not resolve inline comment", "comment_id", c.ID, "error", err)
 					failed++
 				} else {
@@ -605,11 +492,12 @@ func supersedeOldReviews(ctx context.Context, client vcs.Client, provider, vcsUR
 				slog.Warn("some inline comments could not be resolved", "review_id", oldReview.ID, "failed", failed, "pr", prNumber)
 			}
 		}
-	return nil
+	}
+
 }
 
 // fetchFileContext fetches the full content of modified files from the PR branch.
-func fetchFileContext(ctx context.Context, client vcs.PRReader, owner, repo, ref string, files []vcs.ChangedFile) string {
+func fetchFileContext(ctx context.Context, client *gitea.Client, owner, repo, ref string, files []gitea.ChangedFile) string {
 	var sb strings.Builder
 	for _, f := range files {
 		if ctx.Err() != nil {
@@ -618,7 +506,7 @@ func fetchFileContext(ctx context.Context, client vcs.PRReader, owner, repo, ref
 		if f.Status == "removed" {
 			continue // Skip deleted files
 		}
-		content, err := client.GetFileContentAtRef(ctx, owner, repo, f.Filename, ref)
+		content, err := client.GetFileContentRef(ctx, owner, repo, f.Filename, ref)
 		if err != nil {
 			slog.Warn("could not fetch file content", "file", f.Filename, "error", err)
 			continue
@@ -636,7 +524,7 @@ func fetchFileContext(ctx context.Context, client vcs.PRReader, owner, repo, ref
 // patternsFiles is comma-separated list of file paths or directories.
 // If a path ends with / or is a directory, all files within it are fetched recursively.
 // If patternsFiles is empty, all files from the repo root are fetched.
-func fetchPatterns(ctx context.Context, client vcs.FileReader, patternsRepo, patternsFiles string) string {
+func fetchPatterns(ctx context.Context, client *gitea.Client, patternsRepo, patternsFiles string) string {
 	var sb strings.Builder
 
 	repos := strings.Split(patternsRepo, ",")
@@ -674,7 +562,7 @@ func fetchPatterns(ctx context.Context, client vcs.FileReader, patternsRepo, pat
 		var repoSkippedFiles []string
 
 		for _, path := range paths {
-			files, err := vcs.GetAllFilesInPath(ctx, client, owner, repo, path)
+			files, err := client.GetAllFilesInPath(ctx, owner, repo, path)
 			if err != nil {
 				slog.Warn("could not fetch patterns", "path", path, "repo", repoRef, "error", err)
 				continue
@@ -713,20 +601,18 @@ func isPatternFile(path string) bool {
 }
 
 // evaluateCIStatus checks if all CI statuses indicate success.
-// Returns passed=true if no checks have failed (pending checks are not treated as failures).
+func evaluateCIStatus(statuses []gitea.CommitStatus) (passed bool, details string) {
-func evaluateCIStatus(statuses []vcs.CommitStatus) (passed bool, details string) {
 	if len(statuses) == 0 {
 		return true, "no CI statuses found"
 	}
 
 	var failed []string
-	var pending int
 	for _, s := range statuses {
 		switch s.Status {
 		case "success":
 			// good
 		case "pending":
-			pending++
+			// treat pending as not-failed
 		case "failure", "error":
 			failed = append(failed, fmt.Sprintf("%s: %s", s.Context, s.Description))
 		}
@@ -735,9 +621,6 @@ func evaluateCIStatus(statuses []vcs.CommitStatus) (passed bool, details string)
 	if len(failed) > 0 {
 		return false, strings.Join(failed, "; ")
 	}
-	if pending > 0 {
-		return true, fmt.Sprintf("no failures (%d pending)", pending)
-	}
 	return true, "all checks passed"
 }
 
@@ -853,10 +736,10 @@ func buildSupersededBody(originalBody, commitSHA, newReviewURL, sentinel string)
 }
 
 // hasSharedToken detects if another review-bot role posted under the same
-// VCS user. This indicates misconfiguration where two roles share a token
+// Gitea user. This indicates misconfiguration where two roles share a token
-// instead of having separate accounts. Returns true if shared token
+// instead of having separate Gitea accounts. Returns true if shared token
 // detected (caller should skip update-in-place logic to avoid clobbering).
-func hasSharedToken(reviews []vcs.Review, ownSentinel string) bool {
+func hasSharedToken(reviews []gitea.Review, ownSentinel string) bool {
 	ownLogin := ""
 	for _, r := range reviews {
 		if strings.Contains(r.Body, ownSentinel) {
@@ -869,7 +752,7 @@ func hasSharedToken(reviews []vcs.Review, ownSentinel string) bool {
 	}
 	for _, r := range reviews {
 		if r.User.Login == ownLogin && strings.Contains(r.Body, "<!-- review-bot:") && !strings.Contains(r.Body, ownSentinel) {
-			slog.Warn("shared token detected — another review-bot role is using the same VCS user",
+			slog.Warn("shared token detected — another review-bot role is using the same Gitea user",
 				"sibling_role", extractSentinelName(r.Body), "user", ownLogin)
 			return true
 		}
@@ -890,27 +773,29 @@ func extractSentinelName(body string) string {
 	if end < 0 {
 		return "unknown"
 	}
-	name := rest[:end]
+	return rest[:end]
-	// Sanitize: strip control characters to prevent log injection.
-	name = strings.Map(func(r rune) rune {
-		if r < 0x20 || r == 0x7f {
-			return -1
-		}
-		return r
-	}, name)
-	if len(name) > 64 {
-		name = name[:64]
-	}
-	if name == "" {
-		return "unknown"
-	}
-	return name
 }
 
+// findOwnReview locates the most recent non-superseded review matching the sentinel.
+func findOwnReview(reviews []gitea.Review, sentinel string) *gitea.Review {
+	var best *gitea.Review
+	for i := range reviews {
+		if !strings.Contains(reviews[i].Body, sentinel) {
+			continue
+		}
+		if strings.Contains(reviews[i].Body, "~~Original review~~") {
+			continue
+		}
+		if best == nil || reviews[i].ID > best.ID {
+			best = &reviews[i]
+		}
+	}
+	return best
+}
 
 // findAllOwnReviews returns all non-superseded reviews matching the sentinel.
-func findAllOwnReviews(reviews []vcs.Review, sentinel string) []vcs.Review {
+func findAllOwnReviews(reviews []gitea.Review, sentinel string) []gitea.Review {
-	var result []vcs.Review
+	var result []gitea.Review
 	for i := range reviews {
 		if !strings.Contains(reviews[i].Body, sentinel) {
 			continue
@@ -935,3 +820,32 @@ func shouldSkipStaleReview(evaluatedSHA, currentSHA string) bool {
 	}
 	return evaluatedSHA != currentSHA
 }
+
+// giteaClientAdapter adapts gitea.Client to review.GiteaClient interface.
+type giteaClientAdapter struct {
+	client *gitea.Client
+}
+
+func newGiteaClientAdapter(c *gitea.Client) *giteaClientAdapter {
+	return &giteaClientAdapter{client: c}
+}
+
+func (a *giteaClientAdapter) ListContents(ctx context.Context, owner, repo, path string) ([]review.ContentEntry, error) {
+	entries, err := a.client.ListContents(ctx, owner, repo, path)
+	if err != nil {
+		return nil, err
+	}
+	result := make([]review.ContentEntry, len(entries))
+	for i, e := range entries {
+		result[i] = review.ContentEntry{
+			Name: e.Name,
+			Path: e.Path,
+			Type: e.Type,
+		}
+	}
+	return result, nil
+}
+
+func (a *giteaClientAdapter) GetFileContent(ctx context.Context, owner, repo, filepath string) (string, error) {
+	return a.client.GetFileContent(ctx, owner, repo, filepath)
+}

cmd/review-bot/main_test.go

@@ -10,7 +10,7 @@ import (
 	"strings"
 	"testing"
 
-	"gitea.weiker.me/rodin/review-bot/vcs"
+	"gitea.weiker.me/rodin/review-bot/gitea"
 )
 
 func TestValidateReviewerName(t *testing.T) {
@@ -107,6 +107,8 @@ func TestValidateWorkspacePath(t *testing.T) {
 			workspace: tmpDir,
 			path:      "/etc/passwd",
 			wantErr:   true,
+			// Go 1.21+ filepath.Join normalizes absolute paths: Join("/tmp/x", "/etc/passwd")
+			// becomes "/tmp/x/etc/passwd", which is within workspace but doesn't exist.
 			errMatch: "failed to resolve",
 		},
 		{
@@ -152,14 +154,15 @@ func TestValidateWorkspacePath(t *testing.T) {
 	}
 }
 
-func makeReview(id int64, login, state string, stale bool, body string) vcs.Review {
+func makeReview(id int64, login, state string, stale bool, body string) gitea.Review {
-	return vcs.Review{
+	r := gitea.Review{
 		ID:    id,
 		Body:  body,
-		User:  vcs.UserInfo{Login: login},
 		State: state,
 		Stale: stale,
 	}
+	r.User.Login = login
+	return r
 }
 
 func TestBuildSupersededBody(t *testing.T) {
@@ -210,11 +213,96 @@ func TestBuildSupersededBodyShortSHA(t *testing.T) {
 	}
 }
 
+func TestFindOwnReview(t *testing.T) {
+	tests := []struct {
+		name     string
+		reviews  []gitea.Review
+		sentinel string
+		wantID   int64
+		wantNil  bool
+	}{
+		{
+			name:     "no reviews",
+			reviews:  nil,
+			sentinel: "<!-- review-bot:sonnet -->",
+			wantNil:  true,
+		},
+		{
+			name: "found by sentinel",
+			reviews: []gitea.Review{
+				makeReview(42, "bot", "APPROVED", false, "review body\n<!-- review-bot:sonnet -->"),
+			},
+			sentinel: "<!-- review-bot:sonnet -->",
+			wantID:   42,
+		},
+		{
+			name: "wrong sentinel",
+			reviews: []gitea.Review{
+				makeReview(42, "bot", "APPROVED", false, "body\n<!-- review-bot:gpt -->"),
+			},
+			sentinel: "<!-- review-bot:sonnet -->",
+			wantNil:  true,
+		},
+		{
+			name: "multiple reviews, returns first match",
+			reviews: []gitea.Review{
+				makeReview(10, "bot", "APPROVED", false, "old\n<!-- review-bot:gpt -->"),
+				makeReview(20, "bot", "APPROVED", false, "new\n<!-- review-bot:sonnet -->"),
+			},
+			sentinel: "<!-- review-bot:sonnet -->",
+			wantID:   20,
+		},
+		{
+			name: "skips superseded review",
+			reviews: []gitea.Review{
+				makeReview(10, "bot", "APPROVED", false, "~~Original review~~\n\n**Superseded**\n<!-- review-bot:sonnet -->"),
+				makeReview(20, "bot", "APPROVED", false, "fresh review\n<!-- review-bot:sonnet -->"),
+			},
+			sentinel: "<!-- review-bot:sonnet -->",
+			wantID:   20,
+		},
+		{
+			name: "only superseded reviews exist",
+			reviews: []gitea.Review{
+				makeReview(10, "bot", "APPROVED", false, "~~Original review~~\n\n<!-- review-bot:sonnet -->"),
+			},
+			sentinel: "<!-- review-bot:sonnet -->",
+			wantNil:  true,
+		},
+		{
+			name: "picks highest ID among matches",
+			reviews: []gitea.Review{
+				makeReview(50, "bot", "APPROVED", false, "v1\n<!-- review-bot:sonnet -->"),
+				makeReview(30, "bot", "APPROVED", false, "v0\n<!-- review-bot:sonnet -->"),
+			},
+			sentinel: "<!-- review-bot:sonnet -->",
+			wantID:   50,
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			got := findOwnReview(tc.reviews, tc.sentinel)
+			if tc.wantNil {
+				if got != nil {
+					t.Errorf("findOwnReview() = %v, want nil", got)
+				}
+			} else {
+				if got == nil {
+					t.Fatal("findOwnReview() = nil, want non-nil")
+				}
+				if got.ID != tc.wantID {
+					t.Errorf("findOwnReview().ID = %d, want %d", got.ID, tc.wantID)
+				}
+			}
+		})
+	}
+}
 
 func TestHasSharedToken(t *testing.T) {
 	tests := []struct {
 		name     string
-		reviews  []vcs.Review
+		reviews  []gitea.Review
 		sentinel string
 		want     bool
 	}{
@@ -226,36 +314,36 @@ func TestHasSharedToken(t *testing.T) {
 		},
 		{
 			name: "no own review yet - cannot detect",
-			reviews: []vcs.Review{
+			reviews: []gitea.Review{
-				makeReview(1, "other", "APPROVED", false, "<!-- review-bot:gpt --> body"),
+				{ID: 1, User: struct{ Login string `json:"login"` }{Login: "other"}, Body: "<!-- review-bot:gpt --> body"},
 			},
 			sentinel: "<!-- review-bot:sonnet -->",
 			want:     false,
 		},
 		{
 			name: "separate users - no shared token",
-			reviews: []vcs.Review{
+			reviews: []gitea.Review{
-				makeReview(1, "sonnet-review-bot", "APPROVED", false, "<!-- review-bot:sonnet --> body"),
+				{ID: 1, User: struct{ Login string `json:"login"` }{Login: "sonnet-review-bot"}, Body: "<!-- review-bot:sonnet --> body"},
-				makeReview(2, "security-review-bot", "APPROVED", false, "<!-- review-bot:security --> body"),
+				{ID: 2, User: struct{ Login string `json:"login"` }{Login: "security-review-bot"}, Body: "<!-- review-bot:security --> body"},
 			},
 			sentinel: "<!-- review-bot:sonnet -->",
 			want:     false,
 		},
 		{
 			name: "shared token detected - same user different sentinels",
-			reviews: []vcs.Review{
+			reviews: []gitea.Review{
-				makeReview(1, "sonnet-review-bot", "APPROVED", false, "<!-- review-bot:sonnet --> body"),
+				{ID: 1, User: struct{ Login string `json:"login"` }{Login: "sonnet-review-bot"}, Body: "<!-- review-bot:sonnet --> body"},
-				makeReview(2, "sonnet-review-bot", "APPROVED", false, "<!-- review-bot:security --> body"),
+				{ID: 2, User: struct{ Login string `json:"login"` }{Login: "sonnet-review-bot"}, Body: "<!-- review-bot:security --> body"},
 			},
 			sentinel: "<!-- review-bot:sonnet -->",
 			want:     true,
 		},
 		{
 			name: "three roles same user",
-			reviews: []vcs.Review{
+			reviews: []gitea.Review{
-				makeReview(1, "bot", "APPROVED", false, "<!-- review-bot:sonnet --> body"),
+				{ID: 1, User: struct{ Login string `json:"login"` }{Login: "bot"}, Body: "<!-- review-bot:sonnet --> body"},
-				makeReview(2, "bot", "APPROVED", false, "<!-- review-bot:security --> body"),
+				{ID: 2, User: struct{ Login string `json:"login"` }{Login: "bot"}, Body: "<!-- review-bot:security --> body"},
-				makeReview(3, "bot", "APPROVED", false, "<!-- review-bot:gpt --> body"),
+				{ID: 3, User: struct{ Login string `json:"login"` }{Login: "bot"}, Body: "<!-- review-bot:gpt --> body"},
 			},
 			sentinel: "<!-- review-bot:sonnet -->",
 			want:     true,
@@ -465,7 +553,7 @@ func TestBuildPatternPaths(t *testing.T) {
 func TestEvaluateCIStatus(t *testing.T) {
 	tests := []struct {
 		name       string
-		statuses   []vcs.CommitStatus
+		statuses   []gitea.CommitStatus
 		wantPassed bool
 		wantSubstr string
 	}{
@@ -477,7 +565,7 @@ func TestEvaluateCIStatus(t *testing.T) {
 		},
 		{
 			name: "all success",
-			statuses: []vcs.CommitStatus{
+			statuses: []gitea.CommitStatus{
 				{Status: "success", Context: "ci/build", Description: "Build passed"},
 				{Status: "success", Context: "ci/test", Description: "Tests passed"},
 			},
@@ -486,7 +574,7 @@ func TestEvaluateCIStatus(t *testing.T) {
 		},
 		{
 			name: "one failure",
-			statuses: []vcs.CommitStatus{
+			statuses: []gitea.CommitStatus{
 				{Status: "success", Context: "ci/build", Description: "Build passed"},
 				{Status: "failure", Context: "ci/test", Description: "Tests failed"},
 			},
@@ -495,7 +583,7 @@ func TestEvaluateCIStatus(t *testing.T) {
 		},
 		{
 			name: "error status",
-			statuses: []vcs.CommitStatus{
+			statuses: []gitea.CommitStatus{
 				{Status: "error", Context: "ci/lint", Description: "Lint error"},
 			},
 			wantPassed: false,
@@ -503,16 +591,16 @@ func TestEvaluateCIStatus(t *testing.T) {
 		},
 		{
 			name: "pending treated as not-failed",
-			statuses: []vcs.CommitStatus{
+			statuses: []gitea.CommitStatus{
 				{Status: "pending", Context: "ci/build", Description: "In progress"},
 				{Status: "success", Context: "ci/test", Description: "Tests passed"},
 			},
 			wantPassed: true,
-			wantSubstr: "no failures",
+			wantSubstr: "all checks passed",
 		},
 		{
 			name: "multiple failures",
-			statuses: []vcs.CommitStatus{
+			statuses: []gitea.CommitStatus{
 				{Status: "failure", Context: "ci/build", Description: "Build failed"},
 				{Status: "failure", Context: "ci/test", Description: "Tests failed"},
 			},
@@ -521,7 +609,7 @@ func TestEvaluateCIStatus(t *testing.T) {
 		},
 		{
 			name: "mixed with pending and failure",
-			statuses: []vcs.CommitStatus{
+			statuses: []gitea.CommitStatus{
 				{Status: "success", Context: "ci/build", Description: "Build passed"},
 				{Status: "pending", Context: "ci/deploy", Description: "Deploying"},
 				{Status: "failure", Context: "ci/test", Description: "Tests failed"},
@@ -750,7 +838,7 @@ func TestMainSubprocess_InvalidReviewerName(t *testing.T) {
 	if os.Getenv("TEST_SUBPROCESS_MAIN") == "1" {
 		flag.CommandLine = flag.NewFlagSet(os.Args[0], flag.ExitOnError)
 		os.Args = []string{"review-bot",
-			"--vcs-url", "http://localhost",
+			"--gitea-url", "http://localhost",
 			"--repo", "owner/repo",
 			"--pr", "1",
 			"--reviewer-name", "invalid name",
@@ -778,7 +866,7 @@ func TestMainSubprocess_InvalidRepo(t *testing.T) {
 	if os.Getenv("TEST_SUBPROCESS_MAIN") == "1" {
 		flag.CommandLine = flag.NewFlagSet(os.Args[0], flag.ExitOnError)
 		os.Args = []string{"review-bot",
-			"--vcs-url", "http://localhost",
+			"--gitea-url", "http://localhost",
 			"--repo", "invalidrepo",
 			"--pr", "1",
 			"--reviewer-token", "tok",
@@ -805,7 +893,7 @@ func TestMainSubprocess_InvalidPRNumber(t *testing.T) {
 	if os.Getenv("TEST_SUBPROCESS_MAIN") == "1" {
 		flag.CommandLine = flag.NewFlagSet(os.Args[0], flag.ExitOnError)
 		os.Args = []string{"review-bot",
-			"--vcs-url", "http://localhost",
+			"--gitea-url", "http://localhost",
 			"--repo", "owner/repo",
 			"--pr", "notanumber",
 			"--reviewer-token", "tok",
@@ -832,7 +920,7 @@ func TestMainSubprocess_InvalidTemperature(t *testing.T) {
 	if os.Getenv("TEST_SUBPROCESS_MAIN") == "1" {
 		flag.CommandLine = flag.NewFlagSet(os.Args[0], flag.ExitOnError)
 		os.Args = []string{"review-bot",
-			"--vcs-url", "http://localhost",
+			"--gitea-url", "http://localhost",
 			"--repo", "owner/repo",
 			"--pr", "1",
 			"--reviewer-token", "tok",
@@ -860,7 +948,7 @@ func TestMainSubprocess_InvalidProvider(t *testing.T) {
 	if os.Getenv("TEST_SUBPROCESS_MAIN") == "1" {
 		flag.CommandLine = flag.NewFlagSet(os.Args[0], flag.ExitOnError)
 		os.Args = []string{"review-bot",
-			"--vcs-url", "http://localhost",
+			"--gitea-url", "http://localhost",
 			"--repo", "owner/repo",
 			"--pr", "1",
 			"--reviewer-token", "tok",
@@ -884,35 +972,7 @@ func TestMainSubprocess_InvalidProvider(t *testing.T) {
 	}
 }
 
-func TestMainSubprocess_InvalidVCSProvider(t *testing.T) {
+// cleanEnv returns environ without any GITEA/LLM/REVIEWER env vars that would
-	if os.Getenv("TEST_SUBPROCESS_MAIN") == "1" {
-		flag.CommandLine = flag.NewFlagSet(os.Args[0], flag.ExitOnError)
-		os.Args = []string{"review-bot",
-			"--provider", "invalid",
-			"--vcs-url", "http://localhost",
-			"--repo", "owner/repo",
-			"--pr", "1",
-			"--reviewer-token", "tok",
-			"--llm-base-url", "http://localhost",
-			"--llm-api-key", "key",
-			"--llm-model", "model",
-		}
-		main()
-		return
-	}
-
-	cmd := exec.Command(os.Args[0], "-test.run=TestMainSubprocess_InvalidVCSProvider")
-	cmd.Env = append(cleanEnv(), "TEST_SUBPROCESS_MAIN=1")
-	out, err := cmd.CombinedOutput()
-	if err == nil {
-		t.Fatal("expected non-zero exit with invalid VCS provider")
-	}
-	if !strings.Contains(string(out), "invalid --provider") {
-		t.Errorf("expected error about invalid --provider, got: %s", out)
-	}
-}
-
-// cleanEnv returns environ without any GITEA/LLM/REVIEWER/VCS env vars that would
 // interfere with testing missing-flag scenarios.
 func cleanEnv() []string {
 	var env []string
@@ -920,7 +980,6 @@ func cleanEnv() []string {
 		key := strings.SplitN(e, "=", 2)[0]
 		switch {
 		case strings.HasPrefix(key, "GITEA_"),
-			strings.HasPrefix(key, "VCS_"),
 			strings.HasPrefix(key, "LLM_"),
 			strings.HasPrefix(key, "REVIEWER_"),
 			strings.HasPrefix(key, "PR_"),
@@ -938,12 +997,12 @@ func cleanEnv() []string {
 }
 
 func TestFindAllOwnReviews(t *testing.T) {
-	reviews := []vcs.Review{
+	reviews := []gitea.Review{
-		makeReview(1, "bot", "APPROVED", false, "<!-- review-bot:sonnet -->\nfirst review"),
+		{ID: 1, Body: "<!-- review-bot:sonnet -->\nfirst review"},
-		makeReview(2, "bot", "APPROVED", false, "<!-- review-bot:gpt -->\nother bot"),
+		{ID: 2, Body: "<!-- review-bot:gpt -->\nother bot"},
-		makeReview(3, "bot", "APPROVED", false, "<!-- review-bot:sonnet -->\nsecond review"),
+		{ID: 3, Body: "<!-- review-bot:sonnet -->\nsecond review"},
-		makeReview(4, "bot", "APPROVED", false, "~~Original review~~\n<!-- review-bot:sonnet -->\nsuperseded"),
+		{ID: 4, Body: "~~Original review~~\n<!-- review-bot:sonnet -->\nsuperseded"},
-		makeReview(5, "bot", "APPROVED", false, "<!-- review-bot:sonnet -->\nthird review"),
+		{ID: 5, Body: "<!-- review-bot:sonnet -->\nthird review"},
 	}
 
 	got := findAllOwnReviews(reviews, "<!-- review-bot:sonnet -->")
@@ -1007,23 +1066,3 @@ func TestShouldSkipStaleReview(t *testing.T) {
 		})
 	}
 }
-
-func TestVerdictToEvent(t *testing.T) {
-	tests := []struct {
-		verdict string
-		want    vcs.ReviewEvent
-	}{
-		{"APPROVE", vcs.ReviewEventApprove},
-		{"REQUEST_CHANGES", vcs.ReviewEventRequestChanges},
-		{"COMMENT", vcs.ReviewEventComment},
-		{"other", vcs.ReviewEventComment},
-		{"", vcs.ReviewEventComment},
-	}
-
-	for _, tc := range tests {
-		got := verdictToEvent(tc.verdict)
-		if got != tc.want {
-			t.Errorf("verdictToEvent(%q) = %q, want %q", tc.verdict, got, tc.want)
-		}
-	}
-}

docs/DESIGN-vcs-abstraction.md

@@ -1,268 +0,0 @@
-# GitHub Support for review-bot
-
-## Goal
-
-AI code reviews on GitHub PRs using SAP AI Core as the LLM provider.
-
-## Non-Goals
-
-- Auto-detection of platform (explicit `--provider` flag is fine)
-- Unifying into one abstraction layer for its own sake
-
-## Constraints
-
-1. **Same features on both platforms** — anything review-bot does on Gitea should work on GitHub
-2. **Testable** — small interfaces, dependency injection, no global state
-3. **Interface from working code** — extract from gitea/, don't invent in vacuum
-
----
-
-## Part 1: Feature Inventory
-
-What does review-bot actually do?
-
-### Core Review Flow
-
-| Feature | Description |
-|---------|-------------|
-| Get PR metadata | Title, body, head SHA, base ref |
-| Get PR diff | Unified diff format |
-| Get PR files | List of changed files with status |
-| Get file content | Raw file at ref |
-| List directory | Enumerate files in path |
-| Post review | Body + inline comments + verdict |
-
-### Review Management
-
-| Feature | Description |
-|---------|-------------|
-| List reviews | Get existing reviews on PR |
-| Delete review | Remove old review before re-posting |
-| Get authenticated user | Who am I? |
-
-### Platform-Specific (not in shared interface)
-
-| Feature | Gitea | GitHub |
-|---------|-------|--------|
-| Resolve comment | Yes | No equivalent |
-| Timeline API | Yes | No equivalent |
-
-These stay on gitea.Client directly. Callers that need them type-assert.
-
----
-
-## Part 2: GitHub API Mapping
-
-| Feature | Gitea API | GitHub API |
-|---------|-----------|------------|
-| Get PR | `GET /api/v1/repos/.../pulls/{n}` | `GET /repos/.../pulls/{n}` |
-| Get diff | `.diff` suffix | `Accept: application/vnd.github.diff` header |
-| Get files | `GET .../pulls/{n}/files` | Same |
-| Get file content | `GET .../raw/{path}?ref=` | `GET .../contents/{path}?ref=` + base64 decode |
-| List directory | `GET .../contents/{path}` | Same |
-| Post review | `POST .../pulls/{n}/reviews` | Same (adapter handles comment schema) |
-| List reviews | `GET .../pulls/{n}/reviews` | Same |
-| Delete review | `DELETE .../pulls/{n}/reviews/{id}` | Same |
-| Get user | `GET /api/v1/user` | `GET /user` |
-
----
-
-## Part 3: Interface Design
-
-**Principle:** Extract from working gitea/ code. The interface is discovered, not invented.
-
-### Small, role-based interfaces
-
-```go
-// vcs/interfaces.go
-
-type PRReader interface {
-    GetPullRequest(ctx context.Context, owner, repo string, number int) (*PullRequest, error)
-    GetPullRequestDiff(ctx context.Context, owner, repo string, number int) (string, error)
-    GetPullRequestFiles(ctx context.Context, owner, repo string, number int) ([]ChangedFile, error)
-}
-
-type FileReader interface {
-    GetFileContent(ctx context.Context, owner, repo, path, ref string) (string, error)
-    ListContents(ctx context.Context, owner, repo, path string) ([]ContentEntry, error)
-}
-
-type Reviewer interface {
-    PostReview(ctx context.Context, owner, repo string, number int, req ReviewRequest) (*Review, error)
-    ListReviews(ctx context.Context, owner, repo string, number int) ([]Review, error)
-    DeleteReview(ctx context.Context, owner, repo string, number int, reviewID int64) error
-}
-
-type Identity interface {
-    GetAuthenticatedUser(ctx context.Context) (string, error)
-}
-
-// Client combines all for callers that need everything
-type Client interface {
-    PRReader
-    FileReader
-    Reviewer
-    Identity
-}
-```
-
-### Types
-
-Use what gitea/ already has. Move to vcs/types.go or re-export.
-
-```go
-type PullRequest struct { ... }   // from gitea.PullRequest
-type ChangedFile struct { ... }   // from gitea.ChangedFile
-type ContentEntry struct { ... }  // from gitea.ContentEntry
-type Review struct { ... }        // from gitea.Review
-type ReviewRequest struct { ... } // new, for PostReview input
-type ReviewComment struct { ... } // from gitea.ReviewComment
-```
-
-### Adapter responsibilities
-
-Each adapter (gitea, github) handles:
-- API URL construction
-- Auth header format (`token` vs `Bearer`)
-- Request/response mapping
-- Comment schema translation (line numbers, commit IDs, etc.)
-
----
-
-## Part 4: Test Plan
-
-### Unit Tests (mock HTTP)
-
-```
-github/
-  pr_test.go        # TestGetPullRequest, TestGetDiff, TestGetFiles
-  files_test.go     # TestGetFileContent, TestListContents
-  review_test.go    # TestPostReview, TestListReviews, TestDeleteReview
-  identity_test.go  # TestGetAuthenticatedUser
-```
-
-Per method: happy path, 404, 401, 429, malformed response.
-
-### Integration Tests
-
-Against github.com/aweiker/ai-core-review-bot:
-- Fetch real PR
-- Fetch real file
-- Post + delete review (clean up)
-
-### End-to-End
-
-Open PR on test repo, run full review-bot, verify review appears.
-
----
-
-## Part 5: Implementation Phases
-
-### Phase 1: Extract interfaces from gitea/
-
-**Work:**
-- Create `vcs/interfaces.go` with interfaces extracted from gitea/client.go signatures
-- Create `vcs/types.go` — move or alias types from gitea/
-- Verify gitea.Client satisfies vcs.Client (compile-time check)
-
-**Exit criteria:** `var _ vcs.Client = (*gitea.Client)(nil)` compiles.
-
----
-
-### Phase 2: Gitea adapter (if needed)
-
-**Work:**
-- If gitea.Client method signatures don't match exactly, create wrapper
-- Keep gitea/ working exactly as before
-
-**Exit criteria:** Existing tests pass. No behavior change.
-
----
-
-### Phase 3: GitHub client — PRReader
-
-**Work:**
-- `github/client.go` — struct, constructor, HTTP helpers
-- `github/pr.go` — GetPullRequest, GetPullRequestDiff, GetPullRequestFiles
-- Unit tests
-
-**Exit criteria:** `go test ./github/...` passes for PR methods.
-
----
-
-### Phase 4: GitHub client — FileReader
-
-**Work:**
-- `github/files.go` — GetFileContent, ListContents
-- Unit tests
-
-**Exit criteria:** Unit tests pass.
-
----
-
-### Phase 5: GitHub client — Reviewer + Identity
-
-**Work:**
-- `github/review.go` — PostReview, ListReviews, DeleteReview
-- `github/identity.go` — GetAuthenticatedUser
-- Unit tests
-
-**Exit criteria:** Unit tests pass.
-
----
-
-### Phase 6: Integration tests
-
-**Work:**
-- `integration/github_test.go`
-- Test against real GitHub
-
-**Exit criteria:** All integration tests pass.
-
----
-
-### Phase 7: Wire into cmd/review-bot
-
-**Work:**
-- Add `--provider github|gitea` flag (default: gitea for backward compat)
-- Select client based on flag
-- Update to use vcs interfaces where it makes sense
-
-**Exit criteria:**
-- `./review-bot --provider github ...` works
-- `./review-bot --provider gitea ...` works (same as before)
-- Existing Gitea workflows unchanged
-
----
-
-### Phase 8: GitHub Actions workflow + releases
-
-**Work:**
-- `.github/workflows/ci.yml` — test on PR
-- `.github/workflows/release.yml` — publish binary to GitHub releases
-- `.github/actions/review/action.yml` — composite action
-- Action downloads binary from github.com/aweiker/ai-core-review-bot releases
-
-**Exit criteria:** 
-- CI runs on github.com/aweiker/ai-core-review-bot
-- Release creates downloadable binary
-- Review action posts review successfully
-
----
-
-## Part 6: Decisions
-
-| Question | Decision |
-|----------|----------|
-| Auth token | Workflow `GITHUB_TOKEN` (automatic) |
-| Binary distribution | GitHub releases on aweiker/ai-core-review-bot |
-| Comment schema | Adapter's job — translate ReviewComment to platform format |
-| Default provider | `gitea` for backward compatibility |
-| Shared types | vcs/types.go (extracted from gitea/) |
-| Platform-specific features | Stay on concrete client, not interface |
-
----
-
-## Summary
-
-8 phases. Start by extracting interfaces from working gitea/ code, not inventing them. GitHub implements the same interfaces. Each phase has clear exit criteria.

gitea/adapter.go

@@ -1,232 +0,0 @@
-package gitea
-
-import (
-	"context"
-	"fmt"
-
-	"gitea.weiker.me/rodin/review-bot/vcs"
-)
-
-// Adapter wraps a gitea.Client and satisfies the vcs.Client interface.
-// It handles translation between GitHub-canonical diff positions and Gitea
-// line numbers, and between canonical review event strings and Gitea-native values.
-type Adapter struct {
-	client *Client
-}
-
-// Compile-time interface conformance assertion.
-var _ vcs.Client = (*Adapter)(nil)
-
-// NewAdapter creates a new Adapter wrapping the given gitea Client.
-func NewAdapter(client *Client) *Adapter {
-	return &Adapter{client: client}
-}
-
-// Underlying returns the wrapped gitea.Client for Gitea-specific operations
-// that have no vcs.Client equivalent (resolve comment, timeline, supersede flow).
-func (a *Adapter) Underlying() *Client {
-	return a.client
-}
-
-// --- PRReader ---
-
-// GetPullRequest maps gitea.PullRequest to vcs.PullRequest.
-func (a *Adapter) GetPullRequest(ctx context.Context, owner, repo string, number int) (*vcs.PullRequest, error) {
-	pr, err := a.client.GetPullRequest(ctx, owner, repo, number)
-	if err != nil {
-		return nil, fmt.Errorf("get pull request: %w", err)
-	}
-	return &vcs.PullRequest{
-		Number: number,
-		Title:  pr.Title,
-		Body:   pr.Body,
-		Head: vcs.HeadRef{
-			SHA: pr.Head.Sha,
-			Ref: pr.Head.Ref,
-		},
-		Base: vcs.BaseRef{
-			Ref: pr.Base.Ref,
-		},
-	}, nil
-}
-
-// GetPullRequestDiff is a pass-through to the underlying client.
-func (a *Adapter) GetPullRequestDiff(ctx context.Context, owner, repo string, number int) (string, error) {
-	return a.client.GetPullRequestDiff(ctx, owner, repo, number)
-}
-
-// GetPullRequestFiles maps []gitea.ChangedFile to []vcs.ChangedFile.
-// Patch field is omitted (zero-value) since Gitea's /pulls/{n}/files does not return patch text.
-func (a *Adapter) GetPullRequestFiles(ctx context.Context, owner, repo string, number int) ([]vcs.ChangedFile, error) {
-	files, err := a.client.GetPullRequestFiles(ctx, owner, repo, number)
-	if err != nil {
-		return nil, err
-	}
-	result := make([]vcs.ChangedFile, len(files))
-	for i, f := range files {
-		result[i] = vcs.ChangedFile{
-			Filename: f.Filename,
-			Status:   f.Status,
-		}
-	}
-	return result, nil
-}
-
-// GetFileContentAtRef is a pass-through to the underlying client.
-func (a *Adapter) GetFileContentAtRef(ctx context.Context, owner, repo, path, ref string) (string, error) {
-	return a.client.GetFileContentAtRef(ctx, owner, repo, path, ref)
-}
-
-// GetCommitStatuses maps []gitea.CommitStatus to []vcs.CommitStatus.
-func (a *Adapter) GetCommitStatuses(ctx context.Context, owner, repo, sha string) ([]vcs.CommitStatus, error) {
-	statuses, err := a.client.GetCommitStatuses(ctx, owner, repo, sha)
-	if err != nil {
-		return nil, err
-	}
-	result := make([]vcs.CommitStatus, len(statuses))
-	for i, s := range statuses {
-		result[i] = vcs.CommitStatus{
-			Status:      s.Status,
-			Context:     s.Context,
-			Description: s.Description,
-			TargetURL:   s.TargetURL,
-		}
-	}
-	return result, nil
-}
-
-// --- FileReader ---
-
-// GetFileContent delegates to the underlying client, routing to the ref-aware
-// variant when ref is non-empty.
-func (a *Adapter) GetFileContent(ctx context.Context, owner, repo, path, ref string) (string, error) {
-	if ref != "" {
-		return a.client.GetFileContentRef(ctx, owner, repo, path, ref)
-	}
-	return a.client.GetFileContent(ctx, owner, repo, path)
-}
-
-// ListContents maps []gitea.ContentEntry to []vcs.ContentEntry.
-func (a *Adapter) ListContents(ctx context.Context, owner, repo, path string) ([]vcs.ContentEntry, error) {
-	entries, err := a.client.ListContents(ctx, owner, repo, path)
-	if err != nil {
-		return nil, err
-	}
-	result := make([]vcs.ContentEntry, len(entries))
-	for i, e := range entries {
-		result[i] = vcs.ContentEntry{
-			Name: e.Name,
-			Path: e.Path,
-			Type: e.Type,
-		}
-	}
-	return result, nil
-}
-
-// --- Reviewer ---
-
-// translateEvent translates a vcs.ReviewEvent (GitHub-canonical) to a Gitea-native event string.
-func translateEvent(event vcs.ReviewEvent) string {
-	switch event {
-	case vcs.ReviewEventApprove:
-		return "APPROVED"
-	case vcs.ReviewEventRequestChanges:
-		return "REQUEST_CHANGES"
-	case vcs.ReviewEventComment:
-		return "COMMENT"
-	default:
-		// Unknown events pass through as-is. This is intentional: new event types
-		// added to vcs.ReviewEvent will still be forwarded without a code change here,
-		// and Gitea will reject truly invalid values with a clear API error.
-		return string(event)
-	}
-}
-
-// PostReview translates vcs.ReviewRequest to the Gitea-native format.
-// It fetches the PR diff, builds a position-to-line map, and translates each
-// ReviewComment.Position (GitHub diff-position) to a Gitea new_position (line number).
-func (a *Adapter) PostReview(ctx context.Context, owner, repo string, number int, req vcs.ReviewRequest) (*vcs.Review, error) {
-	event := translateEvent(req.Event)
-
-	var giteaComments []ReviewComment
-	if len(req.Comments) > 0 {
-		// Fetch diff to build position → line number map.
-		// The diff is fetched unconditionally when comments exist. This adds latency
-		// for reviews with inline comments but keeps the implementation simple — caching
-		// the diff across calls would add complexity for minimal gain since PostReview
-		// is called at most once per review cycle.
-		diff, err := a.client.GetPullRequestDiff(ctx, owner, repo, number)
-		if err != nil {
-			return nil, fmt.Errorf("fetch diff for position translation: %w", err)
-		}
-
-		posMap := BuildPositionToLineMap(diff)
-
-		for _, c := range req.Comments {
-			lineNum, err := posMap.Translate(c.Path, c.Position)
-			if err != nil {
-				return nil, fmt.Errorf("translate position %d in %s: %w", c.Position, c.Path, err)
-			}
-			// CommitID from vcs.ReviewComment is intentionally not forwarded:
-			// Gitea review comments are pinned to the PR head SHA automatically,
-			// and the CreatePullReview API has no per-comment commit_id field.
-			giteaComments = append(giteaComments, ReviewComment{
-				Path:        c.Path,
-				NewPosition: int64(lineNum),
-				Body:        c.Body,
-			})
-		}
-	}
-
-	review, err := a.client.PostReview(ctx, owner, repo, number, event, req.Body, giteaComments)
-	if err != nil {
-		return nil, fmt.Errorf("post review: %w", err)
-	}
-
-	return &vcs.Review{
-		ID:       review.ID,
-		Body:     review.Body,
-		User:     vcs.UserInfo{Login: review.User.Login},
-		State:    review.State,
-		Stale:    review.Stale,
-		CommitID: review.CommitID,
-	}, nil
-}
-
-// ListReviews maps []gitea.Review to []vcs.Review.
-func (a *Adapter) ListReviews(ctx context.Context, owner, repo string, number int) ([]vcs.Review, error) {
-	reviews, err := a.client.ListReviews(ctx, owner, repo, number)
-	if err != nil {
-		return nil, err
-	}
-	result := make([]vcs.Review, len(reviews))
-	for i, r := range reviews {
-		result[i] = vcs.Review{
-			ID:       r.ID,
-			Body:     r.Body,
-			User:     vcs.UserInfo{Login: r.User.Login},
-			State:    r.State,
-			Stale:    r.Stale,
-			CommitID: r.CommitID,
-		}
-	}
-	return result, nil
-}
-
-// DeleteReview is a pass-through to the underlying client.
-func (a *Adapter) DeleteReview(ctx context.Context, owner, repo string, number int, reviewID int64) error {
-	return a.client.DeleteReview(ctx, owner, repo, number, reviewID)
-}
-
-// DismissReview deletes the review. Gitea supports full deletion of any review state.
-// The message parameter is intentionally unused — Gitea deletion has no dismissal message.
-func (a *Adapter) DismissReview(ctx context.Context, owner, repo string, number int, reviewID int64, message string) error {
-	return a.client.DeleteReview(ctx, owner, repo, number, reviewID)
-}
-
-// --- Identity ---
-
-// GetAuthenticatedUser is a pass-through to the underlying client.
-func (a *Adapter) GetAuthenticatedUser(ctx context.Context) (string, error) {
-	return a.client.GetAuthenticatedUser(ctx)
-}

gitea/adapter_test.go

@@ -1,388 +0,0 @@
-package gitea_test
-
-import (
-	"context"
-	"encoding/json"
-	"net/http"
-	"net/http/httptest"
-	"strings"
-	"testing"
-
-	"gitea.weiker.me/rodin/review-bot/gitea"
-	"gitea.weiker.me/rodin/review-bot/vcs"
-)
-
-func TestAdapter_GetPullRequest(t *testing.T) {
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.Header().Set("Content-Type", "application/json")
-		json.NewEncoder(w).Encode(map[string]any{
-			"title": "Test PR",
-			"body":  "PR body",
-			"head": map[string]any{
-				"sha": "abc123",
-				"ref": "feature-branch",
-			},
-			"base": map[string]any{
-				"ref": "main",
-			},
-		})
-	}))
-	defer server.Close()
-
-	client := gitea.NewClient(server.URL, "token")
-	adapter := gitea.NewAdapter(client)
-
-	pr, err := adapter.GetPullRequest(context.Background(), "owner", "repo", 42)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if pr.Number != 42 {
-		t.Errorf("Number = %d, want 42", pr.Number)
-	}
-	if pr.Title != "Test PR" {
-		t.Errorf("Title = %q, want %q", pr.Title, "Test PR")
-	}
-	if pr.Body != "PR body" {
-		t.Errorf("Body = %q, want %q", pr.Body, "PR body")
-	}
-	if pr.Head.SHA != "abc123" {
-		t.Errorf("Head.SHA = %q, want %q", pr.Head.SHA, "abc123")
-	}
-	if pr.Head.Ref != "feature-branch" {
-		t.Errorf("Head.Ref = %q, want %q", pr.Head.Ref, "feature-branch")
-	}
-	if pr.Base.Ref != "main" {
-		t.Errorf("Base.Ref = %q, want %q", pr.Base.Ref, "main")
-	}
-}
-
-func TestAdapter_GetPullRequestFiles(t *testing.T) {
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.Header().Set("Content-Type", "application/json")
-		json.NewEncoder(w).Encode([]map[string]any{
-			{"filename": "main.go", "status": "modified"},
-			{"filename": "new.go", "status": "added"},
-		})
-	}))
-	defer server.Close()
-
-	client := gitea.NewClient(server.URL, "token")
-	adapter := gitea.NewAdapter(client)
-
-	files, err := adapter.GetPullRequestFiles(context.Background(), "owner", "repo", 1)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if len(files) != 2 {
-		t.Fatalf("got %d files, want 2", len(files))
-	}
-	if files[0].Filename != "main.go" || files[0].Status != "modified" {
-		t.Errorf("files[0] = %+v", files[0])
-	}
-	if files[1].Filename != "new.go" || files[1].Status != "added" {
-		t.Errorf("files[1] = %+v", files[1])
-	}
-}
-
-func TestAdapter_ListReviews(t *testing.T) {
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.Header().Set("Content-Type", "application/json")
-		json.NewEncoder(w).Encode([]map[string]any{
-			{
-				"id":        1,
-				"body":      "LGTM",
-				"user":      map[string]any{"login": "reviewer1"},
-				"state":     "APPROVED",
-				"stale":     false,
-				"commit_id": "abc123",
-			},
-			{
-				"id":        2,
-				"body":      "Needs work",
-				"user":      map[string]any{"login": "reviewer2"},
-				"state":     "REQUEST_CHANGES",
-				"stale":     true,
-				"commit_id": "def456",
-			},
-		})
-	}))
-	defer server.Close()
-
-	client := gitea.NewClient(server.URL, "token")
-	adapter := gitea.NewAdapter(client)
-
-	reviews, err := adapter.ListReviews(context.Background(), "owner", "repo", 1)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if len(reviews) != 2 {
-		t.Fatalf("got %d reviews, want 2", len(reviews))
-	}
-	if reviews[0].ID != 1 || reviews[0].Body != "LGTM" || reviews[0].User.Login != "reviewer1" {
-		t.Errorf("reviews[0] = %+v", reviews[0])
-	}
-	if reviews[0].State != "APPROVED" || reviews[0].Stale || reviews[0].CommitID != "abc123" {
-		t.Errorf("reviews[0] state/stale/commit = %v/%v/%v", reviews[0].State, reviews[0].Stale, reviews[0].CommitID)
-	}
-	if reviews[1].ID != 2 || !reviews[1].Stale || reviews[1].State != "REQUEST_CHANGES" {
-		t.Errorf("reviews[1] = %+v", reviews[1])
-	}
-}
-
-func TestAdapter_GetCommitStatuses(t *testing.T) {
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.Header().Set("Content-Type", "application/json")
-		json.NewEncoder(w).Encode([]map[string]any{
-			{
-				"status":      "success",
-				"context":     "ci/test",
-				"description": "All tests pass",
-				"target_url":  "https://ci.example.com/1",
-			},
-		})
-	}))
-	defer server.Close()
-
-	client := gitea.NewClient(server.URL, "token")
-	adapter := gitea.NewAdapter(client)
-
-	statuses, err := adapter.GetCommitStatuses(context.Background(), "owner", "repo", "abc123")
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if len(statuses) != 1 {
-		t.Fatalf("got %d statuses, want 1", len(statuses))
-	}
-	if statuses[0].Status != "success" {
-		t.Errorf("Status = %q, want %q", statuses[0].Status, "success")
-	}
-	if statuses[0].Context != "ci/test" {
-		t.Errorf("Context = %q, want %q", statuses[0].Context, "ci/test")
-	}
-	if statuses[0].Description != "All tests pass" {
-		t.Errorf("Description = %q, want %q", statuses[0].Description, "All tests pass")
-	}
-	if statuses[0].TargetURL != "https://ci.example.com/1" {
-		t.Errorf("TargetURL = %q, want %q", statuses[0].TargetURL, "https://ci.example.com/1")
-	}
-}
-
-func TestAdapter_PostReview_EventTranslation(t *testing.T) {
-	tests := []struct {
-		name      string
-		event     vcs.ReviewEvent
-		wantEvent string
-	}{
-		{"APPROVE becomes APPROVED", vcs.ReviewEventApprove, "APPROVED"},
-		{"REQUEST_CHANGES stays", vcs.ReviewEventRequestChanges, "REQUEST_CHANGES"},
-		{"COMMENT stays", vcs.ReviewEventComment, "COMMENT"},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			var gotEvent string
-			server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-				w.Header().Set("Content-Type", "application/json")
-				var payload struct {
-					Event string `json:"event"`
-				}
-				json.NewDecoder(r.Body).Decode(&payload)
-				gotEvent = payload.Event
-				json.NewEncoder(w).Encode(map[string]any{
-					"id":   1,
-					"body": "test",
-					"user": map[string]any{"login": "bot"},
-				})
-			}))
-			defer server.Close()
-
-			client := gitea.NewClient(server.URL, "token")
-			adapter := gitea.NewAdapter(client)
-
-			_, err := adapter.PostReview(context.Background(), "owner", "repo", 1, vcs.ReviewRequest{
-				Body:  "test",
-				Event: tt.event,
-				// No comments → no diff fetch needed
-			})
-			if err != nil {
-				t.Fatalf("unexpected error: %v", err)
-			}
-			if gotEvent != tt.wantEvent {
-				t.Errorf("event = %q, want %q", gotEvent, tt.wantEvent)
-			}
-		})
-	}
-}
-
-func TestAdapter_PostReview_WithComments_PositionTranslation(t *testing.T) {
-	diff := `diff --git a/main.go b/main.go
---- a/main.go
-+++ b/main.go
-@@ -1,3 +1,4 @@
- package main
- 
-+// new comment at line 3
- func main() {}
-`
-	var gotComments []struct {
-		Path        string `json:"path"`
-		NewPosition int64  `json:"new_position"`
-		Body        string `json:"body"`
-	}
-
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.Header().Set("Content-Type", "application/json")
-		if strings.HasSuffix(r.URL.Path, ".diff") {
-			// Diff request
-			w.Write([]byte(diff))
-			return
-		}
-		if strings.HasSuffix(r.URL.Path, "/reviews") {
-			// Review post
-			var payload struct {
-				Comments []struct {
-					Path        string `json:"path"`
-					NewPosition int64  `json:"new_position"`
-					Body        string `json:"body"`
-				} `json:"comments"`
-			}
-			json.NewDecoder(r.Body).Decode(&payload)
-			gotComments = payload.Comments
-			json.NewEncoder(w).Encode(map[string]any{
-				"id":   1,
-				"body": "review",
-				"user": map[string]any{"login": "bot"},
-			})
-			return
-		}
-		t.Errorf("unexpected request: %s %s", r.Method, r.URL.Path)
-		w.WriteHeader(http.StatusNotFound)
-	}))
-	defer server.Close()
-
-	client := gitea.NewClient(server.URL, "token")
-	adapter := gitea.NewAdapter(client)
-
-	// Position 4 in this diff is "+// new comment at line 3" → new line 3
-	_, err := adapter.PostReview(context.Background(), "owner", "repo", 1, vcs.ReviewRequest{
-		Body:  "review",
-		Event: vcs.ReviewEventRequestChanges,
-		Comments: []vcs.ReviewComment{
-			{
-				Path:     "main.go",
-				Position: 4,
-				CommitID: "abc123",
-				Body:     "needs fix",
-			},
-		},
-	})
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	if len(gotComments) != 1 {
-		t.Fatalf("got %d comments, want 1", len(gotComments))
-	}
-	if gotComments[0].Path != "main.go" {
-		t.Errorf("path = %q, want %q", gotComments[0].Path, "main.go")
-	}
-	if gotComments[0].NewPosition != 3 {
-		t.Errorf("new_position = %d, want 3", gotComments[0].NewPosition)
-	}
-	if gotComments[0].Body != "needs fix" {
-		t.Errorf("body = %q, want %q", gotComments[0].Body, "needs fix")
-	}
-}
-
-func TestAdapter_DismissReview(t *testing.T) {
-	var deleteCalled bool
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if r.Method == http.MethodDelete {
-			deleteCalled = true
-			w.WriteHeader(204)
-			return
-		}
-		w.WriteHeader(404)
-	}))
-	defer server.Close()
-
-	client := gitea.NewClient(server.URL, "token")
-	adapter := gitea.NewAdapter(client)
-
-	err := adapter.DismissReview(context.Background(), "owner", "repo", 1, 99, "stale review")
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if !deleteCalled {
-		t.Error("expected delete to be called")
-	}
-}
-
-func TestAdapter_Underlying(t *testing.T) {
-	client := gitea.NewClient("http://example.com", "token")
-	adapter := gitea.NewAdapter(client)
-	if adapter.Underlying() != client {
-		t.Error("Underlying() should return the wrapped client")
-	}
-}
-
-func TestAdapter_ListContents(t *testing.T) {
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.Header().Set("Content-Type", "application/json")
-		json.NewEncoder(w).Encode([]map[string]any{
-			{"name": "main.go", "path": "src/main.go", "type": "file"},
-			{"name": "util", "path": "src/util", "type": "dir"},
-		})
-	}))
-	defer server.Close()
-
-	client := gitea.NewClient(server.URL, "token")
-	adapter := gitea.NewAdapter(client)
-
-	entries, err := adapter.ListContents(context.Background(), "owner", "repo", "src")
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if len(entries) != 2 {
-		t.Fatalf("got %d entries, want 2", len(entries))
-	}
-	if entries[0].Name != "main.go" || entries[0].Type != "file" {
-		t.Errorf("entries[0] = %+v", entries[0])
-	}
-	if entries[1].Name != "util" || entries[1].Type != "dir" {
-		t.Errorf("entries[1] = %+v", entries[1])
-	}
-}
-
-func TestAdapter_GetFileContent_RefRouting(t *testing.T) {
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		// When ref is provided, the URL should contain ?ref=
-		if r.URL.RawQuery != "" && strings.Contains(r.URL.RawQuery, "ref=") {
-			w.Write([]byte("content-at-ref"))
-		} else {
-			w.Write([]byte("content-default"))
-		}
-	}))
-	defer server.Close()
-
-	client := gitea.NewClient(server.URL, "token")
-	adapter := gitea.NewAdapter(client)
-
-	// Empty ref → routes to GetFileContent (no ?ref= query param)
-	got, err := adapter.GetFileContent(context.Background(), "owner", "repo", "main.go", "")
-	if err != nil {
-		t.Fatalf("GetFileContent(ref=\"\"): %v", err)
-	}
-	if got != "content-default" {
-		t.Errorf("GetFileContent(ref=\"\") = %q, want %q", got, "content-default")
-	}
-
-	// Non-empty ref → routes to GetFileContentRef (with ?ref= query param)
-	got, err = adapter.GetFileContent(context.Background(), "owner", "repo", "main.go", "abc123")
-	if err != nil {
-		t.Fatalf("GetFileContent(ref=\"abc123\"): %v", err)
-	}
-	if got != "content-at-ref" {
-		t.Errorf("GetFileContent(ref=\"abc123\") = %q, want %q", got, "content-at-ref")
-	}
-}

gitea/client.go

@@ -86,9 +86,6 @@ type PullRequest struct {
 		Sha string `json:"sha"`
 		Ref string `json:"ref"`
 	} `json:"head"`
-	Base struct {
-		Ref string `json:"ref"`
-	} `json:"base"`
 }
 
 // CommitStatus represents a single CI status entry.
@@ -834,15 +831,3 @@ func (c *Client) ResolveComment(ctx context.Context, owner, repo string, comment
 	}
 	return nil
 }
-
-// DismissReview dismisses a review on a pull request.
-// This is a stub for the vcs.Reviewer interface; full implementation is Phase 2.
-func (c *Client) DismissReview(ctx context.Context, owner, repo string, number int, reviewID int64, message string) error {
-	return fmt.Errorf("dismiss review %d on %s/%s#%d: %w", reviewID, owner, repo, number, errors.ErrUnsupported)
-}
-
-// GetFileContentAtRef fetches a file at a specific ref from a repo.
-// This delegates to GetFileContentRef for the Gitea implementation.
-func (c *Client) GetFileContentAtRef(ctx context.Context, owner, repo, path, ref string) (string, error) {
-	return c.GetFileContentRef(ctx, owner, repo, path, ref)
-}

gitea/conformance_test.go

@@ -1,10 +0,0 @@
-package gitea_test
-
-import (
-	"gitea.weiker.me/rodin/review-bot/gitea"
-	"gitea.weiker.me/rodin/review-bot/vcs"
-)
-
-// Compile-time interface conformance assertion.
-// The Adapter (not the raw Client) satisfies the full vcs.Client interface.
-var _ vcs.Client = (*gitea.Adapter)(nil)

gitea/position.go

@@ -1,190 +0,0 @@
-package gitea
-
-import (
-	"fmt"
-	"strconv"
-	"strings"
-)
-
-// PositionMap holds a per-file mapping of GitHub diff-position to new-file line number.
-// Position is a 1-indexed offset from the @@ hunk header line in the unified diff.
-type PositionMap struct {
-	// files maps filename → (position → new-file line number).
-	// Deletion lines are mapped to -1 (no new-file line).
-	files map[string]map[int]int
-	// maxPositions caches the highest position number per file,
-	// tracked during construction to avoid O(n) scans at translate time.
-	maxPositions map[string]int
-}
-
-// Translate converts a GitHub diff-position to a new-file line number for a given file.
-// Returns an error if the file is not in the diff or the position is out of range.
-// If the position targets a deletion line, it maps to the nearest non-deletion line below;
-// if no such line exists, returns an error.
-func (pm *PositionMap) Translate(file string, position int) (int, error) {
-	if pm == nil || pm.files == nil {
-		return 0, fmt.Errorf("empty position map")
-	}
-
-	fileMap, ok := pm.files[file]
-	if !ok {
-		return 0, fmt.Errorf("file %q not found in diff", file)
-	}
-
-	if position < 1 {
-		return 0, fmt.Errorf("position %d out of range (must be >= 1)", position)
-	}
-
-	lineNum, ok := fileMap[position]
-	if !ok {
-		return 0, fmt.Errorf("position %d out of range for file %q", position, file)
-	}
-
-	// lineNum == -1 means this position is a deletion line.
-	// Map to the nearest non-deletion line below.
-	if lineNum == -1 {
-		maxPos := pm.maxPosition(file)
-		for p := position + 1; p <= maxPos; p++ {
-			if ln, exists := fileMap[p]; exists && ln > 0 {
-				return ln, nil
-			}
-		}
-		return 0, fmt.Errorf("position %d targets a deletion line with no subsequent new-file line in %q", position, file)
-	}
-
-	return lineNum, nil
-}
-
-// maxPosition returns the highest position number for a file.
-// O(1) — the maximum is tracked during map construction.
-func (pm *PositionMap) maxPosition(file string) int {
-	return pm.maxPositions[file]
-}
-
-// BuildPositionToLineMap parses a unified diff and builds a PositionMap
-// mapping diff-position → new-file line number per file.
-//
-// Diff-position counting rules (GitHub spec):
-//   - The @@ hunk header line is position 1 for the file's first hunk
-//   - Every subsequent line increments position by 1 — context, additions, AND deletions
-//   - A new @@ hunk within the same file continues incrementing (does not reset)
-//   - Position maps to the new file line number for additions and context lines
-//   - Deletion lines have a position but no new-file line number (stored as -1)
-func BuildPositionToLineMap(diff string) *PositionMap {
-	pm := &PositionMap{
-		files:        make(map[string]map[int]int),
-		maxPositions: make(map[string]int),
-	}
-
-	lines := strings.Split(diff, "\n")
-	var currentFile string
-	var position int
-	var newLine int
-
-	for _, line := range lines {
-		// Detect new file in diff.
-		// "+++ b/" is checked before "+++ /dev/null" — the two prefixes are
-		// non-overlapping ("+++ /dev/null" does not start with "+++ b/"), so
-		// ordering is independent. Checking the common case first for clarity.
-		if strings.HasPrefix(line, "+++ b/") {
-			currentFile = strings.TrimPrefix(line, "+++ b/")
-			position = 0
-			newLine = 0
-			if pm.files[currentFile] == nil {
-				pm.files[currentFile] = make(map[int]int)
-			}
-			continue
-		}
-
-		// Deleted file: +++ /dev/null means the file is being deleted
-		if strings.HasPrefix(line, "+++ /dev/null") {
-			currentFile = ""
-			continue
-		}
-
-		// Skip --- lines (old file header)
-		if strings.HasPrefix(line, "--- ") {
-			continue
-		}
-
-		// Skip diff --git lines
-		if strings.HasPrefix(line, "diff --git") {
-			continue
-		}
-
-		// Skip index lines
-		if strings.HasPrefix(line, "index ") {
-			continue
-		}
-
-		// Binary file detection
-		if strings.HasPrefix(line, "Binary files") {
-			currentFile = ""
-			continue
-		}
-
-		// Parse hunk headers
-		if strings.HasPrefix(line, "@@") && currentFile != "" {
-			position++
-			pm.maxPositions[currentFile] = position
-			newLine = parseHunkStart(line)
-			continue
-		}
-
-		if currentFile == "" {
-			continue
-		}
-
-		// Skip "\ No newline at end of file" markers
-		if strings.HasPrefix(line, `\`) {
-			continue
-		}
-
-		// Process diff content lines
-		if strings.HasPrefix(line, "+") {
-			// Addition: has a new-file line number
-			position++
-			pm.files[currentFile][position] = newLine
-			pm.maxPositions[currentFile] = position
-			newLine++
-		} else if strings.HasPrefix(line, "-") {
-			// Deletion: has a position but no new-file line number
-			position++
-			pm.files[currentFile][position] = -1
-			pm.maxPositions[currentFile] = position
-		} else if strings.HasPrefix(line, " ") {
-			// Context line
-			position++
-			pm.files[currentFile][position] = newLine
-			pm.maxPositions[currentFile] = position
-			newLine++
-		}
-	}
-
-	return pm
-}
-
-// parseHunkStart extracts the new-file starting line number from a hunk header.
-// Format: @@ -old_start[,old_count] +new_start[,new_count] @@
-func parseHunkStart(hunkLine string) int {
-	plusIdx := strings.Index(hunkLine, "+")
-	if plusIdx < 0 {
-		return 1
-	}
-	rest := hunkLine[plusIdx+1:]
-
-	endIdx := 0
-	for endIdx < len(rest) && rest[endIdx] >= '0' && rest[endIdx] <= '9' {
-		endIdx++
-	}
-
-	if endIdx == 0 {
-		return 1
-	}
-
-	n, err := strconv.Atoi(rest[:endIdx])
-	if err != nil {
-		return 1
-	}
-	return n
-}

gitea/position_test.go

@@ -1,274 +0,0 @@
-package gitea
-
-import (
-	"testing"
-)
-
-func TestBuildPositionToLineMap_SingleHunk(t *testing.T) {
-	// @@ -16,4 +16,5 @@  ← position 1
-	// context           ← position 2, new line 16
-	//-deleted           ← position 3, no new line
-	//+added             ← position 4, new line 17
-	// context           ← position 5, new line 18
-	diff := `diff --git a/file.go b/file.go
-index abc..def 100644
---- a/file.go
-+++ b/file.go
-@@ -16,4 +16,5 @@ func example() {
- context line
--deleted line
-+added line
- context after
-`
-	pm := BuildPositionToLineMap(diff)
-
-	tests := []struct {
-		pos      int
-		wantLine int
-	}{
-		{2, 16}, // context line -> new line 16
-		{4, 17}, // added line -> new line 17
-		{5, 18}, // context after -> new line 18
-	}
-	for _, tt := range tests {
-		got, err := pm.Translate("file.go", tt.pos)
-		if err != nil {
-			t.Errorf("Translate(file.go, %d): unexpected error: %v", tt.pos, err)
-			continue
-		}
-		if got != tt.wantLine {
-			t.Errorf("Translate(file.go, %d) = %d, want %d", tt.pos, got, tt.wantLine)
-		}
-	}
-}
-
-func TestBuildPositionToLineMap_MultipleHunks(t *testing.T) {
-	diff := `diff --git a/file.go b/file.go
---- a/file.go
-+++ b/file.go
-@@ -1,3 +1,3 @@ package main
- line1
--old
-+new
-@@ -10,3 +10,4 @@ func foo() {
- func foo() {
-+	// added
- 	return
- }
-`
-	pm := BuildPositionToLineMap(diff)
-
-	tests := []struct {
-		pos      int
-		wantLine int
-	}{
-		// First hunk: @@ is pos 1
-		{2, 1},  // " line1" -> new line 1
-		{4, 2},  // "+new" -> new line 2
-		// Second hunk: @@ is pos 5 (continues from 4)
-		// Wait: first hunk has pos 1(@@ hdr), 2(" line1"), 3("-old"), 4("+new")
-		// Second hunk @@ is pos 5
-		{6, 10}, // " func foo() {" -> new line 10
-		{7, 11}, // "+\t// added" -> new line 11
-		{8, 12}, // " \treturn" -> new line 12
-		{9, 13}, // " }" -> new line 13
-	}
-	for _, tt := range tests {
-		got, err := pm.Translate("file.go", tt.pos)
-		if err != nil {
-			t.Errorf("Translate(file.go, %d): unexpected error: %v", tt.pos, err)
-			continue
-		}
-		if got != tt.wantLine {
-			t.Errorf("Translate(file.go, %d) = %d, want %d", tt.pos, got, tt.wantLine)
-		}
-	}
-}
-
-func TestBuildPositionToLineMap_DeletionTargeted(t *testing.T) {
-	diff := `diff --git a/file.go b/file.go
---- a/file.go
-+++ b/file.go
-@@ -1,4 +1,3 @@ package main
- line1
--deleted
- line3
-`
-	pm := BuildPositionToLineMap(diff)
-
-	// Position 3 is the deletion line "-deleted" — should map to nearest below
-	// Position 4 is " line3" which is new line 2
-	got, err := pm.Translate("file.go", 3)
-	if err != nil {
-		t.Fatalf("Translate(file.go, 3): unexpected error: %v", err)
-	}
-	if got != 2 {
-		t.Errorf("Translate(file.go, 3) = %d, want 2 (nearest non-deletion below)", got)
-	}
-}
-
-func TestBuildPositionToLineMap_DeletionAtEnd(t *testing.T) {
-	// If a deletion line is at the end with no subsequent non-deletion line, error
-	diff := `diff --git a/file.go b/file.go
---- a/file.go
-+++ b/file.go
-@@ -1,3 +1,2 @@ package main
- line1
- line2
--deleted at end
-`
-	pm := BuildPositionToLineMap(diff)
-
-	_, err := pm.Translate("file.go", 4)
-	if err == nil {
-		t.Error("expected error for deletion at end with no subsequent line")
-	}
-}
-
-func TestBuildPositionToLineMap_NewFile(t *testing.T) {
-	diff := `diff --git a/new.go b/new.go
-new file mode 100644
---- /dev/null
-+++ b/new.go
-@@ -0,0 +1,3 @@
-+package main
-+
-+func init() {}
-`
-	pm := BuildPositionToLineMap(diff)
-
-	tests := []struct {
-		pos      int
-		wantLine int
-	}{
-		{2, 1}, // "+package main" -> line 1
-		{3, 2}, // "+" (empty line) -> line 2
-		{4, 3}, // "+func init() {}" -> line 3
-	}
-	for _, tt := range tests {
-		got, err := pm.Translate("new.go", tt.pos)
-		if err != nil {
-			t.Errorf("Translate(new.go, %d): unexpected error: %v", tt.pos, err)
-			continue
-		}
-		if got != tt.wantLine {
-			t.Errorf("Translate(new.go, %d) = %d, want %d", tt.pos, got, tt.wantLine)
-		}
-	}
-}
-
-func TestBuildPositionToLineMap_DeletedFile(t *testing.T) {
-	diff := `diff --git a/old.go b/old.go
-deleted file mode 100644
---- a/old.go
-+++ /dev/null
-@@ -1,3 +0,0 @@
--package main
--
--func old() {}
-`
-	pm := BuildPositionToLineMap(diff)
-
-	// Deleted file has no new-file lines; positions should error
-	_, err := pm.Translate("old.go", 2)
-	if err == nil {
-		t.Error("expected error for deleted file position")
-	}
-}
-
-func TestBuildPositionToLineMap_BinaryFile(t *testing.T) {
-	diff := `diff --git a/image.png b/image.png
-Binary files /dev/null and b/image.png differ
-diff --git a/code.go b/code.go
---- a/code.go
-+++ b/code.go
-@@ -1,2 +1,3 @@
- package main
-+// added
- func main() {}
-`
-	pm := BuildPositionToLineMap(diff)
-
-	// Binary file should not be in the map
-	_, err := pm.Translate("image.png", 1)
-	if err == nil {
-		t.Error("expected error for binary file")
-	}
-
-	// code.go should still work
-	got, err := pm.Translate("code.go", 3)
-	if err != nil {
-		t.Fatalf("Translate(code.go, 3): unexpected error: %v", err)
-	}
-	if got != 2 {
-		t.Errorf("Translate(code.go, 3) = %d, want 2", got)
-	}
-}
-
-func TestBuildPositionToLineMap_OutOfRange(t *testing.T) {
-	diff := `diff --git a/file.go b/file.go
---- a/file.go
-+++ b/file.go
-@@ -1,2 +1,2 @@
- line1
--old
-+new
-`
-	pm := BuildPositionToLineMap(diff)
-
-	// Position 0 is invalid
-	_, err := pm.Translate("file.go", 0)
-	if err == nil {
-		t.Error("expected error for position 0")
-	}
-
-	// Position 5 is out of range (only positions 1-4 exist)
-	_, err = pm.Translate("file.go", 5)
-	if err == nil {
-		t.Error("expected error for position 5 (out of range)")
-	}
-
-	// Unknown file
-	_, err = pm.Translate("unknown.go", 1)
-	if err == nil {
-		t.Error("expected error for unknown file")
-	}
-}
-
-func TestBuildPositionToLineMap_MultipleFiles(t *testing.T) {
-	diff := `diff --git a/a.go b/a.go
---- a/a.go
-+++ b/a.go
-@@ -1,2 +1,3 @@
- package a
-+// file a
- func aFunc() {}
-diff --git a/b.go b/b.go
---- a/b.go
-+++ b/b.go
-@@ -1,2 +1,3 @@
- package b
-+// file b
- func bFunc() {}
-`
-	pm := BuildPositionToLineMap(diff)
-
-	// a.go: pos 3 is "+// file a" -> new line 2
-	got, err := pm.Translate("a.go", 3)
-	if err != nil {
-		t.Fatalf("Translate(a.go, 3): %v", err)
-	}
-	if got != 2 {
-		t.Errorf("Translate(a.go, 3) = %d, want 2", got)
-	}
-
-	// b.go: pos 3 is "+// file b" -> new line 2
-	// Note: position resets per file
-	got, err = pm.Translate("b.go", 3)
-	if err != nil {
-		t.Fatalf("Translate(b.go, 3): %v", err)
-	}
-	if got != 2 {
-		t.Errorf("Translate(b.go, 3) = %d, want 2", got)
-	}
-}

github/client.go

@@ -1,17 +1,14 @@
 // Package github provides a client for the GitHub API.
-// It supports pull request operations, file content retrieval, CI status checks,
+// It supports pull request operations, file content retrieval,
-// and directory listing for both github.com and GitHub Enterprise.
+// and review submission for both github.com and GitHub Enterprise.
 package github
 
 import (
-	"bytes"
 	"context"
-	"encoding/json"
 	"errors"
 	"fmt"
 	"io"
 	"net/http"
-	"net/url"
 	"strconv"
 	"strings"
 	"time"
@@ -19,21 +16,28 @@ import (
 
 const (
 	defaultBaseURL = "https://api.github.com"
-	userAgent      = "review-bot/1.0"
-
-	// maxResponseBytes limits successful response body reads to 10 MiB.
-	maxResponseBytes = 10 * 1024 * 1024
 
 	// maxRetryAttempts is the number of times doRequest will attempt a request.
-	// The retry backoff slice must have length maxRetryAttempts-1.
 	maxRetryAttempts = 3
+
+	// maxRetryAfter caps the maximum delay from a Retry-After header to prevent
+	// a server from stalling the client indefinitely.
+	maxRetryAfter = 60 * time.Second
+
+	// maxErrorBodyBytes limits how much of an error response body we read
+	// to protect against malicious servers sending unbounded data.
+	maxErrorBodyBytes = 64 * 1024 // 64 KB
+
+	// maxResponseBodyBytes limits how much of a successful response body we read
+	// for defense-in-depth against servers returning excessively large payloads.
+	maxResponseBodyBytes = 10 * 1024 * 1024 // 10 MB
 )
 
 // APIError represents an HTTP error response from the GitHub API.
 // It carries the status code so callers can distinguish between
 // different failure modes (e.g. 404 vs 500).
 //
-// The Body field stores up to 4 KiB of the raw response for programmatic
+// The Body field stores up to 64 KiB of the raw response for programmatic
 // inspection. Error() truncates to 200 bytes for safe logging, but callers
 // should avoid logging or propagating Body directly in production since it may
 // contain sensitive details from the upstream server.
@@ -80,155 +84,101 @@ func asAPIError(err error) (*APIError, bool) {
 	return nil, false
 }
 
-// clientConfig holds optional configuration for NewClient.
-type clientConfig struct {
-	allowInsecureHTTP bool
-}
-
-// ClientOption configures optional behavior of NewClient.
-type ClientOption func(*clientConfig)
-
-// AllowInsecureHTTP permits the client to use HTTP (non-TLS) base URLs.
-// This should only be used for trusted internal deployments or testing.
-func AllowInsecureHTTP() ClientOption {
-	return func(c *clientConfig) {
-		c.allowInsecureHTTP = true
-	}
-}
-
 // Client interacts with the GitHub API.
 // A Client is safe for concurrent use by multiple goroutines.
 // SetHTTPClient and SetRetryBackoff are intended for test setup only and must
 // be called before any goroutines issue requests; they have no synchronization.
 type Client struct {
+	// TODO: baseURL is populated by NewClient but not yet consumed by doRequest/doGet.
+	// Higher-level exported methods (GetPullRequest, etc.) will use it to
+	// construct request URLs; remove this field if those methods end up
+	// accepting full URLs instead.
 	baseURL string
 	token   string
-	allowInsecureHTTP bool
 	httpClient *http.Client
 
 	// retryBackoff defines the delays between retry attempts for 429 responses.
 	// retryBackoff[i] is the delay before attempt i+1 (after attempt i fails).
-	// If nil, defaults to {1s, 2s}. Set to shorter durations in tests via SetRetryBackoff.
+	// If nil, defaults to {1s, 2s}.
 	retryBackoff []time.Duration
-}
 
-// defaultCheckRedirect is the redirect policy used by NewClient and SetHTTPClient(nil).
+	// now returns the current time. Defaults to time.Now.
-// It rejects HTTPS→HTTP protocol downgrades (to prevent plaintext leakage) and strips
+	// Override in tests to control HTTP-date Retry-After calculations.
-// the Authorization header on cross-host redirects to prevent credential leakage to
+	now func() time.Time
-// third-party hosts (e.g. CDN redirects from GitHub).
-func defaultCheckRedirect(req *http.Request, via []*http.Request) error {
-	if len(via) >= 10 {
-		return fmt.Errorf("stopped after 10 redirects")
-	}
-	// Guard: net/http guarantees len(via) >= 1 but this is undocumented;
-	// defend against zero-length to avoid panic on index out of range.
-	if len(via) == 0 {
-		return nil
-	}
-	prev := via[len(via)-1]
-	// Reject protocol downgrade: HTTPS→HTTP leaks request metadata over plaintext.
-	if prev.URL.Scheme == "https" && req.URL.Scheme == "http" {
-		return fmt.Errorf("refusing redirect from HTTPS to HTTP (%s → %s)", prev.URL.Host, req.URL.Host)
-	}
-	// Strip Authorization on cross-host redirect to avoid leaking credentials
-	// to third-party hosts (GitHub legitimately redirects to CDN hosts).
-	if req.URL.Host != prev.URL.Host {
-		req.Header.Del("Authorization")
-	}
-	return nil
 }
 
 // NewClient creates a new GitHub API client.
 // If baseURL is empty, it defaults to https://api.github.com.
 // For GitHub Enterprise, pass the API base URL (e.g. https://github.concur.com/api/v3).
-// The baseURL must use HTTPS; pass AllowInsecureHTTP() as an option to permit HTTP
+func NewClient(token, baseURL string) *Client {
-// for trusted internal deployments (e.g. local testing).
-func NewClient(token, baseURL string, opts ...ClientOption) *Client {
 	if baseURL == "" {
 		baseURL = defaultBaseURL
 	}
-	cfg := clientConfig{}
-	for _, o := range opts {
-		o(&cfg)
-	}
 	return &Client{
 		baseURL: strings.TrimRight(baseURL, "/"),
-		allowInsecureHTTP: cfg.allowInsecureHTTP,
 		token:   token,
-		httpClient: &http.Client{
+		httpClient: &http.Client{Timeout: 30 * time.Second},
-			Timeout:       30 * time.Second,
+		now:     time.Now,
-			CheckRedirect: defaultCheckRedirect,
-		},
 	}
 }
 
 // SetHTTPClient sets the underlying HTTP client used for requests.
-// This is intended for test setup only to inject mock transports; it must be
+// This is intended for testing to inject mock transports.
-// called before any goroutines issue requests.
-//
-// Passing nil restores the default client (30s timeout + auth-stripping
-// CheckRedirect policy matching NewClient).
-//
-// Callers providing a non-nil client are responsible for configuring a safe
-// CheckRedirect policy. Without one, the default net/http behavior will follow
-// redirects and may forward the Authorization header to untrusted hosts.
 func (c *Client) SetHTTPClient(hc *http.Client) {
-	if hc == nil {
-		hc = &http.Client{
-			Timeout:       30 * time.Second,
-			CheckRedirect: defaultCheckRedirect,
-		}
-	}
 	c.httpClient = hc
 }
 
-// SetRetryBackoff configures the retry backoff durations for testing.
+// SetRetryBackoff sets the delays between retry attempts.
-// It must be called before any goroutines issue requests.
+// This is intended for testing to speed up retry tests.
-// The slice must have exactly maxRetryAttempts-1 entries (one delay per retry gap).
+//
-// In production the default {1s, 2s} applies.
+// Note: if an empty non-nil slice is provided, Retry-After delays parsed from
-func (c *Client) SetRetryBackoff(d []time.Duration) error {
+// server responses will be computed and capped but not applied (because
-	if len(d) != maxRetryAttempts-1 {
+// attempt < len(backoff) is always false). This is acceptable for the
-		return fmt.Errorf("github: backoff length %d does not match maxRetryAttempts-1 (%d)", len(d), maxRetryAttempts-1)
+// test-only use case but callers should be aware of this edge case.
-	}
+func (c *Client) SetRetryBackoff(backoff []time.Duration) {
-	c.retryBackoff = d
+	c.retryBackoff = backoff
-	return nil
 }
 
-// doWithRetry performs an HTTP request with retry on 429 rate limit responses.
+// parseRetryAfter parses a Retry-After header value, supporting both integer
-// It delegates request construction to buildReq, which is called on each attempt
+// seconds (e.g. "120") and HTTP-date format (e.g. "Thu, 01 Dec 2025 16:00:00 GMT")
-// to produce a fresh *http.Request (allowing body re-reads for POST/PUT).
+// as specified in RFC 7231 §7.1.3.
-// It respects the Retry-After header when present (capped at maxRetryAfter).
+//
-// Transport errors (network failures, context cancellation) are not retried.
+// For integer values, it returns the duration directly.
-func (c *Client) doWithRetry(ctx context.Context, reqURL string, buildReq func() (*http.Request, error)) ([]byte, error) {
+// For HTTP-date values, it computes the delay as the difference between the
-	const maxRetryAfter = 120 * time.Second
+// parsed time and now. If the date is in the past, it returns 0.
+//
+// Returns (0, false) if the value cannot be parsed as either format.
+func (c *Client) parseRetryAfter(value string) (time.Duration, bool) {
+	value = strings.TrimSpace(value)
 
-	// maxErrorBodyBytes limits how much of an error response body is stored.
+	// Try integer seconds first (most common from GitHub).
-	// Kept small (4 KiB) to reduce the risk of sensitive data leakage if callers
+	// RFC 7231 allows delta-seconds of 0 to indicate immediate retry.
-	// log APIError.Body directly. Error() further truncates to 200 bytes.
+	if seconds, err := strconv.Atoi(value); err == nil && seconds >= 0 {
-	const maxErrorBodyBytes = 4 * 1024
+		return time.Duration(seconds) * time.Second, true
+	}
 
-	// backoff holds per-attempt delays: backoff[i] is the delay before attempt i+1.
+	// Try HTTP-date format (RFC 7231 §7.1.3).
-	// Length must be maxRetryAttempts-1 (one entry per retry gap).
+	// http.ParseTime handles RFC 1123, RFC 850, and ASCTIME formats.
-	// SetRetryBackoff validates at configuration time; the default is always valid.
+	if retryAt, err := http.ParseTime(value); err == nil {
-	defaultBackoff := []time.Duration{1 * time.Second, 2 * time.Second}
+		delay := retryAt.Sub(c.now())
+		if delay < 0 {
+			delay = 0
+		}
+		return delay, true
+	}
+
+	return 0, false
+}
+
+// doRequest performs an HTTP request with retry on 429 rate limit responses.
+// It respects the Retry-After header when present, supporting both integer
+// seconds and HTTP-date formats (capped at maxRetryAfter).
+func (c *Client) doRequest(ctx context.Context, method, reqURL string, accept string) ([]byte, error) {
 	var backoff []time.Duration
-	if c.retryBackoff != nil && len(c.retryBackoff) == maxRetryAttempts-1 {
+	if c.retryBackoff != nil {
-		backoff = make([]time.Duration, len(c.retryBackoff))
+		backoff = append([]time.Duration(nil), c.retryBackoff...)
-		copy(backoff, c.retryBackoff)
 	} else {
-		backoff = make([]time.Duration, len(defaultBackoff))
+		backoff = []time.Duration{1 * time.Second, 2 * time.Second}
-		copy(backoff, defaultBackoff)
-	}
-
-	// Reject non-HTTPS URLs early since the URL is immutable across retries.
-	if c.token != "" && !c.allowInsecureHTTP {
-		parsed, err := url.Parse(reqURL)
-		if err != nil {
-			return nil, fmt.Errorf("parse request URL: %w", err)
-		}
-		if !strings.EqualFold(parsed.Scheme, "https") {
-			return nil, fmt.Errorf("refusing to send credentials over non-HTTPS URL %q (use AllowInsecureHTTP option for trusted networks)", reqURL)
-		}
 	}
 
 	var lastErr error
@@ -242,7 +192,7 @@ func (c *Client) doWithRetry(ctx context.Context, reqURL string, buildReq func()
 				timer := time.NewTimer(delay)
 				select {
 				case <-timer.C:
-					timer.Stop() // no-op after fire; kept for symmetry with the ctx.Done case
+					timer.Stop()
 				case <-ctx.Done():
 					timer.Stop()
 					return nil, ctx.Err()
@@ -250,44 +200,42 @@ func (c *Client) doWithRetry(ctx context.Context, reqURL string, buildReq func()
 			}
 		}
 
-		req, err := buildReq()
+		req, err := http.NewRequestWithContext(ctx, method, reqURL, nil)
 		if err != nil {
 			return nil, fmt.Errorf("create request: %w", err)
 		}
+		req.Header.Set("Authorization", "Bearer "+c.token)
+		if accept != "" {
+			req.Header.Set("Accept", accept)
+		} else {
+			req.Header.Set("Accept", "application/vnd.github+json")
+		}
 
 		resp, err := c.httpClient.Do(req)
 		if err != nil {
 			return nil, fmt.Errorf("do request: %w", err)
 		}
 
-		// Capture response metadata before handleResponse takes body ownership.
+		if resp.StatusCode >= 200 && resp.StatusCode < 300 {
-		respStatus := resp.StatusCode
+			body, err := io.ReadAll(io.LimitReader(resp.Body, maxResponseBodyBytes))
-		retryAfterHeader := resp.Header.Get("Retry-After")
+			resp.Body.Close()
-
+			if err != nil {
-		body, done, handleErr := c.handleResponse(resp, maxResponseBytes, maxErrorBodyBytes)
+				return nil, fmt.Errorf("read response body: %w", err)
-		if done {
-			return body, handleErr
 			}
-		lastErr = handleErr
+			return body, nil
+		}
+
+		errBody, _ := io.ReadAll(io.LimitReader(resp.Body, maxErrorBodyBytes))
+		resp.Body.Close()
+
+		lastErr = &APIError{StatusCode: resp.StatusCode, Body: string(errBody)}
 
 		// Retry on 429 rate limit
-		if respStatus == http.StatusTooManyRequests && attempt < maxRetryAttempts-1 {
+		if resp.StatusCode == http.StatusTooManyRequests && attempt < maxRetryAttempts-1 {
 			// Check for Retry-After header and override backoff if present.
 			// Supports both integer seconds (common) and HTTP-date format (RFC 7231).
-			if ra := retryAfterHeader; ra != "" {
+			if ra := resp.Header.Get("Retry-After"); ra != "" {
-				if seconds, err := strconv.Atoi(ra); err == nil && seconds > 0 {
+				if delay, ok := c.parseRetryAfter(ra); ok {
-					delay := time.Duration(seconds) * time.Second
-					if delay > maxRetryAfter {
-						delay = maxRetryAfter
-					}
-					if attempt < len(backoff) {
-						backoff[attempt] = delay
-					}
-				} else if retryAt, err := http.ParseTime(ra); err == nil {
-					delay := time.Until(retryAt)
-					if delay < 0 {
-						delay = 0
-					}
 					if delay > maxRetryAfter {
 						delay = maxRetryAfter
 					}
@@ -306,83 +254,7 @@ func (c *Client) doWithRetry(ctx context.Context, reqURL string, buildReq func()
 	return nil, lastErr
 }
 
-// doRequest performs an HTTP request with retry on 429 rate limit responses.
-// It respects the Retry-After header when present (capped at maxRetryAfter).
-// Transport errors (network failures, context cancellation) are not retried.
-func (c *Client) doRequest(ctx context.Context, method, reqURL string, accept string) ([]byte, error) {
-	buildReq := func() (*http.Request, error) {
-		req, err := http.NewRequestWithContext(ctx, method, reqURL, nil)
-		if err != nil {
-			return nil, err
-		}
-		if c.token != "" {
-			// Bearer is the OAuth2 standard and is accepted by GitHub for both
-			// classic PATs and fine-grained tokens. The alternative "token" scheme
-			// is GitHub-specific and offers no additional compatibility.
-			req.Header.Set("Authorization", "Bearer "+c.token)
-		}
-		req.Header.Set("User-Agent", userAgent)
-		if accept != "" {
-			req.Header.Set("Accept", accept)
-		} else {
-			req.Header.Set("Accept", "application/vnd.github+json")
-		}
-		return req, nil
-	}
-	return c.doWithRetry(ctx, reqURL, buildReq)
-}
-
-// handleResponse reads and closes the response body, returning the result.
-// It uses defer to ensure the body is always closed regardless of code path.
-// Returns (body, done, err) where done=true means the caller should return immediately.
-func (c *Client) handleResponse(resp *http.Response, maxRespBytes int, maxErrBytes int) ([]byte, bool, error) {
-	defer resp.Body.Close()
-
-	if resp.StatusCode >= 200 && resp.StatusCode < 300 {
-		body, err := io.ReadAll(io.LimitReader(resp.Body, int64(maxRespBytes)+1))
-		if err != nil {
-			return nil, true, fmt.Errorf("read response body: %w", err)
-		}
-		if len(body) > maxRespBytes {
-			return nil, true, fmt.Errorf("response body exceeded %d bytes", maxRespBytes)
-		}
-		return body, true, nil
-	}
-
-	errBody, readErr := io.ReadAll(io.LimitReader(resp.Body, int64(maxErrBytes)))
-	if readErr != nil && len(errBody) == 0 {
-		errBody = []byte(fmt.Sprintf("[error reading response body: %v]", readErr))
-	}
-	return nil, false, &APIError{StatusCode: resp.StatusCode, Body: string(errBody)}
-}
-
 // doGet is a convenience wrapper for GET requests with the default Accept header.
-func (c *Client) doGet(ctx context.Context, reqURL string) ([]byte, error) {
+func (c *Client) doGet(ctx context.Context, url string) ([]byte, error) {
-	return c.doRequest(ctx, http.MethodGet, reqURL, "")
+	return c.doRequest(ctx, http.MethodGet, url, "")
-}
-
-// doJSONRequest performs an HTTP request with a JSON body and returns the response body.
-// It delegates retry/backoff/429 handling to doWithRetry.
-// This is a general-purpose helper used by any method that needs to send JSON payloads
-// (e.g. PostReview, DismissReview).
-func (c *Client) doJSONRequest(ctx context.Context, method, reqURL string, payload any) ([]byte, error) {
-	jsonBody, err := json.Marshal(payload)
-	if err != nil {
-		return nil, fmt.Errorf("marshal request body: %w", err)
-	}
-
-	buildReq := func() (*http.Request, error) {
-		req, err := http.NewRequestWithContext(ctx, method, reqURL, bytes.NewReader(jsonBody))
-		if err != nil {
-			return nil, err
-		}
-		if c.token != "" {
-			req.Header.Set("Authorization", "Bearer "+c.token)
-		}
-		req.Header.Set("User-Agent", userAgent)
-		req.Header.Set("Accept", "application/vnd.github+json")
-		req.Header.Set("Content-Type", "application/json")
-		return req, nil
-	}
-	return c.doWithRetry(ctx, reqURL, buildReq)
 }

github/client_test.go

@@ -5,647 +5,405 @@ import (
 	"errors"
 	"net/http"
 	"net/http/httptest"
-	"net/url"
-	"strings"
 	"testing"
 	"time"
 )
 
 func TestNewClient_DefaultBaseURL(t *testing.T) {
-	c := NewClient("test-token", "")
+	c := NewClient("tok", "")
-	if c.baseURL != "https://api.github.com" {
+	if c.baseURL != defaultBaseURL {
-		t.Errorf("expected default base URL, got %q", c.baseURL)
+		t.Errorf("baseURL = %q, want %q", c.baseURL, defaultBaseURL)
 	}
 }
 
 func TestNewClient_CustomBaseURL(t *testing.T) {
-	c := NewClient("test-token", "https://github.concur.com/api/v3")
+	c := NewClient("tok", "https://github.concur.com/api/v3/")
 	if c.baseURL != "https://github.concur.com/api/v3" {
-		t.Errorf("expected custom base URL, got %q", c.baseURL)
+		t.Errorf("baseURL = %q, want trailing slash stripped", c.baseURL)
 	}
 }
 
-func TestNewClient_TrimsTrailingSlash(t *testing.T) {
+func TestDoRequest_Success(t *testing.T) {
-	c := NewClient("test-token", "https://github.concur.com/api/v3/")
-	if c.baseURL != "https://github.concur.com/api/v3" {
-		t.Errorf("expected trailing slash trimmed, got %q", c.baseURL)
-	}
-}
-
-func TestDoRequest_SetsAuthHeader(t *testing.T) {
-	var gotAuth string
 	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		gotAuth = r.Header.Get("Authorization")
+		if got := r.Header.Get("Authorization"); got != "Bearer test-token" {
-		w.WriteHeader(200)
+			t.Errorf("Authorization = %q, want Bearer test-token", got)
-		w.Write([]byte("{}"))
-	}))
-	defer srv.Close()
-
-	c := NewClient("my-token", srv.URL, AllowInsecureHTTP())
-	c.SetHTTPClient(srv.Client())
-	_, _ = c.doGet(context.Background(), srv.URL+"/test")
-
-	if gotAuth != "Bearer my-token" {
-		t.Errorf("expected Bearer auth, got %q", gotAuth)
 		}
-}
+		w.WriteHeader(http.StatusOK)
-
-func TestDoRequest_SetsDefaultAcceptHeader(t *testing.T) {
-	var gotAccept string
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		gotAccept = r.Header.Get("Accept")
-		w.WriteHeader(200)
-		w.Write([]byte("{}"))
-	}))
-	defer srv.Close()
-
-	c := NewClient("token", srv.URL, AllowInsecureHTTP())
-	c.SetHTTPClient(srv.Client())
-	_, _ = c.doGet(context.Background(), srv.URL+"/test")
-
-	if gotAccept != "application/vnd.github+json" {
-		t.Errorf("expected default Accept header, got %q", gotAccept)
-	}
-}
-
-func TestDoRequest_429Retry(t *testing.T) {
-	attempts := 0
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		attempts++
-		if attempts == 1 {
-			w.WriteHeader(429)
-			w.Write([]byte(`{"message":"rate limit"}`))
-			return
-		}
-		w.WriteHeader(200)
 		w.Write([]byte(`{"ok":true}`))
 	}))
 	defer srv.Close()
 
-	c := NewClient("token", srv.URL, AllowInsecureHTTP())
+	c := NewClient("test-token", srv.URL)
-	c.SetHTTPClient(srv.Client())
-	if err := c.SetRetryBackoff([]time.Duration{10 * time.Millisecond, 10 * time.Millisecond}); err != nil {
-		t.Fatalf("SetRetryBackoff: %v", err)
-	}
-
 	body, err := c.doGet(context.Background(), srv.URL+"/test")
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
 	if string(body) != `{"ok":true}` {
-		t.Errorf("unexpected body: %s", body)
+		t.Errorf("body = %q, want %q", body, `{"ok":true}`)
+	}
+}
+
+func TestDoRequest_429_RetryAfter_IntegerSeconds(t *testing.T) {
+	attempts := 0
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		attempts++
+		if attempts == 1 {
+			w.Header().Set("Retry-After", "0")
+			w.WriteHeader(http.StatusTooManyRequests)
+			w.Write([]byte("rate limited"))
+			return
+		}
+		w.WriteHeader(http.StatusOK)
+		w.Write([]byte("success"))
+	}))
+	defer srv.Close()
+
+	c := NewClient("tok", srv.URL)
+	c.SetRetryBackoff([]time.Duration{0, 0})
+
+	body, err := c.doGet(context.Background(), srv.URL+"/test")
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if string(body) != "success" {
+		t.Errorf("body = %q, want %q", body, "success")
 	}
 	if attempts != 2 {
-		t.Errorf("expected 2 attempts, got %d", attempts)
+		t.Errorf("attempts = %d, want 2", attempts)
 	}
 }
 
-func TestDoRequest_429ExhaustsRetries(t *testing.T) {
+func TestDoRequest_429_RetryAfter_HTTPDate(t *testing.T) {
+	// Fix "now" to a known time for deterministic testing.
+	fixedNow := time.Date(2025, 12, 1, 15, 59, 59, 0, time.UTC)
+	retryAt := "Mon, 01 Dec 2025 16:00:00 GMT" // 1 second in the future
+
 	attempts := 0
 	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		attempts++
-		w.WriteHeader(429)
+		if attempts == 1 {
-		w.Write([]byte(`{"message":"rate limit"}`))
+			w.Header().Set("Retry-After", retryAt)
+			w.WriteHeader(http.StatusTooManyRequests)
+			w.Write([]byte("rate limited"))
+			return
+		}
+		w.WriteHeader(http.StatusOK)
+		w.Write([]byte("success"))
 	}))
 	defer srv.Close()
 
-	c := NewClient("token", srv.URL, AllowInsecureHTTP())
+	c := NewClient("tok", srv.URL)
-	c.SetHTTPClient(srv.Client())
+	c.now = func() time.Time { return fixedNow }
-	if err := c.SetRetryBackoff([]time.Duration{1 * time.Millisecond, 1 * time.Millisecond}); err != nil {
+	// Initial backoff is 0; the HTTP-date parser will compute 1s and override.
-		t.Fatalf("SetRetryBackoff: %v", err)
+	c.SetRetryBackoff([]time.Duration{0, 0})
-	}
 
-	_, err := c.doGet(context.Background(), srv.URL+"/test")
+	body, err := c.doGet(context.Background(), srv.URL+"/test")
-	if err == nil {
+	if err != nil {
-		t.Fatal("expected error after exhausting retries")
+		t.Fatalf("unexpected error: %v", err)
 	}
-	apiErr, ok := err.(*APIError)
+	if string(body) != "success" {
-	if !ok {
+		t.Errorf("body = %q, want %q", body, "success")
-		t.Fatalf("expected *APIError, got %T", err)
 	}
-	if apiErr.StatusCode != 429 {
+	if attempts != 2 {
-		t.Errorf("expected 429, got %d", apiErr.StatusCode)
+		t.Errorf("attempts = %d, want 2", attempts)
-	}
-	if attempts != 3 {
-		t.Errorf("expected 3 attempts, got %d", attempts)
 	}
 }
 
-func TestDoRequest_404NoRetry(t *testing.T) {
+func TestDoRequest_429_RetryAfter_HTTPDate_InPast(t *testing.T) {
+	// If the HTTP-date is in the past, delay should be 0 (retry immediately).
+	fixedNow := time.Date(2025, 12, 1, 17, 0, 0, 0, time.UTC)
+	retryAt := "Mon, 01 Dec 2025 16:00:00 GMT" // 1 hour in the past
+
 	attempts := 0
 	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		attempts++
-		w.WriteHeader(404)
+		if attempts == 1 {
-		w.Write([]byte(`{"message":"not found"}`))
+			w.Header().Set("Retry-After", retryAt)
+			w.WriteHeader(http.StatusTooManyRequests)
+			w.Write([]byte("rate limited"))
+			return
+		}
+		w.WriteHeader(http.StatusOK)
+		w.Write([]byte("success"))
 	}))
 	defer srv.Close()
 
-	c := NewClient("token", srv.URL, AllowInsecureHTTP())
+	c := NewClient("tok", srv.URL)
-	c.SetHTTPClient(srv.Client())
+	c.now = func() time.Time { return fixedNow }
+	c.SetRetryBackoff([]time.Duration{0, 0})
 
-	_, err := c.doGet(context.Background(), srv.URL+"/test")
+	body, err := c.doGet(context.Background(), srv.URL+"/test")
-	if err == nil {
+	if err != nil {
-		t.Fatal("expected error for 404")
+		t.Fatalf("unexpected error: %v", err)
 	}
-	if attempts != 1 {
+	if string(body) != "success" {
-		t.Errorf("expected 1 attempt (no retry on 404), got %d", attempts)
+		t.Errorf("body = %q, want %q", body, "success")
 	}
 }
 
-func TestDoRequest_401NoRetry(t *testing.T) {
+func TestDoRequest_429_NoRetryAfter_UsesDefaultBackoff(t *testing.T) {
 	attempts := 0
 	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		attempts++
-		w.WriteHeader(401)
+		if attempts == 1 {
-		w.Write([]byte(`{"message":"bad credentials"}`))
+			w.WriteHeader(http.StatusTooManyRequests)
+			w.Write([]byte("rate limited"))
+			return
+		}
+		w.WriteHeader(http.StatusOK)
+		w.Write([]byte("success"))
 	}))
 	defer srv.Close()
 
-	c := NewClient("token", srv.URL, AllowInsecureHTTP())
+	c := NewClient("tok", srv.URL)
-	c.SetHTTPClient(srv.Client())
+	c.SetRetryBackoff([]time.Duration{0, 0})
 
-	_, err := c.doGet(context.Background(), srv.URL+"/test")
+	body, err := c.doGet(context.Background(), srv.URL+"/test")
-	if err == nil {
+	if err != nil {
-		t.Fatal("expected error for 401")
+		t.Fatalf("unexpected error: %v", err)
 	}
-	if attempts != 1 {
+	if string(body) != "success" {
-		t.Errorf("expected 1 attempt (no retry on 401), got %d", attempts)
+		t.Errorf("body = %q, want %q", body, "success")
+	}
+	if attempts != 2 {
+		t.Errorf("attempts = %d, want 2", attempts)
 	}
 }
 
-func TestIsNotFound(t *testing.T) {
+func TestDoRequest_429_InvalidRetryAfter_UsesDefaultBackoff(t *testing.T) {
-	err := &APIError{StatusCode: 404, Body: "not found"}
+	attempts := 0
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		attempts++
+		if attempts == 1 {
+			w.Header().Set("Retry-After", "not-a-number-or-date")
+			w.WriteHeader(http.StatusTooManyRequests)
+			w.Write([]byte("rate limited"))
+			return
+		}
+		w.WriteHeader(http.StatusOK)
+		w.Write([]byte("success"))
+	}))
+	defer srv.Close()
+
+	c := NewClient("tok", srv.URL)
+	c.SetRetryBackoff([]time.Duration{0, 0})
+
+	body, err := c.doGet(context.Background(), srv.URL+"/test")
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if string(body) != "success" {
+		t.Errorf("body = %q, want %q", body, "success")
+	}
+}
+
+func TestDoRequest_404_NoRetry(t *testing.T) {
+	attempts := 0
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		attempts++
+		w.WriteHeader(http.StatusNotFound)
+		w.Write([]byte("not found"))
+	}))
+	defer srv.Close()
+
+	c := NewClient("tok", srv.URL)
+	_, err := c.doGet(context.Background(), srv.URL+"/test")
+	if err == nil {
+		t.Fatal("expected error, got nil")
+	}
 	if !IsNotFound(err) {
-		t.Error("expected IsNotFound to return true for 404")
+		t.Errorf("expected IsNotFound, got %v", err)
 	}
-	err2 := &APIError{StatusCode: 500, Body: "server error"}
+	if attempts != 1 {
-	if IsNotFound(err2) {
+		t.Errorf("attempts = %d, want 1 (no retry on 404)", attempts)
-		t.Error("expected IsNotFound to return false for 500")
 	}
 }
 
-func TestIsUnauthorized(t *testing.T) {
+func TestDoRequest_401_NoRetry(t *testing.T) {
-	err := &APIError{StatusCode: 401, Body: "bad credentials"}
+	attempts := 0
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		attempts++
+		w.WriteHeader(http.StatusUnauthorized)
+		w.Write([]byte("unauthorized"))
+	}))
+	defer srv.Close()
+
+	c := NewClient("tok", srv.URL)
+	_, err := c.doGet(context.Background(), srv.URL+"/test")
+	if err == nil {
+		t.Fatal("expected error, got nil")
+	}
 	if !IsUnauthorized(err) {
-		t.Error("expected IsUnauthorized to return true for 401")
+		t.Errorf("expected IsUnauthorized, got %v", err)
+	}
+	if attempts != 1 {
+		t.Errorf("attempts = %d, want 1 (no retry on 401)", attempts)
 	}
 }
 
-func TestAPIError_SanitizesNewlines(t *testing.T) {
+func TestDoRequest_ContextCanceled(t *testing.T) {
-	err := &APIError{StatusCode: 500, Body: "line1\ninjected\rmore"}
+	// This test exercises the timer-cancel path in the retry select:
-	msg := err.Error()
+	//   select { case <-timer.C; case <-ctx.Done() }
-	if strings.Contains(msg, "\n") || strings.Contains(msg, "\r") {
+	// The server returns 429 with a long Retry-After, and we cancel the
-		t.Errorf("expected newlines to be sanitized, got: %q", msg)
+	// context shortly after the first response so that cancellation races
-	}
+	// against the timer rather than preventing the initial HTTP round-trip.
-	if !strings.Contains(msg, "line1 injected more") {
+	requestReceived := make(chan struct{}, 1)
-		t.Errorf("expected sanitized body, got: %q", msg)
-	}
-}
-
-func TestDoRequest_429RetryAfterHeader(t *testing.T) {
-	if testing.Short() {
-		t.Skip("skipping slow retry test in short mode")
-	}
-	attempts := 0
 	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		attempts++
+		select {
-		if attempts == 1 {
+		case requestReceived <- struct{}{}:
-			w.Header().Set("Retry-After", "1")
+		default:
-			w.WriteHeader(429)
-			w.Write([]byte(`{"message":"rate limit"}`))
-			return
 		}
-		w.WriteHeader(200)
+		w.Header().Set("Retry-After", "10")
-		w.Write([]byte(`{"ok":true}`))
+		w.WriteHeader(http.StatusTooManyRequests)
 	}))
 	defer srv.Close()
 
-	c := NewClient("token", srv.URL, AllowInsecureHTTP())
+	c := NewClient("tok", srv.URL)
-	c.SetHTTPClient(srv.Client())
+	c.SetRetryBackoff([]time.Duration{10 * time.Second, 10 * time.Second})
-	// Use short backoff; Retry-After should override
-	if err := c.SetRetryBackoff([]time.Duration{1 * time.Millisecond, 1 * time.Millisecond}); err != nil {
-		t.Fatalf("SetRetryBackoff: %v", err)
-	}
 
-	start := time.Now()
+	ctx, cancel := context.WithCancel(context.Background())
-	body, err := c.doGet(context.Background(), srv.URL+"/test")
+	defer cancel()
-	elapsed := time.Since(start)
 
-	if err != nil {
+	// Cancel the context after the first request completes, while the
-		t.Fatalf("unexpected error: %v", err)
+	// client is blocked in the retry timer select.
-	}
+	go func() {
-	if string(body) != `{"ok":true}` {
+		<-requestReceived
-		t.Errorf("unexpected body: %s", body)
+		// Small delay to ensure we're inside the timer select.
-	}
+		time.Sleep(50 * time.Millisecond)
-	if attempts != 2 {
+		cancel()
-		t.Errorf("expected 2 attempts, got %d", attempts)
+	}()
-	}
-	// Retry-After: 1 means at least 1 second delay
-	if elapsed < 900*time.Millisecond {
-		t.Errorf("expected ~1s delay from Retry-After, got %v", elapsed)
-	}
-}
 
-func TestDoRequest_RetryAfterDoesNotMutateBackoff(t *testing.T) {
+	_, err := c.doGet(ctx, srv.URL+"/test")
-	if testing.Short() {
-		t.Skip("skipping slow retry test in short mode")
-	}
-	attempts := 0
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		attempts++
-		if attempts == 1 {
-			w.Header().Set("Retry-After", "1")
-			w.WriteHeader(429)
-			w.Write([]byte(`{"message":"rate limit"}`))
-			return
-		}
-		w.WriteHeader(200)
-		w.Write([]byte(`{"ok":true}`))
-	}))
-	defer srv.Close()
-
-	c := NewClient("token", srv.URL, AllowInsecureHTTP())
-	c.SetHTTPClient(srv.Client())
-	if err := c.SetRetryBackoff([]time.Duration{1 * time.Millisecond, 1 * time.Millisecond}); err != nil {
-		t.Fatalf("SetRetryBackoff: %v", err)
-	}
-
-	_, err := c.doGet(context.Background(), srv.URL+"/test")
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	// Verify the original retryBackoff slice was not mutated
-	if c.retryBackoff[0] != 1*time.Millisecond {
-		t.Errorf("retryBackoff[0] was mutated: got %v, want 1ms", c.retryBackoff[0])
-	}
-	if c.retryBackoff[1] != 1*time.Millisecond {
-		t.Errorf("retryBackoff[1] was mutated: got %v, want 1ms", c.retryBackoff[1])
-	}
-}
-
-func TestDoRequest_429RetryAfterHTTPDate(t *testing.T) {
-	if testing.Short() {
-		t.Skip("skipping slow Retry-After HTTP-date test in short mode")
-	}
-	attempts := 0
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		attempts++
-		if attempts == 1 {
-			// Use HTTP-date format (RFC 7231) — a time 2 seconds in the future.
-			future := time.Now().Add(2 * time.Second).UTC()
-			w.Header().Set("Retry-After", future.Format(http.TimeFormat))
-			w.WriteHeader(429)
-			w.Write([]byte(`{"message":"rate limit"}`))
-			return
-		}
-		w.WriteHeader(200)
-		w.Write([]byte(`{"ok":true}`))
-	}))
-	defer srv.Close()
-
-	c := NewClient("token", srv.URL, AllowInsecureHTTP())
-	c.SetHTTPClient(srv.Client())
-	if err := c.SetRetryBackoff([]time.Duration{1 * time.Millisecond, 1 * time.Millisecond}); err != nil {
-		t.Fatalf("SetRetryBackoff: %v", err)
-	}
-
-	start := time.Now()
-	body, err := c.doGet(context.Background(), srv.URL+"/test")
-	elapsed := time.Since(start)
-
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if string(body) != `{"ok":true}` {
-		t.Errorf("unexpected body: %s", body)
-	}
-	if attempts != 2 {
-		t.Errorf("expected 2 attempts, got %d", attempts)
-	}
-	// HTTP-date was ~2s in the future; by the time client processes it,
-	// time.Until gives ~1-2s. Verify it's meaningfully delayed (not instant).
-	if elapsed < 500*time.Millisecond {
-		t.Errorf("expected meaningful delay from HTTP-date Retry-After, got %v", elapsed)
-	}
-}
-
-func TestDoRequest_429RetryAfterHTTPDateInPast(t *testing.T) {
-	attempts := 0
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		attempts++
-		if attempts == 1 {
-			// Use a time in the past — should result in zero/immediate retry.
-			past := time.Now().Add(-10 * time.Second).UTC()
-			w.Header().Set("Retry-After", past.Format(http.TimeFormat))
-			w.WriteHeader(429)
-			w.Write([]byte(`{"message":"rate limit"}`))
-			return
-		}
-		w.WriteHeader(200)
-		w.Write([]byte(`{"ok":true}`))
-	}))
-	defer srv.Close()
-
-	c := NewClient("token", srv.URL, AllowInsecureHTTP())
-	c.SetHTTPClient(srv.Client())
-	if err := c.SetRetryBackoff([]time.Duration{5 * time.Second, 5 * time.Second}); err != nil {
-		t.Fatalf("SetRetryBackoff: %v", err)
-	}
-
-	start := time.Now()
-	_, err := c.doGet(context.Background(), srv.URL+"/test")
-	elapsed := time.Since(start)
-
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if attempts != 2 {
-		t.Errorf("expected 2 attempts, got %d", attempts)
-	}
-	// Past date should override the 5s backoff to ~0
-	if elapsed > 500*time.Millisecond {
-		t.Errorf("expected near-instant retry for past HTTP-date, got %v", elapsed)
-	}
-}
-
-func TestDoRequest_SetsUserAgentHeader(t *testing.T) {
-	var gotUA string
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		gotUA = r.Header.Get("User-Agent")
-		w.WriteHeader(200)
-		w.Write([]byte("{}"))
-	}))
-	defer srv.Close()
-
-	c := NewClient("token", srv.URL, AllowInsecureHTTP())
-	c.SetHTTPClient(srv.Client())
-	_, _ = c.doGet(context.Background(), srv.URL+"/test")
-
-	if gotUA != "review-bot/1.0" {
-		t.Errorf("expected User-Agent 'review-bot/1.0', got %q", gotUA)
-	}
-}
-
-func TestDoRequest_LimitsResponseBody(t *testing.T) {
-	// Verify that oversized responses return an error rather than silently truncating.
-	bigBody := strings.Repeat("x", maxResponseBytes+1024)
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.WriteHeader(200)
-		w.Write([]byte(bigBody))
-	}))
-	defer srv.Close()
-
-	c := NewClient("token", srv.URL, AllowInsecureHTTP())
-	c.SetHTTPClient(srv.Client())
-	_, err := c.doGet(context.Background(), srv.URL+"/test")
 	if err == nil {
-		t.Fatal("expected error for oversized response body")
+		t.Fatal("expected error, got nil")
 	}
-	if !strings.Contains(err.Error(), "exceeded") {
+	if !errors.Is(err, context.Canceled) {
-		t.Errorf("expected truncation error, got: %v", err)
+		t.Errorf("err = %v, want context.Canceled", err)
 	}
 }
 
-func TestDoRequest_AcceptsExactlyAtLimit(t *testing.T) {
+func TestParseRetryAfter_IntegerSeconds(t *testing.T) {
-	// A response body exactly equal to maxResponseBytes should succeed (not error).
+	c := NewClient("tok", "")
-	exactBody := strings.Repeat("x", maxResponseBytes)
+	delay, ok := c.parseRetryAfter("42")
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+	if !ok {
-		w.WriteHeader(200)
+		t.Fatal("expected ok=true")
-		w.Write([]byte(exactBody))
-	}))
-	defer srv.Close()
-
-	c := NewClient("token", srv.URL, AllowInsecureHTTP())
-	c.SetHTTPClient(srv.Client())
-	body, err := c.doGet(context.Background(), srv.URL+"/test")
-	if err != nil {
-		t.Fatalf("unexpected error for exactly-at-limit body: %v", err)
 	}
-	if len(body) != maxResponseBytes {
+	if delay != 42*time.Second {
-		t.Errorf("expected body length %d, got %d", maxResponseBytes, len(body))
+		t.Errorf("delay = %v, want 42s", delay)
 	}
 }
 
-func TestDoRequest_SkipsAuthWhenTokenEmpty(t *testing.T) {
+func TestParseRetryAfter_ZeroSeconds(t *testing.T) {
-	var gotAuth string
+	c := NewClient("tok", "")
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+	delay, ok := c.parseRetryAfter("0")
-		gotAuth = r.Header.Get("Authorization")
+	if !ok {
-		w.WriteHeader(200)
+		t.Fatal("expected ok=true for zero seconds (RFC 7231 allows immediate retry)")
-		w.Write([]byte("{}"))
+	}
-	}))
+	if delay != 0 {
-	defer srv.Close()
+		t.Errorf("delay = %v, want 0", delay)
-
-	c := NewClient("", srv.URL, AllowInsecureHTTP()) // empty token
-	c.SetHTTPClient(srv.Client())
-	_, _ = c.doGet(context.Background(), srv.URL+"/test")
-
-	if gotAuth != "" {
-		t.Errorf("expected no Authorization header with empty token, got %q", gotAuth)
 	}
 }
 
-func TestNewClient_CheckRedirectStripsAuthOnCrossHost(t *testing.T) {
+func TestParseRetryAfter_NegativeSeconds(t *testing.T) {
-	// Verify the CheckRedirect function is configured
+	c := NewClient("tok", "")
-	c := NewClient("secret-token", "https://api.github.com")
+	_, ok := c.parseRetryAfter("-5")
-	if c.httpClient.CheckRedirect == nil {
+	if ok {
-		t.Fatal("expected CheckRedirect to be set")
+		t.Error("expected ok=false for negative seconds")
 	}
 }
 
-func TestDefaultCheckRedirect_RejectsHTTPSToHTTP(t *testing.T) {
+func TestParseRetryAfter_HTTPDate_Future(t *testing.T) {
-	prev := &http.Request{URL: &url.URL{Scheme: "https", Host: "api.github.com", Path: "/foo"}}
+	fixedNow := time.Date(2025, 12, 1, 15, 59, 50, 0, time.UTC)
-	req := &http.Request{
+	c := NewClient("tok", "")
-		URL:    &url.URL{Scheme: "http", Host: "api.github.com", Path: "/foo"},
+	c.now = func() time.Time { return fixedNow }
-		Header: http.Header{"Authorization": []string{"Bearer token"}},
+
+	delay, ok := c.parseRetryAfter("Mon, 01 Dec 2025 16:00:00 GMT")
+	if !ok {
+		t.Fatal("expected ok=true")
 	}
-	err := defaultCheckRedirect(req, []*http.Request{prev})
+	// Should be 10 seconds in the future.
-	if err == nil {
+	if delay != 10*time.Second {
-		t.Fatal("expected error on HTTPS→HTTP redirect")
+		t.Errorf("delay = %v, want 10s", delay)
-	}
-	if !strings.Contains(err.Error(), "refusing redirect from HTTPS to HTTP") {
-		t.Errorf("unexpected error message: %v", err)
 	}
 }
 
-func TestDefaultCheckRedirect_StripsAuthOnCrossHost(t *testing.T) {
+func TestParseRetryAfter_HTTPDate_Past(t *testing.T) {
-	prev := &http.Request{URL: &url.URL{Scheme: "https", Host: "api.github.com", Path: "/foo"}}
+	fixedNow := time.Date(2025, 12, 1, 17, 0, 0, 0, time.UTC)
-	req := &http.Request{
+	c := NewClient("tok", "")
-		URL:    &url.URL{Scheme: "https", Host: "objects.githubusercontent.com", Path: "/bar"},
+	c.now = func() time.Time { return fixedNow }
-		Header: http.Header{"Authorization": []string{"Bearer token"}},
+
+	delay, ok := c.parseRetryAfter("Mon, 01 Dec 2025 16:00:00 GMT")
+	if !ok {
+		t.Fatal("expected ok=true")
 	}
-	err := defaultCheckRedirect(req, []*http.Request{prev})
+	if delay != 0 {
-	if err != nil {
+		t.Errorf("delay = %v, want 0 (past date)", delay)
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if auth := req.Header.Get("Authorization"); auth != "" {
-		t.Errorf("expected Authorization header to be stripped, got %q", auth)
 	}
 }
 
-func TestDefaultCheckRedirect_PreservesAuthOnSameHost(t *testing.T) {
+func TestParseRetryAfter_RFC850_Format(t *testing.T) {
-	prev := &http.Request{URL: &url.URL{Scheme: "https", Host: "api.github.com", Path: "/foo"}}
+	fixedNow := time.Date(2025, 12, 1, 15, 59, 50, 0, time.UTC)
-	req := &http.Request{
+	c := NewClient("tok", "")
-		URL:    &url.URL{Scheme: "https", Host: "api.github.com", Path: "/bar"},
+	c.now = func() time.Time { return fixedNow }
-		Header: http.Header{"Authorization": []string{"Bearer token"}},
+
+	// RFC 850 format
+	delay, ok := c.parseRetryAfter("Monday, 01-Dec-25 16:00:00 GMT")
+	if !ok {
+		t.Fatal("expected ok=true for RFC 850 format")
 	}
-	err := defaultCheckRedirect(req, []*http.Request{prev})
+	if delay != 10*time.Second {
-	if err != nil {
+		t.Errorf("delay = %v, want 10s", delay)
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if auth := req.Header.Get("Authorization"); auth != "Bearer token" {
-		t.Errorf("expected Authorization to be preserved, got %q", auth)
 	}
 }
 
-func TestDoRequest_RejectsHTTPWithToken(t *testing.T) {
+func TestParseRetryAfter_Invalid(t *testing.T) {
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+	c := NewClient("tok", "")
-		w.WriteHeader(200)
+	_, ok := c.parseRetryAfter("not-valid")
-		w.Write([]byte("{}"))
+	if ok {
-	}))
+		t.Error("expected ok=false for invalid value")
-	defer srv.Close()
-
-	// Without AllowInsecureHTTP, should refuse to send token over HTTP
-	c := NewClient("secret-token", srv.URL)
-	c.SetHTTPClient(srv.Client())
-	_, err := c.doGet(context.Background(), srv.URL+"/test")
-	if err == nil {
-		t.Fatal("expected error when sending token over HTTP")
-	}
-	if !strings.Contains(err.Error(), "refusing to send credentials") {
-		t.Errorf("unexpected error message: %v", err)
 	}
 }
 
-func TestDoRequest_AllowsHTTPWithoutToken(t *testing.T) {
+func TestParseRetryAfter_EmptyString(t *testing.T) {
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+	c := NewClient("tok", "")
-		w.WriteHeader(200)
+	_, ok := c.parseRetryAfter("")
-		w.Write([]byte(`{"ok":true}`))
+	if ok {
-	}))
+		t.Error("expected ok=false for empty string")
-	defer srv.Close()
-
-	// Without token, HTTP should be fine (no credentials to leak)
-	c := NewClient("", srv.URL)
-	c.SetHTTPClient(srv.Client())
-	body, err := c.doGet(context.Background(), srv.URL+"/test")
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if string(body) != `{"ok":true}` {
-		t.Errorf("unexpected body: %s", body)
 	}
 }
 
-func TestDoRequest_AllowsHTTPWithInsecureOption(t *testing.T) {
+func TestParseRetryAfter_MaxCap(t *testing.T) {
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+	// Verify that parseRetryAfter returns the raw value (capping is done by caller).
-		w.WriteHeader(200)
+	c := NewClient("tok", "")
-		w.Write([]byte(`{"ok":true}`))
+	delay, ok := c.parseRetryAfter("3600")
-	}))
+	if !ok {
-	defer srv.Close()
+		t.Fatal("expected ok=true")
-
-	c := NewClient("secret-token", srv.URL, AllowInsecureHTTP())
-	c.SetHTTPClient(srv.Client())
-	body, err := c.doGet(context.Background(), srv.URL+"/test")
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
 	}
-	if string(body) != `{"ok":true}` {
+	if delay != 3600*time.Second {
-		t.Errorf("unexpected body: %s", body)
+		t.Errorf("delay = %v, want 3600s (caller is responsible for capping)", delay)
 	}
 }
 
-func TestSetHTTPClient_NilRestoresDefault(t *testing.T) {
+func TestAPIError_Error_Truncation(t *testing.T) {
-	c := NewClient("token", "https://api.github.com")
+	longBody := make([]byte, 300)
-	c.SetHTTPClient(nil)
+	for i := range longBody {
-	if c.httpClient == nil {
+		longBody[i] = 'x'
-		t.Fatal("expected non-nil httpClient after SetHTTPClient(nil)")
 	}
-	if c.httpClient.Timeout != 30*time.Second {
+	apiErr := &APIError{StatusCode: 500, Body: string(longBody)}
-		t.Errorf("expected 30s timeout, got %v", c.httpClient.Timeout)
+	msg := apiErr.Error()
-	}
+	if len(msg) > 250 {
-	if c.httpClient.CheckRedirect == nil {
+		// "HTTP 500: " (10) + 200 + "...(truncated)" (14) = 224
-		t.Fatal("expected CheckRedirect policy after SetHTTPClient(nil)")
+		t.Errorf("error message too long: %d chars", len(msg))
 	}
 }
 
-
+func TestAPIError_Error_NewlineSanitized(t *testing.T) {
-func TestSetRetryBackoff_RejectsInvalidLength(t *testing.T) {
+	apiErr := &APIError{StatusCode: 400, Body: "line1\nline2\rline3"}
-	c := NewClient("token", "https://api.github.com")
+	msg := apiErr.Error()
-
+	for _, c := range msg {
-	// Too short
+		if c == '\n' || c == '\r' {
-	err := c.SetRetryBackoff([]time.Duration{1 * time.Second})
+			t.Errorf("error message contains unsanitized newline: %q", msg)
-	if err == nil {
+			break
-		t.Fatal("expected error for backoff length 1")
 		}
-	if !strings.Contains(err.Error(), "backoff length 1") {
-		t.Errorf("unexpected error message: %v", err)
-	}
-
-	// Too long
-	err = c.SetRetryBackoff([]time.Duration{1 * time.Second, 2 * time.Second, 3 * time.Second})
-	if err == nil {
-		t.Fatal("expected error for backoff length 3")
-	}
-
-	// Correct length succeeds
-	err = c.SetRetryBackoff([]time.Duration{1 * time.Second, 2 * time.Second})
-	if err != nil {
-		t.Fatalf("unexpected error for valid backoff: %v", err)
-	}
-}
-
-func TestDoJSONRequest_429Retry(t *testing.T) {
-	attempts := 0
-	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		attempts++
-		if attempts < 3 {
-			w.WriteHeader(429)
-			w.Write([]byte(`{"message":"rate limit exceeded"}`))
-			return
-		}
-		w.WriteHeader(200)
-		w.Write([]byte(`{"id":1}`))
-	}))
-	defer ts.Close()
-
-	c := NewClient("token", ts.URL, AllowInsecureHTTP())
-	if err := c.SetRetryBackoff([]time.Duration{1 * time.Millisecond, 1 * time.Millisecond}); err != nil {
-		t.Fatalf("SetRetryBackoff: %v", err)
-	}
-
-	body, err := c.doJSONRequest(context.Background(), http.MethodPost, ts.URL+"/test", map[string]string{"key": "val"})
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if attempts != 3 {
-		t.Errorf("expected 3 attempts, got %d", attempts)
-	}
-	if string(body) != `{"id":1}` {
-		t.Errorf("unexpected body: %s", body)
-	}
-}
-
-func TestDoJSONRequest_429ExhaustsRetries(t *testing.T) {
-	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.WriteHeader(429)
-		w.Write([]byte(`{"message":"rate limit"}`))
-	}))
-	defer ts.Close()
-
-	c := NewClient("token", ts.URL, AllowInsecureHTTP())
-	if err := c.SetRetryBackoff([]time.Duration{1 * time.Millisecond, 1 * time.Millisecond}); err != nil {
-		t.Fatalf("SetRetryBackoff: %v", err)
-	}
-
-	_, err := c.doJSONRequest(context.Background(), http.MethodPost, ts.URL+"/test", map[string]string{"key": "val"})
-	if err == nil {
-		t.Fatal("expected error after exhausting retries")
-	}
-	var apiErr *APIError
-	if !errors.As(err, &apiErr) {
-		t.Fatalf("expected APIError, got %T: %v", err, err)
-	}
-	if apiErr.StatusCode != 429 {
-		t.Errorf("expected 429, got %d", apiErr.StatusCode)
 	}
 }

github/conformance_test.go

@@ -1,10 +0,0 @@
-package github_test
-
-import (
-	"gitea.weiker.me/rodin/review-bot/github"
-	"gitea.weiker.me/rodin/review-bot/vcs"
-)
-
-// Compile-time interface conformance assertions.
-// These verify github.Client satisfies vcs.Client (the full interface).
-var _ vcs.Client = (*github.Client)(nil)

github/files.go

@@ -1,160 +0,0 @@
-package github
-
-import (
-	"context"
-	"encoding/base64"
-	"encoding/json"
-	"fmt"
-	"net/url"
-	"path"
-	"strings"
-
-	"gitea.weiker.me/rodin/review-bot/vcs"
-)
-
-// GetFileContent fetches a file from a repo at the given ref.
-// Delegates to GetFileContentAtRef with the provided ref.
-func (c *Client) GetFileContent(ctx context.Context, owner, repo, filePath, ref string) (string, error) {
-	return c.GetFileContentAtRef(ctx, owner, repo, filePath, ref)
-}
-
-// GetFileContentAtRef fetches a file at a specific ref from a repo.
-// If ref is empty, the query parameter is omitted (uses default branch).
-//
-// Returns an error if the path contains dot-segments (".", "..") or
-// attempts to traverse above the repository root.
-func (c *Client) GetFileContentAtRef(ctx context.Context, owner, repo, filePath, ref string) (string, error) {
-	escaped, err := escapePath(filePath)
-	if err != nil {
-		return "", fmt.Errorf("invalid file path: %w", err)
-	}
-	reqURL := fmt.Sprintf("%s/repos/%s/%s/contents/%s",
-		c.baseURL, url.PathEscape(owner), url.PathEscape(repo), escaped)
-	if ref != "" {
-		reqURL += "?ref=" + url.QueryEscape(ref)
-	}
-	body, err := c.doGet(ctx, reqURL)
-	if err != nil {
-		return "", fmt.Errorf("fetch file %s: %w", filePath, err)
-	}
-	var resp struct {
-		Content  string `json:"content"`
-		Encoding string `json:"encoding"`
-	}
-	if err := json.Unmarshal(body, &resp); err != nil {
-		return "", fmt.Errorf("parse file content JSON: %w", err)
-	}
-	if resp.Encoding != "base64" {
-		return "", fmt.Errorf("unexpected encoding %q for file %s", resp.Encoding, filePath)
-	}
-	decoded, err := decodeBase64Content(resp.Content)
-	if err != nil {
-		return "", fmt.Errorf("decode base64 content for %s: %w", filePath, err)
-	}
-	return decoded, nil
-}
-
-// ListContents lists files and directories at a given path in a repo.
-// Returns the directory listing from the GitHub contents API.
-// If the path points to a single file (not a directory), the API returns
-// a JSON object instead of an array; this is handled by returning a
-// single-element slice.
-func (c *Client) ListContents(ctx context.Context, owner, repo, filePath string) ([]vcs.ContentEntry, error) {
-	escaped, err := escapePath(filePath)
-	if err != nil {
-		return nil, fmt.Errorf("invalid file path: %w", err)
-	}
-	reqURL := fmt.Sprintf("%s/repos/%s/%s/contents/%s",
-		c.baseURL, url.PathEscape(owner), url.PathEscape(repo), escaped)
-	body, err := c.doGet(ctx, reqURL)
-	if err != nil {
-		return nil, fmt.Errorf("list contents %s: %w", filePath, err)
-	}
-
-	type entry struct {
-		Name string `json:"name"`
-		Path string `json:"path"`
-		Type string `json:"type"`
-	}
-
-	// The GitHub contents API returns an array for directories and an object
-	// for single files. Try array first (common case), then fall back to object.
-	// An empty array ([]) is valid — it represents an empty directory — and
-	// results in a zero-length slice returned without error.
-	var entries []entry
-	if err := json.Unmarshal(body, &entries); err != nil {
-		var single entry
-		if err2 := json.Unmarshal(body, &single); err2 != nil {
-			return nil, fmt.Errorf("parse contents JSON: as array: %v; as object: %w", err, err2)
-		}
-		// Guard against empty objects ({}) or unexpected shapes that
-		// unmarshal successfully but carry no useful data.
-		if single.Name == "" && single.Path == "" && single.Type == "" {
-			return nil, fmt.Errorf("parse contents JSON: unexpected response format")
-		}
-		entries = []entry{single}
-	}
-
-	result := make([]vcs.ContentEntry, len(entries))
-	for i, e := range entries {
-		result[i] = vcs.ContentEntry{
-			Name: e.Name,
-			Path: e.Path,
-			Type: e.Type,
-		}
-	}
-	return result, nil
-}
-
-// escapePath validates and encodes a slash-separated file path for use in
-// GitHub API URLs. Returns an error if the path contains dot-segments ("."
-// or "..") or resolves to a path outside the repository root.
-func escapePath(p string) (string, error) {
-	// Reject paths containing dot-segments rather than silently rewriting them.
-	for _, seg := range strings.Split(p, "/") {
-		if seg == "." || seg == ".." {
-			return "", fmt.Errorf("path contains dot-segment %q: %s", seg, p)
-		}
-	}
-
-	// Use path.Clean for canonical form, then verify it doesn't escape root.
-	cleaned := path.Clean(p)
-	if cleaned == "." || strings.HasPrefix(cleaned, "..") {
-		return "", fmt.Errorf("path resolves outside repository root: %s", p)
-	}
-
-	// Encode each segment individually.
-	parts := strings.Split(cleaned, "/")
-	var encoded []string
-	for _, part := range parts {
-		if part == "" {
-			continue
-		}
-		encoded = append(encoded, url.PathEscape(part))
-	}
-	return strings.Join(encoded, "/"), nil
-}
-
-// maxFileContentSize is the maximum decoded file size (10 MB) to prevent
-// resource exhaustion when decoding base64 content from the API.
-const maxFileContentSize = 10 * 1024 * 1024
-
-// decodeBase64Content decodes base64-encoded content from the GitHub contents API.
-// GitHub returns base64 content with line breaks for formatting; we strip \r and \n before decoding.
-// Returns an error if the decoded content exceeds maxFileContentSize.
-func decodeBase64Content(encoded string) (string, error) {
-	cleaned := strings.NewReplacer("\n", "", "\r", "").Replace(encoded)
-	// Check estimated decoded size before allocating.
-	// Base64 encodes 3 bytes into 4 chars, so decoded ~ len*3/4.
-	if len(cleaned)*3/4 > maxFileContentSize {
-		return "", fmt.Errorf("file content too large: estimated %d bytes exceeds limit of %d", len(cleaned)*3/4, maxFileContentSize)
-	}
-	decoded, err := base64.StdEncoding.DecodeString(cleaned)
-	if err != nil {
-		return "", err
-	}
-	if len(decoded) > maxFileContentSize {
-		return "", fmt.Errorf("file content too large: %d bytes exceeds limit of %d", len(decoded), maxFileContentSize)
-	}
-	return string(decoded), nil
-}

github/files_test.go

@@ -1,405 +0,0 @@
-package github
-
-import (
-	"context"
-	"encoding/json"
-	"net/http"
-	"net/http/httptest"
-	"strings"
-	"testing"
-	"time"
-)
-
-func TestGetFileContent_DelegatesToGetFileContentAtRef(t *testing.T) {
-	var gotRef string
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		gotRef = r.URL.Query().Get("ref")
-		json.NewEncoder(w).Encode(map[string]string{
-			"content":  "dGVzdA==", // "test" in base64
-			"encoding": "base64",
-		})
-	}))
-	defer srv.Close()
-
-	c := NewClient("token", srv.URL, AllowInsecureHTTP())
-	c.SetHTTPClient(srv.Client())
-
-	// Call with empty ref — should not include ref param
-	content, err := c.GetFileContent(context.Background(), "owner", "repo", "file.go", "")
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if content != "test" {
-		t.Errorf("expected 'test', got %q", content)
-	}
-	if gotRef != "" {
-		t.Errorf("expected empty ref, got %q", gotRef)
-	}
-}
-
-func TestGetFileContent_WithRef(t *testing.T) {
-	var gotRef string
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		gotRef = r.URL.Query().Get("ref")
-		json.NewEncoder(w).Encode(map[string]string{
-			"content":  "dGVzdA==",
-			"encoding": "base64",
-		})
-	}))
-	defer srv.Close()
-
-	c := NewClient("token", srv.URL, AllowInsecureHTTP())
-	c.SetHTTPClient(srv.Client())
-
-	_, err := c.GetFileContent(context.Background(), "owner", "repo", "file.go", "abc123")
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if gotRef != "abc123" {
-		t.Errorf("expected ref 'abc123', got %q", gotRef)
-	}
-}
-
-func TestGetFileContent_404(t *testing.T) {
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.WriteHeader(404)
-		w.Write([]byte(`{"message":"Not Found"}`))
-	}))
-	defer srv.Close()
-
-	c := NewClient("token", srv.URL, AllowInsecureHTTP())
-	c.SetHTTPClient(srv.Client())
-
-	_, err := c.GetFileContent(context.Background(), "owner", "repo", "missing.go", "")
-	if err == nil {
-		t.Fatal("expected error for 404")
-	}
-}
-
-func TestGetFileContent_401(t *testing.T) {
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.WriteHeader(401)
-		w.Write([]byte(`{"message":"Bad credentials"}`))
-	}))
-	defer srv.Close()
-
-	c := NewClient("token", srv.URL, AllowInsecureHTTP())
-	c.SetHTTPClient(srv.Client())
-
-	_, err := c.GetFileContent(context.Background(), "owner", "repo", "file.go", "")
-	if err == nil {
-		t.Fatal("expected error for 401")
-	}
-}
-
-func TestGetFileContent_429Retry(t *testing.T) {
-	attempts := 0
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		attempts++
-		if attempts == 1 {
-			w.WriteHeader(429)
-			w.Write([]byte(`{"message":"rate limit"}`))
-			return
-		}
-		json.NewEncoder(w).Encode(map[string]string{
-			"content":  "b2s=",
-			"encoding": "base64",
-		})
-	}))
-	defer srv.Close()
-
-	c := NewClient("token", srv.URL, AllowInsecureHTTP())
-	c.SetHTTPClient(srv.Client())
-	if err := c.SetRetryBackoff([]time.Duration{1 * time.Millisecond, 1 * time.Millisecond}); err != nil {
-		t.Fatalf("SetRetryBackoff: %v", err)
-	}
-
-	content, err := c.GetFileContent(context.Background(), "owner", "repo", "file.go", "")
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if content != "ok" {
-		t.Errorf("expected 'ok', got %q", content)
-	}
-	if attempts != 2 {
-		t.Errorf("expected 2 attempts, got %d", attempts)
-	}
-}
-
-func TestGetFileContent_MalformedJSON(t *testing.T) {
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.WriteHeader(200)
-		w.Write([]byte(`not json`))
-	}))
-	defer srv.Close()
-
-	c := NewClient("token", srv.URL, AllowInsecureHTTP())
-	c.SetHTTPClient(srv.Client())
-
-	_, err := c.GetFileContent(context.Background(), "owner", "repo", "file.go", "")
-	if err == nil {
-		t.Fatal("expected error for malformed JSON")
-	}
-}
-
-func TestListContents_HappyPath(t *testing.T) {
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if r.URL.Path != "/repos/owner/repo/contents/src" {
-			t.Errorf("unexpected path: %s", r.URL.Path)
-		}
-		json.NewEncoder(w).Encode([]map[string]string{
-			{"name": "main.go", "path": "src/main.go", "type": "file"},
-			{"name": "lib", "path": "src/lib", "type": "dir"},
-		})
-	}))
-	defer srv.Close()
-
-	c := NewClient("token", srv.URL, AllowInsecureHTTP())
-	c.SetHTTPClient(srv.Client())
-
-	entries, err := c.ListContents(context.Background(), "owner", "repo", "src")
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if len(entries) != 2 {
-		t.Fatalf("expected 2 entries, got %d", len(entries))
-	}
-	if entries[0].Name != "main.go" {
-		t.Errorf("expected name 'main.go', got %q", entries[0].Name)
-	}
-	if entries[0].Path != "src/main.go" {
-		t.Errorf("expected path 'src/main.go', got %q", entries[0].Path)
-	}
-	if entries[0].Type != "file" {
-		t.Errorf("expected type 'file', got %q", entries[0].Type)
-	}
-	if entries[1].Name != "lib" {
-		t.Errorf("expected name 'lib', got %q", entries[1].Name)
-	}
-	if entries[1].Type != "dir" {
-		t.Errorf("expected type 'dir', got %q", entries[1].Type)
-	}
-}
-
-func TestListContents_404(t *testing.T) {
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.WriteHeader(404)
-		w.Write([]byte(`{"message":"Not Found"}`))
-	}))
-	defer srv.Close()
-
-	c := NewClient("token", srv.URL, AllowInsecureHTTP())
-	c.SetHTTPClient(srv.Client())
-
-	_, err := c.ListContents(context.Background(), "owner", "repo", "missing")
-	if err == nil {
-		t.Fatal("expected error for 404")
-	}
-}
-
-func TestListContents_401(t *testing.T) {
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.WriteHeader(401)
-		w.Write([]byte(`{"message":"Bad credentials"}`))
-	}))
-	defer srv.Close()
-
-	c := NewClient("token", srv.URL, AllowInsecureHTTP())
-	c.SetHTTPClient(srv.Client())
-
-	_, err := c.ListContents(context.Background(), "owner", "repo", "src")
-	if err == nil {
-		t.Fatal("expected error for 401")
-	}
-}
-
-func TestListContents_429Retry(t *testing.T) {
-	attempts := 0
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		attempts++
-		if attempts == 1 {
-			w.WriteHeader(429)
-			w.Write([]byte(`{"message":"rate limit"}`))
-			return
-		}
-		json.NewEncoder(w).Encode([]map[string]string{
-			{"name": "file.go", "path": "file.go", "type": "file"},
-		})
-	}))
-	defer srv.Close()
-
-	c := NewClient("token", srv.URL, AllowInsecureHTTP())
-	c.SetHTTPClient(srv.Client())
-	if err := c.SetRetryBackoff([]time.Duration{1 * time.Millisecond, 1 * time.Millisecond}); err != nil {
-		t.Fatalf("SetRetryBackoff: %v", err)
-	}
-
-	entries, err := c.ListContents(context.Background(), "owner", "repo", "src")
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if len(entries) != 1 {
-		t.Fatalf("expected 1 entry, got %d", len(entries))
-	}
-	if attempts != 2 {
-		t.Errorf("expected 2 attempts, got %d", attempts)
-	}
-}
-
-func TestListContents_MalformedJSON(t *testing.T) {
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.WriteHeader(200)
-		w.Write([]byte(`not json`))
-	}))
-	defer srv.Close()
-
-	c := NewClient("token", srv.URL, AllowInsecureHTTP())
-	c.SetHTTPClient(srv.Client())
-
-	_, err := c.ListContents(context.Background(), "owner", "repo", "src")
-	if err == nil {
-		t.Fatal("expected error for malformed JSON")
-	}
-}
-
-func TestListContents_SingleFile(t *testing.T) {
-	// GitHub Contents API returns a JSON object (not array) for single-file paths
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.WriteHeader(200)
-		w.Write([]byte(`{"name":"README.md","path":"README.md","type":"file"}`))
-	}))
-	defer srv.Close()
-
-	c := NewClient("token", srv.URL, AllowInsecureHTTP())
-	c.SetHTTPClient(srv.Client())
-	entries, err := c.ListContents(context.Background(), "owner", "repo", "README.md")
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if len(entries) != 1 {
-		t.Fatalf("expected 1 entry, got %d", len(entries))
-	}
-	if entries[0].Name != "README.md" {
-		t.Errorf("expected name 'README.md', got %q", entries[0].Name)
-	}
-	if entries[0].Type != "file" {
-		t.Errorf("expected type 'file', got %q", entries[0].Type)
-	}
-}
-
-func TestEscapePath_ValidPaths(t *testing.T) {
-	t.Parallel()
-	tests := []struct {
-		name string
-		path string
-		want string
-	}{
-		{"simple file", "file.go", "file.go"},
-		{"nested path", "path/to/file.go", "path/to/file.go"},
-		{"special chars", "path/to/my file.go", "path/to/my%20file.go"},
-		{"leading slash stripped", "/path/to/file.go", "path/to/file.go"},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			t.Parallel()
-			got, err := escapePath(tt.path)
-			if err != nil {
-				t.Fatalf("unexpected error: %v", err)
-			}
-			if got != tt.want {
-				t.Errorf("escapePath(%q) = %q, want %q", tt.path, got, tt.want)
-			}
-		})
-	}
-}
-
-func TestEscapePath_DotSegments(t *testing.T) {
-	t.Parallel()
-	tests := []struct {
-		name string
-		path string
-	}{
-		{"single dot", "./file.go"},
-		{"double dot", "../file.go"},
-		{"dot in middle", "path/./file.go"},
-		{"parent traversal", "path/../file.go"},
-		{"only dots", ".."},
-		{"nested parent traversal", "a/b/../../c"},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			t.Parallel()
-			_, err := escapePath(tt.path)
-			if err == nil {
-				t.Fatalf("expected error for path %q, got nil", tt.path)
-			}
-			if !strings.Contains(err.Error(), "dot-segment") {
-				t.Errorf("expected error about dot-segment, got: %v", err)
-			}
-		})
-	}
-}
-
-func TestGetFileContentAtRef_DotSegmentError(t *testing.T) {
-	// Server should never be called — the error is caught before the request.
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		t.Fatal("server should not have been called")
-	}))
-	defer srv.Close()
-
-	c := NewClient("token", srv.URL, AllowInsecureHTTP())
-	_, err := c.GetFileContentAtRef(context.Background(), "owner", "repo", "foo/../bar.go", "main")
-	if err == nil {
-		t.Fatal("expected error for path with dot-segments")
-	}
-	if !strings.Contains(err.Error(), "invalid file path") {
-		t.Errorf("expected 'invalid file path' error, got: %v", err)
-	}
-}
-
-func TestDecodeBase64Content(t *testing.T) {
-	// Test with newlines (GitHub's format)
-	encoded := "cGFja2FnZSBt\nYWlu"
-	decoded, err := decodeBase64Content(encoded)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if decoded != "package main" {
-		t.Errorf("expected 'package main', got %q", decoded)
-	}
-}
-
-func TestDecodeBase64Content_Invalid(t *testing.T) {
-	_, err := decodeBase64Content("not!!!valid!!!base64")
-	if err == nil {
-		t.Fatal("expected error for invalid base64")
-	}
-}
-
-func TestDecodeBase64Content_CRLF(t *testing.T) {
-	// Base64 of "hello world" with CRLF line breaks inserted
-	encoded := "aGVs\r\nbG8g\r\nd29y\r\nbGQ="
-	decoded, err := decodeBase64Content(encoded)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if decoded != "hello world" {
-		t.Errorf("expected 'hello world', got %q", decoded)
-	}
-}
-
-func TestDecodeBase64Content_SizeLimit(t *testing.T) {
-	t.Parallel()
-	// Create base64 content that would decode to > maxFileContentSize.
-	// maxFileContentSize is 10MB. Base64 of 11MB worth of zeros.
-	// We just need something big enough to trigger the estimated size check.
-	// 14MB of base64 chars (decodes to ~10.5MB).
-	huge := strings.Repeat("A", 14*1024*1024)
-	_, err := decodeBase64Content(huge)
-	if err == nil {
-		t.Fatal("expected error for oversized content")
-	}
-	if !strings.Contains(err.Error(), "too large") {
-		t.Errorf("expected 'too large' error, got: %v", err)
-	}
-}

github/pr.go

@@ -1,222 +0,0 @@
-package github
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"net/http"
-	"net/url"
-
-	"gitea.weiker.me/rodin/review-bot/vcs"
-)
-
-// pullRequestResponse is the GitHub API response for a pull request.
-type pullRequestResponse struct {
-	Number int    `json:"number"`
-	Title  string `json:"title"`
-	Body   string `json:"body"`
-	Head   struct {
-		SHA string `json:"sha"`
-		Ref string `json:"ref"`
-	} `json:"head"`
-	Base struct {
-		Ref string `json:"ref"`
-	} `json:"base"`
-}
-
-// changedFileResponse is the GitHub API response for a changed file in a PR.
-type changedFileResponse struct {
-	Filename string `json:"filename"`
-	Status   string `json:"status"`
-	Patch    string `json:"patch"`
-}
-
-// commitStatusResponse is the GitHub combined status API response.
-type commitStatusResponse struct {
-	Statuses []struct {
-		Context     string `json:"context"`
-		State       string `json:"state"`
-		Description string `json:"description"`
-		TargetURL   string `json:"target_url"`
-	} `json:"statuses"`
-}
-
-// checkRunsResponse is the GitHub check runs API response.
-type checkRunsResponse struct {
-	CheckRuns []struct {
-		Name       string  `json:"name"`
-		Conclusion *string `json:"conclusion"`
-		Status     string  `json:"status"`
-		HTMLURL    string  `json:"html_url"`
-	} `json:"check_runs"`
-}
-
-// GetPullRequest fetches PR metadata from the GitHub API.
-// Returns an *APIError wrapping the HTTP status on non-2xx responses (e.g.
-// IsNotFound for 404, IsUnauthorized for 401). Network and context errors
-// are wrapped but not typed as *APIError.
-func (c *Client) GetPullRequest(ctx context.Context, owner, repo string, number int) (*vcs.PullRequest, error) {
-	reqURL := fmt.Sprintf("%s/repos/%s/%s/pulls/%d", c.baseURL, url.PathEscape(owner), url.PathEscape(repo), number)
-	body, err := c.doGet(ctx, reqURL)
-	if err != nil {
-		return nil, fmt.Errorf("fetch PR: %w", err)
-	}
-	var resp pullRequestResponse
-	if err := json.Unmarshal(body, &resp); err != nil {
-		return nil, fmt.Errorf("parse PR JSON: %w", err)
-	}
-	return &vcs.PullRequest{
-		Number: resp.Number,
-		Title:  resp.Title,
-		Body:   resp.Body,
-		Head:   vcs.HeadRef{SHA: resp.Head.SHA, Ref: resp.Head.Ref},
-		Base:   vcs.BaseRef{Ref: resp.Base.Ref},
-	}, nil
-}
-
-// GetPullRequestDiff fetches the unified diff for a PR.
-// Uses Accept: application/vnd.github.diff to get raw diff text.
-func (c *Client) GetPullRequestDiff(ctx context.Context, owner, repo string, number int) (string, error) {
-	reqURL := fmt.Sprintf("%s/repos/%s/%s/pulls/%d", c.baseURL, url.PathEscape(owner), url.PathEscape(repo), number)
-	body, err := c.doRequest(ctx, http.MethodGet, reqURL, "application/vnd.github.diff")
-	if err != nil {
-		return "", fmt.Errorf("fetch diff: %w", err)
-	}
-	return string(body), nil
-}
-
-const (
-	// maxFilesPages is the upper bound on pagination loops for PR file listing,
-	// preventing unbounded iteration if the server always returns a full page.
-	maxFilesPages = 100
-
-	// maxCheckRunPages is the upper bound on pagination loops for check-run listing,
-	// preventing unbounded iteration if the server always returns a full page.
-	maxCheckRunPages = 100
-)
-
-// GetPullRequestFiles fetches the list of files changed in a PR.
-// Paginates through all pages (100 per page) to collect all files.
-// Returns nil (not an empty slice) when the PR has no changed files.
-// Callers can safely range over or check len() on a nil slice.
-func (c *Client) GetPullRequestFiles(ctx context.Context, owner, repo string, number int) ([]vcs.ChangedFile, error) {
-	var allFiles []vcs.ChangedFile
-
-	for page := 1; page <= maxFilesPages; page++ {
-		reqURL := fmt.Sprintf("%s/repos/%s/%s/pulls/%d/files?per_page=100&page=%d",
-			c.baseURL, url.PathEscape(owner), url.PathEscape(repo), number, page)
-		body, err := c.doGet(ctx, reqURL)
-		if err != nil {
-			return nil, fmt.Errorf("fetch PR files page %d: %w", page, err)
-		}
-		var files []changedFileResponse
-		if err := json.Unmarshal(body, &files); err != nil {
-			return nil, fmt.Errorf("parse PR files JSON: %w", err)
-		}
-		if len(files) == 0 {
-			break
-		}
-		for _, f := range files {
-			allFiles = append(allFiles, vcs.ChangedFile{
-				Filename: f.Filename,
-				Status:   f.Status,
-				Patch:    f.Patch,
-			})
-		}
-		if len(files) < 100 {
-			break
-		}
-	}
-
-	return allFiles, nil
-}
-
-// GetCommitStatuses fetches both commit statuses and check runs for a SHA,
-// merging them into a unified []vcs.CommitStatus slice.
-// Returns nil (not an empty slice) when there are no statuses or check runs.
-// If the commit statuses endpoint fails (e.g. 404 for an unknown SHA), the
-// function returns immediately without attempting the check-runs endpoint.
-// If the check-runs endpoint fails after statuses were fetched successfully,
-// the function returns an error (not a partial result) so callers always get
-// either a complete view or a clear error signal.
-func (c *Client) GetCommitStatuses(ctx context.Context, owner, repo, sha string) ([]vcs.CommitStatus, error) {
-	var result []vcs.CommitStatus
-
-	// Fetch commit statuses
-	statusURL := fmt.Sprintf("%s/repos/%s/%s/commits/%s/status",
-		c.baseURL, url.PathEscape(owner), url.PathEscape(repo), url.PathEscape(sha))
-	statusBody, err := c.doGet(ctx, statusURL)
-	if err != nil {
-		return nil, fmt.Errorf("fetch commit statuses: %w", err)
-	}
-	var statusResp commitStatusResponse
-	if err := json.Unmarshal(statusBody, &statusResp); err != nil {
-		return nil, fmt.Errorf("parse commit statuses JSON: %w", err)
-	}
-	for _, s := range statusResp.Statuses {
-		result = append(result, vcs.CommitStatus{
-			Context:     s.Context,
-			Status:      s.State,
-			Description: s.Description,
-			TargetURL:   s.TargetURL,
-		})
-	}
-
-	// Fetch check runs (paginated)
-	for checkPage := 1; checkPage <= maxCheckRunPages; checkPage++ {
-		checkURL := fmt.Sprintf("%s/repos/%s/%s/commits/%s/check-runs?per_page=100&page=%d",
-			c.baseURL, url.PathEscape(owner), url.PathEscape(repo), url.PathEscape(sha), checkPage)
-		checkBody, err := c.doGet(ctx, checkURL)
-		if err != nil {
-			return nil, fmt.Errorf("fetch check runs page %d: %w", checkPage, err)
-		}
-		var checkResp checkRunsResponse
-		if err := json.Unmarshal(checkBody, &checkResp); err != nil {
-			return nil, fmt.Errorf("parse check runs JSON: %w", err)
-		}
-		for _, cr := range checkResp.CheckRuns {
-			result = append(result, vcs.CommitStatus{
-				Context:     cr.Name,
-				Status:      mapCheckRunStatus(cr.Conclusion),
-				Description: "", // check runs have no human-readable description; conclusion is captured in Status
-				TargetURL:   cr.HTMLURL,
-			})
-		}
-		if len(checkResp.CheckRuns) < 100 {
-			break
-		}
-	}
-
-	return result, nil
-}
-
-// mapCheckRunStatus maps a GitHub check run conclusion to a vcs.CommitStatus status string.
-// Conclusion alone determines the mapped state: nil conclusion means the run is
-// still in progress (pending), regardless of the status field value.
-//
-// Mapping rules:
-//   - nil → "pending" (run still in progress or queued)
-//   - "success" → "success"
-//   - "failure", "action_required", "timed_out" → "failure"
-//   - "cancelled", "skipped", "neutral" → "success" (non-blocking per GitHub check suite semantics)
-//   - "stale" → "pending" (check run became stale before completing)
-//   - unknown values → "pending" (conservative: treat unrecognized conclusions as incomplete)
-func mapCheckRunStatus(conclusion *string) string {
-	if conclusion == nil {
-		// Still running or queued
-		return "pending"
-	}
-	switch *conclusion {
-	case "success":
-		return "success"
-	case "failure", "action_required", "timed_out":
-		return "failure"
-	case "cancelled", "skipped", "neutral":
-		return "success" // non-blocking: these do not indicate a blocking failure per GitHub check suite semantics
-	case "stale":
-		return "pending"
-	default:
-		return "pending"
-	}
-}
-

github/pr_test.go

@@ -1,676 +0,0 @@
-package github
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"net/http"
-	"net/http/httptest"
-	"strings"
-	"testing"
-	"time"
-)
-
-func TestGetPullRequest_HappyPath(t *testing.T) {
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if r.URL.Path != "/repos/owner/repo/pulls/42" {
-			t.Errorf("unexpected path: %s", r.URL.Path)
-		}
-		json.NewEncoder(w).Encode(map[string]interface{}{
-			"number": 42,
-			"title":  "Test PR",
-			"body":   "Description",
-			"head":   map[string]string{"sha": "abc123", "ref": "feature-branch"},
-			"base":   map[string]string{"ref": "main"},
-		})
-	}))
-	defer srv.Close()
-
-	c := NewClient("token", srv.URL, AllowInsecureHTTP())
-	c.SetHTTPClient(srv.Client())
-
-	pr, err := c.GetPullRequest(context.Background(), "owner", "repo", 42)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if pr.Number != 42 {
-		t.Errorf("expected number 42, got %d", pr.Number)
-	}
-	if pr.Title != "Test PR" {
-		t.Errorf("expected title 'Test PR', got %q", pr.Title)
-	}
-	if pr.Body != "Description" {
-		t.Errorf("expected body 'Description', got %q", pr.Body)
-	}
-	if pr.Head.SHA != "abc123" {
-		t.Errorf("expected head SHA 'abc123', got %q", pr.Head.SHA)
-	}
-	if pr.Head.Ref != "feature-branch" {
-		t.Errorf("expected head ref 'feature-branch', got %q", pr.Head.Ref)
-	}
-	if pr.Base.Ref != "main" {
-		t.Errorf("expected base ref 'main', got %q", pr.Base.Ref)
-	}
-}
-
-func TestGetPullRequest_404(t *testing.T) {
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.WriteHeader(404)
-		w.Write([]byte(`{"message":"Not Found"}`))
-	}))
-	defer srv.Close()
-
-	c := NewClient("token", srv.URL, AllowInsecureHTTP())
-	c.SetHTTPClient(srv.Client())
-
-	_, err := c.GetPullRequest(context.Background(), "owner", "repo", 999)
-	if err == nil {
-		t.Fatal("expected error for 404")
-	}
-	if !IsNotFound(err) {
-		t.Errorf("expected IsNotFound=true, got error: %v", err)
-	}
-}
-
-func TestGetPullRequest_401(t *testing.T) {
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.WriteHeader(401)
-		w.Write([]byte(`{"message":"Bad credentials"}`))
-	}))
-	defer srv.Close()
-
-	c := NewClient("token", srv.URL, AllowInsecureHTTP())
-	c.SetHTTPClient(srv.Client())
-
-	_, err := c.GetPullRequest(context.Background(), "owner", "repo", 1)
-	if err == nil {
-		t.Fatal("expected error for 401")
-	}
-	if !IsUnauthorized(err) {
-		t.Errorf("expected IsUnauthorized=true, got error: %v", err)
-	}
-}
-
-func TestGetPullRequest_429Retry(t *testing.T) {
-	attempts := 0
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		attempts++
-		if attempts == 1 {
-			w.WriteHeader(429)
-			w.Write([]byte(`{"message":"rate limit"}`))
-			return
-		}
-		json.NewEncoder(w).Encode(map[string]interface{}{
-			"number": 1,
-			"title":  "PR",
-			"body":   "",
-			"head":   map[string]string{"sha": "abc", "ref": "br"},
-			"base":   map[string]string{"ref": "main"},
-		})
-	}))
-	defer srv.Close()
-
-	c := NewClient("token", srv.URL, AllowInsecureHTTP())
-	c.SetHTTPClient(srv.Client())
-	c.SetRetryBackoff([]time.Duration{1 * time.Millisecond})
-
-	pr, err := c.GetPullRequest(context.Background(), "owner", "repo", 1)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if pr.Number != 1 {
-		t.Errorf("expected number 1, got %d", pr.Number)
-	}
-	if attempts != 2 {
-		t.Errorf("expected 2 attempts, got %d", attempts)
-	}
-}
-
-func TestGetPullRequest_MalformedJSON(t *testing.T) {
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.WriteHeader(200)
-		w.Write([]byte(`{invalid json`))
-	}))
-	defer srv.Close()
-
-	c := NewClient("token", srv.URL, AllowInsecureHTTP())
-	c.SetHTTPClient(srv.Client())
-
-	_, err := c.GetPullRequest(context.Background(), "owner", "repo", 1)
-	if err == nil {
-		t.Fatal("expected error for malformed JSON")
-	}
-	if !strings.Contains(err.Error(), "parse PR JSON") {
-		t.Errorf("expected parse error, got: %v", err)
-	}
-}
-
-func TestGetPullRequestDiff_HappyPath(t *testing.T) {
-	expectedDiff := "diff --git a/file.go b/file.go\n--- a/file.go\n+++ b/file.go\n@@ -1,3 +1,4 @@\n+// new line\n"
-	var gotAccept string
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		gotAccept = r.Header.Get("Accept")
-		w.WriteHeader(200)
-		w.Write([]byte(expectedDiff))
-	}))
-	defer srv.Close()
-
-	c := NewClient("token", srv.URL, AllowInsecureHTTP())
-	c.SetHTTPClient(srv.Client())
-
-	diff, err := c.GetPullRequestDiff(context.Background(), "owner", "repo", 42)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if diff != expectedDiff {
-		t.Errorf("unexpected diff: %q", diff)
-	}
-	if gotAccept != "application/vnd.github.diff" {
-		t.Errorf("expected diff Accept header, got %q", gotAccept)
-	}
-}
-
-func TestGetPullRequestDiff_404(t *testing.T) {
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.WriteHeader(404)
-		w.Write([]byte(`{"message":"Not Found"}`))
-	}))
-	defer srv.Close()
-
-	c := NewClient("token", srv.URL, AllowInsecureHTTP())
-	c.SetHTTPClient(srv.Client())
-
-	_, err := c.GetPullRequestDiff(context.Background(), "owner", "repo", 999)
-	if err == nil {
-		t.Fatal("expected error for 404")
-	}
-}
-
-func TestGetPullRequestDiff_401(t *testing.T) {
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.WriteHeader(401)
-		w.Write([]byte(`{"message":"Bad credentials"}`))
-	}))
-	defer srv.Close()
-
-	c := NewClient("token", srv.URL, AllowInsecureHTTP())
-	c.SetHTTPClient(srv.Client())
-
-	_, err := c.GetPullRequestDiff(context.Background(), "owner", "repo", 1)
-	if err == nil {
-		t.Fatal("expected error for 401")
-	}
-}
-
-func TestGetPullRequestFiles_HappyPath(t *testing.T) {
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		json.NewEncoder(w).Encode([]map[string]interface{}{
-			{"filename": "main.go", "status": "modified", "patch": "@@ -1,3 +1,4 @@\n+line"},
-			{"filename": "test.go", "status": "added", "patch": "@@ -0,0 +1,5 @@\n+new file"},
-		})
-	}))
-	defer srv.Close()
-
-	c := NewClient("token", srv.URL, AllowInsecureHTTP())
-	c.SetHTTPClient(srv.Client())
-
-	files, err := c.GetPullRequestFiles(context.Background(), "owner", "repo", 1)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if len(files) != 2 {
-		t.Fatalf("expected 2 files, got %d", len(files))
-	}
-	if files[0].Filename != "main.go" {
-		t.Errorf("expected filename 'main.go', got %q", files[0].Filename)
-	}
-	if files[0].Status != "modified" {
-		t.Errorf("expected status 'modified', got %q", files[0].Status)
-	}
-	if files[0].Patch != "@@ -1,3 +1,4 @@\n+line" {
-		t.Errorf("unexpected patch: %q", files[0].Patch)
-	}
-}
-
-func TestGetPullRequestFiles_Pagination(t *testing.T) {
-	// Simulate > 100 files requiring pagination
-	page1Files := make([]map[string]string, 100)
-	for i := 0; i < 100; i++ {
-		page1Files[i] = map[string]string{
-			"filename": fmt.Sprintf("file%d.go", i),
-			"status":   "modified",
-			"patch":    fmt.Sprintf("patch%d", i),
-		}
-	}
-	page2Files := []map[string]string{
-		{"filename": "file100.go", "status": "added", "patch": "patch100"},
-	}
-
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		page := r.URL.Query().Get("page")
-		if page == "" || page == "1" {
-			json.NewEncoder(w).Encode(page1Files)
-		} else {
-			json.NewEncoder(w).Encode(page2Files)
-		}
-	}))
-	defer srv.Close()
-
-	c := NewClient("token", srv.URL, AllowInsecureHTTP())
-	c.SetHTTPClient(srv.Client())
-
-	files, err := c.GetPullRequestFiles(context.Background(), "owner", "repo", 1)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if len(files) != 101 {
-		t.Errorf("expected 101 files (paginated), got %d", len(files))
-	}
-	if files[100].Filename != "file100.go" {
-		t.Errorf("expected last file 'file100.go', got %q", files[100].Filename)
-	}
-	if files[100].Patch != "patch100" {
-		t.Errorf("expected last patch 'patch100', got %q", files[100].Patch)
-	}
-}
-
-func TestGetPullRequestFiles_BinaryFile_NoPatch(t *testing.T) {
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		// Binary files have no patch field in GitHub response
-		json.NewEncoder(w).Encode([]map[string]interface{}{
-			{"filename": "image.png", "status": "added"},
-		})
-	}))
-	defer srv.Close()
-
-	c := NewClient("token", srv.URL, AllowInsecureHTTP())
-	c.SetHTTPClient(srv.Client())
-
-	files, err := c.GetPullRequestFiles(context.Background(), "owner", "repo", 1)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if len(files) != 1 {
-		t.Fatalf("expected 1 file, got %d", len(files))
-	}
-	if files[0].Patch != "" {
-		t.Errorf("expected empty patch for binary file, got %q", files[0].Patch)
-	}
-}
-
-func TestGetPullRequestFiles_404(t *testing.T) {
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.WriteHeader(404)
-		w.Write([]byte(`{"message":"Not Found"}`))
-	}))
-	defer srv.Close()
-
-	c := NewClient("token", srv.URL, AllowInsecureHTTP())
-	c.SetHTTPClient(srv.Client())
-
-	_, err := c.GetPullRequestFiles(context.Background(), "owner", "repo", 999)
-	if err == nil {
-		t.Fatal("expected error for 404")
-	}
-}
-
-func TestGetPullRequestFiles_MalformedJSON(t *testing.T) {
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.WriteHeader(200)
-		w.Write([]byte(`not json`))
-	}))
-	defer srv.Close()
-
-	c := NewClient("token", srv.URL, AllowInsecureHTTP())
-	c.SetHTTPClient(srv.Client())
-
-	_, err := c.GetPullRequestFiles(context.Background(), "owner", "repo", 1)
-	if err == nil {
-		t.Fatal("expected error for malformed JSON")
-	}
-}
-
-func TestGetFileContentAtRef_HappyPath(t *testing.T) {
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if r.URL.Path != "/repos/owner/repo/contents/path/to/file.go" {
-			t.Errorf("unexpected path: %s", r.URL.Path)
-		}
-		if r.URL.Query().Get("ref") != "abc123" {
-			t.Errorf("unexpected ref: %s", r.URL.Query().Get("ref"))
-		}
-		json.NewEncoder(w).Encode(map[string]string{
-			"content":  "cGFja2FnZSBtYWlu", // "package main" in base64
-			"encoding": "base64",
-		})
-	}))
-	defer srv.Close()
-
-	c := NewClient("token", srv.URL, AllowInsecureHTTP())
-	c.SetHTTPClient(srv.Client())
-
-	content, err := c.GetFileContentAtRef(context.Background(), "owner", "repo", "path/to/file.go", "abc123")
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if content != "package main" {
-		t.Errorf("expected 'package main', got %q", content)
-	}
-}
-
-func TestGetFileContentAtRef_EmptyRef(t *testing.T) {
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if r.URL.Query().Get("ref") != "" {
-			t.Errorf("expected no ref param, got %q", r.URL.Query().Get("ref"))
-		}
-		json.NewEncoder(w).Encode(map[string]string{
-			"content":  "aGVsbG8=", // "hello" in base64
-			"encoding": "base64",
-		})
-	}))
-	defer srv.Close()
-
-	c := NewClient("token", srv.URL, AllowInsecureHTTP())
-	c.SetHTTPClient(srv.Client())
-
-	content, err := c.GetFileContentAtRef(context.Background(), "owner", "repo", "file.txt", "")
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if content != "hello" {
-		t.Errorf("expected 'hello', got %q", content)
-	}
-}
-
-func TestGetFileContentAtRef_404(t *testing.T) {
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.WriteHeader(404)
-		w.Write([]byte(`{"message":"Not Found"}`))
-	}))
-	defer srv.Close()
-
-	c := NewClient("token", srv.URL, AllowInsecureHTTP())
-	c.SetHTTPClient(srv.Client())
-
-	_, err := c.GetFileContentAtRef(context.Background(), "owner", "repo", "missing.go", "main")
-	if err == nil {
-		t.Fatal("expected error for 404")
-	}
-}
-
-func TestGetFileContentAtRef_401(t *testing.T) {
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.WriteHeader(401)
-		w.Write([]byte(`{"message":"Bad credentials"}`))
-	}))
-	defer srv.Close()
-
-	c := NewClient("token", srv.URL, AllowInsecureHTTP())
-	c.SetHTTPClient(srv.Client())
-
-	_, err := c.GetFileContentAtRef(context.Background(), "owner", "repo", "file.go", "main")
-	if err == nil {
-		t.Fatal("expected error for 401")
-	}
-}
-
-func TestGetFileContentAtRef_MalformedJSON(t *testing.T) {
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.WriteHeader(200)
-		w.Write([]byte(`not valid json`))
-	}))
-	defer srv.Close()
-
-	c := NewClient("token", srv.URL, AllowInsecureHTTP())
-	c.SetHTTPClient(srv.Client())
-
-	_, err := c.GetFileContentAtRef(context.Background(), "owner", "repo", "file.go", "main")
-	if err == nil {
-		t.Fatal("expected error for malformed JSON")
-	}
-}
-
-func TestGetFileContentAtRef_429Retry(t *testing.T) {
-	attempts := 0
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		attempts++
-		if attempts == 1 {
-			w.WriteHeader(429)
-			w.Write([]byte(`{"message":"rate limit"}`))
-			return
-		}
-		json.NewEncoder(w).Encode(map[string]string{
-			"content":  "b2s=", // "ok" in base64
-			"encoding": "base64",
-		})
-	}))
-	defer srv.Close()
-
-	c := NewClient("token", srv.URL, AllowInsecureHTTP())
-	c.SetHTTPClient(srv.Client())
-	c.SetRetryBackoff([]time.Duration{1 * time.Millisecond})
-
-	content, err := c.GetFileContentAtRef(context.Background(), "owner", "repo", "file.go", "main")
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if content != "ok" {
-		t.Errorf("expected 'ok', got %q", content)
-	}
-	if attempts != 2 {
-		t.Errorf("expected 2 attempts, got %d", attempts)
-	}
-}
-
-func TestGetCommitStatuses_HappyPath(t *testing.T) {
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch {
-		case strings.Contains(r.URL.Path, "/status"):
-			json.NewEncoder(w).Encode(map[string]interface{}{
-				"state": "success",
-				"statuses": []map[string]string{
-					{
-						"context":     "ci/build",
-						"state":       "success",
-						"description": "Build passed",
-						"target_url":  "https://ci.example.com/1",
-					},
-				},
-			})
-		case strings.Contains(r.URL.Path, "/check-runs"):
-			conclusion := "success"
-			json.NewEncoder(w).Encode(map[string]interface{}{
-				"total_count": 1,
-				"check_runs": []map[string]interface{}{
-					{
-						"name":       "lint",
-						"conclusion": &conclusion,
-						"status":     "completed",
-						"html_url":   "https://github.com/check/1",
-					},
-				},
-			})
-		default:
-			t.Errorf("unexpected path: %s", r.URL.Path)
-			w.WriteHeader(404)
-		}
-	}))
-	defer srv.Close()
-
-	c := NewClient("token", srv.URL, AllowInsecureHTTP())
-	c.SetHTTPClient(srv.Client())
-
-	statuses, err := c.GetCommitStatuses(context.Background(), "owner", "repo", "abc123")
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if len(statuses) != 2 {
-		t.Fatalf("expected 2 statuses, got %d", len(statuses))
-	}
-	// First should be from commit statuses
-	if statuses[0].Context != "ci/build" {
-		t.Errorf("expected context 'ci/build', got %q", statuses[0].Context)
-	}
-	if statuses[0].Status != "success" {
-		t.Errorf("expected status 'success', got %q", statuses[0].Status)
-	}
-	// Second should be from check runs
-	if statuses[1].Context != "lint" {
-		t.Errorf("expected context 'lint', got %q", statuses[1].Context)
-	}
-	if statuses[1].Status != "success" {
-		t.Errorf("expected status 'success', got %q", statuses[1].Status)
-	}
-}
-
-func TestGetCommitStatuses_CheckRunConclusions(t *testing.T) {
-	tests := []struct {
-		conclusion *string
-		status     string
-		want       string
-	}{
-		{stringPtr("success"), "completed", "success"},
-		{stringPtr("failure"), "completed", "failure"},
-		{stringPtr("action_required"), "completed", "failure"},
-		{stringPtr("timed_out"), "completed", "failure"},
-		{stringPtr("cancelled"), "completed", "success"},
-		{stringPtr("skipped"), "completed", "success"},
-		{stringPtr("neutral"), "completed", "success"},
-		{nil, "in_progress", "pending"},
-		{nil, "queued", "pending"},
-	}
-
-	for _, tt := range tests {
-		name := "nil"
-		if tt.conclusion != nil {
-			name = *tt.conclusion
-		}
-		t.Run(name, func(t *testing.T) {
-			t.Parallel()
-			srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-				if strings.Contains(r.URL.Path, "/status") {
-					json.NewEncoder(w).Encode(map[string]interface{}{
-						"state":    "success",
-						"statuses": []interface{}{},
-					})
-					return
-				}
-				json.NewEncoder(w).Encode(map[string]interface{}{
-					"total_count": 1,
-					"check_runs": []map[string]interface{}{
-						{
-							"name":       "check",
-							"conclusion": tt.conclusion,
-							"status":     tt.status,
-							"html_url":   "https://github.com/check/1",
-						},
-					},
-				})
-			}))
-			defer srv.Close()
-
-			c := NewClient("token", srv.URL, AllowInsecureHTTP())
-			c.SetHTTPClient(srv.Client())
-
-			statuses, err := c.GetCommitStatuses(context.Background(), "owner", "repo", "sha1")
-			if err != nil {
-				t.Fatalf("unexpected error: %v", err)
-			}
-			if len(statuses) != 1 {
-				t.Fatalf("expected 1 status, got %d", len(statuses))
-			}
-			if statuses[0].Status != tt.want {
-				t.Errorf("expected status %q, got %q", tt.want, statuses[0].Status)
-			}
-		})
-	}
-}
-
-func TestGetCommitStatuses_404(t *testing.T) {
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.WriteHeader(404)
-		w.Write([]byte(`{"message":"Not Found"}`))
-	}))
-	defer srv.Close()
-
-	c := NewClient("token", srv.URL, AllowInsecureHTTP())
-	c.SetHTTPClient(srv.Client())
-
-	_, err := c.GetCommitStatuses(context.Background(), "owner", "repo", "badsha")
-	if err == nil {
-		t.Fatal("expected error for 404")
-	}
-}
-
-func TestGetCommitStatuses_401(t *testing.T) {
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.WriteHeader(401)
-		w.Write([]byte(`{"message":"Bad credentials"}`))
-	}))
-	defer srv.Close()
-
-	c := NewClient("token", srv.URL, AllowInsecureHTTP())
-	c.SetHTTPClient(srv.Client())
-
-	_, err := c.GetCommitStatuses(context.Background(), "owner", "repo", "sha")
-	if err == nil {
-		t.Fatal("expected error for 401")
-	}
-}
-
-func TestGetCommitStatuses_MalformedJSON(t *testing.T) {
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.WriteHeader(200)
-		w.Write([]byte(`not json`))
-	}))
-	defer srv.Close()
-
-	c := NewClient("token", srv.URL, AllowInsecureHTTP())
-	c.SetHTTPClient(srv.Client())
-
-	_, err := c.GetCommitStatuses(context.Background(), "owner", "repo", "sha")
-	if err == nil {
-		t.Fatal("expected error for malformed JSON")
-	}
-}
-
-func TestGetCommitStatuses_CheckRunsErrorAfterStatusesSucceed(t *testing.T) {
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch {
-		case strings.Contains(r.URL.Path, "/status"):
-			// Statuses succeed
-			json.NewEncoder(w).Encode(map[string]interface{}{
-				"state": "success",
-				"statuses": []map[string]string{
-					{
-						"context":     "ci/build",
-						"state":       "success",
-						"description": "Build passed",
-						"target_url":  "https://ci.example.com/1",
-					},
-				},
-			})
-		case strings.Contains(r.URL.Path, "/check-runs"):
-			// Check runs fail with 500
-			w.WriteHeader(500)
-			w.Write([]byte(`{"message":"Internal Server Error"}`))
-		default:
-			w.WriteHeader(404)
-		}
-	}))
-	defer srv.Close()
-
-	c := NewClient("token", srv.URL, AllowInsecureHTTP())
-	c.SetHTTPClient(srv.Client())
-
-	_, err := c.GetCommitStatuses(context.Background(), "owner", "repo", "abc123")
-	if err == nil {
-		t.Fatal("expected error when check-runs endpoint fails after statuses succeed")
-	}
-	if !strings.Contains(err.Error(), "fetch check runs") {
-		t.Errorf("expected check runs error, got: %v", err)
-	}
-}
-
-func stringPtr(s string) *string {
-	return &s
-}

github/reviews.go

@@ -1,198 +0,0 @@
-package github
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"log/slog"
-	"net/http"
-	"net/url"
-
-	"gitea.weiker.me/rodin/review-bot/vcs"
-)
-
-const (
-	// reviewsPerPage is the number of reviews to fetch per API page.
-	reviewsPerPage = 100
-	// maxReviewPages is the maximum number of pages to paginate through
-	// when listing reviews. Acts as a safeguard against infinite pagination.
-	maxReviewPages = 100
-)
-
-// reviewResponse is the GitHub API response for a pull request review.
-type reviewResponse struct {
-	ID   int64  `json:"id"`
-	Body string `json:"body"`
-	User struct {
-		Login string `json:"login"`
-	} `json:"user"`
-	State    string `json:"state"`
-	CommitID string `json:"commit_id"`
-}
-
-// reviewCreateRequest is the GitHub API request body for creating a pull request review.
-type reviewCreateRequest struct {
-	Body     string                `json:"body"`
-	Event    string                `json:"event"`
-	Comments []reviewCommentCreate `json:"comments,omitempty"`
-	CommitID string                `json:"commit_id,omitempty"`
-}
-
-// reviewCommentCreate is a single inline comment in a review creation request.
-type reviewCommentCreate struct {
-	Path     string `json:"path"`
-	Position int    `json:"position"`
-	Body     string `json:"body"`
-}
-
-// dismissReviewRequest is the GitHub API request body for dismissing a review.
-type dismissReviewRequest struct {
-	Message string `json:"message"`
-}
-
-// userResponse is the GitHub API response for the authenticated user.
-type userResponse struct {
-	Login string `json:"login"`
-}
-
-// translateReviewEvent converts a vcs.ReviewEvent to the GitHub API event string.
-func translateReviewEvent(event vcs.ReviewEvent) string {
-	switch event {
-	case vcs.ReviewEventApprove:
-		return "APPROVE"
-	case vcs.ReviewEventRequestChanges:
-		return "REQUEST_CHANGES"
-	default:
-		return "COMMENT"
-	}
-}
-
-// PostReview creates a new review on a pull request.
-func (c *Client) PostReview(ctx context.Context, owner, repo string, number int, req vcs.ReviewRequest) (*vcs.Review, error) {
-	reqURL := fmt.Sprintf("%s/repos/%s/%s/pulls/%d/reviews",
-		c.baseURL, url.PathEscape(owner), url.PathEscape(repo), number)
-
-	payload := reviewCreateRequest{
-		Body:  req.Body,
-		Event: translateReviewEvent(req.Event),
-	}
-
-	for _, comment := range req.Comments {
-		rc := reviewCommentCreate{
-			Path:     comment.Path,
-			Position: comment.Position,
-			Body:     comment.Body,
-		}
-		payload.Comments = append(payload.Comments, rc)
-		// Use CommitID from the first comment that has one.
-		// All comments in a single review are expected to reference the same commit.
-		if payload.CommitID == "" && comment.CommitID != "" {
-			payload.CommitID = comment.CommitID
-		}
-	}
-
-	body, err := c.doJSONRequest(ctx, http.MethodPost, reqURL, payload)
-	if err != nil {
-		return nil, fmt.Errorf("post review: %w", err)
-	}
-
-	var resp reviewResponse
-	if err := json.Unmarshal(body, &resp); err != nil {
-		return nil, fmt.Errorf("parse review response: %w", err)
-	}
-
-	return &vcs.Review{
-		ID:       resp.ID,
-		Body:     resp.Body,
-		User:     vcs.UserInfo{Login: resp.User.Login},
-		State:    resp.State,
-		CommitID: resp.CommitID,
-	}, nil
-}
-
-// ListReviews lists all reviews on a pull request.
-func (c *Client) ListReviews(ctx context.Context, owner, repo string, number int) ([]vcs.Review, error) {
-	var allReviews []vcs.Review
-
-	for page := 1; page <= maxReviewPages; page++ {
-		reqURL := fmt.Sprintf("%s/repos/%s/%s/pulls/%d/reviews?per_page=%d&page=%d",
-			c.baseURL, url.PathEscape(owner), url.PathEscape(repo), number, reviewsPerPage, page)
-		body, err := c.doGet(ctx, reqURL)
-		if err != nil {
-			return nil, fmt.Errorf("list reviews page %d: %w", page, err)
-		}
-		var reviews []reviewResponse
-		if err := json.Unmarshal(body, &reviews); err != nil {
-			return nil, fmt.Errorf("parse reviews JSON: %w", err)
-		}
-		if len(reviews) == 0 {
-			break
-		}
-		for _, r := range reviews {
-			allReviews = append(allReviews, vcs.Review{
-				ID:       r.ID,
-				Body:     r.Body,
-				User:     vcs.UserInfo{Login: r.User.Login},
-				State:    r.State,
-				CommitID: r.CommitID,
-			})
-		}
-		if len(reviews) < reviewsPerPage {
-			break
-		}
-		// NOTE: This warning only fires when the final page was full (the short-page
-		// break above did not trigger), meaning additional reviews likely exist beyond
-		// our page limit. The loop naturally exits after this iteration since page
-		// increments past maxReviewPages.
-		if page == maxReviewPages {
-			slog.Warn("ListReviews hit page limit; results may be truncated",
-				"owner", owner, "repo", repo, "pr", number,
-				"maxPages", maxReviewPages, "reviewsFetched", len(allReviews))
-		}
-	}
-
-	return allReviews, nil
-}
-
-// DeleteReview permanently deletes a review from a pull request.
-// Use DismissReview instead when the review should remain visible but marked as dismissed
-// (e.g., superseding an outdated review while preserving history).
-func (c *Client) DeleteReview(ctx context.Context, owner, repo string, number int, reviewID int64) error {
-	reqURL := fmt.Sprintf("%s/repos/%s/%s/pulls/%d/reviews/%d",
-		c.baseURL, url.PathEscape(owner), url.PathEscape(repo), number, reviewID)
-	_, err := c.doRequest(ctx, http.MethodDelete, reqURL, "")
-	if err != nil {
-		return fmt.Errorf("delete review: %w", err)
-	}
-	return nil
-}
-
-// DismissReview dismisses a review on a pull request with a message.
-func (c *Client) DismissReview(ctx context.Context, owner, repo string, number int, reviewID int64, message string) error {
-	reqURL := fmt.Sprintf("%s/repos/%s/%s/pulls/%d/reviews/%d/dismissals",
-		c.baseURL, url.PathEscape(owner), url.PathEscape(repo), number, reviewID)
-
-	payload := dismissReviewRequest{
-		Message: message,
-	}
-
-	_, err := c.doJSONRequest(ctx, http.MethodPut, reqURL, payload)
-	if err != nil {
-		return fmt.Errorf("dismiss review: %w", err)
-	}
-	return nil
-}
-
-// GetAuthenticatedUser returns the login name of the authenticated user.
-func (c *Client) GetAuthenticatedUser(ctx context.Context) (string, error) {
-	reqURL := fmt.Sprintf("%s/user", c.baseURL)
-	body, err := c.doGet(ctx, reqURL)
-	if err != nil {
-		return "", fmt.Errorf("get authenticated user: %w", err)
-	}
-	var resp userResponse
-	if err := json.Unmarshal(body, &resp); err != nil {
-		return "", fmt.Errorf("parse user response: %w", err)
-	}
-	return resp.Login, nil
-}

review/formatter.go

@@ -10,6 +10,18 @@ func FormatMarkdown(result *ReviewResult, reviewerName string) string {
 	return FormatMarkdownWithDisplay(result, reviewerName, reviewerName)
 }
 
+// GiteaEvent converts the verdict to the Gitea API event string.
+func GiteaEvent(verdict string) string {
+	switch verdict {
+	case "APPROVE":
+		return "APPROVED"
+	case "REQUEST_CHANGES":
+		return "REQUEST_CHANGES"
+	default:
+		return "COMMENT"
+	}
+}
+
 // FormatMarkdownWithDisplay formats a ReviewResult with separate display name and sentinel name.
 // Note: displayName is not HTML-escaped as Gitea sanitizes rendered Markdown.
 // Persona display names are controlled by repo owners (trusted input).

review/formatter_test.go

@@ -98,6 +98,25 @@ func TestFormatMarkdown_SpecialChars(t *testing.T) {
 	}
 }
 
+func TestGiteaEvent(t *testing.T) {
+	tests := []struct {
+		verdict  string
+		expected string
+	}{
+		{"APPROVE", "APPROVED"},
+		{"REQUEST_CHANGES", "REQUEST_CHANGES"},
+		{"UNKNOWN", "COMMENT"},
+		{"", "COMMENT"},
+	}
+
+	for _, tc := range tests {
+		got := GiteaEvent(tc.verdict)
+		if got != tc.expected {
+			t.Errorf("GiteaEvent(%q) = %q, want %q", tc.verdict, got, tc.expected)
+		}
+	}
+}
+
 func TestFormatMarkdown_Sentinel(t *testing.T) {
 	result := &ReviewResult{
 		Verdict:        "APPROVE",

review/repo_persona.go

@@ -4,19 +4,32 @@ import (
 	"context"
 	"log/slog"
 	"strings"
-
-	"gitea.weiker.me/rodin/review-bot/vcs"
 )
 
 // RepoPersonaPath is the directory path where repo-specific personas are stored.
 const RepoPersonaPath = ".review-bot/personas"
 
+// GiteaClient defines the subset of gitea.Client methods needed for loading repo personas.
+// This interface allows for easier testing and decouples the review package from gitea.
+type GiteaClient interface {
+	ListContents(ctx context.Context, owner, repo, path string) ([]ContentEntry, error)
+	GetFileContent(ctx context.Context, owner, repo, filepath string) (string, error)
+}
+
+// ContentEntry represents a file or directory entry from the contents API.
+// This mirrors gitea.ContentEntry to avoid import cycles.
+type ContentEntry struct {
+	Name string `json:"name"`
+	Path string `json:"path"`
+	Type string `json:"type"` // "file" or "dir"
+}
+
 // LoadRepoPersonas fetches personas from a repository's .review-bot/personas/ directory.
 // Returns an empty map (not nil) if the directory doesn't exist or is empty.
 // Individual parse failures are logged and skipped; the remaining personas are still returned.
 // Auth errors and other non-404 errors are propagated.
 // Files exceeding MaxPersonaFileSize are rejected to prevent resource exhaustion.
-func LoadRepoPersonas(ctx context.Context, client vcs.FileReader, owner, repo string) (map[string]*Persona, error) {
+func LoadRepoPersonas(ctx context.Context, client GiteaClient, owner, repo string) (map[string]*Persona, error) {
 	result := make(map[string]*Persona)
 
 	entries, err := client.ListContents(ctx, owner, repo, RepoPersonaPath)
@@ -44,7 +57,7 @@ func LoadRepoPersonas(ctx context.Context, client vcs.FileReader, owner, repo st
 			continue
 		}
 
-		content, err := client.GetFileContent(ctx, owner, repo, entry.Path, "")
+		content, err := client.GetFileContent(ctx, owner, repo, entry.Path)
 		if err != nil {
 			slog.Warn("could not fetch repo persona file",
 				"file", entry.Path,

review/repo_persona_test.go

@@ -5,8 +5,6 @@ import (
 	"errors"
 	"strings"
 	"testing"
-
-	"gitea.weiker.me/rodin/review-bot/vcs"
 )
 
 func TestParsePersonaBytes(t *testing.T) {
@@ -19,7 +17,11 @@ func TestParsePersonaBytes(t *testing.T) {
 	}{
 		{
 			name: "valid yaml",
-			data: "name: test\nidentity: test identity\nfocus:\n  - testing\n",
+			data: `name: test
+identity: test identity
+focus:
+  - testing
+`,
 			source:   "test.yaml",
 			wantName: "test",
 		},
@@ -65,15 +67,15 @@ func TestParsePersonaBytes(t *testing.T) {
 	}
 }
 
-// mockGiteaClient implements vcs.FileReader for testing.
+// mockGiteaClient implements GiteaClient for testing.
 type mockGiteaClient struct {
-	contents map[string][]vcs.ContentEntry // path -> entries
+	contents map[string][]ContentEntry // path -> entries
 	files    map[string]string         // path -> content
 	listErr  error
 	fileErr  map[string]error // path -> error
 }
 
-func (m *mockGiteaClient) ListContents(ctx context.Context, owner, repo, path string) ([]vcs.ContentEntry, error) {
+func (m *mockGiteaClient) ListContents(ctx context.Context, owner, repo, path string) ([]ContentEntry, error) {
 	if m.listErr != nil {
 		return nil, m.listErr
 	}
@@ -84,7 +86,7 @@ func (m *mockGiteaClient) ListContents(ctx context.Context, owner, repo, path st
 	return entries, nil
 }
 
-func (m *mockGiteaClient) GetFileContent(ctx context.Context, owner, repo, filepath, ref string) (string, error) {
+func (m *mockGiteaClient) GetFileContent(ctx context.Context, owner, repo, filepath string) (string, error) {
 	if m.fileErr != nil {
 		if err, ok := m.fileErr[filepath]; ok {
 			return "", err
@@ -116,7 +118,7 @@ func TestLoadRepoPersonas(t *testing.T) {
 
 	t.Run("empty directory returns empty map", func(t *testing.T) {
 		client := &mockGiteaClient{
-			contents: map[string][]vcs.ContentEntry{
+			contents: map[string][]ContentEntry{
 				RepoPersonaPath: {},
 			},
 		}
@@ -131,15 +133,27 @@ func TestLoadRepoPersonas(t *testing.T) {
 
 	t.Run("loads valid personas", func(t *testing.T) {
 		client := &mockGiteaClient{
-			contents: map[string][]vcs.ContentEntry{
+			contents: map[string][]ContentEntry{
 				RepoPersonaPath: {
 					{Name: "trading.yaml", Path: ".review-bot/personas/trading.yaml", Type: "file"},
 					{Name: "crypto.yaml", Path: ".review-bot/personas/crypto.yaml", Type: "file"},
 				},
 			},
 			files: map[string]string{
-				".review-bot/personas/trading.yaml": "name: trading\ndisplay_name: Trading Expert\nidentity: You are a trading expert.\nfocus:\n  - order handling\n  - risk management\n",
+				".review-bot/personas/trading.yaml": `name: trading
-				".review-bot/personas/crypto.yaml":  "name: crypto\ndisplay_name: Crypto Expert\nidentity: You are a cryptography expert.\nfocus:\n  - key management\n  - encryption\n",
+display_name: Trading Expert
+identity: You are a trading expert.
+focus:
+  - order handling
+  - risk management
+`,
+				".review-bot/personas/crypto.yaml": `name: crypto
+display_name: Crypto Expert
+identity: You are a cryptography expert.
+focus:
+  - key management
+  - encryption
+`,
 			},
 		}
 		personas, err := LoadRepoPersonas(ctx, client, "owner", "repo")
@@ -162,14 +176,16 @@ func TestLoadRepoPersonas(t *testing.T) {
 
 	t.Run("skips invalid persona files", func(t *testing.T) {
 		client := &mockGiteaClient{
-			contents: map[string][]vcs.ContentEntry{
+			contents: map[string][]ContentEntry{
 				RepoPersonaPath: {
 					{Name: "valid.yaml", Path: ".review-bot/personas/valid.yaml", Type: "file"},
 					{Name: "invalid.yaml", Path: ".review-bot/personas/invalid.yaml", Type: "file"},
 				},
 			},
 			files: map[string]string{
-				".review-bot/personas/valid.yaml":   "name: valid\nidentity: Valid persona\n",
+				".review-bot/personas/valid.yaml": `name: valid
+identity: Valid persona
+`,
 				".review-bot/personas/invalid.yaml": "not valid yaml: [broken",
 			},
 		}
@@ -177,6 +193,7 @@ func TestLoadRepoPersonas(t *testing.T) {
 		if err != nil {
 			t.Fatalf("unexpected error: %v", err)
 		}
+		// Should have the valid one, skip the invalid
 		if len(personas) != 1 {
 			t.Fatalf("expected 1 persona (skipped invalid), got %d", len(personas))
 		}
@@ -187,7 +204,7 @@ func TestLoadRepoPersonas(t *testing.T) {
 
 	t.Run("skips non-yaml files", func(t *testing.T) {
 		client := &mockGiteaClient{
-			contents: map[string][]vcs.ContentEntry{
+			contents: map[string][]ContentEntry{
 				RepoPersonaPath: {
 					{Name: "persona.yaml", Path: ".review-bot/personas/persona.yaml", Type: "file"},
 					{Name: "README.md", Path: ".review-bot/personas/README.md", Type: "file"},
@@ -195,7 +212,9 @@ func TestLoadRepoPersonas(t *testing.T) {
 				},
 			},
 			files: map[string]string{
-				".review-bot/personas/persona.yaml": "name: test\nidentity: Test persona\n",
+				".review-bot/personas/persona.yaml": `name: test
+identity: Test persona
+`,
 				".review-bot/personas/README.md": "# Personas\n\nPut your personas here.",
 			},
 		}
@@ -210,14 +229,16 @@ func TestLoadRepoPersonas(t *testing.T) {
 
 	t.Run("skips subdirectories", func(t *testing.T) {
 		client := &mockGiteaClient{
-			contents: map[string][]vcs.ContentEntry{
+			contents: map[string][]ContentEntry{
 				RepoPersonaPath: {
 					{Name: "persona.yaml", Path: ".review-bot/personas/persona.yaml", Type: "file"},
 					{Name: "subdir", Path: ".review-bot/personas/subdir", Type: "dir"},
 				},
 			},
 			files: map[string]string{
-				".review-bot/personas/persona.yaml": "name: test\nidentity: Test persona\n",
+				".review-bot/personas/persona.yaml": `name: test
+identity: Test persona
+`,
 			},
 		}
 		personas, err := LoadRepoPersonas(ctx, client, "owner", "repo")
@@ -244,14 +265,16 @@ func TestLoadRepoPersonas(t *testing.T) {
 
 	t.Run("skips files that fail to fetch", func(t *testing.T) {
 		client := &mockGiteaClient{
-			contents: map[string][]vcs.ContentEntry{
+			contents: map[string][]ContentEntry{
 				RepoPersonaPath: {
 					{Name: "good.yaml", Path: ".review-bot/personas/good.yaml", Type: "file"},
 					{Name: "bad.yaml", Path: ".review-bot/personas/bad.yaml", Type: "file"},
 				},
 			},
 			files: map[string]string{
-				".review-bot/personas/good.yaml": "name: good\nidentity: Good persona\n",
+				".review-bot/personas/good.yaml": `name: good
+identity: Good persona
+`,
 			},
 			fileErr: map[string]error{
 				".review-bot/personas/bad.yaml": errors.New("HTTP 500: internal server error"),
@@ -267,16 +290,19 @@ func TestLoadRepoPersonas(t *testing.T) {
 	})
 
 	t.Run("skips oversized files", func(t *testing.T) {
+		// Create a content string that exceeds MaxPersonaFileSize (64KB)
 		oversizedContent := strings.Repeat("a", MaxPersonaFileSize+1)
 		client := &mockGiteaClient{
-			contents: map[string][]vcs.ContentEntry{
+			contents: map[string][]ContentEntry{
 				RepoPersonaPath: {
 					{Name: "normal.yaml", Path: ".review-bot/personas/normal.yaml", Type: "file"},
 					{Name: "huge.yaml", Path: ".review-bot/personas/huge.yaml", Type: "file"},
 				},
 			},
 			files: map[string]string{
-				".review-bot/personas/normal.yaml": "name: normal\nidentity: Normal sized persona\n",
+				".review-bot/personas/normal.yaml": `name: normal
+identity: Normal sized persona
+`,
 				".review-bot/personas/huge.yaml": oversizedContent,
 			},
 		}
@@ -284,6 +310,7 @@ func TestLoadRepoPersonas(t *testing.T) {
 		if err != nil {
 			t.Fatalf("unexpected error: %v", err)
 		}
+		// Should have the normal one, skip the oversized
 		if len(personas) != 1 {
 			t.Fatalf("expected 1 persona (skipped oversized), got %d", len(personas))
 		}
@@ -343,6 +370,7 @@ func TestGetBuiltinPersonasMap(t *testing.T) {
 		t.Fatal("expected at least one built-in persona")
 	}
 
+	// Verify expected personas exist
 	expected := []string{"security", "architect", "docs"}
 	for _, name := range expected {
 		if personas[name] == nil {
@@ -350,6 +378,7 @@ func TestGetBuiltinPersonasMap(t *testing.T) {
 		}
 	}
 
+	// Verify personas are valid
 	for name, p := range personas {
 		if p.Name != name {
 			t.Errorf("persona %q has mismatched name %q", name, p.Name)
@@ -393,6 +422,8 @@ func TestIsNotFoundError(t *testing.T) {
 		{nil, false},
 		{errors.New("HTTP 404: not found"), true},
 		{errors.New("HTTP 404"), true},
+		// Intentionally false: generic "not found" could mask auth/transport errors.
+		// Only explicit HTTP 404 responses should be treated as "directory doesn't exist".
 		{errors.New("something not found"), false},
 		{errors.New("HTTP 401: unauthorized"), false},
 		{errors.New("connection refused"), false},

vcs/check_test.go

@@ -1,11 +0,0 @@
-package vcs_test
-
-import (
-	"gitea.weiker.me/rodin/review-bot/gitea"
-	"gitea.weiker.me/rodin/review-bot/vcs"
-)
-
-// Compile-time assertion: the gitea.Adapter satisfies vcs.Client.
-// (The raw gitea.Client does NOT satisfy vcs.Client due to signature differences;
-// the Adapter bridges them.)
-var _ vcs.Client = (*gitea.Adapter)(nil)

vcs/interfaces.go

@@ -1,43 +0,0 @@
-// Package vcs defines the shared VCS client interface and supporting types.
-// Platform adapters (gitea, github) implement these interfaces so the core
-// review logic can work with any VCS platform without platform-specific code.
-package vcs
-
-import "context"
-
-// PRReader can fetch pull request metadata, diffs, and changed files.
-type PRReader interface {
-	GetPullRequest(ctx context.Context, owner, repo string, number int) (*PullRequest, error)
-	GetPullRequestDiff(ctx context.Context, owner, repo string, number int) (string, error)
-	GetPullRequestFiles(ctx context.Context, owner, repo string, number int) ([]ChangedFile, error)
-	GetFileContentAtRef(ctx context.Context, owner, repo, path, ref string) (string, error)
-	GetCommitStatuses(ctx context.Context, owner, repo, sha string) ([]CommitStatus, error)
-}
-
-// FileReader can fetch file contents and list directory entries.
-type FileReader interface {
-	GetFileContent(ctx context.Context, owner, repo, path, ref string) (string, error)
-	ListContents(ctx context.Context, owner, repo, path string) ([]ContentEntry, error)
-}
-
-// Reviewer can post, list, and delete pull request reviews.
-type Reviewer interface {
-	PostReview(ctx context.Context, owner, repo string, number int, req ReviewRequest) (*Review, error)
-	ListReviews(ctx context.Context, owner, repo string, number int) ([]Review, error)
-	DeleteReview(ctx context.Context, owner, repo string, number int, reviewID int64) error
-	DismissReview(ctx context.Context, owner, repo string, number int, reviewID int64, message string) error
-}
-
-// Identity can report who the authenticated user is.
-type Identity interface {
-	GetAuthenticatedUser(ctx context.Context) (string, error)
-}
-
-// Client is the full VCS interface: PR reads, file reads, review management, and identity.
-// Platform adapters (gitea, github) implement this interface.
-type Client interface {
-	PRReader
-	FileReader
-	Reviewer
-	Identity
-}

vcs/types.go

@@ -1,98 +0,0 @@
-package vcs
-
-// ReviewEvent is the event type for a pull request review action.
-// Adapters must translate these action constants to/from platform-native values.
-// For example, Gitea uses "APPROVED" as both action and state, while GitHub
-// uses "APPROVE" for the action and returns "approved" as the state.
-type ReviewEvent string
-
-const (
-	// ReviewEventApprove approves the pull request.
-	ReviewEventApprove ReviewEvent = "APPROVE"
-	// ReviewEventRequestChanges requests changes to the pull request.
-	ReviewEventRequestChanges ReviewEvent = "REQUEST_CHANGES"
-	// ReviewEventComment posts a review comment without approval or rejection.
-	ReviewEventComment ReviewEvent = "COMMENT"
-)
-
-// BaseRef identifies the target branch of a pull request.
-type BaseRef struct {
-	Ref string `json:"ref"`
-}
-
-// HeadRef identifies the source branch and latest commit of a pull request.
-type HeadRef struct {
-	SHA string `json:"sha"`
-	Ref string `json:"ref"`
-}
-
-// UserInfo identifies a user by login name.
-type UserInfo struct {
-	Login string `json:"login"`
-}
-
-// PullRequest holds relevant PR metadata.
-type PullRequest struct {
-	Number int     `json:"number"`
-	Title  string  `json:"title"`
-	Body   string  `json:"body"`
-	Head   HeadRef `json:"head"`
-	Base   BaseRef `json:"base"`
-}
-
-// ChangedFile represents a file modified in a PR.
-type ChangedFile struct {
-	Filename string `json:"filename"`
-	Status   string `json:"status"`
-	Patch    string `json:"patch"`
-}
-
-// ContentEntry represents a file or directory entry from the contents API.
-type ContentEntry struct {
-	Name string `json:"name"`
-	Path string `json:"path"`
-	Type string `json:"type"` // "file" or "dir"
-}
-
-// CommitStatus represents a single CI status entry for a commit.
-type CommitStatus struct {
-	Status      string `json:"status"`
-	Context     string `json:"context"`
-	Description string `json:"description"`
-	TargetURL   string `json:"target_url"`
-}
-
-// Review represents a pull request review.
-type Review struct {
-	ID       int64    `json:"id"`
-	Body     string   `json:"body"`
-	User     UserInfo `json:"user"`
-	State    string   `json:"state"`
-	Stale    bool     `json:"stale"`
-	CommitID string   `json:"commit_id"`
-}
-
-// ReviewComment represents an inline comment in a review.
-// All adapters use GitHub diff-position convention:
-//   - Position is a 1-indexed offset from the @@ hunk line in the unified diff.
-//   - CommitID identifies the commit the comment is anchored to.
-//     It is optional; omit (empty string) for review-level comments that are
-//     not attached to a specific commit.
-//
-// Adapters are responsible for translating to/from platform-native formats
-// (e.g. Gitea uses line numbers; GitHub uses diff positions natively).
-type ReviewComment struct {
-	Path     string `json:"path"`
-	Position int    `json:"position"` // diff-position: 1-indexed offset from @@ hunk line
-	CommitID string `json:"commit_id"`
-	Body     string `json:"body"`
-}
-
-// ReviewRequest is the payload for posting a review.
-type ReviewRequest struct {
-	// Body is the top-level review comment.
-	Body string `json:"body"`
-	// Event is the review action (approve, request changes, or comment).
-	Event    ReviewEvent     `json:"event"`
-	Comments []ReviewComment `json:"comments,omitempty"`
-}

vcs/util.go

@@ -1,193 +0,0 @@
-package vcs
-
-import (
-	"context"
-	"fmt"
-	"strconv"
-	"strings"
-)
-
-const (
-	// maxFilesInPath is the maximum number of files GetAllFilesInPath will fetch.
-	// Prevents unbounded resource consumption on very large directory trees.
-	maxFilesInPath = 10000
-
-	// maxTotalBytesInPath is the maximum total bytes GetAllFilesInPath will accumulate.
-	// Prevents memory exhaustion when fetching large repositories.
-	maxTotalBytesInPath = 100 * 1024 * 1024 // 100 MB
-)
-
-// GetAllFilesInPath recursively fetches all file contents under a path using the
-// provided FileReader. Returns a map of filepath -> content for all files found.
-// If the path points to an empty directory, returns an empty map.
-//
-// This function uses fail-fast error handling: any error from ListContents or
-// GetFileContent aborts the entire traversal and returns the error immediately.
-// This differs from gitea.Client.GetAllFilesInPath, which logs errors and continues.
-// The fail-fast contract ensures callers can trust that a nil error means all files
-// were successfully fetched.
-//
-// Resource limits: the traversal is bounded by maxFilesInPath (file count) and
-// maxTotalBytesInPath (total accumulated bytes). The context is checked before each
-// recursive call and file fetch to respect cancellation.
-func GetAllFilesInPath(ctx context.Context, client FileReader, owner, repo, path string) (map[string]string, error) {
-	results := make(map[string]string)
-	totalBytes := 0
-
-	var walk func(string) error
-	walk = func(dir string) error {
-		if err := ctx.Err(); err != nil {
-			return fmt.Errorf("context canceled during traversal: %w", err)
-		}
-
-		entries, err := client.ListContents(ctx, owner, repo, dir)
-		if err != nil {
-			return fmt.Errorf("list contents %q: %w", dir, err)
-		}
-
-		for _, entry := range entries {
-			if err := ctx.Err(); err != nil {
-				return fmt.Errorf("context canceled during traversal: %w", err)
-			}
-
-			switch entry.Type {
-			case "file":
-				if len(results) >= maxFilesInPath {
-					return fmt.Errorf("exceeded max file count (%d) in path %q", maxFilesInPath, path)
-				}
-
-				content, err := client.GetFileContent(ctx, owner, repo, entry.Path, "")
-				if err != nil {
-					return fmt.Errorf("get file %q: %w", entry.Path, err)
-				}
-
-				totalBytes += len(content)
-				if totalBytes > maxTotalBytesInPath {
-					return fmt.Errorf("exceeded max total bytes (%d) in path %q", maxTotalBytesInPath, path)
-				}
-
-				results[entry.Path] = content
-			case "dir":
-				if err := walk(entry.Path); err != nil {
-					return err
-				}
-			}
-		}
-		return nil
-	}
-
-	if err := walk(path); err != nil {
-		return nil, err
-	}
-	return results, nil
-}
-
-// BuildLineToPositionMap parses a unified diff and returns a map of
-// filename -> (new line number -> diff position). The diff position is a
-// 1-indexed offset from the @@ hunk header line for each file.
-// Only lines that appear in the new file (context lines and additions) are mapped.
-// Deletion-only lines are not included.
-func BuildLineToPositionMap(diff string) map[string]map[int]int {
-	result := make(map[string]map[int]int)
-
-	lines := strings.Split(diff, "\n")
-	var currentFile string
-	var position int
-	var newLine int
-
-	for _, line := range lines {
-		// Detect new file in diff
-		if strings.HasPrefix(line, "+++ b/") {
-			currentFile = strings.TrimPrefix(line, "+++ b/")
-			position = 0
-			newLine = 0
-			if result[currentFile] == nil {
-				result[currentFile] = make(map[int]int)
-			}
-			continue
-		}
-
-		// Skip --- lines (old file header)
-		if strings.HasPrefix(line, "--- ") {
-			continue
-		}
-
-		// Skip diff --git lines
-		if strings.HasPrefix(line, "diff --git") {
-			continue
-		}
-
-		// Skip index lines
-		if strings.HasPrefix(line, "index ") {
-			continue
-		}
-
-		// Parse hunk headers
-		if strings.HasPrefix(line, "@@") {
-			position++
-			// Extract new file start line from @@ -a,b +c,d @@
-			newLine = parseHunkNewStart(line)
-			continue
-		}
-
-		// We need a current file to map lines
-		if currentFile == "" {
-			continue
-		}
-
-		// Skip "\ No newline at end of file" markers — these are git diff
-		// metadata and not part of the file content.
-		if strings.HasPrefix(line, `\`) {
-			continue
-		}
-
-		// Process diff content lines
-		if strings.HasPrefix(line, "+") {
-			position++
-			result[currentFile][newLine] = position
-			newLine++
-		} else if strings.HasPrefix(line, "-") {
-			position++
-			// Deletion lines don't map to new line numbers
-		} else if strings.HasPrefix(line, " ") {
-			// Context line (space-prefixed).
-			// Only map if position > 0, which means we've seen a hunk header.
-			// Lines before the first hunk header (position == 0) are not part
-			// of any diff hunk and should be skipped.
-			if position > 0 {
-				position++
-				result[currentFile][newLine] = position
-				newLine++
-			}
-		}
-	}
-
-	return result
-}
-
-// parseHunkNewStart extracts the new-file starting line number from a hunk header.
-// Format: @@ -old_start[,old_count] +new_start[,new_count] @@
-func parseHunkNewStart(hunkLine string) int {
-	// Find the +N part
-	plusIdx := strings.Index(hunkLine, "+")
-	if plusIdx < 0 {
-		return 1
-	}
-	rest := hunkLine[plusIdx+1:]
-
-	// Find the end of the number (first non-digit after +)
-	endIdx := 0
-	for endIdx < len(rest) && rest[endIdx] >= '0' && rest[endIdx] <= '9' {
-		endIdx++
-	}
-
-	if endIdx == 0 {
-		return 1
-	}
-
-	n, err := strconv.Atoi(rest[:endIdx])
-	if err != nil {
-		return 1
-	}
-	return n
-}

vcs/util_test.go

@@ -1,331 +0,0 @@
-package vcs_test
-
-import (
-	"context"
-	"fmt"
-	"strings"
-	"testing"
-
-	"gitea.weiker.me/rodin/review-bot/vcs"
-)
-
-// mockFileReader implements vcs.FileReader for testing.
-type mockFileReader struct {
-	contents map[string][]vcs.ContentEntry // path -> entries
-	files    map[string]string             // path -> content
-}
-
-func (m *mockFileReader) GetFileContent(ctx context.Context, owner, repo, path, ref string) (string, error) {
-	content, ok := m.files[path]
-	if !ok {
-		return "", fmt.Errorf("HTTP 404: file not found: %s", path)
-	}
-	return content, nil
-}
-
-func (m *mockFileReader) ListContents(ctx context.Context, owner, repo, path string) ([]vcs.ContentEntry, error) {
-	entries, ok := m.contents[path]
-	if !ok {
-		return nil, fmt.Errorf("HTTP 404: path not found: %s", path)
-	}
-	return entries, nil
-}
-
-func TestGetAllFilesInPath(t *testing.T) {
-	ctx := context.Background()
-
-	t.Run("empty directory", func(t *testing.T) {
-		client := &mockFileReader{
-			contents: map[string][]vcs.ContentEntry{
-				"src": {},
-			},
-		}
-		result, err := vcs.GetAllFilesInPath(ctx, client, "owner", "repo", "src")
-		if err != nil {
-			t.Fatalf("unexpected error: %v", err)
-		}
-		if len(result) != 0 {
-			t.Errorf("expected empty map, got %d entries", len(result))
-		}
-	})
-
-	t.Run("flat directory", func(t *testing.T) {
-		client := &mockFileReader{
-			contents: map[string][]vcs.ContentEntry{
-				"src": {
-					{Name: "main.go", Path: "src/main.go", Type: "file"},
-					{Name: "util.go", Path: "src/util.go", Type: "file"},
-				},
-			},
-			files: map[string]string{
-				"src/main.go": "package main",
-				"src/util.go": "package main\n// util",
-			},
-		}
-		result, err := vcs.GetAllFilesInPath(ctx, client, "owner", "repo", "src")
-		if err != nil {
-			t.Fatalf("unexpected error: %v", err)
-		}
-		if len(result) != 2 {
-			t.Fatalf("expected 2 files, got %d", len(result))
-		}
-		if result["src/main.go"] != "package main" {
-			t.Errorf("main.go content = %q", result["src/main.go"])
-		}
-		if result["src/util.go"] != "package main\n// util" {
-			t.Errorf("util.go content = %q", result["src/util.go"])
-		}
-	})
-
-	t.Run("nested directories", func(t *testing.T) {
-		client := &mockFileReader{
-			contents: map[string][]vcs.ContentEntry{
-				"src": {
-					{Name: "main.go", Path: "src/main.go", Type: "file"},
-					{Name: "pkg", Path: "src/pkg", Type: "dir"},
-				},
-				"src/pkg": {
-					{Name: "lib.go", Path: "src/pkg/lib.go", Type: "file"},
-					{Name: "sub", Path: "src/pkg/sub", Type: "dir"},
-				},
-				"src/pkg/sub": {
-					{Name: "deep.go", Path: "src/pkg/sub/deep.go", Type: "file"},
-				},
-			},
-			files: map[string]string{
-				"src/main.go":         "package main",
-				"src/pkg/lib.go":      "package pkg",
-				"src/pkg/sub/deep.go": "package sub",
-			},
-		}
-		result, err := vcs.GetAllFilesInPath(ctx, client, "owner", "repo", "src")
-		if err != nil {
-			t.Fatalf("unexpected error: %v", err)
-		}
-		if len(result) != 3 {
-			t.Fatalf("expected 3 files, got %d", len(result))
-		}
-		if result["src/main.go"] != "package main" {
-			t.Errorf("main.go content = %q", result["src/main.go"])
-		}
-		if result["src/pkg/lib.go"] != "package pkg" {
-			t.Errorf("lib.go content = %q", result["src/pkg/lib.go"])
-		}
-		if result["src/pkg/sub/deep.go"] != "package sub" {
-			t.Errorf("deep.go content = %q", result["src/pkg/sub/deep.go"])
-		}
-	})
-
-	t.Run("mixed files and dirs", func(t *testing.T) {
-		client := &mockFileReader{
-			contents: map[string][]vcs.ContentEntry{
-				"root": {
-					{Name: "README.md", Path: "root/README.md", Type: "file"},
-					{Name: "docs", Path: "root/docs", Type: "dir"},
-					{Name: "config.yaml", Path: "root/config.yaml", Type: "file"},
-				},
-				"root/docs": {
-					{Name: "guide.md", Path: "root/docs/guide.md", Type: "file"},
-				},
-			},
-			files: map[string]string{
-				"root/README.md":     "# Hello",
-				"root/config.yaml":   "key: value",
-				"root/docs/guide.md": "## Guide",
-			},
-		}
-		result, err := vcs.GetAllFilesInPath(ctx, client, "owner", "repo", "root")
-		if err != nil {
-			t.Fatalf("unexpected error: %v", err)
-		}
-		if len(result) != 3 {
-			t.Fatalf("expected 3 files, got %d", len(result))
-		}
-		if result["root/README.md"] != "# Hello" {
-			t.Errorf("README content = %q", result["root/README.md"])
-		}
-		if result["root/docs/guide.md"] != "## Guide" {
-			t.Errorf("guide content = %q", result["root/docs/guide.md"])
-		}
-	})
-}
-
-func TestBuildLineToPositionMap(t *testing.T) {
-	t.Run("single hunk", func(t *testing.T) {
-		diff := "diff --git a/file.go b/file.go\nindex abc..def 100644\n--- a/file.go\n+++ b/file.go\n@@ -1,3 +1,4 @@\n package main\n \n+// new comment\n func main() {}\n"
-		result := vcs.BuildLineToPositionMap(diff)
-		fileMap, ok := result["file.go"]
-		if !ok {
-			t.Fatal("expected file.go in result")
-		}
-		// Hunk header @@ is position 1
-		// Line 1: " package main" -> position 2
-		if fileMap[1] != 2 {
-			t.Errorf("line 1 position = %d, want 2", fileMap[1])
-		}
-		// Line 2: " " (context) -> position 3
-		if fileMap[2] != 3 {
-			t.Errorf("line 2 position = %d, want 3", fileMap[2])
-		}
-		// Line 3: "+// new comment" -> position 4
-		if fileMap[3] != 4 {
-			t.Errorf("line 3 position = %d, want 4", fileMap[3])
-		}
-		// Line 4: " func main() {}" -> position 5
-		if fileMap[4] != 5 {
-			t.Errorf("line 4 position = %d, want 5", fileMap[4])
-		}
-	})
-
-	t.Run("multi hunk", func(t *testing.T) {
-		diff := "diff --git a/file.go b/file.go\n--- a/file.go\n+++ b/file.go\n@@ -1,3 +1,3 @@\n package main\n \n-// old\n+// new\n@@ -10,3 +10,4 @@\n func foo() {\n+\t// added\n \treturn\n }\n"
-		result := vcs.BuildLineToPositionMap(diff)
-		fileMap, ok := result["file.go"]
-		if !ok {
-			t.Fatal("expected file.go in result")
-		}
-		// First hunk: @@ is position 1
-		// Line 1: " package main" -> position 2
-		if fileMap[1] != 2 {
-			t.Errorf("line 1 position = %d, want 2", fileMap[1])
-		}
-		// Line 3: "+// new" -> position 5 (after " ", "-// old" at pos 3,4)
-		if fileMap[3] != 5 {
-			t.Errorf("line 3 position = %d, want 5", fileMap[3])
-		}
-		// Second hunk: @@ is position 6
-		// Line 10: " func foo() {" -> position 7
-		if fileMap[10] != 7 {
-			t.Errorf("line 10 position = %d, want 7", fileMap[10])
-		}
-		// Line 11: "+\t// added" -> position 8
-		if fileMap[11] != 8 {
-			t.Errorf("line 11 position = %d, want 8", fileMap[11])
-		}
-	})
-
-	t.Run("deletion lines not in map", func(t *testing.T) {
-		diff := "diff --git a/file.go b/file.go\n--- a/file.go\n+++ b/file.go\n@@ -1,4 +1,3 @@\n package main\n \n-// deleted line\n func main() {}\n"
-		result := vcs.BuildLineToPositionMap(diff)
-		fileMap, ok := result["file.go"]
-		if !ok {
-			t.Fatal("expected file.go in result")
-		}
-		// Line 1: " package main" -> position 2
-		if fileMap[1] != 2 {
-			t.Errorf("line 1 position = %d, want 2", fileMap[1])
-		}
-		// Line 3 in new file: " func main() {}" -> position 5 (after deletion at pos 4)
-		if fileMap[3] != 5 {
-			t.Errorf("line 3 position = %d, want 5", fileMap[3])
-		}
-		// Should only have 3 entries (lines 1, 2, 3 of new file)
-		if len(fileMap) != 3 {
-			t.Errorf("expected 3 mapped lines, got %d: %v", len(fileMap), fileMap)
-		}
-	})
-
-	t.Run("multiple files", func(t *testing.T) {
-		diff := "diff --git a/a.go b/a.go\n--- a/a.go\n+++ b/a.go\n@@ -1,2 +1,3 @@\n package a\n \n+// file a\ndiff --git a/b.go b/b.go\n--- a/b.go\n+++ b/b.go\n@@ -1,2 +1,3 @@\n package b\n \n+// file b\n"
-		result := vcs.BuildLineToPositionMap(diff)
-		if len(result) != 2 {
-			t.Fatalf("expected 2 files, got %d", len(result))
-		}
-		aMap, ok := result["a.go"]
-		if !ok {
-			t.Fatal("expected a.go in result")
-		}
-		bMap, ok := result["b.go"]
-		if !ok {
-			t.Fatal("expected b.go in result")
-		}
-		// a.go line 3: "+// file a" -> position 4
-		if aMap[3] != 4 {
-			t.Errorf("a.go line 3 position = %d, want 4", aMap[3])
-		}
-		// b.go line 3: "+// file b" -> position 4
-		if bMap[3] != 4 {
-			t.Errorf("b.go line 3 position = %d, want 4", bMap[3])
-		}
-	})
-}
-
-func TestGetAllFilesInPath_ErrorPropagation(t *testing.T) {
-	ctx := context.Background()
-
-	t.Run("ListContents error propagates", func(t *testing.T) {
-		client := &mockFileReader{
-			contents: map[string][]vcs.ContentEntry{
-				// "src" not in map, so ListContents will fail
-			},
-		}
-		_, err := vcs.GetAllFilesInPath(ctx, client, "owner", "repo", "src")
-		if err == nil {
-			t.Fatal("expected error, got nil")
-		}
-		if !strings.Contains(err.Error(), "list contents") {
-			t.Errorf("expected error about list contents, got: %v", err)
-		}
-	})
-
-	t.Run("GetFileContent error propagates", func(t *testing.T) {
-		client := &mockFileReader{
-			contents: map[string][]vcs.ContentEntry{
-				"src": {
-					{Name: "main.go", Path: "src/main.go", Type: "file"},
-				},
-			},
-			files: map[string]string{
-				// "src/main.go" not in files map, so GetFileContent will fail
-			},
-		}
-		_, err := vcs.GetAllFilesInPath(ctx, client, "owner", "repo", "src")
-		if err == nil {
-			t.Fatal("expected error, got nil")
-		}
-		if !strings.Contains(err.Error(), "get file") {
-			t.Errorf("expected error about get file, got: %v", err)
-		}
-	})
-
-	t.Run("nested ListContents error propagates", func(t *testing.T) {
-		client := &mockFileReader{
-			contents: map[string][]vcs.ContentEntry{
-				"src": {
-					{Name: "pkg", Path: "src/pkg", Type: "dir"},
-				},
-				// "src/pkg" not in map, so recursive ListContents will fail
-			},
-		}
-		_, err := vcs.GetAllFilesInPath(ctx, client, "owner", "repo", "src")
-		if err == nil {
-			t.Fatal("expected error, got nil")
-		}
-		if !strings.Contains(err.Error(), "list contents") {
-			t.Errorf("expected error about list contents, got: %v", err)
-		}
-	})
-
-	t.Run("canceled context propagates", func(t *testing.T) {
-		ctx, cancel := context.WithCancel(context.Background())
-		cancel() // Cancel immediately
-
-		client := &mockFileReader{
-			contents: map[string][]vcs.ContentEntry{
-				"src": {
-					{Name: "main.go", Path: "src/main.go", Type: "file"},
-				},
-			},
-			files: map[string]string{
-				"src/main.go": "package main",
-			},
-		}
-		_, err := vcs.GetAllFilesInPath(ctx, client, "owner", "repo", "src")
-		if err == nil {
-			t.Fatal("expected error from canceled context, got nil")
-		}
-		if !strings.Contains(err.Error(), "context canceled") {
-			t.Errorf("expected context cancellation error, got: %v", err)
-		}
-	})
-}