@regardio/dev 1.16.2 → 1.17.0

package/README.md

@@ -27,7 +27,7 @@ The goal is code that's correct, consistent, and a pleasure to work with.
 | **Testing** | Vitest, Playwright, Testing Library |
 | **Build** | TypeScript, tsx, Vite |
 | **Workflow** | Husky, GitLab Flow |
-| **CLI utilities** | exec-clean, exec-p, exec-s, exec-ts, ship-staging, ship-production, ship-hotfix, lint-biome, lint-md, lint-package |
+| **CLI utilities** | exec-clean, exec-p, exec-s, exec-tsc, ship-staging, ship-production, ship-hotfix, lint-biome, lint-md, lint-package |
 
 ## Quick Start
 

package/dist/bin/ship/production.js

@@ -31,9 +31,10 @@ if (!branchExists('production')) {
         + '  git checkout -b production && git push -u origin production');
     process.exit(1);
 }
-const ahead = gitRead('log', 'origin/production..origin/staging', '--oneline');
+git('pull', '--ff-only', 'origin', 'main');
+const ahead = gitRead('log', 'origin/production..HEAD', '--oneline');
 if (!ahead) {
-    console.error('staging is already in sync with production. Nothing to ship.');
+    console.error('main is already in sync with production. Nothing to ship.');
     process.exit(1);
 }
 console.log('\nCommits to be shipped to production:');
@@ -48,16 +49,12 @@ 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...');
+console.log('\nRunning quality checks on main...');
 try {
     runQualityChecks();
 }
 catch {
-    console.error('\nQuality checks failed on staging. Fix issues before shipping.');
-    git('checkout', 'main');
+    console.error('\nQuality checks failed on main. Fix issues before shipping.');
     process.exit(1);
 }
 console.log('✅ Quality checks passed');
@@ -86,19 +83,17 @@ catch {
 }
 git('add', '-A');
 git('commit', '-m', `chore(release): ${packageName}@${newVersion}`, '-m', changeBody);
-console.log('\nMerging staging into production...');
+console.log('\nMerging main into production...');
 git('checkout', 'production');
 git('pull', '--ff-only', 'origin', 'production');
-git('merge', '--ff-only', 'staging');
+git('merge', '--ff-only', 'main');
 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');
+console.log('\nSyncing staging with production...');
 git('checkout', 'staging');
-git('merge', '--ff-only', 'main');
+git('pull', '--ff-only', 'origin', 'staging');
+git('merge', '--ff-only', 'production');
 git('push', 'origin', 'staging');
 git('checkout', 'main');
+git('pull', '--ff-only', 'origin', 'main');
 console.log(`\n✅ Shipped ${packageName}@${newVersion} to production`);
 console.log('You are on main and ready to keep working.');

package/dist/bin/ship/staging.js

@@ -59,4 +59,5 @@ git('push', 'origin', 'staging');
 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 promote to production.');
+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/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://www.schemastore.org/package.json",
   "name": "@regardio/dev",
