amql_engine/

bench.rs

//! Benchmark runner comparing AQL output size against baseline approaches.
//!
//! Parses `.config/aql.bench` XML configs and executes each case, measuring
//! output bytes and estimated tokens for cat and arbitrary shell commands vs AQL.
//! Supports auto-detection from project structure or explicit case definitions.

use crate::code_cache::glob_source_files;
use crate::error::AqlError;
use crate::extractor::ExtractorRegistry;
use crate::navigate;
use crate::resolver::ResolverRegistry;
use crate::store::AnnotationStore;
use crate::types::{ProjectRoot, RelativePath, Scope};
use crate::xml;
use quick_xml::events::Event;
use quick_xml::Reader;
use serde::Serialize;
use std::path::Path;
use std::time::Instant;

// ── Constants ────────────────────────────────────────────────────────────

/// Directories pruned from find commands and directory walks.
const PRUNE_DIRS: &[&str] = &[
    "node_modules",
    ".git",
    "dist",
    "build",
    "target",
    "coverage",
];

// ── Types ────────────────────────────────────────────────────────────────

/// Parsed benchmark configuration from `.config/aql.bench`.
#[derive(Debug, Clone)]
pub struct BenchConfig {
    pub cases: Vec<BenchCase>,
}

/// A single benchmark scenario comparing multiple baselines against AQL.
#[derive(Debug, Clone)]
pub struct BenchCase {
    /// Unique identifier for this case.
    pub name: String,
    /// Human-readable description of the task.
    pub task: String,
    /// Baseline approaches (what you'd do without AQL).
    pub baselines: Vec<BaselineDef>,
    /// AQL approach.
    pub aql: AqlDef,
}

/// Baseline approach definition.
///
/// Each variant knows how to generate a shell command that gets executed
/// via `sh -c`. Output bytes are measured from stdout.
#[derive(Debug, Clone)]
#[non_exhaustive]
pub enum BaselineDef {
    /// Read all matching files verbatim.
    Cat { path: String, globs: Vec<String> },
    /// Arbitrary shell command. Users configure comparison tools (grep, ast-grep, etc.)
    /// via `Command` in `.config/aql.bench`; the engine has no opinion on which tools exist.
    Command { name: String, cmd: String },
}

impl BaselineDef {
    /// Generate the shell command string for this baseline.
    ///
    /// The command is designed to be run via `sh -c` with stdout captured.
    /// Commands use `find | xargs` for directory targets with globs.
    fn to_shell_command(&self, project_root: &Path) -> (String, String) {
        match self {
            BaselineDef::Cat { path, globs } => {
                let target = project_root.join(path);
                let cmd = if target.is_file() {
                    format!("cat {}", shell_escape(&target.to_string_lossy()))
                } else if globs.is_empty() {
                    format!(
                        "find {} {} -type f -print0 | xargs -0 cat",
                        shell_escape(&target.to_string_lossy()),
                        find_prune_clause(),
                    )
                } else {
                    let name_args = globs_to_find_names(globs);
                    format!(
                        "find {} {} -type f \\( {} \\) -print0 | xargs -0 cat",
                        shell_escape(&target.to_string_lossy()),
                        find_prune_clause(),
                        name_args,
                    )
                };
                ("cat".to_string(), cmd)
            }
            BaselineDef::Command { name, cmd } => (name.clone(), cmd.clone()),
        }
    }
}

/// Build the `find` prune clause from `PRUNE_DIRS`.
fn find_prune_clause() -> String {
    let inner: Vec<String> = PRUNE_DIRS.iter().map(|d| format!("-name {d}")).collect();
    format!("\\( {} \\) -prune -o", inner.join(" -o "))
}

/// Convert glob patterns to `find -name` arguments.
fn globs_to_find_names(globs: &[String]) -> String {
    globs
        .iter()
        .enumerate()
        .map(|(i, g)| {
            let prefix = if i > 0 { "-o " } else { "" };
            format!("{prefix}-name {}", shell_escape(g))
        })
        .collect::<Vec<_>>()
        .join(" ")
}

/// Shell-escape a string with single quotes.
fn shell_escape(s: &str) -> String {
    if s.contains('\'') {
        format!("'{}'", s.replace('\'', "'\\''"))
    } else {
        format!("'{s}'")
    }
}

/// AQL approach definition.
#[derive(Debug, Clone)]
#[non_exhaustive]
pub enum AqlDef {
    /// Run a built-in extractor.
    Extract { extractor: String, path: String },
    /// Run tree-sitter node selection.
    NavSelect { path: String, selector: String },
    /// Run a unified query.
    Query { selector: String, scope: String },
}

/// Result of running a single benchmark case.
#[non_exhaustive]
#[derive(Debug, Clone, Serialize)]
pub struct BenchResult {
    pub name: String,
    pub task: String,
    /// Estimated tokens for the task prompt (shared across all approaches).
    pub task_tokens: usize,
    pub baselines: Vec<MeasuredOutput>,
    pub aql: MeasuredOutput,
    /// Worst baseline total / AQL total. `None` when AQL produced zero tokens.
    pub ratio: Option<f64>,
    pub winner: String,
}

/// Measured output from one approach.
#[non_exhaustive]
#[derive(Debug, Clone, Serialize)]
pub struct MeasuredOutput {
    #[serde(rename = "type")]
    pub approach_type: String,
    pub bytes: usize,
    /// Tokens from tool output only.
    pub tokens: usize,
    /// Total tokens an agent would consume: task prompt + tool output.
    pub total_tokens: usize,
    pub wall_ms: u64,
    /// Set when the measurement failed (command error, extractor not found, etc.).
    /// A failed run is excluded from ratio/winner computation.
    pub error: Option<String>,
}

// ── XML Parsing ──────────────────────────────────────────────────────────

/// Look up `key` in pre-collected attr pairs.
fn get_attr<'a>(pairs: &'a [(String, String)], key: &str) -> Option<&'a str> {
    pairs
        .iter()
        .find(|(k, _)| k == key)
        .map(|(_, v)| v.as_str())
}

/// Parse comma-separated globs from an attribute value.
fn parse_globs(raw: &str) -> Vec<String> {
    raw.split(',')
        .map(|s| s.trim().to_string())
        .filter(|s| !s.is_empty())
        .collect()
}

/// Parse a benchmark config from a raw XML string.
#[must_use = "parsing a bench config is useless without inspecting the result"]
pub fn parse_bench_config(raw: &str) -> Result<BenchConfig, AqlError> {
    let mut reader = Reader::from_str(raw);
    let mut buf = Vec::new();
    let mut cases: Vec<BenchCase> = Vec::new();

    let mut in_benchmarks = false;
    let mut current_case: Option<PartialCase> = None;

    loop {
        match reader.read_event_into(&mut buf) {
            Ok(Event::Eof) => break,
            Ok(Event::Start(ref e)) => {
                let name = xml::element_name(e)?;
                let pairs = xml::attr_map(e)?;

                match name.as_str() {
                    "benchmarks" => {
                        in_benchmarks = true;
                    }
                    "case" if in_benchmarks => {
                        current_case = Some(PartialCase {
                            name: get_attr(&pairs, "name").unwrap_or("").to_string(),
                            task: get_attr(&pairs, "task").unwrap_or("").to_string(),
                            baselines: Vec::new(),
                            aql: None,
                        });
                    }
                    _ => {}
                }
            }
            Ok(Event::Empty(ref e)) => {
                let name = xml::element_name(e)?;
                let pairs = xml::attr_map(e)?;

                if let Some(ref mut case) = current_case {
                    match name.as_str() {
                        "baseline" => {
                            case.baselines.push(parse_baseline_def(&pairs)?);
                        }
                        "aql" => {
                            case.aql = Some(parse_aql_def(&pairs)?);
                        }
                        _ => {}
                    }
                }
            }
            Ok(Event::End(ref e)) => {
                let name = xml::end_name(e)?;
                match name.as_str() {
                    "benchmarks" => {
                        in_benchmarks = false;
                    }
                    "case" => {
                        if let Some(partial) = current_case.take() {
                            cases.push(partial.finish()?);
                        }
                    }
                    _ => {}
                }
            }
            Err(e) => return Err(format!("Invalid XML in bench config: {e}").into()),
            _ => {}
        }
        buf.clear();
    }

    if cases.is_empty() {
        return Err("Bench config contains no <case> elements".into());
    }

    Ok(BenchConfig { cases })
}

