willfire 0.1.3 → 0.1.5

package/README.md

@@ -20,20 +20,36 @@ pnpm add willfire
 import { predict } from "willfire";
 import { getOctokit } from "@actions/github"; // or new Octokit({ auth: token })
 
-const { entries, skip } = await predict(getOctokit(token), "owner/repo", 123);
+const { entries, checkNames, skip } = await predict(getOctokit(token), "owner/repo", 123);
+// checkNames: sorted, deduped checkName of every entry with status "run"
 ```
 
 `entries` is a union of two variants, both carrying `workflow` and `reason`:
 
-| variant | `job` | `status` |
-| --- | --- | --- |
-| `WorkflowEntry` | `"*"` | `"run" \| "skipped" \| "no-dispatch"` |
-| `JobEntry` | the job's display name | `"run" \| "skipped" \| "unknown" \| "no-dispatch"` |
+| variant | `job` | `checkName` | `status` |
+| --- | --- | --- | --- |
+| `WorkflowEntry` | `"*"` | always `null` | `"run" \| "skipped" \| "no-dispatch"` |
+| `JobEntry` | the job id | the check name, or `null` | `"run" \| "skipped" \| "unknown" \| "no-dispatch"` |
 
 `"unknown"` is job-level only: every workflow-level verdict is decidable, so a
 `WorkflowEntry` cannot express one. Narrow with the exported `isWorkflowEntry`
 and `isJobEntry` guards rather than testing the `"*"` sentinel yourself.
 
+`checkName` is the name GitHub actually puts on the check — `name:` override,
+matrix parenthetical, and `<caller> / <callee>` prefixing for reusable
+workflows all applied. That is the unit required status checks key on, so it
+is the one worth comparing against. On a `JobEntry` it is `null` only where no
+single name is knowable ahead of the run:
+
+- a matrix computed at runtime (`fromJSON` of another job's output), reported
+  as one `unknown` entry for that job and nothing else;
+- a non-local reusable workflow, whose callee jobs we do not fetch;
+- a `name:` interpolating something we cannot evaluate statically.
+
+Duplicate names in `checkNames` are not possible (it is a set), but duplicate
+check names *are* — GitHub happily creates two identically named checks when a
+matrix job's `name:` does not vary per combination. `entries` shows them.
+
 Auth is any token with `contents: read`, `actions: read`, and
 `pull-requests: read` — inside an action, the workflow's `GITHUB_TOKEN`.
 
@@ -55,15 +71,48 @@ entries, matching how they appear in the checks UI.
 Things that cannot be known statically — e.g. a matrix computed at runtime
 from another job's output — are reported as `unknown` rather than guessed.
 
+## Development
+
+```sh
+pnpm install
+pnpm typecheck        # tsc over src/, tests included
+pnpm test             # vitest, once
+pnpm test:coverage    # the 100% floor CI enforces
+```
+
+Unit tests are colocated with their source (`foo.ts` ↔ `foo.test.ts`) at 100%
+coverage, per the
+[testing-conventions](https://github.com/thekevinscott/testing-conventions)
+standard. `.github/workflows/conventions.yml` enforces that in CI;
+`testing-conventions.toml` holds the thresholds.
+
 ## Verification
 
-Predictions are verified against real GitHub behavior, not just the docs:
+The unit suite fixes the behavior. What fixes the *expectations* is the probe:
+predictions are verified against real GitHub behavior, not just the docs.
 [willrun-probe](https://github.com/thekevinbot/willrun-probe) holds one
 workflow per dispatch rule, and probe PRs exercise each complication
 (docs-only diffs, negation edges, `[skip ci]`, a 301-file diff, PRs into
 non-default branches). The `verify` script diffs predictions against the
 check entries GitHub actually created. All probe PRs currently pass exactly.
 
+Check-name resolution is verified the same way, on probe PR #8. `pnpm test`
+replays those probe workflows through the resolver and asserts the exact job
+names the live run produced. Several of the rules it pins are ones the docs do
+not state:
+
+- a `name:` containing *any* `${{ }}` expression suppresses the matrix
+  parenthetical, even an expression that never reads the matrix — a literal
+  `name:` still gets one, so `name: Static Label` over `a: [x, y]` yields
+  `Static Label (x)` and `Static Label (y)`;
+- keys an `include` entry merges into an existing combination do not appear in
+  the name, but keys of a combination the `include` created from scratch do;
+- object matrix values flatten to their own values, so `{os: linux, arch: x64}`
+  renders as `(linux, x64)`;
+- a skipped job is never set up, so its matrix does not expand and its `name:`
+  is not interpolated: one check, expression text and all.
+
 Scope notes: validated on `opened` pull_request events; `synchronize`/`labeled`
 live events, cross-repo reusable workflows, `branches-ignore`, and diffs far
-beyond 301 files are not yet probe-verified.
+beyond 301 files are not yet probe-verified. Reusable-workflow name prefixing
+is probe-verified to three levels; deeper nesting is inferred.

package/dist/predict.d.ts

@@ -30,6 +30,8 @@ export declare const jobName: <S extends string>(name: S extends "*" ? never : S
  */
 export interface WorkflowEntry extends EntryBase {
     job: "*";
+    /** Always null: a workflow-level verdict is about the run, not a named check. */
+    checkName: null;
     status: "run" | "skipped" | "no-dispatch";
 }
 /**
@@ -41,6 +43,16 @@ export interface WorkflowEntry extends EntryBase {
  */
 export interface JobEntry extends EntryBase {
     job: JobName;
+    /**
+     * The check name GitHub will create for this entry, resolved the way the
+     * Actions runner names jobs: `name:` override, matrix parenthetical, and
+     * `<caller> / <callee>` prefixing for reusable workflows.
+     *
+     * null when there is no single statically-knowable name: a matrix computed
+     * at runtime, a non-local reusable workflow, or a `name:` that interpolates
+     * something we cannot evaluate ahead of the run.
+     */
+    checkName: string | null;
     status: "run" | "skipped" | "unknown" | "no-dispatch";
 }
 export type Entry = WorkflowEntry | JobEntry;
@@ -50,16 +62,46 @@ export declare const isWorkflowEntry: (e: Entry) => e is WorkflowEntry;
 export declare const isJobEntry: (e: Entry) => e is JobEntry;
 export interface Prediction {
     entries: Entry[];
+    /**
+     * Convenience aggregate: the sorted, deduplicated check names of every
+     * entry with status "run" and a resolved name. Entries whose name could
+     * not be resolved are absent here — read `entries` to see them.
+     */
+    checkNames: string[];
     skip: string | null;
 }
 export declare function patternToRegex(pat: string): RegExp;
 /** Order-sensitive match: last matching pattern wins; ! negates. */
 export declare function matchFilters(value: string, patterns: string[]): boolean;
+export interface Ctx {
+    action: string;
+    baseRef: string;
+    files: string[];
+}
+type Workflow = Record<string, any>;
 type Combo = Record<string, any> | null;
 /** Return list of matrix combination dicts, or null if dynamic. */
 export declare function expandMatrix(strategy: any): Combo[] | null;
 /** Return run|skipped|unknown for a job-level if. */
 export declare function evalIf(cond: any): "run" | "skipped" | "unknown";
+/**
+ * One expanded job, before it is paired with its workflow. Named `ExpandedJob`
+ * because `JobEntry` is now the exported job-level variant of `Entry`.
+ */
+export interface ExpandedJob {
+    /** The job id this entry was built from. */
+    job: string;
+    /** The resolved check name, or null when it could not be settled statically. */
+    checkName: string | null;
+    status: "run" | "skipped" | "unknown";
+    reason: string;
+}
+/**
+ * Expand one already-parsed workflow into its job entries. Exported so check
+ * names can be tested against recorded GitHub behaviour without a network
+ * round-trip; `predict` is the API you want.
+ */
+export declare function expandWorkflowJobs(wf: Workflow, ctx: Ctx, fetchFile: (path: string) => Promise<string | null>): Promise<ExpandedJob[]>;
 export declare function makeOctokit(): Octokit;
 export declare function predict(octokit: Octokit, repo: string, prNumber: number): Promise<Prediction>;
 export {};

package/dist/predict.js

@@ -6,7 +6,9 @@
 // pull-requests read). Inside an action, pass the workflow's GITHUB_TOKEN.
 //
 // Faithful port of predict.py, which was verified entry-for-entry against
-// live dispatches on thekevinbot/willrun-probe (PRs 1-7).
+// live dispatches on thekevinbot/willrun-probe (PRs 1-7). Check-name
+// resolution was verified the same way on probe PR 8; the rules it turned up
+// are pinned in src/names.test.ts.
 import { Octokit } from "@octokit/rest";
 import { parse as parseYaml } from "yaml";
 /** Tag a job display name. Rejects the workflow-level sentinel. */
@@ -15,6 +17,10 @@ export const jobName = (name) => name;
 export const isWorkflowEntry = (e) => e.job === "*";
 /** Narrow to the job-level variant without inspecting the sentinel. */
 export const isJobEntry = (e) => e.job !== "*";
+const isWorkflowDraft = (e) => e.job === "*";
+const finalize = (e) => isWorkflowDraft(e)
+    ? { ...e, checkName: null }
+    : { ...e, checkName: e.checkName ?? null };
 // ------------------------------------------------- GitHub filter pattern glob
 // Grammar per docs: * (any chars except /), ** (any chars), ? (zero or one of
 // preceding char), + (one or more of preceding char), [ranges], leading ! negates.
@@ -118,8 +124,7 @@ function workflowDispatches(wf, ctx) {
     }
     return [true, "trigger matched"];
 }
-/** Return list of matrix combination dicts, or null if dynamic. */
-export function expandMatrix(strategy) {
+function expandMatrixDetailed(strategy) {
     const matrix = strategy?.matrix;
     if (matrix == null)
         return [null];
@@ -137,44 +142,134 @@ export function expandMatrix(strategy) {
             return null;
         axes[k] = v;
     }
-    let combos = [{}];
+    const axisKeys = Object.keys(axes);
+    let combos = [{ values: {}, displayKeys: axisKeys }];
     for (const [k, vals] of Object.entries(axes)) {
-        combos = combos.flatMap((c) => vals.map((v) => ({ ...c, [k]: v })));
+        combos = combos.flatMap((c) => vals.map((v) => ({ values: { ...c.values, [k]: v }, displayKeys: axisKeys })));
     }
-    if (Object.keys(axes).length === 0)
+    if (axisKeys.length === 0)
         combos = [];
-    combos = combos.filter((c) => !exclude.some((ex) => Object.entries(ex).every(([k, v]) => c[k] === v)));
+    combos = combos.filter((c) => !exclude.some((ex) => Object.entries(ex).every(([k, v]) => c.values[k] === v)));
     const extra = [];
     for (const inc of include) {
         const overlapping = Object.fromEntries(Object.entries(inc).filter(([k]) => k in axes));
-        const targets = combos.filter((c) => Object.entries(overlapping).every(([k, v]) => c[k] === v));
-        if (Object.keys(overlapping).length > 0 && targets.length > 0) {
+        const targets = combos.filter((c) => Object.entries(overlapping).every(([k, v]) => c.values[k] === v));
+        if (axisKeys.length > 0 && targets.length > 0) {
+            // Merge into the matching combinations. With no overlapping keys this
+            // matches every combination, per the docs ("added to each of the matrix
+            // combinations if none of the key:value pairs overwrite any of the
+            // original matrix values").
             for (const c of targets)
-                Object.assign(c, inc);
+                Object.assign(c.values, inc);
         }
         else {
-            extra.push({ ...inc });
+            // No combination to attach to: the include entry becomes a combination
+            // of its own, and every one of its keys shows in the name.
+            extra.push({ values: { ...inc }, displayKeys: Object.keys(inc) });
         }
     }
     combos.push(...extra);
     return combos.length > 0 ? combos : [null];
 }
+/** Return list of matrix combination dicts, or null if dynamic. */
+export function expandMatrix(strategy) {
+    const detailed = expandMatrixDetailed(strategy);
+    return detailed == null ? null : detailed.map((c) => (c == null ? null : c.values));
+}
+/**
+ * How a single matrix value is rendered inside a check name.
+ *
+ * Probe-verified: object values are flattened to their own values, so
+ * `cfg: {os: linux, arch: x64}` renders as `linux, x64` — the check is
+ * `m-object (linux, x64)`.
+ */
+function formatMatrixValue(v) {
+    if (v == null)
+        return "";
+    if (Array.isArray(v))
+        return v.map(formatMatrixValue).join(", ");
+    if (typeof v === "object")
+        return Object.values(v).map(formatMatrixValue).join(", ");
+    return String(v);
+}
+/** The ` (v1, v2)` suffix GitHub appends for a matrix combination. */
+function matrixSuffix(combo) {
+    const keys = combo.displayKeys.filter((k) => k in combo.values);
+    if (keys.length === 0)
+        return "";
+    return ` (${keys.map((k) => formatMatrixValue(combo.values[k])).join(", ")})`;
+}
+/**
+ * A `name:` that contains any `${{ }}` expression suppresses the matrix
+ * parenthetical; a literal one does not.
+ *
+ * Probe-verified three ways over `a: [x, y]`: `name: Static Label` yields
+ * `Static Label (x)` / `Static Label (y)`, `name: ev ${{ github.event_name }}`
+ * yields two checks both called `ev pull_request`, and
+ * `name: p ${{ matrix.a }}` over `a: [x], b: ["1", "2"]` yields two checks
+ * both called `p x`. So the trigger is the presence of an expression, not
+ * whether the expression happens to read the matrix — and duplicate check
+ * names are a real outcome GitHub allows.
+ */
+const EXPRESSION_RE = /\$\{\{/;
+function lookupPath(obj, path) {
+    let cur = obj;
+    for (const seg of path.split(".")) {
+        if (cur == null || typeof cur !== "object" || !(seg in cur))
+            return undefined;
+        cur = cur[seg];
+    }
+    return cur;
+}
 function renderName(template, combo) {
-    return template.replace(/\$\{\{(.*?)\}\}/g, (whole, inner) => {
+    let resolved = true;
+    const text = template.replace(/\$\{\{(.*?)\}\}/g, (whole, inner) => {
         const expr = String(inner).trim();
-        if (expr.startsWith("matrix.") && combo) {
-            return String(combo[expr.slice("matrix.".length)] ?? "");
+        if (expr.startsWith("matrix.")) {
+            if (!combo) {
+                resolved = false;
+                return whole;
+            }
+            const val = lookupPath(combo, expr.slice("matrix.".length));
+            if (val === undefined) {
+                resolved = false;
+                return whole;
+            }
+            return formatMatrixValue(val);
         }
+        // We only predict pull_request dispatch, so this one is knowable.
+        if (expr === "github.event_name")
+            return "pull_request";
+        resolved = false;
         return whole;
     });
+    return { text, resolved };
 }
+/** The check name for one job/combination. */
 function jobDisplayName(jobId, job, combo) {
-    if ("name" in job && job.name != null)
-        return renderName(String(job.name), combo);
-    let name = jobId;
-    if (combo)
-        name += ` (${Object.values(combo).map(String).join(", ")})`;
-    return name;
+    const raw = job != null && job.name != null ? String(job.name) : null;
+    if (raw === null) {
+        return { name: jobId + (combo ? matrixSuffix(combo) : ""), resolved: true };
+    }
+    const { text, resolved } = renderName(raw, combo?.values ?? null);
+    const suffix = combo && !EXPRESSION_RE.test(raw) ? matrixSuffix(combo) : "";
+    return { name: text + suffix, resolved };
+}
+/**
+ * The check name a job gets when it is skipped.
+ *
+ * A skipped job is never set up, so nothing about it is evaluated: the matrix
+ * does not expand and `name:` is not interpolated. Probe-verified twice over:
+ * `if: false` with `a: [x, y]` produces the single check `m-skipped`, not
+ * `m-skipped (x)` / `m-skipped (y)`; and `name: sk ${{ github.event_name }}`
+ * with `if: false` produces a check literally called
+ * `sk ${{ github.event_name }}`, expression text and all. The same collapse
+ * applies to a skipped reusable-workflow call: one check named after the
+ * caller, with no `/ <callee job>` entries.
+ */
+function skippedDisplayName(jobId, job) {
+    const raw = job != null && job.name != null ? String(job.name) : null;
+    return { name: raw ?? jobId, resolved: true };
 }
 /** Return run|skipped|unknown for a job-level if. */
 export function evalIf(cond) {
@@ -194,7 +289,13 @@ export function evalIf(cond) {
     }
     return "unknown";
 }
-async function expandJobs(wf, ctx, fetchFile, depth = 0, prefix = "") {
+/**
+ * GitHub allows a reusable-workflow call chain four levels deep. Past that the
+ * run itself fails, so anything deeper is not a name we could predict anyway.
+ * Probe-verified to three levels: `call-nested / Mid Call / inner`.
+ */
+const MAX_REUSABLE_DEPTH = 4;
+async function expandJobs(wf, ctx, fetchFile, depth = 0, prefix = "", prefixResolved = true) {
     const entries = [];
     const jobs = wf.jobs ?? {};
     const statuses = {};
@@ -219,44 +320,105 @@ async function expandJobs(wf, ctx, fetchFile, depth = 0, prefix = "") {
             }
         }
         statuses[jobId] = status;
+        // A skipped job never expands its matrix and never dispatches a called
+        // workflow: it collapses to a single check under the bare job name.
+        if (status === "skipped") {
+            const disp = skippedDisplayName(jobId, job);
+            const name = prefix + disp.name;
+            entries.push({
+                job: name,
+                checkName: prefixResolved && disp.resolved ? name : null,
+                status,
+                reason,
+            });
+            continue;
+        }
+        const combos = expandMatrixDetailed(job.strategy);
         if ("uses" in job) {
-            // reusable workflow call
+            // Reusable workflow call. The calling job produces no check of its own;
+            // each called job becomes `<calling job name> / <called job name>`, and
+            // a matrix on the *caller* multiplies the whole callee set.
             const uses = job.uses;
-            const baseName = prefix + (job.name != null ? String(job.name) : jobId);
-            if (depth >= 1) {
-                entries.push([baseName, "unknown", "nested reusable workflow"]);
+            if (combos == null) {
+                entries.push({
+                    job: prefix + jobId,
+                    checkName: null,
+                    status: "unknown",
+                    reason: "dynamic matrix on reusable workflow call",
+                });
                 continue;
             }
+            // Resolve the called workflow once, not once per matrix combination.
+            let subWf = null;
+            let failure = null;
             const m = uses.match(/^\.\/(.+)$/);
-            if (!m) {
-                entries.push([baseName, "unknown", `non-local reusable: ${uses}`]);
-                continue;
+            if (depth + 1 > MAX_REUSABLE_DEPTH) {
+                failure = `reusable workflow nested deeper than ${MAX_REUSABLE_DEPTH} levels`;
             }
-            const content = await fetchFile(m[1]);
-            if (content == null) {
-                entries.push([baseName, "unknown", `cannot fetch ${uses}`]);
-                continue;
+            else if (!m) {
+                failure = `non-local reusable: ${uses}`;
             }
-            if (status === "skipped") {
-                entries.push([baseName, "skipped", reason]);
-                continue;
+            else {
+                const content = await fetchFile(m[1]);
+                if (content == null) {
+                    failure = `cannot fetch ${uses}`;
+                }
+                else {
+                    try {
+                        subWf = parseYaml(content);
+                    }
+                    catch (e) {
+                        failure = `YAML parse error in ${uses}: ${e}`;
+                    }
+                }
+            }
+            for (const combo of combos) {
+                const disp = jobDisplayName(jobId, job, combo);
+                const baseName = prefix + disp.name;
+                const nameResolved = prefixResolved && disp.resolved;
+                if (failure != null || subWf == null) {
+                    entries.push({
+                        job: baseName,
+                        checkName: null,
+                        status: "unknown",
+                        reason: failure ?? `cannot resolve ${uses}`,
+                    });
+                    continue;
+                }
+                entries.push(...(await expandJobs(subWf, ctx, fetchFile, depth + 1, `${baseName} / `, nameResolved)));
             }
-            const subWf = parseYaml(content);
-            const sub = await expandJobs(subWf, ctx, fetchFile, depth + 1, `${baseName} / `);
-            entries.push(...sub);
             continue;
         }
-        const combos = expandMatrix(job.strategy);
         if (combos == null) {
-            entries.push([prefix + jobId, "unknown", "dynamic matrix"]);
+            entries.push({
+                job: prefix + jobId,
+                checkName: null,
+                status: "unknown",
+                reason: "dynamic matrix",
+            });
             continue;
         }
         for (const combo of combos) {
-            entries.push([prefix + jobDisplayName(jobId, job, combo), status, reason]);
+            const disp = jobDisplayName(jobId, job, combo);
+            const name = prefix + disp.name;
+            entries.push({
+                job: name,
+                checkName: prefixResolved && disp.resolved ? name : null,
+                status,
+                reason,
+            });
         }
     }
     return entries;
 }
+/**
+ * Expand one already-parsed workflow into its job entries. Exported so check
+ * names can be tested against recorded GitHub behaviour without a network
+ * round-trip; `predict` is the API you want.
+ */
+export function expandWorkflowJobs(wf, ctx, fetchFile) {
+    return expandJobs(wf, ctx, fetchFile);
+}
 // ------------------------------------------------------------------- pipeline
 export function makeOctokit() {
     const token = process.env.GH_TOKEN ?? process.env.GITHUB_TOKEN;
@@ -285,7 +447,7 @@ export async function predict(octokit, repo, prNumber) {
     });
     const headMsg = headCommit.commit.message;
     if (SKIP_RE.test(headMsg) || SKIP_TRAILER_RE.test(headMsg)) {
-        return { entries: [], skip: "head commit message contains a skip instruction" };
+        return finalizePrediction([], "head commit message contains a skip instruction");
     }
     const fetchFile = async (path) => {
         try {
@@ -353,11 +515,26 @@ export async function predict(octokit, repo, prNumber) {
             entries.push({ workflow: path, job: "*", status: "no-dispatch", reason });
             continue;
         }
-        for (const [name, status, jreason] of await expandJobs(wf, ctx, fetchFile)) {
-            entries.push({ workflow: path, job: jobName(name), status, reason: jreason || reason });
+        for (const j of await expandJobs(wf, ctx, fetchFile)) {
+            entries.push({
+                workflow: path,
+                job: jobName(j.job),
+                checkName: j.checkName,
+                status: j.status,
+                reason: j.reason || reason,
+            });
         }
     }
-    return { entries, skip: null };
+    return finalizePrediction(entries, null);
+}
+function finalizePrediction(entries, skip) {
+    const final = entries.map(finalize);
+    const names = new Set();
+    for (const e of final) {
+        if (e.status === "run" && e.checkName != null)
+            names.add(e.checkName);
+    }
+    return { entries: final, checkNames: [...names].sort(), skip };
 }
 // ------------------------------------------------------------------------ CLI
 function parseArgs(argv) {
@@ -376,9 +553,9 @@ function parseArgs(argv) {
 const isMain = /predict\.(ts|js)$|\/willfire$/.test(process.argv[1] ?? "");
 if (isMain) {
     const args = parseArgs(process.argv.slice(2));
-    const { entries, skip } = await predict(makeOctokit(), args.repo, args.pr);
+    const { entries, checkNames, skip } = await predict(makeOctokit(), args.repo, args.pr);
     if (args.json) {
-        console.log(JSON.stringify({ entries, skip }, null, 2));
+        console.log(JSON.stringify({ entries, checkNames, skip }, null, 2));
     }
     else if (skip) {
         console.log(`# ${skip} -> nothing dispatches`);
