* test(#2724): delete golden-install-parity fixtures, test, and generator Removes the 19 committed path->hash manifests, the two per-file size baselines, tests/golden-install-parity.test.cjs, and scripts/gen-golden-install-parity-zcode.cjs. These were pure functions of the source tree (ADR-2719); the differential attribution check (tests/emitted-attribution.test.cjs + tests/emitted-provenance.test.cjs) is now the sole gate for emitted-artifact propagation. tests/fixtures/install-tree/*.json and tests/golden-install-tree.test.cjs are unchanged (ADR-2719 section 7 exception). Follow-up commits fix the resulting bookkeeping: scripts/ci-test-scope.cjs's existence guard, .gitattributes, package.json scripts, the emitted-provenance totality guard's IO, the differential check's baseline acquisition, CI wiring to publish/restore the baseline artifact, and docs. * refactor(#2724): make the differential attribution check self-sufficient Three fixes required to delete the golden fixtures without breaking CI: - scripts/ci-test-scope.cjs: remove tests/golden-install-parity.test.cjs from the three rules that named it. #2759's missingRuleTestFiles guard hard-throws at module load if a rule names a test file absent from disk, which would break the changes job on every PR the moment the fixture-deletion commit landed. - tests/helpers/emitted-provenance.cjs: loadManifests() read the committed golden fixture directory. With that directory deleted at every future ref, this would throw at module load forever, taking the Phase 2 totality guard down with it. Rebuilt from real installer spawns (MANIFEST_FAMILIES + runMinimalInstall + buildParityManifest), the same shape emitted-runtime.cjs's currentManifests() already uses. - tests/emitted-attribution.test.cjs / tests/helpers/emitted-runtime.cjs: the real-tree test's baseline acquisition swaps from baselineManifestsAtRef(base) (git show at a ref that no longer carries fixtures) to resolveBaseline()'s documented precedence: env, then the on-disk cache, then an in-job build. The build fallback (buildBaselineAtRef, new) checks out base into a throwaway git worktree and runs the new scripts/gen-emitted-baseline.cjs there -- no npm ci needed, since bin/install.js and the test helper shells are Node-builtins-only. That script also publishes the baseline artifact from CI's push-to-next job (wired in a follow-up commit). * refactor(#2724): retire the merge-driver bridge and per-file size baselines The Phase 1 bridge (#2721) is retired now that the artifacts it guarded are deleted: scripts/git-merge-regen-driver.cjs, its test, and the 'setup:merge-driver' npm script are removed, and the .gitattributes merge=gsd-regen/linguist-generated block for the three deleted-path globs is dropped. tests/fixtures/install-tree/*.json keeps its normal merge behavior, unchanged (ADR-2719 section 7). scripts/update-size-baseline.cjs and its test are removed: their sole purpose was regenerating tests/workflow-size-baseline.json and tests/agent-size-baseline.json, both deleted. The 'size:baseline' npm script and its step in 'regen:derived' go with it. The per-file baseline describe blocks in tests/workflow-size-budget.test.cjs and tests/agent-size-budget.test.cjs are removed for the same reason; the independent loose-tier hard caps are untouched. The differential attribution check's size ratchet (tests/emitted-diff.cjs, already shipped in #2723) is the replacement anti-creep mechanism. 'npm run gen:golden' is replaced by 'npm run gen:install-tree', which keeps regenerating tests/fixtures/install-tree/*.json (the one artifact family ADR-2719 section 7 keeps committed); tests/golden-install-tree.test.cjs's error messages point at the new command name. tests/golden-parity-single-source.test.cjs's anti-divergence guard (#2266) is retargeted from the two deleted golden-parity consumers to their two replacements (tests/helpers/emitted-runtime.cjs and tests/helpers/emitted-provenance.cjs), which import buildParityManifest the same way — the divergence risk the guard exists for is unchanged. Also wires CI: a new publish-emitted-baseline job runs scripts/gen-emitted-baseline.cjs after a push to next and caches the result keyed on the sha; the test and test-full jobs restore that cache on pull_request events, keyed on the PR's base sha, and export GSD_EMITTED_BASELINE for tests/emitted-attribution.test.cjs's real-tree test to pick up. * docs(#2724): flip ADR-2719 to Accepted and update contributor docs Status: Proposed -> Accepted. Regenerated docs/adr/README.md index. CONTRIBUTING.md, docs/TESTING-SUITES.md, and CONTEXT.md (RULESET. EMITTED_ATTRIBUTION, RULESET.WORKFLOW_SIZE_BUDGET, RULESET. AGENT_SIZE_BUDGET, and the Emitted Artifact Provenance glossary entry) no longer point at the deleted golden-install-parity fixtures, size baselines, gen:golden, UPDATE_GOLDEN, or the setup:merge-driver / git-merge-regen-driver.cjs bridge. Editing shipped content now requires zero manual fixture regeneration, documented against the differential attribution check instead of the deleted commands. * docs(#2724): add changeset for removed golden-parity commands * fix(#2724): drop stale scripts/update-size-baseline.cjs glossary ref check-glossary-refs.cjs verifies every backtick-wrapped scripts/*.cjs token in CONTEXT.md resolves to a real file. The RULESET. EMITTED_ATTRIBUTION rewrite named the deleted script inside backticks, which the checker reads as a live reference, not historical prose. * test(#2724): retarget ci-test-scope tests off the deleted golden test tests/ci-test-scope.test.cjs asserted specific RULES entries select tests/golden-install-parity.test.cjs, and that every rule selecting it also selects both emitted gates. Both premises broke when the golden test was deleted (#2724): the deleted filename never re-appears in targeted_tests, and there was no longer a third file for the gates to travel alongside. Retargeted the two selection describe blocks to assert tests/emitted-provenance.test.cjs directly (the drift guard the golden gate's rules were retargeted to), and simplified the third block to assert the two emitted gates always travel together, without reference to the golden filename. * docs(#2724): repoint two contributor how-to guides at the differential check Both guides told contributors to regenerate a baseline against tests/golden-install-parity.test.cjs, which #2724 deletes. Repointed at the differential attribution check (tests/emitted-attribution.test.cjs, ADR-2719), which needs no manual regeneration step. * fix(#2724): repair phase6-capstone-conformance's deleted-baseline read An independent orthogonal review caught a real regression this branch introduced into a test file the branch's diff never touched: tests/phase6-capstone-conformance.test.cjs read tests/workflow-size-baseline.json (deleted earlier in this branch) with no fallback, so the whole suite would throw ENOENT the moment this branch landed. The test's actual intent — prove the host-loop workflow files are real, tracked, non-empty docs — is preserved by asserting the live byte count via the same shared counter (scripts/workflow-size.cjs) the size guards already use, instead of a committed snapshot. Also, from the same review: a stale doc comment in scripts/workflow-size.cjs still named the deleted scripts/update-size-baseline.cjs as a consumer, and buildBaselineAtRef's cleanup in tests/helpers/emitted-runtime.cjs left two fs.rmSync calls unguarded against masking the primary result/error, inconsistent with the try/catch already wrapping the git cleanup beside them. Both fixed. A doc comment was added to baselineFamilyNamesAtRef explaining why it (and its siblings) are kept despite having no production caller post-cutover — they still answer real questions about refs that predate the cutover. * fix(#2724): repair three real regressions found by remote verification 1. tests/emitted-provenance.test.cjs's two hostile-input tests (non-object manifest, unreadable fixture) drove loadManifests(tmp) and monkeypatched fs.readFileSync, both premised on the deleted fixture-directory read this branch already replaced with real installer spawns -- the negative assertions silently stopped firing. loadManifests() now accepts injected {families, install, build, clean} (defaulting to production values), giving the tests a real seam to drive a bad build result and a build failure through the ACTUAL loader instead of a reimplementation, and added coverage that clean() still runs on both paths. 2. .github/workflows/test.yml's two 'Export GSD_EMITTED_BASELINE' steps hardcoded shell: bash, which is wrong on windows-latest (native pwsh) and on test-full's macos-latest legs (native zsh per that job's own matrix) -- the repo's H1 shell policy (tests/policy-shell-pinning .test.cjs) caught it. Replaced the inline bash script with scripts/ci-export-emitted-baseline-env.cjs, a plain Node script: a bare 'node <path>' command line has no shell-specific syntax, so it runs correctly under bash, zsh, and pwsh without a shell override. tests/phase6-capstone-conformance.test.cjs's deleted-baseline read (caught by the same remote run, at a commit prior to this one) was already fixed in d0c3b1242 and is not touched here; verified still passing after these changes. * fix(#2724): revive ADR-1610's new-file size cap inside the differential An isolated review caught a real regression: deleting tests/workflow-size-baseline.json silently dropped NEW_FILE_CAP (ADR-1610 Decision point 3, the Codex project_doc_max_bytes anchor) with no successor. tests/helpers/emitted-diff.cjs's size ratchet already 'continue's past any file absent from sizeBaseline -- exactly the files this cap exists to bound -- so a brand-new workflow file sized 32,769-40,960 bytes passed CI clean and shipped, then risked silent truncation at the Codex anchor at runtime. ADR-1610 is Accepted and never referenced anywhere in this branch. Fix: NEW_FILE_CAP=32768 revived inside emitted-diff.cjs's own size-ratchet loop, keyed off the SAME hasOwnProperty(sizeBaseline, name) signal the growth check already computes -- 'new' is exactly 'present in sizeCurrent, absent from sizeBaseline'. Not ack-able, matching the tier hard caps it sits beside: the fix is extraction, not an acknowledgment entry. Documented, disclosed narrowing: the pure differential module cannot see XL_WORKFLOWS/LARGE_WORKFLOWS tiering (tests/workflow-size-budget.test.cjs's classification), so a legitimately large new file must extract rather than tier in, one release earlier than an existing file would need to. ADR-1610 itself is left unamended -- this restores its decision rather than re-litigating it. Also fixes a stale comment plus a redundant real 19-installer-spawn assertion left over from the pre-injection-seam version of tests/emitted-provenance.test.cjs's build-failure test, and annotates 3 of 4 stale golden-fixture citations in docs/reference/host-integration-capability-matrix.md as superseded (the 4th is an accurate historical PR narrative, left alone). * fix(#2724): repair three red CI defects on the golden-fixture cutover Windows-only provenance false attribution (defect A): the `hooks-built` provenance rule attributed `hooks/<name>.cmd` to itself. Those shims are Windows-only installer output (ensureCodexHooksJsonSessionStart / ensureCodexHooksJsonEvent, both in src/runtime-hooks-surface.cts) wrapping the same-named `.js` hook — no `.cmd` file is ever tracked in the repo, so the self-attribution resolved to a path that exists on no platform. Only windows-latest ever emits the key, so this only failed there. Fixed by special-casing `.cmd` inside the SAME `hooks-built` rule (not a dedicated rule) — a dedicated rule would match zero paths, and therefore report as a dead rule, on every non-Windows lane of the same totality guard. `sources` already supported per-match functions; `transforms` is extended to support the same shape so the attribution can vary by match within one rule. Baseline bootstrap was structurally impossible (defect B): `buildBaselineAtRef` ran `scripts/gen-emitted-baseline.cjs` from INSIDE the base-ref worktree, but that script is new in this PR and therefore absent at any base ref that predates it — every call failed closed with "Cannot find module". Fixed by running the PR checkout's own generator against the worktree via a new `--dir` parameter, decoupling "which copy of the script runs" from "which tree it measures" (`currentManifests`/`currentSizes` gained a `repoRoot` override, threaded down to `runMinimalInstall`'s new `installScript` override). This is not just a bootstrap fix: a differential needs ONE measurement schema applied to both sides, or the two stop being comparable the moment that schema evolves — running each side's own copy would silently reintroduce that risk. Verified locally end-to-end against real origin/next: resolves a valid {version, sha, manifests, sizes} artifact with the correct sha and no leaked worktree. Changeset placeholder (defect C): `pr: 0` -> `pr: 2767`, which is what let docs-lint evaluate the fragment for the first time; it already passes (docs/TESTING-SUITES.md and friends already document the removed scripts). Also fixed while in this file: an eslint no-unused-vars warning surfaced by the changed lint run (unused `cleanup` import in tests/emitted-provenance.test.cjs). Added regression coverage for both A and B: a cross-platform spot-check that drives the real hooks-built rule against `.cmd` keys directly (not through a real Windows install), and a real-tree test that drives buildBaselineAtRef against a base ref verified (via git cat-file) to lack the generator, both skipping honestly rather than false-passing when their precondition does not hold. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01W5kQs6ZufZDySC6zDJfYP6 * fix(#2724): repair false .cmd byte-provenance and a permanently-skipping regression test Two isolated-review findings on PR #2767: - `hooks-built`'s `.cmd` branch attributed the Windows shim's bytes to the wrapped `hooks/<name>.js` script, asserting a byte-provenance link that does not exist — traced against buildCodexHookWindowsShimIR (src/runtime-hooks-surface.cts), only the script's NAME (a literal in that same file) flows into the .cmd bytes, never its content. Point `sources` at HOOKS_WINDOWS_SHIM_SRC instead, matching the code-derived convention used elsewhere in the table. Since `sources` is checked before `transforms` in the differential, the wrong mapping silently excused any .cmd byte movement caused by editing the wrapped .js file. - The `buildBaselineAtRef` regression test skipped unless a resolvable base ref still lacked scripts/gen-emitted-baseline.cjs — true only until this PR merges, after which every base ref carries the file and the test skips forever with zero ongoing coverage. Rebuilt hermetically: synthesize the missing-generator condition in-place via git plumbing (a throwaway commit, child of HEAD, with just that one file removed from a scratch index), never touching the real working tree, HEAD, or index, and never depending on ambient history or remotes. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01W5kQs6ZufZDySC6zDJfYP6 * fix(#2724): tolerate the remote runner's dubious-ownership git mount in the emitted baseline path The runner container mounts the repo at a path owned by a different uid than the process running the suite, so git's dubious-ownership protection refuses every git operation there. GitHub Actions never hits this because actions/checkout registers the workspace as safe automatically; this runner's container does not. buildBaselineAtRef is the production build-fallback the sole remaining emitted gate depends on (resolveBaseline's in-job-build leg), not just a test helper, so the fix is in the shared git() wrapper (emitted-runtime.cjs) that every caller — resolveChangedPaths, resolveBase, buildBaselineAtRef's worktree add/remove/prune, and the hermetic regression test added in the prior commit — funnels through, plus gen-emitted-baseline.cjs's own rev-parse (now reusing that same wrapper instead of a second execFileSync, so the fix has one source of truth). Each call declares -c safe.directory=<the exact directory it already operates on>, never the * wildcard. Audited every other helper on this surface (emitted-diff.cjs, emitted-baseline.cjs, install-shared.cjs) for the same gap: none of them shell out to git at all. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01W5kQs6ZufZDySC6zDJfYP6 --------- Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>
This commit is contained in:
@@ -34,6 +34,29 @@ const { attributeEmittedPath } = require('./emitted-provenance.cjs');
|
||||
* shape is public the moment it ships (Hyrum). Loosening later is easy; tightening is not. */
|
||||
const ACK_VERSION = 1;
|
||||
|
||||
/**
|
||||
* A brand-new workflow/agent file — absent from the baseline, present now — must
|
||||
* still stay under the Codex `project_doc_max_bytes` anchor (ADR-1610 Decision
|
||||
* point 3, `NEW_FILE_CAP` in the pre-#2724 tests/workflow-size-budget.test.cjs).
|
||||
*
|
||||
* #2724 (ADR-2719 Phase 4) deleted the committed per-file baseline that cap used to
|
||||
* key "not yet baselined" off of. The size ratchet below (ADR-2719 §4) already
|
||||
* computes the exact same signal for a different reason — a name present in
|
||||
* `sizeCurrent` but absent from `sizeBaseline` IS "new" by construction, the same
|
||||
* definition ADR-1610 used — so no new baseline, git diff, or CI wiring is needed to
|
||||
* revive the cap; it only needed a home once the old one was deleted.
|
||||
*
|
||||
* This is a HARD cap, not ack-able, matching the tier hard caps it sits beside
|
||||
* (XL/LARGE/DEFAULT in tests/workflow-size-budget.test.cjs): the fix for exceeding it
|
||||
* is extraction, never an acknowledgment entry. Not exempted by explicit XL/LARGE
|
||||
* tiering the way the original test-file version was — this module is intentionally
|
||||
* pure and has no access to that classification (tests/workflow-size-budget.test.cjs's
|
||||
* XL_WORKFLOWS/LARGE_WORKFLOWS sets) — so a legitimately large NEW file must be split
|
||||
* via the same lazy-extraction pattern the tier caps already require, one release
|
||||
* earlier than an existing file would need to. Documented narrowing, not a silent one.
|
||||
*/
|
||||
const NEW_FILE_CAP = 32768;
|
||||
|
||||
/**
|
||||
* Does a changed repo path satisfy a provenance `sources` entry?
|
||||
*
|
||||
@@ -115,7 +138,8 @@ function parseAck(doc, { source = 'emitted-drift-ack.json' } = {}) {
|
||||
*
|
||||
* @returns {{
|
||||
* moved: number, attributed: Array, unattributable: Array, acked: Array,
|
||||
* removed: Array, grown: Array, shrunk: Array, staleAcks: string[], errors: string[], ok: boolean
|
||||
* removed: Array, grown: Array, shrunk: Array, newFileCapExceeded: Array,
|
||||
* staleAcks: string[], errors: string[], ok: boolean
|
||||
* }}
|
||||
*/
|
||||
function diffEmitted({
|
||||
@@ -240,9 +264,17 @@ function diffEmitted({
|
||||
// report a size-growth ack as stale.
|
||||
const grown = [];
|
||||
const shrunk = [];
|
||||
const newFileCapExceeded = [];
|
||||
if (sizeBaseline && sizeCurrent) {
|
||||
for (const name of Object.keys(sizeCurrent).sort()) {
|
||||
if (!Object.prototype.hasOwnProperty.call(sizeBaseline, name)) continue;
|
||||
if (!Object.prototype.hasOwnProperty.call(sizeBaseline, name)) {
|
||||
// No baseline entry: this file is NEW. No `from` to diff against, so the
|
||||
// growth ratchet does not apply — but the absolute new-file cap does
|
||||
// (ADR-1610 Decision point 3). Never ack-able; see NEW_FILE_CAP's doc comment.
|
||||
const bytes = sizeCurrent[name];
|
||||
if (bytes > NEW_FILE_CAP) newFileCapExceeded.push({ name, bytes, cap: NEW_FILE_CAP });
|
||||
continue;
|
||||
}
|
||||
const from = sizeBaseline[name];
|
||||
const to = sizeCurrent[name];
|
||||
if (to > from) {
|
||||
@@ -268,7 +300,8 @@ function diffEmitted({
|
||||
const ok = errors.length === 0
|
||||
&& unattributable.length === 0
|
||||
&& unackedGrowth.length === 0
|
||||
&& staleAcks.length === 0;
|
||||
&& staleAcks.length === 0
|
||||
&& newFileCapExceeded.length === 0;
|
||||
|
||||
return {
|
||||
moved,
|
||||
@@ -278,6 +311,7 @@ function diffEmitted({
|
||||
removed,
|
||||
grown,
|
||||
shrunk,
|
||||
newFileCapExceeded,
|
||||
staleAcks,
|
||||
errors,
|
||||
ok,
|
||||
@@ -328,6 +362,14 @@ function formatReport(result, { sampleLimit = 20 } = {}) {
|
||||
);
|
||||
}
|
||||
|
||||
if (result.newFileCapExceeded.length) {
|
||||
const list = result.newFileCapExceeded.slice(0, sampleLimit)
|
||||
.map((f) => ` ${f.name} is ${f.bytes} bytes — exceeds the ${f.cap}-byte new-file cap (ADR-1610)`);
|
||||
parts.push(
|
||||
`${result.newFileCapExceeded.length} new file(s) exceed the new-file cap (extract, not ack):\n${list.join('\n')}`,
|
||||
);
|
||||
}
|
||||
|
||||
if (result.staleAcks.length) {
|
||||
parts.push(
|
||||
`${result.staleAcks.length} stale acknowledgment(s) — the ripple they explained is gone, ` +
|
||||
@@ -341,6 +383,7 @@ function formatReport(result, { sampleLimit = 20 } = {}) {
|
||||
|
||||
module.exports = {
|
||||
ACK_VERSION,
|
||||
NEW_FILE_CAP,
|
||||
sourceSatisfiedBy,
|
||||
parseAck,
|
||||
diffEmitted,
|
||||
|
||||
@@ -38,13 +38,12 @@
|
||||
* risk ADR-2719 records. The spot-check tests pin this pair.
|
||||
*/
|
||||
|
||||
const fs = require('node:fs');
|
||||
const path = require('node:path');
|
||||
|
||||
const REPO_ROOT = path.join(__dirname, '..', '..');
|
||||
const FIXTURES_DIR = path.join(REPO_ROOT, 'tests', 'fixtures', 'golden-install-parity');
|
||||
|
||||
const { MANIFEST_FAMILIES } = require('./install-shared.cjs');
|
||||
const { cleanup } = require('../helpers.cjs');
|
||||
const { MANIFEST_FAMILIES, runMinimalInstall, buildParityManifest } = require('./install-shared.cjs');
|
||||
|
||||
/**
|
||||
* Number of runtime manifests the guard expects to cover. Asserted, so a glob that
|
||||
@@ -76,6 +75,18 @@ const COMMANDS_SRC = 'commands/gsd';
|
||||
* buildClinePreToolUseHook). */
|
||||
const CLINE_BODY_SRC = 'src/runtime-hooks-surface.cts';
|
||||
|
||||
/**
|
||||
* Installer source file that GENERATES the Windows-only `hooks/<name>.cmd` shim
|
||||
* wrapping a Codex hook's `.js` script (#3426). Same physical file as
|
||||
* CLINE_BODY_SRC — kept as its own named constant because the two constants
|
||||
* attribute unrelated transform code that happens to live in one file:
|
||||
* buildCodexHookWindowsShimIR / ensureCodexHooksJsonSessionStart /
|
||||
* ensureCodexHooksJsonEvent (verified via Memtrace: these are the ONLY writers
|
||||
* of a `.cmd` file anywhere in the installer — no other runtime's hook surface
|
||||
* builds one).
|
||||
*/
|
||||
const HOOKS_WINDOWS_SHIM_SRC = 'src/runtime-hooks-surface.cts';
|
||||
|
||||
/** Installer source file that emits the Hermes skill-category DESCRIPTION.md
|
||||
* (writeHermesCategoryDescription) as a code literal. */
|
||||
const INSTALLER_SRC = 'bin/install.js';
|
||||
@@ -199,10 +210,10 @@ function nativePluginDescriptor(runtime) {
|
||||
// `roots` — emitted prefixes this rule applies under (null = match `rel` whole)
|
||||
// `pattern` — matched against the root-stripped tail (or whole `rel` when roots is null)
|
||||
// `sources` — (match, ctx) => string[] of repo-relative paths; [] only for `synthesized`
|
||||
// `transforms` — OPTIONAL string[] of repo paths implementing the TRANSFORM that
|
||||
// produces this rule's emitted bytes (#2757). A `derived`/`code-derived`
|
||||
// artifact's bytes can move for a second reason `sources` alone cannot
|
||||
// express: the transform code changed, not the source it derives from.
|
||||
// `transforms` — OPTIONAL repo paths implementing the TRANSFORM that produces this
|
||||
// rule's emitted bytes (#2757). A `derived`/`code-derived` artifact's
|
||||
// bytes can move for a second reason `sources` alone cannot express:
|
||||
// the transform code changed, not the source it derives from.
|
||||
// Phase 3 (emitted-diff.cjs) attributes a moved path if the diff
|
||||
// satisfies EITHER `sources` OR `transforms`, reusing the same
|
||||
// `sourceSatisfiedBy` matcher for both so exact/prefix semantics stay
|
||||
@@ -210,6 +221,15 @@ function nativePluginDescriptor(runtime) {
|
||||
// `transforms` — enforced by `assertNoIdentityTransforms` below — because
|
||||
// an identity copy's bytes can only move when its source moves; that is
|
||||
// what makes it an identity.
|
||||
// May be a plain `string[]` (the common case) OR a `(match, ctx) => string[]`
|
||||
// function, mirroring `sources`, for a rule whose transform attribution
|
||||
// depends on WHICH emitted path matched — e.g. `hooks-built` below, where
|
||||
// only the `.cmd` shim sub-family has transform code at all; a static
|
||||
// array would either miss that or (worse) falsely blanket-attribute every
|
||||
// plain hook file to the shim generator that cannot move its bytes. A
|
||||
// dedicated rule for the `.cmd` sub-family was considered and rejected: it
|
||||
// is emitted ONLY on win32 (see `hooks-built` below), so on every non-
|
||||
// Windows CI lane it would match zero paths and fail as a "dead" rule.
|
||||
//
|
||||
// Rule ORDER CARRIES NO SEMANTICS. Exactly-one matching is enforced, so rules are
|
||||
// mutually exclusive by construction and the table reads correctly in any order.
|
||||
@@ -294,6 +314,17 @@ const PROVENANCE_RULES = [
|
||||
},
|
||||
{
|
||||
id: 'hooks-built',
|
||||
// `kind` is a single scalar per rule, and this rule's majority sub-family
|
||||
// (plain built hook files) is genuinely `derived` from hooks/<name> via
|
||||
// scripts/build-hooks.js. The `.cmd` shim sub-family is code-derived (see
|
||||
// the pattern-comment and `sources` comment below), but that does not
|
||||
// change this rule's `kind` — a per-match `kind` would need a dedicated
|
||||
// rule, which is exactly what was rejected above (dead on non-Windows CI
|
||||
// lanes). The `.cmd` branch's real (code-derived) provenance is instead
|
||||
// carried precisely by `sources`/`transforms` both pointing at
|
||||
// HOOKS_WINDOWS_SHIM_SRC — `assertNoIdentityTransforms` only constrains
|
||||
// `kind: 'identity'` rules, so a `derived` rule with a non-empty
|
||||
// `transforms` here is unaffected by that guard.
|
||||
kind: 'derived',
|
||||
roots: HOOKS_ROOTS,
|
||||
// Emitted from hooks/dist/, which scripts/build-hooks.js builds from hooks/.
|
||||
@@ -301,8 +332,32 @@ const PROVENANCE_RULES = [
|
||||
// Excludes Copilot's hook-registration JSON (next rule) — that is a code
|
||||
// literal, not a built script, and attributing it here resolved to a
|
||||
// nonexistent `hooks/gsd-session.json`.
|
||||
//
|
||||
// `.cmd` shims are a SEPARATE, Windows-only emission path folded into this
|
||||
// SAME rule rather than a dedicated one (see the `transforms` doc above for
|
||||
// why a standalone rule would go dead on non-Windows CI lanes). Verified via
|
||||
// Memtrace: `hooks/<name>.cmd` is written at install time by
|
||||
// ensureCodexHooksJsonSessionStart / ensureCodexHooksJsonEvent (both gated
|
||||
// on `platform === 'win32'`) via buildCodexHookWindowsShimIR
|
||||
// (HOOKS_WINDOWS_SHIM_SRC, src/runtime-hooks-surface.cts). The `.cmd` bytes
|
||||
// are `@ECHO OFF\r\n@SETLOCAL\r\n@<runner> <script> %*\r\n` — built from the
|
||||
// install-time interpreter token and the absolute install path, plus a
|
||||
// hardcoded literal filename (e.g. `gsd-check-update.js`) baked into that
|
||||
// same source file. The wrapped `.js` file's NAME flows into the `.cmd`
|
||||
// bytes; its CONTENT never does — see the `sources` comment below for why
|
||||
// that rules out attributing to `hooks/<name>.js`.
|
||||
pattern: /^(?!gsd-session\.json$).+$/,
|
||||
sources: (m) => [`hooks/${m[0]}`],
|
||||
// `.cmd` shim bytes are code-derived (a literal template + the install-time
|
||||
// interpreter/path tokens in HOOKS_WINDOWS_SHIM_SRC) — the wrapped `.js`
|
||||
// file's NAME flows in (as a hardcoded literal filename inside that same
|
||||
// source file), but its CONTENT never does, so attributing `sources` to
|
||||
// `hooks/<name>.js` would be a false byte-provenance claim. Point `sources`
|
||||
// at the same file as `transforms`, matching the `code-derived` convention
|
||||
// used elsewhere in this table (copilot-hook-registration, cline-rules-
|
||||
// code-derived, hermes-category-description). The redundancy between
|
||||
// `sources` and `transforms` here is harmless — the mis-attribution was not.
|
||||
sources: (m) => [m[0].endsWith('.cmd') ? HOOKS_WINDOWS_SHIM_SRC : `hooks/${m[0]}`],
|
||||
transforms: (m) => (m[0].endsWith('.cmd') ? [HOOKS_WINDOWS_SHIM_SRC] : []),
|
||||
},
|
||||
{
|
||||
id: 'copilot-hook-registration',
|
||||
@@ -519,13 +574,25 @@ function attributeEmittedPath(rel, runtime, rules = PROVENANCE_RULES) {
|
||||
);
|
||||
}
|
||||
const { rule, match } = hits[0];
|
||||
let transforms;
|
||||
if (typeof rule.transforms === 'function') {
|
||||
transforms = rule.transforms(match, { rel, runtime });
|
||||
if (!Array.isArray(transforms)) {
|
||||
throw new Error(
|
||||
`emitted-provenance: rule "${rule.id}" transforms(match, ctx) must return an array, ` +
|
||||
`got ${typeof transforms} for ${rel}`,
|
||||
);
|
||||
}
|
||||
} else {
|
||||
// #2757: always an array, never undefined, so callers (Phase 3's diffEmitted)
|
||||
// never need a defensive `|| []`.
|
||||
transforms = Array.isArray(rule.transforms) ? rule.transforms : [];
|
||||
}
|
||||
return {
|
||||
ruleId: rule.id,
|
||||
kind: rule.kind,
|
||||
sources: rule.sources(match, { rel, runtime }),
|
||||
// #2757: always an array, never undefined, so callers (Phase 3's diffEmitted)
|
||||
// never need a defensive `|| []`.
|
||||
transforms: Array.isArray(rule.transforms) ? rule.transforms : [],
|
||||
transforms,
|
||||
};
|
||||
}
|
||||
|
||||
@@ -540,12 +607,18 @@ function attributeEmittedPath(rel, runtime, rules = PROVENANCE_RULES) {
|
||||
* future authoring mistake) and exported so tests can drive it against an injected
|
||||
* corrupted table, matching this module's existing injectable-table convention.
|
||||
*
|
||||
* A function-valued `transforms` on an identity rule is rejected outright (without
|
||||
* invoking it) — an identity rule has no legitimate match-dependent transform story
|
||||
* by definition, so allowing the function form there would just be a slower path to
|
||||
* the same false-attribution risk this guard exists to catch.
|
||||
*
|
||||
* @param {Array} rules rule table (injectable)
|
||||
* @throws when any identity rule declares a non-empty transforms array
|
||||
* @throws when any identity rule declares a non-empty transforms array or a function
|
||||
*/
|
||||
function assertNoIdentityTransforms(rules = PROVENANCE_RULES) {
|
||||
const violators = rules.filter(
|
||||
(r) => r.kind === 'identity' && Array.isArray(r.transforms) && r.transforms.length > 0,
|
||||
(r) => r.kind === 'identity'
|
||||
&& (typeof r.transforms === 'function' || (Array.isArray(r.transforms) && r.transforms.length > 0)),
|
||||
);
|
||||
if (violators.length) {
|
||||
throw new Error(
|
||||
@@ -561,39 +634,60 @@ function assertNoIdentityTransforms(rules = PROVENANCE_RULES) {
|
||||
// until some test happens to exercise the corrupted rule.
|
||||
assertNoIdentityTransforms(PROVENANCE_RULES);
|
||||
|
||||
// ─── Fixture loading ──────────────────────────────────────────────────────────
|
||||
// ─── Manifest loading ─────────────────────────────────────────────────────────
|
||||
|
||||
/**
|
||||
* Load every committed golden-parity manifest as {runtime, rel, keys}.
|
||||
* Rejects a manifest whose JSON parses but is not a plain object — treating `0`,
|
||||
* Build the emitted manifest set for every family, for real — one installer spawn
|
||||
* per runtime, exactly as `tests/helpers/emitted-runtime.cjs`'s `currentManifests()`
|
||||
* does for the differential check's CURRENT side.
|
||||
*
|
||||
* Pre-#2724 this read the committed `tests/fixtures/golden-install-parity/*.json`
|
||||
* snapshots. Phase 4 (ADR-2719) deletes those fixtures entirely — not just at HEAD,
|
||||
* at every future ref — so a fixture-reading implementation would throw at module
|
||||
* load on every commit from here forward, taking the Phase 2 totality guard down
|
||||
* with it (the totality guard is supposed to be the *replacement* for the golden
|
||||
* check, not another casualty of deleting it). Building from real installs instead
|
||||
* makes this the same honest, no-fixture-dependency shape as the differential's
|
||||
* current-tree side, and it needs no `fixturesDir` parameter because there is no
|
||||
* longer a fixture directory to point it at.
|
||||
*
|
||||
* Rejects a manifest whose build result is not a plain object — treating `0`,
|
||||
* `"s"`, `[]`, `null` or `true` as "no keys" would let the whole guard pass
|
||||
* vacuously on a corrupt fixture.
|
||||
* vacuously on a corrupt build.
|
||||
*/
|
||||
function loadManifests(fixturesDir = FIXTURES_DIR) {
|
||||
const files = fs.readdirSync(fixturesDir).filter((f) => f.endsWith('.json')).sort();
|
||||
return files.map((file) => {
|
||||
const full = path.join(fixturesDir, file);
|
||||
const raw = fs.readFileSync(full, 'utf8');
|
||||
if (raw.trim() === '') {
|
||||
throw new Error(`emitted-provenance: fixture ${file} is empty`);
|
||||
}
|
||||
/**
|
||||
* @param {object} [deps] injected for testability (hostile-input coverage below) —
|
||||
* production callers use the defaults.
|
||||
* @param {Array} [deps.families] MANIFEST_FAMILIES by default
|
||||
* @param {function} [deps.install] runMinimalInstall by default
|
||||
* @param {function} [deps.build] buildParityManifest by default
|
||||
* @param {function} [deps.clean] cleanup by default
|
||||
*/
|
||||
function loadManifests({
|
||||
families = MANIFEST_FAMILIES,
|
||||
install = runMinimalInstall,
|
||||
build = buildParityManifest,
|
||||
clean = cleanup,
|
||||
} = {}) {
|
||||
return families.map(({ name, runtime, scope }) => {
|
||||
const { configDir, root } = install({ runtime, scope });
|
||||
let parsed;
|
||||
try {
|
||||
parsed = JSON.parse(raw);
|
||||
} catch (err) {
|
||||
throw new Error(`emitted-provenance: fixture ${file} is not valid JSON: ${err.message}`);
|
||||
parsed = build(configDir, root);
|
||||
} finally {
|
||||
clean(root);
|
||||
}
|
||||
if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
|
||||
throw new Error(
|
||||
`emitted-provenance: fixture ${file} must be a JSON object of path->hash, ` +
|
||||
`emitted-provenance: build for ${name} must produce an object of path->hash, ` +
|
||||
`got ${Array.isArray(parsed) ? 'array' : typeof parsed}`,
|
||||
);
|
||||
}
|
||||
return {
|
||||
file,
|
||||
// `claude-local.json` is the claude runtime at local scope; the descriptor
|
||||
// lookup keys on the runtime id, not the fixture name.
|
||||
runtime: file.replace(/\.json$/, '').replace(/-local$/, ''),
|
||||
file: `${name}.json`,
|
||||
// `claude-local` is the claude runtime at local scope; the descriptor lookup
|
||||
// keys on the runtime id, not the family name.
|
||||
runtime,
|
||||
keys: Object.keys(parsed),
|
||||
};
|
||||
});
|
||||
@@ -668,7 +762,6 @@ function assertTotality(manifests, rules = PROVENANCE_RULES, sampleLimit = 10) {
|
||||
|
||||
module.exports = {
|
||||
EXPECTED_MANIFEST_COUNT,
|
||||
FIXTURES_DIR,
|
||||
PROVENANCE_RULES,
|
||||
SKILLS_ROOTS,
|
||||
KIMI_ROOT_AGENT_SRC,
|
||||
@@ -677,6 +770,7 @@ module.exports = {
|
||||
HOOKS_ROOTS,
|
||||
COMMANDS_SRC,
|
||||
CLINE_BODY_SRC,
|
||||
HOOKS_WINDOWS_SHIM_SRC,
|
||||
INSTALLER_SRC,
|
||||
stripSkillPrefix,
|
||||
nativePluginDescriptor,
|
||||
|
||||
@@ -31,7 +31,9 @@
|
||||
*/
|
||||
|
||||
const fs = require('node:fs');
|
||||
const os = require('node:os');
|
||||
const path = require('node:path');
|
||||
const crypto = require('node:crypto');
|
||||
const { execFileSync } = require('node:child_process');
|
||||
|
||||
const { cleanup } = require('../helpers.cjs');
|
||||
@@ -227,8 +229,33 @@ function reconcileFamilies({
|
||||
* macOS CI silently stops reporting. */
|
||||
const GIT_TIMEOUT_MS = 30_000;
|
||||
|
||||
/**
|
||||
* Prepend `-c safe.directory=<dir>` to a git argv.
|
||||
*
|
||||
* The remote test-runner container mounts the repository at a path owned by a
|
||||
* different uid than the process running the suite; git's dubious-ownership
|
||||
* protection then refuses EVERY operation there with "detected dubious ownership"
|
||||
* (#2767 — surfaced when a previously-always-skipping regression test started
|
||||
* actually executing in that container and its very first `git rev-parse HEAD`
|
||||
* failed closed). GitHub Actions never hits this because `actions/checkout`
|
||||
* registers the workspace as a safe directory automatically; this runner's
|
||||
* container does not. `buildBaselineAtRef` is the PRODUCTION build-fallback path
|
||||
* the sole remaining emitted gate depends on (`resolveBaseline`'s in-job-build leg,
|
||||
* ADR-2719 §5) — not just a test helper — so the fix belongs here, not papered
|
||||
* over by skipping the test that found it.
|
||||
*
|
||||
* Declares the SPECIFIC resolved directory each call site already operates on —
|
||||
* never the `*` wildcard, which would mark every repository on the machine safe —
|
||||
* so this cannot broaden trust beyond the one path the caller already intends to
|
||||
* touch. Every git call in this module (and its production/test callers) passes
|
||||
* through here so the fix cannot silently drift per call site.
|
||||
*/
|
||||
function safeDirArgs(dir) {
|
||||
return ['-c', `safe.directory=${path.resolve(dir)}`];
|
||||
}
|
||||
|
||||
function git(args, { cwd = REPO_ROOT } = {}) {
|
||||
return execFileSync('git', args, {
|
||||
return execFileSync('git', [...safeDirArgs(cwd), ...args], {
|
||||
cwd,
|
||||
encoding: 'utf8',
|
||||
timeout: GIT_TIMEOUT_MS,
|
||||
@@ -316,6 +343,15 @@ function resolveBase(env = process.env) {
|
||||
* current registry, so the loop never asks the base ref for it, `baseline` silently omits
|
||||
* a family that genuinely existed, and the dropped-family check can never fire. Asking
|
||||
* the ref what it actually contains is the only way the "before" side is really "before".
|
||||
*
|
||||
* NOT called by the real-tree test's production path as of #2724 (ADR-2719 Phase 4) —
|
||||
* `buildBaselineAtRef` + `resolveBaseline()` replaced it, since the fixture directory
|
||||
* this reads no longer exists at any ref from the cutover commit forward. Kept
|
||||
* (alongside `baselineManifestsAtRef`/`baselineSizesAtRef` below) because it still
|
||||
* answers a real question for a REF THAT PREDATES THE CUTOVER — bisecting into the
|
||||
* dual-run window (#2723) or earlier — and its own regression test below pins a real
|
||||
* property (the baseline must reflect the ref, not the current registry) that would
|
||||
* otherwise go untested.
|
||||
*/
|
||||
function baselineFamilyNamesAtRef(base, { cwd = REPO_ROOT } = {}) {
|
||||
let out;
|
||||
@@ -366,6 +402,111 @@ function baselineManifestsAtRef(base = 'origin/next') {
|
||||
return found === 0 ? null : manifests;
|
||||
}
|
||||
|
||||
/**
|
||||
* Build the baseline artifact at `ref` FOR REAL — a throwaway `git worktree` checked
|
||||
* out at `ref`, MEASURED by `cwd`'s (the calling checkout's) OWN
|
||||
* `scripts/gen-emitted-baseline.cjs` (#2724/#2767, ADR-2719 §5's "in-job build at
|
||||
* origin/next" fallback).
|
||||
*
|
||||
* ── Why the generator runs from `cwd`, not from the worktree ─────────────────────
|
||||
* `scripts/gen-emitted-baseline.cjs` was ADDED by the same PR that deleted the golden
|
||||
* fixtures this fallback used to read instead (#2724). A base ref that predates that PR
|
||||
* — which is every `next` this fallback is ever asked to measure, since the fallback
|
||||
* only runs on a cache miss for a ref that has not been through the publish job yet —
|
||||
* therefore never has the script at `<worktreeDir>/scripts/gen-emitted-baseline.cjs`,
|
||||
* and invoking it there fails closed with `Cannot find module` on every single call: the
|
||||
* fallback could never bootstrap. Running `cwd`'s copy instead, with `--dir worktreeDir`
|
||||
* telling it WHICH tree's installer to measure, isn't merely the workaround for that —
|
||||
* it is the more correct differential semantics regardless: a diff needs ONE measurement
|
||||
* schema applied to BOTH sides, or the sides stop being comparable the moment that
|
||||
* schema evolves (a new exclusion rule, a new manifest family) between the two commits.
|
||||
* Letting each side measure itself with its own, potentially different, version of the
|
||||
* script would silently reintroduce exactly that incomparability.
|
||||
*
|
||||
* This is the slow path, used only on a `resolveBaseline()` cache miss. The worktree
|
||||
* needs no `npm ci`: `bin/install.js` and the `tests/helpers/*.cjs` real-tree shells are
|
||||
* all Node-builtins-only (CONTRIBUTING.md's "No external dependencies in core"). It DOES
|
||||
* need `npm run build:lib` run there first, though — `tests/helpers/install-shared.cjs`
|
||||
* requires the TSC-COMPILED `gsd-core/bin/lib/runtime-artifact-layout.cjs`, which is
|
||||
* gitignored, not committed, and therefore absent from a bare worktree checkout, and
|
||||
* `<worktreeDir>/bin/install.js` (spawned BY `cwd`'s generator via `currentManifests`'s
|
||||
* `repoRoot` override) needs its own compiled copy alongside it, not `cwd`'s. `node_modules`
|
||||
* is symlinked in from the calling checkout (never copied — `npm ci` inside every
|
||||
* fallback build would make an already-slow path far slower) so `tsc` is available
|
||||
* without a second install; the worktree's OWN `src/*.cts` and `tsconfig.build.json`
|
||||
* are what gets compiled, so the MEASURED installer reflects `ref`, not `cwd`'s tree —
|
||||
* only the measurement CODE (the generator, install-shared.cjs, emitted-runtime.cjs)
|
||||
* comes from `cwd`.
|
||||
*
|
||||
* Every subprocess is bounded. The worktree is always removed, success or failure —
|
||||
* a leaked worktree would poison `git worktree list` for every subsequent run in the
|
||||
* same checkout (CI runners reuse the same clone across jobs in some configurations).
|
||||
*
|
||||
* @param {string} ref the ref/sha to build at (e.g. `origin/next`, a 40-hex sha)
|
||||
* @param {object} [o]
|
||||
* @param {string} [o.cwd] repo to run `git worktree` from AND whose generator measures it
|
||||
* @returns {object} the parsed baseline artifact ({version, sha, manifests, sizes})
|
||||
*/
|
||||
function buildBaselineAtRef(ref, { cwd = REPO_ROOT } = {}) {
|
||||
const worktreeDir = fs.mkdtempSync(path.join(os.tmpdir(), 'gsd-emitted-baseline-wt-'));
|
||||
// mkdtempSync already created the directory; `git worktree add` requires the
|
||||
// target to not exist (or be empty) — remove it and let git recreate it.
|
||||
fs.rmdirSync(worktreeDir);
|
||||
const outFile = path.join(os.tmpdir(), `gsd-emitted-baseline-out-${crypto.randomBytes(8).toString('hex')}.json`);
|
||||
|
||||
const WORKTREE_TIMEOUT_MS = 60_000;
|
||||
const BUILD_LIB_TIMEOUT_MS = 180_000;
|
||||
const BUILD_TIMEOUT_MS = 300_000;
|
||||
|
||||
try {
|
||||
execFileSync('git', [...safeDirArgs(cwd), 'worktree', 'add', '--detach', worktreeDir, ref], {
|
||||
cwd, encoding: 'utf8', timeout: WORKTREE_TIMEOUT_MS, stdio: ['ignore', 'pipe', 'pipe'],
|
||||
});
|
||||
|
||||
const sharedNodeModules = path.join(cwd, 'node_modules');
|
||||
if (fs.existsSync(sharedNodeModules)) {
|
||||
fs.symlinkSync(sharedNodeModules, path.join(worktreeDir, 'node_modules'), 'dir');
|
||||
}
|
||||
|
||||
execFileSync('npm', ['run', 'build:lib'], {
|
||||
cwd: worktreeDir, encoding: 'utf8', timeout: BUILD_LIB_TIMEOUT_MS, stdio: ['ignore', 'pipe', 'pipe'],
|
||||
});
|
||||
|
||||
// Run `cwd`'s OWN generator (not the worktree's — see the function doc for why),
|
||||
// pointed at the worktree as the tree to measure.
|
||||
execFileSync(
|
||||
process.execPath,
|
||||
[path.join(cwd, 'scripts', 'gen-emitted-baseline.cjs'), '--dir', worktreeDir, '--out', outFile],
|
||||
{ cwd, encoding: 'utf8', timeout: BUILD_TIMEOUT_MS, stdio: ['ignore', 'pipe', 'pipe'] },
|
||||
);
|
||||
|
||||
const raw = fs.readFileSync(outFile, 'utf8');
|
||||
return JSON.parse(raw);
|
||||
} finally {
|
||||
try {
|
||||
execFileSync('git', [...safeDirArgs(cwd), 'worktree', 'remove', '--force', worktreeDir], {
|
||||
cwd, encoding: 'utf8', timeout: WORKTREE_TIMEOUT_MS, stdio: ['ignore', 'pipe', 'pipe'],
|
||||
});
|
||||
} catch {
|
||||
// Best-effort: the checkout may already be gone (e.g. the build step failed
|
||||
// before writing anything). Prune stale admin data rather than leaving it.
|
||||
try {
|
||||
execFileSync('git', [...safeDirArgs(cwd), 'worktree', 'prune'], {
|
||||
cwd, encoding: 'utf8', timeout: WORKTREE_TIMEOUT_MS, stdio: ['ignore', 'pipe', 'pipe'],
|
||||
});
|
||||
} catch { /* best-effort cleanup; never mask the primary result/error */ }
|
||||
}
|
||||
// Same guarantee as the git cleanup above: an EBUSY/EPERM here must not replace
|
||||
// whatever the `try` block was about to return or throw.
|
||||
try {
|
||||
fs.rmSync(outFile, { force: true });
|
||||
} catch { /* best-effort cleanup; never mask the primary result/error */ }
|
||||
try {
|
||||
fs.rmSync(worktreeDir, { recursive: true, force: true });
|
||||
} catch { /* best-effort cleanup; never mask the primary result/error */ }
|
||||
}
|
||||
}
|
||||
|
||||
/** Size maps at `base`, for the ratchet half. Null when absent at that ref. */
|
||||
function baselineSizesAtRef(base = 'origin/next') {
|
||||
const sizes = {};
|
||||
@@ -386,11 +527,23 @@ function baselineSizesAtRef(base = 'origin/next') {
|
||||
* Build the CURRENT emitted manifest set for real — one installer spawn per runtime.
|
||||
* This is the expensive, honest half: it reflects what the tree actually emits now,
|
||||
* not what the author regenerated into a fixture.
|
||||
*
|
||||
* @param {object} [opts]
|
||||
* @param {string} [opts.repoRoot] - Measure a DIFFERENT checkout's installer instead of
|
||||
* this one's (#2767). When set, `<repoRoot>/bin/install.js` is spawned rather than
|
||||
* THIS checkout's `bin/install.js` — the measurement schema (this function, the
|
||||
* exclusion rules in install-shared.cjs) stays fixed at the caller's version while the
|
||||
* installer code being measured varies. This is what lets `gen-emitted-baseline.cjs`
|
||||
* apply ONE definition of "the emitted manifest" to two different trees (PR HEAD and a
|
||||
* base-ref worktree) so the two sides stay comparable even if the definition itself
|
||||
* evolves — running the OTHER tree's own (older, or absent) copy of this function would
|
||||
* defeat that.
|
||||
*/
|
||||
function currentManifests() {
|
||||
function currentManifests({ repoRoot } = {}) {
|
||||
const installScript = repoRoot ? path.join(repoRoot, 'bin', 'install.js') : undefined;
|
||||
const manifests = {};
|
||||
for (const { name, runtime, scope } of MANIFEST_FAMILIES) {
|
||||
const { configDir, root } = runMinimalInstall({ runtime, scope });
|
||||
const { configDir, root } = runMinimalInstall({ runtime, scope, installScript });
|
||||
try {
|
||||
manifests[name] = buildParityManifest(configDir, root);
|
||||
} finally {
|
||||
@@ -400,12 +553,18 @@ function currentManifests() {
|
||||
return manifests;
|
||||
}
|
||||
|
||||
/** Current on-disk sizes for the workflow + agent families the ratchet covers. */
|
||||
function currentSizes() {
|
||||
/**
|
||||
* Current on-disk sizes for the workflow + agent families the ratchet covers.
|
||||
* @param {object} [opts]
|
||||
* @param {string} [opts.repoRoot] - Read `<repoRoot>/gsd-core/workflows` and
|
||||
* `<repoRoot>/agents` instead of this checkout's own (#2767) — same rationale as
|
||||
* `currentManifests`'s `repoRoot`.
|
||||
*/
|
||||
function currentSizes({ repoRoot = REPO_ROOT } = {}) {
|
||||
const sizes = {};
|
||||
for (const [dir, filter] of [
|
||||
[path.join(REPO_ROOT, 'gsd-core', 'workflows'), (f) => f.endsWith('.md')],
|
||||
[path.join(REPO_ROOT, 'agents'), (f) => f.endsWith('.md')],
|
||||
[path.join(repoRoot, 'gsd-core', 'workflows'), (f) => f.endsWith('.md')],
|
||||
[path.join(repoRoot, 'agents'), (f) => f.endsWith('.md')],
|
||||
]) {
|
||||
if (!fs.existsSync(dir)) continue;
|
||||
for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
|
||||
@@ -446,6 +605,7 @@ module.exports = {
|
||||
touchesRuntimeRegistry,
|
||||
reconcileFamilies,
|
||||
GIT_TIMEOUT_MS,
|
||||
safeDirArgs,
|
||||
git,
|
||||
resolveChangedPaths,
|
||||
resolveBaseSha,
|
||||
@@ -454,6 +614,7 @@ module.exports = {
|
||||
baselineFamilyNamesAtRef,
|
||||
baselineManifestsAtRef,
|
||||
baselineSizesAtRef,
|
||||
buildBaselineAtRef,
|
||||
currentManifests,
|
||||
currentSizes,
|
||||
readAckFile,
|
||||
|
||||
@@ -297,7 +297,18 @@ function installerEnv(overrides = {}) {
|
||||
return env;
|
||||
}
|
||||
|
||||
function runMinimalInstall({ runtime, scope, extraArgs = [] }) {
|
||||
/**
|
||||
* @param {object} opts
|
||||
* @param {string} opts.runtime
|
||||
* @param {string} opts.scope
|
||||
* @param {string[]} [opts.extraArgs]
|
||||
* @param {string} [opts.installScript] - Absolute path to the `bin/install.js` to spawn.
|
||||
* Defaults to THIS checkout's own INSTALL_SCRIPT. Overridable (#2767) so a caller can
|
||||
* measure a DIFFERENT tree's installer — e.g. the differential baseline builder
|
||||
* pointing at a `git worktree` checked out at the base ref, so the emitted manifest it
|
||||
* produces reflects that ref's own installer code, not the PR checkout's.
|
||||
*/
|
||||
function runMinimalInstall({ runtime, scope, extraArgs = [], installScript = INSTALL_SCRIPT }) {
|
||||
const root = fs.mkdtempSync(path.join(os.tmpdir(), `gsd-${runtime}-${scope}-`));
|
||||
try {
|
||||
const LOCAL_DIR_NAME = {
|
||||
@@ -308,7 +319,7 @@ function runMinimalInstall({ runtime, scope, extraArgs = [] }) {
|
||||
};
|
||||
let configDir;
|
||||
let cwd = process.cwd();
|
||||
const args = [INSTALL_SCRIPT, `--${runtime}`];
|
||||
const args = [installScript, `--${runtime}`];
|
||||
if (scope === 'global') {
|
||||
args.push('--global', '--config-dir', root);
|
||||
configDir = root;
|
||||
|
||||
Reference in New Issue
Block a user