@regardio/dev 1.13.8 → 1.14.3

package/README.md

@@ -26,8 +26,8 @@ The goal is code that's correct, consistent, and a pleasure to work with.
 | **Linting** | Biome, Markdownlint, Commitlint |
 | **Testing** | Vitest, Playwright, Testing Library |
 | **Build** | TypeScript, tsx, Vite |
-| **Workflow** | Husky, Changesets |
-| **CLI utilities** | exec-clean, exec-p, exec-s, exec-ts, flow-release, lint-biome, lint-md, lint-package |
+| **Workflow** | Husky, GitLab Flow |
+| **CLI utilities** | exec-clean, exec-p, exec-s, exec-ts, flow-release, flow-ship, flow-hotfix, lint-biome, lint-md, lint-package |
 
 ## Quick Start
 
@@ -67,7 +67,7 @@ Detailed documentation is organized by topic:
 - [Commitlint](./docs/toolchain/commitlint.md) - Commit message validation
 - [Markdownlint](./docs/toolchain/markdownlint.md) - Markdown quality
 - [Husky](./docs/toolchain/husky.md) - Git hooks
-- [Changesets](./docs/toolchain/changesets.md) - Versioning and releases
+- [Release Workflow](./docs/toolchain/release-workflow.md) - GitLab-flow-based versioning and releases
 
 ## Portability
 

package/dist/bin/exec/clean.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export declare function resolveRimrafBin(require: NodeRequire): string | null;
+//# sourceMappingURL=clean.d.ts.map

package/dist/bin/exec/clean.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clean.d.ts","sourceRoot":"","sources":["../../../src/bin/exec/clean.ts"],"names":[],"mappings":";AAcA,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,WAAW,GAAG,MAAM,GAAG,IAAI,CAQpE"}

package/dist/bin/exec/clean.js

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+import { spawn } from 'node:child_process';
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+export function resolveRimrafBin(require) {
+    const pkgPath = require.resolve('rimraf/package.json');
+    const pkg = require(pkgPath);
+    const binRel = typeof pkg.bin === 'string' ? pkg.bin : pkg.bin?.rimraf;
+    if (!binRel)
+        return null;
+    const normalized = binRel.startsWith('./') ? binRel.slice(2) : binRel;
+    return path.join(path.dirname(pkgPath), normalized);
+}
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+    const require = createRequire(import.meta.url);
+    const bin = resolveRimrafBin(require);
+    if (!bin) {
+        console.error('Unable to locate rimraf binary from package.json bin field');
+        process.exit(1);
+    }
+    const args = process.argv.slice(2);
+    const child = spawn(process.execPath, [bin, ...args], { stdio: 'inherit' });
+    child.on('exit', (code) => process.exit(code ?? 0));
+}

package/dist/bin/exec/clean.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=clean.test.d.ts.map

package/dist/bin/exec/clean.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clean.test.d.ts","sourceRoot":"","sources":["../../../src/bin/exec/clean.test.ts"],"names":[],"mappings":""}

package/dist/bin/exec/clean.test.js

@@ -0,0 +1,45 @@
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import { describe, expect, it } from 'vitest';
+import { resolveRimrafBin } from './clean.js';
+function makeRequire(pkgPath, pkg) {
+    const req = (id) => (id === pkgPath ? pkg : undefined);
+    req.resolve = (_id) => pkgPath;
+    return req;
+}
+describe('resolveRimrafBin', () => {
+    it('resolves when bin is a plain string', () => {
+        const pkgPath = '/node_modules/rimraf/package.json';
+        const req = makeRequire(pkgPath, { bin: './dist/esm/bin.js' });
+        const result = resolveRimrafBin(req);
+        expect(result).toBe(path.join('/node_modules/rimraf', 'dist/esm/bin.js'));
+    });
+    it('strips leading ./ from the bin path', () => {
+        const pkgPath = '/node_modules/rimraf/package.json';
+        const req = makeRequire(pkgPath, { bin: './bin/rimraf' });
+        const result = resolveRimrafBin(req);
+        expect(result).toBe(path.join('/node_modules/rimraf', 'bin/rimraf'));
+    });
+    it('resolves when bin is an object with a rimraf key', () => {
+        const pkgPath = '/node_modules/rimraf/package.json';
+        const req = makeRequire(pkgPath, { bin: { rimraf: './dist/esm/bin.js' } });
+        const result = resolveRimrafBin(req);
+        expect(result).toBe(path.join('/node_modules/rimraf', 'dist/esm/bin.js'));
+    });
+    it('returns null when bin field is missing', () => {
+        const pkgPath = '/node_modules/rimraf/package.json';
+        const req = makeRequire(pkgPath, {});
+        expect(resolveRimrafBin(req)).toBeNull();
+    });
+    it('returns null when bin object has no rimraf key', () => {
+        const pkgPath = '/node_modules/rimraf/package.json';
+        const req = makeRequire(pkgPath, { bin: { other: './dist/other.js' } });
+        expect(resolveRimrafBin(req)).toBeNull();
+    });
+    it('resolves against the real rimraf package', () => {
+        const req = createRequire(import.meta.url);
+        const result = resolveRimrafBin(req);
+        expect(result).not.toBeNull();
+        expect(path.isAbsolute(result ?? '')).toBe(true);
+    });
+});

