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

impl GitHistoryIndex {
    /// Get commits that need embeddings
    pub fn get_commits_without_embeddings(
        &self,
        limit: usize,
    ) -> Result<Vec<String>, GitHistoryError> {
        let mut stmt = self
            .conn
            .prepare("SELECT commit_hash FROM git_commits WHERE embedding IS NULL LIMIT ?1")?;

        let hashes = stmt
            .query_map([limit], |row| row.get(0))?
            .filter_map(|r| r.ok())
            .collect();

        Ok(hashes)
    }

    /// Get last indexed commit hash
    pub fn get_last_indexed_commit(&self) -> Result<Option<String>, GitHistoryError> {
        let result: Option<String> = self
            .conn
            .query_row(
                "SELECT value FROM git_metadata WHERE key = 'last_indexed_commit'",
                [],
                |row| row.get(0),
            )
            .optional()?;

        Ok(result)
    }

    /// Set last indexed commit hash
    pub fn set_last_indexed_commit(&self, commit_hash: &str) -> Result<(), GitHistoryError> {
        self.conn.execute(
            "INSERT OR REPLACE INTO git_metadata (key, value) VALUES ('last_indexed_commit', ?1)",
            [commit_hash],
        )?;
        Ok(())
    }

    /// Get total commit count
    pub fn commit_count(&self) -> Result<usize, GitHistoryError> {
        let count: i64 = self
            .conn
            .query_row("SELECT COUNT(*) FROM git_commits", [], |row| row.get(0))?;
        Ok(count as usize)
    }

    /// Get commits by file path
    pub fn get_commits_for_file(
        &self,
        file_path: &str,
        limit: usize,
    ) -> Result<Vec<String>, GitHistoryError> {
        let mut stmt = self.conn.prepare(
            r#"
            SELECT DISTINCT gc.commit_hash
            FROM git_commits gc
            JOIN commit_files cf ON gc.commit_hash = cf.commit_hash
            WHERE cf.file_path = ?1
            ORDER BY gc.timestamp DESC
            LIMIT ?2
            "#,
        )?;

        let hashes = stmt
            .query_map(params![file_path, limit], |row| row.get(0))?
            .filter_map(|r| r.ok())
            .collect();

        Ok(hashes)
    }

    /// Check if a commit exists in the index
    pub fn commit_exists(&self, commit_hash: &str) -> Result<bool, GitHistoryError> {
        let count: i64 = self.conn.query_row(
            "SELECT COUNT(*) FROM git_commits WHERE commit_hash = ?1",
            [commit_hash],
            |row| row.get(0),
        )?;
        Ok(count > 0)
    }

    /// Get commits by timestamp range (for incremental queries)
    pub fn get_commits_since(
        &self,
        timestamp: i64,
        limit: usize,
    ) -> Result<Vec<CommitInfo>, GitHistoryError> {
        let mut stmt = self.conn.prepare(
            r#"
            SELECT commit_hash, message_subject, message_body, author_name, author_email,
                   timestamp, is_merge, is_fix, is_feat, issue_refs
            FROM git_commits
            WHERE timestamp > ?1
            ORDER BY timestamp ASC
            LIMIT ?2
            "#,
        )?;

        let commits = stmt
            .query_map(params![timestamp, limit], |row| {
                let issue_refs_str: String = row.get::<_, String>(9).unwrap_or_default();
                let issue_refs: Vec<String> =
                    serde_json::from_str(&issue_refs_str).unwrap_or_default();

                Ok(CommitInfo {
                    hash: row.get(0)?,
                    message_subject: row.get(1)?,
                    message_body: row.get(2)?,
                    author_name: row.get(3)?,
                    author_email: row.get(4)?,
                    timestamp: row.get(5)?,
                    is_merge: row.get::<_, i32>(6)? != 0,
                    is_fix: row.get::<_, i32>(7)? != 0,
                    is_feat: row.get::<_, i32>(8)? != 0,
                    issue_refs,
                    files: vec![], // Files loaded separately if needed
                })
            })?
            .filter_map(|r| r.ok())
            .collect();

        Ok(commits)
    }

    /// Calculate checksum of index (for falsification test F1)
    pub fn checksum(&self) -> Result<String, GitHistoryError> {
        let count: i64 = self
            .conn
            .query_row("SELECT COUNT(*) FROM git_commits", [], |row| row.get(0))?;

        let last_hash: Option<String> = self
            .conn
            .query_row(
                "SELECT commit_hash FROM git_commits ORDER BY timestamp DESC LIMIT 1",
                [],
                |row| row.get(0),
            )
            .optional()?;

        Ok(format!("{}:{}", count, last_hash.unwrap_or_default()))
    }
}