debtmap 0.21.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
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
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291

use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct LanguagesConfig {
    pub enabled: Vec<String>,

    /// Rust-specific configuration
    #[serde(default)]
    pub rust: Option<LanguageFeatures>,

    /// Python-specific configuration
    #[serde(default)]
    pub python: Option<LanguageFeatures>,

    /// JavaScript-specific configuration
    #[serde(default)]
    pub javascript: Option<LanguageFeatures>,

    /// TypeScript-specific configuration
    #[serde(default)]
    pub typescript: Option<LanguageFeatures>,

    /// Go-specific configuration
    #[serde(default)]
    pub go: Option<GoLanguageConfig>,

    /// Solidity-specific configuration
    #[serde(default)]
    pub solidity: Option<SolidityLanguageConfig>,
}

/// Language-specific feature configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct LanguageFeatures {
    /// Whether to detect dead code for this language
    #[serde(default = "default_detect_dead_code")]
    pub detect_dead_code: bool,

    /// Whether to detect complexity issues for this language
    #[serde(default = "default_detect_complexity")]
    pub detect_complexity: bool,

    /// Whether to detect duplication for this language
    #[serde(default = "default_detect_duplication")]
    pub detect_duplication: bool,
}

/// Go-specific language configuration.
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct GoLanguageConfig {
    #[serde(flatten)]
    pub features: LanguageFeatures,

    /// How generated Go files should be handled.
    #[serde(default)]
    pub generated_code: GeneratedCodeMode,
}

/// Solidity security pattern toggles.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SoliditySecurityConfig {
    #[serde(default = "default_true")]
    pub tx_origin: bool,
    #[serde(default = "default_true")]
    pub reentrancy_heuristic: bool,
    #[serde(default = "default_true")]
    pub unchecked_calls: bool,
    #[serde(default = "default_true")]
    pub delegatecall: bool,
    #[serde(default = "default_true")]
    pub selfdestruct: bool,
    #[serde(default = "default_true")]
    pub assembly_blocks: bool,
    #[serde(default = "default_true")]
    pub unbounded_loops: bool,
    #[serde(default = "default_true")]
    pub missing_access_control: bool,
    #[serde(default = "default_true")]
    pub hardcoded_addresses: bool,
    #[serde(default = "default_true")]
    pub floating_pragma: bool,
    #[serde(default = "default_true")]
    pub large_contracts: bool,
    #[serde(default = "default_true")]
    pub unchecked_arithmetic: bool,
    #[serde(default = "default_true")]
    pub unsafe_erc20_transfer: bool,
    #[serde(default = "default_true")]
    pub push_without_length_cap: bool,
    #[serde(default = "default_true")]
    pub block_timestamp_dependency: bool,
    #[serde(default = "default_true")]
    pub tx_gas_price_dependency: bool,
    #[serde(default = "default_true")]
    pub encode_packed_collision: bool,
    #[serde(default = "default_true")]
    pub delegatecall_in_constructor: bool,
}

impl Default for SoliditySecurityConfig {
    fn default() -> Self {
        Self {
            tx_origin: true,
            reentrancy_heuristic: true,
            unchecked_calls: true,
            delegatecall: true,
            selfdestruct: true,
            assembly_blocks: true,
            unbounded_loops: true,
            missing_access_control: true,
            hardcoded_addresses: true,
            floating_pragma: true,
            large_contracts: true,
            unchecked_arithmetic: true,
            unsafe_erc20_transfer: true,
            push_without_length_cap: true,
            block_timestamp_dependency: true,
            tx_gas_price_dependency: true,
            encode_packed_collision: true,
            delegatecall_in_constructor: true,
        }
    }
}

fn default_true() -> bool {
    true
}

/// Solidity-specific language configuration.
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct SolidityLanguageConfig {
    #[serde(flatten)]
    pub features: LanguageFeatures,

    #[serde(default)]
    pub security: SoliditySecurityConfig,

    /// How generated/vendor Solidity files should be handled.
    #[serde(default)]
    pub vendor_code: GeneratedCodeMode,

    /// Maximum functions/state variables before large-contract advisory.
    #[serde(default = "default_large_contract_threshold")]
    pub large_contract_threshold: usize,
}

fn default_large_contract_threshold() -> usize {
    20
}

