@codyswann/lisa 2.265.0 → 2.266.0

package/scripts/detect-stale-workflow-inputs.mjs

@@ -42,11 +42,26 @@ import fs from "node:fs";
 import path from "node:path";
 import process from "node:process";
 import { fileURLToPath, pathToFileURL } from "node:url";
+import {
+  diffStaleKeys,
+  extractCallerJobs,
+  extractDeclaredInputs,
+  parseReusableReference,
+} from "./lib/reusable-workflow-contract.mjs";
+
+export {
+  diffStaleKeys,
+  extractCallerJobs,
+  extractDeclaredInputs,
+  parseReusableReference,
+};
 
 const REPO_ROOT = path.resolve(
   path.dirname(fileURLToPath(import.meta.url)),
   ".."
 );
+const LISA_OWNER = "codyswanngt";
+const LISA_REPO = "lisa";
 
 /**
  * Usage error — thrown by `parseArgs` for an invalid invocation so `main` can
@@ -68,153 +83,6 @@ function isDirectory(target) {
   }
 }
 
-/**
- * Leading-whitespace width of a line (its indentation level).
- *
- * @param {string} line - a single source line.
- * @returns {number} number of leading whitespace characters.
- */
-function indentOf(line) {
-  return line.length - line.trimStart().length;
-}
-
-/**
- * Collect the immediate child `key:` names nested directly under a block
- * opener line, given the opener's own indentation. Stops at the first line
- * whose indentation is `<= parentIndent` (blank lines are skipped).
- *
- * @param {readonly string[]} lines - full file, split into lines.
- * @param {number} openerIndex - index of the block-opener line (e.g. `with:`).
- * @param {number} parentIndent - indentation width of the opener line itself.
- * @returns {string[]} the immediate child key names, in file order.
- */
-function collectImmediateChildKeys(lines, openerIndex, parentIndent) {
-  const keys = [];
-  for (let k = openerIndex + 1; k < lines.length; k++) {
-    const line = lines[k];
-    if (line.trim() === "") {
-      continue;
-    }
-    const lineIndent = indentOf(line);
-    if (lineIndent <= parentIndent) {
-      break;
-    }
-    const match = /^\s*([A-Za-z0-9_-]+):/.exec(line);
-    if (match && lineIndent === parentIndent + 2) {
-      keys.push(match[1]);
-    }
-  }
-  return keys;
-}
-
-/**
- * Parse a `uses:` value referencing a reusable workflow into its basename and
- * ref, or `null` if it doesn't match the `.../.github/workflows/<file>@<ref>`
- * shape (e.g. a plain action reference like `actions/checkout@v6`).
- *
- * @param {string} usesValue - the raw value after `uses:`.
- * @returns {{ file: string, ref: string } | null} the parsed reference.
- */
-export function parseReusableReference(usesValue) {
-  const match = /\.github\/workflows\/([\w.-]+\.ya?ml)@(\S+)$/.exec(
-    usesValue.trim()
-  );
-  if (!match) {
-    return null;
-  }
-  return { file: match[1], ref: match[2] };
-}
-
-/**
- * Scan a caller workflow file's contents for every job that invokes a
- * reusable workflow, returning the `with:` keys each job passes.
- *
- * @param {string} content - full caller workflow file contents.
- * @returns {{ reusableFile: string, ref: string, withKeys: string[] }[]}
- *   one entry per job that calls a reusable workflow (in file order).
- */
-export function extractCallerJobs(content) {
-  const lines = content.split(/\r?\n/);
-  const jobs = [];
-  for (let i = 0; i < lines.length; i++) {
-    const usesMatch = /^(\s*)uses:\s*(\S+)\s*$/.exec(lines[i]);
-    if (!usesMatch) {
-      continue;
-    }
-    const [, indentStr, usesValue] = usesMatch;
-    const ref = parseReusableReference(usesValue);
-    if (!ref) {
-      continue;
-    }
-    const indent = indentStr.length;
-    let withKeys = [];
-    for (let j = i + 1; j < lines.length; j++) {
-      const line = lines[j];
-      if (line.trim() === "") {
-        continue;
-      }
-      const lineIndent = indentOf(line);
-      if (lineIndent < indent) {
-        break;
-      }
-      if (lineIndent === indent && /^\s*with:\s*$/.test(line)) {
-        withKeys = collectImmediateChildKeys(lines, j, indent).sort();
-        break;
-      }
-    }
-    jobs.push({ reusableFile: ref.file, ref: ref.ref, withKeys });
-  }
-  return jobs;
-}
-
-/**
- * Extract the declared `on.workflow_call.inputs` key names from a reusable
- * workflow's contents.
- *
- * @param {string} content - full reusable workflow file contents.
- * @returns {string[] | null} declared input names (sorted), an empty array when
- *   the reusable workflow declares no inputs, or `null` if the file has no
- *   `workflow_call:` block.
- */
-export function extractDeclaredInputs(content) {
-  const lines = content.split(/\r?\n/);
-  for (let i = 0; i < lines.length; i++) {
-    if (!/^\s*workflow_call:\s*$/.test(lines[i])) {
-      continue;
-    }
-    const wcIndent = indentOf(lines[i]);
-    for (let j = i + 1; j < lines.length; j++) {
-      const line = lines[j];
-      if (line.trim() === "") {
-        continue;
-      }
-      const lineIndent = indentOf(line);
-      if (lineIndent <= wcIndent) {
-        break;
-      }
-      if (lineIndent === wcIndent + 2 && /^\s*inputs:\s*$/.test(line)) {
-        return collectImmediateChildKeys(lines, j, lineIndent).sort();
-      }
-    }
-    return [];
-  }
-  return null;
-}
-
-/**
- * Keys present in `used` but absent from `declared` — i.e. inputs a caller
- * passes that the reusable workflow's contract no longer accepts.
- *
- * @param {readonly string[]} used - `with:` keys a caller passes.
- * @param {readonly string[]} declared - `workflow_call.inputs` keys the
- *   reusable workflow declares.
- * @returns {string[]} the stale keys, sorted.
- */
-export function diffStaleKeys(used, declared) {
-  const declaredSet = new Set(declared);
-  return used.filter(key => !declaredSet.has(key)).sort();
-}
-
 /**
  * Resolve a reusable workflow's declared inputs from the contracts root.
  *
@@ -245,7 +113,12 @@ function resolveContractInputs(contractsRoot, reusableFile) {
 function scanCallerFile(filePath, contractsRoot) {
   const jobs = extractCallerJobs(fs.readFileSync(filePath, "utf8"));
   return jobs.map(job => {
-    const declared = resolveContractInputs(contractsRoot, job.reusableFile);
+    const isLisaContract =
+      job.owner?.toLowerCase() === LISA_OWNER &&
+      job.repo?.toLowerCase() === LISA_REPO;
+    const declared = isLisaContract
+      ? resolveContractInputs(contractsRoot, job.reusableFile)
+      : null;
     if (declared === null) {
       return { ...job, staleInputs: [], status: "unknown-contract" };
     }

package/scripts/lib/reusable-workflow-contract.d.mts

@@ -0,0 +1,24 @@
+export interface ReusableCallerJob {
+  readonly reusableFile: string;
+  readonly ref: string;
+  readonly owner: string | null;
+  readonly repo: string | null;
+  readonly withKeys: readonly string[];
+}
+
+export function parseReusableReference(usesValue: string): {
+  readonly file: string;
+  readonly ref: string;
+  readonly owner: string | null;
+  readonly repo: string | null;
+} | null;
+export function extractCallerJobs(
+  content: string
+): readonly ReusableCallerJob[];
+export function extractDeclaredInputs(
+  content: string
+): readonly string[] | null;
+export function diffStaleKeys(
+  used: readonly string[],
+  declared: readonly string[]
+): readonly string[];

package/scripts/lib/reusable-workflow-contract.mjs

@@ -0,0 +1,123 @@
+/** Pure reusable-workflow caller/contract comparison shared by health and CLI. */
+
+/** @param {string} line @returns {number} */
+function indentOf(line) {
+  return line.length - line.trimStart().length;
+}
+
+/**
+ * @param {readonly string[]} lines
+ * @param {number} openerIndex
+ * @param {number} parentIndent
+ * @returns {string[]}
+ */
+function collectImmediateChildKeys(lines, openerIndex, parentIndent) {
+  const keys = [];
+  for (let index = openerIndex + 1; index < lines.length; index++) {
+    const line = lines[index];
+    if (line.trim() === "") continue;
+    const indentation = indentOf(line);
+    if (indentation <= parentIndent) break;
+    const match = /^\s*([A-Za-z0-9_-]+):/.exec(line);
+    if (match && indentation === parentIndent + 2) keys.push(match[1]);
+  }
+  return keys;
+}
+
+/**
+ * @param {string} usesValue
+ * @returns {{ file: string, ref: string, owner: string | null, repo: string | null } | null}
+ */
+export function parseReusableReference(usesValue) {
+  const value = usesValue.trim();
+  const local = /^\.\/\.github\/workflows\/([\w.-]+\.ya?ml)$/.exec(value);
+  if (local) {
+    return { file: local[1], ref: "local", owner: null, repo: null };
+  }
+  const remote =
+    /^([^/\s]+)\/([^/\s]+)\/\.github\/workflows\/([\w.-]+\.ya?ml)@(\S+)$/.exec(
+      value
+    );
+  return remote
+    ? {
+        file: remote[3],
+        ref: remote[4],
+        owner: remote[1],
+        repo: remote[2],
+      }
+    : null;
+}
+
+/**
+ * @param {string} content
+ * @returns {{ reusableFile: string, ref: string, owner: string | null, repo: string | null, withKeys: string[] }[]}
+ */
+export function extractCallerJobs(content) {
+  const lines = content.split(/\r?\n/);
+  const jobs = [];
+  for (let index = 0; index < lines.length; index++) {
+    const usesMatch = /^(\s*)uses:\s*(\S+)\s*$/.exec(lines[index]);
+    if (!usesMatch) continue;
+    const reference = parseReusableReference(usesMatch[2]);
+    if (!reference) continue;
+    const indentation = usesMatch[1].length;
+    let withKeys = [];
+    for (let child = index + 1; child < lines.length; child++) {
+      const line = lines[child];
+      if (line.trim() === "") continue;
+      const childIndentation = indentOf(line);
+      if (childIndentation < indentation) break;
+      if (childIndentation === indentation && /^\s*with:\s*$/.test(line)) {
+        withKeys = collectImmediateChildKeys(lines, child, indentation).sort(
+          (left, right) => left.localeCompare(right)
+        );
+        break;
+      }
+    }
+    jobs.push({
+      reusableFile: reference.file,
+      ref: reference.ref,
+      owner: reference.owner,
+      repo: reference.repo,
+      withKeys,
+    });
+  }
+  return jobs;
+}
+
+/** @param {string} content @returns {string[] | null} */
+export function extractDeclaredInputs(content) {
+  const lines = content.split(/\r?\n/);
+  for (let index = 0; index < lines.length; index++) {
+    if (!/^\s*workflow_call:\s*$/.test(lines[index])) continue;
+    const indentation = indentOf(lines[index]);
+    for (let child = index + 1; child < lines.length; child++) {
+      const line = lines[child];
+      if (line.trim() === "") continue;
+      const childIndentation = indentOf(line);
+      if (childIndentation <= indentation) break;
+      if (
+        childIndentation === indentation + 2 &&
+        /^\s*inputs:\s*$/.test(line)
+      ) {
+        return collectImmediateChildKeys(lines, child, childIndentation).sort(
+          (left, right) => left.localeCompare(right)
+        );
+      }
+    }
+    return [];
+  }
+  return null;
+}
+
+/**
+ * @param {readonly string[]} used
+ * @param {readonly string[]} declared
+ * @returns {string[]}
+ */
+export function diffStaleKeys(used, declared) {
+  const declaredSet = new Set(declared);
+  return used
+    .filter(key => !declaredSet.has(key))
+    .sort((left, right) => left.localeCompare(right));
+}