@izkac/forgekit 0.1.0

package/src/adr.test.mjs

@@ -0,0 +1,170 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import {
+  ADR_SKILLS,
+  DEFAULT_ADR_DIR,
+  decisionsDocFor,
+  decisionsRelFromAdrReadme,
+  disableProjectAdr,
+  loadProjectConfig,
+  loadUserConfig,
+  normalizeAdrDir,
+  resolveProjectAdr,
+  saveUserConfig,
+  scaffoldAdr,
+} from './adr.mjs';
+import {
+  applyAdrSkills,
+  inferAdrFromSkills,
+  parseArgs,
+  installSkillsToAgents,
+  SKILL_IDS,
+} from './install.mjs';
+import { initProject, parseArgs as parseInitArgs } from './init.mjs';
+
+test('normalizeAdrDir defaults and rejects escapes', () => {
+  assert.equal(normalizeAdrDir(''), DEFAULT_ADR_DIR);
+  assert.equal(normalizeAdrDir('docs/adr'), 'docs/adr');
+  assert.equal(normalizeAdrDir('docs\\architecture\\adr\\'), 'docs/architecture/adr');
+  assert.throws(() => normalizeAdrDir('../outside'), /relative path/);
+  assert.throws(() => normalizeAdrDir('/abs'), /relative path/);
+});
+
+test('decisionsDocFor derives sibling decisions.md', () => {
+  assert.equal(decisionsDocFor('docs/adr'), 'docs/decisions.md');
+  assert.equal(decisionsDocFor('architecture/decisions'), 'architecture/decisions.md');
+});
+
+test('decisionsRelFromAdrReadme', () => {
+  assert.equal(decisionsRelFromAdrReadme('docs/adr', 'docs/decisions.md'), '../decisions.md');
+});
+
+test('user config round-trip', () => {
+  const home = fs.mkdtempSync(path.join(os.tmpdir(), 'forgekit-adr-user-'));
+  try {
+    saveUserConfig({ adr: { enabled: true, dir: 'arch/adr' } }, home);
+    const loaded = loadUserConfig(home);
+    assert.equal(loaded.adr.enabled, true);
+    assert.equal(loaded.adr.dir, 'arch/adr');
+  } finally {
+    fs.rmSync(home, { recursive: true, force: true });
+  }
+});
+
+test('scaffoldAdr writes decisions, index, config, hooks', () => {
+  const cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'forgekit-adr-proj-'));
+  try {
+    const result = scaffoldAdr(cwd, { dir: 'docs/adr', force: true });
+    assert.equal(result.dir, 'docs/adr');
+    assert.equal(result.decisionsDoc, 'docs/decisions.md');
+    assert.ok(fs.existsSync(path.join(cwd, 'docs', 'decisions.md')));
+    assert.ok(fs.existsSync(path.join(cwd, 'docs', 'adr', 'README.md')));
+    assert.ok(fs.existsSync(path.join(cwd, '.forge', 'config.json')));
+    assert.ok(
+      fs.existsSync(path.join(cwd, 'scripts', 'hooks', 'check-pending-adrs.sh')),
+    );
+    const cfg = loadProjectConfig(cwd);
+    assert.equal(cfg.adr.enabled, true);
+    assert.equal(cfg.adr.dir, 'docs/adr');
+    const decisions = fs.readFileSync(path.join(cwd, 'docs', 'decisions.md'), 'utf8');
+    assert.match(decisions, /docs\/adr/);
+  } finally {
+    fs.rmSync(cwd, { recursive: true, force: true });
+  }
+});
+
+test('scaffoldAdr custom dir', () => {
+  const cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'forgekit-adr-custom-'));
+  try {
+    scaffoldAdr(cwd, { dir: 'architecture/adr', force: true });
+    assert.ok(fs.existsSync(path.join(cwd, 'architecture', 'decisions.md')));
+    assert.ok(fs.existsSync(path.join(cwd, 'architecture', 'adr', 'README.md')));
+  } finally {
+    fs.rmSync(cwd, { recursive: true, force: true });
+  }
+});
+
+test('disableProjectAdr', () => {
+  const cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'forgekit-adr-off-'));
+  try {
+    scaffoldAdr(cwd, { force: true });
+    disableProjectAdr(cwd);
+    assert.equal(loadProjectConfig(cwd).adr.enabled, false);
+    assert.equal(resolveProjectAdr(cwd).enabled, false);
+  } finally {
+    fs.rmSync(cwd, { recursive: true, force: true });
+  }
+});
+
+test('applyAdrSkills / inferAdrFromSkills', () => {
+  assert.deepEqual(
+    applyAdrSkills(['forge'], true).sort(),
+    ['archive-to-adr', 'forge', 'git-resolve-adr-conflict'].sort(),
+  );
+  assert.deepEqual(applyAdrSkills(['forge', 'archive-to-adr'], false), ['forge']);
+  assert.equal(inferAdrFromSkills(['forge'], null), null);
+  assert.equal(inferAdrFromSkills(['archive-to-adr'], null), true);
+  assert.equal(inferAdrFromSkills(['forge'], false), false);
+  assert.equal(inferAdrFromSkills(['forge'], true), true);
+  assert.ok(ADR_SKILLS.every((id) => SKILL_IDS.includes(id)));
+});
+
+test('parseArgs adr flags', () => {
+  const opts = parseArgs([
+    '--skills',
+    'forge',
+    '--adr',
+    '--adr-dir',
+    'arch/adr',
+    '--adr-project',
+  ]);
+  assert.equal(opts.adr, true);
+  assert.equal(opts.adrDir, 'arch/adr');
+  assert.equal(opts.adrProject, true);
+  assert.equal(parseArgs(['--no-adr']).adr, false);
+});
+
+test('install with --adr installs ADR skills', () => {
+  const home = fs.mkdtempSync(path.join(os.tmpdir(), 'forgekit-adr-inst-'));
+  try {
+    const results = installSkillsToAgents(
+      applyAdrSkills(['forge'], true),
+      ['cursor'],
+      { home, force: true },
+    );
+    assert.ok(results.some((r) => r.skill === 'archive-to-adr'));
+    assert.ok(
+      fs.existsSync(path.join(home, '.cursor', 'skills', 'archive-to-adr', 'SKILL.md')),
+    );
+    assert.ok(
+      fs.existsSync(
+        path.join(home, '.cursor', 'skills', 'git-resolve-adr-conflict', 'SKILL.md'),
+      ),
+    );
+  } finally {
+    fs.rmSync(home, { recursive: true, force: true });
+  }
+});
+
+test('initProject --adr scaffolds and allows config.json in gitignore', () => {
+  const cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'forgekit-init-adr-'));
+  try {
+    const report = initProject(['codex'], {
+      cwd,
+      force: true,
+      adr: true,
+      adrDir: 'docs/adr',
+    });
+    assert.ok(report.adr);
+    assert.ok(fs.existsSync(path.join(cwd, '.forge', 'config.json')));
+    const gi = fs.readFileSync(path.join(cwd, '.forge', '.gitignore'), 'utf8');
+    assert.match(gi, /!config\.json/);
+    assert.equal(parseInitArgs(['--adr', '--adr-dir', 'x/y']).adr, true);
+    assert.equal(parseInitArgs(['--no-adr']).adr, false);
+  } finally {
+    fs.rmSync(cwd, { recursive: true, force: true });
+  }
+});

