@jakobm/peacekeeper 0.0.0-stage → 0.12.1

package/scripts/remove-empty-directories.js

@@ -0,0 +1,163 @@
+#!/usr/bin/env node
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { execFileSync } = require('node:child_process');
+
+const PROTECTED_ROOT_DIRECTORIES = new Set(['.git', 'node_modules', 'tmp']);
+
+function findRepositoryRoot(cwd) {
+  return execFileSync('git', ['-C', cwd, 'rev-parse', '--show-toplevel'], {
+    encoding: 'utf8',
+  }).trim();
+}
+
+function listPresentFiles(root) {
+  const output = execFileSync(
+    'git',
+    [
+      '-C',
+      root,
+      'ls-files',
+      '-z',
+      '--cached',
+      '--others',
+      '--exclude-standard',
+    ],
+    { encoding: 'buffer' },
+  );
+
+  return output
+    .toString('utf8')
+    .split('\0')
+    .filter(Boolean)
+    .filter((relativePath) => fs.lstatSync(path.join(root, relativePath), {
+      throwIfNoEntry: false,
+    }));
+}
+
+function requiredDirectories(root, files) {
+  const required = new Set();
+
+  for (const file of files) {
+    const absolutePath = path.join(root, file);
+    let directory = fs.lstatSync(absolutePath).isDirectory()
+      ? file.replace(/\/+$/u, '')
+      : path.posix.dirname(file);
+
+    while (directory !== '.') {
+      required.add(directory);
+      directory = path.posix.dirname(directory);
+    }
+  }
+
+  return required;
+}
+
+function findEmptyDirectories(root) {
+  const required = requiredDirectories(root, listPresentFiles(root));
+
+  function visit(absoluteDirectory, relativeDirectory) {
+    // A nested repository owns its contents, even when its parent is ignored.
+    if (relativeDirectory !== '' && fs.lstatSync(path.join(absoluteDirectory, '.git'), {
+      throwIfNoEntry: false,
+    })) return { keep: true, directories: [] };
+
+    let keep = relativeDirectory === '' || required.has(relativeDirectory);
+    const directories = [];
+    for (const entry of fs.readdirSync(absoluteDirectory, {
+      withFileTypes: true,
+    })) {
+      if (!entry.isDirectory()) continue;
+      if (
+        relativeDirectory === ''
+        && PROTECTED_ROOT_DIRECTORIES.has(entry.name)
+      ) continue;
+
+      const relativePath = relativeDirectory
+        ? `${relativeDirectory}/${entry.name}`
+        : entry.name;
+      const absolutePath = path.join(absoluteDirectory, entry.name);
+
+      const child = visit(absolutePath, relativePath);
+      keep ||= child.keep;
+      directories.push(...child.directories);
+    }
+    return { keep, directories: keep ? directories : [relativeDirectory] };
+  }
+
+  return visit(root, '').directories;
+}
+
+function removeEmptyDirectories(root, directories) {
+  for (const directory of directories) {
+    fs.rmSync(path.join(root, directory), { recursive: true });
+  }
+}
+
+function parseArguments(args) {
+  let execute = false;
+
+  for (const argument of args) {
+    if (argument === '--execute') {
+      execute = true;
+    } else if (argument === '--dry-run') {
+      execute = false;
+    } else {
+      throw new Error(`unknown argument: ${argument}`);
+    }
+  }
+
+  return { execute };
+}
+
+function run({ args, cwd, log }) {
+  const { execute } = parseArguments(args);
+  const root = findRepositoryRoot(cwd);
+  const directories = findEmptyDirectories(root);
+
+  if (directories.length === 0) {
+    log('No empty directories found.');
+    return;
+  }
+
+  if (execute) {
+    removeEmptyDirectories(root, directories);
+    for (const directory of directories) log(`Removed ${directory}`);
+    return;
+  }
+
+  for (const directory of directories) log(`Would remove ${directory}`);
+  log('');
+  log('To remove these directories, run:');
+  log('  npm exec --no -- peacekeeper remove-empty-directories --execute');
+}
+
+function main() {
+  if (process.argv.includes('--help') || process.argv.includes('-h')) {
+    console.log('Usage: remove-empty-directories.js [--dry-run | --execute]');
+    console.log('');
+    console.log('Dry-run is the default. Use --execute to remove directories containing only ignored files.');
+    return;
+  }
+
+  try {
+    run({
+      args: process.argv.slice(2),
+      cwd: process.cwd(),
+      log: console.log,
+    });
+  } catch (error) {
+    console.error(`Error: ${error.message}`);
+    process.exitCode = 1;
+  }
+}
+
+if (require.main === module) main();
+
+module.exports = {
+  findEmptyDirectories,
+  parseArguments,
+  removeEmptyDirectories,
+  run,
+};

