@regardio/dev 1.24.0 → 2.0.2

package/src/bin/exec/s.ts

@@ -1,13 +0,0 @@
-#!/usr/bin/env node
-/**
- * exec-s: Run npm scripts sequentially via npm-run-all's run-s.
- * Usage: exec-s <script-patterns>
- */
-import { spawn } from 'node:child_process';
-import { createRequire } from 'node:module';
-
-const require = createRequire(import.meta.url);
-const bin = require.resolve('npm-run-all/bin/run-s/index.js');
-const args = process.argv.slice(2);
-const child = spawn(process.execPath, [bin, ...args], { stdio: 'inherit' });
-child.on('exit', (code) => process.exit(code ?? 0));

package/src/bin/exec/tsc.ts

@@ -1,13 +0,0 @@
-#!/usr/bin/env node
-/**
- * exec-tsc: Run the TypeScript compiler (tsc) via local dependency.
- * Usage: exec-tsc [tsc args...]
- */
-import { spawn } from 'node:child_process';
-import { createRequire } from 'node:module';
-
-const require = createRequire(import.meta.url);
-const bin = require.resolve('typescript/bin/tsc');
-const args = process.argv.slice(2);
-const child = spawn(process.execPath, [bin, ...args], { stdio: 'inherit' });
-child.on('exit', (code) => process.exit(code ?? 0));

package/src/bin/lint/biome.ts

@@ -1,13 +0,0 @@
-#!/usr/bin/env node
-/**
- * lint-biome: Run Biome (formatter/linter) against the codebase.
- * Usage: lint-biome [biome args...]
- */
-import { spawn } from 'node:child_process';
-import { createRequire } from 'node:module';
-
-const require = createRequire(import.meta.url);
-const bin = require.resolve('@biomejs/biome/bin/biome');
-const args = process.argv.slice(2);
-const child = spawn(process.execPath, [bin, ...args], { stdio: 'inherit' });
-child.on('exit', (code) => process.exit(code ?? 0));

package/src/bin/lint/commit.ts

@@ -1,13 +0,0 @@
-#!/usr/bin/env node
-/**
- * lint-commit: Run commitlint against commit messages.
- * Usage: lint-commit [commitlint args...]
- */
-import { spawn } from 'node:child_process';
-import { createRequire } from 'node:module';
-
-const require = createRequire(import.meta.url);
-const bin = require.resolve('@commitlint/cli/cli.js');
-const args = process.argv.slice(2);
-const child = spawn(process.execPath, [bin, ...args], { stdio: 'inherit' });
-child.on('exit', (code) => process.exit(code ?? 0));

package/src/bin/lint/md.ts

@@ -1,28 +0,0 @@
-#!/usr/bin/env node
-/**
- * lint-md: Run markdownlint-cli2 to lint and fix Markdown files.
- * Usage: lint-md [--fix] [globs...]
- *
- * Default globs (if none provided): "**\/*.md" "**\/*.mdx"
- * Default exclusions (always added): "!**\/dist/**" "!**\/node_modules/**"
- */
-import { spawn } from 'node:child_process';
-import { createRequire } from 'node:module';
-import { dirname, join } from 'node:path';
-
-const require = createRequire(import.meta.url);
-const packageDir = dirname(require.resolve('markdownlint-cli2'));
-const bin = join(packageDir, 'markdownlint-cli2-bin.mjs');
-
-const DEFAULT_GLOBS = ['**/*.md', '**/*.mdx'];
-const DEFAULT_EXCLUSIONS = ['!**/dist/**', '!**/node_modules/**'];
-
-const rawArgs = process.argv.slice(2);
-const fixFlag = rawArgs.includes('--fix');
-const userGlobs = rawArgs.filter((arg) => arg !== '--fix');
-
-const globs = userGlobs.length > 0 ? userGlobs : DEFAULT_GLOBS;
-const args = [...(fixFlag ? ['--fix'] : []), ...globs, ...DEFAULT_EXCLUSIONS];
-
-const child = spawn(process.execPath, [bin, ...args], { stdio: 'inherit' });
-child.on('exit', (code) => process.exit(code ?? 0));

package/src/bin/lint/package.test.ts

@@ -1,83 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import { reorderConditions } from './package.js';
-
-describe('lint-package', () => {
-  describe('reorderConditions', () => {
-    it('reorders types before default when default comes first', () => {
-      const input = {
-        './foo': {
-          default: './dist/foo.js',
-          types: './dist/foo.d.ts',
-        },
-      };
-
-      const result = reorderConditions(input);
-
-      expect(Object.keys(result['./foo'] as Record<string, unknown>)).toEqual(['types', 'default']);
-    });
-
-    it('does not modify when types already comes before default', () => {
-      const input = {
-        './foo': {
-          default: './dist/foo.js',
-          types: './dist/foo.d.ts',
-        },
-      };
-
-      const result = reorderConditions(input);
-
-      expect(Object.keys(result['./foo'] as Record<string, unknown>)).toEqual(['types', 'default']);
-    });
-
-    it('handles multiple exports with mixed order', () => {
-      const input = {
-        './a': { default: './dist/a.js', types: './dist/a.d.ts' },
-        './b': { default: './dist/b.js', types: './dist/b.d.ts' },
-      };
-
-      const result = reorderConditions(input);
-
-      expect(Object.keys(result['./a'] as Record<string, unknown>)[0]).toBe('types');
-      expect(Object.keys(result['./b'] as Record<string, unknown>)[0]).toBe('types');
-    });
-
-    it('preserves other keys after types', () => {
-      const input = {
-        './foo': {
-          default: './dist/foo.js',
-          import: './dist/foo.mjs',
-          require: './dist/foo.cjs',
-          types: './dist/foo.d.ts',
-        },
-      };
-
-      const result = reorderConditions(input);
-      const keys = Object.keys(result['./foo'] as Record<string, unknown>);
-
-      expect(keys[0]).toBe('types');
-      expect(keys.slice(1)).toEqual(['default', 'import', 'require']);
-    });
-
-    it('handles exports without types or default', () => {
-      const input = { './styles.css': './dist/styles.css' };
-
-      expect(reorderConditions(input)).toEqual(input);
-    });
-
-    it('handles deeply nested condition objects', () => {
-      const input = {
-        './foo': {
-          browser: { default: './dist/foo.browser.js', types: './dist/foo.browser.d.ts' },
-          node: { default: './dist/foo.node.js', types: './dist/foo.node.d.ts' },
-        },
-      };
-
-      const result = reorderConditions(input);
-      const foo = result['./foo'] as Record<string, Record<string, unknown>>;
-
-      expect(Object.keys(foo.node as object)[0]).toBe('types');
-      expect(Object.keys(foo.browser as object)[0]).toBe('types');
-    });
-  });
-});

