Compare commits
1 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
 Rodin
|
e7bbd55dae |
@@ -26,40 +26,14 @@ inputs:
|
||||
required: false
|
||||
default: ''
|
||||
llm-base-url:
|
||||
description: 'OpenAI-compatible LLM API base URL (not required for aicore provider)'
|
||||
required: false
|
||||
default: ''
|
||||
description: 'OpenAI-compatible LLM API base URL'
|
||||
required: true
|
||||
llm-api-key:
|
||||
description: 'LLM API key (not required for aicore provider)'
|
||||
required: false
|
||||
default: ''
|
||||
description: 'LLM API key'
|
||||
required: true
|
||||
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
|
||||
@@ -88,22 +62,6 @@ inputs:
|
||||
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'
|
||||
@@ -124,38 +82,14 @@ runs:
|
||||
else
|
||||
VERSION="${{ inputs.version }}"
|
||||
fi
|
||||
|
||||
# Detect OS and architecture for platform-specific binary download
|
||||
OS_RAW=$(uname -s | tr '[:upper:]' '[:lower:]')
|
||||
case "$OS_RAW" in
|
||||
linux) OS="linux" ;;
|
||||
darwin) OS="darwin" ;;
|
||||
*)
|
||||
echo "Error: unsupported OS: $(uname -s)" >&2
|
||||
exit 1
|
||||
;;
|
||||
esac
|
||||
|
||||
RAW_ARCH=$(uname -m)
|
||||
case "$RAW_ARCH" in
|
||||
x86_64) ARCH="amd64" ;;
|
||||
aarch64 | arm64) ARCH="arm64" ;;
|
||||
*)
|
||||
echo "Error: unsupported architecture: $RAW_ARCH" >&2
|
||||
exit 1
|
||||
;;
|
||||
esac
|
||||
|
||||
echo "version=${VERSION}" >> "$GITHUB_OUTPUT"
|
||||
echo "os=${OS}" >> "$GITHUB_OUTPUT"
|
||||
echo "arch=${ARCH}" >> "$GITHUB_OUTPUT"
|
||||
|
||||
- name: Cache review-bot binary
|
||||
id: cache
|
||||
uses: actions/cache@v4
|
||||
with:
|
||||
path: ${{ runner.temp }}/review-bot
|
||||
key: review-bot-${{ steps.version.outputs.os }}-${{ steps.version.outputs.arch }}-${{ steps.version.outputs.version }}
|
||||
key: review-bot-linux-amd64-${{ steps.version.outputs.version }}
|
||||
|
||||
- name: Install review-bot
|
||||
if: steps.cache.outputs.cache-hit != 'true'
|
||||
@@ -164,7 +98,7 @@ runs:
|
||||
GITEA_URL="${{ inputs.gitea-url || github.server_url }}"
|
||||
REPO="${{ inputs.repo || 'rodin/review-bot' }}"
|
||||
VERSION="${{ steps.version.outputs.version }}"
|
||||
BINARY="review-bot-${{ steps.version.outputs.os }}-${{ steps.version.outputs.arch }}"
|
||||
BINARY="review-bot-linux-amd64"
|
||||
|
||||
curl -sSfL "${GITEA_URL}/${REPO}/releases/download/${VERSION}/${BINARY}" \
|
||||
-o "${{ runner.temp }}/review-bot"
|
||||
@@ -173,13 +107,8 @@ runs:
|
||||
|
||||
# Verify SHA-256 checksum
|
||||
cd "${{ runner.temp }}"
|
||||
EXPECTED=$(grep -E "^[[:xdigit:]]+[[:space:]]+\*?${BINARY}$" checksums.txt | awk '{print $1}')
|
||||
# sha256sum (GNU) is not available on macOS; use shasum -a 256 on darwin.
|
||||
if [ "${{ steps.version.outputs.os }}" = "darwin" ]; then
|
||||
ACTUAL=$(shasum -a 256 review-bot | awk '{print $1}')
|
||||
else
|
||||
ACTUAL=$(sha256sum review-bot | awk '{print $1}')
|
||||
fi
|
||||
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
|
||||
@@ -193,7 +122,7 @@ runs:
|
||||
fi
|
||||
|
||||
chmod +x "${{ runner.temp }}/review-bot"
|
||||
echo "Installed review-bot-${{ steps.version.outputs.os }}-${{ steps.version.outputs.arch }} ${VERSION} (checksum verified)"
|
||||
echo "Installed review-bot ${VERSION} (checksum verified)"
|
||||
|
||||
- name: Run review
|
||||
shell: bash
|
||||
@@ -211,16 +140,6 @@ runs:
|
||||
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
|
||||
|
||||
+7
-22
@@ -18,10 +18,7 @@ jobs:
|
||||
- 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
|
||||
# Self-review: builds from source since we're pre-release
|
||||
review:
|
||||
runs-on: ubuntu-24.04
|
||||
if: github.event_name == 'pull_request'
|
||||
@@ -31,16 +28,10 @@ jobs:
|
||||
include:
|
||||
- name: sonnet
|
||||
token_secret: SONNET_REVIEW_TOKEN
|
||||
model: anthropic--claude-4.6-sonnet
|
||||
model: gpt-5
|
||||
- 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
|
||||
model: gpt-5-mini
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
- uses: actions/setup-go@v5
|
||||
@@ -53,17 +44,11 @@ jobs:
|
||||
GITEA_REPO: ${{ github.repository }}
|
||||
PR_NUMBER: ${{ github.event.pull_request.number }}
|
||||
REVIEWER_TOKEN: ${{ secrets[matrix.token_secret] }}
|
||||
REVIEWER_NAME: ${{ matrix.name }}
|
||||
LLM_PROVIDER: aicore
|
||||
LLM_BASE_URL: ${{ secrets.LLM_BASE_URL }}
|
||||
LLM_API_KEY: ${{ secrets.LLM_API_KEY }}
|
||||
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/' }}
|
||||
PATTERNS_REPO: "rodin/go-patterns"
|
||||
PATTERNS_FILES: "README.md,patterns/"
|
||||
LLM_TIMEOUT: "600"
|
||||
SYSTEM_PROMPT_FILE: ${{ matrix.system_prompt_file }}
|
||||
run: ./review-bot
|
||||
|
||||
@@ -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}"
|
||||
@@ -69,28 +69,14 @@ jobs:
|
||||
|
||||
echo "Release ID: ${RELEASE_ID}"
|
||||
|
||||
# Upload each asset (idempotent: delete existing asset with same name first)
|
||||
# Upload each asset
|
||||
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)" \
|
||||
"${GITEA_URL}/api/v1/repos/${REPO}/releases/${RELEASE_ID}/assets?name=${filename}" \
|
||||
--data-binary "@${file}"
|
||||
done
|
||||
|
||||
|
||||
@@ -1,2 +1 @@
|
||||
/review-bot
|
||||
coverage.out
|
||||
|
||||
+1
-19
@@ -2,26 +2,8 @@
|
||||
|
||||
## Language & Dependencies
|
||||
|
||||
- Go standard library only — no external dependencies.
|
||||
- Target the latest stable Go release.
|
||||
- **STRICT ALLOWLIST:** Only packages listed below may be imported. No exceptions.
|
||||
|
||||
### Approved Third-Party Packages
|
||||
|
||||
| Package | Use Case | Scope |
|
||||
|---------|----------|-------|
|
||||
| `github.com/goccy/go-yaml` | YAML parsing and AST inspection (subpkgs: `ast`, `parser`) | 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.**
|
||||
|
||||
Transitive dependencies of approved packages are automatically allowed.
|
||||
|
||||
To request a new dependency:
|
||||
1. Open a PR that ONLY updates this table
|
||||
2. Requires explicit approval from Aaron
|
||||
3. After merge, a separate PR may use the package
|
||||
|
||||
*Enforcement: `scripts/check-deps.sh` parses this table — update only here.*
|
||||
|
||||
## Error Handling
|
||||
|
||||
|
||||
@@ -1,26 +0,0 @@
|
||||
.PHONY: build test test-integration lint clean coverage check-deps precommit
|
||||
|
||||
build:
|
||||
go build -o review-bot ./cmd/review-bot/
|
||||
|
||||
test:
|
||||
go test ./...
|
||||
|
||||
test-integration:
|
||||
go test -tags integration -v ./cmd/review-bot/
|
||||
|
||||
lint:
|
||||
go vet ./...
|
||||
|
||||
check-deps:
|
||||
@./scripts/check-deps.sh
|
||||
|
||||
clean:
|
||||
rm -f review-bot
|
||||
|
||||
coverage:
|
||||
go test -coverprofile=coverage.out ./...
|
||||
go tool cover -func=coverage.out
|
||||
|
||||
# Precommit runs all checks required before pushing
|
||||
precommit: check-deps lint test
|
||||
@@ -1,284 +1,17 @@
|
||||
# review-bot
|
||||
|
||||
AI-powered code review bot for Gitea pull requests. Fetches diff + context, sends to an LLM, and posts a structured review (APPROVE / REQUEST_CHANGES) back to the PR.
|
||||
Automated code review bot for Gitea. Fetches a pull request diff, sends it to an LLM for analysis, and posts a structured review back to the PR.
|
||||
|
||||
## Features
|
||||
|
||||
- **Multi-provider**: OpenAI-compatible, Anthropic Messages API, and SAP AI Core
|
||||
- **Context-aware**: Fetches full file content, conventions, language patterns, CI status
|
||||
- **Smart budget**: Automatically trims context to fit model token limits
|
||||
- **Idempotent reviews**: Posts new review, then cleans up stale ones (one review per bot)
|
||||
- **Custom prompts**: Load additional instructions from a file (e.g. security-focused review)
|
||||
- **Minimal dependencies**: Go stdlib + `gopkg.in/yaml.v3` only
|
||||
- Fetches PR metadata, diff, and CI status from Gitea API
|
||||
- Sends context-rich prompts to any OpenAI-compatible LLM
|
||||
- Parses structured JSON review responses
|
||||
- Posts formatted reviews (APPROVE / REQUEST_CHANGES) back to Gitea
|
||||
- Supports custom coding conventions via repo files
|
||||
- Zero external dependencies — Go stdlib only
|
||||
|
||||
## Quick Start: Composite Action
|
||||
|
||||
The easiest way to use review-bot in your Gitea CI:
|
||||
|
||||
```yaml
|
||||
# .gitea/workflows/review.yml
|
||||
name: Review
|
||||
on:
|
||||
pull_request:
|
||||
types: [opened, synchronize]
|
||||
|
||||
jobs:
|
||||
review:
|
||||
runs-on: ubuntu-24.04
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
- uses: https://gitea.weiker.me/rodin/review-bot/.gitea/actions/review@v0.1.0
|
||||
with:
|
||||
reviewer-token: ${{ secrets.REVIEW_TOKEN }}
|
||||
reviewer-name: code-review
|
||||
llm-base-url: ${{ secrets.LLM_BASE_URL }}
|
||||
llm-api-key: ${{ secrets.LLM_API_KEY }}
|
||||
llm-model: gpt-4.1
|
||||
```
|
||||
|
||||
That's it. Every PR gets an automated review.
|
||||
|
||||
## Examples
|
||||
|
||||
### Single reviewer with conventions
|
||||
|
||||
```yaml
|
||||
jobs:
|
||||
review:
|
||||
runs-on: ubuntu-24.04
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
- uses: https://gitea.weiker.me/rodin/review-bot/.gitea/actions/review@v0.1.0
|
||||
with:
|
||||
reviewer-token: ${{ secrets.REVIEW_TOKEN }}
|
||||
reviewer-name: reviewer
|
||||
llm-base-url: ${{ secrets.LLM_BASE_URL }}
|
||||
llm-api-key: ${{ secrets.LLM_API_KEY }}
|
||||
llm-model: gpt-4.1
|
||||
conventions-file: CONVENTIONS.md
|
||||
timeout: '600'
|
||||
```
|
||||
|
||||
### Two reviewers with different models (diversity of opinion)
|
||||
|
||||
```yaml
|
||||
jobs:
|
||||
review:
|
||||
runs-on: ubuntu-24.04
|
||||
strategy:
|
||||
matrix:
|
||||
include:
|
||||
- name: gpt
|
||||
model: gpt-4.1
|
||||
token_secret: GPT_REVIEW_TOKEN
|
||||
- name: claude
|
||||
model: claude-sonnet-4-20250514
|
||||
token_secret: CLAUDE_REVIEW_TOKEN
|
||||
provider: anthropic
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
- uses: https://gitea.weiker.me/rodin/review-bot/.gitea/actions/review@v0.1.0
|
||||
with:
|
||||
reviewer-token: ${{ secrets[matrix.token_secret] }}
|
||||
reviewer-name: ${{ matrix.name }}
|
||||
llm-base-url: ${{ secrets.LLM_BASE_URL }}
|
||||
llm-api-key: ${{ secrets.LLM_API_KEY }}
|
||||
llm-model: ${{ matrix.model }}
|
||||
llm-provider: ${{ matrix.provider }}
|
||||
conventions-file: CONVENTIONS.md
|
||||
```
|
||||
|
||||
Each reviewer posts independently and only cleans up its own stale reviews.
|
||||
|
||||
### Multiple review types from a single bot account
|
||||
|
||||
Use the same Gitea token but different `reviewer-name` values to run specialized reviews without needing multiple bot accounts:
|
||||
|
||||
```yaml
|
||||
jobs:
|
||||
review:
|
||||
runs-on: ubuntu-24.04
|
||||
strategy:
|
||||
matrix:
|
||||
include:
|
||||
- name: code-quality
|
||||
model: gpt-4.1
|
||||
- name: security
|
||||
model: gpt-4.1
|
||||
system_prompt_file: .review/SECURITY.md
|
||||
- name: performance
|
||||
model: gpt-4.1
|
||||
system_prompt_file: .review/PERFORMANCE.md
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
- uses: https://gitea.weiker.me/rodin/review-bot/.gitea/actions/review@v0.1.0
|
||||
with:
|
||||
reviewer-token: ${{ secrets.REVIEW_TOKEN }}
|
||||
reviewer-name: ${{ matrix.name }}
|
||||
llm-base-url: ${{ secrets.LLM_BASE_URL }}
|
||||
llm-api-key: ${{ secrets.LLM_API_KEY }}
|
||||
llm-model: ${{ matrix.model }}
|
||||
system-prompt-file: ${{ matrix.system_prompt_file }}
|
||||
```
|
||||
|
||||
The sentinel `<!-- review-bot:security -->` ensures the security review only replaces previous security reviews, never the code-quality or performance reviews.
|
||||
|
||||
### With language patterns from another repo
|
||||
|
||||
```yaml
|
||||
- uses: https://gitea.weiker.me/rodin/review-bot/.gitea/actions/review@v0.1.0
|
||||
with:
|
||||
reviewer-token: ${{ secrets.REVIEW_TOKEN }}
|
||||
reviewer-name: reviewer
|
||||
llm-base-url: ${{ secrets.LLM_BASE_URL }}
|
||||
llm-api-key: ${{ secrets.LLM_API_KEY }}
|
||||
llm-model: gpt-4.1
|
||||
conventions-file: CLAUDE.md
|
||||
patterns-repo: rodin/go-patterns,rodin/kubernetes-conventions
|
||||
patterns-files: "README.md,patterns/"
|
||||
```
|
||||
|
||||
Pattern repos are fetched at review time. The reviewer uses them as criteria for idiomatic code.
|
||||
|
||||
### Dry run (test without posting)
|
||||
|
||||
```yaml
|
||||
- uses: https://gitea.weiker.me/rodin/review-bot/.gitea/actions/review@v0.1.0
|
||||
with:
|
||||
reviewer-token: ${{ secrets.REVIEW_TOKEN }}
|
||||
reviewer-name: test
|
||||
llm-base-url: ${{ secrets.LLM_BASE_URL }}
|
||||
llm-api-key: ${{ secrets.LLM_API_KEY }}
|
||||
llm-model: gpt-4.1
|
||||
dry-run: 'true'
|
||||
```
|
||||
|
||||
Prints the review to CI logs without posting to the PR. Useful for testing prompt changes.
|
||||
|
||||
### Using Anthropic directly
|
||||
|
||||
```yaml
|
||||
- uses: https://gitea.weiker.me/rodin/review-bot/.gitea/actions/review@v0.1.0
|
||||
with:
|
||||
reviewer-token: ${{ secrets.REVIEW_TOKEN }}
|
||||
reviewer-name: claude
|
||||
llm-base-url: https://api.anthropic.com
|
||||
llm-api-key: ${{ secrets.ANTHROPIC_API_KEY }}
|
||||
llm-model: claude-sonnet-4-20250514
|
||||
llm-provider: anthropic
|
||||
```
|
||||
|
||||
### Using SAP AI Core
|
||||
|
||||
For SAP environments with AI Core deployments, use the `aicore` provider for native authentication:
|
||||
|
||||
```yaml
|
||||
- uses: https://gitea.weiker.me/rodin/review-bot/.gitea/actions/review@v0.1.0
|
||||
with:
|
||||
reviewer-token: ${{ secrets.REVIEW_TOKEN }}
|
||||
reviewer-name: aicore-review
|
||||
llm-model: anthropic--claude-4.6-sonnet # or gpt-5
|
||||
llm-provider: aicore
|
||||
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: default
|
||||
```
|
||||
|
||||
AI Core handles OAuth token management and deployment discovery automatically. Model names must match the deployment name in AI Core (e.g. `anthropic--claude-4.6-sonnet`, `gpt-5`).
|
||||
|
||||
## Action Inputs
|
||||
|
||||
| Input | Required | Default | Description |
|
||||
|-------|----------|---------|-------------|
|
||||
| `reviewer-token` | Yes | — | Gitea token for posting reviews (needs `write:issue`, `write:repository`) |
|
||||
| `reviewer-name` | No | `""` | Logical identity for this reviewer. Used as sentinel for idempotent cleanup. Set this when running multiple review bots on the same PR. |
|
||||
| `llm-base-url` | No* | `""` | LLM API base URL (required unless using aicore provider) |
|
||||
| `llm-api-key` | No* | `""` | LLM API key (required unless using aicore provider) |
|
||||
| `llm-model` | Yes | — | Model name |
|
||||
| `llm-provider` | No | `openai` | API provider: `openai`, `anthropic`, or `aicore` |
|
||||
| `aicore-client-id` | No** | `""` | SAP AI Core client ID |
|
||||
| `aicore-client-secret` | No** | `""` | SAP AI Core client secret |
|
||||
| `aicore-auth-url` | No** | `""` | SAP AI Core authentication URL |
|
||||
| `aicore-api-url` | No** | `""` | SAP AI Core API URL |
|
||||
| `aicore-resource-group` | No | `default` | SAP AI Core resource group |
|
||||
| `conventions-file` | No | `""` | Path to coding conventions file in the repo |
|
||||
| `patterns-repo` | No | `""` | Comma-separated repos with language patterns (e.g. `rodin/go-patterns`) |
|
||||
| `patterns-files` | No | `README.md` | Files/directories to fetch from pattern repos |
|
||||
| `system-prompt-file` | No | `""` | Local file with additional system prompt instructions |
|
||||
| `persona` | No | `""` | Built-in persona name (security, architect, docs) |
|
||||
| `persona-file` | No | `""` | Path to persona file (YAML or JSON) with custom review focus |
|
||||
| `temperature` | No | `0` | LLM temperature (0 = server default) |
|
||||
| `timeout` | No | `300` | LLM request timeout in seconds |
|
||||
| `dry-run` | No | `false` | Print review to stdout instead of posting |
|
||||
| `update-existing` | No | `true` | Delete previous review from same bot before posting. Accepts: true/1/yes or false/0/no |
|
||||
| `version` | No | `latest` | review-bot version to install |
|
||||
|
||||
*Required for `openai` and `anthropic` providers, not for `aicore`.
|
||||
**Required only for `aicore` provider.
|
||||
|
||||
## Runner Requirements
|
||||
|
||||
The composite action requires these tools on the runner:
|
||||
|
||||
| Tool | Used For |
|
||||
|------|----------|
|
||||
| `python3` | JSON parsing during version detection |
|
||||
| `sha256sum` | Checksum verification of downloaded binary |
|
||||
| `curl` | Downloading releases and querying the API |
|
||||
|
||||
All three are pre-installed on `ubuntu-*` runners (e.g. `ubuntu-24.04`). If you use a custom runner image, ensure these are available.
|
||||
|
||||
## How Review Cleanup Works
|
||||
|
||||
When `reviewer-name` is set, the bot embeds a hidden sentinel in each review:
|
||||
|
||||
```html
|
||||
<!-- review-bot:code-review -->
|
||||
```
|
||||
|
||||
On the next run, it finds and deletes any review containing its own sentinel (except the one it just posted). This means:
|
||||
|
||||
- **One review per bot per PR** — no clutter from repeated pushes
|
||||
- **Multiple bots coexist** — each only cleans up its own reviews
|
||||
- **Same token, different roles** — a single bot account can post "code-review" and "security" reviews without conflict
|
||||
- **No extra permissions** — identity comes from the sentinel, not the API
|
||||
|
||||
If `reviewer-name` is empty, cleanup is skipped (reviews stack like before).
|
||||
|
||||
### Shared Token: Worst-Wins Behavior
|
||||
|
||||
When multiple review types share the same Gitea bot account (e.g. code-quality and security), Gitea determines the user's approval state from their **most recent review**. This creates a race condition: if security finds issues (REQUEST_CHANGES) but code-quality finishes last (APPROVE), the PR appears approved.
|
||||
|
||||
review-bot handles this automatically with **worst-wins reconciliation**: before posting, each job checks whether any sibling review from the same user already has REQUEST_CHANGES. If so and this job would post APPROVE, it posts as REQUEST_CHANGES instead — maintaining the block. This ensures the PR stays blocked until all checks pass, regardless of execution order.
|
||||
|
||||
**If you need independent approval/block per review type**, use separate Gitea bot accounts with their own tokens.
|
||||
|
||||
## Custom Review Prompts
|
||||
|
||||
Use `system-prompt-file` to specialize the review focus. The file contents are appended to the base system prompt as "Additional Review Instructions."
|
||||
|
||||
Example `SECURITY_REVIEW.md`:
|
||||
|
||||
```markdown
|
||||
You are performing a security-focused code review.
|
||||
|
||||
Focus areas:
|
||||
- Injection attacks (SQL, command, path traversal, template)
|
||||
- Authentication/Authorization (missing checks, privilege escalation)
|
||||
- Secrets exposure (hardcoded credentials, tokens in logs)
|
||||
- Input validation (unsanitized input, unsafe deserialization)
|
||||
- Race conditions (TOCTOU, unsynchronized shared state)
|
||||
|
||||
Rules:
|
||||
- Only report findings with security implications
|
||||
- Ignore style, naming, and general code quality
|
||||
- MAJOR = exploitable vulnerability, MINOR = hardening opportunity, NIT = theoretical risk
|
||||
- If no security-relevant changes exist, APPROVE with empty findings
|
||||
```
|
||||
|
||||
## CLI Usage
|
||||
## Usage
|
||||
|
||||
```bash
|
||||
review-bot \
|
||||
@@ -286,190 +19,73 @@ review-bot \
|
||||
--repo owner/name \
|
||||
--pr 42 \
|
||||
--reviewer-token "$GITEA_TOKEN" \
|
||||
--reviewer-name "code-review" \
|
||||
--llm-base-url https://api.openai.com/v1 \
|
||||
--llm-api-key "$OPENAI_API_KEY" \
|
||||
--llm-model gpt-4.1 \
|
||||
--conventions-file CONVENTIONS.md
|
||||
--llm-model gpt-4 \
|
||||
--reviewer-name "Sonnet" \
|
||||
--conventions-file CONVENTIONS.md \
|
||||
--dry-run
|
||||
```
|
||||
|
||||
## Environment Variables
|
||||
|
||||
All flags have environment variable equivalents:
|
||||
All flags can be set via environment variables:
|
||||
|
||||
| Flag | Env Var |
|
||||
|------|---------|
|
||||
| `--gitea-url` | `GITEA_URL` |
|
||||
| `--repo` | `GITEA_REPO` |
|
||||
| `--pr` | `PR_NUMBER` |
|
||||
| `--reviewer-token` | `REVIEWER_TOKEN` |
|
||||
| `--reviewer-name` | `REVIEWER_NAME` |
|
||||
| `--llm-base-url` | `LLM_BASE_URL` |
|
||||
| `--llm-api-key` | `LLM_API_KEY` |
|
||||
| `--llm-model` | `LLM_MODEL` |
|
||||
| `--llm-provider` | `LLM_PROVIDER` |
|
||||
| `--conventions-file` | `CONVENTIONS_FILE` |
|
||||
| `--patterns-repo` | `PATTERNS_REPO` |
|
||||
| `--patterns-files` | `PATTERNS_FILES` |
|
||||
| `--system-prompt-file` | `SYSTEM_PROMPT_FILE` |
|
||||
| `--llm-temperature` | `LLM_TEMPERATURE` |
|
||||
| `--llm-timeout` | `LLM_TIMEOUT` |
|
||||
| `--update-existing` | `UPDATE_EXISTING` |
|
||||
| Flag | Env Var | Required | Description |
|
||||
|------|---------|----------|-------------|
|
||||
| `--gitea-url` | `GITEA_URL` | Yes | Gitea instance base URL |
|
||||
| `--repo` | `GITEA_REPO` | Yes | Repository in `owner/name` format |
|
||||
| `--pr` | `PR_NUMBER` | Yes | Pull request number |
|
||||
| `--reviewer-token` | `REVIEWER_TOKEN` | Yes | Gitea API token for posting reviews |
|
||||
| `--llm-base-url` | `LLM_BASE_URL` | Yes | OpenAI-compatible API base URL |
|
||||
| `--llm-api-key` | `LLM_API_KEY` | Yes | LLM API key |
|
||||
| `--llm-model` | `LLM_MODEL` | Yes | Model identifier |
|
||||
| `--reviewer-name` | `REVIEWER_NAME` | No | Display name in review footer |
|
||||
| `--conventions-file` | `CONVENTIONS_FILE` | No | Path to conventions file in repo |
|
||||
| `--dry-run` | — | No | Print review to stdout instead of posting |
|
||||
|
||||
## Setup
|
||||
## Adding to a Gitea Repository
|
||||
|
||||
1. **Create a Gitea bot account** (e.g. `review-bot`)
|
||||
2. **Generate a token** with scopes: `write:issue`, `write:repository`
|
||||
3. **Add secrets** to your Gitea repo (Settings → Actions → Secrets):
|
||||
- `REVIEW_TOKEN` — the bot's Gitea token
|
||||
- `LLM_BASE_URL` — your LLM endpoint
|
||||
- `LLM_API_KEY` — your LLM key
|
||||
4. **Add the workflow** (see Quick Start above)
|
||||
1. Build the binary or use the CI workflow approach (build in CI).
|
||||
|
||||
### Token Scopes Required
|
||||
2. Add secrets to your Gitea repo (Settings → Actions → Secrets):
|
||||
- `SONNET_REVIEW_TOKEN` — Gitea token for the Sonnet reviewer account
|
||||
- `GPT_REVIEW_TOKEN` — Gitea token for the GPT reviewer account
|
||||
- `LLM_BASE_URL` — Your LLM API endpoint
|
||||
- `LLM_API_KEY` — Your LLM API key
|
||||
|
||||
| Scope | Purpose |
|
||||
|-------|--------|
|
||||
| `write:issue` | Post and delete reviews |
|
||||
| `write:repository` | Read PR diffs, file content, commit statuses |
|
||||
| `read:user` | Self-request as reviewer (optional but recommended) |
|
||||
3. Copy `.gitea/workflows/ci.yml` to your repo (or adapt it).
|
||||
|
||||
Without `read:user`, the bot still works but cannot add itself to the PR's reviewer list.
|
||||
4. On every PR, the bot will:
|
||||
- Run tests and vet
|
||||
- Build review-bot
|
||||
- Post reviews from each configured LLM reviewer
|
||||
|
||||
## Development
|
||||
|
||||
```bash
|
||||
go test ./... # Unit tests
|
||||
go vet ./... # Static analysis
|
||||
# Run tests
|
||||
go test ./...
|
||||
|
||||
# Run vet
|
||||
go vet ./...
|
||||
|
||||
# Build
|
||||
go build -o review-bot ./cmd/review-bot
|
||||
|
||||
# Integration tests (requires env vars set)
|
||||
# Integration tests (requires env vars)
|
||||
go test -tags=integration ./...
|
||||
```
|
||||
|
||||
## Architecture
|
||||
|
||||
```
|
||||
cmd/review-bot/ CLI entrypoint + orchestration
|
||||
gitea/ Gitea API client (reviews, PRs, files)
|
||||
llm/ Multi-provider LLM client (OpenAI + Anthropic)
|
||||
cmd/review-bot/ CLI entrypoint
|
||||
gitea/ Gitea API client
|
||||
llm/ OpenAI-compatible LLM client
|
||||
review/ Prompt building, response parsing, formatting
|
||||
budget/ Token estimation + context trimming
|
||||
```
|
||||
|
||||
## License
|
||||
|
||||
MIT
|
||||
|
||||
## Review Personas
|
||||
|
||||
Personas provide role-based review specialization. Instead of generic code review, each persona focuses on a specific domain (security, architecture, documentation) with tailored prompts and severity calibration.
|
||||
|
||||
### Built-in Personas
|
||||
|
||||
| Persona | Focus |
|
||||
|---------|-------|
|
||||
| `security` | Vulnerabilities, auth bypass, secrets exposure, injection attacks |
|
||||
| `architect` | Design patterns, code organization, API contracts, testability |
|
||||
| `docs` | Documentation quality, API clarity, error messages |
|
||||
|
||||
### Using Built-in Personas
|
||||
|
||||
```yaml
|
||||
- uses: rodin/review-bot/.gitea/actions/review@v1
|
||||
with:
|
||||
reviewer-name: security
|
||||
persona: security
|
||||
llm-model: claude-opus-4-20250514 # Security benefits from strong reasoning
|
||||
...
|
||||
```
|
||||
|
||||
### Multiple Personas in Parallel
|
||||
|
||||
```yaml
|
||||
jobs:
|
||||
review:
|
||||
strategy:
|
||||
matrix:
|
||||
include:
|
||||
- name: security
|
||||
persona: security
|
||||
- name: architect
|
||||
persona: architect
|
||||
steps:
|
||||
- uses: rodin/review-bot/.gitea/actions/review@v1
|
||||
with:
|
||||
reviewer-name: ${{ matrix.name }}
|
||||
persona: ${{ matrix.persona }}
|
||||
...
|
||||
```
|
||||
|
||||
Each persona posts independently with its own sentinel, so reviews don't interfere.
|
||||
|
||||
|
||||
### Custom Personas
|
||||
|
||||
Create a YAML file with your domain-specific review focus:
|
||||
|
||||
```yaml
|
||||
# .review/personas/trading.yaml
|
||||
name: trading
|
||||
display_name: Trading Domain Expert
|
||||
|
||||
identity: |
|
||||
You are a trading systems expert reviewing code for correctness.
|
||||
|
||||
Your expertise:
|
||||
- Order lifecycle and state machines
|
||||
- Fill handling and partial fills
|
||||
- Position tracking and P&L calculations
|
||||
- Event sourcing invariants
|
||||
|
||||
focus:
|
||||
- Order state machine correctness
|
||||
- Fill handling edge cases (partial, overfill)
|
||||
- Position and P&L calculation accuracy
|
||||
- Event replay determinism
|
||||
- Decimal precision for money
|
||||
|
||||
ignore:
|
||||
- Code style
|
||||
- General performance
|
||||
- Documentation formatting
|
||||
|
||||
severity:
|
||||
major: "Bugs that cause incorrect positions, fills, or money calculations"
|
||||
minor: "Edge cases that could cause issues under unusual conditions"
|
||||
nit: "Clarity improvements for domain logic"
|
||||
```
|
||||
|
||||
Use it in CI:
|
||||
|
||||
```yaml
|
||||
- uses: rodin/review-bot/.gitea/actions/review@v1
|
||||
with:
|
||||
reviewer-name: trading
|
||||
persona-file: .review/personas/trading.yaml
|
||||
...
|
||||
```
|
||||
|
||||
YAML is the recommended format for personas because it supports:
|
||||
- Multi-line strings with `|` blocks (cleaner identity definitions)
|
||||
- Comments for documentation
|
||||
- More readable arrays and nested structures
|
||||
|
||||
JSON is also supported for backwards compatibility—just use `.json` extension.
|
||||
|
||||
|
||||
### Persona vs system-prompt-file
|
||||
|
||||
| Feature | `persona` / `persona-file` | `system-prompt-file` |
|
||||
|---------|---------------------------|----------------------|
|
||||
| Replaces base prompt | Yes | No (appends) |
|
||||
| Structured format | Yes (YAML/JSON) | No (freeform) |
|
||||
| Focus/ignore lists | Yes | Manual |
|
||||
| Severity calibration | Yes | Manual |
|
||||
| Header display name | Yes | No |
|
||||
| Built-in options | Yes | No |
|
||||
|
||||
Use personas for domain-specialized reviews. Use `system-prompt-file` for minor tweaks to the generic review.
|
||||
|
||||
@@ -1,18 +0,0 @@
|
||||
You are performing a security-focused code review. Your primary concern is identifying vulnerabilities, not general code quality.
|
||||
|
||||
Focus areas:
|
||||
- **Injection attacks**: SQL injection, command injection, path traversal, template injection
|
||||
- **Authentication/Authorization**: Missing auth checks, privilege escalation, IDOR
|
||||
- **Secrets exposure**: Hardcoded credentials, API keys in code, tokens in logs
|
||||
- **Input validation**: Untrusted input used without sanitization, unsafe deserialization
|
||||
- **Cryptography**: Weak algorithms, predictable randomness, improper key management
|
||||
- **Error handling**: Information leakage in error messages, stack traces exposed
|
||||
- **Dependencies**: Known vulnerable patterns, unsafe use of external libraries
|
||||
- **Race conditions**: TOCTOU bugs, unsynchronized shared state
|
||||
- **Resource exhaustion**: Unbounded allocations, missing timeouts, denial-of-service vectors
|
||||
|
||||
Rules for this review:
|
||||
- Only report findings with actual security implications. Ignore style, naming, and general code quality.
|
||||
- Severity mapping: MAJOR = exploitable vulnerability or data exposure. MINOR = defense-in-depth improvement or hardening opportunity. NIT = theoretical concern with low practical risk.
|
||||
- If the code has no security-relevant changes, APPROVE with an empty findings list.
|
||||
- Do not duplicate findings that a standard code review would catch (logic bugs, missing error checks) unless they have a security dimension.
|
||||
+14
-14
@@ -8,7 +8,6 @@ package budget
|
||||
import (
|
||||
"fmt"
|
||||
"strings"
|
||||
"unicode/utf8"
|
||||
)
|
||||
|
||||
// modelLimit pairs a model name prefix with its context window size.
|
||||
@@ -39,7 +38,7 @@ const diffTooLargeMarker = "... [diff too large for context window — review ma
|
||||
const userMetaTruncMarker = "\n... [description truncated] ..."
|
||||
|
||||
// EstimateTokens estimates the number of tokens in a string.
|
||||
// Uses the rough heuristic of ~4 bytes per token, which is
|
||||
// Uses the rough heuristic of ~4 characters per token, which is
|
||||
// conservative for English text and code.
|
||||
func EstimateTokens(s string) int {
|
||||
return len(s) / 4
|
||||
@@ -65,7 +64,7 @@ type Sections struct {
|
||||
Conventions string // Repo conventions (trimmed second)
|
||||
FileContext string // Full file content (trimmed third)
|
||||
Diff string // The actual diff (trimmed last, only truncated)
|
||||
UserMeta string // PR title, description, CI status (truncated only if base exceeds budget)
|
||||
UserMeta string // PR title, description, CI status (never trimmed)
|
||||
}
|
||||
|
||||
// Result holds the trimmed content and metadata about what was dropped.
|
||||
@@ -154,11 +153,7 @@ func Fit(model string, sections Sections) Result {
|
||||
removed := EstimateTokens(sections.Diff) - diffBudget
|
||||
trimmed = append(trimmed, fmt.Sprintf("diff truncated (~%dK tokens removed)", removed/1000))
|
||||
if maxChars > 0 {
|
||||
if diffBudget >= markerBudget {
|
||||
sections.Diff = truncateUTF8(sections.Diff, maxChars) + diffTruncMarker
|
||||
} else {
|
||||
sections.Diff = truncateUTF8(sections.Diff, maxChars)
|
||||
}
|
||||
sections.Diff = truncateUTF8(sections.Diff, maxChars) + diffTruncMarker
|
||||
} else {
|
||||
sections.Diff = diffTooLargeMarker
|
||||
}
|
||||
@@ -193,11 +188,9 @@ func buildResult(s Sections, trimmed []string, estTokens int) Result {
|
||||
usr.WriteString(s.FileContext)
|
||||
usr.WriteString("\n")
|
||||
}
|
||||
if s.Diff != "" {
|
||||
usr.WriteString("\n### Diff (changes to review)\n\n```diff\n")
|
||||
usr.WriteString(s.Diff)
|
||||
usr.WriteString("\n```\n")
|
||||
}
|
||||
usr.WriteString("\n### Diff (changes to review)\n\n```diff\n")
|
||||
usr.WriteString(s.Diff)
|
||||
usr.WriteString("\n```\n")
|
||||
|
||||
if len(trimmed) > 0 {
|
||||
usr.WriteString("\n⚠️ Note: Context was trimmed to fit model limits. Dropped: ")
|
||||
@@ -219,8 +212,15 @@ func truncateUTF8(s string, maxBytes int) string {
|
||||
if len(s) <= maxBytes {
|
||||
return s
|
||||
}
|
||||
for maxBytes > 0 && !utf8.RuneStart(s[maxBytes]) {
|
||||
// Walk backwards from maxBytes to find a valid UTF-8 boundary
|
||||
for maxBytes > 0 && !isUTF8Start(s[maxBytes]) {
|
||||
maxBytes--
|
||||
}
|
||||
return s[:maxBytes]
|
||||
}
|
||||
|
||||
// isUTF8Start returns true if b is a valid start byte for a UTF-8 sequence
|
||||
// (single-byte ASCII or multi-byte lead byte, not a continuation byte).
|
||||
func isUTF8Start(b byte) bool {
|
||||
return b&0xC0 != 0x80
|
||||
}
|
||||
|
||||
@@ -1,161 +0,0 @@
|
||||
//go:build integration
|
||||
|
||||
package main
|
||||
|
||||
import (
|
||||
"context"
|
||||
"os"
|
||||
"strconv"
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"gitea.weiker.me/rodin/review-bot/gitea"
|
||||
"gitea.weiker.me/rodin/review-bot/llm"
|
||||
"gitea.weiker.me/rodin/review-bot/review"
|
||||
)
|
||||
|
||||
// Integration test requires a running Gitea instance and LLM endpoint.
|
||||
// Set environment variables:
|
||||
//
|
||||
// INTEGRATION_GITEA_URL - Gitea base URL
|
||||
// INTEGRATION_GITEA_TOKEN - Gitea API token with repo access
|
||||
// INTEGRATION_GITEA_REPO - owner/repo with an open PR
|
||||
// INTEGRATION_PR_NUMBER - PR number to test against
|
||||
// INTEGRATION_LLM_BASE_URL - LLM API base URL
|
||||
// INTEGRATION_LLM_API_KEY - LLM API key
|
||||
// INTEGRATION_LLM_MODEL - Model name
|
||||
func TestIntegration_FullReviewFlow(t *testing.T) {
|
||||
giteaURL := os.Getenv("INTEGRATION_GITEA_URL")
|
||||
giteaToken := os.Getenv("INTEGRATION_GITEA_TOKEN")
|
||||
giteaRepo := os.Getenv("INTEGRATION_GITEA_REPO")
|
||||
prNumStr := os.Getenv("INTEGRATION_PR_NUMBER")
|
||||
llmBaseURL := os.Getenv("INTEGRATION_LLM_BASE_URL")
|
||||
llmAPIKey := os.Getenv("INTEGRATION_LLM_API_KEY")
|
||||
llmModel := os.Getenv("INTEGRATION_LLM_MODEL")
|
||||
|
||||
if giteaURL == "" || giteaToken == "" || giteaRepo == "" || prNumStr == "" ||
|
||||
llmBaseURL == "" || llmAPIKey == "" || llmModel == "" {
|
||||
t.Skip("Integration test env vars not set, skipping")
|
||||
}
|
||||
|
||||
prNumber, err := strconv.Atoi(prNumStr)
|
||||
if err != nil {
|
||||
t.Fatalf("Invalid PR number %q: %v", prNumStr, err)
|
||||
}
|
||||
|
||||
// Parse owner/repo
|
||||
parts := strings.SplitN(giteaRepo, "/", 2)
|
||||
if len(parts) != 2 {
|
||||
t.Fatalf("Invalid repo format %q", giteaRepo)
|
||||
}
|
||||
owner, repoName := parts[0], parts[1]
|
||||
if owner == "" || repoName == "" {
|
||||
t.Fatalf("Invalid repo format %q", giteaRepo)
|
||||
}
|
||||
|
||||
ctx := context.Background()
|
||||
|
||||
// Step 1: Fetch PR
|
||||
giteaClient := gitea.NewClient(giteaURL, giteaToken)
|
||||
pr, err := giteaClient.GetPullRequest(ctx, owner, repoName, prNumber)
|
||||
if err != nil {
|
||||
t.Fatalf("GetPullRequest: %v", err)
|
||||
}
|
||||
t.Logf("PR: %s (sha: %s)", pr.Title, pr.Head.Sha)
|
||||
|
||||
// Step 2: Fetch diff
|
||||
diff, err := giteaClient.GetPullRequestDiff(ctx, owner, repoName, prNumber)
|
||||
if err != nil {
|
||||
t.Fatalf("GetPullRequestDiff: %v", err)
|
||||
}
|
||||
if diff == "" {
|
||||
t.Fatal("diff is empty")
|
||||
}
|
||||
t.Logf("Diff size: %d bytes", len(diff))
|
||||
|
||||
// Step 3: Build prompts
|
||||
systemPrompt := review.BuildSystemPrompt("", "")
|
||||
userPrompt := review.BuildUserPrompt(pr.Title, pr.Body, diff, "", true, "")
|
||||
|
||||
// Step 4: Call LLM
|
||||
llmClient := llm.NewClient(llmBaseURL, llmAPIKey, llmModel)
|
||||
response, err := llmClient.Complete(ctx, []llm.Message{
|
||||
{Role: "system", Content: systemPrompt},
|
||||
{Role: "user", Content: userPrompt},
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("LLM Complete: %v", err)
|
||||
}
|
||||
t.Logf("LLM response: %d bytes", len(response))
|
||||
|
||||
// Step 5: Parse response
|
||||
result, err := review.ParseResponse(response)
|
||||
if err != nil {
|
||||
t.Fatalf("ParseResponse: %v", err)
|
||||
}
|
||||
t.Logf("Verdict: %s, Findings: %d", result.Verdict, len(result.Findings))
|
||||
|
||||
// Step 6: Format (dry-run validation)
|
||||
body := review.FormatMarkdown(result, "integration-test")
|
||||
if body == "" {
|
||||
t.Fatal("formatted review body is empty")
|
||||
}
|
||||
t.Logf("Review body:\n%s", body)
|
||||
}
|
||||
|
||||
func TestIntegration_PostAndCleanup(t *testing.T) {
|
||||
giteaURL := os.Getenv("INTEGRATION_GITEA_URL")
|
||||
giteaToken := os.Getenv("INTEGRATION_GITEA_TOKEN")
|
||||
giteaRepo := os.Getenv("INTEGRATION_GITEA_REPO")
|
||||
prNumStr := os.Getenv("INTEGRATION_PR_NUMBER")
|
||||
|
||||
if giteaURL == "" || giteaToken == "" || giteaRepo == "" || prNumStr == "" {
|
||||
t.Skip("Integration test env vars not set, skipping")
|
||||
}
|
||||
|
||||
prNumber, err := strconv.Atoi(prNumStr)
|
||||
if err != nil {
|
||||
t.Fatalf("Invalid PR number %q: %v", prNumStr, err)
|
||||
}
|
||||
|
||||
parts := strings.SplitN(giteaRepo, "/", 2)
|
||||
if len(parts) != 2 {
|
||||
t.Fatalf("Invalid repo format %q", giteaRepo)
|
||||
}
|
||||
owner, repoName := parts[0], parts[1]
|
||||
|
||||
ctx := context.Background()
|
||||
giteaClient := gitea.NewClient(giteaURL, giteaToken)
|
||||
|
||||
// Post a test review
|
||||
sentinel := "<!-- review-bot:integration-test -->"
|
||||
testBody := "# Integration Test Review\n\nThis is a test review.\n\n" + sentinel
|
||||
posted, err := giteaClient.PostReview(ctx, owner, repoName, prNumber, "COMMENT", testBody, "", nil)
|
||||
if err != nil {
|
||||
t.Fatalf("PostReview: %v", err)
|
||||
}
|
||||
t.Logf("Posted review ID: %d", posted.ID)
|
||||
|
||||
// Verify it appears in listing
|
||||
reviews, err := giteaClient.ListReviews(ctx, owner, repoName, prNumber)
|
||||
if err != nil {
|
||||
t.Fatalf("ListReviews: %v", err)
|
||||
}
|
||||
|
||||
found := false
|
||||
for _, r := range reviews {
|
||||
if r.ID == posted.ID && strings.Contains(r.Body, sentinel) {
|
||||
found = true
|
||||
break
|
||||
}
|
||||
}
|
||||
if !found {
|
||||
t.Error("posted review not found in listing")
|
||||
}
|
||||
|
||||
// Cleanup: delete the test review
|
||||
err = giteaClient.DeleteReview(ctx, owner, repoName, prNumber, posted.ID)
|
||||
if err != nil {
|
||||
t.Logf("Warning: could not delete test review %d: %v", posted.ID, err)
|
||||
}
|
||||
}
|
||||
+56
-579
@@ -4,9 +4,8 @@ import (
|
||||
"context"
|
||||
"flag"
|
||||
"fmt"
|
||||
"log/slog"
|
||||
"log"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"strconv"
|
||||
"strings"
|
||||
"time"
|
||||
@@ -19,40 +18,8 @@ import (
|
||||
|
||||
var version = "dev"
|
||||
|
||||
// setupLogger configures the global slog default logger based on format and verbosity.
|
||||
func setupLogger(format, verbosity string) {
|
||||
var level slog.Level
|
||||
switch strings.ToLower(verbosity) {
|
||||
case "debug":
|
||||
level = slog.LevelDebug
|
||||
case "info":
|
||||
level = slog.LevelInfo
|
||||
case "warn":
|
||||
level = slog.LevelWarn
|
||||
case "error":
|
||||
level = slog.LevelError
|
||||
default:
|
||||
level = slog.LevelInfo
|
||||
}
|
||||
|
||||
opts := &slog.HandlerOptions{Level: level}
|
||||
|
||||
var handler slog.Handler
|
||||
switch strings.ToLower(format) {
|
||||
case "json":
|
||||
handler = slog.NewJSONHandler(os.Stderr, opts)
|
||||
default:
|
||||
handler = slog.NewTextHandler(os.Stderr, opts)
|
||||
}
|
||||
|
||||
slog.SetDefault(slog.New(handler))
|
||||
}
|
||||
|
||||
func main() {
|
||||
versionFlag := flag.Bool("version", false, "Print version and exit")
|
||||
// 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")
|
||||
// CLI flags
|
||||
giteaURL := flag.String("gitea-url", envOrDefault("GITEA_URL", ""), "Gitea instance URL")
|
||||
repo := flag.String("repo", envOrDefault("GITEA_REPO", ""), "Repository (owner/name)")
|
||||
@@ -63,21 +30,11 @@ func main() {
|
||||
llmAPIKey := flag.String("llm-api-key", envOrDefault("LLM_API_KEY", ""), "LLM API key")
|
||||
llmModel := flag.String("llm-model", envOrDefault("LLM_MODEL", ""), "LLM model name")
|
||||
conventionsFile := flag.String("conventions-file", envOrDefault("CONVENTIONS_FILE", ""), "Conventions file path in repo (e.g. CLAUDE.md)")
|
||||
systemPromptFile := flag.String("system-prompt-file", envOrDefault("SYSTEM_PROMPT_FILE", ""), "Local file with additional system prompt instructions")
|
||||
patternsRepo := flag.String("patterns-repo", envOrDefault("PATTERNS_REPO", ""), "Repo with language patterns (e.g. rodin/elixir-patterns)")
|
||||
patternsFiles := flag.String("patterns-files", envOrDefault("PATTERNS_FILES", ""), "Comma-separated file paths to fetch from patterns repo (empty = all files)")
|
||||
patternsFiles := flag.String("patterns-files", envOrDefault("PATTERNS_FILES", "README.md"), "Comma-separated file paths to fetch from patterns repo")
|
||||
dryRun := flag.Bool("dry-run", false, "Print review to stdout instead of posting")
|
||||
llmTemp := flag.Float64("llm-temperature", envOrDefaultFloat("LLM_TEMPERATURE", 0), "LLM temperature (0 = server default)")
|
||||
llmTimeout := flag.Int("llm-timeout", envOrDefaultInt("LLM_TIMEOUT", 300), "LLM request timeout in seconds (default 300)")
|
||||
llmProvider := flag.String("llm-provider", envOrDefault("LLM_PROVIDER", "openai"), "LLM API provider: openai, anthropic, or aicore")
|
||||
personaName := flag.String("persona", envOrDefault("PERSONA", ""), "Built-in persona name (security, architect, docs)")
|
||||
personaFile := flag.String("persona-file", envOrDefault("PERSONA_FILE", ""), "Path to persona JSON file")
|
||||
// AI Core specific flags (only used when provider=aicore)
|
||||
aicoreClientID := flag.String("aicore-client-id", envOrDefault("AICORE_CLIENT_ID", ""), "SAP AI Core client ID (for provider=aicore)")
|
||||
aicoreClientSecret := flag.String("aicore-client-secret", envOrDefault("AICORE_CLIENT_SECRET", ""), "SAP AI Core client secret (for provider=aicore)")
|
||||
aicoreAuthURL := flag.String("aicore-auth-url", envOrDefault("AICORE_AUTH_URL", ""), "SAP AI Core auth URL (for provider=aicore)")
|
||||
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)")
|
||||
|
||||
flag.Parse()
|
||||
|
||||
@@ -86,84 +43,38 @@ func main() {
|
||||
os.Exit(0)
|
||||
}
|
||||
|
||||
// Initialize structured logger
|
||||
setupLogger(*logFormat, *verbosity)
|
||||
|
||||
slog.Info("review-bot starting", "version", version)
|
||||
log.Printf("review-bot %s", version)
|
||||
|
||||
// Validate required fields
|
||||
// For aicore provider, llm-base-url and llm-api-key are not required
|
||||
isAICore := llm.Provider(*llmProvider) == llm.ProviderAICore
|
||||
if *giteaURL == "" || *repo == "" || *prNum == "" || *reviewerToken == "" || *llmModel == "" {
|
||||
if *giteaURL == "" || *repo == "" || *prNum == "" || *reviewerToken == "" ||
|
||||
*llmBaseURL == "" || *llmAPIKey == "" || *llmModel == "" {
|
||||
fmt.Fprintf(os.Stderr, "Error: missing required flags or environment variables\n\n")
|
||||
fmt.Fprintf(os.Stderr, "Required: --gitea-url, --repo, --pr, --reviewer-token, --llm-model\n")
|
||||
os.Exit(1)
|
||||
}
|
||||
if !isAICore && (*llmBaseURL == "" || *llmAPIKey == "") {
|
||||
fmt.Fprintf(os.Stderr, "Error: --llm-base-url and --llm-api-key are required for provider=%s\n", *llmProvider)
|
||||
os.Exit(1)
|
||||
}
|
||||
if isAICore && (*aicoreClientID == "" || *aicoreClientSecret == "" || *aicoreAuthURL == "" || *aicoreAPIURL == "") {
|
||||
fmt.Fprintf(os.Stderr, "Error: AI Core credentials required for provider=aicore\n\n")
|
||||
fmt.Fprintf(os.Stderr, "Required: --aicore-client-id, --aicore-client-secret, --aicore-auth-url, --aicore-api-url\n")
|
||||
os.Exit(1)
|
||||
}
|
||||
|
||||
// Validate persona flags are mutually exclusive
|
||||
if *personaName != "" && *personaFile != "" {
|
||||
slog.Error("--persona and --persona-file are mutually exclusive")
|
||||
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)
|
||||
fmt.Fprintf(os.Stderr, "Required: --gitea-url, --repo, --pr, --reviewer-token, --llm-base-url, --llm-api-key, --llm-model\n")
|
||||
os.Exit(1)
|
||||
}
|
||||
|
||||
// Parse repo owner/name
|
||||
parts := strings.SplitN(*repo, "/", 2)
|
||||
if len(parts) != 2 {
|
||||
slog.Error("invalid repo format", "repo", *repo, "expected", "owner/name")
|
||||
os.Exit(1)
|
||||
log.Fatalf("Invalid repo format %q, expected owner/name", *repo)
|
||||
}
|
||||
owner, repoName := parts[0], parts[1]
|
||||
|
||||
// Parse PR number
|
||||
prNumber, err := strconv.Atoi(*prNum)
|
||||
if err != nil {
|
||||
slog.Error("invalid PR number", "pr", *prNum, "error", err)
|
||||
os.Exit(1)
|
||||
log.Fatalf("Invalid PR number %q: %v", *prNum, err)
|
||||
}
|
||||
|
||||
// Initialize clients
|
||||
giteaClient := gitea.NewClient(*giteaURL, *reviewerToken)
|
||||
llmClient := llm.NewClient(*llmBaseURL, *llmAPIKey, *llmModel)
|
||||
if *llmTemp < 0 || *llmTemp > 2 {
|
||||
slog.Error("invalid LLM temperature", "temperature", *llmTemp, "range", "0-2")
|
||||
os.Exit(1)
|
||||
log.Fatal("--llm-temperature must be between 0 and 2")
|
||||
}
|
||||
if *llmTemp > 0 {
|
||||
llmClient.WithTemperature(*llmTemp)
|
||||
}
|
||||
switch llm.Provider(*llmProvider) {
|
||||
case llm.ProviderOpenAI, llm.ProviderAnthropic:
|
||||
llmClient.WithProvider(llm.Provider(*llmProvider))
|
||||
case llm.ProviderAICore:
|
||||
llmClient.WithAICore(llm.AICoreConfig{
|
||||
ClientID: *aicoreClientID,
|
||||
ClientSecret: *aicoreClientSecret,
|
||||
AuthURL: *aicoreAuthURL,
|
||||
APIURL: *aicoreAPIURL,
|
||||
ResourceGroup: *aicoreResourceGroup,
|
||||
})
|
||||
slog.Info("using SAP AI Core provider", "resource_group", *aicoreResourceGroup)
|
||||
default:
|
||||
slog.Error("invalid LLM provider", "provider", *llmProvider, "valid", "openai, anthropic, aicore")
|
||||
os.Exit(1)
|
||||
}
|
||||
if *llmTimeout > 0 {
|
||||
llmClient.WithTimeout(time.Duration(*llmTimeout) * time.Second)
|
||||
}
|
||||
@@ -173,69 +84,30 @@ func main() {
|
||||
ctx, cancel := context.WithTimeout(context.Background(), overallTimeout)
|
||||
defer cancel()
|
||||
|
||||
// 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, 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
|
||||
slog.Info("loaded repo persona", "persona", persona.Name, "display", persona.DisplayName, "repo", owner+"/"+repoName)
|
||||
} else {
|
||||
// Fall back to built-in
|
||||
persona, err = review.LoadBuiltinPersona(*personaName)
|
||||
if err != nil {
|
||||
slog.Error("failed to load persona", "persona", *personaName, "error", err)
|
||||
os.Exit(1)
|
||||
}
|
||||
slog.Info("loaded built-in persona", "persona", persona.Name, "display", persona.DisplayName)
|
||||
}
|
||||
} else if *personaFile != "" {
|
||||
resolvedPath, err := validateWorkspacePath(*personaFile, "persona-file")
|
||||
if err != nil {
|
||||
slog.Error("invalid persona-file path", "error", err)
|
||||
os.Exit(1)
|
||||
}
|
||||
persona, err = review.LoadPersona(resolvedPath)
|
||||
if err != nil {
|
||||
slog.Error("failed to load persona file", "file", *personaFile, "error", err)
|
||||
os.Exit(1)
|
||||
}
|
||||
slog.Info("loaded persona from file", "file", *personaFile, "persona", persona.Name)
|
||||
}
|
||||
|
||||
slog.Info("reviewing pull request", "pr", prNumber, "repo", fmt.Sprintf("%s/%s", owner, repoName))
|
||||
log.Printf("Reviewing PR #%d on %s/%s", prNumber, owner, repoName)
|
||||
|
||||
// Step 1: Fetch PR metadata
|
||||
pr, err := giteaClient.GetPullRequest(ctx, owner, repoName, prNumber)
|
||||
if err != nil {
|
||||
slog.Error("failed to fetch PR", "pr", prNumber, "error", err)
|
||||
os.Exit(1)
|
||||
log.Fatalf("Failed to fetch PR: %v", err)
|
||||
}
|
||||
slog.Info("fetched PR metadata", "pr", prNumber, "title", pr.Title)
|
||||
log.Printf("PR: %s", pr.Title)
|
||||
|
||||
// Step 2: Fetch diff
|
||||
diff, err := giteaClient.GetPullRequestDiff(ctx, owner, repoName, prNumber)
|
||||
if err != nil {
|
||||
slog.Error("failed to fetch diff", "pr", prNumber, "error", err)
|
||||
os.Exit(1)
|
||||
log.Fatalf("Failed to fetch diff: %v", err)
|
||||
}
|
||||
slog.Info("fetched diff", "bytes", len(diff))
|
||||
log.Printf("Diff size: %d bytes", len(diff))
|
||||
|
||||
// Step 3: Fetch full file content for modified files
|
||||
fileContext := ""
|
||||
files, err := giteaClient.GetPullRequestFiles(ctx, owner, repoName, prNumber)
|
||||
if err != nil {
|
||||
slog.Warn("could not fetch PR files list", "pr", prNumber, "error", err)
|
||||
log.Printf("Warning: could not fetch PR files list: %v", err)
|
||||
} else {
|
||||
fileContext = fetchFileContext(ctx, giteaClient, owner, repoName, pr.Head.Ref, files)
|
||||
slog.Debug("fetched file context", "files", len(files))
|
||||
log.Printf("Fetched full context for %d files", len(files))
|
||||
}
|
||||
|
||||
// Step 4: Check CI status
|
||||
@@ -244,10 +116,10 @@ func main() {
|
||||
if 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)
|
||||
log.Printf("Warning: could not fetch CI status: %v", err)
|
||||
} else {
|
||||
ciPassed, ciDetails = evaluateCIStatus(statuses)
|
||||
slog.Info("CI status checked", "passed", ciPassed)
|
||||
log.Printf("CI status: passed=%v", ciPassed)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -256,10 +128,10 @@ func main() {
|
||||
if *conventionsFile != "" {
|
||||
content, err := giteaClient.GetFileContent(ctx, owner, repoName, *conventionsFile)
|
||||
if err != nil {
|
||||
slog.Warn("could not load conventions file", "file", *conventionsFile, "error", err)
|
||||
log.Printf("Warning: could not load conventions file %q: %v", *conventionsFile, err)
|
||||
} else {
|
||||
conventions = content
|
||||
slog.Debug("loaded conventions file", "file", *conventionsFile, "bytes", len(conventions))
|
||||
log.Printf("Loaded conventions file: %s (%d bytes)", *conventionsFile, len(conventions))
|
||||
}
|
||||
}
|
||||
|
||||
@@ -267,39 +139,12 @@ func main() {
|
||||
patterns := ""
|
||||
if *patternsRepo != "" {
|
||||
patterns = fetchPatterns(ctx, giteaClient, *patternsRepo, *patternsFiles)
|
||||
slog.Debug("loaded patterns", "repo", *patternsRepo, "bytes", len(patterns))
|
||||
}
|
||||
|
||||
// Step 6b: Load additional system prompt if specified
|
||||
additionalPrompt := ""
|
||||
if *systemPromptFile != "" {
|
||||
resolvedPath, err := validateWorkspacePath(*systemPromptFile, "system-prompt-file")
|
||||
if err != nil {
|
||||
slog.Error("invalid system-prompt-file path", "error", err)
|
||||
os.Exit(1)
|
||||
}
|
||||
data, err := os.ReadFile(resolvedPath)
|
||||
if err != nil {
|
||||
slog.Error("failed to read system prompt file", "path", *systemPromptFile, "error", err)
|
||||
os.Exit(1)
|
||||
}
|
||||
additionalPrompt = string(data)
|
||||
slog.Debug("loaded system prompt file", "file", *systemPromptFile, "bytes", len(additionalPrompt))
|
||||
log.Printf("Loaded patterns from %s (%d bytes)", *patternsRepo, len(patterns))
|
||||
}
|
||||
|
||||
// Step 7: Budget-aware prompt assembly
|
||||
var systemBase string
|
||||
if persona != nil {
|
||||
systemBase = review.BuildPersonaSystemPrompt(persona)
|
||||
slog.Debug("using persona system prompt", "persona", persona.Name)
|
||||
} else {
|
||||
systemBase = review.BuildSystemBase()
|
||||
}
|
||||
if additionalPrompt != "" {
|
||||
systemBase += "\n\n## Additional Review Instructions\n\n" + additionalPrompt
|
||||
}
|
||||
sections := budget.Sections{
|
||||
SystemBase: systemBase,
|
||||
SystemBase: review.BuildSystemBase(),
|
||||
Patterns: patterns,
|
||||
Conventions: conventions,
|
||||
FileContext: fileContext,
|
||||
@@ -307,66 +152,33 @@ func main() {
|
||||
UserMeta: review.BuildUserMeta(pr.Title, pr.Body, ciPassed, ciDetails),
|
||||
}
|
||||
budgetResult := budget.Fit(*llmModel, sections)
|
||||
slog.Info("token budget calculated", "tokens", budgetResult.EstTokens, "limit", budget.LimitForModel(*llmModel), "model", *llmModel)
|
||||
log.Printf("Token estimate: ~%dK (limit: %dK)", budgetResult.EstTokens/1000, budget.LimitForModel(*llmModel)/1000)
|
||||
if len(budgetResult.Trimmed) > 0 {
|
||||
slog.Warn("context trimmed to fit budget", "trimmed", budgetResult.Trimmed)
|
||||
log.Printf("Context trimmed: %v", budgetResult.Trimmed)
|
||||
}
|
||||
|
||||
// Step 8: Call LLM (with retry on parse failure)
|
||||
slog.Info("sending request to LLM", "model", *llmModel)
|
||||
// Step 8: Call LLM
|
||||
log.Printf("Sending to LLM (%s)...", *llmModel)
|
||||
messages := []llm.Message{
|
||||
{Role: "system", Content: budgetResult.SystemPrompt},
|
||||
{Role: "user", Content: budgetResult.UserPrompt},
|
||||
}
|
||||
|
||||
var response string
|
||||
var result *review.ReviewResult
|
||||
for attempt := 1; attempt <= 2; attempt++ {
|
||||
if attempt > 1 {
|
||||
slog.Warn("retrying LLM request after parse failure", "attempt", attempt)
|
||||
time.Sleep(time.Second)
|
||||
}
|
||||
|
||||
response, err = llmClient.Complete(ctx, messages)
|
||||
if err != nil {
|
||||
slog.Error("LLM request failed", "model", *llmModel, "error", err, "attempt", attempt)
|
||||
if attempt == 2 {
|
||||
os.Exit(1)
|
||||
}
|
||||
continue
|
||||
}
|
||||
slog.Info("LLM response received", "bytes", len(response), "attempt", attempt)
|
||||
|
||||
// Step 9: Parse response
|
||||
result, err = review.ParseResponse(response)
|
||||
if err != nil {
|
||||
slog.Error("failed to parse LLM response", "error", err, "attempt", attempt)
|
||||
if attempt == 2 {
|
||||
os.Exit(1)
|
||||
}
|
||||
continue
|
||||
}
|
||||
break
|
||||
response, err := llmClient.Complete(ctx, messages)
|
||||
if err != nil {
|
||||
log.Fatalf("LLM request failed: %v", err)
|
||||
}
|
||||
slog.Info("review parsed", "verdict", result.Verdict, "findings", len(result.Findings))
|
||||
log.Printf("LLM response received (%d bytes)", len(response))
|
||||
|
||||
// Step 9: Parse response
|
||||
result, err := review.ParseResponse(response)
|
||||
if err != nil {
|
||||
log.Fatalf("Failed to parse LLM response: %v", err)
|
||||
}
|
||||
log.Printf("Verdict: %s (%d findings)", result.Verdict, len(result.Findings))
|
||||
|
||||
// Step 10: Format and post review
|
||||
var reviewBody string
|
||||
if persona != nil && persona.DisplayName != "" {
|
||||
reviewBody = review.FormatMarkdownWithDisplay(result, persona.DisplayName, *reviewerName)
|
||||
} else {
|
||||
reviewBody = review.FormatMarkdown(result, *reviewerName)
|
||||
}
|
||||
|
||||
// Add commit footer so readers know which commit was evaluated
|
||||
if pr.Head.Sha != "" {
|
||||
shortSHA := pr.Head.Sha
|
||||
if len(shortSHA) > 8 {
|
||||
shortSHA = shortSHA[:8]
|
||||
}
|
||||
reviewBody += fmt.Sprintf("\n\n---\n*Evaluated against %s*", shortSHA)
|
||||
}
|
||||
|
||||
reviewBody := review.FormatMarkdown(result, *reviewerName)
|
||||
event := review.GiteaEvent(result.Verdict)
|
||||
|
||||
if *dryRun {
|
||||
@@ -376,124 +188,11 @@ func main() {
|
||||
return
|
||||
}
|
||||
|
||||
sentinel := fmt.Sprintf("<!-- review-bot:%s -->", *reviewerName)
|
||||
|
||||
// Stale check: verify HEAD hasn't moved since we started
|
||||
evaluatedSHA := pr.Head.Sha
|
||||
var currentSHA string
|
||||
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
|
||||
log.Printf("Posting review (event=%s)...", event)
|
||||
if err := giteaClient.PostReview(ctx, owner, repoName, prNumber, event, reviewBody); err != nil {
|
||||
log.Fatalf("Failed to post review: %v", err)
|
||||
}
|
||||
if shouldSkipStaleReview(evaluatedSHA, currentSHA) {
|
||||
slog.Warn("HEAD moved during review — skipping stale review",
|
||||
"evaluated", evaluatedSHA,
|
||||
"current", currentSHA,
|
||||
"pr", prNumber)
|
||||
return
|
||||
}
|
||||
|
||||
// Map findings to inline comments for lines present in the diff
|
||||
diffRanges := gitea.ParseDiffNewLines(diff)
|
||||
var inlineComments []gitea.ReviewComment
|
||||
for _, f := range result.Findings {
|
||||
if f.File != "" && f.Line > 0 && diffRanges.Contains(f.File, f.Line) {
|
||||
inlineComments = append(inlineComments, gitea.ReviewComment{
|
||||
Path: f.File,
|
||||
NewPosition: int64(f.Line),
|
||||
Body: fmt.Sprintf("**[%s]** %s", f.Severity, f.Finding),
|
||||
})
|
||||
}
|
||||
}
|
||||
if len(inlineComments) > 0 {
|
||||
slog.Debug("attaching inline comments", "count", len(inlineComments))
|
||||
}
|
||||
|
||||
// --- 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
|
||||
// Order matters: post first so we have the new review's URL for the supersede message.
|
||||
var oldReviews []gitea.Review
|
||||
if *reviewerName != "" {
|
||||
existingReviews, err := giteaClient.ListReviews(ctx, owner, repoName, prNumber)
|
||||
if err != nil {
|
||||
slog.Warn("could not list existing reviews", "pr", prNumber, "error", err)
|
||||
} else {
|
||||
if hasSharedToken(existingReviews, sentinel) {
|
||||
slog.Warn("shared token mode: skipping supersede to avoid clobbering sibling review")
|
||||
} else {
|
||||
oldReviews = findAllOwnReviews(existingReviews, sentinel)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Self-request as reviewer (ensures we appear in required-reviewer checks)
|
||||
authUser, err := giteaClient.GetAuthenticatedUser(ctx)
|
||||
if err != nil {
|
||||
slog.Warn("could not determine authenticated user for reviewer self-request", "error", err)
|
||||
} else if authUser != "" {
|
||||
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)
|
||||
}
|
||||
}
|
||||
|
||||
// POST new review
|
||||
slog.Info("posting review", "event", event, "pr", prNumber)
|
||||
posted, err := giteaClient.PostReview(ctx, owner, repoName, prNumber, event, reviewBody, evaluatedSHA, inlineComments)
|
||||
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 with link to the new one
|
||||
if len(oldReviews) > 0 {
|
||||
newReviewURL := fmt.Sprintf("%s/%s/%s/pulls/%d#pullrequestreview-%d", strings.TrimRight(*giteaURL, "/"), owner, repoName, prNumber, posted.ID)
|
||||
for _, oldReview := range oldReviews {
|
||||
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 := 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", posted.ID, "pr", prNumber)
|
||||
|
||||
// Resolve old review's inline comments
|
||||
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
|
||||
}
|
||||
resolved, failed := 0, 0
|
||||
for _, c := range oldComments {
|
||||
if c.ID == 0 {
|
||||
continue
|
||||
}
|
||||
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 {
|
||||
resolved++
|
||||
}
|
||||
}
|
||||
if resolved > 0 {
|
||||
slog.Info("resolved old inline comments", "review_id", oldReview.ID, "count", resolved, "pr", prNumber)
|
||||
}
|
||||
if failed > 0 {
|
||||
slog.Warn("some inline comments could not be resolved", "review_id", oldReview.ID, "failed", failed, "pr", prNumber)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
log.Printf("Review posted successfully!")
|
||||
}
|
||||
|
||||
// fetchFileContext fetches the full content of modified files from the PR branch.
|
||||
@@ -508,7 +207,7 @@ func fetchFileContext(ctx context.Context, client *gitea.Client, owner, repo, re
|
||||
}
|
||||
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)
|
||||
log.Printf("Warning: could not fetch %s: %v", f.Filename, err)
|
||||
continue
|
||||
}
|
||||
sb.WriteString(fmt.Sprintf("--- %s ---\n", f.Filename))
|
||||
@@ -523,25 +222,11 @@ func fetchFileContext(ctx context.Context, client *gitea.Client, owner, repo, re
|
||||
// patternsRepo is comma-separated list of owner/name repos.
|
||||
// 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 *gitea.Client, patternsRepo, patternsFiles string) string {
|
||||
var sb strings.Builder
|
||||
|
||||
repos := strings.Split(patternsRepo, ",")
|
||||
|
||||
// Build the list of paths to fetch
|
||||
var paths []string
|
||||
if patternsFiles == "" {
|
||||
// Empty patternsFiles means "fetch all files from repo root"
|
||||
paths = []string{""}
|
||||
} else {
|
||||
for _, p := range strings.Split(patternsFiles, ",") {
|
||||
p = strings.TrimSpace(p)
|
||||
if p != "" {
|
||||
paths = append(paths, p)
|
||||
}
|
||||
}
|
||||
}
|
||||
paths := strings.Split(patternsFiles, ",")
|
||||
|
||||
for _, repoRef := range repos {
|
||||
if ctx.Err() != nil {
|
||||
@@ -553,40 +238,31 @@ func fetchPatterns(ctx context.Context, client *gitea.Client, patternsRepo, patt
|
||||
}
|
||||
parts := strings.SplitN(repoRef, "/", 2)
|
||||
if len(parts) != 2 {
|
||||
slog.Warn("invalid patterns-repo format", "repo", repoRef, "expected", "owner/name")
|
||||
log.Printf("Warning: invalid patterns-repo format %q, expected owner/name", repoRef)
|
||||
continue
|
||||
}
|
||||
owner, repo := parts[0], parts[1]
|
||||
|
||||
var repoLoadedFiles []string
|
||||
var repoSkippedFiles []string
|
||||
|
||||
for _, path := range paths {
|
||||
files, err := client.GetAllFilesInPath(ctx, owner, repo, path)
|
||||
if err != nil {
|
||||
slog.Warn("could not fetch patterns", "path", path, "repo", repoRef, "error", err)
|
||||
path = strings.TrimSpace(path)
|
||||
if path == "" {
|
||||
continue
|
||||
}
|
||||
|
||||
for filePath, content := range files {
|
||||
files, err := client.GetAllFilesInPath(ctx, owner, repo, path)
|
||||
if err != nil {
|
||||
log.Printf("Warning: could not fetch %s from %s: %v", path, repoRef, err)
|
||||
continue
|
||||
}
|
||||
|
||||
for filepath, content := range files {
|
||||
// Only include markdown and text files as patterns
|
||||
if !isPatternFile(filePath) {
|
||||
repoSkippedFiles = append(repoSkippedFiles, filePath)
|
||||
if !isPatternFile(filepath) {
|
||||
continue
|
||||
}
|
||||
repoLoadedFiles = append(repoLoadedFiles, filePath)
|
||||
sb.WriteString(fmt.Sprintf("### %s/%s\n\n%s\n\n", repoRef, filePath, content))
|
||||
sb.WriteString(fmt.Sprintf("### %s/%s\n\n%s\n\n", repoRef, filepath, content))
|
||||
}
|
||||
}
|
||||
|
||||
if len(repoLoadedFiles) > 0 {
|
||||
slog.Info("loaded pattern files", "repo", repoRef, "count", len(repoLoadedFiles), "files", repoLoadedFiles)
|
||||
} else {
|
||||
slog.Warn("no pattern files loaded", "repo", repoRef, "paths", paths)
|
||||
}
|
||||
if len(repoSkippedFiles) > 0 {
|
||||
slog.Debug("skipped non-pattern files", "repo", repoRef, "count", len(repoSkippedFiles), "files", repoSkippedFiles)
|
||||
}
|
||||
}
|
||||
return sb.String()
|
||||
}
|
||||
@@ -650,202 +326,3 @@ func envOrDefaultInt(key string, defaultVal int) int {
|
||||
}
|
||||
return defaultVal
|
||||
}
|
||||
|
||||
func envOrDefaultBool(key string, defaultVal bool) bool {
|
||||
v := strings.TrimSpace(strings.ToLower(os.Getenv(key)))
|
||||
if v == "" {
|
||||
return defaultVal
|
||||
}
|
||||
return v == "true" || v == "1" || v == "yes"
|
||||
}
|
||||
|
||||
// validateReviewerName checks that the name contains only safe characters
|
||||
// for embedding in an HTML comment sentinel ([a-zA-Z0-9_-]).
|
||||
func validateReviewerName(name string) error {
|
||||
if name == "" {
|
||||
return nil
|
||||
}
|
||||
for _, ch := range name {
|
||||
if !((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || (ch >= '0' && ch <= '9') || ch == '-' || ch == '_') {
|
||||
return fmt.Errorf("reviewer-name must contain only [a-zA-Z0-9_-] (got %q)", name)
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// validateWorkspacePath ensures a file path is within the workspace and resolves
|
||||
// symlinks to prevent traversal attacks. Returns the resolved absolute path or
|
||||
// an error if the path is outside the workspace.
|
||||
func validateWorkspacePath(path, pathName string) (string, error) {
|
||||
workspace := os.Getenv("GITHUB_WORKSPACE")
|
||||
if workspace == "" {
|
||||
workspace, _ = os.Getwd()
|
||||
}
|
||||
absWorkspace, err := filepath.Abs(workspace)
|
||||
if err != nil {
|
||||
return "", fmt.Errorf("failed to resolve workspace path: %w", err)
|
||||
}
|
||||
|
||||
// Join and clean the path
|
||||
fullPath := filepath.Join(absWorkspace, path)
|
||||
fullPath = filepath.Clean(fullPath)
|
||||
|
||||
// Check path is within workspace using filepath.Rel (more robust than HasPrefix)
|
||||
rel, err := filepath.Rel(absWorkspace, fullPath)
|
||||
if err != nil || strings.HasPrefix(rel, "..") {
|
||||
return "", fmt.Errorf("%s resolves outside workspace: path=%s workspace=%s", pathName, fullPath, absWorkspace)
|
||||
}
|
||||
|
||||
// Resolve symlinks and re-validate to prevent symlink traversal
|
||||
resolvedPath, err := filepath.EvalSymlinks(fullPath)
|
||||
if err != nil {
|
||||
return "", fmt.Errorf("failed to resolve %s: %w", pathName, err)
|
||||
}
|
||||
|
||||
relResolved, err := filepath.Rel(absWorkspace, resolvedPath)
|
||||
if err != nil || strings.HasPrefix(relResolved, "..") {
|
||||
return "", fmt.Errorf("%s symlink resolves outside workspace: resolved=%s workspace=%s", pathName, resolvedPath, absWorkspace)
|
||||
}
|
||||
|
||||
return resolvedPath, nil
|
||||
}
|
||||
|
||||
// buildSupersededBody creates the body for a superseded review: struck-through banner
|
||||
// with collapsed original content and the commit it was evaluated against.
|
||||
func buildSupersededBody(originalBody, commitSHA, newReviewURL, sentinel string) string {
|
||||
shortSHA := commitSHA
|
||||
if len(shortSHA) > 8 {
|
||||
shortSHA = shortSHA[:8]
|
||||
}
|
||||
var sb strings.Builder
|
||||
sb.WriteString("~~Original review~~\n\n")
|
||||
sb.WriteString("**Superseded** \u2014 [see current review](")
|
||||
sb.WriteString(newReviewURL)
|
||||
sb.WriteString(") for up-to-date findings.\n\n")
|
||||
if shortSHA != "" {
|
||||
sb.WriteString("<details><summary>Previous findings (commit ")
|
||||
sb.WriteString(shortSHA)
|
||||
sb.WriteString(")</summary>\n\n")
|
||||
} else {
|
||||
sb.WriteString("<details><summary>Previous findings</summary>\n\n")
|
||||
}
|
||||
sb.WriteString(originalBody)
|
||||
sb.WriteString("\n\n</details>\n\n")
|
||||
sb.WriteString(sentinel)
|
||||
return sb.String()
|
||||
}
|
||||
|
||||
// hasSharedToken detects if another review-bot role posted under the same
|
||||
// Gitea user. This indicates misconfiguration where two roles share a 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 []gitea.Review, ownSentinel string) bool {
|
||||
ownLogin := ""
|
||||
for _, r := range reviews {
|
||||
if strings.Contains(r.Body, ownSentinel) {
|
||||
ownLogin = r.User.Login
|
||||
break
|
||||
}
|
||||
}
|
||||
if ownLogin == "" {
|
||||
return false
|
||||
}
|
||||
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 Gitea user",
|
||||
"sibling_role", extractSentinelName(r.Body), "user", ownLogin)
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
// extractSentinelName pulls the reviewer name from a sentinel comment.
|
||||
func extractSentinelName(body string) string {
|
||||
const prefix = "<!-- review-bot:"
|
||||
const suffix = " -->"
|
||||
idx := strings.Index(body, prefix)
|
||||
if idx < 0 {
|
||||
return "unknown"
|
||||
}
|
||||
rest := body[idx+len(prefix):]
|
||||
end := strings.Index(rest, suffix)
|
||||
if end < 0 {
|
||||
return "unknown"
|
||||
}
|
||||
return rest[:end]
|
||||
}
|
||||
|
||||
// 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 []gitea.Review, sentinel string) []gitea.Review {
|
||||
var result []gitea.Review
|
||||
for i := range reviews {
|
||||
if !strings.Contains(reviews[i].Body, sentinel) {
|
||||
continue
|
||||
}
|
||||
if strings.Contains(reviews[i].Body, "~~Original review~~") {
|
||||
continue
|
||||
}
|
||||
result = append(result, reviews[i])
|
||||
}
|
||||
return result
|
||||
}
|
||||
|
||||
// shouldSkipStaleReview reports whether to skip posting because HEAD moved.
|
||||
// Returns true (skip) if evaluatedSHA differs from currentSHA.
|
||||
// Returns false (don't skip) if:
|
||||
// - SHAs match (no movement)
|
||||
// - currentSHA is empty (re-fetch failed; prefer posting stale over failing)
|
||||
func shouldSkipStaleReview(evaluatedSHA, currentSHA string) bool {
|
||||
if currentSHA == "" {
|
||||
// Re-fetch failed; better to post potentially stale than fail
|
||||
return false
|
||||
}
|
||||
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)
|
||||
}
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,334 +0,0 @@
|
||||
# Design: Role-based Review Personas (Issue #51)
|
||||
|
||||
> **Note:** This design was revised during implementation to use JSON instead of YAML
|
||||
> to maintain the repository's zero-external-dependencies convention. All persona
|
||||
> files use JSON format. See "Design Revision" section at the end for details.
|
||||
|
||||
## Problem
|
||||
|
||||
Current review-bot performs generic code review. Every reviewer (regardless of `reviewer-name`) uses the same base prompt and evaluates the same concerns. This leads to:
|
||||
|
||||
1. **Redundancy** — Two reviewers (e.g., GPT + Claude twins) often flag identical issues
|
||||
2. **Gaps** — Generic reviewers miss specialized concerns (security, domain logic, architecture)
|
||||
3. **Noise** — NITs about style mixed with critical security findings
|
||||
4. **No ownership** — Findings lack clear domain attribution
|
||||
|
||||
## Constraints
|
||||
|
||||
- Must work with existing CLI flags and CI workflow patterns
|
||||
- Must not break backwards compatibility (existing configs still work)
|
||||
- Must integrate cleanly with the budget system (personas add to context)
|
||||
- Multiple personas running in parallel must not interfere with each other
|
||||
- Each persona must have clear scope boundaries (no duplication)
|
||||
|
||||
## Proposed Approach
|
||||
|
||||
### 1. Persona Definition
|
||||
|
||||
A persona is a named review role with:
|
||||
- **Identity** — Who am I? What's my expertise?
|
||||
- **Focus** — What do I look for?
|
||||
- **Scope boundaries** — What do I explicitly NOT comment on?
|
||||
- **Severity calibration** — What counts as MAJOR/MINOR/NIT for MY domain?
|
||||
|
||||
Personas are defined in JSON files that can live:
|
||||
1. In the pattern repos (shared across projects)
|
||||
2. In the target repo (project-specific personas)
|
||||
3. Inline via a new `--persona-file` flag (JSON format)
|
||||
|
||||
### 2. Persona File Format
|
||||
|
||||
```json
|
||||
# .review/personas/security.yaml
|
||||
name: security
|
||||
display_name: Security Specialist
|
||||
model_preference: opus # optional hint for expensive analysis
|
||||
|
||||
identity: |
|
||||
You are a security specialist reviewing code for vulnerabilities.
|
||||
Your expertise: OWASP Top 10, injection attacks, auth/authz, secrets management,
|
||||
event sourcing security (replay attacks, event injection).
|
||||
|
||||
focus:
|
||||
- Injection attacks (SQL, command, path traversal, template)
|
||||
- Authentication and authorization gaps
|
||||
- Secrets exposure (hardcoded credentials, tokens in logs)
|
||||
- Input validation (unsanitized input, unsafe deserialization)
|
||||
- Race conditions with security implications
|
||||
- Event sourcing attack vectors
|
||||
|
||||
ignore:
|
||||
- Code style and naming conventions
|
||||
- Performance (unless security-related)
|
||||
- Documentation
|
||||
- General code quality
|
||||
- Test coverage
|
||||
|
||||
severity:
|
||||
critical: "Remote code execution, auth bypass, data exfiltration"
|
||||
major: "Privilege escalation, information disclosure, DoS"
|
||||
minor: "Missing rate limiting, verbose errors"
|
||||
nit: "Theoretical risk with low exploitability"
|
||||
|
||||
output_format: |
|
||||
For each finding:
|
||||
- Severity: [CRITICAL|MAJOR|MINOR|NIT]
|
||||
- Attack vector: How could this be exploited?
|
||||
- Evidence: Code snippet showing the vulnerability
|
||||
- Recommendation: Specific fix
|
||||
```
|
||||
|
||||
### 3. New CLI Flags
|
||||
|
||||
```
|
||||
--persona-file PATH Path to persona JSON file (local or in repo)
|
||||
--persona NAME Built-in persona name (security, architect, domain)
|
||||
```
|
||||
|
||||
Either flag sets the persona. If neither is provided, behavior is unchanged (generic review).
|
||||
|
||||
### 4. Prompt Assembly
|
||||
|
||||
Current flow:
|
||||
```
|
||||
SystemBase → Patterns → Conventions → [LLM]
|
||||
```
|
||||
|
||||
New flow with persona:
|
||||
```
|
||||
PersonaPrompt (from YAML) → Patterns (filtered?) → Conventions → [LLM]
|
||||
```
|
||||
|
||||
The persona's identity/focus/ignore/severity sections become the system prompt, replacing the generic "You are an expert code reviewer" base.
|
||||
|
||||
### 5. Built-in Personas
|
||||
|
||||
Ship with these built-in personas (loadable via `--persona NAME`):
|
||||
|
||||
| Name | Focus |
|
||||
|------|-------|
|
||||
| `security` | Vulnerabilities, auth, secrets |
|
||||
| `architect` | Patterns, consistency, design |
|
||||
| `domain` | Business logic (requires repo-specific config) |
|
||||
| `docs` | Documentation, API clarity |
|
||||
|
||||
Built-in personas live in `review/personas/` as embedded Go assets or YAML shipped with the binary.
|
||||
|
||||
### 6. CI Workflow Integration
|
||||
|
||||
Single persona:
|
||||
```yaml
|
||||
- uses: rodin/review-bot/.gitea/actions/review@v1
|
||||
with:
|
||||
reviewer-name: security
|
||||
persona: security
|
||||
...
|
||||
```
|
||||
|
||||
Multiple personas (parallel jobs):
|
||||
```yaml
|
||||
jobs:
|
||||
review:
|
||||
strategy:
|
||||
matrix:
|
||||
include:
|
||||
- name: security
|
||||
persona: security
|
||||
- name: architect
|
||||
persona: architect
|
||||
steps:
|
||||
- uses: rodin/review-bot/.gitea/actions/review@v1
|
||||
with:
|
||||
reviewer-name: ${{ matrix.name }}
|
||||
persona: ${{ matrix.persona }}
|
||||
```
|
||||
|
||||
Custom persona from repo:
|
||||
```yaml
|
||||
- uses: rodin/review-bot/.gitea/actions/review@v1
|
||||
with:
|
||||
reviewer-name: trading
|
||||
persona-file: .review/personas/trading.yaml
|
||||
```
|
||||
|
||||
### 7. Persona + Patterns Interaction
|
||||
|
||||
Some personas benefit from filtered patterns:
|
||||
- Security → only security-related patterns
|
||||
- Architect → all patterns (structural focus)
|
||||
- Domain → domain docs, not language patterns
|
||||
|
||||
For v1, keep it simple: all patterns are included regardless of persona. Future enhancement could add `patterns_filter` to persona YAML.
|
||||
|
||||
### 8. Output Format Changes
|
||||
|
||||
Persona name appears in the review header:
|
||||
```markdown
|
||||
# Security Review
|
||||
|
||||
## Summary
|
||||
No critical vulnerabilities found in this change.
|
||||
|
||||
## Findings
|
||||
| # | Severity | File | Line | Finding |
|
||||
...
|
||||
|
||||
## Recommendation
|
||||
**APPROVE** — No security-relevant issues detected.
|
||||
|
||||
---
|
||||
*Review by security*
|
||||
<!-- review-bot:security -->
|
||||
```
|
||||
|
||||
## State/Data Model
|
||||
|
||||
### Persona struct
|
||||
|
||||
```go
|
||||
// review/persona.go
|
||||
type Persona struct {
|
||||
Name string `yaml:"name"`
|
||||
DisplayName string `yaml:"display_name"`
|
||||
ModelPref string `yaml:"model_preference,omitempty"`
|
||||
Identity string `yaml:"identity"`
|
||||
Focus []string `yaml:"focus"`
|
||||
Ignore []string `yaml:"ignore"`
|
||||
Severity Severity `yaml:"severity"`
|
||||
OutputFormat string `yaml:"output_format,omitempty"`
|
||||
}
|
||||
|
||||
type Severity struct {
|
||||
Critical string `yaml:"critical"`
|
||||
Major string `yaml:"major"`
|
||||
Minor string `yaml:"minor"`
|
||||
Nit string `yaml:"nit"`
|
||||
}
|
||||
```
|
||||
|
||||
### Loading precedence
|
||||
|
||||
1. `--persona-file PATH` → load from local file system
|
||||
2. `--persona NAME` → load from embedded built-ins
|
||||
3. Neither → use generic system prompt (current behavior)
|
||||
|
||||
## Error Cases
|
||||
|
||||
| Error | Handling |
|
||||
|-------|----------|
|
||||
| Persona file not found | Fatal exit with clear message |
|
||||
| Invalid YAML in persona file | Fatal exit with parse error |
|
||||
| Both `--persona` and `--persona-file` specified | Fatal exit: mutually exclusive |
|
||||
| Unknown built-in persona name | Fatal exit with list of valid names |
|
||||
| Empty identity in persona | Warning, fall back to generic prompt |
|
||||
|
||||
## Edge Cases
|
||||
|
||||
- **Empty focus list**: Valid — persona relies on identity alone
|
||||
- **Empty ignore list**: Valid — no explicit scope exclusions
|
||||
- **No severity section**: Use default MAJOR/MINOR/NIT definitions
|
||||
- **Model preference set but budget insufficient**: Ignore preference, log warning
|
||||
- **Persona file in pattern repo**: Fetch like other pattern files
|
||||
|
||||
## Testing Strategy
|
||||
|
||||
### Unit tests
|
||||
- `persona_test.go`: Parse valid/invalid YAML, validate required fields
|
||||
- `prompt_test.go`: Verify persona prompt assembly
|
||||
- Integration with budget: persona prompts count toward token limit
|
||||
|
||||
### Integration tests
|
||||
- End-to-end with `--persona security` (built-in)
|
||||
- End-to-end with `--persona-file custom.yaml`
|
||||
- Backwards compatibility: no flags = generic behavior
|
||||
|
||||
### Manual verification
|
||||
- Run security persona on a PR with obvious vulnerability
|
||||
- Verify security persona ignores style issues
|
||||
- Verify non-security persona doesn't flag security issues
|
||||
|
||||
## Implementation Phases
|
||||
|
||||
### Phase 1: Persona types and loading
|
||||
- [ ] `review/persona.go`: Persona struct + YAML parsing
|
||||
- [ ] `review/persona_test.go`: Unit tests
|
||||
- [ ] Embed built-in personas in binary
|
||||
- [ ] Compiles clean, tests pass
|
||||
|
||||
### Phase 2: Prompt generation
|
||||
- [ ] `review/prompt.go`: `BuildPersonaPrompt(p Persona) string`
|
||||
- [ ] Modify `BuildSystemBase()` to accept optional persona
|
||||
- [ ] Integrate persona prompt with budget system
|
||||
- [ ] Tests for prompt assembly
|
||||
|
||||
### Phase 3: CLI integration
|
||||
- [ ] Add `--persona` and `--persona-file` flags
|
||||
- [ ] Flag validation (mutually exclusive, valid names)
|
||||
- [ ] Load persona based on flags
|
||||
- [ ] Pass persona to prompt builder
|
||||
|
||||
### Phase 4: Action integration
|
||||
- [ ] Add `persona` and `persona-file` inputs to action.yml
|
||||
- [ ] Update README with persona examples
|
||||
- [ ] End-to-end CI test
|
||||
|
||||
### Phase 5: Built-in personas
|
||||
- [ ] `security.yaml` built-in
|
||||
- [ ] `architect.yaml` built-in
|
||||
- [ ] `docs.yaml` built-in
|
||||
- [ ] Document each persona's focus
|
||||
|
||||
## Open Questions
|
||||
|
||||
1. **Persona file location in repo**: Should we support `--persona-file .review/security.yaml` where the file is fetched from the PR's repo (like conventions)? This adds complexity but enables project-specific personas without action changes.
|
||||
|
||||
2. **Model preference enforcement**: If persona specifies `model_preference: opus` but the action uses a different model, should we warn? Override? Ignore? Current thinking: log warning, use the specified model (user controls model via action input).
|
||||
|
||||
3. **Severity override output**: If persona defines custom severity levels (CRITICAL), should the JSON output include them, or map back to standard MAJOR/MINOR/NIT? Current thinking: keep standard output format, use severity calibration only for prompt guidance.
|
||||
|
||||
## Completion Checklist
|
||||
|
||||
1. Persona struct matches YAML schema exactly?
|
||||
2. Built-in personas embedded in binary (not external files)?
|
||||
3. `--persona` and `--persona-file` are mutually exclusive?
|
||||
4. Unknown persona name produces clear error with valid options?
|
||||
5. Empty persona file fields have sensible defaults?
|
||||
6. Persona prompt integrates with budget system (token counting)?
|
||||
7. Backwards compatibility: no flags = current behavior?
|
||||
8. Review header shows persona display name?
|
||||
9. Sentinel still uses reviewer-name (not persona name)?
|
||||
10. Unit tests cover parse errors, missing fields, valid YAML?
|
||||
|
||||
## Design Review Findings (Self-Review)
|
||||
|
||||
### Finding 1: Severity Mapping
|
||||
The persona YAML allows `critical` severity, but the LLM output parser (`review/parser.go`) only accepts MAJOR/MINOR/NIT.
|
||||
|
||||
**Resolution:** Keep standard output format. Persona severity section is ONLY for calibrating the LLM's judgment (prompt guidance). Output must still use MAJOR/MINOR/NIT. Document this clearly in persona format docs.
|
||||
|
||||
### Finding 2: Embedding Built-in Personas
|
||||
Go doesn't natively embed YAML. Must use `//go:embed` directive (Go 1.16+).
|
||||
|
||||
**Resolution:** Create `review/personas/` directory with YAML files and use:
|
||||
```go
|
||||
//go:embed personas/*.yaml
|
||||
var embeddedPersonas embed.FS
|
||||
```
|
||||
|
||||
### Finding 3: display_name vs reviewer-name
|
||||
Design says header shows "persona display name" but sentinel uses "reviewer-name". This is correct - they serve different purposes:
|
||||
- `display_name` → human-readable header ("Security Specialist Review")
|
||||
- `reviewer-name` → machine sentinel for cleanup (`<!-- review-bot:security -->`)
|
||||
|
||||
When persona is used, `display_name` takes precedence for the header title, but `reviewer-name` (CLI flag) is still used for the sentinel.
|
||||
|
||||
## Design Revision: YAML with gopkg.in/yaml.v3
|
||||
|
||||
**Decision:** Add `gopkg.in/yaml.v3` as a dependency.
|
||||
|
||||
YAML is preferred over JSON for persona files because:
|
||||
- Multi-line strings are cleaner (no escaping quotes in identity/focus text)
|
||||
- Comments are supported for documentation
|
||||
- More human-readable for complex persona definitions
|
||||
|
||||
The implementation supports both YAML (`.yaml`, `.yml`) and JSON (`.json`) for backwards compatibility, with YAML as the default for built-in personas.
|
||||
@@ -1,87 +0,0 @@
|
||||
# Design: YAML Support for Persona Files (#57)
|
||||
|
||||
## Problem
|
||||
|
||||
JSON is awkward for persona files that contain multi-line text (identity, severity descriptions). YAML supports cleaner multi-line strings and comments, improving readability and maintainability.
|
||||
|
||||
## Constraints
|
||||
|
||||
- Backwards compatibility: existing JSON personas must continue to work
|
||||
- Security: protect against DoS via deeply nested YAML (AIKIDO-2024-10486)
|
||||
- Consistency: use `.yaml` extension (not `.yml`)
|
||||
- Library: use `github.com/goccy/go-yaml` v1.16.0+ (approved in CONVENTIONS.md); we implement custom AST-based depth/node-count checks for precise alias-aware validation
|
||||
|
||||
## Proposed Approach
|
||||
|
||||
1. **Update `parsePersona`** to detect format from file extension
|
||||
2. **Add YAML parsing** with explicit depth limit (defense in depth)
|
||||
3. **Keep JSON as fallback** for files without `.yaml`/`.yml` extension
|
||||
4. **Convert built-in personas** to YAML format
|
||||
5. **Update embed directive** to include both formats
|
||||
|
||||
### File Extension Detection
|
||||
|
||||
```go
|
||||
func parsePersona(data []byte, source string) (*Persona, error) {
|
||||
isYAML := strings.HasSuffix(source, ".yaml") || strings.HasSuffix(source, ".yml")
|
||||
if isYAML {
|
||||
return parseYAML(data, source)
|
||||
}
|
||||
return parseJSON(data, source)
|
||||
}
|
||||
```
|
||||
|
||||
### YAML Parsing with Depth Protection
|
||||
|
||||
We implement a custom AST-based depth/node-count walk (`checkYAMLDepth` in
|
||||
`review/persona.go`) rather than relying on library decoder options. Key design
|
||||
decisions:
|
||||
|
||||
- **Library:** `github.com/goccy/go-yaml` with `ast.Node`-based traversal
|
||||
- **Dual-map tracking:** `validated` (depth-aware short-circuit) + `visiting` (cycle detection)
|
||||
- **Node-count limit:** Conservative overcounting bounds total validation work
|
||||
- **Alias-aware depth:** Aliases increment depth and are re-checked when encountered at greater depths
|
||||
|
||||
See `review/persona.go:checkYAMLDepth` for the authoritative implementation.
|
||||
|
||||
## State/Data Model
|
||||
|
||||
No new state. Same `Persona` struct, just different parsing.
|
||||
|
||||
## Error Cases
|
||||
|
||||
| Error | Handling |
|
||||
|-------|----------|
|
||||
| Invalid YAML syntax | Return parse error with source file |
|
||||
| Deeply nested YAML | Custom AST walk (`checkYAMLDepth`) rejects before decode |
|
||||
| Unknown extension | Fall back to JSON parsing |
|
||||
| Missing required fields | Validation rejects after parse |
|
||||
|
||||
## Edge Cases
|
||||
|
||||
- File with `.json` extension but YAML content → JSON parse fails, user sees error
|
||||
- File with no extension → defaults to JSON
|
||||
- Embedded persona reference like `builtin:security` → detect by embed path (`personas/X.yaml`)
|
||||
|
||||
## Testing Strategy
|
||||
|
||||
1. Unit tests for YAML parsing (valid, invalid, deeply nested)
|
||||
2. Unit tests for extension detection
|
||||
3. Integration test for built-in personas (now YAML)
|
||||
4. Backwards compat test: verify JSON still works for external files
|
||||
|
||||
## Completion Checklist
|
||||
|
||||
1. [ ] `go-yaml` dependency added at v1.16.0+
|
||||
2. [ ] Extension detection uses case-insensitive comparison
|
||||
3. [ ] YAML parse errors include source file name
|
||||
4. [ ] JSON parsing still works for `.json` files
|
||||
5. [ ] Built-in personas converted to YAML with readable multi-line strings
|
||||
6. [ ] Embed directive updated to include `*.yaml`
|
||||
7. [ ] Test for deeply nested YAML rejection
|
||||
8. [ ] All existing tests pass
|
||||
|
||||
## Open Questions
|
||||
|
||||
- Should we support both `.yaml` AND `.yml`? Issue says `.yaml` only for consistency, but some users expect `.yml`. **Decision:** Support both for reading, recommend `.yaml` in docs.
|
||||
- Should we add a "format" field to detect mismatched extension/content? **Decision:** No, keep it simple. Extension determines format.
|
||||
@@ -1,97 +0,0 @@
|
||||
# Review Update Strategy
|
||||
|
||||
review-bot uses an **edit-in-place** strategy for updating reviews. Reviews are never deleted — this preserves conversation threads on inline comments.
|
||||
|
||||
## State Transition Diagram
|
||||
|
||||
```mermaid
|
||||
stateDiagram-v2
|
||||
[*] --> NoExistingReview: First run
|
||||
|
||||
NoExistingReview --> POST_Review: Generate findings + event
|
||||
POST_Review --> PostEscalationCheck: event == APPROVED?
|
||||
|
||||
PostEscalationCheck --> Done: No sibling blocks
|
||||
PostEscalationCheck --> Supersede_And_Repost: Sibling has REQUEST_CHANGES
|
||||
Supersede_And_Repost --> Done: Posted as REQUEST_CHANGES
|
||||
|
||||
[*] --> ExistingReviewFound: Subsequent run (sentinel match)
|
||||
|
||||
ExistingReviewFound --> CheckEscalation: Determine final event
|
||||
CheckEscalation --> CompareState: Apply worst-wins if needed
|
||||
|
||||
CompareState --> SameState: existing.state == new event
|
||||
CompareState --> StateChange: existing.state != new event
|
||||
|
||||
SameState --> Skip: Body unchanged
|
||||
SameState --> PatchBody: Body changed → PATCH in place
|
||||
|
||||
StateChange --> Escalate: APPROVED → REQUEST_CHANGES
|
||||
StateChange --> Downgrade: REQUEST_CHANGES → APPROVED
|
||||
|
||||
Escalate --> Supersede: PATCH old body → "Superseded"
|
||||
Supersede --> POST_New_RC: POST new REQUEST_CHANGES
|
||||
|
||||
Downgrade --> POST_New_Approve: POST new APPROVED (old stays intact)
|
||||
|
||||
Skip --> Done
|
||||
PatchBody --> Done
|
||||
POST_New_RC --> Done
|
||||
POST_New_Approve --> Done
|
||||
```
|
||||
|
||||
## Rules
|
||||
|
||||
| Scenario | Action | Reason |
|
||||
|----------|--------|--------|
|
||||
| No existing review | POST new | First run |
|
||||
| Same state, same body | Skip | Nothing changed — preserve threads |
|
||||
| Same state, body changed | PATCH body | Update findings without losing threads |
|
||||
| APPROVED → REQUEST_CHANGES | Supersede old + POST new | Can always escalate; old APPROVED is no longer valid |
|
||||
| REQUEST_CHANGES → APPROVED | POST new APPROVED | Can't edit state; old REQUEST_CHANGES stays as historical record |
|
||||
| Sibling has REQUEST_CHANGES (worst-wins) | Escalate to REQUEST_CHANGES | PR must stay blocked if ANY reviewer blocks |
|
||||
|
||||
## Key Constraints
|
||||
|
||||
1. **Review state is immutable after POST** — Gitea has no API to change APPROVED ↔ REQUEST_CHANGES
|
||||
2. **Never delete reviews** — Deleting cascades to inline comments and reply threads
|
||||
3. **"Last review per user" wins** — Gitea uses the most recent review from a user for merge decisions
|
||||
4. **REQUEST_CHANGES reviews are never touched** — Their inline comments and threads are preserved as historical record
|
||||
5. **APPROVED reviews can be superseded** — When escalation is needed, mark old as superseded and POST new
|
||||
|
||||
## Worst-Wins (Shared Token)
|
||||
|
||||
When multiple reviewer roles share a token (e.g., `sonnet` and `security` both use `sonnet-review-bot`):
|
||||
|
||||
```
|
||||
CI Matrix Run:
|
||||
sonnet → REQUEST_CHANGES (findings)
|
||||
security → APPROVED (no security issues)
|
||||
↓
|
||||
security sees sibling REQUEST_CHANGES
|
||||
↓
|
||||
security escalates → REQUEST_CHANGES
|
||||
↓
|
||||
PR stays blocked ✓
|
||||
```
|
||||
|
||||
The **first-run case** (no existing review to read login from) uses a post-posting fallback:
|
||||
POST APPROVED → check siblings → if blocked, supersede own APPROVED → re-POST as REQUEST_CHANGES.
|
||||
|
||||
## Edit Mechanism
|
||||
|
||||
Reviews are edited via `PATCH /repos/{owner}/{repo}/issues/comments/{id}`:
|
||||
|
||||
- **Review body**: ID obtained from the timeline API (`/issues/{index}/timeline`, type `"review"`)
|
||||
- **Inline comments**: IDs obtained from `/pulls/{index}/reviews/{id}/comments`
|
||||
- **Both are editable** by the token that created them
|
||||
- **ListReviews always returns the original body** (reads from review table, not comment table) — sentinel matching works regardless of edits
|
||||
|
||||
## Inline Comments Lifecycle
|
||||
|
||||
| Event | Inline comments behavior |
|
||||
|-------|--------------------------|
|
||||
| First POST | Created on specific diff lines |
|
||||
| PATCH body (same state) | Unchanged — still current findings |
|
||||
| Supersede (state change) | Old inline comments stay (readable but on outdated code) |
|
||||
| New POST after supersede | Fresh inline comments on current diff |
|
||||
+45
-726
@@ -7,103 +7,21 @@ import (
|
||||
"bytes"
|
||||
"context"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
"io"
|
||||
"log/slog"
|
||||
"math"
|
||||
"net"
|
||||
"log"
|
||||
"net/http"
|
||||
"net/url"
|
||||
"strings"
|
||||
"syscall"
|
||||
"time"
|
||||
)
|
||||
|
||||
// APIError represents an HTTP error response from the Gitea API.
|
||||
// It carries the status code so callers can distinguish between
|
||||
// different failure modes (e.g. 404 vs 500).
|
||||
type APIError struct {
|
||||
StatusCode int
|
||||
Body string
|
||||
}
|
||||
|
||||
func (e *APIError) Error() string {
|
||||
body := e.Body
|
||||
if len(body) > 200 {
|
||||
body = body[:200] + "...(truncated)"
|
||||
}
|
||||
return fmt.Sprintf("HTTP %d: %s", e.StatusCode, body)
|
||||
}
|
||||
|
||||
// IsNotFound reports whether an error is an API 404 response.
|
||||
func IsNotFound(err error) bool {
|
||||
var apiErr *APIError
|
||||
return errors.As(err, &apiErr) && apiErr.StatusCode == http.StatusNotFound
|
||||
}
|
||||
|
||||
// IsServerError reports whether an error is an API 5xx response.
|
||||
func IsServerError(err error) bool {
|
||||
var apiErr *APIError
|
||||
return errors.As(err, &apiErr) && apiErr.StatusCode >= 500 && apiErr.StatusCode < 600
|
||||
}
|
||||
|
||||
// DefaultMaxDiffSize is the default maximum diff size in bytes (10 MB).
|
||||
const DefaultMaxDiffSize = 10 * 1024 * 1024
|
||||
|
||||
// ErrDiffTooLarge is returned when a PR diff exceeds the configured MaxDiffSize.
|
||||
var ErrDiffTooLarge = errors.New("diff size exceeds maximum allowed size")
|
||||
|
||||
// Client interacts with the Gitea API.
|
||||
// A Client is safe for concurrent use by multiple goroutines.
|
||||
type Client struct {
|
||||
baseURL string
|
||||
token string
|
||||
http *http.Client
|
||||
|
||||
// RetryBackoff defines the delays between retry attempts.
|
||||
// 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.
|
||||
//
|
||||
// This field must be configured before the first request is made.
|
||||
// Modifying it while requests are in flight is not safe.
|
||||
RetryBackoff []time.Duration
|
||||
|
||||
// MaxDiffSize is the maximum number of bytes allowed when fetching a PR diff.
|
||||
// If zero, defaults to DefaultMaxDiffSize (10 MB). Set to any negative value
|
||||
// (or math.MaxInt64) to disable the limit.
|
||||
//
|
||||
// This field must be configured before the first request is made.
|
||||
// Modifying it while requests are in flight is not safe.
|
||||
MaxDiffSize int64
|
||||
}
|
||||
|
||||
// defaultCheckRedirect is the redirect policy used by NewClient.
|
||||
// NOTE: This function is intentionally duplicated in github/client.go (and vice versa)
|
||||
// because the packages are separate. Changes here must be mirrored there.
|
||||
// It rejects HTTPS->HTTP protocol downgrades (to prevent plaintext leakage)
|
||||
// and cross-host redirects (to prevent following responses from untrusted
|
||||
// endpoints). Same-host, same-or-upgraded-scheme redirects are allowed.
|
||||
func defaultCheckRedirect(req *http.Request, via []*http.Request) error {
|
||||
if len(via) >= 10 {
|
||||
return fmt.Errorf("stopped after 10 redirects")
|
||||
}
|
||||
// Guard for direct invocation in tests and any future callers;
|
||||
// net/http guarantees len(via) >= 1 during actual redirects.
|
||||
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: HTTPS to HTTP downgrade (%s -> %s)", prev.URL.Host, req.URL.Host)
|
||||
}
|
||||
// Reject cross-host redirect entirely to avoid consuming responses
|
||||
// from untrusted endpoints.
|
||||
if req.URL.Host != prev.URL.Host {
|
||||
return fmt.Errorf("refusing redirect: cross-host (%s -> %s)", prev.URL.Host, req.URL.Host)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// NewClient creates a new Gitea API client.
|
||||
@@ -111,33 +29,10 @@ func NewClient(baseURL, token string) *Client {
|
||||
return &Client{
|
||||
baseURL: strings.TrimRight(baseURL, "/"),
|
||||
token: token,
|
||||
http: &http.Client{
|
||||
Timeout: 30 * time.Second,
|
||||
CheckRedirect: defaultCheckRedirect,
|
||||
},
|
||||
http: &http.Client{Timeout: 30 * time.Second},
|
||||
}
|
||||
}
|
||||
|
||||
// SetHTTPClient sets the underlying HTTP client used for requests.
|
||||
// This is intended for test setup only to inject mock transports; it must be
|
||||
// called before any goroutines issue requests.
|
||||
//
|
||||
// Passing nil restores the default client (30s timeout + redirect-rejecting
|
||||
// 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.http = hc
|
||||
}
|
||||
|
||||
// PullRequest holds relevant PR metadata.
|
||||
type PullRequest struct {
|
||||
Title string `json:"title"`
|
||||
@@ -162,17 +57,9 @@ type ChangedFile struct {
|
||||
Status string `json:"status"`
|
||||
}
|
||||
|
||||
// ReviewComment represents an inline comment to attach to a review.
|
||||
type ReviewComment struct {
|
||||
ID int64 `json:"id,omitempty"`
|
||||
Path string `json:"path"`
|
||||
NewPosition int64 `json:"new_position"`
|
||||
Body string `json:"body"`
|
||||
}
|
||||
|
||||
// GetPullRequest fetches PR metadata.
|
||||
func (c *Client) GetPullRequest(ctx context.Context, owner, repo string, number int) (*PullRequest, error) {
|
||||
reqURL := fmt.Sprintf("%s/api/v1/repos/%s/%s/pulls/%d", c.baseURL, url.PathEscape(owner), url.PathEscape(repo), number)
|
||||
reqURL := fmt.Sprintf("%s/api/v1/repos/%s/%s/pulls/%d", c.baseURL, owner, repo, number)
|
||||
body, err := c.doGet(ctx, reqURL)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("fetch PR: %w", err)
|
||||
@@ -185,28 +72,9 @@ func (c *Client) GetPullRequest(ctx context.Context, owner, repo string, number
|
||||
}
|
||||
|
||||
// GetPullRequestDiff fetches the unified diff for a PR.
|
||||
// It enforces MaxDiffSize to prevent unbounded memory allocation.
|
||||
// Returns ErrDiffTooLarge if the diff exceeds the configured limit.
|
||||
func (c *Client) GetPullRequestDiff(ctx context.Context, owner, repo string, number int) (string, error) {
|
||||
reqURL := fmt.Sprintf("%s/api/v1/repos/%s/%s/pulls/%d.diff", c.baseURL, url.PathEscape(owner), url.PathEscape(repo), number)
|
||||
|
||||
maxSize := c.MaxDiffSize
|
||||
if maxSize == 0 {
|
||||
maxSize = DefaultMaxDiffSize
|
||||
}
|
||||
|
||||
// When the limit is disabled (negative) or set to math.MaxInt64 (which
|
||||
// would overflow the +1 detection and silently disable enforcement),
|
||||
// use the standard unlimited doGet path.
|
||||
if maxSize < 0 || maxSize == math.MaxInt64 {
|
||||
body, err := c.doGet(ctx, reqURL)
|
||||
if err != nil {
|
||||
return "", fmt.Errorf("fetch diff: %w", err)
|
||||
}
|
||||
return string(body), nil
|
||||
}
|
||||
|
||||
body, err := c.doGetLimited(ctx, reqURL, maxSize)
|
||||
reqURL := fmt.Sprintf("%s/api/v1/repos/%s/%s/pulls/%d.diff", c.baseURL, owner, repo, number)
|
||||
body, err := c.doGet(ctx, reqURL)
|
||||
if err != nil {
|
||||
return "", fmt.Errorf("fetch diff: %w", err)
|
||||
}
|
||||
@@ -215,7 +83,7 @@ func (c *Client) GetPullRequestDiff(ctx context.Context, owner, repo string, num
|
||||
|
||||
// GetPullRequestFiles fetches the list of files changed in a PR.
|
||||
func (c *Client) GetPullRequestFiles(ctx context.Context, owner, repo string, number int) ([]ChangedFile, error) {
|
||||
reqURL := fmt.Sprintf("%s/api/v1/repos/%s/%s/pulls/%d/files", c.baseURL, url.PathEscape(owner), url.PathEscape(repo), number)
|
||||
reqURL := fmt.Sprintf("%s/api/v1/repos/%s/%s/pulls/%d/files", c.baseURL, owner, repo, number)
|
||||
body, err := c.doGet(ctx, reqURL)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("fetch PR files: %w", err)
|
||||
@@ -229,7 +97,7 @@ func (c *Client) GetPullRequestFiles(ctx context.Context, owner, repo string, nu
|
||||
|
||||
// GetCommitStatuses fetches CI statuses for a commit SHA.
|
||||
func (c *Client) GetCommitStatuses(ctx context.Context, owner, repo, sha string) ([]CommitStatus, error) {
|
||||
reqURL := fmt.Sprintf("%s/api/v1/repos/%s/%s/commits/%s/statuses", c.baseURL, url.PathEscape(owner), url.PathEscape(repo), url.PathEscape(sha))
|
||||
reqURL := fmt.Sprintf("%s/api/v1/repos/%s/%s/commits/%s/statuses", c.baseURL, owner, repo, sha)
|
||||
body, err := c.doGet(ctx, reqURL)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("fetch commit statuses: %w", err)
|
||||
@@ -243,7 +111,7 @@ func (c *Client) GetCommitStatuses(ctx context.Context, owner, repo, sha string)
|
||||
|
||||
// GetFileContent fetches a file from the default branch of a repo.
|
||||
func (c *Client) GetFileContent(ctx context.Context, owner, repo, filepath string) (string, error) {
|
||||
reqURL := fmt.Sprintf("%s/api/v1/repos/%s/%s/raw/%s", c.baseURL, url.PathEscape(owner), url.PathEscape(repo), escapePath(filepath))
|
||||
reqURL := fmt.Sprintf("%s/api/v1/repos/%s/%s/raw/%s", c.baseURL, owner, repo, escapePath(filepath))
|
||||
body, err := c.doGet(ctx, reqURL)
|
||||
if err != nil {
|
||||
return "", fmt.Errorf("fetch file %s: %w", filepath, err)
|
||||
@@ -253,7 +121,7 @@ func (c *Client) GetFileContent(ctx context.Context, owner, repo, filepath strin
|
||||
|
||||
// GetFileContentRef fetches a file from a specific ref (branch/tag/sha) in a repo.
|
||||
func (c *Client) GetFileContentRef(ctx context.Context, owner, repo, filepath, ref string) (string, error) {
|
||||
reqURL := fmt.Sprintf("%s/api/v1/repos/%s/%s/raw/%s?ref=%s", c.baseURL, url.PathEscape(owner), url.PathEscape(repo), escapePath(filepath), url.QueryEscape(ref))
|
||||
reqURL := fmt.Sprintf("%s/api/v1/repos/%s/%s/raw/%s?ref=%s", c.baseURL, owner, repo, escapePath(filepath), url.QueryEscape(ref))
|
||||
body, err := c.doGet(ctx, reqURL)
|
||||
if err != nil {
|
||||
return "", fmt.Errorf("fetch file %s@%s: %w", filepath, ref, err)
|
||||
@@ -261,272 +129,62 @@ func (c *Client) GetFileContentRef(ctx context.Context, owner, repo, filepath, r
|
||||
return string(body), nil
|
||||
}
|
||||
|
||||
// PostReview submits a review to a PR and returns the created review.
|
||||
// event should be one of "APPROVED", "REQUEST_CHANGES", or "COMMENT".
|
||||
// commitID anchors the review to a specific commit SHA. If empty, Gitea
|
||||
// defaults to the current PR head.
|
||||
// comments are optional inline comments attached to specific lines.
|
||||
func (c *Client) PostReview(ctx context.Context, owner, repo string, number int, event, body, commitID string, comments []ReviewComment) (*Review, error) {
|
||||
reqURL := fmt.Sprintf("%s/api/v1/repos/%s/%s/pulls/%d/reviews", c.baseURL, url.PathEscape(owner), url.PathEscape(repo), number)
|
||||
// PostReview submits a review to a PR.
|
||||
// event should be "APPROVED" or "REQUEST_CHANGES".
|
||||
func (c *Client) PostReview(ctx context.Context, owner, repo string, number int, event, body string) error {
|
||||
reqURL := fmt.Sprintf("%s/api/v1/repos/%s/%s/pulls/%d/reviews", c.baseURL, owner, repo, number)
|
||||
|
||||
payload := struct {
|
||||
Body string `json:"body"`
|
||||
Event string `json:"event"`
|
||||
CommitID string `json:"commit_id,omitempty"`
|
||||
Comments []ReviewComment `json:"comments,omitempty"`
|
||||
Body string `json:"body"`
|
||||
Event string `json:"event"`
|
||||
}{
|
||||
Body: body,
|
||||
Event: event,
|
||||
CommitID: commitID,
|
||||
Comments: comments,
|
||||
Body: body,
|
||||
Event: event,
|
||||
}
|
||||
|
||||
data, err := json.Marshal(payload)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("marshal review payload: %w", err)
|
||||
return fmt.Errorf("marshal review payload: %w", err)
|
||||
}
|
||||
|
||||
req, err := http.NewRequestWithContext(ctx, http.MethodPost, reqURL, bytes.NewReader(data))
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("create review request: %w", err)
|
||||
return fmt.Errorf("create review request: %w", err)
|
||||
}
|
||||
req.Header.Set("Authorization", "token "+c.token)
|
||||
req.Header.Set("Content-Type", "application/json")
|
||||
|
||||
resp, err := c.http.Do(req)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("post review: %w", err)
|
||||
return fmt.Errorf("post review: %w", err)
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
|
||||
if resp.StatusCode < 200 || resp.StatusCode >= 300 {
|
||||
respBody, _ := io.ReadAll(resp.Body)
|
||||
return nil, fmt.Errorf("post review failed (status %d): %s", resp.StatusCode, string(respBody))
|
||||
return fmt.Errorf("post review failed (status %d): %s", resp.StatusCode, string(respBody))
|
||||
}
|
||||
|
||||
respBody, err := io.ReadAll(resp.Body)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("read review response: %w", err)
|
||||
}
|
||||
var review Review
|
||||
if err := json.Unmarshal(respBody, &review); err != nil {
|
||||
return nil, fmt.Errorf("parse review response: %w", err)
|
||||
}
|
||||
return &review, nil
|
||||
return nil
|
||||
}
|
||||
|
||||
// isTemporaryNetError reports whether err is a temporary network error worth retrying.
|
||||
// This includes connection refused, network unreachable, connection reset, and DNS
|
||||
// timeouts. It explicitly excludes permanent errors like permission denied or
|
||||
// "no such host" DNS failures.
|
||||
func isTemporaryNetError(err error) bool {
|
||||
if err == nil {
|
||||
return false
|
||||
}
|
||||
|
||||
// Check for OpError and inspect the underlying syscall error.
|
||||
// Not all OpErrors are transient — permission denied, for example, is permanent.
|
||||
var opErr *net.OpError
|
||||
if errors.As(err, &opErr) {
|
||||
return isRetriableSyscallError(opErr.Err)
|
||||
}
|
||||
|
||||
// DNS errors: only retry on timeout, not on "no such host" which is permanent.
|
||||
var dnsErr *net.DNSError
|
||||
if errors.As(err, &dnsErr) {
|
||||
return dnsErr.IsTimeout
|
||||
}
|
||||
|
||||
// Check for net.Error with Timeout() (Temporary is deprecated)
|
||||
var netErr net.Error
|
||||
if errors.As(err, &netErr) {
|
||||
return netErr.Timeout()
|
||||
}
|
||||
|
||||
return false
|
||||
}
|
||||
|
||||
// isRetriableSyscallError reports whether the underlying error from a net.OpError
|
||||
// is a transient syscall error worth retrying.
|
||||
func isRetriableSyscallError(err error) bool {
|
||||
if err == nil {
|
||||
return false
|
||||
}
|
||||
|
||||
// Check for syscall.Errno directly or wrapped
|
||||
var errno syscall.Errno
|
||||
if errors.As(err, &errno) {
|
||||
switch errno {
|
||||
case syscall.ECONNREFUSED, // connection refused — server not listening
|
||||
syscall.ECONNRESET, // connection reset by peer
|
||||
syscall.ENETUNREACH, // network unreachable
|
||||
syscall.EHOSTUNREACH, // host unreachable
|
||||
syscall.ETIMEDOUT: // connection timed out
|
||||
return true
|
||||
default:
|
||||
// EACCES, EPERM, etc. are permanent — don't retry
|
||||
return false
|
||||
}
|
||||
}
|
||||
|
||||
// If we can't identify the specific syscall error, be conservative and retry.
|
||||
// This handles wrapped errors or platform-specific error types.
|
||||
// The retry count is limited, so erring on the side of retrying is safe.
|
||||
return true
|
||||
}
|
||||
|
||||
// redactURL strips query parameters and userinfo credentials from a URL for
|
||||
// safe logging. This prevents accidental exposure of sensitive data (tokens in
|
||||
// query strings, or user:pass in the authority) in log output.
|
||||
func redactURL(rawURL string) string {
|
||||
parsed, err := url.Parse(rawURL)
|
||||
if err != nil {
|
||||
// If we cannot parse it, return a safe placeholder rather than
|
||||
// potentially logging something sensitive.
|
||||
return "[invalid URL]"
|
||||
}
|
||||
if parsed.User != nil {
|
||||
parsed.User = url.User("REDACTED")
|
||||
}
|
||||
if parsed.RawQuery != "" {
|
||||
parsed.RawQuery = "[redacted]"
|
||||
}
|
||||
return parsed.String()
|
||||
}
|
||||
|
||||
// sanitizeErrorForLog returns a loggable version of an error that omits
|
||||
// potentially sensitive content like response bodies. For APIError, only
|
||||
// the status code is included; for other errors, the type is preserved.
|
||||
func sanitizeErrorForLog(err error) string {
|
||||
if err == nil {
|
||||
return "<nil>"
|
||||
}
|
||||
var apiErr *APIError
|
||||
if errors.As(err, &apiErr) {
|
||||
return fmt.Sprintf("HTTP %d", apiErr.StatusCode)
|
||||
}
|
||||
return err.Error()
|
||||
}
|
||||
|
||||
// doGetWithReader performs an HTTP GET request with retry on 5xx errors and
|
||||
// temporary network errors. Retries up to 3 times with exponential backoff
|
||||
// (1s, 2s delays by default; configurable via Client.RetryBackoff for testing).
|
||||
// The readBody function is called with the response body on success (2xx) and
|
||||
// is responsible for reading and closing it.
|
||||
func (c *Client) doGetWithReader(ctx context.Context, reqURL string, readBody func(io.ReadCloser) ([]byte, error)) ([]byte, error) {
|
||||
const maxAttempts = 3
|
||||
// backoff[i] is the delay before attempt i+1 (i.e., after attempt i fails).
|
||||
// First attempt (i=0) has no delay; retries wait 1s then 2s by default.
|
||||
backoff := c.RetryBackoff
|
||||
if backoff == nil {
|
||||
backoff = []time.Duration{1 * time.Second, 2 * time.Second}
|
||||
}
|
||||
|
||||
// maxErrorBodyBytes limits how much of an error response body we read
|
||||
// to protect against malicious servers sending unbounded data.
|
||||
const maxErrorBodyBytes = 64 * 1024 // 64 KB
|
||||
|
||||
var lastErr error
|
||||
for attempt := 0; attempt < maxAttempts; attempt++ {
|
||||
if attempt > 0 {
|
||||
// Determine delay: use backoff slice if available, otherwise retry immediately.
|
||||
// An empty RetryBackoff slice means "retry without delay" — this is intentional
|
||||
// as the caller explicitly configured no delays.
|
||||
var delay time.Duration
|
||||
if attempt-1 < len(backoff) {
|
||||
delay = backoff[attempt-1]
|
||||
}
|
||||
|
||||
if delay > 0 {
|
||||
slog.Warn("retrying request after error",
|
||||
"attempt", attempt+1,
|
||||
"url", redactURL(reqURL),
|
||||
"delay", delay.String(),
|
||||
"lastError", sanitizeErrorForLog(lastErr))
|
||||
|
||||
timer := time.NewTimer(delay)
|
||||
select {
|
||||
case <-timer.C:
|
||||
case <-ctx.Done():
|
||||
timer.Stop()
|
||||
return nil, ctx.Err()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
req, err := http.NewRequestWithContext(ctx, http.MethodGet, reqURL, nil)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
req.Header.Set("Authorization", "token "+c.token)
|
||||
|
||||
resp, err := c.http.Do(req)
|
||||
if err != nil {
|
||||
// Always capture the error for consistent return at loop end.
|
||||
// This ensures both network errors and HTTP 5xx return lastErr.
|
||||
lastErr = err
|
||||
|
||||
// Only retry temporary network errors when attempts remain.
|
||||
if attempt < maxAttempts-1 && isTemporaryNetError(err) {
|
||||
slog.Warn("temporary network error, will retry",
|
||||
"attempt", attempt+1,
|
||||
"url", redactURL(reqURL),
|
||||
"error", err)
|
||||
continue
|
||||
}
|
||||
// Non-retryable network error or final attempt exhausted.
|
||||
return nil, lastErr
|
||||
}
|
||||
if resp.StatusCode >= 200 && resp.StatusCode < 300 {
|
||||
return readBody(resp.Body)
|
||||
}
|
||||
|
||||
// Error path: limit how much we read from potentially malicious server
|
||||
errBody, _ := io.ReadAll(io.LimitReader(resp.Body, maxErrorBodyBytes))
|
||||
resp.Body.Close()
|
||||
|
||||
lastErr = &APIError{StatusCode: resp.StatusCode, Body: string(errBody)}
|
||||
|
||||
// Only retry on 5xx server errors
|
||||
if resp.StatusCode < 500 || resp.StatusCode >= 600 {
|
||||
return nil, lastErr
|
||||
}
|
||||
}
|
||||
|
||||
return nil, lastErr
|
||||
}
|
||||
|
||||
// doGet performs an HTTP GET request with retry, reading the full response body.
|
||||
func (c *Client) doGet(ctx context.Context, reqURL string) ([]byte, error) {
|
||||
return c.doGetWithReader(ctx, reqURL, func(body io.ReadCloser) ([]byte, error) {
|
||||
defer body.Close()
|
||||
return io.ReadAll(body)
|
||||
})
|
||||
}
|
||||
req, err := http.NewRequestWithContext(ctx, http.MethodGet, reqURL, nil)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
req.Header.Set("Authorization", "token "+c.token)
|
||||
|
||||
// doGetLimited performs an HTTP GET request with retry but enforces a maximum
|
||||
// response body size. Returns ErrDiffTooLarge if the response exceeds maxBytes.
|
||||
// It reads maxBytes+1 (clamped to avoid overflow) to detect truncation without
|
||||
// buffering the entire body.
|
||||
func (c *Client) doGetLimited(ctx context.Context, reqURL string, maxBytes int64) ([]byte, error) {
|
||||
return c.doGetWithReader(ctx, reqURL, func(body io.ReadCloser) ([]byte, error) {
|
||||
defer body.Close()
|
||||
// Read up to maxBytes+1 to detect overflow.
|
||||
// Clamp to prevent integer overflow when maxBytes == math.MaxInt64.
|
||||
limitBytes := maxBytes + 1
|
||||
if limitBytes <= 0 {
|
||||
limitBytes = math.MaxInt64
|
||||
}
|
||||
limited := io.LimitReader(body, limitBytes)
|
||||
data, err := io.ReadAll(limited)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if int64(len(data)) > maxBytes {
|
||||
return nil, fmt.Errorf("%w: response exceeds %d bytes", ErrDiffTooLarge, maxBytes)
|
||||
}
|
||||
return data, nil
|
||||
})
|
||||
resp, err := c.http.Do(req)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
|
||||
if resp.StatusCode < 200 || resp.StatusCode >= 300 {
|
||||
body, _ := io.ReadAll(resp.Body)
|
||||
return nil, fmt.Errorf("HTTP %d: %s", resp.StatusCode, string(body))
|
||||
}
|
||||
return io.ReadAll(resp.Body)
|
||||
}
|
||||
|
||||
// escapePath escapes each segment of a relative file path for use in URLs.
|
||||
@@ -550,18 +208,12 @@ type ContentEntry struct {
|
||||
|
||||
// ListContents lists files and directories at a given path in a repo.
|
||||
// Pass an empty path to list the repository root.
|
||||
// If the path points to a file (not a directory), Gitea returns a single
|
||||
// object instead of an array; this method normalizes both cases to a slice.
|
||||
func (c *Client) ListContents(ctx context.Context, owner, repo, path string) ([]ContentEntry, error) {
|
||||
// Normalize "." to empty string — Gitea API rejects "." with 500
|
||||
if path == "." {
|
||||
path = ""
|
||||
}
|
||||
var reqURL string
|
||||
if path == "" {
|
||||
reqURL = fmt.Sprintf("%s/api/v1/repos/%s/%s/contents", c.baseURL, url.PathEscape(owner), url.PathEscape(repo))
|
||||
reqURL = fmt.Sprintf("%s/api/v1/repos/%s/%s/contents", c.baseURL, owner, repo)
|
||||
} else {
|
||||
reqURL = fmt.Sprintf("%s/api/v1/repos/%s/%s/contents/%s", c.baseURL, url.PathEscape(owner), url.PathEscape(repo), escapePath(path))
|
||||
reqURL = fmt.Sprintf("%s/api/v1/repos/%s/%s/contents/%s", c.baseURL, owner, repo, escapePath(path))
|
||||
}
|
||||
body, err := c.doGet(ctx, reqURL)
|
||||
if err != nil {
|
||||
@@ -569,16 +221,7 @@ func (c *Client) ListContents(ctx context.Context, owner, repo, path string) ([]
|
||||
}
|
||||
var entries []ContentEntry
|
||||
if err := json.Unmarshal(body, &entries); err != nil {
|
||||
// Gitea returns a single object (not an array) when path is a file
|
||||
var single ContentEntry
|
||||
if err2 := json.Unmarshal(body, &single); err2 != nil {
|
||||
return nil, fmt.Errorf("parse contents JSON: %w", err)
|
||||
}
|
||||
// Guard against empty/malformed responses
|
||||
if single.Name == "" && single.Path == "" {
|
||||
return nil, fmt.Errorf("parse contents JSON: empty response for path %q", path)
|
||||
}
|
||||
entries = []ContentEntry{single}
|
||||
return nil, fmt.Errorf("parse contents JSON: %w", err)
|
||||
}
|
||||
return entries, nil
|
||||
}
|
||||
@@ -592,15 +235,10 @@ func (c *Client) GetAllFilesInPath(ctx context.Context, owner, repo, path string
|
||||
// Try listing as directory first
|
||||
entries, err := c.ListContents(ctx, owner, repo, path)
|
||||
if err != nil {
|
||||
// Only fall back to single-file fetch on 404 (path is a file, not a dir).
|
||||
// Propagate all other errors (auth failures, server errors, rate limits).
|
||||
if !IsNotFound(err) {
|
||||
return nil, fmt.Errorf("list contents %q: %w", path, err)
|
||||
}
|
||||
// 404 means the path might be a file — try fetching directly
|
||||
// Might be a file, try fetching directly
|
||||
content, fileErr := c.GetFileContent(ctx, owner, repo, path)
|
||||
if fileErr != nil {
|
||||
return nil, fmt.Errorf("path %q is neither a file nor directory: %w", path, fileErr)
|
||||
return nil, fmt.Errorf("path %q is neither a file nor directory: %w", path, err)
|
||||
}
|
||||
results[path] = content
|
||||
return results, nil
|
||||
@@ -611,14 +249,14 @@ func (c *Client) GetAllFilesInPath(ctx context.Context, owner, repo, path string
|
||||
case "file":
|
||||
content, err := c.GetFileContent(ctx, owner, repo, entry.Path)
|
||||
if err != nil {
|
||||
slog.Warn("could not fetch file from patterns repo", "file", entry.Path, "error", err)
|
||||
log.Printf("Warning: could not fetch file %s: %v", entry.Path, err)
|
||||
continue
|
||||
}
|
||||
results[entry.Path] = content
|
||||
case "dir":
|
||||
subResults, err := c.GetAllFilesInPath(ctx, owner, repo, entry.Path)
|
||||
if err != nil {
|
||||
slog.Warn("could not recurse into directory", "dir", entry.Path, "error", err)
|
||||
log.Printf("Warning: could not recurse into %s: %v", entry.Path, err)
|
||||
continue
|
||||
}
|
||||
for k, v := range subResults {
|
||||
@@ -628,322 +266,3 @@ func (c *Client) GetAllFilesInPath(ctx context.Context, owner, repo, path string
|
||||
}
|
||||
return results, nil
|
||||
}
|
||||
|
||||
// Review represents a pull request review from the Gitea API.
|
||||
type Review struct {
|
||||
ID int64 `json:"id"`
|
||||
Body string `json:"body"`
|
||||
User struct {
|
||||
Login string `json:"login"`
|
||||
} `json:"user"`
|
||||
State string `json:"state"`
|
||||
Stale bool `json:"stale"`
|
||||
CommitID string `json:"commit_id"`
|
||||
}
|
||||
|
||||
// ListReviews returns all reviews on a pull request.
|
||||
// Paginates through all pages to ensure no reviews are missed.
|
||||
func (c *Client) ListReviews(ctx context.Context, owner, repo string, number int) ([]Review, error) {
|
||||
const pageSize = 50
|
||||
var all []Review
|
||||
for page := 1; ; page++ {
|
||||
reqURL := fmt.Sprintf("%s/api/v1/repos/%s/%s/pulls/%d/reviews?limit=%d&page=%d",
|
||||
c.baseURL,
|
||||
url.PathEscape(owner),
|
||||
url.PathEscape(repo),
|
||||
number,
|
||||
pageSize,
|
||||
page)
|
||||
body, err := c.doGet(ctx, reqURL)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("list reviews (page %d): %w", page, err)
|
||||
}
|
||||
var batch []Review
|
||||
if err := json.Unmarshal(body, &batch); err != nil {
|
||||
return nil, fmt.Errorf("parse reviews (page %d): %w", page, err)
|
||||
}
|
||||
all = append(all, batch...)
|
||||
if len(batch) < pageSize {
|
||||
break
|
||||
}
|
||||
}
|
||||
return all, nil
|
||||
}
|
||||
|
||||
// DeleteReview deletes a review by ID. The token must belong to the review author.
|
||||
func (c *Client) DeleteReview(ctx context.Context, owner, repo string, number int, reviewID int64) error {
|
||||
reqURL := fmt.Sprintf("%s/api/v1/repos/%s/%s/pulls/%d/reviews/%d",
|
||||
c.baseURL,
|
||||
url.PathEscape(owner),
|
||||
url.PathEscape(repo),
|
||||
number,
|
||||
reviewID)
|
||||
|
||||
req, err := http.NewRequestWithContext(ctx, http.MethodDelete, reqURL, nil)
|
||||
if err != nil {
|
||||
return fmt.Errorf("create delete request: %w", err)
|
||||
}
|
||||
req.Header.Set("Authorization", "token "+c.token)
|
||||
|
||||
resp, err := c.http.Do(req)
|
||||
if err != nil {
|
||||
return fmt.Errorf("delete review: %w", err)
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
|
||||
if resp.StatusCode < 200 || resp.StatusCode >= 300 {
|
||||
respBody, _ := io.ReadAll(resp.Body)
|
||||
return fmt.Errorf("delete review failed (status %d): %s", resp.StatusCode, string(respBody))
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// TimelineEvent represents an entry from the issue timeline API.
|
||||
type TimelineEvent struct {
|
||||
ID int64 `json:"id"`
|
||||
Type string `json:"type"`
|
||||
Body string `json:"body"`
|
||||
User struct {
|
||||
Login string `json:"login"`
|
||||
} `json:"user"`
|
||||
}
|
||||
|
||||
// GetTimelineReviewCommentID finds the comment ID for a review body by
|
||||
// scanning the issue timeline for a review event containing the sentinel.
|
||||
func (c *Client) GetTimelineReviewCommentID(ctx context.Context, owner, repo string, number int, sentinel string) (int64, error) {
|
||||
const pageSize = 50
|
||||
for page := 1; ; page++ {
|
||||
reqURL := fmt.Sprintf("%s/api/v1/repos/%s/%s/issues/%d/timeline?limit=%d&page=%d",
|
||||
c.baseURL,
|
||||
url.PathEscape(owner),
|
||||
url.PathEscape(repo),
|
||||
number,
|
||||
pageSize,
|
||||
page)
|
||||
body, err := c.doGet(ctx, reqURL)
|
||||
if err != nil {
|
||||
return 0, fmt.Errorf("get timeline (page %d): %w", page, err)
|
||||
}
|
||||
var events []TimelineEvent
|
||||
if err := json.Unmarshal(body, &events); err != nil {
|
||||
return 0, fmt.Errorf("parse timeline (page %d): %w", page, err)
|
||||
}
|
||||
for _, ev := range events {
|
||||
if ev.Type == "review" && strings.Contains(ev.Body, sentinel) {
|
||||
return ev.ID, nil
|
||||
}
|
||||
}
|
||||
if len(events) < pageSize {
|
||||
break
|
||||
}
|
||||
}
|
||||
return 0, fmt.Errorf("no timeline event found with sentinel")
|
||||
}
|
||||
|
||||
// GetTimelineReviewCommentIDForReview finds the timeline comment ID for a
|
||||
// specific review by matching its body content in the timeline.
|
||||
func (c *Client) GetTimelineReviewCommentIDForReview(ctx context.Context, owner, repo string, number int, reviewID int64) (int64, error) {
|
||||
// Use the reviews API to get the review body, then find in timeline
|
||||
reqURL := fmt.Sprintf("%s/api/v1/repos/%s/%s/pulls/%d/reviews/%d",
|
||||
c.baseURL,
|
||||
url.PathEscape(owner),
|
||||
url.PathEscape(repo),
|
||||
number,
|
||||
reviewID)
|
||||
body, err := c.doGet(ctx, reqURL)
|
||||
if err != nil {
|
||||
return 0, fmt.Errorf("get review %d: %w", reviewID, err)
|
||||
}
|
||||
var review struct {
|
||||
Body string `json:"body"`
|
||||
User struct {
|
||||
Login string `json:"login"`
|
||||
} `json:"user"`
|
||||
}
|
||||
if err := json.Unmarshal(body, &review); err != nil {
|
||||
return 0, fmt.Errorf("parse review %d: %w", reviewID, err)
|
||||
}
|
||||
if review.Body == "" {
|
||||
return 0, fmt.Errorf("review %d has empty body", reviewID)
|
||||
}
|
||||
|
||||
// Use a prefix for matching (handles minor trailing whitespace differences)
|
||||
matchPrefix := review.Body
|
||||
if len(matchPrefix) > 200 {
|
||||
matchPrefix = matchPrefix[:200]
|
||||
}
|
||||
|
||||
const pageSize = 50
|
||||
for page := 1; ; page++ {
|
||||
timelineURL := fmt.Sprintf("%s/api/v1/repos/%s/%s/issues/%d/timeline?limit=%d&page=%d",
|
||||
c.baseURL,
|
||||
url.PathEscape(owner),
|
||||
url.PathEscape(repo),
|
||||
number,
|
||||
pageSize,
|
||||
page)
|
||||
tlBody, err := c.doGet(ctx, timelineURL)
|
||||
if err != nil {
|
||||
return 0, fmt.Errorf("get timeline (page %d): %w", page, err)
|
||||
}
|
||||
var events []TimelineEvent
|
||||
if err := json.Unmarshal(tlBody, &events); err != nil {
|
||||
return 0, fmt.Errorf("parse timeline (page %d): %w", page, err)
|
||||
}
|
||||
for _, ev := range events {
|
||||
if ev.Type == "review" && ev.User.Login == review.User.Login && strings.HasPrefix(ev.Body, matchPrefix) {
|
||||
return ev.ID, nil
|
||||
}
|
||||
}
|
||||
if len(events) < pageSize {
|
||||
break
|
||||
}
|
||||
}
|
||||
return 0, fmt.Errorf("no timeline event found for review %d", reviewID)
|
||||
}
|
||||
|
||||
// EditComment updates the body of an issue/review comment.
|
||||
func (c *Client) EditComment(ctx context.Context, owner, repo string, commentID int64, newBody string) error {
|
||||
reqURL := fmt.Sprintf("%s/api/v1/repos/%s/%s/issues/comments/%d",
|
||||
c.baseURL,
|
||||
url.PathEscape(owner),
|
||||
url.PathEscape(repo),
|
||||
commentID)
|
||||
|
||||
payload := struct {
|
||||
Body string `json:"body"`
|
||||
}{Body: newBody}
|
||||
data, err := json.Marshal(payload)
|
||||
if err != nil {
|
||||
return fmt.Errorf("marshal edit payload: %w", err)
|
||||
}
|
||||
|
||||
req, err := http.NewRequestWithContext(ctx, http.MethodPatch, reqURL, bytes.NewReader(data))
|
||||
if err != nil {
|
||||
return fmt.Errorf("create edit request: %w", err)
|
||||
}
|
||||
req.Header.Set("Authorization", "token "+c.token)
|
||||
req.Header.Set("Content-Type", "application/json")
|
||||
|
||||
resp, err := c.http.Do(req)
|
||||
if err != nil {
|
||||
return fmt.Errorf("edit comment: %w", err)
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
|
||||
if resp.StatusCode != http.StatusOK {
|
||||
body, _ := io.ReadAll(resp.Body)
|
||||
return fmt.Errorf("edit comment failed (status %d): %s", resp.StatusCode, body)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// GetAuthenticatedUser returns the login of the user authenticated by the token.
|
||||
func (c *Client) GetAuthenticatedUser(ctx context.Context) (string, error) {
|
||||
reqURL := fmt.Sprintf("%s/api/v1/user", c.baseURL)
|
||||
body, err := c.doGet(ctx, reqURL)
|
||||
if err != nil {
|
||||
return "", fmt.Errorf("get authenticated user: %w", err)
|
||||
}
|
||||
var result struct {
|
||||
Login string `json:"login"`
|
||||
}
|
||||
if err := json.Unmarshal(body, &result); err != nil {
|
||||
return "", fmt.Errorf("parse user response: %w", err)
|
||||
}
|
||||
return result.Login, nil
|
||||
}
|
||||
|
||||
// RequestReviewer adds the given user as a requested reviewer on a pull request.
|
||||
// This is idempotent — requesting an already-requested reviewer is a no-op.
|
||||
func (c *Client) RequestReviewer(ctx context.Context, owner, repo string, number int, reviewer string) error {
|
||||
reqURL := fmt.Sprintf("%s/api/v1/repos/%s/%s/pulls/%d/requested_reviewers",
|
||||
c.baseURL,
|
||||
url.PathEscape(owner),
|
||||
url.PathEscape(repo),
|
||||
number)
|
||||
|
||||
payload := struct {
|
||||
Reviewers []string `json:"reviewers"`
|
||||
}{Reviewers: []string{reviewer}}
|
||||
data, err := json.Marshal(payload)
|
||||
if err != nil {
|
||||
return fmt.Errorf("marshal reviewer request: %w", err)
|
||||
}
|
||||
|
||||
req, err := http.NewRequestWithContext(ctx, http.MethodPost, reqURL, bytes.NewReader(data))
|
||||
if err != nil {
|
||||
return fmt.Errorf("create reviewer request: %w", err)
|
||||
}
|
||||
req.Header.Set("Authorization", "token "+c.token)
|
||||
req.Header.Set("Content-Type", "application/json")
|
||||
|
||||
resp, err := c.http.Do(req)
|
||||
if err != nil {
|
||||
return fmt.Errorf("request reviewer: %w", err)
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
|
||||
if resp.StatusCode != http.StatusOK && resp.StatusCode != http.StatusCreated && resp.StatusCode != http.StatusNoContent {
|
||||
body, _ := io.ReadAll(io.LimitReader(resp.Body, 256))
|
||||
return fmt.Errorf("request reviewer failed (status %d): %s", resp.StatusCode, body)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// ListReviewComments returns the inline comments attached to a specific review.
|
||||
// Paginates through all pages.
|
||||
func (c *Client) ListReviewComments(ctx context.Context, owner, repo string, prNumber int, reviewID int64) ([]ReviewComment, error) {
|
||||
const pageSize = 50
|
||||
var all []ReviewComment
|
||||
for page := 1; ; page++ {
|
||||
reqURL := fmt.Sprintf("%s/api/v1/repos/%s/%s/pulls/%d/reviews/%d/comments?limit=%d&page=%d",
|
||||
c.baseURL,
|
||||
url.PathEscape(owner),
|
||||
url.PathEscape(repo),
|
||||
prNumber,
|
||||
reviewID,
|
||||
pageSize,
|
||||
page)
|
||||
body, err := c.doGet(ctx, reqURL)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("list review comments (page %d): %w", page, err)
|
||||
}
|
||||
var batch []ReviewComment
|
||||
if err := json.Unmarshal(body, &batch); err != nil {
|
||||
return nil, fmt.Errorf("parse review comments (page %d): %w", page, err)
|
||||
}
|
||||
all = append(all, batch...)
|
||||
if len(batch) < pageSize {
|
||||
break
|
||||
}
|
||||
}
|
||||
return all, nil
|
||||
}
|
||||
|
||||
// ResolveComment marks an inline review comment as resolved.
|
||||
func (c *Client) ResolveComment(ctx context.Context, owner, repo string, commentID int64) error {
|
||||
reqURL := fmt.Sprintf("%s/api/v1/repos/%s/%s/pulls/comments/%d/resolve",
|
||||
c.baseURL,
|
||||
url.PathEscape(owner),
|
||||
url.PathEscape(repo),
|
||||
commentID)
|
||||
|
||||
req, err := http.NewRequestWithContext(ctx, http.MethodPost, reqURL, nil)
|
||||
if err != nil {
|
||||
return fmt.Errorf("create resolve request: %w", err)
|
||||
}
|
||||
req.Header.Set("Authorization", "token "+c.token)
|
||||
|
||||
resp, err := c.http.Do(req)
|
||||
if err != nil {
|
||||
return fmt.Errorf("resolve comment: %w", err)
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
|
||||
if resp.StatusCode != http.StatusOK && resp.StatusCode != http.StatusCreated && resp.StatusCode != http.StatusNoContent {
|
||||
body, _ := io.ReadAll(io.LimitReader(resp.Body, 256))
|
||||
return fmt.Errorf("resolve comment failed (status %d): %s", resp.StatusCode, body)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
+8
-975
File diff suppressed because it is too large
Load Diff
@@ -1,85 +0,0 @@
|
||||
package gitea
|
||||
|
||||
import (
|
||||
"strconv"
|
||||
"strings"
|
||||
)
|
||||
|
||||
// DiffLineRanges maps filenames to the set of new-file line numbers present in the diff.
|
||||
type DiffLineRanges struct {
|
||||
files map[string]map[int]bool
|
||||
}
|
||||
|
||||
// Contains reports whether the given file+line is within the diff hunks.
|
||||
func (d *DiffLineRanges) Contains(file string, line int) bool {
|
||||
if d == nil || d.files == nil {
|
||||
return false
|
||||
}
|
||||
lines, ok := d.files[file]
|
||||
if !ok {
|
||||
return false
|
||||
}
|
||||
return lines[line]
|
||||
}
|
||||
|
||||
// ParseDiffNewLines parses a unified diff and extracts the new-file line numbers
|
||||
// that appear in each hunk (both added and context lines).
|
||||
func ParseDiffNewLines(diff string) *DiffLineRanges {
|
||||
result := &DiffLineRanges{files: make(map[string]map[int]bool)}
|
||||
|
||||
var currentFile string
|
||||
var newLine int
|
||||
|
||||
for _, line := range strings.Split(diff, "\n") {
|
||||
// Track current file from +++ header
|
||||
if strings.HasPrefix(line, "+++ b/") {
|
||||
currentFile = strings.TrimPrefix(line, "+++ b/")
|
||||
if result.files[currentFile] == nil {
|
||||
result.files[currentFile] = make(map[int]bool)
|
||||
}
|
||||
continue
|
||||
}
|
||||
if strings.HasPrefix(line, "+++ /dev/null") {
|
||||
currentFile = ""
|
||||
continue
|
||||
}
|
||||
|
||||
// Parse hunk header: @@ -old,count +new,count @@ or @@ -old +new @@
|
||||
if strings.HasPrefix(line, "@@") && currentFile != "" {
|
||||
// Extract the +N part — handle both "+10,8" and "+1" forms
|
||||
parts := strings.Split(line, "+")
|
||||
if len(parts) >= 2 {
|
||||
// Take everything before comma or space
|
||||
numStr := parts[1]
|
||||
if idx := strings.IndexAny(numStr, ", "); idx != -1 {
|
||||
numStr = numStr[:idx]
|
||||
}
|
||||
n, err := strconv.Atoi(numStr)
|
||||
if err == nil {
|
||||
newLine = n
|
||||
}
|
||||
}
|
||||
continue
|
||||
}
|
||||
|
||||
if currentFile == "" {
|
||||
continue
|
||||
}
|
||||
|
||||
// Skip diff metadata lines
|
||||
if strings.HasPrefix(line, "\\") {
|
||||
continue
|
||||
}
|
||||
|
||||
// Count lines in hunk
|
||||
if strings.HasPrefix(line, "+") || strings.HasPrefix(line, " ") {
|
||||
result.files[currentFile][newLine] = true
|
||||
newLine++
|
||||
} else if strings.HasPrefix(line, "-") {
|
||||
// Removed lines don't advance new line counter
|
||||
continue
|
||||
}
|
||||
}
|
||||
|
||||
return result
|
||||
}
|
||||
@@ -1,97 +0,0 @@
|
||||
package gitea
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"math"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"strings"
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
func TestGetPullRequestDiff_SizeLimits(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
diff string
|
||||
maxDiffSize int64
|
||||
wantErr error
|
||||
wantDiff string
|
||||
}{
|
||||
{
|
||||
name: "exceeds max size",
|
||||
diff: strings.Repeat("+ added line\n", 1000), // ~13 KB
|
||||
maxDiffSize: 100,
|
||||
wantErr: ErrDiffTooLarge,
|
||||
},
|
||||
{
|
||||
name: "within max size",
|
||||
diff: "diff --git a/f.go b/f.go\n--- a/f.go\n+++ b/f.go\n@@ -1 +1 @@\n-old\n+new\n",
|
||||
maxDiffSize: 1024,
|
||||
wantDiff: "diff --git a/f.go b/f.go\n--- a/f.go\n+++ b/f.go\n@@ -1 +1 @@\n-old\n+new\n",
|
||||
},
|
||||
{
|
||||
name: "exactly at limit",
|
||||
diff: strings.Repeat("x", 50),
|
||||
maxDiffSize: 50,
|
||||
wantDiff: strings.Repeat("x", 50),
|
||||
},
|
||||
{
|
||||
name: "one byte over limit",
|
||||
diff: strings.Repeat("x", 51),
|
||||
maxDiffSize: 50,
|
||||
wantErr: ErrDiffTooLarge,
|
||||
},
|
||||
{
|
||||
name: "disabled limit",
|
||||
diff: strings.Repeat("x", 10000),
|
||||
maxDiffSize: -1,
|
||||
wantDiff: strings.Repeat("x", 10000),
|
||||
},
|
||||
{
|
||||
name: "math.MaxInt64 treated as disabled",
|
||||
diff: strings.Repeat("x", 10000),
|
||||
maxDiffSize: math.MaxInt64,
|
||||
wantDiff: strings.Repeat("x", 10000),
|
||||
},
|
||||
{
|
||||
name: "default limit",
|
||||
diff: "diff content",
|
||||
maxDiffSize: 0, // zero means use DefaultMaxDiffSize
|
||||
wantDiff: "diff content",
|
||||
},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
w.Write([]byte(tt.diff)) //nolint:errcheck // test handler
|
||||
}))
|
||||
defer server.Close()
|
||||
|
||||
client := NewClient(server.URL, "test-token")
|
||||
client.MaxDiffSize = tt.maxDiffSize
|
||||
client.RetryBackoff = []time.Duration{}
|
||||
|
||||
got, err := client.GetPullRequestDiff(context.Background(), "owner", "repo", 1)
|
||||
|
||||
if tt.wantErr != nil {
|
||||
if err == nil {
|
||||
t.Fatal("expected error, got nil")
|
||||
}
|
||||
if !errors.Is(err, tt.wantErr) {
|
||||
t.Errorf("expected %v, got: %v", tt.wantErr, err)
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
if err != nil {
|
||||
t.Fatalf("unexpected error: %v", err)
|
||||
}
|
||||
if got != tt.wantDiff {
|
||||
t.Errorf("diff mismatch: got length %d, want length %d", len(got), len(tt.wantDiff))
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
@@ -1,115 +0,0 @@
|
||||
package gitea
|
||||
|
||||
import (
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestParseDiffLineRanges(t *testing.T) {
|
||||
diff := `diff --git a/main.go b/main.go
|
||||
index abc1234..def5678 100644
|
||||
--- a/main.go
|
||||
+++ b/main.go
|
||||
@@ -10,6 +10,8 @@ func main() {
|
||||
fmt.Println("hello")
|
||||
+ fmt.Println("new line 11")
|
||||
+ fmt.Println("new line 12")
|
||||
fmt.Println("existing")
|
||||
}
|
||||
@@ -30,4 +32,5 @@ func other() {
|
||||
return nil
|
||||
+ // added at line 33
|
||||
}
|
||||
diff --git a/util.go b/util.go
|
||||
new file mode 100644
|
||||
--- /dev/null
|
||||
+++ b/util.go
|
||||
@@ -0,0 +1,5 @@
|
||||
+package main
|
||||
+
|
||||
+func helper() string {
|
||||
+ return "hi"
|
||||
+}
|
||||
`
|
||||
|
||||
ranges := ParseDiffNewLines(diff)
|
||||
|
||||
// main.go should have lines 10-17 (first hunk) and 32-36 (second hunk)
|
||||
if !ranges.Contains("main.go", 11) {
|
||||
t.Error("expected main.go:11 to be in diff")
|
||||
}
|
||||
if !ranges.Contains("main.go", 12) {
|
||||
t.Error("expected main.go:12 to be in diff")
|
||||
}
|
||||
if !ranges.Contains("main.go", 10) {
|
||||
t.Error("expected main.go:10 to be in diff (context line)")
|
||||
}
|
||||
if !ranges.Contains("main.go", 33) {
|
||||
t.Error("expected main.go:33 to be in diff")
|
||||
}
|
||||
if ranges.Contains("main.go", 25) {
|
||||
t.Error("main.go:25 should NOT be in diff")
|
||||
}
|
||||
|
||||
// util.go is entirely new, lines 1-5
|
||||
if !ranges.Contains("util.go", 1) {
|
||||
t.Error("expected util.go:1 to be in diff")
|
||||
}
|
||||
if !ranges.Contains("util.go", 5) {
|
||||
t.Error("expected util.go:5 to be in diff")
|
||||
}
|
||||
if ranges.Contains("util.go", 6) {
|
||||
t.Error("util.go:6 should NOT be in diff")
|
||||
}
|
||||
|
||||
// Unknown file
|
||||
if ranges.Contains("unknown.go", 1) {
|
||||
t.Error("unknown.go should not be in diff")
|
||||
}
|
||||
}
|
||||
|
||||
func TestParseDiffNewLines_Empty(t *testing.T) {
|
||||
ranges := ParseDiffNewLines("")
|
||||
if ranges.Contains("any.go", 1) {
|
||||
t.Error("empty diff should contain nothing")
|
||||
}
|
||||
}
|
||||
|
||||
func TestParseDiffNewLines_NoCommaHunk(t *testing.T) {
|
||||
// Single-line hunks omit the comma: @@ -1 +1 @@
|
||||
diff := `diff --git a/single.go b/single.go
|
||||
--- a/single.go
|
||||
+++ b/single.go
|
||||
@@ -1 +1 @@
|
||||
-old line
|
||||
+new line
|
||||
`
|
||||
ranges := ParseDiffNewLines(diff)
|
||||
if !ranges.Contains("single.go", 1) {
|
||||
t.Error("expected single.go:1 to be in diff (no-comma hunk)")
|
||||
}
|
||||
if ranges.Contains("single.go", 2) {
|
||||
t.Error("single.go:2 should NOT be in diff")
|
||||
}
|
||||
}
|
||||
|
||||
func TestParseDiffNewLines_NoNewlineMarker(t *testing.T) {
|
||||
// "\ No newline at end of file" should not advance line counter
|
||||
diff := `diff --git a/noeof.go b/noeof.go
|
||||
--- a/noeof.go
|
||||
+++ b/noeof.go
|
||||
@@ -1,2 +1,2 @@
|
||||
+line one
|
||||
+line two
|
||||
\ No newline at end of file
|
||||
`
|
||||
ranges := ParseDiffNewLines(diff)
|
||||
if !ranges.Contains("noeof.go", 1) {
|
||||
t.Error("expected noeof.go:1")
|
||||
}
|
||||
if !ranges.Contains("noeof.go", 2) {
|
||||
t.Error("expected noeof.go:2")
|
||||
}
|
||||
if ranges.Contains("noeof.go", 3) {
|
||||
t.Error("noeof.go:3 should NOT be in diff (no-newline marker)")
|
||||
}
|
||||
}
|
||||
@@ -1,88 +0,0 @@
|
||||
package gitea
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestPostReview_WithComments(t *testing.T) {
|
||||
var gotPayload struct {
|
||||
Body string `json:"body"`
|
||||
Event string `json:"event"`
|
||||
Comments []struct {
|
||||
Path string `json:"path"`
|
||||
NewPosition int64 `json:"new_position"`
|
||||
Body string `json:"body"`
|
||||
} `json:"comments"`
|
||||
}
|
||||
|
||||
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
json.NewDecoder(r.Body).Decode(&gotPayload)
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
w.WriteHeader(200)
|
||||
json.NewEncoder(w).Encode(map[string]any{
|
||||
"id": 99,
|
||||
"body": gotPayload.Body,
|
||||
"user": map[string]any{"login": "bot"},
|
||||
})
|
||||
}))
|
||||
defer server.Close()
|
||||
|
||||
client := NewClient(server.URL, "test-token")
|
||||
comments := []ReviewComment{
|
||||
{Path: "main.go", NewPosition: 42, Body: "[MAJOR] Something bad"},
|
||||
{Path: "util.go", NewPosition: 10, Body: "[MINOR] Style issue"},
|
||||
}
|
||||
|
||||
_, err := client.PostReview(context.Background(), "owner", "repo", 1, "REQUEST_CHANGES", "summary", "", comments)
|
||||
if err != nil {
|
||||
t.Fatalf("unexpected error: %v", err)
|
||||
}
|
||||
|
||||
if len(gotPayload.Comments) != 2 {
|
||||
t.Fatalf("expected 2 comments, got %d", len(gotPayload.Comments))
|
||||
}
|
||||
if gotPayload.Comments[0].Path != "main.go" {
|
||||
t.Errorf("expected path main.go, got %s", gotPayload.Comments[0].Path)
|
||||
}
|
||||
if gotPayload.Comments[0].NewPosition != 42 {
|
||||
t.Errorf("expected new_position 42, got %d", gotPayload.Comments[0].NewPosition)
|
||||
}
|
||||
if gotPayload.Comments[1].Body != "[MINOR] Style issue" {
|
||||
t.Errorf("unexpected body: %s", gotPayload.Comments[1].Body)
|
||||
}
|
||||
}
|
||||
|
||||
func TestPostReview_NilComments(t *testing.T) {
|
||||
var gotPayload map[string]any
|
||||
|
||||
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
json.NewDecoder(r.Body).Decode(&gotPayload)
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
w.WriteHeader(200)
|
||||
json.NewEncoder(w).Encode(map[string]any{
|
||||
"id": 100,
|
||||
"body": "test",
|
||||
"user": map[string]any{"login": "bot"},
|
||||
})
|
||||
}))
|
||||
defer server.Close()
|
||||
|
||||
client := NewClient(server.URL, "test-token")
|
||||
_, err := client.PostReview(context.Background(), "owner", "repo", 1, "APPROVED", "all good", "", nil)
|
||||
if err != nil {
|
||||
t.Fatalf("unexpected error: %v", err)
|
||||
}
|
||||
|
||||
// With nil comments, the field should be omitted (omitempty)
|
||||
comments, ok := gotPayload["comments"]
|
||||
if ok && comments != nil {
|
||||
arr, isArr := comments.([]any)
|
||||
if isArr && len(arr) > 0 {
|
||||
t.Error("expected no comments in payload when nil passed")
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,378 +0,0 @@
|
||||
// Package github provides a client for the GitHub API.
|
||||
// It supports pull request operations, file content retrieval,
|
||||
// and review submission for both github.com and GitHub Enterprise.
|
||||
package github
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"fmt"
|
||||
"io"
|
||||
"log/slog"
|
||||
"net/http"
|
||||
"net/url"
|
||||
"os"
|
||||
"strconv"
|
||||
"strings"
|
||||
"time"
|
||||
)
|
||||
|
||||
const (
|
||||
defaultBaseURL = "https://api.github.com"
|
||||
|
||||
// maxRetryAttempts is the number of times doRequest will attempt a request.
|
||||
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 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.
|
||||
type APIError struct {
|
||||
StatusCode int
|
||||
Body string
|
||||
}
|
||||
|
||||
func (e *APIError) Error() string {
|
||||
body := e.Body
|
||||
if len(body) > 200 {
|
||||
body = body[:200] + "...(truncated)"
|
||||
}
|
||||
// Sanitize newlines to prevent log injection from upstream response bodies.
|
||||
body = strings.ReplaceAll(body, "\n", " ")
|
||||
body = strings.ReplaceAll(body, "\r", " ")
|
||||
return fmt.Sprintf("HTTP %d: %s", e.StatusCode, body)
|
||||
}
|
||||
|
||||
// IsNotFound reports whether an error is an API 404 response.
|
||||
func IsNotFound(err error) bool {
|
||||
if apiErr, ok := asAPIError(err); ok {
|
||||
return apiErr.StatusCode == http.StatusNotFound
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
// IsUnauthorized reports whether an error is an API 401 response.
|
||||
func IsUnauthorized(err error) bool {
|
||||
if apiErr, ok := asAPIError(err); ok {
|
||||
return apiErr.StatusCode == http.StatusUnauthorized
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
func asAPIError(err error) (*APIError, bool) {
|
||||
if err == nil {
|
||||
return nil, false
|
||||
}
|
||||
var target *APIError
|
||||
if errors.As(err, &target) {
|
||||
return target, true
|
||||
}
|
||||
return nil, false
|
||||
}
|
||||
|
||||
// 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
|
||||
httpClient *http.Client
|
||||
|
||||
// allowInsecureHTTP permits requests to HTTP (non-TLS) endpoints.
|
||||
// When false, doRequest rejects URLs with an http:// scheme.
|
||||
allowInsecureHTTP bool
|
||||
|
||||
// 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}.
|
||||
retryBackoff []time.Duration
|
||||
|
||||
// now returns the current time. Defaults to time.Now.
|
||||
// Override in tests to control HTTP-date Retry-After calculations.
|
||||
now func() time.Time
|
||||
}
|
||||
|
||||
// defaultCheckRedirect is the redirect policy used by NewClient.
|
||||
// NOTE: This function is intentionally duplicated in gitea/client.go (and vice versa)
|
||||
// because the packages are separate. Changes here must be mirrored there.
|
||||
// It rejects HTTPS->HTTP protocol downgrades (to prevent plaintext leakage)
|
||||
// and cross-host redirects (to prevent following responses from untrusted
|
||||
// endpoints). Same-host, same-or-upgraded-scheme redirects are allowed.
|
||||
func defaultCheckRedirect(req *http.Request, via []*http.Request) error {
|
||||
if len(via) >= 10 {
|
||||
return fmt.Errorf("stopped after 10 redirects")
|
||||
}
|
||||
// Guard for direct invocation in tests and any future callers;
|
||||
// net/http guarantees len(via) >= 1 during actual redirects.
|
||||
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: HTTPS to HTTP downgrade (%s -> %s)", prev.URL.Host, req.URL.Host)
|
||||
}
|
||||
// Reject cross-host redirect entirely to avoid consuming responses
|
||||
// from untrusted endpoints.
|
||||
if req.URL.Host != prev.URL.Host {
|
||||
return fmt.Errorf("refusing redirect: cross-host (%s -> %s)", prev.URL.Host, req.URL.Host)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// ClientOption configures optional behavior of a Client.
|
||||
type ClientOption func(*clientConfig)
|
||||
|
||||
type clientConfig struct {
|
||||
allowInsecureHTTP bool
|
||||
insecureIsTestBypass bool
|
||||
}
|
||||
|
||||
// AllowInsecureHTTP permits sending credentials over plaintext HTTP connections.
|
||||
// In production, this option is gated by the REVIEW_BOT_ALLOW_INSECURE=1
|
||||
// environment variable. Without the env var set, the option is ignored
|
||||
// and a warning is logged.
|
||||
//
|
||||
// For tests, use AllowInsecureHTTPForTest (defined in a _test.go file in the same package) which bypasses the env gate.
|
||||
func AllowInsecureHTTP() ClientOption {
|
||||
return func(cfg *clientConfig) {
|
||||
cfg.allowInsecureHTTP = true
|
||||
}
|
||||
}
|
||||
|
||||
// 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).
|
||||
func NewClient(token, baseURL string, opts ...ClientOption) *Client {
|
||||
if baseURL == "" {
|
||||
baseURL = defaultBaseURL
|
||||
}
|
||||
|
||||
var cfg clientConfig
|
||||
for _, opt := range opts {
|
||||
opt(&cfg)
|
||||
}
|
||||
|
||||
if cfg.allowInsecureHTTP && !cfg.insecureIsTestBypass {
|
||||
if os.Getenv("REVIEW_BOT_ALLOW_INSECURE") != "1" {
|
||||
slog.Warn("AllowInsecureHTTP ignored: set REVIEW_BOT_ALLOW_INSECURE=1 to enable")
|
||||
cfg.allowInsecureHTTP = false
|
||||
} else {
|
||||
slog.Warn("AllowInsecureHTTP enabled — credentials may be sent over plaintext",
|
||||
"env", "REVIEW_BOT_ALLOW_INSECURE=1")
|
||||
}
|
||||
}
|
||||
|
||||
return &Client{
|
||||
baseURL: strings.TrimRight(baseURL, "/"),
|
||||
token: token,
|
||||
allowInsecureHTTP: cfg.allowInsecureHTTP,
|
||||
httpClient: &http.Client{
|
||||
Timeout: 30 * time.Second,
|
||||
CheckRedirect: defaultCheckRedirect,
|
||||
},
|
||||
now: time.Now,
|
||||
}
|
||||
}
|
||||
|
||||
// SetHTTPClient sets the underlying HTTP client used for requests.
|
||||
// This is intended for test setup only to inject mock transports; it must be
|
||||
// called before any goroutines issue requests.
|
||||
//
|
||||
// Passing nil restores the default client (30s timeout + redirect-rejecting
|
||||
// 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 sets the delays between retry attempts.
|
||||
// This is intended for testing to speed up retry tests.
|
||||
//
|
||||
// Note: if an empty non-nil slice is provided, Retry-After delays parsed from
|
||||
// server responses will be computed and capped but not applied (because
|
||||
// attempt < len(backoff) is always false). This is acceptable for the
|
||||
// test-only use case but callers should be aware of this edge case.
|
||||
func (c *Client) SetRetryBackoff(backoff []time.Duration) {
|
||||
c.retryBackoff = backoff
|
||||
}
|
||||
|
||||
// parseRetryAfter parses a Retry-After header value, supporting both integer
|
||||
// seconds (e.g. "120") and HTTP-date format (e.g. "Thu, 01 Dec 2025 16:00:00 GMT")
|
||||
// as specified in RFC 7231 §7.1.3.
|
||||
//
|
||||
// For integer values, it returns the duration directly.
|
||||
// For HTTP-date values, it computes the delay as the difference between the
|
||||
// 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)
|
||||
|
||||
// Try integer seconds first (most common from GitHub).
|
||||
// RFC 7231 allows delta-seconds of 0 to indicate immediate retry.
|
||||
if seconds, err := strconv.Atoi(value); err == nil && seconds >= 0 {
|
||||
return time.Duration(seconds) * time.Second, true
|
||||
}
|
||||
|
||||
// Try HTTP-date format (RFC 7231 §7.1.3).
|
||||
// http.ParseTime handles RFC 1123, RFC 850, and ASCTIME formats.
|
||||
if retryAt, err := http.ParseTime(value); err == nil {
|
||||
delay := retryAt.Sub(c.now())
|
||||
if delay < 0 {
|
||||
delay = 0
|
||||
}
|
||||
return delay, true
|
||||
}
|
||||
|
||||
return 0, false
|
||||
}
|
||||
|
||||
// redactURL redacts sensitive components from a URL for safe inclusion in error
|
||||
// messages and log output. It removes userinfo (e.g., user:pass@) and replaces
|
||||
// query parameters with a placeholder.
|
||||
func redactURL(rawURL string) string {
|
||||
u, err := url.Parse(rawURL)
|
||||
if err != nil {
|
||||
return "<unparseable URL>"
|
||||
}
|
||||
u.User = nil
|
||||
|
||||
if u.RawQuery != "" {
|
||||
u.RawQuery = "<redacted>"
|
||||
}
|
||||
return u.String()
|
||||
}
|
||||
|
||||
// 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) {
|
||||
// NOTE: This parses reqURL a second time (http.NewRequestWithContext parses it
|
||||
// again internally). Acceptable cost: URL parsing is cheap and threading the
|
||||
// parsed *url.URL through would complicate the interface for negligible gain.
|
||||
if !c.allowInsecureHTTP {
|
||||
parsed, err := url.Parse(reqURL)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("parse request URL: %w", err)
|
||||
}
|
||||
if strings.EqualFold(parsed.Scheme, "http") {
|
||||
return nil, fmt.Errorf("refusing HTTP request to %s: use HTTPS or set AllowInsecureHTTP option", redactURL(reqURL))
|
||||
}
|
||||
}
|
||||
|
||||
var backoff []time.Duration
|
||||
if c.retryBackoff != nil {
|
||||
backoff = append([]time.Duration(nil), c.retryBackoff...)
|
||||
} else {
|
||||
backoff = []time.Duration{1 * time.Second, 2 * time.Second}
|
||||
}
|
||||
|
||||
var lastErr error
|
||||
for attempt := 0; attempt < maxRetryAttempts; attempt++ {
|
||||
if attempt > 0 {
|
||||
var delay time.Duration
|
||||
if attempt-1 < len(backoff) {
|
||||
delay = backoff[attempt-1]
|
||||
}
|
||||
if delay > 0 {
|
||||
timer := time.NewTimer(delay)
|
||||
select {
|
||||
case <-timer.C:
|
||||
timer.Stop() // no-op after fire; kept for symmetry with the ctx.Done case
|
||||
case <-ctx.Done():
|
||||
timer.Stop()
|
||||
return nil, ctx.Err()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
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)
|
||||
}
|
||||
|
||||
if resp.StatusCode >= 200 && resp.StatusCode < 300 {
|
||||
body, err := io.ReadAll(io.LimitReader(resp.Body, maxResponseBodyBytes))
|
||||
resp.Body.Close()
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("read response body: %w", err)
|
||||
}
|
||||
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 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 := resp.Header.Get("Retry-After"); ra != "" {
|
||||
if delay, ok := c.parseRetryAfter(ra); ok {
|
||||
if delay > maxRetryAfter {
|
||||
delay = maxRetryAfter
|
||||
}
|
||||
if attempt < len(backoff) {
|
||||
backoff[attempt] = delay
|
||||
}
|
||||
}
|
||||
}
|
||||
continue
|
||||
}
|
||||
|
||||
// Don't retry other errors
|
||||
return nil, lastErr
|
||||
}
|
||||
|
||||
return nil, lastErr
|
||||
}
|
||||
|
||||
// doGet is a convenience wrapper for GET requests with the default Accept header.
|
||||
func (c *Client) doGet(ctx context.Context, url string) ([]byte, error) {
|
||||
return c.doRequest(ctx, http.MethodGet, url, "")
|
||||
}
|
||||
@@ -1,658 +0,0 @@
|
||||
package github
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"net/url"
|
||||
"strings"
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
func TestNewClient_DefaultBaseURL(t *testing.T) {
|
||||
c := NewClient("tok", "")
|
||||
if c.baseURL != defaultBaseURL {
|
||||
t.Errorf("baseURL = %q, want %q", c.baseURL, defaultBaseURL)
|
||||
}
|
||||
}
|
||||
|
||||
func TestNewClient_CustomBaseURL(t *testing.T) {
|
||||
c := NewClient("tok", "https://github.concur.com/api/v3/")
|
||||
if c.baseURL != "https://github.concur.com/api/v3" {
|
||||
t.Errorf("baseURL = %q, want trailing slash stripped", c.baseURL)
|
||||
}
|
||||
}
|
||||
|
||||
func TestDoRequest_Success(t *testing.T) {
|
||||
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
if got := r.Header.Get("Authorization"); got != "Bearer test-token" {
|
||||
t.Errorf("Authorization = %q, want Bearer test-token", got)
|
||||
}
|
||||
w.WriteHeader(http.StatusOK)
|
||||
w.Write([]byte(`{"ok":true}`))
|
||||
}))
|
||||
defer srv.Close()
|
||||
|
||||
c := NewClient("test-token", srv.URL, AllowInsecureHTTPForTest())
|
||||
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("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, AllowInsecureHTTPForTest())
|
||||
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("attempts = %d, want 2", attempts)
|
||||
}
|
||||
}
|
||||
|
||||
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++
|
||||
if attempts == 1 {
|
||||
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("tok", srv.URL, AllowInsecureHTTPForTest())
|
||||
c.now = func() time.Time { return fixedNow }
|
||||
// Initial backoff is 0; the HTTP-date parser will compute 1s and override.
|
||||
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("attempts = %d, want 2", attempts)
|
||||
}
|
||||
}
|
||||
|
||||
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++
|
||||
if attempts == 1 {
|
||||
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("tok", srv.URL, AllowInsecureHTTPForTest())
|
||||
c.now = func() time.Time { return fixedNow }
|
||||
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_429_NoRetryAfter_UsesDefaultBackoff(t *testing.T) {
|
||||
attempts := 0
|
||||
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
attempts++
|
||||
if attempts == 1 {
|
||||
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, AllowInsecureHTTPForTest())
|
||||
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("attempts = %d, want 2", attempts)
|
||||
}
|
||||
}
|
||||
|
||||
func TestDoRequest_429_InvalidRetryAfter_UsesDefaultBackoff(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", "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, AllowInsecureHTTPForTest())
|
||||
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, AllowInsecureHTTPForTest())
|
||||
_, err := c.doGet(context.Background(), srv.URL+"/test")
|
||||
if err == nil {
|
||||
t.Fatal("expected error, got nil")
|
||||
}
|
||||
if !IsNotFound(err) {
|
||||
t.Errorf("expected IsNotFound, got %v", err)
|
||||
}
|
||||
if attempts != 1 {
|
||||
t.Errorf("attempts = %d, want 1 (no retry on 404)", attempts)
|
||||
}
|
||||
}
|
||||
|
||||
func TestDoRequest_401_NoRetry(t *testing.T) {
|
||||
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, AllowInsecureHTTPForTest())
|
||||
_, err := c.doGet(context.Background(), srv.URL+"/test")
|
||||
if err == nil {
|
||||
t.Fatal("expected error, got nil")
|
||||
}
|
||||
if !IsUnauthorized(err) {
|
||||
t.Errorf("expected IsUnauthorized, got %v", err)
|
||||
}
|
||||
if attempts != 1 {
|
||||
t.Errorf("attempts = %d, want 1 (no retry on 401)", attempts)
|
||||
}
|
||||
}
|
||||
|
||||
func TestDoRequest_ContextCanceled(t *testing.T) {
|
||||
// This test exercises the timer-cancel path in the retry select:
|
||||
// select { case <-timer.C; case <-ctx.Done() }
|
||||
// The server returns 429 with a long Retry-After, and we cancel the
|
||||
// context shortly after the first response so that cancellation races
|
||||
// against the timer rather than preventing the initial HTTP round-trip.
|
||||
requestReceived := make(chan struct{}, 1)
|
||||
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
select {
|
||||
case requestReceived <- struct{}{}:
|
||||
default:
|
||||
}
|
||||
w.Header().Set("Retry-After", "10")
|
||||
w.WriteHeader(http.StatusTooManyRequests)
|
||||
}))
|
||||
defer srv.Close()
|
||||
|
||||
c := NewClient("tok", srv.URL, AllowInsecureHTTPForTest())
|
||||
c.SetRetryBackoff([]time.Duration{10 * time.Second, 10 * time.Second})
|
||||
|
||||
ctx, cancel := context.WithCancel(context.Background())
|
||||
defer cancel()
|
||||
|
||||
// Cancel the context after the first request completes, while the
|
||||
// client is blocked in the retry timer select.
|
||||
go func() {
|
||||
<-requestReceived
|
||||
// Small delay to ensure we're inside the timer select.
|
||||
time.Sleep(50 * time.Millisecond)
|
||||
cancel()
|
||||
}()
|
||||
|
||||
_, err := c.doGet(ctx, srv.URL+"/test")
|
||||
if err == nil {
|
||||
t.Fatal("expected error, got nil")
|
||||
}
|
||||
if !errors.Is(err, context.Canceled) {
|
||||
t.Errorf("err = %v, want context.Canceled", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestParseRetryAfter_IntegerSeconds(t *testing.T) {
|
||||
c := NewClient("tok", "")
|
||||
delay, ok := c.parseRetryAfter("42")
|
||||
if !ok {
|
||||
t.Fatal("expected ok=true")
|
||||
}
|
||||
if delay != 42*time.Second {
|
||||
t.Errorf("delay = %v, want 42s", delay)
|
||||
}
|
||||
}
|
||||
|
||||
func TestParseRetryAfter_ZeroSeconds(t *testing.T) {
|
||||
c := NewClient("tok", "")
|
||||
delay, ok := c.parseRetryAfter("0")
|
||||
if !ok {
|
||||
t.Fatal("expected ok=true for zero seconds (RFC 7231 allows immediate retry)")
|
||||
}
|
||||
if delay != 0 {
|
||||
t.Errorf("delay = %v, want 0", delay)
|
||||
}
|
||||
}
|
||||
|
||||
func TestParseRetryAfter_NegativeSeconds(t *testing.T) {
|
||||
c := NewClient("tok", "")
|
||||
_, ok := c.parseRetryAfter("-5")
|
||||
if ok {
|
||||
t.Error("expected ok=false for negative seconds")
|
||||
}
|
||||
}
|
||||
|
||||
func TestParseRetryAfter_HTTPDate_Future(t *testing.T) {
|
||||
fixedNow := time.Date(2025, 12, 1, 15, 59, 50, 0, time.UTC)
|
||||
c := NewClient("tok", "")
|
||||
c.now = func() time.Time { return fixedNow }
|
||||
|
||||
delay, ok := c.parseRetryAfter("Mon, 01 Dec 2025 16:00:00 GMT")
|
||||
if !ok {
|
||||
t.Fatal("expected ok=true")
|
||||
}
|
||||
// Should be 10 seconds in the future.
|
||||
if delay != 10*time.Second {
|
||||
t.Errorf("delay = %v, want 10s", delay)
|
||||
}
|
||||
}
|
||||
|
||||
func TestParseRetryAfter_HTTPDate_Past(t *testing.T) {
|
||||
fixedNow := time.Date(2025, 12, 1, 17, 0, 0, 0, time.UTC)
|
||||
c := NewClient("tok", "")
|
||||
c.now = func() time.Time { return fixedNow }
|
||||
|
||||
delay, ok := c.parseRetryAfter("Mon, 01 Dec 2025 16:00:00 GMT")
|
||||
if !ok {
|
||||
t.Fatal("expected ok=true")
|
||||
}
|
||||
if delay != 0 {
|
||||
t.Errorf("delay = %v, want 0 (past date)", delay)
|
||||
}
|
||||
}
|
||||
|
||||
func TestParseRetryAfter_RFC850_Format(t *testing.T) {
|
||||
fixedNow := time.Date(2025, 12, 1, 15, 59, 50, 0, time.UTC)
|
||||
c := NewClient("tok", "")
|
||||
c.now = func() time.Time { return fixedNow }
|
||||
|
||||
// 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")
|
||||
}
|
||||
if delay != 10*time.Second {
|
||||
t.Errorf("delay = %v, want 10s", delay)
|
||||
}
|
||||
}
|
||||
|
||||
func TestParseRetryAfter_Invalid(t *testing.T) {
|
||||
c := NewClient("tok", "")
|
||||
_, ok := c.parseRetryAfter("not-valid")
|
||||
if ok {
|
||||
t.Error("expected ok=false for invalid value")
|
||||
}
|
||||
}
|
||||
|
||||
func TestParseRetryAfter_EmptyString(t *testing.T) {
|
||||
c := NewClient("tok", "")
|
||||
_, ok := c.parseRetryAfter("")
|
||||
if ok {
|
||||
t.Error("expected ok=false for empty string")
|
||||
}
|
||||
}
|
||||
|
||||
func TestParseRetryAfter_MaxCap(t *testing.T) {
|
||||
// Verify that parseRetryAfter returns the raw value (capping is done by caller).
|
||||
c := NewClient("tok", "")
|
||||
delay, ok := c.parseRetryAfter("3600")
|
||||
if !ok {
|
||||
t.Fatal("expected ok=true")
|
||||
}
|
||||
if delay != 3600*time.Second {
|
||||
t.Errorf("delay = %v, want 3600s (caller is responsible for capping)", delay)
|
||||
}
|
||||
}
|
||||
|
||||
func TestAPIError_Error_Truncation(t *testing.T) {
|
||||
longBody := make([]byte, 300)
|
||||
for i := range longBody {
|
||||
longBody[i] = 'x'
|
||||
}
|
||||
apiErr := &APIError{StatusCode: 500, Body: string(longBody)}
|
||||
msg := apiErr.Error()
|
||||
if len(msg) > 250 {
|
||||
// "HTTP 500: " (10) + 200 + "...(truncated)" (14) = 224
|
||||
t.Errorf("error message too long: %d chars", len(msg))
|
||||
}
|
||||
}
|
||||
|
||||
func TestAPIError_Error_NewlineSanitized(t *testing.T) {
|
||||
apiErr := &APIError{StatusCode: 400, Body: "line1\nline2\rline3"}
|
||||
msg := apiErr.Error()
|
||||
for _, c := range msg {
|
||||
if c == '\n' || c == '\r' {
|
||||
t.Errorf("error message contains unsanitized newline: %q", msg)
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestNewClient_HasCheckRedirect(t *testing.T) {
|
||||
c := NewClient("secret-token", "https://api.github.com")
|
||||
if c.httpClient.CheckRedirect == nil {
|
||||
t.Fatal("expected CheckRedirect to be set")
|
||||
}
|
||||
}
|
||||
|
||||
func TestDefaultCheckRedirect_RejectsHTTPSToHTTP(t *testing.T) {
|
||||
prev := &http.Request{URL: &url.URL{Scheme: "https", Host: "api.github.com", Path: "/foo"}}
|
||||
req := &http.Request{
|
||||
URL: &url.URL{Scheme: "http", Host: "api.github.com", Path: "/foo"},
|
||||
Header: http.Header{"Authorization": []string{"Bearer token"}},
|
||||
}
|
||||
err := defaultCheckRedirect(req, []*http.Request{prev})
|
||||
if err == nil {
|
||||
t.Fatal("expected error on HTTPS->HTTP redirect")
|
||||
}
|
||||
if !strings.Contains(err.Error(), "HTTPS to HTTP downgrade") {
|
||||
t.Errorf("unexpected error message: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestDefaultCheckRedirect_RejectsCrossHost(t *testing.T) {
|
||||
prev := &http.Request{URL: &url.URL{Scheme: "https", Host: "api.github.com", Path: "/foo"}}
|
||||
req := &http.Request{
|
||||
URL: &url.URL{Scheme: "https", Host: "objects.githubusercontent.com", Path: "/bar"},
|
||||
Header: http.Header{"Authorization": []string{"Bearer token"}},
|
||||
}
|
||||
err := defaultCheckRedirect(req, []*http.Request{prev})
|
||||
if err == nil {
|
||||
t.Fatal("expected error on cross-host redirect")
|
||||
}
|
||||
if !strings.Contains(err.Error(), "cross-host") {
|
||||
t.Errorf("unexpected error message: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestDefaultCheckRedirect_AllowsSameHost(t *testing.T) {
|
||||
prev := &http.Request{URL: &url.URL{Scheme: "https", Host: "api.github.com", Path: "/foo"}}
|
||||
req := &http.Request{
|
||||
URL: &url.URL{Scheme: "https", Host: "api.github.com", Path: "/bar"},
|
||||
Header: http.Header{"Authorization": []string{"Bearer token"}},
|
||||
}
|
||||
err := defaultCheckRedirect(req, []*http.Request{prev})
|
||||
if err != nil {
|
||||
t.Fatalf("unexpected error: %v", err)
|
||||
}
|
||||
// Auth should be preserved on same-host redirect
|
||||
if auth := req.Header.Get("Authorization"); auth != "Bearer token" {
|
||||
t.Errorf("expected Authorization to be preserved, got %q", auth)
|
||||
}
|
||||
}
|
||||
|
||||
func TestDefaultCheckRedirect_AllowsSameHostHTTPToHTTP(t *testing.T) {
|
||||
prev := &http.Request{URL: &url.URL{Scheme: "http", Host: "localhost:8080", Path: "/foo"}}
|
||||
req := &http.Request{
|
||||
URL: &url.URL{Scheme: "http", Host: "localhost:8080", Path: "/bar"},
|
||||
Header: http.Header{},
|
||||
}
|
||||
err := defaultCheckRedirect(req, []*http.Request{prev})
|
||||
if err != nil {
|
||||
t.Fatalf("unexpected error: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestDefaultCheckRedirect_RejectsTooManyRedirects(t *testing.T) {
|
||||
via := make([]*http.Request, 10)
|
||||
for i := range via {
|
||||
via[i] = &http.Request{URL: &url.URL{Scheme: "https", Host: "api.github.com", Path: "/"}}
|
||||
}
|
||||
req := &http.Request{URL: &url.URL{Scheme: "https", Host: "api.github.com", Path: "/final"}}
|
||||
err := defaultCheckRedirect(req, via)
|
||||
if err == nil {
|
||||
t.Fatal("expected error after 10 redirects")
|
||||
}
|
||||
if !strings.Contains(err.Error(), "10 redirects") {
|
||||
t.Errorf("unexpected error message: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestDefaultCheckRedirect_EmptyViaAllowed(t *testing.T) {
|
||||
req := &http.Request{URL: &url.URL{Scheme: "https", Host: "api.github.com", Path: "/foo"}}
|
||||
err := defaultCheckRedirect(req, nil)
|
||||
if err != nil {
|
||||
t.Fatalf("unexpected error with empty via: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestSetHTTPClient_NilRestoresDefault(t *testing.T) {
|
||||
c := NewClient("token", "https://api.github.com")
|
||||
c.SetHTTPClient(nil)
|
||||
if c.httpClient == nil {
|
||||
t.Fatal("expected non-nil httpClient after SetHTTPClient(nil)")
|
||||
}
|
||||
if c.httpClient.Timeout != 30*time.Second {
|
||||
t.Errorf("expected 30s timeout, got %v", c.httpClient.Timeout)
|
||||
}
|
||||
if c.httpClient.CheckRedirect == nil {
|
||||
t.Fatal("expected CheckRedirect policy after SetHTTPClient(nil)")
|
||||
}
|
||||
}
|
||||
|
||||
func TestAllowInsecureHTTPForTest_PermitsHTTP(t *testing.T) {
|
||||
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
w.WriteHeader(http.StatusOK)
|
||||
w.Write([]byte("ok"))
|
||||
}))
|
||||
defer srv.Close()
|
||||
|
||||
c := NewClient("tok", srv.URL, AllowInsecureHTTPForTest())
|
||||
body, err := c.doGet(context.Background(), srv.URL+"/test")
|
||||
if err != nil {
|
||||
t.Fatalf("unexpected error: %v", err)
|
||||
}
|
||||
if string(body) != "ok" {
|
||||
t.Errorf("body = %q, want %q", body, "ok")
|
||||
}
|
||||
}
|
||||
|
||||
func TestNoInsecureOption_RejectsHTTP(t *testing.T) {
|
||||
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
t.Fatal("request should not have been sent")
|
||||
}))
|
||||
defer srv.Close()
|
||||
|
||||
c := NewClient("tok", srv.URL)
|
||||
_, err := c.doGet(context.Background(), srv.URL+"/test")
|
||||
if err == nil {
|
||||
t.Fatal("expected error for HTTP request without AllowInsecureHTTP")
|
||||
}
|
||||
if !strings.Contains(err.Error(), "refusing HTTP request") {
|
||||
t.Errorf("unexpected error message: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestNoInsecureOption_RejectsUppercaseHTTP(t *testing.T) {
|
||||
// Verify case-insensitive scheme check (RFC 3986).
|
||||
c := NewClient("tok", "HTTP://127.0.0.1:1")
|
||||
_, err := c.doGet(context.Background(), "HTTP://127.0.0.1:1/test")
|
||||
if err == nil {
|
||||
t.Fatal("expected error for uppercase HTTP scheme")
|
||||
}
|
||||
if !strings.Contains(err.Error(), "refusing HTTP request") {
|
||||
t.Errorf("unexpected error message: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestNoInsecureOption_RejectsMixedCaseHTTP(t *testing.T) {
|
||||
// Verify mixed case like "Http://" is also rejected.
|
||||
c := NewClient("tok", "Http://127.0.0.1:1")
|
||||
_, err := c.doGet(context.Background(), "Http://127.0.0.1:1/test")
|
||||
if err == nil {
|
||||
t.Fatal("expected error for mixed-case HTTP scheme")
|
||||
}
|
||||
if !strings.Contains(err.Error(), "refusing HTTP request") {
|
||||
t.Errorf("unexpected error message: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestAllowInsecureHTTP_WithoutEnvVar_Rejected(t *testing.T) {
|
||||
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
t.Fatal("request should not have been sent")
|
||||
}))
|
||||
defer srv.Close()
|
||||
|
||||
t.Setenv("REVIEW_BOT_ALLOW_INSECURE", "")
|
||||
|
||||
c := NewClient("tok", srv.URL, AllowInsecureHTTP())
|
||||
_, err := c.doGet(context.Background(), srv.URL+"/test")
|
||||
if err == nil {
|
||||
t.Fatal("expected error: AllowInsecureHTTP without env var should be rejected")
|
||||
}
|
||||
if !strings.Contains(err.Error(), "refusing HTTP request") {
|
||||
t.Errorf("unexpected error message: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestAllowInsecureHTTP_WithEnvVar_Permitted(t *testing.T) {
|
||||
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
w.WriteHeader(http.StatusOK)
|
||||
w.Write([]byte("insecure-ok"))
|
||||
}))
|
||||
defer srv.Close()
|
||||
|
||||
t.Setenv("REVIEW_BOT_ALLOW_INSECURE", "1")
|
||||
|
||||
c := NewClient("tok", srv.URL, AllowInsecureHTTP())
|
||||
body, err := c.doGet(context.Background(), srv.URL+"/test")
|
||||
if err != nil {
|
||||
t.Fatalf("unexpected error: %v", err)
|
||||
}
|
||||
if string(body) != "insecure-ok" {
|
||||
t.Errorf("body = %q, want %q", body, "insecure-ok")
|
||||
}
|
||||
}
|
||||
|
||||
func TestAllowInsecureHTTP_EnvVarNotOne_Rejected(t *testing.T) {
|
||||
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
t.Fatal("request should not have been sent")
|
||||
}))
|
||||
defer srv.Close()
|
||||
|
||||
// "true" is not "1" — strict check
|
||||
t.Setenv("REVIEW_BOT_ALLOW_INSECURE", "true")
|
||||
|
||||
c := NewClient("tok", srv.URL, AllowInsecureHTTP())
|
||||
_, err := c.doGet(context.Background(), srv.URL+"/test")
|
||||
if err == nil {
|
||||
t.Fatal("expected error: env var 'true' is not '1'")
|
||||
}
|
||||
if !strings.Contains(err.Error(), "refusing HTTP request") {
|
||||
t.Errorf("unexpected error message: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestRedactURL_WithQuery(t *testing.T) {
|
||||
got := redactURL("http://localhost:1234/path?secret=token&foo=bar")
|
||||
want := "http://localhost:1234/path?<redacted>"
|
||||
if got != want {
|
||||
t.Errorf("redactURL = %q, want %q", got, want)
|
||||
}
|
||||
}
|
||||
|
||||
func TestRedactURL_NoQuery(t *testing.T) {
|
||||
got := redactURL("http://localhost:1234/path")
|
||||
want := "http://localhost:1234/path"
|
||||
if got != want {
|
||||
t.Errorf("redactURL = %q, want %q", got, want)
|
||||
}
|
||||
}
|
||||
|
||||
func TestRedactURL_Userinfo(t *testing.T) {
|
||||
got := redactURL("http://user:pass@localhost:1234/path")
|
||||
want := "http://localhost:1234/path"
|
||||
if got != want {
|
||||
t.Errorf("redactURL = %q, want %q", got, want)
|
||||
}
|
||||
}
|
||||
|
||||
func TestRedactURL_UserinfoWithQuery(t *testing.T) {
|
||||
got := redactURL("http://user:pass@localhost:1234/path?secret=token")
|
||||
want := "http://localhost:1234/path?<redacted>"
|
||||
if got != want {
|
||||
t.Errorf("redactURL = %q, want %q", got, want)
|
||||
}
|
||||
}
|
||||
@@ -1,13 +0,0 @@
|
||||
package github
|
||||
|
||||
// AllowInsecureHTTPForTest permits sending credentials over plaintext HTTP
|
||||
// without requiring the REVIEW_BOT_ALLOW_INSECURE environment variable.
|
||||
// This is intended exclusively for test code using httptest.Server.
|
||||
//
|
||||
// Defined in a _test.go file so it is only available to test binaries.
|
||||
func AllowInsecureHTTPForTest() ClientOption {
|
||||
return func(cfg *clientConfig) {
|
||||
cfg.allowInsecureHTTP = true
|
||||
cfg.insecureIsTestBypass = true
|
||||
}
|
||||
}
|
||||
@@ -1,5 +1,3 @@
|
||||
module gitea.weiker.me/rodin/review-bot
|
||||
|
||||
go 1.26.2
|
||||
|
||||
require github.com/goccy/go-yaml v1.19.2
|
||||
|
||||
@@ -1,2 +0,0 @@
|
||||
github.com/goccy/go-yaml v1.19.2 h1:PmFC1S6h8ljIz6gMRBopkjP1TVT7xuwrButHID66PoM=
|
||||
github.com/goccy/go-yaml v1.19.2/go.mod h1:XBurs7gK8ATbW4ZPGKgcbrY1Br56PdM69F7LkFRi1kA=
|
||||
-391
@@ -1,391 +0,0 @@
|
||||
package llm
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"io"
|
||||
"net/http"
|
||||
"net/url"
|
||||
"strings"
|
||||
"sync"
|
||||
"time"
|
||||
)
|
||||
|
||||
// AICoreOpenAIAPIVersion is the API version used for OpenAI models through AI Core.
|
||||
// Update this when SAP AI Core releases a new stable version.
|
||||
const AICoreOpenAIAPIVersion = "2024-12-01-preview"
|
||||
|
||||
// maxErrorBodyLen limits the length of response bodies included in error messages
|
||||
// to prevent leaking potentially sensitive upstream details in logs.
|
||||
const maxErrorBodyLen = 200
|
||||
|
||||
// AICoreConfig holds SAP AI Core authentication and connection settings.
|
||||
type AICoreConfig struct {
|
||||
ClientID string
|
||||
ClientSecret string
|
||||
AuthURL string
|
||||
APIURL string
|
||||
ResourceGroup string
|
||||
}
|
||||
|
||||
// AICoreClient wraps AI Core authentication and deployment discovery.
|
||||
// Thread-safe for concurrent use after construction.
|
||||
//
|
||||
// Design: The deployment cache is populated once and never invalidated. This is
|
||||
// acceptable for short-lived CI runner processes, but longer-lived deployments
|
||||
// may want to add a TTL or re-fetch on errors.
|
||||
type AICoreClient struct {
|
||||
config AICoreConfig
|
||||
http *http.Client
|
||||
|
||||
mu sync.RWMutex
|
||||
token string
|
||||
tokenExpiry time.Time
|
||||
deployments map[string]string // model name -> deployment URL
|
||||
}
|
||||
|
||||
// NewAICoreClient creates a new AI Core client with the given configuration.
|
||||
// The client uses a default 5-minute timeout; use WithTimeout to customize.
|
||||
func NewAICoreClient(cfg AICoreConfig) *AICoreClient {
|
||||
return &AICoreClient{
|
||||
config: cfg,
|
||||
http: &http.Client{Timeout: 5 * time.Minute},
|
||||
deployments: make(map[string]string),
|
||||
}
|
||||
}
|
||||
|
||||
// WithTimeout sets the HTTP request timeout for AI Core calls.
|
||||
// This should be called during construction, before concurrent use.
|
||||
func (c *AICoreClient) WithTimeout(d time.Duration) *AICoreClient {
|
||||
c.http.Timeout = d
|
||||
return c
|
||||
}
|
||||
|
||||
// truncateBody truncates a response body for inclusion in error messages.
|
||||
// This prevents leaking potentially sensitive upstream response details in logs.
|
||||
func truncateBody(body []byte) string {
|
||||
if len(body) <= maxErrorBodyLen {
|
||||
return string(body)
|
||||
}
|
||||
return string(body[:maxErrorBodyLen]) + "..."
|
||||
}
|
||||
|
||||
// getToken returns a valid OAuth token, refreshing if necessary.
|
||||
func (c *AICoreClient) getToken(ctx context.Context) (string, error) {
|
||||
c.mu.RLock()
|
||||
if c.token != "" && time.Now().Add(5*time.Minute).Before(c.tokenExpiry) {
|
||||
token := c.token
|
||||
c.mu.RUnlock()
|
||||
return token, nil
|
||||
}
|
||||
c.mu.RUnlock()
|
||||
|
||||
c.mu.Lock()
|
||||
defer c.mu.Unlock()
|
||||
|
||||
// Double-check after acquiring write lock
|
||||
if c.token != "" && time.Now().Add(5*time.Minute).Before(c.tokenExpiry) {
|
||||
return c.token, nil
|
||||
}
|
||||
|
||||
token, expiry, err := c.fetchToken(ctx)
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
c.token = token
|
||||
c.tokenExpiry = expiry
|
||||
return token, nil
|
||||
}
|
||||
|
||||
func (c *AICoreClient) fetchToken(ctx context.Context) (string, time.Time, error) {
|
||||
tokenURL := strings.TrimRight(c.config.AuthURL, "/") + "/oauth/token"
|
||||
|
||||
data := url.Values{}
|
||||
data.Set("grant_type", "client_credentials")
|
||||
data.Set("client_id", c.config.ClientID)
|
||||
data.Set("client_secret", c.config.ClientSecret)
|
||||
|
||||
req, err := http.NewRequestWithContext(ctx, http.MethodPost, tokenURL, strings.NewReader(data.Encode()))
|
||||
if err != nil {
|
||||
return "", time.Time{}, fmt.Errorf("create token request: %w", err)
|
||||
}
|
||||
req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
|
||||
|
||||
resp, err := c.http.Do(req)
|
||||
if err != nil {
|
||||
return "", time.Time{}, fmt.Errorf("token request: %w", err)
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
|
||||
body, err := io.ReadAll(resp.Body)
|
||||
if err != nil {
|
||||
return "", time.Time{}, fmt.Errorf("read token response: %w", err)
|
||||
}
|
||||
|
||||
if resp.StatusCode < 200 || resp.StatusCode >= 300 {
|
||||
return "", time.Time{}, fmt.Errorf("token request failed (status %d): %s", resp.StatusCode, truncateBody(body))
|
||||
}
|
||||
|
||||
var tokenResp struct {
|
||||
AccessToken string `json:"access_token"`
|
||||
ExpiresIn int `json:"expires_in"`
|
||||
}
|
||||
if err := json.Unmarshal(body, &tokenResp); err != nil {
|
||||
return "", time.Time{}, fmt.Errorf("parse token response: %w", err)
|
||||
}
|
||||
|
||||
if tokenResp.AccessToken == "" {
|
||||
return "", time.Time{}, fmt.Errorf("empty access token in response")
|
||||
}
|
||||
|
||||
expiry := time.Now().Add(time.Duration(tokenResp.ExpiresIn) * time.Second)
|
||||
return tokenResp.AccessToken, expiry, nil
|
||||
}
|
||||
|
||||
// getDeploymentURL returns the deployment URL for a model, fetching deployments if needed.
|
||||
// getDeploymentURL returns the deployment URL for a model, fetching deployments if needed.
|
||||
// Also returns a valid token for use by the caller, avoiding redundant getToken calls.
|
||||
//
|
||||
// Note: The token is fetched before acquiring the write lock to avoid holding the lock
|
||||
// during network I/O. In rare cases where multiple goroutines race and one waits a long
|
||||
// time for the write lock, the token could theoretically expire. The 5-minute refresh
|
||||
// buffer in getToken makes this extremely unlikely in practice.
|
||||
func (c *AICoreClient) getDeploymentURL(ctx context.Context, model string) (deployURL, token string, err error) {
|
||||
c.mu.RLock()
|
||||
if u, ok := c.deployments[model]; ok {
|
||||
c.mu.RUnlock()
|
||||
// Still need a token for the caller
|
||||
token, err = c.getToken(ctx)
|
||||
if err != nil {
|
||||
return "", "", fmt.Errorf("get token: %w", err)
|
||||
}
|
||||
return u, token, nil
|
||||
}
|
||||
c.mu.RUnlock()
|
||||
|
||||
// Fetch token first (before acquiring write lock to avoid holding lock during I/O)
|
||||
token, err = c.getToken(ctx)
|
||||
if err != nil {
|
||||
return "", "", fmt.Errorf("get token for deployments: %w", err)
|
||||
}
|
||||
|
||||
c.mu.Lock()
|
||||
defer c.mu.Unlock()
|
||||
|
||||
// Double-check after acquiring write lock
|
||||
if u, ok := c.deployments[model]; ok {
|
||||
return u, token, nil
|
||||
}
|
||||
|
||||
if err := c.fetchDeployments(ctx, token); err != nil {
|
||||
return "", "", err
|
||||
}
|
||||
|
||||
if u, ok := c.deployments[model]; ok {
|
||||
return u, token, nil
|
||||
}
|
||||
return "", "", fmt.Errorf("no deployment found for model %q", model)
|
||||
}
|
||||
|
||||
func (c *AICoreClient) fetchDeployments(ctx context.Context, token string) error {
|
||||
deployURL := strings.TrimRight(c.config.APIURL, "/") + "/v2/lm/deployments"
|
||||
req, err := http.NewRequestWithContext(ctx, http.MethodGet, deployURL, nil)
|
||||
if err != nil {
|
||||
return fmt.Errorf("create deployments request: %w", err)
|
||||
}
|
||||
req.Header.Set("Authorization", "Bearer "+token)
|
||||
req.Header.Set("AI-Resource-Group", c.config.ResourceGroup)
|
||||
|
||||
resp, err := c.http.Do(req)
|
||||
if err != nil {
|
||||
return fmt.Errorf("deployments request: %w", err)
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
|
||||
body, err := io.ReadAll(resp.Body)
|
||||
if err != nil {
|
||||
return fmt.Errorf("read deployments response: %w", err)
|
||||
}
|
||||
|
||||
if resp.StatusCode < 200 || resp.StatusCode >= 300 {
|
||||
return fmt.Errorf("deployments request failed (status %d): %s", resp.StatusCode, truncateBody(body))
|
||||
}
|
||||
|
||||
var deployResp struct {
|
||||
Resources []struct {
|
||||
DeploymentURL string `json:"deploymentUrl"`
|
||||
Status string `json:"status"`
|
||||
Details struct {
|
||||
Resources struct {
|
||||
BackendDetails struct {
|
||||
Model struct {
|
||||
Name string `json:"name"`
|
||||
} `json:"model"`
|
||||
} `json:"backend_details"`
|
||||
} `json:"resources"`
|
||||
} `json:"details"`
|
||||
} `json:"resources"`
|
||||
}
|
||||
if err := json.Unmarshal(body, &deployResp); err != nil {
|
||||
return fmt.Errorf("parse deployments response: %w", err)
|
||||
}
|
||||
|
||||
for _, r := range deployResp.Resources {
|
||||
if r.Status != "RUNNING" {
|
||||
continue
|
||||
}
|
||||
modelName := r.Details.Resources.BackendDetails.Model.Name
|
||||
if modelName == "" {
|
||||
continue
|
||||
}
|
||||
c.deployments[modelName] = r.DeploymentURL
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// CompleteAnthropic sends a request to an Anthropic model via AI Core.
|
||||
func (c *AICoreClient) CompleteAnthropic(ctx context.Context, model string, messages []Message, maxTokens int, temperature float64) (string, error) {
|
||||
deployURL, token, err := c.getDeploymentURL(ctx, model)
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
|
||||
// Extract system message
|
||||
var system string
|
||||
var userMessages []anthropicMsg
|
||||
for _, m := range messages {
|
||||
if m.Role == "system" {
|
||||
system = m.Content
|
||||
} else {
|
||||
userMessages = append(userMessages, anthropicMsg{
|
||||
Role: m.Role,
|
||||
Content: m.Content,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
reqBody := anthropicRequest{
|
||||
AnthropicVersion: "bedrock-2023-05-31", // SAP AI Core uses Bedrock format
|
||||
// Model omitted - AI Core deployment already specifies model
|
||||
MaxTokens: maxTokens,
|
||||
System: system,
|
||||
Messages: userMessages,
|
||||
}
|
||||
if temperature > 0 {
|
||||
reqBody.Temperature = temperature
|
||||
}
|
||||
|
||||
data, err := json.Marshal(reqBody)
|
||||
if err != nil {
|
||||
return "", fmt.Errorf("marshal request: %w", err)
|
||||
}
|
||||
|
||||
// AI Core uses /invoke for Anthropic models
|
||||
invokeURL := strings.TrimRight(deployURL, "/") + "/invoke"
|
||||
req, err := http.NewRequestWithContext(ctx, http.MethodPost, invokeURL, bytes.NewReader(data))
|
||||
if err != nil {
|
||||
return "", fmt.Errorf("create request: %w", err)
|
||||
}
|
||||
req.Header.Set("Authorization", "Bearer "+token)
|
||||
req.Header.Set("AI-Resource-Group", c.config.ResourceGroup)
|
||||
req.Header.Set("Content-Type", "application/json")
|
||||
|
||||
resp, err := c.http.Do(req)
|
||||
if err != nil {
|
||||
return "", fmt.Errorf("AI Core request: %w", err)
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
|
||||
body, err := io.ReadAll(resp.Body)
|
||||
if err != nil {
|
||||
return "", fmt.Errorf("read response: %w", err)
|
||||
}
|
||||
|
||||
if resp.StatusCode < 200 || resp.StatusCode >= 300 {
|
||||
return "", fmt.Errorf("AI Core API error (status %d): %s", resp.StatusCode, truncateBody(body))
|
||||
}
|
||||
|
||||
var anthropicResp anthropicResponse
|
||||
if err := json.Unmarshal(body, &anthropicResp); err != nil {
|
||||
return "", fmt.Errorf("parse response: %w", err)
|
||||
}
|
||||
|
||||
if len(anthropicResp.Content) == 0 {
|
||||
return "", fmt.Errorf("no content in response")
|
||||
}
|
||||
|
||||
var sb strings.Builder
|
||||
for _, block := range anthropicResp.Content {
|
||||
if block.Type == "text" {
|
||||
sb.WriteString(block.Text)
|
||||
}
|
||||
}
|
||||
result := sb.String()
|
||||
if result == "" {
|
||||
return "", fmt.Errorf("no text content in response")
|
||||
}
|
||||
return result, nil
|
||||
}
|
||||
|
||||
// CompleteOpenAI sends a request to an OpenAI model via AI Core.
|
||||
func (c *AICoreClient) CompleteOpenAI(ctx context.Context, model string, messages []Message, temperature float64) (string, error) {
|
||||
deployURL, token, err := c.getDeploymentURL(ctx, model)
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
|
||||
reqBody := ChatRequest{
|
||||
Model: model,
|
||||
Temperature: temperature,
|
||||
Messages: messages,
|
||||
}
|
||||
|
||||
data, err := json.Marshal(reqBody)
|
||||
if err != nil {
|
||||
return "", fmt.Errorf("marshal request: %w", err)
|
||||
}
|
||||
|
||||
// AI Core uses /chat/completions?api-version=<version> for OpenAI models
|
||||
chatURL := strings.TrimRight(deployURL, "/") + "/chat/completions?api-version=" + AICoreOpenAIAPIVersion
|
||||
req, err := http.NewRequestWithContext(ctx, http.MethodPost, chatURL, bytes.NewReader(data))
|
||||
if err != nil {
|
||||
return "", fmt.Errorf("create request: %w", err)
|
||||
}
|
||||
req.Header.Set("Authorization", "Bearer "+token)
|
||||
req.Header.Set("AI-Resource-Group", c.config.ResourceGroup)
|
||||
req.Header.Set("Content-Type", "application/json")
|
||||
|
||||
resp, err := c.http.Do(req)
|
||||
if err != nil {
|
||||
return "", fmt.Errorf("AI Core request: %w", err)
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
|
||||
body, err := io.ReadAll(resp.Body)
|
||||
if err != nil {
|
||||
return "", fmt.Errorf("read response: %w", err)
|
||||
}
|
||||
|
||||
if resp.StatusCode < 200 || resp.StatusCode >= 300 {
|
||||
return "", fmt.Errorf("AI Core API error (status %d): %s", resp.StatusCode, truncateBody(body))
|
||||
}
|
||||
|
||||
var openaiResp ChatResponse
|
||||
if err := json.Unmarshal(body, &openaiResp); err != nil {
|
||||
return "", fmt.Errorf("parse response: %w", err)
|
||||
}
|
||||
|
||||
if len(openaiResp.Choices) == 0 {
|
||||
return "", fmt.Errorf("no choices in response")
|
||||
}
|
||||
return openaiResp.Choices[0].Message.Content, nil
|
||||
}
|
||||
|
||||
// IsAnthropicModel returns true if the model name indicates an Anthropic model.
|
||||
// SAP AI Core uses "anthropic--" prefix for Anthropic models (e.g., "anthropic--claude-3-5-sonnet").
|
||||
func IsAnthropicModel(model string) bool {
|
||||
return strings.HasPrefix(model, "anthropic--")
|
||||
}
|
||||
@@ -1,535 +0,0 @@
|
||||
package llm
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"strings"
|
||||
"sync/atomic"
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
func TestAICoreClient_TokenFetch(t *testing.T) {
|
||||
tokenCalls := int32(0)
|
||||
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
if r.URL.Path == "/oauth/token" {
|
||||
atomic.AddInt32(&tokenCalls, 1)
|
||||
if r.Method != http.MethodPost {
|
||||
t.Errorf("expected POST for token, got %s", r.Method)
|
||||
}
|
||||
if r.Header.Get("Content-Type") != "application/x-www-form-urlencoded" {
|
||||
t.Errorf("expected form content type")
|
||||
}
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
json.NewEncoder(w).Encode(map[string]interface{}{
|
||||
"access_token": "test-token-123",
|
||||
"expires_in": 3600,
|
||||
})
|
||||
return
|
||||
}
|
||||
t.Errorf("unexpected path: %s", r.URL.Path)
|
||||
}))
|
||||
defer server.Close()
|
||||
|
||||
client := NewAICoreClient(AICoreConfig{
|
||||
ClientID: "test-id",
|
||||
ClientSecret: "test-secret",
|
||||
AuthURL: server.URL,
|
||||
APIURL: server.URL,
|
||||
ResourceGroup: "default",
|
||||
})
|
||||
|
||||
token, err := client.getToken(context.Background())
|
||||
if err != nil {
|
||||
t.Fatalf("unexpected error: %v", err)
|
||||
}
|
||||
if token != "test-token-123" {
|
||||
t.Errorf("expected token 'test-token-123', got %q", token)
|
||||
}
|
||||
|
||||
// Second call should use cached token
|
||||
token2, err := client.getToken(context.Background())
|
||||
if err != nil {
|
||||
t.Fatalf("unexpected error: %v", err)
|
||||
}
|
||||
if token2 != "test-token-123" {
|
||||
t.Errorf("expected cached token")
|
||||
}
|
||||
if atomic.LoadInt32(&tokenCalls) != 1 {
|
||||
t.Errorf("expected 1 token call (cached), got %d", tokenCalls)
|
||||
}
|
||||
}
|
||||
|
||||
func TestAICoreClient_DeploymentFetch(t *testing.T) {
|
||||
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
if r.URL.Path == "/oauth/token" {
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
json.NewEncoder(w).Encode(map[string]interface{}{
|
||||
"access_token": "test-token",
|
||||
"expires_in": 3600,
|
||||
})
|
||||
return
|
||||
}
|
||||
if r.URL.Path == "/v2/lm/deployments" {
|
||||
if r.Header.Get("Authorization") != "Bearer test-token" {
|
||||
t.Errorf("expected Bearer auth")
|
||||
}
|
||||
if r.Header.Get("AI-Resource-Group") != "default" {
|
||||
t.Errorf("expected resource group header")
|
||||
}
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
json.NewEncoder(w).Encode(map[string]interface{}{
|
||||
"resources": []map[string]interface{}{
|
||||
{
|
||||
"id": "deploy-123",
|
||||
"deploymentUrl": "https://example.com/v2/inference/deployments/deploy-123",
|
||||
"status": "RUNNING",
|
||||
"details": map[string]interface{}{
|
||||
"resources": map[string]interface{}{
|
||||
"backend_details": map[string]interface{}{
|
||||
"model": map[string]interface{}{
|
||||
"name": "anthropic--claude-4.6-sonnet",
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
"id": "deploy-456",
|
||||
"deploymentUrl": "https://example.com/v2/inference/deployments/deploy-456",
|
||||
"status": "STOPPED",
|
||||
"details": map[string]interface{}{
|
||||
"resources": map[string]interface{}{
|
||||
"backend_details": map[string]interface{}{
|
||||
"model": map[string]interface{}{
|
||||
"name": "gpt-5",
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
"id": "deploy-789",
|
||||
"deploymentUrl": "https://example.com/v2/inference/deployments/deploy-789",
|
||||
"status": "RUNNING",
|
||||
"details": map[string]interface{}{
|
||||
"resources": map[string]interface{}{
|
||||
"backend_details": map[string]interface{}{
|
||||
"model": map[string]interface{}{
|
||||
"name": "gpt-5",
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
})
|
||||
return
|
||||
}
|
||||
t.Errorf("unexpected path: %s", r.URL.Path)
|
||||
}))
|
||||
defer server.Close()
|
||||
|
||||
client := NewAICoreClient(AICoreConfig{
|
||||
ClientID: "test-id",
|
||||
ClientSecret: "test-secret",
|
||||
AuthURL: server.URL,
|
||||
APIURL: server.URL,
|
||||
ResourceGroup: "default",
|
||||
})
|
||||
|
||||
// Should find running deployment
|
||||
url, _, err := client.getDeploymentURL(context.Background(), "anthropic--claude-4.6-sonnet")
|
||||
if err != nil {
|
||||
t.Fatalf("unexpected error: %v", err)
|
||||
}
|
||||
if url != "https://example.com/v2/inference/deployments/deploy-123" {
|
||||
t.Errorf("unexpected URL: %s", url)
|
||||
}
|
||||
|
||||
// Should find running gpt-5, not stopped one
|
||||
url, _, err = client.getDeploymentURL(context.Background(), "gpt-5")
|
||||
if err != nil {
|
||||
t.Fatalf("unexpected error: %v", err)
|
||||
}
|
||||
if url != "https://example.com/v2/inference/deployments/deploy-789" {
|
||||
t.Errorf("unexpected URL: %s", url)
|
||||
}
|
||||
|
||||
// Should error on unknown model
|
||||
_, _, err = client.getDeploymentURL(context.Background(), "unknown-model")
|
||||
if err == nil {
|
||||
t.Error("expected error for unknown model")
|
||||
}
|
||||
}
|
||||
|
||||
func TestAICoreClient_CompleteAnthropic(t *testing.T) {
|
||||
// baseURL is set after server creation; captured by closure in handlers
|
||||
var baseURL string
|
||||
mux := http.NewServeMux()
|
||||
mux.HandleFunc("/oauth/token", func(w http.ResponseWriter, r *http.Request) {
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
json.NewEncoder(w).Encode(map[string]interface{}{
|
||||
"access_token": "test-token",
|
||||
"expires_in": 3600,
|
||||
})
|
||||
})
|
||||
mux.HandleFunc("/v2/lm/deployments", func(w http.ResponseWriter, r *http.Request) {
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
json.NewEncoder(w).Encode(map[string]interface{}{
|
||||
"resources": []map[string]interface{}{
|
||||
{
|
||||
"id": "deploy-anthropic",
|
||||
"deploymentUrl": baseURL + "/deployments/anthropic",
|
||||
"status": "RUNNING",
|
||||
"details": map[string]interface{}{
|
||||
"resources": map[string]interface{}{
|
||||
"backend_details": map[string]interface{}{
|
||||
"model": map[string]interface{}{
|
||||
"name": "anthropic--claude-4.6-sonnet",
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
})
|
||||
})
|
||||
mux.HandleFunc("/deployments/anthropic/invoke", func(w http.ResponseWriter, r *http.Request) {
|
||||
if r.Header.Get("Authorization") != "Bearer test-token" {
|
||||
t.Errorf("expected Bearer auth on invoke")
|
||||
}
|
||||
var req anthropicRequest
|
||||
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
|
||||
t.Fatalf("decode request: %v", err)
|
||||
}
|
||||
if req.AnthropicVersion != "bedrock-2023-05-31" {
|
||||
t.Errorf("expected bedrock anthropic_version in request")
|
||||
}
|
||||
if req.System != "You are helpful" {
|
||||
t.Errorf("expected system prompt: %q", req.System)
|
||||
}
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
json.NewEncoder(w).Encode(map[string]interface{}{
|
||||
"content": []map[string]interface{}{
|
||||
{"type": "text", "text": "Hello from AI Core!"},
|
||||
},
|
||||
})
|
||||
})
|
||||
|
||||
server := httptest.NewServer(mux)
|
||||
baseURL = server.URL
|
||||
defer server.Close()
|
||||
|
||||
client := NewAICoreClient(AICoreConfig{
|
||||
ClientID: "test-id",
|
||||
ClientSecret: "test-secret",
|
||||
AuthURL: server.URL,
|
||||
APIURL: server.URL,
|
||||
ResourceGroup: "default",
|
||||
})
|
||||
|
||||
result, err := client.CompleteAnthropic(context.Background(), "anthropic--claude-4.6-sonnet", []Message{
|
||||
{Role: "system", Content: "You are helpful"},
|
||||
{Role: "user", Content: "Hello"},
|
||||
}, 8192, 0)
|
||||
if err != nil {
|
||||
t.Fatalf("unexpected error: %v", err)
|
||||
}
|
||||
if result != "Hello from AI Core!" {
|
||||
t.Errorf("expected 'Hello from AI Core!', got %q", result)
|
||||
}
|
||||
}
|
||||
|
||||
func TestAICoreClient_CompleteOpenAI(t *testing.T) {
|
||||
var baseURL string
|
||||
mux := http.NewServeMux()
|
||||
mux.HandleFunc("/oauth/token", func(w http.ResponseWriter, r *http.Request) {
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
json.NewEncoder(w).Encode(map[string]interface{}{
|
||||
"access_token": "test-token",
|
||||
"expires_in": 3600,
|
||||
})
|
||||
})
|
||||
mux.HandleFunc("/v2/lm/deployments", func(w http.ResponseWriter, r *http.Request) {
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
json.NewEncoder(w).Encode(map[string]interface{}{
|
||||
"resources": []map[string]interface{}{
|
||||
{
|
||||
"id": "deploy-openai",
|
||||
"deploymentUrl": baseURL + "/deployments/openai",
|
||||
"status": "RUNNING",
|
||||
"details": map[string]interface{}{
|
||||
"resources": map[string]interface{}{
|
||||
"backend_details": map[string]interface{}{
|
||||
"model": map[string]interface{}{
|
||||
"name": "gpt-5",
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
})
|
||||
})
|
||||
mux.HandleFunc("/deployments/openai/chat/completions", func(w http.ResponseWriter, r *http.Request) {
|
||||
if r.URL.Query().Get("api-version") != AICoreOpenAIAPIVersion {
|
||||
t.Errorf("expected api-version %s, got %s", AICoreOpenAIAPIVersion, r.URL.Query().Get("api-version"))
|
||||
}
|
||||
var req ChatRequest
|
||||
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
|
||||
t.Fatalf("decode request: %v", err)
|
||||
}
|
||||
if req.Model != "gpt-5" {
|
||||
t.Errorf("expected model gpt-5, got %s", req.Model)
|
||||
}
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
json.NewEncoder(w).Encode(ChatResponse{
|
||||
Choices: []struct {
|
||||
Message struct {
|
||||
Content string `json:"content"`
|
||||
} `json:"message"`
|
||||
}{
|
||||
{Message: struct {
|
||||
Content string `json:"content"`
|
||||
}{Content: "Hello from GPT-5!"}},
|
||||
},
|
||||
})
|
||||
})
|
||||
|
||||
server := httptest.NewServer(mux)
|
||||
baseURL = server.URL
|
||||
defer server.Close()
|
||||
|
||||
client := NewAICoreClient(AICoreConfig{
|
||||
ClientID: "test-id",
|
||||
ClientSecret: "test-secret",
|
||||
AuthURL: server.URL,
|
||||
APIURL: server.URL,
|
||||
ResourceGroup: "default",
|
||||
})
|
||||
|
||||
result, err := client.CompleteOpenAI(context.Background(), "gpt-5", []Message{
|
||||
{Role: "user", Content: "Hello"},
|
||||
}, 0)
|
||||
if err != nil {
|
||||
t.Fatalf("unexpected error: %v", err)
|
||||
}
|
||||
if result != "Hello from GPT-5!" {
|
||||
t.Errorf("expected 'Hello from GPT-5!', got %q", result)
|
||||
}
|
||||
}
|
||||
|
||||
func TestIsAnthropicModel(t *testing.T) {
|
||||
tests := []struct {
|
||||
model string
|
||||
expected bool
|
||||
}{
|
||||
// SAP AI Core uses "anthropic--" prefix for Anthropic models
|
||||
{"anthropic--claude-4.6-sonnet", true},
|
||||
{"anthropic--claude-4.6-opus", true},
|
||||
{"anthropic--claude-3-5-sonnet", true},
|
||||
// Non-prefixed model names are not detected as Anthropic
|
||||
// (SAP AI Core always uses the prefix for Anthropic models)
|
||||
{"claude-sonnet-4", false},
|
||||
{"gpt-5", false},
|
||||
{"gpt-4.1", false},
|
||||
{"llama-3", false},
|
||||
{"my-claude-model", false}, // Avoid false positives on "claude" substring
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
got := IsAnthropicModel(tt.model)
|
||||
if got != tt.expected {
|
||||
t.Errorf("IsAnthropicModel(%q) = %v, want %v", tt.model, got, tt.expected)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestAICoreClient_TokenExpiry(t *testing.T) {
|
||||
tokenCalls := int32(0)
|
||||
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
if r.URL.Path == "/oauth/token" {
|
||||
call := atomic.AddInt32(&tokenCalls, 1)
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
json.NewEncoder(w).Encode(map[string]interface{}{
|
||||
"access_token": fmt.Sprintf("token-%d", call),
|
||||
"expires_in": 1, // 1 second expiry
|
||||
})
|
||||
return
|
||||
}
|
||||
}))
|
||||
defer server.Close()
|
||||
|
||||
client := NewAICoreClient(AICoreConfig{
|
||||
ClientID: "test-id",
|
||||
ClientSecret: "test-secret",
|
||||
AuthURL: server.URL,
|
||||
APIURL: server.URL,
|
||||
ResourceGroup: "default",
|
||||
})
|
||||
|
||||
// First call
|
||||
token1, err := client.getToken(context.Background())
|
||||
if err != nil {
|
||||
t.Fatalf("first getToken: %v", err)
|
||||
}
|
||||
|
||||
// Force token expiry by manipulating expiry time
|
||||
client.mu.Lock()
|
||||
client.tokenExpiry = time.Now().Add(-time.Hour)
|
||||
client.mu.Unlock()
|
||||
|
||||
// Should fetch new token
|
||||
token2, err := client.getToken(context.Background())
|
||||
if err != nil {
|
||||
t.Fatalf("second getToken: %v", err)
|
||||
}
|
||||
|
||||
if token1 == token2 {
|
||||
t.Error("expected different tokens after expiry")
|
||||
}
|
||||
if atomic.LoadInt32(&tokenCalls) != 2 {
|
||||
t.Errorf("expected 2 token calls, got %d", tokenCalls)
|
||||
}
|
||||
}
|
||||
|
||||
func TestAICoreClient_WithTimeout(t *testing.T) {
|
||||
client := NewAICoreClient(AICoreConfig{
|
||||
ClientID: "test-id",
|
||||
ClientSecret: "test-secret",
|
||||
AuthURL: "https://auth.example.com",
|
||||
APIURL: "https://api.example.com",
|
||||
ResourceGroup: "default",
|
||||
})
|
||||
|
||||
// Default timeout is 5 minutes
|
||||
if client.http.Timeout != 5*time.Minute {
|
||||
t.Errorf("expected default timeout 5m, got %v", client.http.Timeout)
|
||||
}
|
||||
|
||||
// WithTimeout should update the timeout
|
||||
client.WithTimeout(10 * time.Minute)
|
||||
if client.http.Timeout != 10*time.Minute {
|
||||
t.Errorf("expected timeout 10m, got %v", client.http.Timeout)
|
||||
}
|
||||
}
|
||||
|
||||
func TestClient_WithAICore(t *testing.T) {
|
||||
client := NewClient("http://example.com", "key", "model")
|
||||
if client.provider != ProviderOpenAI {
|
||||
t.Errorf("expected default provider openai, got %s", client.provider)
|
||||
}
|
||||
|
||||
client.WithAICore(AICoreConfig{
|
||||
ClientID: "id",
|
||||
ClientSecret: "secret",
|
||||
AuthURL: "https://auth.example.com",
|
||||
APIURL: "https://api.example.com",
|
||||
ResourceGroup: "default",
|
||||
})
|
||||
|
||||
if client.provider != ProviderAICore {
|
||||
t.Errorf("expected provider aicore, got %s", client.provider)
|
||||
}
|
||||
if client.aicore == nil {
|
||||
t.Error("expected aicore client to be set")
|
||||
}
|
||||
}
|
||||
|
||||
func TestClient_WithTimeout_PropagatestoAICore(t *testing.T) {
|
||||
client := NewClient("http://example.com", "key", "model").
|
||||
WithAICore(AICoreConfig{
|
||||
ClientID: "id",
|
||||
ClientSecret: "secret",
|
||||
AuthURL: "https://auth.example.com",
|
||||
APIURL: "https://api.example.com",
|
||||
ResourceGroup: "default",
|
||||
})
|
||||
|
||||
// Default should be 5 minutes (inherited from parent client)
|
||||
if client.aicore.http.Timeout != 5*time.Minute {
|
||||
t.Errorf("expected aicore default timeout 5m, got %v", client.aicore.http.Timeout)
|
||||
}
|
||||
|
||||
// WithTimeout should propagate to AI Core client
|
||||
client.WithTimeout(15 * time.Minute)
|
||||
if client.http.Timeout != 15*time.Minute {
|
||||
t.Errorf("expected parent timeout 15m, got %v", client.http.Timeout)
|
||||
}
|
||||
if client.aicore.http.Timeout != 15*time.Minute {
|
||||
t.Errorf("expected aicore timeout 15m, got %v", client.aicore.http.Timeout)
|
||||
}
|
||||
}
|
||||
|
||||
func TestClient_CompleteAICore(t *testing.T) {
|
||||
var baseURL string
|
||||
mux := http.NewServeMux()
|
||||
mux.HandleFunc("/oauth/token", func(w http.ResponseWriter, r *http.Request) {
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
json.NewEncoder(w).Encode(map[string]interface{}{
|
||||
"access_token": "test-token",
|
||||
"expires_in": 3600,
|
||||
})
|
||||
})
|
||||
mux.HandleFunc("/v2/lm/deployments", func(w http.ResponseWriter, r *http.Request) {
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
json.NewEncoder(w).Encode(map[string]interface{}{
|
||||
"resources": []map[string]interface{}{
|
||||
{
|
||||
"id": "deploy-test",
|
||||
"deploymentUrl": baseURL + "/deployments/test",
|
||||
"status": "RUNNING",
|
||||
"details": map[string]interface{}{
|
||||
"resources": map[string]interface{}{
|
||||
"backend_details": map[string]interface{}{
|
||||
"model": map[string]interface{}{
|
||||
"name": "gpt-5",
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
})
|
||||
})
|
||||
mux.HandleFunc("/deployments/test/chat/completions", func(w http.ResponseWriter, r *http.Request) {
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
json.NewEncoder(w).Encode(ChatResponse{
|
||||
Choices: []struct {
|
||||
Message struct {
|
||||
Content string `json:"content"`
|
||||
} `json:"message"`
|
||||
}{
|
||||
{Message: struct {
|
||||
Content string `json:"content"`
|
||||
}{Content: "AI Core via Client works!"}},
|
||||
},
|
||||
})
|
||||
})
|
||||
|
||||
server := httptest.NewServer(mux)
|
||||
baseURL = server.URL
|
||||
defer server.Close()
|
||||
|
||||
client := NewClient("", "", "gpt-5").WithAICore(AICoreConfig{
|
||||
ClientID: "test-id",
|
||||
ClientSecret: "test-secret",
|
||||
AuthURL: server.URL,
|
||||
APIURL: server.URL,
|
||||
ResourceGroup: "default",
|
||||
})
|
||||
|
||||
result, err := client.Complete(context.Background(), []Message{
|
||||
{Role: "user", Content: "Hello"},
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("unexpected error: %v", err)
|
||||
}
|
||||
if !strings.Contains(result, "AI Core via Client works!") {
|
||||
t.Errorf("unexpected result: %s", result)
|
||||
}
|
||||
}
|
||||
+24
-223
@@ -1,6 +1,4 @@
|
||||
// Package llm provides clients for LLM chat completion APIs.
|
||||
//
|
||||
// Supports OpenAI-compatible (default), Anthropic Messages API, and SAP AI Core providers.
|
||||
// Package llm provides a client for OpenAI-compatible chat completion APIs.
|
||||
package llm
|
||||
|
||||
import (
|
||||
@@ -14,50 +12,30 @@ import (
|
||||
"time"
|
||||
)
|
||||
|
||||
// Provider identifies which API format to use.
|
||||
type Provider string
|
||||
|
||||
const (
|
||||
// ProviderOpenAI uses the OpenAI-compatible chat/completions endpoint.
|
||||
ProviderOpenAI Provider = "openai"
|
||||
// ProviderAnthropic uses the Anthropic Messages API endpoint.
|
||||
ProviderAnthropic Provider = "anthropic"
|
||||
// ProviderAICore uses SAP AI Core with OAuth authentication.
|
||||
ProviderAICore Provider = "aicore"
|
||||
)
|
||||
|
||||
// Client calls an LLM chat completion API.
|
||||
// Client calls an OpenAI-compatible chat completion API.
|
||||
// A Client is safe for concurrent use by multiple goroutines after construction.
|
||||
// WithTimeout, WithTemperature, and WithProvider must be called during setup,
|
||||
// before concurrent use.
|
||||
// WithTimeout and WithTemperature must be called during setup, before concurrent use.
|
||||
type Client struct {
|
||||
baseURL string
|
||||
apiKey string
|
||||
model string
|
||||
temperature float64
|
||||
provider Provider
|
||||
http *http.Client
|
||||
aicore *AICoreClient // Only set when provider is aicore
|
||||
}
|
||||
|
||||
// NewClient creates a new LLM client. Default provider is OpenAI-compatible.
|
||||
// NewClient creates a new LLM client.
|
||||
func NewClient(baseURL, apiKey, model string) *Client {
|
||||
return &Client{
|
||||
baseURL: strings.TrimRight(baseURL, "/"),
|
||||
apiKey: apiKey,
|
||||
model: model,
|
||||
provider: ProviderOpenAI,
|
||||
http: &http.Client{Timeout: 5 * time.Minute},
|
||||
baseURL: strings.TrimRight(baseURL, "/"),
|
||||
apiKey: apiKey,
|
||||
model: model,
|
||||
http: &http.Client{Timeout: 5 * time.Minute},
|
||||
}
|
||||
}
|
||||
|
||||
// WithTimeout sets the HTTP request timeout for LLM calls (default 5 minutes).
|
||||
// When using AI Core, this also sets the timeout on the AI Core client.
|
||||
func (c *Client) WithTimeout(d time.Duration) *Client {
|
||||
c.http.Timeout = d
|
||||
if c.aicore != nil {
|
||||
c.aicore.WithTimeout(d)
|
||||
}
|
||||
return c
|
||||
}
|
||||
|
||||
@@ -67,102 +45,20 @@ func (c *Client) WithTemperature(t float64) *Client {
|
||||
return c
|
||||
}
|
||||
|
||||
// WithProvider sets the API provider format (openai, anthropic, or aicore).
|
||||
func (c *Client) WithProvider(p Provider) *Client {
|
||||
c.provider = p
|
||||
return c
|
||||
}
|
||||
|
||||
// WithAICore configures the client to use SAP AI Core for authentication.
|
||||
// This sets the provider to aicore automatically.
|
||||
// The AI Core client inherits the current HTTP timeout from this client.
|
||||
func (c *Client) WithAICore(cfg AICoreConfig) *Client {
|
||||
c.provider = ProviderAICore
|
||||
c.aicore = NewAICoreClient(cfg).WithTimeout(c.http.Timeout)
|
||||
return c
|
||||
}
|
||||
|
||||
// Message represents a chat message.
|
||||
type Message struct {
|
||||
Role string `json:"role"`
|
||||
Content string `json:"content"`
|
||||
}
|
||||
|
||||
// Complete sends a chat completion request and returns the assistant's response content.
|
||||
// The first message with role "system" is treated as the system prompt.
|
||||
func (c *Client) Complete(ctx context.Context, messages []Message) (string, error) {
|
||||
var result string
|
||||
var err error
|
||||
|
||||
for attempt := 0; attempt < 2; attempt++ {
|
||||
switch c.provider {
|
||||
case ProviderAnthropic:
|
||||
result, err = c.completeAnthropic(ctx, messages)
|
||||
case ProviderAICore:
|
||||
result, err = c.completeAICore(ctx, messages)
|
||||
default:
|
||||
result, err = c.completeOpenAI(ctx, messages)
|
||||
}
|
||||
|
||||
if err == nil {
|
||||
return result, nil
|
||||
}
|
||||
|
||||
// Only retry on response body read errors (transient network issues).
|
||||
// Do not retry on context cancellation, status errors, or parse errors
|
||||
// that indicate a structural API problem.
|
||||
if !isRetryableError(err) {
|
||||
return "", err
|
||||
}
|
||||
|
||||
if attempt == 0 && ctx.Err() == nil {
|
||||
// Brief pause before retry to allow transient issues to resolve.
|
||||
time.Sleep(500 * time.Millisecond)
|
||||
}
|
||||
}
|
||||
|
||||
return "", err
|
||||
}
|
||||
|
||||
// completeAICore routes to AI Core using the appropriate endpoint based on model type.
|
||||
func (c *Client) completeAICore(ctx context.Context, messages []Message) (string, error) {
|
||||
if c.aicore == nil {
|
||||
return "", fmt.Errorf("AI Core client not configured")
|
||||
}
|
||||
|
||||
if IsAnthropicModel(c.model) {
|
||||
return c.aicore.CompleteAnthropic(ctx, c.model, messages, 8192, c.temperature)
|
||||
}
|
||||
return c.aicore.CompleteOpenAI(ctx, c.model, messages, c.temperature)
|
||||
}
|
||||
|
||||
// isRetryableError returns true for transient errors worth retrying.
|
||||
func isRetryableError(err error) bool {
|
||||
if err == nil {
|
||||
return false
|
||||
}
|
||||
s := err.Error()
|
||||
// Body read failures (connection reset, truncation)
|
||||
if strings.Contains(s, "read response") {
|
||||
return true
|
||||
}
|
||||
// Unexpected body length (our content-length validation)
|
||||
if strings.Contains(s, "body length mismatch") {
|
||||
return true
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
// --- OpenAI-compatible implementation ---
|
||||
|
||||
// ChatRequest is the OpenAI request payload.
|
||||
// ChatRequest is the request payload.
|
||||
type ChatRequest struct {
|
||||
Model string `json:"model"`
|
||||
Messages []Message `json:"messages"`
|
||||
Temperature float64 `json:"temperature,omitempty"`
|
||||
}
|
||||
|
||||
// ChatResponse is the OpenAI response.
|
||||
// ChatResponse is the response from the API.
|
||||
type ChatResponse struct {
|
||||
Choices []struct {
|
||||
Message struct {
|
||||
@@ -171,7 +67,8 @@ type ChatResponse struct {
|
||||
} `json:"choices"`
|
||||
}
|
||||
|
||||
func (c *Client) completeOpenAI(ctx context.Context, messages []Message) (string, error) {
|
||||
// Complete sends a chat completion request and returns the assistant's response content.
|
||||
func (c *Client) Complete(ctx context.Context, messages []Message) (string, error) {
|
||||
reqBody := ChatRequest{
|
||||
Model: c.model,
|
||||
Temperature: c.temperature,
|
||||
@@ -184,133 +81,37 @@ func (c *Client) completeOpenAI(ctx context.Context, messages []Message) (string
|
||||
}
|
||||
|
||||
url := c.baseURL + "/chat/completions"
|
||||
req, err := http.NewRequestWithContext(ctx, http.MethodPost, url, bytes.NewReader(data))
|
||||
req, err := http.NewRequestWithContext(ctx, "POST", url, bytes.NewReader(data))
|
||||
if err != nil {
|
||||
return "", fmt.Errorf("create request: %w", err)
|
||||
}
|
||||
req.Header.Set("Authorization", "Bearer "+c.apiKey)
|
||||
req.Header.Set("Content-Type", "application/json")
|
||||
|
||||
return c.doRequest(req, func(body []byte) (string, error) {
|
||||
var resp ChatResponse
|
||||
if err := json.Unmarshal(body, &resp); err != nil {
|
||||
return "", fmt.Errorf("parse response: %w", err)
|
||||
}
|
||||
if len(resp.Choices) == 0 {
|
||||
return "", fmt.Errorf("no choices in LLM response")
|
||||
}
|
||||
return resp.Choices[0].Message.Content, nil
|
||||
})
|
||||
}
|
||||
|
||||
// --- Anthropic Messages API implementation ---
|
||||
|
||||
type anthropicRequest struct {
|
||||
AnthropicVersion string `json:"anthropic_version,omitempty"`
|
||||
Model string `json:"model,omitempty"`
|
||||
MaxTokens int `json:"max_tokens"`
|
||||
System string `json:"system,omitempty"`
|
||||
Messages []anthropicMsg `json:"messages"`
|
||||
Temperature float64 `json:"temperature,omitempty"`
|
||||
}
|
||||
|
||||
type anthropicMsg struct {
|
||||
Role string `json:"role"`
|
||||
Content string `json:"content"`
|
||||
}
|
||||
|
||||
type anthropicResponse struct {
|
||||
Content []struct {
|
||||
Type string `json:"type"`
|
||||
Text string `json:"text"`
|
||||
} `json:"content"`
|
||||
}
|
||||
|
||||
func (c *Client) completeAnthropic(ctx context.Context, messages []Message) (string, error) {
|
||||
// Extract system message (first message with role "system")
|
||||
var system string
|
||||
var userMessages []anthropicMsg
|
||||
for _, m := range messages {
|
||||
if m.Role == "system" {
|
||||
system = m.Content
|
||||
} else {
|
||||
userMessages = append(userMessages, anthropicMsg{
|
||||
Role: m.Role,
|
||||
Content: m.Content,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
reqBody := anthropicRequest{
|
||||
Model: c.model,
|
||||
MaxTokens: 8192,
|
||||
System: system,
|
||||
Messages: userMessages,
|
||||
}
|
||||
if c.temperature > 0 {
|
||||
reqBody.Temperature = c.temperature
|
||||
}
|
||||
|
||||
data, err := json.Marshal(reqBody)
|
||||
if err != nil {
|
||||
return "", fmt.Errorf("marshal request: %w", err)
|
||||
}
|
||||
|
||||
url := c.baseURL + "/messages"
|
||||
req, err := http.NewRequestWithContext(ctx, http.MethodPost, url, bytes.NewReader(data))
|
||||
if err != nil {
|
||||
return "", fmt.Errorf("create request: %w", err)
|
||||
}
|
||||
req.Header.Set("x-api-key", c.apiKey)
|
||||
req.Header.Set("anthropic-version", "2023-06-01")
|
||||
req.Header.Set("Content-Type", "application/json")
|
||||
|
||||
return c.doRequest(req, func(body []byte) (string, error) {
|
||||
var resp anthropicResponse
|
||||
if err := json.Unmarshal(body, &resp); err != nil {
|
||||
return "", fmt.Errorf("parse response: %w", err)
|
||||
}
|
||||
if len(resp.Content) == 0 {
|
||||
return "", fmt.Errorf("no content in Anthropic response")
|
||||
}
|
||||
// Concatenate all text blocks
|
||||
var sb strings.Builder
|
||||
for _, block := range resp.Content {
|
||||
if block.Type == "text" {
|
||||
sb.WriteString(block.Text)
|
||||
}
|
||||
}
|
||||
result := sb.String()
|
||||
if result == "" {
|
||||
return "", fmt.Errorf("no text content in Anthropic response")
|
||||
}
|
||||
return result, nil
|
||||
})
|
||||
}
|
||||
|
||||
// --- Shared HTTP execution ---
|
||||
|
||||
func (c *Client) doRequest(req *http.Request, parse func([]byte) (string, error)) (string, error) {
|
||||
resp, err := c.http.Do(req)
|
||||
if err != nil {
|
||||
return "", fmt.Errorf("LLM request: %w", err)
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
|
||||
if resp.StatusCode < 200 || resp.StatusCode >= 300 {
|
||||
body, _ := io.ReadAll(resp.Body)
|
||||
return "", fmt.Errorf("LLM API error (status %d): %s", resp.StatusCode, string(body))
|
||||
}
|
||||
|
||||
body, err := io.ReadAll(resp.Body)
|
||||
if err != nil {
|
||||
return "", fmt.Errorf("read response: %w", err)
|
||||
}
|
||||
|
||||
// Validate body length against Content-Length header when present.
|
||||
// A mismatch indicates the response was truncated in transit.
|
||||
if cl := resp.ContentLength; cl > 0 && int64(len(body)) < cl {
|
||||
return "", fmt.Errorf("body length mismatch: Content-Length=%d, received=%d", cl, len(body))
|
||||
var chatResp ChatResponse
|
||||
if err := json.Unmarshal(body, &chatResp); err != nil {
|
||||
return "", fmt.Errorf("parse response: %w", err)
|
||||
}
|
||||
|
||||
if resp.StatusCode < 200 || resp.StatusCode >= 300 {
|
||||
return "", fmt.Errorf("LLM API error (status %d): %s", resp.StatusCode, string(body))
|
||||
if len(chatResp.Choices) == 0 {
|
||||
return "", fmt.Errorf("no choices in LLM response")
|
||||
}
|
||||
|
||||
return parse(body)
|
||||
return chatResp.Choices[0].Message.Content, nil
|
||||
}
|
||||
|
||||
@@ -3,7 +3,6 @@ package llm
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"testing"
|
||||
@@ -209,218 +208,3 @@ func TestWithTimeout(t *testing.T) {
|
||||
t.Error("expected timeout error with 50ms timeout and 200ms server delay")
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
func TestComplete_Anthropic_Success(t *testing.T) {
|
||||
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
if r.URL.Path != "/messages" {
|
||||
t.Errorf("unexpected path: %s", r.URL.Path)
|
||||
}
|
||||
if r.Header.Get("x-api-key") != "test-key" {
|
||||
t.Errorf("expected x-api-key header, got %q", r.Header.Get("x-api-key"))
|
||||
}
|
||||
if r.Header.Get("anthropic-version") != "2023-06-01" {
|
||||
t.Errorf("expected anthropic-version header, got %q", r.Header.Get("anthropic-version"))
|
||||
}
|
||||
|
||||
var req map[string]interface{}
|
||||
json.NewDecoder(r.Body).Decode(&req)
|
||||
|
||||
if req["system"] != "You are helpful" {
|
||||
t.Errorf("expected system prompt, got %v", req["system"])
|
||||
}
|
||||
msgs := req["messages"].([]interface{})
|
||||
if len(msgs) != 1 {
|
||||
t.Errorf("expected 1 user message, got %d", len(msgs))
|
||||
}
|
||||
if req["max_tokens"] != float64(8192) {
|
||||
t.Errorf("expected max_tokens 8192, got %v", req["max_tokens"])
|
||||
}
|
||||
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
w.Write([]byte(`{"content":[{"type":"text","text":"Hello from Claude!"}]}`))
|
||||
}))
|
||||
defer server.Close()
|
||||
|
||||
client := NewClient(server.URL, "test-key", "claude-sonnet").WithProvider(ProviderAnthropic)
|
||||
got, err := client.Complete(context.Background(), []Message{
|
||||
{Role: "system", Content: "You are helpful"},
|
||||
{Role: "user", Content: "Hi"},
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("unexpected error: %v", err)
|
||||
}
|
||||
if got != "Hello from Claude!" {
|
||||
t.Errorf("expected %q, got %q", "Hello from Claude!", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestComplete_Anthropic_NoContent(t *testing.T) {
|
||||
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
w.Write([]byte(`{"content":[]}`))
|
||||
}))
|
||||
defer server.Close()
|
||||
|
||||
client := NewClient(server.URL, "test-key", "claude-sonnet").WithProvider(ProviderAnthropic)
|
||||
_, err := client.Complete(context.Background(), []Message{{Role: "user", Content: "Hi"}})
|
||||
if err == nil {
|
||||
t.Fatal("expected error for empty content, got nil")
|
||||
}
|
||||
}
|
||||
|
||||
func TestComplete_Anthropic_APIError(t *testing.T) {
|
||||
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
w.WriteHeader(http.StatusBadRequest)
|
||||
w.Write([]byte(`{"error":{"message":"invalid request"}}`))
|
||||
}))
|
||||
defer server.Close()
|
||||
|
||||
client := NewClient(server.URL, "test-key", "claude-sonnet").WithProvider(ProviderAnthropic)
|
||||
_, err := client.Complete(context.Background(), []Message{{Role: "user", Content: "Hi"}})
|
||||
if err == nil {
|
||||
t.Fatal("expected error for 400, got nil")
|
||||
}
|
||||
}
|
||||
|
||||
func TestWithProvider(t *testing.T) {
|
||||
client := NewClient("http://example.com", "key", "model")
|
||||
if client.provider != ProviderOpenAI {
|
||||
t.Errorf("expected default provider openai, got %s", client.provider)
|
||||
}
|
||||
result := client.WithProvider(ProviderAnthropic)
|
||||
if result != client {
|
||||
t.Error("WithProvider should return the same client for chaining")
|
||||
}
|
||||
if client.provider != ProviderAnthropic {
|
||||
t.Errorf("expected provider anthropic, got %s", client.provider)
|
||||
}
|
||||
}
|
||||
|
||||
func TestComplete_RetryOnBodyReadError(t *testing.T) {
|
||||
attempts := 0
|
||||
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
attempts++
|
||||
if attempts == 1 {
|
||||
// First attempt: send headers then close connection abruptly
|
||||
// Simulate by writing partial response and flushing with wrong Content-Length
|
||||
w.Header().Set("Content-Length", "1000")
|
||||
w.WriteHeader(http.StatusOK)
|
||||
w.Write([]byte(`{"choices":[{"message":{"con`))
|
||||
// The test HTTP server will close the connection after handler returns,
|
||||
// but Content-Length mismatch means client gets fewer bytes than expected
|
||||
return
|
||||
}
|
||||
// Second attempt: succeed
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
json.NewEncoder(w).Encode(ChatResponse{
|
||||
Choices: []struct {
|
||||
Message struct {
|
||||
Content string `json:"content"`
|
||||
} `json:"message"`
|
||||
}{{Message: struct {
|
||||
Content string `json:"content"`
|
||||
}{Content: "success"}}},
|
||||
})
|
||||
}))
|
||||
defer server.Close()
|
||||
|
||||
client := NewClient(server.URL, "key", "model")
|
||||
got, err := client.Complete(context.Background(), []Message{{Role: "user", Content: "Hi"}})
|
||||
if err != nil {
|
||||
t.Fatalf("expected retry to succeed, got error: %v", err)
|
||||
}
|
||||
if got != "success" {
|
||||
t.Errorf("expected %q, got %q", "success", got)
|
||||
}
|
||||
if attempts != 2 {
|
||||
t.Errorf("expected 2 attempts, got %d", attempts)
|
||||
}
|
||||
}
|
||||
|
||||
func TestComplete_ContentLengthMismatch(t *testing.T) {
|
||||
attempts := 0
|
||||
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
attempts++
|
||||
if attempts == 1 {
|
||||
// Claim Content-Length is larger than actual body
|
||||
w.Header().Set("Content-Length", "500")
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
w.WriteHeader(http.StatusOK)
|
||||
// Write less than 500 bytes
|
||||
w.Write([]byte(`{"choices":[{"message":{"content":"partial"}}]}`))
|
||||
return
|
||||
}
|
||||
// Second attempt succeeds
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
json.NewEncoder(w).Encode(ChatResponse{
|
||||
Choices: []struct {
|
||||
Message struct {
|
||||
Content string `json:"content"`
|
||||
} `json:"message"`
|
||||
}{{Message: struct {
|
||||
Content string `json:"content"`
|
||||
}{Content: "complete"}}},
|
||||
})
|
||||
}))
|
||||
defer server.Close()
|
||||
|
||||
client := NewClient(server.URL, "key", "model")
|
||||
got, err := client.Complete(context.Background(), []Message{{Role: "user", Content: "Hi"}})
|
||||
if err != nil {
|
||||
t.Fatalf("expected retry to succeed on content-length mismatch, got: %v", err)
|
||||
}
|
||||
if got != "complete" {
|
||||
t.Errorf("expected %q, got %q", "complete", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestComplete_NoRetryOnAPIError(t *testing.T) {
|
||||
attempts := 0
|
||||
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
attempts++
|
||||
w.WriteHeader(http.StatusBadRequest)
|
||||
w.Write([]byte(`{"error":"bad request"}`))
|
||||
}))
|
||||
defer server.Close()
|
||||
|
||||
client := NewClient(server.URL, "key", "model")
|
||||
_, err := client.Complete(context.Background(), []Message{{Role: "user", Content: "Hi"}})
|
||||
if err == nil {
|
||||
t.Fatal("expected error for 400, got nil")
|
||||
}
|
||||
if attempts != 1 {
|
||||
t.Errorf("should not retry on API errors, got %d attempts", attempts)
|
||||
}
|
||||
}
|
||||
|
||||
func TestIsRetryableError(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
err string
|
||||
expected bool
|
||||
}{
|
||||
{"nil formatted", "", false},
|
||||
{"read response error", "read response: unexpected EOF", true},
|
||||
{"body length mismatch", "body length mismatch: Content-Length=1000, received=500", true},
|
||||
{"API error", "LLM API error (status 400): bad request", false},
|
||||
{"parse error", "parse response: unexpected end of JSON input", false},
|
||||
{"request error", "LLM request: connection refused", false},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
if tt.err == "" {
|
||||
if isRetryableError(nil) {
|
||||
t.Error("nil error should not be retryable")
|
||||
}
|
||||
return
|
||||
}
|
||||
err := fmt.Errorf("%s", tt.err)
|
||||
got := isRetryableError(err)
|
||||
if got != tt.expected {
|
||||
t.Errorf("isRetryableError(%q) = %v, want %v", tt.err, got, tt.expected)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
+14
-36
@@ -7,40 +7,8 @@ import (
|
||||
|
||||
// FormatMarkdown formats a ReviewResult into the markdown body for a Gitea review.
|
||||
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).
|
||||
// displayName is used for the header title, sentinelName is used for the cleanup sentinel.
|
||||
// If displayName is empty, sentinelName is used for both.
|
||||
func FormatMarkdownWithDisplay(result *ReviewResult, displayName, sentinelName string) string {
|
||||
var sb strings.Builder
|
||||
|
||||
// Use display name for header, or fall back to sentinel name
|
||||
headerName := displayName
|
||||
if headerName == "" {
|
||||
headerName = sentinelName
|
||||
}
|
||||
|
||||
if headerName != "" {
|
||||
title := CapitalizeFirst(headerName)
|
||||
sb.WriteString(fmt.Sprintf("# %s Review\n\n", title))
|
||||
}
|
||||
|
||||
sb.WriteString("## Summary\n\n")
|
||||
sb.WriteString(result.Summary)
|
||||
sb.WriteString("\n\n")
|
||||
@@ -60,11 +28,21 @@ func FormatMarkdownWithDisplay(result *ReviewResult, displayName, sentinelName s
|
||||
sb.WriteString("## Recommendation\n\n")
|
||||
sb.WriteString(fmt.Sprintf("**%s** — %s\n", result.Verdict, result.Recommendation))
|
||||
|
||||
if sentinelName != "" {
|
||||
sb.WriteString(fmt.Sprintf("\n---\n*Review by %s*\n", headerName))
|
||||
// Hidden sentinel for identifying this bot's reviews during cleanup
|
||||
sb.WriteString(fmt.Sprintf("\n<!-- review-bot:%s -->\n", sentinelName))
|
||||
if reviewerName != "" {
|
||||
sb.WriteString(fmt.Sprintf("\n---\n*Review by %s*\n", reviewerName))
|
||||
}
|
||||
|
||||
return sb.String()
|
||||
}
|
||||
|
||||
// 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"
|
||||
}
|
||||
}
|
||||
|
||||
@@ -116,101 +116,3 @@ func TestGiteaEvent(t *testing.T) {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestFormatMarkdown_Sentinel(t *testing.T) {
|
||||
result := &ReviewResult{
|
||||
Verdict: "APPROVE",
|
||||
Summary: "All good.",
|
||||
Recommendation: "Merge it.",
|
||||
}
|
||||
output := FormatMarkdown(result, "security")
|
||||
if !strings.Contains(output, "<!-- review-bot:security -->") {
|
||||
t.Error("expected sentinel comment in output")
|
||||
}
|
||||
|
||||
// Empty reviewer name should NOT have sentinel
|
||||
output2 := FormatMarkdown(result, "")
|
||||
if strings.Contains(output2, "<!-- review-bot") {
|
||||
t.Error("should not contain sentinel when reviewer name is empty")
|
||||
}
|
||||
}
|
||||
|
||||
func TestFormatMarkdown_RoleTitle(t *testing.T) {
|
||||
result := &ReviewResult{
|
||||
Verdict: "APPROVE",
|
||||
Summary: "All good.",
|
||||
Recommendation: "Merge it.",
|
||||
}
|
||||
|
||||
// With reviewer name: should have title header
|
||||
output := FormatMarkdown(result, "security")
|
||||
if !strings.Contains(output, "# Security Review\n") {
|
||||
t.Error("expected '# Security Review' header when reviewer name is set")
|
||||
}
|
||||
|
||||
output2 := FormatMarkdown(result, "gpt")
|
||||
if !strings.Contains(output2, "# Gpt Review\n") {
|
||||
t.Error("expected '# Gpt Review' header")
|
||||
}
|
||||
|
||||
// Without reviewer name: no title header
|
||||
output3 := FormatMarkdown(result, "")
|
||||
if strings.Contains(output3, "# ") && strings.Contains(output3, " Review\n") {
|
||||
t.Error("should not contain role title header when reviewer name is empty")
|
||||
}
|
||||
}
|
||||
|
||||
func TestFormatMarkdownWithDisplay(t *testing.T) {
|
||||
result := &ReviewResult{
|
||||
Verdict: "APPROVE",
|
||||
Summary: "Test summary",
|
||||
Findings: nil,
|
||||
Recommendation: "Test recommendation",
|
||||
}
|
||||
|
||||
t.Run("with display name", func(t *testing.T) {
|
||||
body := FormatMarkdownWithDisplay(result, "Security Specialist", "security")
|
||||
|
||||
// Header should use display name
|
||||
if !strings.Contains(body, "# Security Specialist Review") {
|
||||
t.Error("header should use display name")
|
||||
}
|
||||
|
||||
// Sentinel should use sentinel name
|
||||
if !strings.Contains(body, "<!-- review-bot:security -->") {
|
||||
t.Error("sentinel should use sentinel name")
|
||||
}
|
||||
|
||||
// Footer "Review by" should use display name
|
||||
if !strings.Contains(body, "*Review by Security Specialist*") {
|
||||
t.Error("footer should use display name")
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("without display name", func(t *testing.T) {
|
||||
body := FormatMarkdownWithDisplay(result, "", "reviewer")
|
||||
|
||||
// Should fall back to sentinel name for header
|
||||
if !strings.Contains(body, "# Reviewer Review") {
|
||||
t.Error("header should fall back to sentinel name")
|
||||
}
|
||||
|
||||
if !strings.Contains(body, "<!-- review-bot:reviewer -->") {
|
||||
t.Error("sentinel should use sentinel name")
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("empty both names", func(t *testing.T) {
|
||||
body := FormatMarkdownWithDisplay(result, "", "")
|
||||
|
||||
// Should not have header
|
||||
if strings.Contains(body, "# ") && strings.Contains(body, " Review") {
|
||||
t.Error("should not have header when both names empty")
|
||||
}
|
||||
|
||||
// Should not have sentinel
|
||||
if strings.Contains(body, "<!-- review-bot:") {
|
||||
t.Error("should not have sentinel when sentinel name empty")
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
+1
-240
@@ -29,19 +29,7 @@ func ParseResponse(response string) (*ReviewResult, error) {
|
||||
|
||||
var result ReviewResult
|
||||
if err := json.Unmarshal([]byte(cleaned), &result); err != nil {
|
||||
// LLMs sometimes produce JSON with unescaped quotes inside string values.
|
||||
// Try to repair before giving up.
|
||||
repaired := repairJSON(cleaned)
|
||||
if err2 := json.Unmarshal([]byte(repaired), &result); err2 != nil {
|
||||
// Include diagnostic info: lengths help identify truncation
|
||||
rawLen := len(response)
|
||||
cleanedLen := len(cleaned)
|
||||
preview := cleaned
|
||||
if len(preview) > 200 {
|
||||
preview = preview[:100] + "..." + preview[len(preview)-100:]
|
||||
}
|
||||
return nil, fmt.Errorf("parse LLM response as JSON: %w\nRaw length: %d, cleaned length: %d\nCleaned preview: %s", err, rawLen, cleanedLen, preview)
|
||||
}
|
||||
return nil, fmt.Errorf("parse LLM response as JSON: %w\nRaw response: %s", err, response)
|
||||
}
|
||||
|
||||
// Validate verdict
|
||||
@@ -86,230 +74,3 @@ func extractJSON(s string) string {
|
||||
s = strings.TrimSpace(s)
|
||||
return s
|
||||
}
|
||||
|
||||
// repairJSON attempts to fix common LLM JSON issues:
|
||||
// - Unescaped double quotes inside string values
|
||||
//
|
||||
// Strategy: walk the JSON structurally. Object keys are parsed normally (LLMs
|
||||
// get those right). For string VALUES, we find all candidate closing quotes and
|
||||
// pick the LAST one that leaves valid JSON structure afterward — maximizing
|
||||
// string content, which is the correct bias for the "LLM put unescaped quotes
|
||||
// in a string value" failure mode.
|
||||
func repairJSON(s string) string {
|
||||
runes := []rune(s)
|
||||
var out strings.Builder
|
||||
out.Grow(len(s) + 64)
|
||||
|
||||
i := 0
|
||||
for i < len(runes) {
|
||||
c := runes[i]
|
||||
|
||||
if c != '"' {
|
||||
out.WriteRune(c)
|
||||
i++
|
||||
continue
|
||||
}
|
||||
|
||||
// We hit an opening quote. Determine if this is a key or a value.
|
||||
// Keys: the standard JSON parser in LLMs gets keys right, so we parse
|
||||
// them normally (first unescaped quote closes).
|
||||
// Values: may contain unescaped quotes — use the repair heuristic.
|
||||
isValue := isValuePosition(runes, i)
|
||||
|
||||
if !isValue {
|
||||
// Parse key/simple string normally
|
||||
out.WriteRune('"')
|
||||
i++
|
||||
for i < len(runes) {
|
||||
ch := runes[i]
|
||||
if ch == '\\' && i+1 < len(runes) {
|
||||
out.WriteRune(ch)
|
||||
i++
|
||||
out.WriteRune(runes[i])
|
||||
i++
|
||||
continue
|
||||
}
|
||||
if ch == '"' {
|
||||
out.WriteRune('"')
|
||||
i++
|
||||
break
|
||||
}
|
||||
out.WriteRune(ch)
|
||||
i++
|
||||
}
|
||||
continue
|
||||
}
|
||||
|
||||
// Value string — find the correct close using last-valid-candidate heuristic
|
||||
out.WriteRune('"')
|
||||
i++
|
||||
|
||||
closeIdx := findClosingQuote(runes, i)
|
||||
|
||||
// Write everything between open and close, escaping interior quotes
|
||||
for j := i; j < closeIdx; j++ {
|
||||
ch := runes[j]
|
||||
if ch == '\\' && j+1 < closeIdx {
|
||||
// Already-escaped sequence — pass through
|
||||
out.WriteRune(ch)
|
||||
j++
|
||||
out.WriteRune(runes[j])
|
||||
} else if ch == '"' {
|
||||
out.WriteRune('\\')
|
||||
out.WriteRune('"')
|
||||
} else {
|
||||
out.WriteRune(ch)
|
||||
}
|
||||
}
|
||||
|
||||
// Write the closing quote
|
||||
out.WriteRune('"')
|
||||
i = closeIdx + 1
|
||||
}
|
||||
|
||||
return out.String()
|
||||
}
|
||||
|
||||
// isValuePosition determines if the quote at position i is opening a JSON value
|
||||
// string (as opposed to an object key). We only apply repair to values that
|
||||
// follow ':' since those are the free-text fields where LLMs produce unescaped
|
||||
// quotes. Array elements and keys are left alone (parsed normally).
|
||||
func isValuePosition(runes []rune, i int) bool {
|
||||
// Look backward, skipping whitespace, for the preceding structural char
|
||||
j := i - 1
|
||||
for j >= 0 && (runes[j] == ' ' || runes[j] == '\t' || runes[j] == '\n' || runes[j] == '\r') {
|
||||
j--
|
||||
}
|
||||
if j < 0 {
|
||||
return false
|
||||
}
|
||||
// After ':' → definitely a value
|
||||
return runes[j] == ':'
|
||||
}
|
||||
|
||||
// findClosingQuote finds the index of the true closing quote for a JSON string
|
||||
// value starting at position start (the character after the opening quote).
|
||||
// It collects all unescaped quote candidates and returns the FIRST one that
|
||||
// produces valid JSON continuation (deeper lookahead verifies the next token).
|
||||
func findClosingQuote(runes []rune, start int) int {
|
||||
// Collect all candidate positions for the closing quote.
|
||||
var candidates []int
|
||||
for j := start; j < len(runes); j++ {
|
||||
if runes[j] == '\\' {
|
||||
j++ // skip escaped character
|
||||
continue
|
||||
}
|
||||
if runes[j] == '"' {
|
||||
candidates = append(candidates, j)
|
||||
}
|
||||
}
|
||||
|
||||
if len(candidates) == 0 {
|
||||
return len(runes)
|
||||
}
|
||||
|
||||
if len(candidates) == 1 {
|
||||
return candidates[0]
|
||||
}
|
||||
|
||||
// Try candidates from FIRST to LAST. The correct closing quote is the
|
||||
// earliest one that produces valid JSON structure after it (verified by
|
||||
// deeper lookahead that checks the next token is a valid JSON start).
|
||||
for _, idx := range candidates {
|
||||
if isValidJSONAfterClose(runes, idx+1) {
|
||||
return idx
|
||||
}
|
||||
}
|
||||
|
||||
// Fallback: return the last candidate
|
||||
return candidates[len(candidates)-1]
|
||||
}
|
||||
|
||||
// isValidJSONAfterClose checks whether the runes after a candidate closing quote
|
||||
// look like valid JSON continuation for a VALUE string. Since we only use this
|
||||
// for value positions, ':' is NOT a valid continuation (values are never keys).
|
||||
// Checks deeper structure to avoid being fooled by JSON-like content in strings.
|
||||
func isValidJSONAfterClose(runes []rune, pos int) bool {
|
||||
j := pos
|
||||
for j < len(runes) && (runes[j] == ' ' || runes[j] == '\t' || runes[j] == '\n' || runes[j] == '\r') {
|
||||
j++
|
||||
}
|
||||
|
||||
if j >= len(runes) {
|
||||
return true
|
||||
}
|
||||
|
||||
next := runes[j]
|
||||
if next == '}' || next == ']' {
|
||||
// Closing a container. Verify what follows the close is also valid:
|
||||
// another structural char, comma, or EOF.
|
||||
return isValidAfterContainerClose(runes, j+1)
|
||||
}
|
||||
if next == ',' {
|
||||
// After comma, must be followed by a valid JSON token
|
||||
j++
|
||||
for j < len(runes) && (runes[j] == ' ' || runes[j] == '\t' || runes[j] == '\n' || runes[j] == '\r') {
|
||||
j++
|
||||
}
|
||||
if j >= len(runes) {
|
||||
return false // trailing comma with nothing after — invalid
|
||||
}
|
||||
return isJSONTokenStart(runes, j)
|
||||
}
|
||||
// ':' is NOT valid here — we're in a value position, not a key.
|
||||
// Any other character is also invalid.
|
||||
return false
|
||||
}
|
||||
|
||||
// isValidAfterContainerClose checks that after a } or ], the continuation is
|
||||
// structurally valid: more closes, comma+token, or EOF.
|
||||
func isValidAfterContainerClose(runes []rune, pos int) bool {
|
||||
j := pos
|
||||
for j < len(runes) && (runes[j] == ' ' || runes[j] == '\t' || runes[j] == '\n' || runes[j] == '\r') {
|
||||
j++
|
||||
}
|
||||
if j >= len(runes) {
|
||||
return true
|
||||
}
|
||||
next := runes[j]
|
||||
if next == '}' || next == ']' {
|
||||
return isValidAfterContainerClose(runes, j+1)
|
||||
}
|
||||
if next == ',' {
|
||||
j++
|
||||
for j < len(runes) && (runes[j] == ' ' || runes[j] == '\t' || runes[j] == '\n' || runes[j] == '\r') {
|
||||
j++
|
||||
}
|
||||
if j >= len(runes) {
|
||||
return false
|
||||
}
|
||||
return isJSONTokenStart(runes, j)
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
// isJSONTokenStart returns true if the rune could begin a JSON value or key.
|
||||
// For keywords (true/false/null), verifies the full keyword is present.
|
||||
func isJSONTokenStart(runes []rune, pos int) bool {
|
||||
if pos >= len(runes) {
|
||||
return false
|
||||
}
|
||||
r := runes[pos]
|
||||
switch {
|
||||
case r == '"': // string
|
||||
return true
|
||||
case r == '{' || r == '[': // object or array
|
||||
return true
|
||||
case r == 't': // true
|
||||
return pos+4 <= len(runes) && string(runes[pos:pos+4]) == "true"
|
||||
case r == 'f': // false
|
||||
return pos+5 <= len(runes) && string(runes[pos:pos+5]) == "false"
|
||||
case r == 'n': // null
|
||||
return pos+4 <= len(runes) && string(runes[pos:pos+4]) == "null"
|
||||
case r >= '0' && r <= '9': // number
|
||||
return true
|
||||
case r == '-': // negative number
|
||||
return true
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
@@ -1,7 +1,6 @@
|
||||
package review
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"testing"
|
||||
)
|
||||
|
||||
@@ -113,112 +112,3 @@ func TestParseResponse_MarkdownFencesNoLang(t *testing.T) {
|
||||
t.Errorf("expected APPROVE, got %q", result.Verdict)
|
||||
}
|
||||
}
|
||||
|
||||
func TestParseResponse_UnescapedQuotesInStrings(t *testing.T) {
|
||||
// Real failure from CI: Sonnet puts unescaped quotes like (e.g. "28") in findings
|
||||
input := `{"verdict": "APPROVE", "summary": "Clean PR", "findings": [{"severity": "NIT", "file": "ci/Dockerfile", "line": 14, "finding": "The comment says OTP_VERSION is the major version (e.g. \"28\") but it actually contains unescaped quotes like (e.g. "28") which breaks JSON"}], "recommendation": "Ship it"}`
|
||||
|
||||
result, err := ParseResponse(input)
|
||||
if err != nil {
|
||||
t.Fatalf("expected repair to handle unescaped quotes, got error: %v", err)
|
||||
}
|
||||
if result.Verdict != "APPROVE" {
|
||||
t.Errorf("expected APPROVE, got %q", result.Verdict)
|
||||
}
|
||||
if len(result.Findings) != 1 {
|
||||
t.Fatalf("expected 1 finding, got %d", len(result.Findings))
|
||||
}
|
||||
}
|
||||
|
||||
func TestRepairJSON_NoOpOnValid(t *testing.T) {
|
||||
valid := `{"key": "value", "num": 42}`
|
||||
result := repairJSON(valid)
|
||||
if result != valid {
|
||||
t.Errorf("repairJSON should not modify valid JSON\n got: %s\n want: %s", result, valid)
|
||||
}
|
||||
}
|
||||
|
||||
func TestRepairJSON_FixesUnescapedQuotes(t *testing.T) {
|
||||
// Interior quote followed by non-structural character
|
||||
input := `{"msg": "use "foo" here"}`
|
||||
result := repairJSON(input)
|
||||
|
||||
// Should be parseable now
|
||||
var m map[string]interface{}
|
||||
if err := json.Unmarshal([]byte(result), &m); err != nil {
|
||||
t.Fatalf("repaired JSON should parse, got: %v\nrepaired: %s", err, result)
|
||||
}
|
||||
}
|
||||
|
||||
func TestRepairJSON_InteriorQuoteBeforeComma(t *testing.T) {
|
||||
// Bug reported by reviewer: interior quoted word immediately before a comma
|
||||
input := `{"msg": "say "yes", and go"}`
|
||||
result := repairJSON(input)
|
||||
|
||||
var m map[string]interface{}
|
||||
if err := json.Unmarshal([]byte(result), &m); err != nil {
|
||||
t.Fatalf("repaired JSON should parse, got: %v\nrepaired: %s", err, result)
|
||||
}
|
||||
// The full string content should be preserved
|
||||
msg, ok := m["msg"].(string)
|
||||
if !ok {
|
||||
t.Fatal("msg field missing or not a string")
|
||||
}
|
||||
if msg != `say "yes", and go` {
|
||||
t.Errorf("unexpected msg content: %q", msg)
|
||||
}
|
||||
}
|
||||
|
||||
func TestRepairJSON_InteriorQuoteBeforeCloseBrace(t *testing.T) {
|
||||
// Bug reported by reviewer: JSON-shaped syntax inside string values
|
||||
input := `{"msg": "input map {"key": "val"} caused error"}`
|
||||
result := repairJSON(input)
|
||||
|
||||
var m map[string]interface{}
|
||||
if err := json.Unmarshal([]byte(result), &m); err != nil {
|
||||
t.Fatalf("repaired JSON should parse, got: %v\nrepaired: %s", err, result)
|
||||
}
|
||||
}
|
||||
|
||||
func TestRepairJSON_MultipleFields(t *testing.T) {
|
||||
// Multiple string fields with unescaped quotes in different positions
|
||||
input := `{"a": "hello "world"", "b": "foo"}`
|
||||
result := repairJSON(input)
|
||||
|
||||
var m map[string]interface{}
|
||||
if err := json.Unmarshal([]byte(result), &m); err != nil {
|
||||
t.Fatalf("repaired JSON should parse, got: %v\nrepaired: %s", err, result)
|
||||
}
|
||||
if _, ok := m["b"]; !ok {
|
||||
t.Error("expected 'b' field to be preserved")
|
||||
}
|
||||
}
|
||||
|
||||
func TestRepairJSON_PreservesEscapedQuotes(t *testing.T) {
|
||||
// Already-escaped quotes should not be double-escaped
|
||||
input := `{"msg": "already \"escaped\" here"}`
|
||||
result := repairJSON(input)
|
||||
|
||||
if result != input {
|
||||
t.Errorf("repairJSON should not modify already-escaped quotes\n got: %s\n want: %s", result, input)
|
||||
}
|
||||
|
||||
var m map[string]interface{}
|
||||
if err := json.Unmarshal([]byte(result), &m); err != nil {
|
||||
t.Fatalf("repaired JSON should parse, got: %v\nrepaired: %s", err, result)
|
||||
}
|
||||
}
|
||||
|
||||
func TestRepairJSON_ComplexNestedContent(t *testing.T) {
|
||||
// Combines both reviewer bugs: quoted words before commas AND JSON-like content
|
||||
input := `{"verdict": "APPROVE", "findings": [{"finding": "The map {"key": "val"} and (e.g. "28") and say "yes", then stop"}]}`
|
||||
result := repairJSON(input)
|
||||
|
||||
var parsed map[string]interface{}
|
||||
if err := json.Unmarshal([]byte(result), &parsed); err != nil {
|
||||
t.Fatalf("repaired JSON should parse, got: %v\nrepaired: %s", err, result)
|
||||
}
|
||||
if parsed["verdict"] != "APPROVE" {
|
||||
t.Errorf("expected verdict APPROVE, got %v", parsed["verdict"])
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,367 +0,0 @@
|
||||
package review
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"embed"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"io"
|
||||
"os"
|
||||
"sort"
|
||||
"strings"
|
||||
"unicode/utf8"
|
||||
|
||||
"github.com/goccy/go-yaml"
|
||||
"github.com/goccy/go-yaml/ast"
|
||||
"github.com/goccy/go-yaml/parser"
|
||||
)
|
||||
|
||||
//go:embed personas/*.yaml
|
||||
var embeddedPersonas embed.FS
|
||||
|
||||
// MaxPersonaFileSize is the maximum size for persona files (64 KB).
|
||||
// This prevents denial-of-service via excessively large files.
|
||||
const MaxPersonaFileSize = 64 * 1024
|
||||
|
||||
// MaxYAMLDepth is the maximum nesting depth allowed in YAML persona files.
|
||||
// This prevents stack exhaustion from deeply nested structures.
|
||||
const MaxYAMLDepth = 20
|
||||
|
||||
// MaxYAMLNodes is the maximum number of YAML nodes allowed in persona files.
|
||||
// This prevents DoS via wide-but-shallow structures that bypass depth limits.
|
||||
const MaxYAMLNodes = 1000
|
||||
|
||||
// Persona defines a specialized review role with focused expertise.
|
||||
type Persona struct {
|
||||
Name string `json:"name" yaml:"name"`
|
||||
DisplayName string `json:"display_name" yaml:"display_name"`
|
||||
ModelPref string `json:"model_preference,omitempty" yaml:"model_preference,omitempty"`
|
||||
Identity string `json:"identity" yaml:"identity"`
|
||||
Focus []string `json:"focus" yaml:"focus"`
|
||||
Ignore []string `json:"ignore" yaml:"ignore"`
|
||||
Severity Severity `json:"severity" yaml:"severity"`
|
||||
OutputFormat string `json:"output_format,omitempty" yaml:"output_format,omitempty"`
|
||||
}
|
||||
|
||||
// Severity defines what constitutes each severity level for this persona.
|
||||
// These are prompt guidance for the LLM, not output format changes.
|
||||
type Severity struct {
|
||||
Major string `json:"major" yaml:"major"`
|
||||
Minor string `json:"minor" yaml:"minor"`
|
||||
Nit string `json:"nit" yaml:"nit"`
|
||||
}
|
||||
|
||||
// LoadPersona loads a persona from a JSON or YAML file path.
|
||||
// Format is detected by file extension: .yaml/.yml for YAML, .json or other for JSON.
|
||||
// Files larger than MaxPersonaFileSize are rejected.
|
||||
//
|
||||
// Symlinks are supported: os.Stat follows symlinks, so a symlink pointing to
|
||||
// a regular file will pass the IsRegular() check. Symlinks to non-regular files
|
||||
// (directories, FIFOs, devices) are still rejected.
|
||||
func LoadPersona(path string) (*Persona, error) {
|
||||
// os.Stat follows symlinks, so symlinks to regular files are supported.
|
||||
// The IsRegular() check operates on the target, not the symlink itself.
|
||||
info, err := os.Stat(path)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("read persona file %s: %w", path, err)
|
||||
}
|
||||
if !info.Mode().IsRegular() {
|
||||
return nil, fmt.Errorf("persona file %s is not a regular file", path)
|
||||
}
|
||||
if info.Size() > MaxPersonaFileSize {
|
||||
return nil, fmt.Errorf("persona file %s exceeds maximum size (%d bytes)", path, MaxPersonaFileSize)
|
||||
}
|
||||
data, err := os.ReadFile(path)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("read persona file %s: %w", path, err)
|
||||
}
|
||||
// Re-check size after read to defend against TOCTOU races where file
|
||||
// grows between stat and read (e.g., appending process, replaced file).
|
||||
if len(data) > MaxPersonaFileSize {
|
||||
return nil, fmt.Errorf("persona file %s exceeds maximum size (%d bytes)", path, MaxPersonaFileSize)
|
||||
}
|
||||
return parsePersona(data, path)
|
||||
}
|
||||
|
||||
// LoadBuiltinPersona loads a built-in persona by name.
|
||||
// Returns an error if the persona doesn't exist.
|
||||
// Built-in personas are stored in YAML format only (see embed directive).
|
||||
func LoadBuiltinPersona(name string) (*Persona, error) {
|
||||
yamlFile := name + ".yaml"
|
||||
data, err := embeddedPersonas.ReadFile("personas/" + yamlFile)
|
||||
if err != nil {
|
||||
available := ListBuiltinPersonas()
|
||||
return nil, fmt.Errorf("unknown built-in persona %q (available: %s)", name, strings.Join(available, ", "))
|
||||
}
|
||||
return parsePersona(data, "builtin:"+yamlFile)
|
||||
}
|
||||
|
||||
// ListBuiltinPersonas returns the names of all built-in personas in sorted order.
|
||||
// Returns an empty slice if the embedded directory cannot be read.
|
||||
func ListBuiltinPersonas() []string {
|
||||
entries, err := embeddedPersonas.ReadDir("personas")
|
||||
if err != nil {
|
||||
return []string{}
|
||||
}
|
||||
seen := make(map[string]bool)
|
||||
for _, e := range entries {
|
||||
if e.IsDir() {
|
||||
continue
|
||||
}
|
||||
name := e.Name()
|
||||
// Strip extension to get persona name
|
||||
var personaName string
|
||||
switch {
|
||||
case strings.HasSuffix(name, ".yaml"):
|
||||
personaName = strings.TrimSuffix(name, ".yaml")
|
||||
case strings.HasSuffix(name, ".yml"):
|
||||
personaName = strings.TrimSuffix(name, ".yml")
|
||||
case strings.HasSuffix(name, ".json"):
|
||||
personaName = strings.TrimSuffix(name, ".json")
|
||||
default:
|
||||
continue
|
||||
}
|
||||
seen[personaName] = true
|
||||
}
|
||||
names := make([]string, 0, len(seen))
|
||||
for name := range seen {
|
||||
names = append(names, name)
|
||||
}
|
||||
sort.Strings(names)
|
||||
return names
|
||||
}
|
||||
|
||||
// parsePersona parses persona data from JSON or YAML format.
|
||||
// Format is detected by the source file extension.
|
||||
func parsePersona(data []byte, source string) (*Persona, error) {
|
||||
lowerSource := strings.ToLower(source)
|
||||
isYAML := strings.HasSuffix(lowerSource, ".yaml") || strings.HasSuffix(lowerSource, ".yml")
|
||||
|
||||
var p Persona
|
||||
var err error
|
||||
if isYAML {
|
||||
err = unmarshalYAMLWithDepthLimit(data, &p, MaxYAMLDepth)
|
||||
} else {
|
||||
// Use json.Decoder with DisallowUnknownFields for consistency with
|
||||
// YAML's Strict() - both reject unknown fields to catch typos.
|
||||
dec := json.NewDecoder(bytes.NewReader(data))
|
||||
dec.DisallowUnknownFields()
|
||||
err = dec.Decode(&p)
|
||||
if err == nil {
|
||||
// Reject trailing content after the first valid JSON object.
|
||||
// Without this check, input like `{"name":"x"}garbage` would
|
||||
// silently succeed because Decoder stops after one object.
|
||||
var dummy json.RawMessage
|
||||
if err2 := dec.Decode(&dummy); err2 != io.EOF {
|
||||
err = fmt.Errorf("unexpected trailing content after JSON object")
|
||||
}
|
||||
}
|
||||
}
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("parse persona %s: %w", source, err)
|
||||
}
|
||||
if err := validatePersona(&p, source); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return &p, nil
|
||||
}
|
||||
|
||||
// unmarshalYAMLWithDepthLimit unmarshals YAML data with three safety checks:
|
||||
// - Depth limiting: rejects AST trees exceeding maxDepth to prevent stack exhaustion.
|
||||
// - Multi-document rejection: prevents silent data loss from ignored extra documents.
|
||||
// - Strict field checking: rejects unknown YAML keys to catch typos early.
|
||||
func unmarshalYAMLWithDepthLimit(data []byte, out any, maxDepth int) error {
|
||||
// First pass: parse into AST to check depth limits, node counts, and
|
||||
// multi-document rejection. This prevents stack exhaustion before we
|
||||
// attempt to decode into structs.
|
||||
file, err := parser.ParseBytes(data, 0)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
// Reject empty YAML input (whitespace-only, comment-only, or truly empty files).
|
||||
// The parser returns a single doc with nil body for these cases.
|
||||
if len(file.Docs) == 0 || file.Docs[0].Body == nil {
|
||||
return fmt.Errorf("empty YAML document")
|
||||
}
|
||||
|
||||
// Reject multi-document YAML files - silently ignoring additional documents
|
||||
// could lead to confusing behavior where users think their changes take effect.
|
||||
if len(file.Docs) > 1 {
|
||||
return fmt.Errorf("multi-document YAML is not supported; only single-document files are allowed")
|
||||
}
|
||||
|
||||
nodeCount := 0
|
||||
if err := checkYAMLDepth(file.Docs[0].Body, 0, maxDepth, MaxYAMLNodes, make(map[ast.Node]int), make(map[ast.Node]bool), &nodeCount); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
// Second pass: decode with strict field checking enabled.
|
||||
// Strict() rejects unknown keys, catching typos like "focuss" or "identiy".
|
||||
//
|
||||
// Safety note: goccy/go-yaml's decoder does not expand YAML aliases
|
||||
// recursively — it resolves them via the pre-built AST, which our first
|
||||
// pass already depth-checked. Alias chains that would exceed depth limits
|
||||
// are caught above; the decoder merely reads the resolved scalar values.
|
||||
dec := yaml.NewDecoder(bytes.NewReader(data), yaml.Strict())
|
||||
return dec.Decode(out)
|
||||
}
|
||||
|
||||
// checkYAMLDepth recursively checks that YAML AST nodes don't exceed the depth
|
||||
// limit or the total node count limit. It uses two tracking maps:
|
||||
// - validated: maps each node to the maximum depth at which it was previously
|
||||
// checked. If a node is revisited at a deeper depth (e.g., via an alias),
|
||||
// we re-check it to ensure the combined effective depth doesn't exceed limits.
|
||||
// - visiting: per-path recursion stack for true cycle detection. A node on the
|
||||
// current path is a cycle (alias loop); we return nil to avoid infinite recursion.
|
||||
//
|
||||
// This design prevents the alias depth bypass where an anchored subtree validated
|
||||
// at a shallow depth could be referenced via alias at a greater depth, effectively
|
||||
// exceeding MaxYAMLDepth.
|
||||
func checkYAMLDepth(node ast.Node, depth, maxDepth, maxNodes int, validated map[ast.Node]int, visiting map[ast.Node]bool, nodeCount *int) error {
|
||||
if node == nil {
|
||||
return nil
|
||||
}
|
||||
|
||||
if depth > maxDepth {
|
||||
return fmt.Errorf("YAML nesting depth exceeds maximum (%d)", maxDepth)
|
||||
}
|
||||
|
||||
// Cycle detection: if we're currently visiting this node on the current
|
||||
// recursion path, it's a cycle (e.g., alias pointing to an ancestor).
|
||||
// Return nil to break the cycle without error — cycles are a structural
|
||||
// property, not a depth violation.
|
||||
if visiting[node] {
|
||||
return nil
|
||||
}
|
||||
|
||||
// Track total nodes visited as defense-in-depth against wide-but-shallow attacks.
|
||||
// Placed after cycle detection but before the depth-aware short-circuit. This means
|
||||
// nodes revisited at shallower depths (via aliases) are counted each time they are
|
||||
// encountered — intentional conservative overcounting. This bounds the total work
|
||||
// performed during validation rather than tracking unique nodes, which is the safer
|
||||
// security posture for untrusted YAML input.
|
||||
*nodeCount++
|
||||
if *nodeCount > maxNodes {
|
||||
return fmt.Errorf("YAML node count exceeds maximum (%d)", maxNodes)
|
||||
}
|
||||
|
||||
// Depth-aware short-circuit: skip re-validation only when the current visit
|
||||
// depth is the same or shallower than the depth at which this node was
|
||||
// previously validated. A shallower (or equal) current depth means the
|
||||
// prior, deeper validation already covered any subtree depth violations.
|
||||
// If the current depth exceeds the previous validation depth (e.g., an alias
|
||||
// references this node deeper in the tree), we must re-traverse to ensure
|
||||
// the combined effective depth doesn't exceed maxDepth.
|
||||
//
|
||||
// Note: using ast.Node (interface) as map key relies on pointer identity,
|
||||
// which is correct because all goccy/go-yaml AST node types are pointer
|
||||
// receivers (*MappingNode, *SequenceNode, etc.), never value types.
|
||||
if prevDepth, ok := validated[node]; ok && depth <= prevDepth {
|
||||
return nil
|
||||
}
|
||||
validated[node] = depth
|
||||
|
||||
// Mark as visiting (on the current recursion path) for cycle detection.
|
||||
visiting[node] = true
|
||||
defer func() { visiting[node] = false }()
|
||||
|
||||
// Walk children based on node type.
|
||||
switch n := node.(type) {
|
||||
case *ast.MappingNode:
|
||||
for _, value := range n.Values {
|
||||
if err := checkYAMLDepth(value, depth+1, maxDepth, maxNodes, validated, visiting, nodeCount); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
case *ast.MappingValueNode:
|
||||
// Both Key and Value are visited at depth+1 relative to this
|
||||
// MappingValueNode. Since MappingNode visits its MappingValueNode
|
||||
// children at depth+1 as well, keys and values end up at depth+2
|
||||
// from the parent MappingNode. This is intentional: it mirrors the
|
||||
// actual nesting structure (mapping → key-value pair → key/value).
|
||||
if err := checkYAMLDepth(n.Key, depth+1, maxDepth, maxNodes, validated, visiting, nodeCount); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := checkYAMLDepth(n.Value, depth+1, maxDepth, maxNodes, validated, visiting, nodeCount); err != nil {
|
||||
return err
|
||||
}
|
||||
case *ast.SequenceNode:
|
||||
for _, value := range n.Values {
|
||||
if err := checkYAMLDepth(value, depth+1, maxDepth, maxNodes, validated, visiting, nodeCount); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
case *ast.AliasNode:
|
||||
// Follow alias to its target, incrementing depth since aliases expand
|
||||
// the effective structure.
|
||||
if err := checkYAMLDepth(n.Value, depth+1, maxDepth, maxNodes, validated, visiting, nodeCount); err != nil {
|
||||
return err
|
||||
}
|
||||
case *ast.AnchorNode:
|
||||
// Increment depth for anchor values as a conservative measure: the
|
||||
// anchor definition itself is structural, and treating it as a depth
|
||||
// level ensures that deeply nested anchors are caught at definition
|
||||
// time rather than only when referenced via alias. This +1 is
|
||||
// asymmetric with alias (which also increments) — by design, the
|
||||
// effective depth budget for anchored-then-aliased content is reduced
|
||||
// because both the definition site and the reference site each consume
|
||||
// a level, making deeply nested anchor/alias pairs hit the limit sooner.
|
||||
if err := checkYAMLDepth(n.Value, depth+1, maxDepth, maxNodes, validated, visiting, nodeCount); err != nil {
|
||||
return err
|
||||
}
|
||||
case *ast.TagNode:
|
||||
if err := checkYAMLDepth(n.Value, depth+1, maxDepth, maxNodes, validated, visiting, nodeCount); err != nil {
|
||||
return err
|
||||
}
|
||||
case *ast.MergeKeyNode:
|
||||
// MergeKeyNode represents the literal "<<" merge key token. It has no
|
||||
// child nodes — the value side of a merge (e.g., *alias) lives in the
|
||||
// parent MappingValueNode.Value, which is already recursed into above.
|
||||
// Explicitly listed here (rather than in the default case) to prevent
|
||||
// future library changes from silently bypassing depth checks.
|
||||
default:
|
||||
// Scalar leaf nodes (StringNode, IntegerNode, FloatNode, BoolNode,
|
||||
// NullNode, InfinityNode, NanNode, LiteralNode) have no children to
|
||||
// recurse into.
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// ParsePersonaBytes parses persona data from bytes with a source label for errors.
|
||||
// This is useful for parsing personas fetched from external sources (e.g., Gitea API)
|
||||
// without requiring filesystem access. Format is detected by source extension.
|
||||
// Input is bounded by MaxPersonaFileSize to prevent resource exhaustion.
|
||||
func ParsePersonaBytes(data []byte, source string) (*Persona, error) {
|
||||
if len(data) > MaxPersonaFileSize {
|
||||
return nil, fmt.Errorf("persona data from %s exceeds maximum size (%d bytes, limit %d)", source, len(data), MaxPersonaFileSize)
|
||||
}
|
||||
return parsePersona(data, source)
|
||||
}
|
||||
|
||||
func validatePersona(p *Persona, source string) error {
|
||||
if p.Name == "" {
|
||||
return fmt.Errorf("persona %s: name is required", source)
|
||||
}
|
||||
if p.Identity == "" {
|
||||
return fmt.Errorf("persona %s: identity is required", source)
|
||||
}
|
||||
// DisplayName defaults to Name if not set
|
||||
if p.DisplayName == "" {
|
||||
p.DisplayName = p.Name
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// CapitalizeFirst capitalizes the first rune of a string in a Unicode-safe way.
|
||||
// Returns the original string if it's empty.
|
||||
func CapitalizeFirst(s string) string {
|
||||
if s == "" {
|
||||
return s
|
||||
}
|
||||
r, size := utf8.DecodeRuneInString(s)
|
||||
if r == utf8.RuneError {
|
||||
return s
|
||||
}
|
||||
return strings.ToUpper(string(r)) + s[size:]
|
||||
}
|
||||
@@ -1,104 +0,0 @@
|
||||
package review
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"strings"
|
||||
)
|
||||
|
||||
// BuildPersonaSystemPrompt constructs a system prompt from a persona definition.
|
||||
// This replaces BuildSystemBase when a persona is provided.
|
||||
func BuildPersonaSystemPrompt(p *Persona) string {
|
||||
var sb strings.Builder
|
||||
|
||||
// Identity section
|
||||
sb.WriteString(p.Identity)
|
||||
sb.WriteString("\n\n")
|
||||
|
||||
// Focus section
|
||||
if len(p.Focus) > 0 {
|
||||
sb.WriteString("## Focus Areas\n\n")
|
||||
sb.WriteString("Concentrate your review on:\n")
|
||||
for _, f := range p.Focus {
|
||||
sb.WriteString(fmt.Sprintf("- %s\n", f))
|
||||
}
|
||||
sb.WriteString("\n")
|
||||
}
|
||||
|
||||
// Ignore section
|
||||
if len(p.Ignore) > 0 {
|
||||
sb.WriteString("## Explicitly Out of Scope\n\n")
|
||||
sb.WriteString("Do NOT comment on:\n")
|
||||
for _, i := range p.Ignore {
|
||||
sb.WriteString(fmt.Sprintf("- %s\n", i))
|
||||
}
|
||||
sb.WriteString("\n")
|
||||
}
|
||||
|
||||
// Severity calibration
|
||||
if p.Severity.Major != "" || p.Severity.Minor != "" || p.Severity.Nit != "" {
|
||||
sb.WriteString("## Severity Calibration\n\n")
|
||||
sb.WriteString("Use these severity definitions for YOUR domain:\n")
|
||||
if p.Severity.Major != "" {
|
||||
sb.WriteString(fmt.Sprintf("- **MAJOR**: %s\n", p.Severity.Major))
|
||||
}
|
||||
if p.Severity.Minor != "" {
|
||||
sb.WriteString(fmt.Sprintf("- **MINOR**: %s\n", p.Severity.Minor))
|
||||
}
|
||||
if p.Severity.Nit != "" {
|
||||
sb.WriteString(fmt.Sprintf("- **NIT**: %s\n", p.Severity.Nit))
|
||||
}
|
||||
sb.WriteString("\n")
|
||||
}
|
||||
|
||||
// Output format instructions (shared schema from prompt.go)
|
||||
sb.WriteString("## Review Instructions\n\n")
|
||||
sb.WriteString("CONTEXT:\n")
|
||||
sb.WriteString("- You will receive the full content of modified files for reference, followed by the diff showing what changed.\n")
|
||||
sb.WriteString("- The diff shows ONLY what was added/removed. The full file content provides complete context.\n")
|
||||
sb.WriteString("- Focus your review on the CHANGES (the diff), using the full files for context.\n\n")
|
||||
sb.WriteString("Your task:\n")
|
||||
sb.WriteString("1. Review the diff for issues within YOUR focus areas only.\n")
|
||||
sb.WriteString("2. Consider the CI status — if CI has failed, that is an automatic REQUEST_CHANGES regardless of code quality.\n")
|
||||
sb.WriteString("3. Output your review as structured JSON (and ONLY JSON, no markdown fences or other text).\n\n")
|
||||
sb.WriteString("Output format:\n")
|
||||
sb.WriteString(outputSchemaJSON)
|
||||
sb.WriteString("\n\n")
|
||||
sb.WriteString(verdictRules)
|
||||
sb.WriteString("\n- Only report findings within your focus areas. Ignore everything else.\n")
|
||||
sb.WriteString("- Line numbers should reference the new file line numbers from the diff headers.\n")
|
||||
sb.WriteString("- If the diff has no changes relevant to your focus areas, APPROVE with no findings.\n")
|
||||
|
||||
// Custom output format if provided
|
||||
if p.OutputFormat != "" {
|
||||
sb.WriteString("\n\n## Additional Output Guidelines\n\n")
|
||||
sb.WriteString(p.OutputFormat)
|
||||
}
|
||||
|
||||
return sb.String()
|
||||
}
|
||||
|
||||
// BuildSystemPromptWithPersona constructs the full system prompt, using either
|
||||
// a persona or the default generic prompt. This is a convenience wrapper that
|
||||
// combines BuildPersonaSystemPrompt (or BuildSystemBase) with patterns and conventions.
|
||||
// It is exported for use by callers who want one-shot prompt assembly.
|
||||
func BuildSystemPromptWithPersona(persona *Persona, conventions, patterns string) string {
|
||||
var base string
|
||||
if persona != nil {
|
||||
base = BuildPersonaSystemPrompt(persona)
|
||||
} else {
|
||||
base = BuildSystemBase()
|
||||
}
|
||||
|
||||
var sb strings.Builder
|
||||
sb.WriteString(base)
|
||||
|
||||
if patterns != "" {
|
||||
sb.WriteString(fmt.Sprintf("\n\n## Language Patterns & Idioms\n\nUse the following patterns as review criteria. Code that violates these established patterns is a finding:\n\n%s\n", patterns))
|
||||
}
|
||||
|
||||
if conventions != "" {
|
||||
sb.WriteString(fmt.Sprintf("\n\n## Repository Conventions\n\nThe repository has the following coding conventions that must be respected:\n\n%s\n", conventions))
|
||||
}
|
||||
|
||||
return sb.String()
|
||||
}
|
||||
@@ -1,157 +0,0 @@
|
||||
package review
|
||||
|
||||
import (
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestBuildPersonaSystemPrompt(t *testing.T) {
|
||||
p := &Persona{
|
||||
Name: "security",
|
||||
DisplayName: "Security Specialist",
|
||||
Identity: "You are a security specialist.",
|
||||
Focus: []string{"injection attacks", "auth bypass"},
|
||||
Ignore: []string{"code style", "performance"},
|
||||
Severity: Severity{
|
||||
Major: "exploitable vulnerabilities",
|
||||
Minor: "defense in depth",
|
||||
Nit: "theoretical risks",
|
||||
},
|
||||
}
|
||||
|
||||
prompt := BuildPersonaSystemPrompt(p)
|
||||
|
||||
// Check identity is included
|
||||
if !strings.Contains(prompt, "You are a security specialist.") {
|
||||
t.Error("prompt should contain identity")
|
||||
}
|
||||
|
||||
// Check focus areas
|
||||
if !strings.Contains(prompt, "Focus Areas") {
|
||||
t.Error("prompt should contain Focus Areas section")
|
||||
}
|
||||
if !strings.Contains(prompt, "injection attacks") {
|
||||
t.Error("prompt should contain focus item")
|
||||
}
|
||||
|
||||
// Check ignore section
|
||||
if !strings.Contains(prompt, "Out of Scope") {
|
||||
t.Error("prompt should contain Out of Scope section")
|
||||
}
|
||||
if !strings.Contains(prompt, "code style") {
|
||||
t.Error("prompt should contain ignore item")
|
||||
}
|
||||
|
||||
// Check severity calibration
|
||||
if !strings.Contains(prompt, "Severity Calibration") {
|
||||
t.Error("prompt should contain Severity Calibration section")
|
||||
}
|
||||
if !strings.Contains(prompt, "exploitable vulnerabilities") {
|
||||
t.Error("prompt should contain major severity definition")
|
||||
}
|
||||
|
||||
// Check JSON output format is included
|
||||
if !strings.Contains(prompt, `"verdict"`) {
|
||||
t.Error("prompt should contain JSON output format")
|
||||
}
|
||||
if !strings.Contains(prompt, "APPROVE") {
|
||||
t.Error("prompt should mention APPROVE verdict")
|
||||
}
|
||||
}
|
||||
|
||||
func TestBuildPersonaSystemPromptMinimal(t *testing.T) {
|
||||
// Minimal persona with only required fields
|
||||
p := &Persona{
|
||||
Name: "minimal",
|
||||
Identity: "You are a minimal reviewer.",
|
||||
}
|
||||
|
||||
prompt := BuildPersonaSystemPrompt(p)
|
||||
|
||||
// Should still work without optional fields
|
||||
if !strings.Contains(prompt, "You are a minimal reviewer.") {
|
||||
t.Error("prompt should contain identity")
|
||||
}
|
||||
|
||||
// Should not have empty sections
|
||||
if strings.Contains(prompt, "Focus Areas") && !strings.Contains(prompt, "Concentrate your review on:") {
|
||||
t.Error("should not have Focus Areas header without content")
|
||||
}
|
||||
}
|
||||
|
||||
func TestBuildSystemPromptWithPersona(t *testing.T) {
|
||||
t.Run("with persona", func(t *testing.T) {
|
||||
p := &Persona{
|
||||
Name: "test",
|
||||
Identity: "Test persona identity.",
|
||||
Focus: []string{"testing"},
|
||||
}
|
||||
|
||||
prompt := BuildSystemPromptWithPersona(p, "test conventions", "test patterns")
|
||||
|
||||
if !strings.Contains(prompt, "Test persona identity.") {
|
||||
t.Error("should contain persona identity")
|
||||
}
|
||||
if !strings.Contains(prompt, "test conventions") {
|
||||
t.Error("should contain conventions")
|
||||
}
|
||||
if !strings.Contains(prompt, "test patterns") {
|
||||
t.Error("should contain patterns")
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("without persona", func(t *testing.T) {
|
||||
prompt := BuildSystemPromptWithPersona(nil, "test conventions", "test patterns")
|
||||
|
||||
// Should use default system base
|
||||
if !strings.Contains(prompt, "expert code reviewer") {
|
||||
t.Error("should contain default system base when no persona")
|
||||
}
|
||||
if !strings.Contains(prompt, "test conventions") {
|
||||
t.Error("should contain conventions")
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("empty conventions and patterns", func(t *testing.T) {
|
||||
p := &Persona{
|
||||
Name: "test",
|
||||
Identity: "Test identity.",
|
||||
}
|
||||
|
||||
prompt := BuildSystemPromptWithPersona(p, "", "")
|
||||
|
||||
if strings.Contains(prompt, "Language Patterns") {
|
||||
t.Error("should not contain patterns section when empty")
|
||||
}
|
||||
if strings.Contains(prompt, "Repository Conventions") {
|
||||
t.Error("should not contain conventions section when empty")
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
func TestPersonaPromptContainsOutputRules(t *testing.T) {
|
||||
p := &Persona{
|
||||
Name: "test",
|
||||
Identity: "Test.",
|
||||
}
|
||||
|
||||
prompt := BuildPersonaSystemPrompt(p)
|
||||
|
||||
// Must contain the critical output rules
|
||||
requiredStrings := []string{
|
||||
"APPROVE",
|
||||
"REQUEST_CHANGES",
|
||||
"MAJOR",
|
||||
"MINOR",
|
||||
"NIT",
|
||||
"verdict",
|
||||
"findings",
|
||||
"CI",
|
||||
}
|
||||
|
||||
for _, s := range requiredStrings {
|
||||
if !strings.Contains(prompt, s) {
|
||||
t.Errorf("prompt should contain %q", s)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,959 +0,0 @@
|
||||
package review
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"github.com/goccy/go-yaml/ast"
|
||||
)
|
||||
|
||||
func TestLoadBuiltinPersona(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
personaName string
|
||||
wantErr bool
|
||||
wantDisplay string
|
||||
}{
|
||||
{
|
||||
name: "security persona",
|
||||
personaName: "security",
|
||||
wantErr: false,
|
||||
wantDisplay: "Security Specialist",
|
||||
},
|
||||
{
|
||||
name: "architect persona",
|
||||
personaName: "architect",
|
||||
wantErr: false,
|
||||
wantDisplay: "Software Architect",
|
||||
},
|
||||
{
|
||||
name: "docs persona",
|
||||
personaName: "docs",
|
||||
wantErr: false,
|
||||
wantDisplay: "Documentation Reviewer",
|
||||
},
|
||||
{
|
||||
name: "unknown persona",
|
||||
personaName: "nonexistent",
|
||||
wantErr: true,
|
||||
},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
p, err := LoadBuiltinPersona(tt.personaName)
|
||||
if tt.wantErr {
|
||||
if err == nil {
|
||||
t.Error("expected error, got nil")
|
||||
}
|
||||
return
|
||||
}
|
||||
if err != nil {
|
||||
t.Fatalf("unexpected error: %v", err)
|
||||
}
|
||||
if p.Name != tt.personaName {
|
||||
t.Errorf("Name = %q, want %q", p.Name, tt.personaName)
|
||||
}
|
||||
if p.DisplayName != tt.wantDisplay {
|
||||
t.Errorf("DisplayName = %q, want %q", p.DisplayName, tt.wantDisplay)
|
||||
}
|
||||
if p.Identity == "" {
|
||||
t.Error("Identity should not be empty")
|
||||
}
|
||||
if len(p.Focus) == 0 {
|
||||
t.Error("Focus should not be empty")
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestListBuiltinPersonas(t *testing.T) {
|
||||
names := ListBuiltinPersonas()
|
||||
if len(names) == 0 {
|
||||
t.Fatal("expected at least one built-in persona")
|
||||
}
|
||||
|
||||
// Check for expected personas
|
||||
expected := map[string]bool{"security": false, "architect": false, "docs": false}
|
||||
for _, name := range names {
|
||||
if _, ok := expected[name]; ok {
|
||||
expected[name] = true
|
||||
}
|
||||
}
|
||||
for name, found := range expected {
|
||||
if !found {
|
||||
t.Errorf("expected built-in persona %q not found", name)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestLoadPersonaFromYAMLFile(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
path := filepath.Join(dir, "test.yaml")
|
||||
|
||||
content := `# Test persona
|
||||
name: test
|
||||
display_name: Test Persona
|
||||
identity: |
|
||||
You are a test persona.
|
||||
Multi-line identity works.
|
||||
focus:
|
||||
- testing
|
||||
- validation
|
||||
ignore:
|
||||
- nothing
|
||||
severity:
|
||||
major: Big problems
|
||||
minor: Small problems
|
||||
nit: Tiny problems
|
||||
`
|
||||
|
||||
if err := os.WriteFile(path, []byte(content), 0644); err != nil {
|
||||
t.Fatalf("failed to write test file: %v", err)
|
||||
}
|
||||
|
||||
p, err := LoadPersona(path)
|
||||
if err != nil {
|
||||
t.Fatalf("LoadPersona failed: %v", err)
|
||||
}
|
||||
|
||||
if p.Name != "test" {
|
||||
t.Errorf("Name = %q, want %q", p.Name, "test")
|
||||
}
|
||||
if p.DisplayName != "Test Persona" {
|
||||
t.Errorf("DisplayName = %q, want %q", p.DisplayName, "Test Persona")
|
||||
}
|
||||
if len(p.Focus) != 2 {
|
||||
t.Errorf("Focus len = %d, want 2", len(p.Focus))
|
||||
}
|
||||
if !strings.Contains(p.Identity, "Multi-line") {
|
||||
t.Error("Identity should contain multi-line content")
|
||||
}
|
||||
}
|
||||
|
||||
func TestLoadPersonaFromYMLFile(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
path := filepath.Join(dir, "test.yml")
|
||||
|
||||
content := `name: test
|
||||
display_name: Test YML
|
||||
identity: Test identity
|
||||
focus:
|
||||
- testing
|
||||
ignore: []
|
||||
severity:
|
||||
major: Big
|
||||
minor: Small
|
||||
nit: Tiny
|
||||
`
|
||||
|
||||
if err := os.WriteFile(path, []byte(content), 0644); err != nil {
|
||||
t.Fatalf("failed to write test file: %v", err)
|
||||
}
|
||||
|
||||
p, err := LoadPersona(path)
|
||||
if err != nil {
|
||||
t.Fatalf("LoadPersona failed: %v", err)
|
||||
}
|
||||
|
||||
if p.Name != "test" {
|
||||
t.Errorf("Name = %q, want %q", p.Name, "test")
|
||||
}
|
||||
if p.DisplayName != "Test YML" {
|
||||
t.Errorf("DisplayName = %q, want %q", p.DisplayName, "Test YML")
|
||||
}
|
||||
}
|
||||
|
||||
func TestLoadPersonaFromJSONFile(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
path := filepath.Join(dir, "test.json")
|
||||
|
||||
content := `{
|
||||
"name": "test",
|
||||
"display_name": "Test Persona",
|
||||
"identity": "You are a test persona.\nMulti-line identity works.",
|
||||
"focus": ["testing", "validation"],
|
||||
|
||||
"ignore": ["nothing"],
|
||||
"severity": {
|
||||
"major": "Big problems",
|
||||
"minor": "Small problems",
|
||||
"nit": "Tiny problems"
|
||||
}
|
||||
}`
|
||||
|
||||
if err := os.WriteFile(path, []byte(content), 0644); err != nil {
|
||||
t.Fatalf("failed to write test file: %v", err)
|
||||
}
|
||||
|
||||
p, err := LoadPersona(path)
|
||||
if err != nil {
|
||||
t.Fatalf("LoadPersona failed: %v", err)
|
||||
}
|
||||
|
||||
if p.Name != "test" {
|
||||
t.Errorf("Name = %q, want %q", p.Name, "test")
|
||||
}
|
||||
if p.DisplayName != "Test Persona" {
|
||||
t.Errorf("DisplayName = %q, want %q", p.DisplayName, "Test Persona")
|
||||
}
|
||||
if len(p.Focus) != 2 {
|
||||
t.Errorf("Focus len = %d, want 2", len(p.Focus))
|
||||
}
|
||||
if !strings.Contains(p.Identity, "Multi-line") {
|
||||
t.Error("Identity should contain multi-line content")
|
||||
}
|
||||
}
|
||||
|
||||
func TestLoadPersonaValidation(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
content string
|
||||
ext string
|
||||
wantErr string
|
||||
}{
|
||||
{
|
||||
name: "missing name yaml",
|
||||
content: "identity: test\n",
|
||||
ext: ".yaml",
|
||||
wantErr: "name is required",
|
||||
},
|
||||
{
|
||||
name: "missing identity yaml",
|
||||
content: "name: test\n",
|
||||
ext: ".yaml",
|
||||
wantErr: "identity is required",
|
||||
},
|
||||
{
|
||||
name: "missing name json",
|
||||
content: `{"identity": "test"}`,
|
||||
ext: ".json",
|
||||
wantErr: "name is required",
|
||||
},
|
||||
{
|
||||
name: "missing identity json",
|
||||
content: `{"name": "test"}`,
|
||||
ext: ".json",
|
||||
wantErr: "identity is required",
|
||||
},
|
||||
{
|
||||
name: "display_name defaults to name",
|
||||
content: "name: test\nidentity: test identity\n",
|
||||
ext: ".yaml",
|
||||
// No error expected - should succeed
|
||||
},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
path := filepath.Join(dir, "test"+tt.ext)
|
||||
if err := os.WriteFile(path, []byte(tt.content), 0644); err != nil {
|
||||
t.Fatalf("failed to write test file: %v", err)
|
||||
}
|
||||
|
||||
p, err := LoadPersona(path)
|
||||
if tt.wantErr != "" {
|
||||
if err == nil {
|
||||
t.Errorf("expected error containing %q, got nil", tt.wantErr)
|
||||
return
|
||||
}
|
||||
if !strings.Contains(err.Error(), tt.wantErr) {
|
||||
t.Errorf("error = %q, want containing %q", err.Error(), tt.wantErr)
|
||||
}
|
||||
return
|
||||
}
|
||||
if err != nil {
|
||||
t.Fatalf("unexpected error: %v", err)
|
||||
}
|
||||
// Check display_name defaulting
|
||||
if p.DisplayName == "" {
|
||||
t.Error("DisplayName should default to Name")
|
||||
}
|
||||
if p.DisplayName != p.Name {
|
||||
t.Errorf("DisplayName should default to Name, got %q", p.DisplayName)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestLoadPersonaFileNotFound(t *testing.T) {
|
||||
_, err := LoadPersona("/nonexistent/path/persona.yaml")
|
||||
if err == nil {
|
||||
t.Error("expected error for nonexistent file")
|
||||
}
|
||||
}
|
||||
|
||||
func TestLoadPersonaInvalidYAML(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
path := filepath.Join(dir, "invalid.yaml")
|
||||
if err := os.WriteFile(path, []byte("not valid yaml:\n - [broken"), 0644); err != nil {
|
||||
t.Fatalf("failed to write test file: %v", err)
|
||||
}
|
||||
|
||||
_, err := LoadPersona(path)
|
||||
if err == nil {
|
||||
t.Error("expected error for invalid YAML")
|
||||
}
|
||||
}
|
||||
|
||||
func TestLoadPersonaInvalidJSON(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
path := filepath.Join(dir, "invalid.json")
|
||||
if err := os.WriteFile(path, []byte("not valid json {"), 0644); err != nil {
|
||||
t.Fatalf("failed to write test file: %v", err)
|
||||
}
|
||||
|
||||
_, err := LoadPersona(path)
|
||||
if err == nil {
|
||||
t.Error("expected error for invalid JSON")
|
||||
}
|
||||
}
|
||||
|
||||
func TestLoadPersonaCaseInsensitiveExtension(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
ext string
|
||||
}{
|
||||
{"lowercase yaml", ".yaml"},
|
||||
{"uppercase YAML", ".YAML"},
|
||||
{"mixed case Yaml", ".Yaml"},
|
||||
{"lowercase yml", ".yml"},
|
||||
{"uppercase YML", ".YML"},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
path := filepath.Join(dir, "test"+tt.ext)
|
||||
content := "name: test\nidentity: test identity\n"
|
||||
if err := os.WriteFile(path, []byte(content), 0644); err != nil {
|
||||
t.Fatalf("failed to write test file: %v", err)
|
||||
}
|
||||
|
||||
p, err := LoadPersona(path)
|
||||
if err != nil {
|
||||
t.Fatalf("LoadPersona failed for extension %s: %v", tt.ext, err)
|
||||
}
|
||||
if p.Name != "test" {
|
||||
t.Errorf("Name = %q, want %q", p.Name, "test")
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestCapitalizeFirst(t *testing.T) {
|
||||
tests := []struct {
|
||||
input string
|
||||
want string
|
||||
}{
|
||||
{"hello", "Hello"},
|
||||
{"Hello", "Hello"},
|
||||
{"HELLO", "HELLO"},
|
||||
{"a", "A"},
|
||||
{"", ""},
|
||||
{"日本語", "日本語"}, // Non-ASCII: Japanese doesn't have case
|
||||
{"über", "Über"}, // German umlaut
|
||||
{"élève", "Élève"}, // French accent
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.input, func(t *testing.T) {
|
||||
got := CapitalizeFirst(tt.input)
|
||||
if got != tt.want {
|
||||
t.Errorf("CapitalizeFirst(%q) = %q, want %q", tt.input, got, tt.want)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestListBuiltinPersonasReturnsEmptySlice(t *testing.T) {
|
||||
// ListBuiltinPersonas should return an empty slice (not nil) on error.
|
||||
// We can't easily test the error case, but we can verify the success case
|
||||
// returns a proper slice.
|
||||
names := ListBuiltinPersonas()
|
||||
if names == nil {
|
||||
t.Error("ListBuiltinPersonas should return empty slice, not nil")
|
||||
}
|
||||
}
|
||||
|
||||
func TestYAMLMultilineStrings(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
path := filepath.Join(dir, "multiline.yaml")
|
||||
|
||||
// Test literal block scalar (|) which preserves newlines
|
||||
content := `name: multiline
|
||||
display_name: Multiline Test
|
||||
identity: |
|
||||
First line.
|
||||
Second line.
|
||||
Third line.
|
||||
focus:
|
||||
- item one
|
||||
ignore: []
|
||||
severity:
|
||||
major: Major issue
|
||||
minor: Minor issue
|
||||
nit: Nit
|
||||
`
|
||||
|
||||
if err := os.WriteFile(path, []byte(content), 0644); err != nil {
|
||||
t.Fatalf("failed to write test file: %v", err)
|
||||
}
|
||||
|
||||
p, err := LoadPersona(path)
|
||||
if err != nil {
|
||||
t.Fatalf("LoadPersona failed: %v", err)
|
||||
}
|
||||
|
||||
// Literal block scalar preserves newlines
|
||||
if !strings.Contains(p.Identity, "\n") {
|
||||
t.Error("Identity should contain newlines from literal block scalar")
|
||||
}
|
||||
if !strings.Contains(p.Identity, "Second line") {
|
||||
t.Error("Identity should contain 'Second line'")
|
||||
}
|
||||
}
|
||||
|
||||
func TestYAMLComments(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
path := filepath.Join(dir, "comments.yaml")
|
||||
|
||||
content := `# This is a comment
|
||||
name: commented # inline comment
|
||||
display_name: Commented Persona
|
||||
# Another comment
|
||||
identity: Test identity
|
||||
focus:
|
||||
- item # comment after item
|
||||
ignore: []
|
||||
severity:
|
||||
major: Major
|
||||
minor: Minor
|
||||
nit: Nit
|
||||
`
|
||||
|
||||
if err := os.WriteFile(path, []byte(content), 0644); err != nil {
|
||||
t.Fatalf("failed to write test file: %v", err)
|
||||
}
|
||||
|
||||
p, err := LoadPersona(path)
|
||||
if err != nil {
|
||||
t.Fatalf("LoadPersona failed: %v", err)
|
||||
}
|
||||
|
||||
// Comments should be ignored
|
||||
if p.Name != "commented" {
|
||||
t.Errorf("Name = %q, want %q", p.Name, "commented")
|
||||
}
|
||||
if p.Focus[0] != "item" {
|
||||
t.Errorf("Focus[0] = %q, want %q", p.Focus[0], "item")
|
||||
}
|
||||
}
|
||||
|
||||
func TestYAMLDeeplyNestedRejection(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
path := filepath.Join(dir, "deeply-nested.yaml")
|
||||
|
||||
// Build a deeply nested YAML structure that exceeds MaxYAMLDepth (20).
|
||||
// Depth accumulation trace for "nested: \n level0: \n level1: ...":
|
||||
// - Document root parsed at depth 0
|
||||
// - Root MappingNode children (MappingValueNodes) visited at depth 1
|
||||
// - "nested" MappingValueNode: key at depth 2, value at depth 2
|
||||
// - Each levelN adds depth via MappingValueNode traversal (key + value)
|
||||
// - Exact depth per level depends on AST structure (MappingNode wrapping),
|
||||
// but 25 levels reliably exceeds MaxYAMLDepth (20) with comfortable margin.
|
||||
// The test uses 25 levels rather than exactly 21 to avoid brittleness.
|
||||
var sb strings.Builder
|
||||
sb.WriteString("name: test\nidentity: test\nnested:\n")
|
||||
indent := " "
|
||||
for i := 0; i < 25; i++ {
|
||||
sb.WriteString(strings.Repeat(indent, i+1))
|
||||
sb.WriteString(fmt.Sprintf("level%d:\n", i))
|
||||
}
|
||||
sb.WriteString(strings.Repeat(indent, 26))
|
||||
sb.WriteString("value: too-deep\n")
|
||||
|
||||
if err := os.WriteFile(path, []byte(sb.String()), 0644); err != nil {
|
||||
t.Fatalf("failed to write test file: %v", err)
|
||||
}
|
||||
|
||||
_, err := LoadPersona(path)
|
||||
if err == nil {
|
||||
t.Error("expected error for deeply nested YAML, got nil")
|
||||
}
|
||||
if !strings.Contains(err.Error(), "nesting depth exceeds") {
|
||||
t.Errorf("error = %q, want containing 'nesting depth exceeds'", err.Error())
|
||||
}
|
||||
}
|
||||
|
||||
func TestYAMLEmptyFileRejection(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
content string
|
||||
}{
|
||||
{"completely_empty", ""},
|
||||
{"whitespace_only", " \n\n "},
|
||||
{"comment_only", "# just a comment\n"},
|
||||
}
|
||||
|
||||
for _, tc := range tests {
|
||||
t.Run(tc.name, func(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
path := filepath.Join(dir, tc.name+".yaml")
|
||||
if err := os.WriteFile(path, []byte(tc.content), 0644); err != nil {
|
||||
t.Fatalf("failed to write test file: %v", err)
|
||||
}
|
||||
|
||||
_, err := LoadPersona(path)
|
||||
if err == nil {
|
||||
t.Fatal("expected error for empty YAML input, got nil")
|
||||
}
|
||||
if !strings.Contains(err.Error(), "empty YAML document") {
|
||||
t.Errorf("expected error containing %q, got: %v", "empty YAML document", err)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestYAMLFileSizeLimit(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
path := filepath.Join(dir, "huge.yaml")
|
||||
|
||||
// Create a file larger than MaxPersonaFileSize (64 KB)
|
||||
content := "name: test\nidentity: " + strings.Repeat("x", MaxPersonaFileSize+1) + "\n"
|
||||
if err := os.WriteFile(path, []byte(content), 0644); err != nil {
|
||||
t.Fatalf("failed to write test file: %v", err)
|
||||
}
|
||||
|
||||
_, err := LoadPersona(path)
|
||||
if err == nil {
|
||||
t.Error("expected error for oversized file, got nil")
|
||||
}
|
||||
if !strings.Contains(err.Error(), "exceeds maximum size") {
|
||||
t.Errorf("error = %q, want containing 'exceeds maximum size'", err.Error())
|
||||
}
|
||||
}
|
||||
|
||||
func TestYAMLAliasCycleDetection(t *testing.T) {
|
||||
// Test that our checkYAMLDepth function handles alias cycles gracefully
|
||||
// by using the visiting map to prevent infinite recursion.
|
||||
|
||||
// Create a node structure where an alias points to a parent node,
|
||||
// simulating what could happen with crafted input.
|
||||
parent := &ast.MappingNode{
|
||||
Values: []*ast.MappingValueNode{
|
||||
{
|
||||
Key: &ast.StringNode{Value: "name"},
|
||||
Value: &ast.StringNode{Value: "test"},
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
// Create a child that aliases back to the parent (artificial cycle)
|
||||
aliasToParent := &ast.AliasNode{
|
||||
Value: parent,
|
||||
}
|
||||
parent.Values = append(parent.Values, &ast.MappingValueNode{
|
||||
Key: &ast.StringNode{Value: "nested"},
|
||||
Value: aliasToParent,
|
||||
})
|
||||
|
||||
nodeCount := 0
|
||||
validated := make(map[ast.Node]int)
|
||||
visiting := make(map[ast.Node]bool)
|
||||
|
||||
// This should NOT hang or stack overflow - cycle detection prevents infinite recursion
|
||||
err := checkYAMLDepth(parent, 0, MaxYAMLDepth, MaxYAMLNodes, validated, visiting, &nodeCount)
|
||||
if err != nil {
|
||||
t.Errorf("unexpected error traversing cyclic structure: %v", err)
|
||||
}
|
||||
|
||||
// Verify we tracked the parent in the validated map
|
||||
if _, ok := validated[parent]; !ok {
|
||||
t.Error("parent node not tracked in validated map")
|
||||
}
|
||||
}
|
||||
|
||||
func TestYAMLMultiDocumentRejection(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
path := filepath.Join(dir, "multi.yaml")
|
||||
|
||||
// Multi-document YAML (documents separated by ---)
|
||||
content := `name: first
|
||||
identity: first document
|
||||
---
|
||||
name: second
|
||||
identity: second document
|
||||
`
|
||||
if err := os.WriteFile(path, []byte(content), 0644); err != nil {
|
||||
t.Fatalf("failed to write test file: %v", err)
|
||||
}
|
||||
|
||||
_, err := LoadPersona(path)
|
||||
if err == nil {
|
||||
t.Error("expected error for multi-document YAML, got nil")
|
||||
}
|
||||
if !strings.Contains(err.Error(), "multi-document") {
|
||||
t.Errorf("error = %q, want containing 'multi-document'", err.Error())
|
||||
}
|
||||
}
|
||||
|
||||
func TestYAMLNodeCountLimit(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
path := filepath.Join(dir, "wide.yaml")
|
||||
|
||||
// Build a YAML structure that's shallow but wide - many keys at the same level
|
||||
// to test the node count limit (should exceed MaxYAMLNodes = 1000)
|
||||
var sb strings.Builder
|
||||
sb.WriteString("name: test\nidentity: test\n")
|
||||
for i := 0; i < 600; i++ {
|
||||
sb.WriteString(fmt.Sprintf("key%d: value%d\n", i, i))
|
||||
}
|
||||
|
||||
if err := os.WriteFile(path, []byte(sb.String()), 0644); err != nil {
|
||||
t.Fatalf("failed to write test file: %v", err)
|
||||
}
|
||||
|
||||
_, err := LoadPersona(path)
|
||||
if err == nil {
|
||||
t.Error("expected error for wide YAML exceeding node count, got nil")
|
||||
}
|
||||
if !strings.Contains(err.Error(), "node count exceeds") {
|
||||
t.Errorf("error = %q, want containing 'node count exceeds'", err.Error())
|
||||
}
|
||||
}
|
||||
|
||||
func TestCheckYAMLDepthCycleDetectionDirect(t *testing.T) {
|
||||
// Direct test of cycle detection in checkYAMLDepth by creating
|
||||
// a node structure with an artificial cycle.
|
||||
node := &ast.MappingNode{
|
||||
Values: []*ast.MappingValueNode{
|
||||
{
|
||||
Key: &ast.StringNode{Value: "key"},
|
||||
Value: &ast.StringNode{Value: "value"},
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
// Create a cycle by making a child reference the parent
|
||||
cycleChild := &ast.AliasNode{
|
||||
Value: node, // Points back to the parent
|
||||
}
|
||||
node.Values = append(node.Values, &ast.MappingValueNode{
|
||||
Key: &ast.StringNode{Value: "cyclic"},
|
||||
Value: cycleChild,
|
||||
})
|
||||
|
||||
nodeCount := 0
|
||||
validated := make(map[ast.Node]int)
|
||||
visiting := make(map[ast.Node]bool)
|
||||
err := checkYAMLDepth(node, 0, MaxYAMLDepth, MaxYAMLNodes, validated, visiting, &nodeCount)
|
||||
|
||||
// Should complete without infinite recursion due to cycle detection
|
||||
if err != nil {
|
||||
t.Errorf("unexpected error: %v", err)
|
||||
}
|
||||
// The validated map should contain multiple entries
|
||||
if len(validated) < 2 {
|
||||
t.Errorf("validated map has %d entries, expected at least 2", len(validated))
|
||||
}
|
||||
}
|
||||
|
||||
func TestYAMLAliasDepthBypass(t *testing.T) {
|
||||
// Test that an anchored subtree first validated at a shallow depth is
|
||||
// re-checked when referenced via alias at a deeper position. Without the
|
||||
// depth-aware validated map, the alias reference would skip re-checking
|
||||
// and allow the effective nesting to exceed MaxYAMLDepth.
|
||||
|
||||
dir := t.TempDir()
|
||||
path := filepath.Join(dir, "alias-depth-bypass.yaml")
|
||||
|
||||
// Build YAML with an anchor at shallow depth containing a subtree near the limit,
|
||||
// then reference it via alias deep enough that effective depth exceeds MaxYAMLDepth.
|
||||
var sb strings.Builder
|
||||
sb.WriteString("name: test\nidentity: test\n")
|
||||
|
||||
// Create the anchored subtree at depth 1 (key level) that nests 15 levels deep.
|
||||
sb.WriteString("anchor_key: &deep_anchor\n")
|
||||
for i := 0; i < 15; i++ {
|
||||
sb.WriteString(strings.Repeat(" ", i+1))
|
||||
sb.WriteString(fmt.Sprintf("level%d:\n", i))
|
||||
}
|
||||
sb.WriteString(strings.Repeat(" ", 16))
|
||||
sb.WriteString("leaf: value\n")
|
||||
|
||||
// Create a wrapper that nests 6 levels deep, then references the anchor.
|
||||
// Effective depth at alias target = 6 (wrapper nesting) + 1 (alias) + 15 (subtree) = 22 > 20
|
||||
sb.WriteString("wrapper:\n")
|
||||
for i := 0; i < 6; i++ {
|
||||
sb.WriteString(strings.Repeat(" ", i+1))
|
||||
sb.WriteString(fmt.Sprintf("n%d:\n", i))
|
||||
}
|
||||
sb.WriteString(strings.Repeat(" ", 7))
|
||||
sb.WriteString("alias_ref: *deep_anchor\n")
|
||||
|
||||
if err := os.WriteFile(path, []byte(sb.String()), 0644); err != nil {
|
||||
t.Fatalf("failed to write test file: %v", err)
|
||||
}
|
||||
|
||||
_, err := LoadPersona(path)
|
||||
if err == nil {
|
||||
t.Fatal("expected error for alias depth bypass, got nil")
|
||||
}
|
||||
if !strings.Contains(err.Error(), "nesting depth exceeds") {
|
||||
t.Errorf("error = %q, want containing 'nesting depth exceeds'", err.Error())
|
||||
}
|
||||
}
|
||||
|
||||
func TestListBuiltinPersonasSortedOrder(t *testing.T) {
|
||||
names := ListBuiltinPersonas()
|
||||
if len(names) < 2 {
|
||||
t.Skip("need at least 2 personas to test ordering")
|
||||
}
|
||||
|
||||
// Verify the list is sorted
|
||||
for i := 1; i < len(names); i++ {
|
||||
if names[i-1] > names[i] {
|
||||
t.Errorf("ListBuiltinPersonas not sorted: %q > %q", names[i-1], names[i])
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestYAMLUnknownFieldsRejected(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
content string
|
||||
wantErr string
|
||||
}{
|
||||
{
|
||||
name: "unknown top-level field",
|
||||
content: `name: test
|
||||
identity: test identity
|
||||
unknown_field: should fail
|
||||
`,
|
||||
wantErr: "unknown_field",
|
||||
},
|
||||
{
|
||||
name: "typo in field name",
|
||||
content: `name: test
|
||||
identiy: typo should fail
|
||||
`,
|
||||
wantErr: "identiy",
|
||||
},
|
||||
{
|
||||
name: "unknown field in severity",
|
||||
content: `name: test
|
||||
identity: test
|
||||
severity:
|
||||
major: Major
|
||||
minro: typo
|
||||
`,
|
||||
wantErr: "minro",
|
||||
},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
path := filepath.Join(dir, "unknown.yaml")
|
||||
if err := os.WriteFile(path, []byte(tt.content), 0644); err != nil {
|
||||
t.Fatalf("failed to write test file: %v", err)
|
||||
}
|
||||
|
||||
_, err := LoadPersona(path)
|
||||
if err == nil {
|
||||
t.Errorf("expected error for unknown field %q, got nil", tt.wantErr)
|
||||
return
|
||||
}
|
||||
if !strings.Contains(err.Error(), tt.wantErr) {
|
||||
t.Errorf("error = %q, want containing %q", err.Error(), tt.wantErr)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestJSONUnknownFieldsRejected(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
content string
|
||||
wantErr string
|
||||
}{
|
||||
{
|
||||
name: "unknown top-level field",
|
||||
content: `{
|
||||
"name": "test",
|
||||
"identity": "test identity",
|
||||
"unknown_field": "should fail"
|
||||
}`,
|
||||
wantErr: "unknown_field",
|
||||
},
|
||||
{
|
||||
name: "typo in field name",
|
||||
content: `{
|
||||
"name": "test",
|
||||
"identiy": "typo should fail"
|
||||
}`,
|
||||
wantErr: "identiy",
|
||||
},
|
||||
{
|
||||
name: "unknown field in severity",
|
||||
content: `{
|
||||
"name": "test",
|
||||
"identity": "test",
|
||||
"severity": {
|
||||
"major": "ok",
|
||||
"miner": "typo"
|
||||
}
|
||||
}`,
|
||||
wantErr: "miner",
|
||||
},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
path := filepath.Join(dir, "test.json")
|
||||
if err := os.WriteFile(path, []byte(tt.content), 0644); err != nil {
|
||||
t.Fatalf("failed to write test file: %v", err)
|
||||
}
|
||||
|
||||
_, err := LoadPersona(path)
|
||||
if err == nil {
|
||||
t.Fatal("expected error for unknown field, got nil")
|
||||
}
|
||||
if !strings.Contains(err.Error(), tt.wantErr) {
|
||||
t.Errorf("error = %q, want to contain %q", err.Error(), tt.wantErr)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestLoadPersonaSymlink(t *testing.T) {
|
||||
// Create a regular persona file
|
||||
dir := t.TempDir()
|
||||
realFile := filepath.Join(dir, "real.yaml")
|
||||
content := `name: test
|
||||
identity: test identity
|
||||
`
|
||||
if err := os.WriteFile(realFile, []byte(content), 0644); err != nil {
|
||||
t.Fatalf("failed to write test file: %v", err)
|
||||
}
|
||||
|
||||
// Create a symlink to it
|
||||
symlink := filepath.Join(dir, "link.yaml")
|
||||
if err := os.Symlink(realFile, symlink); err != nil {
|
||||
t.Fatalf("failed to create symlink: %v", err)
|
||||
}
|
||||
|
||||
// LoadPersona should work via symlink
|
||||
p, err := LoadPersona(symlink)
|
||||
if err != nil {
|
||||
t.Fatalf("LoadPersona via symlink failed: %v", err)
|
||||
}
|
||||
if p.Name != "test" {
|
||||
t.Errorf("Name = %q, want %q", p.Name, "test")
|
||||
}
|
||||
}
|
||||
|
||||
func TestJSONTrailingContentRejected(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
content string
|
||||
}{
|
||||
{
|
||||
name: "trailing garbage after object",
|
||||
content: `{"name":"test","identity":"test identity"}garbage`,
|
||||
},
|
||||
{
|
||||
name: "two JSON objects",
|
||||
content: `{"name":"test","identity":"test identity"}{"name":"other"}`,
|
||||
},
|
||||
{
|
||||
name: "trailing array",
|
||||
content: `{"name":"test","identity":"test identity"}[]`,
|
||||
},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
path := filepath.Join(dir, "test.json")
|
||||
if err := os.WriteFile(path, []byte(tt.content), 0644); err != nil {
|
||||
t.Fatalf("failed to write test file: %v", err)
|
||||
}
|
||||
|
||||
_, err := LoadPersona(path)
|
||||
if err == nil {
|
||||
t.Fatal("expected error for trailing content, got nil")
|
||||
}
|
||||
if !strings.Contains(err.Error(), "trailing content") {
|
||||
t.Errorf("error = %q, want to contain 'trailing content'", err.Error())
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestParsePersonaBytesSizeLimit(t *testing.T) {
|
||||
// ParsePersonaBytes should reject input exceeding MaxPersonaFileSize
|
||||
oversized := make([]byte, MaxPersonaFileSize+1)
|
||||
for i := range oversized {
|
||||
oversized[i] = 'x'
|
||||
}
|
||||
|
||||
_, err := ParsePersonaBytes(oversized, "oversized.yaml")
|
||||
if err == nil {
|
||||
t.Fatal("expected error for oversized input, got nil")
|
||||
}
|
||||
if !strings.Contains(err.Error(), "exceeds maximum size") {
|
||||
t.Errorf("error = %q, want to contain 'exceeds maximum size'", err.Error())
|
||||
}
|
||||
|
||||
// Just under the limit should not trigger size error (may fail parse, but not size)
|
||||
underLimit := []byte("name: test\nidentity: test persona\n")
|
||||
p, err := ParsePersonaBytes(underLimit, "valid.yaml")
|
||||
if err != nil {
|
||||
t.Fatalf("unexpected error for valid input: %v", err)
|
||||
}
|
||||
if p.Name != "test" {
|
||||
t.Errorf("Name = %q, want %q", p.Name, "test")
|
||||
}
|
||||
}
|
||||
|
||||
func TestYAMLMergeKeyDepthCheck(t *testing.T) {
|
||||
// Verify that YAML merge keys (<<: *alias) are properly handled by the
|
||||
// depth checker. The merge key content is in the MappingValueNode.Value
|
||||
// (an AliasNode), not in the MergeKeyNode itself.
|
||||
p, err := ParsePersonaBytes([]byte("name: merge-test\nidentity: test\n"), "merge.yaml")
|
||||
if err != nil {
|
||||
t.Fatalf("basic parse failed: %v", err)
|
||||
}
|
||||
if p.Name != "merge-test" {
|
||||
t.Errorf("Name = %q, want %q", p.Name, "merge-test")
|
||||
}
|
||||
|
||||
// Test that deeply nested merge keys still hit depth limit.
|
||||
// Build YAML with merge key content nested beyond MaxYAMLDepth.
|
||||
var sb strings.Builder
|
||||
sb.WriteString("name: deep-merge\nidentity: deep merge persona\n")
|
||||
sb.WriteString("anchor: &deep\n")
|
||||
indent := " "
|
||||
for i := 0; i < MaxYAMLDepth+5; i++ {
|
||||
sb.WriteString(indent)
|
||||
sb.WriteString(fmt.Sprintf("level%d:\n", i))
|
||||
indent += " "
|
||||
}
|
||||
sb.WriteString(indent + "leaf: value\n")
|
||||
sb.WriteString("target:\n <<: *deep\n")
|
||||
|
||||
_, err = ParsePersonaBytes([]byte(sb.String()), "deep-merge.yaml")
|
||||
if err == nil {
|
||||
t.Fatal("expected error for deeply nested merge key content, got nil")
|
||||
}
|
||||
if !strings.Contains(err.Error(), "depth") {
|
||||
t.Errorf("error = %q, want to contain 'depth'", err.Error())
|
||||
}
|
||||
}
|
||||
@@ -1,37 +0,0 @@
|
||||
# Software Architect Persona
|
||||
# Focuses on design quality, patterns, and code organization
|
||||
|
||||
name: architect
|
||||
display_name: Software Architect
|
||||
|
||||
identity: |
|
||||
You are a software architect reviewing code for design quality.
|
||||
|
||||
Your expertise:
|
||||
- Design patterns and anti-patterns
|
||||
- Code organization and module boundaries
|
||||
- API design and contracts
|
||||
- Testability and dependency injection
|
||||
- Consistency with existing architecture
|
||||
- Technical debt identification
|
||||
|
||||
focus:
|
||||
- Design pattern violations or misuse
|
||||
- Module boundary violations (inappropriate coupling)
|
||||
- API design issues (unclear contracts, leaky abstractions)
|
||||
- Testability problems (hidden dependencies, god objects)
|
||||
- Inconsistency with existing codebase patterns
|
||||
- Unnecessary complexity or over-engineering
|
||||
- Missing abstractions or premature abstraction
|
||||
|
||||
ignore:
|
||||
- Security vulnerabilities (security persona handles these)
|
||||
- Performance micro-optimizations
|
||||
- Code style and formatting
|
||||
- Documentation typos
|
||||
- Test implementation details
|
||||
|
||||
severity:
|
||||
major: "Architectural violations that will cause maintenance problems or make the codebase harder to evolve"
|
||||
minor: "Design issues that reduce clarity or testability but don't block progress"
|
||||
nit: "Minor pattern deviations or style preferences"
|
||||
@@ -1,36 +0,0 @@
|
||||
# Documentation Reviewer Persona
|
||||
# Focuses on clarity, documentation quality, and self-documenting code
|
||||
|
||||
name: docs
|
||||
display_name: Documentation Reviewer
|
||||
|
||||
identity: |
|
||||
You are a documentation specialist reviewing code for clarity and documentation quality.
|
||||
|
||||
Your expertise:
|
||||
- API documentation and examples
|
||||
- Code comments and their accuracy
|
||||
- Error message clarity
|
||||
- README and guide quality
|
||||
- Naming clarity and self-documenting code
|
||||
|
||||
focus:
|
||||
- Missing or outdated documentation
|
||||
- Unclear or misleading comments
|
||||
- Poor error messages (cryptic, unhelpful, missing context)
|
||||
- Confusing naming (functions, variables, types)
|
||||
- Missing examples for complex APIs
|
||||
- Inconsistent terminology
|
||||
- Documentation that contradicts the code
|
||||
|
||||
ignore:
|
||||
- Security vulnerabilities
|
||||
- Performance issues
|
||||
- Design patterns
|
||||
- Test coverage
|
||||
- Code style (unless it affects readability)
|
||||
|
||||
severity:
|
||||
major: "Documentation that actively misleads or missing docs for critical functionality"
|
||||
minor: "Unclear documentation or poor error messages that will confuse users"
|
||||
nit: "Minor clarity improvements or typo fixes"
|
||||
@@ -1,37 +0,0 @@
|
||||
# Security Specialist Persona
|
||||
# Focuses on vulnerabilities, auth issues, and security best practices
|
||||
|
||||
name: security
|
||||
display_name: Security Specialist
|
||||
|
||||
identity: |
|
||||
You are a security specialist reviewing code for vulnerabilities.
|
||||
|
||||
Your expertise:
|
||||
- OWASP Top 10 vulnerabilities
|
||||
- Injection attacks (SQL, command, path traversal, template)
|
||||
- Authentication and authorization patterns
|
||||
- Secrets management and exposure risks
|
||||
- Race conditions with security implications
|
||||
- Event sourcing attack vectors (replay attacks, event injection)
|
||||
|
||||
focus:
|
||||
- Injection attacks (SQL, command, path traversal, template injection)
|
||||
- Authentication and authorization gaps or bypasses
|
||||
- Secrets exposure (hardcoded credentials, tokens in logs, config leaks)
|
||||
- Input validation failures (unsanitized input, unsafe deserialization)
|
||||
- Race conditions that could be exploited
|
||||
- Cryptographic weaknesses (weak algorithms, improper key handling)
|
||||
- Information disclosure through error messages or logs
|
||||
|
||||
ignore:
|
||||
- Code style and naming conventions
|
||||
- Performance optimizations (unless security-related)
|
||||
- Documentation quality
|
||||
- General code quality or readability
|
||||
- Test coverage
|
||||
|
||||
severity:
|
||||
major: "Exploitable vulnerabilities: auth bypass, injection, data exfiltration, privilege escalation, RCE"
|
||||
minor: "Defense-in-depth issues: missing rate limiting, verbose errors, weak input validation"
|
||||
nit: "Theoretical risks with low exploitability or impact"
|
||||
+18
-26
@@ -7,28 +7,6 @@ import (
|
||||
"strings"
|
||||
)
|
||||
|
||||
// outputSchemaJSON is the shared JSON output format specification used by both
|
||||
// the generic reviewer and persona-based reviewers.
|
||||
const outputSchemaJSON = `{
|
||||
"verdict": "APPROVE" or "REQUEST_CHANGES",
|
||||
"summary": "Brief overall assessment (1-3 sentences)",
|
||||
"findings": [
|
||||
{
|
||||
"severity": "MAJOR" or "MINOR" or "NIT",
|
||||
"file": "path/to/file",
|
||||
"line": <line number from the diff>,
|
||||
"finding": "Description of the issue"
|
||||
}
|
||||
],
|
||||
"recommendation": "Full recommendation text explaining your verdict"
|
||||
}`
|
||||
|
||||
// verdictRules is the shared verdict determination rules.
|
||||
const verdictRules = `Rules:
|
||||
- If there are any MAJOR findings → verdict must be REQUEST_CHANGES
|
||||
- If there are no MAJOR findings → verdict should be APPROVE
|
||||
- If CI has failed → verdict must be REQUEST_CHANGES with a finding noting the CI failure`
|
||||
|
||||
// BuildSystemBase returns the core system prompt instructions without
|
||||
// patterns or conventions. Used by the budget package to separate
|
||||
// trimmable from non-trimmable content.
|
||||
@@ -45,10 +23,24 @@ func BuildSystemBase() string {
|
||||
sb.WriteString("2. Consider the CI status — if CI has failed, that is an automatic REQUEST_CHANGES regardless of code quality.\n")
|
||||
sb.WriteString("3. Output your review as structured JSON (and ONLY JSON, no markdown fences or other text).\n\n")
|
||||
sb.WriteString("Output format:\n")
|
||||
sb.WriteString(outputSchemaJSON)
|
||||
sb.WriteString("\n\n")
|
||||
sb.WriteString(verdictRules)
|
||||
sb.WriteString("\n- Be thorough but fair. Don't nitpick style unless it impacts readability significantly.\n")
|
||||
sb.WriteString("{\n")
|
||||
sb.WriteString(" \"verdict\": \"APPROVE\" or \"REQUEST_CHANGES\",\n")
|
||||
sb.WriteString(" \"summary\": \"Brief overall assessment (1-3 sentences)\",\n")
|
||||
sb.WriteString(" \"findings\": [\n")
|
||||
sb.WriteString(" {\n")
|
||||
sb.WriteString(" \"severity\": \"MAJOR\" or \"MINOR\" or \"NIT\",\n")
|
||||
sb.WriteString(" \"file\": \"path/to/file\",\n")
|
||||
sb.WriteString(" \"line\": <line number from the diff>,\n")
|
||||
sb.WriteString(" \"finding\": \"Description of the issue\"\n")
|
||||
sb.WriteString(" }\n")
|
||||
sb.WriteString(" ],\n")
|
||||
sb.WriteString(" \"recommendation\": \"Full recommendation text explaining your verdict\"\n")
|
||||
sb.WriteString("}\n\n")
|
||||
sb.WriteString("Rules:\n")
|
||||
sb.WriteString("- If there are any MAJOR findings → verdict must be REQUEST_CHANGES\n")
|
||||
sb.WriteString("- If there are no MAJOR findings → verdict should be APPROVE\n")
|
||||
sb.WriteString("- If CI has failed → verdict must be REQUEST_CHANGES with a finding noting the CI failure\n")
|
||||
sb.WriteString("- Be thorough but fair. Don't nitpick style unless it impacts readability significantly.\n")
|
||||
sb.WriteString("- Line numbers should reference the new file line numbers from the diff headers.\n")
|
||||
sb.WriteString("- If the diff is empty or trivial (only formatting/whitespace), APPROVE with no findings.\n")
|
||||
|
||||
|
||||
@@ -1,150 +0,0 @@
|
||||
package review
|
||||
|
||||
import (
|
||||
"context"
|
||||
"log/slog"
|
||||
"strings"
|
||||
)
|
||||
|
||||
// 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 GiteaClient, owner, repo string) (map[string]*Persona, error) {
|
||||
result := make(map[string]*Persona)
|
||||
|
||||
entries, err := client.ListContents(ctx, owner, repo, RepoPersonaPath)
|
||||
if err != nil {
|
||||
// Check if this is a 404 (directory doesn't exist) - expected case
|
||||
if isNotFoundError(err) {
|
||||
slog.Debug("no repo personas directory found", "repo", owner+"/"+repo)
|
||||
return result, nil
|
||||
}
|
||||
// Other errors (auth, server) should propagate
|
||||
return nil, err
|
||||
}
|
||||
|
||||
if len(entries) == 0 {
|
||||
slog.Debug("repo personas directory is empty", "repo", owner+"/"+repo)
|
||||
return result, nil
|
||||
}
|
||||
|
||||
for _, entry := range entries {
|
||||
if entry.Type != "file" {
|
||||
continue
|
||||
}
|
||||
// Only process YAML files
|
||||
if !isYAMLFile(entry.Name) {
|
||||
continue
|
||||
}
|
||||
|
||||
content, err := client.GetFileContent(ctx, owner, repo, entry.Path)
|
||||
if err != nil {
|
||||
slog.Warn("could not fetch repo persona file",
|
||||
"file", entry.Path,
|
||||
"repo", owner+"/"+repo,
|
||||
"error", err)
|
||||
continue
|
||||
}
|
||||
|
||||
// Enforce size limit before parsing to prevent resource exhaustion
|
||||
if len(content) > MaxPersonaFileSize {
|
||||
slog.Warn("repo persona file exceeds maximum size",
|
||||
"file", entry.Path,
|
||||
"repo", owner+"/"+repo,
|
||||
"size", len(content),
|
||||
"max", MaxPersonaFileSize)
|
||||
continue
|
||||
}
|
||||
|
||||
persona, err := ParsePersonaBytes([]byte(content), entry.Path)
|
||||
if err != nil {
|
||||
slog.Warn("could not parse repo persona file",
|
||||
"file", entry.Path,
|
||||
"repo", owner+"/"+repo,
|
||||
"error", err)
|
||||
continue
|
||||
}
|
||||
|
||||
result[persona.Name] = persona
|
||||
slog.Debug("loaded repo persona",
|
||||
"name", persona.Name,
|
||||
"file", entry.Path,
|
||||
"repo", owner+"/"+repo)
|
||||
}
|
||||
|
||||
return result, nil
|
||||
}
|
||||
|
||||
// MergePersonas combines built-in personas with repo personas.
|
||||
// Repo personas take precedence on name collision.
|
||||
// Returns a new map; inputs are not modified.
|
||||
func MergePersonas(builtin, repo map[string]*Persona) map[string]*Persona {
|
||||
result := make(map[string]*Persona, len(builtin)+len(repo))
|
||||
|
||||
// Copy built-in personas first
|
||||
for name, p := range builtin {
|
||||
result[name] = p
|
||||
}
|
||||
|
||||
// Overlay repo personas (override on collision)
|
||||
for name, p := range repo {
|
||||
if _, exists := result[name]; exists {
|
||||
slog.Debug("repo persona overrides built-in", "name", name)
|
||||
}
|
||||
result[name] = p
|
||||
}
|
||||
|
||||
return result
|
||||
}
|
||||
|
||||
// GetBuiltinPersonasMap returns all built-in personas as a map keyed by name.
|
||||
// Returns an empty map (not nil) if loading fails.
|
||||
func GetBuiltinPersonasMap() map[string]*Persona {
|
||||
result := make(map[string]*Persona)
|
||||
for _, name := range ListBuiltinPersonas() {
|
||||
p, err := LoadBuiltinPersona(name)
|
||||
if err != nil {
|
||||
slog.Warn("could not load built-in persona", "name", name, "error", err)
|
||||
continue
|
||||
}
|
||||
result[name] = p
|
||||
}
|
||||
return result
|
||||
}
|
||||
|
||||
// isYAMLFile checks if a filename has a YAML extension.
|
||||
func isYAMLFile(name string) bool {
|
||||
lower := strings.ToLower(name)
|
||||
return strings.HasSuffix(lower, ".yaml") || strings.HasSuffix(lower, ".yml")
|
||||
}
|
||||
|
||||
// isNotFoundError checks if an error represents a 404 response.
|
||||
// This uses a specific "HTTP 404" substring match rather than a generic "not found"
|
||||
// match to avoid masking authentication failures or transport errors that might
|
||||
// contain "not found" in their message.
|
||||
func isNotFoundError(err error) bool {
|
||||
if err == nil {
|
||||
return false
|
||||
}
|
||||
return strings.Contains(err.Error(), "HTTP 404")
|
||||
}
|
||||
@@ -1,443 +0,0 @@
|
||||
package review
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestParsePersonaBytes(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
data string
|
||||
source string
|
||||
wantName string
|
||||
wantErr string
|
||||
}{
|
||||
{
|
||||
name: "valid yaml",
|
||||
data: `name: test
|
||||
identity: test identity
|
||||
focus:
|
||||
- testing
|
||||
`,
|
||||
source: "test.yaml",
|
||||
wantName: "test",
|
||||
},
|
||||
{
|
||||
name: "missing name",
|
||||
data: "identity: test\n",
|
||||
source: "test.yaml",
|
||||
wantErr: "name is required",
|
||||
},
|
||||
{
|
||||
name: "invalid yaml",
|
||||
data: "not: valid:\n yaml: [broken",
|
||||
source: "test.yaml",
|
||||
wantErr: "parse",
|
||||
},
|
||||
{
|
||||
name: "json format by extension",
|
||||
data: `{"name": "jsontest", "identity": "json identity"}`,
|
||||
source: "test.json",
|
||||
wantName: "jsontest",
|
||||
},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
p, err := ParsePersonaBytes([]byte(tt.data), tt.source)
|
||||
if tt.wantErr != "" {
|
||||
if err == nil {
|
||||
t.Fatalf("expected error containing %q, got nil", tt.wantErr)
|
||||
}
|
||||
if !strings.Contains(err.Error(), tt.wantErr) {
|
||||
t.Errorf("error = %q, want containing %q", err.Error(), tt.wantErr)
|
||||
}
|
||||
return
|
||||
}
|
||||
if err != nil {
|
||||
t.Fatalf("unexpected error: %v", err)
|
||||
}
|
||||
if p.Name != tt.wantName {
|
||||
t.Errorf("Name = %q, want %q", p.Name, tt.wantName)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// mockGiteaClient implements GiteaClient for testing.
|
||||
type mockGiteaClient struct {
|
||||
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) ([]ContentEntry, error) {
|
||||
if m.listErr != nil {
|
||||
return nil, m.listErr
|
||||
}
|
||||
entries, ok := m.contents[path]
|
||||
if !ok {
|
||||
return nil, errors.New("list contents .review-bot/personas: HTTP 404: not found")
|
||||
}
|
||||
return entries, nil
|
||||
}
|
||||
|
||||
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
|
||||
}
|
||||
}
|
||||
content, ok := m.files[filepath]
|
||||
if !ok {
|
||||
return "", errors.New("HTTP 404: file not found")
|
||||
}
|
||||
return content, nil
|
||||
}
|
||||
|
||||
func TestLoadRepoPersonas(t *testing.T) {
|
||||
ctx := context.Background()
|
||||
|
||||
t.Run("directory not found returns empty map", func(t *testing.T) {
|
||||
client := &mockGiteaClient{} // No contents configured -> 404
|
||||
personas, err := LoadRepoPersonas(ctx, client, "owner", "repo")
|
||||
if err != nil {
|
||||
t.Fatalf("unexpected error: %v", err)
|
||||
}
|
||||
if personas == nil {
|
||||
t.Error("expected empty map, got nil")
|
||||
}
|
||||
if len(personas) != 0 {
|
||||
t.Errorf("expected 0 personas, got %d", len(personas))
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("empty directory returns empty map", func(t *testing.T) {
|
||||
client := &mockGiteaClient{
|
||||
contents: map[string][]ContentEntry{
|
||||
RepoPersonaPath: {},
|
||||
},
|
||||
}
|
||||
personas, err := LoadRepoPersonas(ctx, client, "owner", "repo")
|
||||
if err != nil {
|
||||
t.Fatalf("unexpected error: %v", err)
|
||||
}
|
||||
if len(personas) != 0 {
|
||||
t.Errorf("expected 0 personas, got %d", len(personas))
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("loads valid personas", func(t *testing.T) {
|
||||
client := &mockGiteaClient{
|
||||
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
|
||||
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")
|
||||
if err != nil {
|
||||
t.Fatalf("unexpected error: %v", err)
|
||||
}
|
||||
if len(personas) != 2 {
|
||||
t.Fatalf("expected 2 personas, got %d", len(personas))
|
||||
}
|
||||
if personas["trading"] == nil {
|
||||
t.Error("expected trading persona")
|
||||
}
|
||||
if personas["crypto"] == nil {
|
||||
t.Error("expected crypto persona")
|
||||
}
|
||||
if personas["trading"].DisplayName != "Trading Expert" {
|
||||
t.Errorf("trading display name = %q, want %q", personas["trading"].DisplayName, "Trading Expert")
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("skips invalid persona files", func(t *testing.T) {
|
||||
client := &mockGiteaClient{
|
||||
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
|
||||
identity: Valid persona
|
||||
`,
|
||||
".review-bot/personas/invalid.yaml": "not valid yaml: [broken",
|
||||
},
|
||||
}
|
||||
personas, err := LoadRepoPersonas(ctx, client, "owner", "repo")
|
||||
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))
|
||||
}
|
||||
if personas["valid"] == nil {
|
||||
t.Error("expected valid persona")
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("skips non-yaml files", func(t *testing.T) {
|
||||
client := &mockGiteaClient{
|
||||
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"},
|
||||
{Name: "notes.txt", Path: ".review-bot/personas/notes.txt", Type: "file"},
|
||||
},
|
||||
},
|
||||
files: map[string]string{
|
||||
".review-bot/personas/persona.yaml": `name: test
|
||||
identity: Test persona
|
||||
`,
|
||||
".review-bot/personas/README.md": "# Personas\n\nPut your personas here.",
|
||||
},
|
||||
}
|
||||
personas, err := LoadRepoPersonas(ctx, client, "owner", "repo")
|
||||
if err != nil {
|
||||
t.Fatalf("unexpected error: %v", err)
|
||||
}
|
||||
if len(personas) != 1 {
|
||||
t.Fatalf("expected 1 persona (yaml only), got %d", len(personas))
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("skips subdirectories", func(t *testing.T) {
|
||||
client := &mockGiteaClient{
|
||||
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
|
||||
identity: Test persona
|
||||
`,
|
||||
},
|
||||
}
|
||||
personas, err := LoadRepoPersonas(ctx, client, "owner", "repo")
|
||||
if err != nil {
|
||||
t.Fatalf("unexpected error: %v", err)
|
||||
}
|
||||
if len(personas) != 1 {
|
||||
t.Fatalf("expected 1 persona (files only), got %d", len(personas))
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("propagates auth errors", func(t *testing.T) {
|
||||
client := &mockGiteaClient{
|
||||
listErr: errors.New("HTTP 401: unauthorized"),
|
||||
}
|
||||
_, err := LoadRepoPersonas(ctx, client, "owner", "repo")
|
||||
if err == nil {
|
||||
t.Fatal("expected error for auth failure")
|
||||
}
|
||||
if !strings.Contains(err.Error(), "401") {
|
||||
t.Errorf("error = %q, want containing '401'", err.Error())
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("skips files that fail to fetch", func(t *testing.T) {
|
||||
client := &mockGiteaClient{
|
||||
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
|
||||
identity: Good persona
|
||||
`,
|
||||
},
|
||||
fileErr: map[string]error{
|
||||
".review-bot/personas/bad.yaml": errors.New("HTTP 500: internal server error"),
|
||||
},
|
||||
}
|
||||
personas, err := LoadRepoPersonas(ctx, client, "owner", "repo")
|
||||
if err != nil {
|
||||
t.Fatalf("unexpected error: %v", err)
|
||||
}
|
||||
if len(personas) != 1 {
|
||||
t.Fatalf("expected 1 persona (skipped failed fetch), got %d", len(personas))
|
||||
}
|
||||
})
|
||||
|
||||
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][]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
|
||||
identity: Normal sized persona
|
||||
`,
|
||||
".review-bot/personas/huge.yaml": oversizedContent,
|
||||
},
|
||||
}
|
||||
personas, err := LoadRepoPersonas(ctx, client, "owner", "repo")
|
||||
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))
|
||||
}
|
||||
if personas["normal"] == nil {
|
||||
t.Error("expected normal persona")
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
func TestMergePersonas(t *testing.T) {
|
||||
builtin := map[string]*Persona{
|
||||
"security": {Name: "security", Identity: "Built-in security"},
|
||||
"docs": {Name: "docs", Identity: "Built-in docs"},
|
||||
}
|
||||
repo := map[string]*Persona{
|
||||
"security": {Name: "security", Identity: "Repo security override"},
|
||||
"trading": {Name: "trading", Identity: "Repo trading"},
|
||||
}
|
||||
|
||||
merged := MergePersonas(builtin, repo)
|
||||
|
||||
t.Run("repo overrides builtin on collision", func(t *testing.T) {
|
||||
if merged["security"].Identity != "Repo security override" {
|
||||
t.Errorf("security identity = %q, want repo override", merged["security"].Identity)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("builtin preserved when no collision", func(t *testing.T) {
|
||||
if merged["docs"].Identity != "Built-in docs" {
|
||||
t.Errorf("docs identity = %q, want built-in", merged["docs"].Identity)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("repo-only persona added", func(t *testing.T) {
|
||||
if merged["trading"] == nil {
|
||||
t.Error("expected trading persona from repo")
|
||||
}
|
||||
if merged["trading"].Identity != "Repo trading" {
|
||||
t.Errorf("trading identity = %q, want repo", merged["trading"].Identity)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("original maps not modified", func(t *testing.T) {
|
||||
if builtin["trading"] != nil {
|
||||
t.Error("builtin map was modified")
|
||||
}
|
||||
if len(repo) != 2 {
|
||||
t.Error("repo map was modified")
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
func TestGetBuiltinPersonasMap(t *testing.T) {
|
||||
personas := GetBuiltinPersonasMap()
|
||||
|
||||
if len(personas) == 0 {
|
||||
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 {
|
||||
t.Errorf("expected built-in persona %q", name)
|
||||
}
|
||||
}
|
||||
|
||||
// Verify personas are valid
|
||||
for name, p := range personas {
|
||||
if p.Name != name {
|
||||
t.Errorf("persona %q has mismatched name %q", name, p.Name)
|
||||
}
|
||||
if p.Identity == "" {
|
||||
t.Errorf("persona %q has empty identity", name)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestIsYAMLFile(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
want bool
|
||||
}{
|
||||
{"test.yaml", true},
|
||||
{"test.yml", true},
|
||||
{"test.YAML", true},
|
||||
{"test.YML", true},
|
||||
{"test.json", false},
|
||||
{"test.md", false},
|
||||
{"test.txt", false},
|
||||
{"yaml", false},
|
||||
{"yaml.md", false},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
if got := isYAMLFile(tt.name); got != tt.want {
|
||||
t.Errorf("isYAMLFile(%q) = %v, want %v", tt.name, got, tt.want)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestIsNotFoundError(t *testing.T) {
|
||||
tests := []struct {
|
||||
err error
|
||||
want bool
|
||||
}{
|
||||
{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},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
name := "nil"
|
||||
if tt.err != nil {
|
||||
name = tt.err.Error()
|
||||
}
|
||||
t.Run(name, func(t *testing.T) {
|
||||
if got := isNotFoundError(tt.err); got != tt.want {
|
||||
t.Errorf("isNotFoundError(%v) = %v, want %v", tt.err, got, tt.want)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
@@ -1,127 +0,0 @@
|
||||
#!/usr/bin/env bash
|
||||
# check-deps.sh - Enforces the strict dependency allowlist from CONVENTIONS.md
|
||||
# Exit 1 if any unapproved import is found.
|
||||
#
|
||||
# Requires: Bash 4+ (for associative arrays), Go toolchain
|
||||
#
|
||||
# The allowlist is parsed from CONVENTIONS.md to maintain a single source of truth.
|
||||
# Enforces Scope column: "test only" packages cannot appear in non-test code.
|
||||
|
||||
set -euo pipefail
|
||||
|
||||
# Check bash version
|
||||
if ((BASH_VERSINFO[0] < 4)); then
|
||||
echo "❌ Bash 4+ required (found ${BASH_VERSION})"
|
||||
echo " On macOS: brew install bash"
|
||||
exit 1
|
||||
fi
|
||||
|
||||
CONVENTIONS_FILE="${1:-CONVENTIONS.md}"
|
||||
|
||||
if [ ! -f "$CONVENTIONS_FILE" ]; then
|
||||
echo "❌ CONVENTIONS.md not found"
|
||||
exit 1
|
||||
fi
|
||||
|
||||
# Parse approved packages from CONVENTIONS.md table using awk (POSIX-compatible)
|
||||
# Format: | `package` | use case | scope |
|
||||
declare -A ALLOWED_PROD=()
|
||||
declare -A ALLOWED_TEST=()
|
||||
|
||||
while IFS= read -r line; do
|
||||
# Use awk to extract package and scope from table row
|
||||
pkg=$(echo "$line" | awk -F'|' '{gsub(/^[[:space:]]*`|`[[:space:]]*$/, "", $2); print $2}')
|
||||
scope=$(echo "$line" | awk -F'|' '{gsub(/^[[:space:]]+|[[:space:]]+$/, "", $4); print tolower($4)}')
|
||||
|
||||
if [ -n "$pkg" ] && [ "$pkg" != "Package" ] && [[ "$pkg" =~ ^[a-zA-Z] ]]; then
|
||||
if [[ "$scope" == *"test"* ]]; then
|
||||
ALLOWED_TEST["$pkg"]=1
|
||||
else
|
||||
ALLOWED_PROD["$pkg"]=1
|
||||
fi
|
||||
fi
|
||||
done < <(grep '| `' "$CONVENTIONS_FILE" 2>/dev/null || true)
|
||||
|
||||
ALL_ALLOWED=("${!ALLOWED_PROD[@]}" "${!ALLOWED_TEST[@]}")
|
||||
|
||||
if [ ${#ALL_ALLOWED[@]} -eq 0 ]; then
|
||||
echo "⚠️ No approved packages found in $CONVENTIONS_FILE"
|
||||
echo " (This is fine if you want stdlib-only)"
|
||||
fi
|
||||
|
||||
# Helper: check if import matches any package in an associative array (literal prefix, no glob)
|
||||
matches_allowlist() {
|
||||
local import="$1"
|
||||
shift
|
||||
local -n allowlist=$1
|
||||
|
||||
for allowed in "${!allowlist[@]}"; do
|
||||
# Exact match
|
||||
if [ "$import" = "$allowed" ]; then
|
||||
return 0
|
||||
fi
|
||||
# Literal prefix match for subpackages: must match "pkg/" exactly
|
||||
if [ "${import#"$allowed/"}" != "$import" ]; then
|
||||
return 0
|
||||
fi
|
||||
done
|
||||
return 1
|
||||
}
|
||||
|
||||
# Get direct module dependencies from go.mod
|
||||
DIRECT_IMPORTS=$(go list -m -f '{{if and (not .Indirect) (not .Main)}}{{.Path}}{{end}}' all 2>&1) || {
|
||||
echo "❌ Failed to list dependencies: $DIRECT_IMPORTS"
|
||||
exit 1
|
||||
}
|
||||
DIRECT_IMPORTS=$(echo "$DIRECT_IMPORTS" | grep -v '^$' || true)
|
||||
|
||||
if [ -z "$DIRECT_IMPORTS" ]; then
|
||||
echo "✅ No external dependencies"
|
||||
exit 0
|
||||
fi
|
||||
|
||||
# Check ALL direct dependencies are in some allowlist
|
||||
VIOLATIONS=""
|
||||
while IFS= read -r import; do
|
||||
[ -z "$import" ] && continue
|
||||
|
||||
if ! matches_allowlist "$import" ALLOWED_PROD && ! matches_allowlist "$import" ALLOWED_TEST; then
|
||||
VIOLATIONS="${VIOLATIONS} - ${import} (not in allowlist)"$'\n'
|
||||
fi
|
||||
done <<< "$DIRECT_IMPORTS"
|
||||
|
||||
if [ -n "$VIOLATIONS" ]; then
|
||||
echo "❌ UNAPPROVED DEPENDENCIES DETECTED"
|
||||
echo ""
|
||||
echo "The following imports are not in the allowlist:"
|
||||
printf "%s" "$VIOLATIONS"
|
||||
echo ""
|
||||
echo "To add a dependency, update CONVENTIONS.md (requires Aaron's approval)"
|
||||
exit 1
|
||||
fi
|
||||
|
||||
# Enforce Scope: test-only packages must not appear in non-test code
|
||||
# Get imports used by non-test code only (go list -deps without -test excludes test deps)
|
||||
PROD_IMPORTS=$(go list -deps -f '{{if not .Standard}}{{.ImportPath}}{{end}}' ./... 2>/dev/null || true)
|
||||
|
||||
TEST_ONLY_IN_PROD=""
|
||||
for test_pkg in "${!ALLOWED_TEST[@]}"; do
|
||||
# Use word-boundary matching: exact match or followed by /
|
||||
if echo "$PROD_IMPORTS" | grep -qE "^${test_pkg}(/|\$|$)"; then
|
||||
TEST_ONLY_IN_PROD="${TEST_ONLY_IN_PROD} - ${test_pkg} (marked 'test only' but used in production code)"$'\n'
|
||||
fi
|
||||
done
|
||||
|
||||
if [ -n "$TEST_ONLY_IN_PROD" ]; then
|
||||
echo "❌ TEST-ONLY DEPENDENCIES IN PRODUCTION CODE"
|
||||
echo ""
|
||||
printf "%s" "$TEST_ONLY_IN_PROD"
|
||||
echo ""
|
||||
echo "These packages are marked 'test only' in CONVENTIONS.md"
|
||||
echo "and must only be imported from *_test.go files."
|
||||
exit 1
|
||||
fi
|
||||
|
||||
echo "✅ All dependencies are approved"
|
||||
echo " Direct module deps: $(echo "$DIRECT_IMPORTS" | wc -l | tr -d ' ')"
|
||||
echo " Production allowlist: ${#ALLOWED_PROD[@]}, Test-only allowlist: ${#ALLOWED_TEST[@]}"
|
||||
Reference in New Issue
Block a user