heal-cli 0.4.0

Hook-driven Evaluation & Autonomous Loop — code-health harness CLI for AI coding agents
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

//! `complexity` section — CCN + Cognitive top functions, per file.

use std::io::{self, Write};

use serde_json::json;

use crate::cli::MetricKind;
use crate::commands::metrics::section::{write_section_header, MetricSection, SectionCtx};
use crate::observer::code::complexity::{ComplexityMetric, ComplexityReport};

pub(super) struct ComplexitySection;

impl MetricSection for ComplexitySection {
    fn metric(&self) -> MetricKind {
        MetricKind::Complexity
    }

    fn render_text(&self, ctx: &SectionCtx<'_>, w: &mut dyn Write) -> io::Result<()> {
        let obs = &ctx.reports.complexity_observer;
        let report = &ctx.reports.complexity;
        let top_n = ctx.cfg.metrics.top_n_complexity();
        if !obs.ccn_enabled && !obs.cognitive_enabled {
            return Ok(());
        }
        write_section_header("Complexity", self.metric(), ctx, w)?;
        if report.files.is_empty() {
            writeln!(w, "  no supported source files found")?;
            return Ok(());
        }
        writeln!(
            w,
            "  {} functions across {} files (max CCN={}, max Cognitive={})",
            report.totals.functions,
            report.totals.files,
            report.totals.max_ccn,
            report.totals.max_cognitive,
        )?;
        if obs.ccn_enabled {
            print_top(w, report, "highest CCN", ComplexityMetric::Ccn, top_n)?;
        }
        if obs.cognitive_enabled {
            print_top(
                w,
                report,
                "highest Cognitive",
                ComplexityMetric::Cognitive,
                top_n,
            )?;
        }
        Ok(())
    }

    fn raw_json(&self, ctx: &SectionCtx<'_>) -> serde_json::Value {
        json!(&ctx.reports.complexity)
    }

    fn worst_json(&self, ctx: &SectionCtx<'_>) -> (usize, serde_json::Value) {
        let n = ctx.cfg.metrics.top_n_complexity();
        let ccn = ctx.reports.complexity.worst_n(n, ComplexityMetric::Ccn);
        let cog = ctx
            .reports
            .complexity
            .worst_n(n, ComplexityMetric::Cognitive);
        (n, json!({ "ccn": ccn, "cognitive": cog }))
    }
}

fn print_top(
    w: &mut dyn Write,
    report: &ComplexityReport,
    header: &str,
    metric: ComplexityMetric,
    top_n: usize,
) -> io::Result<()> {
    let top = report.worst_n(top_n, metric);
    if top.is_empty() {
        return Ok(());
    }
    writeln!(w, "  {header}:")?;
    for f in &top {
        let score = match metric {
            ComplexityMetric::Ccn => f.ccn,
            ComplexityMetric::Cognitive => f.cognitive,
        };
        writeln!(
            w,
            "    - {:>3}  {}:{:<4}  {}",
            score,
            f.file.display(),
            f.line,
            f.name,
        )?;
    }
    Ok(())
}