package/src/bin/lint/package.ts

@@ -1,108 +0,0 @@
-#!/usr/bin/env node
-/**
- * Sorts package.json files using sort-package-json and fixes
- * exports condition order (types must come before default for TypeScript).
- */
-import { execSync } from 'node:child_process';
-import { existsSync, readFileSync, writeFileSync } from 'node:fs';
-import { dirname, join, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-/**
- * Recursively reorder exports condition objects so that `types` always
- * appears before `default`. Returns a new object; does not mutate input.
- */
-export function reorderConditions(obj: Record<string, unknown>): Record<string, unknown> {
-  if (typeof obj !== 'object' || obj === null) return obj;
-
-  const processed: Record<string, unknown> = {};
-  for (const [key, value] of Object.entries(obj)) {
-    processed[key] =
-      typeof value === 'object' && value !== null && !Array.isArray(value)
-        ? reorderConditions(value as Record<string, unknown>)
-        : value;
-  }
-
-  if ('types' in processed && 'default' in processed) {
-    const keys = Object.keys(processed);
-    if (keys.indexOf('default') < keys.indexOf('types')) {
-      const reordered: Record<string, unknown> = { types: processed.types };
-      for (const key of keys) {
-        if (key !== 'types') reordered[key] = processed[key];
-      }
-      return reordered;
-    }
-  }
-
-  return processed;
-}
-
-/**
- * Fix exports condition order in a package.json file.
- * Returns true if the file needs changes (or was changed when fix=true).
- */
-export function fixExportsOrder(filePath: string, fix: boolean): boolean {
-  const fullPath = resolve(process.cwd(), filePath);
-  if (!existsSync(fullPath)) return false;
-
-  const content = readFileSync(fullPath, 'utf-8');
-  const pkg = JSON.parse(content) as Record<string, unknown>;
-
-  if (!pkg.exports || typeof pkg.exports !== 'object') return false;
-
-  const fixed = reorderConditions(pkg.exports as Record<string, unknown>);
-  const changed = JSON.stringify(fixed) !== JSON.stringify(pkg.exports);
-
-  if (changed && fix) {
-    writeFileSync(fullPath, `${JSON.stringify({ ...pkg, exports: fixed }, null, 2)}\n`);
-  }
-
-  return changed;
-}
-
-// ---------------------------------------------------------------------------
-// CLI entry point — only runs when executed directly
-// ---------------------------------------------------------------------------
-if (fileURLToPath(import.meta.url) === resolve(process.argv[1] ?? '')) {
-  const __dirname = dirname(fileURLToPath(import.meta.url));
-  const devRoot = resolve(__dirname, '../../..');
-
-  const sortPkgBin = join(devRoot, 'node_modules/.bin/sort-package-json');
-  const sortPkgBinAlt = join(devRoot, 'node_modules/sort-package-json/cli.js');
-
-  let bin = '';
-  if (existsSync(sortPkgBin)) {
-    bin = sortPkgBin;
-  } else if (existsSync(sortPkgBinAlt)) {
-    bin = `node ${sortPkgBinAlt}`;
-  } else {
-    bin = 'npx sort-package-json';
-  }
-
-  const args = process.argv.slice(2);
-  const fixMode = args.includes('--fix');
-  const files = args.filter((arg) => arg !== '--fix');
-  const targets = files.length > 0 ? files : ['package.json'];
-
-  try {
-    const checkFlag = fixMode ? '' : '--check';
-    execSync(`${bin} ${checkFlag} ${targets.join(' ')}`.trim(), { stdio: 'inherit' });
-  } catch {
-    process.exit(1);
-  }
-
-  let hasExportsIssues = false;
-  for (const file of targets) {
-    const needsFix = fixExportsOrder(file, fixMode);
-    if (needsFix && !fixMode) {
-      console.error(
-        `${file}: exports condition order is incorrect (types must come before default)`,
-      );
-      hasExportsIssues = true;
-    }
-  }
-
-  if (hasExportsIssues) {
-    process.exit(1);
-  }
-}

package/src/bin/ship/hotfix.ts

@@ -1,241 +0,0 @@
-#!/usr/bin/env node
-/**
- * ship-hotfix: Manage hotfix branches based on production code.
- *
- * Usage:
- *   ship-hotfix start <name>                        - Create hotfix/<name> from production
- *   ship-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 { execSync } from 'node:child_process';
-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: ship-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: ship-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: ship-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: ship-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 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
-  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('  ship-hotfix start <name>');
-console.error('  ship-hotfix finish <patch|minor> "description"');
-process.exit(1);