From 4810bfe4dfd8cf5fbbfe40d85942dc0c407f154a Mon Sep 17 00:00:00 2001 From: Tom Boucher Date: Sun, 28 Jun 2026 00:26:13 -0400 Subject: [PATCH] =?UTF-8?q?refactor(#1679):=20ADR-1239=20Phase=20B=20?= =?UTF-8?q?=E2=80=94=20collapse=20getConfigDirFromHome=20chain=20into=20ge?= =?UTF-8?q?tGlobalConfigHomeFragment=20[AC2=20slice=202/6]=20(#1801)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * refactor(#1679): ADR-1239 Phase B — collapse getConfigDirFromHome chain into getGlobalConfigHomeFragment AC2 slice 2. Collapses the 14-branch runtime->global-config-home source-fragment chain in bin/install.js getConfigDirFromHome (the hook path.join() codegen mapping) into a single getGlobalConfigHomeFragment(runtime) lookup in runtime-name-policy.cts, sibling to getDirName / getRuntimeLabel. The antigravity branch stays dynamic in the caller (resolveAntigravityGlobalDir + path.relative — env-overridable, multi-segment); the prior inner unreachable `if (!isGlobal) return "'agents'"` (dead: !isGlobal returns at the fn top) is dropped. Behavior: byte-identical. Fragments preserved verbatim in the table. - claude/unknown/empty -> default '.claude' fragment - 14 runtimes (copilot..kimi) -> table lookup - antigravity -> dynamic (unchanged) Verification: - TDD: tests/global-config-home-fragment.test.cjs (golden map + 2 drift guards + fallbacks). Red->green. - 16-runtime golden install parity: byte-identical (hook codegen output unchanged) - eslint + test-file-count + regression-names clean - runtime === count in install.js: 115 -> 101 (-14) * chore(changeset): add Changed fragment for getConfigDirFromHome collapse (#1679) --- .changeset/witty-seals-snooze.md | 7 ++ bin/install.js | 30 ++----- src/runtime-name-policy.cts | 49 +++++++++++ tests/global-config-home-fragment.test.cjs | 95 ++++++++++++++++++++++ 4 files changed, 159 insertions(+), 22 deletions(-) create mode 100644 .changeset/witty-seals-snooze.md create mode 100644 tests/global-config-home-fragment.test.cjs diff --git a/.changeset/witty-seals-snooze.md b/.changeset/witty-seals-snooze.md new file mode 100644 index 000000000..31d48e0d7 --- /dev/null +++ b/.changeset/witty-seals-snooze.md @@ -0,0 +1,7 @@ +--- +type: Changed +pr: 1801 +--- +**Internal: the installer's runtime → global-config-home hook-pathogen fragment is now a single `getGlobalConfigHomeFragment` lookup** — the 14-branch `if (runtime === 'x') return "'...'"` chain in `getConfigDirFromHome` (`bin/install.js`, the hook `path.join()` codegen mapping) is collapsed into one table in `runtime-name-policy.cts`, sibling to `getRuntimeLabel` (ADR-1239 Phase B, #1679 AC2 slice 2). Generated hook output is byte-identical for all 16 runtimes (golden-parity asserted); antigravity's dynamic env-overridable resolution is preserved in the caller. No user-facing change. + + diff --git a/bin/install.js b/bin/install.js index 33b9cf5b1..7d62d5709 100755 --- a/bin/install.js +++ b/bin/install.js @@ -37,7 +37,7 @@ const { // installer to the runtime-name-policy leaf (ADR-1508 / #1510 Phase 1) so the // conversion module's rewrite engine can consume it without importing // bin/install.js. Re-exported below for back-compat consumers/tests. -const { getDirName, getRuntimeLabel } = require('../gsd-core/bin/lib/runtime-name-policy.cjs'); +const { getDirName, getRuntimeLabel, getGlobalConfigHomeFragment } = require('../gsd-core/bin/lib/runtime-name-policy.cjs'); const { applyWorktreeBaseRef, readBaseRefFromSettings, @@ -510,18 +510,11 @@ function getConfigDirFromHome(runtime, isGlobal) { // Local installs use the same dir name pattern return `'${getDirName(runtime)}'`; } - // Global installs - OpenCode uses XDG path structure - if (runtime === 'copilot') return "'.copilot'"; - if (runtime === 'opencode') { - // OpenCode: ~/.config/opencode -> '.config', 'opencode' - // Return as comma-separated for path.join() replacement - return "'.config', 'opencode'"; - } - if (runtime === 'gemini') return "'.gemini'"; - if (runtime === 'kilo') return "'.config', 'kilo'"; - if (runtime === 'codex') return "'.codex'"; + // Global installs. antigravity's home is resolved dynamically (env-overridable, + // multi-segment via resolveAntigravityGlobalDir + path.relative) — not a table + // entry. (The prior inner `if (!isGlobal) return "'.agents'"` was unreachable: + // !isGlobal returns at the top of this function.) if (runtime === 'antigravity') { - if (!isGlobal) return "'.agents'"; const antigravityDir = resolveAntigravityGlobalDir(); const rel = path.relative(os.homedir(), antigravityDir); const segments = rel.split(path.sep).filter(Boolean); @@ -532,16 +525,9 @@ function getConfigDirFromHome(runtime, isGlobal) { // stable legacy template so generated path.join() calls remain valid. return "'.gemini', 'antigravity'"; } - if (runtime === 'cursor') return "'.cursor'"; - if (runtime === 'windsurf') return "'.windsurf'"; - if (runtime === 'augment') return "'.augment'"; - if (runtime === 'trae') return "'.trae'"; - if (runtime === 'qwen') return "'.qwen'"; - if (runtime === 'hermes') return "'.hermes'"; - if (runtime === 'codebuddy') return "'.codebuddy'"; - if (runtime === 'cline') return "'.cline'"; - if (runtime === 'kimi') return "'.config', 'agents'"; - return "'.claude'"; + // All other runtimes: single source-of-truth fragment table (ADR-1239 Phase B, + // #1679). claude/unknown fall through to the table's default '.claude'. + return getGlobalConfigHomeFragment(runtime); } /** diff --git a/src/runtime-name-policy.cts b/src/runtime-name-policy.cts index d31f89f7e..0ca9ef667 100644 --- a/src/runtime-name-policy.cts +++ b/src/runtime-name-policy.cts @@ -208,3 +208,52 @@ export function getRuntimeLabel(runtime: string): string { const label = RUNTIME_LABELS[runtime]; return typeof label === 'string' && label.length > 0 ? label : 'Claude Code'; } + +/** + * Source-string fragments for the runtime → global config-home path, used by + * `getConfigDirFromHome` in bin/install.js to template `path.join()` calls in + * generated hook scripts. Each value is a JS-source snippet (embedded quotes / + * commas are intentional — it is spliced into generated code as path.join args). + * + * Collapses the prior 14-branch `if (runtime === 'x') return "'...'"` chain in + * bin/install.js (ADR-1239 Phase B / #1679, AC2 slice 2) — the add-a-host tax: + * a new runtime meant remembering to add a branch here. Values are preserved + * BYTE-FOR-BYTE from the prior chain; golden install parity asserts generated + * hook output is unchanged across all 16 runtimes. + * + * Two runtimes are intentionally absent (handled by the caller, NOT this table): + * - `claude` → the default; falls through to `DEFAULT_FRAGMENT`. + * - `antigravity`→ resolved dynamically via resolveAntigravityGlobalDir + + * path.relative (multi-segment, env-overridable). + * + * Unknown/empty ids fall back to the default (`.claude`). + */ +const DEFAULT_CONFIG_HOME_FRAGMENT = "'.claude'"; +const GLOBAL_CONFIG_HOME_FRAGMENTS: Readonly> = { + copilot: "'.copilot'", + opencode: "'.config', 'opencode'", + gemini: "'.gemini'", + kilo: "'.config', 'kilo'", + codex: "'.codex'", + cursor: "'.cursor'", + windsurf: "'.windsurf'", + augment: "'.augment'", + trae: "'.trae'", + qwen: "'.qwen'", + hermes: "'.hermes'", + codebuddy: "'.codebuddy'", + cline: "'.cline'", + kimi: "'.config', 'agents'", +}; + +/** + * Return the global config-home path-fragment source snippet for a runtime + * (for hook path.join() codegen). `claude`/unknown/empty → the default + * `'.claude'` fragment. `antigravity` is NOT handled here (caller resolves it + * dynamically). Pure: no I/O. Sibling to `getDirName` / `getRuntimeLabel`. + */ +export function getGlobalConfigHomeFragment(runtime: string): string { + if (!runtime) return DEFAULT_CONFIG_HOME_FRAGMENT; + const frag = GLOBAL_CONFIG_HOME_FRAGMENTS[runtime]; + return typeof frag === 'string' && frag.length > 0 ? frag : DEFAULT_CONFIG_HOME_FRAGMENT; +} diff --git a/tests/global-config-home-fragment.test.cjs b/tests/global-config-home-fragment.test.cjs new file mode 100644 index 000000000..19ee42c95 --- /dev/null +++ b/tests/global-config-home-fragment.test.cjs @@ -0,0 +1,95 @@ +'use strict'; +/** + * Drift-guard + collapse: getGlobalConfigHomeFragment must be the SINGLE source + * of truth for the runtime → global config-home path-fragment mapping used by + * `getConfigDirFromHome` in bin/install.js for hook path.join() codegen. + * + * Collapses the prior 14-branch `if (runtime === 'x') return "'...'"` chain + * (install.js ~514-543) into one table — ADR-1239 Phase B / #1679, AC2 slice 2. + * + * Invariants pinned here: + * 1. Each of the 14 table runtimes returns its exact verbatim source fragment + * (byte-identical to the prior chain — golden install parity asserts the + * generated hook output is unchanged). + * 2. claude + unknown + empty fall back to the default "'.claude'" fragment. + * 3. antigravity is intentionally NOT in the table (handled dynamically by the + * caller via resolveAntigravityGlobalDir). + * 4. Drift guard: every registry runtime EXCEPT {claude, antigravity} has a + * table entry — so adding a runtime forces a deliberate fragment decision + * here (the add-a-host tax this collapse removes). + * + * ADR-1239 Phase B (#1679). Behavioral tests only. + */ + +const { test } = require('node:test'); +const assert = require('node:assert/strict'); +const runtimeNamePolicy = require('../gsd-core/bin/lib/runtime-name-policy.cjs'); +const registry = require('../gsd-core/bin/lib/capability-registry.cjs'); + +const { getGlobalConfigHomeFragment } = runtimeNamePolicy; + +// Golden oracle: the exact source-string fragments the prior install.js chain +// emitted, preserved verbatim. These are path.join() arg-source snippets (the +// embedded quotes/commas are intentional — they get spliced into generated hook +// scripts). Pinned here as the test oracle. +const GOLDEN_FRAGMENT_MAP = { + copilot: "'.copilot'", + opencode: "'.config', 'opencode'", + gemini: "'.gemini'", + kilo: "'.config', 'kilo'", + codex: "'.codex'", + cursor: "'.cursor'", + windsurf: "'.windsurf'", + augment: "'.augment'", + trae: "'.trae'", + qwen: "'.qwen'", + hermes: "'.hermes'", + codebuddy: "'.codebuddy'", + cline: "'.cline'", + kimi: "'.config', 'agents'", +}; + +// Runtimes intentionally NOT in the table: claude is the default; antigravity is +// resolved dynamically by the caller (resolveAntigravityGlobalDir + path.relative). +const SPECIAL_CASED = new Set(['claude', 'antigravity']); + +test('getGlobalConfigHomeFragment: golden map matches for all 14 table runtimes', () => { + for (const [id, expected] of Object.entries(GOLDEN_FRAGMENT_MAP)) { + const actual = getGlobalConfigHomeFragment(id); + assert.strictEqual( + actual, + expected, + `getGlobalConfigHomeFragment('${id}') diverged from golden.\n` + + ` actual: ${JSON.stringify(actual)}\n` + + ` expected: ${JSON.stringify(expected)}`, + ); + } +}); + +test('getGlobalConfigHomeFragment fallback: claude/unknown/empty return the default fragment', () => { + assert.strictEqual(getGlobalConfigHomeFragment('claude'), "'.claude'", + 'claude must return the default fragment (it is special-cased as the default)'); + assert.strictEqual(getGlobalConfigHomeFragment('unknown'), "'.claude'", + 'unknown runtime must return the default fragment'); + assert.strictEqual(getGlobalConfigHomeFragment(''), "'.claude'", + 'empty input must return the default fragment'); +}); + +test('drift guard: every registry runtime except {claude, antigravity} has a table entry (add-a-host tax removed)', () => { + // A newly-added registry runtime that is NOT claude/antigravity MUST get a + // deliberate fragment entry here — otherwise it silently falls through to the + // '.claude' default. claude (default) and antigravity (caller-dynamic) are the + // only legitimate absences. + const tableIds = new Set(Object.keys(GOLDEN_FRAGMENT_MAP)); + const missing = Object.keys(registry.runtimes) + .filter((id) => !SPECIAL_CASED.has(id) && !tableIds.has(id)); + assert.deepEqual(missing, [], + `registry runtimes missing a fragment table entry (add one to GOLDEN_FRAGMENT_MAP + the module table, or add to SPECIAL_CASED if caller-dynamic): ${missing.join(', ')}`); +}); + +test('drift guard: table keys are a subset of the registry (no stale entries)', () => { + const registryIds = new Set(Object.keys(registry.runtimes)); + const stale = Object.keys(GOLDEN_FRAGMENT_MAP).filter((id) => !registryIds.has(id)); + assert.deepEqual(stale, [], + `fragment table references runtimes not in the registry (stale entries): ${stale.join(', ')}`); +});