@hasna/terminal 2.0.5 → 2.3.0

package/temp/rtk/src/container.rs

@@ -0,0 +1,855 @@
+use crate::tracking;
+use anyhow::{Context, Result};
+use std::ffi::OsString;
+use std::process::Command;
+
+#[derive(Debug, Clone, Copy)]
+pub enum ContainerCmd {
+    DockerPs,
+    DockerImages,
+    DockerLogs,
+    KubectlPods,
+    KubectlServices,
+    KubectlLogs,
+}
+
+pub fn run(cmd: ContainerCmd, args: &[String], verbose: u8) -> Result<()> {
+    match cmd {
+        ContainerCmd::DockerPs => docker_ps(verbose),
+        ContainerCmd::DockerImages => docker_images(verbose),
+        ContainerCmd::DockerLogs => docker_logs(args, verbose),
+        ContainerCmd::KubectlPods => kubectl_pods(args, verbose),
+        ContainerCmd::KubectlServices => kubectl_services(args, verbose),
+        ContainerCmd::KubectlLogs => kubectl_logs(args, verbose),
+    }
+}
+
+fn docker_ps(_verbose: u8) -> Result<()> {
+    let timer = tracking::TimedExecution::start();
+
+    let raw = Command::new("docker")
+        .args(["ps"])
+        .output()
+        .map(|o| String::from_utf8_lossy(&o.stdout).to_string())
+        .unwrap_or_default();
+
+    let output = Command::new("docker")
+        .args([
+            "ps",
+            "--format",
+            "{{.ID}}\t{{.Names}}\t{{.Status}}\t{{.Image}}\t{{.Ports}}",
+        ])
+        .output()
+        .context("Failed to run docker ps")?;
+
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    let mut rtk = String::new();
+
+    if stdout.trim().is_empty() {
+        rtk.push_str("🐳 0 containers");
+        println!("{}", rtk);
+        timer.track("docker ps", "rtk docker ps", &raw, &rtk);
+        return Ok(());
+    }
+
+    let count = stdout.lines().count();
+    rtk.push_str(&format!("🐳 {} containers:\n", count));
+
+    for line in stdout.lines().take(15) {
+        let parts: Vec<&str> = line.split('\t').collect();
+        if parts.len() >= 4 {
+            let id = &parts[0][..12.min(parts[0].len())];
+            let name = parts[1];
+            let short_image = parts.get(3).unwrap_or(&"").split('/').last().unwrap_or("");
+            let ports = compact_ports(parts.get(4).unwrap_or(&""));
+            if ports == "-" {
+                rtk.push_str(&format!("  {} {} ({})\n", id, name, short_image));
+            } else {
+                rtk.push_str(&format!(
+                    "  {} {} ({}) [{}]\n",
+                    id, name, short_image, ports
+                ));
+            }
+        }
+    }
+    if count > 15 {
+        rtk.push_str(&format!("  ... +{} more", count - 15));
+    }
+
+    print!("{}", rtk);
+    timer.track("docker ps", "rtk docker ps", &raw, &rtk);
+    Ok(())
+}
+
+fn docker_images(_verbose: u8) -> Result<()> {
+    let timer = tracking::TimedExecution::start();
+
+    let raw = Command::new("docker")
+        .args(["images"])
+        .output()
+        .map(|o| String::from_utf8_lossy(&o.stdout).to_string())
+        .unwrap_or_default();
+
+    let output = Command::new("docker")
+        .args(["images", "--format", "{{.Repository}}:{{.Tag}}\t{{.Size}}"])
+        .output()
+        .context("Failed to run docker images")?;
+
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    let lines: Vec<&str> = stdout.lines().collect();
+    let mut rtk = String::new();
+
+    if lines.is_empty() {
+        rtk.push_str("🐳 0 images");
+        println!("{}", rtk);
+        timer.track("docker images", "rtk docker images", &raw, &rtk);
+        return Ok(());
+    }
+
+    let mut total_size_mb: f64 = 0.0;
+    for line in &lines {
+        let parts: Vec<&str> = line.split('\t').collect();
+        if let Some(size_str) = parts.get(1) {
+            if size_str.contains("GB") {
+                if let Ok(n) = size_str.replace("GB", "").trim().parse::<f64>() {
+                    total_size_mb += n * 1024.0;
+                }
+            } else if size_str.contains("MB") {
+                if let Ok(n) = size_str.replace("MB", "").trim().parse::<f64>() {
+                    total_size_mb += n;
+                }
+            }
+        }
+    }
+
+    let total_display = if total_size_mb > 1024.0 {
+        format!("{:.1}GB", total_size_mb / 1024.0)
+    } else {
+        format!("{:.0}MB", total_size_mb)
+    };
+    rtk.push_str(&format!("🐳 {} images ({})\n", lines.len(), total_display));
+
+    for line in lines.iter().take(15) {
+        let parts: Vec<&str> = line.split('\t').collect();
+        if !parts.is_empty() {
+            let image = parts[0];
+            let size = parts.get(1).unwrap_or(&"");
+            let short = if image.len() > 40 {
+                format!("...{}", &image[image.len() - 37..])
+            } else {
+                image.to_string()
+            };
+            rtk.push_str(&format!("  {} [{}]\n", short, size));
+        }
+    }
+    if lines.len() > 15 {
+        rtk.push_str(&format!("  ... +{} more", lines.len() - 15));
+    }
+
+    print!("{}", rtk);
+    timer.track("docker images", "rtk docker images", &raw, &rtk);
+    Ok(())
+}
+
+fn docker_logs(args: &[String], _verbose: u8) -> Result<()> {
+    let timer = tracking::TimedExecution::start();
+
+    let container = args.first().map(|s| s.as_str()).unwrap_or("");
+    if container.is_empty() {
+        println!("Usage: rtk docker logs <container>");
+        return Ok(());
+    }
+
+    let output = Command::new("docker")
+        .args(["logs", "--tail", "100", container])
+        .output()
+        .context("Failed to run docker logs")?;
+
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    let stderr = String::from_utf8_lossy(&output.stderr);
+    let raw = format!("{}\n{}", stdout, stderr);
+
+    let analyzed = crate::log_cmd::run_stdin_str(&raw);
+    let rtk = format!("🐳 Logs for {}:\n{}", container, analyzed);
+    println!("{}", rtk);
+    timer.track(
+        &format!("docker logs {}", container),
+        "rtk docker logs",
+        &raw,
+        &rtk,
+    );
+    Ok(())
+}
+
+fn kubectl_pods(args: &[String], _verbose: u8) -> Result<()> {
+    let timer = tracking::TimedExecution::start();
+
+    let mut cmd = Command::new("kubectl");
+    cmd.args(["get", "pods", "-o", "json"]);
+    for arg in args {
+        cmd.arg(arg);
+    }
+
+    let output = cmd.output().context("Failed to run kubectl get pods")?;
+    let raw = String::from_utf8_lossy(&output.stdout).to_string();
+    let mut rtk = String::new();
+
+    let json: serde_json::Value = match serde_json::from_str(&raw) {
+        Ok(v) => v,
+        Err(_) => {
+            rtk.push_str("☸️  No pods found");
+            println!("{}", rtk);
+            timer.track("kubectl get pods", "rtk kubectl pods", &raw, &rtk);
+            return Ok(());
+        }
+    };
+
+    let items = json["items"].as_array();
+    if items.is_none() || items.unwrap().is_empty() {
+        rtk.push_str("☸️  No pods found");
+        println!("{}", rtk);
+        timer.track("kubectl get pods", "rtk kubectl pods", &raw, &rtk);
+        return Ok(());
+    }
+
+    let pods = items.unwrap();
+    let (mut running, mut pending, mut failed, mut restarts_total) = (0, 0, 0, 0i64);
+    let mut issues: Vec<String> = Vec::new();
+
+    for pod in pods {
+        let ns = pod["metadata"]["namespace"].as_str().unwrap_or("-");
+        let name = pod["metadata"]["name"].as_str().unwrap_or("-");
+        let phase = pod["status"]["phase"].as_str().unwrap_or("Unknown");
+
+        if let Some(containers) = pod["status"]["containerStatuses"].as_array() {
+            for c in containers {
+                restarts_total += c["restartCount"].as_i64().unwrap_or(0);
+            }
+        }
+
+        match phase {
+            "Running" => running += 1,
+            "Pending" => {
+                pending += 1;
+                issues.push(format!("{}/{} Pending", ns, name));
+            }
+            "Failed" | "Error" => {
+                failed += 1;
+                issues.push(format!("{}/{} {}", ns, name, phase));
+            }
+            _ => {
+                if let Some(containers) = pod["status"]["containerStatuses"].as_array() {
+                    for c in containers {
+                        if let Some(w) = c["state"]["waiting"]["reason"].as_str() {
+                            if w.contains("CrashLoop") || w.contains("Error") {
+                                failed += 1;
+                                issues.push(format!("{}/{} {}", ns, name, w));
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    let mut parts = Vec::new();
+    if running > 0 {
+        parts.push(format!("{} ✓", running));
+    }
+    if pending > 0 {
+        parts.push(format!("{} pending", pending));
+    }
+    if failed > 0 {
+        parts.push(format!("{} ✗", failed));
+    }
+    if restarts_total > 0 {
+        parts.push(format!("{} restarts", restarts_total));
+    }
+
+    rtk.push_str(&format!("☸️  {} pods: {}\n", pods.len(), parts.join(", ")));
+    if !issues.is_empty() {
+        rtk.push_str("⚠️  Issues:\n");
+        for issue in issues.iter().take(10) {
+            rtk.push_str(&format!("  {}\n", issue));
+        }
+        if issues.len() > 10 {
+            rtk.push_str(&format!("  ... +{} more", issues.len() - 10));
+        }
+    }
+
+    print!("{}", rtk);
+    timer.track("kubectl get pods", "rtk kubectl pods", &raw, &rtk);
+    Ok(())
+}
+
+fn kubectl_services(args: &[String], _verbose: u8) -> Result<()> {
+    let timer = tracking::TimedExecution::start();
+
+    let mut cmd = Command::new("kubectl");
+    cmd.args(["get", "services", "-o", "json"]);
+    for arg in args {
+        cmd.arg(arg);
+    }
+
+    let output = cmd.output().context("Failed to run kubectl get services")?;
+    let raw = String::from_utf8_lossy(&output.stdout).to_string();
+    let mut rtk = String::new();
+
+    let json: serde_json::Value = match serde_json::from_str(&raw) {
+        Ok(v) => v,
+        Err(_) => {
+            rtk.push_str("☸️  No services found");
+            println!("{}", rtk);
+            timer.track("kubectl get svc", "rtk kubectl svc", &raw, &rtk);
+            return Ok(());
+        }
+    };
+
+    let items = json["items"].as_array();
+    if items.is_none() || items.unwrap().is_empty() {
+        rtk.push_str("☸️  No services found");
+        println!("{}", rtk);
+        timer.track("kubectl get svc", "rtk kubectl svc", &raw, &rtk);
+        return Ok(());
+    }
+
+    let services = items.unwrap();
+    rtk.push_str(&format!("☸️  {} services:\n", services.len()));
+
+    for svc in services.iter().take(15) {
+        let ns = svc["metadata"]["namespace"].as_str().unwrap_or("-");
+        let name = svc["metadata"]["name"].as_str().unwrap_or("-");
+        let svc_type = svc["spec"]["type"].as_str().unwrap_or("-");
+        let ports: Vec<String> = svc["spec"]["ports"]
+            .as_array()
+            .map(|arr| {
+                arr.iter()
+                    .map(|p| {
+                        let port = p["port"].as_i64().unwrap_or(0);
+                        let target = p["targetPort"]
+                            .as_i64()
+                            .or_else(|| p["targetPort"].as_str().and_then(|s| s.parse().ok()))
+                            .unwrap_or(port);
+                        if port == target {
+                            format!("{}", port)
+                        } else {
+                            format!("{}→{}", port, target)
+                        }
+                    })
+                    .collect()
+            })
+            .unwrap_or_default();
+        rtk.push_str(&format!(
+            "  {}/{} {} [{}]\n",
+            ns,
+            name,
+            svc_type,
+            ports.join(",")
+        ));
+    }
+    if services.len() > 15 {
+        rtk.push_str(&format!("  ... +{} more", services.len() - 15));
+    }
+
+    print!("{}", rtk);
+    timer.track("kubectl get svc", "rtk kubectl svc", &raw, &rtk);
+    Ok(())
+}
+
+fn kubectl_logs(args: &[String], _verbose: u8) -> Result<()> {
+    let timer = tracking::TimedExecution::start();
+
+    let pod = args.first().map(|s| s.as_str()).unwrap_or("");
+    if pod.is_empty() {
+        println!("Usage: rtk kubectl logs <pod>");
+        return Ok(());
+    }
+
+    let mut cmd = Command::new("kubectl");
+    cmd.args(["logs", "--tail", "100", pod]);
+    for arg in args.iter().skip(1) {
+        cmd.arg(arg);
+    }
+
+    let output = cmd.output().context("Failed to run kubectl logs")?;
+    let raw = String::from_utf8_lossy(&output.stdout).to_string();
+    let analyzed = crate::log_cmd::run_stdin_str(&raw);
+    let rtk = format!("☸️  Logs for {}:\n{}", pod, analyzed);
+    println!("{}", rtk);
+    timer.track(
+        &format!("kubectl logs {}", pod),
+        "rtk kubectl logs",
+        &raw,
+        &rtk,
+    );
+    Ok(())
+}
+
+/// Format `docker compose ps --format` output into compact form.
+/// Expects tab-separated lines: Name\tImage\tStatus\tPorts
+/// (no header row — `--format` output is headerless)
+pub fn format_compose_ps(raw: &str) -> String {
+    let lines: Vec<&str> = raw.lines().filter(|l| !l.trim().is_empty()).collect();
+
+    if lines.is_empty() {
+        return "🐳 0 compose services".to_string();
+    }
+
+    let mut result = format!("🐳 {} compose services:\n", lines.len());
+
+    for line in lines.iter().take(20) {
+        let parts: Vec<&str> = line.split('\t').collect();
+        if parts.len() >= 4 {
+            let name = parts[0];
+            let image = parts[1];
+            let status = parts[2];
+            let ports = parts[3];
+
+            let short_image = image.split('/').next_back().unwrap_or(image);
+
+            let port_str = if ports.trim().is_empty() {
+                String::new()
+            } else {
+                let compact = compact_ports(ports.trim());
+                if compact == "-" {
+                    String::new()
+                } else {
+                    format!(" [{}]", compact)
+                }
+            };
+
+            result.push_str(&format!(
+                "  {} ({}) {}{}\n",
+                name, short_image, status, port_str
+            ));
+        }
+    }
+    if lines.len() > 20 {
+        result.push_str(&format!("  ... +{} more\n", lines.len() - 20));
+    }
+
+    result.trim_end().to_string()
+}
+
+/// Format `docker compose logs` output into compact form
+pub fn format_compose_logs(raw: &str) -> String {
+    if raw.trim().is_empty() {
+        return "🐳 No logs".to_string();
+    }
+
+    // docker compose logs prefixes each line with "service-N  | "
+    // Use the existing log deduplication engine
+    let analyzed = crate::log_cmd::run_stdin_str(raw);
+    format!("🐳 Compose logs:\n{}", analyzed)
+}
+
+/// Format `docker compose build` output into compact summary
+pub fn format_compose_build(raw: &str) -> String {
+    if raw.trim().is_empty() {
+        return "🐳 Build: no output".to_string();
+    }
+
+    let mut result = String::new();
+
+    // Extract the summary line: "[+] Building 12.3s (8/8) FINISHED"
+    for line in raw.lines() {
+        if line.contains("Building") && line.contains("FINISHED") {
+            result.push_str(&format!("🐳 {}\n", line.trim()));
+            break;
+        }
+    }
+
+    if result.is_empty() {
+        // No FINISHED line found — might still be building or errored
+        if let Some(line) = raw.lines().find(|l| l.contains("Building")) {
+            result.push_str(&format!("🐳 {}\n", line.trim()));
+        } else {
+            result.push_str("🐳 Build:\n");
+        }
+    }
+
+    // Collect unique service names from build steps like "[web 1/4]"
+    let mut services: Vec<String> = Vec::new();
+    // find('[') returns byte offset — use byte slicing throughout
+    // '[' and ']' are single-byte ASCII, so byte arithmetic is safe
+    for line in raw.lines() {
+        if let Some(start) = line.find('[') {
+            if let Some(end) = line[start + 1..].find(']') {
+                let bracket = &line[start + 1..start + 1 + end];
+                let svc = bracket.split_whitespace().next().unwrap_or("");
+                if !svc.is_empty() && svc != "+" && !services.contains(&svc.to_string()) {
+                    services.push(svc.to_string());
+                }
+            }
+        }
+    }
+
+    if !services.is_empty() {
+        result.push_str(&format!("  Services: {}\n", services.join(", ")));
+    }
+
+    // Count build steps (lines starting with " => ")
+    let step_count = raw
+        .lines()
+        .filter(|l| l.trim_start().starts_with("=> "))
+        .count();
+    if step_count > 0 {
+        result.push_str(&format!("  Steps: {}", step_count));
+    }
+
+    result.trim_end().to_string()
+}
+
+fn compact_ports(ports: &str) -> String {
+    if ports.is_empty() {
+        return "-".to_string();
+    }
+
+    // Extract just the port numbers
+    let port_nums: Vec<&str> = ports
+        .split(',')
+        .filter_map(|p| p.split("->").next().and_then(|s| s.split(':').last()))
+        .collect();
+
+    if port_nums.len() <= 3 {
+        port_nums.join(", ")
+    } else {
+        format!(
+            "{}, ... +{}",
+            port_nums[..2].join(", "),
+            port_nums.len() - 2
+        )
+    }
+}
+
+/// Runs an unsupported docker subcommand by passing it through directly
+pub fn run_docker_passthrough(args: &[OsString], verbose: u8) -> Result<()> {
+    let timer = tracking::TimedExecution::start();
+
+    if verbose > 0 {
+        eprintln!("docker passthrough: {:?}", args);
+    }
+    let status = Command::new("docker")
+        .args(args)
+        .status()
+        .context("Failed to run docker")?;
+
+    let args_str = tracking::args_display(args);
+    timer.track_passthrough(
+        &format!("docker {}", args_str),
+        &format!("rtk docker {} (passthrough)", args_str),
+    );
+
+    if !status.success() {
+        std::process::exit(status.code().unwrap_or(1));
+    }
+    Ok(())
+}
+
+/// Run `docker compose ps` with compact output
+pub fn run_compose_ps(verbose: u8) -> Result<()> {
+    let timer = tracking::TimedExecution::start();
+
+    // Raw output for token tracking
+    let raw_output = Command::new("docker")
+        .args(["compose", "ps"])
+        .output()
+        .context("Failed to run docker compose ps")?;
+
+    if !raw_output.status.success() {
+        let stderr = String::from_utf8_lossy(&raw_output.stderr);
+        eprintln!("{}", stderr);
+        std::process::exit(raw_output.status.code().unwrap_or(1));
+    }
+    let raw = String::from_utf8_lossy(&raw_output.stdout).to_string();
+
+    // Structured output for parsing (same pattern as docker_ps)
+    let output = Command::new("docker")
+        .args([
+            "compose",
+            "ps",
+            "--format",
+            "{{.Name}}\t{{.Image}}\t{{.Status}}\t{{.Ports}}",
+        ])
+        .output()
+        .context("Failed to run docker compose ps --format")?;
+
+    if !output.status.success() {
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        eprintln!("{}", stderr);
+        std::process::exit(output.status.code().unwrap_or(1));
+    }
+    let structured = String::from_utf8_lossy(&output.stdout).to_string();
+
+    if verbose > 0 {
+        eprintln!("raw docker compose ps:\n{}", raw);
+    }
+
+    let rtk = format_compose_ps(&structured);
+    println!("{}", rtk);
+    timer.track("docker compose ps", "rtk docker compose ps", &raw, &rtk);
+    Ok(())
+}
+
+/// Run `docker compose logs` with deduplication
+pub fn run_compose_logs(service: Option<&str>, verbose: u8) -> Result<()> {
+    let timer = tracking::TimedExecution::start();
+
+    let mut cmd = Command::new("docker");
+    cmd.args(["compose", "logs", "--tail", "100"]);
+    if let Some(svc) = service {
+        cmd.arg(svc);
+    }
+
+    let output = cmd.output().context("Failed to run docker compose logs")?;
+
+    if !output.status.success() {
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        eprintln!("{}", stderr);
+        std::process::exit(output.status.code().unwrap_or(1));
+    }
+
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    let stderr = String::from_utf8_lossy(&output.stderr);
+    let raw = format!("{}\n{}", stdout, stderr);
+
+    if verbose > 0 {
+        eprintln!("raw docker compose logs:\n{}", raw);
+    }
+
+    let rtk = format_compose_logs(&raw);
+    println!("{}", rtk);
+    let svc_label = service.unwrap_or("all");
+    timer.track(
+        &format!("docker compose logs {}", svc_label),
+        "rtk docker compose logs",
+        &raw,
+        &rtk,
+    );
+    Ok(())
+}
+
+/// Run `docker compose build` with summary output
+pub fn run_compose_build(service: Option<&str>, verbose: u8) -> Result<()> {
+    let timer = tracking::TimedExecution::start();
+
+    let mut cmd = Command::new("docker");
+    cmd.args(["compose", "build"]);
+    if let Some(svc) = service {
+        cmd.arg(svc);
+    }
+
+    let output = cmd.output().context("Failed to run docker compose build")?;
+
+    if !output.status.success() {
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        eprintln!("{}", stderr);
+        std::process::exit(output.status.code().unwrap_or(1));
+    }
+
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    let stderr = String::from_utf8_lossy(&output.stderr);
+    let raw = format!("{}\n{}", stdout, stderr);
+
+    if verbose > 0 {
+        eprintln!("raw docker compose build:\n{}", raw);
+    }
+
+    let rtk = format_compose_build(&raw);
+    println!("{}", rtk);
+    let svc_label = service.unwrap_or("all");
+    timer.track(
+        &format!("docker compose build {}", svc_label),
+        "rtk docker compose build",
+        &raw,
+        &rtk,
+    );
+    Ok(())
+}
+
+/// Runs an unsupported docker compose subcommand by passing it through directly
+pub fn run_compose_passthrough(args: &[OsString], verbose: u8) -> Result<()> {
+    let timer = tracking::TimedExecution::start();
+
+    if verbose > 0 {
+        eprintln!("docker compose passthrough: {:?}", args);
+    }
+    let status = Command::new("docker")
+        .arg("compose")
+        .args(args)
+        .status()
+        .context("Failed to run docker compose")?;
+
+    let args_str = tracking::args_display(args);
+    timer.track_passthrough(
+        &format!("docker compose {}", args_str),
+        &format!("rtk docker compose {} (passthrough)", args_str),
+    );
+
+    if !status.success() {
+        std::process::exit(status.code().unwrap_or(1));
+    }
+    Ok(())
+}
+
+/// Runs an unsupported kubectl subcommand by passing it through directly
+pub fn run_kubectl_passthrough(args: &[OsString], verbose: u8) -> Result<()> {
+    let timer = tracking::TimedExecution::start();
+
+    if verbose > 0 {
+        eprintln!("kubectl passthrough: {:?}", args);
+    }
+    let status = Command::new("kubectl")
+        .args(args)
+        .status()
+        .context("Failed to run kubectl")?;
+
+    let args_str = tracking::args_display(args);
+    timer.track_passthrough(
+        &format!("kubectl {}", args_str),
+        &format!("rtk kubectl {} (passthrough)", args_str),
+    );
+
+    if !status.success() {
+        std::process::exit(status.code().unwrap_or(1));
+    }
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    // ── format_compose_ps ──────────────────────────────────
+
+    #[test]
+    fn test_format_compose_ps_basic() {
+        // Tab-separated --format output: Name\tImage\tStatus\tPorts
+        let raw = "web-1\tnginx:latest\tUp 2 hours\t0.0.0.0:80->80/tcp\n\
+                   api-1\tnode:20\tUp 2 hours\t0.0.0.0:3000->3000/tcp\n\
+                   db-1\tpostgres:16\tUp 2 hours\t0.0.0.0:5432->5432/tcp";
+        let out = format_compose_ps(raw);
+        assert!(out.contains("3"), "should show container count");
+        assert!(out.contains("web"), "should show service name");
+        assert!(out.contains("api"), "should show service name");
+        assert!(out.contains("db"), "should show service name");
+        assert!(out.contains("Up 2 hours"), "should show status");
+        assert!(out.len() < raw.len(), "output should be shorter than raw");
+    }
+
+    #[test]
+    fn test_format_compose_ps_empty() {
+        let out = format_compose_ps("");
+        assert!(out.contains("0"), "should show zero containers");
+    }
+
+    #[test]
+    fn test_format_compose_ps_whitespace_only() {
+        let out = format_compose_ps("   \n  \n");
+        assert!(out.contains("0"), "should show zero containers");
+    }
+
+    #[test]
+    fn test_format_compose_ps_exited_service() {
+        // Tab-separated --format output
+        let raw = "worker-1\tpython:3.12\tExited (1) 2 minutes ago\t";
+        let out = format_compose_ps(raw);
+        assert!(out.contains("worker"), "should show service name");
+        assert!(out.contains("Exited"), "should show exited status");
+    }
+
+    #[test]
+    fn test_format_compose_ps_no_ports() {
+        let raw = "redis-1\tredis:7\tUp 5 hours\t";
+        let out = format_compose_ps(raw);
+        assert!(out.contains("redis"), "should show service name");
+        assert!(
+            !out.contains("["),
+            "should not show port brackets when empty"
+        );
+    }
+
+    #[test]
+    fn test_format_compose_ps_long_image_path() {
+        let raw = "app-1\tghcr.io/myorg/myapp:latest\tUp 1 hour\t0.0.0.0:8080->8080/tcp";
+        let out = format_compose_ps(raw);
+        assert!(
+            out.contains("myapp:latest"),
+            "should shorten image to last segment"
+        );
+        assert!(
+            !out.contains("ghcr.io"),
+            "should not show full registry path"
+        );
+    }
+
+    // ── format_compose_logs ────────────────────────────────
+
+    #[test]
+    fn test_format_compose_logs_basic() {
+        let raw = "\
+web-1  | 192.168.1.1 - GET / 200
+web-1  | 192.168.1.1 - GET /favicon.ico 404
+api-1  | Server listening on port 3000
+api-1  | Connected to database";
+        let out = format_compose_logs(raw);
+        assert!(
+            out.contains("Compose logs"),
+            "should have compose logs header"
+        );
+    }
+
+    #[test]
+    fn test_format_compose_logs_empty() {
+        let out = format_compose_logs("");
+        assert!(out.contains("No logs"), "should indicate no logs");
+    }
+
+    // ── format_compose_build ───────────────────────────────
+
+    #[test]
+    fn test_format_compose_build_basic() {
+        let raw = "\
+[+] Building 12.3s (8/8) FINISHED
+ => [web internal] load build definition from Dockerfile           0.0s
+ => [web internal] load metadata for docker.io/library/node:20     1.2s
+ => [web 1/4] FROM docker.io/library/node:20@sha256:abc123         0.0s
+ => [web 2/4] WORKDIR /app                                         0.1s
+ => [web 3/4] COPY package*.json ./                                0.1s
+ => [web 4/4] RUN npm install                                      8.5s
+ => [web] exporting to image                                       2.3s
+ => => naming to docker.io/library/myapp-web                       0.0s";
+        let out = format_compose_build(raw);
+        assert!(out.contains("12.3s"), "should show total build time");
+        assert!(out.contains("web"), "should show service name");
+        assert!(out.len() < raw.len(), "should be shorter than raw");
+    }
+
+    #[test]
+    fn test_format_compose_build_empty() {
+        let out = format_compose_build("");
+        assert!(
+            !out.is_empty(),
+            "should produce output even for empty input"
+        );
+    }
+
+    // ── compact_ports (existing, previously untested) ──────
+
+    #[test]
+    fn test_compact_ports_empty() {
+        assert_eq!(compact_ports(""), "-");
+    }
+
+    #[test]
+    fn test_compact_ports_single() {
+        let result = compact_ports("0.0.0.0:8080->80/tcp");
+        assert!(result.contains("8080"));
+    }
+
+    #[test]
+    fn test_compact_ports_many() {
+        let result = compact_ports("0.0.0.0:80->80/tcp, 0.0.0.0:443->443/tcp, 0.0.0.0:8080->8080/tcp, 0.0.0.0:9090->9090/tcp");
+        assert!(result.contains("..."), "should truncate for >3 ports");
+    }
+}