feat(workflow): add coverage-gap and exposure helpers to pr-review's deterministic core

Extends the afbk.1 deterministic core for afbk.4's coverage gate and
compound-defect check: exposure fan-in counts and high-exposure filtering
(blast.go), cluster/finding coverage matching and grouping (coverage.go),
and a high-priority severity predicate the evidence verifier gates on
(scoring.go).
This commit is contained in:
sam committed 2026-09-28 11:04:25 +10:00
1 parent 62b4fbf4ab
commit b4a174c629
5 files changed
+213

No files matched your search

@@ -51,6 +51,58 @@ func BlastRadius(fsys fs.FS, changed []string) ([]string, error) {
return radius, nil
}
// ExposureCounts returns, for every file the change reaches without touching,
// how many changed files reach it: a fan-in count computed from the same
// import graph BlastRadius walks. It is BlastRadius's detail, not its
// replacement -- the coverage gate needs to tell a file three unrelated
// changed files each reach apart from one only one of them happens to import.
func ExposureCounts(fsys fs.FS, changed []string) (map[string]int, error) {
graph, err := buildImportGraph(fsys)
if err != nil {
return nil, err
}
changedSet := make(map[string]bool, len(changed))
for _, file := range changed {
changedSet[file] = true
}
counts := map[string]int{}
for _, file := range changed {
reached := map[string]bool{}
for _, imported := range graph.imports[file] {
reached[imported] = true
}
for _, dependent := range graph.dependents[file] {
reached[dependent] = true
}
for target := range reached {
if changedSet[target] {
continue
}
counts[target]++
}
}
return counts, nil
}
// HighExposureThreshold is the fan-in above which a blast-radius file counts
// as high-exposure for the coverage gate: reached by more than one changed
// file, so a regression there is not one dimension's problem to have covered.
const HighExposureThreshold = 1
// HighExposureFiles returns the blast-radius files whose exposure count
// exceeds HighExposureThreshold, sorted for a deterministic gap-review order.
func HighExposureFiles(counts map[string]int) []string {
var files []string
for file, count := range counts {
if count > HighExposureThreshold {
files = append(files, file)
}
}
sort.Strings(files)
return files
}
// importGraph is a snapshot's file-level dependency graph, in both directions:
// an edge exists when one file's imports resolve to another file.
type importGraph struct {
@@ -174,3 +174,25 @@ func TestBlastRadiusJavaScriptAndTypeScript(t *testing.T) {
})
}
}
func TestExposureCountsAndHighExposureFiles(t *testing.T) {
t.Parallel()
fsys := fstest.MapFS{
"go.mod": {Data: []byte("module example.com/m\n\ngo 1.27.0\n")},
"internal/store/store.go": {Data: []byte("package store\n\nfunc Get() int { return 1 }\n")},
"internal/app/app.go": {Data: []byte("package app\n\nimport \"example.com/m/internal/store\"\n\nfunc Run() int { return store.Get() }\n")},
"internal/other/other.go": {Data: []byte("package other\n\nimport \"example.com/m/internal/store\"\n\nfunc Run2() int { return store.Get() }\n")},
}
counts, err := ExposureCounts(fsys, []string{"internal/app/app.go", "internal/other/other.go"})
if err != nil {
t.Fatalf("ExposureCounts() error = %v", err)
}
if counts["internal/store/store.go"] != 2 {
t.Errorf("store.go exposure = %d, want 2 (reached by both changed files)", counts["internal/store/store.go"])
}
high := HighExposureFiles(counts)
wantStrings(t, high, []string{"internal/store/store.go"})
}
@@ -0,0 +1,53 @@
package prreview
// CoverageGaps returns the clusters with no finding pointing at any of their
// files, and the high-exposure blast-radius files no finding points at
// either: the two things phase 6's coverage gate checks (docs/prds/
// pr-review-agent.md, phase 6).
func CoverageGaps(clusters []Cluster, highExposure []string, findings []Finding) (uncoveredClusters []Cluster, uncoveredFiles []string) {
reviewed := make(map[string]bool, len(findings))
for _, f := range findings {
reviewed[f.File] = true
}
for _, cluster := range clusters {
covered := false
for _, file := range cluster.Files {
if reviewed[file] {
covered = true
break
}
}
if !covered {
uncoveredClusters = append(uncoveredClusters, cluster)
}
}
for _, file := range highExposure {
if !reviewed[file] {
uncoveredFiles = append(uncoveredFiles, file)
}
}
return uncoveredClusters, uncoveredFiles
}
// ClusterFindings groups findings by the cluster whose files contain them,
// keyed by cluster ID. Phase 5's compound-defect check runs once per cluster
// with more than one confirmed finding, because a compound defect is a
// property of findings that share a place, not of the whole PR. A finding
// whose file belongs to no cluster contributes to none.
func ClusterFindings(clusters []Cluster, findings []Finding) map[string][]Finding {
fileToCluster := make(map[string]string, len(findings))
for _, cluster := range clusters {
for _, file := range cluster.Files {
fileToCluster[file] = cluster.ID
}
}
grouped := make(map[string][]Finding)
for _, f := range findings {
id, ok := fileToCluster[f.File]
if !ok {
continue
}
grouped[id] = append(grouped[id], f)
}
return grouped
}
@@ -0,0 +1,66 @@
package prreview
import "testing"
func TestCoverageGapsFindsUncoveredClustersAndFiles(t *testing.T) {
t.Parallel()
clusters := []Cluster{
{ID: "cluster_0", Name: "internal/a", Files: []string{"internal/a/a.go"}},
{ID: "cluster_1", Name: "internal/b", Files: []string{"internal/b/b.go"}},
}
highExposure := []string{"internal/c/c.go", "internal/d/d.go"}
findings := []Finding{
{File: "internal/a/a.go"},
{File: "internal/d/d.go"},
}
uncoveredClusters, uncoveredFiles := CoverageGaps(clusters, highExposure, findings)
if len(uncoveredClusters) != 1 || uncoveredClusters[0].ID != "cluster_1" {
t.Errorf("uncoveredClusters = %+v, want only cluster_1", uncoveredClusters)
}
if len(uncoveredFiles) != 1 || uncoveredFiles[0] != "internal/c/c.go" {
t.Errorf("uncoveredFiles = %v, want only internal/c/c.go", uncoveredFiles)
}
}
func TestCoverageGapsReportsNothingWhenFullyCovered(t *testing.T) {
t.Parallel()
clusters := []Cluster{{ID: "cluster_0", Files: []string{"a.go"}}}
highExposure := []string{"b.go"}
findings := []Finding{{File: "a.go"}, {File: "b.go"}}
uncoveredClusters, uncoveredFiles := CoverageGaps(clusters, highExposure, findings)
if uncoveredClusters != nil || uncoveredFiles != nil {
t.Errorf("want no gaps, got clusters=%v files=%v", uncoveredClusters, uncoveredFiles)
}
}
func TestClusterFindingsGroupsByFileMembership(t *testing.T) {
t.Parallel()
clusters := []Cluster{
{ID: "cluster_0", Files: []string{"a.go", "a_test.go"}},
{ID: "cluster_1", Files: []string{"b.go"}},
}
findings := []Finding{
{File: "a.go", Title: "f1"},
{File: "a_test.go", Title: "f2"},
{File: "b.go", Title: "f3"},
{File: "unrelated.go", Title: "f4"},
}
grouped := ClusterFindings(clusters, findings)
if len(grouped["cluster_0"]) != 2 {
t.Errorf("cluster_0 findings = %d, want 2", len(grouped["cluster_0"]))
}
if len(grouped["cluster_1"]) != 1 {
t.Errorf("cluster_1 findings = %d, want 1", len(grouped["cluster_1"]))
}
if _, ok := grouped["cluster_2"]; ok {
t.Error("no finding belongs to a cluster_2 that doesn't exist")
}
}
@@ -414,6 +414,26 @@ func CapInlineComments(findings []ScoredFinding) []ScoredFinding {
return findings
}
// IsAIGenerated reports whether intake's machine-written confidence clears
// AIGeneratedThreshold: a coin-flip is not evidence, so it takes strictly
// more than the threshold to count.
func IsAIGenerated(confidence float64) bool {
return confidence > AIGeneratedThreshold
}
// IsHighPriority reports whether a finding's severity is high enough for
// phase 5's evidence verifier to check it against its evidence package: a
// hallucinated nitpick costs a reader little, a hallucinated critical costs
// them a debugging session chasing a defect that was never there.
func IsHighPriority(f Finding) bool {
switch normalizeSeverity(f.Severity) {
case SeverityCritical, SeverityImportant:
return true
default:
return false
}
}
// ReviewEventFor decides the event a review is submitted with: a blocking
// finding requests changes, and anything else -- including a review that found
// nothing -- is a comment. A pipeline that found nothing has said nothing about