package/scripts/run-tests.js

@@ -0,0 +1,56 @@
+#!/usr/bin/env node
+
+const { spawnSync } = require('node:child_process');
+const fs = require('node:fs');
+const { checkReceipt, successMessage } = require('./check-test-receipt');
+const { recordReceipt } = require('./record-test-receipt');
+const { projectConfig } = require('./project-config');
+const { receiptPath, snapshot } = require('./receipt-state');
+
+function run(command, root) {
+  const result = spawnSync(command, { cwd: root, stdio: 'inherit', shell: true });
+  if (result.error) throw result.error;
+  return result.status ?? 1;
+}
+
+function hasReusableReceipt() {
+  try {
+    return checkReceipt();
+  } catch (error) {
+    console.error(error.message);
+    return false;
+  }
+}
+
+function main() {
+  const config = projectConfig();
+  const force = process.argv.length === 3 && ['rerun', '--force'].includes(process.argv[2]);
+  if (process.argv.length !== 2 && !force) {
+    console.error('Usage: node scripts/run-tests.js [rerun|--force]');
+    process.exitCode = 2;
+    return;
+  }
+  if (!force && !process.env.CI && hasReusableReceipt()) {
+    console.log(successMessage(config.root));
+    return;
+  }
+  fs.rmSync(receiptPath(config.root), { force: true });
+  const testedSnapshot = snapshot(config.root);
+  for (const command of config.tests.commands) {
+    const status = run(command, config.root);
+    if (status !== 0) {
+      process.exitCode = status;
+      return;
+    }
+  }
+  recordReceipt(config.root, testedSnapshot);
+}
+
+if (require.main === module) {
+  try {
+    main();
+  } catch (error) {
+    console.error(error.message);
+    process.exitCode = 1;
+  }
+}

package/scripts/verify-release-core.js

@@ -0,0 +1,39 @@
+'use strict';
+const { verifyProtection } = require('./release-protection');
+
+function list(api, endpoint, member) {
+  const items = [];
+  for (let page = 1; ; page += 1) {
+    const response = api(`${endpoint}${endpoint.includes('?') ? '&' : '?'}per_page=100&page=${page}`);
+    const batch = member ? response[member] : response;
+    if (!Array.isArray(batch)) throw new Error(`GitHub returned an invalid list for ${endpoint}`);
+    items.push(...batch);
+    if (batch.length < 100) return items;
+  }
+}
+
+function verifyRelease({ api, slug, sha, tag, branch, checks, workflow }) {
+  if (!/^v\d+\.\d+\.\d+$/u.test(tag)) throw new Error('Expected a stable release tag');
+  verifyProtection({ api, slug, branch, checks });
+  const base = `repos/${slug}`;
+  const commit = api(`${base}/commits/${encodeURIComponent(sha)}`);
+  const comparison = api(`${base}/compare/${commit.sha}...${encodeURIComponent(branch)}`);
+  if (!['ahead', 'identical'].includes(comparison.status)) throw new Error('Release commit must belong to the default branch');
+  const pulls = list(api, `${base}/commits/${commit.sha}/pulls`);
+  const pull = pulls.find(pr => pr.merged_at && pr.merge_commit_sha === commit.sha &&
+    pr.base.ref === branch && pr.base.repo.full_name === slug &&
+    pr.head.repo?.full_name === slug && pr.head.ref === `release/${tag}`);
+  if (!pull) throw new Error('Tag must point to a merged release PR');
+  const runs = list(api, `${base}/actions/workflows/${encodeURIComponent(workflow)}/runs?event=pull_request&head_sha=${pull.head.sha}`, 'workflow_runs');
+  const run = runs.sort((a, b) => b.run_number - a.run_number)[0];
+  if (!run || run.conclusion !== 'success') throw new Error('Release PR must have a successful CI run');
+  const jobs = list(api, `${base}/actions/runs/${run.id}/jobs?filter=latest`, 'jobs');
+  for (const name of checks) {
+    const matching = jobs.filter(job => job.name === name);
+    if (!matching.length || matching.some(job => job.conclusion !== 'success')) {
+      throw new Error(`Release PR requires successful ${name} check`);
+    }
+  }
+}
+
+module.exports = { verifyRelease };

