@regardio/dev 1.13.8 → 1.14.3

package/src/bin/flow/hotfix.ts

@@ -0,0 +1,210 @@
+#!/usr/bin/env node
+/**
+ * flow-hotfix: Manage hotfix branches based on production code.
+ *
+ * Usage:
+ *   flow-hotfix start <name>                        - Create hotfix/<name> from production
+ *   flow-hotfix finish <patch|minor> "description"  - Finish and propagate the hotfix
+ *
+ * GitLab workflow:
+ *   production → hotfix/<name> → production → staging → main
+ *
+ * start:
+ *   1. Fetches origin, checks out production, creates hotfix/<name>
+ *
+ * finish:
+ *   1. Ensures you are on a hotfix/* branch with a clean working tree
+ *   2. Runs quality checks
+ *   3. Bumps version (patch or minor) and updates CHANGELOG.md
+ *   4. Commits, then merges into production
+ *   5. Merges production into staging
+ *   6. Merges staging into main
+ *   7. Pushes all three branches, deletes the hotfix branch
+ *   8. Checks out main
+ */
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+import {
+  branchExists,
+  bumpVersion,
+  git,
+  gitRead,
+  insertChangelog,
+  runQualityChecks,
+  runScript,
+} from './utils.js';
+
+const subcommand = process.argv[2];
+const subArgs = process.argv.slice(3);
+
+// ---------------------------------------------------------------------------
+// flow-hotfix start <name>
+// ---------------------------------------------------------------------------
+if (subcommand === 'start') {
+  const name = subArgs[0];
+  if (!name) {
+    console.error('Usage: flow-hotfix start <name>');
+    process.exit(1);
+  }
+
+  const hotfixBranch = `hotfix/${name}`;
+
+  const status = gitRead('status', '--porcelain');
+  if (status) {
+    console.error('Working directory has uncommitted changes. Commit or stash them first.');
+    process.exit(1);
+  }
+
+  console.log('\nFetching latest state from origin...');
+  git('fetch', 'origin');
+
+  if (!branchExists('production')) {
+    console.error(
+      'Branch "production" does not exist. Create it first:\n'
+        + '  git checkout -b production && git push -u origin production',
+    );
+    process.exit(1);
+  }
+
+  git('checkout', 'production');
+  git('pull', '--ff-only', 'origin', 'production');
+  git('checkout', '-b', hotfixBranch);
+
+  console.log(`\n✅ Hotfix branch "${hotfixBranch}" created from production.`);
+  console.log('Apply your fix, then run: flow-hotfix finish <patch|minor> "description"');
+  process.exit(0);
+}
+
+// ---------------------------------------------------------------------------
+// flow-hotfix finish <patch|minor> "description"
+// ---------------------------------------------------------------------------
+if (subcommand === 'finish') {
+  const bumpType = subArgs[0];
+  const message = subArgs.slice(1).join(' ');
+
+  if (!bumpType || !['patch', 'minor'].includes(bumpType)) {
+    console.error('Usage: flow-hotfix finish <patch|minor> "description"');
+    console.error('Hotfixes use patch or minor bumps only.');
+    process.exit(1);
+  }
+
+  if (!message) {
+    console.error('A description is required.');
+    console.error('Example: flow-hotfix finish patch "Fix critical auth bug"');
+    process.exit(1);
+  }
+
+  // Guard: must be on a hotfix/* branch
+  const currentBranch = gitRead('branch', '--show-current');
+  if (!currentBranch.startsWith('hotfix/')) {
+    console.error(`Must be on a hotfix/* branch. Currently on: ${currentBranch}`);
+    process.exit(1);
+  }
+
+  // Guard: working tree must be clean
+  const status = gitRead('status', '--porcelain');
+  if (status) {
+    console.error('Working directory has uncommitted changes. Commit or stash them first.');
+    process.exit(1);
+  }
+
+  // Quality checks
+  console.log('\nRunning quality checks...');
+  try {
+    runQualityChecks();
+  } catch {
+    console.error('\nQuality checks failed. Fix all issues before finishing the hotfix.');
+    process.exit(1);
+  }
+  console.log('✅ Quality checks passed');
+
+  // Read package.json
+  const packageJsonPath = join(process.cwd(), 'package.json');
+  if (!existsSync(packageJsonPath)) {
+    console.error('No package.json found in current directory.');
+    process.exit(1);
+  }
+
+  const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8')) as {
+    name: string;
+    version: string;
+  };
+  const packageName = packageJson.name;
+  const oldVersion = packageJson.version;
+  const newVersion = bumpVersion(oldVersion, bumpType);
+
+  console.log(`\nBumping ${packageName}: ${oldVersion} → ${newVersion}`);
+
+  writeFileSync(
+    packageJsonPath,
+    `${JSON.stringify({ ...packageJson, version: newVersion }, null, 2)}\n`,
+  );
+
+  // Update CHANGELOG.md
+  const changelogPath = join(process.cwd(), 'CHANGELOG.md');
+  const today = new Date().toISOString().slice(0, 10);
+  insertChangelog(changelogPath, `## [${newVersion}] - ${today} (hotfix)\n\n${message}\n`);
+
+  // Fix formatting if available
+  try {
+    runScript('fix');
+  } catch {
+    // fix may not exist in all packages
+  }
+
+  // Commit
+  git('add', '-A');
+  git('commit', '-m', `chore(hotfix): ${packageName}@${newVersion}`, '-m', message);
+
+  // Fetch before merging
+  console.log('\nFetching latest state from origin...');
+  git('fetch', 'origin');
+
+  // Merge hotfix → production
+  console.log('\nMerging hotfix into production...');
+  git('checkout', 'production');
+  git('pull', '--ff-only', 'origin', 'production');
+  git(
+    'merge',
+    '--no-ff',
+    currentBranch,
+    '-m',
+    `chore(hotfix): merge ${currentBranch} into production`,
+  );
+  git('push', 'origin', 'production');
+
+  // Merge production → staging
+  console.log('\nPropagating hotfix to staging...');
+  git('checkout', 'staging');
+  git('pull', '--ff-only', 'origin', 'staging');
+  git('merge', '--no-ff', 'production', '-m', 'chore(hotfix): merge production into staging');
+  git('push', 'origin', 'staging');
+
+  // Merge staging → main
+  console.log('\nPropagating hotfix to main...');
+  git('checkout', 'main');
+  git('pull', '--ff-only', 'origin', 'main');
+  git('merge', '--no-ff', 'staging', '-m', 'chore(hotfix): merge staging into main');
+  git('push', 'origin', 'main');
+
+  // Delete hotfix branch
+  git('branch', '-d', currentBranch);
+  try {
+    git('push', 'origin', '--delete', currentBranch);
+  } catch {
+    // Remote branch may not exist if it was never pushed
+  }
+
+  console.log(`\n✅ Hotfix ${packageName}@${newVersion} shipped to production → staging → main`);
+  console.log('You are on main and ready to keep working.');
+  process.exit(0);
+}
+
+// ---------------------------------------------------------------------------
+// Unknown subcommand
+// ---------------------------------------------------------------------------
+console.error('Usage:');
+console.error('  flow-hotfix start <name>');
+console.error('  flow-hotfix finish <patch|minor> "description"');
+process.exit(1);