/// Intermediate state while parsing a <case> element.
struct PartialCase {
    name: String,
    task: String,
    baselines: Vec<BaselineDef>,
    aql: Option<AqlDef>,
}

impl PartialCase {
    fn finish(self) -> Result<BenchCase, String> {
        if self.baselines.is_empty() {
            return Err(format!(
                "Bench case '{}' missing <baseline> element",
                self.name
            ));
        }
        let aql = self
            .aql
            .ok_or_else(|| format!("Bench case '{}' missing <aql> element", self.name))?;
        Ok(BenchCase {
            name: self.name,
            task: self.task,
            baselines: self.baselines,
            aql,
        })
    }
}

fn parse_baseline_def(pairs: &[(String, String)]) -> Result<BaselineDef, String> {
    let baseline_type = get_attr(pairs, "type").unwrap_or("cat");
    // Defensive: empty path defaults to project root; intentional for project-wide cat.
    let path = get_attr(pairs, "path").unwrap_or("").trim().to_string();
    let globs = get_attr(pairs, "globs")
        .map(parse_globs)
        .unwrap_or_default();

    match baseline_type {
        "cat" => Ok(BaselineDef::Cat { path, globs }),
        "command" => {
            let name = get_attr(pairs, "name")
                .unwrap_or("custom")
                .trim()
                .to_string();
            let cmd = get_attr(pairs, "cmd").unwrap_or("").trim().to_string();
            if cmd.trim().is_empty() {
                return Err(
                    "baseline type=\"command\" requires a non-empty cmd attribute".to_string(),
                );
            }
            Ok(BaselineDef::Command { name, cmd })
        }
        other => Err(format!("Unknown baseline type: {other}")),
    }
}

fn parse_aql_def(pairs: &[(String, String)]) -> Result<AqlDef, String> {
    let aql_type = get_attr(pairs, "type").unwrap_or("extract");
    match aql_type {
        "extract" => {
            let extractor = get_attr(pairs, "extractor")
                .unwrap_or("")
                .trim()
                .to_string();
            let path = get_attr(pairs, "path").unwrap_or("").trim().to_string();
            if extractor.trim().is_empty() {
                return Err(
                    "aql type=\"extract\" requires a non-empty extractor attribute".to_string(),
                );
            }
            if path.trim().is_empty() {
                return Err("aql type=\"extract\" requires a non-empty path attribute".to_string());
            }
            Ok(AqlDef::Extract { extractor, path })
        }
        "nav-select" => {
            let path = get_attr(pairs, "path").unwrap_or("").trim().to_string();
            let selector = get_attr(pairs, "selector").unwrap_or("").trim().to_string();
            if path.trim().is_empty() {
                return Err(
                    "aql type=\"nav-select\" requires a non-empty path attribute".to_string(),
                );
            }
            if selector.trim().is_empty() {
                return Err(
                    "aql type=\"nav-select\" requires a non-empty selector attribute".to_string(),
                );
            }
            Ok(AqlDef::NavSelect { path, selector })
        }
        "query" => {
            let selector = get_attr(pairs, "selector").unwrap_or("").trim().to_string();
            if selector.trim().is_empty() {
                return Err(
                    "aql type=\"query\" requires a non-empty selector attribute".to_string()
                );
            }
            Ok(AqlDef::Query {
                selector,
                scope: get_attr(pairs, "scope").unwrap_or("").trim().to_string(),
            })
        }
        other => Err(format!("Unknown aql type: {other}")),
    }
}

// ── Auto-detect ──────────────────────────────────────────────────────────

/// Auto-generate benchmark cases by scanning the project.
///
/// 1. Scan for test files → extract-vs-cat case
/// 2. Try other extractors (express, react, go-http, go-test) → extract-vs-cat case
///
/// Users can add comparison commands (grep, ast-grep, etc.) via `--baseline` or
/// `.config/aql.bench` `<baseline type="command" .../>` entries.
pub fn auto_detect_cases(
    project_root: &ProjectRoot,
    registry: &ExtractorRegistry,
    resolvers: &ResolverRegistry,
) -> Vec<BenchCase> {
    let mut cases = Vec::new();

    // Find test files via the "test" extractor
    if let Some(test_ext) = registry.get("test") {
        let extensions: rustc_hash::FxHashSet<&str> = test_ext
            .extensions()
            .iter()
            .map(|e| e.trim_start_matches('.'))
            .collect();

        let all_files = glob_source_files(project_root, &Scope::from(""), resolvers);
        let test_files: Vec<_> = all_files
            .iter()
            .filter(|f| {
                let ext = f.extension().and_then(|e| e.to_str()).unwrap_or("");
                let fname = f.file_name().and_then(|n| n.to_str()).unwrap_or("");
                extensions.contains(ext)
                    && (fname.contains(".test.")
                        || fname.contains(".spec.")
                        || fname.contains("_test."))
            })
            .collect();

        if !test_files.is_empty() {
            let test_dir = find_common_dir(&test_files, project_root);
            let globs: Vec<String> = test_ext
                .extensions()
                .iter()
                .map(|e| format!("*{e}"))
                .collect();

            cases.push(BenchCase {
                name: "test-structure".to_string(),
                task: "List all test suites with nesting".to_string(),
                baselines: vec![BaselineDef::Cat {
                    path: test_dir.clone(),
                    globs,
                }],
                aql: AqlDef::Extract {
                    extractor: "test".to_string(),
                    path: test_dir,
                },
            });
        }
    }

    // Try other extractors (express, react, go-http, go_test)
    let extractor_names = ["express", "react", "go-http", "go_test"];
    let all_extractor_files = glob_source_files(project_root, &Scope::from(""), resolvers);
    for ext_name in &extractor_names {
        if let Some(ext) = registry.get(ext_name) {
            let all_files = &all_extractor_files;
            let ext_set: rustc_hash::FxHashSet<&str> = ext
                .extensions()
                .iter()
                .map(|e| e.trim_start_matches('.'))
                .collect();

            let mut matching: Vec<&std::path::PathBuf> = all_files
                .iter()
                .filter(|f| {
                    let file_ext = f.extension().and_then(|e| e.to_str()).unwrap_or("");
                    ext_set.contains(file_ext)
                })
                .collect();

            if matching.is_empty() {
                continue;
            }

            // Sort for determinism before probing
            matching.sort();

            // Probe up to 10 files to verify this extractor produces output
            let produces_output = matching.iter().take(10).any(|sample| {
                let rel = sample
                    .strip_prefix(project_root.as_ref())
                    .map(|r| RelativePath::from(r.to_string_lossy().as_ref()))
                    .unwrap_or_else(|_| RelativePath::from(sample.to_string_lossy().as_ref()));
                std::fs::read_to_string(sample)
                    .map(|source| !ext.extract(&source, &rel).is_empty())
                    .unwrap_or(false)
            });
            if !produces_output {
                continue;
            }

            let ext_dir = find_common_dir(&matching, project_root);
            let globs: Vec<String> = ext.extensions().iter().map(|e| format!("*{e}")).collect();

            cases.push(BenchCase {
                name: format!("{ext_name}-extract"),
                task: format!("Extract {ext_name} annotations from source"),
                baselines: vec![BaselineDef::Cat {
                    path: ext_dir.clone(),
                    globs,
                }],
                aql: AqlDef::Extract {
                    extractor: ext_name.to_string(),
                    path: ext_dir,
                },
            });

            // One non-test extractor case is sufficient for a representative benchmark.
            break;
        }
    }

    cases
}

