@quikit/quikpilot-runner 8.2.4 → 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" },
@@ -214,6 +215,13 @@ function matchesDeniedPath(path, patterns) {
   }
   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"]);
@@ -384,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(
@@ -404,15 +418,14 @@ async function runCodegen(gateway, targets, workspaceListing, requiredTests, den
     for (const s of added.skipped) {
       warnings.push(`not shown to the test for ${target.path}: ${s.path} (${s.reason})`);
     }
-    console.log(
-      JSON.stringify({
-        event: "codegen.context",
-        targetPath: target.path,
-        contextPaths,
-        addedPaths: added.entries.map((e) => e.path),
-        skipped: added.skipped
-      })
-    );
+    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,
@@ -470,6 +483,8 @@ async function runCodegen(gateway, targets, workspaceListing, requiredTests, den
     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}`);
@@ -1200,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}`);
   }
@@ -1269,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, "/");
@@ -1335,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);
@@ -1349,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");
@@ -1392,7 +1518,8 @@ async function run(env2) {
           packet.requiredTests,
           packet.guardrails.deniedPaths,
           judgedByPool,
-          warnings
+          warnings,
+          contextLog
         )
       ]);
       const depCheck = checkImportDependencies(
@@ -1486,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 };
 }