graph-agents-cli 0.3.1__py3-none-any.whl

graph_agents_cli/eval/cmd_analyze.py

@@ -0,0 +1,278 @@
+# Copyright 2026 graph-agents-cli contributors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""graph-agents-cli eval analyze command: cluster failures by reason."""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+from typing import Any
+
+import click
+from rich.table import Table
+
+from graph_agents_cli._output import Console
+from graph_agents_cli._project import find_project_root
+from graph_agents_cli.eval import _paths
+from graph_agents_cli.eval._common import (
+    EvalConfigError,
+    load_json_file,
+    resolve_judge_identity,
+    utc_now_iso,
+    write_json_file,
+)
+from graph_agents_cli.eval._judge import results_by_id, run_judge_runner
+from graph_agents_cli.eval.config import load_eval_config
+from graph_agents_cli.eval.gate import STATUS_PASSED, STATUS_RANK
+
+_QUOTED = re.compile(r"'[^']*'|\"[^\"]*\"")
+_NUMBER = re.compile(r"-?\d+(?:\.\d+)?")
+_SPACES = re.compile(r"\s+")
+_PATTERN_LIMIT = 120
+
+
+def normalize_reason(reason: str) -> tuple[str, str]:
+    """``(kind, pattern)`` for a reason line: the prefix before ':' and a masked message.
+
+    Quoted literals become ``<x>`` and numbers ``#`` so ``contains: response does
+    not contain 'hello'`` and ``... 'goodbye'`` fall into one cluster.
+    """
+    kind, sep, rest = reason.partition(":")
+    if not sep:
+        kind, rest = "other", reason
+    kind = kind.strip().lower() or "other"
+    if kind == "error":
+        # "error: judge <metric>: ..." / "error: custom metric <metric>: ..." -> keep
+        # the metric name out of the pattern.
+        sub_kind, sub_sep, sub_rest = rest.strip().partition(":")
+        if sub_sep and sub_kind.lower().startswith("judge "):
+            kind = "error/judge"
+            rest = sub_rest
+        elif sub_sep and sub_kind.lower().startswith("custom metric "):
+            kind = "error/custom"
+            rest = sub_rest
+    pattern = rest.strip().lower()
+    pattern = _QUOTED.sub("<x>", pattern)
+    pattern = _NUMBER.sub("#", pattern)
+    pattern = _SPACES.sub(" ", pattern).strip()
+    if len(pattern) > _PATTERN_LIMIT:
+        pattern = pattern[: _PATTERN_LIMIT - 3] + "..."
+    return kind, pattern
+
+
+def cluster_results(results: dict[str, Any]) -> list[dict[str, Any]]:
+    """Deterministic clusters of every non-passed case's reasons."""
+    clusters: dict[tuple[str, str, str], dict[str, Any]] = {}
+    for case in results.get("cases", []):
+        status = case.get("status")
+        if status == STATUS_PASSED:
+            continue
+        reasons = case.get("reasons") or [f"{status}: no reason recorded"]
+        for reason in reasons:
+            kind, pattern = normalize_reason(str(reason))
+            key = (str(status), kind, pattern)
+            cluster = clusters.setdefault(
+                key,
+                {
+                    "status": status,
+                    "kind": kind,
+                    "pattern": pattern,
+                    "count": 0,
+                    "case_ids": [],
+                    "examples": [],
+                },
+            )
+            cluster["count"] += 1
+            if case["id"] not in cluster["case_ids"]:
+                cluster["case_ids"].append(case["id"])
+            if len(cluster["examples"]) < 3:
+                cluster["examples"].append(str(reason))
+    ordered = sorted(
+        clusters.values(),
+        key=lambda c: (-c["count"], -STATUS_RANK.get(c["status"], 0), c["kind"], c["pattern"]),
+    )
+    for index, cluster in enumerate(ordered, start=1):
+        cluster["rank"] = index
+    return ordered
+
+
+def _summary_prompt(results: dict[str, Any], clusters: list[dict[str, Any]]) -> str:
+    lines = [
+        "You are reviewing the failures of an automated evaluation of an AI agent.",
+        f"Summary: {results.get('summary')}",
+        "Failure clusters (status / check-or-metric / pattern / count / examples):",
+    ]
+    for cluster in clusters[:20]:
+        lines.append(
+            f"- [{cluster['rank']}] {cluster['status']} / {cluster['kind']} / {cluster['pattern']} "
+            f"/ {cluster['count']} case(s): {cluster['case_ids'][:5]}"
+        )
+        for example in cluster["examples"]:
+            lines.append(f"    e.g. {example}")
+    lines.append(
+        "For each cluster give the most likely root cause (prompt, tool, data, or expectation) "
+        "and one concrete fix. Finish with the three highest-priority actions. Be brief."
+    )
+    return "\n".join(lines)
+
+
+def _resolve_results_path(project_root: Path | None, results: str | None) -> Path:
+    if results:
+        path = Path(results)
+        if not path.is_absolute() and project_root is not None and not path.exists():
+            path = project_root / path
+        if not path.is_file():
+            raise EvalConfigError(f"results file not found: {path}")
+        return path
+    if project_root is None:
+        raise EvalConfigError("not inside a graph-agents-cli project; pass --results PATH")
+    latest = _paths.latest_file(
+        _paths.default_grade_results_dir(project_root), _paths.RESULTS_FILE_PREFIX
+    )
+    if latest is None:
+        raise EvalConfigError(
+            f"no results found under {_paths.default_grade_results_dir(project_root)}; "
+            "run `graph-agents-cli eval grade` first or pass --results PATH"
+        )
+    return latest
+
+
+@click.command("analyze")
+@click.option(
+    "--results",
+    default=None,
+    help="Results file. Defaults to the newest artifacts/grade_results/results_<ts>.json.",
+)
+@click.option(
+    "--output",
+    "output_path",
+    default=None,
+    help="Analysis file. Defaults to artifacts/analysis_<ts>.json.",
+)
+@click.option(
+    "--top-k", type=click.IntRange(min=1), default=None, help="Print only the K largest clusters."
+)
+@click.option(
+    "--judge", is_flag=True, help="Ask the judge model for root causes and fixes per cluster."
+)
+@click.option("--judge-provider", default=None, help="Override the judge provider (with --judge).")
+@click.option("--judge-model", default=None, help="Override the judge model (with --judge).")
+def cmd_analyze(
+    *,
+    results: str | None,
+    output_path: str | None,
+    top_k: int | None,
+    judge: bool,
+    judge_provider: str | None,
+    judge_model: str | None,
+) -> None:
+    """Cluster failed, quality-below-threshold, error and missing cases by reason.
+
+    Grouping is deterministic (status, check or metric, masked message), so two
+    runs of the same results file produce the same clusters. With --judge the
+    clusters are also summarised by the judge model through the project's
+    judge runner. The analysis is written to artifacts/analysis_<ts>.json.
+    """
+    console = Console()
+    project_root = find_project_root()
+    results_path = _resolve_results_path(project_root, results)
+    data = load_json_file(results_path, "results file")
+    if not isinstance(data, dict) or not isinstance(data.get("cases"), list):
+        raise EvalConfigError(f"results file {results_path} has no 'cases' list")
+
+    clusters = cluster_results(data)
+    flagged = sorted({cid for c in clusters for cid in c["case_ids"]})
+    analysis: dict[str, Any] = {
+        "results_file": str(results_path),
+        "dataset_hash": data.get("dataset_hash"),
+        "generated_at": utc_now_iso(),
+        "total_cases": len(data["cases"]),
+        "flagged_cases": len(flagged),
+        "summary": data.get("summary"),
+        "clusters": clusters,
+        "judge_summary": None,
+    }
+
+    if judge and clusters:
+        if project_root is None:
+            raise EvalConfigError("--judge needs the project's environment; run inside the project")
+        config = load_eval_config(_paths.default_eval_config(project_root))
+        identity = resolve_judge_identity(
+            project_root,
+            config_provider=config.judge_provider,
+            config_model=config.judge_model,
+            flag_provider=judge_provider,
+            flag_model=judge_model,
+        )
+        console.print("Asking the judge model to summarise the clusters...")
+        output = run_judge_runner(
+            project_root,
+            {
+                "judge": identity,
+                "items": [
+                    {
+                        "id": "summary",
+                        "kind": "summarize",
+                        "prompt": _summary_prompt(data, clusters),
+                    }
+                ],
+            },
+        )
+        entry = results_by_id(output).get("summary") or {}
+        if entry.get("error"):
+            raise EvalConfigError(f"judge summary failed: {entry['error']}")
+        analysis["judge_summary"] = entry.get("reasoning") or ""
+        analysis["judge"] = {"provider": output.get("provider"), "model": output.get("model")}
+
+    root = project_root or Path.cwd()
+    out = Path(output_path) if output_path else _paths.default_analysis_path(root)
+    if not out.is_absolute():
+        out = root / out
+    write_json_file(out, analysis)
+
+    shown = clusters[:top_k] if top_k else clusters
+    if not clusters:
+        console.print(
+            f"[green]No failures to analyze[/green] in {results_path} ({len(data['cases'])} case(s) passed)."
+        )
+    else:
+        table = Table(
+            title=f"Failure clusters ({len(flagged)} of {len(data['cases'])} cases)",
+            show_header=True,
+            header_style="bold",
+        )
+        table.add_column("#", justify="right")
+        table.add_column("Status")
+        table.add_column("Check / metric")
+        table.add_column("Pattern")
+        table.add_column("Cases", justify="right")
+        table.add_column("Case ids")
+        for cluster in shown:
+            ids = ", ".join(cluster["case_ids"][:5]) + (
+                ", ..." if len(cluster["case_ids"]) > 5 else ""
+            )
+            table.add_row(
+                str(cluster["rank"]),
+                cluster["status"],
+                cluster["kind"],
+                cluster["pattern"],
+                str(cluster["count"]),
+                ids,
+            )
+        console.print(table)
+    if analysis["judge_summary"]:
+        console.rule("[bold]Judge summary[/bold]")
+        console.print(analysis["judge_summary"])
+    console.print(f"Analysis saved to [green]{out}[/green]")

