@therocketcode/gsd-core 1.4.0

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

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

@@ -0,0 +1,261 @@
+'use strict';
+
+const path = require('path');
+const os = require('os');
+const fs = require('fs');
+const { execFileSync } = require('child_process');
+const { runMain, ExitError } = require('../lib/cli-exit.cjs');
+
+/**
+ * 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. "@therocketcode/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
+function main() {
+  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) {
+    if (err instanceof ExitError) throw err;
+    throw new ExitError(1, err && err.message ? err.message : String(err));
+  }
+}
+
+if (require.main === module) {
+  runMain(main);
+}
+
+module.exports = { formatReleaseNotes, classifyTitle };