kiss/

stats.rs

use crate::graph::DependencyGraph;
use crate::parsing::ParsedFile;
use crate::py_metrics::{compute_class_metrics, compute_file_metrics, compute_function_metrics};
use crate::rust_fn_metrics::{
    compute_rust_file_metrics, compute_rust_function_metrics, count_non_doc_attrs, is_cfg_test_mod,
};
use crate::rust_parsing::ParsedRustFile;
use rayon::prelude::*;
use syn::{ImplItem, Item};
use tree_sitter::Node;

#[derive(Debug, Default)]
pub struct MetricStats {
    pub statements_per_function: Vec<usize>,
    pub arguments_per_function: Vec<usize>,
    pub arguments_positional: Vec<usize>,
    pub arguments_keyword_only: Vec<usize>,
    pub max_indentation: Vec<usize>,
    pub nested_function_depth: Vec<usize>,
    pub returns_per_function: Vec<usize>,
    pub return_values_per_function: Vec<usize>,
    pub branches_per_function: Vec<usize>,
    pub local_variables_per_function: Vec<usize>,
    pub statements_per_try_block: Vec<usize>,
    pub boolean_parameters: Vec<usize>,
    pub annotations_per_function: Vec<usize>,
    pub calls_per_function: Vec<usize>,
    pub methods_per_class: Vec<usize>,
    pub statements_per_file: Vec<usize>,
    pub lines_per_file: Vec<usize>,
    pub functions_per_file: Vec<usize>,
    pub interface_types_per_file: Vec<usize>,
    pub concrete_types_per_file: Vec<usize>,
    pub imported_names_per_file: Vec<usize>,
    pub fan_in: Vec<usize>,
    pub fan_out: Vec<usize>,
    pub cycle_size: Vec<usize>,
    pub indirect_dependencies: Vec<usize>,
    pub dependency_depth: Vec<usize>,
}

impl MetricStats {
    pub fn collect(parsed_files: &[&ParsedFile]) -> Self {
        // This is the hot path for `kiss stats`: per-file tree walks and per-function metric
        // extraction. Parallelize at the file level and merge the per-thread aggregates.
        parsed_files
            .par_iter()
            .map(|parsed| {
                let mut stats = Self::default();
                let fm = compute_file_metrics(parsed);
                stats.statements_per_file.push(fm.statements);
                stats.lines_per_file.push(parsed.source.lines().count());
                stats.functions_per_file.push(fm.functions);
                stats.interface_types_per_file.push(fm.interface_types);
                stats.concrete_types_per_file.push(fm.concrete_types);
                stats.imported_names_per_file.push(fm.imports);
                collect_from_node(parsed.tree.root_node(), &parsed.source, &mut stats, false);
                stats
            })
            .reduce(Self::default, |mut a, b| {
                a.merge(b);
                a
            })
    }

    pub fn merge(&mut self, o: Self) {
        macro_rules! ext { ($($f:ident),*) => { $(self.$f.extend(o.$f);)* }; }
        ext!(
            statements_per_function,
            arguments_per_function,
            arguments_positional,
            arguments_keyword_only,
            max_indentation,
            nested_function_depth,
            returns_per_function,
            return_values_per_function,
            branches_per_function,
            local_variables_per_function,
            statements_per_try_block,
            boolean_parameters,
            annotations_per_function,
            calls_per_function,
            methods_per_class,
            statements_per_file,
            lines_per_file,
            functions_per_file,
            interface_types_per_file,
            concrete_types_per_file,
            imported_names_per_file,
            fan_in,
            fan_out,
            cycle_size,
            indirect_dependencies,
            dependency_depth
        );
    }

    pub fn collect_graph_metrics(&mut self, graph: &DependencyGraph) {
        use std::collections::HashMap;

        let cycles = graph.find_cycles().cycles;
        let mut cycle_size_by_module: HashMap<&str, usize> = HashMap::new();
        for cycle in &cycles {
            let size = cycle.len();
            for m in cycle {
                cycle_size_by_module.insert(m.as_str(), size);
            }
        }

        // Only include internal modules (those with a known path). External imports create nodes
        // but should not skew per-module distributions in `stats`.
        for name in graph.paths.keys() {
            let m = graph.module_metrics(name);
            self.fan_in.push(m.fan_in);
            self.fan_out.push(m.fan_out);
            self.indirect_dependencies.push(m.indirect_dependencies);
            self.dependency_depth.push(m.dependency_depth);
            self.cycle_size
                .push(*cycle_size_by_module.get(name.as_str()).unwrap_or(&0));
        }
    }

