doesitfire 0.1.2__py3-none-any.whl

doesitfire/docker/Dockerfile

@@ -0,0 +1,24 @@
+# Agent sandbox image for doesitfire. CLI versions are pinned on purpose:
+# their JSON event formats change between releases.
+FROM node:26.13.0-bookworm-slim
+
+ARG CLAUDE_CODE_VERSION=2.1.317
+ARG CODEX_VERSION=0.166.0
+ARG OPENCODE_VERSION=1.19.5
+
+RUN npm install -g --no-audit --no-fund \
+      @anthropic-ai/claude-code@${CLAUDE_CODE_VERSION} \
+      @openai/codex@${CODEX_VERSION} \
+      opencode-ai@${OPENCODE_VERSION} \
+    && npm cache clean --force \
+    && apt-get update && apt-get install -y --no-install-recommends ca-certificates git ripgrep \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY egress-proxy.mjs /opt/doesitfire/egress-proxy.mjs
+COPY entrypoint.sh /opt/doesitfire/entrypoint.sh
+RUN chmod 0755 /opt/doesitfire/entrypoint.sh
+
+RUN mkdir -p /home/node/work && chown -R node:node /home/node
+USER node
+WORKDIR /home/node
+ENTRYPOINT ["/opt/doesitfire/entrypoint.sh"]

doesitfire/docker/egress-proxy.mjs

@@ -0,0 +1,113 @@
+// Minimal egress proxy: the only way out of the internal Docker network.
+// Allows HTTP CONNECT (HTTPS) and plain HTTP forwarding to an allowlist of
+// host:port pairs given in DOESITFIRE_ALLOW (comma separated). Everything
+// else gets 403. No logging of request bodies.
+import http from "node:http";
+import net from "node:net";
+
+const allow = new Set(
+  (process.env.DOESITFIRE_ALLOW || "").split(",").map((s) => s.trim().toLowerCase()).filter(Boolean),
+);
+const port = Number(process.env.DOESITFIRE_PROXY_PORT || 8888);
+// Ollama's OpenAI Responses endpoint drops input messages with role "developer", which is
+// where Codex puts its skill list. For local Ollama only (plain HTTP), rewrite them to
+// "system", which Ollama keeps. HTTPS traffic to paid APIs is tunnelled and never touched.
+const developerAsSystem = process.env.DOESITFIRE_DEVELOPER_AS_SYSTEM === "1";
+
+function rewriteDeveloper(buf) {
+  try {
+    const body = JSON.parse(buf.toString("utf8"));
+    if (!Array.isArray(body.input)) return buf;
+    let changed = false;
+    for (const item of body.input) {
+      if (item && item.role === "developer") {
+        item.role = "system";
+        changed = true;
+      }
+    }
+    return changed ? Buffer.from(JSON.stringify(body), "utf8") : buf;
+  } catch {
+    return buf;
+  }
+}
+
+function allowed(host, p) {
+  return allow.has(`${String(host).toLowerCase()}:${p}`);
+}
+
+const server = http.createServer((req, res) => {
+  req.on("error", () => {});
+  res.on("error", () => {});
+  let url;
+  try {
+    url = new URL(req.url);
+  } catch {
+    res.writeHead(400).end("absolute URL required\n");
+    return;
+  }
+  const p = url.port || (url.protocol === "https:" ? 443 : 80);
+  if (url.protocol !== "http:" || !allowed(url.hostname, p)) {
+    console.error(`deny ${req.method} ${url.hostname}:${p}`);
+    res.writeHead(403).end("blocked by doesitfire egress proxy\n");
+    return;
+  }
+  console.error(`allow ${req.method} ${url.hostname}:${p}${url.pathname}`);
+  const headers = { ...req.headers };
+  delete headers["proxy-connection"];
+  delete headers["proxy-authorization"];
+  const forward = (body) => {
+    if (body) {
+      headers["content-length"] = String(body.length);
+      delete headers["transfer-encoding"];
+    }
+    const upstream = http.request(
+      { host: url.hostname, port: p, method: req.method, path: url.pathname + url.search, headers },
+      (up) => {
+        res.writeHead(up.statusCode || 502, up.headers);
+        up.pipe(res);
+      },
+    );
+    upstream.on("error", () => {
+      if (!res.headersSent) res.writeHead(502);
+      res.end();
+    });
+    res.on("close", () => upstream.destroy());
+    if (body) upstream.end(body);
+    else req.pipe(upstream);
+  };
+  if (developerAsSystem && req.method === "POST" && url.pathname.endsWith("/responses")) {
+    const chunks = [];
+    req.on("data", (c) => chunks.push(c));
+    req.on("end", () => forward(rewriteDeveloper(Buffer.concat(chunks))));
+  } else {
+    forward(null);
+  }
+});
+
+server.on("connect", (req, socket, head) => {
+  socket.on("error", () => {});
+  const [host, p] = String(req.url).split(":");
+  if (!allowed(host, p || 443)) {
+    console.error(`deny CONNECT ${req.url}`);
+    socket.end("HTTP/1.1 403 Forbidden\r\n\r\n");
+    return;
+  }
+  console.error(`allow CONNECT ${req.url}`);
+  const upstream = net.connect(Number(p || 443), host, () => {
+    socket.write("HTTP/1.1 200 Connection Established\r\n\r\n");
+    upstream.write(head);
+    upstream.pipe(socket);
+    socket.pipe(upstream);
+  });
+  upstream.on("error", () => socket.destroy());
+  socket.on("error", () => upstream.destroy());
+  socket.on("close", () => upstream.destroy());
+});
+
+server.on("clientError", (err, socket) => socket.destroy());
+// A proxy must never die because one client hung up mid-stream.
+process.on("uncaughtException", (err) => console.error(`proxy error: ${err.code || err.message}`));
+
+server.listen(port, "0.0.0.0", () => {
+  console.error(`egress proxy on :${port}, allow=${[...allow].join(",") || "(nothing)"}`);
+});

