@pareto4/pp-core 1.5.0

package/scripts/registry-smoke.cjs

@@ -0,0 +1,337 @@
+#!/usr/bin/env node
+/**
+ * scripts/registry-smoke.cjs
+ *
+ * Post-publish registry smoke test (D-12 regression guard).
+ *
+ * Strategy: install the REAL published @pareto4/pp-core from the npm registry
+ * into a temp prefix, invoke the installed pp-core installer in a clean fixture
+ * HOME, assert the /pp-progress artifact lands. Reuses the Phase-5 clean-room
+ * helpers from release-tarball-smoke.cjs, repointed from a local tarball at the
+ * live registry.
+ *
+ * Purpose: SC2's mandatory gate is the live human smoke (plan 10). This automated
+ * check is a regression guard for FUTURE releases. Build it now so plan 10 can
+ * run it against the freshly published package, and so CI can run it post-publish.
+ *
+ * Exports:
+ *   SMOKE             — frozen enum of result codes (re-exported from release-tarball-smoke.cjs)
+ *   runRegistrySmoke  — pure function; accepts { registryTag, expectedVersion,
+ *                       installPrefix, fixtureDir, dryRun }
+ *
+ * CLI entry: node scripts/registry-smoke.cjs [--registry-tag <tag>]
+ *                                            [--expected-version <ver>]
+ *                                            [--dry-run]
+ *   Installs from the registry, runs the pp-core installer, asserts /pp-progress artifact.
+ *   Exits 0 on SMOKE.OK, 1 otherwise.
+ *
+ * Key links:
+ *   - scripts/release-tarball-smoke.cjs : reuses SMOKE enum, locateProgressArtifact,
+ *     findInstallerBin, binInvocation, RUNTIME_FLAGS
+ *   - pp-core/bin/lib/package-identity.cjs : PACKAGE_NAME (never hardcode @pareto4/pp-core)
+ */
+
+'use strict';
+
+const { execFileSync, spawnSync } = require('child_process');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const { PACKAGE_NAME } = require('../pp-core/bin/lib/package-identity.cjs');
+const { ExitError, runMain } = require('./lib/cli-exit.cjs');
+
+// Reuse helpers from release-tarball-smoke — do not re-implement.
+const {
+  SMOKE,
+  locateProgressArtifact,
+  findInstallerBin,
+  binInvocation,
+  RUNTIME_FLAGS, // eslint-disable-line no-unused-vars -- re-exported for callers
+} = require('./release-tarball-smoke.cjs');
+
+// Same timeout as release-tarball-smoke.cjs (600 s on Windows, 120 s elsewhere).
+// Windows npm global installs on cold-cache can take up to 10 minutes.
+const CHILD_TIMEOUT_MS = process.platform === 'win32' ? 600_000 : 120_000;
+
+// Suppress npm noise during install — mirrors the constant in release-tarball-smoke.cjs.
+const QUIET_NPM_ENV = Object.freeze({
+  npm_config_loglevel: 'error',
+  npm_config_update_notifier: 'false',
+  NO_UPDATE_NOTIFIER: '1',
+});
+
+// ---------------------------------------------------------------------------
+// Registry availability wait (synchronous — adapted from verify-npm-publish.cjs)
+// ---------------------------------------------------------------------------
+
+/**
+ * Synchronously wait for PACKAGE_NAME@version to appear on the npm registry.
+ * Uses a blocking Atomics.wait sleep between retries (safe in Node.js main thread).
+ *
+ * Adapted from verify-npm-publish.cjs verifyPublish() lines 45-95, converted to
+ * synchronous form so it composes with spawnSync-based install without requiring
+ * an async runRegistrySmoke.
+ *
+ * @param {string} version
+ * @param {{ maxAttempts?: number, intervalMs?: number }} [opts]
+ * @returns {{ ok: boolean, attempts: number }}
+ */
+function waitForRegistryVersion(version, { maxAttempts = 20, intervalMs = 5000 } = {}) {
+  const npmCmd = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      const out = execFileSync(
+        npmCmd,
+        ['view', `${PACKAGE_NAME}@${version}`, 'version'],
+        {
+          encoding: 'utf-8',
+          stdio: ['ignore', 'pipe', 'ignore'],
+          timeout: 15_000,
+          shell: process.platform === 'win32',
+        },
+      ).trim();
+      if (out === version) return { ok: true, attempts: attempt };
+    } catch {
+      // Version not yet available — retry below.
+    }
+    if (attempt < maxAttempts) {
+      // Synchronous sleep: safe in Node.js main thread (unlike browsers).
+      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, intervalMs);
+    }
+  }
+  return { ok: false, attempts: maxAttempts };
+}
+
+// ---------------------------------------------------------------------------
+// Cleanup helper
+// ---------------------------------------------------------------------------
+
+function cleanup(...dirs) {
+  for (const dir of dirs) {
+    try {
+      fs.rmSync(dir, { recursive: true, force: true });
+    } catch {
+      // best-effort
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Pure function: runRegistrySmoke
+// ---------------------------------------------------------------------------
+
+/**
+ * Install the REAL published package from the npm registry into a clean tmp
+ * HOME, invoke the pp-core installer, and assert the /pp-progress artifact
+ * lands. The ONLY substantive difference from runSmoke() in release-tarball-
+ * smoke.cjs is the install spec (registry spec instead of a .tgz path) and
+ * the absence of an npm pack step.
+ *
+ * @param {object} opts
+ * @param {string}  [opts.registryTag='latest']  - npm dist-tag to install (e.g. 'latest', 'next')
+ * @param {string}  [opts.expectedVersion]       - If provided, wait for this exact version to be
+ *   visible on the registry before installing; also recorded in result details.
+ * @param {string}  opts.installPrefix           - Temp directory for npm --prefix (global install)
+ * @param {string}  opts.fixtureDir              - Temp dir used as cwd+HOME for the installer
+ * @param {boolean} [opts.dryRun=false]          - If true, short-circuit immediately without
+ *   touching the network (mirrors release-tarball-smoke.cjs lines 420-422)
+ * @returns {{ code: string, details: object }}
+ */
+function runRegistrySmoke({
+  registryTag = 'latest',
+  expectedVersion,
+  installPrefix,
+  fixtureDir,
+  dryRun = false,
+}) {
+  const details = {
+    packageName: PACKAGE_NAME,
+    registryTag,
+    expectedVersion,
+    prefix: installPrefix,
+  };
+
+  // Dry-run short-circuit — mirrors release-tarball-smoke.cjs lines 420-422.
+  if (dryRun) {
+    return { code: SMOKE.OK, details: { ...details, version: expectedVersion, dryRun: true } };
+  }
+
+  // Optionally wait for the expected version to be available on the registry.
+  // This bounds the wait for registry/CDN propagation lag after a fresh publish
+  // (T-06-08 mitigation — denial-of-service / registry not yet propagated).
+  if (expectedVersion) {
+    const waitResult = waitForRegistryVersion(expectedVersion);
+    if (!waitResult.ok) {
+      return {
+        code: SMOKE.INSTALL_FAILED,
+        details: {
+          ...details,
+          reason: 'registry-version-not-visible',
+          attempts: waitResult.attempts,
+        },
+      };
+    }
+  }
+
+  // Install from the registry.
+  // ONLY substantive difference from the tarball harness: use a registry spec
+  // (${PACKAGE_NAME}@${registryTag}) instead of a .tgz path; no npm pack step.
+  const npmCmd = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+  const effectiveNpmEnv = { ...process.env, ...QUIET_NPM_ENV };
+  const registrySpec = `${PACKAGE_NAME}@${registryTag}`;
+
+  const installResult = spawnSync(
+    npmCmd,
+    ['install', '-g', '--prefix', installPrefix, registrySpec],
+    {
+      encoding: 'utf-8',
+      shell: process.platform === 'win32',
+      timeout: CHILD_TIMEOUT_MS,
+      env: effectiveNpmEnv,
+    },
+  );
+
+  if (installResult.status !== 0) {
+    return {
+      code: SMOKE.INSTALL_FAILED,
+      details: {
+        ...details,
+        registrySpec,
+        stderr: installResult.stderr,
+        stdout: installResult.stdout,
+        signal: installResult.signal ?? null,
+        installError: installResult.error ? String(installResult.error) : null,
+      },
+    };
+  }
+
+  // Locate the installed pp-core installer binary.
+  const installerBin = findInstallerBin(installPrefix);
+  if (!installerBin) {
+    return {
+      code: SMOKE.BIN_NOT_CALLABLE,
+      details: { ...details, registrySpec, installPrefix },
+    };
+  }
+
+  // Invoke pp-core --local --claude in the clean fixture dir.
+  // Set HOME+USERPROFILE to fixtureDir so npm/installer writes never touch the
+  // operator's real ~/.claude (T-06-07 mitigation: isolated fixture HOME).
+  const childEnv = { ...effectiveNpmEnv, HOME: fixtureDir, USERPROFILE: fixtureDir };
+  delete childEnv.GSD_TEST_MODE; // install.js skips main() when GSD_TEST_MODE is set
+
+  const inv = binInvocation(installerBin, ['--local', '--claude']);
+  const initResult = spawnSync(inv.command, inv.args, {
+    encoding: 'utf-8',
+    cwd: fixtureDir,
+    stdio: ['pipe', 'pipe', 'pipe'],
+    env: childEnv,
+    timeout: CHILD_TIMEOUT_MS,
+    shell: inv.shell,
+  });
+
+  if (initResult.status !== 0) {
+    return {
+      code: SMOKE.INIT_FAILED,
+      details: {
+        ...details,
+        registrySpec,
+        fixtureDir,
+        stderr: initResult.stderr,
+        stdout: initResult.stdout,
+      },
+    };
+  }
+
+  // Assert the /pp-progress artifact landed in the installed config root.
+  // locateProgressArtifact() checks all three layout forms (command-flat,
+  // command-subdir, skill) — mirrors the D-12 flat-hyphen scope asymmetry
+  // discovered in Phase 5 (05-05 Task 2).
+  const claudeRoot = path.join(fixtureDir, '.claude');
+  const artifact = locateProgressArtifact(claudeRoot);
+
+  if (!artifact) {
+    return {
+      code: SMOKE.COMMAND_FILE_MISSING,
+      details: {
+        ...details,
+        registrySpec,
+        fixtureDir,
+        claudeRoot,
+        reason: 'pp-progress artifact not found after registry install',
+      },
+    };
+  }
+
+  details.artifact = artifact;
+  details.version = expectedVersion || registryTag;
+
+  return { code: SMOKE.OK, details };
+}
+
+// ---------------------------------------------------------------------------
+// CLI entry
+// ---------------------------------------------------------------------------
+
+function cliMain() {
+  const argv = process.argv.slice(2);
+  let registryTag = 'latest';
+  let expectedVersion;
+  let dryRun = false;
+
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === '--registry-tag') {
+      const v = argv[++i];
+      if (!v || v.startsWith('-')) throw new ExitError(2, 'error: --registry-tag requires a value');
+      registryTag = v;
+    } else if (a === '--expected-version') {
+      const v = argv[++i];
+      if (!v || v.startsWith('-')) throw new ExitError(2, 'error: --expected-version requires a value');
+      expectedVersion = v;
+    } else if (a === '--dry-run') {
+      dryRun = true;
+    } else if (a === '--help' || a === '-h') {
+      process.stdout.write(
+        'Usage: node scripts/registry-smoke.cjs [options]\n' +
+        '\n' +
+        'Options:\n' +
+        '  --registry-tag <tag>       npm dist-tag to install (default: latest)\n' +
+        '  --expected-version <ver>   wait for this version to be visible, then install\n' +
+        '  --dry-run                  skip all network calls; validate flag parsing only\n' +
+        '  --help, -h                 show this help\n',
+      );
+      throw new ExitError(0);
+    } else {
+      throw new ExitError(2, `error: unknown argument: ${a}`);
+    }
+  }
+
+  const installPrefix = fs.mkdtempSync(path.join(os.tmpdir(), 'pp-reg-smoke-prefix-'));
+  const fixtureDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pp-reg-smoke-fixture-'));
+
+  let result;
+  try {
+    result = runRegistrySmoke({ registryTag, expectedVersion, installPrefix, fixtureDir, dryRun });
+  } finally {
+    cleanup(installPrefix, fixtureDir);
+  }
+
+  const statusLine = result.code === SMOKE.OK
+    ? `[registry-smoke] OK: ${PACKAGE_NAME}@${registryTag} — ${JSON.stringify(result.details)}`
+    : `[registry-smoke] FAIL (${result.code}): ${JSON.stringify(result.details)}`;
+  process.stdout.write(statusLine + '\n');
+
+  return result.code === SMOKE.OK ? 0 : 1;
+}
+
+// ---------------------------------------------------------------------------
+// Exports
+// ---------------------------------------------------------------------------
+
+module.exports = { SMOKE, runRegistrySmoke };
+
+if (require.main === module) {
+  runMain(cliMain);
+}

package/scripts/release-notes/discord-release-summary.cjs

@@ -0,0 +1,373 @@
+#!/usr/bin/env node
+'use strict';
+
+const cp = require('node:child_process');
+const fs = require('fs');
+const path = require('path');
+const { ExitError, runMain } = require('../lib/cli-exit.cjs');
+const { classifyTitle } = require('./format-github-release-notes.cjs');
+
+const DEFAULT_MAX_CONTENT = 1850;
+const SECTION_LIMITS = Object.freeze([
+  ['Breaking', 4],
+  ['Security', 4],
+  ['Feature', 4],
+  ['Fix', 4],
+  ['Enhancement', 3],
+  ['Internal', 2],
+  ['New Contributors', 3],
+]);
+
+function normalizeNewlines(value) {
+  return String(value || '').replace(/\r\n/g, '\n');
+}
+
+function releaseTag(release) {
+  return release.tagName || release.tag_name || release.name || 'release';
+}
+
+function releaseName(release) {
+  return release.name || releaseTag(release);
+}
+
+function releaseUrl(release) {
+  return release.url || release.html_url || '';
+}
+
+function releaseIsPrerelease(release) {
+  return release.isPrerelease === true || release.prerelease === true || /-/.test(releaseTag(release));
+}
+
+function loadPackageName(repoRoot = path.resolve(__dirname, '..', '..')) {
+  const pkgJson = JSON.parse(fs.readFileSync(path.join(repoRoot, 'package.json'), 'utf8'));
+  return pkgJson.name || 'package';
+}
+
+function normalizeHeading(value) {
+  const heading = value.trim().replace(/:$/, '');
+  const lower = heading.toLowerCase();
+
+  if (lower.includes('breaking')) return 'Breaking';
+  if (lower.includes('security')) return 'Security';
+  if (lower === 'feature' || lower === 'features') return 'Feature';
+  if (lower === 'fix' || lower === 'fixes' || lower === 'bug fixes') return 'Fix';
+  if (lower === 'enhancement' || lower === 'enhancements' || lower === 'improvements') return 'Enhancement';
+  if (lower === 'internal' || lower === 'maintenance') return 'Internal';
+  if (lower === 'new contributors') return 'New Contributors';
+  if (lower === "what's changed" || lower === 'whats changed') return "What's Changed";
+  return heading;
+}
+
+function collectSections(body) {
+  const sections = new Map();
+  let current = null;
+
+  for (const line of normalizeNewlines(body).split('\n')) {
+    const trimmed = line.trim();
+    const heading = trimmed.match(/^#{2,3}\s+(.+)$/);
+
+    if (heading) {
+      current = normalizeHeading(heading[1]);
+      continue;
+    }
+
+    const bullet = trimmed.match(/^([*-])\s+(.+)$/);
+    if (!bullet || !current) continue;
+
+    let section = current;
+    if (section === "What's Changed") {
+      section = classifyTitle(trimmed);
+    }
+
+    if (!sections.has(section)) sections.set(section, []);
+    sections.get(section).push(cleanBullet(trimmed));
+  }
+
+  return sections;
+}
+
+function cleanBullet(value) {
+  let text = String(value)
+    .replace(/^[*-]\s+/, '')
+    .replace(/\s+by\s+@[A-Za-z0-9-]+\s+in\s+https:\/\/github\.com\/[^/\s]+\/[^/\s]+\/pull\/(\d+)/g, ' (#$1)')
+    .replace(/\[([^\]]+)\]\((https:\/\/github\.com\/[^/\s]+\/[^/\s]+\/(?:pull|issues)\/(\d+))\)/g, '$1 (#$3)')
+    .replace(/\[([^\]]+)\]\((https?:\/\/[^)]+)\)/g, '$1')
+    .replace(/https:\/\/github\.com\/[^/\s]+\/[^/\s]+\/pull\/(\d+)/g, '#$1')
+    .replace(/https:\/\/github\.com\/[^/\s]+\/[^/\s]+\/issues\/(\d+)/g, '#$1')
+    .replace(/https:\/\/github\.com\/[^/\s]+\/[^/\s]+\/commit\/([0-9a-f]{7})[0-9a-f]*/gi, '$1')
+    .replace(/\*\*/g, '')
+    .replace(/\s+/g, ' ')
+    .trim();
+
+  text = text
+    .replace(/^\[codex\]\s+/i, '')
+    .replace(/^(?:feat|fix|docs|chore|ci|refactor|test)(?:\([^)]+\))?!?:\s+/i, '');
+  text = text.replace(/#(\d+)\s+\(#\1\)/g, '#$1');
+  text = text.replace(/\s+\(#(\d+)\)\s+\(#\1\)$/g, ' (#$1)');
+
+  return truncateAtWord(text, 220);
+}
+
+function truncateAtWord(value, maxLength) {
+  if (value.length <= maxLength) return value;
+  const splitAt = value.lastIndexOf(' ', maxLength - 3);
+  if (splitAt < 80) return `${value.slice(0, maxLength - 3)}...`;
+  return `${value.slice(0, splitAt)}...`;
+}
+
+function extractInstallCommand(body, packageName, release) {
+  const lines = normalizeNewlines(body).split('\n');
+  let inInstall = false;
+  let inFence = false;
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+
+    if (/^##\s+Install\b/i.test(trimmed)) {
+      inInstall = true;
+      continue;
+    }
+
+    if (inInstall && /^##\s+/.test(trimmed)) break;
+    if (!inInstall) continue;
+
+    if (trimmed.startsWith('```')) {
+      inFence = !inFence;
+      continue;
+    }
+
+    if (inFence && /^npm\s+(?:i|install)\s+/.test(trimmed)) {
+      return trimmed;
+    }
+  }
+
+  const channel = releaseIsPrerelease(release) ? 'next' : 'latest';
+  return `npm i ${packageName}@${channel}`;
+}
+
+function buildDiscordReleasePayload({ release, packageName = loadPackageName(), maxContent = DEFAULT_MAX_CONTENT }) {
+  const tag = releaseTag(release);
+  const name = releaseName(release);
+  const url = releaseUrl(release);
+  const prerelease = releaseIsPrerelease(release);
+  const channel = prerelease ? 'next' : 'latest';
+  const body = release.body || '';
+  const sections = collectSections(body);
+  const footer = url ? `Full changelog: ${url}` : `Full changelog: ${tag}`;
+  const baseLines = [
+    `**${packageName} ${name}${prerelease ? ' pre-release' : ''} is out**`,
+    '',
+    'Install:',
+    `\`${extractInstallCommand(body, packageName, release)}\``,
+  ];
+
+  const lines = baseLines.slice();
+  for (const [section, limit] of SECTION_LIMITS) {
+    appendSection(lines, section, sections.get(section) || [], limit, footer, maxContent);
+  }
+
+  if (lines.length === baseLines.length) {
+    appendLineGroup(lines, ['', 'No release notes were provided.'], footer, maxContent);
+  }
+
+  if (joinedLength(lines, footer) > maxContent) {
+    while (lines.length > baseLines.length && joinedLength(lines, footer) > maxContent) {
+      lines.pop();
+    }
+  }
+
+  const content = [...lines, '', footer].join('\n');
+  return {
+    username: 'GSD Releases',
+    content,
+    embeds: [
+      {
+        title: 'Release details',
+        url: url || undefined,
+        color: prerelease ? 0xd9a441 : 0x2f9e44,
+        fields: [
+          { name: 'Package', value: `\`${packageName}\``, inline: true },
+          { name: 'Channel', value: `\`${channel}\``, inline: true },
+          { name: 'Version', value: `\`${tag}\``, inline: true },
+        ],
+      },
+    ],
+    allowed_mentions: { parse: [] },
+  };
+}
+
+function appendSection(lines, section, bullets, limit, footer, maxContent) {
+  if (bullets.length === 0) return;
+
+  const label = sectionLabel(section);
+  const selected = [];
+  for (const bullet of bullets.slice(0, limit)) {
+    const candidate = ['', `**${label}**`, ...selected.map((item) => `- ${item}`), `- ${bullet}`];
+    if (joinedLength([...lines, ...candidate], footer) > maxContent) break;
+    selected.push(bullet);
+  }
+
+  if (selected.length === 0) return;
+
+  const group = ['', `**${label}**`, ...selected.map((item) => `- ${item}`)];
+  const remaining = bullets.length - selected.length;
+  if (remaining > 0) {
+    const moreLine = `- ...and ${remaining} more ${label.toLowerCase()}`;
+    if (joinedLength([...lines, ...group, moreLine], footer) <= maxContent) {
+      group.push(moreLine);
+    }
+  }
+
+  appendLineGroup(lines, group, footer, maxContent);
+}
+
+function appendLineGroup(lines, group, footer, maxContent) {
+  if (joinedLength([...lines, ...group], footer) <= maxContent) {
+    lines.push(...group);
+  }
+}
+
+function joinedLength(lines, footer) {
+  return [...lines, '', footer].join('\n').length;
+}
+
+function sectionLabel(section) {
+  if (section === 'Feature') return 'Features';
+  if (section === 'Fix') return 'Fixes';
+  if (section === 'Enhancement') return 'Enhancements';
+  return section;
+}
+
+function fetchRelease({ tag, repo, latest = false }) {
+  const args = ['release', 'view'];
+  if (!latest && tag) args.push(tag);
+  args.push('--json', 'tagName,name,isPrerelease,body,url');
+  if (repo) args.push('--repo', repo);
+  const raw = cp.execFileSync('gh', args, { encoding: 'utf8' });
+  return JSON.parse(raw);
+}
+
+async function postWebhook(webhookUrl, payload) {
+  const response = await fetch(webhookUrl, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify(payload),
+  });
+
+  if (!response.ok) {
+    throw new ExitError(1, `Discord webhook failed with ${response.status}: ${await response.text()}`);
+  }
+}
+
+function parseArgs(argv) {
+  const opts = {
+    tag: null,
+    repo: null,
+    latest: false,
+    stdin: false,
+    post: false,
+    json: false,
+    allowMissingWebhook: false,
+    packageName: null,
+    maxContent: DEFAULT_MAX_CONTENT,
+  };
+
+  const args = argv.slice();
+  while (args.length > 0) {
+    const arg = args.shift();
+    if (arg === '--tag') {
+      opts.tag = requireValue(args, arg);
+    } else if (arg === '--repo') {
+      opts.repo = requireValue(args, arg);
+    } else if (arg === '--package') {
+      opts.packageName = requireValue(args, arg);
+    } else if (arg === '--max-content') {
+      opts.maxContent = Number(requireValue(args, arg));
+    } else if (arg === '--latest') {
+      opts.latest = true;
+    } else if (arg === '--stdin') {
+      opts.stdin = true;
+    } else if (arg === '--post') {
+      opts.post = true;
+    } else if (arg === '--json') {
+      opts.json = true;
+    } else if (arg === '--allow-missing-webhook') {
+      opts.allowMissingWebhook = true;
+    } else if (arg === '--help' || arg === '-h') {
+      process.stdout.write(
+        'Usage: node scripts/release-notes/discord-release-summary.cjs [--tag <tag>|--latest|--stdin] [options]\n' +
+        '\n' +
+        'Options:\n' +
+        '  --tag <tag>                 GitHub release tag to announce\n' +
+        '  --latest                    Announce the latest GitHub release\n' +
+        '  --stdin                     Read release JSON from stdin\n' +
+        '  --repo <owner/repo>          Repository for gh release view\n' +
+        '  --package <name>             Package name override\n' +
+        '  --post                      POST to DISCORD_WEBHOOK_URL\n' +
+        '  --allow-missing-webhook      Warn and skip instead of failing when posting without a webhook\n' +
+        '  --json                      Print webhook payload JSON instead of content preview\n' +
+        '  --max-content <n>            Max Discord content characters before webhook footer\n'
+      );
+      throw new ExitError(0);
+    } else {
+      throw new ExitError(2, `error: unknown argument ${arg}`);
+    }
+  }
+
+  if (!Number.isFinite(opts.maxContent) || opts.maxContent < 500 || opts.maxContent > 2000) {
+    throw new ExitError(2, 'error: --max-content must be between 500 and 2000');
+  }
+
+  return opts;
+}
+
+function requireValue(args, flag) {
+  const value = args.shift();
+  if (!value || value.startsWith('-')) {
+    throw new ExitError(2, `error: ${flag} requires a value`);
+  }
+  return value;
+}
+
+async function main() {
+  const opts = parseArgs(process.argv.slice(2));
+  let release;
+
+  if (opts.stdin) {
+    release = JSON.parse(fs.readFileSync('/dev/stdin', 'utf8'));
+  } else {
+    release = fetchRelease(opts);
+  }
+
+  const payload = buildDiscordReleasePayload({
+    release,
+    packageName: opts.packageName || loadPackageName(),
+    maxContent: opts.maxContent,
+  });
+
+  if (opts.post) {
+    const webhookUrl = process.env.DISCORD_WEBHOOK_URL;
+    if (!webhookUrl) {
+      if (opts.allowMissingWebhook) {
+        process.stderr.write('warning: DISCORD_WEBHOOK_URL is not set; skipping Discord announcement\n');
+      } else {
+        throw new ExitError(1, 'error: DISCORD_WEBHOOK_URL is not set');
+      }
+    } else {
+      await postWebhook(webhookUrl, payload);
+    }
+  }
+
+  process.stdout.write(opts.json ? `${JSON.stringify(payload, null, 2)}\n` : `${payload.content}\n`);
+}
+
+if (require.main === module) {
+  runMain(main);
+}
+
+module.exports = {
+  buildDiscordReleasePayload,
+  cleanBullet,
+  collectSections,
+  extractInstallCommand,
+};