pmat 3.15.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

impl DemoRunner {
    #[cfg(feature = "git-lib")]
    #[provable_contracts_macros::contract("pmat-core.yaml", equation = "check_compliance")]
    async fn clone_and_prepare(&self, url: &str) -> Result<PathBuf> {
        println!("🔄 Cloning repository: {url}");

        // Create a temporary directory for cloning
        let temp_dir = env::temp_dir().join(format!("paiml-demo-{}", uuid::Uuid::new_v4()));
        tokio::fs::create_dir_all(&temp_dir).await?;

        // Create git cloner with progress tracking
        let cloner = GitCloner::new(temp_dir.clone()).with_timeout(Duration::from_secs(120)); // 2 minute timeout

        // Monitor progress in background
        let progress_handle = {
            let cloner = cloner.clone();
            tokio::spawn(async move {
                let mut last_stage = String::with_capacity(1024);
                loop {
                    sleep(Duration::from_millis(500)).await;
                    let progress = cloner.get_progress().await;

                    if progress.stage != last_stage {
                        println!("   📦 {}", progress.stage);
                        last_stage = progress.stage.clone();
                    }

                    if progress.total > 0 {
                        let percent =
                            (progress.current as f64 / progress.total as f64 * 100.0) as u32;
                        print!(
                            "\r   ⏳ Progress: {}% ({}/{})",
                            percent, progress.current, progress.total
                        );
                        io::stdout().flush().ok();
                    }
                }
            })
        };

        // Clone the repository
        match cloner.clone_or_update(url).await {
            Ok(cloned) => {
                progress_handle.abort();
                println!("\r   ✅ Clone complete!                                         ");

                if cloned.cached {
                    println!("   📋 Using cached repository");
                }

                Ok(cloned.path)
            }
            Err(e) => {
                progress_handle.abort();
                println!("\r   ❌ Clone failed                                           ");

                // Clean up on failure
                let _ = tokio::fs::remove_dir_all(&temp_dir).await;

                match e {
                    CloneError::Timeout => {
                        Err(anyhow!("Repository clone timed out after 2 minutes"))
                    }
                    CloneError::InvalidUrl(msg) => Err(anyhow!("Invalid GitHub URL: {msg}")),
                    CloneError::GitError(e) => Err(anyhow!("Git error: {e}")),
                    _ => Err(anyhow!("Failed to clone repository: {e}")),
                }
            }
        }
    }

    #[cfg(not(feature = "git-lib"))]
    #[provable_contracts_macros::contract("pmat-core.yaml", equation = "check_compliance")]
    async fn clone_and_prepare(&self, url: &str) -> Result<PathBuf> {
        use std::process::Command;

        println!("🔄 Cloning repository: {url}");

        // Extract repo name from URL
        let repo_name = url
            .trim_end_matches('/')
            .split('/')
            .next_back()
            .unwrap_or("repo")
            .trim_end_matches(".git");

        // Create a temporary directory for cloning
        let temp_dir = env::temp_dir().join(format!("paiml-demo-{}", uuid::Uuid::new_v4()));
        tokio::fs::create_dir_all(&temp_dir).await?;

        let clone_path = temp_dir.join(repo_name);
        let clone_path_str = clone_path
            .to_str()
            .ok_or_else(|| anyhow!("Clone path contains invalid UTF-8"))?;

        // Clone using shell git command
        let output = Command::new("git")
            .args(["clone", "--depth", "1", url, clone_path_str])
            .output()
            .map_err(|e| anyhow!("Failed to run git clone: {e}"))?;

        if output.status.success() {
            println!("   ✅ Clone complete!");
            Ok(clone_path)
        } else {
            let stderr = String::from_utf8_lossy(&output.stderr);
            let _ = tokio::fs::remove_dir_all(&temp_dir).await;
            Err(anyhow!("Git clone failed: {}", stderr.trim()))
        }
    }
}