code-ranker 2.0.0__tar.gz → 3.0.0a1__tar.gz

{code_ranker-2.0.0 → code_ranker-3.0.0a1}/Cargo.lock

@@ -208,7 +208,7 @@ checksum = "c8d4a3bb8b1e0c1050499d1815f5ab16d04f0959b233085fb31653fbfc9d98f9"
 
 [[package]]
 name = "code-ranker"
-version = "2.0.0"
+version = "3.0.0-alpha.1"
 dependencies = [
  "anyhow",
  "chrono",
@@ -231,7 +231,7 @@ dependencies = [
 
 [[package]]
 name = "code-ranker-ecmascript-core"
-version = "2.0.0"
+version = "3.0.0-alpha.1"
 dependencies = [
  "anyhow",
  "code-ranker-graph",
@@ -246,7 +246,7 @@ dependencies = [
 
 [[package]]
 name = "code-ranker-graph"
-version = "2.0.0"
+version = "3.0.0-alpha.1"
 dependencies = [
  "anyhow",
  "chrono",
@@ -257,7 +257,7 @@ dependencies = [
 
 [[package]]
 name = "code-ranker-plugin-api"
-version = "2.0.0"
+version = "3.0.0-alpha.1"
 dependencies = [
  "anyhow",
  "chrono",
@@ -266,7 +266,7 @@ dependencies = [
 
 [[package]]
 name = "code-ranker-plugin-javascript"
-version = "2.0.0"
+version = "3.0.0-alpha.1"
 dependencies = [
  "anyhow",
  "code-ranker-ecmascript-core",
@@ -278,7 +278,7 @@ dependencies = [
 
 [[package]]
 name = "code-ranker-plugin-python"
-version = "2.0.0"
+version = "3.0.0-alpha.1"
 dependencies = [
  "anyhow",
  "code-ranker-graph",
@@ -292,7 +292,7 @@ dependencies = [
 
 [[package]]
 name = "code-ranker-plugin-rust"
-version = "2.0.0"
+version = "3.0.0-alpha.1"
 dependencies = [
  "anyhow",
  "cargo_metadata",
@@ -307,7 +307,7 @@ dependencies = [
 
 [[package]]
 name = "code-ranker-plugin-typescript"
-version = "2.0.0"
+version = "3.0.0-alpha.1"
 dependencies = [
  "anyhow",
  "code-ranker-ecmascript-core",
@@ -319,14 +319,14 @@ dependencies = [
 
 [[package]]
 name = "code-ranker-test-support"
-version = "2.0.0"
+version = "3.0.0-alpha.1"
 dependencies = [
  "code-ranker-plugin-api",
 ]
 
 [[package]]
 name = "code-ranker-viewer"
-version = "2.0.0"
+version = "3.0.0-alpha.1"
 dependencies = [
  "anyhow",
  "code-ranker-graph",

{code_ranker-2.0.0 → code_ranker-3.0.0a1}/Cargo.toml

@@ -3,7 +3,7 @@ members = ["crates/*"]
 resolver = "3"
 
 [workspace.package]
-version = "2.0.0"
+version = "3.0.0-alpha.1"
 edition = "2024"
 rust-version = "1.88"
 license = "Apache-2.0"
@@ -12,14 +12,14 @@ keywords = ["dependency-graph", "coupling", "refactoring", "code-quality", "stat
 categories = ["development-tools", "command-line-utilities"]
 
 [workspace.dependencies]
-code-ranker-graph = { path = "crates/code-ranker-graph", version = "2.0.0" }
-code-ranker-plugin-api = { path = "crates/code-ranker-plugin-api", version = "2.0.0" }
-code-ranker-ecmascript-core = { path = "crates/code-ranker-ecmascript-core", version = "2.0.0" }
-code-ranker-plugin-rust = { path = "crates/code-ranker-plugin-rust", version = "2.0.0" }
-code-ranker-plugin-python = { path = "crates/code-ranker-plugin-python", version = "2.0.0" }
-code-ranker-plugin-javascript = { path = "crates/code-ranker-plugin-javascript", version = "2.0.0" }
-code-ranker-plugin-typescript = { path = "crates/code-ranker-plugin-typescript", version = "2.0.0" }
-code-ranker-viewer = { path = "crates/code-ranker-viewer", version = "2.0.0" }
+code-ranker-graph = { path = "crates/code-ranker-graph", version = "3.0.0-alpha.1" }
+code-ranker-plugin-api = { path = "crates/code-ranker-plugin-api", version = "3.0.0-alpha.1" }
+code-ranker-ecmascript-core = { path = "crates/code-ranker-ecmascript-core", version = "3.0.0-alpha.1" }
+code-ranker-plugin-rust = { path = "crates/code-ranker-plugin-rust", version = "3.0.0-alpha.1" }
+code-ranker-plugin-python = { path = "crates/code-ranker-plugin-python", version = "3.0.0-alpha.1" }
+code-ranker-plugin-javascript = { path = "crates/code-ranker-plugin-javascript", version = "3.0.0-alpha.1" }
+code-ranker-plugin-typescript = { path = "crates/code-ranker-plugin-typescript", version = "3.0.0-alpha.1" }
+code-ranker-viewer = { path = "crates/code-ranker-viewer", version = "3.0.0-alpha.1" }
 
 anyhow = "1.0"
 globset = "0.4"

{code_ranker-2.0.0 → code_ranker-3.0.0a1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-ranker
-Version: 2.0.0
+Version: 3.0.0a1
 Classifier: Development Status :: 3 - Alpha
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers
@@ -41,7 +41,7 @@ Structural-analysis tool for **Rust, Python, JavaScript and TypeScript** codebas
 
 ```sh
 cargo install code-ranker --version 1.1.0   # install the CLI
-code-ranker report .                                # make html report in .code-ranker/ folder
+code-ranker report .                        # make html report in .code-ranker/ folder
 ```
 
 `report .` needs no flags: it writes a self-contained HTML report (plus a JSON

{code_ranker-2.0.0 → code_ranker-3.0.0a1}/README.md

@@ -18,7 +18,7 @@ Structural-analysis tool for **Rust, Python, JavaScript and TypeScript** codebas
 
 ```sh
 cargo install code-ranker --version 1.1.0   # install the CLI
-code-ranker report .                                # make html report in .code-ranker/ folder
+code-ranker report .                        # make html report in .code-ranker/ folder
 ```
 
 `report .` needs no flags: it writes a self-contained HTML report (plus a JSON

{code_ranker-2.0.0 → code_ranker-3.0.0a1}/crates/code-ranker-cli/src/check.rs

@@ -1,6 +1,6 @@
 //! `check` — the linter: evaluate rules (and, with `--baseline`, regressions),
-//! render diagnostics (human / json / github / sarif), and the `--suggest-config`
-//! current-values dump.
+//! render diagnostics (human / json / github / sarif / codequality), and the
+//! `--suggest-config` current-values dump.
 
 use crate::analyze::{analyze_input, load_snapshot_any, project_name};
 use crate::cli::{AnalyzeArgs, OutputFormat};
@@ -136,6 +136,7 @@ fn emit_diagnostics(
             }
         }
         OutputFormat::Sarif => println!("{}", sarif_document(violations)),
+        OutputFormat::Codequality => println!("{}", codequality_document(violations)),
     }
 }
 
@@ -336,7 +337,10 @@ fn group_digits(n: u64) -> String {
 /// Minimal SARIF 2.1.0 document. `ruleId` is the dotted rule id (e.g.
 /// `threshold.file.loc`); the rules that actually fired are described under
 /// `tool.driver.rules` (id, group, rationale, helpUri) so the report is self-documenting.
-fn sarif_document(violations: &[config::Violation]) -> String {
+/// Each result carries a `partialFingerprints` entry keyed on `(rule, location)` (no
+/// line number) so a consumer matches the same finding across runs even when code
+/// shifts — the same identity `check --baseline` uses internally.
+pub(crate) fn sarif_document(violations: &[config::Violation]) -> String {
     // Distinct fired rule ids, first-seen order, so each results.ruleId resolves.
     let mut seen: Vec<&config::Violation> = Vec::new();
     for v in violations {
@@ -367,6 +371,15 @@ fn sarif_document(violations: &[config::Violation]) -> String {
                 "ruleId": v.rule,
                 "level": "error",
                 "message": { "text": v.summary() },
+                // Stable cross-run identity for the consumer (GitHub code scanning,
+                // SARIF viewers): the same `(rule, location)` signature `check
+                // --baseline` matches on internally. The line number is deliberately
+                // excluded, so shifting a finding up/down the file does not reopen it
+                // as "new". The value is the readable composite key (no hashing) — a
+                // metric finding has at most one `(rule, location)`, so it is unique.
+                "partialFingerprints": {
+                    "codeRankerRuleLocation/v1": format!("{}:{}", v.rule, v.location),
+                },
                 "properties": { "group": v.group, "graph": v.graph, "weight": v.weight },
             });
             // A physical location lets GitHub code scanning render the result
@@ -398,6 +411,36 @@ fn sarif_document(violations: &[config::Violation]) -> String {
     serde_json::to_string_pretty(&doc).unwrap_or_else(|_| "{}".into())
 }
 
+/// GitLab **Code Quality** report (the CodeClimate-derived JSON GitLab ingests as
+/// `artifacts:reports:codequality`). A flat array of issues; GitLab renders them
+/// in the MR widget / diff. Each issue carries the dotted rule id as `check_name`,
+/// the human message, a `major` severity, the repo-relative `location.path` +
+/// `lines.begin`, and a stable `fingerprint` keyed on `(rule, location)` — no line
+/// number, so GitLab tracks the same finding across pipelines even when code
+/// shifts (the same identity SARIF and `check --baseline` use). Unlike GitHub
+/// SARIF this needs no feature flag and works on current GitLab.
+pub(crate) fn codequality_document(violations: &[config::Violation]) -> String {
+    let issues: Vec<serde_json::Value> = violations
+        .iter()
+        .map(|v| {
+            serde_json::json!({
+                "description": v.summary(),
+                "check_name": v.rule,
+                // Readable composite identity (no hashing) — a finding has at most
+                // one (rule, location), so it is unique; line excluded so a shift
+                // does not reopen it.
+                "fingerprint": format!("{}:{}", v.rule, v.location),
+                "severity": "major",
+                "location": {
+                    "path": violation_rel_path(&v.location).unwrap_or(v.location.as_str()),
+                    "lines": { "begin": v.line.unwrap_or(1) },
+                },
+            })
+        })
+        .collect();
+    serde_json::to_string_pretty(&issues).unwrap_or_else(|_| "[]".into())
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -454,4 +497,52 @@ mod tests {
         let v: serde_json::Value = serde_json::from_str(&doc).unwrap();
         assert!(v["runs"][0]["results"][0].get("locations").is_none());
     }
+
+    #[test]
+    fn codequality_issue_has_fingerprint_path_and_line() {
+        let doc = codequality_document(&[viol("{target}/src/x.rs", Some(7))]);
+        let v: serde_json::Value = serde_json::from_str(&doc).unwrap();
+        let issue = &v[0];
+        assert_eq!(issue["check_name"], "threshold.file.loc");
+        assert_eq!(issue["severity"], "major");
+        assert_eq!(issue["location"]["path"], "src/x.rs");
+        assert_eq!(issue["location"]["lines"]["begin"], 7);
+        // Stable identity = rule:location, no line (so a shift does not reopen it).
+        assert_eq!(issue["fingerprint"], "threshold.file.loc:{target}/src/x.rs");
+    }
+
+    #[test]
+    fn codequality_whole_file_metric_defaults_line_to_one() {
+        // A whole-file metric has no line → CodeClimate needs one, default 1.
+        let doc = codequality_document(&[viol("{target}/src/x.rs", None)]);
+        let v: serde_json::Value = serde_json::from_str(&doc).unwrap();
+        assert_eq!(v[0]["location"]["lines"]["begin"], 1);
+    }
+
+    #[test]
+    fn sarif_partial_fingerprint_is_rule_and_location() {
+        let doc = sarif_document(&[viol("{target}/src/x.rs", Some(7))]);
+        let v: serde_json::Value = serde_json::from_str(&doc).unwrap();
+        let fp = &v["runs"][0]["results"][0]["partialFingerprints"];
+        assert_eq!(
+            fp["codeRankerRuleLocation/v1"],
+            "threshold.file.loc:{target}/src/x.rs"
+        );
+    }
+
+    #[test]
+    fn sarif_partial_fingerprint_is_stable_across_line_shifts() {
+        // The same finding at a different line keeps the same fingerprint, so a
+        // code shift does not reopen it for the consumer.
+        let at_7 = sarif_document(&[viol("{target}/src/x.rs", Some(7))]);
+        let at_42 = sarif_document(&[viol("{target}/src/x.rs", Some(42))]);
+        let fp = |doc: &str| -> String {
+            let v: serde_json::Value = serde_json::from_str(doc).unwrap();
+            v["runs"][0]["results"][0]["partialFingerprints"]["codeRankerRuleLocation/v1"]
+                .as_str()
+                .unwrap()
+                .to_owned()
+        };
+        assert_eq!(fp(&at_7), fp(&at_42));
+    }
 }

{code_ranker-2.0.0 → code_ranker-3.0.0a1}/crates/code-ranker-cli/src/cli.rs

@@ -23,6 +23,7 @@ pub(crate) enum OutputFormat {
     Json,
     Github,
     Sarif,
+    Codequality,
 }
 
 /// Common input + analysis options shared by `check` and `report`.
@@ -137,6 +138,26 @@ pub(crate) enum Command {
         #[arg(long = "output.html.path", value_name = "PATH")]
         output_html_path: Option<String>,
 
+        /// Emit a SARIF 2.1.0 report of rule violations (path from
+        /// --output.sarif.path / config / default).
+        #[arg(long = "output.sarif")]
+        output_sarif: bool,
+
+        /// SARIF destination: a path or name template, or `stdout`/`-`.
+        /// Placeholders: {project-dir}, {ts}, {git-hash}, {git-hash-N}. Selects SARIF.
+        #[arg(long = "output.sarif.path", value_name = "PATH")]
+        output_sarif_path: Option<String>,
+
+        /// Emit a GitLab Code Quality (CodeClimate) report of rule violations
+        /// (path from --output.codequality.path / config / default).
+        #[arg(long = "output.codequality")]
+        output_codequality: bool,
+
+        /// Code Quality destination: a path or name template, or `stdout`/`-`.
+        /// Placeholders: {project-dir}, {ts}, {git-hash}, {git-hash-N}. Selects it.
+        #[arg(long = "output.codequality.path", value_name = "PATH")]
+        output_codequality_path: Option<String>,
+
         /// Emit the AI prompt for one principle (default to a `…-{preset}.md` file).
         #[arg(long = "output.prompt")]
         output_prompt: bool,

{code_ranker-2.0.0 → code_ranker-3.0.0a1}/crates/code-ranker-cli/src/config/load.rs

@@ -1,7 +1,7 @@
 //! Config loading: discover `code-ranker.toml` (or `Cargo.toml` metadata),
 //! apply inline `KEY=VALUE` and `--cycle-rule` / `--threshold` CLI overrides.
 
-use super::model::{Config, CycleRule, MetricThresholds, parse_number};
+use super::model::{Config, CycleRule, MetricThresholds, parse_number, quote_suffixed_thresholds};
 use anyhow::{Context, Result};
 use code_ranker_plugin_api::log;
 use std::path::Path;
@@ -46,7 +46,8 @@ fn load_file(workspace: &Path, explicit: Option<&Path>) -> Result<(Config, Optio
     if let Some(path) = explicit {
         let text =
             std::fs::read_to_string(path).with_context(|| format!("reading {}", path.display()))?;
-        let cfg = toml::from_str(&text).with_context(|| format!("parsing {}", path.display()))?;
+        let cfg = toml::from_str(&quote_suffixed_thresholds(&text))
+            .with_context(|| format!("parsing {}", path.display()))?;
         return Ok((cfg, Some(path.display().to_string())));
     }
 
@@ -57,7 +58,8 @@ fn load_file(workspace: &Path, explicit: Option<&Path>) -> Result<(Config, Optio
         if p.exists() {
             let text =
                 std::fs::read_to_string(&p).with_context(|| format!("reading {}", p.display()))?;
-            let cfg = toml::from_str(&text).with_context(|| format!("parsing {}", p.display()))?;
+            let cfg = toml::from_str(&quote_suffixed_thresholds(&text))
+                .with_context(|| format!("parsing {}", p.display()))?;
             let canonical = p.canonicalize().unwrap_or(p);
             return Ok((cfg, Some(canonical.display().to_string())));
         }
@@ -79,8 +81,8 @@ fn load_from_cargo_toml(dir: &Path) -> Result<Option<(Config, String)>> {
     }
     let text =
         std::fs::read_to_string(&cargo).with_context(|| format!("reading {}", cargo.display()))?;
-    let val: toml::Value =
-        toml::from_str(&text).with_context(|| format!("parsing {}", cargo.display()))?;
+    let val: toml::Value = toml::from_str(&quote_suffixed_thresholds(&text))
+        .with_context(|| format!("parsing {}", cargo.display()))?;
 
     let section = val
         .get("workspace")
@@ -202,17 +204,13 @@ fn set_threshold(cfg: &mut Config, scope: &str, metric: &str, val: f64) -> Resul
 }
 
 fn set_metric(bucket: &mut MetricThresholds, metric: &str, val: f64) -> Result<()> {
-    match metric {
-        "hk" => bucket.hk = Some(val),
-        "cyclomatic" => bucket.cyclomatic = Some(val),
-        "cognitive" => bucket.cognitive = Some(val),
-        "fan_in" => bucket.fan_in = Some(val),
-        "fan_out" => bucket.fan_out = Some(val),
-        "loc" => bucket.loc = Some(val),
-        other => anyhow::bail!(
-            "unknown metric {other:?}; expected hk|cyclomatic|cognitive|fan_in|fan_out|loc"
-        ),
+    if !super::metrics::is_threshold_metric(metric) {
+        anyhow::bail!(
+            "unknown threshold metric {metric:?}; expected a per-file metric such as \
+             sloc, loc, cyclomatic, cognitive, hk, fan_in, fan_out, mi, volume, bugs"
+        );
     }
+    bucket.set(metric.to_string(), val);
     Ok(())
 }
 
@@ -258,8 +256,8 @@ mod tests {
         .unwrap();
         assert_eq!(cfg.rules.cycles.chain, CycleRule::Max(0));
         assert_eq!(cfg.rules.cycles.mutual, CycleRule::Off);
-        assert_eq!(cfg.rules.thresholds.file.cognitive, Some(25.0));
-        assert_eq!(cfg.rules.thresholds.file.hk, Some(1000.0));
+        assert_eq!(cfg.rules.thresholds.file.get("cognitive"), Some(25.0));
+        assert_eq!(cfg.rules.thresholds.file.get("hk"), Some(1000.0));
     }
 
     #[test]
@@ -278,6 +276,7 @@ mod tests {
                 "output.html.enabled=true",
                 "rules.cycles.chain=7",
                 "rules.thresholds.file.loc=800",
+                "rules.thresholds.file.sloc=1200",
             ],
         )
         .unwrap();
@@ -289,7 +288,8 @@ mod tests {
         assert_eq!(cfg.output.json.enabled, Some(false));
         assert_eq!(cfg.output.html.enabled, Some(true));
         assert_eq!(cfg.rules.cycles.chain, CycleRule::Max(7));
-        assert_eq!(cfg.rules.thresholds.file.loc, Some(800.0));
+        assert_eq!(cfg.rules.thresholds.file.get("loc"), Some(800.0));
+        assert_eq!(cfg.rules.thresholds.file.get("sloc"), Some(1200.0));
     }
 
     #[test]
@@ -320,8 +320,21 @@ mod tests {
     #[test]
     fn set_metric_each_then_unknown() {
         let mut b = MetricThresholds::default();
-        for m in ["hk", "cyclomatic", "cognitive", "fan_in", "fan_out", "loc"] {
+        // The full open vocabulary is accepted — not just the legacy six.
+        for m in [
+            "hk",
+            "cyclomatic",
+            "cognitive",
+            "fan_in",
+            "fan_out",
+            "loc",
+            "sloc",
+            "mi",
+            "bugs",
+            "volume",
+        ] {
             set_metric(&mut b, m, 1.0).unwrap();
+            assert_eq!(b.get(m), Some(1.0));
         }
         assert!(set_metric(&mut b, "bogus", 1.0).is_err());
     }
@@ -331,7 +344,7 @@ mod tests {
         let mut cfg = Config::default();
         assert!(set_threshold(&mut cfg, "function", "loc", 1.0).is_err());
         set_threshold(&mut cfg, "file", "hk", 5.0).unwrap();
-        assert_eq!(cfg.rules.thresholds.file.hk, Some(5.0));
+        assert_eq!(cfg.rules.thresholds.file.get("hk"), Some(5.0));
         assert!(set_cycle(&mut cfg, "weird", CycleRule::Off).is_err());
     }
 

code_ranker-3.0.0a1/crates/code-ranker-cli/src/config/metrics.rs

@@ -0,0 +1,88 @@
+//! The per-file threshold metric vocabulary: every metric that can carry a
+//! `[rules.thresholds.file]` limit, with its concern group and human label.
+//!
+//! This is a **leaf** module — it depends on nothing else in `config`, so both
+//! the data model (`model`, which validates config keys against it) and the rule
+//! catalog (`rules`, which resolves a metric's group through it) can use it
+//! without forming a `model ↔ rules` dependency cycle.
+
+/// A per-file metric that can carry a threshold: its key, the concern `group`
+/// (one of `CPX` / `CPL` / `SIZ`, matching the [`super::rules::RULES`] groups),
+/// and the human `label` used in the breach message. A threshold is a
+/// `value > limit` gate, so this is the whole numeric per-file vocabulary — every
+/// metric the engine emits is accepted, not a hand-picked subset.
+/// `threshold_metrics_cover_engine_specs` (test) guards that this list stays in
+/// sync with the engine's metric specs.
+pub struct ThresholdMetric {
+    pub key: &'static str,
+    pub group: &'static str,
+    pub label: &'static str,
+}
+
+pub const THRESHOLD_METRICS: &[ThresholdMetric] = &[
+    // CPX — control-flow complexity, maintainability, and Halstead effort.
+    tm("cyclomatic", "CPX", "cyclomatic complexity"),
+    tm("cognitive", "CPX", "cognitive complexity"),
+    tm("exits", "CPX", "exit points"),
+    tm("args", "CPX", "argument count"),
+    tm("closures", "CPX", "closure count"),
+    tm("mi", "CPX", "maintainability index"),
+    tm("mi_sei", "CPX", "maintainability index (SEI)"),
+    tm("length", "CPX", "Halstead length"),
+    tm("vocabulary", "CPX", "Halstead vocabulary"),
+    tm("volume", "CPX", "Halstead volume"),
+    tm("effort", "CPX", "Halstead effort"),
+    tm("time", "CPX", "Halstead time"),
+    tm("bugs", "CPX", "Halstead bugs"),
+    tm("unsafe", "CPX", "unsafe blocks"),
+    // SIZ — size.
+    tm("sloc", "SIZ", "source loc"),
+    tm("loc", "SIZ", "source loc"),
+    tm("lloc", "SIZ", "logical loc"),
+    tm("cloc", "SIZ", "comment loc"),
+    tm("blank", "SIZ", "blank lines"),
+    tm("tloc", "SIZ", "test loc"),
+    tm("items", "SIZ", "item count"),
+    // CPL — coupling.
+    tm("fan_in", "CPL", "fan-in"),
+    tm("fan_out", "CPL", "fan-out"),
+    tm("fan_out_external", "CPL", "external fan-out"),
+    tm("hk", "CPL", "Henry-Kafura hk"),
+];
+
+const fn tm(key: &'static str, group: &'static str, label: &'static str) -> ThresholdMetric {
+    ThresholdMetric { key, group, label }
+}
+
+/// The threshold metadata for a metric key, if it is a known per-file metric.
+pub fn threshold_metric(key: &str) -> Option<&'static ThresholdMetric> {
+    THRESHOLD_METRICS.iter().find(|m| m.key == key)
+}
+
+/// Is `key` a metric that can carry a per-file threshold?
+pub fn is_threshold_metric(key: &str) -> bool {
+    threshold_metric(key).is_some()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn threshold_metrics_cover_engine_specs() {
+        // Every numeric per-file metric the engine emits must be thresholdable, so
+        // the config accepts the full vocabulary. `cycle` is a string attribute
+        // (a cycle kind), not a numeric threshold, so it is excluded.
+        let (metrics, _) = code_ranker_graph::metric_specs();
+        let (coupling, _) = code_ranker_graph::coupling_specs();
+        for key in metrics.keys().chain(coupling.keys()) {
+            if key == "cycle" {
+                continue;
+            }
+            assert!(
+                is_threshold_metric(key),
+                "engine metric {key:?} is not in THRESHOLD_METRICS — add it (with a group)"
+            );
+        }
+    }
+}

{code_ranker-2.0.0 → code_ranker-3.0.0a1}/crates/code-ranker-cli/src/config/mod.rs

@@ -6,6 +6,7 @@
 
 pub mod ignore;
 pub mod load;
+pub mod metrics;
 pub mod model;
 pub mod rules;
 pub mod violations;