pmat 3.11.0

PMAT - Zero-config AI context generation and code quality toolkit (CLI, MCP, HTTP)
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

//! BUG-004: Multi-Language Dead Code Analysis
//!
//! This example demonstrates the fix for BUG-004 where dead code analysis
//! now works for C/C++/Python projects without requiring Cargo.toml.
//!
//! Run with: `cargo run --example bug_004_dead_code_c_project`

use anyhow::Result;
use pmat::services::dead_code_multi_language::analyze_dead_code_multi_language;
use std::fs;
use tempfile::TempDir;

fn main() -> Result<()> {
    println!("🐛 BUG-004: Multi-Language Dead Code Analysis\n");

    // Example 1: C Project (no Cargo.toml required!)
    println!("Example 1: C project dead code analysis");
    println!("{}", "=".repeat(60));

    let c_project = create_c_project()?;
    println!("Created C project at: {:?}", c_project.path());
    println!("Files:");
    println!("  - src/main.c (calls used_function)");
    println!("  - src/utils.c (defines used_function and unused_function)");
    println!("  - include/utils.h (declarations)");
    println!("  - Makefile (C project indicator)");
    println!("  - NO Cargo.toml!");

    println!("\n🔍 Running dead code analysis...");

    let result = analyze_dead_code_multi_language(c_project.path())?;

    println!("✅ Analysis successful!");
    println!("  Language: {}", result.language);
    println!("  Total functions: {}", result.total_functions);
    println!("  Dead functions: {}", result.dead_functions.len());
    println!("  Dead code %: {:.1}%", result.dead_code_percentage);

    println!("\n📊 Dead Functions:");
    for func in &result.dead_functions {
        println!("  - {} ({}:{})", func.name, func.file, func.line);
        println!("    Reason: {}", func.reason);
    }

    // Example 2: Python Project
    println!("\n\nExample 2: Python project dead code analysis");
    println!("{}", "=".repeat(60));

    let py_project = create_python_project()?;
    println!("Created Python project at: {:?}", py_project.path());

    let result = analyze_dead_code_multi_language(py_project.path())?;

    println!("✅ Analysis successful!");
    println!("  Language: {}", result.language);
    println!("  Dead functions: {}", result.dead_functions.len());

    println!("\n✅ BUG-004 FIXED: Multi-language dead code analysis works!");

    Ok(())
}

fn create_c_project() -> Result<TempDir> {
    let temp = TempDir::new()?;
    let base = temp.path();

    fs::create_dir_all(base.join("src"))?;
    fs::create_dir_all(base.join("include"))?;

    // main.c
    fs::write(
        base.join("src/main.c"),
        r#"
#include <stdio.h>
#include "utils.h"

int main() {
    used_function();
    return 0;
}
"#,
    )?;

    // utils.c with dead code
    fs::write(
        base.join("src/utils.c"),
        r#"
#include <stdio.h>
#include "utils.h"

void used_function() {
    printf("Used\n");
}

void unused_function() {
    printf("DEAD CODE!\n");
}
"#,
    )?;

    // utils.h
    fs::write(
        base.join("include/utils.h"),
        r#"
#ifndef UTILS_H
#define UTILS_H

void used_function();
void unused_function();

#endif
"#,
    )?;

    // Makefile (C project indicator)
    fs::write(base.join("Makefile"), "CC=gcc\nCFLAGS=-Wall\n\nall: main\n")?;

    Ok(temp)
}

fn create_python_project() -> Result<TempDir> {
    let temp = TempDir::new()?;
    let base = temp.path();

    // main.py
    fs::write(
        base.join("main.py"),
        r#"
from utils import used_function

def main():
    used_function()

if __name__ == "__main__":
    main()
"#,
    )?;

    // utils.py with dead code
    fs::write(
        base.join("utils.py"),
        r#"
def used_function():
    print("Used")

def unused_function():
    print("DEAD CODE!")
"#,
    )?;

    // pyproject.toml
    fs::write(base.join("pyproject.toml"), "[project]\nname = \"test\"\n")?;

    Ok(temp)
}