    pub fn max_depth(&self) -> usize {
        self.dependency_depth.iter().copied().max().unwrap_or(0)
    }

    pub fn collect_rust(parsed_files: &[&ParsedRustFile]) -> Self {
        let mut stats = Self::default();
        for parsed in parsed_files {
            let fm = compute_rust_file_metrics(parsed);
            stats.statements_per_file.push(fm.statements);
            stats.lines_per_file.push(parsed.source.lines().count());
            stats.functions_per_file.push(fm.functions);
            stats.interface_types_per_file.push(fm.interface_types);
            stats.concrete_types_per_file.push(fm.concrete_types);
            stats.imported_names_per_file.push(fm.imports);
            collect_rust_from_items(&parsed.ast.items, &mut stats);
        }
        stats
    }
}

// inside_class tracks context for method counting; passed through recursion to nested scopes
#[allow(clippy::only_used_in_recursion)]
fn collect_from_node(node: Node, source: &str, stats: &mut MetricStats, inside_class: bool) {
    match node.kind() {
        "function_definition" | "async_function_definition" => {
            let m = compute_function_metrics(node, source);
            if !m.has_error {
                push_py_fn_metrics(stats, &m);
            }
            let mut c = node.walk();
            for child in node.children(&mut c) {
                collect_from_node(child, source, stats, false);
            }
        }
        "class_definition" => {
            let m = compute_class_metrics(node);
            stats.methods_per_class.push(m.methods);
            let mut c = node.walk();
            for child in node.children(&mut c) {
                collect_from_node(child, source, stats, true);
            }
        }
        _ => {
            let mut c = node.walk();
            for child in node.children(&mut c) {
                collect_from_node(child, source, stats, inside_class);
            }
        }
    }
}

fn push_py_fn_metrics(stats: &mut MetricStats, m: &crate::py_metrics::FunctionMetrics) {
    stats.statements_per_function.push(m.statements);
    stats.arguments_per_function.push(m.arguments);
    stats.arguments_positional.push(m.arguments_positional);
    stats.arguments_keyword_only.push(m.arguments_keyword_only);
    stats.max_indentation.push(m.max_indentation);
    stats.nested_function_depth.push(m.nested_function_depth);
    stats.returns_per_function.push(m.returns);
    stats.return_values_per_function.push(m.max_return_values);
    stats.branches_per_function.push(m.branches);
    stats.local_variables_per_function.push(m.local_variables);
    stats
        .statements_per_try_block
        .push(m.max_try_block_statements);
    stats.boolean_parameters.push(m.boolean_parameters);
    stats.annotations_per_function.push(m.decorators);
    stats.calls_per_function.push(m.calls);
}

fn push_rust_fn_metrics(stats: &mut MetricStats, m: &crate::rust_counts::RustFunctionMetrics) {
    stats.statements_per_function.push(m.statements);
    stats.arguments_per_function.push(m.arguments);
    // N/A: Rust has no positional/keyword distinction; don't push to avoid skewing distributions
    stats.max_indentation.push(m.max_indentation);
    stats.nested_function_depth.push(m.nested_function_depth);
    stats.returns_per_function.push(m.returns);
    // N/A: Rust doesn't have multiple-return-value tuples in the same sense as Python
    stats.branches_per_function.push(m.branches);
    stats.local_variables_per_function.push(m.local_variables);
    // N/A: try-block size is Python-only; don't push to avoid skewing distributions
    stats.boolean_parameters.push(m.bool_parameters);
    stats.annotations_per_function.push(m.attributes);
    stats.calls_per_function.push(m.calls);
}

fn collect_rust_from_items(items: &[Item], stats: &mut MetricStats) {
    for item in items {
        match item {
            Item::Fn(f) => push_rust_fn_metrics(
                stats,
                &compute_rust_function_metrics(
                    &f.sig.inputs,
                    &f.block,
                    count_non_doc_attrs(&f.attrs),
                ),
            ),
            Item::Impl(i) => {
                let mcnt = i
                    .items
                    .iter()
                    .filter(|ii| matches!(ii, ImplItem::Fn(_)))
                    .count();
                stats.methods_per_class.push(mcnt);
                for ii in &i.items {
                    if let ImplItem::Fn(m) = ii {
                        push_rust_fn_metrics(
                            stats,
                            &compute_rust_function_metrics(
                                &m.sig.inputs,
                                &m.block,
                                count_non_doc_attrs(&m.attrs),
                            ),
                        );
                    }
                }
            }
            Item::Mod(m) => {
                if !is_cfg_test_mod(m)
                    && let Some((_, items)) = &m.content
                {
                    collect_rust_from_items(items, stats);
                }
            }
            _ => {}
        }
    }
}