@@ -387,8 +564,10 @@ if (isMain) {
         for (const e of entries) {
             if (isWorkflowEntry(e))
                 console.log(`# ${e.workflow} :: ${e.status} (${e.reason})`);
-            else
-                console.log(`${e.workflow} :: ${e.job} :: ${e.status}`);
+            else {
+                const name = e.checkName ?? `${e.job} (name unresolved)`;
+                console.log(`${e.workflow} :: ${name} :: ${e.status}`);
+            }
         }
     }
 }

package/dist/verify.js

@@ -44,8 +44,18 @@ if (!repo || !prArg) {
 const pr = Number(prArg);
 const octokit = makeOctokit();
 const { entries: predictedRaw } = await predict(octokit, repo, pr);
-const predicted = new Map(predictedRaw.filter(isJobEntry).map((r) => [`${r.workflow} :: ${r.job}`, r.status]));
-const unknownWfs = new Set(predictedRaw.filter((r) => r.status === "unknown").map((r) => r.workflow));
+// Compare on the resolved check name — that is the string GitHub actually
+// puts on the job. Entries whose name could not be resolved statically have
+// no key to compare and are reported separately below.
+const predicted = new Map(predictedRaw
+    .filter(isJobEntry)
+    .filter((r) => r.checkName != null)
+    .map((r) => [`${r.workflow} :: ${r.checkName}`, r.status]));
+const unresolved = predictedRaw.filter(isJobEntry).filter((r) => r.checkName == null);
+const unknownWfs = new Set(predictedRaw
+    .filter((r) => r.status === "unknown")
+    .map((r) => r.workflow)
+    .concat(unresolved.map((r) => r.workflow)));
 const { entries: actual, incomplete } = await actualEntries(octokit, repo, pr);
 if (incomplete.length > 0) {
     console.log(`WARNING: runs still in progress: ${incomplete}`);
@@ -80,5 +90,8 @@ for (const key of keys) {
         console.log(`DIFF  ${key} :: predicted ${p}, actual ${a}`);
     }
 }
+for (const r of unresolved) {
+    console.log(`  ?   ${r.workflow} :: ${r.job} :: name unresolved: ${r.reason}`);
+}
 console.log(ok ? "PASS" : "FAIL");
 process.exit(ok ? 0 : 1);

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "willfire",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "Predict the set of CI check entries GitHub Actions will create for a pull request",
   "license": "MIT",
+  "packageManager": "pnpm@10.33.0",
   "author": "Kevin Scott <me@thekevinscott.com>",
   "repository": {
     "type": "git",
@@ -35,8 +36,11 @@
   },
   "scripts": {
     "build": "tsc -p tsconfig.build.json",
-    "prepublishOnly": "pnpm build",
     "predict": "tsx src/predict.ts",
+    "prepare": "pnpm build",
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage",
+    "typecheck": "tsc -p tsconfig.json",
     "verify": "tsx src/verify.ts"
   },
   "dependencies": {
@@ -45,7 +49,10 @@
   },
   "devDependencies": {
     "@types/node": "^22.0.0",
+    "@vitest/coverage-v8": "^4.1.10",
+    "testing-conventions": "^0.0.91",
     "tsx": "^4.19.0",
-    "typescript": "^5.6.0"
+    "typescript": "^5.6.0",
+    "vitest": "^4.1.10"
   }
 }