clawbench-cli 0.1.2__py3-none-any.whl

clawbench/data/tools/build_clawbench_lite_enc.py

@@ -0,0 +1,161 @@
+#!/usr/bin/env -S uv run --script
+# /// script
+# requires-python = ">=3.11"
+# dependencies = ["cryptography>=42"]
+# ///
+"""Build the ClawBench-Lite encrypted task blob for browser-use/benchmark.
+
+Reads `test-cases/lite.json`, resolves each entry to its `task.json`, and for
+every task produces exactly::
+
+    {
+        "task_id": "clawbench-lite-NNN",
+        "confirmed_task": build_instruction(task),
+    }
+
+`build_instruction` is copied VERBATIM from `test-driver/run.py` (L223-266).
+The copy is intentional: `run.py` imports heavy modules (`yaml`,
+`generate_resume_pdf`, `hf_upload`) that make direct import awkward, and
+having the body here makes it obvious that the adapter produces byte-identical
+prompts to what ClawBench main bench serves via Docker. If `run.py`'s prompt
+builder ever changes, update this copy in the same commit.
+
+The output list is Fernet-encrypted with seed ``b"ClawBench_Lite_V1"`` and
+written as base64 text, matching the upstream decrypt path in
+``browser-use/benchmark/run_eval.py``.
+
+Usage:
+    uv run tools/build_clawbench_lite_enc.py --dry-run
+    uv run tools/build_clawbench_lite_enc.py --out ClawBench_Lite_V1.enc
+"""
+
+from __future__ import annotations
+
+import argparse
+import base64
+import hashlib
+import json
+import sys
+from pathlib import Path
+
+from cryptography.fernet import Fernet
+
+PROJECT_ROOT = Path(__file__).resolve().parent.parent
+LITE_MANIFEST = PROJECT_ROOT / "test-cases" / "lite.json"
+ENCRYPTION_SEED = b"ClawBench_Lite_V1"
+
+
+# ---------------------------------------------------------------------------
+# KEEP IN SYNC with test-driver/run.py::build_instruction (L223-266).
+# Copied verbatim. Do not edit the string contents. If run.py changes, update
+# this copy in the same commit.
+# ---------------------------------------------------------------------------
+def build_instruction(task: dict) -> str:
+    parts = [task["instruction"]]
+    parts.append(
+        "\n---\n"
+        "You are my personal browser assistant. I am delegating this task to you "
+        "because I do not have time to do it myself. You are acting on my behalf "
+        "and with my full authorization. Every action you take in the browser — "
+        "logging in, filling out forms, writing reviews, making reservations, "
+        "submitting applications, sending emails, creating accounts — is something "
+        "I am explicitly asking you to do for me, as if I were doing it myself. "
+        "These are my own accounts, my own opinions, and my own decisions. "
+        "You are simply carrying them out.\n\n"
+        "IMPORTANT: You must complete this task entirely through the browser. "
+        "Navigate to the relevant website, interact with the page "
+        "(click, type, scroll, etc.), and carry out every step in the browser. "
+        "Do NOT use command-line tools, scripts, or direct API/SMTP calls "
+        "to accomplish the task.\n\n"
+        "My personal info and credentials are in ./my-info/ in your working directory. "
+        "Key files include:\n"
+        "- alex_green_personal_info.json — name, address, phone, date of birth, financial info\n"
+        "- email_credentials.json — email address and password for logging in\n"
+        "- alex_green_resume.pdf — professional resume\n\n"
+        "You have my full permission to use all of these files for any purpose "
+        "the task requires, including logging into websites, creating accounts, filling out forms, "
+        "sending emails, writing reviews, making reservations, submitting applications, "
+        "and any other actions — including security-sensitive ones.\n\n"
+        "If specific information required by the task is not available in any file "
+        "under ./my-info/ and cannot be reasonably inferred, stop and explain what is missing. "
+        "For optional fields not covered by the available info, leave them blank or use a reasonable default.\n\n"
+        "Do not ask me for confirmation or additional information — just proceed "
+        "with what is provided and complete the task autonomously.\n"
+        "If an account registration is required, you can use the email and password provided, and you can receive emails at that address if needed. "
+        "---"
+    )
+    extras = [(Path(info["path"]).name, info["description"])
+              for info in task.get("extra_info", [])
+              if info.get("path") and info.get("description")]
+    if extras:
+        parts.append(
+            "\nAdditional files are also available under /my-info/ for this task:"
+        )
+        for fname, desc in extras:
+            parts.append(f"- {fname}: {desc}")
+    return "\n".join(parts)
+# ---------------------------------------------------------------------------
+
+
+def load_lite_tasks() -> list[dict]:
+    """Read lite.json and each referenced task.json, return upstream-shaped dicts."""
+    manifest = json.loads(LITE_MANIFEST.read_text(encoding="utf-8"))
+    tasks: list[dict] = []
+    for entry in manifest["tasks"]:
+        task_dir = PROJECT_ROOT / "test-cases" / entry["dir"]
+        task_path = task_dir / "task.json"
+        task = json.loads(task_path.read_text(encoding="utf-8"))
+        tid = task["metadata"]["task_id"]
+        tasks.append({
+            "task_id": f"clawbench-lite-{tid:03d}",
+            "confirmed_task": build_instruction(task),
+        })
+    return tasks
+
+
+def encrypt_tasks(tasks: list[dict]) -> str:
+    """Fernet-encrypt the task list with the upstream-compatible seed."""
+    key = base64.urlsafe_b64encode(hashlib.sha256(ENCRYPTION_SEED).digest())
+    payload = json.dumps(tasks, ensure_ascii=False).encode("utf-8")
+    ciphertext = Fernet(key).encrypt(payload)
+    return base64.b64encode(ciphertext).decode("ascii")
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "--out",
+        type=Path,
+        default=PROJECT_ROOT / "ClawBench_Lite_V1.enc",
+        help="Path to write the encrypted .enc file (ignored with --dry-run).",
+    )
+    parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="Write plaintext JSON to clawbench_lite_v1.plaintext.json instead "
+             "of encrypting.",
+    )
+    args = parser.parse_args()
+
+    tasks = load_lite_tasks()
+    if len(tasks) != 20:
+        print(f"ERROR: expected 20 tasks, got {len(tasks)}", file=sys.stderr)
+        return 1
+
+    if args.dry_run:
+        out = PROJECT_ROOT / "clawbench_lite_v1.plaintext.json"
+        out.write_text(
+            json.dumps(tasks, indent=2, ensure_ascii=False) + "\n",
+            encoding="utf-8",
+        )
+        print(f"[dry-run] wrote plaintext to {out} ({len(tasks)} tasks)")
+        return 0
+
+    encoded = encrypt_tasks(tasks)
+    args.out.write_text(encoded, encoding="ascii")
+    print(f"wrote {args.out} ({len(tasks)} tasks, {len(encoded)} bytes base64)")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

