use std::fs;
use std::path::{Path, PathBuf};
use std::time::{SystemTime, UNIX_EPOCH};
use supercode_harness::audit::{audit_dir, Corpus, Coverage};
use supercode_harness::{
core_messages, measure_fidelity, DiscoveryQuery, HarnessCatalog, HarnessHomes, HarnessId, Role,
Session, SessionFormat, SessionSource, SessionWatchEvent,
};
fn fixture(name: &str) -> PathBuf {
Path::new(env!("CARGO_MANIFEST_DIR"))
.join("tests/fixtures/grok_session")
.join(name)
}
fn temp_dir(label: &str) -> PathBuf {
let nonce = SystemTime::now()
.duration_since(UNIX_EPOCH)
.unwrap()
.as_nanos();
let path = std::env::temp_dir().join(format!(
"supercode-grok-{label}-{}-{nonce}",
std::process::id()
));
fs::create_dir_all(&path).unwrap();
path
}
#[test]
fn loads_sanitized_native_transcript_with_tools_and_metadata() {
let text = fs::read_to_string(fixture("chat_history.jsonl")).unwrap();
let session = Session::from_grok_str(&text).unwrap();
assert_eq!(session.meta.source, SessionSource::Grok);
assert_eq!(session.meta.model.as_deref(), Some("grok-code-fixture"));
assert!(session.meta.system_prompt.is_some());
assert_eq!(session.messages.len(), 6);
assert_eq!(session.messages[0].role, Role::User);
assert_eq!(session.messages[1].tool_calls().len(), 1);
assert_eq!(
session.messages[1].tool_calls()[0].function.name,
"read_file"
);
assert_eq!(session.messages[2].role, Role::Tool);
assert_eq!(session.messages[2].name.as_deref(), Some("read_file"));
assert!(session.messages[3].content.is_none());
assert_eq!(
session.messages[3].tool_calls()[0].function.name,
"list_files"
);
assert_eq!(
session.messages[3]
.metadata
.get("grok_model_fingerprint")
.map(String::as_str),
Some("fixture-fingerprint")
);
assert_eq!(session.raw_verbatim(), text);
assert_eq!(session.parse_error_lines, 0);
}
#[test]
fn normalizes_grok_user_wrappers_and_ignores_injected_context() {
let session = Session::from_grok_str(
r#"{"type":"user","content":[{"type":"text","text":"<user_info>private context</user_info>"}]}
{"type":"user","content":[{"type":"text","text":"<system-reminder>private reminder</system-reminder>"}]}
{"type":"user","content":[{"type":"text","text":"<user_query>hello terminal</user_query>"}],"prompt_index":4}
"#,
)
.unwrap();
assert_eq!(session.messages.len(), 1);
assert_eq!(
session.messages[0].content.as_deref(),
Some("hello terminal")
);
assert_eq!(
session.messages[0]
.metadata
.get("grok_prompt_index")
.map(String::as_str),
Some("4")
);
}
#[test]
fn grok_semantic_export_reloads_and_cross_exports_to_every_existing_format() {
let original = Session::from_grok(fixture("chat_history.jsonl")).unwrap();
let grok = original.to_jsonl(SessionFormat::Grok).unwrap();
let reloaded = Session::from_grok_str(&grok).unwrap();
assert_eq!(reloaded.messages, original.messages);
for target in [
SessionFormat::ClaudeCode,
SessionFormat::Codex,
SessionFormat::OpenCode,
SessionFormat::Pi,
] {
let exported = original.to_jsonl(target).unwrap();
let translated = Session::load_str(&exported, target).unwrap();
let metric = measure_fidelity(
&core_messages(&original.messages),
&core_messages(&translated.messages),
);
assert!(
metric.is_semantically_lossless(),
"Grok -> {target:?} residue: {:?}",
metric.residue
);
}
}
#[test]
fn grok_tool_only_metadata_survives_codex_and_a_second_translation_hop() {
let original = Session::from_grok_str(
r#"{"type":"user","content":[{"type":"text","text":"Search for it."}],"prompt_index":7}
{"type":"assistant","content":"","tool_calls":[{"id":"call-tool-only","name":"tool_search","arguments":"{\"query\":\"needle\"}"}],"model_id":"grok-tool-only","model_fingerprint":"fingerprint-tool-only","reasoning_effort":"high"}
{"type":"tool_result","tool_call_id":"call-tool-only","content":"[]"}
"#,
)
.unwrap();
let codex = original.to_jsonl(SessionFormat::Codex).unwrap();
let from_codex = Session::load_str(&codex, SessionFormat::Codex).unwrap();
let assistant = from_codex
.messages
.iter()
.find(|message| message.role == Role::Assistant)
.unwrap();
assert_eq!(
assistant.metadata.get("grok_model_id").map(String::as_str),
Some("grok-tool-only")
);
assert_eq!(
assistant
.metadata
.get("grok_model_fingerprint")
.map(String::as_str),
Some("fingerprint-tool-only")
);
let pi = from_codex.to_jsonl(SessionFormat::Pi).unwrap();
let from_pi = Session::load_str(&pi, SessionFormat::Pi).unwrap();
let grok = from_pi.to_jsonl(SessionFormat::Grok).unwrap();
let round_tripped = Session::load_str(&grok, SessionFormat::Grok).unwrap();
let assistant = round_tripped
.messages
.iter()
.find(|message| message.role == Role::Assistant)
.unwrap();
assert_eq!(
assistant.metadata.get("grok_model_id").map(String::as_str),
Some("grok-tool-only")
);
assert_eq!(
assistant
.metadata
.get("grok_reasoning_effort")
.map(String::as_str),
Some("high")
);
}
#[test]
fn native_wrapper_and_spliced_export_preserve_the_grok_prefix() {
let text = fs::read_to_string(fixture("chat_history.jsonl")).unwrap();
let original = Session::from_grok_str(&text).unwrap();
let wrapped = original.to_native_jsonl();
let reconstructed = Session::from_native_str(&wrapped).unwrap();
assert_eq!(reconstructed.meta.source, SessionSource::Grok);
assert_eq!(reconstructed.raw_verbatim(), text);
let sidecar = original.to_native_jsonl_v2(&[supercode_harness::ChatMessage::user(
"A new continuation turn.",
)]);
let continued = Session::from_sidecar_str(&sidecar).unwrap();
let spliced = continued
.to_jsonl_spliced(SessionFormat::Grok, None)
.unwrap();
assert!(spliced.starts_with(&text));
let reloaded = Session::from_grok_str(&spliced).unwrap();
assert_eq!(
reloaded
.messages
.last()
.and_then(|message| message.content.as_deref()),
Some("A new continuation turn.")
);
}
#[test]
fn catalog_discovers_loads_and_passively_follows_grok() {
let root = temp_dir("catalog");
let workspace = root.join("fixture-workspace");
let encoded_workspace = workspace.to_string_lossy().replace('/', "%2F");
let session_dir = root
.join("sessions")
.join(encoded_workspace)
.join("grok-fixture-session");
fs::create_dir_all(&session_dir).unwrap();
for name in ["chat_history.jsonl", "summary.json", "updates.jsonl"] {
fs::copy(fixture(name), session_dir.join(name)).unwrap();
}
let catalog = HarnessCatalog::new();
let found = catalog
.discover(&DiscoveryQuery {
workspace: Some(workspace.clone()),
harnesses: vec![HarnessId::from(HarnessId::GROK)],
homes: HarnessHomes {
grok: root.join("sessions"),
..HarnessHomes::default()
},
..DiscoveryQuery::default()
})
.unwrap();
assert_eq!(found.len(), 1);
let descriptor = &found[0];
assert_eq!(descriptor.locator.harness.as_str(), HarnessId::GROK);
assert_eq!(descriptor.locator.session_id, "grok-fixture-session");
assert_eq!(descriptor.cwd.as_deref(), Some(workspace.as_path()));
assert_eq!(
descriptor.title.as_deref(),
Some("Sanitized fixture session")
);
assert_eq!(descriptor.message_count, Some(6));
let loaded = catalog.load(&descriptor.locator).unwrap();
assert_eq!(
loaded.meta.session_id.as_deref(),
Some("grok-fixture-session")
);
assert_eq!(loaded.meta.cwd.as_deref(), Some(workspace.as_path()));
let mut follower = catalog.follow(&descriptor.locator).unwrap();
assert!(matches!(
follower.poll().unwrap(),
Some(SessionWatchEvent::SessionSnapshot { .. })
));
let transcript = session_dir.join("chat_history.jsonl");
let mut text = fs::read_to_string(&transcript).unwrap();
text.push_str(
"{\"type\":\"assistant\",\"content\":\"A live appended reply.\",\"tool_calls\":[],\"model_id\":\"grok-code-fixture\"}\n",
);
fs::write(&transcript, text).unwrap();
match follower.poll().unwrap() {
Some(SessionWatchEvent::MessagesAppended { messages, .. }) => {
assert_eq!(messages.len(), 1);
assert_eq!(
messages[0].content.as_deref(),
Some("A live appended reply.")
);
}
other => panic!("expected appended Grok message, got {other:?}"),
}
fs::remove_dir_all(root).ok();
}
#[test]
fn corpus_audit_scores_only_resumable_grok_transcripts() {
let report = audit_dir(&fixture("."), Corpus::Grok, None);
assert_eq!(report.corpus, Some("grok"));
assert_eq!(
report.files, 1,
"updates.jsonl is not a resumable transcript"
);
assert_eq!(report.parse_errors, 0);
assert_eq!(report.records["user"].0, Coverage::Normalized);
assert_eq!(
report.records["assistant/tool_call"].0,
Coverage::Normalized
);
assert_eq!(report.records["reasoning"].0, Coverage::Dropped);
assert!(!report
.records
.values()
.any(|(coverage, _)| *coverage == Coverage::Unmodeled));
}
#[test]
fn grok_local_corpus_loads_when_requested() {
if std::env::var_os("SUPERCODE_CORPUS").is_none() {
return;
}
let catalog = HarnessCatalog::new();
let sessions = catalog
.discover(&DiscoveryQuery {
harnesses: vec![HarnessId::from(HarnessId::GROK)],
..DiscoveryQuery::default()
})
.unwrap();
assert!(!sessions.is_empty(), "no Grok sessions discovered");
let mut errors = Vec::new();
let mut nonempty = 0usize;
for descriptor in &sessions {
match catalog.load(&descriptor.locator) {
Ok(session) if !session.messages.is_empty() => nonempty += 1,
Ok(_) => {}
Err(error) => errors.push(format!("{}: {error}", descriptor.locator.session_id)),
}
}
assert!(errors.is_empty(), "Grok corpus load failures: {errors:?}");
assert!(
nonempty * 10 >= sessions.len() * 9,
"too many empty Grok parses: {nonempty}/{}",
sessions.len()
);
}