graph_agents_cli/eval/cmd_compare.py

@@ -0,0 +1,284 @@
+# Copyright 2026 Google LLC
+# Modifications Copyright 2026 graph-agents-cli contributors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""graph-agents-cli eval compare command: diff two results files."""
+
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+from typing import Any
+
+import click
+from rich.table import Table
+
+from graph_agents_cli._output import Console, emit
+from graph_agents_cli.eval._common import EXIT_GATE_FAILED, load_json_file
+from graph_agents_cli.eval.gate import STATUS_RANK
+
+
+def _diff(base: dict, cand: dict, prefix: str = "") -> dict:
+    """Compute a recursive diff between two dicts.
+
+    Nested dicts are diffed recursively with dotted key paths.
+    Numeric changes include a delta (e.g., "+0.07" or "-0.03").
+    """
+    differences = {}
+
+    all_keys = set(base.keys()) | set(cand.keys())
+    for key in sorted(all_keys):
+        full_key = f"{prefix}{key}" if not prefix else f"{prefix}.{key}"
+        base_val = base.get(key)
+        cand_val = cand.get(key)
+
+        if base_val == cand_val:
+            continue
+
+        # Recurse into nested dicts
+        if isinstance(base_val, dict) and isinstance(cand_val, dict):
+            nested = _diff(base_val, cand_val, prefix=full_key)
+            differences.update(nested["differences"])
+            continue
+
+        entry = {"baseline": base_val, "candidate": cand_val}
+        if isinstance(base_val, int | float) and isinstance(cand_val, int | float):
+            delta = cand_val - base_val
+            entry["delta"] = f"+{delta}" if delta >= 0 else str(delta)
+        differences[full_key] = entry
+
+    if prefix:
+        return {"differences": differences}
+
+    return {
+        "baseline_keys": sorted(base.keys()),
+        "candidate_keys": sorted(cand.keys()),
+        "differences": differences,
+        "changed_keys": sorted(differences.keys()),
+        "unchanged_keys": sorted(k for k in all_keys if k not in differences),
+    }
+
+
+def _rank(status: str | None) -> int:
+    return STATUS_RANK.get(status or "", 3)
+
+
+def _score_map(case: dict[str, Any]) -> dict[str, float | None]:
+    return {
+        name: entry.get("score")
+        for name, entry in (case.get("judge_scores") or {}).items()
+        if isinstance(entry, dict)
+    }
+
+
+def compare_results(base: dict[str, Any], cand: dict[str, Any]) -> dict[str, Any]:
+    """Per-case status changes, quality-rate deltas, summary deltas, regression flag."""
+    base_cases = {c["id"]: c for c in base.get("cases", []) if isinstance(c, dict)}
+    cand_cases = {c["id"]: c for c in cand.get("cases", []) if isinstance(c, dict)}
+    cases: dict[str, dict[str, Any]] = {}
+    regressions: list[str] = []
+    improvements: list[str] = []
+    for case_id in sorted(set(base_cases) | set(cand_cases)):
+        b = base_cases.get(case_id)
+        c = cand_cases.get(case_id)
+        b_status = b.get("status") if b else None
+        c_status = c.get("status") if c else None
+        if b is None:
+            change = "added"
+        elif c is None:
+            change = "removed"
+            regressions.append(f"{case_id}: removed from the candidate run")
+        elif _rank(c_status) > _rank(b_status):
+            change = "regressed"
+            regressions.append(f"{case_id}: {b_status} -> {c_status}")
+        elif _rank(c_status) < _rank(b_status):
+            change = "improved"
+            improvements.append(f"{case_id}: {b_status} -> {c_status}")
+        else:
+            change = "unchanged"
+        scores: dict[str, dict[str, Any]] = {}
+        b_scores = _score_map(b) if b else {}
+        c_scores = _score_map(c) if c else {}
+        for metric in sorted(set(b_scores) | set(c_scores)):
+            entry: dict[str, Any] = {
+                "baseline": b_scores.get(metric),
+                "candidate": c_scores.get(metric),
+            }
+            if isinstance(entry["baseline"], int | float) and isinstance(
+                entry["candidate"], int | float
+            ):
+                entry["delta"] = round(entry["candidate"] - entry["baseline"], 4)
+            scores[metric] = entry
+        cases[case_id] = {
+            "baseline": b_status,
+            "candidate": c_status,
+            "change": change,
+            "candidate_reasons": (c or {}).get("reasons", []),
+            "scores": scores,
+        }
+
+    quality: dict[str, dict[str, Any]] = {}
+    b_quality = base.get("quality") or {}
+    c_quality = cand.get("quality") or {}
+    for metric in sorted(set(b_quality) | set(c_quality)):
+        b_entry = b_quality.get(metric) or {}
+        c_entry = c_quality.get(metric) or {}
+        b_rate = b_entry.get("pass_rate")
+        c_rate = c_entry.get("pass_rate")
+        entry = {
+            "baseline_pass_rate": b_rate,
+            "candidate_pass_rate": c_rate,
+            "baseline_met": b_entry.get("met"),
+            "candidate_met": c_entry.get("met"),
+            "min_pass_rate": c_entry.get("min_pass_rate", b_entry.get("min_pass_rate")),
+        }
+        if isinstance(b_rate, int | float) and isinstance(c_rate, int | float):
+            entry["delta"] = round(c_rate - b_rate, 4)
+            if c_rate < b_rate:
+                regressions.append(f"quality {metric}: pass rate {b_rate:.0%} -> {c_rate:.0%}")
+            elif c_rate > b_rate:
+                improvements.append(f"quality {metric}: pass rate {b_rate:.0%} -> {c_rate:.0%}")
+        if b_entry.get("met") is True and c_entry.get("met") is False:
+            regressions.append(f"quality {metric}: min_pass_rate no longer met")
+        quality[metric] = entry
+
+    b_summary = base.get("summary") or {}
+    c_summary = cand.get("summary") or {}
+    b_exit = b_summary.get("exit_code")
+    c_exit = c_summary.get("exit_code")
+    if isinstance(b_exit, int) and isinstance(c_exit, int) and c_exit > b_exit:
+        regressions.append(f"exit code {b_exit} -> {c_exit}")
+
+    return {
+        "dataset_hash": {
+            "baseline": base.get("dataset_hash"),
+            "candidate": cand.get("dataset_hash"),
+        },
+        "same_dataset": base.get("dataset_hash") == cand.get("dataset_hash"),
+        "traces_dataset_hash": {
+            label: {
+                "value": doc.get("traces_dataset_hash"),
+                # Only a recorded, differing value is a mismatch (older results lack the key).
+                "mismatch": bool(
+                    doc.get("traces_dataset_hash")
+                    and doc.get("dataset_hash")
+                    and doc.get("traces_dataset_hash") != doc.get("dataset_hash")
+                ),
+            }
+            for label, doc in (("baseline", base), ("candidate", cand))
+        },
+        "summary": _diff(b_summary, c_summary),
+        "quality": quality,
+        "cases": cases,
+        "regressions": regressions,
+        "improvements": improvements,
+        "regressed": bool(regressions),
+    }
+
+
+def _print_report(console: Console, report: dict[str, Any], baseline: str, candidate: str) -> None:
+    console.print(f"Baseline:  [cyan]{baseline}[/cyan]")
+    console.print(f"Candidate: [cyan]{candidate}[/cyan]")
+    if not report["same_dataset"]:
+        console.print("[yellow]Warning:[/yellow] the two results come from different datasets.")
+    for label, entry in (
+        ("baseline", report["traces_dataset_hash"]["baseline"]),
+        ("candidate", report["traces_dataset_hash"]["candidate"]),
+    ):
+        if entry["mismatch"]:
+            console.print(
+                f"[yellow]Warning:[/yellow] the {label} results were graded against a dataset "
+                "the traces were not generated from (traces_dataset_hash != dataset_hash)."
+            )
+
+    changed = {k: v for k, v in report["cases"].items() if v["change"] != "unchanged"}
+    table = Table(title="Case status changes", show_header=True, header_style="bold")
+    table.add_column("Case")
+    table.add_column("Baseline")
+    table.add_column("Candidate")
+    table.add_column("Change")
+    style = {"regressed": "red", "improved": "green", "added": "cyan", "removed": "magenta"}
+    for case_id, entry in changed.items():
+        table.add_row(
+            case_id,
+            str(entry["baseline"]),
+            str(entry["candidate"]),
+            f"[{style[entry['change']]}]{entry['change']}[/{style[entry['change']]}]",
+        )
+    if changed:
+        console.print(table)
+    else:
+        console.print(f"No case status changes across {len(report['cases'])} case(s).")
+
+    if report["quality"]:
+        qtable = Table(title="Quality metrics", show_header=True, header_style="bold")
+        qtable.add_column("Metric")
+        qtable.add_column("Baseline", justify="right")
+        qtable.add_column("Candidate", justify="right")
+        qtable.add_column("Delta", justify="right")
+        for metric, entry in report["quality"].items():
+            b, c = entry["baseline_pass_rate"], entry["candidate_pass_rate"]
+            qtable.add_row(
+                metric,
+                "n/a" if b is None else f"{b:.0%}",
+                "n/a" if c is None else f"{c:.0%}",
+                "n/a" if "delta" not in entry else f"{entry['delta']:+.0%}",
+            )
+        console.print(qtable)
+
+    diffs = report["summary"]["differences"]
+    if diffs:
+        console.print("Summary deltas:")
+        for key, entry in diffs.items():
+            delta = f" ({entry['delta']})" if "delta" in entry else ""
+            console.print(f"  {key}: {entry['baseline']} -> {entry['candidate']}{delta}")
+    if report["regressions"]:
+        console.print("[red]Regressions:[/red]")
+        for line in report["regressions"]:
+            console.print(f"  - {line}")
+    if report["improvements"]:
+        console.print("[green]Improvements:[/green]")
+        for line in report["improvements"]:
+            console.print(f"  - {line}")
+    if not report["regressions"]:
+        console.print("[green]No regressions.[/green]")
+
+
+@click.command("compare")
+@click.argument("baseline", type=click.Path(exists=True, dir_okay=False))
+@click.argument("candidate", type=click.Path(exists=True, dir_okay=False))
+@click.option("--fail-on-regression", is_flag=True, help="Exit 1 when the candidate regresses.")
+@click.option(
+    "--json", "as_json", is_flag=True, help="Print the full comparison as JSON instead of tables."
+)
+def cmd_compare(baseline: str, candidate: str, *, fail_on_regression: bool, as_json: bool) -> None:
+    """Compare two eval results files (baseline, candidate).
+
+    Reports per-case status changes, quality pass-rate deltas and summary
+    deltas. A regression is a case whose status got worse (or disappeared), a
+    quality metric whose pass rate dropped or stopped meeting its
+    min_pass_rate, or a worse exit code. Purely in-process.
+    """
+    base = load_json_file(Path(baseline), "baseline results")
+    cand = load_json_file(Path(candidate), "candidate results")
+    report = compare_results(base, cand)
+    report["baseline"] = baseline
+    report["candidate"] = candidate
+    if as_json:
+        emit(json.loads(json.dumps(report)))
+    else:
+        _print_report(Console(), report, baseline, candidate)
+    if fail_on_regression and report["regressed"]:
+        sys.exit(EXIT_GATE_FAILED)

