@quikit/quikpilot-runner 8.2.3 → 8.2.5

package/README.md

@@ -1,27 +1,27 @@
-# @quikit/quikpilot-runner
-
-QuikPilot's CI runner. Invoked automatically by the `.github/workflows/quikpilot.yml` file QuikPilot
-installs in an onboarded repository — it fetches the run's work packet, runs your setup/lint/test
-commands, reports results to QuikTest, enforces the denied-path guardrail, commits, pushes, and
-reports back to QuikTrack.
-
-This package is not meant to be installed or run by hand. It exists so a fix to QuikPilot's runner
-logic ships as a new package version rather than a new pull request into every onboarded repository
-— the workflow file itself lives in your repository (QuikIT cannot update it directly), so it stays a
-thin, ~25-line launcher that invokes an exact, pinned version of this package via `npx`.
-
-It carries no secrets and needs none of your credentials: it authenticates to QuikTrack and to GitHub
-using short-lived tokens exchanged at runtime, never a value baked into the workflow file or this
-package.
-
-## Versioning and support
-
-Every workflow file pins an **exact** version of this package (`npx --yes
-@quikit/quikpilot-runner@<version>`, never a range or `latest`) — a repository never picks up a new
-release on its own. Older published versions are not removed from npm and keep working as long as a
-repository's workflow file keeps pinning them; upgrading to a newer version only happens through a new
-pull request into that repository (QuikTrack's "re-bootstrap" flow), never silently.
-
-Releases follow [SemVer](https://semver.org/): a major version bump means the workflow file's own
-shape changed (inputs, permissions) and requires a new pull request regardless of this package's
-version; minor/patch releases are runner-logic fixes safe to pick up on the next re-bootstrap.
+# @quikit/quikpilot-runner
+
+QuikPilot's CI runner. Invoked automatically by the `.github/workflows/quikpilot.yml` file QuikPilot
+installs in an onboarded repository — it fetches the run's work packet, runs your setup/lint/test
+commands, reports results to QuikTest, enforces the denied-path guardrail, commits, pushes, and
+reports back to QuikTrack.
+
+This package is not meant to be installed or run by hand. It exists so a fix to QuikPilot's runner
+logic ships as a new package version rather than a new pull request into every onboarded repository
+— the workflow file itself lives in your repository (QuikIT cannot update it directly), so it stays a
+thin, ~25-line launcher that invokes an exact, pinned version of this package via `npx`.
+
+It carries no secrets and needs none of your credentials: it authenticates to QuikTrack and to GitHub
+using short-lived tokens exchanged at runtime, never a value baked into the workflow file or this
+package.
+
+## Versioning and support
+
+Every workflow file pins an **exact** version of this package (`npx --yes
+@quikit/quikpilot-runner@<version>`, never a range or `latest`) — a repository never picks up a new
+release on its own. Older published versions are not removed from npm and keep working as long as a
+repository's workflow file keeps pinning them; upgrading to a newer version only happens through a new
+pull request into that repository (QuikTrack's "re-bootstrap" flow), never silently.
+
+Releases follow [SemVer](https://semver.org/): a major version bump means the workflow file's own
+shape changed (inputs, permissions) and requires a new pull request regardless of this package's
+version; minor/patch releases are runner-logic fixes safe to pick up on the next re-bootstrap.

package/dist/index.js

@@ -73,10 +73,11 @@ async function describeQuikTrackFailure(res) {
 
 // src/callback.ts
 async function reportBack(params) {
-  const { callbackUrl, runToken, status, branch, warnings } = params;
+  const { callbackUrl, runToken, status, branch, warnings, targeting } = params;
   const body = { status };
   if (branch) body.branch = branch;
   if (warnings && warnings.length > 0) body.warnings = warnings;
+  if (targeting) body.targeting = targeting;
   const res = await fetch(callbackUrl, {
     method: "POST",
     headers: { Authorization: `Bearer ${runToken}`, "Content-Type": "application/json" },
@@ -202,6 +203,26 @@ function commitAndPush(branch, runId, installationToken, targeted, issueKey, iss
 var import_node_fs = require("node:fs");
 var import_node_path = require("node:path");
 
+// src/deniedPaths.ts
+function globToRegExp(pattern) {
+  const escaped = pattern.split("").map((c) => /[.+^${}()|[\]\\]/.test(c) ? `\\${c}` : c).join("");
+  const withGlobs = escaped.replace(/\*\*\//g, " SLASH ").replace(/\*\*/g, " STAR ").replace(/\*/g, "[^/]*").replace(/ SLASH /g, "(?:.*/)?").replace(/ STAR /g, ".*");
+  return new RegExp(`^${withGlobs}$`);
+}
+function matchesDeniedPath(path, patterns) {
+  for (const pattern of patterns) {
+    if (globToRegExp(pattern).test(path)) return pattern;
+  }
+  return null;
+}
+function findDeniedContextPath(contextPaths, patterns) {
+  for (const path of contextPaths) {
+    const pattern = matchesDeniedPath(path, patterns);
+    if (pattern) return { path, pattern };
+  }
+  return null;
+}
+
 // src/envelope.ts
 var HARD_FAILURE_CODES = /* @__PURE__ */ new Set(["SEMANTIC_MISMATCH", "CONTRACT_REJECTED"]);
 function checkHardFailure(envelope, useCase, target) {
@@ -256,6 +277,37 @@ var CONTEXT_TOO_LARGE_CODE = "CODEGEN_CONTEXT_TOO_LARGE";
 var OUTPUT_TOO_LARGE_CODE = "CODEGEN_OUTPUT_TOO_LARGE";
 var NOT_RETRIED_CODES = /* @__PURE__ */ new Set([FILE_TOO_LARGE_CODE, CONTEXT_TOO_LARGE_CODE, OUTPUT_TOO_LARGE_CODE]);
 var JUDGED_BY_TOO_LARGE_CODE = "CODEGEN_JUDGED_BY_TOO_LARGE";
+var MAX_ADDED_FILE_CHARS = 4e4;
+var MAX_ADDED_CONTEXT_CHARS = 6e4;
+function collectRunContext(target, targets, alreadyNamed, deniedPaths, readFile = (p) => (0, import_node_fs.readFileSync)(p, "utf8")) {
+  const added = { entries: [], skipped: [] };
+  if (!target.automationIds?.length) return added;
+  const seen = new Set(alreadyNamed);
+  seen.add(target.path);
+  let total = 0;
+  for (const candidate of targets) {
+    if (candidate.kind !== "EXISTING" || candidate.automationIds?.length) continue;
+    if (seen.has(candidate.path)) continue;
+    seen.add(candidate.path);
+    if (matchesDeniedPath(candidate.path, deniedPaths)) continue;
+    let content;
+    try {
+      content = readFile(candidate.path);
+    } catch {
+      added.skipped.push({ path: candidate.path, reason: "unreadable" });
+      continue;
+    }
+    if (content.length > MAX_ADDED_FILE_CHARS) {
+      added.skipped.push({ path: candidate.path, reason: "too large" });
+    } else if (total + content.length > MAX_ADDED_CONTEXT_CHARS) {
+      added.skipped.push({ path: candidate.path, reason: "over budget" });
+    } else {
+      total += content.length;
+      added.entries.push({ path: candidate.path, content });
+    }
+  }
+  return added;
+}
 var SUSPECT_PLACEHOLDER_RE = /rest(?: of the)? (?:file|code) unchanged|remainder unchanged|\/\/\s*\.\.\.\s*(?:rest|remaining)/i;
 var SUSPECT_LENGTH_DROP_RATIO = 0.6;
 var SUSPECT_REMOVED_LINE_RATIO = 0.3;
@@ -340,13 +392,19 @@ function narrowJudgedByForTarget(pool, targets, codeTargetPath) {
 function toWireJudgedBy(pool) {
   return pool.map(({ automationId: _automationId, ...rest }) => rest);
 }
-async function runCodegen(gateway, targets, workspaceListing, requiredTests, deniedPaths, judgedByPool, warnings) {
+async function runCodegen(gateway, targets, workspaceListing, requiredTests, deniedPaths, judgedByPool, warnings, contextLog) {
   const results = [];
   const listing = new Set(workspaceListing);
   for (const target of targets) {
     const isNewFile = target.kind === "NEW_FILE";
     const currentContent = isNewFile ? "" : (0, import_node_fs.readFileSync)(target.path, "utf8");
     const contextPaths = target.contextPaths ?? [];
+    const deniedContext = findDeniedContextPath(contextPaths, deniedPaths);
+    if (deniedContext) {
+      throw new Error(
+        `pilot.codegen contextPaths cited a denied path (${deniedContext.pattern}): ${deniedContext.path} (target ${target.path})`
+      );
+    }
     for (const contextPath of contextPaths) {
       if (!listing.has(contextPath)) {
         throw new Error(
@@ -354,7 +412,20 @@ async function runCodegen(gateway, targets, workspaceListing, requiredTests, den
         );
       }
     }
-    const contextContents = contextPaths.map((path) => ({ path, content: (0, import_node_fs.readFileSync)(path, "utf8") }));
+    const namedContents = contextPaths.map((path) => ({ path, content: (0, import_node_fs.readFileSync)(path, "utf8") }));
+    const added = collectRunContext(target, targets, new Set(contextPaths), deniedPaths);
+    const contextContents = [...namedContents, ...added.entries];
+    for (const s of added.skipped) {
+      warnings.push(`not shown to the test for ${target.path}: ${s.path} (${s.reason})`);
+    }
+    const contextRecord = {
+      targetPath: target.path,
+      contextPaths,
+      addedPaths: added.entries.map((e) => e.path),
+      skipped: added.skipped
+    };
+    console.log(JSON.stringify({ event: "codegen.context", ...contextRecord }));
+    contextLog?.push(contextRecord);
     const contextData = {
       targetPath: target.path,
       currentContent,
@@ -409,6 +480,18 @@ async function runCodegen(gateway, targets, workspaceListing, requiredTests, den
       envelope = await res.json();
       checkHardFailure(envelope, "pilot.codegen", target.path);
     }
+    if (envelope?.errorCode === CONTEXT_TOO_LARGE_CODE && added.entries.length > 0) {
+      contextData.contextContents = namedContents;
+      warnings.push(`context for ${target.path} was too large with the run's other files; retried without them`);
+      contextRecord.addedPaths = [];
+      contextRecord.retriedWithoutAdded = true;
+      res = await callCodegen();
+      if (!res.ok) {
+        throw new Error(`Codegen call failed for ${target.path}: ${res.status} ${res.statusText}`);
+      }
+      envelope = await res.json();
+      checkHardFailure(envelope, "pilot.codegen", target.path);
+    }
     if (typeof envelope?.errorCode === "string" && NOT_RETRIED_CODES.has(envelope.errorCode)) {
       const detail = envelope.error ? `: ${envelope.error}` : "";
       throw new Error(`Codegen refused ${target.path}: ${envelope.errorCode} (not retried)${detail}`);
@@ -1121,21 +1204,6 @@ function describeScopeViolations(check) {
 
 // src/targeting.ts
 var import_node_path4 = require("node:path");
-
-// src/deniedPaths.ts
-function globToRegExp(pattern) {
-  const escaped = pattern.split("").map((c) => /[.+^${}()|[\]\\]/.test(c) ? `\\${c}` : c).join("");
-  const withGlobs = escaped.replace(/\*\*\//g, " SLASH ").replace(/\*\*/g, " STAR ").replace(/\*/g, "[^/]*").replace(/ SLASH /g, "(?:.*/)?").replace(/ STAR /g, ".*");
-  return new RegExp(`^${withGlobs}$`);
-}
-function matchesDeniedPath(path, patterns) {
-  for (const pattern of patterns) {
-    if (globToRegExp(pattern).test(path)) return pattern;
-  }
-  return null;
-}
-
-// src/targeting.ts
 var CONTRACT_VERSION2 = "test-targets-1";
 function listWorkspaceFiles(workspaceRoot) {
   return listFiles(workspaceRoot ?? ".");
@@ -1147,6 +1215,12 @@ function validateTarget(target, workspaceRoot, workspaceListing, deniedPaths) {
       `pilot.targeting proposed a target matching a denied path (${denied}): ${target.path}`
     );
   }
+  const deniedContext = findDeniedContextPath(target.contextPaths ?? [], deniedPaths);
+  if (deniedContext) {
+    throw new Error(
+      `pilot.targeting cited a denied path as context (${deniedContext.pattern}): ${deniedContext.path} (target ${target.path})`
+    );
+  }
   if (target.kind !== "EXISTING" && target.kind !== "NEW_FILE") {
     throw new Error(`pilot.targeting returned an unknown kind "${target.kind}" for ${target.path}`);
   }
@@ -1216,6 +1290,108 @@ async function runTargeting(gateway, design, workspaceRoot, workspaceListing, re
   };
 }
 
+// src/targetingRecord.ts
+var MAX_TARGETS = 25;
+var MAX_IDS_PER_TARGET = 50;
+var MAX_CONTEXT_PATHS = 20;
+var MAX_ADDED_PATHS = 20;
+var MAX_SKIPPED_CONTEXT = 20;
+var MAX_SKIPPED_CASES = 200;
+var MAX_CONTEXT_RECORDS = 25;
+var MAX_PATH_CHARS = 300;
+var MAX_ID_CHARS = 100;
+var MAX_REASON_CHARS = 300;
+function clampList(values, max, maxChars) {
+  let cut = false;
+  const kept = [];
+  for (const raw of values ?? []) {
+    const v = typeof raw === "string" ? raw.trim() : "";
+    if (v.length === 0) continue;
+    if (v.length > maxChars || kept.length >= max) {
+      cut = true;
+      continue;
+    }
+    kept.push(v);
+  }
+  return { kept, cut };
+}
+function buildTargetingRecord(targeting, contextLog) {
+  let truncated = false;
+  const note = (cut) => {
+    if (cut) truncated = true;
+  };
+  if (targeting.outcome === "NO_TARGET") {
+    const record2 = { outcome: "NO_TARGET", targets: [], skippedCaseIds: [], codegenContext: [] };
+    const reason = (targeting.reason ?? "").trim();
+    if (reason.length > 0) {
+      record2.noTargetReason = reason.slice(0, MAX_REASON_CHARS);
+      if (reason.length > MAX_REASON_CHARS) record2.noTargetReasonTruncated = true;
+    }
+    return record2;
+  }
+  const targets = [];
+  for (const t of targeting.targets) {
+    if (targets.length >= MAX_TARGETS) {
+      truncated = true;
+      break;
+    }
+    const path = typeof t.path === "string" ? t.path.trim() : "";
+    if (path.length === 0 || path.length > MAX_PATH_CHARS) {
+      truncated = true;
+      continue;
+    }
+    const contextPaths = clampList(t.contextPaths, MAX_CONTEXT_PATHS, MAX_PATH_CHARS);
+    const automationIds = clampList(t.automationIds, MAX_IDS_PER_TARGET, MAX_ID_CHARS);
+    note(contextPaths.cut);
+    note(automationIds.cut);
+    targets.push({ path, kind: t.kind, contextPaths: contextPaths.kept, automationIds: automationIds.kept });
+  }
+  const skipped = clampList(
+    (targeting.skippedCases ?? []).map((c) => c.automationId),
+    MAX_SKIPPED_CASES,
+    MAX_ID_CHARS
+  );
+  note(skipped.cut);
+  const codegenContext = [];
+  for (const entry of contextLog) {
+    if (codegenContext.length >= MAX_CONTEXT_RECORDS) {
+      truncated = true;
+      break;
+    }
+    const targetPath = typeof entry.targetPath === "string" ? entry.targetPath.trim() : "";
+    if (targetPath.length === 0 || targetPath.length > MAX_PATH_CHARS) {
+      truncated = true;
+      continue;
+    }
+    const contextPaths = clampList(entry.contextPaths, MAX_CONTEXT_PATHS, MAX_PATH_CHARS);
+    const addedPaths = clampList(entry.addedPaths, MAX_ADDED_PATHS, MAX_PATH_CHARS);
+    const skippedPaths = clampList(
+      (entry.skipped ?? []).map((s) => s.path),
+      MAX_SKIPPED_CONTEXT,
+      MAX_PATH_CHARS
+    );
+    note(contextPaths.cut);
+    note(addedPaths.cut);
+    note(skippedPaths.cut);
+    const reasonByPath = new Map((entry.skipped ?? []).map((s) => [s.path.trim(), s.reason]));
+    codegenContext.push({
+      targetPath,
+      contextPaths: contextPaths.kept,
+      addedPaths: addedPaths.kept,
+      skipped: skippedPaths.kept.map((path) => ({ path, reason: String(reasonByPath.get(path) ?? "skipped").slice(0, 40) })),
+      ...entry.retriedWithoutAdded ? { retriedWithoutAdded: true } : {}
+    });
+  }
+  const record = {
+    outcome: "TARGETED",
+    targets,
+    skippedCaseIds: skipped.kept,
+    codegenContext
+  };
+  if (truncated) record.truncated = true;
+  return record;
+}
+
 // src/testPlacementCheck.ts
 function isDiscovered(targetPath, discoveredFiles) {
   const normalized = targetPath.replace(/\\/g, "/");
@@ -1282,6 +1458,8 @@ async function run(env2) {
   let warnings = [];
   let targeted = false;
   let generatedFilePaths = [];
+  let targetingResult;
+  const contextLog = [];
   try {
     runToken = await exchangeForRunToken(env2.tokenUrl, await fetchGithubOidcToken());
     packet = await fetchPacket(env2.packetUrl, runToken, env2.githubRunId);
@@ -1296,6 +1474,7 @@ async function run(env2) {
       packet.guardrails.deniedPaths,
       packet.testDiscovery
     );
+    targetingResult = targeting;
     if (targeting.outcome === "NO_TARGET") {
       writePhase0Marker(env2.runId);
       runCommand(packet.commands.setup, "Setup");
@@ -1339,7 +1518,8 @@ async function run(env2) {
           packet.requiredTests,
           packet.guardrails.deniedPaths,
           judgedByPool,
-          warnings
+          warnings,
+          contextLog
         )
       ]);
       const depCheck = checkImportDependencies(
@@ -1433,7 +1613,9 @@ async function run(env2) {
     runToken,
     status: hardFailure ? "failed" : "completed",
     branch,
-    warnings
+    warnings,
+    // Omitted when targeting itself never produced a result (nothing exists to record).
+    targeting: targetingResult ? buildTargetingRecord(targetingResult, contextLog) : void 0
   });
   return { hardFailure };
 }