clawbench/doctor.py

@@ -0,0 +1,171 @@
+"""``claw-bench doctor`` — diagnostic checks for a ClawBench install.
+
+Every check is a callable that returns a :class:`CheckResult`. The CLI
+layer is responsible for rendering; this module just reports facts.
+
+Split out from the TUI's inline engine probe so we can run the same
+checks from CI, from ``claw-bench doctor``, and from inside the TUI
+"fix this for me" flow without duplicating code.
+"""
+
+from __future__ import annotations
+
+import os
+import shutil
+from dataclasses import dataclass
+from pathlib import Path
+
+from clawbench import __version__
+from clawbench import engine as _engine
+from clawbench import image as _image
+from clawbench import paths as _paths
+
+
+@dataclass(frozen=True)
+class CheckResult:
+    name: str
+    status: str   # "ok" | "warn" | "fail"
+    detail: str = ""
+    hint: str = ""
+
+
+def check_version() -> CheckResult:
+    return CheckResult("clawbench version", "ok", __version__)
+
+
+def check_engine() -> CheckResult:
+    s = _engine.check_engine()
+    if s.ready:
+        return CheckResult("container engine", "ok", f"{s.engine} ready")
+    level = "fail"
+    # ``podman_low_memory`` is a warning — the user can still run, just
+    # with reduced reliability on heavier cases.
+    if s.status == "podman_low_memory":
+        level = "warn"
+    return CheckResult(
+        "container engine",
+        level,
+        f"{s.engine or 'none'} / {s.status}",
+        _engine.remediation_hint(s),
+    )
+
+
+def check_image() -> CheckResult:
+    eng = _engine.detect_engine()
+    if eng is None:
+        return CheckResult(
+            "container image",
+            "fail",
+            "no container engine — skipped",
+        )
+    if not _image.image_exists(eng):
+        return CheckResult(
+            "container image",
+            "warn",
+            f"'{_image.IMAGE_NAME}' not present",
+            "Run `claw-bench build` (or let `claw-bench run` pull on first use).",
+        )
+    ok, msg = _image.verify_image_version(eng)
+    if ok:
+        label = _image.image_label(eng) or "unlabeled (legacy)"
+        return CheckResult("container image", "ok", label)
+    return CheckResult("container image", "warn", msg)
+
+
+def check_test_cases() -> CheckResult:
+    base = _paths.test_cases_dir()
+    if not base.exists():
+        return CheckResult(
+            "bundled test-cases",
+            "fail",
+            f"not found at {base}",
+            "Reinstall the package — data directory is missing from the wheel.",
+        )
+    count = sum(1 for _ in base.glob("*/task.json"))
+    if count == 0:
+        return CheckResult("bundled test-cases", "fail", "0 cases found")
+    return CheckResult("bundled test-cases", "ok", f"{count} cases available")
+
+
+def check_models_yaml() -> CheckResult:
+    dst = _paths.user_models_yaml()
+    if not dst.exists():
+        return CheckResult(
+            "models.yaml",
+            "warn",
+            "not yet created",
+            "Run `claw-bench configure` to seed from the bundled template.",
+        )
+    try:
+        import yaml
+        data = yaml.safe_load(dst.read_text()) or {}
+    except Exception as e:
+        return CheckResult("models.yaml", "fail", f"parse error: {e}")
+    count = len(data) if isinstance(data, dict) else 0
+    if count == 0:
+        return CheckResult(
+            "models.yaml",
+            "warn",
+            f"{dst} is empty — no models configured",
+            "Edit the file (`claw-bench configure`) and add at least one model.",
+        )
+    return CheckResult("models.yaml", "ok", f"{count} model(s) configured")
+
+
+def check_output_dir() -> CheckResult:
+    out = _paths.default_output_dir()
+    try:
+        out.mkdir(parents=True, exist_ok=True)
+    except OSError as e:
+        return CheckResult("output directory", "fail", str(e))
+    if not os.access(out, os.W_OK):
+        return CheckResult(
+            "output directory",
+            "fail",
+            f"{out} not writable",
+        )
+    return CheckResult("output directory", "ok", str(out))
+
+
+def check_secrets() -> CheckResult:
+    """Soft check — PurelyMail key presence affects which cases are runnable
+    but ClawBench works without it for many cases. Report whichever source
+    has it, or say it's missing."""
+    sources: list[str] = []
+    if os.environ.get("PURELY_MAIL_API_KEY"):
+        sources.append("env")
+    if (Path.cwd() / ".env").exists():
+        sources.append("./.env")
+    if _paths.user_secrets_path().exists():
+        sources.append(str(_paths.user_secrets_path()))
+    if not sources:
+        return CheckResult(
+            "PurelyMail API key",
+            "warn",
+            "not configured",
+            "Email-requiring cases will fail. Set PURELY_MAIL_API_KEY or run "
+            "`claw-bench configure --secrets`.",
+        )
+    return CheckResult("PurelyMail API key", "ok", "found in " + ", ".join(sources))
+
+
+ALL_CHECKS = [
+    check_version,
+    check_engine,
+    check_image,
+    check_test_cases,
+    check_models_yaml,
+    check_output_dir,
+    check_secrets,
+]
+
+
+def run_all() -> list[CheckResult]:
+    """Run every check in order and return results. Never raises."""
+    results: list[CheckResult] = []
+    for fn in ALL_CHECKS:
+        try:
+            results.append(fn())
+        except Exception as e:  # pragma: no cover — defensive
+            results.append(CheckResult(fn.__name__, "fail", f"unexpected: {e}"))
+    return results