/// Find common directory prefix from a list of path strings.
fn find_common_dir_from_paths(paths: &[&str]) -> String {
    if paths.is_empty() {
        return String::new();
    }
    let first_parts: Vec<&str> = paths[0].split('/').collect();
    let mut common_depth = 0;

    'outer: for i in 0..first_parts.len().saturating_sub(1) {
        let segment = first_parts[i];
        for path in &paths[1..] {
            let other_parts: Vec<&str> = path.split('/').collect();
            if i >= other_parts.len() || other_parts[i] != segment {
                break 'outer;
            }
        }
        common_depth = i + 1;
    }

    if common_depth == 0 {
        String::new()
    } else {
        first_parts[..common_depth].join("/")
    }
}

/// Find the common directory prefix for a set of files, relative to project root.
fn find_common_dir(files: &[&std::path::PathBuf], project_root: &ProjectRoot) -> String {
    if files.is_empty() {
        return String::new();
    }

    let relatives: Vec<String> = files
        .iter()
        .filter_map(|f| {
            f.strip_prefix(project_root.as_ref())
                .ok()
                .map(|r| r.to_string_lossy().to_string())
        })
        .collect();

    if relatives.is_empty() {
        return String::new();
    }

    let refs: Vec<&str> = relatives.iter().map(|s| s.as_str()).collect();
    find_common_dir_from_paths(&refs)
}

// ── Runner ───────────────────────────────────────────────────────────────

/// Execute all benchmark cases and collect results.
///
/// Each baseline is executed as a real shell command via `sh -c`, like
/// hyperfine. AQL approaches run in-process. Output bytes are measured
/// from stdout.
pub fn run_bench(
    project_root: &ProjectRoot,
    cases: &[BenchCase],
    registry: &ExtractorRegistry,
    resolvers: &ResolverRegistry,
) -> Vec<BenchResult> {
    cases
        .iter()
        .map(|case| run_single_case(project_root, case, registry, resolvers))
        .collect()
}

fn run_single_case(
    project_root: &ProjectRoot,
    case: &BenchCase,
    registry: &ExtractorRegistry,
    resolvers: &ResolverRegistry,
) -> BenchResult {
    // Task prompt tokens: what the agent receives as the task description.
    // Simulate: "Implement: {task}\nFiles: {file list}\n"
    let task_tokens = case.task.len() / 4;

    let mut baselines: Vec<MeasuredOutput> = case
        .baselines
        .iter()
        .map(|b| measure_baseline(project_root, b))
        .collect();

    // Fill total_tokens = task_tokens + tool output tokens
    for b in &mut baselines {
        b.total_tokens = task_tokens + b.tokens;
    }

    let mut aql = measure_aql(project_root, &case.aql, registry, resolvers);
    aql.total_tokens = task_tokens + aql.tokens;

    let successful_baselines: Vec<&MeasuredOutput> =
        baselines.iter().filter(|b| b.error.is_none()).collect();

    let best_baseline_total = successful_baselines
        .iter()
        .map(|b| b.total_tokens)
        .filter(|&t| t > 0)
        .min()
        .unwrap_or(0);

    let (ratio, winner) = if aql.error.is_some() {
        (None, "error".to_string())
    } else if successful_baselines.is_empty() {
        (None, "n/a".to_string())
    } else if aql.total_tokens == 0 || best_baseline_total == 0 {
        (None, "n/a:no-data".to_string())
    } else {
        let r = best_baseline_total as f64 / aql.total_tokens as f64;
        let w = if aql.total_tokens < best_baseline_total {
            "aql"
        } else {
            "baseline"
        };
        (Some(r), w.to_string())
    };

    BenchResult {
        name: case.name.clone(),
        task: case.task.clone(),
        task_tokens,
        baselines,
        aql,
        ratio,
        winner,
    }
}

/// Execute a baseline by running its shell command via `sh -c`.
fn measure_baseline(project_root: &ProjectRoot, def: &BaselineDef) -> MeasuredOutput {
    let (approach_type, cmd) = def.to_shell_command(project_root.as_ref());
    let start = Instant::now();
    let result = run_shell_command(&cmd, project_root.as_ref());
    let wall_ms = start.elapsed().as_millis() as u64;
    match result {
        Ok(bytes) => MeasuredOutput {
            approach_type,
            bytes,
            tokens: bytes / 4,
            total_tokens: 0,
            wall_ms,
            error: None,
        },
        Err(e) => MeasuredOutput {
            approach_type,
            bytes: 0,
            tokens: 0,
            total_tokens: 0,
            wall_ms,
            error: Some(e),
        },
    }
}

/// Run a shell command via `sh -c` and return stdout byte count.
///
/// Enforces a 30-second timeout via a background thread + channel.
/// On timeout the spawned thread is leaked but the child process will
/// eventually exit on its own (acceptable for a bench tool).
fn run_shell_command(cmd: &str, cwd: &Path) -> Result<usize, String> {
    use std::process::Stdio;
    use std::sync::mpsc;
    use std::time::Duration;

    let cmd = cmd.to_string();
    let cwd = cwd.to_path_buf();
    let cmd_label: String = cmd.chars().take(80).collect();

    let (tx, rx) = mpsc::channel();
    std::thread::spawn(move || {
        let result = std::process::Command::new("sh")
            .args(["-c", &cmd])
            .current_dir(&cwd)
            .stdout(Stdio::piped())
            .stderr(Stdio::piped())
            .output();
        let _ = tx.send(result);
    });

    match rx.recv_timeout(Duration::from_secs(30)) {
        Ok(Ok(output)) => {
            if output.status.success() {
                Ok(output.stdout.len())
            } else {
                let stderr = String::from_utf8_lossy(&output.stderr);
                let snippet: String = stderr.chars().take(500).collect();
                Err(if snippet.trim().is_empty() {
                    format!("command exited with {}", output.status)
                } else {
                    format!("command exited with {}: {}", output.status, snippet.trim())
                })
            }
        }
        Ok(Err(e)) => Err(format!("failed to run command: {e}")),
        Err(_) => Err(format!("command timed out after 30s: {cmd_label}")),
    }
}