doesitfire/docker/entrypoint.sh

@@ -0,0 +1,14 @@
+#!/bin/sh
+# Copies the skills mounted read-only at /skills into the discovery directory
+# of the agent under test (DOESITFIRE_SKILLS_DIR, relative to a fresh
+# workspace), writes optional agent config, then runs the agent command.
+set -eu
+WORK=/home/node/work
+mkdir -p "$WORK"
+cd "$WORK"
+git init -q . >/dev/null 2>&1 || true
+if [ -d /skills ] && [ -n "${DOESITFIRE_SKILLS_DIR:-}" ]; then
+  mkdir -p "$WORK/$DOESITFIRE_SKILLS_DIR"
+  cp -R /skills/. "$WORK/$DOESITFIRE_SKILLS_DIR/"
+fi
+exec "$@"

doesitfire/errors.py

@@ -0,0 +1,17 @@
+"""User-facing errors. The CLI prints these without a traceback."""
+
+
+class DoesItFireError(Exception):
+    """An error with a message that tells the user what to do next."""
+
+    exit_code = 2
+
+
+class BudgetExceeded(DoesItFireError):
+    """Raised when --max-cost would be exceeded; carries the partial results."""
+
+    exit_code = 3
+
+    def __init__(self, message: str, results: dict | None = None):
+        super().__init__(message)
+        self.results = results

doesitfire/html.py

@@ -0,0 +1,26 @@
+"""Static, self-contained HTML report (one file, no external JS)."""
+
+from __future__ import annotations
+
+import json
+from importlib import resources
+from pathlib import Path
+
+from .metrics import overall, summarize
+
+
+def render_html(results: dict) -> str:
+    summary = summarize(results)
+    payload = {
+        "meta": {k: v for k, v in results.items() if k != "trials"},
+        "summary": summary,
+        "overall": overall(summary),
+        "runs": len(results.get("trials", [])),
+    }
+    data = json.dumps(payload, ensure_ascii=False).replace("</", "<\\/")
+    template = (resources.files("doesitfire") / "templates" / "report.html").read_text(encoding="utf-8")
+    return template.replace("__DOESITFIRE_DATA__", data)
+
+
+def write_html(results: dict, path: Path) -> None:
+    path.write_text(render_html(results), encoding="utf-8")

doesitfire/metrics.py

