Files
clean-architecture-frontend…/scripts/lib/feature-scaffold-drill.ts
T
DongHyeonka 8de1403b92 ci(gates): 선택 runtime 제거 드릴 셋을 main 단계의 FE-GATE-030으로 옮긴다
문제: runner PR 1회(merge job 셋, capacity 1이라 차례로)가 28.5분이다
(run 151). tests job의 FE-GATE-020이 13분 13초로 가장 크고, 그 안의
선택 runtime 제거 드릴 셋(optional recipe, browser file/storage,
realtime)이 약 7분이다. worker를 늘리지 않는 대책을 다 넣어도 25분
목표에 닿지 않는다.

고른 방법(소유자 결정 p, 2026-11-12): 그 드릴 셋을 새 게이트
FE-GATE-030 `optional-removability`로 떼어 main 단계(`main_gate`,
FE-GATE-029 다음)에서 돌린다. 샘플 제거와 scaffold 드릴은 merge의
FE-GATE-020에 남는다. 짝 백엔드가 무거운 lane을 nightly로 옮긴 것과
같은 모양이다.
- 계약: 정규 게이트 ID를 001..030으로, MAIN_READY를 029·030으로,
  main_gate job의 게이트를 029·030으로 바꾼다. 계약 보고서의 gateCount는
  29(016은 은퇴).
- scaffold 드릴의 제외 목록에서 셋을 뺀다. 이제 merge 명령이 아니라서,
  계약 검사가 「merge 밖 명령을 제외하면 숨긴다」고 거절했다.
- main job 이름을 `main / self-tests and removal drills`로 바꾼다.
- 시험: 020은 merge·merge_test에서 sample·scaffold만, 030은
  main·main_gate에서 셋을 돈다고 단언한다. 승격 공식 시험에 030을 더한다.
- 문서: 결정 색인(decisions.md 2.2), 구조·시험·리뷰 기준·CI 문서,
  fe-structure 스킬의 드릴 명령.

위험·한계: 선택 runtime을 바꾼 PR의 제거 회귀는 병합 뒤 main run에서
본다. main이 빨강이면 다음 PR이 고친다. 그런 PR은
`scripts/verify.sh gate FE-GATE-030`을 직접 돌려야 한다(structure.md
12절에 적음). 파생 프로젝트가 main job 이름을 필수 검사로 걸었으면
이름이 바뀐다.

검증(desktop): generate:ci-workflow, 생성 시험 스냅샷 갱신,
ci-workflow-generation·promotion-readiness·feature-scaffold-drill·
removal-drill-test-paths·example-feature-rules 등 483개 통과,
check:ci(29 gates) rc=0, check:ci:gating rc=0, verify:documentation
PASS_SCOPED, check:types·eslint rc=0. 로그 /tmp/claude-gates/w2fe2-o1b~g/.
2026-11-13 02:03:01 +09:00

173 lines
7.6 KiB
TypeScript