fn measure_aql(
    project_root: &ProjectRoot,
    def: &AqlDef,
    registry: &ExtractorRegistry,
    resolvers: &ResolverRegistry,
) -> MeasuredOutput {
    let start = Instant::now();

    let (approach_type, result) = match def {
        AqlDef::Extract { extractor, path } => {
            let r = run_extractor_measure(project_root, extractor, path, registry, resolvers);
            ("extract".to_string(), r)
        }
        AqlDef::NavSelect { path, selector } => {
            let r = if path.contains('\n') {
                run_nav_select_multi(project_root, path, selector)
            } else {
                run_nav_select_measure(project_root, path, selector)
            };
            ("nav-select".to_string(), r)
        }
        AqlDef::Query { selector, scope } => {
            let r = run_query_measure(
                project_root,
                selector,
                &Scope::from(scope.as_str()),
                registry,
                resolvers,
            );
            ("query".to_string(), r)
        }
    };

    let wall_ms = start.elapsed().as_millis() as u64;

    match result {
        Ok(bytes) => MeasuredOutput {
            approach_type,
            bytes,
            tokens: bytes / 4,
            total_tokens: 0,
            wall_ms,
            error: None,
        },
        Err(e) => MeasuredOutput {
            approach_type,
            bytes: 0,
            tokens: 0,
            total_tokens: 0,
            wall_ms,
            error: Some(e),
        },
    }
}

/// Run extractor and measure serialized output bytes.
fn run_extractor_measure(
    project_root: &ProjectRoot,
    extractor_name: &str,
    path: &str,
    registry: &ExtractorRegistry,
    resolvers: &ResolverRegistry,
) -> Result<usize, String> {
    let builtin = match registry.get(extractor_name) {
        Some(e) => e,
        None => return Err(format!("Unknown extractor: {extractor_name}")),
    };

    let path_scope = Scope::from(path);
    let source_files = glob_source_files(project_root, &path_scope, resolvers);

    if !path.is_empty() && source_files.is_empty() {
        return Err(format!("no source files found at path: {path}"));
    }

    let ext_set: rustc_hash::FxHashSet<&str> = builtin
        .extensions()
        .iter()
        .map(|e| e.trim_start_matches('.'))
        .collect();

    let mut all_annotations = Vec::new();
    for file in &source_files {
        let ext = file.extension().and_then(|e| e.to_str()).unwrap_or("");
        if !ext_set.contains(ext) {
            continue;
        }

        let relative = file
            .strip_prefix(project_root.as_ref())
            .map(|r| RelativePath::from(r.to_string_lossy().as_ref()))
            .unwrap_or_else(|_| RelativePath::from(file.to_string_lossy().as_ref()));

        if let Ok(source) = std::fs::read_to_string(file) {
            let annotations = builtin.extract(&source, &relative);
            all_annotations.extend(annotations);
        }
    }

    let output = serde_json::json!({ "annotations": all_annotations });
    serde_json::to_string(&output)
        .map(|s| s.len())
        .map_err(|e| format!("serialization failed: {e}"))
}

/// Run nav-select on a single file and measure serialized output bytes.
fn run_nav_select_measure(
    project_root: &ProjectRoot,
    path: &str,
    selector: &str,
) -> Result<usize, String> {
    let abs = project_root.as_ref().join(path);
    if !abs.is_file() {
        return Err(format!("file not found: {path}"));
    }
    let rel = RelativePath::from(path);
    let mut total_bytes = 0;

    for kind in selector.split(',') {
        let kind = kind.trim();
        if kind.is_empty() {
            continue;
        }
        let result = navigate::select(project_root, &rel, None, kind).map_err(|e| e.to_string())?;
        let json =
            serde_json::to_string(&result).map_err(|e| format!("serialization failed: {e}"))?;
        total_bytes += json.len();
    }
    Ok(total_bytes)
}

/// Run nav-select across multiple files (newline-separated paths).
fn run_nav_select_multi(
    project_root: &ProjectRoot,
    paths: &str,
    selector: &str,
) -> Result<usize, String> {
    let mut total_bytes = 0;
    for path in paths.lines() {
        let path = path.trim();
        if path.is_empty() {
            continue;
        }
        total_bytes += run_nav_select_measure(project_root, path, selector)?;
    }
    Ok(total_bytes)
}

/// Run unified query and measure serialized output bytes.
///
/// Runs all built-in extractors to populate annotations even when no
/// manifest exists. This measures what an agent would see if AQL was
/// configured for the project.
fn run_query_measure(
    project_root: &ProjectRoot,
    selector: &str,
    scope: &Scope,
    registry: &ExtractorRegistry,
    resolvers: &ResolverRegistry,
) -> Result<usize, String> {
    let mut cache = crate::code_cache::CodeCache::new(project_root);
    let mut store = AnnotationStore::new(project_root);
    store.load_all_from_locator();

    // Load from manifest if available
    let manifest_path = project_root.as_ref().join(".config").join("aql.schema");
    if manifest_path.is_file() {
        if let Ok(raw) = std::fs::read_to_string(&manifest_path) {
            if let Ok(manifest) = crate::manifest::parse_manifest(&raw) {
                let results =
                    crate::extractor::run_all_extractors(&manifest, project_root, registry);
                for result in results {
                    if !result.annotations.is_empty() {
                        store.load_extractor_output(result.annotations);
                    }
                }
            }
        }
    }

    // Run all built-in extractors on scope to ensure annotations exist
    let source_files = glob_source_files(project_root, scope, resolvers);

    if !scope.is_empty() && source_files.is_empty() {
        return Err(format!("no source files found in scope: {scope}"));
    }
    // Deduplicate: registry.names() includes aliases; filter by canonical extractor name.
    let mut seen_ext_names: rustc_hash::FxHashSet<&str> = rustc_hash::FxHashSet::default();
    for registry_key in registry.names() {
        if let Some(ext) = registry.get(registry_key) {
            let canonical = ext.name();
            if !seen_ext_names.insert(canonical) {
                continue;
            }
            let ext_set: rustc_hash::FxHashSet<&str> = ext
                .extensions()
                .iter()
                .map(|e| e.trim_start_matches('.'))
                .collect();
            for file in &source_files {
                let file_ext = file.extension().and_then(|e| e.to_str()).unwrap_or("");
                if !ext_set.contains(file_ext) {
                    continue;
                }
                let relative = file
                    .strip_prefix(project_root.as_ref())
                    .map(|r| RelativePath::from(r.to_string_lossy().as_ref()))
                    .unwrap_or_else(|_| RelativePath::from(file.to_string_lossy().as_ref()));
                if let Ok(source) = std::fs::read_to_string(file) {
                    let annotations = ext.extract(&source, &relative);
                    if !annotations.is_empty() {
                        store.load_extractor_output(annotations);
                    }
                }
            }
        }
    }

    let results =
        crate::query::unified_query(selector, scope, &mut cache, &mut store, resolvers, None)
            .map_err(|e| e.to_string())?;
    serde_json::to_string(&results)
        .map(|s| s.len())
        .map_err(|e| format!("serialization failed: {e}"))
}

// ── Formatter ────────────────────────────────────────────────────────────

/// Format benchmark results as a human-readable table.
/// Detect terminal column width.
///
/// Priority: `COLUMNS` env var (set by most shells and iTerm2) → 120 fallback.
fn terminal_width() -> usize {
    std::env::var("COLUMNS")
        .ok()
        .and_then(|v| v.trim().parse::<usize>().ok())
        .filter(|&w| w >= 40)
        .unwrap_or(120)
}

