willfire 0.1.13 → 0.1.15

package/dist/cli/parseArgs.js

@@ -27,8 +27,9 @@ export function parseArgs(argv) {
     // execution the caller thought they asked for.
     const execute = [];
     for (let i = 0; i < argv.length; i++) {
-        if (argv[i] !== "--execute")
+        if (argv[i] !== "--execute") {
             continue;
+        }
         const spec = argv[i + 1];
         const grant = spec == null ? null : parseGrant(spec);
         if (grant == null) {

package/dist/cli.js

@@ -25,8 +25,9 @@ if (isMain) {
         }
         else {
             for (const e of entries) {
-                if (isWorkflowEntry(e))
+                if (isWorkflowEntry(e)) {
                     console.log(`# ${e.workflow} :: ${e.status} (${e.reason})`);
+                }
                 else {
                     const name = e.checkName ?? `${e.job} (name unresolved)`;
                     console.log(`${e.workflow} :: ${name} :: ${e.status}`);
@@ -35,7 +36,8 @@ if (isMain) {
         }
         // Last, and on the skip path too, so a red gate's first question — which
         // commits was this read from? — is answered wherever the reader lands.
-        for (const s of sources)
+        for (const s of sources) {
             console.log(`# read ${s.owner}/${s.repo}@${s.ref} -> ${s.sha}`);
+        }
     }
 }

package/dist/execute.js

@@ -40,19 +40,22 @@ import { UNKNOWN } from "./expr/val.js";
 /** `owner/repo:job1,job2` as the CLI spells a grant. */
 export function parseGrant(spec) {
     const colon = spec.indexOf(":");
-    if (colon <= 0)
+    if (colon <= 0) {
         return null;
+    }
     const repo = spec.slice(0, colon);
     const parts = repo.split("/");
-    if (parts.length !== 2 || parts.some((p) => p === ""))
+    if (parts.length !== 2 || parts.some((p) => p === "")) {
         return null;
+    }
     const jobs = spec
         .slice(colon + 1)
         .split(",")
         .map((s) => s.trim())
         .filter((s) => s !== "");
-    if (jobs.length === 0)
+    if (jobs.length === 0) {
         return null;
+    }
     return { repo, jobs };
 }
 const err = (reason) => ({ ok: false, reason });
@@ -77,15 +80,18 @@ function renderTemplate(text, scope) {
 }
 /** An `env:` block rendered to concrete strings, every key or nothing. */
 function renderEnvLayer(layer, scope) {
-    if (layer == null)
+    if (layer == null) {
         return { ok: true, v: {} };
-    if (typeof layer !== "object" || Array.isArray(layer))
+    }
+    if (typeof layer !== "object" || Array.isArray(layer)) {
         return err("env block is not a map");
+    }
     const out = {};
     for (const [k, raw] of Object.entries(layer)) {
         const rendered = renderTemplate(String(raw ?? ""), scope);
-        if (rendered == null)
+        if (rendered == null) {
             return err(`cannot resolve env '${k}'`);
+        }
         out[k] = rendered;
     }
     return { ok: true, v: out };
@@ -103,15 +109,17 @@ export function parseGithubOutput(text) {
     while (i < lines.length) {
         const line = lines[i];
         i++;
-        if (line === "")
+        if (line === "") {
             continue;
+        }
         const heredoc = /^([^=<]+)<<(.+)$/.exec(line);
         if (heredoc != null) {
             const [, name, delim] = heredoc;
             const buf = [];
             for (;;) {
-                if (i >= lines.length)
+                if (i >= lines.length) {
                     return null; // unterminated heredoc
+                }
                 if (lines[i] === delim) {
                     i++;
                     break;
@@ -123,8 +131,9 @@ export function parseGithubOutput(text) {
             continue;
         }
         const eq = line.indexOf("=");
-        if (eq <= 0)
+        if (eq <= 0) {
             return null;
+        }
         out[line.slice(0, eq)] = line.slice(eq + 1);
     }
     return out;
@@ -136,17 +145,21 @@ export function parseGithubOutput(text) {
  * lives at the repo root. Expressions and `docker://` images return null.
  */
 function parseActionUses(uses) {
-    if (uses.includes("${{") || uses.startsWith("docker://"))
+    if (uses.includes("${{") || uses.startsWith("docker://")) {
         return null;
+    }
     const at = uses.lastIndexOf("@");
-    if (at <= 0)
+    if (at <= 0) {
         return null;
+    }
     const ref = uses.slice(at + 1);
-    if (ref === "")
+    if (ref === "") {
         return null;
+    }
     const [owner, repo, ...rest] = uses.slice(0, at).split("/");
-    if (!owner || !repo)
+    if (!owner || !repo) {
         return null;
+    }
     return { path: rest.join("/"), source: { owner, repo, ref } };
 }
 /** Read `action.yml` (or `.yaml`) from a directory, or null if neither exists. */
@@ -171,8 +184,9 @@ async function readActionManifest(dir) {
  */
 function bindActionInputs(action, withBlock, scope) {
     const bind = (raw) => {
-        if (raw == null)
+        if (raw == null) {
             return { kind: "value", v: "" };
+        }
         if (typeof raw === "boolean" || typeof raw === "number") {
             return { kind: "value", v: String(raw) };
         }
@@ -213,13 +227,15 @@ async function runSteps(steps, scope, ctx) {
         const stepScope = { ...scope, steps: stepsCtx };
         if (step.if != null) {
             const verdict = evaluate(String(step.if), stepScope);
-            if (verdict == null)
+            if (verdict == null) {
                 return err(`cannot decide if: for ${label}`);
+            }
             if (!verdict) {
                 // A skipped step still occupies its id, with no outputs — that is the
                 // empty string every later read gets, and what `||` coalesces past.
-                if (typeof step.id === "string")
+                if (typeof step.id === "string") {
                     stepsCtx[step.id] = { outputs: {} };
+                }
                 continue;
             }
         }
@@ -233,10 +249,12 @@ async function runSteps(steps, scope, ctx) {
         else {
             return err(`${label} has neither uses nor run`);
         }
-        if (!res.ok)
+        if (!res.ok) {
             return res;
-        if (typeof step.id === "string")
+        }
+        if (typeof step.id === "string") {
             stepsCtx[step.id] = { outputs: res.v };
+        }
     }
     return { ok: true, v: stepsCtx };
 }
@@ -263,12 +281,14 @@ async function runUses(step, label, scope, ctx) {
     }
     else {
         const target = parseActionUses(uses);
-        if (target == null)
+        if (target == null) {
             return err(`${label}: unresolvable uses: ${uses}`);
+        }
         const { ref } = target.source;
         const sha = SHA_RE.test(ref) ? ref : await ctx.deps.resolveRef(target.source);
-        if (sha == null)
+        if (sha == null) {
             return err(`${label}: cannot resolve ref for ${uses}`);
+        }
         const source = { ...target.source, sha };
         const root = await ctx.deps.provideTree(source);
         if (root == null) {
@@ -277,8 +297,9 @@ async function runUses(step, label, scope, ctx) {
         actionDir = target.path === "" ? root : join(root, target.path);
     }
     const manifest = await readActionManifest(actionDir);
-    if (manifest == null)
+    if (manifest == null) {
         return err(`${label}: no action.yml under ${uses}`);
+    }
     let action;
     try {
         action = parseYaml(manifest);
@@ -302,19 +323,22 @@ async function runUses(step, label, scope, ctx) {
         actionPath: actionDir,
         depth: ctx.depth + 1,
     });
-    if (!walked.ok)
+    if (!walked.ok) {
         return err(`${label} (${uses}): ${walked.reason}`);
+    }
     // The action's declared outputs are its whole surface: each `value:` is
     // evaluated against the child's own steps, and every one must land.
     const outScope = { ...childScope, steps: walked.v };
     const outputs = {};
     for (const [name, decl] of Object.entries(action.outputs ?? {})) {
         const raw = decl?.["value"];
-        if (raw == null)
+        if (raw == null) {
             return err(`${label}: output '${name}' of ${uses} has no value`);
+        }
         const rendered = renderTemplate(String(raw), outScope);
-        if (rendered == null)
+        if (rendered == null) {
             return err(`${label}: cannot resolve output '${name}' of ${uses}`);
+        }
         outputs[name] = rendered;
     }
     return { ok: true, v: outputs };
@@ -326,8 +350,9 @@ async function runRun(step, label, scope, ctx) {
         return err(`${label}: shell '${shell}' is not modelled`);
     }
     const script = renderTemplate(String(step.run), scope);
-    if (script == null)
+    if (script == null) {
         return err(`${label}: cannot resolve \${{ }} in run`);
+    }
     const env = {
         // The two the runner always provides and scripts assume. Everything else
         // a step sees, it declared.
@@ -335,19 +360,22 @@ async function runRun(step, label, scope, ctx) {
         HOME: process.env.HOME ?? "",
         GITHUB_WORKSPACE: ctx.tree,
     };
-    if (ctx.actionPath != null)
+    if (ctx.actionPath != null) {
         env.GITHUB_ACTION_PATH = ctx.actionPath;
+    }
     for (const layer of [...ctx.envLayers, step.env]) {
         const rendered = renderEnvLayer(layer, scope);
-        if (!rendered.ok)
+        if (!rendered.ok) {
             return err(`${label}: ${rendered.reason}`);
+        }
         Object.assign(env, rendered.v);
     }
     let cwd = ctx.tree;
     if (step["working-directory"] != null) {
         const wd = renderTemplate(String(step["working-directory"]), scope);
-        if (wd == null)
+        if (wd == null) {
             return err(`${label}: cannot resolve working-directory`);
+        }
         cwd = resolve(ctx.tree, wd);
     }
     const outDir = await mkdtemp(join(tmpdir(), "willfire-out-"));
@@ -362,8 +390,9 @@ async function runRun(step, label, scope, ctx) {
         return err(`${label}: exited ${r.code}${tail === "" ? "" : ` (${tail})`}`);
     }
     const outputs = parseGithubOutput(await readFile(outFile, "utf8"));
-    if (outputs == null)
+    if (outputs == null) {
         return err(`${label}: malformed GITHUB_OUTPUT`);
+    }
     return { ok: true, v: outputs };
 }
 // ------------------------------------------------------------------ executor
@@ -382,13 +411,15 @@ export function makeExecutor(opts) {
             // The shapes execution does not model, refused by name rather than run
             // wrong: a matrix'd job is several executions, and a container changes
             // what every step means.
-            if (job.strategy != null)
+            if (job.strategy != null) {
                 return fail(`job '${jobId}' has a strategy; not modelled`);
+            }
             if (job.container != null || job.services != null) {
                 return fail(`job '${jobId}' uses a container or services; not modelled`);
             }
-            if (!Array.isArray(job.steps))
+            if (!Array.isArray(job.steps)) {
                 return fail(`job '${jobId}' has no steps`);
+            }
             const tree = await deps.provideTree(workspace);
             if (tree == null) {
                 return fail(`cannot materialize workspace ${workspace.owner}/${workspace.repo}@${workspace.sha}`);
@@ -400,8 +431,9 @@ export function makeExecutor(opts) {
                 deps,
                 depth: 0,
             });
-            if (!walked.ok)
+            if (!walked.ok) {
                 return fail(walked.reason);
+            }
             // The job's `outputs:` map is the whole point of having run anything.
             // Every declared entry must land; a hole here would hand consumers a
             // partial map, which the Scope contract calls a lie.
@@ -409,8 +441,9 @@ export function makeExecutor(opts) {
             const outputs = {};
             for (const [name, raw] of Object.entries(job.outputs ?? {})) {
                 const rendered = renderTemplate(String(raw), outScope);
-                if (rendered == null)
+                if (rendered == null) {
                     return fail(`cannot resolve job output '${name}'`);
+                }
                 outputs[name] = rendered;
             }
             return { ok: true, outputs };
@@ -436,8 +469,9 @@ export const runShell = (spec) => new Promise((resolvePromise) => {
     child.stderr.on("data", (d) => {
         stderr += String(d);
         // Keep the tail; a failure reason wants the last line, not a transcript.
-        if (stderr.length > 4096)
+        if (stderr.length > 4096) {
             stderr = stderr.slice(-4096);
+        }
     });
     child.on("error", () => resolvePromise({ code: 127, stderr }));
     child.on("close", (code) => resolvePromise({ code: code ?? 1, stderr }));
@@ -454,8 +488,9 @@ export function makeTreeProvider(download, runCommand) {
     return (source) => {
         const key = `${source.owner}/${source.repo}@${source.sha}`;
         const hit = cache.get(key);
-        if (hit !== undefined)
+        if (hit !== undefined) {
             return hit;
+        }
         const p = materialize(source, download, runCommand);
         cache.set(key, p);
         return p;
@@ -463,8 +498,9 @@ export function makeTreeProvider(download, runCommand) {
 }
 async function materialize(source, download, runCommand) {
     const bytes = await download(source);
-    if (bytes == null)
+    if (bytes == null) {
         return null;
+    }
     const dir = await mkdtemp(join(tmpdir(), "willfire-tree-"));
     const archive = join(dir, "tree.tar.gz");
     await writeFile(archive, bytes);
@@ -480,13 +516,15 @@ async function materialize(source, download, runCommand) {
             WILLFIRE_DEST: dest,
         },
     });
-    if (r.code !== 0)
+    if (r.code !== 0) {
         return null;
+    }
     const entries = await readdir(dest);
     if (entries.length === 1) {
         const sub = join(dest, entries[0]);
-        if ((await stat(sub)).isDirectory())
+        if ((await stat(sub)).isDirectory()) {
             return sub;
+        }
     }
     return dest;
 }

package/dist/filters/matchFilters.js

@@ -5,8 +5,9 @@ export function matchFilters(value, patterns) {
     for (const pat of patterns) {
         const neg = pat.startsWith("!");
         const p = neg ? pat.slice(1) : pat;
-        if (patternToRegex(p).test(value))
+        if (patternToRegex(p).test(value)) {
             matched = !neg;
+        }
     }
     return matched;
 }

package/dist/jobs/evalIf.js

@@ -9,10 +9,12 @@ import { prScope } from "./prScope.js";
  * `needs.*`.
  */
 export function evalIf(cond, scope = {}) {
-    if (cond == null)
+    if (cond == null) {
         return "run";
+    }
     const verdict = evaluate(String(cond), prScope(scope));
-    if (verdict === null)
+    if (verdict === null) {
         return "unknown";
+    }
     return verdict ? "run" : "skipped";
 }

package/dist/jobs/expandJobs.js

@@ -16,22 +16,27 @@ import { prScope } from "./prScope.js";
  * existed; nothing regresses.
  */
 function inputLiteral(raw) {
-    if (raw == null)
+    if (raw == null) {
         return { kind: "value", v: "" };
-    if (typeof raw === "boolean" || typeof raw === "number")
+    }
+    if (typeof raw === "boolean" || typeof raw === "number") {
         return { kind: "value", v: raw };
-    if (typeof raw === "string")
+    }
+    if (typeof raw === "string") {
         return raw.includes("${{") ? UNKNOWN : { kind: "value", v: raw };
+    }
     return UNKNOWN;
 }
 /** The `on.workflow_call.inputs` block, tolerating the YAML 1.1 `on` -> true key. */
 function workflowCallInputs(wf) {
     const on = wf?.["on"] ?? wf?.["true"];
-    if (on == null || typeof on !== "object")
+    if (on == null || typeof on !== "object") {
         return {};
+    }
     const call = on["workflow_call"];
-    if (call == null || typeof call !== "object")
+    if (call == null || typeof call !== "object") {
         return {};
+    }
     const inputs = call["inputs"];
     return inputs != null && typeof inputs === "object" ? inputs : {};
 }
@@ -87,11 +92,13 @@ export async function expandJobs(wf, ctx, reader, source, depth = 0, prefix = ""
     const execFailures = {};
     if (executor != null) {
         for (const [jobId, jobRaw] of Object.entries(jobs)) {
-            if (!executor.granted(source, jobId))
+            if (!executor.granted(source, jobId)) {
                 continue;
+            }
             const job = jobRaw ?? {};
-            if (evalIf(job.if, scoped) !== "run")
+            if (evalIf(job.if, scoped) !== "run") {
                 continue;
+            }
             const res = await executor.executeJob(jobId, job, wf, scoped);
             if (res.ok) {
                 scoped = { ...scoped, needs: { ...scoped.needs, [jobId]: { outputs: res.outputs } } };
@@ -110,8 +117,9 @@ export async function expandJobs(wf, ctx, reader, source, depth = 0, prefix = ""
         let status = evalIf(job.if, scoped);
         let reason = job.if != null ? `if: ${JSON.stringify(job.if)}` : "";
         let needs = job.needs ?? [];
-        if (typeof needs === "string")
+        if (typeof needs === "string") {
             needs = [needs];
+        }
         const cond = String(job.if ?? "");
         if (status !== "skipped" && !cond.includes("always()")) {
             for (const n of needs) {

package/dist/verify.js

@@ -18,8 +18,9 @@ async function actualEntries(octokit, repo, prNumber) {
     const entries = new Map();
     const incomplete = [];
     for (const run of runs) {
-        if (run.status !== "completed")
+        if (run.status !== "completed") {
             incomplete.push(run.path);
+        }
         const jobs = await octokit.paginate(octokit.rest.actions.listJobsForWorkflowRun, {
             ...base,
             run_id: run.id,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "willfire",
-  "version": "0.1.13",
+  "version": "0.1.15",
   "description": "Predict the set of CI check entries GitHub Actions will create for a pull request",
   "license": "MIT",
   "packageManager": "pnpm@10.33.0",