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
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
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320

#![allow(deprecated)]
// CLI Semantic Search Integration Tests
// Sprint 33 (PMAT-SEARCH-011)
//
// Tests for semantic search CLI commands

use assert_cmd::Command;
use predicates::prelude::*;
use std::fs;
use tempfile::TempDir;

// Helper to check if OPENAI_API_KEY is set
fn has_api_key() -> bool {
    std::env::var("OPENAI_API_KEY").is_ok()
}

// Test 1: pmat embed --help shows help text
#[ignore = "requires semantic integration setup"]
#[test]
#[ignore] // Integration test requires pmat binary
fn test_embed_help() {
    let mut cmd = Command::cargo_bin("pmat").unwrap();
    cmd.arg("embed").arg("--help");

    cmd.assert()
        .success()
        .stdout(predicate::str::contains(
            "Manage semantic search embeddings",
        ))
        .stdout(predicate::str::contains("sync"))
        .stdout(predicate::str::contains("status"))
        .stdout(predicate::str::contains("clear"));
}

// Test 2: pmat embed sync --help shows sync help
#[ignore = "requires semantic integration setup"]
#[test]
#[ignore] // Integration test requires pmat binary
fn test_embed_sync_help() {
    let mut cmd = Command::cargo_bin("pmat").unwrap();
    cmd.arg("embed").arg("sync").arg("--help");

    cmd.assert()
        .success()
        .stdout(predicate::str::contains("Sync embeddings"))
        .stdout(predicate::str::contains("--path"))
        .stdout(predicate::str::contains("--language"));
}

// Test 3: pmat embed status --help shows status help
#[ignore = "requires semantic integration setup"]
#[test]
#[ignore] // Integration test requires pmat binary
fn test_embed_status_help() {
    let mut cmd = Command::cargo_bin("pmat").unwrap();
    cmd.arg("embed").arg("status").arg("--help");

    cmd.assert()
        .success()
        .stdout(predicate::str::contains("Show embedding database status"));
}

// Test 4: pmat embed clear --help shows clear help
#[ignore = "requires semantic integration setup"]
#[test]
#[ignore] // Integration test requires pmat binary
fn test_embed_clear_help() {
    let mut cmd = Command::cargo_bin("pmat").unwrap();
    cmd.arg("embed").arg("clear").arg("--help");

    cmd.assert()
        .success()
        .stdout(predicate::str::contains("Remove all embeddings"))
        .stdout(predicate::str::contains("--confirm"));
}

// Test 5: pmat semantic --help shows help text
#[ignore = "requires semantic integration setup"]
#[test]
#[ignore] // Integration test requires pmat binary
fn test_semantic_help() {
    let mut cmd = Command::cargo_bin("pmat").unwrap();
    cmd.arg("semantic").arg("--help");

    cmd.assert()
        .success()
        .stdout(predicate::str::contains("Semantic code search"))
        .stdout(predicate::str::contains("search"))
        .stdout(predicate::str::contains("similar"));
}

// Test 6: pmat semantic search --help shows search help
#[ignore = "requires semantic integration setup"]
#[test]
#[ignore] // Integration test requires pmat binary
fn test_semantic_search_help() {
    let mut cmd = Command::cargo_bin("pmat").unwrap();
    cmd.arg("semantic").arg("search").arg("--help");

    cmd.assert()
        .success()
        .stdout(predicate::str::contains("Search code"))
        .stdout(predicate::str::contains("--mode"))
        .stdout(predicate::str::contains("--limit"))
        .stdout(predicate::str::contains("--language"));
}

// Test 7: pmat semantic similar --help shows similar help
#[ignore = "requires semantic integration setup"]
#[test]
#[ignore] // Integration test requires pmat binary
fn test_semantic_similar_help() {
    let mut cmd = Command::cargo_bin("pmat").unwrap();
    cmd.arg("semantic").arg("similar").arg("--help");

    cmd.assert()
        .success()
        .stdout(predicate::str::contains("Find similar code"))
        .stdout(predicate::str::contains("--limit"));
}

// Test 8: pmat analyze cluster --help shows cluster help
#[ignore = "requires semantic integration setup"]
#[test]
#[ignore] // Integration test requires pmat binary
fn test_analyze_cluster_help() {
    let mut cmd = Command::cargo_bin("pmat").unwrap();
    cmd.arg("analyze").arg("cluster").arg("--help");

    cmd.assert()
        .success()
        .stdout(predicate::str::contains("Cluster"))
        .stdout(predicate::str::contains("--method"))
        .stdout(predicate::str::contains("--k"));
}

// Test 9: pmat analyze topics --help shows topics help
#[ignore = "requires semantic integration setup"]
#[test]
#[ignore] // Integration test requires pmat binary
fn test_analyze_topics_help() {
    let mut cmd = Command::cargo_bin("pmat").unwrap();
    cmd.arg("analyze").arg("topics").arg("--help");

    cmd.assert()
        .success()
        .stdout(predicate::str::contains("topics"))
        .stdout(predicate::str::contains("--num-topics"));
}