package/src/bin/flow/release.ts

@@ -0,0 +1,130 @@
+#!/usr/bin/env node
+/**
+ * flow-release: Deploy changes to staging following the GitLab workflow.
+ *
+ * Usage: flow-release "message"
+ *
+ * GitLab workflow:
+ *   main → staging  (staging deploy, no version bump yet)
+ *
+ * Versioning happens at ship time (flow-ship), not here.
+ * This keeps version numbers reserved for production-verified code.
+ *
+ * This script:
+ * 1. Ensures the current branch is main and the working tree is clean
+ * 2. Pulls latest main from origin
+ * 3. Runs quality checks locally (build, typecheck, tests)
+ * 4. Runs fix — commits formatting output (if any) with a commitlint-compliant message
+ * 5. Merges main into staging (fast-forward) and pushes
+ * 6. Pushes main and returns so work can continue
+ */
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+import { branchExists, git, gitRead, runQualityChecks, runScript } from './utils.js';
+
+const args = process.argv.slice(2);
+const message = args.join(' ');
+
+if (!message) {
+  console.error('Usage: flow-release "message"');
+  console.error('Example: flow-release "Add new vitest configs"');
+  process.exit(1);
+}
+
+// ---------------------------------------------------------------------------
+// Guard: must be on main
+// ---------------------------------------------------------------------------
+const currentBranch = gitRead('branch', '--show-current');
+if (currentBranch !== 'main') {
+  console.error(`Must be on the main branch to release. Currently on: ${currentBranch}`);
+  process.exit(1);
+}
+
+// Guard: working tree must be clean
+const status = gitRead('status', '--porcelain');
+if (status) {
+  console.error('Working directory has uncommitted changes. Commit or stash them first.');
+  process.exit(1);
+}
+
+// ---------------------------------------------------------------------------
+// Sync with origin before doing anything
+// ---------------------------------------------------------------------------
+console.log('\nFetching latest state from origin...');
+git('fetch', 'origin');
+git('pull', '--ff-only', 'origin', 'main');
+
+// ---------------------------------------------------------------------------
+// Read package.json
+// ---------------------------------------------------------------------------
+const packageJsonPath = join(process.cwd(), 'package.json');
+if (!existsSync(packageJsonPath)) {
+  console.error('No package.json found in current directory.');
+  process.exit(1);
+}
+
+const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8')) as { name: string };
+const packageName = packageJson.name;
+
+if (!packageName) {
+  console.error('No "name" field found in package.json.');
+  process.exit(1);
+}
+
+// Guard: staging branch must exist
+if (!branchExists('staging')) {
+  console.error(
+    'Branch "staging" does not exist locally or on origin. Create it first:\n'
+      + '  git checkout -b staging && git push -u origin staging',
+  );
+  process.exit(1);
+}
+
+// ---------------------------------------------------------------------------
+// Quality checks — no broken code may be committed
+// ---------------------------------------------------------------------------
+console.log('\nRunning quality checks...');
+try {
+  runQualityChecks();
+} catch {
+  console.error('\nQuality checks failed. Fix all issues before releasing.');
+  process.exit(1);
+}
+console.log('✅ Quality checks passed');
+
+// ---------------------------------------------------------------------------
+// Fix formatting if available
+// ---------------------------------------------------------------------------
+try {
+  runScript('fix');
+} catch {
+  // fix may not exist in all packages
+}
+
+// ---------------------------------------------------------------------------
+// Commit formatting fixes (if any)
+// ---------------------------------------------------------------------------
+git('add', '-A');
+const hasStagedChanges = gitRead('diff', '--cached', '--name-only') !== '';
+if (hasStagedChanges) {
+  git('commit', '-m', `chore(staging): ${message}`);
+}
+
+// ---------------------------------------------------------------------------
+// Merge into staging
+// ---------------------------------------------------------------------------
+console.log('\nMerging main into staging...');
+git('checkout', 'staging');
+git('merge', '--ff-only', 'main');
+git('push', 'origin', 'staging');
+
+// ---------------------------------------------------------------------------
+// Return to main and sync
+// ---------------------------------------------------------------------------
+git('checkout', 'main');
+git('push', 'origin', 'main');
+
+console.log('\n✅ Changes deployed to staging');
+console.log(`   "${message}"`);
+console.log('Run flow-ship <patch|minor|major> when ready to promote to production.');

