fix(#2998): populate gsd-pristine/ from install transform pipeline so verifier has a real baseline (#3004)
* fix(#2998): populate gsd-pristine/ from install transform pipeline so verifier has a real baseline saveLocalPatches declared a pristineDir variable and JSDoc'd 'saves pristine copies to gsd-pristine/' but no code ever wrote there. Effect: /gsd-reapply-patches Step 5 verifier (#2972) silently fell back to its over-broad heuristic ('every significant backup line') -- exactly the silent-success-on-lost-content failure mode #2969 was designed to prevent. Fix: new populatePristineDir({...}) helper runs copyWithPathReplacement (the install transform pipeline) into a tmp staging dir, then copies out only the modified-file paths into gsd-pristine/. saveLocalPatches now accepts a pristineCtx and calls the helper when local patches are detected. Soft-fails on transform errors (logs warning, continues with empty pristine -- no worse than pre-fix). Pristine reflects the about-to-install version's content, which is the right baseline for 'what would survive without the user's modifications'. Tests: bug-2998-pristine-dir-populated.test.cjs asserts the helper is exported, no-ops on empty input, writes one pristine file per source- existing path, skips ghost paths, and produces deterministic output (byte-identical across runs -- the property pristine_hashes depends on). Closes #2998 * chore(#2998): add changeset fragment for PR #3004 * fix(#2998): expand pristine to all manifest install roots; clear stale pristine on populate (CR) CodeRabbit on PR #3004 caught two issues: 1. populatePristineDir only staged packageSrc/get-shit-done/ but manifest.files records edits under several install roots (commands/, agents/, hooks/, skills/, root files like .clinerules). Modified paths outside get-shit-done/ were silently skipped, leaving the verifier with no baseline for those edits. Fixed by computing the set of top-level dirs from the modified set and staging each one that exists in source. Root-level files (no slash) bypass the transform pipeline and are copied directly. 2. populatePristineDir did not wipe pre-existing gsd-pristine/ before populating. A previous run's stale pristine could survive into the current run's diff baseline. Now wipe before populate AND in the catch path so soft-failures don't leave half-populated data on disk. Tests: bug-2998-pristine-dir-populated.test.cjs grows by 2 cases: - agents/ paths are staged and copied (was silently skipped pre-fix) - mixed get-shit-done/ + agents/ in same modified list both stage
This commit is contained in:
Tom Boucher
5
.changeset/plucky-ibex-gather.md
Normal file
5
.changeset/plucky-ibex-gather.md
Normal file
@@ -0,0 +1,5 @@
|
||||
---
|
||||
type: Fixed
|
||||
pr: 2998
|
||||
---
|
||||
gsd-pristine/ is now populated by the installer when local patches are detected — saveLocalPatches calls a new populatePristineDir helper that runs the install transform pipeline into a tmp staging dir and copies modified files into pristineDir. The reapply-patches Step 5 verifier no longer falls back to its over-broad heuristic. See #2998.
|
||||
@@ -12,6 +12,9 @@ Format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
|
||||
|
||||
### Fixed
|
||||
|
||||
- **`gsd-pristine/` is now populated by the installer when local patches are detected** — `saveLocalPatches` declared a `pristineDir` variable and JSDoc'd "saves pristine copies (from manifest) to gsd-pristine/ to enable three-way merge during reapply-patches", but no code ever wrote to that directory. Effect: the `/gsd-reapply-patches` Step 5 verifier (#2972) silently degraded to its over-broad fallback heuristic ("every significant backup line"), exactly the silent-success-on-lost-content failure mode #2969 was designed to prevent. Fix: new `populatePristineDir({ packageSrc, pristineDir, modified, runtime, pathPrefix, isGlobal })` helper runs the install transform pipeline (`copyWithPathReplacement`) into a tmp staging dir, then copies out only the modified-file paths into `gsd-pristine/`. `saveLocalPatches` now accepts a `pristineCtx` and calls the helper when local patches are detected; the install entry point passes the package source root, runtime, pathPrefix, and isGlobal so transforms produce byte-identical output to what `copyWithPathReplacement` would have written under normal install. Soft-fails on transform errors (logs a warning, continues with empty pristine — no worse than pre-fix behavior). Pristine reflects the about-to-install version's content, which is what the verifier needs as the "what would survive without the user's modifications" baseline. Regression covered by `tests/bug-2998-pristine-dir-populated.test.cjs` (6 tests across two suites): asserts the helper is exported, returns 0 for empty modified list, writes one pristine file per source-existing path, skips ghost paths without corrupting pristine, and produces deterministic output (two runs with same inputs yield byte-identical pristine — the property `pristine_hashes` in `backup-meta.json` depends on). (#2998)
|
||||
|
||||
|
||||
- **`release-sdk` hotfix re-run no longer fails at `Dry-run publish validation` when the version is already on npm** — the `Detect prior publish (reconciliation mode)` step sets `skip_publish=true` when the package version is already on the registry, and the actual publish step honors that gate. The `Dry-run publish validation` step was missing the same guard, so any operator re-run of an already-published hotfix (the typical recovery path when later steps fail mid-flight) hit `npm publish --dry-run` first and got `npm error You cannot publish over the previously published versions: X.Y.Z` — `npm publish --dry-run` contacts the registry and rejects existing-version targets even though it doesn't actually publish. The dry-run validation step is now gated on the same `steps.prior_publish.outputs.skip_publish != 'true'` condition as the publish step. The rehearsal still runs on first publishes (where it has value); it skips only in the specific reconciliation case where the publish itself would be skipped. Trigger run: [25233855236](https://github.com/gsd-build/get-shit-done/actions/runs/25233855236/job/73995605643). Regression covered by `tests/bug-2987-dry-run-validation-skip-on-reconciliation.test.cjs`. (#2987)
|
||||
- **`release-sdk` hotfix flow hardened against silent classifier failures, missing-classifier-at-base-tag, and a vestigial merge-back PR step** — three issues surfaced by CodeRabbit's post-merge review of #2981 plus a production failure on the v1.39.1 release run. **(1)** `scripts/diff-touches-shipped-paths.cjs` reused exit code `1` for both the legitimate "no shipped paths" classifier result and Node's default uncaught-throw exit, so any tooling failure was indistinguishable from a normal skip. The script now uses `0` (shipped), `1` (not shipped), `2` (classifier error) with `try`/`catch` + `uncaughtException`/`unhandledRejection` handlers routing all failure paths to exit `2`. **(2)** The workflow's `git checkout -b "$BRANCH" "$BASE_TAG"` overwrote the working tree with the base tag's contents *before* the cherry-pick loop ran the classifier — but base tags predating the classifier's introduction (notably v1.39.0) don't have the file in their tree, so `node scripts/diff-touches-shipped-paths.cjs` would exit non-zero and silently drop every commit, producing an empty hotfix release. The classifier is now staged into `$RUNNER_TEMP` at the top of `Prepare hotfix branch` (before any working-tree-mutating git command), and the loop references that staged copy. The cherry-pick loop snapshots `$PIPESTATUS` into a local array (`PIPE_RC=("${PIPESTATUS[@]}")`) immediately after the classifier pipeline — under bracketed `set +e`/`set -e` — and dispatches via explicit `case`: `0` proceeds, `1` skips into `NON_SHIPPED_SKIPPED`, anything else emits `::error::shipped-paths classifier failed for $SHA (exit N)` and fails the workflow. CodeRabbit on PR #2984 caught a subtler bug in the first iteration: `pipeline \|\| true; RC=${PIPESTATUS[1]}` is broken because `\|\| true` runs `true` as its own one-command pipeline on the failure paths, overwriting `PIPESTATUS` to `(0)` and leaving `${PIPESTATUS[1]}` unset. The array-snapshot form is invariant against this. The same hardening also surfaces `git diff-tree`'s exit code (via `PIPE_RC[0]`); a non-zero diff-tree result now also fails the workflow rather than feeding partial input to the classifier. **(3)** Removed the `Open merge-back PR (hotfix only)` step. The auto-cherry-pick hotfix flow only picks commits already on main (`git cherry HEAD origin/main` outputs the unmerged ones), so by construction every code commit on the hotfix branch is already on main. The only hotfix-branch-only commit is the version-bump chore, which would either no-op against main or rewind main's in-progress version. The step also failed in production with `GitHub Actions is not permitted to create or approve pull requests (createPullRequest)` (org policy) on run [25232968975](https://github.com/gsd-build/get-shit-done/actions/runs/25232968975). The `pull-requests: write` permission previously granted to the release job has been dropped in line with least-privilege. The run-summary line that previously echoed `Merge-back PR opened against main` has been replaced with `No merge-back PR (auto-picked commits are already on main)` so operators reading the summary see an accurate non-action statement (CodeRabbit on PR #2984). Regression covered by `tests/bug-2983-classifier-exit-codes-and-base-tag-staging.test.cjs` (15 assertions across exit-code semantics, classifier staging, error dispatch, PIPESTATUS-snapshot hardening, diff-tree fail-fast, merge-back removal, and run-summary accuracy). (#2983)
|
||||
- **`release-sdk` hotfix only cherry-picks commits that change what actually ships** — the `fix:`/`chore:` filter in `Prepare hotfix branch` was too broad: it picked any commit with that conventional-commit type regardless of whether the diff could affect the published npm package. CI-only fixes (release-sdk.yml itself, hotfix tooling, test-only commits) were getting cherry-picked into hotfix branches even though they cannot change the tarball — and the subset touching `.github/workflows/*` then caused the prepare job's `git push` to be rejected by GitHub because the default `GITHUB_TOKEN` lacks the `workflow` scope, aborting the run. v1.39.1 hit this on PR #2977 (run [25232010071](https://github.com/gsd-build/get-shit-done/actions/runs/25232010071)). The loop now pre-skips any candidate commit whose `git diff-tree` output doesn't intersect the npm tarball's shipped paths (entries in `package.json` `files`, plus `package.json` itself, which `npm pack` always includes). Skipped commits land in a new `NON_SHIPPED_SKIPPED` summary bucket framed as informational — non-shipping commits cannot affect the package, so the skip needs no operator action. The shipped-paths classifier lives in `scripts/diff-touches-shipped-paths.cjs` so its rules (file-OR-directory prefix matching `npm pack` semantics, the always-shipped rule for `package.json`, the lockfile-not-shipped rule) are unit-testable. Regression covered by `tests/bug-2980-hotfix-only-picks-shipping-changes.test.cjs`. (#2980)
|
||||
|
||||
145
bin/install.js
145
bin/install.js
@@ -6798,13 +6798,98 @@ function writeManifest(configDir, runtime = 'claude', options = {}) {
|
||||
return manifest;
|
||||
}
|
||||
|
||||
/**
|
||||
* Populate gsd-pristine/ with the transformed pristine versions of every
|
||||
* `modified` file, derived from the current package's source tree by
|
||||
* running the install transform pipeline (`copyWithPathReplacement`)
|
||||
* into a tmp directory, then copying out only the relevant paths.
|
||||
*
|
||||
* Pristine semantically represents "what the install would write to
|
||||
* configDir/<relPath> if the user had not modified it." This is what the
|
||||
* /gsd-reapply-patches Step 5 verifier (#2972) uses as the diff base
|
||||
* for "user-added lines" — lines in the user's backup that are NOT in
|
||||
* the pristine baseline. Without this dir, the verifier degrades to its
|
||||
* over-broad fallback ("every significant backup line"), exactly the
|
||||
* silent-success-on-lost-content failure mode #2969 was designed to
|
||||
* prevent (#2998).
|
||||
*
|
||||
* Implementation note: we run the FULL transform pipeline against a tmp
|
||||
* staging dir (one-time, only when modified.length > 0), then copy out
|
||||
* just the modified paths. This re-uses the existing transform code
|
||||
* exactly — pristine is byte-identical to what `copyWithPathReplacement`
|
||||
* would have written under normal install. Cost: one extra full transform
|
||||
* pass per install where local patches were detected; acceptable.
|
||||
*/
|
||||
function populatePristineDir({ packageSrc, pristineDir, modified, runtime, pathPrefix, isGlobal }) {
|
||||
if (!modified || modified.length === 0) return 0;
|
||||
// Modified paths come from manifest.files which can live under several
|
||||
// install roots: get-shit-done/, commands/gsd/, command/, skills/, agents/,
|
||||
// hooks/, plus runtime-specific root files (#3004 CR). Stage every
|
||||
// top-level dir that actually contains a modified path; root-level files
|
||||
// are copied directly without the transform pipeline (they don't need
|
||||
// path replacement).
|
||||
const stageRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'gsd-pristine-stage-'));
|
||||
let written = 0;
|
||||
try {
|
||||
const topLevels = new Set();
|
||||
for (const relPath of modified) {
|
||||
const norm = relPath.replace(/\\/g, '/');
|
||||
const slash = norm.indexOf('/');
|
||||
topLevels.add(slash === -1 ? '' : norm.slice(0, slash));
|
||||
}
|
||||
|
||||
for (const top of topLevels) {
|
||||
if (top === '') {
|
||||
// Root-level files — copy directly from package source. The transform
|
||||
// pipeline is directory-oriented; root files don't need path-prefix
|
||||
// substitution (they're not markdown content with embedded paths).
|
||||
for (const relPath of modified) {
|
||||
const norm = relPath.replace(/\\/g, '/');
|
||||
if (norm.includes('/')) continue;
|
||||
const src = path.join(packageSrc, relPath);
|
||||
if (!fs.existsSync(src)) continue;
|
||||
const stagedFile = path.join(stageRoot, relPath);
|
||||
fs.mkdirSync(path.dirname(stagedFile), { recursive: true });
|
||||
fs.copyFileSync(src, stagedFile);
|
||||
}
|
||||
continue;
|
||||
}
|
||||
const srcDir = path.join(packageSrc, top);
|
||||
const stageDir = path.join(stageRoot, top);
|
||||
if (!fs.existsSync(srcDir)) continue;
|
||||
copyWithPathReplacement(srcDir, stageDir, pathPrefix, runtime, false, isGlobal);
|
||||
}
|
||||
|
||||
for (const relPath of modified) {
|
||||
// Only populate pristine for paths we successfully staged. If a path's
|
||||
// source dir does not exist (obsolete manifest entry), skip silently
|
||||
// rather than corrupting pristine with stale data.
|
||||
const stagedPath = path.join(stageRoot, relPath);
|
||||
if (!fs.existsSync(stagedPath)) continue;
|
||||
const out = path.join(pristineDir, relPath);
|
||||
fs.mkdirSync(path.dirname(out), { recursive: true });
|
||||
fs.copyFileSync(stagedPath, out);
|
||||
written++;
|
||||
}
|
||||
} finally {
|
||||
try { fs.rmSync(stageRoot, { recursive: true, force: true }); } catch { /* best-effort cleanup */ }
|
||||
}
|
||||
return written;
|
||||
}
|
||||
|
||||
/**
|
||||
* Detect user-modified GSD files by comparing against install manifest.
|
||||
* Backs up modified files to gsd-local-patches/ for reapply after update.
|
||||
* Also saves pristine copies (from manifest) to gsd-pristine/ to enable
|
||||
* three-way merge during reapply-patches (pristine vs user vs new).
|
||||
*
|
||||
* The optional `pristineCtx` parameter (set by the install entry point)
|
||||
* carries the source package root, runtime, pathPrefix, and isGlobal
|
||||
* needed to populate gsd-pristine/. If omitted (legacy callers), pristine
|
||||
* stays empty — the verifier falls back to its over-broad heuristic, same
|
||||
* behavior as before #2998.
|
||||
*/
|
||||
function saveLocalPatches(configDir) {
|
||||
function saveLocalPatches(configDir, pristineCtx) {
|
||||
const manifestPath = path.join(configDir, MANIFEST_NAME);
|
||||
if (!fs.existsSync(manifestPath)) return [];
|
||||
|
||||
@@ -6836,16 +6921,12 @@ function saveLocalPatches(configDir) {
|
||||
}
|
||||
}
|
||||
|
||||
// Save pristine copies of modified files from the CURRENT install (before wipe)
|
||||
// These represent the original GSD distribution files that the user then modified.
|
||||
// The reapply-patches workflow uses these for three-way merge:
|
||||
// pristine (original) → user's version (what they changed) → new version (after update)
|
||||
// Save pristine copies of modified files from the CURRENT install (before wipe).
|
||||
// Pristine semantically represents "what the install would write to configDir
|
||||
// if the user had not modified it" — used by /gsd-reapply-patches Step 5
|
||||
// (#2972) as the diff baseline for the user-added-lines computation. Without
|
||||
// this dir the verifier degrades to its over-broad fallback heuristic (#2998).
|
||||
if (modified.length > 0) {
|
||||
// We need the pristine originals, but the current files on disk are user-modified.
|
||||
// The manifest records SHA-256 hashes but not content. However, we can reconstruct
|
||||
// the pristine version from the npm package cache or git history.
|
||||
// As a practical approach: save the manifest's version info so the reapply workflow
|
||||
// knows which GSD version these files came from, enabling npm-based reconstruction.
|
||||
const meta = {
|
||||
backed_up_at: new Date().toISOString(),
|
||||
from_version: manifest.version,
|
||||
@@ -6863,6 +6944,37 @@ function saveLocalPatches(configDir) {
|
||||
for (const f of modified) {
|
||||
console.log(' ' + dim + f + reset);
|
||||
}
|
||||
|
||||
// #2998: populate gsd-pristine/ via the install transform pipeline so the
|
||||
// reapply-patches verifier (#2972) gets a real diff baseline instead of
|
||||
// falling back to its over-broad "every significant backup line" heuristic.
|
||||
if (pristineCtx) {
|
||||
// #3004 CR: wipe any pre-existing pristine content BEFORE populating
|
||||
// (and again in the catch path). Without this, a previous run's stale
|
||||
// pristine could be picked up by the verifier as if it were the
|
||||
// baseline for THIS modified set, causing a misleading three-way diff.
|
||||
try { fs.rmSync(pristineDir, { recursive: true, force: true }); } catch { /* not present */ }
|
||||
try {
|
||||
const written = populatePristineDir({
|
||||
packageSrc: pristineCtx.packageSrc,
|
||||
pristineDir,
|
||||
modified,
|
||||
runtime: pristineCtx.runtime,
|
||||
pathPrefix: pristineCtx.pathPrefix,
|
||||
isGlobal: pristineCtx.isGlobal,
|
||||
});
|
||||
if (written > 0) {
|
||||
console.log(' ' + green + '✓' + reset + ' Populated ' + cyan + 'gsd-pristine/' + reset + ' (' + written + ' file(s)) for three-way merge');
|
||||
}
|
||||
} catch (err) {
|
||||
// Soft failure: keep the install moving even if the transform pipeline
|
||||
// throws on an unusual configuration. Wipe the partial pristine so the
|
||||
// verifier falls back cleanly to its pre-#2998 heuristic instead of
|
||||
// reading half-populated data (#3004 CR).
|
||||
try { fs.rmSync(pristineDir, { recursive: true, force: true }); } catch { /* best-effort */ }
|
||||
console.log(' ' + yellow + 'i' + reset + ' Could not populate gsd-pristine/ (' + (err && err.message ? err.message : 'unknown') + '). Falls back to over-broad verify heuristic.');
|
||||
}
|
||||
}
|
||||
}
|
||||
return modified;
|
||||
}
|
||||
@@ -6974,8 +7086,16 @@ function install(isGlobal, runtime = 'claude') {
|
||||
// Track installation failures
|
||||
const failures = [];
|
||||
|
||||
// Save any locally modified GSD files before they get wiped
|
||||
saveLocalPatches(targetDir);
|
||||
// Save any locally modified GSD files before they get wiped.
|
||||
// The pristine context lets saveLocalPatches populate gsd-pristine/ via
|
||||
// the install transform pipeline, giving the reapply-patches Step 5
|
||||
// verifier a real diff baseline (#2998).
|
||||
saveLocalPatches(targetDir, {
|
||||
packageSrc: src,
|
||||
runtime,
|
||||
pathPrefix,
|
||||
isGlobal,
|
||||
});
|
||||
|
||||
// Clean up orphaned files from previous versions
|
||||
cleanupOrphanedFiles(targetDir);
|
||||
@@ -9071,6 +9191,7 @@ if (process.env.GSD_TEST_MODE) {
|
||||
validateHookFields,
|
||||
preserveUserArtifacts,
|
||||
restoreUserArtifacts,
|
||||
populatePristineDir,
|
||||
USER_OWNED_ARTIFACTS,
|
||||
finishInstall,
|
||||
trySelfLinkGsdSdk,
|
||||
|
||||
202
tests/bug-2998-pristine-dir-populated.test.cjs
Normal file
202
tests/bug-2998-pristine-dir-populated.test.cjs
Normal file
@@ -0,0 +1,202 @@
|
||||
'use strict';
|
||||
|
||||
process.env.GSD_TEST_MODE = '1';
|
||||
|
||||
/**
|
||||
* Bug #2998: gsd-pristine/ snapshot is documented but never populated by
|
||||
* the installer. saveLocalPatches declared a pristineDir variable and
|
||||
* promised "saves pristine copies (from manifest) to gsd-pristine/ to
|
||||
* enable three-way merge during reapply-patches" -- but no code ever
|
||||
* wrote to that directory. Effect: the /gsd-reapply-patches Step 5
|
||||
* verifier (#2972) silently degrades to its over-broad fallback heuristic
|
||||
* ("every significant backup line"), exactly the silent-success-on-lost-
|
||||
* content failure mode #2969 was designed to prevent.
|
||||
*
|
||||
* Fix: new populatePristineDir({...}) helper runs the install transform
|
||||
* pipeline (copyWithPathReplacement) into a tmp staging dir, then copies
|
||||
* out the modified-file paths into gsd-pristine/. saveLocalPatches now
|
||||
* accepts a pristineCtx and calls the helper when local patches are
|
||||
* detected.
|
||||
*/
|
||||
|
||||
const { test, describe } = require('node:test');
|
||||
const assert = require('node:assert/strict');
|
||||
const fs = require('node:fs');
|
||||
const path = require('node:path');
|
||||
const os = require('node:os');
|
||||
const crypto = require('node:crypto');
|
||||
|
||||
const ROOT = path.join(__dirname, '..');
|
||||
const INSTALL = require(path.join(ROOT, 'bin', 'install.js'));
|
||||
|
||||
function sha256(content) {
|
||||
return crypto.createHash('sha256').update(content).digest('hex');
|
||||
}
|
||||
|
||||
describe('Bug #2998: populatePristineDir is exported and writes pristine for modified files', () => {
|
||||
test('exported as a function', () => {
|
||||
assert.equal(typeof INSTALL.populatePristineDir, 'function',
|
||||
'expected populatePristineDir in install.js exports (#2998)');
|
||||
});
|
||||
|
||||
test('returns 0 when no files are modified (no-op)', () => {
|
||||
const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'gsd-2998-'));
|
||||
try {
|
||||
const written = INSTALL.populatePristineDir({
|
||||
packageSrc: ROOT,
|
||||
pristineDir: path.join(tmp, 'gsd-pristine'),
|
||||
modified: [],
|
||||
runtime: 'claude',
|
||||
pathPrefix: '$HOME/.claude/',
|
||||
isGlobal: true,
|
||||
});
|
||||
assert.equal(written, 0);
|
||||
} finally {
|
||||
fs.rmSync(tmp, { recursive: true, force: true });
|
||||
}
|
||||
});
|
||||
|
||||
test('writes one pristine file per modified path that exists in source', () => {
|
||||
const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'gsd-2998-'));
|
||||
const pristineDir = path.join(tmp, 'gsd-pristine');
|
||||
try {
|
||||
// Pick a real installed-side relPath from the package source. The
|
||||
// install transforms map source `get-shit-done/<rel>` to installed
|
||||
// `get-shit-done/<rel>` for skills-aware runtimes (like claude),
|
||||
// so the relPath is the same on both sides.
|
||||
const candidate = path.join('get-shit-done', 'workflows', 'reapply-patches.md');
|
||||
const sourcePath = path.join(ROOT, candidate);
|
||||
assert.equal(fs.existsSync(sourcePath), true,
|
||||
`precondition: source file exists at ${candidate}`);
|
||||
const written = INSTALL.populatePristineDir({
|
||||
packageSrc: ROOT,
|
||||
pristineDir,
|
||||
modified: [candidate],
|
||||
runtime: 'claude',
|
||||
pathPrefix: '$HOME/.claude/',
|
||||
isGlobal: true,
|
||||
});
|
||||
assert.equal(written, 1, 'expected exactly one pristine file written');
|
||||
const out = path.join(pristineDir, candidate);
|
||||
assert.equal(fs.existsSync(out), true, `expected pristine file at ${out}`);
|
||||
// The pristine content should be the transformed version (not raw source):
|
||||
// copyWithPathReplacement substitutes ~/.claude/ for the runtime path prefix.
|
||||
// For claude+global, the prefix is $HOME/.claude/ which equals the original,
|
||||
// so the transform is effectively identity here. We assert the content is a
|
||||
// non-empty markdown file rather than asserting on transform specifics.
|
||||
const content = fs.readFileSync(out, 'utf-8');
|
||||
assert.ok(content.length > 0, 'pristine file should be non-empty');
|
||||
} finally {
|
||||
fs.rmSync(tmp, { recursive: true, force: true });
|
||||
}
|
||||
});
|
||||
|
||||
test('skips paths not present in source (does not corrupt pristine with stale data)', () => {
|
||||
const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'gsd-2998-'));
|
||||
const pristineDir = path.join(tmp, 'gsd-pristine');
|
||||
try {
|
||||
const written = INSTALL.populatePristineDir({
|
||||
packageSrc: ROOT,
|
||||
pristineDir,
|
||||
modified: ['get-shit-done/this-path-does-not-exist.md'],
|
||||
runtime: 'claude',
|
||||
pathPrefix: '$HOME/.claude/',
|
||||
isGlobal: true,
|
||||
});
|
||||
assert.equal(written, 0, 'expected zero pristine files for non-existent source paths');
|
||||
const out = path.join(pristineDir, 'get-shit-done/this-path-does-not-exist.md');
|
||||
assert.equal(fs.existsSync(out), false, 'pristine should not contain ghost paths');
|
||||
} finally {
|
||||
fs.rmSync(tmp, { recursive: true, force: true });
|
||||
}
|
||||
});
|
||||
|
||||
test('pristine files have stable content (transformations are deterministic)', () => {
|
||||
// Determinism is what makes the verifier's hash check meaningful:
|
||||
// backup-meta.json records pristine_hashes computed at this same step,
|
||||
// so re-running with the same inputs must yield byte-identical files.
|
||||
const tmp1 = fs.mkdtempSync(path.join(os.tmpdir(), 'gsd-2998-d1-'));
|
||||
const tmp2 = fs.mkdtempSync(path.join(os.tmpdir(), 'gsd-2998-d2-'));
|
||||
try {
|
||||
const candidate = path.join('get-shit-done', 'workflows', 'reapply-patches.md');
|
||||
const ctx = {
|
||||
packageSrc: ROOT,
|
||||
modified: [candidate],
|
||||
runtime: 'claude',
|
||||
pathPrefix: '$HOME/.claude/',
|
||||
isGlobal: true,
|
||||
};
|
||||
INSTALL.populatePristineDir(Object.assign({ pristineDir: path.join(tmp1, 'gsd-pristine') }, ctx));
|
||||
INSTALL.populatePristineDir(Object.assign({ pristineDir: path.join(tmp2, 'gsd-pristine') }, ctx));
|
||||
const a = fs.readFileSync(path.join(tmp1, 'gsd-pristine', candidate));
|
||||
const b = fs.readFileSync(path.join(tmp2, 'gsd-pristine', candidate));
|
||||
assert.equal(sha256(a), sha256(b), 'two runs of the same inputs must yield identical pristine content');
|
||||
} finally {
|
||||
fs.rmSync(tmp1, { recursive: true, force: true });
|
||||
fs.rmSync(tmp2, { recursive: true, force: true });
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
// ─── #3004 CR follow-up: multi-root pristine expansion ─────────────────────
|
||||
|
||||
describe('Bug #2998 (#3004 CR): pristine expansion covers every manifest install root', () => {
|
||||
test('paths under agents/ are staged via copyWithPathReplacement, not silently skipped', () => {
|
||||
const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'gsd-2998-multi-'));
|
||||
const pristineDir = path.join(tmp, 'gsd-pristine');
|
||||
try {
|
||||
const candidate = path.join('agents', 'gsd-planner.md');
|
||||
const sourcePath = path.join(ROOT, candidate);
|
||||
assert.equal(fs.existsSync(sourcePath), true,
|
||||
`precondition: source file exists at ${candidate}`);
|
||||
const written = INSTALL.populatePristineDir({
|
||||
packageSrc: ROOT,
|
||||
pristineDir,
|
||||
modified: [candidate],
|
||||
runtime: 'claude',
|
||||
pathPrefix: '$HOME/.claude/',
|
||||
isGlobal: true,
|
||||
});
|
||||
assert.equal(written, 1, 'expected agents/ path to be staged and copied to pristine');
|
||||
assert.equal(fs.existsSync(path.join(pristineDir, candidate)), true);
|
||||
} finally {
|
||||
fs.rmSync(tmp, { recursive: true, force: true });
|
||||
}
|
||||
});
|
||||
|
||||
test('a mix of get-shit-done/ and agents/ paths in modified list are all staged', () => {
|
||||
const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'gsd-2998-mix-'));
|
||||
const pristineDir = path.join(tmp, 'gsd-pristine');
|
||||
try {
|
||||
const a = path.join('get-shit-done', 'workflows', 'reapply-patches.md');
|
||||
const b = path.join('agents', 'gsd-planner.md');
|
||||
assert.equal(fs.existsSync(path.join(ROOT, a)), true);
|
||||
assert.equal(fs.existsSync(path.join(ROOT, b)), true);
|
||||
const written = INSTALL.populatePristineDir({
|
||||
packageSrc: ROOT,
|
||||
pristineDir,
|
||||
modified: [a, b],
|
||||
runtime: 'claude',
|
||||
pathPrefix: '$HOME/.claude/',
|
||||
isGlobal: true,
|
||||
});
|
||||
assert.equal(written, 2, 'expected both top-level dirs to be staged');
|
||||
assert.equal(fs.existsSync(path.join(pristineDir, a)), true);
|
||||
assert.equal(fs.existsSync(path.join(pristineDir, b)), true);
|
||||
} finally {
|
||||
fs.rmSync(tmp, { recursive: true, force: true });
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
describe('Bug #2998: saveLocalPatches no longer leaves the pristineDir variable unused', () => {
|
||||
test('saveLocalPatches accepts a pristineCtx and exposes the helper for direct testing', () => {
|
||||
// Structural assertion: the function exists with the new signature shape.
|
||||
// Behavioral end-to-end is covered by the populatePristineDir tests above
|
||||
// (that helper is what saveLocalPatches calls internally).
|
||||
assert.equal(typeof INSTALL.populatePristineDir, 'function');
|
||||
// The signature for saveLocalPatches isn't exported, but the helper IS,
|
||||
// and it's the unit of behavior the bug is about. Asserting on the helper
|
||||
// is the structural-IR equivalent of the no-source-grep convention.
|
||||
});
|
||||
});
|
||||
Reference in New Issue
Block a user