// Test 10: pmat embed sync without API key shows error
#[ignore = "requires semantic integration setup"]
#[test]
#[ignore] // Integration test requires pmat binary
fn test_embed_sync_no_api_key() {
    if has_api_key() {
        eprintln!("Skipping test: OPENAI_API_KEY is set");
        return;
    }

    let temp_dir = TempDir::new().unwrap();

    let mut cmd = Command::cargo_bin("pmat").unwrap();
    cmd.arg("embed")
        .arg("sync")
        .arg("--path")
        .arg(temp_dir.path())
        .env_remove("OPENAI_API_KEY");

    cmd.assert()
        .failure()
        .stderr(predicate::str::contains("API key").or(predicate::str::contains("not enabled")));
}

// Test 11: pmat semantic search without API key shows error
#[ignore = "requires semantic integration setup"]
#[test]
#[ignore] // Integration test requires pmat binary
fn test_semantic_search_no_api_key() {
    if has_api_key() {
        eprintln!("Skipping test: OPENAI_API_KEY is set");
        return;
    }

    let mut cmd = Command::cargo_bin("pmat").unwrap();
    cmd.arg("semantic")
        .arg("search")
        .arg("test query")
        .env_remove("OPENAI_API_KEY");

    cmd.assert()
        .failure()
        .stderr(predicate::str::contains("API key").or(predicate::str::contains("not enabled")));
}

// Test 12: pmat embed status without initialized database
#[ignore = "requires semantic integration setup"]
#[test]
#[ignore] // Integration test requires pmat binary
fn test_embed_status_no_database() {
    let temp_dir = TempDir::new().unwrap();
    let db_path = temp_dir.path().join("nonexistent.db");

    let mut cmd = Command::cargo_bin("pmat").unwrap();
    cmd.arg("embed")
        .arg("status")
        .env_remove("OPENAI_API_KEY")
        .env("PMAT_VECTOR_DB_PATH", db_path);

    // Should either fail or show empty status
    let output = cmd.output().unwrap();
    assert!(
        !output.status.success()
            || String::from_utf8_lossy(&output.stdout).contains("0")
            || String::from_utf8_lossy(&output.stderr).contains("not enabled")
    );
}

// Test 13: pmat embed clear without --confirm flag shows error
#[ignore = "requires semantic integration setup"]
#[test]
#[ignore] // Integration test requires pmat binary
fn test_embed_clear_requires_confirm() {
    let mut cmd = Command::cargo_bin("pmat").unwrap();
    cmd.arg("embed").arg("clear");

    // Should fail without --confirm
    cmd.assert().failure();
}

// Test 14: pmat semantic search with invalid mode shows error
#[ignore = "requires semantic integration setup"]
#[test]
// Requires API key and database
fn test_semantic_search_invalid_mode() {
    let mut cmd = Command::cargo_bin("pmat").unwrap();
    cmd.arg("semantic")
        .arg("search")
        .arg("test query")
        .arg("--mode")
        .arg("invalid");

    cmd.assert()
        .failure()
        .stderr(predicate::str::contains("invalid").or(predicate::str::contains("mode")));
}

// Test 15: pmat semantic similar requires file path
#[ignore = "requires semantic integration setup"]
#[test]
#[ignore] // Integration test requires pmat binary
fn test_semantic_similar_requires_file_path() {
    let mut cmd = Command::cargo_bin("pmat").unwrap();
    cmd.arg("semantic").arg("similar");

    // Should fail - missing required file_path argument
    cmd.assert().failure();
}

// Test 16: pmat analyze cluster requires method
#[ignore = "requires semantic integration setup"]
#[test]
#[ignore] // Integration test requires pmat binary
fn test_analyze_cluster_requires_method() {
    let mut cmd = Command::cargo_bin("pmat").unwrap();
    cmd.arg("analyze").arg("cluster");

    // Should fail - missing required --method argument
    cmd.assert().failure();
}

// Test 17: pmat analyze topics requires num_topics
#[ignore = "requires semantic integration setup"]
#[test]
#[ignore] // Integration test requires pmat binary
fn test_analyze_topics_requires_num_topics() {
    let mut cmd = Command::cargo_bin("pmat").unwrap();
    cmd.arg("analyze").arg("topics");

    // Should fail - missing required --num-topics argument
    cmd.assert().failure();
}

// Test 18: Configuration environment variables are respected
#[ignore = "requires semantic integration setup"]
#[test]
#[ignore] // Integration test requires pmat binary
fn test_env_var_configuration() {
    if !has_api_key() {
        eprintln!("Skipping test: OPENAI_API_KEY not set");
        return;
    }

    let temp_dir = TempDir::new().unwrap();
    let db_path = temp_dir.path().join("test.db");
    let workspace = temp_dir.path();

    // Create a simple test file
    let test_file = workspace.join("test.rs");
    fs::write(&test_file, "fn main() { println!(\"hello\"); }").unwrap();

    let mut cmd = Command::cargo_bin("pmat").unwrap();
    cmd.arg("embed")
        .arg("sync")
        .arg("--path")
        .arg(workspace)
        .env("PMAT_VECTOR_DB_PATH", &db_path)
        .env("PMAT_WORKSPACE", workspace);

    // Should either succeed or fail with specific error (not generic config error)
    let output = cmd.output().unwrap();
    let stderr = String::from_utf8_lossy(&output.stderr);

    // Should not contain generic "not configured" error
    assert!(
        !stderr.contains("not configured")
            || stderr.contains("Synced")
            || stderr.contains("Indexed")
    );
}