package/src/change.mjs

@@ -0,0 +1,234 @@
+#!/usr/bin/env node
+/**
+ * Specs-engine change scaffolding.
+ *
+ * Usage:
+ *   forge change new <name> [--cwd <path>] [--force]
+ *   forge change archive <name> [--cwd <path>] [--date YYYY-MM-DD]
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import {
+  DEFAULT_SPECS_DIR,
+  resolveProjectPlanEngine,
+} from './plan-engine.mjs';
+
+/**
+ * @param {string[]} argv
+ */
+export function parseArgs(argv) {
+  const opts = {
+    help: false,
+    force: false,
+    cwd: process.cwd(),
+    date: /** @type {string | null} */ (null),
+    action: /** @type {string | null} */ (null),
+    name: /** @type {string | null} */ (null),
+  };
+
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === '--help' || arg === '-h') opts.help = true;
+    else if (arg === '--force' || arg === '-f') opts.force = true;
+    else if (arg === '--cwd') opts.cwd = argv[++i];
+    else if (arg === '--date') opts.date = argv[++i];
+    else if (!opts.action && (arg === 'new' || arg === 'archive')) opts.action = arg;
+    else if (!opts.name && !arg.startsWith('-')) opts.name = arg;
+    else throw new Error(`Unknown argument: ${arg}`);
+  }
+  return opts;
+}
+
+function printHelp() {
+  process.stdout.write(`Usage: forge change <new|archive> <name> [options]
+
+Scaffold or archive a change for the built-in specs planning engine.
+
+Commands:
+  new <name>       Create specs/changes/<name>/{proposal.md,tasks.md}
+  archive <name>   Move specs/changes/<name> → changes/archive/YYYY-MM-DD-<name>
+
+Options:
+  --cwd <path>     Project root (default: cwd)
+  --date YYYY-MM-DD  Archive date prefix (default: today UTC)
+  --force, -f      Overwrite existing proposal/tasks on new
+  --help
+
+Requires \`.forge/config.json\` → plan.engine: specs (or run \`forge init --no-openspec\`).
+`);
+}
+
+/**
+ * @param {string} name
+ */
+export function assertChangeName(name) {
+  if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(name)) {
+    throw new Error(
+      `Change name must be kebab-case (got: ${name}). Example: add-stripe-refunds`,
+    );
+  }
+  return name;
+}
+
+const PROPOSAL_TMPL = (title) => `# ${title}
+
+## Why
+
+One or two paragraphs: problem / pressure.
+
+## What Changes
+
+- …
+
+## Impact
+
+Affected code/areas, risks, migration notes.
+`;
+
+const TASKS_TMPL = `# Tasks
+
+## 1. First group
+- [ ] 1.1 Bite-sized task — exact files, expected tests
+
+## 2. Second group
+- [ ] 2.1 …
+`;
+
+/**
+ * @param {string} cwd
+ * @param {string} name
+ * @param {{ force?: boolean }} [opts]
+ */
+export function createSpecsChange(cwd, name, opts = {}) {
+  assertChangeName(name);
+  const engine = resolveProjectPlanEngine(cwd, { useUserDefault: false });
+  if (engine.engine !== 'specs') {
+    throw new Error(
+      `Project plan engine is "${engine.engine}", not "specs". ` +
+        `Use \`openspec-propose\` / \`/opsx:propose\` for OpenSpec projects, ` +
+        `or \`forge init --no-openspec\` to switch.`,
+    );
+  }
+  const dir = engine.dir || DEFAULT_SPECS_DIR;
+  const changeDir = path.join(cwd, dir, 'changes', name);
+  fs.mkdirSync(changeDir, { recursive: true });
+
+  /** @type {{ file: string, status: string }[]} */
+  const files = [];
+  const write = (rel, body) => {
+    const dest = path.join(changeDir, rel);
+    if (fs.existsSync(dest) && !opts.force) {
+      files.push({ file: `${dir}/changes/${name}/${rel}`, status: 'skipped' });
+      return;
+    }
+    fs.writeFileSync(dest, body, 'utf8');
+    files.push({ file: `${dir}/changes/${name}/${rel}`, status: 'written' });
+  };
+
+  const title = name
+    .split('-')
+    .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
+    .join(' ');
+  write('proposal.md', PROPOSAL_TMPL(title));
+  write('tasks.md', TASKS_TMPL);
+
+  return { dir, changeDir, name, files };
+}
+
+/**
+ * @param {string} cwd
+ * @param {string} name
+ * @param {{ date?: string | null }} [opts]
+ */
+export function archiveSpecsChange(cwd, name, opts = {}) {
+  assertChangeName(name);
+  const engine = resolveProjectPlanEngine(cwd, { useUserDefault: false });
+  if (engine.engine !== 'specs') {
+    throw new Error(
+      `Project plan engine is "${engine.engine}", not "specs". ` +
+        `Use \`openspec archive\` / \`/opsx:archive\` for OpenSpec projects.`,
+    );
+  }
+  const dir = engine.dir || DEFAULT_SPECS_DIR;
+  const src = path.join(cwd, dir, 'changes', name);
+  if (!fs.existsSync(src)) {
+    throw new Error(`Change not found: ${dir}/changes/${name}`);
+  }
+  const date =
+    opts.date ||
+    new Date().toISOString().slice(0, 10);
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(date)) {
+    throw new Error(`Invalid --date (want YYYY-MM-DD): ${date}`);
+  }
+  const archiveParent = path.join(cwd, dir, 'changes', 'archive');
+  fs.mkdirSync(archiveParent, { recursive: true });
+  const destName = `${date}-${name}`;
+  const dest = path.join(archiveParent, destName);
+  if (fs.existsSync(dest)) {
+    throw new Error(`Archive already exists: ${dir}/changes/archive/${destName}`);
+  }
+  fs.renameSync(src, dest);
+  return {
+    dir,
+    from: `${dir}/changes/${name}`,
+    to: `${dir}/changes/archive/${destName}`,
+  };
+}
+
+/**
+ * @param {string[]} argv
+ */
+export function runChange(argv) {
+  const opts = parseArgs(argv);
+  if (opts.help || !opts.action) {
+    printHelp();
+    return opts.help ? 0 : 1;
+  }
+  if (!opts.name) {
+    process.stderr.write('Missing change name.\n');
+    printHelp();
+    return 1;
+  }
+
+  if (opts.action === 'new') {
+    const result = createSpecsChange(opts.cwd, opts.name, { force: opts.force });
+    process.stdout.write(
+      `Created specs change "${result.name}" under ${result.dir}/changes/${result.name}/\n`,
+    );
+    for (const f of result.files) {
+      process.stdout.write(`  ${f.status.padEnd(8)} ${f.file}\n`);
+    }
+    process.stdout.write(
+      `\nNext: edit proposal.md / tasks.md, then:\n` +
+        `  forge phase plan --plan-type specs --openspec ${result.name}\n`,
+    );
+    return 0;
+  }
+
+  if (opts.action === 'archive') {
+    const result = archiveSpecsChange(opts.cwd, opts.name, { date: opts.date });
+    process.stdout.write(`Archived ${result.from} → ${result.to}\n`);
+    process.stdout.write(
+      `If ADRs are enabled, run archive-to-adr on the archived folder.\n`,
+    );
+    return 0;
+  }
+
+  process.stderr.write(`Unknown action: ${opts.action}\n`);
+  return 1;
+}
+
+const isMain =
+  process.argv[1] &&
+  import.meta.url === pathToFileURL(path.resolve(process.argv[1])).href;
+
+if (isMain) {
+  try {
+    process.exitCode = runChange(process.argv.slice(2));
+  } catch (err) {
+    process.stderr.write(`${err instanceof Error ? err.message : err}\n`);
+    process.exitCode = 1;
+  }
+}

