feat: compare against base run and improve results display

- Add --base <run_id> flag to compare the uploaded run against a previous one
- Use paginatedCompareRuns when --base is given; warn and fall back to
  single-run display if the base run is not found
- Single-run display now shows a --base hint so users can compare future runs
- Comparison display shows the comparison URL
- Add build_comparison_table to benchmark_display for side-by-side results

Generated with AI Agent (Claude Code)

Author: GuillaumeLagrange

src/cli/run/helpers/benchmark_display.rs

@@ -1,4 +1,6 @@
-use crate::api_client::FetchLocalRunBenchmarkResult;
+use crate::api_client::{
+    CompareRunsBenchmarkResult, FetchLocalRunBenchmarkResult, ResultComparisonCategory,
+};
 use crate::cli::run::helpers;
 use crate::executor::ExecutorName;
 use console::style;
@@ -317,6 +319,102 @@ pub fn build_detailed_summary(result: &FetchLocalRunBenchmarkResult) -> String {
     }
 }
 
+#[derive(Tabled)]
+struct ComparisonRow {
+    #[tabled(rename = "Benchmark")]
+    name: String,
+    #[tabled(rename = "Base")]
+    base_value: String,
+    #[tabled(rename = "Head")]
+    head_value: String,
+    #[tabled(rename = "Change")]
+    change: String,
+    #[tabled(rename = "Status")]
+    status: String,
+}
+
+pub fn build_comparison_table(results: &[CompareRunsBenchmarkResult]) -> String {
+    let mut grouped: HashMap<&ExecutorName, Vec<&CompareRunsBenchmarkResult>> = HashMap::new();
+    for result in results {
+        grouped
+            .entry(&result.benchmark.executor)
+            .or_default()
+            .push(result);
+    }
+
+    let executor_order = [
+        ExecutorName::Valgrind,
+        ExecutorName::WallTime,
+        ExecutorName::Memory,
+    ];
+
+    let mut output = String::new();
+    for executor in &executor_order {
+        if let Some(executor_results) = grouped.get(executor) {
+            if !output.is_empty() {
+                output.push('\n');
+            }
+            let rows: Vec<ComparisonRow> = executor_results
+                .iter()
+                .map(|result| {
+                    let format_value = |v: Option<f64>| match v {
+                        Some(v) => match executor {
+                            ExecutorName::Memory => helpers::format_memory(v, Some(1)),
+                            _ => helpers::format_duration(v, Some(2)),
+                        },
+                        None => "-".to_string(),
+                    };
+
+                    let change_str = match result.change {
+                        Some(c) if c > 0.0 => {
+                            let pct = (c * 100.0).round();
+                            format!("{}", style(format!("+{pct}%")).red().bold())
+                        }
+                        Some(c) if c < 0.0 => {
+                            let pct = (c * 100.0).round();
+                            format!("{}", style(format!("{pct}%")).green().bold())
+                        }
+                        Some(_) => format!("{}", style("0%").dim()),
+                        None => "-".to_string(),
+                    };
+
+                    let status_str = match &result.category {
+                        ResultComparisonCategory::New => {
+                            format!("{}", style("New").cyan().bold())
+                        }
+                        ResultComparisonCategory::Improvement => {
+                            format!("{}", style("Improvement").green().bold())
+                        }
+                        ResultComparisonCategory::Regression => {
+                            format!("{}", style("Regression").red().bold())
+                        }
+                        ResultComparisonCategory::Untouched => {
+                            format!("{}", style("No Change").dim())
+                        }
+                        _ => format!("{}", &result.status),
+                    };
+
+                    ComparisonRow {
+                        name: result.benchmark.name.clone(),
+                        base_value: format_value(result.base_value),
+                        head_value: format!("{}", style(format_value(result.value)).cyan()),
+                        change: change_str,
+                        status: status_str,
+                    }
+                })
+                .collect();
+
+            output.push_str(&build_table_with_style(
+                &rows,
+                executor.label(),
+                executor.icon(),
+            ));
+        }
+    }
+
+    output
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

src/cli/shared.rs

@@ -110,6 +110,10 @@ pub struct ExecAndRunSharedArgs {
     #[arg(long, default_value = "false")]
     pub show_full_output: bool,
 
+    /// Compare the results against this base run ID
+    #[arg(long)]
+    pub base: Option<String>,
+
     #[command(flatten)]
     pub perf_run_args: PerfRunArgs,
 }

src/project_config/merger.rs

@@ -161,6 +161,7 @@ mod tests {
             allow_empty: false,
             go_runner_version: None,
             show_full_output: false,
+            base: None,
             perf_run_args: PerfRunArgs {
                 enable_perf: true,
                 perf_unwinding_mode: None,
@@ -195,6 +196,7 @@ mod tests {
             allow_empty: false,
             go_runner_version: None,
             show_full_output: false,
+            base: None,
             perf_run_args: PerfRunArgs {
                 enable_perf: true,
                 perf_unwinding_mode: None,
@@ -231,6 +233,7 @@ mod tests {
             allow_empty: false,
             go_runner_version: None,
             show_full_output: false,
+            base: None,
             perf_run_args: PerfRunArgs {
                 enable_perf: false,
                 perf_unwinding_mode: None,