* chore(#2896): convert CONTEXT.md prose defect registry into enforced gates Squashes the prior 4-commit sequence and fixes defects found while resuming this branch: 5 orphaned/corrupted DEFECT fragment lines left by an earlier botched edit, 17 "Source of truth: Memtrace `find_symbol`" placeholders that had destroyed real file-path citations, and 3 DEFECT.GENERATIVE-* entries merged into one RULESET.GENERATIVE-FIX predicate (policy, not an unenforced defect) to satisfy the zero DEFECT.<NAME>.<field>= acceptance criterion. Six mechanizable defects get real gates: DEFECT.UNBOUNDED-SUBPROCESS (eslint-rules/require-subprocess-timeout.cjs), DEFECT.CANARY-VERSION-LEAK (scripts/lint-canary-version-leak.cjs + version-gate.yml), DEFECT.CHANGESET-PR-FIELD-DRIFT (findPrFieldDrift in changeset/lint.cjs), DEFECT.FRONTMATTER-SCALAR-BROAD-GREP, DEFECT.REMOVED-BUT-NEEDED, and DEFECT.DEFAULT-FLIP-DOCUMENTATION (new lint scripts, wired into lint:ci). Already-enforced and unenforceable prose entries are deleted; the gate is the record. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com> * chore(#2896): route the new lint tests' subprocess calls through the bounded process-seam helper The 4 new test files for this PR's lint checks called cp.spawnSync/ execFileSync directly with no timeout, tripping this repo's own existing local/no-unbounded-spawn ESLint rule. Route every one through runNode/gitOrThrow (tests/helpers/process-seam.cjs, tests/helpers/git-fixture.cjs) instead, matching the pattern already used elsewhere in the suite (e.g. tests/changeset-lint.test.cjs). Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com> * fix: register claude-orchestration.cjs and regenerate stale generated indexes Pre-existing drift on next, unrelated to this PR's own change, surfaced by running lint:ci as part of verifying #2896: two cli_modules (claude-orchestration.cjs, write-set.cjs) landed without a manifest regen, and CONTEXT.md's own edits in this PR staled its two generated indexes. Adds the missing docs/INVENTORY.md row for claude-orchestration.cjs (write-set.cjs already had one — only its manifest entry was stale) and regenerates docs/INVENTORY-MANIFEST.json, docs/CONTEXT-INDEX.json, and examples/dynamic-context-management/CONTEXT-INDEX.json. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com> * fix(#2896): default-flip-documentation lint's local fallback base was main, not next Found in review: every other base-ref fallback in this repo (see scripts/changeset/lint.cjs's DEFAULT_BASE, #2988) defaults to `next`, the integration branch every PR actually targets — `main` is the release branch. This script's local fallback (used only when GITHUB_BASE_REF is unset, i.e. never in CI, but potentially on a local or direct invocation) diffed against the wrong ref. No test exercised the unset-env-var path, so it shipped unnoticed; every e2e test sets GITHUB_BASE_REF explicitly and is unaffected by this fix. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com> * fix(#2896): stale eslint comment, overclaiming CONTEXT.md wording, and an incompletely-regenerated manifest Found by the isolated Standards code-review pass: - eslint.config.mjs's require-subprocess-timeout comment said "'warn' for now... flip to 'error' once migrated" while the rule already shipped as 'error' with all 8 sites migrated in the same commit — described a state that never existed. - The CONTEXT.md pointer block claimed the rule's bounded call sites "never throw", but roadmap-upgrade.cts's pre-mutation clean-tree check correctly still throws on failure (it gates a destructive real-run migration; degrading to "assume clean" would risk clobbering uncommitted work) — softened the claim to describe both shapes accurately instead of overclaiming one. - docs/INVENTORY-MANIFEST.json's claude-orchestration.cjs/write-set.cjs entries from the prior "fix: register claude-orchestration.cjs..." commit didn't actually land — re-running the generator now includes them; lint:generated-sync is green. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com> * chore(#2896): backfill changeset pr field with the real PR number Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com> * fix(#2896): normalize buildCorpus file paths to POSIX in lint-removed-but-needed Windows CI caught it: path.relative(root, abs) returns backslash- separated paths on Windows, but findSurvivingReferences's package-lock special case does file.startsWith('.github/workflows') — a forward- slash literal. On Windows the check silently never matched, so tests/removed-but-needed-lint.test.cjs's real-defect-shape fixture got exit 0 instead of the expected exit 1. Normalize at the production source (RULESET.CONTENT-PATH-NORMALIZATION) rather than the test side. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com> --------- Co-authored-by: sim <sim@local> Co-authored-by: Claude Sonnet 5 <noreply@anthropic.com>
This commit is contained in:
Tom Boucher
5
.changeset/patient-dogs-sprint.md
Normal file
5
.changeset/patient-dogs-sprint.md
Normal file
@@ -0,0 +1,5 @@
|
||||
---
|
||||
type: Fixed
|
||||
pr: 3325
|
||||
---
|
||||
**Known-defect warnings that lived only in docs are now enforced checks** — six failure modes that `CONTEXT.md` merely described are now caught automatically, including unbounded subprocesses that could hang a run indefinitely and an unscoped frontmatter read that could pick up a body line. Writing the checks surfaced nine live instances, all fixed. (#2896)
|
||||
42
.github/workflows/default-flip-documentation.yml
vendored
Normal file
42
.github/workflows/default-flip-documentation.yml
vendored
Normal file
@@ -0,0 +1,42 @@
|
||||
name: Default Flip Documentation
|
||||
|
||||
# DEFECT.DEFAULT-FLIP-DOCUMENTATION (CONTEXT.md): a PR that changes an
|
||||
# existing default value in gsd-core/bin/shared/config-defaults.manifest.json
|
||||
# must document the migration semantics in a `## Breaking Changes` PR-body
|
||||
# section (when the new default takes effect, the opt-back-in command,
|
||||
# effect on in-flight artifacts) — see scripts/lint-default-flip-documentation.cjs
|
||||
# for the full rationale and scope notes.
|
||||
|
||||
on:
|
||||
pull_request:
|
||||
types: [opened, synchronize, reopened, edited]
|
||||
|
||||
concurrency:
|
||||
group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
|
||||
cancel-in-progress: true
|
||||
|
||||
permissions:
|
||||
contents: read
|
||||
pull-requests: read
|
||||
|
||||
jobs:
|
||||
default-flip-documentation:
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1
|
||||
with:
|
||||
# Intentionally shallow — see tests/policy-lint-shallow-checkout.test.cjs.
|
||||
fetch-depth: 50
|
||||
- name: Fetch base ref for diff
|
||||
# git show origin/<base>:<path> needs the base ref present locally;
|
||||
# the shallow checkout above only guarantees PR-branch ancestry.
|
||||
run: git fetch origin "${BASE_REF}:refs/remotes/origin/${BASE_REF}"
|
||||
env:
|
||||
BASE_REF: ${{ github.event.pull_request.base.ref }}
|
||||
- uses: actions/setup-node@a0853c24544627f65ddf259abe73b1d18a591444 # v5.0.0
|
||||
with:
|
||||
node-version: '24'
|
||||
- name: Check default-flip documentation
|
||||
env:
|
||||
GITHUB_BASE_REF: ${{ github.base_ref }}
|
||||
run: node scripts/lint-default-flip-documentation.cjs
|
||||
21
.github/workflows/version-gate.yml
vendored
21
.github/workflows/version-gate.yml
vendored
@@ -3,9 +3,13 @@ name: Issue Version Gate
|
||||
on:
|
||||
issues:
|
||||
types: [opened]
|
||||
pull_request:
|
||||
types: [opened, reopened, synchronize, edited]
|
||||
branches:
|
||||
- main
|
||||
|
||||
concurrency:
|
||||
group: ${{ github.workflow }}-${{ github.event.issue.number }}
|
||||
group: ${{ github.workflow }}-${{ github.event.issue.number || github.event.pull_request.number }}
|
||||
cancel-in-progress: false
|
||||
|
||||
permissions:
|
||||
@@ -14,6 +18,7 @@ permissions:
|
||||
|
||||
jobs:
|
||||
gate:
|
||||
if: github.event_name == 'issues'
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
|
||||
@@ -45,3 +50,17 @@ jobs:
|
||||
owner, repo, issue_number: issue.number,
|
||||
state: 'closed', state_reason: 'not_planned',
|
||||
});
|
||||
|
||||
# DEFECT.CANARY-VERSION-LEAK: package.json .version must never carry a
|
||||
# -canary.<N> suffix on main — that suffix is a dev-branch marker. Explicit
|
||||
# base-branch condition below (not just the trigger's `branches: [main]`
|
||||
# filter) so the gate is unambiguous even if the trigger is ever widened.
|
||||
canary-version-leak:
|
||||
if: github.event_name == 'pull_request' && github.event.pull_request.base.ref == 'main'
|
||||
runs-on: ubuntu-latest
|
||||
permissions:
|
||||
contents: read
|
||||
steps:
|
||||
- uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
|
||||
- name: Reject a -canary.<N> version landing on main
|
||||
run: node scripts/lint-canary-version-leak.cjs
|
||||
|
||||
237
CONTEXT.md
237
CONTEXT.md
File diff suppressed because one or more lines are too long
File diff suppressed because one or more lines are too long
@@ -453,6 +453,7 @@ Full listing: `gsd-core/bin/lib/*.cjs`.
|
||||
| `broken-windows.cjs` | Broken-windows ledger library (issue #1950) — typed IR + I/O for `.planning/WINDOWS.md` (cross-phase defect register); pure `parseLedger`/`renderLedger`/`appendWindow`/`markWaived`/`markFixed`/`openCount` + I/O `cmdWindowsStatus`/`cmdWindowsAppend`/`cmdWindowsWaive`/`cmdWindowsMarkFixed`; frozen `REASON` enum for typed-error assertions; CLI surface `gsd-tools windows status\|append\|waive\|fixed`. Generated from `src/broken-windows.cts` |
|
||||
| `capability-writer.cjs` | Capability State Writer (ADR-1213) — write-side inverse of the resolver; projects desired per-capability enabled/gates onto surface + config substrates, then re-resolves (assert-and-report); exports `setCapabilityState` and I/O handler `cmdCapabilitySet`; command surface: `gsd-tools capability set <id> [--on\|--off] [--gate <key>=<true\|false>]` |
|
||||
| `check-command-router.cjs` | Thin CJS subcommand router adapter for `gsd-tools check` |
|
||||
| `claude-orchestration.cjs` | Claude Orchestration capability (#1143) — Workflow-tool backend detection + emitter; `detectWorkflowBackend` fail-closed gate (`{available, backend: 'workflow'\|'inline', reason}`, degrades to today's inline behavior unless every gate opens) and `emitWorkflowScript` (maps GSD's wave/plan model onto Workflow primitives: wave → sequential `parallel()` barriers, plan → `agent(...)` with per-plan worktree isolation mirroring the inline path). Pure, zero external dependencies, never throws; never invokes the Workflow tool itself |
|
||||
| `cli-exit.cjs` | `ExitError` class and `runMain()` helper — CLI entrypoints throw `ExitError` instead of calling `process.exit()`; `runMain()` translates the outcome into `process.exitCode` so output flushes cleanly |
|
||||
| `cjs-command-router-adapter.cjs` | Shared compatibility adapter for manifest-backed CJS command-family routers |
|
||||
| `clock.cjs` | Injectable clock seam (now/sleep) for deterministic lock testing |
|
||||
|
||||
225
eslint-rules/require-subprocess-timeout.cjs
Normal file
225
eslint-rules/require-subprocess-timeout.cjs
Normal file
@@ -0,0 +1,225 @@
|
||||
'use strict';
|
||||
|
||||
/**
|
||||
* require-subprocess-timeout
|
||||
*
|
||||
* Flag: an `execSync` / `execFileSync` / `spawnSync` call (the synchronous
|
||||
* `node:child_process` primitives named in `DEFECT.UNBOUNDED-SUBPROCESS`)
|
||||
* whose options object does not carry a `timeout` key.
|
||||
*
|
||||
* The canonical defect: a sync subprocess with no `timeout` cannot be
|
||||
* interrupted and hangs indefinitely on a stuck remote, a large repo, or a
|
||||
* missing network — freezing the calling process (and, on a CI runner, the
|
||||
* whole chunk) with no diagnostic. CLAUDE.md's fix-forward is 5-30s for git,
|
||||
* 60s for npm, with a degraded-result + warning on timeout rather than a
|
||||
* throw.
|
||||
*
|
||||
* References:
|
||||
* DEFECT.UNBOUNDED-SUBPROCESS (CONTEXT.md)
|
||||
*
|
||||
* Message:
|
||||
* Cite DEFECT.UNBOUNDED-SUBPROCESS: a sync subprocess without `timeout`
|
||||
* hangs indefinitely on a stuck remote/large repo/missing network. Add
|
||||
* `timeout` (5-30s for git, 60s for npm).
|
||||
*
|
||||
* ── Known boundaries ─────────────────────────────────────────────────────────
|
||||
*
|
||||
* (a) Name-based matching only, mirroring require-fs-op-fallback.cjs's
|
||||
* fs.rename precedent. Two callee shapes are recognized:
|
||||
* - a bare Identifier call: `execSync(...)` / `execFileSync(...)` /
|
||||
* `spawnSync(...)` (the destructured-import shape used by every
|
||||
* production call site surveyed: `import { execFileSync } from
|
||||
* 'node:child_process'`).
|
||||
* - a dotted MemberExpression call on ANY object identifier:
|
||||
* `childProcess.spawnSync(...)`, `cp.execSync(...)` (the
|
||||
* default-import shape). Unlike require-fs-op-fallback's `fs.rename`
|
||||
* check, the object name is NOT constrained to a fixed spelling
|
||||
* (e.g. `childProcess`) — `execSync`/`execFileSync`/`spawnSync` are
|
||||
* distinctive enough names that constraining the receiver would only
|
||||
* create false negatives for equally-valid aliases (`cp`,
|
||||
* `child_process`), unlike the generic `rename` method name that
|
||||
* motivated locking `fs.rename` to the `fs` spelling.
|
||||
* There is deliberately no static verification that the callee actually
|
||||
* resolves to `node:child_process` (no import-binding trace) — the
|
||||
* production survey showed zero collisions with unrelated methods of
|
||||
* these three names.
|
||||
*
|
||||
* (b) Options-argument POSITION is resolved by fixed Node.js call arity, not
|
||||
* "the last argument" — `execSync(command, options?)` puts options at
|
||||
* index 1; `execFileSync(file, args?, options?)` / `spawnSync(file,
|
||||
* args?, options?)` put options at index 2. A fixed index (rather than
|
||||
* "last argument") is required because a 2-argument execFileSync/
|
||||
* spawnSync call's 2nd argument is the command's `args` ARRAY, not
|
||||
* options — treating it as a candidate options value would silently
|
||||
* swallow the "no options passed at all" case (categorically unbounded).
|
||||
* The one Node.js shape this does NOT detect: `execFileSync(file,
|
||||
* options)` with the middle `args` array omitted entirely — the
|
||||
* production survey found zero call sites using it, so it is out of
|
||||
* scope for v1.
|
||||
*
|
||||
* (c) Only an OBJECT LITERAL at that fixed index is inspected for a
|
||||
* `timeout` property (a plain key, e.g. `timeout: 5000` or `timeout:
|
||||
* opts.timeout ?? 10_000` — the key's PRESENCE is what matters, not its
|
||||
* value). An Identifier or spread-only options argument
|
||||
* (`execFileSync('git', args, opts)`) is NOT flagged — the options may
|
||||
* have been pre-built with a timeout elsewhere and this rule chooses
|
||||
* precision over recall rather than trace the identifier back to its
|
||||
* declaration.
|
||||
*
|
||||
* (d) A call with NO options argument at that index at all
|
||||
* (`execSync('git status')`, `execFileSync('git', ['status'])`) IS
|
||||
* flagged. The production survey of `src/**\/*.cts` found every real
|
||||
* call site already passes an options object literal — there is no
|
||||
* existing "bare, no options" shape to accommodate — and a call with no
|
||||
* options object has categorically no `timeout`, so it is the same
|
||||
* defect as an options object missing the key.
|
||||
*
|
||||
* Suppression: `// allow-unbounded-subprocess: <reason>` as a trailing
|
||||
* comment on the call's line (mirrors the `// allow-adhoc-markdown: <reason>`
|
||||
* / `// allow-test-rule: <reason>` per-finding-exemption convention).
|
||||
*/
|
||||
|
||||
const SYNC_SUBPROCESS_METHODS = new Set(['execSync', 'execFileSync', 'spawnSync']);
|
||||
|
||||
// Fixed options-argument index per method (see boundary (b) above):
|
||||
// execSync(command, options?) -> options at index 1
|
||||
// execFileSync(file, args?, options?) -> options at index 2
|
||||
// spawnSync(file, args?, options?) -> options at index 2
|
||||
const OPTIONS_ARG_INDEX = {
|
||||
execSync: 1,
|
||||
execFileSync: 2,
|
||||
spawnSync: 2,
|
||||
};
|
||||
|
||||
/**
|
||||
* Returns the matched method name ('execSync'/'execFileSync'/'spawnSync') for
|
||||
* a bare Identifier call or a dotted MemberExpression call on any object
|
||||
* identifier (see boundary (a)), or null if `node` is not such a call.
|
||||
*/
|
||||
function matchSyncSubprocessMethodName(node) {
|
||||
if (!node || node.type !== 'CallExpression') return null;
|
||||
const callee = node.callee;
|
||||
if (callee.type === 'Identifier' && SYNC_SUBPROCESS_METHODS.has(callee.name)) {
|
||||
return callee.name;
|
||||
}
|
||||
if (
|
||||
callee.type === 'MemberExpression' &&
|
||||
!callee.computed &&
|
||||
callee.property.type === 'Identifier' &&
|
||||
SYNC_SUBPROCESS_METHODS.has(callee.property.name)
|
||||
) {
|
||||
return callee.property.name;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the AST node at the method's fixed options-argument index (see
|
||||
* OPTIONS_ARG_INDEX / boundary (b)), or undefined if the call was not given
|
||||
* that many arguments (no options passed at all).
|
||||
*/
|
||||
function getOptionsArgument(node, methodName) {
|
||||
const idx = OPTIONS_ARG_INDEX[methodName];
|
||||
return node.arguments[idx];
|
||||
}
|
||||
|
||||
/**
|
||||
* True if `optionsArg` is an ObjectExpression that carries a `timeout` key
|
||||
* (any property kind: plain, computed-with-literal name). False for
|
||||
* `undefined` (no options argument at all — boundary (d)), a non-object
|
||||
* argument (Identifier/spread/etc — boundary (c)), or an object literal with
|
||||
* no `timeout` key.
|
||||
*/
|
||||
function hasTimeoutOptionsObject(optionsArg) {
|
||||
if (!optionsArg || optionsArg.type !== 'ObjectExpression') return false;
|
||||
return optionsArg.properties.some((prop) => {
|
||||
if (prop.type !== 'Property') return false; // skip SpreadElement
|
||||
if (prop.computed) {
|
||||
return prop.key.type === 'Literal' && prop.key.value === 'timeout';
|
||||
}
|
||||
if (prop.key.type === 'Identifier') return prop.key.name === 'timeout';
|
||||
if (prop.key.type === 'Literal') return prop.key.value === 'timeout';
|
||||
return false;
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* True if `optionsArg` IS present but is NOT an object literal (Identifier,
|
||||
* spread-built, CallExpression, etc) — i.e. a pre-built options value the
|
||||
* rule deliberately declines to trace (boundary (c): precision over recall).
|
||||
*/
|
||||
function isNonLiteralOptionsArg(optionsArg) {
|
||||
return optionsArg !== undefined && optionsArg.type !== 'ObjectExpression';
|
||||
}
|
||||
|
||||
/**
|
||||
* True when a `// allow-unbounded-subprocess: <reason>` comment sits on the
|
||||
* node's start line or end line (covers both a trailing comment on a
|
||||
* single-line call and one on the closing-paren line of a multi-line call).
|
||||
*/
|
||||
function hasSuppressionComment(node, sourceCode) {
|
||||
const startLine = node.loc.start.line;
|
||||
const endLine = node.loc.end.line;
|
||||
const allComments = sourceCode.getAllComments();
|
||||
return allComments.some((c) => {
|
||||
if (!/allow-unbounded-subprocess:\s*\S/.test(c.value)) return false;
|
||||
return c.loc.start.line === startLine || c.loc.start.line === endLine;
|
||||
});
|
||||
}
|
||||
|
||||
/** @type {import('eslint').Rule.RuleModule} */
|
||||
const rule = {
|
||||
meta: {
|
||||
type: 'problem',
|
||||
docs: {
|
||||
description:
|
||||
'Require execSync/execFileSync/spawnSync to carry a `timeout` option (DEFECT.UNBOUNDED-SUBPROCESS)',
|
||||
category: 'Portability',
|
||||
},
|
||||
schema: [],
|
||||
messages: {
|
||||
requireSubprocessTimeout:
|
||||
'Unbounded sync subprocess: execSync/execFileSync/spawnSync without `timeout` hangs indefinitely ' +
|
||||
'on a stuck remote, a large repo, or missing network (DEFECT.UNBOUNDED-SUBPROCESS). Add `timeout` ' +
|
||||
'(5-30s for git, 60s for npm) and handle the timeout with a degraded result, not a throw. ' +
|
||||
'Suppress with: // allow-unbounded-subprocess: <reason>',
|
||||
},
|
||||
},
|
||||
|
||||
create(context) {
|
||||
// Scope: src/**/*.cts only (never tests/**). eslint.config.mjs also scopes
|
||||
// the plugin registration to `files: ['src/**/*.cts']`, but RuleTester
|
||||
// runs the rule directly with no config-level file filtering, so the
|
||||
// filename check must live in the rule itself for the VALID
|
||||
// tests/**-filename test case to hold.
|
||||
const filename = context.getFilename ? context.getFilename() : context.filename;
|
||||
if (!/(?:^|\/)src\/.*\.cts$/.test(filename.replace(/\\/g, '/'))) {
|
||||
return {};
|
||||
}
|
||||
|
||||
const sourceCode = context.sourceCode ?? context.getSourceCode();
|
||||
|
||||
return {
|
||||
CallExpression(node) {
|
||||
const methodName = matchSyncSubprocessMethodName(node);
|
||||
if (!methodName) return;
|
||||
|
||||
const optionsArg = getOptionsArgument(node, methodName);
|
||||
|
||||
// Precision over recall: an Identifier/spread-built options arg is
|
||||
// not traced back to its declaration — not flagged.
|
||||
if (isNonLiteralOptionsArg(optionsArg)) return;
|
||||
|
||||
// Object literal carrying a `timeout` key -> OK. (`optionsArg`
|
||||
// undefined — no options passed at all — falls through to report.)
|
||||
if (hasTimeoutOptionsObject(optionsArg)) return;
|
||||
|
||||
if (hasSuppressionComment(node, sourceCode)) return;
|
||||
|
||||
context.report({ node, messageId: 'requireSubprocessTimeout' });
|
||||
},
|
||||
};
|
||||
},
|
||||
};
|
||||
|
||||
module.exports = rule;
|
||||
@@ -26,6 +26,7 @@ import normalizePathInContent from './eslint-rules/normalize-path-in-content.cjs
|
||||
import requireFsOpFallback from './eslint-rules/require-fs-op-fallback.cjs';
|
||||
import noUnboundedSpawn from './eslint-rules/no-unbounded-spawn.cjs';
|
||||
import noDuplicateFoldMarker from './eslint-rules/no-duplicate-fold-marker.cjs';
|
||||
import requireSubprocessTimeout from './eslint-rules/require-subprocess-timeout.cjs';
|
||||
|
||||
const localPlugin = {
|
||||
rules: {
|
||||
@@ -46,6 +47,7 @@ const localPlugin = {
|
||||
'require-fs-op-fallback': requireFsOpFallback,
|
||||
'no-unbounded-spawn': noUnboundedSpawn,
|
||||
'no-duplicate-fold-marker': noDuplicateFoldMarker,
|
||||
'require-subprocess-timeout': requireSubprocessTimeout,
|
||||
},
|
||||
};
|
||||
|
||||
@@ -302,6 +304,11 @@ export default tseslint.config(
|
||||
// (EPERM/EBUSY/EACCES retry or a Windows platform guard). See
|
||||
// DEFECT.WINDOWS-FS-OPS in CONTEXT.md.
|
||||
'local/require-fs-op-fallback': 'error',
|
||||
// Flag execSync/execFileSync/spawnSync without a `timeout` option — an
|
||||
// unbounded sync subprocess hangs indefinitely on a stuck remote/large
|
||||
// repo/missing network (DEFECT.UNBOUNDED-SUBPROCESS in CONTEXT.md).
|
||||
// The 8 pre-existing call sites this surfaced were migrated in #2896.
|
||||
'local/require-subprocess-timeout': 'error',
|
||||
},
|
||||
},
|
||||
|
||||
|
||||
File diff suppressed because one or more lines are too long
@@ -112,7 +112,9 @@
|
||||
"lint": "eslint . --cache --cache-location node_modules/.cache/eslint/ --max-warnings 0",
|
||||
"lint:fix": "eslint . --fix",
|
||||
"lint:table-schema-drift": "node scripts/lint-table-schema-drift.cjs",
|
||||
"lint:ci": "npm run lint && npm run lint:skill-deps && npm run lint:generated-sync && node scripts/lint-test-file-count.cjs && node scripts/lint-command-contract.cjs && node scripts/lint-pr-check-project-dir.cjs && npm run lint:legacy-name && node scripts/lint-regression-test-names.cjs && node scripts/lint-allow-test-rule-refs.cjs && node scripts/lint-resolution-provenance.cjs && node scripts/lint-emitted-drift-ack.cjs && node scripts/lint-portable-timeout.cjs && node scripts/validate-registry.cjs && node scripts/lint-table-schema-drift.cjs && node scripts/lint-fix-has-regression-test.cjs && node scripts/lint-example-parser-parity.cjs && node scripts/lint-docs-command-form.cjs && node scripts/lint-plan-count-drift.cjs && node scripts/lint-milestone-window-drift.cjs && node scripts/lint-phase-enumeration-drift.cjs && node scripts/lint-planning-prompt-drift.cjs && node scripts/lint-completion-ratio-drift.cjs && node scripts/lint-state-field-drift.cjs && node scripts/lint-completion-predicate-drift.cjs",
|
||||
"lint:frontmatter-scalar-broad-grep": "node scripts/lint-frontmatter-scalar-broad-grep.cjs",
|
||||
"lint:removed-but-needed": "node scripts/lint-removed-but-needed.cjs",
|
||||
"lint:ci": "npm run lint && npm run lint:skill-deps && npm run lint:generated-sync && node scripts/lint-test-file-count.cjs && node scripts/lint-command-contract.cjs && node scripts/lint-pr-check-project-dir.cjs && npm run lint:legacy-name && node scripts/lint-regression-test-names.cjs && node scripts/lint-allow-test-rule-refs.cjs && node scripts/lint-resolution-provenance.cjs && node scripts/lint-emitted-drift-ack.cjs && node scripts/lint-portable-timeout.cjs && node scripts/validate-registry.cjs && node scripts/lint-table-schema-drift.cjs && node scripts/lint-fix-has-regression-test.cjs && node scripts/lint-example-parser-parity.cjs && node scripts/lint-docs-command-form.cjs && node scripts/lint-plan-count-drift.cjs && node scripts/lint-milestone-window-drift.cjs && node scripts/lint-phase-enumeration-drift.cjs && node scripts/lint-planning-prompt-drift.cjs && node scripts/lint-completion-ratio-drift.cjs && node scripts/lint-state-field-drift.cjs && node scripts/lint-completion-predicate-drift.cjs && node scripts/lint-frontmatter-scalar-broad-grep.cjs && node scripts/lint-removed-but-needed.cjs",
|
||||
"lint:allow-test-rule-refs": "node scripts/lint-allow-test-rule-refs.cjs",
|
||||
"lint:regression-names": "node scripts/lint-regression-test-names.cjs",
|
||||
"lint:descriptions": "node scripts/lint-descriptions.cjs",
|
||||
|
||||
@@ -22,6 +22,7 @@ const LINT_REASON = Object.freeze({
|
||||
OK_NO_USER_FACING_CHANGES: 'ok_no_user_facing_changes',
|
||||
FAIL_MISSING_FRAGMENT: 'fail_missing_fragment',
|
||||
FAIL_INVALID_FRAGMENT: 'fail_invalid_fragment',
|
||||
FAIL_PR_FIELD_DRIFT: 'fail_pr_field_drift',
|
||||
});
|
||||
|
||||
const OPT_OUT_LABEL = 'no-changelog';
|
||||
@@ -53,10 +54,47 @@ function isFragment(file) {
|
||||
return /^\.changeset\/[^/]+\.md$/.test(file) && !file.endsWith('/README.md');
|
||||
}
|
||||
|
||||
function evaluateLint({ changedFiles, labels, fragmentFailures = [] }) {
|
||||
/**
|
||||
* DEFECT.CHANGESET-PR-FIELD-DRIFT (#3316, #3325): a fragment's `pr:` field is
|
||||
* a guess (issue number, stacked-PR leftover) that never got backfilled to
|
||||
* the real PR number after `gh api POST /pulls` returned it.
|
||||
*
|
||||
* Pure: given `prEntries` (`[{ file, pr }]`, one entry per successfully
|
||||
* parsed changed fragment — `pr` is always a positive integer, since
|
||||
* `parseFragment` already rejects `pr: 0` / non-numeric values as
|
||||
* `invalid_pr` before a fragment ever reaches this function) and
|
||||
* `realPrNumber` (the PR this run belongs to, or `null` when unknown —
|
||||
* push/non-PR runs), returns every fragment whose `pr` disagrees with
|
||||
* `realPrNumber`. `realPrNumber == null` always yields `[]`: with no PR
|
||||
* event payload to compare against, there is nothing to drift-check.
|
||||
*
|
||||
* `pr === 0` is always silent regardless of `realPrNumber` — CONTRIBUTING.md
|
||||
* documents `pr: 0` as the deliberate placeholder used "during initial
|
||||
* commit" before `gh api POST /pulls` returns the real number, so it is not
|
||||
* yet a drifted value, just an unbackfilled one. (In practice `parseFragment`
|
||||
* already rejects `pr: 0` as `invalid_pr` before a fragment reaches this
|
||||
* function via `main()`'s wiring — this guard documents and locks in the
|
||||
* pure function's own contract independent of that upstream check.)
|
||||
*/
|
||||
function findPrFieldDrift(prEntries, realPrNumber) {
|
||||
if (realPrNumber == null) return [];
|
||||
const drift = [];
|
||||
for (const { file, pr } of prEntries) {
|
||||
if (pr === 0) continue;
|
||||
if (pr !== realPrNumber) {
|
||||
drift.push({ file, found: pr, expected: realPrNumber });
|
||||
}
|
||||
}
|
||||
return drift;
|
||||
}
|
||||
|
||||
function evaluateLint({ changedFiles, labels, fragmentFailures = [], prFieldDrift = [] }) {
|
||||
if (fragmentFailures.length > 0) {
|
||||
return { ok: false, reason: LINT_REASON.FAIL_INVALID_FRAGMENT, failures: fragmentFailures };
|
||||
}
|
||||
if (prFieldDrift.length > 0) {
|
||||
return { ok: false, reason: LINT_REASON.FAIL_PR_FIELD_DRIFT, drift: prFieldDrift };
|
||||
}
|
||||
if (changedFiles.some(isFragment)) {
|
||||
return { ok: true, reason: LINT_REASON.OK_FRAGMENT_PRESENT };
|
||||
}
|
||||
@@ -78,10 +116,18 @@ function main() {
|
||||
// GitHub Actions event payload path
|
||||
const eventPath = process.env.GITHUB_EVENT_PATH;
|
||||
let labels = [];
|
||||
// DEFECT.CHANGESET-PR-FIELD-DRIFT: the real PR number this run belongs to,
|
||||
// read from the same event payload. `null` on a push / non-PR run (no
|
||||
// `pull_request` in the payload, or no payload at all) — the drift check
|
||||
// below is a no-op in that case, it never fails a push run.
|
||||
let realPrNumber = null;
|
||||
if (eventPath && fs.existsSync(eventPath)) {
|
||||
try {
|
||||
const event = JSON.parse(fs.readFileSync(eventPath, 'utf8'));
|
||||
labels = (event.pull_request?.labels || []).map((l) => l.name);
|
||||
if (event.pull_request && Number.isInteger(event.pull_request.number)) {
|
||||
realPrNumber = event.pull_request.number;
|
||||
}
|
||||
} catch { /* fall through */ }
|
||||
}
|
||||
// #2988: local fallback must match the repo's integration branch (`next`),
|
||||
@@ -107,6 +153,7 @@ function main() {
|
||||
|
||||
// Validate the content of every changed fragment file.
|
||||
const fragmentFailures = [];
|
||||
const prEntries = [];
|
||||
for (const file of changedFiles) {
|
||||
if (!isFragment(file)) continue;
|
||||
// A fragment path in the diff that no longer exists on disk was deleted in
|
||||
@@ -125,10 +172,13 @@ function main() {
|
||||
const result = parseFragment(src);
|
||||
if (!result.ok) {
|
||||
fragmentFailures.push({ file, reason: result.reason, detail: result.detail });
|
||||
continue;
|
||||
}
|
||||
prEntries.push({ file, pr: result.fragment.pr });
|
||||
}
|
||||
|
||||
const verdict = evaluateLint({ changedFiles, labels, fragmentFailures });
|
||||
const prFieldDrift = findPrFieldDrift(prEntries, realPrNumber);
|
||||
const verdict = evaluateLint({ changedFiles, labels, fragmentFailures, prFieldDrift });
|
||||
if (process.argv.includes('--json')) {
|
||||
process.stdout.write(JSON.stringify({ ...verdict, changedFiles, labels }, null, 2) + '\n');
|
||||
} else if (verdict.ok) {
|
||||
@@ -141,6 +191,13 @@ function main() {
|
||||
process.stderr.write(` ${f.file}: ${f.reason}${detail}\n`);
|
||||
}
|
||||
process.stderr.write(`Fix the fragment(s) above before merging.\n`);
|
||||
} else if (verdict.reason === LINT_REASON.FAIL_PR_FIELD_DRIFT) {
|
||||
process.stderr.write(`\nERROR changeset-lint: ${verdict.reason}\n`);
|
||||
process.stderr.write(`The following .changeset fragment(s) have a stale \`pr:\` field (DEFECT.CHANGESET-PR-FIELD-DRIFT):\n`);
|
||||
for (const d of verdict.drift) {
|
||||
process.stderr.write(` ${d.file}: pr: ${d.found}, expected pr: ${d.expected}\n`);
|
||||
}
|
||||
process.stderr.write(`Backfill \`pr:\` with this PR's real number (see .changeset/README.md), then push again.\n`);
|
||||
} else {
|
||||
process.stderr.write(`\nERROR changeset-lint: ${verdict.reason}\n`);
|
||||
process.stderr.write(`PR touches user-facing files but does not include a .changeset/*.md fragment.\n`);
|
||||
@@ -152,4 +209,4 @@ function main() {
|
||||
|
||||
if (require.main === module) runMain(main);
|
||||
|
||||
module.exports = { evaluateLint, LINT_REASON, OPT_OUT_LABEL, isUserFacing, isFragment, DEFAULT_BASE };
|
||||
module.exports = { evaluateLint, LINT_REASON, OPT_OUT_LABEL, isUserFacing, isFragment, DEFAULT_BASE, findPrFieldDrift };
|
||||
|
||||
73
scripts/lint-canary-version-leak.cjs
Normal file
73
scripts/lint-canary-version-leak.cjs
Normal file
@@ -0,0 +1,73 @@
|
||||
#!/usr/bin/env node
|
||||
'use strict';
|
||||
|
||||
/**
|
||||
* Canary-version-leak lint (DEFECT.CANARY-VERSION-LEAK, CONTEXT.md).
|
||||
*
|
||||
* `package.json` `.version` on `main` must never carry a `-canary.<N>`
|
||||
* suffix — that suffix is a dev-branch/prerelease marker. Nothing published
|
||||
* depends on the string at runtime, but every consumer of the version
|
||||
* metadata (release flow, install banners, statusline) surfaces the
|
||||
* dev-channel label as if it were the shipped release. The 2026-05-16 audit
|
||||
* found `origin/main` at `"version": "1.50.0-canary.0"`, landed by a fix PR
|
||||
* that accidentally carried a version bump from a dev-branch base (commit
|
||||
* 2d32ad82, #3206).
|
||||
*
|
||||
* Modeled on scripts/lint-package-identity-drift.cjs / scripts/lint-table-schema-drift.cjs:
|
||||
* a standalone node script (not a node:test), exit 0 clean / exit 1 + message
|
||||
* on a leaked canary version. Wired to run only for PRs targeting `main`
|
||||
* (.github/workflows/version-gate.yml) — a canary version is expected and
|
||||
* harmless on every other branch.
|
||||
*/
|
||||
|
||||
const fs = require('node:fs');
|
||||
const path = require('node:path');
|
||||
|
||||
const CANARY_RE = /-canary\.\d+/;
|
||||
|
||||
/**
|
||||
* Pure: does this version string carry a `-canary.<N>` suffix?
|
||||
* @param {string} version
|
||||
* @returns {boolean}
|
||||
*/
|
||||
function isCanaryVersion(version) {
|
||||
return typeof version === 'string' && CANARY_RE.test(version);
|
||||
}
|
||||
|
||||
/**
|
||||
* Read `<root>/package.json` and return its `.version`, or null if the file
|
||||
* is missing/unreadable/unparsable.
|
||||
* @param {string} root
|
||||
* @returns {string|null}
|
||||
*/
|
||||
function readPackageVersion(root) {
|
||||
try {
|
||||
const raw = fs.readFileSync(path.join(root, 'package.json'), 'utf8');
|
||||
const pkg = JSON.parse(raw);
|
||||
return typeof pkg.version === 'string' ? pkg.version : null;
|
||||
} catch {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
function main() {
|
||||
const root = path.join(__dirname, '..');
|
||||
const version = readPackageVersion(root);
|
||||
if (version == null) {
|
||||
process.stderr.write('canary-version-leak: could not read/parse package.json .version\n');
|
||||
process.exitCode = 1;
|
||||
return;
|
||||
}
|
||||
if (!isCanaryVersion(version)) {
|
||||
process.stdout.write(`ok canary-version-leak: package.json version '${version}' carries no -canary.<N> suffix\n`);
|
||||
return;
|
||||
}
|
||||
process.stderr.write(`canary-version-leak: package.json version '${version}' carries a -canary.<N> suffix (DEFECT.CANARY-VERSION-LEAK).\n`);
|
||||
process.stderr.write('A -canary.<N> version must never land on main. Reset .version to the canonical\n');
|
||||
process.stderr.write('pre-canary stable before merging — see CONTEXT.md DEFECT.CANARY-VERSION-LEAK.\n');
|
||||
process.exitCode = 1;
|
||||
}
|
||||
|
||||
if (require.main === module) main();
|
||||
|
||||
module.exports = { isCanaryVersion, readPackageVersion, CANARY_RE };
|
||||
193
scripts/lint-default-flip-documentation.cjs
Normal file
193
scripts/lint-default-flip-documentation.cjs
Normal file
@@ -0,0 +1,193 @@
|
||||
#!/usr/bin/env node
|
||||
'use strict';
|
||||
|
||||
/**
|
||||
* lint-default-flip-documentation.cjs — DEFECT.DEFAULT-FLIP-DOCUMENTATION
|
||||
* (CONTEXT.md).
|
||||
*
|
||||
* ## Why
|
||||
*
|
||||
* A PR flips a config default but doesn't call out the migration semantics
|
||||
* (when the new default takes effect; existing configs vs new configs; what
|
||||
* the opt-back-in looks like — #3309, the v2 default flip from mid-flight to
|
||||
* end-of-phase).
|
||||
*
|
||||
* ## Scope (deliberately narrower than the full DEFECT.detect clause)
|
||||
*
|
||||
* The DEFECT text names two surfaces: `CONFIG_DEFAULTS` and
|
||||
* `buildNewProjectConfig`. This check covers ONLY the single-source-of-truth
|
||||
* defaults manifest, `gsd-core/bin/shared/config-defaults.manifest.json`
|
||||
* (what `CONFIG_DEFAULTS` in `src/configuration.cts` / `src/config.cts`
|
||||
* actually loads at runtime) — because it is pure JSON, a resolved
|
||||
* key→value-map diff between base and head is trivially reliable: no line
|
||||
* movement, reordering, or refactor can ever produce a false "value changed"
|
||||
* verdict, only an actual value change can.
|
||||
*
|
||||
* `buildNewProjectConfig`'s `hardcoded` object literal in `src/config.cts`
|
||||
* is DELIBERATELY OUT OF SCOPE here. It mixes literal values with
|
||||
* environment-derived branches (`hasBraveSearch`, etc.) and spreads of
|
||||
* `CONFIG_DEFAULTS.*` — there is no reliable way to compute its *resolved*
|
||||
* value map from source text alone without executing the compiled module at
|
||||
* both refs, and a line/AST-level diff of that literal would inherit exactly
|
||||
* the false-positive risk (a harmless refactor that moves or restructures
|
||||
* the literal reads as a "flip") this check exists to avoid. Per the audit's
|
||||
* own risk callout, a noisy check here is worse than no check — the
|
||||
* `buildNewProjectConfig` half of the DEFECT stays prose-only.
|
||||
*
|
||||
* ## What this checks
|
||||
*
|
||||
* If any *value* differs between the base and head resolved manifest
|
||||
* key→value maps (additions/removals alone don't count as a "flip" — the
|
||||
* symptom is specifically about an EXISTING default changing), fail unless
|
||||
* the PR body contains a `## Breaking Changes` (or `# Breaking Changes`)
|
||||
* heading.
|
||||
*
|
||||
* Needs a PR event payload (`GITHUB_EVENT_PATH`) to read the PR body — this
|
||||
* is a dedicated-workflow check (like `lint-canary-version-leak.cjs`), not a
|
||||
* `lint:ci` member, since a local/push run has no PR body to check against.
|
||||
*/
|
||||
|
||||
const fs = require('node:fs');
|
||||
const path = require('node:path');
|
||||
const cp = require('node:child_process');
|
||||
const { ExitError, runMain } = require('./lib/cli-exit.cjs');
|
||||
|
||||
const ROOT = path.join(__dirname, '..');
|
||||
const MANIFEST_PATH = path.join('gsd-core', 'bin', 'shared', 'config-defaults.manifest.json');
|
||||
const BREAKING_CHANGES_RE = /^#{1,6}\s*Breaking Changes\b/im;
|
||||
|
||||
/**
|
||||
* Pure: flatten a nested plain-object JSON value into dot-path
|
||||
* `{ "a.b.c": value }` leaves. Arrays and primitives are leaves (compared by
|
||||
* JSON.stringify equality, never recursed into) so array reordering reads as
|
||||
* one value change, not N.
|
||||
* @param {unknown} value
|
||||
* @param {string} prefix
|
||||
* @param {Record<string, unknown>} out
|
||||
* @returns {Record<string, unknown>}
|
||||
*/
|
||||
function flatten(value, prefix = '', out = {}) {
|
||||
if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
|
||||
for (const [key, v] of Object.entries(value)) {
|
||||
flatten(v, prefix ? `${prefix}.${key}` : key, out);
|
||||
}
|
||||
} else {
|
||||
out[prefix] = value;
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
/**
|
||||
* Pure: given two resolved (already-flattened) key→value maps, return the
|
||||
* keys present in BOTH whose value differs. Additions/removals are NOT
|
||||
* "flips" — a brand-new default has no prior behavior to contradict.
|
||||
* @param {Record<string, unknown>} baseMap
|
||||
* @param {Record<string, unknown>} headMap
|
||||
* @returns {{ key: string, from: unknown, to: unknown }[]}
|
||||
*/
|
||||
function findDefaultValueChanges(baseMap, headMap) {
|
||||
const changes = [];
|
||||
for (const key of Object.keys(baseMap)) {
|
||||
if (!Object.prototype.hasOwnProperty.call(headMap, key)) continue;
|
||||
if (JSON.stringify(baseMap[key]) !== JSON.stringify(headMap[key])) {
|
||||
changes.push({ key, from: baseMap[key], to: headMap[key] });
|
||||
}
|
||||
}
|
||||
return changes;
|
||||
}
|
||||
|
||||
/**
|
||||
* Pure verdict: given the detected default-value changes and the PR body,
|
||||
* decide pass/fail.
|
||||
* @param {{ key: string, from: unknown, to: unknown }[]} changes
|
||||
* @param {string} prBody
|
||||
* @returns {{ ok: boolean, changes: object[] }}
|
||||
*/
|
||||
function evaluateDefaultFlipDoc(changes, prBody) {
|
||||
if (changes.length === 0) return { ok: true, changes: [] };
|
||||
if (BREAKING_CHANGES_RE.test(prBody || '')) return { ok: true, changes };
|
||||
return { ok: false, changes };
|
||||
}
|
||||
|
||||
/**
|
||||
* Read and JSON.parse the manifest at a given git ref. Returns `{}` when the
|
||||
* file doesn't exist at that ref (new file, or ref predates it) — that is
|
||||
* not a "flip", it's an addition, and is silently excluded by
|
||||
* findDefaultValueChanges's both-sides-present requirement anyway.
|
||||
* @param {string} root
|
||||
* @param {string} ref
|
||||
* @returns {Record<string, unknown>}
|
||||
*/
|
||||
function readManifestAtRef(root, ref) {
|
||||
let raw;
|
||||
try {
|
||||
raw = cp.execFileSync('git', ['show', `${ref}:${MANIFEST_PATH.split(path.sep).join('/')}`], {
|
||||
cwd: root,
|
||||
encoding: 'utf8',
|
||||
timeout: 15000,
|
||||
});
|
||||
} catch {
|
||||
return {};
|
||||
}
|
||||
try {
|
||||
return JSON.parse(raw);
|
||||
} catch (e) {
|
||||
throw new ExitError(2, `lint-default-flip-documentation: ${ref}:${MANIFEST_PATH} is not valid JSON: ${e.message}`);
|
||||
}
|
||||
}
|
||||
|
||||
function readPrBody() {
|
||||
const eventPath = process.env.GITHUB_EVENT_PATH;
|
||||
if (!eventPath || !fs.existsSync(eventPath)) return null;
|
||||
try {
|
||||
const event = JSON.parse(fs.readFileSync(eventPath, 'utf8'));
|
||||
return typeof event.pull_request?.body === 'string' ? event.pull_request.body : '';
|
||||
} catch {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
function main() {
|
||||
const prBody = readPrBody();
|
||||
if (prBody === null) {
|
||||
console.log('lint-default-flip-documentation: no PR event payload (not a pull_request run), skipping');
|
||||
return;
|
||||
}
|
||||
|
||||
const baseRef = `origin/${process.env.GITHUB_BASE_REF || 'next'}`; // #2988
|
||||
const baseMap = flatten(readManifestAtRef(ROOT, baseRef));
|
||||
const headMap = flatten(readManifestAtRef(ROOT, 'HEAD'));
|
||||
const changes = findDefaultValueChanges(baseMap, headMap);
|
||||
const verdict = evaluateDefaultFlipDoc(changes, prBody);
|
||||
|
||||
if (!verdict.ok) {
|
||||
const detail = verdict.changes
|
||||
.map((c) => ` ${c.key}: ${JSON.stringify(c.from)} → ${JSON.stringify(c.to)}`)
|
||||
.join('\n');
|
||||
throw new ExitError(
|
||||
1,
|
||||
'lint-default-flip-documentation: this PR changes an existing default value in\n'
|
||||
+ 'config-defaults.manifest.json (DEFECT.DEFAULT-FLIP-DOCUMENTATION) but the PR body has no\n'
|
||||
+ '`## Breaking Changes` section. Add one covering: (a) when the new default takes effect\n'
|
||||
+ '(config-set, fresh project, regenerated config), (b) the opt-back-in command\n'
|
||||
+ '(`gsd config-set <key> <old-value>`), (c) effect on in-flight artifacts. Changed default(s):\n'
|
||||
+ detail,
|
||||
);
|
||||
}
|
||||
console.log(
|
||||
changes.length === 0
|
||||
? 'ok lint-default-flip-documentation: no default value changed'
|
||||
: `ok lint-default-flip-documentation: ${changes.length} default value change(s), PR body documents Breaking Changes`,
|
||||
);
|
||||
}
|
||||
|
||||
module.exports = {
|
||||
flatten,
|
||||
findDefaultValueChanges,
|
||||
evaluateDefaultFlipDoc,
|
||||
readManifestAtRef,
|
||||
MANIFEST_PATH,
|
||||
BREAKING_CHANGES_RE,
|
||||
};
|
||||
|
||||
if (require.main === module) runMain(main);
|
||||
237
scripts/lint-frontmatter-scalar-broad-grep.cjs
Normal file
237
scripts/lint-frontmatter-scalar-broad-grep.cjs
Normal file
@@ -0,0 +1,237 @@
|
||||
#!/usr/bin/env node
|
||||
'use strict';
|
||||
|
||||
/**
|
||||
* lint-frontmatter-scalar-broad-grep.cjs — DEFECT.FRONTMATTER-SCALAR-BROAD-GREP
|
||||
* (CONTEXT.md).
|
||||
*
|
||||
* ## Why
|
||||
*
|
||||
* A YAML-frontmatter scalar (e.g. VERIFICATION.md `status:`) read with
|
||||
* `grep "^key:"` over the WHOLE markdown report instead of the frontmatter
|
||||
* block returns extra matches whenever a `key:` line also appears in the
|
||||
* body (a code block, a copied artifact, an example). Piped into
|
||||
* `cut`/`tr`, those extra matches concatenate into a value that matches no
|
||||
* expected token, silently misrouting a valid state (#586/PR #650:
|
||||
* `grep "^status:"` also matched body `status:` lines, yielding
|
||||
* `passed+gaps_found+human_needed` instead of `passed` and blocking a
|
||||
* passed phase).
|
||||
*
|
||||
* The fix-forward is to scope the grep to the leading frontmatter block and
|
||||
* take only the first match:
|
||||
* sed -n '/^---$/,/^---$/p' "$f" | grep -m1 "^<key>:" | cut -d: -f2 | tr -d ' '
|
||||
*
|
||||
* ## What this scans
|
||||
*
|
||||
* Every fenced ```bash / ```sh code block in `gsd-core/workflows/*.md`,
|
||||
* `agents/*.md`, and `commands/**\/*.md`. Within each block, flags a
|
||||
* `grep "^key:"` / `grep '^key:'` invocation that:
|
||||
* - is NOT preceded (earlier in the SAME block) by a frontmatter-scoping
|
||||
* idiom (`sed -n '/^---$/,/^---$/p'`, a JS `/^---\n([\s\S]*?)\n---/`
|
||||
* extraction, or an equivalent range over the `---` delimiter), AND
|
||||
* - does NOT carry a `-m1` (or `-m 1`) flag, and is NOT immediately piped
|
||||
* into `head -1`/`head -n 1` (frontmatter always precedes the body in
|
||||
* these generated reports, so `head -1` on the whole file is the same
|
||||
* single-match guarantee as `-m1`), AND
|
||||
* - is used for exact-token comparison: piped (same line) into
|
||||
* `cut`/`tr`, or captured into a shell variable that is later compared
|
||||
* via `==`/`case` elsewhere in the same block.
|
||||
*
|
||||
* ## False-positive risk (moderate-to-high, per audit)
|
||||
*
|
||||
* Some `grep "^key:"` uses are intentionally whole-body (scanning multiple
|
||||
* report files at once, not one frontmatter block) and are not a bug. Add
|
||||
* `# lint-allow: frontmatter-scalar-broad-grep — <reason>` on the same line
|
||||
* (or the line immediately above) to suppress a specific invocation.
|
||||
*/
|
||||
|
||||
const fs = require('fs');
|
||||
const path = require('path');
|
||||
const { ExitError, runMain } = require('./lib/cli-exit.cjs');
|
||||
|
||||
const ROOT = path.join(__dirname, '..');
|
||||
const DEFAULT_ROOTS = ['gsd-core/workflows', 'agents', 'commands'];
|
||||
|
||||
const FENCE_RE = /^```(bash|sh)\s*$/;
|
||||
const FENCE_END_RE = /^```\s*$/;
|
||||
|
||||
// A `grep "^key:"` / `grep '^key:'` invocation. Captures the key name and the
|
||||
// full option string preceding the pattern (so callers can check for -m1).
|
||||
const GREP_KEY_RE = /grep\s+((?:-\S+\s+)*)(["'])\^([A-Za-z_][\w-]*):\2/;
|
||||
|
||||
// A frontmatter-scoping idiom: a delimiter-range extraction anchored on the
|
||||
// `---` frontmatter fence, opened by `^---` (sed/awk `/^---$/,/^---$/p`, or a
|
||||
// JS regex like `/^---\n([\s\S]*?)\n---/`) and closed by a second `---`
|
||||
// within a short window. Matches both idioms without caring which language
|
||||
// wrote the delimiter.
|
||||
const FRONTMATTER_SCOPE_RE = /\^---[\s\S]{0,300}?---/;
|
||||
|
||||
const ALLOW_RE = /#\s*lint-allow:\s*frontmatter-scalar-broad-grep/;
|
||||
|
||||
// `| head -1` / `| head -n 1` immediately after the grep is functionally
|
||||
// equivalent to `-m1` for this check: frontmatter always precedes the body
|
||||
// in these generated reports, so the first grep match is always the
|
||||
// frontmatter's, and `head -1` discards every later (body) match exactly
|
||||
// like `-m1` would.
|
||||
function hasSingleMatchGuard(line, optionString) {
|
||||
if (/(^|\s)-m\s*1(\s|$)/.test(optionString) || /(^|\s)--max-count[= ]1(\s|$)/.test(optionString)) return true;
|
||||
return /\|\s*head\s+(-1|-n\s*1)\b/.test(line);
|
||||
}
|
||||
|
||||
function isSuppressed(lines, idx) {
|
||||
if (ALLOW_RE.test(lines[idx])) return true;
|
||||
if (idx > 0 && ALLOW_RE.test(lines[idx - 1])) return true;
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Extract fenced ```bash/```sh code blocks from markdown text.
|
||||
* @param {string} text
|
||||
* @returns {{ startLine: number, lines: string[] }[]}
|
||||
*/
|
||||
function extractBashBlocks(text) {
|
||||
const allLines = text.split(/\r?\n/);
|
||||
const blocks = [];
|
||||
let inBlock = false;
|
||||
let blockLines = [];
|
||||
let blockStart = 0;
|
||||
for (let i = 0; i < allLines.length; i += 1) {
|
||||
const line = allLines[i];
|
||||
if (!inBlock && FENCE_RE.test(line.trim())) {
|
||||
inBlock = true;
|
||||
blockLines = [];
|
||||
blockStart = i + 2; // first line INSIDE the block is 1-indexed i+2
|
||||
continue;
|
||||
}
|
||||
if (inBlock && FENCE_END_RE.test(line.trim())) {
|
||||
blocks.push({ startLine: blockStart, lines: blockLines });
|
||||
inBlock = false;
|
||||
continue;
|
||||
}
|
||||
if (inBlock) blockLines.push(line);
|
||||
}
|
||||
return blocks;
|
||||
}
|
||||
|
||||
/**
|
||||
* Pure: find every un-scoped, token-comparison `grep "^key:"` invocation in a
|
||||
* single fenced bash/sh block's lines. Returns `{ line, key, snippet }[]`
|
||||
* (line numbers relative to the block's startLine, already offset by caller).
|
||||
* @param {string[]} lines
|
||||
* @returns {{ lineIndex: number, key: string, snippet: string }[]}
|
||||
*/
|
||||
function findBroadGrepsInBlock(lines) {
|
||||
const findings = [];
|
||||
// Variables assigned from a grep-key capture on this block, so a later
|
||||
// `==`/`case` use of that variable (without an intervening scope/-m1) also
|
||||
// counts as "used for exact-token comparison".
|
||||
const capturedVars = new Set();
|
||||
let scopeSeenAt = -1;
|
||||
|
||||
for (let i = 0; i < lines.length; i += 1) {
|
||||
const line = lines[i];
|
||||
|
||||
if (FRONTMATTER_SCOPE_RE.test(line)) {
|
||||
scopeSeenAt = i;
|
||||
}
|
||||
|
||||
const m = line.match(GREP_KEY_RE);
|
||||
if (!m) continue;
|
||||
const [, options, , key] = m;
|
||||
if (hasSingleMatchGuard(line, options)) continue;
|
||||
if (isSuppressed(lines, i)) continue;
|
||||
// Scoping must appear strictly before this grep line in the same block.
|
||||
const scoped = scopeSeenAt !== -1 && scopeSeenAt <= i;
|
||||
if (scoped) continue;
|
||||
|
||||
const pipedToTokenTool = /\|\s*(cut|tr)\b/.test(line);
|
||||
const assignMatch = line.match(/^\s*(?:export\s+)?([A-Za-z_][\w]*)=\$\(/);
|
||||
if (assignMatch) capturedVars.add(assignMatch[1]);
|
||||
|
||||
let comparedLater = false;
|
||||
if (assignMatch) {
|
||||
const varName = assignMatch[1];
|
||||
for (let j = i + 1; j < lines.length; j += 1) {
|
||||
if (
|
||||
new RegExp(`\\$\\{?${varName}\\}?"?\\s*(==|!=)`).test(lines[j])
|
||||
|| new RegExp(`case\\s+"?\\$\\{?${varName}\\}?"?\\s+in`).test(lines[j])
|
||||
) {
|
||||
comparedLater = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (pipedToTokenTool || comparedLater) {
|
||||
findings.push({ lineIndex: i, key, snippet: line.trim() });
|
||||
}
|
||||
}
|
||||
return findings;
|
||||
}
|
||||
|
||||
function walkMarkdown(dir) {
|
||||
const out = [];
|
||||
let entries;
|
||||
try {
|
||||
entries = fs.readdirSync(dir, { withFileTypes: true });
|
||||
} catch {
|
||||
return out; // a missing root is not an error — some surfaces are optional
|
||||
}
|
||||
for (const entry of entries) {
|
||||
const full = path.join(dir, entry.name);
|
||||
if (entry.isDirectory()) out.push(...walkMarkdown(full));
|
||||
else if (entry.isFile() && entry.name.endsWith('.md')) out.push(full);
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
/**
|
||||
* Scan the given roots (repo-relative) for un-scoped frontmatter-scalar
|
||||
* broad-greps.
|
||||
* @param {string[]} roots
|
||||
* @returns {{ file: string, line: number, key: string, snippet: string }[]}
|
||||
*/
|
||||
function scan(roots = DEFAULT_ROOTS) {
|
||||
const offenders = [];
|
||||
for (const rel of roots) {
|
||||
const abs = path.isAbsolute(rel) ? rel : path.join(ROOT, rel);
|
||||
for (const file of walkMarkdown(abs)) {
|
||||
const blocks = extractBashBlocks(fs.readFileSync(file, 'utf8'));
|
||||
for (const block of blocks) {
|
||||
for (const finding of findBroadGrepsInBlock(block.lines)) {
|
||||
offenders.push({
|
||||
file: path.relative(ROOT, file),
|
||||
line: block.startLine + finding.lineIndex,
|
||||
key: finding.key,
|
||||
snippet: finding.snippet,
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return offenders;
|
||||
}
|
||||
|
||||
function main() {
|
||||
const rootsEnv = process.env.GSD_LINT_FRONTMATTER_SCALAR_ROOTS;
|
||||
const roots = rootsEnv ? rootsEnv.split(path.delimiter).filter(Boolean) : DEFAULT_ROOTS;
|
||||
const offenders = scan(roots);
|
||||
if (offenders.length > 0) {
|
||||
const detail = offenders.map((o) => ` ${o.file}:${o.line} ${o.snippet}`).join('\n');
|
||||
throw new ExitError(
|
||||
1,
|
||||
'lint-frontmatter-scalar-broad-grep: `grep "^key:"` over the whole file, compared to an\n'
|
||||
+ 'exact token, with no frontmatter scoping and no -m1 (DEFECT.FRONTMATTER-SCALAR-BROAD-GREP).\n'
|
||||
+ 'A body line beginning `key:` is enough to break this. Scope to the frontmatter block:\n'
|
||||
+ ' sed -n \'/^---$/,/^---$/p\' "$f" | grep -m1 "^<key>:" | cut -d: -f2 | tr -d \' \'\n'
|
||||
+ 'or add `# lint-allow: frontmatter-scalar-broad-grep — <reason>` if this is a genuine\n'
|
||||
+ 'whole-body scan:\n'
|
||||
+ detail,
|
||||
);
|
||||
}
|
||||
console.log(`ok lint-frontmatter-scalar-broad-grep: no un-scoped frontmatter-scalar greps in ${roots.length} root(s)`);
|
||||
}
|
||||
|
||||
module.exports = { findBroadGrepsInBlock, extractBashBlocks, scan, DEFAULT_ROOTS };
|
||||
|
||||
if (require.main === module) runMain(main);
|
||||
208
scripts/lint-removed-but-needed.cjs
Normal file
208
scripts/lint-removed-but-needed.cjs
Normal file
@@ -0,0 +1,208 @@
|
||||
#!/usr/bin/env node
|
||||
'use strict';
|
||||
|
||||
/**
|
||||
* lint-removed-but-needed.cjs — DEFECT.REMOVED-BUT-NEEDED (CONTEXT.md).
|
||||
*
|
||||
* ## Why
|
||||
*
|
||||
* A file/key gets removed because "no longer used" without verifying every
|
||||
* consumer (workflows, docs, manifests, npm scripts). #3316: root
|
||||
* `package-lock.json` was deleted while `package.json` still declares deps
|
||||
* and workflows still use `cache: 'npm'` + `npm ci` (which require a
|
||||
* lockfile). e3b52c70: docs referenced a removed `/gsd-new-workspace`
|
||||
* workflow after it was deleted.
|
||||
*
|
||||
* ## What this checks
|
||||
*
|
||||
* For every file deleted (`git diff --name-status <base>...HEAD`, status
|
||||
* `D`), grep the post-diff tree (`.github/workflows/`, `gsd-core/`, `docs/`,
|
||||
* `package.json`) for the deleted file's basename. Fails if any reference
|
||||
* survives. `package-lock.json` deletions additionally fail if any workflow
|
||||
* still uses `npm ci` or `cache: 'npm'`/`cache: "npm"` — those depend on a
|
||||
* lockfile even though they never spell out its filename.
|
||||
*
|
||||
* ## False-positive risk (moderate, per audit)
|
||||
*
|
||||
* A common basename (`index.js`, `config.json`) can coincidentally match an
|
||||
* unrelated file, and this only catches LITERAL string references — not a
|
||||
* variable holding the filename or a glob that happened to match it.
|
||||
*/
|
||||
|
||||
const fs = require('node:fs');
|
||||
const path = require('node:path');
|
||||
const cp = require('node:child_process');
|
||||
const { ExitError, runMain } = require('./lib/cli-exit.cjs');
|
||||
|
||||
const ROOT = path.join(__dirname, '..');
|
||||
const SCAN_ROOTS = ['.github/workflows', 'gsd-core', 'docs'];
|
||||
const EXTRA_FILES = ['package.json'];
|
||||
|
||||
// Skip these when walking SCAN_ROOTS — binary/generated content that can
|
||||
// never carry a meaningful basename reference, and is often large.
|
||||
const SKIP_EXT = new Set(['.png', '.jpg', '.jpeg', '.gif', '.ico', '.woff', '.woff2', '.ttf', '.zip']);
|
||||
|
||||
function escapeRegex(s) {
|
||||
return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
|
||||
}
|
||||
|
||||
/**
|
||||
* Pure: does `content` contain a literal reference to `basename`, delimited
|
||||
* by non-identifier/non-path characters on both sides (so "foo.json" doesn't
|
||||
* match inside "old-foo.json.bak" style names but does match in a normal
|
||||
* path/prose context)?
|
||||
* @param {string} content
|
||||
* @param {string} basename
|
||||
* @returns {boolean}
|
||||
*/
|
||||
function referencesBasename(content, basename) {
|
||||
const re = new RegExp(`(^|[^\\w.-])${escapeRegex(basename)}($|[^\\w.-])`);
|
||||
return re.test(content);
|
||||
}
|
||||
|
||||
/**
|
||||
* Pure: given the deleted file's basename, does content contain a
|
||||
* lockfile-dependent idiom (`npm ci`, `cache: 'npm'` / `cache: "npm"`)?
|
||||
* Only meaningful for package-lock.json deletions.
|
||||
* @param {string} content
|
||||
* @returns {boolean}
|
||||
*/
|
||||
function referencesNpmLockfileDependency(content) {
|
||||
return /\bnpm ci\b/.test(content) || /cache:\s*['"]npm['"]/.test(content);
|
||||
}
|
||||
|
||||
function walk(dir) {
|
||||
const out = [];
|
||||
let entries;
|
||||
try {
|
||||
entries = fs.readdirSync(dir, { withFileTypes: true });
|
||||
} catch {
|
||||
return out;
|
||||
}
|
||||
for (const entry of entries) {
|
||||
const full = path.join(dir, entry.name);
|
||||
if (entry.isDirectory()) out.push(...walk(full));
|
||||
else if (entry.isFile() && !SKIP_EXT.has(path.extname(entry.name))) out.push(full);
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
/**
|
||||
* Pure: given a list of deleted basenames and a `{ file, content }[]` corpus
|
||||
* of the post-diff tree, find every surviving reference.
|
||||
* @param {string[]} deletedFiles - repo-relative deleted paths
|
||||
* @param {{ file: string, content: string }[]} corpus
|
||||
* @returns {{ deletedFile: string, referencedIn: string, reason: string }[]}
|
||||
*/
|
||||
function findSurvivingReferences(deletedFiles, corpus) {
|
||||
const violations = [];
|
||||
for (const deletedFile of deletedFiles) {
|
||||
const basename = path.basename(deletedFile);
|
||||
for (const { file, content } of corpus) {
|
||||
if (referencesBasename(content, basename)) {
|
||||
violations.push({ deletedFile, referencedIn: file, reason: `basename '${basename}' still referenced` });
|
||||
}
|
||||
}
|
||||
if (basename === 'package-lock.json') {
|
||||
for (const { file, content } of corpus) {
|
||||
if (file.startsWith('.github/workflows') && referencesNpmLockfileDependency(content)) {
|
||||
violations.push({
|
||||
deletedFile,
|
||||
referencedIn: file,
|
||||
reason: '`npm ci` / `cache: \'npm\'` still present — both require a lockfile',
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return violations;
|
||||
}
|
||||
|
||||
function getDeletedFiles(root, baseRef) {
|
||||
// Deliberately let a git failure (unresolvable ref, no merge base, etc.)
|
||||
// propagate as a plain Error — main() treats ANY scan() failure as "cannot
|
||||
// resolve this base ref in this environment" and degrades to a skip,
|
||||
// matching lint-fix-has-regression-test.cjs. There is no failure mode here
|
||||
// that should hard-exit non-zero; a real drift is only ever reported once
|
||||
// the diff succeeds and findSurvivingReferences finds a violation.
|
||||
const out = cp.execFileSync('git', ['diff', '--name-status', `${baseRef}...HEAD`], {
|
||||
cwd: root,
|
||||
encoding: 'utf8',
|
||||
timeout: 15000,
|
||||
});
|
||||
return out
|
||||
.trim()
|
||||
.split('\n')
|
||||
.filter(Boolean)
|
||||
.filter((line) => line.startsWith('D\t'))
|
||||
.map((line) => line.slice(2));
|
||||
}
|
||||
|
||||
function buildCorpus(root) {
|
||||
const corpus = [];
|
||||
for (const rel of SCAN_ROOTS) {
|
||||
for (const abs of walk(path.join(root, rel))) {
|
||||
try {
|
||||
corpus.push({ file: path.relative(root, abs).replace(/\\/g, '/'), content: fs.readFileSync(abs, 'utf8') });
|
||||
} catch {
|
||||
// unreadable (broken symlink, binary that slipped past SKIP_EXT) — skip
|
||||
}
|
||||
}
|
||||
}
|
||||
for (const rel of EXTRA_FILES) {
|
||||
const abs = path.join(root, rel);
|
||||
try {
|
||||
corpus.push({ file: rel, content: fs.readFileSync(abs, 'utf8') });
|
||||
} catch {
|
||||
// optional file absent — skip
|
||||
}
|
||||
}
|
||||
return corpus;
|
||||
}
|
||||
|
||||
function scan(root, baseRef) {
|
||||
const deletedFiles = getDeletedFiles(root, baseRef);
|
||||
if (deletedFiles.length === 0) return [];
|
||||
const corpus = buildCorpus(root);
|
||||
return findSurvivingReferences(deletedFiles, corpus);
|
||||
}
|
||||
|
||||
function main() {
|
||||
const baseRef = `origin/${process.env.GSD_REMOVED_BUT_NEEDED_BASE || process.env.GITHUB_BASE_REF || 'next'}`;
|
||||
let violations;
|
||||
try {
|
||||
violations = scan(ROOT, baseRef);
|
||||
} catch (e) {
|
||||
// origin/<base> unreachable in this environment (e.g. a shallow local
|
||||
// clone with no matching remote-tracking ref) — degrade to a skip rather
|
||||
// than a false failure, matching lint-fix-has-regression-test.cjs.
|
||||
console.log(`lint-removed-but-needed: could not resolve ${baseRef}, skipping (${e.message})`);
|
||||
return;
|
||||
}
|
||||
if (violations.length > 0) {
|
||||
const detail = violations
|
||||
.map((v) => ` ${v.deletedFile} deleted, but still referenced in ${v.referencedIn}: ${v.reason}`)
|
||||
.join('\n');
|
||||
throw new ExitError(
|
||||
1,
|
||||
'lint-removed-but-needed: a deleted file is still referenced by a live consumer\n'
|
||||
+ '(DEFECT.REMOVED-BUT-NEEDED). Either restore the file or update every consumer in the\n'
|
||||
+ 'same commit — do not paper over with a workaround that loses reproducibility:\n'
|
||||
+ detail,
|
||||
);
|
||||
}
|
||||
console.log('ok lint-removed-but-needed: no deleted file has a surviving reference');
|
||||
}
|
||||
|
||||
module.exports = {
|
||||
referencesBasename,
|
||||
referencesNpmLockfileDependency,
|
||||
findSurvivingReferences,
|
||||
getDeletedFiles,
|
||||
buildCorpus,
|
||||
scan,
|
||||
SCAN_ROOTS,
|
||||
EXTRA_FILES,
|
||||
};
|
||||
|
||||
if (require.main === module) runMain(main);
|
||||
@@ -364,6 +364,7 @@ function recentCommitMessages(projectDir: string): string {
|
||||
encoding: 'utf-8',
|
||||
maxBuffer: 4 * 1024 * 1024,
|
||||
windowsHide: true,
|
||||
timeout: 15_000,
|
||||
});
|
||||
} catch {
|
||||
return '';
|
||||
@@ -663,6 +664,7 @@ function computeUiSafetyGate(projectDir: string, phase: string): {
|
||||
encoding: 'utf-8',
|
||||
maxBuffer: 2 * 1024 * 1024,
|
||||
windowsHide: true,
|
||||
timeout: 10_000,
|
||||
});
|
||||
hasUiFiles = changed.split('\n').some((f) =>
|
||||
f.trim() && (UI_FILE_EXTENSIONS_RE.test(f) || UI_PATH_PATTERNS_RE.test(f)),
|
||||
@@ -821,7 +823,7 @@ function cmdTddReviewCheckpoint(projectDir: string, args: string[], raw: boolean
|
||||
try {
|
||||
const redCommit = execFileSync(
|
||||
'git', ['log', '--oneline', `--grep=^test(${planId}):`, '--', '.'],
|
||||
{ cwd: projectDir, encoding: 'utf-8', maxBuffer: 1024 * 1024, windowsHide: true },
|
||||
{ cwd: projectDir, encoding: 'utf-8', maxBuffer: 1024 * 1024, windowsHide: true, timeout: 10_000 },
|
||||
);
|
||||
red = redCommit.trim().length > 0;
|
||||
} catch { /* git unavailable or no match */ }
|
||||
@@ -829,7 +831,7 @@ function cmdTddReviewCheckpoint(projectDir: string, args: string[], raw: boolean
|
||||
try {
|
||||
const greenCommit = execFileSync(
|
||||
'git', ['log', '--oneline', `--grep=^feat(${planId}):`, '--', '.'],
|
||||
{ cwd: projectDir, encoding: 'utf-8', maxBuffer: 1024 * 1024, windowsHide: true },
|
||||
{ cwd: projectDir, encoding: 'utf-8', maxBuffer: 1024 * 1024, windowsHide: true, timeout: 10_000 },
|
||||
);
|
||||
green = greenCommit.trim().length > 0;
|
||||
} catch { /* git unavailable or no match */ }
|
||||
@@ -837,7 +839,7 @@ function cmdTddReviewCheckpoint(projectDir: string, args: string[], raw: boolean
|
||||
try {
|
||||
const refactorCommit = execFileSync(
|
||||
'git', ['log', '--oneline', `--grep=^refactor(${planId}):`, '--', '.'],
|
||||
{ cwd: projectDir, encoding: 'utf-8', maxBuffer: 1024 * 1024, windowsHide: true },
|
||||
{ cwd: projectDir, encoding: 'utf-8', maxBuffer: 1024 * 1024, windowsHide: true, timeout: 10_000 },
|
||||
);
|
||||
refactor = refactorCommit.trim().length > 0;
|
||||
} catch { /* git unavailable or no match */ }
|
||||
|
||||
@@ -490,7 +490,7 @@ function applyMigration(cwd: string, plan: MigrationPlan, options: { dryRun?: bo
|
||||
// ── Real run: verify clean working tree ───────────────────────────────────
|
||||
let gitStatus: string;
|
||||
try {
|
||||
gitStatus = execSync('git status --porcelain', { cwd, encoding: 'utf8', windowsHide: true });
|
||||
gitStatus = execSync('git status --porcelain', { cwd, encoding: 'utf8', windowsHide: true, timeout: 10_000 });
|
||||
} catch (err) {
|
||||
throw new Error(`git status failed: ${(err as Error).message}`);
|
||||
}
|
||||
|
||||
@@ -791,6 +791,7 @@ export function probeTty(opts: { platform?: string } = {}): string | null {
|
||||
const ttyPath = childProcess.execFileSync('tty', [], {
|
||||
encoding: 'utf-8',
|
||||
stdio: ['inherit', 'pipe', 'ignore'],
|
||||
timeout: 5_000,
|
||||
}).trim();
|
||||
if (!ttyPath || ttyPath === 'not a tty') return null;
|
||||
return ttyPath;
|
||||
|
||||
@@ -187,6 +187,7 @@ function readGitSignals(cwd: string): GitSignals {
|
||||
maxBuffer: 4 * 1024 * 1024,
|
||||
windowsHide: true,
|
||||
stdio: ['pipe', 'pipe', 'pipe'],
|
||||
timeout: 10_000,
|
||||
});
|
||||
} catch {
|
||||
return '';
|
||||
|
||||
109
tests/canary-version-leak-lint.test.cjs
Normal file
109
tests/canary-version-leak-lint.test.cjs
Normal file
@@ -0,0 +1,109 @@
|
||||
'use strict';
|
||||
process.env.GSD_TEST_MODE = '1';
|
||||
|
||||
/**
|
||||
* Canary-version-leak lint (DEFECT.CANARY-VERSION-LEAK, CONTEXT.md).
|
||||
*
|
||||
* scripts/lint-canary-version-leak.cjs fails a run whose package.json
|
||||
* .version carries a -canary.<N> suffix — that suffix belongs to a dev
|
||||
* branch only and must never land on main (2026-05-16 audit: origin/main at
|
||||
* "1.50.0-canary.0", commit 2d32ad82, #3206). Wired into
|
||||
* .github/workflows/version-gate.yml, gated to PRs targeting main.
|
||||
*/
|
||||
|
||||
const { test, describe } = require('node:test');
|
||||
const assert = require('node:assert/strict');
|
||||
const fs = require('node:fs');
|
||||
const os = require('node:os');
|
||||
const path = require('node:path');
|
||||
const fc = require('fast-check');
|
||||
|
||||
const ROOT = path.join(__dirname, '..');
|
||||
const LINT_SCRIPT = path.join(ROOT, 'scripts', 'lint-canary-version-leak.cjs');
|
||||
const { isCanaryVersion, readPackageVersion } = require(LINT_SCRIPT);
|
||||
const { cleanup } = require('./helpers.cjs');
|
||||
const { runNode } = require('./helpers/process-seam.cjs');
|
||||
|
||||
describe('canary-version-leak lint: isCanaryVersion (pure)', () => {
|
||||
test('a plain release version is not canary', () => {
|
||||
assert.equal(isCanaryVersion('1.8.0'), false);
|
||||
});
|
||||
|
||||
test('a -canary.<N> version IS flagged', () => {
|
||||
assert.equal(isCanaryVersion('1.8.0-canary.3'), true);
|
||||
});
|
||||
|
||||
test('boundary: -canary.0 (N=0) is flagged', () => {
|
||||
assert.equal(isCanaryVersion('1.50.0-canary.0'), true);
|
||||
});
|
||||
|
||||
test('a non-canary prerelease suffix (e.g. -rc.1) is not flagged', () => {
|
||||
assert.equal(isCanaryVersion('1.8.0-rc.1'), false);
|
||||
});
|
||||
|
||||
test('non-string input is not flagged (fails closed to false, main() handles missing version separately)', () => {
|
||||
assert.equal(isCanaryVersion(undefined), false);
|
||||
assert.equal(isCanaryVersion(null), false);
|
||||
});
|
||||
|
||||
test('property: appending -canary.<N> to any base string always flags it', () => {
|
||||
fc.assert(
|
||||
fc.property(
|
||||
fc.string().filter((s) => !/-canary\.\d+/.test(s)),
|
||||
fc.nat(),
|
||||
(base, n) => {
|
||||
assert.equal(isCanaryVersion(`${base}-canary.${n}`), true);
|
||||
},
|
||||
),
|
||||
);
|
||||
});
|
||||
|
||||
test('property: a version with no "-canary." substring is never flagged', () => {
|
||||
fc.assert(
|
||||
fc.property(
|
||||
fc.string().filter((s) => !s.includes('-canary.')),
|
||||
(version) => {
|
||||
assert.equal(isCanaryVersion(version), false);
|
||||
},
|
||||
),
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
describe('canary-version-leak lint: the live repo package.json is clean', () => {
|
||||
test('readPackageVersion + isCanaryVersion pass against the real package.json', () => {
|
||||
const version = readPackageVersion(ROOT);
|
||||
assert.equal(typeof version, 'string');
|
||||
assert.equal(isCanaryVersion(version), false, `package.json version '${version}' must not carry -canary.<N>`);
|
||||
});
|
||||
});
|
||||
|
||||
describe('canary-version-leak lint: main() end-to-end wiring', () => {
|
||||
function writeFixtureRoot(version) {
|
||||
const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'gsd-canary-lint-e2e-'));
|
||||
fs.writeFileSync(path.join(tmpDir, 'package.json'), JSON.stringify({ name: 'fixture', version }), 'utf8');
|
||||
return tmpDir;
|
||||
}
|
||||
|
||||
test('exit 0 on a clean version (real package.json, 1.8.0)', () => {
|
||||
const result = runNode([LINT_SCRIPT], { cwd: ROOT });
|
||||
assert.equal(result.exitCode, 0, `expected exit 0, got ${result.exitCode}: ${result.stderr}`);
|
||||
});
|
||||
|
||||
test('exit 1 on a fixture package.json carrying a -canary.<N> suffix (never touches the real package.json)', (t) => {
|
||||
const tmpDir = writeFixtureRoot('1.8.0-canary.3');
|
||||
t.after(() => cleanup(tmpDir));
|
||||
|
||||
// The script resolves its target as `<script-dir>/../package.json`, so
|
||||
// run a throwaway copy of the script from inside the fixture root
|
||||
// rather than mutating the real repo's package.json.
|
||||
const scriptCopyDir = path.join(tmpDir, 'scripts');
|
||||
fs.mkdirSync(scriptCopyDir, { recursive: true });
|
||||
const scriptCopy = path.join(scriptCopyDir, 'lint-canary-version-leak.cjs');
|
||||
fs.copyFileSync(LINT_SCRIPT, scriptCopy);
|
||||
|
||||
const result = runNode([scriptCopy]);
|
||||
assert.equal(result.exitCode, 1, `expected exit 1, got ${result.exitCode}`);
|
||||
assert.match(result.stderr, /canary-version-leak/);
|
||||
});
|
||||
});
|
||||
@@ -7,7 +7,7 @@ const path = require('node:path');
|
||||
const fs = require('node:fs');
|
||||
const os = require('node:os');
|
||||
|
||||
const { evaluateLint, LINT_REASON, DEFAULT_BASE: CHANGESET_DEFAULT_BASE } = require(path.join(__dirname, '..', 'scripts', 'changeset', 'lint.cjs'));
|
||||
const { evaluateLint, LINT_REASON, findPrFieldDrift, DEFAULT_BASE: CHANGESET_DEFAULT_BASE } = require(path.join(__dirname, '..', 'scripts', 'changeset', 'lint.cjs'));
|
||||
const { DEFAULT_BASE: DOCS_DEFAULT_BASE } = require(path.join(__dirname, '..', 'scripts', 'lint-docs-required.cjs'));
|
||||
|
||||
const ROOT = path.join(__dirname, '..');
|
||||
@@ -87,6 +87,31 @@ function runLint(repoDir) {
|
||||
return { status: result.exitCode, report };
|
||||
}
|
||||
|
||||
/**
|
||||
* Like runLint, but with a real GITHUB_EVENT_PATH pointing at a synthetic PR
|
||||
* event payload — needed to exercise DEFECT.CHANGESET-PR-FIELD-DRIFT, which
|
||||
* compares each fragment's `pr:` against `event.pull_request.number`.
|
||||
* @param {string} repoDir
|
||||
* @param {number|undefined} prNumber - omit to simulate a push/non-PR run
|
||||
* (no `pull_request` key in the payload at all).
|
||||
*/
|
||||
function runLintWithPrEvent(repoDir, prNumber) {
|
||||
const eventPath = path.join(repoDir, 'event.json');
|
||||
const payload = prNumber === undefined ? {} : { pull_request: { number: prNumber, labels: [] } };
|
||||
fs.writeFileSync(eventPath, JSON.stringify(payload));
|
||||
const result = runNode(
|
||||
[LINT_SCRIPT, '--json'],
|
||||
{
|
||||
cwd: repoDir,
|
||||
env: { ...process.env, GITHUB_BASE_REF: 'main', GITHUB_EVENT_PATH: eventPath },
|
||||
timeoutMs: PROBE_TIMEOUT_MS,
|
||||
},
|
||||
);
|
||||
let report = {};
|
||||
try { report = JSON.parse(result.stdout); } catch { /* leave as empty object */ }
|
||||
return { status: result.exitCode, report };
|
||||
}
|
||||
|
||||
// evaluateLint is a pure function over file lists + label list — no fs, no git.
|
||||
// Tests assert on the structured verdict: { ok: bool, reason: LINT_REASON.X }.
|
||||
|
||||
@@ -94,7 +119,10 @@ describe('changeset lint: pure verdict (#2975)', () => {
|
||||
test('LINT_REASON enum exposes the documented codes', () => {
|
||||
assert.deepEqual(
|
||||
Object.keys(LINT_REASON).sort(),
|
||||
['OK_FRAGMENT_PRESENT', 'OK_NO_USER_FACING_CHANGES', 'OK_OPT_OUT_LABEL', 'FAIL_MISSING_FRAGMENT', 'FAIL_INVALID_FRAGMENT'].sort(),
|
||||
[
|
||||
'OK_FRAGMENT_PRESENT', 'OK_NO_USER_FACING_CHANGES', 'OK_OPT_OUT_LABEL',
|
||||
'FAIL_MISSING_FRAGMENT', 'FAIL_INVALID_FRAGMENT', 'FAIL_PR_FIELD_DRIFT',
|
||||
].sort(),
|
||||
);
|
||||
});
|
||||
|
||||
@@ -175,6 +203,57 @@ describe('changeset lint: pure verdict (#2975)', () => {
|
||||
assert.equal(verdict.ok, false);
|
||||
assert.equal(verdict.reason, LINT_REASON.FAIL_INVALID_FRAGMENT);
|
||||
});
|
||||
|
||||
test('FAIL_PR_FIELD_DRIFT when prFieldDrift is non-empty, even with a fragment present', () => {
|
||||
const verdict = evaluateLint({
|
||||
changedFiles: ['.changeset/good.md'],
|
||||
labels: [],
|
||||
prFieldDrift: [{ file: '.changeset/good.md', found: 1234, expected: 1240 }],
|
||||
});
|
||||
assert.equal(verdict.ok, false);
|
||||
assert.equal(verdict.reason, LINT_REASON.FAIL_PR_FIELD_DRIFT);
|
||||
assert.deepEqual(verdict.drift, [{ file: '.changeset/good.md', found: 1234, expected: 1240 }]);
|
||||
});
|
||||
|
||||
test('FAIL_INVALID_FRAGMENT beats FAIL_PR_FIELD_DRIFT (checked first)', () => {
|
||||
const verdict = evaluateLint({
|
||||
changedFiles: ['.changeset/bad.md'],
|
||||
labels: [],
|
||||
fragmentFailures: [{ file: '.changeset/bad.md', reason: 'invalid_pr', detail: '0' }],
|
||||
prFieldDrift: [{ file: '.changeset/bad.md', found: 1, expected: 2 }],
|
||||
});
|
||||
assert.equal(verdict.reason, LINT_REASON.FAIL_INVALID_FRAGMENT);
|
||||
});
|
||||
});
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// DEFECT.CHANGESET-PR-FIELD-DRIFT (#3316, #3325): a fragment's pr: field is a
|
||||
// guess (issue number, stacked-PR leftover) that never got backfilled to the
|
||||
// real PR number.
|
||||
// ---------------------------------------------------------------------------
|
||||
describe('changeset lint: findPrFieldDrift (pure)', () => {
|
||||
test('a fragment whose pr matches the real PR number is not drift', () => {
|
||||
assert.deepEqual(findPrFieldDrift([{ file: '.changeset/good.md', pr: 1234 }], 1234), []);
|
||||
});
|
||||
|
||||
test('a fragment whose pr disagrees with the real PR number IS flagged, naming the file', () => {
|
||||
const drift = findPrFieldDrift([{ file: '.changeset/stale.md', pr: 1234 }], 1240);
|
||||
assert.deepEqual(drift, [{ file: '.changeset/stale.md', found: 1234, expected: 1240 }]);
|
||||
});
|
||||
|
||||
test('realPrNumber === null (no PR event payload) always yields no drift — push/non-PR runs never fail', () => {
|
||||
assert.deepEqual(findPrFieldDrift([{ file: '.changeset/anything.md', pr: 999 }], null), []);
|
||||
});
|
||||
|
||||
test('a pr: 0 placeholder entry is silent even when it disagrees with a real, non-zero PR number', () => {
|
||||
// CONTRIBUTING.md documents pr:0 as the deliberate placeholder used
|
||||
// "during initial commit" before the real PR number is backfilled — it
|
||||
// is unbackfilled, not drifted, so it must never be flagged. (In the
|
||||
// real main() wiring, parseFragment already rejects pr:0 upstream as
|
||||
// invalid_pr before a fragment reaches this function at all — this test
|
||||
// locks in the pure function's own contract independent of that.)
|
||||
assert.deepEqual(findPrFieldDrift([{ file: '.changeset/placeholder.md', pr: 0 }], 1234), []);
|
||||
});
|
||||
});
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
@@ -315,3 +394,76 @@ describe('#2988: changeset + docs lints resolve the same local base fallback', (
|
||||
`the two lints must not diverge on base resolution: changeset='${CHANGESET_DEFAULT_BASE}' docs='${DOCS_DEFAULT_BASE}'`);
|
||||
});
|
||||
});
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// DEFECT.CHANGESET-PR-FIELD-DRIFT end-to-end: real main() wiring reading
|
||||
// GITHUB_EVENT_PATH's pull_request.number and comparing it against each
|
||||
// changed fragment's pr: field.
|
||||
// ---------------------------------------------------------------------------
|
||||
describe('changeset lint: PR-field-drift end-to-end wiring', () => {
|
||||
test('correct pr: (matches the real PR number) passes the gate', (t) => {
|
||||
const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'gsd-lint-e2e-'));
|
||||
t.after(() => cleanup(tmpDir));
|
||||
|
||||
buildTempRepo(tmpDir, [
|
||||
{ file: 'bin/thing.js', content: '// placeholder\n' },
|
||||
{ file: '.changeset/good.md', content: '---\ntype: Fixed\npr: 4242\n---\n**Good** fix. (#4242)\n' },
|
||||
]);
|
||||
|
||||
const { status, report } = runLintWithPrEvent(tmpDir, 4242);
|
||||
|
||||
assert.equal(status, 0, `expected exit 0, got ${status}: ${JSON.stringify(report)}`);
|
||||
assert.equal(report.reason, LINT_REASON.OK_FRAGMENT_PRESENT);
|
||||
});
|
||||
|
||||
test('wrong pr: (stale/guessed number) fails the gate, naming the offending file', (t) => {
|
||||
const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'gsd-lint-e2e-'));
|
||||
t.after(() => cleanup(tmpDir));
|
||||
|
||||
buildTempRepo(tmpDir, [
|
||||
{ file: 'bin/thing.js', content: '// placeholder\n' },
|
||||
{ file: '.changeset/stale.md', content: '---\ntype: Fixed\npr: 3312\n---\n**Stale pr field** fix. (#3316)\n' },
|
||||
]);
|
||||
|
||||
const { status, report } = runLintWithPrEvent(tmpDir, 3316);
|
||||
|
||||
assert.equal(status, 1, `expected exit 1, got ${status}`);
|
||||
assert.equal(report.reason, LINT_REASON.FAIL_PR_FIELD_DRIFT);
|
||||
assert.ok(Array.isArray(report.drift), 'drift must be an array');
|
||||
const entry = report.drift.find((d) => d.file.endsWith('.changeset/stale.md'));
|
||||
assert.ok(entry, `drift must name the offending file, got: ${JSON.stringify(report.drift)}`);
|
||||
assert.equal(entry.found, 3312);
|
||||
assert.equal(entry.expected, 3316);
|
||||
});
|
||||
|
||||
test('no PR event payload (push / non-PR run) skips the drift check entirely, even with a stale pr:', (t) => {
|
||||
const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'gsd-lint-e2e-'));
|
||||
t.after(() => cleanup(tmpDir));
|
||||
|
||||
buildTempRepo(tmpDir, [
|
||||
{ file: 'bin/thing.js', content: '// placeholder\n' },
|
||||
{ file: '.changeset/anything.md', content: '---\ntype: Fixed\npr: 999\n---\n**Anything** fix. (#999)\n' },
|
||||
]);
|
||||
|
||||
// runLint() (no override) sets GITHUB_EVENT_PATH: '' — no payload at all.
|
||||
const { status, report } = runLint(tmpDir);
|
||||
|
||||
assert.equal(status, 0, `expected exit 0, got ${status}: ${JSON.stringify(report)}`);
|
||||
assert.equal(report.reason, LINT_REASON.OK_FRAGMENT_PRESENT);
|
||||
});
|
||||
|
||||
test('event payload present but with no pull_request key (also push-shaped) skips the drift check', (t) => {
|
||||
const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'gsd-lint-e2e-'));
|
||||
t.after(() => cleanup(tmpDir));
|
||||
|
||||
buildTempRepo(tmpDir, [
|
||||
{ file: 'bin/thing.js', content: '// placeholder\n' },
|
||||
{ file: '.changeset/anything.md', content: '---\ntype: Fixed\npr: 999\n---\n**Anything** fix. (#999)\n' },
|
||||
]);
|
||||
|
||||
const { status, report } = runLintWithPrEvent(tmpDir, undefined);
|
||||
|
||||
assert.equal(status, 0, `expected exit 0, got ${status}: ${JSON.stringify(report)}`);
|
||||
assert.equal(report.reason, LINT_REASON.OK_FRAGMENT_PRESENT);
|
||||
});
|
||||
});
|
||||
|
||||
197
tests/default-flip-documentation-lint.test.cjs
Normal file
197
tests/default-flip-documentation-lint.test.cjs
Normal file
@@ -0,0 +1,197 @@
|
||||
'use strict';
|
||||
process.env.GSD_TEST_MODE = '1';
|
||||
|
||||
/**
|
||||
* Default-flip-documentation lint (DEFECT.DEFAULT-FLIP-DOCUMENTATION,
|
||||
* CONTEXT.md).
|
||||
*
|
||||
* scripts/lint-default-flip-documentation.cjs fails a PR that changes an
|
||||
* EXISTING default value in gsd-core/bin/shared/config-defaults.manifest.json
|
||||
* (the single source `CONFIG_DEFAULTS` loads at runtime) without a
|
||||
* `## Breaking Changes` PR-body section covering the migration semantics
|
||||
* (#3309: the v2 default flip from mid-flight to end-of-phase).
|
||||
*
|
||||
* Scope note: this check is deliberately narrower than the full DEFECT text
|
||||
* — it does NOT cover `buildNewProjectConfig`'s hardcoded object literal in
|
||||
* src/config.cts, because that literal mixes env-derived branches with
|
||||
* CONFIG_DEFAULTS spreads and cannot be reduced to a resolved value map from
|
||||
* source text alone without executing the compiled module at both refs. A
|
||||
* line/text diff of that literal would inherit the exact false-positive
|
||||
* risk (a harmless refactor reading as a "flip") this check exists to
|
||||
* avoid, so it is left out rather than shipped noisy. See the script's own
|
||||
* header comment for the full rationale.
|
||||
*/
|
||||
|
||||
const { test, describe } = require('node:test');
|
||||
const assert = require('node:assert/strict');
|
||||
const fs = require('node:fs');
|
||||
const os = require('node:os');
|
||||
const path = require('node:path');
|
||||
|
||||
const ROOT = path.join(__dirname, '..');
|
||||
const LINT_SCRIPT = path.join(ROOT, 'scripts', 'lint-default-flip-documentation.cjs');
|
||||
const { flatten, findDefaultValueChanges, evaluateDefaultFlipDoc, MANIFEST_PATH } = require(LINT_SCRIPT);
|
||||
const { cleanup } = require('./helpers.cjs');
|
||||
const { runNode } = require('./helpers/process-seam.cjs');
|
||||
const { gitOrThrow } = require('./helpers/git-fixture.cjs');
|
||||
|
||||
describe('default-flip-documentation lint: flatten (pure)', () => {
|
||||
test('flattens a nested object into dot-path leaves', () => {
|
||||
assert.deepEqual(
|
||||
flatten({ workflow: { human_verify_mode: 'end-of-phase' }, model_profile: 'balanced' }),
|
||||
{ 'workflow.human_verify_mode': 'end-of-phase', model_profile: 'balanced' },
|
||||
);
|
||||
});
|
||||
|
||||
test('an array is a leaf, not recursed into (reordering reads as one change, not N)', () => {
|
||||
assert.deepEqual(flatten({ tags: ['a', 'b'] }), { tags: ['a', 'b'] });
|
||||
});
|
||||
});
|
||||
|
||||
describe('default-flip-documentation lint: findDefaultValueChanges (pure)', () => {
|
||||
test('the real #3309 defect shape IS a change: an existing key value differs', () => {
|
||||
const changes = findDefaultValueChanges(
|
||||
{ 'workflow.human_verify_mode': 'mid-flight' },
|
||||
{ 'workflow.human_verify_mode': 'end-of-phase' },
|
||||
);
|
||||
assert.deepEqual(changes, [{ key: 'workflow.human_verify_mode', from: 'mid-flight', to: 'end-of-phase' }]);
|
||||
});
|
||||
|
||||
test('LOOKALIKE: a brand-new key (addition, not a flip) is NOT a change', () => {
|
||||
const changes = findDefaultValueChanges({ a: 1 }, { a: 1, b: 2 });
|
||||
assert.deepEqual(changes, []);
|
||||
});
|
||||
|
||||
test('LOOKALIKE: a removed key (not a flip either) is NOT a change', () => {
|
||||
const changes = findDefaultValueChanges({ a: 1, b: 2 }, { a: 1 });
|
||||
assert.deepEqual(changes, []);
|
||||
});
|
||||
|
||||
test('LOOKALIKE: the whole object reordered/restructured with identical resolved values is NOT a change (the false-positive the audit called out)', () => {
|
||||
const base = { workflow: { a: 1, b: 2 }, git: { create_tag: true } };
|
||||
const head = { git: { create_tag: true }, workflow: { b: 2, a: 1 } };
|
||||
assert.deepEqual(findDefaultValueChanges(flatten(base), flatten(head)), []);
|
||||
});
|
||||
|
||||
test('an unchanged value is not reported', () => {
|
||||
assert.deepEqual(findDefaultValueChanges({ a: 1 }, { a: 1 }), []);
|
||||
});
|
||||
});
|
||||
|
||||
describe('default-flip-documentation lint: evaluateDefaultFlipDoc (pure)', () => {
|
||||
test('no changes: always ok regardless of PR body', () => {
|
||||
assert.equal(evaluateDefaultFlipDoc([], '').ok, true);
|
||||
});
|
||||
|
||||
test('a real flip with no Breaking Changes section in the PR body fails', () => {
|
||||
const verdict = evaluateDefaultFlipDoc([{ key: 'x', from: 1, to: 2 }], 'just a normal PR description');
|
||||
assert.equal(verdict.ok, false);
|
||||
});
|
||||
|
||||
test('a real flip WITH a "## Breaking Changes" heading in the PR body passes', () => {
|
||||
const verdict = evaluateDefaultFlipDoc(
|
||||
[{ key: 'x', from: 1, to: 2 }],
|
||||
'Summary\n\n## Breaking Changes\n\nNew default takes effect on config-set.',
|
||||
);
|
||||
assert.equal(verdict.ok, true);
|
||||
});
|
||||
|
||||
test('the heading match is case-insensitive and tolerates heading level', () => {
|
||||
const verdict = evaluateDefaultFlipDoc([{ key: 'x', from: 1, to: 2 }], '# breaking changes\ndetails');
|
||||
assert.equal(verdict.ok, true);
|
||||
});
|
||||
});
|
||||
|
||||
describe('default-flip-documentation lint: main() end-to-end wiring', () => {
|
||||
const git = (dir, ...args) => gitOrThrow(args, { cwd: dir });
|
||||
|
||||
function buildRepo(tmpDir, baseManifest, headManifest) {
|
||||
git(tmpDir, 'init', '-q', '-b', 'main');
|
||||
git(tmpDir, 'config', 'user.email', 'test@example.com');
|
||||
git(tmpDir, 'config', 'user.name', 'Test');
|
||||
const manifestAbs = path.join(tmpDir, MANIFEST_PATH);
|
||||
fs.mkdirSync(path.dirname(manifestAbs), { recursive: true });
|
||||
fs.writeFileSync(manifestAbs, JSON.stringify(baseManifest));
|
||||
git(tmpDir, 'add', '-A');
|
||||
git(tmpDir, 'commit', '-q', '-m', 'base');
|
||||
git(tmpDir, 'update-ref', 'refs/remotes/origin/main', 'HEAD');
|
||||
|
||||
git(tmpDir, 'checkout', '-q', '-b', 'pr');
|
||||
fs.writeFileSync(manifestAbs, JSON.stringify(headManifest));
|
||||
git(tmpDir, 'add', '-A');
|
||||
git(tmpDir, 'commit', '-q', '-m', 'pr');
|
||||
|
||||
const scriptsDir = path.join(tmpDir, 'scripts');
|
||||
const libDir = path.join(scriptsDir, 'lib');
|
||||
fs.mkdirSync(libDir, { recursive: true });
|
||||
const scriptCopy = path.join(scriptsDir, 'lint-default-flip-documentation.cjs');
|
||||
fs.copyFileSync(LINT_SCRIPT, scriptCopy);
|
||||
fs.copyFileSync(path.join(ROOT, 'scripts', 'lib', 'cli-exit.cjs'), path.join(libDir, 'cli-exit.cjs'));
|
||||
return scriptCopy;
|
||||
}
|
||||
|
||||
function runWithPrBody(tmpDir, scriptCopy, prBody) {
|
||||
const eventPath = path.join(tmpDir, 'event.json');
|
||||
fs.writeFileSync(eventPath, JSON.stringify({ pull_request: { body: prBody } }));
|
||||
return runNode(
|
||||
[scriptCopy],
|
||||
{
|
||||
cwd: tmpDir,
|
||||
env: { ...process.env, GITHUB_BASE_REF: 'main', GITHUB_EVENT_PATH: eventPath },
|
||||
},
|
||||
);
|
||||
}
|
||||
|
||||
test('exit 1: a flipped default with no Breaking Changes section in the PR body', (t) => {
|
||||
const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'gsd-default-flip-e2e-'));
|
||||
t.after(() => cleanup(tmpDir));
|
||||
const scriptCopy = buildRepo(
|
||||
tmpDir,
|
||||
{ workflow: { human_verify_mode: 'mid-flight' } },
|
||||
{ workflow: { human_verify_mode: 'end-of-phase' } },
|
||||
);
|
||||
const result = runWithPrBody(tmpDir, scriptCopy, 'Flips the default. No migration notes.');
|
||||
assert.equal(result.exitCode, 1, `expected exit 1, got ${result.exitCode}: ${result.stderr}`);
|
||||
assert.match(result.stderr, /DEFAULT-FLIP-DOCUMENTATION/);
|
||||
});
|
||||
|
||||
test('exit 0: a flipped default WITH a Breaking Changes section', (t) => {
|
||||
const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'gsd-default-flip-e2e-doc-'));
|
||||
t.after(() => cleanup(tmpDir));
|
||||
const scriptCopy = buildRepo(
|
||||
tmpDir,
|
||||
{ workflow: { human_verify_mode: 'mid-flight' } },
|
||||
{ workflow: { human_verify_mode: 'end-of-phase' } },
|
||||
);
|
||||
const result = runWithPrBody(
|
||||
tmpDir,
|
||||
scriptCopy,
|
||||
'## Breaking Changes\n\nNew default takes effect when config.json is regenerated; opt back in with `gsd config-set workflow.human_verify_mode mid-flight`.',
|
||||
);
|
||||
assert.equal(result.exitCode, 0, `expected exit 0, got ${result.exitCode}: ${result.stderr}`);
|
||||
});
|
||||
|
||||
test('LOOKALIKE: manifest restructured/reformatted with identical resolved values does NOT fail, even with no Breaking Changes section', (t) => {
|
||||
const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'gsd-default-flip-e2e-reformat-'));
|
||||
t.after(() => cleanup(tmpDir));
|
||||
const scriptCopy = buildRepo(
|
||||
tmpDir,
|
||||
{ a: 1, workflow: { x: true, y: false } },
|
||||
{ workflow: { y: false, x: true }, a: 1 },
|
||||
);
|
||||
const result = runWithPrBody(tmpDir, scriptCopy, 'Pure reformat, no PR body sections at all.');
|
||||
assert.equal(result.exitCode, 0, `expected exit 0 (no real value change), got ${result.exitCode}: ${result.stderr}`);
|
||||
});
|
||||
|
||||
test('exit 0 and skip when there is no PR event payload (push / local run)', (t) => {
|
||||
const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'gsd-default-flip-e2e-noevent-'));
|
||||
t.after(() => cleanup(tmpDir));
|
||||
const scriptCopy = buildRepo(tmpDir, { a: 1 }, { a: 2 });
|
||||
const result = runNode(
|
||||
[scriptCopy],
|
||||
{ cwd: tmpDir, env: { ...process.env, GITHUB_BASE_REF: 'main', GITHUB_EVENT_PATH: '' } },
|
||||
);
|
||||
assert.equal(result.exitCode, 0, `expected exit 0, got ${result.exitCode}: ${result.stderr}`);
|
||||
assert.match(result.stdout, /skipping/);
|
||||
});
|
||||
});
|
||||
@@ -9,6 +9,7 @@
|
||||
* - local/no-elapsed-assertion
|
||||
* - local/no-raw-rmsync-in-tests
|
||||
* - local/no-adhoc-markdown-parsing
|
||||
* - local/require-subprocess-timeout
|
||||
*/
|
||||
|
||||
const { test, describe } = require('node:test');
|
||||
@@ -24,6 +25,7 @@ const noRawRmsyncInTests = require('../eslint-rules/no-raw-rmsync-in-tests.cjs')
|
||||
const noTautologicalAssert = require('../eslint-rules/no-tautological-assert.cjs');
|
||||
const noAdhocMarkdownParsing = require('../eslint-rules/no-adhoc-markdown-parsing.cjs');
|
||||
const noDuplicateFoldMarker = require('../eslint-rules/no-duplicate-fold-marker.cjs');
|
||||
const requireSubprocessTimeout = require('../eslint-rules/require-subprocess-timeout.cjs');
|
||||
|
||||
const ruleTester = new RuleTester({
|
||||
languageOptions: {
|
||||
@@ -1592,7 +1594,7 @@ describe('no-adhoc-markdown-parsing rule', () => {
|
||||
});
|
||||
});
|
||||
|
||||
// ─── no-duplicate-fold-marker ────────────────────────────────────────────────
|
||||
// ─── no-duplicate-fold-marker ────────────────────────────────────────
|
||||
|
||||
describe('no-duplicate-fold-marker rule', () => {
|
||||
const REPO_ROOT = path.join(__dirname, '..');
|
||||
@@ -1962,3 +1964,145 @@ describe('no-duplicate-fold-marker rule', () => {
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
// ─── require-subprocess-timeout ────────────────────────────────────
|
||||
|
||||
describe('require-subprocess-timeout rule', () => {
|
||||
test('rule module exports a create function', () => {
|
||||
assert.strictEqual(typeof requireSubprocessTimeout.create, 'function');
|
||||
});
|
||||
|
||||
// ── INVALID cases (must error) ────────────────────────────────────────────
|
||||
|
||||
test('invalid: execFileSync("git", args, { cwd }) — object-literal options with no timeout key', () => {
|
||||
ruleTester.run('require-subprocess-timeout', requireSubprocessTimeout, {
|
||||
valid: [],
|
||||
invalid: [
|
||||
{
|
||||
code: `
|
||||
const { execFileSync } = require('node:child_process');
|
||||
const args = ['status'];
|
||||
const cwd = '/repo';
|
||||
execFileSync('git', args, { cwd });
|
||||
`,
|
||||
filename: 'src/some-module.cts',
|
||||
errors: [{ messageId: 'requireSubprocessTimeout' }],
|
||||
},
|
||||
],
|
||||
});
|
||||
});
|
||||
|
||||
test('invalid: execSync("npm ci", { encoding: "utf8" }) — object-literal options with no timeout key', () => {
|
||||
ruleTester.run('require-subprocess-timeout', requireSubprocessTimeout, {
|
||||
valid: [],
|
||||
invalid: [
|
||||
{
|
||||
code: `
|
||||
const { execSync } = require('node:child_process');
|
||||
execSync('npm ci', { encoding: 'utf8' });
|
||||
`,
|
||||
filename: 'src/some-module.cts',
|
||||
errors: [{ messageId: 'requireSubprocessTimeout' }],
|
||||
},
|
||||
],
|
||||
});
|
||||
});
|
||||
|
||||
test('invalid: spawnSync with a dotted childProcess.spawnSync callee and no timeout', () => {
|
||||
ruleTester.run('require-subprocess-timeout', requireSubprocessTimeout, {
|
||||
valid: [],
|
||||
invalid: [
|
||||
{
|
||||
code: `
|
||||
const childProcess = require('node:child_process');
|
||||
childProcess.spawnSync('git', ['log'], { cwd: '/repo', encoding: 'utf-8' });
|
||||
`,
|
||||
filename: 'src/some-module.cts',
|
||||
errors: [{ messageId: 'requireSubprocessTimeout' }],
|
||||
},
|
||||
],
|
||||
});
|
||||
});
|
||||
|
||||
test('invalid: execFileSync with NO options argument at all — categorically no timeout', () => {
|
||||
ruleTester.run('require-subprocess-timeout', requireSubprocessTimeout, {
|
||||
valid: [],
|
||||
invalid: [
|
||||
{
|
||||
code: `
|
||||
const { execFileSync } = require('node:child_process');
|
||||
execFileSync('git', ['status']);
|
||||
`,
|
||||
filename: 'src/some-module.cts',
|
||||
errors: [{ messageId: 'requireSubprocessTimeout' }],
|
||||
},
|
||||
],
|
||||
});
|
||||
});
|
||||
|
||||
// ── VALID cases (must NOT error) ──────────────────────────────────────────
|
||||
|
||||
test('valid: execFileSync("git", args, { cwd, timeout: 30000 }) — timeout key present', () => {
|
||||
ruleTester.run('require-subprocess-timeout', requireSubprocessTimeout, {
|
||||
valid: [
|
||||
{
|
||||
code: `
|
||||
const { execFileSync } = require('node:child_process');
|
||||
const args = ['status'];
|
||||
const cwd = '/repo';
|
||||
execFileSync('git', args, { cwd, timeout: 30000 });
|
||||
`,
|
||||
filename: 'src/some-module.cts',
|
||||
},
|
||||
],
|
||||
invalid: [],
|
||||
});
|
||||
});
|
||||
|
||||
test('valid: options as a pre-built identifier — execFileSync("git", args, opts) is not traced', () => {
|
||||
ruleTester.run('require-subprocess-timeout', requireSubprocessTimeout, {
|
||||
valid: [
|
||||
{
|
||||
code: `
|
||||
const { execFileSync } = require('node:child_process');
|
||||
const args = ['status'];
|
||||
const opts = { cwd: '/repo', timeout: 30000 };
|
||||
execFileSync('git', args, opts);
|
||||
`,
|
||||
filename: 'src/some-module.cts',
|
||||
},
|
||||
],
|
||||
invalid: [],
|
||||
});
|
||||
});
|
||||
|
||||
test('valid: same unbounded call under a tests/** filename — rule is inert outside src/*.cts', () => {
|
||||
ruleTester.run('require-subprocess-timeout', requireSubprocessTimeout, {
|
||||
valid: [
|
||||
{
|
||||
code: `
|
||||
const { execFileSync } = require('node:child_process');
|
||||
execFileSync('git', ['status'], { cwd: '/repo' });
|
||||
`,
|
||||
filename: 'tests/foo.test.cjs',
|
||||
},
|
||||
],
|
||||
invalid: [],
|
||||
});
|
||||
});
|
||||
|
||||
test('valid: allow-unbounded-subprocess suppression comment on the call line', () => {
|
||||
ruleTester.run('require-subprocess-timeout', requireSubprocessTimeout, {
|
||||
valid: [
|
||||
{
|
||||
code: `
|
||||
const { execFileSync } = require('node:child_process');
|
||||
execFileSync('git', ['status'], { cwd: '/repo' }); // allow-unbounded-subprocess: bounded by caller's own watchdog
|
||||
`,
|
||||
filename: 'src/some-module.cts',
|
||||
},
|
||||
],
|
||||
invalid: [],
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
181
tests/lint-frontmatter-scalar-broad-grep.test.cjs
Normal file
181
tests/lint-frontmatter-scalar-broad-grep.test.cjs
Normal file
@@ -0,0 +1,181 @@
|
||||
'use strict';
|
||||
process.env.GSD_TEST_MODE = '1';
|
||||
|
||||
/**
|
||||
* Frontmatter-scalar-broad-grep lint (DEFECT.FRONTMATTER-SCALAR-BROAD-GREP,
|
||||
* CONTEXT.md).
|
||||
*
|
||||
* scripts/lint-frontmatter-scalar-broad-grep.cjs flags a `grep "^key:"` over
|
||||
* a whole markdown report (not scoped to the frontmatter block, no -m1/
|
||||
* `head -1` single-match guard) whose result feeds an exact-token comparison
|
||||
* — the #586/#651 bug class where a body line beginning `key:` concatenates
|
||||
* onto the intended frontmatter value and misroutes a valid state.
|
||||
*/
|
||||
|
||||
const { test, describe } = require('node:test');
|
||||
const assert = require('node:assert/strict');
|
||||
const fs = require('node:fs');
|
||||
const os = require('node:os');
|
||||
const path = require('node:path');
|
||||
|
||||
const ROOT = path.join(__dirname, '..');
|
||||
const LINT_SCRIPT = path.join(ROOT, 'scripts', 'lint-frontmatter-scalar-broad-grep.cjs');
|
||||
const { findBroadGrepsInBlock, extractBashBlocks, scan } = require(LINT_SCRIPT);
|
||||
const { cleanup } = require('./helpers.cjs');
|
||||
const { runNode } = require('./helpers/process-seam.cjs');
|
||||
|
||||
describe('frontmatter-scalar-broad-grep lint: findBroadGrepsInBlock (pure)', () => {
|
||||
test('the real #586/#651 defect shape IS flagged: whole-file grep, no scope, no -m1, piped to cut|tr', () => {
|
||||
const lines = [
|
||||
'grep "^status:" "${QUICK_DIR}/${quick_id}-VERIFICATION.md" | cut -d: -f2 | tr -d \' \'',
|
||||
];
|
||||
const findings = findBroadGrepsInBlock(lines);
|
||||
assert.equal(findings.length, 1);
|
||||
assert.equal(findings[0].key, 'status');
|
||||
});
|
||||
|
||||
test('a variable captured from a broad grep and later compared with == is also flagged', () => {
|
||||
const lines = [
|
||||
'STATUS=$(grep "^status:" "$FILE")',
|
||||
'if [ "$STATUS" == "passed" ]; then echo ok; fi',
|
||||
];
|
||||
const findings = findBroadGrepsInBlock(lines);
|
||||
assert.equal(findings.length, 1);
|
||||
});
|
||||
|
||||
test('LOOKALIKE: sed-scoped to the frontmatter block is NOT flagged', () => {
|
||||
const lines = [
|
||||
'sed -n \'/^---$/,/^---$/p\' "$f" | grep -m1 "^status:" | cut -d: -f2 | tr -d \' \'',
|
||||
];
|
||||
assert.deepEqual(findBroadGrepsInBlock(lines), []);
|
||||
});
|
||||
|
||||
test('LOOKALIKE: -m1 on the grep itself is NOT flagged even without a preceding scope', () => {
|
||||
const lines = [
|
||||
'grep -m1 "^status:" "$FILE" | cut -d: -f2 | tr -d \' \'',
|
||||
];
|
||||
assert.deepEqual(findBroadGrepsInBlock(lines), []);
|
||||
});
|
||||
|
||||
test('LOOKALIKE: piped to `head -1` immediately after grep is NOT flagged (frontmatter is always first)', () => {
|
||||
const lines = [
|
||||
'AUDIT_STATUS=$(grep "^status:" "${AUDIT_FILE}" 2>/dev/null | head -1 | cut -d: -f2 | tr -d \' \')',
|
||||
];
|
||||
assert.deepEqual(findBroadGrepsInBlock(lines), []);
|
||||
});
|
||||
|
||||
test('LOOKALIKE: a frontmatter block already extracted into a variable (JS regex idiom), then multiple keys parsed from it', () => {
|
||||
const lines = [
|
||||
'FRONTMATTER=$(node -e "',
|
||||
' const m = content.match(/^---\\n([\\s\\S]*?)\\n---/);',
|
||||
' if (m) process.stdout.write(m[1]);',
|
||||
'")',
|
||||
'STATUS=$(echo "$FRONTMATTER" | grep "^status:" | cut -d: -f2 | xargs)',
|
||||
'FILES_REVIEWED=$(echo "$FRONTMATTER" | grep "^files_reviewed:" | cut -d: -f2 | xargs)',
|
||||
];
|
||||
assert.deepEqual(findBroadGrepsInBlock(lines), []);
|
||||
});
|
||||
|
||||
test('LOOKALIKE: an explicit `# lint-allow:` suppression comment silences the finding', () => {
|
||||
const lines = [
|
||||
'# lint-allow: frontmatter-scalar-broad-grep — intentional multi-file scan, not a single report',
|
||||
'grep "^status:" reports/*.md | cut -d: -f2 | tr -d \' \'',
|
||||
];
|
||||
assert.deepEqual(findBroadGrepsInBlock(lines), []);
|
||||
});
|
||||
|
||||
test('a grep not piped to cut/tr and never compared is NOT flagged (not a token-comparison use)', () => {
|
||||
const lines = ['grep -c "^status:" "$FILE"'];
|
||||
assert.deepEqual(findBroadGrepsInBlock(lines), []);
|
||||
});
|
||||
});
|
||||
|
||||
describe('frontmatter-scalar-broad-grep lint: extractBashBlocks (pure)', () => {
|
||||
test('extracts a fenced ```bash block and reports its 1-indexed start line', () => {
|
||||
const text = [
|
||||
'intro',
|
||||
'```bash',
|
||||
'echo hi',
|
||||
'```',
|
||||
'outro',
|
||||
].join('\n');
|
||||
const blocks = extractBashBlocks(text);
|
||||
assert.equal(blocks.length, 1);
|
||||
assert.equal(blocks[0].startLine, 3);
|
||||
assert.deepEqual(blocks[0].lines, ['echo hi']);
|
||||
});
|
||||
|
||||
test('a non-bash fenced block (e.g. ```json) is ignored', () => {
|
||||
const text = ['```json', '{"a":1}', '```'].join('\n');
|
||||
assert.deepEqual(extractBashBlocks(text), []);
|
||||
});
|
||||
});
|
||||
|
||||
describe('frontmatter-scalar-broad-grep lint: the live repo is clean', () => {
|
||||
test('scan() finds zero offenders in the real workflow/agent/command markdown', () => {
|
||||
const offenders = scan();
|
||||
assert.deepEqual(
|
||||
offenders,
|
||||
[],
|
||||
'un-scoped frontmatter-scalar grep(s) found:\n' + offenders.map((o) => ` ${o.file}:${o.line} ${o.snippet}`).join('\n'),
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
describe('frontmatter-scalar-broad-grep lint: main() end-to-end wiring', () => {
|
||||
test('exit 0 on the real repo tree', () => {
|
||||
const result = runNode([LINT_SCRIPT], { cwd: ROOT });
|
||||
assert.equal(result.exitCode, 0, `expected exit 0, got ${result.exitCode}: ${result.stderr}`);
|
||||
});
|
||||
|
||||
test('exit 1 on a fixture reproducing the real defect shape', (t) => {
|
||||
const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'gsd-frontmatter-grep-lint-e2e-'));
|
||||
t.after(() => cleanup(tmpDir));
|
||||
const workflowsDir = path.join(tmpDir, 'gsd-core', 'workflows');
|
||||
fs.mkdirSync(workflowsDir, { recursive: true });
|
||||
fs.writeFileSync(
|
||||
path.join(workflowsDir, 'quick.md'),
|
||||
[
|
||||
'# Quick',
|
||||
'```bash',
|
||||
'grep "^status:" "${QUICK_DIR}/${quick_id}-VERIFICATION.md" | cut -d: -f2 | tr -d \' \'',
|
||||
'```',
|
||||
].join('\n'),
|
||||
);
|
||||
const scriptCopyDir = path.join(tmpDir, 'scripts');
|
||||
fs.mkdirSync(scriptCopyDir, { recursive: true });
|
||||
const scriptCopy = path.join(scriptCopyDir, 'lint-frontmatter-scalar-broad-grep.cjs');
|
||||
fs.copyFileSync(LINT_SCRIPT, scriptCopy);
|
||||
fs.mkdirSync(path.join(scriptCopyDir, 'lib'), { recursive: true });
|
||||
fs.copyFileSync(path.join(ROOT, 'scripts', 'lib', 'cli-exit.cjs'), path.join(scriptCopyDir, 'lib', 'cli-exit.cjs'));
|
||||
|
||||
const result = runNode([scriptCopy]);
|
||||
assert.equal(result.exitCode, 1, `expected exit 1, got ${result.exitCode}`);
|
||||
assert.match(result.stderr, /FRONTMATTER-SCALAR-BROAD-GREP/);
|
||||
});
|
||||
|
||||
test('exit 0 on a fixture that is properly scoped (no false positive)', (t) => {
|
||||
const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'gsd-frontmatter-grep-lint-e2e-clean-'));
|
||||
t.after(() => cleanup(tmpDir));
|
||||
const workflowsDir = path.join(tmpDir, 'gsd-core', 'workflows');
|
||||
fs.mkdirSync(workflowsDir, { recursive: true });
|
||||
fs.writeFileSync(
|
||||
path.join(workflowsDir, 'quick.md'),
|
||||
[
|
||||
'# Quick',
|
||||
'```bash',
|
||||
'sed -n \'/^---$/,/^---$/p\' "$f" | grep -m1 "^status:" | cut -d: -f2 | tr -d \' \'',
|
||||
'```',
|
||||
].join('\n'),
|
||||
);
|
||||
const scriptCopyDir = path.join(tmpDir, 'scripts');
|
||||
fs.mkdirSync(scriptCopyDir, { recursive: true });
|
||||
const scriptCopy = path.join(scriptCopyDir, 'lint-frontmatter-scalar-broad-grep.cjs');
|
||||
fs.copyFileSync(LINT_SCRIPT, scriptCopy);
|
||||
fs.mkdirSync(path.join(scriptCopyDir, 'lib'), { recursive: true });
|
||||
fs.copyFileSync(path.join(ROOT, 'scripts', 'lib', 'cli-exit.cjs'), path.join(scriptCopyDir, 'lib', 'cli-exit.cjs'));
|
||||
|
||||
const result = runNode([scriptCopy]);
|
||||
assert.equal(result.exitCode, 0, `expected exit 0, got ${result.exitCode}: ${result.stderr}`);
|
||||
});
|
||||
});
|
||||
229
tests/removed-but-needed-lint.test.cjs
Normal file
229
tests/removed-but-needed-lint.test.cjs
Normal file
@@ -0,0 +1,229 @@
|
||||
'use strict';
|
||||
process.env.GSD_TEST_MODE = '1';
|
||||
|
||||
/**
|
||||
* Removed-but-needed lint (DEFECT.REMOVED-BUT-NEEDED, CONTEXT.md).
|
||||
*
|
||||
* scripts/lint-removed-but-needed.cjs fails a PR that deletes a file while a
|
||||
* live consumer (a workflow, docs, or package.json) still references it —
|
||||
* #3316 (root package-lock.json deleted while workflows still used
|
||||
* `cache: 'npm'` + `npm ci`), e3b52c70 (docs referenced a removed
|
||||
* `/gsd-new-workspace` workflow).
|
||||
*/
|
||||
|
||||
const { test, describe } = require('node:test');
|
||||
const assert = require('node:assert/strict');
|
||||
const fs = require('node:fs');
|
||||
const os = require('node:os');
|
||||
const path = require('node:path');
|
||||
|
||||
const ROOT = path.join(__dirname, '..');
|
||||
const LINT_SCRIPT = path.join(ROOT, 'scripts', 'lint-removed-but-needed.cjs');
|
||||
const { referencesBasename, referencesNpmLockfileDependency, findSurvivingReferences, scan } = require(LINT_SCRIPT);
|
||||
const { cleanup } = require('./helpers.cjs');
|
||||
const { runNode } = require('./helpers/process-seam.cjs');
|
||||
const { gitOrThrow } = require('./helpers/git-fixture.cjs');
|
||||
|
||||
describe('removed-but-needed lint: referencesBasename (pure)', () => {
|
||||
test('a plain filename reference in prose is found', () => {
|
||||
assert.equal(referencesBasename('see docs/gsd-new-workspace.md for details', 'gsd-new-workspace.md'), true);
|
||||
});
|
||||
|
||||
test('no reference at all is not found', () => {
|
||||
assert.equal(referencesBasename('nothing to see here', 'gsd-new-workspace.md'), false);
|
||||
});
|
||||
|
||||
test('a coincidental substring inside a different filename is NOT a false match (word-boundary guard)', () => {
|
||||
assert.equal(referencesBasename('old-config.json.bak lives here', 'config.json'), false);
|
||||
});
|
||||
|
||||
test('a path-embedded reference (with separators) IS found', () => {
|
||||
assert.equal(referencesBasename('run: node scripts/gsd-new-workspace.cjs', 'gsd-new-workspace.cjs'), true);
|
||||
});
|
||||
});
|
||||
|
||||
describe('removed-but-needed lint: referencesNpmLockfileDependency (pure)', () => {
|
||||
test('`npm ci` is flagged', () => {
|
||||
assert.equal(referencesNpmLockfileDependency(' run: npm ci'), true);
|
||||
});
|
||||
|
||||
test('`cache: \'npm\'` is flagged', () => {
|
||||
assert.equal(referencesNpmLockfileDependency(" cache: 'npm'"), true);
|
||||
});
|
||||
|
||||
test('an unrelated workflow step is not flagged', () => {
|
||||
assert.equal(referencesNpmLockfileDependency(' run: npm run build'), false);
|
||||
});
|
||||
});
|
||||
|
||||
describe('removed-but-needed lint: findSurvivingReferences (pure)', () => {
|
||||
test('the real #3316 defect shape IS flagged: package-lock.json deleted, workflow still runs npm ci', () => {
|
||||
const violations = findSurvivingReferences(
|
||||
['package-lock.json'],
|
||||
[{ file: '.github/workflows/ci.yml', content: 'jobs:\n test:\n steps:\n - run: npm ci\n' }],
|
||||
);
|
||||
assert.ok(violations.some((v) => v.deletedFile === 'package-lock.json'));
|
||||
});
|
||||
|
||||
test('a deleted workflow still referenced in docs IS flagged (e3b52c70 shape)', () => {
|
||||
const violations = findSurvivingReferences(
|
||||
['gsd-core/workflows/new-workspace.md'],
|
||||
[{ file: 'docs/getting-started.md', content: 'run /gsd:new-workspace.md to start' }],
|
||||
);
|
||||
assert.equal(violations.length, 1);
|
||||
assert.equal(violations[0].referencedIn, 'docs/getting-started.md');
|
||||
});
|
||||
|
||||
test('LOOKALIKE: a deleted file with zero surviving references is clean', () => {
|
||||
const violations = findSurvivingReferences(
|
||||
['gsd-core/workflows/retired.md'],
|
||||
[{ file: 'docs/getting-started.md', content: 'nothing relevant here' }],
|
||||
);
|
||||
assert.deepEqual(violations, []);
|
||||
});
|
||||
|
||||
test('LOOKALIKE: a coincidental basename collision with an unrelated live file is not silently skipped, but the word-boundary guard avoids substring noise', () => {
|
||||
const violations = findSurvivingReferences(
|
||||
['old/config.json'],
|
||||
[{ file: 'docs/setup.md', content: 'we removed archived-config.json.old, unrelated' }],
|
||||
);
|
||||
assert.deepEqual(violations, []);
|
||||
});
|
||||
});
|
||||
|
||||
describe('removed-but-needed lint: the live repo (against origin/next) is clean', () => {
|
||||
test('scan() finds zero surviving references for anything deleted since origin/next', () => {
|
||||
let violations;
|
||||
try {
|
||||
violations = scan(ROOT, 'origin/next');
|
||||
} catch {
|
||||
// origin/next unreachable in this environment — nothing to assert.
|
||||
return;
|
||||
}
|
||||
assert.deepEqual(
|
||||
violations,
|
||||
[],
|
||||
'deleted file(s) still referenced by a live consumer:\n'
|
||||
+ violations.map((v) => ` ${v.deletedFile} -> ${v.referencedIn}: ${v.reason}`).join('\n'),
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
/**
|
||||
* Build a minimal temp git repo shaped like a PR branch, mirroring
|
||||
* tests/changeset-lint.test.cjs's fixture builder: origin/main = base
|
||||
* commit, pr = PR branch with caller-supplied file mutations on top.
|
||||
* @param {string} tmpDir
|
||||
* @param {Array<{file: string, content: string|null}>} baseFiles
|
||||
* @param {Array<{file: string, content: string|null}>} prFiles - null content deletes
|
||||
*/
|
||||
function buildTempRepo(tmpDir, baseFiles, prFiles) {
|
||||
const git = (...args) => gitOrThrow(args, { cwd: tmpDir });
|
||||
git('init', '-q', '-b', 'main');
|
||||
git('config', 'user.email', 'test@example.com');
|
||||
git('config', 'user.name', 'Test');
|
||||
|
||||
for (const { file, content } of baseFiles) {
|
||||
const abs = path.join(tmpDir, file);
|
||||
fs.mkdirSync(path.dirname(abs), { recursive: true });
|
||||
fs.writeFileSync(abs, content);
|
||||
}
|
||||
git('add', '-A');
|
||||
git('commit', '-q', '-m', 'base');
|
||||
git('update-ref', 'refs/remotes/origin/main', 'HEAD');
|
||||
|
||||
git('checkout', '-q', '-b', 'pr');
|
||||
for (const { file, content } of prFiles) {
|
||||
const abs = path.join(tmpDir, file);
|
||||
if (content === null) {
|
||||
try { fs.unlinkSync(abs); } catch { /* already absent */ }
|
||||
} else {
|
||||
fs.mkdirSync(path.dirname(abs), { recursive: true });
|
||||
fs.writeFileSync(abs, content);
|
||||
}
|
||||
}
|
||||
git('add', '-A');
|
||||
git('commit', '-q', '-m', 'pr changes');
|
||||
return tmpDir;
|
||||
}
|
||||
|
||||
/**
|
||||
* The lint script resolves its scan root from `path.join(__dirname, '..')`
|
||||
* (matching every other standalone lint script in this repo, e.g.
|
||||
* lint-canary-version-leak.cjs) — it does NOT use `process.cwd()`. So an
|
||||
* end-to-end fixture must run a COPY of the script placed inside the fixture
|
||||
* repo, not the real repo's script, or it would scan the real repo instead
|
||||
* of the fixture tree.
|
||||
* @param {string} tmpDir
|
||||
* @returns {string} path to the copied script inside tmpDir/scripts/
|
||||
*/
|
||||
function copyScriptInto(tmpDir) {
|
||||
const scriptsDir = path.join(tmpDir, 'scripts');
|
||||
const libDir = path.join(scriptsDir, 'lib');
|
||||
fs.mkdirSync(libDir, { recursive: true });
|
||||
const scriptCopy = path.join(scriptsDir, 'lint-removed-but-needed.cjs');
|
||||
fs.copyFileSync(LINT_SCRIPT, scriptCopy);
|
||||
fs.copyFileSync(path.join(ROOT, 'scripts', 'lib', 'cli-exit.cjs'), path.join(libDir, 'cli-exit.cjs'));
|
||||
return scriptCopy;
|
||||
}
|
||||
|
||||
describe('removed-but-needed lint: main() end-to-end wiring', () => {
|
||||
test('exit 1 in a fixture repo reproducing the real defect shape (package-lock.json deleted, workflow still npm ci)', (t) => {
|
||||
const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'gsd-removed-but-needed-e2e-'));
|
||||
t.after(() => cleanup(tmpDir));
|
||||
buildTempRepo(
|
||||
tmpDir,
|
||||
[
|
||||
{ file: 'package-lock.json', content: '{}' },
|
||||
{ file: '.github/workflows/ci.yml', content: 'jobs:\n test:\n steps:\n - run: npm ci\n' },
|
||||
],
|
||||
[{ file: 'package-lock.json', content: null }],
|
||||
);
|
||||
const scriptCopy = copyScriptInto(tmpDir);
|
||||
const result = runNode(
|
||||
[scriptCopy],
|
||||
{ cwd: tmpDir, env: { ...process.env, GSD_REMOVED_BUT_NEEDED_BASE: 'main' } },
|
||||
);
|
||||
assert.equal(result.exitCode, 1, `expected exit 1, got ${result.exitCode}: ${result.stderr}`);
|
||||
assert.match(result.stderr, /REMOVED-BUT-NEEDED/);
|
||||
});
|
||||
|
||||
test('exit 0 in a fixture repo where the deletion is clean (no surviving reference, workflow updated too)', (t) => {
|
||||
const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'gsd-removed-but-needed-e2e-clean-'));
|
||||
t.after(() => cleanup(tmpDir));
|
||||
buildTempRepo(
|
||||
tmpDir,
|
||||
[
|
||||
{ file: 'package-lock.json', content: '{}' },
|
||||
{ file: '.github/workflows/ci.yml', content: 'jobs:\n test:\n steps:\n - run: npm install\n' },
|
||||
],
|
||||
[{ file: 'package-lock.json', content: null }],
|
||||
);
|
||||
const scriptCopy = copyScriptInto(tmpDir);
|
||||
const result = runNode(
|
||||
[scriptCopy],
|
||||
{ cwd: tmpDir, env: { ...process.env, GSD_REMOVED_BUT_NEEDED_BASE: 'main' } },
|
||||
);
|
||||
assert.equal(result.exitCode, 0, `expected exit 0, got ${result.exitCode}: ${result.stderr}`);
|
||||
});
|
||||
|
||||
test('gracefully skips (exit 0) when the base ref cannot be resolved', (t) => {
|
||||
const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'gsd-removed-but-needed-e2e-noref-'));
|
||||
t.after(() => cleanup(tmpDir));
|
||||
const git = (...args) => gitOrThrow(args, { cwd: tmpDir });
|
||||
git('init', '-q', '-b', 'main');
|
||||
git('config', 'user.email', 'test@example.com');
|
||||
git('config', 'user.name', 'Test');
|
||||
fs.writeFileSync(path.join(tmpDir, 'README.md'), '# x\n');
|
||||
git('add', '-A');
|
||||
git('commit', '-q', '-m', 'only commit');
|
||||
const scriptCopy = copyScriptInto(tmpDir);
|
||||
|
||||
const result = runNode(
|
||||
[scriptCopy],
|
||||
{ cwd: tmpDir, env: { ...process.env, GSD_REMOVED_BUT_NEEDED_BASE: 'nonexistent-branch' } },
|
||||
);
|
||||
assert.equal(result.exitCode, 0, `expected graceful skip (exit 0), got ${result.exitCode}: ${result.stderr}`);
|
||||
assert.match(result.stdout, /skipping/);
|
||||
});
|
||||
});
|
||||
Reference in New Issue
Block a user