pub fn format_bench_table(
    project_name: &str,
    source_file_count: usize,
    results: &[BenchResult],
) -> String {
    let mut out = String::new();
    let term_width = terminal_width();

    out.push_str(&format!(
        "AQL Benchmark — project: {project_name} ({source_file_count} source files)\n\n"
    ));

    // Column preferred widths (content only, no borders/spaces)
    // Layout: │ Approach │ Tool output │ Tool tkns │ Agent total │ vs AQL │ Time │
    // Borders: 2 spaces indent + │ + (col + 2 spaces) * 6 cols + extra │
    // Fixed overhead per row: 2 (indent) + 1 + (1+1)*6 + 6*1 = 2 + 1 + 12 + 6 = 21, but:
    // Actually: "  │ {col} │ {col} │ ... │\n" → 2 indent + (3 + col_w) * 6 + 1
    // Separator overhead = 2 + 1 + 6*(3+col_w) + 1 — compute dynamically.

    const MIN_APPROACH: usize = 6;
    const MIN_TOOL_OUT: usize = 8;
    const MIN_TOOL_TKNS: usize = 6;
    const MIN_AGENT: usize = 8;

    const PREF_APPROACH: usize = 10;
    const PREF_TOOL_OUT: usize = 12;
    const PREF_TOOL_TKNS: usize = 10;
    const PREF_AGENT: usize = 12;
    const PREF_VS_AQL: usize = 8;
    const PREF_TIME: usize = 8;

    // Fixed separator overhead: "  │ " + " │ " between cols (5 per col) + " │\n"
    // 6 cols → 2 + 1 + 6*(1 + col + 1 + 1) + 1 = 2 + 1 + 6*3 + sum(cols) + 1
    // = 22 + sum(cols)  — simplify: border_overhead = 2 + 1 + 6*3 + 1 = 22
    let border_overhead: usize = 22; // 2 indent + pipes and spaces for 6 cols
    let available = term_width.saturating_sub(border_overhead);

    // Distribute available width to columns, compressing in priority order
    let total_pref =
        PREF_APPROACH + PREF_TOOL_OUT + PREF_TOOL_TKNS + PREF_AGENT + PREF_VS_AQL + PREF_TIME;
    let (w_approach, w_tool_out, w_tool_tkns, w_agent, w_vs_aql, w_time) = if available
        >= total_pref
    {
        (
            PREF_APPROACH,
            PREF_TOOL_OUT,
            PREF_TOOL_TKNS,
            PREF_AGENT,
            PREF_VS_AQL,
            PREF_TIME,
        )
    } else {
        // Compress tool_out and tool_tkns first, then approach
        let fixed = PREF_AGENT + PREF_VS_AQL + PREF_TIME;
        let compressible = available.saturating_sub(fixed + MIN_APPROACH);
        let w_tool_out = (compressible / 2).clamp(MIN_TOOL_OUT, PREF_TOOL_OUT);
        let w_tool_tkns = (compressible / 2).clamp(MIN_TOOL_TKNS, PREF_TOOL_TKNS);
        let remaining = available.saturating_sub(fixed + w_tool_out + w_tool_tkns);
        let w_approach = remaining.clamp(MIN_APPROACH, PREF_APPROACH);
        (
            w_approach,
            w_tool_out,
            w_tool_tkns,
            PREF_AGENT.min(
                available
                    .saturating_sub(w_approach + w_tool_out + w_tool_tkns + PREF_VS_AQL + PREF_TIME)
                    .max(MIN_AGENT),
            ),
            PREF_VS_AQL,
            PREF_TIME,
        )
    };

    // Box drawing helpers
    let top = format!(
        "  ┌{a}┬{b}┬{c}┬{d}┬{e}┬{f}┐",
        a = "─".repeat(w_approach + 2),
        b = "─".repeat(w_tool_out + 2),
        c = "─".repeat(w_tool_tkns + 2),
        d = "─".repeat(w_agent + 2),
        e = "─".repeat(w_vs_aql + 2),
        f = "─".repeat(w_time + 2),
    );
    let mid = top.replace('┌', "├").replace('┐', "┤").replace('┬', "┼");
    let sep = top.replace('┌', "├").replace('┐', "┤").replace('┬', "┼");
    let bot = top.replace('┌', "└").replace('┐', "┘").replace('┬', "┴");

    let header = format!(
        "  │ {:<wa$} │ {:<wb$} │ {:<wc$} │ {:<wd$} │ {:<we$} │ {:<wf$} │",
        "Approach",
        "Tool output",
        "Tool tkns",
        "Agent total",
        "vs AQL",
        "Time",
        wa = w_approach,
        wb = w_tool_out,
        wc = w_tool_tkns,
        wd = w_agent,
        we = w_vs_aql,
        wf = w_time,
    );

    for r in results {
        out.push_str(&format!("  {}: \"{}\"\n", r.name, r.task));
        if r.task_tokens > 0 {
            out.push_str(&format!(
                "  Task prompt: {} tokens\n",
                format_number(r.task_tokens)
            ));
        }
        out.push_str(&format!("{top}\n"));
        out.push_str(&format!("{header}\n"));
        out.push_str(&format!("{mid}\n"));

        let aql_total = if r.aql.error.is_none() && r.aql.total_tokens > 0 {
            Some(r.aql.total_tokens)
        } else {
            None
        };

        let mut footnotes: Vec<String> = Vec::new();

        for b in &r.baselines {
            let output_col = if let Some(ref e) = b.error {
                let idx = footnotes.len() + 1;
                footnotes.push(format!("† {}: {e}", b.approach_type));
                format!("ERR†{idx}")
            } else {
                format_number(b.bytes)
            };
            let tkns_col = if b.error.is_some() {
                "—".to_string()
            } else {
                format_number(b.tokens)
            };
            let agent_col = if b.error.is_some() {
                "—".to_string()
            } else {
                format_number(b.total_tokens)
            };
            let vs_col = if b.error.is_some() {
                "—".to_string()
            } else if let Some(aql_t) = aql_total {
                if aql_t > 0 {
                    format!("{:.1}×", b.total_tokens as f64 / aql_t as f64)
                } else {
                    "—".to_string()
                }
            } else {
                "—".to_string()
            };
            out.push_str(&format!(
                "  │ {:<wa$} │ {:<wb$} │ {:<wc$} │ {:<wd$} │ {:<we$} │ {:<wf$} │\n",
                truncate(&b.approach_type, w_approach),
                output_col,
                tkns_col,
                agent_col,
                vs_col,
                format_ms(b.wall_ms),
                wa = w_approach,
                wb = w_tool_out,
                wc = w_tool_tkns,
                wd = w_agent,
                we = w_vs_aql,
                wf = w_time,
            ));
        }

        out.push_str(&format!("{sep}\n"));

        let aql_output_col = if let Some(ref e) = r.aql.error {
            let idx = footnotes.len() + 1;
            footnotes.push(format!("† aql: {e}"));
            format!("ERR†{idx}")
        } else {
            format_number(r.aql.bytes)
        };

        out.push_str(&format!(
            "  │ {:<wa$} │ {:<wb$} │ {:<wc$} │ {:<wd$} │ {:<we$} │ {:<wf$} │\n",
            "aql",
            aql_output_col,
            if r.aql.error.is_some() {
                "—".to_string()
            } else {
                format_number(r.aql.tokens)
            },
            if r.aql.error.is_some() {
                "—".to_string()
            } else {
                format_number(r.aql.total_tokens)
            },
            "—",
            format_ms(r.aql.wall_ms),
            wa = w_approach,
            wb = w_tool_out,
            wc = w_tool_tkns,
            wd = w_agent,
            we = w_vs_aql,
            wf = w_time,
        ));

        out.push_str(&format!("{bot}\n"));

        for note in &footnotes {
            out.push_str(&format!("  {note}\n"));
        }

        // Winner line
        let winner_line = match r.winner.as_str() {
            "error" => "  Winner: error (AQL measurement failed)".to_string(),
            "n/a" => "  Winner: n/a (all baselines failed)".to_string(),
            "n/a:no-data" => "  Winner: n/a (no output produced)".to_string(),
            "aql" => {
                if let Some(ratio) = r.ratio {
                    format!("  Winner: aql ({ratio:.1}× fewer agent tokens vs best baseline)")
                } else {
                    "  Winner: aql".to_string()
                }
            }
            _ => {
                if let Some(ratio) = r.ratio {
                    format!(
                        "  Winner: baseline ({:.1}× fewer agent tokens vs aql)",
                        1.0 / ratio
                    )
                } else {
                    "  Winner: baseline".to_string()
                }
            }
        };
        out.push_str(&format!("{winner_line}\n"));

        out.push('\n');
    }

    out
}