package/dist/bin/exec/husky.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=husky.d.ts.map

package/dist/bin/exec/husky.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"husky.d.ts","sourceRoot":"","sources":["../../../src/bin/exec/husky.ts"],"names":[],"mappings":""}

package/dist/bin/exec/p.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=p.d.ts.map

package/dist/bin/exec/p.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"p.d.ts","sourceRoot":"","sources":["../../../src/bin/exec/p.ts"],"names":[],"mappings":""}

package/dist/bin/exec/s.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=s.d.ts.map

package/dist/bin/exec/s.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"s.d.ts","sourceRoot":"","sources":["../../../src/bin/exec/s.ts"],"names":[],"mappings":""}

package/dist/bin/exec/ts.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export declare function resolveTsxBin(require: NodeRequire): string | null;
+//# sourceMappingURL=ts.d.ts.map

package/dist/bin/exec/ts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ts.d.ts","sourceRoot":"","sources":["../../../src/bin/exec/ts.ts"],"names":[],"mappings":";AAcA,wBAAgB,aAAa,CAAC,OAAO,EAAE,WAAW,GAAG,MAAM,GAAG,IAAI,CAYjE"}

package/dist/bin/exec/ts.js

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+import { spawn } from 'node:child_process';
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+export function resolveTsxBin(require) {
+    const pkgPath = require.resolve('tsx/package.json');
+    const pkg = require(pkgPath);
+    const binRel = pkg.bin;
+    const binEntry = typeof binRel === 'string'
+        ? binRel
+        : typeof binRel === 'object' && binRel !== null && 'tsx' in binRel
+            ? binRel.tsx
+            : undefined;
+    if (!binEntry)
+        return null;
+    return path.join(path.dirname(pkgPath), binEntry);
+}
+if (fileURLToPath(import.meta.url) === path.resolve(process.argv[1] ?? '')) {
+    const args = process.argv.slice(2);
+    if (args.length === 0) {
+        console.error('Usage: exec-ts <script.ts> [args...]');
+        process.exit(1);
+    }
+    const [scriptArg, ...rest] = args;
+    const script = scriptArg ?? '';
+    const require = createRequire(import.meta.url);
+    const bin = resolveTsxBin(require);
+    if (!bin) {
+        console.error('Unable to locate tsx binary from package.json bin field');
+        process.exit(1);
+    }
+    const spawnOptions = { stdio: 'inherit' };
+    const child = spawn(process.execPath, [bin, script, ...rest], spawnOptions);
+    child.on('exit', (code) => process.exit(code ?? 0));
+}

package/dist/bin/exec/ts.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ts.test.d.ts.map

package/dist/bin/exec/ts.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ts.test.d.ts","sourceRoot":"","sources":["../../../src/bin/exec/ts.test.ts"],"names":[],"mappings":""}

package/dist/bin/exec/ts.test.js

