feat(workflow): pr-review intake depth and dimension merge

First slice of archie-core-afbk.3's pr-review pipeline (phases 1 and 3's
deterministic logic): depth classification from changed-line count with the
operator-override rule, the depth-to-dimension-cap table, cross-lens
dimension merge/dedup/cap, and the hallucination-check dimension added for a
likely-machine-written PR.

Table-driven tests cover the classification boundaries, the override rule,
duplicate-name merging, priority-ordered capping and the AI-generated
threshold. Stage wiring (agent calls, StepExecution recording, the fan-out
concurrency phases 3/4/9 need, and a PR diff/snapshot source) is still open;
see the bead for what remains.
This commit is contained in:
sam committed 2026-09-28 03:00:59 +10:00
1 parent f20d226369
commit b76e63d686
4 files changed
+260

No files matched your search

@@ -0,0 +1,69 @@
package prreview
import (
"cmp"
"slices"
)
// Dimension is one review dimension a lens proposed: a name, a reviewer
// prompt written for this PR, the files the reviewer must read, and a
// priority phase 3 ranks dimensions by when the depth's cap forces a cut.
type Dimension struct {
Name string
Prompt string
TargetFiles []string
ContextFiles []string
Priority float64
}
// MergeDimensions drops duplicate dimension names across the lenses' outputs
// (keeping the higher-priority copy), sorts by priority, and cuts the tail at
// cap. Order is stable for equal priority: the input order of the first lens
// that produced the name wins, so re-running the same lenses in the same
// order always keeps the same dimensions.
func MergeDimensions(lensOutputs [][]Dimension, limit int) []Dimension {
byName := make(map[string]Dimension)
order := make([]string, 0)
for _, lens := range lensOutputs {
for _, d := range lens {
existing, ok := byName[d.Name]
if !ok {
order = append(order, d.Name)
byName[d.Name] = d
continue
}
if d.Priority > existing.Priority {
byName[d.Name] = d
}
}
}
merged := make([]Dimension, 0, len(order))
for _, name := range order {
merged = append(merged, byName[name])
}
slices.SortStableFunc(merged, func(a, b Dimension) int {
return cmp.Compare(b.Priority, a.Priority)
})
if len(merged) > limit {
merged = merged[:limit]
}
return merged
}
// HallucinationDimension is the extra review dimension phase 3 adds for a PR
// intake scores as likely machine-written: claims, citations and behaviour
// the diff does not actually implement. Returns nil at or below
// AIGeneratedThreshold -- a coin-flip is not evidence, so it is not added.
func HallucinationDimension(aiGenerated float64) *Dimension {
if aiGenerated <= AIGeneratedThreshold {
return nil
}
return &Dimension{
Name: "hallucination-check",
Prompt: "This PR's description or commit messages read as likely machine-written. " +
"Check every claim the PR makes -- what it says it does, any cited behaviour, API, or test result -- " +
"against what the diff actually implements. Report a finding for any claim, citation, or described " +
"behaviour that the diff does not actually carry out.",
Priority: 1,
}
}
@@ -0,0 +1,68 @@
package prreview
import "testing"
func TestMergeDimensionsDropsDuplicatesByName(t *testing.T) {
t.Parallel()
lenses := [][]Dimension{
{{Name: "security", Priority: 0.9}, {Name: "types", Priority: 0.4}},
{{Name: "security", Priority: 0.5}, {Name: "docs", Priority: 0.2}},
}
got := MergeDimensions(lenses, 10)
if len(got) != 3 {
t.Fatalf("MergeDimensions() returned %d dimensions, want 3 (security, types, docs merged from duplicates)", len(got))
}
for _, d := range got {
if d.Name == "security" && d.Priority != 0.9 {
t.Errorf("duplicate %q kept priority %v, want the higher-priority lens's 0.9", d.Name, d.Priority)
}
}
}
func TestMergeDimensionsCapsAtTheDepthLimit(t *testing.T) {
t.Parallel()
lenses := [][]Dimension{
{
{Name: "a", Priority: 0.9},
{Name: "b", Priority: 0.8},
{Name: "c", Priority: 0.7},
{Name: "d", Priority: 0.1},
},
}
got := MergeDimensions(lenses, 2)
if len(got) != 2 {
t.Fatalf("MergeDimensions() with cap 2 returned %d dimensions, want 2", len(got))
}
if got[0].Name != "a" || got[1].Name != "b" {
t.Errorf("MergeDimensions() with cap 2 kept %+v, want the two highest-priority dimensions (a, b)", got)
}
}
func TestMergeDimensionsIsDeterministicForTheSameInput(t *testing.T) {
t.Parallel()
lenses := [][]Dimension{{{Name: "x", Priority: 0.5}, {Name: "y", Priority: 0.5}}}
got1 := MergeDimensions(lenses, 10)
got2 := MergeDimensions(lenses, 10)
if got1[0].Name != got2[0].Name || got1[1].Name != got2[1].Name {
t.Errorf("MergeDimensions() on the same input produced different orders across calls: %+v vs %+v", got1, got2)
}
}
func TestHallucinationDimensionOnlyAddedAboveTheAIGeneratedThreshold(t *testing.T) {
t.Parallel()
if got := HallucinationDimension(AIGeneratedThreshold); got != nil {
t.Errorf("HallucinationDimension() at the threshold = %+v, want nil (the PRD says above, not at)", got)
}
got := HallucinationDimension(AIGeneratedThreshold + 0.01)
if got == nil {
t.Fatal("HallucinationDimension() above the threshold = nil, want a dimension")
}
if got.Name == "" || got.Prompt == "" {
t.Errorf("HallucinationDimension() = %+v, want a named dimension with a reviewer prompt", got)
}
}
@@ -0,0 +1,62 @@
package prreview
// Depth is how many review dimensions a run affords, driven by the size of
// the change (docs/prds/pr-review-agent.md, phase 1).
type Depth string
const (
DepthQuick Depth = "quick"
DepthStandard Depth = "standard"
DepthDeep Depth = "deep"
)
// The line-count boundaries phase 1 classifies depth from: under 100 is
// quick, under 500 is standard, otherwise deep.
const (
quickLinesCeiling = 100
standardLinesCeiling = 500
)
// The dimension caps each depth affords.
const (
maxDimensionsQuick = 3
maxDimensionsStandard = 6
maxDimensionsDeep = 12
)
// ClassifyDepth derives a review depth from the number of changed lines
// (additions plus deletions).
func ClassifyDepth(changedLines int) Depth {
switch {
case changedLines < quickLinesCeiling:
return DepthQuick
case changedLines < standardLinesCeiling:
return DepthStandard
default:
return DepthDeep
}
}
// MaxDimensionsFor returns how many review dimensions a depth affords. An
// unrecognised depth gets the cheapest cap, never the most expensive: a typo
// or a stale value must not silently buy a deep run's budget.
func MaxDimensionsFor(depth Depth) int {
switch depth {
case DepthStandard:
return maxDimensionsStandard
case DepthDeep:
return maxDimensionsDeep
default:
return maxDimensionsQuick
}
}
// ResolveDepth applies the PRD's override rule: an operator-set depth wins
// over the line-count classification. An empty explicit depth means no
// override was given.
func ResolveDepth(changedLines int, explicit Depth) Depth {
if explicit != "" {
return explicit
}
return ClassifyDepth(changedLines)
}
@@ -0,0 +1,61 @@
package prreview
import "testing"
func TestClassifyDepth(t *testing.T) {
t.Parallel()
tests := []struct {
name string
changedLines int
want Depth
}{
{"zero lines is quick", 0, DepthQuick},
{"just under the quick boundary", 99, DepthQuick},
{"the quick boundary itself is standard", 100, DepthStandard},
{"just under the standard boundary", 499, DepthStandard},
{"the standard boundary itself is deep", 500, DepthDeep},
{"far above the standard boundary is deep", 5000, DepthDeep},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
t.Parallel()
if got := ClassifyDepth(tt.changedLines); got != tt.want {
t.Errorf("ClassifyDepth(%d) = %q, want %q", tt.changedLines, got, tt.want)
}
})
}
}
func TestMaxDimensionsFor(t *testing.T) {
t.Parallel()
tests := []struct {
depth Depth
want int
}{
{DepthQuick, 3},
{DepthStandard, 6},
{DepthDeep, 12},
{Depth("unknown"), 3}, // an unrecognised depth is treated as the cheapest, never the most expensive
}
for _, tt := range tests {
if got := MaxDimensionsFor(tt.depth); got != tt.want {
t.Errorf("MaxDimensionsFor(%q) = %d, want %d", tt.depth, got, tt.want)
}
}
}
func TestExplicitDepthOverridesClassification(t *testing.T) {
t.Parallel()
got := ResolveDepth(5000, DepthQuick)
if got != DepthQuick {
t.Errorf("ResolveDepth with an explicit operator depth = %q, want %q (the explicit value must win over the line count)", got, DepthQuick)
}
got = ResolveDepth(5000, "")
if got != DepthDeep {
t.Errorf("ResolveDepth with no explicit depth = %q, want %q (falls back to classification)", got, DepthDeep)
}
}