@opengsd/gsd-core 1.2.0 → 1.3.0

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

@@ -20,11 +20,32 @@
 // See docs/TESTING-SUITES.md for full grouping policy.
 'use strict';
 
-const { readdirSync } = require('fs');
+const { readdirSync, existsSync } = require('fs');
 const { join } = require('path');
 const { execFileSync } = require('child_process');
 
 const SUITES = ['all', 'unit', 'integration', 'install', 'security', 'slow'];
+
+// 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
+// invocation), so build the artifact here if missing. It is a no-op once built
+// (dev, pretest, a prior run in the same job), which keeps the harness test's
+// spawned invocations side-effect-free. Paths resolve from __dirname (not cwd),
+// so it works regardless of GSD_TEST_DIR / temp-dir cwd. NOTE: the sentinel is
+// the pilot module; revisit (or switch to an unconditional quiet build) as more
+// modules migrate into src/.
+function ensureBuiltArtifacts() {
+  const root = join(__dirname, '..');
+  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')], {
+    cwd: root,
+    stdio: 'inherit',
+  });
+}
 const MARKED_SUITES = ['integration', 'install', 'security', 'slow'];
 
 function parseArgs(argv) {
@@ -140,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);
@@ -203,6 +232,9 @@ function main() {
     process.exit(0);
   }
 
+  // Build the gitignored bin/lib artifact if absent, before any test requires it.
+  ensureBuiltArtifacts();
+
   // Log selected files to stderr for CI / harness-test visibility.
   // node:test default reporter doesn't echo filenames, so this gives
   // operators a single stable line they can grep.

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 };