@1aboveio/skills 0.18.0 → 0.19.1

package/skills/engineering/rush-release/scripts/plan.mjs

@@ -0,0 +1,292 @@
+#!/usr/bin/env node
+// Changelog + SemVer plan from baseline tag..SHA.
+//
+// Usage:
+//   node plan.mjs --sha <sha> [--trunk main] [--json] [--strict]
+//
+// Exit: 0 ok · 1 git/inspect failed · 2 usage
+import { existsSync, readFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { spawnSync } from 'node:child_process'
+import { isMainModule } from '../../engineering-runtime/scripts/main-module.mjs'
+
+const SEMVER_RE = /^v?(\d+)\.(\d+)\.(\d+)$/
+const TITLE_RE = /^\s*([a-zA-Z]+)(?:\(([^)]*)\))?(!)?:\s*(.+)$/
+const SECTION_BY_TYPE = {
+  feat: 'Added',
+  fix: 'Fixed',
+  perf: 'Changed',
+  refactor: 'Changed',
+  revert: 'Removed',
+  security: 'Security',
+}
+const INTERNAL_TYPES = new Set(['build', 'chore', 'ci', 'docs', 'style', 'test'])
+const SECTION_ORDER = ['Breaking', 'Added', 'Changed', 'Removed', 'Fixed', 'Security']
+export const DISTRIBUTION_MANIFEST = 'skills/distribution/manifest.json'
+
+export function parseSemver(input) {
+  const match = SEMVER_RE.exec(String(input || '').trim())
+  if (!match) return null
+  return { major: Number(match[1]), minor: Number(match[2]), patch: Number(match[3]) }
+}
+
+export function formatVersion(version) {
+  return `${version.major}.${version.minor}.${version.patch}`
+}
+
+export function compareVersions(left, right) {
+  for (const key of ['major', 'minor', 'patch']) {
+    if (left[key] !== right[key]) return left[key] < right[key] ? -1 : 1
+  }
+  return 0
+}
+
+export function latestReleaseTag(tags) {
+  const parsed = tags
+    .map((tag) => ({ tag, version: parseSemver(tag) }))
+    .filter((item) => item.version)
+  if (parsed.length === 0) return null
+  parsed.sort((left, right) => compareVersions(left.version, right.version))
+  return parsed[parsed.length - 1]
+}
+
+export function classifySubject(subject, body = '') {
+  const title = String(subject || '').trim()
+  const match = TITLE_RE.exec(title)
+  const type = match ? match[1].toLowerCase() : 'other'
+  const breaking = Boolean(match && match[3]) || /(^|\n)BREAKING[ -]CHANGE:/.test(body)
+  const internal = INTERNAL_TYPES.has(type)
+  const section = breaking ? 'Breaking' : internal ? null : (SECTION_BY_TYPE[type] || 'Changed')
+  return {
+    title,
+    type,
+    breaking,
+    internal,
+    section,
+    scope: match ? match[2] || null : null,
+    summary: match ? match[4] : title,
+  }
+}
+
+export function bumpFor(changes, current, { strict = false } = {}) {
+  const zeroVer = !strict && current.major === 0
+  if (changes.some((change) => change.breaking)) {
+    return { bump: zeroVer ? 'minor' : 'major', reason: 'breaking change in the release content' }
+  }
+  if (changes.some((change) => change.type === 'feat')) {
+    return { bump: 'minor', reason: 'new feature in the release content' }
+  }
+  return { bump: 'patch', reason: 'fixes and internal changes only' }
+}
+
+export function nextVersion(current, bump) {
+  if (bump === 'major') return { major: current.major + 1, minor: 0, patch: 0 }
+  if (bump === 'minor') return { major: current.major, minor: current.minor + 1, patch: 0 }
+  return { major: current.major, minor: current.minor, patch: current.patch + 1 }
+}
+
+export function renderChangelog({ version, date, changes }) {
+  const groups = new Map(SECTION_ORDER.map((name) => [name, []]))
+  for (const change of changes) {
+    if (!change.section) continue
+    const list = groups.get(change.section)
+    if (list) list.push(change)
+  }
+  const lines = [`## [${version}] - ${date}`]
+  for (const name of SECTION_ORDER) {
+    const items = groups.get(name)
+    if (!items.length) continue
+    lines.push('', `### ${name}`)
+    for (const item of items) lines.push(`- ${item.summary}`)
+  }
+  if (lines.length === 1) {
+    lines.push('', '- See the commits included in this tag.')
+  }
+  return `${lines.join('\n')}\n`
+}
+
+function distributionVersion(text) {
+  try {
+    const manifest = JSON.parse(text)
+    const targets = (manifest.sources ?? [])
+      .flatMap((source) => source.renderTargets ?? [])
+      .filter((target) => target.id === 'public-npm')
+    if (targets.length !== 1 || !parseSemver(targets[0].version)) return null
+    return formatVersion(parseSemver(targets[0].version))
+  } catch {
+    return null
+  }
+}
+
+export function discoverVersionFiles(root) {
+  const distributionPath = join(root, DISTRIBUTION_MANIFEST)
+  if (existsSync(distributionPath) && distributionVersion(readFileSync(distributionPath, 'utf8'))) {
+    return [DISTRIBUTION_MANIFEST]
+  }
+  const files = []
+  for (const name of ['package.json', 'package-lock.json', 'pyproject.toml', 'VERSION']) {
+    if (existsSync(join(root, name))) files.push(name)
+  }
+  return files
+}
+
+export function currentVersionFromFiles(root, files = discoverVersionFiles(root)) {
+  if (files.includes(DISTRIBUTION_MANIFEST)) {
+    return distributionVersion(readFileSync(join(root, DISTRIBUTION_MANIFEST), 'utf8'))
+  }
+  if (files.includes('package.json')) {
+    const pkg = JSON.parse(readFileSync(join(root, 'package.json'), 'utf8'))
+    const parsed = parseSemver(pkg.version)
+    if (parsed) return formatVersion(parsed)
+  }
+  if (files.includes('pyproject.toml')) {
+    const text = readFileSync(join(root, 'pyproject.toml'), 'utf8')
+    const match = text.match(/^version\s*=\s*"([^"]+)"/m)
+    const parsed = match && parseSemver(match[1])
+    if (parsed) return formatVersion(parsed)
+  }
+  if (files.includes('VERSION')) {
+    const parsed = parseSemver(readFileSync(join(root, 'VERSION'), 'utf8'))
+    if (parsed) return formatVersion(parsed)
+  }
+  return null
+}
+
+function git(args, cwd) {
+  const result = spawnSync('git', args, { encoding: 'utf8', cwd })
+  if (result.status !== 0) {
+    const err = new Error(result.stderr.trim() || `git ${args.join(' ')} failed`)
+    err.exitCode = 1
+    throw err
+  }
+  return result.stdout
+}
+
+function versionFilesAt(sha, cwd) {
+  const tree = new Set(git(['ls-tree', '-r', '--name-only', sha], cwd)
+    .split('\n')
+    .map((line) => line.trim())
+    .filter(Boolean))
+  if (tree.has(DISTRIBUTION_MANIFEST)) {
+    const version = distributionVersion(git(['show', `${sha}:${DISTRIBUTION_MANIFEST}`], cwd))
+    if (version) return [DISTRIBUTION_MANIFEST]
+  }
+  return ['package.json', 'package-lock.json', 'pyproject.toml', 'VERSION']
+    .filter((name) => tree.has(name))
+}
+
+function versionFromGitFiles(sha, files, cwd) {
+  const contents = (path) => git(['show', `${sha}:${path}`], cwd)
+  if (files.includes(DISTRIBUTION_MANIFEST)) {
+    return distributionVersion(contents(DISTRIBUTION_MANIFEST))
+  }
+  if (files.includes('package.json')) {
+    const parsed = parseSemver(JSON.parse(contents('package.json')).version)
+    if (parsed) return formatVersion(parsed)
+  }
+  if (files.includes('pyproject.toml')) {
+    const match = contents('pyproject.toml').match(/^version\s*=\s*"([^"]+)"/m)
+    const parsed = match && parseSemver(match[1])
+    if (parsed) return formatVersion(parsed)
+  }
+  if (files.includes('VERSION')) {
+    const parsed = parseSemver(contents('VERSION'))
+    if (parsed) return formatVersion(parsed)
+  }
+  return null
+}
+
+function parseLog(stdout) {
+  return stdout
+    .split('\u001e')
+    .map((chunk) => chunk.trim())
+    .filter(Boolean)
+    .map((chunk) => {
+      const [subject, ...rest] = chunk.split('\n')
+      return classifySubject(subject, rest.join('\n'))
+    })
+}
+
+export function planRelease({ sha, trunk = 'main', strict = false, cwd = process.cwd(), now = new Date() } = {}) {
+  if (!sha) {
+    const err = new Error('usage: plan.mjs --sha <sha> [--trunk main] [--json] [--strict]')
+    err.exitCode = 2
+    throw err
+  }
+  git(['rev-parse', '--verify', sha], cwd)
+  const tags = git(['tag', '--merged', sha, '--list', 'v*'], cwd)
+    .split('\n')
+    .map((line) => line.trim())
+    .filter((tag) => parseSemver(tag))
+  const baseline = latestReleaseTag(tags)
+  const range = baseline ? `${baseline.tag}..${sha}` : sha
+  const logArgs = baseline
+    ? ['log', range, '--first-parent', '--format=%s%n%b%x1e']
+    : ['log', sha, '--first-parent', '-n', '50', '--format=%s%n%b%x1e']
+  const changes = parseLog(git(logArgs, cwd))
+  const files = versionFilesAt(sha, cwd)
+  const fileVersion = versionFromGitFiles(sha, files, cwd)
+  const current = parseSemver(fileVersion) || baseline?.version || { major: 0, minor: 0, patch: 0 }
+  const { bump, reason } = bumpFor(changes, current, { strict })
+  const next = nextVersion(current, bump)
+  const version = formatVersion(next)
+  const date = now.toISOString().slice(0, 10)
+  return {
+    trunk,
+    sha,
+    baselineTag: baseline?.tag || null,
+    currentVersion: formatVersion(current),
+    bump,
+    reason,
+    nextVersion: version,
+    tag: `v${version}`,
+    versionFiles: files,
+    changes,
+    date,
+    changelogMarkdown: renderChangelog({ version, date, changes }),
+  }
+}
+
+function parseArgs(argv) {
+  const opts = { json: false, strict: false, trunk: 'main', sha: null }
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i]
+    if (arg === '--json') opts.json = true
+    else if (arg === '--strict') opts.strict = true
+    else if (arg === '--sha') opts.sha = argv[++i]
+    else if (arg === '--trunk') opts.trunk = argv[++i]
+    else if (arg === '--help' || arg === '-h') opts.help = true
+    else {
+      const err = new Error(`unknown argument: ${arg}`)
+      err.exitCode = 2
+      throw err
+    }
+  }
+  if (opts.help) return opts
+  if (!opts.sha || !opts.trunk) {
+    const err = new Error('usage: plan.mjs --sha <sha> [--trunk main] [--json] [--strict]')
+    err.exitCode = 2
+    throw err
+  }
+  return opts
+}
+
+export function main(argv = process.argv.slice(2)) {
+  const opts = parseArgs(argv)
+  if (opts.help) {
+    process.stdout.write('plan.mjs --sha <sha> [--trunk main] [--json] [--strict]\n')
+    return 0
+  }
+  const result = planRelease(opts)
+  process.stdout.write(opts.json ? `${JSON.stringify(result, null, 2)}\n` : `${result.tag}\n${result.changelogMarkdown}`)
+  return 0
+}
+
+if (isMainModule(import.meta.url)) {
+  try {
+    process.exitCode = main()
+  } catch (error) {
+    process.stderr.write(`${error.message}\n`)
+    process.exitCode = error.exitCode || 1
+  }
+}