Files
reverse-engineering-anything/scripts/ci/change-plan.mjs
T
morluto 062b3835f9 ci: trace script modules and built-server consumers in PR test selection, and balance selected shards (#11516)
* ci: trace shared script modules to the tests that import them

A pull request that changed any scripts/lib module ran the complete
suite. Shared script modules now pass a change through to the tests,
verifiers and other shared modules that import them, like test helpers.
Another consumer (a build or test-runner script, root configuration,
package metadata, a hook or a workflow) that imports the module or names
it by file name still selects the complete suite.

The tracing core is exported as traceAffectedTests so a bounded local
gate can reuse it.

Fixes #11381

* ci: follow verifier source loads and named verifiers when tracing script modules

- Module URLs (new URL("./x.mts", import.meta.url), as loaded by
  importVerifierSource) are import edges.
- A test that names a verifier or shared module the change reaches is
  selected, not only one that names a changed path.
- A changed shared module that no test reaches runs the complete suite
  even when other changes select tests.

* ci: select tests that start the built server beside a changed presentation owner (#11519)

* ci: select tests that start the built server beside a changed presentation owner

A test that starts the built CLI or MCP server reaches server, contract,
entrypoint and CLI modules through the build, not an import, so a change
there selected none of them (#11146 failed on main this way). Such a
test is now selected when it, or a helper it imports, starts
scripts/rea.mjs or dist/, and it imports a module from the changed
owner's directory.

Fixes #11366

* ci: recognise only the repository's built entry points as runtime launchers

A package subpath such as ajv/dist/2020.js matched the dist/ pattern, so
in-process tests importing Ajv counted as built-runtime launchers.

* ci: balance selected test shards by recorded duration (#11522)

A selected PR run split its files across groups round-robin, so a few
slow files could land together. The plan now records the selected files
and a shard count (version 3), and each job runs one --shard of the
selection through the exact-test runner with the timing history main
already publishes, so the CI sequencer balances shards by per-file
duration (the median for files without a timing). Without history,
Vitest's own deterministic sharding applies.

Fixes #11382
2026-11-16 06:14:14 +08:00

419 lines
15 KiB
JavaScript

import { execFileSync } from "node:child_process";
import { matchesGlob } from "node:path";
import { isLivingProsePath } from "../lib/docs-facts.mjs";
import {
CI_FLAGS as flags,
MANUAL_VERIFIERS,
CI_LANES,
SHARED_BOUNDARY,
WINDOWS_EXECUTABLE_SELECTION_INPUTS,
} from "./scopes.mjs";
import { planTestSelection, testShards } from "./test-selection.mjs";
// Actionlint validates workflow syntax only. The semantic suite asserts these
// workflows' release, publication and self-hosted runner safeguards.
const GUARDED_WORKFLOWS = new Set([
".github/workflows/codeql.yml",
".github/workflows/pr-title.yml",
".github/workflows/pr-readiness.yml",
".github/workflows/ci-full-pr.yml",
".github/workflows/release.yml",
".github/workflows/release-recovery.yml",
".github/workflows/real-ghidra-windows.yml",
".github/workflows/sqlite-runtime.yml",
".github/workflows/ci-timings.yml",
".github/workflows/mutation.yml",
]);
// Sources compiled by build-conformance-fixtures.mjs. The readiness journey
// analyzes the built C fixture as well as its own applications.
const FIXTURE_SOURCES = [
"scripts/build-conformance-fixtures.mjs",
"scripts/verify-conformance-fixtures.mjs",
"scripts/lib/conformance-fixtures.mjs",
"tests/conformance/c/**",
"tests/conformance/napi/**",
"tests/conformance/objc/**",
"tests/conformance/swift/**",
"tests/conformance/versions/**",
];
// These reporters affect CI output only; they do not select a host or provider
// verification lane when changed on their own.
const PORTABLE_CI_REPORTERS = new Set([
"scripts/ci/job-timings.mjs",
"scripts/ci/job-timings-batch.mjs",
"scripts/ci/test-report.mjs",
"scripts/ci/test-timing-reporter.mjs",
"scripts/ci/test-history.mjs",
]);
const matchesAny = (file, patterns) =>
patterns.some((pattern) => matchesGlob(file, pattern));
/**
* Plan the CI lanes for one event. `repository` answers the Git questions the
* plan asks, so the classification runs without a process per decision.
*
* @param {import("./change-plan.d.mts").ChangePlanRequest} request
* @param {import("./change-plan.d.mts").ChangePlanRepository} repository
* @returns {import("./change-plan.d.mts").ChangePlan}
*/
export function planChanges(request, repository) {
const selected = Object.fromEntries(flags.map((flag) => [flag, false]));
const reasons = [];
const full = (reason) => {
if (tier === "full") {
for (const flag of flags) selected[flag] = true;
} else {
selected.code = true;
selected.runtime = true;
}
reasons.push(reason);
};
function classifyPackage(base, head) {
const before = JSON.parse(repository.readFile(base, "package.json"));
const after = JSON.parse(repository.readFile(head, "package.json"));
const { scripts: beforeScripts, ...beforeRest } = before;
const { scripts: afterScripts, ...afterRest } = after;
const compilerDependencies = (metadata) => ({
dependencies: {
typescript: metadata.dependencies?.typescript,
tsrs: metadata.dependencies?.tsrs,
},
devDependencies: {
typescript: metadata.devDependencies?.typescript,
tsrs: metadata.devDependencies?.tsrs,
},
});
const compilerScripts = [
"compile",
"typecheck",
"build",
"build:cached",
"test:prepare",
"docs:prepare",
"verify:frida:bindings",
].flatMap((name) => [name, `pre${name}`, `post${name}`]);
selected.package ||=
JSON.stringify(compilerDependencies(before)) !==
JSON.stringify(compilerDependencies(after)) ||
compilerScripts.some(
(name) => beforeScripts?.[name] !== afterScripts?.[name],
);
if (JSON.stringify(beforeRest) !== JSON.stringify(afterRest)) {
full("Package metadata or dependencies changed");
return;
}
selected.code = true;
const changed = [
...new Set([
...Object.keys(beforeScripts ?? {}),
...Object.keys(afterScripts ?? {}),
]),
].filter((key) => beforeScripts?.[key] !== afterScripts?.[key]);
for (const script of changed) {
if (/^test:(coverage|mutation):reverse-tools$/.test(script)) {
selected.reverse_tools = true;
continue;
}
if (script === "test:python") {
selected.python = true;
continue;
}
if (script === "test:sqlite" || script === "test:sqlite:run") {
selected.sqlite = true;
continue;
}
if (
/^(test(?::|$)|check(?::|$)|lint(?::|$)|format(?::|$)|knip(?::|$)|jscpd$)/.test(
script,
)
)
continue;
if (
["compile:termux", "build:termux", "build:termux:run"].includes(script)
) {
selected.workflows = true;
reasons.push(
`Android build script changed; real Android verification remains manual: ${script}`,
);
continue;
}
// Verify scripts own provider setup as well as execution. Reuse their
// existing source-file ownership rather than maintaining a second map.
const entrypoint = (command) =>
/^(?:npm run build:cached && )?node (scripts\/[\w/-]+\.mjs)(?: [\w./=-]+)*$/.exec(
command ?? "",
)?.[1];
const beforeEntry = entrypoint(beforeScripts?.[script]);
const afterEntry = entrypoint(afterScripts?.[script]);
const entries = [beforeEntry, afterEntry].filter(Boolean);
const simple =
(!beforeScripts?.[script] || beforeEntry) &&
(!afterScripts?.[script] || afterEntry);
const scriptOwners =
simple &&
entries.every((entry) =>
Object.values(CI_LANES).some(({ paths }) => matchesAny(entry, paths)),
)
? Object.entries(CI_LANES)
.filter(([, { paths }]) =>
entries.some((entry) => matchesAny(entry, paths)),
)
.map(([owner]) => owner)
: [];
if (scriptOwners.length)
for (const owner of scriptOwners) selected[owner] = true;
else full(`Shared or unknown package script: ${script}`);
}
}
const { event } = request;
if (
!["pull_request", "push", "schedule", "workflow_dispatch"].includes(event)
)
throw new Error(`Unsupported CI event: ${event}`);
const requestedFull =
event === "schedule" || event === "workflow_dispatch" || request.full;
const tier =
event === "schedule" && request.skipFull && !request.full
? "reused"
: requestedFull
? "full"
: "fast";
/** Select the lanes one changed path owns. */
const classifyFile = (file, base, head) => {
selected.package ||= matchesAny(file, WINDOWS_EXECUTABLE_SELECTION_INPUTS);
for (const [owner, { paths, earlyAll, earlyInputs = [] }] of Object.entries(
CI_LANES,
))
if (matchesAny(file, earlyAll ? paths : earlyInputs))
selected[owner] = true;
// The documentation check scans living prose outside docs/ too.
if (isLivingProsePath(file)) selected.docs = true;
if (
/^(README(?:_[^/]+)?\.md|AGENTS\.md|CONTRIBUTING\.md|CHANGELOG\.md|SECURITY\.md|native\/windows\/README\.md|\.github\/pull_request_template\.md)$/.test(
file,
) ||
file.startsWith("docs/") ||
file === "scripts/verify-documentation-routes.mjs" ||
file.startsWith(".github/ISSUE_TEMPLATE/")
) {
selected.docs = true;
// Authored code and its Node package scopes belong to static checkers.
selected.code ||=
file.startsWith("docs/") &&
(/\.(?:[cm]?[jt]s|[jt]sx)$/u.test(file) ||
file.endsWith("/package.json"));
selected.website ||= matchesAny(file, CI_LANES.website.paths);
return;
}
if (/^(src|tests)\/.*\.(?:test|spec)\.[cm]?[jt]sx?$/.test(file)) {
selected.code = true;
for (const [owner, { paths, testInputs }] of Object.entries(CI_LANES))
if (testInputs && matchesAny(file, paths)) selected[owner] = true;
return;
}
if (matchesAny(file, MANUAL_VERIFIERS)) {
selected.code = true;
return;
}
// Timing and report helpers stay on the portable suite. They are not a
// runtime or provider change.
if (PORTABLE_CI_REPORTERS.has(file)) {
selected.code = true;
return;
}
// A shared boundary is not evidence that every provider or host changed.
// One lane that names the file is path evidence; a lane that only covers
// it through a `**` directory glob is not. Several naming lanes means the
// same registration file is listed by many lanes; fast qualification does
// not fan those out or start the multi-host package matrix.
if (tier !== "full" && SHARED_BOUNDARY.test(file)) {
selected.code = true;
selected.runtime = true;
const owners = Object.entries(CI_LANES)
.filter(([, { paths }]) =>
matchesAny(
file,
paths.filter((pattern) => !pattern.includes("**")),
),
)
.map(([owner]) => owner);
if (owners.length === 1) selected[owners[0]] = true;
reasons.push(`Shared boundary on fast tier: ${file}`);
return;
}
const owners = Object.entries(CI_LANES)
.filter(([, { paths }]) => matchesAny(file, paths))
.map(([owner]) => owner);
for (const owner of owners) selected[owner] = true;
if (
file.startsWith(".github/workflows/") ||
file.startsWith(".github/codeql/") ||
file === ".github/actionlint.yaml"
) {
selected.workflows = true;
if (GUARDED_WORKFLOWS.has(file) || file.startsWith(".github/codeql/"))
selected.code = true;
if (file !== ".github/workflows/ci.yml") return;
}
// The Notes example is also the source-owned agent evaluation fixture.
if (file.startsWith("website/public/examples/notes-electron/"))
selected.code = true;
if (owners.length === 1 && owners[0] === "website") return;
if (/^src\/(contracts|domain)\//.test(file)) selected.docs = true;
if (file === "package.json") {
classifyPackage(base, head);
return;
}
selected.code = true;
if (matchesAny(file, FIXTURE_SOURCES)) {
selected.fixtures = true;
selected.readiness = true;
}
if (file.startsWith("tests/")) return;
if (SHARED_BOUNDARY.test(file)) {
full(`Shared boundary: ${file}`);
} else if (owners.length) {
if (file.startsWith("src/") || file.startsWith("bridge/"))
selected.runtime = true;
} else if (/^(src|bridge)\//.test(file)) {
// Unowned runtime sources keep the Linux x64 installed-package baseline;
// full qualification retains every native host.
selected.runtime = true;
reasons.push(`Unowned runtime source: ${file}`);
} else if (file.startsWith(".agents/skills/")) {
selected.runtime = true;
selected.docs = true;
} else {
full(`Unclassified input: ${file}`);
}
};
let files = [];
if (tier === "reused") {
reasons.push(
"Recent exact-SHA full qualification reused; no fresh provider observation",
);
} else if (tier === "full") {
full("Full baseline requested by event or ci:full label");
} else if (event === "pull_request" || event === "push") {
const { head } = request;
let base;
if (event === "pull_request") {
base = repository.mergeBase(request.base, head);
} else {
const candidate = request.base;
const { baselineReason } = request;
try {
if (!candidate || !/^[0-9a-f]{40}$/i.test(candidate))
throw new Error(
baselineReason || "No valid successful push baseline was found",
);
if (!repository.isAncestor(candidate, head))
throw new Error("Push baseline is not an ancestor");
base = candidate;
} catch {
full(
baselineReason ||
"No valid successful push baseline ancestor; selecting all lanes",
);
}
}
if (base) {
// Disable rename detection so both the removed and added paths participate.
files = repository.changedFiles(base, head);
for (const file of files) classifyFile(file, base, head);
}
}
selected.runtime ||= selected.package;
const linux = { os: "ubuntu-latest", platform: "linux", architecture: "x64" };
// macOS x64 is the slowest package host. Fast qualification omits it.
const intel =
tier === "full"
? [{ os: "macos-15-intel", platform: "darwin", architecture: "x64" }]
: [];
const matrix = {
include: selected.package
? [
linux,
{ os: "ubuntu-24.04-arm", platform: "linux", architecture: "arm64" },
{ os: "macos-15", platform: "darwin", architecture: "arm64" },
...intel,
]
: [linux],
};
const testSelection = planTestSelection({
files,
event,
tier,
code: selected.code,
// The checked-out revision is the one whose tests run. Script and
// configuration files are listed so shared script modules can be traced.
snapshot: {
list: () => repository.listFiles("HEAD", []),
read: (paths) => repository.readFiles("HEAD", paths),
},
});
return {
...selected,
tier,
matrix,
files,
reasons,
testSelection,
testShards: testShards(tier, testSelection),
};
}
/** Answer the plan's Git questions from the repository in `cwd`. */
export const gitRepository = (cwd = process.cwd()) => {
const git = (...args) =>
execFileSync("git", args, { cwd, encoding: "utf8" }).trimEnd();
return {
mergeBase: (base, head) => git("merge-base", base, head),
isAncestor: (ancestor, head) => {
try {
execFileSync("git", ["merge-base", "--is-ancestor", ancestor, head], {
cwd,
stdio: "ignore",
});
return true;
} catch {
return false;
}
},
// Disable rename detection so both the removed and added paths participate.
changedFiles: (base, head) =>
git("diff", "--name-only", "--no-renames", "-z", base, head)
.split("\0")
.filter(Boolean),
readFile: (revision, path) => git("show", `${revision}:${path}`),
listFiles: (revision, directories) =>
git("ls-tree", "-r", "-z", "--name-only", revision, "--", ...directories)
.split("\0")
.filter(Boolean),
// One batch process reads every requested blob.
readFiles: (revision, paths) => {
const output = execFileSync("git", ["cat-file", "--batch"], {
cwd,
input: paths.map((path) => `${revision}:${path}\n`).join(""),
maxBuffer: 512 * 1024 * 1024,
});
const contents = new Map();
let offset = 0;
for (const path of paths) {
const end = output.indexOf(10, offset);
const [, type, size] = output.toString("utf8", offset, end).split(" ");
if (type !== "blob")
throw new Error(`Git could not read ${revision}:${path}`);
const start = end + 1;
contents.set(
path,
output.toString("utf8", start, start + Number(size)),
);
offset = start + Number(size) + 1;
}
return contents;
},
};
};