/// Generated Go handling policy.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)]
#[serde(rename_all = "snake_case")]
pub enum GeneratedCodeMode {
    /// Analyze generated files normally and emit debt items.
    Analyze,
    /// Analyze generated files, but suppress generated-file debt items.
    #[default]
    SuppressDebt,
    /// Exclude generated files from config-driven batch analysis.
    Exclude,
}

impl Default for LanguageFeatures {
    fn default() -> Self {
        Self {
            detect_dead_code: default_detect_dead_code(),
            detect_complexity: default_detect_complexity(),
            detect_duplication: default_detect_duplication(),
        }
    }
}

// Default feature flags - dead code detection disabled by default (spec 191)
pub fn default_detect_dead_code() -> bool {
    false
}

pub fn default_detect_complexity() -> bool {
    true
}

pub fn default_detect_duplication() -> bool {
    true
}

/// Entropy-based complexity scoring configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct EntropyConfig {
    /// Whether entropy-based scoring is enabled
    #[serde(default = "default_entropy_enabled")]
    pub enabled: bool,

    /// Weight of entropy in complexity adjustment (0.0-1.0)
    #[serde(default = "default_entropy_weight")]
    pub weight: f64,

    /// Minimum tokens required for entropy calculation
    #[serde(default = "default_entropy_min_tokens")]
    pub min_tokens: usize,

    /// Pattern similarity threshold for repetition detection (0.0-1.0)
    #[serde(default = "default_entropy_pattern_threshold")]
    pub pattern_threshold: f64,

    /// Entropy threshold for low entropy detection (0.0-1.0)
    #[serde(default = "default_entropy_threshold")]
    pub entropy_threshold: f64,

    /// Whether to use smarter token classification (false by default for backward compatibility)
    #[serde(default)]
    pub use_classification: Option<bool>,

    /// Branch similarity threshold for detection (0.0-1.0)
    #[serde(default = "default_branch_threshold")]
    pub branch_threshold: f64,

    /// Maximum reduction for high repetition (0.0-1.0)
    #[serde(default = "default_max_repetition_reduction")]
    pub max_repetition_reduction: f64,

    /// Maximum reduction for low entropy (0.0-1.0)
    #[serde(default = "default_max_entropy_reduction")]
    pub max_entropy_reduction: f64,

    /// Maximum reduction for similar branches (0.0-1.0)
    #[serde(default = "default_max_branch_reduction")]
    pub max_branch_reduction: f64,

    /// Maximum combined reduction (0.0-1.0)
    #[serde(default = "default_max_combined_reduction")]
    pub max_combined_reduction: f64,
}

impl Default for EntropyConfig {
    fn default() -> Self {
        Self {
            enabled: default_entropy_enabled(),
            weight: default_entropy_weight(),
            min_tokens: default_entropy_min_tokens(),
            pattern_threshold: default_entropy_pattern_threshold(),
            entropy_threshold: default_entropy_threshold(),
            use_classification: None, // Default to None for backward compatibility
            branch_threshold: default_branch_threshold(),
            max_repetition_reduction: default_max_repetition_reduction(),
            max_entropy_reduction: default_max_entropy_reduction(),
            max_branch_reduction: default_max_branch_reduction(),
            max_combined_reduction: default_max_combined_reduction(),
        }
    }
}

pub fn default_entropy_enabled() -> bool {
    true // Enabled by default for better match statement handling
}

pub fn default_entropy_weight() -> f64 {
    1.0 // Full weight when enabled (user can adjust)
}

pub fn default_entropy_min_tokens() -> usize {
    20
}

pub fn default_entropy_pattern_threshold() -> f64 {
    0.7
}

pub fn default_entropy_threshold() -> f64 {
    0.4 // Below 0.4 entropy is considered low
}

pub fn default_branch_threshold() -> f64 {
    0.8 // Above 80% branch similarity triggers dampening
}

pub fn default_max_repetition_reduction() -> f64 {
    0.20 // Max 20% reduction for high repetition
}

pub fn default_max_entropy_reduction() -> f64 {
    0.15 // Max 15% reduction for low entropy
}

pub fn default_max_branch_reduction() -> f64 {
    0.25 // Max 25% reduction for similar branches
}

pub fn default_max_combined_reduction() -> f64 {
    0.30 // Max 30% total reduction (cap)
}