-  "version": "1.16.2",
+  "version": "1.17.0",
   "private": false,
   "description": "Regardio developer tooling for testing, linting, and build workflows",
   "keywords": [
@@ -59,7 +59,6 @@
     "exec-husky": "dist/bin/exec/husky.js",
     "exec-p": "dist/bin/exec/p.js",
     "exec-s": "dist/bin/exec/s.js",
-    "exec-ts": "dist/bin/exec/ts.js",
     "exec-tsc": "dist/bin/exec/tsc.js",
     "lint-biome": "dist/bin/lint/biome.js",
     "lint-commit": "dist/bin/lint/commit.js",
@@ -91,28 +90,28 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@biomejs/biome": "2.4.5",
-    "@commitlint/cli": "20.4.2",
-    "@commitlint/config-conventional": "20.4.2",
+    "@biomejs/biome": "2.4.7",
+    "@commitlint/cli": "20.5.0",
+    "@commitlint/config-conventional": "20.5.0",
     "@playwright/test": "1.58.2",
     "@testing-library/jest-dom": "6.9.1",
     "@testing-library/react": "16.3.2",
     "@total-typescript/ts-reset": "0.6.1",
-    "@types/node": "25.3.3",
-    "@vitest/coverage-v8": "4.0.18",
-    "@vitest/ui": "4.0.18",
+    "@types/node": "25.5.0",
+    "@vitest/coverage-v8": "4.1.0",
+    "@vitest/ui": "4.1.0",
     "husky": "9.1.7",
-    "jsdom": "28.1.0",
+    "jsdom": "29.0.0",
     "markdownlint-cli2": "0.21.0",
     "npm-run-all": "4.1.5",
-    "postcss": "8.5.6",
+    "postcss": "8.5.8",
     "rimraf": "6.1.3",
     "rollup": "4.59.0",
     "sort-package-json": "3.6.1",
     "tsx": "4.21.0",
     "typescript": "5.9.3",
-    "vite": "7.3.1",
-    "vitest": "4.0.18"
+    "vite": "8.0.0",
+    "vitest": "4.1.0"
   },
   "peerDependencies": {
     "postcss": "8.4"

package/src/bin/ship/production.ts

@@ -1,26 +1,26 @@
 #!/usr/bin/env node
 /**
- * ship-production: Version and promote staging to production following the GitLab workflow.
+ * ship-production: Version and promote main to production following the GitLab workflow.
  *
  * Usage: ship-production <patch|minor|major>
  *
  * GitLab workflow:
- *   staging → (version bump commit) → production
+ *   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 staging is ahead of production (there is something to ship)
- * 3. Runs quality checks on the staging branch
+ * 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 staging
+ * 5. Collects change descriptions from git log between production and main
  * 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 ship-staging can ff-merge cleanly
+ * 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 { existsSync, readFileSync, writeFileSync } from 'node:fs';
@@ -85,11 +85,12 @@ if (!branchExists('production')) {
 }
 
 // ---------------------------------------------------------------------------
-// Verify staging has commits not yet in production
+// Verify main has commits not yet in production
 // ---------------------------------------------------------------------------
-const ahead = gitRead('log', 'origin/production..origin/staging', '--oneline');
+git('pull', '--ff-only', 'origin', 'main');
+const ahead = gitRead('log', 'origin/production..HEAD', '--oneline');
 if (!ahead) {
-  console.error('staging is already in sync with production. Nothing to ship.');
+  console.error('main is already in sync with production. Nothing to ship.');
   process.exit(1);
 }
 
@@ -114,24 +115,19 @@ if (!confirm(`\nShip ${packageName} as a ${bumpType} release?`)) {
 }
 
 // ---------------------------------------------------------------------------
-// Quality checks on staging
+// Quality checks on main
 // ---------------------------------------------------------------------------
-console.log('\nChecking out staging for quality checks...');
-git('checkout', 'staging');
-git('pull', '--ff-only', 'origin', 'staging');
-
-console.log('\nRunning quality checks on staging...');
+console.log('\nRunning quality checks on main...');
 try {
   runQualityChecks();
 } catch {
-  console.error('\nQuality checks failed on staging. Fix issues before shipping.');
-  git('checkout', 'main');
+  console.error('\nQuality checks failed on main. Fix issues before shipping.');
   process.exit(1);
 }
 console.log('✅ Quality checks passed');
 
 // ---------------------------------------------------------------------------
-// Read version from staging package.json and bump
+// Read version from main package.json and bump
 // ---------------------------------------------------------------------------
 const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8')) as {
   name: string;
@@ -180,36 +176,34 @@ try {
 }
 
 // ---------------------------------------------------------------------------
-// Commit version bump on staging
+// Commit version bump on main
 // ---------------------------------------------------------------------------
 git('add', '-A');
 git('commit', '-m', `chore(release): ${packageName}@${newVersion}`, '-m', changeBody);
 
 // ---------------------------------------------------------------------------
-// Merge staging → production
+// Merge main → production
 // ---------------------------------------------------------------------------
-console.log('\nMerging staging into production...');
+console.log('\nMerging main into production...');
 git('checkout', 'production');
 git('pull', '--ff-only', 'origin', 'production');
-git('merge', '--ff-only', 'staging');
+git('merge', '--ff-only', 'main');
 git('push', 'origin', 'production');
 
 // ---------------------------------------------------------------------------
-// Bring version commit back to main
+// Sync staging with production
 // ---------------------------------------------------------------------------
-console.log('\nSyncing version commit back to main...');
-git('checkout', 'main');
-git('pull', '--ff-only', 'origin', 'main');
+console.log('\nSyncing staging with production...');
+git('checkout', 'staging');
+git('pull', '--ff-only', 'origin', 'staging');
 git('merge', '--ff-only', 'production');
-git('push', 'origin', 'main');
+git('push', 'origin', 'staging');
 
 // ---------------------------------------------------------------------------
-// Sync staging with main so the next flow-release can ff-merge cleanly
+// Return to main and sync
 // ---------------------------------------------------------------------------
-git('checkout', 'staging');
-git('merge', '--ff-only', 'main');
-git('push', 'origin', 'staging');
 git('checkout', 'main');
+git('pull', '--ff-only', '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

@@ -7,6 +7,12 @@
  * 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.
  *
@@ -120,4 +126,5 @@ 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 promote to production.');
+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/dist/bin/exec/ts.d.ts

@@ -1,3 +0,0 @@
-#!/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

@@ -1 +0,0 @@
-{"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

@@ -1,36 +0,0 @@
-#!/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

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

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

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

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

@@ -1,39 +0,0 @@
-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/src/bin/exec/ts.test.ts

@@ -1,54 +0,0 @@
-import { createRequire } from 'node:module';
-import path from 'node:path';
-import { describe, expect, it } from 'vitest';
-
-import { resolveTsxBin } from './ts.js';
-
-function makeRequire(pkgPath: string, pkg: unknown): NodeRequire {
-  const req = (id: string): unknown => (id === pkgPath ? pkg : undefined);
-  req.resolve = (_id: string) => pkgPath;
-  return req as unknown as NodeRequire;
-}
-
-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/src/bin/exec/ts.ts

@@ -1,52 +0,0 @@
-#!/usr/bin/env node
-/**
- * exec-ts: Run a local TypeScript file via tsx with TS support.
- * Usage: exec-ts path/to/script.ts [args...]
- */
-import { type SpawnOptions, spawn } from 'node:child_process';
-import { createRequire } from 'node:module';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-/**
- * Resolve the absolute path to the tsx binary from its package.json bin field.
- * Returns the resolved path, or null if it cannot be determined.
- */
-export function resolveTsxBin(require: NodeRequire): string | null {
-  const pkgPath = require.resolve('tsx/package.json');
-  const pkg = require(pkgPath) as { bin?: unknown };
-  const binRel = pkg.bin;
-  const binEntry: string | undefined =
-    typeof binRel === 'string'
-      ? binRel
-      : typeof binRel === 'object' && binRel !== null && 'tsx' in binRel
-        ? (binRel as Record<string, string>).tsx
-        : undefined;
-  if (!binEntry) return null;
-  return path.join(path.dirname(pkgPath), binEntry);
-}
-
-// ---------------------------------------------------------------------------
-// CLI entry point — only runs when executed directly
-// ---------------------------------------------------------------------------
-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: SpawnOptions = { stdio: 'inherit' };
-  const child = spawn(process.execPath, [bin, script, ...rest], spawnOptions);
-  child.on('exit', (code: number | null) => process.exit(code ?? 0));
-}