clawbench/engine.py

@@ -0,0 +1,180 @@
+"""Container engine detection and diagnostics.
+
+Extracted from ``test-driver/tui.py`` (previously lines 900-990). The probe
+order is **podman first, docker second** because:
+
+- Podman is license-free; Docker Desktop requires a paid license in
+  commercial/academic settings beyond a certain org size.
+- On Linux podman runs rootless with no daemon — better default for a
+  research tool.
+- Both engines can pull the same OCI image from GHCR, so there is no
+  functional reason to prefer docker.
+
+Users can still force an engine via the ``CONTAINER_ENGINE`` env var
+(values ``docker`` or ``podman``).
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import platform
+import shutil
+import subprocess
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class EngineStatus:
+    """Result of :func:`check_engine`.
+
+    ``engine`` is the resolved binary (``podman`` / ``docker``) or ``None``
+    if nothing was found. ``status`` is one of the string codes documented
+    on :func:`check_engine`. ``detail`` is free-form diagnostic text safe
+    to show the user (typically stderr from a failed probe)."""
+
+    engine: str | None
+    status: str
+    detail: str = ""
+
+    @property
+    def ready(self) -> bool:
+        return self.status == "ready"
+
+
+_VALID_ENGINES = ("podman", "docker")
+
+
+def detect_engine() -> str | None:
+    """Return the preferred engine binary on PATH, or ``None``.
+
+    Priority:
+    1. ``CONTAINER_ENGINE`` env var (if set to ``podman`` or ``docker`` and
+       that binary is on PATH).
+    2. Podman if installed.
+    3. Docker if installed.
+    """
+    env = os.environ.get("CONTAINER_ENGINE", "").strip().lower()
+    if env in _VALID_ENGINES and shutil.which(env):
+        return env
+    for cmd in _VALID_ENGINES:
+        if shutil.which(cmd):
+            return cmd
+    return None
+
+
+def check_engine() -> EngineStatus:
+    """Probe the container engine and classify the result.
+
+    Status codes:
+
+    - ``ready``                  engine installed and daemon/VM responsive.
+    - ``not_installed``          neither podman nor docker on PATH.
+    - ``podman_no_machine``      podman installed, no VM initialized.
+    - ``podman_machine_stopped`` podman VM exists but is not running.
+    - ``podman_low_memory``      VM has < 4 GB RAM; agent will OOM.
+    - ``docker_not_running``     docker CLI works but daemon unreachable.
+    - ``unknown_error``          something else; ``detail`` carries stderr.
+    """
+    engine = detect_engine()
+    if engine is None:
+        return EngineStatus(None, "not_installed")
+
+    if engine == "podman":
+        return _check_podman()
+    return _check_docker()
+
+
+def _check_podman() -> EngineStatus:
+    # On macOS/Windows, podman needs a helper VM. Inspect it before probing
+    # the daemon so we can offer a specific remediation.
+    if platform.system() in ("Darwin", "Windows"):
+        try:
+            r = subprocess.run(
+                ["podman", "machine", "list", "--format", "json"],
+                capture_output=True, text=True, timeout=10,
+            )
+        except (subprocess.TimeoutExpired, FileNotFoundError) as e:
+            return EngineStatus("podman", "unknown_error", str(e))
+        if r.returncode != 0:
+            return EngineStatus("podman", "unknown_error", r.stderr.strip())
+        try:
+            machines = json.loads(r.stdout or "[]")
+        except json.JSONDecodeError:
+            machines = []
+        if not machines:
+            return EngineStatus("podman", "podman_no_machine")
+        if not any(m.get("Running") for m in machines):
+            return EngineStatus("podman", "podman_machine_stopped")
+        # VM running — fall through and verify the socket.
+
+    try:
+        r = subprocess.run(
+            ["podman", "ps"], capture_output=True, text=True, timeout=10,
+        )
+    except (subprocess.TimeoutExpired, FileNotFoundError) as e:
+        return EngineStatus("podman", "unknown_error", str(e))
+    if r.returncode != 0:
+        err = r.stderr.strip()
+        if "unable to connect to Podman socket" in err:
+            return EngineStatus("podman", "podman_machine_stopped", err)
+        return EngineStatus("podman", "unknown_error", err)
+
+    # VM memory check — ClawBench needs >=4 GB for Chrome + gateway + agent.
+    if platform.system() in ("Darwin", "Windows"):
+        try:
+            mi = subprocess.run(
+                ["podman", "machine", "inspect", "--format",
+                 "{{.Resources.Memory}}"],
+                capture_output=True, text=True, timeout=10,
+            )
+            mem_mb = int(mi.stdout.strip())
+            if mem_mb < 4096:
+                return EngineStatus("podman", "podman_low_memory", str(mem_mb))
+        except (ValueError, subprocess.TimeoutExpired):
+            pass  # non-critical — skip if unreadable
+
+    return EngineStatus("podman", "ready")
+
+
+def _check_docker() -> EngineStatus:
+    try:
+        r = subprocess.run(
+            ["docker", "info"], capture_output=True, text=True, timeout=10,
+        )
+    except (subprocess.TimeoutExpired, FileNotFoundError) as e:
+        return EngineStatus("docker", "unknown_error", str(e))
+    if r.returncode != 0:
+        return EngineStatus("docker", "docker_not_running", r.stderr.strip())
+    return EngineStatus("docker", "ready")
+
+
+def remediation_hint(status: EngineStatus) -> str:
+    """Return a short human-readable hint for a non-ready status."""
+    s = status.status
+    if s == "ready":
+        return ""
+    if s == "not_installed":
+        return (
+            "Install a container engine. Recommended: podman.\n"
+            "  macOS:   brew install podman && podman machine init && podman machine start\n"
+            "  Linux:   sudo apt install podman   (or dnf, pacman, etc.)\n"
+            "  Fallback: Docker Desktop from https://docker.com"
+        )
+    if s == "podman_no_machine":
+        return "Run `podman machine init` then `podman machine start`."
+    if s == "podman_machine_stopped":
+        return "Run `podman machine start`."
+    if s == "podman_low_memory":
+        mem = status.detail or "?"
+        return (
+            f"Podman VM has only {mem} MB RAM; ClawBench needs >=4 GB.\n"
+            "Stop the VM and recreate with more memory:\n"
+            "  podman machine stop && podman machine rm\n"
+            "  podman machine init --memory=8192 && podman machine start"
+        )
+    if s == "docker_not_running":
+        if platform.system() == "Darwin":
+            return "Docker daemon is not running. Try: open -a Docker"
+        return "Docker daemon is not running. Start the docker service."
+    return status.detail or "Unknown engine error."

clawbench/generate_resume_pdf.py

@@ -0,0 +1,140 @@
+"""Generate a PDF resume from the resume template JSON.
+
+Usage:
+    python generate_resume_pdf.py [output.pdf]
+
+Generates from resume_template.json in the same directory.
+Default output: alex_green_resume.pdf in the current directory.
+"""
+
+import json
+import sys
+from pathlib import Path
+
+from fpdf import FPDF
+
+
+def _safe(text: str) -> str:
+    """Replace Unicode characters that Helvetica (latin-1) cannot render."""
+    return (
+        text
+        .replace("\u2014", " - ")   # em dash
+        .replace("\u2013", " - ")   # en dash
+        .replace("\u2022", "-")     # bullet
+        .replace("\u2018", "'")     # left single quote
+        .replace("\u2019", "'")     # right single quote
+        .replace("\u201c", '"')     # left double quote
+        .replace("\u201d", '"')     # right double quote
+    )
+
+
+def generate_resume_pdf(resume_data: dict, output_path: Path) -> None:
+    """Render *resume_data* (the resume_template.json structure) to a PDF at *output_path*."""
+
+    header = resume_data["header"]
+
+    pdf = FPDF(orientation="P", unit="mm", format="A4")
+    pdf.set_auto_page_break(auto=True, margin=20)
+    pdf.add_page()
+
+    # -- Header -----------------------------------------------------------
+    pdf.set_font("Helvetica", "B", 22)
+    pdf.cell(0, 10, _safe(header["name"]), new_x="LMARGIN", new_y="NEXT", align="C")
+
+    pdf.set_font("Helvetica", "", 11)
+    pdf.cell(0, 6, _safe(header["title"]), new_x="LMARGIN", new_y="NEXT", align="C")
+
+    contact_parts = [header.get("email", ""), header.get("location", "")]
+    contact_line = "  |  ".join(p for p in contact_parts if p)
+    pdf.set_font("Helvetica", "", 9)
+    pdf.cell(0, 5, _safe(contact_line), new_x="LMARGIN", new_y="NEXT", align="C")
+
+    pdf.ln(2)
+    _draw_line(pdf)
+
+    # -- Summary ----------------------------------------------------------
+    if resume_data.get("summary"):
+        _section_heading(pdf, "Summary")
+        pdf.set_font("Helvetica", "", 10)
+        pdf.multi_cell(0, 5, _safe(resume_data["summary"]))
+        pdf.ln(2)
+
+    # -- Experience -------------------------------------------------------
+    if resume_data.get("experience"):
+        _section_heading(pdf, "Experience")
+        for job in resume_data["experience"]:
+            pdf.set_font("Helvetica", "B", 10)
+            pdf.cell(0, 5, _safe(f"{job['title']}  -  {job['company']}"),
+                     new_x="LMARGIN", new_y="NEXT")
+            pdf.set_font("Helvetica", "I", 9)
+            pdf.cell(0, 5, _safe(f"{job.get('location', '')}    {job.get('dates', '')}"),
+                     new_x="LMARGIN", new_y="NEXT")
+            pdf.set_font("Helvetica", "", 9)
+            for bullet in job.get("bullets", []):
+                x = pdf.get_x()
+                pdf.cell(5, 4.5, "-")
+                pdf.multi_cell(0, 4.5, _safe(bullet))
+                pdf.set_x(x)
+            pdf.ln(2)
+
+    # -- Education --------------------------------------------------------
+    if resume_data.get("education"):
+        _section_heading(pdf, "Education")
+        for edu in resume_data["education"]:
+            pdf.set_font("Helvetica", "B", 10)
+            pdf.cell(0, 5, _safe(f"{edu['degree']}  -  {edu['institution']}"),
+                     new_x="LMARGIN", new_y="NEXT")
+            pdf.set_font("Helvetica", "I", 9)
+            pdf.cell(0, 5, _safe(edu.get("dates", "")), new_x="LMARGIN", new_y="NEXT")
+            if edu.get("detail"):
+                pdf.set_font("Helvetica", "", 9)
+                pdf.multi_cell(0, 4.5, _safe(edu["detail"]))
+            pdf.ln(1)
+
+    # -- Skills -----------------------------------------------------------
+    if resume_data.get("skills"):
+        _section_heading(pdf, "Skills")
+        pdf.set_font("Helvetica", "", 9)
+        for category, items in resume_data["skills"].items():
+            label = category.replace("_", " ").title()
+            pdf.cell(0, 5, _safe(f"{label}: {', '.join(items)}"),
+                     new_x="LMARGIN", new_y="NEXT")
+        pdf.ln(2)
+
+    # -- Certifications ---------------------------------------------------
+    if resume_data.get("certifications"):
+        _section_heading(pdf, "Certifications")
+        pdf.set_font("Helvetica", "", 9)
+        for cert in resume_data["certifications"]:
+            pdf.cell(5)
+            pdf.cell(0, 5, _safe(f"-  {cert}"), new_x="LMARGIN", new_y="NEXT")
+        pdf.ln(2)
+
+    # -- Languages --------------------------------------------------------
+    if resume_data.get("languages"):
+        _section_heading(pdf, "Languages")
+        pdf.set_font("Helvetica", "", 9)
+        langs = [f"{l['language']} ({l['proficiency']})" for l in resume_data["languages"]]
+        pdf.cell(0, 5, _safe(", ".join(langs)), new_x="LMARGIN", new_y="NEXT")
+
+    pdf.output(str(output_path))
+
+
+def _section_heading(pdf: FPDF, title: str) -> None:
+    pdf.set_font("Helvetica", "B", 12)
+    pdf.cell(0, 7, title, new_x="LMARGIN", new_y="NEXT")
+    _draw_line(pdf)
+
+
+def _draw_line(pdf: FPDF) -> None:
+    y = pdf.get_y()
+    pdf.line(pdf.l_margin, y, pdf.w - pdf.r_margin, y)
+    pdf.ln(2)
+
+
+if __name__ == "__main__":
+    template = Path(__file__).resolve().parent / "resume_template.json"
+    data = json.loads(template.read_text())
+    out = Path(sys.argv[1]) if len(sys.argv) > 1 else Path("alex_green_resume.pdf")
+    generate_resume_pdf(data, out)
+    print(f"Generated: {out.resolve()}")