@opengsd/gsd-core 1.3.0-rc.1 → 1.3.0

package/scripts/release-notes/format-github-release-notes.cjs

@@ -0,0 +1,256 @@
+'use strict';
+
+const path = require('path');
+const os = require('os');
+const fs = require('fs');
+const { execFileSync } = require('child_process');
+
+/**
+ * Classify a What's-Changed bullet line into 'Feature', 'Fix', or 'Enhancement'.
+ * @param {string} bulletLine - Full bullet line including the leading `* ` or `- ` marker.
+ * @returns {'Feature'|'Fix'|'Enhancement'}
+ */
+function classifyTitle(bulletLine) {
+  // Strip leading `* ` or `- ` marker
+  const withoutMarker = bulletLine.replace(/^[*-]\s+/, '');
+
+  // Extract title = text before ` by @`
+  const byIdx = withoutMarker.indexOf(' by @');
+  const title = (byIdx !== -1 ? withoutMarker.slice(0, byIdx) : withoutMarker).trim();
+
+  if (/^feat(?:ure)?\s*(?:\(|!|:)/i.test(title)) return 'Feature';
+  if (/^fix\s*(?:\(|!|:)/i.test(title)) return 'Fix';
+  return 'Enhancement';
+}
+
+/**
+ * Reformat GitHub's auto-generated release notes into the repo's hand-curated format.
+ *
+ * @param {object} opts
+ * @param {string} opts.generatedBody - The raw GitHub-generated release body.
+ * @param {string} opts.version       - Version string (e.g. "1.3.0-rc.1"), no leading "v".
+ * @param {boolean} opts.prerelease   - Whether this is a pre-release.
+ * @param {string} opts.packageName   - npm package name (e.g. "@opengsd/gsd-core").
+ * @returns {string} Formatted release body (no trailing newline).
+ */
+function formatReleaseNotes({ generatedBody, version, prerelease, packageName }) {
+  const lines = generatedBody.split('\n');
+
+  const featureBullets = [];
+  const fixBullets = [];
+  const enhancementBullets = [];
+  const newContributorBullets = [];
+  let fullChangelogLine = null;
+
+  let inWhatsChanged = false;
+  let inNewContributors = false;
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+
+    // Detect section headings
+    if (trimmed === '## What\'s Changed') {
+      inWhatsChanged = true;
+      inNewContributors = false;
+      continue;
+    }
+
+    if (trimmed === '## New Contributors') {
+      inWhatsChanged = false;
+      inNewContributors = true;
+      continue;
+    }
+
+    // Full changelog line ends the What's Changed section
+    if (trimmed.startsWith('**Full Changelog**:')) {
+      inWhatsChanged = false;
+      inNewContributors = false;
+      fullChangelogLine = trimmed;
+      continue;
+    }
+
+    // Any other `##` heading ends current section
+    if (trimmed.startsWith('## ')) {
+      inWhatsChanged = false;
+      inNewContributors = false;
+      continue;
+    }
+
+    // Collect bullets
+    if (inWhatsChanged && (trimmed.startsWith('* ') || trimmed.startsWith('- '))) {
+      const category = classifyTitle(trimmed);
+      if (category === 'Feature') featureBullets.push(trimmed);
+      else if (category === 'Fix') fixBullets.push(trimmed);
+      else enhancementBullets.push(trimmed);
+      continue;
+    }
+
+    if (inNewContributors && (trimmed.startsWith('* ') || trimmed.startsWith('- '))) {
+      newContributorBullets.push(trimmed);
+      continue;
+    }
+  }
+
+  // Build Install block
+  let installBlock;
+  if (prerelease) {
+    installBlock = [
+      '## Install',
+      '',
+      'This pre-release is published to npm under the `next` dist-tag.',
+      '',
+      '```bash',
+      `npm i ${packageName}@${version}`,
+      '# or',
+      `npm i ${packageName}@next`,
+      '```',
+    ].join('\n');
+  } else {
+    installBlock = [
+      '## Install',
+      '',
+      '```bash',
+      `npm i ${packageName}@${version}`,
+      '# or',
+      `npm i ${packageName}@latest`,
+      '```',
+    ].join('\n');
+  }
+
+  // Assemble groups (omit empty ones)
+  const groups = [];
+
+  // Group A: Install
+  groups.push(installBlock);
+
+  // Group B: What's Changed heading
+  groups.push('## What\'s Changed');
+
+  // Group C: Features
+  if (featureBullets.length > 0) {
+    groups.push('### Feature\n' + featureBullets.join('\n'));
+  }
+
+  // Group D: Enhancements
+  if (enhancementBullets.length > 0) {
+    groups.push('### Enhancement\n' + enhancementBullets.join('\n'));
+  }
+
+  // Group E: Fixes
+  if (fixBullets.length > 0) {
+    groups.push('### Fix\n' + fixBullets.join('\n'));
+  }
+
+  // Group F: New Contributors
+  if (newContributorBullets.length > 0) {
+    groups.push('## New Contributors\n' + newContributorBullets.join('\n'));
+  }
+
+  // Group G: Full Changelog
+  if (fullChangelogLine) {
+    groups.push(fullChangelogLine);
+  }
+
+  return groups.join('\n\n');
+}
+
+// CLI entry point
+if (require.main === module) {
+  try {
+    const argv = process.argv.slice(2);
+
+    let tag = null;
+    let repo = null;
+    let packageName = null;
+    let prerelease = null;
+    let useStdin = false;
+    let doApply = false;
+
+    for (let i = 0; i < argv.length; i++) {
+      const arg = argv[i];
+      if (arg === '--tag') {
+        tag = argv[++i];
+      } else if (arg === '--repo') {
+        repo = argv[++i];
+      } else if (arg === '--package') {
+        packageName = argv[++i];
+      } else if (arg === '--prerelease') {
+        prerelease = true;
+      } else if (arg === '--latest') {
+        prerelease = false;
+      } else if (arg === '--stdin') {
+        useStdin = true;
+      } else if (arg === '--apply') {
+        doApply = true;
+      }
+    }
+
+    // Derive version from tag
+    const version = tag ? tag.replace(/^v/, '') : null;
+
+    // Resolve package name if not provided
+    if (!packageName) {
+      const repoRoot = path.resolve(__dirname, '..', '..');
+      const pkgJson = JSON.parse(fs.readFileSync(path.join(repoRoot, 'package.json'), 'utf8'));
+      packageName = pkgJson.name;
+    }
+
+    let generatedBody;
+
+    if (useStdin) {
+      // Read from stdin
+      if (!version) {
+        throw new Error('--stdin mode requires --tag or --version to derive version');
+      }
+      if (prerelease === null) {
+        throw new Error('--stdin mode requires --prerelease or --latest');
+      }
+      generatedBody = fs.readFileSync('/dev/stdin', 'utf8');
+    } else {
+      // Fetch from gh
+      if (!tag) {
+        throw new Error('--tag <tag> is required');
+      }
+
+      const ghArgs = ['release', 'view', tag, '--json', 'body', '-q', '.body'];
+      if (repo) ghArgs.push('--repo', repo);
+
+      generatedBody = execFileSync('gh', ghArgs, { encoding: 'utf8' });
+
+      // Determine prerelease if not forced
+      if (prerelease === null) {
+        try {
+          const ghPreArgs = ['release', 'view', tag, '--json', 'isPrerelease', '-q', '.isPrerelease'];
+          if (repo) ghPreArgs.push('--repo', repo);
+          const result = execFileSync('gh', ghPreArgs, { encoding: 'utf8' }).trim();
+          prerelease = result === 'true';
+        } catch (_e) {
+          // Final fallback: check if tag contains `-` after version digits
+          prerelease = /-/.test(version);
+        }
+      }
+    }
+
+    const formatted = formatReleaseNotes({ generatedBody, version, prerelease, packageName });
+
+    if (doApply) {
+      const tmpFile = path.join(os.tmpdir(), `release-notes-${Date.now()}.md`);
+      fs.writeFileSync(tmpFile, formatted, 'utf8');
+      try {
+        const ghArgs = ['release', 'edit', tag, '--notes-file', tmpFile];
+        if (repo) ghArgs.push('--repo', repo);
+        execFileSync('gh', ghArgs, { encoding: 'utf8' });
+        process.stderr.write(`Release notes updated for ${tag}\n`);
+      } finally {
+        fs.unlinkSync(tmpFile);
+      }
+    } else {
+      process.stdout.write(formatted + '\n');
+    }
+  } catch (err) {
+    process.stderr.write((err.message || String(err)) + '\n');
+    process.exit(1);
+  }
+}
+
+module.exports = { formatReleaseNotes, classifyTitle };

package/scripts/release-tarball-smoke.cjs

@@ -33,7 +33,7 @@
  *   Non-interactive: --local --claude flags skip all prompts.
  *
  * Workflow-body checks (Cycle 3 — informational):
- *   - Scans all installed get-shit-done/workflows/*.md for /gsd:<known-cmd>
+ *   - Scans all installed gsd-core/workflows/*.md for /gsd:<known-cmd>
  *     colon-namespace leaks (WORKFLOW_BODY_COLON_LEAK).
  *   This check populates result.details with counters but does NOT return a
  *   failure code by default; it is informational until enforcement is enabled.
@@ -45,7 +45,7 @@ const { execFileSync, spawnSync } = require('child_process');
 const fs = require('fs');
 const os = require('os');
 const path = require('path');
-const { PACKAGE_NAME } = require('../get-shit-done/bin/lib/package-identity.cjs');
+const { PACKAGE_NAME } = require('../gsd-core/bin/lib/package-identity.cjs');
 // 120 s proved too tight on Windows GitHub-hosted runners: cold-cache
 // `npm install -g` with a 1499-file tarball took ~120 s exactly, causing
 // spawnSync to fire SIGTERM and return { status: null, stdout: '', stderr: '' }
@@ -182,15 +182,15 @@ function findInstallerBin(installPrefix) {
  * Structured parser — only inspects individual lines; never regexes on the
  * whole-file string. Two recognised forms (in priority order):
  *
- *   1. @-import line:  `@~/.claude/get-shit-done/workflows/<name>.md`
- *   2. Inline mention: any line containing `~/.claude/get-shit-done/workflows/<name>.md`
+ *   1. @-import line:  `@~/.claude/gsd-core/workflows/<name>.md`
+ *   2. Inline mention: any line containing `~/.claude/gsd-core/workflows/<name>.md`
  *      (takes the LAST occurrence so conditional-dispatch files resolve to the
  *       default / unconditional branch, e.g. discuss-phase.md)
  *
  * Returns the bare workflow filename (e.g. `"discuss-phase.md"`) or null.
  */
 function parseWorkflowRef(mdContent) {
-  const WORKFLOW_PREFIX = 'get-shit-done/workflows/';
+  const WORKFLOW_PREFIX = 'gsd-core/workflows/';
   let atImportResult = null;
   let lastInlineResult = null;
 
@@ -433,7 +433,7 @@ function runSmoke({
     // Verify expected dirs were created
     const expectedDirs = [
       path.join(fixtureDir, '.claude', 'commands'),
-      path.join(fixtureDir, '.claude', 'get-shit-done'),
+      path.join(fixtureDir, '.claude', 'gsd-core'),
     ];
     for (const dir of expectedDirs) {
       if (!fs.existsSync(dir) || !fs.statSync(dir).isDirectory()) {
@@ -472,9 +472,9 @@ function runSmoke({
 
     let workflowPath = null;
     if (workflowName) {
-      // Workflow files live at get-shit-done/workflows/<name> in the package.
+      // Workflow files live at gsd-core/workflows/<name> in the package.
       // Some live in subdirectories; try flat first then scan once.
-      const flat = path.join(pkg, 'get-shit-done', 'workflows', workflowName);
+      const flat = path.join(pkg, 'gsd-core', 'workflows', workflowName);
       workflowPath = fs.existsSync(flat) ? flat : null;
 
       if (!workflowPath) {
@@ -503,7 +503,7 @@ function runSmoke({
   // ─────────────────────────────────────────────────────────────────────────
 
   // --- Workflow-body checks (informational — #3668 not yet fixed) ----------
-  const workflowsDir = path.join(pkg, 'get-shit-done', 'workflows');
+  const workflowsDir = path.join(pkg, 'gsd-core', 'workflows');
   const installedCmdNames = readInstalledCmdNames(pkg);
 
   let workflowsScanned = 0;

package/scripts/run-tests.cjs

@@ -26,7 +26,7 @@ const { execFileSync } = require('child_process');
 
 const SUITES = ['all', 'unit', 'integration', 'install', 'security', 'slow'];
 
-// ADR-457 build-at-publish: get-shit-done/bin/lib/*.cjs is generated from
+// ADR-457 build-at-publish: gsd-core/bin/lib/*.cjs is generated from
 // src/*.cts and gitignored, so on a clean checkout (fresh CI, before any build)
 // the artifact is absent — yet test files require it. This is the universal
 // chokepoint every test path funnels through (test:unit, --files-from, direct
@@ -38,7 +38,7 @@ const SUITES = ['all', 'unit', 'integration', 'install', 'security', 'slow'];
 // modules migrate into src/.
 function ensureBuiltArtifacts() {
   const root = join(__dirname, '..');
-  const sentinel = join(root, 'get-shit-done', 'bin', 'lib', 'semver-compare.cjs');
+  const sentinel = join(root, 'gsd-core', 'bin', 'lib', 'semver-compare.cjs');
   if (existsSync(sentinel)) return;
   const tscBin = require.resolve('typescript/bin/tsc');
   execFileSync(process.execPath, [tscBin, '-p', join(root, 'tsconfig.build.json')], {
@@ -161,7 +161,15 @@ function selectExplicitFiles(allFiles, filesValue, filesFrom) {
   const selected = [];
   const missing = [];
   for (const file of requested) {
-    if (available.has(file)) {
+    // If the token is a bare suite name (e.g. "unit" written by ci-test-scope
+    // as the #408 fallback sentinel), delegate to the existing suite resolver
+    // rather than treating it as a filename. This prevents the
+    // "requested test file(s) not found: unit" crash (#641).
+    if (SUITES.includes(file)) {
+      for (const f of selectFiles(allFiles, file)) {
+        selected.push(f);
+      }
+    } else if (available.has(file)) {
       selected.push(file);
     } else {
       missing.push(file);

package/scripts/strip-prose-atrefs.cjs

@@ -2,7 +2,7 @@
 /**
  * strip-prose-atrefs.cjs
  *
- * Removes redundant @~/.claude/get-shit-done/ path tokens from prose lines
+ * Removes redundant @~/.claude/gsd-core/ path tokens from prose lines
  * in <process> and <context> blocks. The path is already declared in
  * <execution_context> where it actually loads the file. Prose copies are
  * inert and add ~900 tokens/invocation of dead weight.
@@ -30,7 +30,7 @@ const DRY_RUN      = process.argv.includes('--dry-run');
 const ROOT         = path.join(__dirname, '..');
 const COMMANDS_DIR = path.join(ROOT, 'commands', 'gsd');
 
-const AT_PATH_PATTERN = /@(?:~|\$HOME)\/.+?get-shit-done\/[^\s`\)]+/;
+const AT_PATH_PATTERN = /@(?:~|\$HOME)\/.+?gsd-core\/[^\s`\)]+/;
 const mkAtRe = () => new RegExp(AT_PATH_PATTERN.source, 'g');
 
 function transformLine(line) {

package/scripts/sync-runtime-launcher.cjs

@@ -2,7 +2,7 @@
 /**
  * sync-runtime-launcher.cjs
  *
- * Idempotent transform: for every get-shit-done/workflows/*.md (and subdirs),
+ * Idempotent transform: for every gsd-core/workflows/*.md (and subdirs),
  * rewrite all bash/sh/shell fenced blocks to:
  *   1. Strip ALL old resolver forms from every bash block (GSD_TOOLS=,
  *      GSD_SDK=, the if/elif/else/fi resolver, _GSD_SHIM_NAME=, and any
@@ -19,7 +19,7 @@
 const fs = require('node:fs');
 const path = require('node:path');
 
-const WORKFLOWS_DIR = path.join(__dirname, '..', 'get-shit-done', 'workflows');
+const WORKFLOWS_DIR = path.join(__dirname, '..', 'gsd-core', 'workflows');
 const SNIPPET_FILE = path.join(WORKFLOWS_DIR, '_runtime-launcher.snippet.sh');
 
 // Read canonical preamble (full content of snippet file)

package/scripts/verify-npm-publish.cjs

@@ -0,0 +1,252 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * verify-npm-publish.cjs — verifies a freshly-published npm version is
+ * retrievable, tolerating registry/CDN propagation lag via bounded retry.
+ * Fixes #623. Used by both Verify-publish steps in .github/workflows/release.yml.
+ */
+
+const cp = require('node:child_process');
+
+// ---- Constants ---------------------------------------------------------------
+
+const REASON = Object.freeze({
+  OK_VERSION_LIVE: 'ok_version_live',
+  FAIL_VERSION_NOT_FOUND: 'fail_version_not_found',
+});
+
+// ---- Sleep -------------------------------------------------------------------
+
+const defaultSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+// ---- npm fetchers ------------------------------------------------------------
+
+function defaultFetchVersion(pkg, version) {
+  try {
+    const out = cp.execFileSync('npm', ['view', `${pkg}@${version}`, 'version'],
+      { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+    return out || null;
+  } catch { return null; }
+}
+
+function defaultFetchDistTag(pkg, distTag) {
+  try {
+    const out = cp.execFileSync('npm', ['view', pkg, 'dist-tags', '--json'],
+      { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
+    const tags = JSON.parse(out);
+    return (tags && typeof tags === 'object' && tags[distTag]) || null;
+  } catch { return null; }
+}
+
+// ---- Core async function (unit-tested seam) ----------------------------------
+
+async function verifyPublish({
+  pkg,
+  version,
+  distTag = null,
+  fetchVersion = defaultFetchVersion,
+  fetchDistTag = defaultFetchDistTag,
+  maxAttempts = 20,
+  intervalMs = 5000,
+  sleep = defaultSleep,
+}) {
+  let attempts = 0;
+
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    const found = fetchVersion(pkg, version);
+    attempts++;
+
+    if (found === version) {
+      // Version confirmed live — optionally resolve dist-tag informally
+      let distTagResult = null;
+
+      if (distTag && typeof distTag === 'string' && distTag.length > 0) {
+        let pointsTo = null;
+
+        for (let dt = 1; dt <= maxAttempts; dt++) {
+          const tagVal = fetchDistTag(pkg, distTag);
+          if (tagVal !== null) {
+            pointsTo = tagVal;
+            break;
+          }
+          if (dt < maxAttempts) {
+            await sleep(intervalMs);
+          }
+        }
+
+        distTagResult = {
+          name: distTag,
+          points_to: pointsTo,
+          matches: pointsTo === version,
+        };
+      }
+
+      return {
+        ok: true,
+        reason: REASON.OK_VERSION_LIVE,
+        pkg,
+        version,
+        attempts,
+        distTag: distTagResult,
+      };
+    }
+
+    // Not found yet — sleep before retry (but not after the final attempt)
+    if (attempt < maxAttempts) {
+      await sleep(intervalMs);
+    }
+  }
+
+  return {
+    ok: false,
+    reason: REASON.FAIL_VERSION_NOT_FOUND,
+    pkg,
+    version,
+    attempts,
+    distTag: null,
+  };
+}
+
+// ---- Argument parsing --------------------------------------------------------
+
+function parseArgs(argv) {
+  const opts = {
+    pkg: null,
+    version: null,
+    distTag: null,
+    maxAttempts: 20,
+    intervalMs: 5000,
+    json: false,
+  };
+
+  const args = argv.slice();
+  while (args.length > 0) {
+    const arg = args.shift();
+
+    if (arg === '--help' || arg === '-h') {
+      process.stdout.write(
+        'Usage: node scripts/verify-npm-publish.cjs --package <pkg> --version <ver> [options]\n' +
+        '\n' +
+        'Options:\n' +
+        '  --package <s>       npm package name (required)\n' +
+        '  --version <s>       version to verify (required)\n' +
+        '  --dist-tag <s>      dist-tag to report (optional, informational only)\n' +
+        '  --max-attempts <n>  max retry attempts (default: 20)\n' +
+        '  --interval-ms <n>   ms between retries (default: 5000)\n' +
+        '  --json              emit structured JSON output\n' +
+        '  --help, -h          show this help\n'
+      );
+      process.exit(0);
+    } else if (arg === '--package') {
+      const val = args.shift();
+      if (!val || val.startsWith('-')) {
+        process.stderr.write('error: --package requires a value\n');
+        process.exit(2);
+      }
+      opts.pkg = val;
+    } else if (arg === '--version') {
+      const val = args.shift();
+      if (!val || val.startsWith('-')) {
+        process.stderr.write('error: --version requires a value\n');
+        process.exit(2);
+      }
+      opts.version = val;
+    } else if (arg === '--dist-tag') {
+      const val = args.shift();
+      if (!val || val.startsWith('-')) {
+        process.stderr.write('error: --dist-tag requires a value\n');
+        process.exit(2);
+      }
+      opts.distTag = val;
+    } else if (arg === '--max-attempts') {
+      const val = args.shift();
+      if (!val || val.startsWith('-')) {
+        process.stderr.write('error: --max-attempts requires a value\n');
+        process.exit(2);
+      }
+      const n = parseInt(val, 10);
+      if (isNaN(n) || n < 1) {
+        process.stderr.write('error: --max-attempts must be a positive integer\n');
+        process.exit(2);
+      }
+      opts.maxAttempts = n;
+    } else if (arg === '--interval-ms') {
+      const val = args.shift();
+      if (!val || val.startsWith('-')) {
+        process.stderr.write('error: --interval-ms requires a value\n');
+        process.exit(2);
+      }
+      const n = parseInt(val, 10);
+      if (isNaN(n) || n < 0) {
+        process.stderr.write('error: --interval-ms must be a non-negative integer\n');
+        process.exit(2);
+      }
+      opts.intervalMs = n;
+    } else if (arg === '--json') {
+      opts.json = true;
+    } else {
+      process.stderr.write(`unknown argument: ${arg}\n`);
+      process.exit(2);
+    }
+  }
+
+  if (!opts.pkg) {
+    process.stderr.write('error: --package is required\n');
+    process.exit(2);
+  }
+  if (!opts.version) {
+    process.stderr.write('error: --version is required\n');
+    process.exit(2);
+  }
+
+  return opts;
+}
+
+// ---- Main entry point --------------------------------------------------------
+
+async function main() {
+  const opts = parseArgs(process.argv.slice(2));
+  const result = await verifyPublish({
+    pkg: opts.pkg,
+    version: opts.version,
+    distTag: opts.distTag,
+    maxAttempts: opts.maxAttempts,
+    intervalMs: opts.intervalMs,
+  });
+
+  if (opts.json) {
+    process.stdout.write(JSON.stringify(result, null, 2) + '\n');
+  } else {
+    if (result.ok) {
+      process.stdout.write(
+        `✓ Verified: ${result.pkg}@${result.version} is live on npm (after ${result.attempts} attempt(s))\n`
+      );
+      if (result.distTag) {
+        process.stdout.write(`✓ ${result.distTag.name} tag points to: ${result.distTag.points_to}\n`);
+        if (!result.distTag.matches) {
+          process.stdout.write(
+            `::warning::${result.distTag.name} dist-tag points to ${result.distTag.points_to}, expected ${result.version}\n`
+          );
+        }
+      }
+    } else {
+      process.stdout.write(
+        `::error::Published version verification failed. ${result.pkg}@${result.version} not found after ${result.attempts} attempt(s)\n`
+      );
+    }
+  }
+
+  process.exit(result.ok ? 0 : 1);
+}
+
+// ---- Guard -------------------------------------------------------------------
+
+if (require.main === module) {
+  main().catch((err) => {
+    process.stderr.write(String((err && err.stack) || err) + '\n');
+    process.exit(1);
+  });
+}
+
+module.exports = { verifyPublish, parseArgs, REASON, defaultFetchVersion, defaultFetchDistTag };