#[allow(
    clippy::cast_precision_loss,
    clippy::cast_possible_truncation,
    clippy::cast_sign_loss
)]
pub fn percentile(sorted: &[usize], p: f64) -> usize {
    if sorted.is_empty() {
        return 0;
    }
    let len = sorted.len();
    let idx_f = (len.saturating_sub(1) as f64) * p / 100.0;
    let idx = idx_f.round().max(0.0) as usize;
    sorted[idx.min(len - 1)]
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum MetricScope {
    Function,
    Type,
    File,
    Module,
}

#[derive(Debug, Clone, Copy)]
pub struct MetricDef {
    pub metric_id: &'static str,
    pub scope: MetricScope,
}

/// Central registry of all metrics with stable IDs
pub const METRICS: &[MetricDef] = &[
    MetricDef {
        metric_id: "statements_per_function",
        scope: MetricScope::Function,
    },
    MetricDef {
        metric_id: "arguments_per_function",
        scope: MetricScope::Function,
    },
    MetricDef {
        metric_id: "positional_args",
        scope: MetricScope::Function,
    },
    MetricDef {
        metric_id: "keyword_only_args",
        scope: MetricScope::Function,
    },
    MetricDef {
        metric_id: "max_indentation_depth",
        scope: MetricScope::Function,
    },
    MetricDef {
        metric_id: "nested_function_depth",
        scope: MetricScope::Function,
    },
    MetricDef {
        metric_id: "returns_per_function",
        scope: MetricScope::Function,
    },
    MetricDef {
        metric_id: "return_values_per_function",
        scope: MetricScope::Function,
    },
    MetricDef {
        metric_id: "branches_per_function",
        scope: MetricScope::Function,
    },
    MetricDef {
        metric_id: "local_variables_per_function",
        scope: MetricScope::Function,
    },
    MetricDef {
        metric_id: "statements_per_try_block",
        scope: MetricScope::Function,
    },
    MetricDef {
        metric_id: "boolean_parameters",
        scope: MetricScope::Function,
    },
    MetricDef {
        metric_id: "annotations_per_function",
        scope: MetricScope::Function,
    },
    MetricDef {
        metric_id: "calls_per_function",
        scope: MetricScope::Function,
    },
    MetricDef {
        metric_id: "methods_per_class",
        scope: MetricScope::Type,
    },
    MetricDef {
        metric_id: "statements_per_file",
        scope: MetricScope::File,
    },
    MetricDef {
        metric_id: "lines_per_file",
        scope: MetricScope::File,
    },
    MetricDef {
        metric_id: "functions_per_file",
        scope: MetricScope::File,
    },
    MetricDef {
        metric_id: "interface_types_per_file",
        scope: MetricScope::File,
    },
    MetricDef {
        metric_id: "concrete_types_per_file",
        scope: MetricScope::File,
    },
    MetricDef {
        metric_id: "imported_names_per_file",
        scope: MetricScope::File,
    },
    MetricDef {
        metric_id: "fan_in",
        scope: MetricScope::Module,
    },
    MetricDef {
        metric_id: "fan_out",
        scope: MetricScope::Module,
    },
    MetricDef {
        metric_id: "cycle_size",
        scope: MetricScope::Module,
    },
    MetricDef {
        metric_id: "indirect_dependencies",
        scope: MetricScope::Module,
    },
    MetricDef {
        metric_id: "dependency_depth",
        scope: MetricScope::Module,
    },
];

pub fn get_metric_def(metric_id: &str) -> Option<&'static MetricDef> {
    METRICS.iter().find(|m| m.metric_id == metric_id)
}

#[derive(Debug)]
pub struct PercentileSummary {
    pub metric_id: &'static str,
    pub count: usize,
    pub p50: usize,
    pub p90: usize,
    pub p95: usize,
    pub p99: usize,
    pub max: usize,
}

impl PercentileSummary {
    pub fn from_values(metric_id: &'static str, values: &[usize]) -> Self {
        if values.is_empty() {
            return Self {
                metric_id,
                count: 0,
                p50: 0,
                p90: 0,
                p95: 0,
                p99: 0,
                max: 0,
            };
        }
        let mut sorted = values.to_vec();
        sorted.sort_unstable();
        Self {
            metric_id,
            count: sorted.len(),
            p50: percentile(&sorted, 50.0),
            p90: percentile(&sorted, 90.0),
            p95: percentile(&sorted, 95.0),
            p99: percentile(&sorted, 99.0),
            max: *sorted.last().unwrap_or(&0),
        }
    }
}

