mirror of
https://github.com/callstack/agent-device.git
synced 2026-09-14 20:06:34 +08:00
cc521decb8
* test(structure): per-package eager-closure budgets (#1960) ADR-0019 requires platform-package façades to stay implementation-lazy and is explicit that a startup threshold alone is not a substitute for preserving the loading shape. #1950 built the AST-level walker (eager-import-closure.fixtures.ts) and proved the planted-red procedure on one file (session-teardown.ts's android-helper denylist); this generalizes it into a data-driven budget table so any workspace-package façade -- or a designated hub module -- can get an eager-closure ceiling without a bespoke test. Seeds a budget for every packages/*/src/facades/*.ts file (discovered the same way package-boundaries.test.ts discovers façades, not hand-listed) from its measured current closure size, plus a platform-implementation denylist for façades whose contract is implementation-neutral vocabulary. Also demonstrates the mechanism on two designated hub modules (cli.ts, session-teardown.ts) alongside their existing, more specific ad hoc pins. Closes #1960 * test(structure): derive facade roots from manifests, add edge chains, reseed tight Review findings on #1965: 1. Discovery scanned only `packages/*/src/facades/*.ts`, which omits every package that publishes its entry surface straight from the manifest — including all six `packages/platform-*/src/index.ts` façades, the exact subject of ADR-0019's implementation-laziness rule. Discovery now derives from `readWorkspacePackages(...).exportTargets` and then adds `/src/facades/` files, reusing the R11 helper rather than reimplementing it so the two gates cannot disagree about what an entry surface is. The table grows from 14 façades + 2 hubs to 95 entry surfaces + 8 hubs. 2. Budgets carried a few files of slack each. They are now exact ratchets with no headroom, matching how the repo pins R9/R10 and test-file size: growth is allowed, it just has to be a visible number change in the diff of the PR that causes it. Every budget is reseeded from post-#1969 measurement. 3. Violations printed a flat sorted set, which named the offender but not the route. `eagerClosureGraphOf` records each file's discoverer, so failures now print the transitive chain entry -> ... -> offender. `eagerClosureOf` keeps its contract and is expressed in terms of the new walk; per-file edges are memoized, which also cuts the existing pins' runtime (cli closure test 2336ms -> ~550ms). The platform-package façades evaluate exactly one module each — themselves — so their budget of 1 is the tightest statement of "metadata-eager, implementation-lazy" the walker can make. * test(structure): make the eager-closure pins exact, bounded, and single-owner Second review pass on #1965 found four holes, two of which were places the PR text claimed a property the code did not have. 1. Rows were documented as exact ratchets but asserted with `<=`, so a shrink silently became headroom a later regression could grow back into. The comparison is now equality, in a pure `classifyBudget` with a separate message for each direction ("lower its pin to N in this PR so the ratchet keeps the gain"), matching test-file-size-ratchet.ts and the R9/R10 pins. 2. An over-pin failure printed a chain per evaluated module — 361 of them for src/cli.ts. It now prints a bounded attribution: the entry's heaviest direct edges (capped at 4) with a couple of representative deep routes each, ranked so a newly added import sorts first. The comment states plainly that this attributes by shortest import route and does NOT diff against a recorded baseline; naming a true delta would mean checking in ~1,500 module paths and rewriting them on every contracts refactor. 3. Discovery reimplemented a one-level `src/facades` scan while canonical R11 discovery is recursive, so a nested façade file could be covered by R11 and silently missing here. `facadeEntryFiles` is now a single exported owner in package-boundaries.ts that both R11's façade gate and this table consume. 4. Rows were converted to Sets before any uniqueness check, so a duplicate was unobservable. The table is now two `Record<string, number>` literals keyed by path, making an in-record duplicate a TypeScript error (ts1117); the only remaining case — one path in both records — is asserted on the array. Each of the four holes gets a test that fails when the rule is broken, since a tree that happens to satisfy its pins cannot distinguish a correct rule from a vacuous one. Writing those found a real bug in the duplicate check itself (`Set.add` returns the Set, so the filter never matched). Pins reseeded on04e4c23b9. * test(structure): restore tracked-only layering discovery and bound platform diagnostics Two findings from the third #1965 review. 1. R11 REGRESSION, introduced by the previous commit in this PR. Extracting one recursive facade-discovery owner was right, but it was implemented as a raw filesystem walk, which silently changed R11 from tracked-source discovery (listSourceFiles) to "whatever is on disk". A layering gate describes committed state, so an uncommitted scratch facade under a scanned path must be invisible; instead it could fail both R11 and the budget gate on a contributor's working directory. Worse, the test asserted the new behaviour, pinning the regression in place. The tracked-source enumerator now lives in a leaf module, scripts/layering/tracked-sources.ts, that both check.ts and package-boundaries.ts consume (check.ts imports package-boundaries.ts, so the dependency cannot run the other way). facadeEntryFiles reads listTrackedProductionSources, keeping the single recursive owner while restoring tracked-only scope. The temp-dir test is replaced by a real git fixture following platform-package-repository.test.ts: a tracked nested facade that must be discovered, plus untracked siblings — one beside it and one beside the nested file — that must not be. Reverting to the filesystem walk turns it red. 2. Only the numeric-pressure diagnostic was bounded; the platform-implementation assertion still emitted every offender with a full chain, so one eager platform subtree buried the single import that caused it under hundreds of lines. Both diagnostics now share one renderer that groups targets by the entry's own import they arrived through, caps edges and routes, and states the omitted counts. A wide planted-red fixture (300 offenders under one owning edge plus extra edges) proves the cap engages rather than assuming it. src/cli.ts reseeded 361 -> 362 for drift from the rebase onto7aaa559e2. * test(structure): close the manifest half of tracked-only discovery The previous commit intersected the `src/facades/` walk with tracked sources but left manifest-derived entry surfaces bypassing that intersection entirely — the same bug class, on the path it did not close. Two distinct leaks: 1. `readWorkspacePackages` enumerated `packages/` with `readdirSync`, so an uncommitted scratch package contributed a name, export targets, and dependency edges to every R11 rule built on it, not just to facade discovery. Closed at the source: it now reads tracked manifests via `listTrackedPackageManifests`, mirroring how R13's `readTrackedPlatformPackageDeclarations` has always enumerated its own. 2. A TRACKED manifest can still name an uncommitted target in its working-tree content, which the trailing `existsSync` admitted. `facadeEntryFiles` now intersects manifest-derived targets with the tracked production set as well, so every path it returns is committed whatever its origin. Three fixtures, each verified failing before the fix and passing after: - `readWorkspacePackages reads tracked manifests only` (in R11's own suite, since leak 1 affects every rule that reads packages, not only this gate) — red when manifest enumeration reverts to `readdirSync`. - `an untracked PACKAGE contributes no entry surface` — red when both fixes are reverted. - `a dirty manifest naming an UNTRACKED target contributes no entry surface` — red when the target intersection is dropped. The shared git fixture builder is factored out of the existing discovery test so all four use one committed baseline. Pins reseeded on8d280a208: six new contracts entry surfaces from #1993, which the exhaustiveness gate caught on its own, plus dispatch 100 -> 94 and platform-runtime 31 -> 36.
65 lines
3.2 KiB
TypeScript
65 lines
3.2 KiB
TypeScript
// The file list every layering scan reads: TRACKED production TypeScript, nothing else.
|
|
//
|
|
// A leaf module on purpose. `check.ts` owns the scan and imports `package-boundaries.ts`, so the
|
|
// boundary rules cannot import `check.ts` back for its file list; without a shared leaf the two
|
|
// would each grow their own enumerator, and the moment those disagree a rule silently changes
|
|
// scope. That is not hypothetical -- it is the #1965 review finding this module exists to fix:
|
|
// `facadeEntryFiles` was briefly implemented as a raw `readdir` walk, which quietly widened R11
|
|
// from tracked files to whatever happened to be on disk.
|
|
//
|
|
// Tracked-only is a hard rule, not an optimization. A layering gate describes COMMITTED state:
|
|
// `docs/adr/0019-request-bound-platform-runtime.md` requires review "from a clean committed tree
|
|
// with all production files present in HEAD", and `check.ts` separately fails closed when
|
|
// production TypeScript is untracked. A scratch file a contributor has not committed -- a
|
|
// throwaway `facades/experiment.ts`, a half-finished module -- must be invisible here, or a gate
|
|
// that is supposed to describe the repository starts failing on the contents of someone's working
|
|
// directory instead.
|
|
|
|
import { execFileSync } from 'node:child_process';
|
|
|
|
// `src/**/*.ts` only matches NESTED files, so root-level `src/*.ts` (src/cli.ts,
|
|
// src/command-catalog.ts) needs its own pathspec or it silently drops out of every scan.
|
|
// Workspace package sources are production files too (#1490 W0).
|
|
const TRACKED_SOURCE_PATHSPECS = [
|
|
'src/*.ts',
|
|
'src/**/*.ts',
|
|
'packages/*/src/*.ts',
|
|
'packages/*/src/**/*.ts',
|
|
];
|
|
|
|
/**
|
|
* Every tracked `packages/<pkg>/package.json`, repo-root-relative.
|
|
*
|
|
* The manifest half of the same rule. A package directory a contributor has created but not
|
|
* committed declares no entry surfaces as far as any gate is concerned -- otherwise scratch work
|
|
* changes what R11 and the loading-shape budgets police (#1965 review, second tracked-only pass).
|
|
* `platform-package-repository.ts` already reads its manifests this way for R13; this is the same
|
|
* enumeration widened to every workspace package.
|
|
*/
|
|
export function listTrackedPackageManifests(repoRoot: string): string[] {
|
|
const out = execFileSync('git', ['ls-files', 'packages/*/package.json'], {
|
|
cwd: repoRoot,
|
|
encoding: 'utf8',
|
|
});
|
|
return out.split('\n').filter(Boolean);
|
|
}
|
|
|
|
/** Every tracked `.ts` source file under the scanned roots, repo-root-relative. */
|
|
export function listTrackedTypeScriptFiles(repoRoot: string): string[] {
|
|
const out = execFileSync('git', ['ls-files', ...TRACKED_SOURCE_PATHSPECS], {
|
|
cwd: repoRoot,
|
|
encoding: 'utf8',
|
|
});
|
|
return out.split('\n').filter(Boolean);
|
|
}
|
|
|
|
/** Production sources only: test files and `__tests__/` trees are not layering subjects. */
|
|
export function isProductionSourceFile(file: string): boolean {
|
|
return file.endsWith('.ts') && !/(?:^|\/)__tests__\//.test(file) && !/\.test\.ts$/.test(file);
|
|
}
|
|
|
|
/** The canonical layering scan input: tracked, production, repo-root-relative. */
|
|
export function listTrackedProductionSources(repoRoot: string): string[] {
|
|
return listTrackedTypeScriptFiles(repoRoot).filter(isProductionSourceFile);
|
|
}
|