repopilot 0.4.0

Local-first CLI for repository audit, architecture risk detection, baseline tracking, and CI-friendly code review.
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

use repopilot::baseline::reader::read_baseline;
use std::fs;
use tempfile::tempdir;

#[test]
fn reads_valid_baseline() {
    let temp = tempdir().expect("failed to create temp dir");
    let path = temp.path().join("baseline.json");
    fs::write(&path, valid_baseline_json()).expect("failed to write baseline");

    let baseline = read_baseline(&path).expect("baseline should read");

    assert_eq!(baseline.schema_version, 1);
    assert_eq!(baseline.tool, "repopilot");
    assert_eq!(
        baseline.findings[0].key,
        "security.secret-candidate:src/config.rs:1"
    );
}

#[test]
fn rejects_invalid_json() {
    let temp = tempdir().expect("failed to create temp dir");
    let path = temp.path().join("baseline.json");
    fs::write(&path, "{not json").expect("failed to write baseline");

    let error = read_baseline(&path).expect_err("invalid JSON should fail");

    assert!(error.to_string().contains("invalid JSON"));
}

#[test]
fn rejects_empty_baseline_file() {
    let temp = tempdir().expect("failed to create temp dir");
    let path = temp.path().join("baseline.json");
    fs::write(&path, "\n").expect("failed to write baseline");

    let error = read_baseline(&path).expect_err("empty baseline should fail");

    assert!(error.to_string().contains("baseline file is empty"));
}

#[test]
fn rejects_unsupported_schema_version() {
    let temp = tempdir().expect("failed to create temp dir");
    let path = temp.path().join("baseline.json");
    fs::write(
        &path,
        valid_baseline_json().replace("\"schema_version\": 1", "\"schema_version\": 99"),
    )
    .expect("failed to write baseline");

    let error = read_baseline(&path).expect_err("unsupported schema should fail");

    assert!(
        error
            .to_string()
            .contains("Unsupported baseline schema version: 99")
    );
    assert!(error.to_string().contains("Supported version: 1"));
}

#[test]
fn handles_missing_file_with_clear_error() {
    let temp = tempdir().expect("failed to create temp dir");
    let path = temp.path().join("missing.json");

    let error = read_baseline(&path).expect_err("missing file should fail");

    assert!(error.to_string().contains("Failed to read baseline file"));
    assert!(error.to_string().contains("file does not exist"));
}

#[test]
fn rejects_finding_missing_required_field() {
    let temp = tempdir().expect("failed to create temp dir");
    let path = temp.path().join("baseline.json");
    fs::write(
        &path,
        valid_baseline_json().replace(
            "\"key\": \"security.secret-candidate:src/config.rs:1\",\n      ",
            "",
        ),
    )
    .expect("failed to write baseline");

    let error = read_baseline(&path).expect_err("missing finding key should fail");

    assert!(error.to_string().contains("key"));
}

fn valid_baseline_json() -> String {
    r#"{
  "schema_version": 1,
  "tool": "repopilot",
  "created_at": "2026-05-06T12:00:00Z",
  "root": ".",
  "findings": [
    {
      "key": "security.secret-candidate:src/config.rs:1",
      "rule_id": "security.secret-candidate",
      "severity": "high",
      "path": "src/config.rs",
      "message": "Possible secret detected"
    }
  ]
}"#
    .to_string()
}