@0dai-dev/cli 4.3.6 → 4.3.8

package/lib/python/receipt_png.py

@@ -0,0 +1,727 @@
+#!/usr/bin/env python3
+"""The Bill — shareable receipt PNG for a 0dai session.
+
+Industrializes the "AI-dev receipt screenshot" format (vinext $1,100,
+Huntley $297 → $50k, Fynn API-leak) by fusing cost + LOC + agent identity
++ elapsed time + CI status from existing 0dai telemetry into a 1200×630
+OG-sized PNG.
+
+Pipeline
+--------
+1. `collect_session_stats(target, session)` — pure data: reads the session
+   payload (active.json or saved/<id>.json) + experience events in window.
+2. `render_receipt(stats, out_path)` — Pillow 1200×630, monospace,
+   neural-substrate palette, big number + 4 chips.
+3. `copy_to_clipboard(path)` — pbcopy (mac) / xclip / wl-copy (linux),
+   image/png content type where the tool supports it.
+
+Issue: #529
+Design: ai/ideas/20260418-062835-0dai_feature_ideation_33_bold_plays_for_April_2026.md #1
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import pathlib
+import shutil
+import subprocess
+import sys
+import time
+
+# ---------------------------------------------------------------------------
+# Palette — neural-substrate (matches CLI T = \x1b[38;2;45;212;168m)
+# ---------------------------------------------------------------------------
+
+PALETTE = {
+    "bg":      (11, 18, 32),      # #0B1220
+    "panel":   (17, 25, 43),      # #11192B
+    "accent":  (45, 212, 168),    # #2DD4A8  (0dai teal)
+    "text":    (230, 237, 243),   # #E6EDF3
+    "dim":     (107, 114, 128),   # #6B7280
+    "success": (134, 239, 172),   # #86EFAC
+    "warn":    (252, 211, 77),    # #FCD34D
+    "error":   (248, 113, 113),   # #F87171
+}
+
+CANVAS = (1200, 630)
+RECEIPTS_DIR_ENV = "ODAI_RECEIPTS_DIR"
+
+
+# ---------------------------------------------------------------------------
+# File helpers
+# ---------------------------------------------------------------------------
+
+
+def _receipts_dir() -> pathlib.Path:
+    override = os.environ.get(RECEIPTS_DIR_ENV)
+    if override:
+        return pathlib.Path(override).expanduser()
+    return pathlib.Path.home() / ".0dai" / "receipts"
+
+
+def _load_json(path: pathlib.Path) -> dict | None:
+    try:
+        return json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return None
+
+
+def _parse_iso(value: str | None) -> float:
+    if not value:
+        return 0.0
+    try:
+        from datetime import datetime, timezone
+        text = str(value).strip().replace("Z", "+00:00")
+        return datetime.fromisoformat(text).astimezone(timezone.utc).timestamp()
+    except (ValueError, TypeError):
+        return 0.0
+
+
+# ---------------------------------------------------------------------------
+# Session lookup
+# ---------------------------------------------------------------------------
+
+
+def _active_session(target: pathlib.Path) -> dict | None:
+    return _load_json(target / "ai" / "sessions" / "active.json")
+
+
+def _saved_session(target: pathlib.Path, session_id: str) -> dict | None:
+    saved_dir = target / "ai" / "sessions" / "saved"
+    if not saved_dir.is_dir():
+        return None
+    # Exact match first
+    direct = saved_dir / f"{session_id}.json"
+    if direct.is_file():
+        return _load_json(direct)
+    # Then search payloads by id field
+    for path in saved_dir.glob("*.json"):
+        payload = _load_json(path)
+        if payload and str(payload.get("session_id") or payload.get("id") or "") == session_id:
+            return payload
+    return None
+
+
+def _last_saved_session(target: pathlib.Path) -> dict | None:
+    saved_dir = target / "ai" / "sessions" / "saved"
+    if not saved_dir.is_dir():
+        return None
+    candidates: list[tuple[float, dict]] = []
+    for path in saved_dir.glob("*.json"):
+        payload = _load_json(path)
+        if not payload:
+            continue
+        ts = _parse_iso(
+            payload.get("saved_at") or payload.get("updated") or payload.get("started")
+        )
+        candidates.append((ts, payload))
+    if not candidates:
+        return None
+    candidates.sort(key=lambda x: x[0], reverse=True)
+    return candidates[0][1]
+
+
+def _resolve_session(target: pathlib.Path, selector: str) -> dict | None:
+    """selector: 'active' | 'last' | <session_id>."""
+    if selector == "active":
+        return _active_session(target)
+    if selector == "last":
+        last = _last_saved_session(target)
+        if last:
+            return last
+        return _active_session(target)
+    explicit = _saved_session(target, selector)
+    if explicit:
+        return explicit
+    active = _active_session(target)
+    if active and str(active.get("id") or active.get("session_id") or "") == selector:
+        return active
+    return None
+
+
+# ---------------------------------------------------------------------------
+# Experience events → cost / agents / tasks
+# ---------------------------------------------------------------------------
+
+
+def _iter_events(target: pathlib.Path) -> list[dict]:
+    events_dir = target / "ai" / "experience" / "events"
+    if not events_dir.is_dir():
+        return []
+    events: list[dict] = []
+    for path in sorted(events_dir.glob("*.jsonl")):
+        try:
+            for line in path.read_text(encoding="utf-8").splitlines():
+                line = line.strip()
+                if not line:
+                    continue
+                try:
+                    events.append(json.loads(line))
+                except json.JSONDecodeError:
+                    continue
+        except OSError:
+            continue
+    # Also allow single-event .json files (saved event payloads)
+    for path in sorted(events_dir.glob("*.json")):
+        payload = _load_json(path)
+        if payload:
+            events.append(payload)
+    return events
+
+
+def _event_cost(event: dict) -> float:
+    task = event.get("task") or {}
+    value = task.get("cost_usd") or event.get("cost_usd") or event.get("cost")
+    try:
+        return float(value or 0.0)
+    except (TypeError, ValueError):
+        return 0.0
+
+
+def _event_agent(event: dict) -> str:
+    return str(
+        event.get("tool") or event.get("agent") or (event.get("task") or {}).get("agent") or ""
+    ).strip()
+
+
+def _event_elapsed(event: dict) -> float:
+    task = event.get("task") or {}
+    value = (
+        task.get("elapsed_seconds")
+        or event.get("elapsed_seconds")
+        or event.get("elapsed")
+        or 0.0
+    )
+    try:
+        return float(value or 0.0)
+    except (TypeError, ValueError):
+        return 0.0
+
+
+def _event_result(event: dict) -> str:
+    task = event.get("task") or {}
+    result = task.get("result") or event.get("result") or event.get("event_type") or ""
+    if event.get("success") is True:
+        return "success"
+    if event.get("success") is False:
+        return "failure"
+    if event.get("ci_passed") is True:
+        return "success"
+    if event.get("ci_passed") is False:
+        return "failure"
+    return str(result or "").lower()
+
+
+# ---------------------------------------------------------------------------
+# Git diff → lines_added / lines_removed
+# ---------------------------------------------------------------------------
+
+
+def _git_shortstat(target: pathlib.Path, base_ref: str | None) -> tuple[int, int]:
+    """Return (added, removed) via `git diff --shortstat`.
+
+    base_ref can be a commit SHA, branch, or None (working-tree diff).
+    Silent on any git error — returns (0, 0).
+    """
+    cmd = ["git", "-C", str(target), "diff", "--shortstat"]
+    if base_ref:
+        cmd.append(base_ref)
+    try:
+        out = subprocess.run(
+            cmd, check=False, capture_output=True, text=True, timeout=10,
+        ).stdout.strip()
+    except (OSError, subprocess.TimeoutExpired):
+        return (0, 0)
+    added = removed = 0
+    for chunk in out.split(","):
+        chunk = chunk.strip()
+        if "insertion" in chunk:
+            added = int(chunk.split(" ", 1)[0])
+        elif "deletion" in chunk:
+            removed = int(chunk.split(" ", 1)[0])
+    return (added, removed)
+
+
+# ---------------------------------------------------------------------------
+# Stats collection
+# ---------------------------------------------------------------------------
+
+
+def collect_session_stats(
+    target: pathlib.Path | str,
+    session: str = "active",
+    *,
+    now_epoch: float | None = None,
+    diff_reader=_git_shortstat,
+) -> dict:
+    """Build a receipt-ready stats dict for a session.
+
+    Values default to neutral (0 / empty / "unknown") when telemetry is
+    partial — the receipt still renders so operators can share *something*
+    even on low-data sessions.
+    """
+    target = pathlib.Path(target).resolve()
+    payload = _resolve_session(target, session) or {}
+
+    session_id = str(payload.get("session_id") or payload.get("id") or "session")
+    started = _parse_iso(payload.get("started") or payload.get("started_at"))
+    ended = _parse_iso(
+        payload.get("saved_at") or payload.get("updated") or payload.get("completed_at")
+    )
+    if ended <= 0:
+        ended = now_epoch if now_epoch is not None else time.time()
+    elapsed_s = max(0.0, ended - started) if started else 0.0
+
+    # Agents: started_by + current_agent + history + event-tool set
+    agents: list[str] = []
+    def _add(agent: str) -> None:
+        a = str(agent or "").strip()
+        if a and a not in agents:
+            agents.append(a)
+
+    _add(payload.get("started_by") or "")
+    _add(payload.get("current_agent") or "")
+    for entry in (payload.get("history") or []):
+        if isinstance(entry, dict):
+            _add(entry.get("agent") or "")
+
+    events = _iter_events(target)
+    in_window = []
+    for event in events:
+        ts = _parse_iso(event.get("timestamp") or event.get("ts") or "")
+        if started and ended and (ts == 0.0 or not (started <= ts <= ended)):
+            continue
+        in_window.append(event)
+
+    for event in in_window:
+        _add(_event_agent(event))
+
+    cost_usd = round(sum(_event_cost(e) for e in in_window), 4)
+    tasks_count = sum(
+        1 for e in in_window
+        if str(e.get("event_type") or e.get("type") or "").startswith("task_")
+        or e.get("task_id")
+    )
+
+    results = [_event_result(e) for e in in_window if _event_result(e)]
+    failures = sum(1 for r in results if r in ("failure", "stuck", "timeout", "error"))
+    regressions = failures
+    if results and failures == 0:
+        status = "green"
+    elif results and failures > 0:
+        status = "red"
+    else:
+        status = "unknown"
+
+    base_ref = (payload.get("context") or {}).get("last_commit") or payload.get("base_commit")
+    lines_added, lines_removed = diff_reader(target, base_ref)
+
+    return {
+        "session_id": session_id,
+        "started": payload.get("started") or payload.get("started_at") or "",
+        "ended": payload.get("updated") or payload.get("saved_at") or "",
+        "elapsed_seconds": round(elapsed_s, 1),
+        "agents": agents or ["unknown"],
+        "cost_usd": cost_usd,
+        "lines_added": int(lines_added),
+        "lines_removed": int(lines_removed),
+        "lines_changed": int(lines_added + lines_removed),
+        "tasks_count": tasks_count,
+        "regressions": regressions,
+        "status": status,
+    }
+
+
+# ---------------------------------------------------------------------------
+# Formatting — chips
+# ---------------------------------------------------------------------------
+
+
+def _format_elapsed(seconds: float) -> str:
+    seconds = max(0, int(seconds))
+    if seconds < 60:
+        return f"{seconds}s"
+    if seconds < 3600:
+        return f"{seconds // 60}m"
+    hours, rem = divmod(seconds, 3600)
+    minutes = rem // 60
+    return f"{hours}h{minutes:02d}m" if minutes else f"{hours}h"
+
+
+def _format_agents(agents: list[str]) -> str:
+    if not agents:
+        return "0"
+    if len(agents) == 1:
+        return agents[0]
+    return f"{len(agents)} agents"
+
+
+def format_chips(stats: dict) -> list[tuple[str, str]]:
+    """Return the 4 display chips rendered under the headline cost.
+
+    Order matches the pitch: lines · agents · time · regressions.
+    """
+    lines = stats.get("lines_changed") or 0
+    agents = stats.get("agents") or []
+    elapsed = stats.get("elapsed_seconds") or 0
+    regressions = stats.get("regressions") or 0
+    return [
+        ("LINES", f"{int(lines):,}"),
+        ("AGENTS", _format_agents(agents)),
+        ("TIME", _format_elapsed(elapsed)),
+        ("REGRESSIONS", "zero" if regressions == 0 else str(int(regressions))),
+    ]
+
+
+def format_cost(cost_usd: float) -> str:
+    try:
+        cost = float(cost_usd)
+    except (TypeError, ValueError):
+        cost = 0.0
+    if cost >= 100:
+        return f"${cost:,.0f}"
+    if cost >= 10:
+        return f"${cost:,.2f}"
+    return f"${cost:.2f}"
+
+
+# ---------------------------------------------------------------------------
+# Rendering
+# ---------------------------------------------------------------------------
+
+
+def _load_font(size: int, *, bold: bool = False):
+    from PIL import ImageFont  # type: ignore
+
+    candidates = []
+    if bold:
+        candidates += [
+            "/usr/share/fonts/truetype/dejavu/DejaVuSansMono-Bold.ttf",
+            "/System/Library/Fonts/Menlo.ttc",
+            "/usr/share/fonts/truetype/liberation/LiberationMono-Bold.ttf",
+        ]
+    candidates += [
+        "/usr/share/fonts/truetype/dejavu/DejaVuSansMono.ttf",
+        "/System/Library/Fonts/Menlo.ttc",
+        "/usr/share/fonts/truetype/liberation/LiberationMono-Regular.ttf",
+        "/Library/Fonts/Andale Mono.ttf",
+    ]
+    for path in candidates:
+        if pathlib.Path(path).is_file():
+            try:
+                return ImageFont.truetype(path, size)
+            except OSError:
+                continue
+    return ImageFont.load_default()
+
+
+def render_receipt(
+    stats: dict,
+    out_path: pathlib.Path | str,
+) -> pathlib.Path:
+    """Render a 1200×630 PNG receipt for `stats` to `out_path`. Returns path."""
+    from PIL import Image, ImageDraw  # type: ignore
+
+    out = pathlib.Path(out_path)
+    out.parent.mkdir(parents=True, exist_ok=True)
+
+    img = Image.new("RGB", CANVAS, PALETTE["bg"])
+    draw = ImageDraw.Draw(img)
+
+    # Thin accent bar on the left edge — signature 0dai teal
+    draw.rectangle([(0, 0), (8, CANVAS[1])], fill=PALETTE["accent"])
+
+    # Header
+    header_font = _load_font(28, bold=True)
+    draw.text(
+        (56, 48),
+        "0dai · session receipt",
+        font=header_font,
+        fill=PALETTE["accent"],
+    )
+
+    session_id = str(stats.get("session_id") or "session")[:28]
+    sid_font = _load_font(20)
+    draw.text((56, 90), session_id, font=sid_font, fill=PALETTE["dim"])
+
+    # Big headline: cost
+    cost_font = _load_font(168, bold=True)
+    cost_text = format_cost(stats.get("cost_usd") or 0)
+    bbox = draw.textbbox((0, 0), cost_text, font=cost_font)
+    cost_w = bbox[2] - bbox[0]
+    cost_x = (CANVAS[0] - cost_w) // 2
+    draw.text((cost_x, 160), cost_text, font=cost_font, fill=PALETTE["text"])
+
+    # Sub-headline
+    sub_font = _load_font(22)
+    sub_text = "session total · receipts that ship themselves"
+    sbbox = draw.textbbox((0, 0), sub_text, font=sub_font)
+    sub_w = sbbox[2] - sbbox[0]
+    draw.text(
+        ((CANVAS[0] - sub_w) // 2, 350),
+        sub_text,
+        font=sub_font,
+        fill=PALETTE["dim"],
+    )
+
+    # 4 chips along the bottom — equal widths
+    chips = format_chips(stats)
+    chip_label_font = _load_font(18)
+    chip_value_font = _load_font(30, bold=True)
+
+    chip_area_top = 420
+    chip_area_bottom = 560
+    chip_gap = 24
+    margin = 56
+    chip_w = (CANVAS[0] - margin * 2 - chip_gap * (len(chips) - 1)) // len(chips)
+
+    for idx, (label, value) in enumerate(chips):
+        x0 = margin + idx * (chip_w + chip_gap)
+        x1 = x0 + chip_w
+        draw.rectangle([(x0, chip_area_top), (x1, chip_area_bottom)], fill=PALETTE["panel"])
+        # Teal accent rail on top of each chip
+        draw.rectangle([(x0, chip_area_top), (x1, chip_area_top + 4)], fill=PALETTE["accent"])
+
+        draw.text(
+            (x0 + 18, chip_area_top + 22),
+            label,
+            font=chip_label_font,
+            fill=PALETTE["dim"],
+        )
+        value_color = PALETTE["text"]
+        if label == "REGRESSIONS":
+            value_color = PALETTE["success"] if value == "zero" else PALETTE["error"]
+        draw.text(
+            (x0 + 18, chip_area_top + 58),
+            value,
+            font=chip_value_font,
+            fill=value_color,
+        )
+
+    # Footer — 0dai.dev · status dot
+    footer_font = _load_font(18)
+    status = str(stats.get("status") or "unknown").lower()
+    status_color = {
+        "green": PALETTE["success"],
+        "red": PALETTE["error"],
+        "unknown": PALETTE["warn"],
+    }.get(status, PALETTE["warn"])
+    draw.ellipse([(56, 588), (72, 604)], fill=status_color)
+    draw.text((84, 586), f"ci: {status}", font=footer_font, fill=PALETTE["dim"])
+    draw.text(
+        (CANVAS[0] - 140, 586),
+        "0dai.dev",
+        font=footer_font,
+        fill=PALETTE["dim"],
+    )
+
+    img.save(out, format="PNG")
+    return out
+
+
+# ---------------------------------------------------------------------------
+# Clipboard
+# ---------------------------------------------------------------------------
+
+
+def _which(name: str) -> str | None:
+    return shutil.which(name)
+
+
+def copy_to_clipboard(
+    image_path: pathlib.Path | str,
+    *,
+    platform: str | None = None,
+) -> dict:
+    """Copy the PNG at `image_path` to the system clipboard.
+
+    Returns {copied: bool, tool: str|None, error: str|None}. Silent on
+    missing clipboard tools — receipts are saved to disk regardless.
+    """
+    path = pathlib.Path(image_path)
+    if not path.is_file():
+        return {"copied": False, "tool": None, "error": f"not a file: {path}"}
+
+    plat = (platform or sys.platform or "").lower()
+
+    # macOS: pbcopy does not accept image/png — use osascript to set the
+    # clipboard to a PNG file URL.
+    if plat.startswith("darwin"):
+        osascript = _which("osascript")
+        if not osascript:
+            return {"copied": False, "tool": None, "error": "osascript not found"}
+        script = (
+            'set the clipboard to (read (POSIX file "'
+            + str(path.resolve())
+            + '") as «class PNGf»)'
+        )
+        try:
+            subprocess.run(
+                [osascript, "-e", script],
+                check=True, capture_output=True, timeout=10,
+            )
+            return {"copied": True, "tool": "osascript", "error": None}
+        except (subprocess.CalledProcessError, OSError, subprocess.TimeoutExpired) as exc:
+            return {"copied": False, "tool": "osascript", "error": str(exc)}
+
+    # Wayland first, fall back to X11
+    for tool, args in (
+        ("wl-copy", ["--type", "image/png"]),
+        ("xclip", ["-selection", "clipboard", "-t", "image/png", "-i", str(path)]),
+    ):
+        binary = _which(tool)
+        if not binary:
+            continue
+        try:
+            if tool == "wl-copy":
+                with path.open("rb") as fh:
+                    subprocess.run(
+                        [binary, *args],
+                        check=True, stdin=fh, capture_output=True, timeout=10,
+                    )
+            else:
+                subprocess.run(
+                    [binary, *args],
+                    check=True, capture_output=True, timeout=10,
+                )
+            return {"copied": True, "tool": tool, "error": None}
+        except (subprocess.CalledProcessError, OSError, subprocess.TimeoutExpired) as exc:
+            return {"copied": False, "tool": tool, "error": str(exc)}
+
+    return {
+        "copied": False,
+        "tool": None,
+        "error": "no clipboard tool found (install xclip, wl-copy, or use macOS)",
+    }
+
+
+# ---------------------------------------------------------------------------
+# End-to-end
+# ---------------------------------------------------------------------------
+
+
+def generate_receipt(
+    target: pathlib.Path | str,
+    session: str = "last",
+    *,
+    output: pathlib.Path | str | None = None,
+    copy: bool = True,
+    now_epoch: float | None = None,
+) -> dict:
+    """Collect stats, render PNG, optionally copy to clipboard.
+
+    Returns a result dict with stats, path, and clipboard status.
+    """
+    target_p = pathlib.Path(target).resolve()
+    stats = collect_session_stats(target_p, session, now_epoch=now_epoch)
+
+    if output is None:
+        base = _receipts_dir()
+        base.mkdir(parents=True, exist_ok=True)
+        slug = "".join(c if c.isalnum() or c in "-_" else "-" for c in stats["session_id"])[:40]
+        stamp = time.strftime("%Y%m%d-%H%M%S", time.gmtime())
+        out_path = base / f"{stamp}-{slug or 'session'}.png"
+    else:
+        out_path = pathlib.Path(output)
+
+    rendered = render_receipt(stats, out_path)
+    clipboard = copy_to_clipboard(rendered) if copy else {
+        "copied": False, "tool": None, "error": "clipboard disabled"
+    }
+
+    return {
+        "stats": stats,
+        "path": str(rendered),
+        "clipboard": clipboard,
+    }
+
+
+# ---------------------------------------------------------------------------
+# CLI
+# ---------------------------------------------------------------------------
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="receipt_png",
+        description="The Bill — shareable receipt PNG for a 0dai session.",
+    )
+    parser.add_argument("--target", default=".", help="Repo root (default: cwd)")
+    group = parser.add_mutually_exclusive_group()
+    group.add_argument(
+        "--last", action="store_const", dest="session", const="last",
+        help="Use the most recent saved session (default fallback to active).",
+    )
+    group.add_argument(
+        "--active", action="store_const", dest="session", const="active",
+        help="Use the current active session.",
+    )
+    group.add_argument(
+        "--session", dest="session",
+        help="Use a specific session id (matches saved/<id>.json or active.json id).",
+    )
+    parser.set_defaults(session="last")
+    parser.add_argument("--output", help="Output PNG path (default: ~/.0dai/receipts/)")
+    parser.add_argument(
+        "--no-clipboard", action="store_true",
+        help="Skip the clipboard copy step.",
+    )
+    parser.add_argument("--json", action="store_true", help="Emit JSON result.")
+    parser.add_argument(
+        "--stats-only", action="store_true",
+        help="Print the collected stats and exit (no PNG render).",
+    )
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = _build_parser()
+    args = parser.parse_args(argv)
+
+    target = pathlib.Path(args.target).resolve()
+    session = args.session or "last"
+
+    if args.stats_only:
+        stats = collect_session_stats(target, session)
+        if args.json:
+            print(json.dumps(stats, indent=2, ensure_ascii=False))
+        else:
+            print(_render_stats_text(stats))
+        return 0
+
+    result = generate_receipt(
+        target, session, output=args.output, copy=not args.no_clipboard,
+    )
+    if args.json:
+        print(json.dumps(result, indent=2, ensure_ascii=False))
+    else:
+        stats = result["stats"]
+        print(f"\n  \U0001f9fe Receipt saved: {result['path']}")
+        print(f"     {format_cost(stats['cost_usd'])}  ·  "
+              f"{stats['lines_changed']:,} lines  ·  "
+              f"{_format_agents(stats['agents'])}  ·  "
+              f"{_format_elapsed(stats['elapsed_seconds'])}  ·  "
+              f"{'zero regressions' if stats['regressions'] == 0 else str(stats['regressions']) + ' regressions'}")
+        clip = result["clipboard"]
+        if clip.get("copied"):
+            print(f"     copied to clipboard via {clip['tool']}")
+        elif clip.get("error"):
+            print(f"     clipboard: {clip['error']}")
+        print()
+    return 0
+
+
+def _render_stats_text(stats: dict) -> str:
+    chips = format_chips(stats)
+    chip_line = "  ·  ".join(f"{label.lower()}: {value}" for label, value in chips)
+    return (
+        f"\n  session: {stats['session_id']}\n"
+        f"  cost:    {format_cost(stats['cost_usd'])}\n"
+        f"  status:  {stats['status']}\n"
+        f"  {chip_line}\n"
+    )
+
+
+if __name__ == "__main__":
+    sys.exit(main())