glab-setup-git-identity 0.6.0

package/scripts/instant-version-bump.mjs

@@ -0,0 +1,172 @@
+#!/usr/bin/env bun
+
+/**
+ * Instant version bump script for manual releases
+ * Bypasses the changeset workflow and directly updates version and changelog
+ *
+ * Usage: node scripts/instant-version-bump.mjs --bump-type <major|minor|patch> [--description <description>] [--js-root <path>]
+ *
+ * Configuration:
+ * - CLI: --js-root <path> to explicitly set JavaScript root
+ * - Environment: JS_ROOT=<path>
+ *
+ * Uses link-foundation libraries:
+ * - use-m: Dynamic package loading without package.json dependencies
+ * - command-stream: Modern shell command execution with streaming support
+ * - lino-arguments: Unified configuration from CLI args, env vars, and .lenv files
+ *
+ * Addresses issues documented in:
+ * - Issue #21: Supporting both single and multi-language repository structures
+ * - Reference: link-assistant/agent PR #112 (--legacy-peer-deps fix)
+ * - Reference: link-assistant/agent PR #114 (configurable package root)
+ */
+
+import { readFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+
+import {
+  getJsRoot,
+  getPackageJsonPath,
+  needsCd,
+  parseJsRootConfig,
+} from './js-paths.mjs';
+
+// Load use-m dynamically
+const { use } = eval(
+  await (await fetch('https://unpkg.com/use-m/use.js')).text()
+);
+
+// Import link-foundation libraries
+const { $ } = await use('command-stream');
+const { makeConfig } = await use('lino-arguments');
+
+// Parse CLI arguments using lino-arguments
+const config = makeConfig({
+  yargs: ({ yargs, getenv }) =>
+    yargs
+      .option('bump-type', {
+        type: 'string',
+        default: getenv('BUMP_TYPE', ''),
+        describe: 'Version bump type: major, minor, or patch',
+        choices: ['major', 'minor', 'patch'],
+      })
+      .option('description', {
+        type: 'string',
+        default: getenv('DESCRIPTION', ''),
+        describe: 'Description for the version bump',
+      })
+      .option('js-root', {
+        type: 'string',
+        default: getenv('JS_ROOT', ''),
+        describe:
+          'JavaScript package root directory (auto-detected if not specified)',
+      }),
+});
+
+// Store the original working directory to restore after cd commands
+// IMPORTANT: command-stream's cd is a virtual command that calls process.chdir()
+const originalCwd = process.cwd();
+
+try {
+  const { bumpType, description, jsRoot: jsRootArg } = config;
+
+  // Get JavaScript package root (auto-detect or use explicit config)
+  const jsRootConfig = jsRootArg || parseJsRootConfig();
+  const jsRoot = getJsRoot({ jsRoot: jsRootConfig, verbose: true });
+
+  const finalDescription = description || `Manual ${bumpType} release`;
+
+  if (!bumpType || !['major', 'minor', 'patch'].includes(bumpType)) {
+    console.error(
+      'Usage: node scripts/instant-version-bump.mjs --bump-type <major|minor|patch> [--description <description>] [--js-root <path>]'
+    );
+    process.exit(1);
+  }
+
+  console.log(`\nBumping version (${bumpType})...`);
+
+  // Get current version
+  const packageJsonPath = getPackageJsonPath({ jsRoot });
+  const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+  const oldVersion = packageJson.version;
+  console.log(`Current version: ${oldVersion}`);
+
+  // Bump version using npm version (doesn't create git tag)
+  // IMPORTANT: cd is a virtual command that calls process.chdir(), so we restore after
+  if (needsCd({ jsRoot })) {
+    await $`cd ${jsRoot} && npm version ${bumpType} --no-git-tag-version`;
+    process.chdir(originalCwd);
+  } else {
+    await $`npm version ${bumpType} --no-git-tag-version`;
+  }
+
+  // Get new version
+  const updatedPackageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+  const newVersion = updatedPackageJson.version;
+  console.log(`New version: ${newVersion}`);
+
+  // Update CHANGELOG.md
+  console.log('\nUpdating CHANGELOG.md...');
+  const changelogPath =
+    jsRoot === '.' ? 'CHANGELOG.md' : join(jsRoot, 'CHANGELOG.md');
+  let changelog = readFileSync(changelogPath, 'utf-8');
+
+  // Create new changelog entry
+  const newEntry = `## ${newVersion}
+
+### ${bumpType.charAt(0).toUpperCase() + bumpType.slice(1)} Changes
+
+- ${finalDescription}
+
+`;
+
+  // Insert new entry after the first heading (# Changelog or similar)
+  // Look for the first ## heading and insert before it
+  const firstVersionMatch = changelog.match(/^## /m);
+
+  if (firstVersionMatch) {
+    const insertPosition = firstVersionMatch.index;
+    changelog =
+      changelog.slice(0, insertPosition) +
+      newEntry +
+      changelog.slice(insertPosition);
+  } else {
+    // If no version headings exist, append after the main heading
+    const mainHeadingMatch = changelog.match(/^# .+$/m);
+    if (mainHeadingMatch) {
+      const insertPosition =
+        mainHeadingMatch.index + mainHeadingMatch[0].length;
+      changelog = `${changelog.slice(0, insertPosition)}\n\n${newEntry}${changelog.slice(insertPosition)}`;
+    } else {
+      // If no headings at all, prepend
+      changelog = `${newEntry}\n${changelog}`;
+    }
+  }
+
+  writeFileSync(changelogPath, changelog, 'utf-8');
+  console.log('✅ CHANGELOG.md updated');
+
+  // Synchronize package-lock.json
+  console.log('\nSynchronizing package-lock.json...');
+
+  // Use --legacy-peer-deps to handle peer dependency conflicts
+  // This addresses npm ERESOLVE errors documented in issue #111 / PR #112
+  // IMPORTANT: cd is a virtual command that calls process.chdir(), so we restore after
+  if (needsCd({ jsRoot })) {
+    await $`cd ${jsRoot} && npm install --package-lock-only --legacy-peer-deps`;
+    process.chdir(originalCwd);
+  } else {
+    await $`npm install --package-lock-only --legacy-peer-deps`;
+  }
+
+  console.log('\n✅ Instant version bump complete');
+  console.log(`Version: ${oldVersion} → ${newVersion}`);
+} catch (error) {
+  // Restore cwd on error
+  process.chdir(originalCwd);
+  console.error('Error during instant version bump:', error.message);
+  if (process.env.DEBUG) {
+    console.error('Stack trace:', error.stack);
+  }
+  process.exit(1);
+}

package/scripts/js-paths.mjs

@@ -0,0 +1,177 @@
+#!/usr/bin/env node
+
+/**
+ * JavaScript package path detection utility
+ *
+ * Automatically detects the JavaScript package root for both:
+ * - Single-language repositories (package.json in root)
+ * - Multi-language repositories (package.json in js/ subfolder)
+ *
+ * This utility addresses the issues documented in:
+ * - Issue #21: Supporting both single and multi-language repository structures
+ * - Reference: link-assistant/agent PR #114
+ *
+ * Usage:
+ *   import { getJsRoot, getPackageJsonPath, getChangesetDir, needsCd } from './js-paths.mjs';
+ *
+ *   const jsRoot = getJsRoot();           // Returns 'js' or '.'
+ *   const pkgPath = getPackageJsonPath(); // Returns 'js/package.json' or './package.json'
+ *   const changesetDir = getChangesetDir(); // Returns 'js/.changeset' or './.changeset'
+ *
+ * Configuration:
+ *   - CLI: --js-root <path>
+ *   - Environment: JS_ROOT=<path>
+ */
+
+import { existsSync } from 'fs';
+import { join } from 'path';
+
+// Cache for detected paths (computed once per process)
+let cachedJsRoot = null;
+
+/**
+ * Detect JavaScript package root directory
+ * Checks in order:
+ * 1. ./package.json (single-language repo)
+ * 2. ./js/package.json (multi-language repo)
+ *
+ * @param {Object} options - Configuration options
+ * @param {string} [options.jsRoot] - Explicitly set JavaScript root (overrides auto-detection)
+ * @param {boolean} [options.verbose=false] - Log detection details
+ * @returns {string} The JavaScript root directory ('.' or 'js')
+ * @throws {Error} If no package.json is found in expected locations
+ */
+export function getJsRoot(options = {}) {
+  const { jsRoot: explicitRoot, verbose = false } = options;
+
+  // If explicitly configured, use that
+  if (explicitRoot !== undefined && explicitRoot !== '') {
+    if (verbose) {
+      console.log(
+        `Using explicitly configured JavaScript root: ${explicitRoot}`
+      );
+    }
+    return explicitRoot;
+  }
+
+  // Return cached value if already computed
+  if (cachedJsRoot !== null) {
+    return cachedJsRoot;
+  }
+
+  // Check for single-language repo (package.json in root)
+  if (existsSync('./package.json')) {
+    if (verbose) {
+      console.log('Detected single-language repository (package.json in root)');
+    }
+    cachedJsRoot = '.';
+    return cachedJsRoot;
+  }
+
+  // Check for multi-language repo (package.json in js/ subfolder)
+  if (existsSync('./js/package.json')) {
+    if (verbose) {
+      console.log('Detected multi-language repository (package.json in js/)');
+    }
+    cachedJsRoot = 'js';
+    return cachedJsRoot;
+  }
+
+  // No package.json found
+  throw new Error(
+    'Could not find package.json in expected locations.\n' +
+      'Searched in:\n' +
+      '  - ./package.json (single-language repository)\n' +
+      '  - ./js/package.json (multi-language repository)\n\n' +
+      'To fix this, either:\n' +
+      '  1. Run the script from the repository root\n' +
+      '  2. Explicitly configure the JavaScript root using --js-root option\n' +
+      '  3. Set the JS_ROOT environment variable'
+  );
+}
+
+/**
+ * Get the path to package.json
+ * @param {Object} options - Configuration options (passed to getJsRoot)
+ * @returns {string} Path to package.json
+ */
+export function getPackageJsonPath(options = {}) {
+  const jsRoot =
+    options.jsRoot !== undefined ? options.jsRoot : getJsRoot(options);
+  return jsRoot === '.' ? './package.json' : join(jsRoot, 'package.json');
+}
+
+/**
+ * Get the path to package-lock.json
+ * @param {Object} options - Configuration options (passed to getJsRoot)
+ * @returns {string} Path to package-lock.json
+ */
+export function getPackageLockPath(options = {}) {
+  const jsRoot =
+    options.jsRoot !== undefined ? options.jsRoot : getJsRoot(options);
+  return jsRoot === '.'
+    ? './package-lock.json'
+    : join(jsRoot, 'package-lock.json');
+}
+
+/**
+ * Get the path to .changeset directory
+ * @param {Object} options - Configuration options (passed to getJsRoot)
+ * @returns {string} Path to .changeset directory
+ */
+export function getChangesetDir(options = {}) {
+  const jsRoot =
+    options.jsRoot !== undefined ? options.jsRoot : getJsRoot(options);
+  return jsRoot === '.' ? './.changeset' : join(jsRoot, '.changeset');
+}
+
+/**
+ * Get the cd command prefix for running npm commands
+ * Returns empty string for single-language repos, 'cd js && ' for multi-language repos
+ * @param {Object} options - Configuration options (passed to getJsRoot)
+ * @returns {string} CD prefix for shell commands
+ */
+export function getCdPrefix(options = {}) {
+  const jsRoot =
+    options.jsRoot !== undefined ? options.jsRoot : getJsRoot(options);
+  return jsRoot === '.' ? '' : `cd ${jsRoot} && `;
+}
+
+/**
+ * Check if we need to change directory before running npm commands
+ * @param {Object} options - Configuration options (passed to getJsRoot)
+ * @returns {boolean} True if cd is needed
+ */
+export function needsCd(options = {}) {
+  const jsRoot =
+    options.jsRoot !== undefined ? options.jsRoot : getJsRoot(options);
+  return jsRoot !== '.';
+}
+
+/**
+ * Reset the cached JavaScript root (useful for testing)
+ */
+export function resetCache() {
+  cachedJsRoot = null;
+}
+
+/**
+ * Parse JavaScript root from CLI arguments or environment
+ * Supports --js-root argument and JS_ROOT environment variable
+ * @returns {string|undefined} Configured JavaScript root or undefined for auto-detection
+ */
+export function parseJsRootConfig() {
+  // Check CLI arguments
+  const args = process.argv.slice(2);
+  const jsRootIndex = args.indexOf('--js-root');
+  if (jsRootIndex >= 0 && args[jsRootIndex + 1]) {
+    return args[jsRootIndex + 1];
+  }
+
+  // Check environment variable
+  if (process.env.JS_ROOT) {
+    return process.env.JS_ROOT;
+  }
+
+  return undefined;
+}

package/scripts/merge-changesets.mjs

@@ -0,0 +1,263 @@
+#!/usr/bin/env bun
+
+/**
+ * Merge multiple changeset files into a single changeset
+ *
+ * Key behavior:
+ * - Combines all pending changesets into a single changeset file
+ * - Uses the highest version bump type (major > minor > patch)
+ * - Preserves all descriptions in chronological order (by file modification time)
+ * - Removes the individual changeset files after merging
+ * - Does nothing if there's only one or no changesets
+ *
+ * This script is run before `changeset version` to ensure a clean release
+ * even when multiple PRs have merged before a release cycle.
+ *
+ * IMPORTANT: Update the package name below to match your package.json
+ */
+
+import {
+  readdirSync,
+  readFileSync,
+  writeFileSync,
+  unlinkSync,
+  statSync,
+} from 'fs';
+import { join } from 'path';
+
+// TODO: Update this to match your package name in package.json
+const PACKAGE_NAME = 'glab-setup-git-identity';
+const CHANGESET_DIR = '.changeset';
+
+// Version bump type priority (higher number = higher priority)
+const BUMP_PRIORITY = {
+  patch: 1,
+  minor: 2,
+  major: 3,
+};
+
+/**
+ * Generate a random changeset file name (similar to what @changesets/cli does)
+ * @returns {string}
+ */
+function generateChangesetName() {
+  const adjectives = [
+    'bright',
+    'calm',
+    'cool',
+    'cyan',
+    'dark',
+    'fast',
+    'gold',
+    'good',
+    'green',
+    'happy',
+    'kind',
+    'loud',
+    'neat',
+    'nice',
+    'pink',
+    'proud',
+    'quick',
+    'red',
+    'rich',
+    'safe',
+    'shy',
+    'soft',
+    'sweet',
+    'tall',
+    'warm',
+    'wise',
+    'young',
+  ];
+  const nouns = [
+    'apple',
+    'bird',
+    'book',
+    'car',
+    'cat',
+    'cloud',
+    'desk',
+    'dog',
+    'door',
+    'fish',
+    'flower',
+    'frog',
+    'grass',
+    'house',
+    'key',
+    'lake',
+    'leaf',
+    'moon',
+    'mouse',
+    'owl',
+    'park',
+    'rain',
+    'river',
+    'rock',
+    'sea',
+    'star',
+    'sun',
+    'tree',
+    'wave',
+    'wind',
+  ];
+
+  const randomAdjective =
+    adjectives[Math.floor(Math.random() * adjectives.length)];
+  const randomNoun = nouns[Math.floor(Math.random() * nouns.length)];
+
+  return `${randomAdjective}-${randomNoun}`;
+}
+
+/**
+ * Parse a changeset file and extract its metadata
+ * @param {string} filePath
+ * @returns {{type: string, description: string, mtime: Date} | null}
+ */
+function parseChangeset(filePath) {
+  try {
+    const content = readFileSync(filePath, 'utf-8');
+    const stats = statSync(filePath);
+
+    // Extract version type - support both quoted and unquoted package names
+    const versionTypeRegex = new RegExp(
+      `^['"]?${PACKAGE_NAME.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}['"]?:\\s+(major|minor|patch)`,
+      'm'
+    );
+    const versionTypeMatch = content.match(versionTypeRegex);
+
+    if (!versionTypeMatch) {
+      console.warn(
+        `Warning: Could not parse version type from ${filePath}, skipping`
+      );
+      return null;
+    }
+
+    // Extract description
+    const parts = content.split('---');
+    const description =
+      parts.length >= 3 ? parts.slice(2).join('---').trim() : '';
+
+    return {
+      type: versionTypeMatch[1],
+      description,
+      mtime: stats.mtime,
+    };
+  } catch (error) {
+    console.warn(`Warning: Failed to parse ${filePath}: ${error.message}`);
+    return null;
+  }
+}
+
+/**
+ * Get the highest priority bump type
+ * @param {string[]} types
+ * @returns {string}
+ */
+function getHighestBumpType(types) {
+  let highest = 'patch';
+  for (const type of types) {
+    if (BUMP_PRIORITY[type] > BUMP_PRIORITY[highest]) {
+      highest = type;
+    }
+  }
+  return highest;
+}
+
+/**
+ * Create a merged changeset file
+ * @param {string} type
+ * @param {string[]} descriptions
+ * @returns {string}
+ */
+function createMergedChangeset(type, descriptions) {
+  const combinedDescription = descriptions.join('\n\n');
+
+  return `---
+'${PACKAGE_NAME}': ${type}
+---
+
+${combinedDescription}
+`;
+}
+
+function main() {
+  console.log('Checking for multiple changesets to merge...');
+
+  // Get all changeset files
+  const changesetFiles = readdirSync(CHANGESET_DIR).filter(
+    (file) => file.endsWith('.md') && file !== 'README.md'
+  );
+
+  console.log(`Found ${changesetFiles.length} changeset file(s)`);
+
+  // If 0 or 1 changesets, nothing to merge
+  if (changesetFiles.length <= 1) {
+    console.log('No merging needed (0 or 1 changeset found)');
+    return;
+  }
+
+  console.log('Multiple changesets found, merging...');
+  changesetFiles.forEach((file) => console.log(`  - ${file}`));
+
+  // Parse all changesets
+  const parsedChangesets = [];
+  for (const file of changesetFiles) {
+    const filePath = join(CHANGESET_DIR, file);
+    const parsed = parseChangeset(filePath);
+    if (parsed) {
+      parsedChangesets.push({
+        file,
+        filePath,
+        ...parsed,
+      });
+    }
+  }
+
+  if (parsedChangesets.length === 0) {
+    console.error('Error: No valid changesets could be parsed');
+    process.exit(1);
+  }
+
+  // Sort by modification time (oldest first) to preserve chronological order
+  parsedChangesets.sort((a, b) => a.mtime.getTime() - b.mtime.getTime());
+
+  // Determine the highest bump type
+  const bumpTypes = parsedChangesets.map((c) => c.type);
+  const highestBumpType = getHighestBumpType(bumpTypes);
+
+  console.log(`\nMerge summary:`);
+  console.log(`  Bump types found: ${[...new Set(bumpTypes)].join(', ')}`);
+  console.log(`  Using highest: ${highestBumpType}`);
+
+  // Collect descriptions in chronological order
+  const descriptions = parsedChangesets
+    .filter((c) => c.description)
+    .map((c) => c.description);
+
+  console.log(`  Descriptions to merge: ${descriptions.length}`);
+
+  // Create merged changeset content
+  const mergedContent = createMergedChangeset(highestBumpType, descriptions);
+
+  // Generate a unique name for the merged changeset
+  const mergedFileName = `merged-${generateChangesetName()}.md`;
+  const mergedFilePath = join(CHANGESET_DIR, mergedFileName);
+
+  // Write the merged changeset
+  writeFileSync(mergedFilePath, mergedContent);
+  console.log(`\nCreated merged changeset: ${mergedFileName}`);
+
+  // Remove the original changeset files
+  console.log('\nRemoving original changeset files:');
+  for (const changeset of parsedChangesets) {
+    unlinkSync(changeset.filePath);
+    console.log(`  Removed: ${changeset.file}`);
+  }
+
+  console.log('\nChangeset merge completed successfully');
+  console.log(`\nMerged changeset content:\n${mergedContent}`);
+}
+
+main();