package/scripts/verify-release-protection.js

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+'use strict';
+const { spawnSync } = require('node:child_process');
+const { projectConfig } = require('./project-config');
+const { originRepository } = require('./release-core');
+const { githubApi, requiredChecks, verifyProtection } = require('./release-protection');
+
+try {
+  const cwd = process.cwd();
+  const config = projectConfig(cwd);
+  const remote = spawnSync('git', ['remote', 'get-url', config.git.remote], { encoding: 'utf8' });
+  if (remote.status !== 0) throw new Error(remote.stderr);
+  const { host, slug } = originRepository(remote.stdout.trim());
+  const api = githubApi((command, args, options) => spawnSync(command, args, { ...options, encoding: 'utf8' }), cwd, host);
+  verifyProtection({ api, slug, branch: process.env.GITHUB_BASE_REF || config.git.defaultBranch, checks: requiredChecks(cwd) });
+} catch (error) {
+  console.error(error.message);
+  process.exitCode = 1;
+}

package/scripts/verify-release-version.js

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('node:fs');
+
+const manifest = JSON.parse(fs.readFileSync('package.json', 'utf8'));
+const lockfile = JSON.parse(fs.readFileSync('package-lock.json', 'utf8'));
+const expectedTag = `v${manifest.version}`;
+if (process.env.RELEASE_TAG !== expectedTag) {
+  throw new Error(`Release tag must be ${expectedTag}, got ${process.env.RELEASE_TAG}`);
+}
+if (lockfile.version !== manifest.version || lockfile.packages[''].version !== manifest.version) {
+  throw new Error('package-lock.json version must match package.json');
+}

package/scripts/verify-release.js

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+'use strict';
+const { spawnSync, execFileSync } = require('node:child_process');
+const path = require('node:path');
+const { projectConfig } = require('./project-config');
+const { originRepository, inspectWorkflow } = require('./release-core');
+const { githubApi, requiredChecks } = require('./release-protection');
+const { verifyRelease } = require('./verify-release-core');
+
+try {
+  // Preserve the standalone version command's contract and error messages.
+  execFileSync(process.execPath, [path.join(__dirname, 'verify-release-version.js')], { stdio: 'inherit' });
+  const cwd = process.cwd();
+  const config = projectConfig(cwd);
+  const remote = execFileSync('git', ['remote', 'get-url', config.git.remote], { encoding: 'utf8' }).trim();
+  const { host, slug } = originRepository(remote);
+  const api = githubApi((command, args, options) => spawnSync(command, args, { ...options, encoding: 'utf8' }), cwd, host);
+  const tag = process.env.RELEASE_TAG;
+  const sha = execFileSync('git', ['rev-parse', 'HEAD'], { encoding: 'utf8' }).trim();
+  const publishWorkflow = inspectWorkflow(cwd, tag);
+  verifyRelease({ api, slug, sha, tag, branch: config.git.defaultBranch,
+    checks: requiredChecks(cwd), workflow: config.git.releaseTestWorkflow || path.basename(publishWorkflow.path) });
+} catch (error) {
+  console.error(error.message);
+  process.exitCode = 1;
+}