fn metric_values<'a>(stats: &'a MetricStats, metric_id: &str) -> Option<&'a [usize]> {
    Some(match metric_id {
        "statements_per_function" => &stats.statements_per_function,
        "arguments_per_function" => &stats.arguments_per_function,
        "positional_args" => &stats.arguments_positional,
        "keyword_only_args" => &stats.arguments_keyword_only,
        "max_indentation_depth" => &stats.max_indentation,
        "nested_function_depth" => &stats.nested_function_depth,
        "returns_per_function" => &stats.returns_per_function,
        "return_values_per_function" => &stats.return_values_per_function,
        "branches_per_function" => &stats.branches_per_function,
        "local_variables_per_function" => &stats.local_variables_per_function,
        "statements_per_try_block" => &stats.statements_per_try_block,
        "boolean_parameters" => &stats.boolean_parameters,
        "annotations_per_function" => &stats.annotations_per_function,
        "calls_per_function" => &stats.calls_per_function,
        "methods_per_class" => &stats.methods_per_class,
        "statements_per_file" => &stats.statements_per_file,
        "lines_per_file" => &stats.lines_per_file,
        "functions_per_file" => &stats.functions_per_file,
        "interface_types_per_file" => &stats.interface_types_per_file,
        "concrete_types_per_file" => &stats.concrete_types_per_file,
        "imported_names_per_file" => &stats.imported_names_per_file,
        "fan_in" => &stats.fan_in,
        "fan_out" => &stats.fan_out,
        "cycle_size" => &stats.cycle_size,
        "indirect_dependencies" => &stats.indirect_dependencies,
        "dependency_depth" => &stats.dependency_depth,
        _ => return None,
    })
}

pub fn compute_summaries(stats: &MetricStats) -> Vec<PercentileSummary> {
    METRICS
        .iter()
        .filter_map(|m| {
            let values = metric_values(stats, m.metric_id)?;
            if values.is_empty() {
                None
            } else {
                Some(PercentileSummary::from_values(m.metric_id, values))
            }
        })
        .collect()
}

pub fn format_stats_table(summaries: &[PercentileSummary]) -> String {
    use std::fmt::Write;
    let header = format!(
        "{:<28} {:>5} {:>5} {:>5} {:>5} {:>5} {:>5}",
        "metric_id", "N", "p50", "p90", "p95", "p99", "max"
    );
    let mut out = header;
    out.push('\n');
    out.push_str(&"-".repeat(out.trim_end_matches('\n').len()));
    out.push('\n');
    for s in summaries.iter().filter(|s| s.count > 0) {
        let _ = writeln!(
            out,
            "{:<28} {:>5} {:>5} {:>5} {:>5} {:>5} {:>5}",
            s.metric_id, s.count, s.p50, s.p90, s.p95, s.p99, s.max
        );
    }
    out
}

/// Map `metric_id` to config key (some metrics use different config key names)
fn config_key_for(metric_id: &str) -> Option<&'static str> {
    Some(match metric_id {
        "statements_per_function" => "statements_per_function",
        "arguments_per_function" => "arguments_per_function",
        "positional_args" => "arguments_positional",
        "keyword_only_args" => "arguments_keyword_only",
        "max_indentation_depth" => "max_indentation_depth",
        "nested_function_depth" => "nested_function_depth",
        "returns_per_function" => "returns_per_function",
        "return_values_per_function" => "return_values_per_function",
        "branches_per_function" => "branches_per_function",
        "local_variables_per_function" => "local_variables_per_function",
        "statements_per_try_block" => "statements_per_try_block",
        "boolean_parameters" => "boolean_parameters",
        "annotations_per_function" => "annotations_per_function",
        "calls_per_function" => "calls_per_function",
        "methods_per_class" => "methods_per_class",
        "statements_per_file" => "statements_per_file",
        "lines_per_file" => "lines_per_file",
        "functions_per_file" => "functions_per_file",
        "interface_types_per_file" => "interface_types_per_file",
        "concrete_types_per_file" => "concrete_types_per_file",
        "imported_names_per_file" => "imported_names_per_file",
        "fan_in" => "fan_in",
        "fan_out" => "fan_out",
        "cycle_size" => "cycle_size",
        "indirect_dependencies" => "indirect_dependencies",
        "dependency_depth" => "dependency_depth",
        _ => return None,
    })
}

