tldr-cli 0.1.2

CLI binary for TLDR code analysis tool
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

//! Maintainability command - Calculate Maintainability Index
//!
//! Returns MaintainabilityReport with MI scores per file and summary.
//! Auto-routes through daemon when available for ~35x speedup.

use std::path::PathBuf;

use anyhow::Result;
use clap::Args;

use tldr_core::quality::maintainability::{maintainability_index, MaintainabilityReport};
use tldr_core::{detect_or_parse_language, validate_file_path, Language};

use crate::commands::daemon_router::{params_with_path, try_daemon_route};
use crate::output::{format_maintainability_text, OutputFormat, OutputWriter};

/// Calculate Maintainability Index for files
#[derive(Debug, Args)]
pub struct MaintainabilityArgs {
    /// File or directory to analyze
    #[arg(default_value = ".")]
    pub path: PathBuf,

    /// Include detailed Halstead metrics in output
    #[arg(long, short = 'H')]
    pub halstead: bool,

    /// Programming language filter (auto-detect if not specified)
    #[arg(long, short = 'l')]
    pub lang: Option<Language>,
}

impl MaintainabilityArgs {
    /// Run the maintainability command
    pub fn run(&self, format: OutputFormat, quiet: bool) -> Result<()> {
        let writer = OutputWriter::new(format, quiet);

        // Validate path exists (M28: shared validator)
        let validated_path = validate_file_path(
            self.path.to_str().unwrap_or_default(),
            None,
        )?;

        // Try daemon first for cached result
        if let Some(report) = try_daemon_route::<MaintainabilityReport>(
            &validated_path,
            "maintainability",
            params_with_path(Some(&validated_path)),
        ) {
            // Output summary in progress
            writer.progress(&format!(
                "Analyzed {} files, average MI: {:.1} (grade: {})",
                report.summary.files_analyzed,
                report.summary.average_mi,
                grade_from_mi(report.summary.average_mi)
            ));
            if writer.is_text() {
                writer.write_text(&format_maintainability_text(&report))?;
            } else {
                writer.write(&report)?;
            }
            return Ok(());
        }

        // Fallback to direct compute

        // Get language filter if specified
        let language = if let Some(ref lang) = self.lang {
            Some(detect_or_parse_language(
                Some(lang.as_str()),
                &validated_path,
            )?)
        } else {
            None
        };

        writer.progress(&format!(
            "Calculating Maintainability Index for {}...",
            validated_path.display()
        ));

        // Calculate MI
        let report = maintainability_index(&validated_path, self.halstead, language)?;

        // Output summary in progress
        writer.progress(&format!(
            "Analyzed {} files, average MI: {:.1} (grade: {})",
            report.summary.files_analyzed,
            report.summary.average_mi,
            grade_from_mi(report.summary.average_mi)
        ));

        // Output based on format
        if writer.is_text() {
            writer.write_text(&format_maintainability_text(&report))?;
        } else {
            writer.write(&report)?;
        }

        Ok(())
    }
}

/// Get letter grade from MI score
fn grade_from_mi(mi: f64) -> char {
    if mi > 85.0 {
        'A'
    } else if mi > 65.0 {
        'B'
    } else if mi > 45.0 {
        'C'
    } else if mi > 25.0 {
        'D'
    } else {
        'F'
    }
}