aria-code 0.167.0__py3-none-win_amd64.whl

aria_code/evals/scorecard.py

@@ -0,0 +1,322 @@
+"""A model scorecard: how each model does on Aria's verifiable tasks, and what routing could save.
+
+    python3 -m aria_code.evals.scorecard run \\
+        --model aria=google/gemini-3.8-flash --model claude=anthropic/claude-sonnet-5-5 \\
+        --suite evals/suites/core.yaml --suite evals/suites/operations.yaml --repeat 3 --out scorecard/
+    python3 -m aria_code.evals.scorecard run ... --yes        # without --yes it only prints the plan
+    python3 -m aria_code.evals.scorecard report scorecard/ --cost aria=0.02 --cost claude=0.30
+
+Before training a router (or anything else) the question is whether routing is
+worth anything: on the tasks Aria is actually given, does a cheaper model succeed
+often enough that sending it there beats always using the strongest one? Nobody
+knows until the same tasks have been run on several models and checked by the same
+verifiers. This does that, keeps each run's trajectories (the first training
+material), and answers the question with a number.
+
+The routing figure is an upper bound. It assumes the router knows in advance which
+model will pass; a real one has to guess, and a failed cheap attempt costs money
+before the strong model starts. If even the upper bound is small, a learned router
+is not worth building.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import math
+import subprocess
+import sys
+from pathlib import Path
+from typing import Dict, List, Mapping, Optional, Sequence, Tuple
+
+#: A model "passes" a task when it passes at least this share of its scored attempts.
+PASS_SHARE = 0.5
+
+
+def wilson(passed: int, scored: int, z: float = 1.96) -> Tuple[float, float]:
+    """95% Wilson interval for a pass rate; (0, 1) when nothing was scored."""
+    if scored <= 0:
+        return 0.0, 1.0
+    p = passed / scored
+    denom = 1 + z * z / scored
+    centre = (p + z * z / (2 * scored)) / denom
+    half = z * math.sqrt(p * (1 - p) / scored + z * z / (4 * scored * scored)) / denom
+    return max(0.0, centre - half), min(1.0, centre + half)
+
+
+def parse_labelled(items: Sequence[str], what: str) -> Dict[str, str]:
+    """`["aria=google/x", "claude=anthropic/y"]` as an ordered {label: value}."""
+    out: Dict[str, str] = {}
+    for item in items:
+        label, sep, value = item.partition("=")
+        if not sep or not label.strip() or not value.strip():
+            raise ValueError(f"{what} must look like label=value, got {item!r}")
+        out[label.strip()] = value.strip()
+    return out
+
+
+def load_reports(root: Path) -> Dict[str, Dict[str, dict]]:
+    """`root/<label>/<suite>.json` as {label: {suite: report}}, labels in directory order."""
+    reports: Dict[str, Dict[str, dict]] = {}
+    for label_dir in sorted(p for p in Path(root).iterdir() if p.is_dir()):
+        for path in sorted(label_dir.glob("*.json")):
+            try:
+                data = json.loads(path.read_text(encoding="utf-8"))
+            except (OSError, ValueError):
+                continue
+            if isinstance(data, dict) and "results" in data:
+                reports.setdefault(label_dir.name, {})[str(data.get("suite") or path.stem)] = data
+    return reports
+
+
+def _scored(result: Mapping) -> bool:
+    return str(result.get("outcome", "")).lower() in ("pass", "fail")
+
+
+def model_stats(by_suite: Mapping[str, dict]) -> dict:
+    """Overall and per-domain (tag) numbers for one model across the suites it ran."""
+    passed = scored = errored = invalid = timed_out = 0
+    seconds: List[float] = []
+    domains: Dict[str, List[int]] = {}
+    for report in by_suite.values():
+        for result in report.get("results") or []:
+            outcome = str(result.get("outcome", "")).lower()
+            errored += outcome == "error"
+            timed_out += outcome == "error" and bool(result.get("timed_out"))
+            invalid += outcome == "invalid"
+            if not _scored(result):
+                continue
+            scored += 1
+            passed += outcome == "pass"
+            seconds.append(float(result.get("seconds") or 0))
+            for tag in result.get("tags") or []:
+                stats = domains.setdefault(str(tag), [0, 0])
+                stats[0] += outcome == "pass"
+                stats[1] += 1
+    low, high = wilson(passed, scored)
+    return {
+        "passed": passed, "scored": scored, "errored": errored, "invalid": invalid,
+        "timed_out": timed_out,
+        "pass_rate": passed / scored if scored else 0.0, "ci95": (low, high),
+        "mean_seconds": sum(seconds) / len(seconds) if seconds else 0.0,
+        "domains": {tag: {"passed": p, "scored": n, "pass_rate": p / n if n else 0.0}
+                    for tag, (p, n) in sorted(domains.items())},
+    }
+
+
+def task_matrix(reports: Mapping[str, Mapping[str, dict]]) -> Dict[str, Dict[str, Tuple[int, int]]]:
+    """{"suite/task": {label: (passed, scored)}} over every attempt of every model."""
+    matrix: Dict[str, Dict[str, List[int]]] = {}
+    for label, by_suite in reports.items():
+        for suite, report in by_suite.items():
+            for result in report.get("results") or []:
+                if not _scored(result):
+                    continue
+                cell = matrix.setdefault(f"{suite}/{result.get('task_id')}", {}).setdefault(label, [0, 0])
+                cell[0] += str(result.get("outcome", "")).lower() == "pass"
+                cell[1] += 1
+    return {task: {label: (p, n) for label, (p, n) in cells.items()} for task, cells in matrix.items()}
+
+
+def passes(cell: Optional[Tuple[int, int]]) -> bool:
+    return bool(cell) and cell[1] > 0 and cell[0] / cell[1] >= PASS_SHARE
+
+
+def routing_analysis(matrix: Mapping[str, Mapping[str, Tuple[int, int]]], order: Sequence[str],
+                     costs: Optional[Mapping[str, float]] = None, strong: str = "") -> dict:
+    """What an oracle router would have scored and spent, against always using one model.
+
+    `order` is cheapest first (or by `costs` when given). The oracle sends each task
+    to the cheapest model that passes it; `strong` (default: the model with the best
+    pass rate) is the always-use-it baseline. Costs are per task attempt, supplied by
+    the caller, because the eval reports do not carry token counts.
+    """
+    labels = sorted({l for cells in matrix.values() for l in cells}, key=lambda l: (
+        (costs or {}).get(l, float("inf")) if costs else 0.0, list(order).index(l) if l in order else len(order)))
+    if not labels or not matrix:
+        return {}
+    rates = {l: sum(passes(cells.get(l)) for cells in matrix.values()) for l in labels}
+    strong = strong if strong in labels else max(labels, key=lambda l: (rates[l], -labels.index(l)))
+    cost = lambda l: float((costs or {}).get(l, 0.0))  # noqa: E731
+    chosen: Dict[str, str] = {}
+    for task, cells in matrix.items():
+        for label in labels:
+            if passes(cells.get(label)):
+                chosen[task] = label
+                break
+    tasks = len(matrix)
+    # A task nobody solved still gets tried on the strongest model, so it is charged there.
+    oracle_cost = sum(cost(l) for l in chosen.values()) + cost(strong) * (tasks - len(chosen))
+    strong_solved = sum(passes(cells.get(strong)) for cells in matrix.values())
+    by_label: Dict[str, int] = {}
+    for label in chosen.values():
+        by_label[label] = by_label.get(label, 0) + 1
+    return {
+        "tasks": tasks, "strong": strong, "order": labels,
+        "strong_solved": strong_solved, "oracle_solved": len(chosen),
+        "strong_cost": cost(strong) * tasks, "oracle_cost": oracle_cost,
+        "sent_to": dict(sorted(by_label.items(), key=lambda kv: labels.index(kv[0]))),
+        "unsolved": sorted(t for t in matrix if t not in chosen),
+        "only_one_model": sorted(t for t, cells in matrix.items() if sum(passes(c) for c in cells.values()) == 1),
+        "has_costs": bool(costs),
+    }
+
+
+def render_markdown(reports: Mapping[str, Mapping[str, dict]], costs: Optional[Mapping[str, float]] = None,
+                    strong: str = "") -> str:
+    stats = {label: model_stats(by_suite) for label, by_suite in reports.items()}
+    domains = sorted({d for s in stats.values() for d in s["domains"]})
+    lines = ["## Model scorecard", "",
+             "| Model | Pass rate | 95% CI | Scored | Not scored | Timed out | Mean seconds |",
+             "|---|---:|---:|---:|---:|---:|---:|"]
+    for label, s in stats.items():
+        low, high = s["ci95"]
+        lines.append(f"| {label} | {s['pass_rate']:.0%} | {low:.0%}–{high:.0%} | {s['scored']} | "
+                     f"{s['errored'] + s['invalid']} | {s['timed_out']} | {s['mean_seconds']:.0f} |")
+    if domains:
+        lines += ["", "### By domain", "", "| Model | " + " | ".join(domains) + " |", "|---|" + "---:|" * len(domains)]
+        for label, s in stats.items():
+            cells = [f"{s['domains'][d]['passed']}/{s['domains'][d]['scored']}" if d in s["domains"] else "-" for d in domains]
+            lines.append(f"| {label} | " + " | ".join(cells) + " |")
+    analysis = routing_analysis(task_matrix(reports), list(reports), costs, strong)
+    if analysis:
+        n = analysis["tasks"]
+        lines += ["", "### Would routing pay?", "",
+                  f"{n} tasks. Always `{analysis['strong']}`: {analysis['strong_solved']}/{n} solved. "
+                  f"An oracle that sends each task to the cheapest model that passes it: {analysis['oracle_solved']}/{n} solved."]
+        if analysis["sent_to"]:
+            lines.append("Sent to: " + ", ".join(f"{label} {count}" for label, count in analysis["sent_to"].items()) + ".")
+        if analysis["has_costs"]:
+            saved = analysis["strong_cost"] - analysis["oracle_cost"]
+            share = saved / analysis["strong_cost"] if analysis["strong_cost"] else 0.0
+            lines.append(f"Cost per run of all tasks: ${analysis['strong_cost']:.2f} always-strong vs "
+                         f"${analysis['oracle_cost']:.2f} oracle ({share:.0%} less).")
+        else:
+            lines.append("No `--cost` given, so no spend comparison; add `--cost label=USD_per_task`.")
+        if analysis["only_one_model"]:
+            lines.append("Passed by exactly one model (where choosing matters): " + ", ".join(analysis["only_one_model"][:12]) + ".")
+        if analysis["unsolved"]:
+            lines.append("Solved by none: " + ", ".join(analysis["unsolved"][:12]) + ".")
+        lines += ["", "This is an upper bound: the oracle knows which model will pass before trying, "
+                      "and a real router pays for the cheap attempts that fail. If it is small here, "
+                      "a learned router will not recover it."]
+    return "\n".join(lines) + "\n"
+
+
+# ── running ──────────────────────────────────────────────────────────────────
+
+def plan(models: Mapping[str, str], suites: Sequence[str], repeat: int, out: Path, force: bool) -> List[dict]:
+    """Every (model, suite) run to make, skipping the ones already reported unless forced."""
+    jobs = []
+    for label, model in models.items():
+        for suite in suites:
+            report = Path(out) / label / f"{Path(suite).stem}.json"
+            jobs.append({"label": label, "model": model, "suite": suite, "report": report,
+                         "skip": report.exists() and not force})
+    return jobs
+
+
+def task_ids(suite: str) -> List[str]:
+    from .harness import load_suite
+
+    return [str(task.id) for task in load_suite(Path(suite))[1]]
+
+
+def task_count(suite: str) -> int:
+    return len(task_ids(suite))
+
+
+def unknown_tasks(suites: Sequence[str], only: Sequence[str]) -> List[str]:
+    """Ids in `only` that no named suite contains. The runner would run nothing and
+    report 0/0, which reads as a result; a typo has to be an error instead."""
+    known = {tid for suite in suites for tid in task_ids(suite)}
+    return [tid for tid in only if tid not in known]
+
+
+def command_for(job: Mapping, repeat: int, out: Path, timeout: int, runtime: str, only: Sequence[str],
+                local: Sequence[str] = ()) -> List[str]:
+    command = [sys.executable, "-m", "aria_code.evals.runner", str(job["suite"]), "--model", job["model"],
+               "--repeat", str(repeat), "--report", str(job["report"]), "--solve-timeout", str(timeout),
+               "--trajectories", str(Path(out) / job["label"] / "trajectories")]
+    if runtime != "python":
+        command.extend(["--runtime", runtime])
+    if job["label"] in local:
+        command.append("--local")  # Ollama only, no cloud: for a model on this machine
+    if only:
+        command.extend(["--only", *only])
+    return command
+
+
+def main(argv: Optional[Sequence[str]] = None) -> int:
+    parser = argparse.ArgumentParser(prog="aria-scorecard", description=__doc__,
+                                     formatter_class=argparse.RawDescriptionHelpFormatter)
+    sub = parser.add_subparsers(dest="action", required=True)
+    run = sub.add_parser("run", help="run the suites on several models (prints the plan unless --yes)")
+    run.add_argument("--model", action="append", default=[], metavar="LABEL=MODEL", help="repeatable, cheapest first")
+    run.add_argument("--suite", action="append", default=[], metavar="PATH", help="repeatable")
+    run.add_argument("--repeat", type=int, default=3)
+    run.add_argument("--out", default="scorecard")
+    run.add_argument("--only", nargs="*", default=[], help="limit to these task ids (a smoke test)")
+    run.add_argument("--solve-timeout", type=int, default=900)
+    run.add_argument("--runtime", choices=("python", "native"), default="python")
+    run.add_argument("--local", action="append", default=[], metavar="LABEL",
+                     help="run this label's model on this machine (Ollama), free; repeatable")
+    run.add_argument("--force", action="store_true", help="redo runs that already have a report")
+    run.add_argument("--yes", action="store_true", help="actually run; this calls the models and costs money")
+    rep = sub.add_parser("report", help="summarise the reports under a folder")
+    rep.add_argument("root")
+    rep.add_argument("--cost", action="append", default=[], metavar="LABEL=USD", help="estimated USD per task attempt")
+    rep.add_argument("--strong", default="", help="the always-use baseline (default: the best pass rate)")
+    args = parser.parse_args(argv)
+
+    try:
+        if args.action == "report":
+            costs = {k: float(v) for k, v in parse_labelled(args.cost, "--cost").items()}
+            reports = load_reports(Path(args.root))
+            if not reports:
+                print(f"no reports under {args.root}", file=sys.stderr)
+                return 2
+            print(render_markdown(reports, costs or None, args.strong))
+            return 0
+        models = parse_labelled(args.model, "--model")
+    except ValueError as exc:
+        print(str(exc), file=sys.stderr)
+        return 2
+    if not models or not args.suite:
+        print("give at least one --model and one --suite", file=sys.stderr)
+        return 2
+    missing = unknown_tasks(args.suite, args.only)
+    if missing:
+        print(f"no such task in the suites: {', '.join(missing)}", file=sys.stderr)
+        return 2
+    out = Path(args.out)
+    jobs = plan(models, args.suite, args.repeat, out, args.force)
+    attempts = 0
+    print(f"\n{len(models)} model(s) x {len(args.suite)} suite(s), {args.repeat} attempt(s) per task:")
+    for job in jobs:
+        tasks = len(args.only) if args.only else task_count(job["suite"])
+        calls = tasks * args.repeat
+        attempts += 0 if job["skip"] else calls
+        print(f"  {job['label']:<12} {Path(job['suite']).stem:<12} {tasks} tasks x {args.repeat} = {calls} agent runs"
+              f"{'  (already done, skipped)' if job['skip'] else ''}")
+    print(f"\n{attempts} agent runs in all. Each is a full coding session on the model, so this spends real money.")
+    if not args.yes:
+        print("Nothing was run. Add --yes to run it (try --only <task-id> first as a smoke test).")
+        return 0
+    failures = 0
+    for job in jobs:
+        if job["skip"]:
+            continue
+        Path(job["report"]).parent.mkdir(parents=True, exist_ok=True)
+        print(f"\n== {job['label']} · {Path(job['suite']).stem}")
+        # A task the model gets wrong exits 1; only a runner that could not start is a failure here.
+        done = subprocess.run(command_for(job, args.repeat, out, args.solve_timeout, args.runtime, args.only, args.local), check=False)
+        if done.returncode not in (0, 1) or not Path(job["report"]).exists():
+            failures += 1
+            print(f"!! {job['label']} · {Path(job['suite']).stem} did not produce a report (exit {done.returncode})")
+    print(f"\nnext: python3 -m aria_code.evals.scorecard report {out}")
+    return 1 if failures else 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

aria_code/evals/summary.py

@@ -0,0 +1,125 @@
+"""Turn eval reports into a Markdown scoreboard, and decide whether the run is healthy.
+
+    python3 -m aria_code.evals.summary evals-core.json evals-operations.json [--private evals-holdout.json]
+
+Each suite's score comes with the mean per-task pass rate and its standard
+error, so two runs can be told apart from noise. A report passed after
+``--private`` (the holdout suites, kept in a private repository) is shown as
+counts only: no task ids, details or logs, because the summary is public.
+
+The suites ran in CI only with ``--check``: every fixture still starts red,
+but no model ever attempted them, so nothing measured whether Aria can fix
+code. The weekly workflow (.github/workflows/evals.yml) runs them with a real
+model and writes this summary.
+
+A task the model gets wrong is a result, not a broken build: the exit code is
+1 only when a task could not run (ERROR) or no longer measures anything
+(INVALID), the two outcomes that mean the harness, not the model, needs work.
+"""
+
+from __future__ import annotations
+
+import json
+import math
+import sys
+from collections import defaultdict
+from pathlib import Path
+
+
+def mean_sem(report: dict) -> tuple[float, float, int] | None:
+    """Mean per-task pass rate over scored attempts, its standard error, and the task count."""
+    passed: dict[str, int] = defaultdict(int)
+    scored: dict[str, int] = defaultdict(int)
+    for r in report.get("results") or []:
+        if str(r.get("outcome", "")).lower() in ("pass", "fail"):
+            scored[str(r.get("task_id"))] += 1
+            passed[str(r.get("task_id"))] += str(r.get("outcome")).lower() == "pass"
+    rates = [passed[t] / scored[t] for t in scored]
+    if not rates:
+        return None
+    mean = sum(rates) / len(rates)
+    if len(rates) < 2:
+        return mean, 0.0, 1
+    var = sum((x - mean) ** 2 for x in rates) / (len(rates) - 1)
+    return mean, math.sqrt(var / len(rates)), len(rates)
+
+
+def summarise(reports: list[dict], model: str = "", private: list[dict] | None = None) -> tuple[str, int]:
+    """Markdown for the reports, and the exit code the run should have."""
+    lines = [f"## Aria eval scoreboard{f' · {model}' if model else ''}", ""]
+    unhealthy = 0
+    for report in [*reports, *(private or [])]:
+        is_private = any(report is p for p in private or [])
+        suite = report.get("suite", "?")
+        lines.append(f"### {suite}{' (holdout)' if is_private else ''}: "
+                     f"{report.get('passed', 0)}/{report.get('scored', 0)} ({report.get('pass_rate', 0):.0%})")
+        stats = mean_sem(report)
+        if stats:
+            mean, sem, n = stats
+            lines.append(f"Mean task pass rate {mean:.0%} ± {sem:.0%} (SEM over {n} task{'s' if n != 1 else ''}).")
+        extras = [f"{report[k]} {k}" for k in ("errored", "invalid") if report.get(k)]
+        if report.get("timed_out"):
+            # Timeouts are ERROR and drop out of the rate; say how many, or a
+            # suite where most attempts timed out reads like a high score.
+            extras.append(f"{report['timed_out']} of the errors timed out")
+        if extras:
+            lines.append(f"Not scored: {', '.join(extras)}.")
+        unhealthy += int(report.get("errored", 0)) + int(report.get("invalid", 0))
+        if is_private:
+            lines += ["Task ids, details and logs are not published for holdout suites.", ""]
+            continue
+        lines += ["", "| Task | Outcome | Seconds | Detail |", "|---|---|---:|---|"]
+        for result in report.get("results", []):
+            detail = str(result.get("detail") or "").replace("|", "\\|")[:120]
+            lines.append(f"| {result.get('task_id')} | {result.get('outcome')} | "
+                         f"{result.get('seconds', 0):.0f} | {detail} |")
+        for result in report.get("results", []):
+            tail = result.get("log_tail") or []
+            if tail and str(result.get("outcome", "")).lower() != "pass":
+                body = "\n".join(tail).replace("```", "` ` `")
+                lines += ["", f"<details><summary>{result.get('task_id')}: last lines of the log</summary>",
+                          "", "```", body, "```", "</details>"]
+        checks = report.get("behavior") or {}
+        if checks:
+            lines += ["", "| Behaviour check | Passed |", "|---|---:|"]
+            lines += [f"| {name.replace('|', '/')} | {s['passed']}/{s['runs']} |" for name, s in checks.items()]
+        by_tag = report.get("by_tag") or {}
+        if by_tag:
+            tags = ", ".join(f"{tag} {s['passed']}/{s['scored']}" for tag, s in by_tag.items() if s.get("scored"))
+            if tags:
+                lines += ["", f"By tag: {tags}"]
+        lines.append("")
+    return "\n".join(lines), (1 if unhealthy else 0)
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = list(sys.argv[1:] if argv is None else argv)
+    model = ""
+    if args[:1] == ["--model"] and len(args) > 1:
+        model, args = args[1], args[2:]
+    public_names, private_names = args, []
+    if "--private" in args:
+        i = args.index("--private")
+        public_names, private_names = args[:i], args[i + 1:]
+
+    def load(names: list[str]) -> list[dict]:
+        out = []
+        for name in names:
+            path = Path(name)
+            if path.exists():
+                out.append(json.loads(path.read_text(encoding="utf-8")))
+            else:
+                print(f"(no report at {name})", file=sys.stderr)
+        return out
+
+    reports, private = load(public_names), load(private_names)
+    if not reports and not private:
+        print("no eval reports to summarise", file=sys.stderr)
+        return 1
+    text, code = summarise(reports, model, private)
+    print(text)
+    return code
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

aria_code/external_agent_runner.py

@@ -0,0 +1,115 @@
+"""Delegate a task to the Claude Code or Codex CLI as an external headless agent.
+
+Complements runtime/subagent.py's spawn_task system: by default a spawned
+task runs inside aria-code's own LLM loop, but a task can instead be
+delegated to another agentic coding CLI already installed on the machine
+(``backend="claude"`` / ``backend="codex"``), reusing whatever coding
+capability that tool has. Both runners return plain text — a success/failure
+string, never a raised exception — so a missing binary or a CLI-side failure
+degrades the same way a normal subagent failure does (task.status="failed"
+with .error set), and never crashes the background task loop.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import shutil
+from typing import Optional
+
+
+async def _run_cli(
+    binary: str,
+    args: list[str],
+    *,
+    cwd: Optional[str],
+    timeout: float,
+) -> tuple[bool, str]:
+    """Run one CLI invocation. Returns (ok, text) — never raises."""
+    if not shutil.which(binary):
+        return False, f"{binary} CLI not found on PATH. Install it first."
+    try:
+        proc = await asyncio.create_subprocess_exec(
+            binary, *args,
+            cwd=cwd,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+    except Exception as exc:
+        return False, f"Failed to launch {binary}: {exc}"
+
+    try:
+        stdout, stderr = await asyncio.wait_for(proc.communicate(), timeout=timeout)
+    except asyncio.TimeoutError:
+        proc.kill()
+        return False, f"{binary} CLI timed out after {timeout:.0f}s."
+
+    out_text = stdout.decode("utf-8", errors="replace")
+    if proc.returncode != 0:
+        err_text = stderr.decode("utf-8", errors="replace")[:500]
+        return False, f"{binary} CLI exited {proc.returncode}: {err_text or out_text[:500]}"
+    return True, out_text
+
+
+def _extract_json_result(raw: str, *keys: str) -> str:
+    """Best-effort pull of the human-readable result out of a CLI's JSON output.
+
+    Both CLIs' exact JSON shapes can vary by version, so this tries each
+    candidate key and falls back to the raw text — a schema drift should
+    degrade to "less clean output", not a crash or an empty result.
+    """
+    raw = raw.strip()
+    if not raw:
+        return "(no output)"
+    try:
+        data = json.loads(raw)
+    except json.JSONDecodeError:
+        return raw
+    if isinstance(data, dict):
+        for key in keys:
+            value = data.get(key)
+            if isinstance(value, str) and value:
+                return value
+    return raw
+
+
+async def run_claude_code_headless(
+    prompt: str,
+    *,
+    cwd: Optional[str] = None,
+    timeout: float = 600.0,
+) -> str:
+    """Delegate `prompt` to `claude -p` (Claude Code headless mode)."""
+    ok, text = await _run_cli(
+        "claude",
+        ["-p", prompt, "--output-format", "json"],
+        cwd=cwd,
+        timeout=timeout,
+    )
+    if not ok:
+        return f"错误: {text}"
+    return _extract_json_result(text, "result", "response")
+
+
+async def run_codex_headless(
+    prompt: str,
+    *,
+    cwd: Optional[str] = None,
+    timeout: float = 600.0,
+) -> str:
+    """Delegate `prompt` to `codex exec` (OpenAI Codex CLI headless mode)."""
+    ok, text = await _run_cli(
+        "codex",
+        ["exec", prompt, "--json"],
+        cwd=cwd,
+        timeout=timeout,
+    )
+    if not ok:
+        return f"错误: {text}"
+    return _extract_json_result(text, "result", "message", "output")
+
+
+RUNNERS = {
+    "claude": run_claude_code_headless,
+    "codex": run_codex_headless,
+}

aria_code/figma_client.py

@@ -0,0 +1,4 @@
+"""Compatibility import for :mod:`clients.figma_client`."""
+from importlib import import_module as _import_module
+import sys as _sys
+_sys.modules[__name__] = _import_module("clients.figma_client")

aria_code/file_analysis_tools.py

@@ -0,0 +1,4 @@
+"""Compatibility import for :mod:`tools.file_analysis_tools`."""
+from importlib import import_module as _import_module
+import sys as _sys
+_sys.modules[__name__] = _import_module("tools.file_analysis_tools")

aria_code/finance_formulas.py

@@ -0,0 +1,4 @@
+"""Compatibility import for :mod:`domain.finance_formulas`."""
+from importlib import import_module as _import_module
+import sys as _sys
+_sys.modules[__name__] = _import_module("domain.finance_formulas")

aria_code/football_data_client.py

@@ -0,0 +1,4 @@
+"""Compatibility import for :mod:`clients.football_data_client`."""
+from importlib import import_module as _import_module
+import sys as _sys
+_sys.modules[__name__] = _import_module("clients.football_data_client")

aria_code/image_gen_tools.py

@@ -0,0 +1,4 @@
+"""Compatibility import for :mod:`tools.image_gen_tools`."""
+from importlib import import_module as _import_module
+import sys as _sys
+_sys.modules[__name__] = _import_module("tools.image_gen_tools")