/// Format a number with comma separators.
fn format_number(n: usize) -> String {
    let s = n.to_string();
    let mut result = String::new();
    for (i, ch) in s.chars().rev().enumerate() {
        if i > 0 && i % 3 == 0 {
            result.push(',');
        }
        result.push(ch);
    }
    result.chars().rev().collect()
}

/// Format milliseconds as a human-readable duration.
fn format_ms(ms: u64) -> String {
    if ms < 1000 {
        format!("{ms}ms")
    } else {
        format!("{:.1}s", ms as f64 / 1000.0)
    }
}

/// Truncate a string to `max` characters (Unicode-safe).
fn truncate(s: &str, max_chars: usize) -> &str {
    match s.char_indices().nth(max_chars) {
        Some((idx, _)) => &s[..idx],
        None => s,
    }
}

/// Count source files in a project.
pub fn count_source_files(project_root: &ProjectRoot, resolvers: &ResolverRegistry) -> usize {
    glob_source_files(project_root, &Scope::from(""), resolvers).len()
}

/// Derive a project name from the project root directory.
pub fn project_name(project_root: &ProjectRoot) -> String {
    project_root
        .as_ref()
        .file_name()
        .and_then(|n| n.to_str())
        .unwrap_or("unknown")
        .to_string()
}

// ── Orchestration ────────────────────────────────────────────────────────

/// Input for a single bench run. Shims construct this from their input format.
#[derive(Debug, Clone)]
pub struct BenchRequest {
    /// Explicit AQL operation. Mutually exclusive with `config`.
    pub aql: Option<AqlDef>,
    /// Explicit path for the AQL op (required for NavSelect, optional for others).
    pub path: Option<String>,
    /// Inline baselines to compare against. If empty and `aql` is set, auto-adds Cat on `path`.
    pub baselines: Vec<BaselineDef>,
    /// Path to `.config/aql.bench` relative to project root. Mutually exclusive with `aql`.
    pub config: Option<String>,
}

/// Output from a bench run.
#[derive(Debug, Clone, Serialize)]
pub struct BenchResponse {
    pub project: String,
    pub source_files: usize,
    pub cases: Vec<BenchResult>,
}

/// Execute a bench request end-to-end: validate, build cases, run, return results.
///
/// All orchestration logic lives here; shims only parse their input format and
/// format output.
pub fn execute_bench_request(
    root: &ProjectRoot,
    req: BenchRequest,
    registry: &ExtractorRegistry,
    resolvers: &ResolverRegistry,
) -> Result<BenchResponse, AqlError> {
    // Validate mutual exclusivity
    if req.aql.is_some() && req.config.is_some() {
        return Err("aql operation and config are mutually exclusive".into());
    }

    // Validate NavSelect requirements
    if let Some(AqlDef::NavSelect { .. }) = &req.aql {
        match &req.path {
            None => return Err("nav_select requires a path (file)".into()),
            Some(p) if root.as_ref().join(p).is_dir() => {
                return Err(format!("nav_select requires a file path, not a directory: {p}").into())
            }
            _ => {}
        }
    }

    // Build cases
    let cases: Vec<BenchCase> = if let Some(aql_def) = req.aql {
        let path = req.path.as_deref().unwrap_or(".").to_string();
        let (case_name, task) = match &aql_def {
            AqlDef::Extract { extractor, .. } => (
                format!("extract:{extractor}"),
                format!("Extract {extractor} annotations from {path}"),
            ),
            AqlDef::NavSelect { selector, .. } => (
                format!("nav-select:{selector}"),
                format!("Select {selector} nodes in {path}"),
            ),
            AqlDef::Query { selector, .. } => (
                format!("query:{selector}"),
                format!("Query '{selector}' in {path}"),
            ),
        };
        let baselines = if req.baselines.is_empty() {
            vec![BaselineDef::Cat {
                path: path.clone(),
                globs: Vec::new(),
            }]
        } else {
            req.baselines
        };
        vec![BenchCase {
            name: case_name,
            task,
            baselines,
            aql: aql_def,
        }]
    } else if let Some(config_rel) = req.config {
        let config_abs = if std::path::Path::new(&config_rel).is_absolute() {
            std::path::PathBuf::from(&config_rel)
        } else {
            root.as_ref().join(&config_rel)
        };
        let raw = std::fs::read_to_string(&config_abs)
            .map_err(|e| format!("Failed to read config {}: {e}", config_abs.display()))?;
        let mut parsed_cases = parse_bench_config(&raw)?.cases;
        for case in &mut parsed_cases {
            case.baselines.extend(req.baselines.iter().cloned());
        }
        parsed_cases
    } else {
        // Auto-detect: try .config/aql.bench first, then structural scan
        let default_config = root.as_ref().join(".config").join("aql.bench");
        let mut detected = if default_config.is_file() {
            let raw = std::fs::read_to_string(&default_config)
                .map_err(|e| format!("Failed to read {}: {e}", default_config.display()))?;
            parse_bench_config(&raw)?.cases
        } else {
            auto_detect_cases(root, registry, resolvers)
        };
        for case in &mut detected {
            case.baselines.extend(req.baselines.iter().cloned());
        }
        detected
    };

    if cases.is_empty() {
        return Err(
            "no benchmark cases found — use --extract, --query, --nav-select, or add a .config/aql.bench file".into(),
        );
    }

    for case in &cases {
        let mut seen: rustc_hash::FxHashSet<&str> = rustc_hash::FxHashSet::default();
        for b in &case.baselines {
            let name = match b {
                BaselineDef::Cat { .. } => "cat",
                BaselineDef::Command { name, .. } => name.as_str(),
            };
            if !seen.insert(name) {
                return Err(
                    format!("case '{}': duplicate baseline name '{name}'", case.name).into(),
                );
            }
        }
    }

    let results = run_bench(root, &cases, registry, resolvers);
    Ok(BenchResponse {
        project: project_name(root),
        source_files: count_source_files(root, resolvers),
        cases: results,
    })
}