graph_agents_cli/eval/cmd_eval_group.py

@@ -0,0 +1,80 @@
+# Copyright 2026 Google LLC
+# Modifications Copyright 2026 graph-agents-cli contributors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""graph-agents-cli eval command group."""
+
+import click
+
+from graph_agents_cli._click import LazyGroup
+
+
+@click.group("eval", cls=LazyGroup)
+def eval_group():
+    """Evaluate agents and compare results.
+
+    \b
+    Core:
+      run       Chain generate + grade in one command
+      generate  Run the agent over the eval dataset and write traces
+      grade     Grade traces against checks and judges; apply the gate
+      compare   Compare two eval results files
+      metric    Discover evaluation metrics
+
+    \b
+    Analysis and sharing:
+      analyze   Cluster failures by reason (optionally judge-summarised)
+      submit    Upload a dataset and results to LangSmith (optional)
+
+    \b
+    Exit codes (run, generate, grade):
+      0 gate met, 1 gate failed, 2 incomplete run, 3 configuration error
+    """
+
+
+eval_group.add_lazy_command(
+    "run",
+    "graph_agents_cli.eval.cmd_run:cmd_run",
+    "Chain `eval generate` and `eval grade` in one command.",
+)
+eval_group.add_lazy_command(
+    "generate",
+    "graph_agents_cli.eval.cmd_generate:cmd_generate",
+    "Run the agent over the eval dataset and write traces.",
+)
+eval_group.add_lazy_command(
+    "grade",
+    "graph_agents_cli.eval.cmd_grade:cmd_grade",
+    "Grade traces against the dataset's checks and judges and apply the gate.",
+)
+eval_group.add_lazy_command(
+    "compare",
+    "graph_agents_cli.eval.cmd_compare:cmd_compare",
+    "Compare two eval results files (baseline, candidate).",
+)
+eval_group.add_lazy_command(
+    "analyze",
+    "graph_agents_cli.eval.cmd_analyze:cmd_analyze",
+    "Cluster failed, quality-below-threshold, error and missing cases by reason.",
+)
+eval_group.add_lazy_command(
+    "submit",
+    "graph_agents_cli.eval.cmd_submit:cmd_submit",
+    "Upload the dataset and a results file to LangSmith as an experiment.",
+)
+eval_group.add_lazy_command(
+    "metric",
+    "graph_agents_cli.eval.cmd_metric:metric_group",
+    "Discover evaluation metrics: deterministic checks and judges.",
+)