@@ -0,0 +1,117 @@
+"""Turn raw trials into the activation matrix.
+
+Per agent x skill:
+- recall          = fired runs / valid runs, over should-fire prompts
+- false-fire rate = fired runs / valid runs, over should-not-fire prompts
+- precision       = true fires / (true fires + false fires)
+Runs that errored (timeout, API error) are excluded from every denominator and counted apart.
+"""
+
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass, field
+
+
+@dataclass
+class Cell:
+    agent: str
+    skill: str
+    fire_runs: int = 0  # valid runs on should-fire prompts
+    true_fires: int = 0
+    nofire_runs: int = 0  # valid runs on should-not-fire prompts
+    false_fires: int = 0
+    errors: int = 0
+    prompts: list[dict] = field(default_factory=list)
+
+    @property
+    def recall(self) -> float | None:
+        return self.true_fires / self.fire_runs if self.fire_runs else None
+
+    @property
+    def false_fire_rate(self) -> float | None:
+        return self.false_fires / self.nofire_runs if self.nofire_runs else None
+
+    @property
+    def precision(self) -> float | None:
+        fired = self.true_fires + self.false_fires
+        return self.true_fires / fired if fired else None
+
+    def to_dict(self) -> dict:
+        d = asdict(self)
+        d.update(recall=self.recall, false_fire_rate=self.false_fire_rate, precision=self.precision)
+        return d
+
+
+def _add(cell: Cell, t: dict) -> None:
+    if t.get("error"):
+        cell.errors += 1
+        return
+    if t["expect"] == "fire":
+        cell.fire_runs += 1
+        cell.true_fires += bool(t["fired"])
+    else:
+        cell.nofire_runs += 1
+        cell.false_fires += bool(t["fired"])
+
+
+def summarize(results: dict) -> dict:
+    agents = [a["name"] for a in results["agents"]]
+    skills = [s["name"] for s in results["skills"]]
+    cells = {(a, s): Cell(a, s) for a in agents for s in skills}
+    totals = {a: Cell(a, "*") for a in agents}
+    per_prompt: dict[tuple, dict] = {}
+    for t in results["trials"]:
+        key = (t["agent"], t["skill"])
+        if key not in cells:
+            continue
+        _add(cells[key], t)
+        _add(totals[t["agent"]], t)
+        pk = (t["agent"], t["skill"], t["expect"], t["prompt"])
+        row = per_prompt.setdefault(
+            pk, {"prompt": t["prompt"], "expect": t["expect"], "fired": 0, "runs": 0, "errors": 0, "other": []}
+        )
+        if t.get("error"):
+            row["errors"] += 1
+        else:
+            row["runs"] += 1
+            row["fired"] += bool(t["fired"])
+        for other in t.get("activated") or []:
+            if other != t["skill"] and other not in row["other"]:
+                row["other"].append(other)
+    for (a, s, _e, _p), row in per_prompt.items():
+        cells[(a, s)].prompts.append(row)
+    return {
+        "agents": agents,
+        "skills": skills,
+        "cells": {f"{a}|{s}": c.to_dict() for (a, s), c in cells.items()},
+        "totals": {a: c.to_dict() for a, c in totals.items()},
+    }
+
+
+def overall(summary: dict) -> dict:
+    """Pooled figures across agents and skills (used by the badge)."""
+    tf = sum(c["true_fires"] for c in summary["totals"].values())
+    fr = sum(c["fire_runs"] for c in summary["totals"].values())
+    ff = sum(c["false_fires"] for c in summary["totals"].values())
+    nr = sum(c["nofire_runs"] for c in summary["totals"].values())
+    return {
+        "recall": tf / fr if fr else None,
+        "false_fire_rate": ff / nr if nr else None,
+        "precision": tf / (tf + ff) if (tf + ff) else None,
+    }
+
+
+def pct(value: float | None) -> str:
+    return "n/a" if value is None else f"{round(value * 100):d}%"
+
+
+def check_thresholds(summary: dict, min_recall: float | None, max_false_fire: float | None) -> list[str]:
+    """Return human-readable failures for cells below the thresholds."""
+    failures = []
+    for key, c in summary["cells"].items():
+        agent, skill = key.split("|", 1)
+        if min_recall is not None and c["recall"] is not None and c["recall"] < min_recall:
+            failures.append(f"{skill} on {agent}: recall {pct(c['recall'])} < {pct(min_recall)}")
+        if max_false_fire is not None and c["false_fire_rate"] is not None and c["false_fire_rate"] > max_false_fire:
+            failures.append(f"{skill} on {agent}: false-fire rate {pct(c['false_fire_rate'])} > {pct(max_false_fire)}")
+    return failures

