shiplog 0.10.0

CLI evidence compiler for review-cycle packets with receipts, coverage, gaps, and safe share profiles.
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

use anyhow::{Context, Result};
use url::Url;

/// Abstraction over LLM APIs. Enables testing with mocks.
pub trait LlmBackend {
    fn complete(&self, system: &str, user: &str) -> Result<String>;
}

/// Backend that speaks the OpenAI chat completions protocol.
pub struct OpenAiCompatibleBackend {
    pub endpoint: String,
    pub api_key: String,
    pub model: String,
    pub temperature: f64,
    pub timeout_secs: u64,
}

impl LlmBackend for OpenAiCompatibleBackend {
    #[mutants::skip]
    fn complete(&self, system: &str, user: &str) -> Result<String> {
        validate_https_endpoint(&self.endpoint)?;

        let client = reqwest::blocking::Client::builder()
            .timeout(std::time::Duration::from_secs(self.timeout_secs))
            .build()?;

        let body = serde_json::json!({
            "model": self.model,
            "temperature": self.temperature,
            "response_format": { "type": "json_object" },
            "messages": [
                { "role": "system", "content": system },
                { "role": "user", "content": user }
            ]
        });

        let resp = client
            .post(&self.endpoint)
            .header("Authorization", format!("Bearer {}", self.api_key))
            .header("Content-Type", "application/json")
            .json(&body)
            .send()
            .context("LLM API request failed")?;

        if !resp.status().is_success() {
            let status = resp.status();
            let text = resp.text().unwrap_or_default();
            anyhow::bail!("LLM API returned {status}: {text}");
        }

        let json: serde_json::Value = resp.json().context("parse LLM response")?;
        let content = json["choices"][0]["message"]["content"]
            .as_str()
            .ok_or_else(|| anyhow::anyhow!("no content in LLM response"))?
            .to_string();

        Ok(content)
    }
}

fn validate_https_endpoint(endpoint: &str) -> Result<()> {
    let parsed = Url::parse(endpoint).context("parse LLM API endpoint")?;
    if parsed.scheme() != "https" {
        anyhow::bail!("LLM API endpoint must use https, got {}", parsed.scheme());
    }
    if parsed.host_str().is_none() {
        anyhow::bail!("LLM API endpoint must include a host");
    }
    Ok(())
}

/// Mock backend for testing.
pub struct MockLlmBackend {
    pub response: String,
}

impl LlmBackend for MockLlmBackend {
    fn complete(&self, _system: &str, _user: &str) -> Result<String> {
        Ok(self.response.clone())
    }
}

/// Mock backend that always fails.
pub struct FailingLlmBackend;

impl LlmBackend for FailingLlmBackend {
    #[mutants::skip]
    fn complete(&self, _system: &str, _user: &str) -> Result<String> {
        anyhow::bail!("LLM backend failed (mock)")
    }
}

#[cfg(test)]
mod tests {
    use super::validate_https_endpoint;
    use anyhow::Result;

    #[test]
    fn accepts_https_endpoint() -> Result<()> {
        validate_https_endpoint("https://api.example.com/v1/chat/completions")?;
        Ok(())
    }

    #[test]
    fn rejects_http_endpoint() -> Result<()> {
        let error = validate_https_endpoint("http://api.example.com/v1/chat/completions")
            .err()
            .ok_or_else(|| anyhow::anyhow!("HTTP endpoint should be rejected"))?;
        if !error.to_string().contains("must use https") {
            anyhow::bail!("unexpected validation error: {error}");
        }
        Ok(())
    }

    #[test]
    fn rejects_invalid_endpoint() -> Result<()> {
        validate_https_endpoint("not a URL")
            .err()
            .ok_or_else(|| anyhow::anyhow!("invalid endpoint should be rejected"))?;
        Ok(())
    }
}