use std::collections::{BTreeMap, BTreeSet};
use std::fs;
use std::path::{Path, PathBuf};
use std::time::UNIX_EPOCH;
use serde_json::{json, Value};
use supercode_harness::{
harness_support_registry, DiscoveryQuery, HarnessCatalog, HarnessHomes, HarnessId, Session,
};
fn argument<T: std::str::FromStr>(name: &str) -> T {
let mut arguments = std::env::args();
while let Some(argument) = arguments.next() {
if argument == name {
return arguments
.next()
.unwrap_or_else(|| panic!("{name} requires a value"))
.parse()
.unwrap_or_else(|_| panic!("invalid value for {name}"));
}
}
panic!("required argument {name} is missing")
}
fn collect_jsonl(root: &Path, output: &mut Vec<PathBuf>) {
let Ok(entries) = fs::read_dir(root) else {
return;
};
for entry in entries.flatten() {
let path = entry.path();
let Ok(kind) = entry.file_type() else {
continue;
};
if kind.is_dir() {
if path.file_name().and_then(|name| name.to_str()) != Some("subagents") {
collect_jsonl(&path, output);
}
} else if kind.is_file()
&& path.extension().and_then(|value| value.to_str()) == Some("jsonl")
{
output.push(path);
}
}
}
fn modified(path: &Path) -> u128 {
fs::metadata(path)
.and_then(|metadata| metadata.modified())
.ok()
.and_then(|time| time.duration_since(UNIX_EPOCH).ok())
.map(|duration| duration.as_millis())
.unwrap_or_default()
}
fn jsonl_sample(
root: &Path,
sample_size: usize,
max_sample_bytes: u64,
required_file_name: Option<&str>,
) -> Value {
let mut paths = Vec::new();
collect_jsonl(root, &mut paths);
if let Some(name) = required_file_name {
paths.retain(|path| path.file_name().and_then(|value| value.to_str()) == Some(name));
}
let observed = paths.len();
paths.retain(|path| {
fs::metadata(path)
.map(|metadata| metadata.len() <= max_sample_bytes)
.unwrap_or(false)
});
let eligible = paths.len();
paths.sort_by_key(|path| std::cmp::Reverse(modified(path)));
paths.truncate(sample_size);
let mut loaded = 0;
let mut failures = 0;
let mut messages = 0;
for path in paths {
match Session::load(path) {
Ok(session) => {
loaded += 1;
messages += session.messages.len();
}
Err(_) => failures += 1,
}
}
json!({
"status": if loaded >= sample_size && failures == 0 { "verified" } else { "insufficient" },
"observed": observed,
"eligible_under_byte_cap": eligible,
"max_sample_bytes": max_sample_bytes,
"requested": sample_size,
"loaded": loaded,
"load_failures": failures,
"messages": messages,
})
}
fn opencode_sample(
catalog: &HarnessCatalog,
homes: &HarnessHomes,
sample_size: usize,
max_sample_bytes: u64,
) -> Value {
let discovered = catalog
.discover(&DiscoveryQuery {
harnesses: vec![HarnessId::from(HarnessId::OPENCODE)],
homes: homes.clone(),
limit: Some(sample_size),
..DiscoveryQuery::default()
})
.expect("OpenCode corpus discovery is read-only");
let mut loaded = 0;
let mut failures = 0;
let mut messages = 0;
let mut oversized = 0;
for descriptor in &discovered {
match catalog.load(&descriptor.locator) {
Ok(session) => {
let encoded_bytes = session
.to_jsonl(supercode_harness::SessionFormat::OpenCode)
.map(|encoded| encoded.len() as u64)
.unwrap_or(u64::MAX);
if encoded_bytes <= max_sample_bytes {
loaded += 1;
messages += session.messages.len();
} else {
oversized += 1;
}
}
Err(_) => failures += 1,
}
}
json!({
"status": if loaded >= sample_size && failures == 0 { "verified" } else { "insufficient" },
"observed_at_least": discovered.len(),
"requested": sample_size,
"loaded": loaded,
"load_failures": failures,
"oversized": oversized,
"max_sample_bytes": max_sample_bytes,
"messages": messages,
})
}
fn catalog_sample(
catalog: &HarnessCatalog,
homes: &HarnessHomes,
harness: &str,
sample_size: usize,
max_sample_bytes: u64,
) -> Value {
let discovered = catalog
.discover(&DiscoveryQuery {
harnesses: vec![HarnessId::from(harness)],
homes: homes.clone(),
limit: Some(sample_size),
..DiscoveryQuery::default()
})
.expect("native corpus discovery is read-only");
let mut loaded = 0;
let mut failures = 0;
let mut messages = 0;
let mut oversized = 0;
for descriptor in &discovered {
match catalog.load(&descriptor.locator) {
Ok(session) => {
if session.to_native_jsonl().len() as u64 <= max_sample_bytes {
loaded += 1;
messages += session.messages.len();
} else {
oversized += 1;
}
}
Err(_) => failures += 1,
}
}
json!({
"status": if loaded >= sample_size && failures == 0 { "verified" } else { "insufficient" },
"observed_at_least": discovered.len(),
"requested": sample_size,
"loaded": loaded,
"load_failures": failures,
"oversized": oversized,
"max_sample_bytes": max_sample_bytes,
"messages": messages,
})
}
fn main() {
let sample_size = argument("--sample-size");
let max_sample_bytes = argument("--max-bytes");
let homes = HarnessHomes::default();
let catalog = HarnessCatalog::new();
let harnesses = BTreeMap::from([
(
HarnessId::CLAUDE_CODE,
jsonl_sample(&homes.claude_code, sample_size, max_sample_bytes, None),
),
(
HarnessId::CODEX,
jsonl_sample(&homes.codex, sample_size, max_sample_bytes, None),
),
(
HarnessId::PI,
jsonl_sample(&homes.pi, sample_size, max_sample_bytes, None),
),
(
HarnessId::OPENCODE,
opencode_sample(&catalog, &homes, sample_size, max_sample_bytes),
),
(
HarnessId::GROK,
jsonl_sample(
&homes.grok,
sample_size,
max_sample_bytes,
Some("chat_history.jsonl"),
),
),
(
HarnessId::GEMINI,
catalog_sample(
&catalog,
&homes,
HarnessId::GEMINI,
sample_size,
max_sample_bytes,
),
),
(
HarnessId::GOOSE,
catalog_sample(
&catalog,
&homes,
HarnessId::GOOSE,
sample_size,
max_sample_bytes,
),
),
(
HarnessId::SUPERCODE,
catalog_sample(
&catalog,
&homes,
HarnessId::SUPERCODE,
sample_size,
max_sample_bytes,
),
),
]);
let registry_ids = harness_support_registry()
.harnesses
.into_iter()
.map(|harness| harness.id.0)
.collect::<BTreeSet<_>>();
let sampled_ids = harnesses
.keys()
.map(|id| (*id).to_owned())
.collect::<BTreeSet<_>>();
assert_eq!(
sampled_ids, registry_ids,
"every registry harness needs exactly one corpus sampler"
);
println!(
"{}",
serde_json::to_string_pretty(&json!({
"schema": "supercode.corpus-probe.v1",
"scope": "local-read-only-bounded-sample",
"sample_size": sample_size,
"max_sample_bytes": max_sample_bytes,
"content_emitted": false,
"harnesses": harnesses,
}))
.expect("serialize corpus probe")
);
}