doesitfire/providers.py

@@ -0,0 +1,121 @@
+"""Model provider presets and which agent can talk to which provider.
+
+Keys are read from environment variables only and are never written to disk,
+printed, or passed on a command line: Docker receives the variable *name* and
+copies the value from this process's environment.
+"""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+from urllib.parse import urlparse
+
+from .errors import DoesItFireError
+
+
+@dataclass(frozen=True)
+class Provider:
+    name: str
+    openai_base: str  # OpenAI-compatible base URL (".../v1")
+    key_env: str | None  # env var holding the API key; None for local models
+    anthropic_base: str | None = None  # Anthropic Messages-compatible base, if any
+    responses_api: bool = False  # serves the OpenAI Responses API (needed by Codex)
+    local: bool = False
+
+    @property
+    def paid(self) -> bool:
+        return not self.local
+
+
+def _ollama_root() -> str:
+    host = os.environ.get("OLLAMA_HOST", "http://localhost:11434").strip().rstrip("/")
+    if "://" not in host:
+        host = "http://" + host
+    parsed = urlparse(host)
+    if parsed.hostname in ("0.0.0.0", "", None):
+        host = f"{parsed.scheme}://localhost:{parsed.port or 11434}"
+    return host
+
+
+def get_provider(name: str) -> Provider:
+    if name == "ollama":
+        root = _ollama_root()
+        return Provider("ollama", root + "/v1", None, anthropic_base=root, responses_api=True, local=True)
+    if name == "openrouter":
+        return Provider(
+            "openrouter",
+            "https://openrouter.ai/api/v1",
+            "OPENROUTER_API_KEY",
+            anthropic_base="https://openrouter.ai/api",
+            responses_api=True,
+        )
+    if name == "openai":
+        return Provider("openai", "https://api.openai.com/v1", "OPENAI_API_KEY", responses_api=True)
+    if name == "mistral":
+        return Provider("mistral", "https://api.mistral.ai/v1", "MISTRAL_API_KEY")
+    if name == "anthropic":
+        return Provider(
+            "anthropic",
+            "https://api.anthropic.com/v1",
+            "ANTHROPIC_API_KEY",
+            anthropic_base="https://api.anthropic.com",
+        )
+    raise DoesItFireError(f"Unknown provider '{name}'. Use one of: {', '.join(PROVIDER_NAMES)}.")
+
+
+PROVIDER_NAMES = ("ollama", "openrouter", "openai", "mistral", "anthropic")
+
+# Which providers each agent CLI can use, and through which API.
+SUPPORTED = {
+    "claude-code": ("anthropic", "ollama", "openrouter"),  # Anthropic Messages API
+    "codex": ("ollama", "openai", "openrouter"),  # OpenAI Responses API
+    "opencode": ("ollama", "openrouter", "openai", "mistral", "anthropic"),
+}
+
+
+def check_supported(agent: str, provider: str) -> None:
+    if provider not in SUPPORTED[agent]:
+        why = {
+            "claude-code": "Claude Code speaks the Anthropic Messages API",
+            "codex": "Codex needs the OpenAI Responses API",
+        }.get(agent, "")
+        raise DoesItFireError(
+            f"Agent '{agent}' cannot use provider '{provider}'"
+            + (f" ({why})" if why else "")
+            + f". Supported: {', '.join(SUPPORTED[agent])}."
+        )
+
+
+def resolve_key(agent: str, provider: Provider) -> tuple[str, str] | None:
+    """Return (env var name, value) for the key this agent needs, or None for local models."""
+    if provider.key_env is None:
+        return None
+    candidates = [provider.key_env]
+    if agent == "claude-code" and provider.name == "anthropic":
+        # A Claude subscription token from `claude setup-token` works too.
+        candidates.append("CLAUDE_CODE_OAUTH_TOKEN")
+    for var in candidates:
+        value = os.environ.get(var, "").strip()
+        if value:
+            return var, value
+    raise DoesItFireError(
+        f"Missing API key for provider '{provider.name}' (agent '{agent}'). "
+        f"Set the {' or '.join(candidates)} environment variable, or switch the agent to "
+        "provider 'ollama' in doesitfire.yaml."
+    )
+
+
+def container_url(url: str) -> str:
+    """Rewrite localhost URLs so they work from inside a container."""
+    parsed = urlparse(url)
+    if parsed.hostname in ("localhost", "127.0.0.1", "::1"):
+        netloc = "host.docker.internal" + (f":{parsed.port}" if parsed.port else "")
+        return parsed._replace(netloc=netloc).geturl()
+    return url
+
+
+def host_port(url: str) -> str:
+    parsed = urlparse(url)
+    port = parsed.port or (443 if parsed.scheme == "https" else 80)
+    return f"{parsed.hostname}:{port}"

