refactor: split feedback stats helpers

Separate feedback bucket primitives from threshold scoring so the report builder can evolve bucket shaping and confusion-matrix logic independently.

Made-with: Cursor

Author: haasonsaas

TODO.md

@@ -67,7 +67,7 @@
 - [x] `src/commands/eval/pattern/matching.rs`: split normalized rule-id helpers, matcher predicates, and focused matcher tests.
 - [x] `src/commands/eval/metrics/rules.rs`: separate aggregate math, rule counting, and summary reduction helpers.
 - [x] `src/commands/doctor/endpoint/inference.rs`: split request building, HTTP execution/error handling, and response parsing.
-- [ ] `src/commands/feedback_eval/report/build/stats.rs`: split threshold confusion-matrix scoring from bucket primitives.
+- [x] `src/commands/feedback_eval/report/build/stats.rs`: split threshold confusion-matrix scoring from bucket primitives.
 - [ ] `src/commands/doctor/command/display.rs`: separate header/config output, endpoint listing, and inference result rendering.
 - [ ] `src/commands/doctor/command/run.rs`: separate endpoint discovery, recommendation flow, and test helpers.
 - [ ] `src/commands/eval/runner/matching.rs`: split required-match search, unexpected-match detection, and rule metric assembly.

src/commands/feedback_eval/report/build/stats.rs

@@ -1,101 +1,7 @@
-use std::collections::HashMap;
+#[path = "stats/buckets.rs"]
+mod buckets;
+#[path = "stats/thresholds.rs"]
+mod thresholds;
 
-use super::super::super::{FeedbackEvalBucket, FeedbackEvalComment, FeedbackThresholdMetrics};
-
-pub(super) fn build_threshold_metrics(
-    comments: &[FeedbackEvalComment],
-    confidence_threshold: f32,
-) -> Option<FeedbackThresholdMetrics> {
-    let scored_comments = comments
-        .iter()
-        .filter_map(|comment| comment.confidence.map(|confidence| (comment, confidence)))
-        .collect::<Vec<_>>();
-    if scored_comments.is_empty() {
-        return None;
-    }
-
-    let mut metrics = FeedbackThresholdMetrics {
-        total_scored: scored_comments.len(),
-        ..Default::default()
-    };
-
-    for (comment, confidence) in scored_comments {
-        let predicted_accepted = confidence >= confidence_threshold;
-        match (predicted_accepted, comment.accepted) {
-            (true, true) => metrics.true_positive += 1,
-            (true, false) => metrics.false_positive += 1,
-            (false, false) => metrics.true_negative += 1,
-            (false, true) => metrics.false_negative += 1,
-        }
-    }
-
-    metrics.precision = ratio(
-        metrics.true_positive,
-        metrics.true_positive + metrics.false_positive,
-    );
-    metrics.recall = ratio(
-        metrics.true_positive,
-        metrics.true_positive + metrics.false_negative,
-    );
-    metrics.f1 = harmonic_mean(metrics.precision, metrics.recall);
-    metrics.agreement_rate = ratio(
-        metrics.true_positive + metrics.true_negative,
-        metrics.total_scored,
-    );
-    Some(metrics)
-}
-
-pub(super) fn add_bucket_count(
-    counts: &mut HashMap<String, (usize, usize)>,
-    name: &str,
-    accepted: bool,
-) {
-    let entry = counts.entry(name.to_string()).or_default();
-    if accepted {
-        entry.0 += 1;
-    } else {
-        entry.1 += 1;
-    }
-}
-
-pub(super) fn buckets_from_counts(
-    counts: HashMap<String, (usize, usize)>,
-) -> Vec<FeedbackEvalBucket> {
-    let mut buckets = counts
-        .into_iter()
-        .map(|(name, (accepted, rejected))| build_bucket(name, accepted + rejected, accepted))
-        .collect::<Vec<_>>();
-    buckets.sort_by(|left, right| {
-        right
-            .total
-            .cmp(&left.total)
-            .then_with(|| left.name.cmp(&right.name))
-    });
-    buckets
-}
-
-pub(super) fn build_bucket(name: String, total: usize, accepted: usize) -> FeedbackEvalBucket {
-    FeedbackEvalBucket {
-        name,
-        total,
-        accepted,
-        rejected: total.saturating_sub(accepted),
-        acceptance_rate: ratio(accepted, total),
-    }
-}
-
-pub(super) fn ratio(numerator: usize, denominator: usize) -> f32 {
-    if denominator == 0 {
-        0.0
-    } else {
-        numerator as f32 / denominator as f32
-    }
-}
-
-fn harmonic_mean(left: f32, right: f32) -> f32 {
-    if left + right <= f32::EPSILON {
-        0.0
-    } else {
-        2.0 * left * right / (left + right)
-    }
-}
+pub(super) use buckets::{add_bucket_count, buckets_from_counts, build_bucket, ratio};
+pub(super) use thresholds::build_threshold_metrics;

src/commands/feedback_eval/report/build/stats/buckets.rs