import { spawnSync } from "node:child_process";
import type { CiGateContract } from "../contracts/ci-gates.ts";
import { classifyGateStepResult, type GateStepExpectation } from "./ci-step-result.ts";
import { FIXTURE_PNPM_ENVIRONMENT } from "./fixture-node-modules.ts";
import type { RemovalCheck } from "./removal-fixture.ts";
/**
* 1103/12-02. test:feature-scaffold proves that a feature from
* `create:feature` passes the merge gates. It ran a hand-kept list of 15
* commands while the merge stage has 88, so a template change that broke a
* generated feature in any other merge command passed FE-GATE-020.
*
* The drill now runs the merge stage of the copy's config/ci/gates.json, in
* stage order, each command once. A command added to the merge stage runs here
* unless this list names it, with the reason it cannot run in the drill.
*/
const BROWSER =
"needs Playwright browsers. FE-GATE-020 runs in a merge job without them " +
"(merge_test installs none). The generated routes in the browser " +
"gates are reviewed as 1103/12-01 and 12-03.";
const DRILL =
"a removal drill copies the repository again. The drill runs the generated " +
"feature's own removal instead (feature-removal).";
/**
* The drill runs FE-GATE-005's test:coverage in the same copy, and its paths
* hold every path of these suites (tests/unit/removal-drill-test-paths.test.ts).
* Running them plain as well found nothing more and cost about 80 s a drill.
*/
const COVERED =
"test:coverage runs the same test files in this copy " +
"(tests/unit/removal-drill-test-paths.test.ts checks the paths).";
export const SCAFFOLD_DRILL_COVERED_SUITES: readonly string[] = Object.freeze([
"test:runtime-schema",
"test:unit",
"test:contract",
"test:component",
"test:integration",
]);
/**
* What a removal drill runs next to test:coverage so that every test:all path
* still runs once in the copy (scripts/test-sample-removal.ts). The rest of
* test:all, check:release-coherence included, is inside coverage's paths.
*/
export const REMOVAL_DRILL_SUITES_OUTSIDE_COVERAGE: readonly string[] = Object.freeze([
"test:recipes",
]);
export const SCAFFOLD_DRILL_EXCLUDED_SCRIPTS: Readonly<Record<string, string>> = Object.freeze({
"verify:lockfile":
"runs pnpm install, which writes into the node_modules the copy links from " +
"the repository (scripts/lib/fixture-node-modules.ts).",
"test:e2e": BROWSER,
"test:browser-capabilities": BROWSER,
"verify:browser-capability-evidence": `reads the test:browser-capabilities results; ${BROWSER}`,
"test:storybook": BROWSER,
"test:visual": BROWSER,
"check:test-evidence:browser": `reads the browser gates' results; ${BROWSER}`,
"test:a11y": BROWSER,
"test:system":
"needs the CI runner's bubblewrap, systemd and cgroup v2 " +
"(scripts/check-system-test-prerequisites.ts). It tests the provider " +
"sandbox, which a feature does not reach.",
...Object.fromEntries(SCAFFOLD_DRILL_COVERED_SUITES.map((script) => [script, COVERED])),
"test:sample-removal": DRILL,
"test:feature-scaffold": "is this drill.",
});
export type ScaffoldDrillCommand = Readonly<{
/** `<gate>:<command id>`, the check's name in the drill report. */
name: string;
script: string;
args: readonly string[];
expectation: GateStepExpectation;
}>;
type ContractShape = Pick<CiGateContract, "commands" | "gates" | "stages">;
export function scaffoldDrillCommands(
contract: ContractShape,
excluded: Readonly<Record<string, string>> = SCAFFOLD_DRILL_EXCLUDED_SCRIPTS,
): readonly ScaffoldDrillCommand[] {
const merge = contract.stages.find(({ id }) => id === "merge");
if (!merge) throw new TypeError("the CI contract has no merge stage");
const commands = new Map(contract.commands.map((command) => [command.id, command]));
const mergeScripts = new Set<string>();
const seen = new Set<string>();
const selected: ScaffoldDrillCommand[] = [];
// A covered suite is left out only while the drill runs test:coverage. A
// copy whose merge stage lost it runs the suites plain again.
const runsCoverage = !Object.hasOwn(excluded, "test:coverage") && merge.gateIds.some((gateId) =>
contract.gates.find(({ id }) => id === gateId)?.commandIds.some((commandId) =>
commands.get(commandId)?.script === "test:coverage"));
const leftOut = (script: string) =>
Object.hasOwn(excluded, script) &&
(runsCoverage || !SCAFFOLD_DRILL_COVERED_SUITES.includes(script) || excluded[script] !== COVERED);
for (const gateId of merge.gateIds) {
const gate = contract.gates.find(({ id }) => id === gateId);
if (!gate) throw new TypeError(`the merge stage names an undefined gate: ${gateId}`);
for (const commandId of gate.commandIds) {
const command = commands.get(commandId);
if (!command) throw new TypeError(`${gateId} names an undefined command: ${commandId}`);
mergeScripts.add(command.script);
if (seen.has(commandId) || leftOut(command.script)) continue;
seen.add(commandId);
selected.push(Object.freeze({
name: `${gateId}:${commandId}`,
script: command.script,
args: Object.freeze([...(command.args ?? [])]),
expectation: command.expect === "pass"
? Object.freeze({ kind: "pass" as const })
: Object.freeze({
kind: "fail" as const,
expectedExitCode: command.expectedExitCode ?? 1,
expectedDiagnosticId: command.expectedDiagnosticId ?? "",
}),
}));
}
}
// An exclusion for a command that moved out of the merge stage would hide
// nothing today and silently drop it if it came back. A command the contract
// no longer has at all (a removal drill pruned its capability) is not stale.
const contractScripts = new Set(contract.commands.map(({ script }) => script));
const stale = Object.keys(excluded).filter(
(script) => contractScripts.has(script) && !mergeScripts.has(script),
);
if (stale.length > 0) {
throw new TypeError(
`the scaffold drill excludes scripts the contract runs outside the merge stage: ${stale.join(", ")}`,
);
}
return Object.freeze(selected);
}
/**
* Runs one merge command in the fixture. A negative fixture command passes
* only with its registered exit code and diagnostic, as in run-ci-gate.ts.
*/
export function runScaffoldDrillCommand(
command: ScaffoldDrillCommand,
root: string,
pnpmCli: string,
): RemovalCheck {
const capture = command.expectation.kind === "fail";
const result = spawnSync(process.execPath, [pnpmCli, command.script, ...command.args], {
cwd: root,
encoding: "utf8",
stdio: capture ? "pipe" : "inherit",
maxBuffer: 64 * 1024 * 1024,
env: { ...process.env, ...FIXTURE_PNPM_ENVIRONMENT },
});
if (capture) {
process.stdout.write(result.stdout ?? "");
process.stderr.write(result.stderr ?? "");
}
const classification = classifyGateStepResult(command.expectation, {
status: result.status,
signal: result.signal,
stdout: result.stdout ?? "",
stderr: result.stderr ?? "",
...(result.error ? { error: { code: (result.error as NodeJS.ErrnoException).code } } : {}),
});
if (classification.expectationMet) return { name: command.name, passed: true };
const invocation = `corepack pnpm ${[command.script, ...command.args].join(" ")}`;
return {
name: command.name,
passed: false,
failure: command.expectation.kind === "fail"
? `${invocation}: ${classification.kind}, expected exit ${command.expectation.expectedExitCode} with ${JSON.stringify(command.expectation.expectedDiagnosticId)}, got exit ${result.status ?? result.signal}`
: `${invocation} exited ${result.status ?? result.signal ?? "on a spawn error"}`,
};
}