@eclipse-docks/cli 0.7.114

package/README.md

@@ -0,0 +1,26 @@
+# @eclipse-docks/cli
+
+Developer CLI for apps built on Eclipse Docks.
+
+## Usage
+
+```bash
+npx @eclipse-docks/cli release                       # bump patch, prompt for release notes
+npx @eclipse-docks/cli release minor                 # bump minor
+npx @eclipse-docks/cli release major -m "notes"      # bump major with inline release notes
+npx @eclipse-docks/cli release v1.2.3                # explicit version
+npx @eclipse-docks/cli release --dry-run             # print what would be committed
+npx @eclipse-docks/cli release --no-push             # commit locally without pushing
+```
+
+## `release`
+
+Creates an empty commit whose subject is the next version (`vX.Y.Z`) and pushes it.
+Pair this with a CI workflow that tags/releases on that commit subject (see
+[`.github/workflows/app-release.yml`](../../.github/workflows/app-release.yml) for a
+reusable one) — the commit body becomes the release notes.
+
+If no release notes are given via `-m`, an end-user-facing summary is generated from the
+commits since the last version, grouped under **Features**, **Fixes**, **Docs**, and
+**Chore/Refactor**, and offered as the default (press Enter on an empty first line to
+accept it).

package/bin.js

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+import { commands } from './src/index.js';
+
+async function main() {
+  const [name, ...rest] = process.argv.slice(2);
+  const command = name ? commands[name] : undefined;
+
+  if (!command) {
+    console.error(
+      `Usage: docks <command> [...args]\n\nCommands:\n${Object.keys(commands)
+        .map((c) => `  ${c}`)
+        .join('\n')}`,
+    );
+    process.exit(name ? 1 : 0);
+  }
+
+  await command(rest);
+}
+
+main().catch((err) => {
+  console.error(err instanceof Error ? err.message : err);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "@eclipse-docks/cli",
+  "version": "0.7.114",
+  "description": "Developer CLI for Eclipse Docks apps (release automation and more)",
+  "type": "module",
+  "bin": {
+    "docks": "./bin.js"
+  },
+  "files": [
+    "bin.js",
+    "src"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/eclipse-docks/core"
+  },
+  "license": "EPL-2.0"
+}

package/src/commands/release.js

@@ -0,0 +1,162 @@
+import { spawnSync } from 'node:child_process';
+import { createInterface } from 'node:readline/promises';
+
+const VERSION_RE = /^v\d+\.\d+\.\d+$/;
+
+function git(args, cwd) {
+  const result = spawnSync('git', args, { cwd, encoding: 'utf8' });
+  if (result.status !== 0) {
+    throw new Error(`git ${args.join(' ')} failed: ${result.stderr.trim()}`);
+  }
+  return result.stdout.trim();
+}
+
+function gitOrNull(args, cwd) {
+  const result = spawnSync('git', args, { cwd, encoding: 'utf8' });
+  return result.status === 0 ? result.stdout.trim() : null;
+}
+
+function parseArgs(argv) {
+  const opts = { bump: 'patch', version: '', notes: '', dryRun: false, push: true };
+
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === 'major' || arg === 'minor' || arg === 'patch') {
+      opts.bump = arg;
+    } else if (VERSION_RE.test(arg)) {
+      opts.version = arg;
+    } else if (arg === '-m' || arg === '--message') {
+      opts.notes = argv[++i] ?? '';
+    } else if (arg === '-n' || arg === '--dry-run') {
+      opts.dryRun = true;
+    } else if (arg === '-p' || arg === '--push') {
+      opts.push = true;
+    } else if (arg === '--no-push') {
+      opts.push = false;
+    } else {
+      throw new Error(
+        `Unknown argument: ${arg}\nUsage: docks release [major|minor|patch|vX.Y.Z] [-m "release notes"] [--dry-run] [--no-push]`,
+      );
+    }
+  }
+
+  return opts;
+}
+
+function findLastVersion(cwd) {
+  const log = gitOrNull(['log', '--pretty=%s'], cwd);
+  if (!log) return null;
+  for (const subject of log.split('\n')) {
+    if (VERSION_RE.test(subject)) return subject;
+  }
+  return null;
+}
+
+function bumpVersion(last, bump) {
+  const [major, minor, patch] = last.slice(1).split('.').map(Number);
+  switch (bump) {
+    case 'major':
+      return `v${major + 1}.0.0`;
+    case 'minor':
+      return `v${major}.${minor + 1}.0`;
+    default:
+      return `v${major}.${minor}.${patch + 1}`;
+  }
+}
+
+function generateSummary(cwd, last) {
+  // find the commit whose subject *is* the last version, not a tag (tags may not exist locally)
+  const lastCommit = last ? gitOrNull(['log', '-E', '--pretty=%H', '-1', `--grep=^${last}$`], cwd) : null;
+  const range = lastCommit ? `${lastCommit}..HEAD` : 'HEAD';
+
+  const log = gitOrNull(['log', range, '--no-merges', '--pretty=%s'], cwd) ?? '';
+  const buckets = { features: [], fixes: [], docs: [], chores: [] };
+
+  for (const subject of log.split('\n')) {
+    if (!subject || VERSION_RE.test(subject)) continue;
+
+    const stripped = subject.includes(': ') ? subject.slice(subject.indexOf(': ') + 2) : subject;
+    const text = stripped.charAt(0).toUpperCase() + stripped.slice(1);
+
+    if (/^(feat|perf)/.test(subject)) buckets.features.push(text);
+    else if (/^fix/.test(subject)) buckets.fixes.push(text);
+    else if (/^docs/.test(subject)) buckets.docs.push(text);
+    else if (/^(chore|ci|build|test|refactor|style)/.test(subject)) buckets.chores.push(text);
+    else buckets.features.push(text);
+  }
+
+  const sections = [];
+  const render = (title, items) => {
+    if (items.length) sections.push(`${title}\n${items.map((i) => `- ${i}`).join('\n')}`);
+  };
+  render('Features', buckets.features);
+  render('Fixes', buckets.fixes);
+  render('Docs', buckets.docs);
+  render('Chore/Refactor', buckets.chores);
+
+  return sections.join('\n\n');
+}
+
+async function promptNotes(version, summary) {
+  console.log(`Enter release notes for ${version} (end with an empty line).`);
+  if (summary) {
+    console.log('Press Enter on an empty first line to use this auto-generated summary:');
+    console.log(summary.replace(/^/gm, '  '));
+  }
+
+  const rl = createInterface({ input: process.stdin });
+  const lines = [];
+  for await (const line of rl) {
+    if (line === '') break;
+    lines.push(line);
+  }
+  rl.close();
+
+  return lines.length ? lines.join('\n') + '\n' : summary ? summary + '\n' : '';
+}
+
+export async function release(argv, cwd = process.cwd()) {
+  const opts = parseArgs(argv);
+
+  if (!opts.dryRun && git(['status', '--porcelain'], cwd) !== '') {
+    throw new Error('Working tree is not clean. Commit or stash your changes first.');
+  }
+
+  const last = findLastVersion(cwd);
+  let version = opts.version;
+  if (!version) {
+    version = bumpVersion(last ?? 'v0.0.0', opts.bump);
+    console.log(`Last version commit: ${last ?? 'v0.0.0'}`);
+  }
+
+  if (gitOrNull(['rev-parse', version], cwd)) {
+    throw new Error(`Tag ${version} already exists.`);
+  }
+
+  let notes = opts.notes;
+  if (!notes) {
+    const summary = generateSummary(cwd, last);
+    notes = await promptNotes(version, summary);
+  }
+
+  if (opts.dryRun) {
+    console.log(`\n[dry run] would create empty commit:\n  ${version}\n`);
+    console.log(notes.replace(/^/gm, '  '));
+    if (opts.push) {
+      const branch = git(['rev-parse', '--abbrev-ref', 'HEAD'], cwd);
+      console.log(`[dry run] would push to origin ${branch}`);
+    }
+    return;
+  }
+
+  git(['commit', '--allow-empty', '-m', version, '-m', notes], cwd);
+
+  const branch = git(['rev-parse', '--abbrev-ref', 'HEAD'], cwd);
+  if (opts.push) {
+    git(['push', 'origin', branch], cwd);
+    console.log(`\nPushed ${version} to origin/${branch}; the release workflow will take over.`);
+  } else {
+    console.log(`\nCreated release commit for ${version}. Push it to trigger the release:`);
+    console.log(`  git push origin ${branch}`);
+  }
+}

package/src/index.js

@@ -0,0 +1,5 @@
+import { release } from './commands/release.js';
+
+export const commands = {
+  release,
+};