@@ -0,0 +1,39 @@
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import { describe, expect, it } from 'vitest';
+import { resolveTsxBin } from './ts.js';
+function makeRequire(pkgPath, pkg) {
+    const req = (id) => (id === pkgPath ? pkg : undefined);
+    req.resolve = (_id) => pkgPath;
+    return req;
+}
+describe('resolveTsxBin', () => {
+    it('resolves when bin is a string', () => {
+        const pkgPath = '/node_modules/tsx/package.json';
+        const req = makeRequire(pkgPath, { bin: './dist/cli.mjs' });
+        const result = resolveTsxBin(req);
+        expect(result).toBe(path.join('/node_modules/tsx', 'dist/cli.mjs'));
+    });
+    it('resolves when bin is an object with a tsx key', () => {
+        const pkgPath = '/node_modules/tsx/package.json';
+        const req = makeRequire(pkgPath, { bin: { tsx: './dist/cli.mjs' } });
+        const result = resolveTsxBin(req);
+        expect(result).toBe(path.join('/node_modules/tsx', 'dist/cli.mjs'));
+    });
+    it('returns null when bin field is missing', () => {
+        const pkgPath = '/node_modules/tsx/package.json';
+        const req = makeRequire(pkgPath, {});
+        expect(resolveTsxBin(req)).toBeNull();
+    });
+    it('returns null when bin object has no tsx key', () => {
+        const pkgPath = '/node_modules/tsx/package.json';
+        const req = makeRequire(pkgPath, { bin: { other: './dist/other.js' } });
+        expect(resolveTsxBin(req)).toBeNull();
+    });
+    it('resolves against the real tsx package', () => {
+        const req = createRequire(import.meta.url);
+        const result = resolveTsxBin(req);
+        expect(result).not.toBeNull();
+        expect(path.isAbsolute(result ?? '')).toBe(true);
+    });
+});

package/dist/bin/exec/tsc.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=tsc.d.ts.map

package/dist/bin/exec/tsc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tsc.d.ts","sourceRoot":"","sources":["../../../src/bin/exec/tsc.ts"],"names":[],"mappings":""}

package/dist/bin/flow/hotfix.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=hotfix.d.ts.map

package/dist/bin/flow/hotfix.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hotfix.d.ts","sourceRoot":"","sources":["../../../src/bin/flow/hotfix.ts"],"names":[],"mappings":""}

package/dist/bin/flow/hotfix.js

@@ -0,0 +1,116 @@
+#!/usr/bin/env node
+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);
+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);
+}
+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);
+    }
+    const currentBranch = gitRead('branch', '--show-current');
+    if (!currentBranch.startsWith('hotfix/')) {
+        console.error(`Must be on a hotfix/* branch. Currently on: ${currentBranch}`);
+        process.exit(1);
+    }
+    const status = gitRead('status', '--porcelain');
+    if (status) {
+        console.error('Working directory has uncommitted changes. Commit or stash them first.');
+        process.exit(1);
+    }
+    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');
+    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'));
+    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`);
+    const changelogPath = join(process.cwd(), 'CHANGELOG.md');
+    const today = new Date().toISOString().slice(0, 10);
+    insertChangelog(changelogPath, `## [${newVersion}] - ${today} (hotfix)\n\n${message}\n`);
+    try {
+        runScript('fix');
+    }
+    catch {
+    }
+    git('add', '-A');
+    git('commit', '-m', `chore(hotfix): ${packageName}@${newVersion}`, '-m', message);
+    console.log('\nFetching latest state from origin...');
+    git('fetch', 'origin');
+    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');
+    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');
+    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');
+    git('branch', '-d', currentBranch);
+    try {
+        git('push', 'origin', '--delete', currentBranch);
+    }
+    catch {
+    }
+    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);
+}
+console.error('Usage:');
+console.error('  flow-hotfix start <name>');
+console.error('  flow-hotfix finish <patch|minor> "description"');
+process.exit(1);

package/dist/bin/flow/release.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=release.d.ts.map

package/dist/bin/flow/release.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"release.d.ts","sourceRoot":"","sources":["../../../src/bin/flow/release.ts"],"names":[],"mappings":""}

package/dist/bin/flow/release.js

@@ -0,0 +1,68 @@
+#!/usr/bin/env node
+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);
+}
+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);
+}
+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');
+git('pull', '--ff-only', 'origin', 'main');
+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'));
+const packageName = packageJson.name;
+if (!packageName) {
+    console.error('No "name" field found in package.json.');
+    process.exit(1);
+}
+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);
+}
+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');
+try {
+    runScript('fix');
+}
+catch {
+}
+git('add', '-A');
+const hasStagedChanges = gitRead('diff', '--cached', '--name-only') !== '';
+if (hasStagedChanges) {
+    git('commit', '-m', `chore(staging): ${message}`);
+}
+console.log('\nMerging main into staging...');
+git('checkout', 'staging');
+git('merge', '--ff-only', 'main');
+git('push', 'origin', 'staging');
+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/dist/bin/flow/ship.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=ship.d.ts.map

package/dist/bin/flow/ship.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ship.d.ts","sourceRoot":"","sources":["../../../src/bin/flow/ship.ts"],"names":[],"mappings":""}

package/dist/bin/flow/ship.js