doesitfire/report.py

@@ -0,0 +1,175 @@
+"""Terminal matrix, JUnit XML, badge SVG and shields.io endpoint JSON."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from xml.sax.saxutils import escape, quoteattr
+
+from rich.console import Console
+from rich.table import Table
+from rich.text import Text
+
+from .metrics import overall, pct, summarize
+
+OK, WARN, ERR = "#11813c", "#a45e00", "#c22826"
+ACCENT = "#a1319b"
+
+
+def recall_color(v: float | None) -> str:
+    if v is None:
+        return "dim"
+    return "green" if v >= 0.8 else "yellow" if v >= 0.5 else "red"
+
+
+def false_color(v: float | None) -> str:
+    if v is None:
+        return "dim"
+    return "green" if v <= 0.1 else "yellow" if v <= 0.3 else "red"
+
+
+def recorded_banner(results: dict) -> str:
+    models = ", ".join(sorted({f"{a['provider']}/{a['model']}" for a in results["agents"]}))
+    host = results.get("host") or {}
+    when = (results.get("started_at") or "")[:10]
+    parts = [f"{when}", f"doesitfire {results.get('version')}", models]
+    if host.get("hardware"):
+        parts.append(host["hardware"])
+    return " | ".join(p for p in parts if p)
+
+
+def print_matrix(results: dict, console: Console | None = None) -> dict:
+    console = console or Console()
+    summary = summarize(results)
+    if results.get("recorded"):
+        console.print(Text(f"RECORDED RESULT, not a live run: {recorded_banner(results)}", style="bold magenta"))
+    table = Table(title="Skill activation (fired runs / valid runs)", title_justify="left", expand=False)
+    table.add_column("skill", style="bold")
+    for agent in results["agents"]:
+        label = agent["name"] + (" (experimental)" if agent.get("experimental") else "")
+        table.add_column(f"{label}\n[dim]{agent['model']}[/dim]", justify="left")
+    for skill in summary["skills"]:
+        row: list[Text | str] = [skill]
+        for agent in summary["agents"]:
+            c = summary["cells"][f"{agent}|{skill}"]
+            t = Text()
+            t.append(f"fires {c['true_fires']}/{c['fire_runs']}", style=recall_color(c["recall"]))
+            t.append("\n")
+            t.append(f"false {c['false_fires']}/{c['nofire_runs']}", style=false_color(c["false_fire_rate"]))
+            if c["errors"]:
+                t.append(f"\nerrors {c['errors']}", style="red")
+            row.append(t)
+        table.add_row(*row)
+    table.add_section()
+    for label, key, colorer in (
+        ("recall", "recall", recall_color),
+        ("false-fire rate", "false_fire_rate", false_color),
+        ("precision", "precision", recall_color),
+    ):
+        row = [Text(label, style="dim")]
+        for agent in summary["agents"]:
+            v = summary["totals"][agent][key]
+            row.append(Text(pct(v), style=colorer(v)))
+        table.add_row(*row)
+    console.print(table)
+    cost = results.get("cost_usd") or 0.0
+    reps = {a.get("repeats", results.get("repeats")) for a in results["agents"]}
+    rep_text = (
+        f"{reps.pop()} repeat(s) per prompt"
+        if len(reps) == 1
+        else "repeats " + ", ".join(f"{a['name']} {a.get('repeats')}" for a in results["agents"])
+    )
+    console.print(
+        f"[dim]{len(results['trials'])} runs, {rep_text}, "
+        f"{results.get('duration_s') or 0:.0f}s, cost {cost:.4f} USD[/dim]"
+    )
+    if any(a.get("experimental") for a in results["agents"]):
+        console.print(
+            "[dim]Codex is experimental: it reports no activation event, so a run counts as fired "
+            "when Codex reads the skill's SKILL.md.[/dim]"
+        )
+    return summary
+
+
+def write_junit(results: dict, path: Path) -> None:
+    summary = summarize(results)
+    suites, total = [], {"tests": 0, "failures": 0, "errors": 0}
+    for agent in summary["agents"]:
+        cases, counts = [], {"tests": 0, "failures": 0, "errors": 0}
+        for skill in summary["skills"]:
+            for row in summary["cells"][f"{agent}|{skill}"]["prompts"]:
+                counts["tests"] += 1
+                label = "should fire" if row["expect"] == "fire" else "should not fire"
+                name = f"[{label}] {row['prompt']}"
+                body = ""
+                result = f"fired {row['fired']}/{row['runs']} valid runs"
+                if row["runs"] == 0:
+                    counts["errors"] += 1
+                    errored = f"all {row['errors']} runs errored"
+                    body = f"<error message={quoteattr(errored)}/>"
+                else:
+                    majority = row["fired"] * 2 > row["runs"]
+                    ok = majority if row["expect"] == "fire" else not majority
+                    if not ok:
+                        counts["failures"] += 1
+                        body = f"<failure message={quoteattr(result)}/>"
+                cases.append(
+                    f"    <testcase classname={quoteattr(f'{agent}.{skill}')} name={quoteattr(name)}>"
+                    f"{body}<system-out>{escape(result)}</system-out></testcase>"
+                )
+        for k in total:
+            total[k] += counts[k]
+        suites.append(
+            f'  <testsuite name={quoteattr(agent)} tests="{counts["tests"]}" failures="{counts["failures"]}" '
+            f'errors="{counts["errors"]}">\n' + "\n".join(cases) + "\n  </testsuite>"
+        )
+    xml = (
+        '<?xml version="1.0" encoding="UTF-8"?>\n'
+        f'<testsuites name="doesitfire" tests="{total["tests"]}" failures="{total["failures"]}" '
+        f'errors="{total["errors"]}">\n' + "\n".join(suites) + "\n</testsuites>\n"
+    )
+    path.write_text(xml, encoding="utf-8")
+
+
+def _badge_parts(results: dict) -> tuple[str, str]:
+    o = overall(summarize(results))
+    message = f"fires {pct(o['recall'])} · false {pct(o['false_fire_rate'])}"
+    r = o["recall"]
+    color = OK if r is not None and r >= 0.8 else WARN if r is not None and r >= 0.5 else ERR
+    return message, color
+
+
+def _text_width(s: str) -> int:
+    # Approximate Verdana 11px advance widths, enough for a badge.
+    narrow, wide = set("fijlrt ·:|!.,'"), set("mwMW%")
+    return int(sum(4 if c in narrow else 10 if c in wide else 7 for c in s)) + 10
+
+
+def badge_svg(results: dict, label: str = "doesitfire") -> str:
+    message, color = _badge_parts(results)
+    lw, mw = _text_width(label), _text_width(message)
+    w = lw + mw
+    aria = f"{escape(label)}: {escape(message)}"
+    return f"""<svg xmlns="http://www.w3.org/2000/svg" width="{w}" height="20" role="img" aria-label="{aria}">
+  <title>{escape(label)}: {escape(message)}</title>
+  <clipPath id="r"><rect width="{w}" height="20" rx="3" fill="#fff"/></clipPath>
+  <g clip-path="url(#r)">
+    <rect width="{lw}" height="20" fill="{ACCENT}"/>
+    <rect x="{lw}" width="{mw}" height="20" fill="{color}"/>
+  </g>
+  <g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" font-size="11">
+    <text x="{lw / 2:.1f}" y="14">{escape(label)}</text>
+    <text x="{lw + mw / 2:.1f}" y="14">{escape(message)}</text>
+  </g>
+</svg>
+"""
+
+
+def badge_endpoint(results: dict, label: str = "doesitfire") -> dict:
+    message, color = _badge_parts(results)
+    return {"schemaVersion": 1, "label": label, "message": message, "color": color.lstrip("#")}
+
+
+def write_badges(results: dict, out: Path) -> None:
+    (out / "badge.svg").write_text(badge_svg(results), encoding="utf-8")
+    (out / "badge.json").write_text(json.dumps(badge_endpoint(results), indent=2) + "\n", encoding="utf-8")