// ── Tests ────────────────────────────────────────────────────────────────

#[cfg(test)]
mod tests {
    use super::*;

    const SAMPLE_CONFIG: &str = r#"
<benchmarks>
  <case name="test-structure" task="List all test suites with nesting">
    <baseline type="cat" path="src/__tests__/" globs="*.test.*,*.spec.*" />
    <aql type="extract" extractor="test" path="src/__tests__/" />
  </case>
  <case name="custom-grep" task="Find describe blocks">
    <baseline type="command" name="sg" cmd="sg -p 'describe($$$)' src/" />
    <aql type="query" selector="describe" scope="src/" />
  </case>
  <case name="surgical-read" task="Read only function declarations">
    <baseline type="cat" path="src/main.ts" />
    <aql type="nav-select" path="src/main.ts" selector="function_declaration" />
  </case>
</benchmarks>
"#;

    #[test]
    fn parses_bench_config_with_multiple_cases() {
        // Act
        let config = parse_bench_config(SAMPLE_CONFIG).unwrap();

        // Assert
        assert_eq!(config.cases.len(), 3, "should parse all three cases");
        assert_eq!(
            config.cases[0].baselines.len(),
            1,
            "first case should have one baseline"
        );
        assert_eq!(config.cases[0].name, "test-structure", "first case name");
    }

    #[test]
    fn parses_baseline_cat() {
        // Arrange and Act
        let config = parse_bench_config(SAMPLE_CONFIG).unwrap();

        // Assert
        match &config.cases[0].baselines[0] {
            BaselineDef::Cat { path, globs } => {
                assert_eq!(path, "src/__tests__/", "cat path");
                assert_eq!(globs, &["*.test.*", "*.spec.*"], "cat globs");
            }
            other => panic!("expected Cat, got {other:?}"),
        }
    }

    #[test]
    fn parses_aql_extract() {
        // Arrange and Act
        let config = parse_bench_config(SAMPLE_CONFIG).unwrap();

        // Assert
        match &config.cases[0].aql {
            AqlDef::Extract { extractor, path } => {
                assert_eq!(extractor, "test", "extractor name");
                assert_eq!(path, "src/__tests__/", "extractor path");
            }
            other => panic!("expected Extract, got {other:?}"),
        }
    }

    #[test]
    fn parses_command_baseline_in_case() {
        // Arrange and Act
        let config = parse_bench_config(SAMPLE_CONFIG).unwrap();

        // Assert
        match &config.cases[1].baselines[0] {
            BaselineDef::Command { name, cmd } => {
                assert_eq!(name, "sg", "command name");
                assert_eq!(cmd, "sg -p 'describe($$$)' src/", "command string");
            }
            other => panic!("expected Command, got {other:?}"),
        }
    }

    #[test]
    fn parses_aql_nav_select() {
        // Arrange and Act
        let config = parse_bench_config(SAMPLE_CONFIG).unwrap();

        // Assert
        match &config.cases[2].aql {
            AqlDef::NavSelect { path, selector } => {
                assert_eq!(path, "src/main.ts", "nav-select path");
                assert_eq!(selector, "function_declaration", "nav-select selector");
            }
            other => panic!("expected NavSelect, got {other:?}"),
        }
    }

    #[test]
    fn parses_aql_query() {
        // Arrange and Act
        let config = parse_bench_config(SAMPLE_CONFIG).unwrap();

        // Assert
        match &config.cases[1].aql {
            AqlDef::Query { selector, scope } => {
                assert_eq!(selector, "describe", "query selector");
                assert_eq!(scope, "src/", "query scope");
            }
            other => panic!("expected Query, got {other:?}"),
        }
    }

    #[test]
    fn rejects_empty_config() {
        // Act
        let err = parse_bench_config("<benchmarks></benchmarks>").unwrap_err();

        // Assert
        assert!(
            err.to_string().contains("no <case> elements"),
            "should reject empty config"
        );
    }

    #[test]
    fn rejects_case_without_baseline() {
        // Arrange
        let xml = r#"
<benchmarks>
  <case name="x" task="y">
    <aql type="extract" extractor="test" path="." />
  </case>
</benchmarks>
"#;

        // Act
        let err = parse_bench_config(xml).unwrap_err();

        // Assert
        assert!(
            err.to_string().contains("missing <baseline>"),
            "should reject case without baseline"
        );
    }

    #[test]
    fn rejects_case_without_aql() {
        // Arrange
        let xml = r#"
<benchmarks>
  <case name="x" task="y">
    <baseline type="cat" path="." />
  </case>
</benchmarks>
"#;

        // Act
        let err = parse_bench_config(xml).unwrap_err();

        // Assert
        assert!(
            err.to_string().contains("missing <aql>"),
            "should reject case without aql"
        );
    }

    #[test]
    fn formats_number_with_commas() {
        // Assert
        assert_eq!(format_number(0), "0", "zero");
        assert_eq!(format_number(999), "999", "three digits");
        assert_eq!(format_number(1_000), "1,000", "four digits");
        assert_eq!(format_number(136_380), "136,380", "six digits");
        assert_eq!(format_number(1_000_000), "1,000,000", "seven digits");
    }

    #[test]
    fn formats_bench_table_multi_baseline() {
        // Arrange
        let results = vec![BenchResult {
            name: "test-structure".to_string(),
            task: "List all test suites".to_string(),
            task_tokens: 5,
            baselines: vec![
                MeasuredOutput {
                    approach_type: "cat".to_string(),
                    bytes: 136_380,
                    tokens: 34_095,
                    total_tokens: 34_100,
                    wall_ms: 12,
                    error: None,
                },
                MeasuredOutput {
                    approach_type: "grep".to_string(),
                    bytes: 20_000,
                    tokens: 5_000,
                    total_tokens: 5_005,
                    wall_ms: 8,
                    error: None,
                },
                MeasuredOutput {
                    approach_type: "ast-grep".to_string(),
                    bytes: 36_000,
                    tokens: 9_000,
                    total_tokens: 9_005,
                    wall_ms: 45,
                    error: None,
                },
            ],
            aql: MeasuredOutput {
                approach_type: "extract".to_string(),
                bytes: 21_667,
                tokens: 5_416,
                total_tokens: 5_421,
                wall_ms: 26,
                error: None,
            },
            ratio: Some(0.92),
            winner: "baseline".to_string(),
        }];

        // Act
        let table = format_bench_table("testproj", 42, &results);

        // Assert
        assert!(table.contains("testproj"), "should contain project name");
        assert!(
            table.contains("42 source files"),
            "should contain file count"
        );
        assert!(table.contains("cat"), "should show cat baseline");
        assert!(table.contains("grep"), "should show grep baseline");
        assert!(table.contains("ast-grep"), "should show ast-grep baseline");
        assert!(table.contains("aql"), "should show AQL");
        assert!(table.contains("34,095"), "should show cat tokens");
        assert!(table.contains("5,416"), "should show AQL tokens");
    }

    #[test]
    fn shell_escape_works() {
        // Assert
        assert_eq!(shell_escape("hello"), "'hello'", "simple string");
        assert_eq!(
            shell_escape("it's"),
            "'it'\\''s'",
            "string with single quote"
        );
    }

