macro_rules! static_regex {
($pattern:expr) => {{
static RE: std::sync::OnceLock<regex::Regex> = std::sync::OnceLock::new();
RE.get_or_init(|| {
regex::Regex::new($pattern).expect(concat!("BUG: invalid static regex: ", $pattern))
})
}};
}
fn timestamp_re() -> &'static regex::Regex {
static_regex!(r"^\[?\d{4}[-/]\d{2}[-/]\d{2}[T ]\d{2}:\d{2}:\d{2}[^\]\s]*\]?\s*")
}
fn is_block_separator(line: &str) -> bool {
let t = line.trim();
if t.is_empty() {
return false;
}
if t.len() >= 3 && t.chars().all(|c| c == '=' || c == '-') {
return true;
}
if t.starts_with("===") || t.starts_with("---") {
return true;
}
if t.starts_with("commit ")
&& t.len() >= 12
&& t[7..].starts_with(|c: char| c.is_ascii_hexdigit())
{
return true;
}
if t.starts_with("diff --git ") {
return true;
}
if t.starts_with("##") || t.starts_with("Step ") || t.starts_with("STEP ") {
return true;
}
false
}
struct Block {
separator: Option<String>,
entries: Vec<(String, u32)>,
}
pub fn compress(output: &str) -> Option<String> {
let lines: Vec<&str> = output.lines().collect();
if lines.len() <= 10 {
return None;
}
let mut blocks: Vec<Block> = Vec::new();
let mut current = Block {
separator: None,
entries: Vec::new(),
};
let mut error_lines = Vec::new();
let total_lines = lines.len();
for line in &lines {
let stripped = timestamp_re().replace(line, "").trim().to_string();
if stripped.is_empty() {
continue;
}
if is_block_separator(&stripped) {
if !current.entries.is_empty() || current.separator.is_some() {
blocks.push(current);
}
current = Block {
separator: Some(stripped.clone()),
entries: Vec::new(),
};
continue;
}
let lower = stripped.to_lowercase();
if lower.contains("error")
|| lower.contains("critical")
|| lower.contains("fatal")
|| lower.contains("panic")
|| lower.contains("exception")
{
error_lines.push(stripped.clone());
}
if let Some(last) = current.entries.last_mut() {
if last.0 == stripped {
last.1 += 1;
continue;
}
}
current.entries.push((stripped, 1));
}
if !current.entries.is_empty() || current.separator.is_some() {
blocks.push(current);
}
let total_unique: usize = blocks.iter().map(|b| b.entries.len()).sum();
let mut parts = Vec::new();
parts.push(format!("{total_lines} lines → {total_unique} unique"));
if !error_lines.is_empty() {
parts.push(format!("{} errors:", error_lines.len()));
for e in error_lines.iter().take(5) {
parts.push(format!(" {e}"));
}
if error_lines.len() > 5 {
parts.push(format!(" ... +{} more errors", error_lines.len() - 5));
}
}
let has_multiple_blocks = blocks.len() > 1;
for block in &blocks {
if let Some(sep) = &block.separator {
parts.push(sep.clone());
}
let formatted: Vec<String> = block
.entries
.iter()
.map(|(line, count)| {
if *count > 1 {
format!("{line} (x{count})")
} else {
line.clone()
}
})
.collect();
if !has_multiple_blocks && formatted.len() > 30 {
let tail = &formatted[formatted.len() - 15..];
parts.push(format!("last 15 unique lines:\n{}", tail.join("\n")));
} else if has_multiple_blocks && formatted.len() > 20 {
for line in formatted.iter().take(5) {
parts.push(line.clone());
}
let omitted = formatted.len() - 10;
parts.push(format!("[{omitted} lines omitted]"));
for line in formatted.iter().skip(formatted.len() - 5) {
parts.push(line.clone());
}
} else {
for line in &formatted {
parts.push(line.clone());
}
}
}
Some(parts.join("\n"))
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn short_output_returns_none() {
let output = "line1\nline2\nline3";
assert!(compress(output).is_none());
}
#[test]
fn deduplicates_consecutive_lines() {
let lines = vec!["INFO Processing request"; 15];
let output = lines.join("\n");
let result = compress(&output).unwrap();
assert!(result.contains("(x15)"), "must show repeat count: {result}");
assert!(
result.contains("15 lines"),
"must show total lines: {result}"
);
}
#[test]
fn respects_block_separators_equals() {
let mut lines = vec!["=== commit aaaa001 ==="];
lines.extend(vec!["file_a.rs | 10 +++++"; 5]);
lines.push("=== commit aaaa002 ===");
lines.extend(vec!["file_b.rs | 20 ++++++++++"; 5]);
let output = lines.join("\n");
let result = compress(&output).unwrap();
assert!(
result.contains("=== commit aaaa001 ==="),
"first block separator must be preserved: {result}"
);
assert!(
result.contains("=== commit aaaa002 ==="),
"second block separator must be preserved: {result}"
);
assert!(
result.contains("file_a.rs"),
"first block content must be preserved: {result}"
);
assert!(
result.contains("file_b.rs"),
"second block content must be preserved: {result}"
);
}
#[test]
fn does_not_merge_across_blocks() {
let lines = vec![
"=== block 1 ===",
"same line",
"same line",
"same line",
"=== block 2 ===",
"same line",
"same line",
"=== block 3 ===",
"same line",
"same line",
"different line here",
];
let output = lines.join("\n");
let result = compress(&output).unwrap();
assert!(
result.contains("=== block 1 ==="),
"block 1 must exist: {result}"
);
assert!(
result.contains("=== block 2 ==="),
"block 2 must exist: {result}"
);
assert!(
result.contains("=== block 3 ==="),
"block 3 must exist: {result}"
);
let count_same = result.matches("same line").count();
assert!(
count_same >= 3,
"each block must have its own 'same line' entry, got {count_same}: {result}"
);
}
#[test]
fn git_commit_separator_detected() {
assert!(is_block_separator("commit abc1234def5678"));
assert!(is_block_separator("commit 1a2b3c4d5e6f7890"));
assert!(!is_block_separator("committed to fixing"));
}
#[test]
fn diff_separator_detected() {
assert!(is_block_separator("diff --git a/file.rs b/file.rs"));
assert!(!is_block_separator("different approach"));
}
#[test]
fn triple_equals_dashes_detected() {
assert!(is_block_separator("==="));
assert!(is_block_separator("=========="));
assert!(is_block_separator("---"));
assert!(is_block_separator("-----------"));
assert!(is_block_separator("=== test block ==="));
assert!(is_block_separator("--- a/file.rs"));
}
#[test]
fn error_lines_preserved_across_blocks() {
let lines = vec![
"=== step 1 ===",
"ok line",
"ok line",
"ok line",
"ERROR: something failed",
"ok line",
"ok line",
"ok line",
"=== step 2 ===",
"ok line 2",
"ok line 2",
"ok line 2",
"ok line 2",
"ok line 2",
"ok line 2",
];
let output = lines.join("\n");
let result = compress(&output).unwrap();
assert!(
result.contains("1 errors:"),
"error count must be shown: {result}"
);
assert!(
result.contains("ERROR: something failed"),
"error line must be preserved: {result}"
);
}
#[test]
fn git_show_loop_not_deduplicated() {
let commits = [
(
"aaaa001",
"accounts_test.exs | 70 ++",
"schema_test.exs | 30 ++",
),
("aaaa002", "query_test.exs | 45 ++", "api_test.exs | 12 ++"),
("aaaa003", "main_test.exs | 55 ++", "helper_test.exs | 8 ++"),
];
let mut lines = Vec::new();
for (sha, file1, file2) in &commits {
lines.push(format!("=== {sha} ==="));
lines.push(file1.to_string());
lines.push(file2.to_string());
lines.push("2 files changed".to_string());
lines.push(String::new());
}
let output = lines.join("\n");
let result = compress(&output).unwrap();
assert!(
result.contains("aaaa001") && result.contains("aaaa002") && result.contains("aaaa003"),
"all commit separators must be preserved: {result}"
);
assert!(
result.contains("accounts_test.exs"),
"first commit files must be present: {result}"
);
assert!(
result.contains("query_test.exs"),
"second commit files must be present: {result}"
);
assert!(
result.contains("main_test.exs"),
"third commit files must be present: {result}"
);
}
}