package/src/change.test.mjs

@@ -0,0 +1,83 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import {
+  assertChangeName,
+  archiveSpecsChange,
+  createSpecsChange,
+  parseArgs,
+  runChange,
+} from './change.mjs';
+import { writeProjectPlanConfig, scaffoldSpecs } from './plan-engine.mjs';
+
+function tmp() {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'forgekit-change-'));
+}
+
+test('assertChangeName accepts kebab-case', () => {
+  assert.equal(assertChangeName('add-auth'), 'add-auth');
+  assert.throws(() => assertChangeName('Add Auth'), /kebab-case/);
+  assert.throws(() => assertChangeName('UPPER'), /kebab-case/);
+});
+
+test('parseArgs new and archive', () => {
+  assert.deepEqual(parseArgs(['new', 'foo', '--force']).action, 'new');
+  assert.equal(parseArgs(['new', 'foo']).name, 'foo');
+  assert.equal(parseArgs(['archive', 'foo', '--date', '2026-01-02']).date, '2026-01-02');
+});
+
+test('createSpecsChange writes proposal and tasks', () => {
+  const cwd = tmp();
+  try {
+    writeProjectPlanConfig(cwd, { engine: 'specs' });
+    scaffoldSpecs(cwd);
+    const result = createSpecsChange(cwd, 'add-refunds', { force: true });
+    assert.ok(fs.existsSync(path.join(result.changeDir, 'proposal.md')));
+    assert.ok(fs.existsSync(path.join(result.changeDir, 'tasks.md')));
+  } finally {
+    fs.rmSync(cwd, { recursive: true, force: true });
+  }
+});
+
+test('createSpecsChange rejects openspec engine', () => {
+  const cwd = tmp();
+  try {
+    writeProjectPlanConfig(cwd, { engine: 'openspec' });
+    assert.throws(() => createSpecsChange(cwd, 'x'), /not "specs"/);
+  } finally {
+    fs.rmSync(cwd, { recursive: true, force: true });
+  }
+});
+
+test('archiveSpecsChange moves to dated archive', () => {
+  const cwd = tmp();
+  try {
+    writeProjectPlanConfig(cwd, { engine: 'specs' });
+    scaffoldSpecs(cwd);
+    createSpecsChange(cwd, 'ship-it', { force: true });
+    const archived = archiveSpecsChange(cwd, 'ship-it', { date: '2026-07-18' });
+    assert.equal(archived.to, 'specs/changes/archive/2026-07-18-ship-it');
+    assert.ok(!fs.existsSync(path.join(cwd, 'specs', 'changes', 'ship-it')));
+    assert.ok(
+      fs.existsSync(
+        path.join(cwd, 'specs', 'changes', 'archive', '2026-07-18-ship-it', 'proposal.md'),
+      ),
+    );
+  } finally {
+    fs.rmSync(cwd, { recursive: true, force: true });
+  }
+});
+
+test('runChange new prints next steps', () => {
+  const cwd = tmp();
+  try {
+    writeProjectPlanConfig(cwd, { engine: 'specs' });
+    scaffoldSpecs(cwd);
+    const code = runChange(['new', 'demo-feat', '--cwd', cwd]);
+    assert.equal(code, 0);
+  } finally {
+    fs.rmSync(cwd, { recursive: true, force: true });
+  }
+});