@@ -0,0 +1,104 @@
+#!/usr/bin/env node
+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);
+}
+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);
+}
+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('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);
+}
+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);
+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'));
+if (!confirm(`\nShip ${packageName} as a ${bumpType} release?`)) {
+    console.log('Aborted.');
+    process.exit(0);
+}
+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');
+const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+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`);
+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`;
+const changelogPath = join(process.cwd(), 'CHANGELOG.md');
+const today = new Date().toISOString().slice(0, 10);
+insertChangelog(changelogPath, `## [${newVersion}] - ${today}\n\n${changeBody}\n`);
+try {
+    runScript('fix');
+}
+catch {
+}
+git('add', '-A');
+git('commit', '-m', `chore(release): ${packageName}@${newVersion}`, '-m', changeBody);
+console.log('\nMerging staging into production...');
+git('checkout', 'production');
+git('pull', '--ff-only', 'origin', 'production');
+git('merge', '--ff-only', 'staging');
+git('push', 'origin', 'production');
+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');
+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.');

package/dist/bin/flow/utils.d.ts

@@ -0,0 +1,9 @@
+export declare const git: (...args: string[]) => void;
+export declare const gitRead: (...args: string[]) => string;
+export declare const runScript: (script: string) => void;
+export declare const bumpVersion: (current: string, bump: string) => string;
+export declare const insertChangelog: (changelogPath: string, entry: string) => void;
+export declare const runQualityChecks: () => void;
+export declare const branchExists: (name: string) => boolean;
+export declare const confirm: (prompt: string, ttyPath?: string) => boolean;
+//# sourceMappingURL=utils.d.ts.map

package/dist/bin/flow/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/bin/flow/utils.ts"],"names":[],"mappings":"AAeA,eAAO,MAAM,GAAG,GAAI,GAAG,MAAM,MAAM,EAAE,KAAG,IAGvC,CAAC;AAMF,eAAO,MAAM,OAAO,GAAI,GAAG,MAAM,MAAM,EAAE,KAAG,MACa,CAAC;AAM1D,eAAO,MAAM,SAAS,GAAI,QAAQ,MAAM,KAAG,IAG1C,CAAC;AAKF,eAAO,MAAM,WAAW,GAAI,SAAS,MAAM,EAAE,MAAM,MAAM,KAAG,MAS3D,CAAC;AAMF,eAAO,MAAM,eAAe,GAAI,eAAe,MAAM,EAAE,OAAO,MAAM,KAAG,IAetE,CAAC;AAKF,eAAO,MAAM,gBAAgB,QAAO,IAInC,CAAC;AAMF,eAAO,MAAM,YAAY,GAAI,MAAM,MAAM,KAAG,OAE0B,CAAC;AAOvE,eAAO,MAAM,OAAO,GAAI,QAAQ,MAAM,EAAE,gBAAoB,KAAG,OAe9D,CAAC"}

package/dist/bin/flow/utils.js

@@ -0,0 +1,63 @@
+import { execFileSync, execSync } from 'node:child_process';
+import { closeSync, existsSync, openSync, readFileSync, readSync, writeFileSync } from 'node:fs';
+export const git = (...args) => {
+    console.log(`$ git ${args.join(' ')}`);
+    execFileSync('git', args, { stdio: 'inherit' });
+};
+export const gitRead = (...args) => execFileSync('git', args, { encoding: 'utf-8' }).trim();
+export const runScript = (script) => {
+    console.log(`$ pnpm ${script}`);
+    execSync(`pnpm ${script}`, { stdio: 'inherit' });
+};
+export const bumpVersion = (current, bump) => {
+    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;
+    if (bump === 'major')
+        return `${major + 1}.0.0`;
+    if (bump === 'minor')
+        return `${major}.${minor + 1}.0`;
+    return `${major}.${minor}.${patch + 1}`;
+};
+export const insertChangelog = (changelogPath, entry) => {
+    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}`);
+    }
+};
+export const runQualityChecks = () => {
+    runScript('build');
+    runScript('typecheck');
+    runScript('report');
+};
+export const branchExists = (name) => gitRead('branch', '--list', name) !== ''
+    || gitRead('branch', '--list', '--remotes', `origin/${name}`) !== '';
+export const confirm = (prompt, ttyPath = '/dev/tty') => {
+    process.stdout.write(`${prompt} (y/N) `);
+    const buf = Buffer.alloc(1024);
+    let fd;
+    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';
+};

package/dist/bin/flow/utils.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=utils.test.d.ts.map

package/dist/bin/flow/utils.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.test.d.ts","sourceRoot":"","sources":["../../../src/bin/flow/utils.test.ts"],"names":[],"mappings":""}