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 log_ts_re() -> &'static regex::Regex {
static_regex!(r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\S*\s+")
}
fn resource_action_re() -> &'static regex::Regex {
static_regex!(r"(\S+/\S+)\s+(configured|created|unchanged|deleted)")
}
pub fn compress(command: &str, output: &str) -> Option<String> {
if command.contains("logs") || command.contains("log ") {
return Some(compress_logs(output));
}
if command.contains("describe") {
return Some(compress_describe(output));
}
if command.contains("apply") {
return Some(compress_apply(output));
}
if command.contains("delete") {
return Some(compress_delete(output));
}
if command.contains("get") {
return Some(compress_get(output));
}
if command.contains("exec") {
return Some(compress_exec(output));
}
if command.contains("top") {
return Some(compress_top(output));
}
if command.contains("rollout") {
return Some(compress_rollout(output));
}
if command.contains("scale") {
return Some(compress_simple(output));
}
Some(compact_table(output))
}
fn compress_get(output: &str) -> String {
let lines: Vec<&str> = output.lines().collect();
if lines.is_empty() {
return "no resources".to_string();
}
if lines.len() == 1 && lines[0].starts_with("No resources") {
return "no resources".to_string();
}
if lines.len() <= 1 {
return output.trim().to_string();
}
let header = lines[0];
let cols: Vec<&str> = header.split_whitespace().collect();
let status_col = cols.iter().position(|c| c.eq_ignore_ascii_case("STATUS"));
let data_lines: Vec<Vec<&str>> = lines[1..]
.iter()
.map(|l| l.split_whitespace().collect::<Vec<&str>>())
.filter(|p| !p.is_empty())
.collect();
if data_lines.is_empty() {
return "no resources".to_string();
}
let total = data_lines.len();
if let Some(si) = status_col {
if total > 5 {
let mut status_counts: std::collections::HashMap<&str, usize> =
std::collections::HashMap::new();
for row in &data_lines {
if let Some(status) = row.get(si) {
*status_counts.entry(status).or_default() += 1;
}
}
let mut summary_parts: Vec<String> = status_counts
.iter()
.map(|(k, v)| format!("{v} {k}"))
.collect();
summary_parts.sort_by(|a, b| b.cmp(a));
return format!("{total} resources ({})", summary_parts.join(", "));
}
}
let mut rows = Vec::new();
for parts in &data_lines {
let name = parts[0];
let relevant: Vec<&str> = parts.iter().skip(1).take(4).copied().collect();
rows.push(format!("{name} {}", relevant.join(" ")));
}
let col_hint = cols
.iter()
.skip(1)
.take(4)
.copied()
.collect::<Vec<&str>>()
.join(" ");
format!("[{col_hint}]\n{}", rows.join("\n"))
}
fn compress_logs(output: &str) -> String {
let lines: Vec<&str> = output.lines().collect();
if lines.len() <= 10 {
return output.to_string();
}
let mut deduped: Vec<(String, u32)> = Vec::new();
for line in &lines {
let stripped = log_ts_re().replace(line, "").trim().to_string();
if stripped.is_empty() {
continue;
}
if let Some(last) = deduped.last_mut() {
if last.0 == stripped {
last.1 += 1;
continue;
}
}
deduped.push((stripped, 1));
}
let result: Vec<String> = deduped
.iter()
.map(|(line, count)| {
if *count > 1 {
format!("{line} (x{count})")
} else {
line.clone()
}
})
.collect();
if result.len() > 30 {
let tail = &result[result.len() - 20..];
return format!("... ({} lines total)\n{}", lines.len(), tail.join("\n"));
}
result.join("\n")
}
fn compress_describe(output: &str) -> String {
let lines: Vec<&str> = output.lines().collect();
if lines.len() <= 20 {
return output.to_string();
}
let mut sections = Vec::new();
let mut current_section = String::new();
let mut current_lines: Vec<&str> = Vec::new();
for line in &lines {
if !line.starts_with(' ')
&& !line.starts_with('\t')
&& line.ends_with(':')
&& !line.contains(" ")
{
if !current_section.is_empty() {
let count = current_lines.len();
if count <= 3 {
sections.push(format!("{current_section}\n{}", current_lines.join("\n")));
} else {
sections.push(format!("{current_section} ({count} lines)"));
}
}
current_section = line.trim_end_matches(':').to_string();
current_lines.clear();
} else {
current_lines.push(line);
}
}
if !current_section.is_empty() {
let count = current_lines.len();
if current_section == "Events" && count > 5 {
let last_events = ¤t_lines[count.saturating_sub(5)..];
sections.push(format!(
"Events (last 5 of {count}):\n{}",
last_events.join("\n")
));
} else if count <= 5 {
sections.push(format!("{current_section}\n{}", current_lines.join("\n")));
} else {
sections.push(format!("{current_section} ({count} lines)"));
}
}
sections.join("\n")
}
fn compress_apply(output: &str) -> String {
let trimmed = output.trim();
if trimmed.is_empty() {
return "ok".to_string();
}
let mut configured = 0u32;
let mut created = 0u32;
let mut unchanged = 0u32;
let mut deleted = 0u32;
let mut resources = Vec::new();
for line in trimmed.lines() {
if let Some(caps) = resource_action_re().captures(line) {
let resource = &caps[1];
let action = &caps[2];
match action {
"configured" => configured += 1,
"created" => created += 1,
"unchanged" => unchanged += 1,
"deleted" => deleted += 1,
_ => {}
}
resources.push(format!("{resource} {action}"));
}
}
let total = configured + created + unchanged + deleted;
if total == 0 {
return compact_output(trimmed, 5);
}
let mut summary = Vec::new();
if created > 0 {
summary.push(format!("{created} created"));
}
if configured > 0 {
summary.push(format!("{configured} configured"));
}
if unchanged > 0 {
summary.push(format!("{unchanged} unchanged"));
}
if deleted > 0 {
summary.push(format!("{deleted} deleted"));
}
format!("ok ({total} resources: {})", summary.join(", "))
}
fn compress_delete(output: &str) -> String {
let trimmed = output.trim();
if trimmed.is_empty() {
return "ok".to_string();
}
let deleted: Vec<&str> = trimmed.lines().filter(|l| l.contains("deleted")).collect();
if deleted.is_empty() {
return compact_output(trimmed, 3);
}
format!("deleted {} resources", deleted.len())
}
fn compress_exec(output: &str) -> String {
let trimmed = output.trim();
if trimmed.is_empty() {
return "ok".to_string();
}
let lines: Vec<&str> = trimmed.lines().collect();
if lines.len() > 20 {
let tail = &lines[lines.len() - 10..];
return format!("... ({} lines)\n{}", lines.len(), tail.join("\n"));
}
trimmed.to_string()
}
fn compress_top(output: &str) -> String {
compact_table(output)
}
fn compress_rollout(output: &str) -> String {
compact_output(output, 5)
}
fn compress_simple(output: &str) -> String {
let trimmed = output.trim();
if trimmed.is_empty() {
return "ok".to_string();
}
compact_output(trimmed, 3)
}
fn compact_table(text: &str) -> String {
let lines: Vec<&str> = text.lines().filter(|l| !l.trim().is_empty()).collect();
if lines.len() <= 15 {
return lines.join("\n");
}
format!(
"{}\n... ({} more rows)",
lines[..15].join("\n"),
lines.len() - 15
)
}
fn compact_output(text: &str, max: usize) -> String {
let lines: Vec<&str> = text.lines().filter(|l| !l.trim().is_empty()).collect();
if lines.len() <= max {
return lines.join("\n");
}
format!(
"{}\n... ({} more lines)",
lines[..max].join("\n"),
lines.len() - max
)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn get_pods_many_aggregates_by_status() {
let output = "\
NAME READY STATUS RESTARTS AGE
api-server-abc123 1/1 Running 0 5d
api-server-def456 1/1 Running 0 5d
worker-1-ghi789 1/1 Running 2 3d
worker-2-jkl012 1/1 Running 0 3d
scheduler-mno345 0/1 Pending 0 1h
cache-pqr678 0/1 CrashLoopBackOff 5 2d
db-stu901 1/1 Running 0 10d
";
let result = compress("kubectl get pods -A", output);
let r = result.unwrap();
assert!(r.contains("7 resources"));
assert!(r.contains("Running"));
assert!(r.contains("Pending"));
assert!(r.contains("CrashLoopBackOff"));
}
#[test]
fn get_pods_few_shows_compact_table() {
let output = "\
NAME READY STATUS RESTARTS AGE
my-pod-123 1/1 Running 0 5d
my-pod-456 1/1 Running 0 3d
";
let result = compress("kubectl get pods", output);
let r = result.unwrap();
assert!(r.contains("my-pod-123"));
assert!(r.contains("[READY STATUS RESTARTS AGE]"));
}
#[test]
fn get_no_resources() {
let result = compress(
"kubectl get pods",
"No resources found in default namespace.\n",
);
assert_eq!(result.unwrap(), "no resources");
}
#[test]
fn apply_aggregates_actions() {
let output = "\
service/api-gateway configured
deployment.apps/api-server configured
configmap/settings created
secret/db-credentials unchanged
";
let result = compress("kubectl apply -f deploy/", output);
let r = result.unwrap();
assert!(r.contains("4 resources"));
assert!(r.contains("2 configured"));
assert!(r.contains("1 created"));
assert!(r.contains("1 unchanged"));
}
#[test]
fn logs_deduplicates_repeated_lines() {
let mut lines = Vec::new();
for i in 0..20 {
lines.push(format!("2026-05-25T10:{i:02}:00Z INFO: Processing request"));
}
lines.push("2026-05-25T10:20:00Z ERROR: Connection refused".to_string());
let output = lines.join("\n");
let result = compress("kubectl logs my-pod", &output);
let r = result.unwrap();
assert!(r.contains("(x"));
assert!(r.contains("Connection refused"));
}
#[test]
fn describe_extracts_events() {
let mut output = String::new();
output.push_str("Name: my-pod\n");
output.push_str("Namespace: default\n");
output.push_str("Labels:\n");
for i in 0..10 {
output.push_str(&format!(" app=myapp-{i}\n"));
}
output.push_str("Conditions:\n");
output.push_str(" Type Status\n");
output.push_str(" Ready True\n");
output.push_str("Events:\n");
for i in 0..8 {
output.push_str(&format!(" Normal Pulled {i}m kubelet pulled image\n"));
}
let result = compress("kubectl describe pod my-pod", &output);
let r = result.unwrap();
assert!(r.contains("Events (last 5 of 8)"));
}
#[test]
fn delete_counts_resources() {
let output = "\
pod \"worker-1\" deleted
pod \"worker-2\" deleted
pod \"worker-3\" deleted
";
let result = compress("kubectl delete pods -l app=worker", output);
assert_eq!(result.unwrap(), "deleted 3 resources");
}
}