@regardio/dev 1.24.0 → 2.0.1

package/src/bin/ship/production.ts

@@ -1,240 +0,0 @@
-#!/usr/bin/env node
-/**
- * ship-production: Version and promote main to production following the GitLab workflow.
- *
- * Usage: ship-production <patch|minor|major>
- *
- * GitLab workflow:
- *   main → (version bump commit) → production → staging → main
- *
- * 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 main is ahead of production (there is something to ship)
- * 3. Runs quality checks on main
- * 4. Bumps the version in package.json
- * 5. Collects change descriptions from git log between production and main
- * 6. Updates CHANGELOG.md
- * 7. Commits the version bump on main
- * 8. Merges main into production (fast-forward) and pushes
- * 9. Merges production into staging to keep it in sync
- * 10. Merges production back into main to ensure consistency
- * 11. Returns to main
- */
-import { execSync } from 'node:child_process';
-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: ship-production <patch|minor|major>');
-  console.error('Example: ship-production 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 main has commits not yet in production
-// ---------------------------------------------------------------------------
-git('pull', '--ff-only', 'origin', 'main');
-const ahead = gitRead('log', 'origin/production..HEAD', '--oneline');
-if (!ahead) {
-  console.error('main 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 main
-// ---------------------------------------------------------------------------
-console.log('\nRunning quality checks on main...');
-try {
-  runQualityChecks();
-} catch {
-  console.error('\nQuality checks failed on main. Fix issues before shipping.');
-  process.exit(1);
-}
-console.log('✅ Quality checks passed');
-
-// ---------------------------------------------------------------------------
-// Read version from main 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 of modified files (package.json, CHANGELOG.md)
-// ---------------------------------------------------------------------------
-try {
-  runScript('fix:pkg');
-} catch {
-  // fix:pkg may not exist
-}
-
-// Format modified files
-try {
-  git('add', '-A');
-  const changedFiles = gitRead('diff', '--cached', '--name-only').split('\n').filter(Boolean);
-
-  // Format JSON files with biome
-  for (const file of changedFiles) {
-    if (file.endsWith('.json')) {
-      try {
-        execSync(`npx biome check --write ${file}`, { cwd: process.cwd(), stdio: 'inherit' });
-      } catch {
-        // File might not need formatting or biome not available
-      }
-    }
-  }
-
-  // Format markdown files with markdownlint
-  for (const file of changedFiles) {
-    if (file.endsWith('.md')) {
-      try {
-        execSync(`npx markdownlint-cli2 --fix ${file}`, { cwd: process.cwd(), stdio: 'inherit' });
-      } catch {
-        // File might not need formatting or markdownlint not available
-      }
-    }
-  }
-} catch {
-  // Formatters not available
-}
-
-// ---------------------------------------------------------------------------
-// Commit version bump on main
-// ---------------------------------------------------------------------------
-git('add', '-A');
-git('commit', '-m', `chore(release): ${packageName}@${newVersion}`, '-m', changeBody);
-
-// ---------------------------------------------------------------------------
-// Merge main → production
-// ---------------------------------------------------------------------------
-console.log('\nMerging main into production...');
-git('checkout', 'production');
-git('pull', '--ff-only', 'origin', 'production');
-git('merge', '--ff-only', 'main');
-git('push', 'origin', 'production');
-
-// ---------------------------------------------------------------------------
-// Sync staging with production
-// ---------------------------------------------------------------------------
-console.log('\nSyncing staging with production...');
-git('checkout', 'staging');
-git('pull', '--ff-only', 'origin', 'staging');
-git('merge', '--ff-only', 'production');
-git('push', 'origin', 'staging');
-
-// ---------------------------------------------------------------------------
-// Return to main and push
-// ---------------------------------------------------------------------------
-git('checkout', 'main');
-git('push', 'origin', 'main');
-
-console.log(`\n✅ Shipped ${packageName}@${newVersion} to production`);
-console.log('You are on main and ready to keep working.');

package/src/bin/ship/staging.ts

@@ -1,108 +0,0 @@
-#!/usr/bin/env node
-/**
- * ship-staging: Deploy changes to staging following the GitLab workflow.
- *
- * Usage: ship-staging [message]
- *
- * GitLab workflow:
- *   main → staging  (staging deploy, no version bump yet)
- *
- * This script is OPTIONAL. You can ship directly to production using ship-production,
- * which will automatically sync staging afterward.
- *
- * Use ship-staging when you want to test changes in a staging environment before
- * shipping to production. Otherwise, skip this step and use ship-production directly.
- *
- * Versioning happens at ship time (ship-production), 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, lint, typecheck, tests)
- * 4. Merges main into staging (fast-forward) and pushes
- * 5. Pushes main and returns so work can continue
- */
-import { existsSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
-
-import { branchExists, git, gitRead, runQualityChecks } from './utils.js';
-
-// ---------------------------------------------------------------------------
-// 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');
-
-// ---------------------------------------------------------------------------
-// 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('Run ship-production <patch|minor|major> when ready to ship to production.');
-console.log('(Or ship directly from main to production without using ship-staging first.)');

package/src/bin/ship/utils.test.ts

@@ -1,178 +0,0 @@
-import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-
-import { bumpVersion, confirm, insertChangelog } from './utils.js';
-
-// ---------------------------------------------------------------------------
-// bumpVersion
-// ---------------------------------------------------------------------------
-
-describe('bumpVersion', () => {
-  it('bumps patch', () => {
-    expect(bumpVersion('1.2.3', 'patch')).toBe('1.2.4');
-  });
-
-  it('bumps minor and resets patch', () => {
-    expect(bumpVersion('1.2.3', 'minor')).toBe('1.3.0');
-  });
-
-  it('bumps major and resets minor + patch', () => {
-    expect(bumpVersion('1.2.3', 'major')).toBe('2.0.0');
-  });
-
-  it('handles zero components', () => {
-    expect(bumpVersion('0.0.0', 'patch')).toBe('0.0.1');
-    expect(bumpVersion('0.0.0', 'minor')).toBe('0.1.0');
-    expect(bumpVersion('0.0.0', 'major')).toBe('1.0.0');
-  });
-
-  it('defaults to patch for unknown bump type', () => {
-    expect(bumpVersion('1.2.3', 'unknown')).toBe('1.2.4');
-  });
-
-  it('throws for invalid semver', () => {
-    expect(() => bumpVersion('not-semver', 'patch')).toThrow('Invalid semver');
-    expect(() => bumpVersion('1.2', 'patch')).toThrow('Invalid semver');
-    expect(() => bumpVersion('1.2.x', 'patch')).toThrow('Invalid semver');
-  });
-});
-
-// ---------------------------------------------------------------------------
-// insertChangelog
-// ---------------------------------------------------------------------------
-
-describe('insertChangelog', () => {
-  let tmpDir: string;
-  let changelogPath: string;
-
-  beforeEach(() => {
-    tmpDir = join(tmpdir(), `flow-utils-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-    mkdirSync(tmpDir, { recursive: true });
-    changelogPath = join(tmpDir, 'CHANGELOG.md');
-  });
-
-  afterEach(() => {
-    rmSync(tmpDir, { force: true, recursive: true });
-  });
-
-  it('creates a new file when none exists', () => {
-    insertChangelog(changelogPath, '## [1.0.0] - 2025-01-01\n\n- initial release\n');
-
-    expect(existsSync(changelogPath)).toBe(true);
-    const content = readFileSync(changelogPath, 'utf-8');
-    expect(content).toContain('# Changelog');
-    expect(content).toContain('## [1.0.0] - 2025-01-01');
-  });
-
-  it('inserts before the first existing ## section', () => {
-    writeFileSync(changelogPath, '# Changelog\n\n## [1.0.0] - 2025-01-01\n\n- old entry\n');
-
-    insertChangelog(changelogPath, '## [1.1.0] - 2025-02-01\n\n- new entry\n');
-
-    const content = readFileSync(changelogPath, 'utf-8');
-    const newIdx = content.indexOf('## [1.1.0]');
-    const oldIdx = content.indexOf('## [1.0.0]');
-    expect(newIdx).toBeLessThan(oldIdx);
-  });
-
-  it('appends when no ## section exists yet', () => {
-    writeFileSync(changelogPath, '# Changelog\n');
-
-    insertChangelog(changelogPath, '## [1.0.0] - 2025-01-01\n\n- initial\n');
-
-    const content = readFileSync(changelogPath, 'utf-8');
-    expect(content).toContain('## [1.0.0]');
-  });
-
-  it('preserves existing entries when inserting', () => {
-    writeFileSync(changelogPath, '# Changelog\n\n## [1.0.0] - 2025-01-01\n\n- old entry\n');
-
-    insertChangelog(changelogPath, '## [1.1.0] - 2025-02-01\n\n- new entry\n');
-
-    const content = readFileSync(changelogPath, 'utf-8');
-    expect(content).toContain('## [1.0.0]');
-    expect(content).toContain('- old entry');
-    expect(content).toContain('## [1.1.0]');
-    expect(content).toContain('- new entry');
-  });
-
-  it('appends when file exists but has no title line', () => {
-    writeFileSync(changelogPath, '## [1.0.0] - 2025-01-01\n\n- old entry\n');
-
-    insertChangelog(changelogPath, '## [1.1.0] - 2025-02-01\n\n- new entry\n');
-
-    const content = readFileSync(changelogPath, 'utf-8');
-    expect(content).toContain('## [1.0.0]');
-    expect(content).toContain('## [1.1.0]');
-  });
-
-  it('handles multiple existing entries in the correct order', () => {
-    writeFileSync(
-      changelogPath,
-      '# Changelog\n\n## [1.1.0] - 2025-02-01\n\n- second\n\n## [1.0.0] - 2025-01-01\n\n- first\n',
-    );
-
-    insertChangelog(changelogPath, '## [1.2.0] - 2025-03-01\n\n- third\n');
-
-    const content = readFileSync(changelogPath, 'utf-8');
-    const idx120 = content.indexOf('## [1.2.0]');
-    const idx110 = content.indexOf('## [1.1.0]');
-    const idx100 = content.indexOf('## [1.0.0]');
-    expect(idx120).toBeLessThan(idx110);
-    expect(idx110).toBeLessThan(idx100);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// confirm
-// ---------------------------------------------------------------------------
-
-describe('confirm', () => {
-  let tmpDir: string;
-  let inputFile: string;
-
-  beforeEach(() => {
-    tmpDir = join(tmpdir(), `confirm-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-    mkdirSync(tmpDir, { recursive: true });
-    inputFile = join(tmpDir, 'input');
-    vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
-  });
-
-  afterEach(() => {
-    rmSync(tmpDir, { force: true, recursive: true });
-    vi.restoreAllMocks();
-  });
-
-  it('returns true for "y"', () => {
-    writeFileSync(inputFile, 'y\n');
-    expect(confirm('Continue?', inputFile)).toBe(true);
-  });
-
-  it('returns true for "Y"', () => {
-    writeFileSync(inputFile, 'Y\n');
-    expect(confirm('Continue?', inputFile)).toBe(true);
-  });
-
-  it('returns false for "n"', () => {
-    writeFileSync(inputFile, 'n\n');
-    expect(confirm('Continue?', inputFile)).toBe(false);
-  });
-
-  it('returns false for empty input', () => {
-    writeFileSync(inputFile, '\n');
-    expect(confirm('Continue?', inputFile)).toBe(false);
-  });
-
-  it('returns false for any other input', () => {
-    writeFileSync(inputFile, 'yes\n');
-    expect(confirm('Continue?', inputFile)).toBe(false);
-  });
-
-  it('writes the prompt to stdout', () => {
-    writeFileSync(inputFile, 'y\n');
-    confirm('Ship it?', inputFile);
-    expect(process.stdout.write).toHaveBeenCalledWith('Ship it? (y/N) ');
-  });
-});

package/src/bin/ship/utils.ts

@@ -1,109 +0,0 @@
-/**
- * Shared utilities for ship-staging, ship-production, and ship-hotfix.
- *
- * Git commands use execFileSync (not a shell string) so user-provided
- * strings such as commit messages are never interpolated by the shell.
- * pnpm script invocations use execSync via shell since script names are
- * developer-controlled and pnpm itself is resolved through PATH.
- */
-import { execFileSync, execSync } from 'node:child_process';
-import { closeSync, existsSync, openSync, readFileSync, readSync, writeFileSync } from 'node:fs';
-
-/**
- * Run a git command with the given arguments.
- * Output is inherited (visible to the user).
- */
-export const git = (...args: string[]): void => {
-  console.log(`$ git ${args.join(' ')}`);
-  execFileSync('git', args, { stdio: 'inherit' });
-};
-
-/**
- * Run a git command and return trimmed stdout.
- * Stderr is suppressed; throws on non-zero exit.
- */
-export const gitRead = (...args: string[]): string =>
-  execFileSync('git', args, { encoding: 'utf-8' }).trim();
-
-/**
- * Run a pnpm script via the shell.
- * Only pass developer-controlled script names — never user input.
- */
-export const runScript = (script: string): void => {
-  console.log(`$ pnpm ${script}`);
-  execSync(`pnpm ${script}`, { stdio: 'inherit' });
-};
-
-/**
- * Bump a semver string by the given increment type.
- */
-export const bumpVersion = (current: string, bump: string): string => {
-  const parts = current.split('.').map(Number);
-  if (parts.length !== 3 || parts.some(Number.isNaN)) {
-    throw new Error(`Invalid semver: ${current}`);
-  }
-  const [major, minor, patch] = parts as [number, number, number];
-  if (bump === 'major') return `${major + 1}.0.0`;
-  if (bump === 'minor') return `${major}.${minor + 1}.0`;
-  return `${major}.${minor}.${patch + 1}`;
-};
-
-/**
- * Insert a new changelog entry after the title line of CHANGELOG.md.
- * Creates the file if it does not exist.
- */
-export const insertChangelog = (changelogPath: string, entry: string): void => {
-  if (existsSync(changelogPath)) {
-    const existing = readFileSync(changelogPath, 'utf-8');
-    const insertAt = existing.indexOf('\n## ');
-    if (insertAt === -1) {
-      writeFileSync(changelogPath, `${existing.trimEnd()}\n\n${entry}`);
-    } else {
-      writeFileSync(
-        changelogPath,
-        `${existing.slice(0, insertAt)}\n\n${entry}${existing.slice(insertAt + 1)}`,
-      );
-    }
-  } else {
-    writeFileSync(changelogPath, `# Changelog\n\n${entry}`);
-  }
-};
-
-/**
- * Run quality checks. Throws if any step fails.
- */
-export const runQualityChecks = (): void => {
-  runScript('build');
-  runScript('typecheck');
-  runScript('test');
-};
-
-/**
- * Check whether a branch exists locally or on origin.
- * Requires a prior `git fetch` to have up-to-date remote refs.
- */
-export const branchExists = (name: string): boolean =>
-  gitRead('branch', '--list', name) !== ''
-  || gitRead('branch', '--list', '--remotes', `origin/${name}`) !== '';
-
-/**
- * Prompt the user for confirmation and return true only if they type "y" or "Y".
- * Defaults to "no" on empty input, so pressing Enter alone aborts.
- * The ttyPath parameter is injectable for testing.
- */
-export const confirm = (prompt: string, ttyPath = '/dev/tty'): boolean => {
-  process.stdout.write(`${prompt} (y/N) `);
-  const buf = Buffer.alloc(1024);
-  let fd: number;
-  let shouldClose = false;
-  try {
-    fd = openSync(ttyPath, 'r');
-    shouldClose = true;
-  } catch {
-    fd = process.stdin.fd;
-  }
-  const bytesRead = readSync(fd, buf, 0, buf.length, null);
-  if (shouldClose) closeSync(fd);
-  const answer = buf.slice(0, bytesRead).toString().trim();
-  return answer === 'y' || answer === 'Y';
-};