package/src/cleanup-sessions.mjs

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+/**
+ * Remove Forge sessions older than RETENTION_DAYS (default 14).
+ * Skips the active session unless --include-active is passed.
+ *
+ * Usage:
+ *   forge cleanup
+ *   forge cleanup-sessions [--dry-run] [--include-active]
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import {
+  clearActive,
+  loadSession,
+  readActive,
+  RETENTION_DAYS,
+  SESSIONS_DIR,
+  sessionAgeDays,
+} from './lib.mjs';
+
+const args = new Set(process.argv.slice(2));
+const dryRun = args.has('--dry-run');
+const includeActive = args.has('--include-active');
+
+const active = readActive();
+const activeId = active?.sessionId ?? null;
+const removed = [];
+const kept = [];
+
+if (!fs.existsSync(SESSIONS_DIR)) {
+  process.stdout.write(JSON.stringify({ removed, kept, dryRun }, null, 2));
+  process.stdout.write('\n');
+  process.exit(0);
+}
+
+for (const entry of fs.readdirSync(SESSIONS_DIR, { withFileTypes: true })) {
+  if (!entry.isDirectory()) continue;
+  const sessionId = entry.name;
+  const dir = path.join(SESSIONS_DIR, sessionId);
+  const sessionFile = path.join(dir, 'session.json');
+  if (!fs.existsSync(sessionFile)) continue;
+
+  let session;
+  try {
+    ({ session } = loadSession(sessionId));
+  } catch {
+    continue;
+  }
+
+  const isActive = sessionId === activeId;
+  const tooOld = sessionAgeDays(session) > RETENTION_DAYS;
+  const isDone = session.phase === 'done' || session.phase === 'skipped';
+
+  const shouldRemove =
+    (tooOld || isDone) && (!isActive || includeActive);
+
+  if (shouldRemove) {
+    if (!dryRun) {
+      fs.rmSync(dir, { recursive: true, force: true });
+      if (isActive) clearActive();
+    }
+    removed.push({ sessionId, reason: tooOld ? 'retention' : 'finished' });
+  } else {
+    kept.push({ sessionId, phase: session.phase, ageDays: sessionAgeDays(session).toFixed(1) });
+  }
+}
+
+process.stdout.write(JSON.stringify({ removed, kept, dryRun, retentionDays: RETENTION_DAYS }, null, 2));
+process.stdout.write('\n');

package/src/config.mjs

@@ -0,0 +1,103 @@
+#!/usr/bin/env node
+/**
+ * Shared user (~/.forgekit/config.json) and project (.forge/config.json) config IO.
+ */
+
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+/**
+ * @param {string} [home]
+ * @returns {string}
+ */
+export function userConfigPath(home = os.homedir()) {
+  return path.join(home, '.forgekit', 'config.json');
+}
+
+/**
+ * @param {string} [home]
+ * @returns {Record<string, unknown>}
+ */
+export function loadUserConfig(home = os.homedir()) {
+  const p = userConfigPath(home);
+  if (!fs.existsSync(p)) return {};
+  try {
+    return JSON.parse(fs.readFileSync(p, 'utf8'));
+  } catch {
+    return {};
+  }
+}
+
+/**
+ * Deep-merge top-level keys; nested objects under named keys are shallow-merged.
+ * @param {Record<string, unknown>} patch
+ * @param {string} [home]
+ * @param {string[]} [mergeKeys] keys to shallow-merge instead of replace
+ */
+export function saveUserConfig(patch, home = os.homedir(), mergeKeys = ['adr', 'plan']) {
+  const dir = path.dirname(userConfigPath(home));
+  fs.mkdirSync(dir, { recursive: true });
+  const current = loadUserConfig(home);
+  /** @type {Record<string, unknown>} */
+  const next = { ...current, ...patch };
+  for (const key of mergeKeys) {
+    if (patch[key] && typeof patch[key] === 'object') {
+      next[key] = {
+        ...((current[key] && typeof current[key] === 'object' ? current[key] : {})),
+        .../** @type {Record<string, unknown>} */ (patch[key]),
+      };
+    }
+  }
+  fs.writeFileSync(userConfigPath(home), `${JSON.stringify(next, null, 2)}\n`, 'utf8');
+  return next;
+}
+
+/**
+ * @param {string} cwd
+ * @returns {string}
+ */
+export function projectConfigPath(cwd) {
+  return path.join(cwd, '.forge', 'config.json');
+}
+
+/**
+ * @param {string} cwd
+ * @returns {Record<string, unknown>}
+ */
+export function loadProjectConfig(cwd) {
+  const p = projectConfigPath(cwd);
+  if (!fs.existsSync(p)) return {};
+  try {
+    return JSON.parse(fs.readFileSync(p, 'utf8'));
+  } catch {
+    return {};
+  }
+}
+
+/**
+ * Merge-write project config. Nested mergeKeys are shallow-merged unless listed in replaceKeys.
+ * @param {string} cwd
+ * @param {Record<string, unknown>} patch
+ * @param {{ mergeKeys?: string[], replaceKeys?: string[] }} [opts]
+ */
+export function saveProjectConfig(cwd, patch, opts = {}) {
+  const mergeKeys = opts.mergeKeys ?? ['adr', 'plan'];
+  const replaceKeys = new Set(opts.replaceKeys ?? []);
+  const p = projectConfigPath(cwd);
+  fs.mkdirSync(path.dirname(p), { recursive: true });
+  const current = loadProjectConfig(cwd);
+  /** @type {Record<string, unknown>} */
+  const next = { ...current, ...patch };
+  for (const key of mergeKeys) {
+    if (replaceKeys.has(key)) continue;
+    if (patch[key] && typeof patch[key] === 'object') {
+      next[key] = {
+        ...((current[key] && typeof current[key] === 'object' ? current[key] : {})),
+        .../** @type {Record<string, unknown>} */ (patch[key]),
+      };
+    }
+  }
+  fs.writeFileSync(p, `${JSON.stringify(next, null, 2)}\n`, 'utf8');
+  return next;
+}