package/src/bin/flow/ship.ts

@@ -0,0 +1,215 @@
+#!/usr/bin/env node
+/**
+ * flow-ship: Version and promote staging to production following the GitLab workflow.
+ *
+ * Usage: flow-ship <patch|minor|major>
+ *
+ * GitLab workflow:
+ *   staging → (version bump commit) → production
+ *
+ * Versioning is intentionally deferred to this step so that version numbers
+ * only ever correspond to production-verified code.
+ *
+ * This script:
+ * 1. Ensures the current branch is main and the working tree is clean
+ * 2. Verifies staging is ahead of production (there is something to ship)
+ * 3. Runs quality checks on the staging branch
+ * 4. Bumps the version in package.json
+ * 5. Collects change descriptions from git log between production and staging
+ * 6. Updates CHANGELOG.md
+ * 7. Commits the version bump on staging
+ * 8. Merges staging into production (fast-forward) and pushes
+ * 9. Merges production back into main to carry the version commit forward
+ * 10. Syncs staging with main so the next flow-release can ff-merge cleanly
+ * 11. Returns to main
+ */
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+import {
+  branchExists,
+  bumpVersion,
+  confirm,
+  git,
+  gitRead,
+  insertChangelog,
+  runQualityChecks,
+  runScript,
+} from './utils.js';
+
+const args = process.argv.slice(2);
+const bumpType = args[0];
+
+if (!bumpType || !['patch', 'minor', 'major'].includes(bumpType)) {
+  console.error('Usage: flow-ship <patch|minor|major>');
+  console.error('Example: flow-ship minor');
+  process.exit(1);
+}
+
+// ---------------------------------------------------------------------------
+// Guard: must be on main
+// ---------------------------------------------------------------------------
+const currentBranch = gitRead('branch', '--show-current');
+if (currentBranch !== 'main') {
+  console.error(`Must be on the main branch to ship. Currently on: ${currentBranch}`);
+  process.exit(1);
+}
+
+// Guard: working tree must be clean
+const status = gitRead('status', '--porcelain');
+if (status) {
+  console.error('Working directory has uncommitted changes. Commit or stash them first.');
+  process.exit(1);
+}
+
+// ---------------------------------------------------------------------------
+// Fetch and verify both branches exist
+// ---------------------------------------------------------------------------
+console.log('\nFetching latest state from origin...');
+git('fetch', 'origin');
+
+if (!branchExists('staging')) {
+  console.error(
+    'Branch "staging" does not exist. Create it first:\n'
+      + '  git checkout -b staging && git push -u origin staging',
+  );
+  process.exit(1);
+}
+
+if (!branchExists('production')) {
+  console.error(
+    'Branch "production" does not exist. Create it first:\n'
+      + '  git checkout -b production && git push -u origin production',
+  );
+  process.exit(1);
+}
+
+// ---------------------------------------------------------------------------
+// Verify staging has commits not yet in production
+// ---------------------------------------------------------------------------
+const ahead = gitRead('log', 'origin/production..origin/staging', '--oneline');
+if (!ahead) {
+  console.error('staging is already in sync with production. Nothing to ship.');
+  process.exit(1);
+}
+
+console.log('\nCommits to be shipped to production:');
+console.log(ahead);
+
+// ---------------------------------------------------------------------------
+// Read package name for the confirmation prompt
+// ---------------------------------------------------------------------------
+const packageJsonPath = join(process.cwd(), 'package.json');
+if (!existsSync(packageJsonPath)) {
+  console.error('No package.json found in current directory.');
+  process.exit(1);
+}
+const { name: packageName } = JSON.parse(readFileSync(packageJsonPath, 'utf-8')) as {
+  name: string;
+};
+
+if (!confirm(`\nShip ${packageName} as a ${bumpType} release?`)) {
+  console.log('Aborted.');
+  process.exit(0);
+}
+
+// ---------------------------------------------------------------------------
+// Quality checks on staging
+// ---------------------------------------------------------------------------
+console.log('\nChecking out staging for quality checks...');
+git('checkout', 'staging');
+git('pull', '--ff-only', 'origin', 'staging');
+
+console.log('\nRunning quality checks on staging...');
+try {
+  runQualityChecks();
+} catch {
+  console.error('\nQuality checks failed on staging. Fix issues before shipping.');
+  git('checkout', 'main');
+  process.exit(1);
+}
+console.log('✅ Quality checks passed');
+
+// ---------------------------------------------------------------------------
+// Read version from staging package.json and bump
+// ---------------------------------------------------------------------------
+const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8')) as {
+  name: string;
+  version: string;
+};
+const oldVersion = packageJson.version;
+const newVersion = bumpVersion(oldVersion, bumpType);
+
+console.log(`\nBumping ${packageName}: ${oldVersion} → ${newVersion}`);
+
+writeFileSync(
+  packageJsonPath,
+  `${JSON.stringify({ ...packageJson, version: newVersion }, null, 2)}\n`,
+);
+
+// ---------------------------------------------------------------------------
+// Derive change descriptions from git log between production and staging
+// ---------------------------------------------------------------------------
+const logOutput = gitRead('log', 'origin/production..HEAD', '--pretty=format:%s');
+const changeLines = logOutput
+  ? logOutput
+      .split('\n')
+      .map((s) => s.trim())
+      .filter((s) => s.length > 0)
+  : [];
+
+const changeBody =
+  changeLines.length > 0
+    ? changeLines.map((c) => `- ${c.length > 98 ? `${c.slice(0, 95)}...` : c}`).join('\n')
+    : `${bumpType} release`;
+
+// ---------------------------------------------------------------------------
+// Update CHANGELOG.md
+// ---------------------------------------------------------------------------
+const changelogPath = join(process.cwd(), 'CHANGELOG.md');
+const today = new Date().toISOString().slice(0, 10);
+insertChangelog(changelogPath, `## [${newVersion}] - ${today}\n\n${changeBody}\n`);
+
+// ---------------------------------------------------------------------------
+// Fix formatting if available
+// ---------------------------------------------------------------------------
+try {
+  runScript('fix');
+} catch {
+  // fix may not exist in all packages
+}
+
+// ---------------------------------------------------------------------------
+// Commit version bump on staging
+// ---------------------------------------------------------------------------
+git('add', '-A');
+git('commit', '-m', `chore(release): ${packageName}@${newVersion}`, '-m', changeBody);
+
+// ---------------------------------------------------------------------------
+// Merge staging → production
+// ---------------------------------------------------------------------------
+console.log('\nMerging staging into production...');
+git('checkout', 'production');
+git('pull', '--ff-only', 'origin', 'production');
+git('merge', '--ff-only', 'staging');
+git('push', 'origin', 'production');
+
+// ---------------------------------------------------------------------------
+// Bring version commit back to main
+// ---------------------------------------------------------------------------
+console.log('\nSyncing version commit back to main...');
+git('checkout', 'main');
+git('pull', '--ff-only', 'origin', 'main');
+git('merge', '--ff-only', 'production');
+git('push', 'origin', 'main');
+
+// ---------------------------------------------------------------------------
+// Sync staging with main so the next flow-release can ff-merge cleanly
+// ---------------------------------------------------------------------------
+git('checkout', 'staging');
+git('merge', '--ff-only', 'main');
+git('push', 'origin', 'staging');
+git('checkout', 'main');
+
+console.log(`\n✅ Shipped ${packageName}@${newVersion} to production`);
+console.log('You are on main and ready to keep working.');