drep-ai 2.5.0

A local commit gate: runs the linters your repo configures, and sends changed code to an LLM for 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
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

//! Codex-specific doctor readiness and redaction contracts.

use std::path::Path;

use crate::cli::doctor::{DoctorArgs, run_at_with_codex};
use crate::llm::codex::CodexStatus;

fn report_with_probe(dir: &Path, probe: &dyn Fn() -> Result<CodexStatus, String>) -> String {
    let args = DoctorArgs {
        path: dir.to_path_buf(),
        config: None,
    };
    let mut out = Vec::new();
    run_at_with_codex(&mut out, &args, &dir.join("auth.toml"), probe)
        .expect("doctor remains diagnostic");
    String::from_utf8(out).expect("utf8")
}

#[test]
fn a_ready_codex_backend_reports_only_redacted_subscription_facts() {
    let dir = tempfile::tempdir().expect("tempdir");
    std::fs::write(dir.path().join("a.py"), "x = 1\n").expect("source");
    std::fs::write(
        dir.path().join("drep.toml"),
        r#"
[[llm]]
backend = "codex"
model = "gpt-5.6-sol"
reasoning_effort = "high"
"#,
    )
    .expect("config");

    let report = report_with_probe(dir.path(), &|| Ok(CodexStatus::new("0.148.0")));

    assert!(
        report.contains("gpt-5.6-sol via ChatGPT/Codex subscription"),
        "got {report}"
    );
    assert!(report.contains("Codex CLI: 0.148.0"), "got {report}");
    assert!(
        report.contains("authentication: ChatGPT-managed"),
        "got {report}"
    );
    assert!(
        report.contains("isolation: ephemeral, read-only, tools disabled"),
        "got {report}"
    );
    assert!(!report.contains("no endpoint"), "got {report}");
    assert!(!report.contains("key:"), "got {report}");
}

#[test]
fn a_codex_readiness_failure_is_actionable_but_not_a_doctor_failure() {
    let dir = tempfile::tempdir().expect("tempdir");
    std::fs::write(
        dir.path().join("drep.toml"),
        r#"
[[llm]]
backend = "codex"
model = "gpt-5.6-sol"
reasoning_effort = "high"
"#,
    )
    .expect("config");

    let report = report_with_probe(dir.path(), &|| {
        Err("Codex CLI was not found; install it and run `codex login`".to_owned())
    });

    assert!(report.contains("Codex CLI was not found"), "got {report}");
    assert!(report.contains("`codex login`"), "got {report}");
}

#[test]
fn a_disabled_codex_backend_does_not_run_the_diagnostic() {
    let dir = tempfile::tempdir().expect("tempdir");
    std::fs::write(
        dir.path().join("drep.toml"),
        r#"
[[llm]]
backend = "codex"
enabled = false
model = "gpt-5.6-sol"
reasoning_effort = "high"

[[llm]]
model = "local"
endpoint = "http://localhost:1234/v1"
"#,
    )
    .expect("config");
    let calls = std::cell::Cell::new(0);

    let report = report_with_probe(dir.path(), &|| {
        calls.set(calls.get() + 1);
        Ok(CodexStatus::new("unused"))
    });

    assert_eq!(calls.get(), 0, "disabled providers are inert");
    assert!(
        report.contains("via ChatGPT/Codex subscription (disabled - skipped)"),
        "got {report}"
    );
}

#[test]
fn a_codex_only_config_never_reads_the_http_auth_store() {
    let dir = tempfile::tempdir().expect("tempdir");
    std::fs::write(
        dir.path().join("drep.toml"),
        r#"
[[llm]]
backend = "codex"
model = "gpt-5.6-sol"
"#,
    )
    .expect("config");
    std::fs::write(dir.path().join("auth.toml"), "not valid TOML = [")
        .expect("corrupt HTTP auth store");

    let report = report_with_probe(dir.path(), &|| Ok(CodexStatus::new("0.148.0")));

    assert!(
        !report.contains("auth store could not be read"),
        "a Codex-only setup must not consult HTTP credentials: {report}"
    );
}