ruask 0.1.1

A command-line assistant for command lookup and command output explanation
use std::process::{Command, Stdio};

use mockito::Server;
use serde_json::{Value, json};

fn openai_stream(text: &str) -> String {
    format!(
        "data: {}\n\ndata: {}\n\ndata: [DONE]\n\n",
        json!({"choices":[{"index":0,"delta":{"content":text}}]}),
        json!({"choices":[{"index":0,"delta":{},"finish_reason":"stop"}]})
    )
}

fn command(server: &Server) -> Command {
    let mut command = Command::new(env!("CARGO_BIN_EXE_ruask"));
    command
        .env_clear()
        .env("OPENAI_BASE_URL", format!("{}/v1", server.url()))
        .env("OPENAI_API_KEY", "private-credential")
        .env("OPENAI_MODEL", "private-model")
        .stdin(Stdio::null())
        .args(["-q", "private-query"]);
    command
}

fn trace(stderr: &[u8]) -> Value {
    let text = String::from_utf8_lossy(stderr);
    let lines: Vec<_> = text
        .lines()
        .filter_map(|line| line.strip_prefix("ruask-trace: "))
        .collect();
    assert_eq!(lines.len(), 1, "{text}");
    serde_json::from_str(lines[0]).unwrap()
}

#[test]
fn trace_is_opt_in_and_never_changes_stdout_or_records_private_data() {
    let mut server = Server::new();
    let response = server
        .mock("POST", "/v1/chat/completions")
        .with_header("content-type", "text/event-stream")
        .with_body(openai_stream(
            "# same title\n> private-answer\n- Check:\n`git status`\n",
        ))
        .expect(2)
        .create();
    let plain = command(&server).output().unwrap();
    let measured = command(&server).env("RUASK_TRACE", "1").output().unwrap();
    assert!(plain.status.success() && measured.status.success());
    assert!(plain.stderr.is_empty());
    assert_eq!(plain.stdout, measured.stdout);
    let diagnostics = String::from_utf8_lossy(&measured.stderr);
    for secret in [
        "private-credential",
        "private-query",
        "private-answer",
        "private-model",
        &server.url(),
    ] {
        assert!(!diagnostics.contains(secret));
    }
    let record = trace(&measured.stderr);
    let events = record["events"].as_array().unwrap();
    for pair in events.windows(2) {
        assert!(pair[0]["elapsed_us"].as_u64() <= pair[1]["elapsed_us"].as_u64());
    }
    let names: Vec<_> = events.iter().map(|e| e["name"].as_str().unwrap()).collect();
    for pair in [
        ("http_start", "http_headers"),
        ("http_headers", "first_http_body_byte"),
        ("first_http_body_byte", "first_answer_text"),
        ("first_answer_text", "first_stdout_line"),
        ("first_stdout_line", "first_command_candidate"),
        ("first_command_candidate", "response_complete"),
        ("response_complete", "exit"),
    ] {
        assert!(
            names.iter().position(|x| *x == pair.0).unwrap()
                < names.iter().position(|x| *x == pair.1).unwrap()
        );
    }
    response.assert();
}

#[test]
fn error_trace_does_not_invent_answer_or_command_timings() {
    let mut server = Server::new();
    let response = server
        .mock("POST", "/v1/chat/completions")
        .with_status(401)
        .with_body(r#"{"error":{"message":"private-credential"}}"#)
        .expect(1)
        .create();
    let output = command(&server).env("RUASK_TRACE", "1").output().unwrap();
    assert!(!output.status.success());
    let record = trace(&output.stderr);
    let events = record["events"].as_array().unwrap();
    assert!(!events.iter().any(|e| matches!(
        e["name"].as_str(),
        Some("first_answer_text" | "first_command_candidate" | "response_complete")
    )));
    assert_eq!(events.last().unwrap()["value"], 0);
    response.assert();
}

#[test]
fn fallback_trace_keeps_both_attempts_and_one_answer() {
    let mut server = Server::new();
    let unsupported = server
        .mock("POST", "/v1/chat/completions")
        .match_body(mockito::Matcher::PartialJson(json!({"stream":true})))
        .with_status(400)
        .with_body(
            r#"{"error":{"code":"unsupported_streaming","message":"streaming is not supported"}}"#,
        )
        .expect(1)
        .create();
    let answer = server.mock("POST", "/v1/chat/completions")
        .match_body(mockito::Matcher::PartialJson(json!({"stream":false})))
        .with_header("content-type", "application/json")
        .with_body(json!({"choices":[{"message":{"content":"- Check:\n`git status`"},"finish_reason":"stop"}]}).to_string())
        .expect(1).create();
    let output = command(&server).env("RUASK_TRACE", "1").output().unwrap();
    assert!(output.status.success(), "{output:?}");
    let record = trace(&output.stderr);
    let events = record["events"].as_array().unwrap();
    assert_eq!(
        events.iter().filter(|e| e["name"] == "http_start").count(),
        2
    );
    assert_eq!(
        events
            .iter()
            .filter(|e| e["name"] == "first_answer_text")
            .count(),
        1
    );
    unsupported.assert();
    answer.assert();
}