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:
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)
|
||||||
|
}
|
||||||
|
}
|
||||||
Reference in new issue
Block a user