pub fn generate_config_toml(summaries: &[PercentileSummary]) -> String {
    use std::fmt::Write;
    let mut out = String::from(
        "# Generated by kiss mimic\n# Thresholds based on 99th percentile\n\n[thresholds]\n",
    );
    for s in summaries {
        if let Some(k) = config_key_for(s.metric_id) {
            let _ = writeln!(out, "{k} = {}", s.p99);
        }
    }
    out
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::parsing::{create_parser, parse_file};
    use crate::rust_parsing::parse_rust_file;
    use std::io::Write;

    #[test]
    fn test_stats_helpers() {
        assert_eq!(percentile(&[], 50.0), 0);
        assert_eq!(percentile(&[42], 50.0), 42);
        let s = PercentileSummary::from_values("test_id", &[]);
        assert_eq!(s.count, 0);
        let vals: Vec<usize> = (1..=100).collect();
        assert_eq!(PercentileSummary::from_values("test_id", &vals).max, 100);
        let mut a = MetricStats::default();
        a.statements_per_function.push(5);
        let mut b = MetricStats::default();
        b.statements_per_function.push(10);
        a.merge(b);
        assert_eq!(a.statements_per_function.len(), 2);
        let s2 = MetricStats {
            statements_per_function: vec![1, 2, 3],
            ..Default::default()
        };
        assert!(!compute_summaries(&s2).is_empty());
        let toml = generate_config_toml(&[PercentileSummary {
            metric_id: "statements_per_function",
            count: 10,
            p50: 5,
            p90: 9,
            p95: 10,
            p99: 15,
            max: 20,
        }]);
        assert!(toml.contains("statements_per_function = 15"));
        assert_eq!(
            config_key_for("statements_per_function"),
            Some("statements_per_function")
        );
        assert!(
            format_stats_table(&[PercentileSummary {
                metric_id: "test_id",
                count: 10,
                p50: 5,
                p90: 8,
                p95: 9,
                p99: 10,
                max: 12
            }])
            .contains("test_id")
        );
    }

    #[test]
    fn test_metric_registry() {
        assert!(get_metric_def("statements_per_function").is_some());
        assert!(get_metric_def("fan_in").is_some());
        assert!(get_metric_def("nonexistent").is_none());
        assert_eq!(
            get_metric_def("statements_per_function").unwrap().scope,
            MetricScope::Function
        );
        assert_eq!(get_metric_def("fan_in").unwrap().scope, MetricScope::Module);
        assert!(METRICS.len() > 20); // Verify we have a reasonable number of metrics
        // Test MetricDef struct fields
        let def = MetricDef {
            metric_id: "test",
            scope: MetricScope::Function,
        };
        assert_eq!(def.metric_id, "test");
    }

    #[test]
    fn test_push_py_fn_metrics() {
        let mut stats = MetricStats::default();
        let m = crate::py_metrics::FunctionMetrics {
            statements: 3,
            arguments: 2,
            has_error: false,
            ..Default::default()
        };
        push_py_fn_metrics(&mut stats, &m);
        assert_eq!(stats.statements_per_function, vec![3]);
        assert_eq!(stats.arguments_per_function, vec![2]);
    }

    #[test]
    fn test_collection() {
        let mut stats = MetricStats::default();
        let mut tmp_rs = tempfile::NamedTempFile::with_suffix(".rs").unwrap();
        write!(tmp_rs, "fn foo() {{ let x = 1; }}").unwrap();
        let parsed_rs = parse_rust_file(tmp_rs.path()).unwrap();
        assert!(
            !MetricStats::collect_rust(&[&parsed_rs])
                .statements_per_file
                .is_empty()
        );
        let mut tmp_py = tempfile::NamedTempFile::with_suffix(".py").unwrap();
        write!(tmp_py, "def foo():\n    x = 1").unwrap();
        let parsed_py = parse_file(&mut create_parser().unwrap(), tmp_py.path()).unwrap();
        let mut stats2 = MetricStats::default();
        collect_from_node(
            parsed_py.tree.root_node(),
            &parsed_py.source,
            &mut stats2,
            false,
        );
        assert!(!stats2.statements_per_function.is_empty());
        let m = crate::rust_counts::RustFunctionMetrics {
            statements: 5,
            arguments: 2,
            max_indentation: 1,
            nested_function_depth: 0,
            returns: 1,
            branches: 0,
            local_variables: 2,
            bool_parameters: 0,
            attributes: 0,
            calls: 3,
        };
        push_rust_fn_metrics(&mut stats, &m);
        let ast: syn::File = syn::parse_str("fn bar() { let y = 2; }").unwrap();
        collect_rust_from_items(&ast.items, &mut stats);
    }

    #[test]
    fn test_graph_metrics() {
        let mut stats = MetricStats::default();
        let mut graph = crate::graph::DependencyGraph::new();
        graph.add_dependency("a", "b");
        graph.add_dependency("b", "c");
        graph
            .paths
            .insert("a".into(), std::path::PathBuf::from("a.py"));
        graph
            .paths
            .insert("b".into(), std::path::PathBuf::from("b.py"));
        graph
            .paths
            .insert("c".into(), std::path::PathBuf::from("c.py"));
        stats.collect_graph_metrics(&graph);
        assert!(!stats.fan_in.is_empty());
        assert!(!stats.fan_out.is_empty());
        assert!(!stats.indirect_dependencies.is_empty());
        assert!(!stats.dependency_depth.is_empty());
        assert!(stats.max_depth() > 0);
    }

    #[test]
    fn test_graph_metrics_exclude_external_nodes_from_distributions() {
        // Regression: `stats` distributions should only include internal modules (those with paths).
        let mut stats = MetricStats::default();
        let mut graph = crate::graph::DependencyGraph::new();

        // Internal module a imports an external node "os".
        graph.get_or_create_node("a");
        graph
            .paths
            .insert("a".into(), std::path::PathBuf::from("a.py"));
        graph.add_dependency("a", "os");

        stats.collect_graph_metrics(&graph);
        assert_eq!(
            stats.fan_out.len(),
            1,
            "fan_out should only include internal modules"
        );
        assert_eq!(
            stats.fan_out[0], 1,
            "a should have one outgoing edge (to external os)"
        );
    }

    #[test]
    fn test_cycle_size_is_per_module_distribution() {
        // Regression guard: module-scoped metrics should collect one value per module.
        // `cycle_size` should behave like fan_in/fan_out: for modules in a cycle, record the size
        // of their cycle (SCC); for modules not in any cycle, record 0.
        let mut stats = MetricStats::default();
        let mut graph = crate::graph::DependencyGraph::new();

        // a <-> b forms a 2-module cycle; c is acyclic.
        graph.add_dependency("a", "b");
        graph.add_dependency("b", "a");
        graph.get_or_create_node("c");
        graph
            .paths
            .insert("a".into(), std::path::PathBuf::from("a.py"));
        graph
            .paths
            .insert("b".into(), std::path::PathBuf::from("b.py"));
        graph
            .paths
            .insert("c".into(), std::path::PathBuf::from("c.py"));

        stats.collect_graph_metrics(&graph);

        assert_eq!(
            stats.cycle_size.len(),
            graph.paths.len(),
            "Expected cycle_size to have one entry per internal module (got {:?} for {} modules)",
            stats.cycle_size,
            graph.paths.len()
        );

        let mut got = stats.cycle_size.clone();
        got.sort_unstable();
        assert_eq!(
            got,
            vec![0, 2, 2],
            "Expected modules in the cycle to record 2, and the acyclic module to record 0"
        );
    }

    // === Bug-hunting tests ===

    #[test]
    fn test_generate_config_toml_includes_boolean_parameters() {
        // generate_config_toml should include newer metrics like boolean_parameters
        let summaries = vec![PercentileSummary {
            metric_id: "boolean_parameters",
            count: 10,
            p50: 0,
            p90: 1,
            p95: 1,
            p99: 2,
            max: 3,
        }];
        let toml = generate_config_toml(&summaries);
        assert!(
            toml.contains("boolean_parameters"),
            "Generated config should include boolean_parameters threshold"
        );
    }

    #[test]
    fn test_metric_values() {
        let mut stats = MetricStats::default();
        stats.statements_per_function.push(10);
        stats.arguments_per_function.push(3);
        stats.fan_in.push(2);
        assert_eq!(
            super::metric_values(&stats, "statements_per_function"),
            Some(&[10][..])
        );
        assert_eq!(
            super::metric_values(&stats, "arguments_per_function"),
            Some(&[3][..])
        );
        assert_eq!(super::metric_values(&stats, "fan_in"), Some(&[2][..]));
        assert_eq!(super::metric_values(&stats, "unknown_metric"), None);
    }
}