    #[test]
    fn globs_to_find_names_works() {
        // Arrange
        let globs = vec!["*.test.*".to_string(), "*.spec.*".to_string()];

        // Act
        let result = globs_to_find_names(&globs);

        // Assert
        assert!(result.contains("-name '*.test.*'"), "first glob");
        assert!(
            result.contains("-o -name '*.spec.*'"),
            "second glob with -o"
        );
    }

    #[test]
    fn baseline_cat_to_command() {
        // Arrange
        let def = BaselineDef::Cat {
            path: "src/main.ts".to_string(),
            globs: Vec::new(),
        };

        // Act
        let (name, cmd) = def.to_shell_command(Path::new("/tmp/proj"));

        // Assert
        assert_eq!(name, "cat", "approach name");
        assert!(cmd.contains("cat"), "should use cat");
        assert!(cmd.contains("src/main.ts"), "should include path");
    }

    #[test]
    fn baseline_command_passthrough() {
        // Arrange
        let def = BaselineDef::Command {
            name: "ripgrep".to_string(),
            cmd: "rg -n 'fn ' src/".to_string(),
        };

        // Act
        let (name, cmd) = def.to_shell_command(Path::new("/tmp/proj"));

        // Assert
        assert_eq!(name, "ripgrep", "custom name");
        assert_eq!(cmd, "rg -n 'fn ' src/", "command passthrough");
    }

    #[test]
    fn parses_command_baseline() {
        // Arrange
        let xml = r#"
<benchmarks>
  <case name="custom" task="Custom grep">
    <baseline type="command" name="ripgrep" cmd="rg -n 'fn ' src/" />
    <aql type="extract" extractor="test" path="src/" />
  </case>
</benchmarks>
"#;

        // Act
        let config = parse_bench_config(xml).unwrap();

        // Assert
        match &config.cases[0].baselines[0] {
            BaselineDef::Command { name, cmd } => {
                assert_eq!(name, "ripgrep", "command name");
                assert_eq!(cmd, "rg -n 'fn ' src/", "command string");
            }
            other => panic!("expected Command, got {other:?}"),
        }
    }

    #[test]
    fn common_dir_from_paths() {
        // Arrange
        let paths = vec!["src/foo/a.ts", "src/foo/b.ts", "src/foo/bar/c.ts"];

        // Act
        let common = find_common_dir_from_paths(&paths);

        // Assert
        assert_eq!(common, "src/foo", "should find common prefix");
    }

    #[test]
    fn common_dir_no_overlap() {
        // Arrange
        let paths = vec!["src/a.ts", "lib/b.ts"];

        // Act
        let common = find_common_dir_from_paths(&paths);

        // Assert
        assert_eq!(common, "", "no common prefix");
    }

    #[test]
    fn format_ms_works() {
        // Assert
        assert_eq!(format_ms(0), "0ms", "zero");
        assert_eq!(format_ms(42), "42ms", "under a second");
        assert_eq!(format_ms(1500), "1.5s", "over a second");
    }

    #[test]
    fn truncate_works() {
        // Assert
        assert_eq!(truncate("short", 10), "short", "no truncation needed");
        assert_eq!(truncate("a-very-long-name", 10), "a-very-lon", "truncated");
    }

    #[test]
    fn winner_is_na_when_all_baselines_fail() {
        // Arrange
        let root = crate::types::ProjectRoot::from(std::path::Path::new("/nonexistent_path_xyz"));
        let registry = crate::extractor::ExtractorRegistry::with_defaults();
        let resolvers = crate::resolver::ResolverRegistry::with_defaults();
        let case = BenchCase {
            name: "test-fail".to_string(),
            task: "test task".to_string(),
            baselines: vec![BaselineDef::Command {
                name: "fail".to_string(),
                cmd: "exit 1".to_string(),
            }],
            aql: AqlDef::Extract {
                extractor: "test".to_string(),
                path: "/nonexistent".to_string(),
            },
        };

        // Act
        let results = run_bench(&root, &[case], &registry, &resolvers);

        // Assert
        assert_eq!(results.len(), 1, "should return one result");
        let r = &results[0];
        assert!(r.baselines[0].error.is_some(), "baseline should have error");
        assert!(
            r.winner == "n/a" || r.winner == "error" || r.winner == "n/a:no-data",
            "winner should be n/a, n/a:no-data, or error when measurement fails, got: {}",
            r.winner
        );
    }

    #[test]
    fn winner_is_error_when_aql_fails() {
        // Arrange
        let root = crate::types::ProjectRoot::from(std::path::Path::new("/tmp"));
        let registry = crate::extractor::ExtractorRegistry::with_defaults();
        let resolvers = crate::resolver::ResolverRegistry::with_defaults();
        let case = BenchCase {
            name: "test-aql-fail".to_string(),
            task: "test task".to_string(),
            baselines: vec![BaselineDef::Command {
                name: "echo".to_string(),
                cmd: "echo hello".to_string(),
            }],
            aql: AqlDef::Extract {
                extractor: "nonexistent_extractor_xyz".to_string(),
                path: ".".to_string(),
            },
        };

        // Act
        let results = run_bench(&root, &[case], &registry, &resolvers);

        // Assert
        assert_eq!(results.len(), 1, "should return one result");
        let r = &results[0];
        assert!(
            r.aql.error.is_some(),
            "AQL should have error for unknown extractor"
        );
        assert_eq!(r.winner, "error", "winner should be 'error' when AQL fails");
        assert!(r.ratio.is_none(), "ratio should be None when AQL fails");
    }

    #[test]
    fn execute_bench_request_rejects_duplicate_baseline_names() {
        // Arrange
        let root = crate::types::ProjectRoot::from(std::path::Path::new("/tmp"));
        let registry = crate::extractor::ExtractorRegistry::with_defaults();
        let resolvers = crate::resolver::ResolverRegistry::with_defaults();
        let req = BenchRequest {
            aql: Some(AqlDef::Extract {
                extractor: "test".to_string(),
                path: ".".to_string(),
            }),
            path: Some(".".to_string()),
            baselines: vec![
                BaselineDef::Command {
                    name: "rg".to_string(),
                    cmd: "echo a".to_string(),
                },
                BaselineDef::Command {
                    name: "rg".to_string(),
                    cmd: "echo b".to_string(),
                },
            ],
            config: None,
        };

        // Act
        let result = execute_bench_request(&root, req, &registry, &resolvers);

        // Assert
        assert!(result.is_err(), "should reject duplicate baseline names");
        let msg = result.unwrap_err().to_string();
        assert!(
            msg.contains("duplicate"),
            "error should mention 'duplicate', got: {msg}"
        );
    }

    #[test]
    fn format_bench_table_shows_no_output_for_zero_tokens() {
        // Arrange
        let results = vec![BenchResult {
            name: "zero-case".to_string(),
            task: "task".to_string(),
            task_tokens: 0,
            baselines: vec![MeasuredOutput {
                approach_type: "cat".to_string(),
                bytes: 0,
                tokens: 0,
                total_tokens: 0,
                wall_ms: 0,
                error: None,
            }],
            aql: MeasuredOutput {
                approach_type: "extract".to_string(),
                bytes: 0,
                tokens: 0,
                total_tokens: 0,
                wall_ms: 0,
                error: None,
            },
            ratio: None,
            winner: "n/a:no-data".to_string(),
        }];

        // Act
        let table = format_bench_table("test-project", 10, &results);

        // Assert
        assert!(
            table.contains("no output produced"),
            "table should explain zero-token n/a, got: {table}"
        );
    }
}