@@ -0,0 +1,74 @@
+use std::collections::HashMap;
+
+use super::super::super::super::FeedbackEvalBucket;
+
+pub(in super::super) fn add_bucket_count(
+    counts: &mut HashMap<String, (usize, usize)>,
+    name: &str,
+    accepted: bool,
+) {
+    let entry = counts.entry(name.to_string()).or_default();
+    if accepted {
+        entry.0 += 1;
+    } else {
+        entry.1 += 1;
+    }
+}
+
+pub(in super::super) fn buckets_from_counts(
+    counts: HashMap<String, (usize, usize)>,
+) -> Vec<FeedbackEvalBucket> {
+    let mut buckets = counts
+        .into_iter()
+        .map(|(name, (accepted, rejected))| build_bucket(name, accepted + rejected, accepted))
+        .collect::<Vec<_>>();
+    buckets.sort_by(|left, right| {
+        right
+            .total
+            .cmp(&left.total)
+            .then_with(|| left.name.cmp(&right.name))
+    });
+    buckets
+}
+
+pub(in super::super) fn build_bucket(
+    name: String,
+    total: usize,
+    accepted: usize,
+) -> FeedbackEvalBucket {
+    FeedbackEvalBucket {
+        name,
+        total,
+        accepted,
+        rejected: total.saturating_sub(accepted),
+        acceptance_rate: ratio(accepted, total),
+    }
+}
+
+pub(in super::super) fn ratio(numerator: usize, denominator: usize) -> f32 {
+    if denominator == 0 {
+        0.0
+    } else {
+        numerator as f32 / denominator as f32
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn buckets_from_counts_orders_by_total_then_name() {
+        let counts = HashMap::from([
+            ("zeta".to_string(), (2, 1)),
+            ("alpha".to_string(), (2, 1)),
+            ("beta".to_string(), (1, 0)),
+        ]);
+
+        let buckets = buckets_from_counts(counts);
+
+        assert_eq!(buckets[0].name, "alpha");
+        assert_eq!(buckets[1].name, "zeta");
+        assert_eq!(buckets[2].name, "beta");
+    }
+}

src/commands/feedback_eval/report/build/stats/thresholds.rs

@@ -0,0 +1,105 @@
+use super::super::super::super::{FeedbackEvalComment, FeedbackThresholdMetrics};
+use super::buckets::ratio;
+
+pub(in super::super) fn build_threshold_metrics(
+    comments: &[FeedbackEvalComment],
+    confidence_threshold: f32,
+) -> Option<FeedbackThresholdMetrics> {
+    let scored_comments = comments
+        .iter()
+        .filter_map(|comment| comment.confidence.map(|confidence| (comment, confidence)))
+        .collect::<Vec<_>>();
+    if scored_comments.is_empty() {
+        return None;
+    }
+
+    let mut metrics = FeedbackThresholdMetrics {
+        total_scored: scored_comments.len(),
+        ..Default::default()
+    };
+
+    for (comment, confidence) in scored_comments {
+        let predicted_accepted = confidence >= confidence_threshold;
+        match (predicted_accepted, comment.accepted) {
+            (true, true) => metrics.true_positive += 1,
+            (true, false) => metrics.false_positive += 1,
+            (false, false) => metrics.true_negative += 1,
+            (false, true) => metrics.false_negative += 1,
+        }
+    }
+
+    metrics.precision = ratio(
+        metrics.true_positive,
+        metrics.true_positive + metrics.false_positive,
+    );
+    metrics.recall = ratio(
+        metrics.true_positive,
+        metrics.true_positive + metrics.false_negative,
+    );
+    metrics.f1 = harmonic_mean(metrics.precision, metrics.recall);
+    metrics.agreement_rate = ratio(
+        metrics.true_positive + metrics.true_negative,
+        metrics.total_scored,
+    );
+    Some(metrics)
+}
+
+fn harmonic_mean(left: f32, right: f32) -> f32 {
+    if left + right <= f32::EPSILON {
+        0.0
+    } else {
+        2.0 * left * right / (left + right)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::path::PathBuf;
+
+    fn build_comment(accepted: bool, confidence: Option<f32>) -> FeedbackEvalComment {
+        FeedbackEvalComment {
+            source_kind: "review-session".to_string(),
+            review_id: Some("review-1".to_string()),
+            repo: Some("owner/repo".to_string()),
+            pr_number: Some(12),
+            title: Some("Fix query path".to_string()),
+            file_path: Some(PathBuf::from("src/lib.rs")),
+            line_number: Some(10),
+            file_patterns: vec!["*.rs".to_string()],
+            content: "User-controlled SQL is interpolated into the query string.".to_string(),
+            category: "Security".to_string(),
+            severity: Some("Warning".to_string()),
+            confidence,
+            accepted,
+        }
+    }
+
+    #[test]
+    fn build_threshold_metrics_scores_confusion_matrix_counts() {
+        let comments = vec![
+            build_comment(true, Some(0.9)),
+            build_comment(false, Some(0.8)),
+            build_comment(false, Some(0.2)),
+            build_comment(true, Some(0.1)),
+        ];
+
+        let metrics = build_threshold_metrics(&comments, 0.5).unwrap();
+
+        assert_eq!(metrics.total_scored, 4);
+        assert_eq!(metrics.true_positive, 1);
+        assert_eq!(metrics.false_positive, 1);
+        assert_eq!(metrics.true_negative, 1);
+        assert_eq!(metrics.false_negative, 1);
+        assert!((metrics.precision - 0.5).abs() < f32::EPSILON);
+        assert!((metrics.recall - 0.5).abs() < f32::EPSILON);
+        assert!((metrics.f1 - 0.5).abs() < f32::EPSILON);
+        assert!((metrics.agreement_rate - 0.5).abs() < f32::EPSILON);
+    }
+
+    #[test]
+    fn build_threshold_metrics_returns_none_without_scored_comments() {
+        let comments = vec![build_comment(true, None)];
+        assert!(build_threshold_metrics(&comments, 0.5).is_none());
+    }
+}