codesearch 0.1.9

A fast, intelligent CLI tool with multiple search modes (regex, fuzzy, semantic), code analysis, and dead code detection for popular programming languages
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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

//! Design Metrics Reporting
//!
//! Functions for displaying design metrics analysis results.

use super::types::DesignMetrics;
use colored::*;

pub fn print_design_metrics(metrics: &DesignMetrics, detailed: bool) {
    println!("\n{}", "Design Metrics Analysis".cyan().bold());
    println!("{}", "=".repeat(60).cyan());

    println!("\n{}", "Overall Statistics:".green().bold());
    println!("  Total modules: {}", metrics.overall_stats.total_modules);
    println!(
        "  Average afferent coupling (Ca): {:.2}",
        metrics.overall_stats.avg_afferent_coupling
    );
    println!(
        "  Average efferent coupling (Ce): {:.2}",
        metrics.overall_stats.avg_efferent_coupling
    );
    println!(
        "  Average instability (I): {:.2}",
        metrics.overall_stats.avg_instability
    );
    println!(
        "  Average cohesion: {:.2}",
        metrics.overall_stats.avg_cohesion
    );

    if !metrics.overall_stats.highly_coupled_modules.is_empty() {
        println!("\n{}", "⚠️  Highly Coupled Modules:".yellow().bold());
        for module in &metrics.overall_stats.highly_coupled_modules {
            println!("  - {}", module);
        }
    }

    if !metrics.overall_stats.unstable_modules.is_empty() {
        println!("\n{}", "⚠️  Unstable Modules (I > 0.7):".yellow().bold());
        for module in &metrics.overall_stats.unstable_modules {
            if let Some(m) = metrics.modules.get(module) {
                println!("  - {} (I = {:.2})", module, m.instability);
            }
        }
    }

    if !metrics.overall_stats.low_cohesion_modules.is_empty() {
        println!("\n{}", "⚠️  Low Cohesion Modules:".yellow().bold());
        for module in &metrics.overall_stats.low_cohesion_modules {
            if let Some(m) = metrics.modules.get(module) {
                println!("  - {} (cohesion = {:.2})", module, m.cohesion);
            }
        }
    }

    let critical = metrics.get_critical_modules();
    if !critical.is_empty() {
        println!("\n{}", "🔴 Critical Modules (Ca > 5):".red().bold());
        for module in &critical {
            if let Some(m) = metrics.modules.get(module) {
                println!("  - {} (Ca = {})", module, m.afferent_coupling);
            }
        }
    }

    let stable = metrics.get_stable_modules();
    if !stable.is_empty() {
        println!("\n{}", "✅ Stable Modules (I < 0.3):".green().bold());
        for module in &stable {
            if let Some(m) = metrics.modules.get(module) {
                println!("  - {} (I = {:.2})", module, m.instability);
            }
        }
    }

    if detailed {
        println!("\n{}", "Detailed Module Metrics:".cyan().bold());
        println!("{}", "=".repeat(60).cyan());

        let mut modules: Vec<_> = metrics.modules.values().collect();
        modules.sort_by(|a, b| b.afferent_coupling.cmp(&a.afferent_coupling));

        for module in modules {
            println!(
                "\n{}",
                format!("Module: {}", module.module_name).green().bold()
            );
            println!("  File: {}", module.file_path);
            println!(
                "  Afferent Coupling (Ca): {} modules depend on this",
                module.afferent_coupling
            );
            println!(
                "  Efferent Coupling (Ce): {} dependencies",
                module.efferent_coupling
            );
            println!("  Instability (I): {:.2}", module.instability);
            println!("  Abstractness (A): {:.2}", module.abstractness);
            println!("  Distance from Main: {:.2}", module.distance_from_main);
            println!("  Cohesion: {:.2}", module.cohesion);

            if !module.dependents.is_empty() {
                println!("  Dependents: {}", module.dependents.join(", "));
            }

            if !module.dependencies.is_empty() {
                println!("  Dependencies: {}", module.dependencies.join(", "));
            }

            if !module.classes.is_empty() {
                println!("  Classes:");
                for class in &module.classes {
                    println!(
                        "    - {} (LCOM: {:.2}, methods: {}, fields: {})",
                        class.class_name,
                        class.lcom,
                        class.methods.len(),
                        class.fields.len()
                    );
                }
            }
        }
    }
}