debtmap 0.18.0

Code complexity and technical debt analyzer
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

//! Pattern extraction functions for complexity analysis
//!
//! Provides functions to extract complexity patterns from recommendation text
//! and language-specific data (state machines, coordinators).

use crate::core::LanguageSpecificData;
use crate::io::writers::pattern_display::PATTERN_CONFIDENCE_THRESHOLD;

/// Extract complexity pattern from recommendation text
pub fn extract_complexity_pattern(rationale: &str, action: &str) -> Option<String> {
    // Check for moderate complexity (preventive)
    if action.contains("Maintain current low complexity")
        || action.contains("approaching thresholds")
    {
        return Some("ModerateComplexity".to_string());
    }

    // Check for specific patterns in the rationale
    if rationale.contains("Deep nesting") || rationale.contains("nesting is primary issue") {
        Some("DeepNesting".to_string())
    } else if rationale.contains("Many decision points")
        || rationale.contains("branches) drive cyclomatic")
    {
        Some("HighBranching".to_string())
    } else if rationale.contains("State machine pattern") {
        Some("StateMachine".to_string())
    } else if rationale.contains("High token entropy")
        || rationale.contains("inconsistent structure")
    {
        Some("ChaoticStructure".to_string())
    } else if action.contains("Clean dispatcher pattern") || rationale.contains("dispatcher") {
        Some("Dispatcher".to_string())
    } else if rationale.contains("repetitive validation")
        || rationale.contains("Repetitive validation")
    {
        Some("RepetitiveValidation".to_string())
    } else if rationale.contains("coordinator") || rationale.contains("orchestrat") {
        Some("Coordinator".to_string())
    } else if rationale.contains("nesting and branching") || action.contains("two-phase approach") {
        Some("MixedComplexity".to_string())
    } else {
        None
    }
}

/// Extract pattern data from language-specific information
///
/// Returns (pattern_type, confidence, details) if a pattern is detected with sufficient confidence
pub fn extract_pattern_data(
    language_specific: &Option<LanguageSpecificData>,
) -> (Option<String>, Option<f64>, Option<serde_json::Value>) {
    if let Some(LanguageSpecificData::Rust(rust_data)) = language_specific {
        // Check state machine first (higher priority)
        if let Some(sm_signals) = &rust_data.state_machine_signals
            && sm_signals.confidence >= PATTERN_CONFIDENCE_THRESHOLD
        {
            let details = serde_json::json!({
                "transition_count": sm_signals.transition_count,
                "match_expression_count": sm_signals.match_expression_count,
                "action_dispatch_count": sm_signals.action_dispatch_count,
            });
            return (
                Some("state_machine".to_string()),
                Some(sm_signals.confidence),
                Some(details),
            );
        }

        // Check coordinator second
        if let Some(coord_signals) = &rust_data.coordinator_signals
            && coord_signals.confidence >= PATTERN_CONFIDENCE_THRESHOLD
        {
            let details = serde_json::json!({
                "actions": coord_signals.actions,
                "comparisons": coord_signals.comparisons,
            });
            return (
                Some("coordinator".to_string()),
                Some(coord_signals.confidence),
                Some(details),
            );
        }
    }
    (None, None, None)
}