supercode-core 0.1.0

//! Guarantees about the typed schema's coverage of the real corpus.
//!
//! The fixture-level tests run always; the corpus-level guarantee (no record
//! type anywhere in thousands of real logs falls into an `Unknown` typed
//! bucket) is opt-in via `SUPERCODE_CORPUS=1`.

use std::path::PathBuf;

use supercode::audit::{audit_dir, Corpus};

#[test]
fn fixtures_have_no_unknown_records() {
    // Each committed fixture must parse fully into modeled discriminants when
    // read with its OWN format's parser. (They live in one dir, so isolate each
    // into a temp dir keyed by format before auditing.)
    let fixtures = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("tests/fixtures");
    for (file, corpus) in [
        ("claude_code_session.jsonl", Corpus::ClaudeCode),
        ("codex_session.jsonl", Corpus::Codex),
    ] {
        let tmp = std::env::temp_dir().join(format!(
            "sc-cov-{}-{}",
            std::process::id(),
            file.replace('.', "_")
        ));
        std::fs::create_dir_all(&tmp).unwrap();
        std::fs::copy(fixtures.join(file), tmp.join(file)).unwrap();

        let report = audit_dir(&tmp, corpus, None);
        assert_eq!(report.parse_errors, 0, "{corpus:?}: typed parse errors");
        let unknown: Vec<_> = report
            .records
            .keys()
            .filter(|k| k.starts_with("<line>/"))
            .collect();
        assert!(
            unknown.is_empty(),
            "{corpus:?}: unknown record discriminants: {unknown:?}"
        );
        std::fs::remove_dir_all(&tmp).ok();
    }
}

/// P6 sub-discriminant guard: the top-level `Unknown` check can't see payload
/// types nested under `event_msg`/`response_item`, `system.subtype`, or
/// `attachment.type`. This walks the corpus and fails if a record key the audit
/// reports is **not** in our known set — so a newly-appearing sub-discriminant
/// surfaces instead of being silently dropped.
#[test]
#[ignore = "requires local session corpus; set SUPERCODE_CORPUS=1"]
fn corpus_subdiscriminants_are_all_known() {
    if std::env::var("SUPERCODE_CORPUS").is_err() {
        panic!(
            "SUPERCODE_CORPUS not set — this corpus test asserts nothing without \
             the maintainer's local session logs; set SUPERCODE_CORPUS=1 to run it."
        );
    }
    let home = std::env::var("HOME").unwrap();
    // Known record keys (prefix match) the audit may emit. A new sub-discriminant
    // produces a key not covered here, failing the test with its name.
    let known_prefixes = [
        // Codex
        "response_item/",
        "event_msg/",
        "session_meta",
        "turn_context",
        "compacted",
        // Claude
        "user",
        "assistant",
        "system/",
        "attachment",
        "file-history-snapshot",
        "ai-title",
        "permission-mode",
        "mode",
        "last-prompt",
        "queue-operation",
        "pr-link",
        "agent-name",
        "started",
        "result",
        "worktree-state",
    ];
    let known = |k: &str| known_prefixes.iter().any(|p| k.starts_with(p));

    for (sub, corpus) in [
        (".claude/projects", Corpus::ClaudeCode),
        (".codex/sessions", Corpus::Codex),
    ] {
        let dir = PathBuf::from(&home).join(sub);
        let report = audit_dir(&dir, corpus, Some(800));
        let unknown: Vec<&String> = report
            .records
            .keys()
            .filter(|k| !k.starts_with("<line>/") && !known(k))
            .collect();
        assert!(
            unknown.is_empty(),
            "{corpus:?}: unmodeled sub-discriminants (add handling or extend the known set): {unknown:?}"
        );
    }
}

#[test]
#[ignore = "requires local session corpus; set SUPERCODE_CORPUS=1"]
fn corpus_has_no_unknown_record_types() {
    if std::env::var("SUPERCODE_CORPUS").is_err() {
        panic!(
            "SUPERCODE_CORPUS not set — this corpus test asserts nothing without \
             the maintainer's local session logs; set SUPERCODE_CORPUS=1 to run it."
        );
    }
    let home = std::env::var("HOME").unwrap();
    for (sub, corpus) in [
        (".claude/projects", Corpus::ClaudeCode),
        (".codex/sessions", Corpus::Codex),
    ] {
        let dir = PathBuf::from(&home).join(sub);
        let report = audit_dir(&dir, corpus, Some(1500));
        eprintln!(
            "{corpus:?}: files={} lines={} parse_errors={}",
            report.files, report.lines, report.parse_errors
        );
        // Every line must deserialize into the typed schema.
        assert_eq!(report.parse_errors, 0, "{corpus:?}: typed parse errors");
        // No record/envelope type may fall into the Unknown bucket — if a new
        // one appears, this fails and tells us exactly what to model.
        let unknown: Vec<_> = report
            .records
            .keys()
            .filter(|k| k.starts_with("<line>/"))
            .collect();
        assert!(
            unknown.is_empty(),
            "{corpus:?}: unmodeled record discriminants found: {unknown:?}"
        );
    }
}