glab-setup-git-identity 0.6.0

package/scripts/version-and-commit.mjs

@@ -0,0 +1,284 @@
+#!/usr/bin/env bun
+
+/**
+ * Version packages and commit to main
+ * Usage: node scripts/version-and-commit.mjs --mode <changeset|instant> [--bump-type <type>] [--description <desc>] [--js-root <path>]
+ *   changeset: Run changeset version
+ *   instant: Run instant version bump with bump_type (patch|minor|major) and optional description
+ *
+ * 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, appendFileSync, readdirSync } from 'fs';
+
+import {
+  getJsRoot,
+  getPackageJsonPath,
+  getChangesetDir,
+  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('mode', {
+        type: 'string',
+        default: getenv('MODE', 'changeset'),
+        describe: 'Version mode: changeset or instant',
+        choices: ['changeset', 'instant'],
+      })
+      .option('bump-type', {
+        type: 'string',
+        default: getenv('BUMP_TYPE', ''),
+        describe: 'Version bump type for instant mode: major, minor, or patch',
+      })
+      .option('description', {
+        type: 'string',
+        default: getenv('DESCRIPTION', ''),
+        describe: 'Description for instant version bump',
+      })
+      .option('js-root', {
+        type: 'string',
+        default: getenv('JS_ROOT', ''),
+        describe:
+          'JavaScript package root directory (auto-detected if not specified)',
+      }),
+});
+
+const { mode, 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 });
+
+// Debug: Log parsed configuration
+console.log('Parsed configuration:', {
+  mode,
+  bumpType,
+  description: description || '(none)',
+  jsRoot,
+});
+
+// Detect if positional arguments were used (common mistake)
+const args = process.argv.slice(2);
+if (args.length > 0 && !args[0].startsWith('--')) {
+  console.error('Error: Positional arguments detected!');
+  console.error('Command line arguments:', args);
+  console.error('');
+  console.error(
+    'This script requires named arguments (--mode, --bump-type, --description, --js-root).'
+  );
+  console.error('Usage:');
+  console.error('  Changeset mode:');
+  console.error(
+    '    node scripts/version-and-commit.mjs --mode changeset [--js-root <path>]'
+  );
+  console.error('  Instant mode:');
+  console.error(
+    '    node scripts/version-and-commit.mjs --mode instant --bump-type <major|minor|patch> [--description <desc>] [--js-root <path>]'
+  );
+  console.error('');
+  console.error('Examples:');
+  console.error(
+    '  node scripts/version-and-commit.mjs --mode instant --bump-type patch --description "Fix bug"'
+  );
+  console.error('  node scripts/version-and-commit.mjs --mode changeset');
+  console.error(
+    '  node scripts/version-and-commit.mjs --mode changeset --js-root js'
+  );
+  process.exit(1);
+}
+
+// Validation: Ensure mode is set correctly
+if (mode !== 'changeset' && mode !== 'instant') {
+  console.error(`Invalid mode: "${mode}". Expected "changeset" or "instant".`);
+  console.error('Command line arguments:', process.argv.slice(2));
+  process.exit(1);
+}
+
+// Validation: Ensure bump type is provided for instant mode
+if (mode === 'instant' && !bumpType) {
+  console.error('Error: --bump-type is required for instant mode');
+  console.error(
+    'Usage: node scripts/version-and-commit.mjs --mode instant --bump-type <major|minor|patch> [--description <desc>] [--js-root <path>]'
+  );
+  process.exit(1);
+}
+
+// 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();
+
+/**
+ * Append to GitHub Actions output file
+ * @param {string} key
+ * @param {string} value
+ */
+function setOutput(key, value) {
+  const outputFile = process.env.GITHUB_OUTPUT;
+  if (outputFile) {
+    appendFileSync(outputFile, `${key}=${value}\n`);
+  }
+}
+
+/**
+ * Count changeset files (excluding README.md)
+ */
+function countChangesets() {
+  try {
+    const changesetDir = getChangesetDir({ jsRoot });
+    const files = readdirSync(changesetDir);
+    return files.filter((f) => f.endsWith('.md') && f !== 'README.md').length;
+  } catch {
+    return 0;
+  }
+}
+
+/**
+ * Get package version
+ * @param {string} source - 'local' or 'remote'
+ */
+async function getVersion(source = 'local') {
+  const packageJsonPath = getPackageJsonPath({ jsRoot });
+  if (source === 'remote') {
+    const result = await $`git show origin/main:${packageJsonPath}`.run({
+      capture: true,
+    });
+    return JSON.parse(result.stdout).version;
+  }
+  return JSON.parse(readFileSync(packageJsonPath, 'utf8')).version;
+}
+
+async function main() {
+  try {
+    // Configure git
+    await $`git config user.name "github-actions[bot]"`;
+    await $`git config user.email "github-actions[bot]@users.noreply.github.com"`;
+
+    // Check if remote main has advanced (handles re-runs after partial success)
+    console.log('Checking for remote changes...');
+    await $`git fetch origin main`;
+
+    const localHeadResult = await $`git rev-parse HEAD`.run({ capture: true });
+    const localHead = localHeadResult.stdout.trim();
+
+    const remoteHeadResult = await $`git rev-parse origin/main`.run({
+      capture: true,
+    });
+    const remoteHead = remoteHeadResult.stdout.trim();
+
+    if (localHead !== remoteHead) {
+      console.log(
+        `Remote main has advanced (local: ${localHead}, remote: ${remoteHead})`
+      );
+      console.log('This may indicate a previous attempt partially succeeded.');
+
+      // Check if the remote version is already the expected bump
+      const remoteVersion = await getVersion('remote');
+      console.log(`Remote version: ${remoteVersion}`);
+
+      // Check if there are changesets to process
+      const changesetCount = countChangesets();
+
+      if (changesetCount === 0) {
+        console.log('No changesets to process and remote has advanced.');
+        console.log(
+          'Assuming version bump was already completed in a previous attempt.'
+        );
+        setOutput('version_committed', 'false');
+        setOutput('already_released', 'true');
+        setOutput('new_version', remoteVersion);
+        return;
+      } else {
+        console.log('Rebasing on remote main to incorporate changes...');
+        await $`git rebase origin/main`;
+      }
+    }
+
+    // Get current version before bump
+    const oldVersion = await getVersion();
+    console.log(`Current version: ${oldVersion}`);
+
+    if (mode === 'instant') {
+      console.log('Running instant version bump...');
+      // Run instant version bump script
+      // Pass --js-root to ensure consistent path handling
+      // Rely on command-stream's auto-quoting for proper argument handling
+      if (description) {
+        await $`node scripts/instant-version-bump.mjs --bump-type ${bumpType} --description ${description} --js-root ${jsRoot}`;
+      } else {
+        await $`node scripts/instant-version-bump.mjs --bump-type ${bumpType} --js-root ${jsRoot}`;
+      }
+    } else {
+      console.log('Running changeset version...');
+      // Run changeset version to bump versions and update CHANGELOG
+      // IMPORTANT: cd is a virtual command that calls process.chdir(), so we restore after
+      if (needsCd({ jsRoot })) {
+        await $`cd ${jsRoot} && npm run changeset:version`;
+        process.chdir(originalCwd);
+      } else {
+        await $`npm run changeset:version`;
+      }
+    }
+
+    // Get new version after bump
+    const newVersion = await getVersion();
+    console.log(`New version: ${newVersion}`);
+    setOutput('new_version', newVersion);
+
+    // Check if there are changes to commit
+    const statusResult = await $`git status --porcelain`.run({ capture: true });
+    const status = statusResult.stdout.trim();
+
+    if (status) {
+      console.log('Changes detected, committing...');
+
+      // Stage all changes (package.json, package-lock.json, CHANGELOG.md, deleted changesets)
+      await $`git add -A`;
+
+      // Commit with version number as message
+      const commitMessage = newVersion;
+      const escapedMessage = commitMessage.replace(/"/g, '\\"');
+      await $`git commit -m "${escapedMessage}"`;
+
+      // Push directly to main
+      await $`git push origin main`;
+
+      console.log('\u2705 Version bump committed and pushed to main');
+      setOutput('version_committed', 'true');
+    } else {
+      console.log('No changes to commit');
+      setOutput('version_committed', 'false');
+    }
+  } catch (error) {
+    // Restore cwd on error
+    process.chdir(originalCwd);
+    console.error('Error:', error.message);
+    process.exit(1);
+  }
+}
+
+main();

package/src/cli.js

@@ -0,0 +1,386 @@
+#!/usr/bin/env node
+
+/**
+ * glab-setup-git-identity CLI
+ *
+ * Command-line interface for setting up git identity based on GitLab user
+ */
+
+import { makeConfig } from 'lino-arguments';
+import {
+  setupGitIdentity,
+  isGlabAuthenticated,
+  runGlabAuthLogin,
+  runGlabAuthSetupGit,
+  verifyGitIdentity,
+  defaultAuthOptions,
+} from './index.js';
+import { $ } from 'command-stream';
+
+// Parse command-line arguments with environment variable and .lenv support
+const config = makeConfig({
+  yargs: ({ yargs, getenv }) =>
+    yargs
+      .usage('Usage: $0 [options]')
+      // Git identity options
+      .option('global', {
+        alias: 'g',
+        type: 'boolean',
+        description: 'Set git config globally (default)',
+        default: false,
+      })
+      .option('local', {
+        alias: 'l',
+        type: 'boolean',
+        description: 'Set git config locally (in current repository)',
+        default: getenv('GLAB_SETUP_GIT_IDENTITY_LOCAL', false),
+      })
+      .option('verbose', {
+        alias: 'v',
+        type: 'boolean',
+        description: 'Enable verbose output',
+        default: getenv('GLAB_SETUP_GIT_IDENTITY_VERBOSE', false),
+      })
+      .option('dry-run', {
+        alias: 'dry',
+        type: 'boolean',
+        description:
+          'Dry run mode - show what would be done without making changes',
+        default: getenv('GLAB_SETUP_GIT_IDENTITY_DRY_RUN', false),
+      })
+      .option('verify', {
+        type: 'boolean',
+        description: 'Verify current git identity configuration',
+        default: false,
+      })
+      // glab auth login options
+      .option('hostname', {
+        type: 'string',
+        description: 'GitLab hostname to authenticate with',
+        default: getenv('GLAB_AUTH_HOSTNAME', defaultAuthOptions.hostname),
+      })
+      .option('token', {
+        alias: 't',
+        type: 'string',
+        description: 'GitLab access token',
+        default: getenv('GLAB_AUTH_TOKEN', undefined),
+      })
+      .option('stdin', {
+        type: 'boolean',
+        description: 'Read token from standard input',
+        default: false,
+      })
+      .option('git-protocol', {
+        alias: 'p',
+        type: 'string',
+        description: 'Protocol for git operations: ssh, https, or http',
+        choices: ['ssh', 'https', 'http'],
+        default: getenv(
+          'GLAB_AUTH_GIT_PROTOCOL',
+          defaultAuthOptions.gitProtocol
+        ),
+      })
+      .option('api-protocol', {
+        type: 'string',
+        description: 'Protocol for API calls: https or http',
+        choices: ['https', 'http'],
+        default: getenv(
+          'GLAB_AUTH_API_PROTOCOL',
+          defaultAuthOptions.apiProtocol
+        ),
+      })
+      .option('api-host', {
+        type: 'string',
+        description: 'Custom API host URL',
+        default: getenv('GLAB_AUTH_API_HOST', undefined),
+      })
+      .option('use-keyring', {
+        type: 'boolean',
+        description: 'Store token in system keyring',
+        default: getenv('GLAB_AUTH_USE_KEYRING', defaultAuthOptions.useKeyring),
+      })
+      .option('job-token', {
+        alias: 'j',
+        type: 'string',
+        description: 'CI job token for authentication',
+        default: getenv('GLAB_AUTH_JOB_TOKEN', undefined),
+      })
+      .check((argv) => {
+        // --global and --local are mutually exclusive
+        if (argv.global && argv.local) {
+          throw new Error('Arguments global and local are mutually exclusive');
+        }
+        // --token and --stdin are mutually exclusive
+        if (argv.token && argv.stdin) {
+          throw new Error('Arguments token and stdin are mutually exclusive');
+        }
+        // --token and --job-token are mutually exclusive
+        if (argv.token && argv.jobToken) {
+          throw new Error(
+            'Arguments token and job-token are mutually exclusive'
+          );
+        }
+        return true;
+      })
+      .example('$0', 'Setup git identity globally using GitLab user')
+      .example('$0 --local', 'Setup git identity for current repository only')
+      .example(
+        '$0 --dry-run',
+        'Show what would be configured without making changes'
+      )
+      .example('$0 --verify', 'Verify current git identity configuration')
+      .example(
+        '$0 --hostname gitlab.company.com',
+        'Authenticate with self-hosted GitLab'
+      )
+      .example('$0 --git-protocol ssh', 'Use SSH protocol for git operations')
+      .example(
+        'echo "$TOKEN" | $0 --stdin',
+        'Authenticate using token from stdin'
+      )
+      .example('$0 --token glpat-xxxxx', 'Authenticate using a token directly')
+      .example(
+        '$0 --job-token "$CI_JOB_TOKEN"',
+        'Authenticate using CI job token'
+      )
+      .help('h')
+      .alias('h', 'help')
+      .version()
+      .strict(),
+});
+
+/**
+ * Run verification commands and display results
+ * @param {string} scope - 'global' or 'local'
+ * @param {boolean} verbose - Enable verbose logging
+ */
+async function runVerify(scope, verbose) {
+  const scopeFlag = scope === 'local' ? '--local' : '--global';
+
+  console.log('Verifying git identity configuration...');
+  console.log('');
+
+  // 1. Run glab auth status
+  console.log('1. GitLab CLI authentication status:');
+  console.log('   $ glab auth status');
+  console.log('');
+
+  // Run glab auth status - use command-stream with inherited stdio for interactive output
+  try {
+    await $`glab auth status`.run({ mirror: { stdout: true, stderr: true } });
+  } catch {
+    // Continue even if not authenticated
+  }
+
+  console.log('');
+
+  // 2. Get git config user.name
+  console.log(`2. Git user.name (${scope}):`);
+  console.log(`   $ git config ${scopeFlag} user.name`);
+
+  const identity = await verifyGitIdentity({ scope, verbose });
+
+  if (identity.username) {
+    console.log(`   ${identity.username}`);
+  } else {
+    console.log('   (not set)');
+  }
+
+  console.log('');
+
+  // 3. Get git config user.email
+  console.log(`3. Git user.email (${scope}):`);
+  console.log(`   $ git config ${scopeFlag} user.email`);
+
+  if (identity.email) {
+    console.log(`   ${identity.email}`);
+  } else {
+    console.log('   (not set)');
+  }
+
+  console.log('');
+  console.log('Verification complete!');
+}
+
+/**
+ * Get auth options from CLI config
+ * @returns {Object} Auth options
+ */
+function getAuthOptions() {
+  return {
+    hostname: config.hostname,
+    token: config.token,
+    gitProtocol: config.gitProtocol,
+    apiProtocol: config.apiProtocol,
+    apiHost: config.apiHost,
+    useKeyring: config.useKeyring,
+    jobToken: config.jobToken,
+    stdin: config.stdin,
+    verbose: config.verbose,
+  };
+}
+
+/**
+ * Handle authentication flow
+ * @returns {Promise<boolean>} True if authentication succeeded or already authenticated
+ */
+async function ensureAuthenticated() {
+  const authenticated = await isGlabAuthenticated({
+    hostname: config.hostname,
+    verbose: config.verbose,
+  });
+
+  if (authenticated) {
+    return handleAlreadyAuthenticated();
+  }
+
+  return handleNotAuthenticated();
+}
+
+/**
+ * Handle case when already authenticated
+ * @returns {Promise<boolean>} True
+ */
+async function handleAlreadyAuthenticated() {
+  // Ensure git credential helper is configured
+  const setupGitSuccess = await runGlabAuthSetupGit({
+    hostname: config.hostname,
+    verbose: config.verbose,
+  });
+
+  if (!setupGitSuccess && config.verbose) {
+    console.log(
+      'Note: Git credential helper may not be configured. Consider running:'
+    );
+    console.log(
+      '  Configure manually or use --force option to overwrite existing config'
+    );
+  }
+
+  return true;
+}
+
+/**
+ * Handle case when not authenticated
+ * @returns {Promise<boolean>} True if login succeeded
+ */
+async function handleNotAuthenticated() {
+  console.log('GitLab CLI is not authenticated. Starting authentication...');
+  console.log('');
+
+  const loginSuccess = await runGlabAuthLogin(getAuthOptions());
+
+  if (!loginSuccess) {
+    console.log('');
+    console.log('Authentication failed. Please try running manually:');
+    console.log(
+      `  glab auth login --hostname ${config.hostname} --git-protocol ${config.gitProtocol}`
+    );
+    return false;
+  }
+
+  // Setup git credential helper after successful login
+  const setupGitSuccess = await runGlabAuthSetupGit({
+    hostname: config.hostname,
+    verbose: config.verbose,
+  });
+
+  if (!setupGitSuccess) {
+    console.log('');
+    console.log(
+      'Warning: Failed to setup git credential helper. HTTPS git operations may require manual authentication.'
+    );
+  }
+
+  return true;
+}
+
+/**
+ * Display the setup results
+ * @param {Object} result - Setup result with username and email
+ * @param {Object} options - Setup options
+ */
+function displayResults(result, options) {
+  const { scope, dryRun } = options;
+
+  console.log('');
+  console.log(`  ${dryRun ? '[DRY MODE] Would configure' : 'Git configured'}:`);
+  console.log(`    user.name:  ${result.username}`);
+  console.log(`    user.email: ${result.email}`);
+  console.log(
+    `  Scope: ${scope === 'global' ? 'global (--global)' : 'local (--local)'}`
+  );
+
+  if (!dryRun) {
+    console.log('');
+    console.log('Git identity setup complete!');
+    console.log('');
+    console.log('You can verify your configuration with:');
+    console.log('  glab auth status');
+    console.log(
+      `  git config ${scope === 'global' ? '--global' : '--local'} user.name`
+    );
+    console.log(
+      `  git config ${scope === 'global' ? '--global' : '--local'} user.email`
+    );
+  }
+}
+
+/**
+ * Main CLI function
+ */
+async function main() {
+  try {
+    const scope = config.local ? 'local' : 'global';
+
+    // Handle --verify mode
+    if (config.verify) {
+      await runVerify(scope, config.verbose);
+      process.exit(0);
+    }
+
+    // Ensure authenticated
+    const authSuccess = await ensureAuthenticated();
+    if (!authSuccess) {
+      process.exit(1);
+    }
+
+    // Prepare options
+    const options = {
+      hostname: config.hostname,
+      scope,
+      dryRun: config.dryRun,
+      verbose: config.verbose,
+    };
+
+    if (options.verbose) {
+      console.log('Options:', options);
+    }
+
+    if (options.dryRun) {
+      console.log('');
+      console.log('DRY MODE - No actual changes will be made');
+    }
+
+    // Setup git identity
+    const result = await setupGitIdentity(options);
+
+    // Display results
+    displayResults(result, options);
+
+    process.exit(0);
+  } catch (error) {
+    console.error('');
+    console.error('Error:', error.message);
+
+    if (config.verbose) {
+      console.error('Stack trace:');
+      console.error(error.stack);
+    }
+
+    process.exit(1);
+  }
+}
+
+// Run the CLI
+main();