gh-setup-git-identity 0.2.0

package/src/index.js

@@ -0,0 +1,312 @@
+#!/usr/bin/env node
+
+/**
+ * gh-setup-git-identity - Core library for setting up git identity
+ *
+ * This library provides functionality to:
+ * - Check if GitHub CLI is authenticated
+ * - Get GitHub user information (username and email)
+ * - Configure git user.name and user.email
+ */
+
+import { spawn } from 'node:child_process';
+import makeLog from 'log-lazy';
+
+/**
+ * Create a logger instance
+ * This can be customized by users when using the library
+ */
+function createDefaultLogger(options = {}) {
+  const { verbose = false, logger = console } = options;
+
+  const log = makeLog({
+    level: verbose ? 'development' : 'info',
+    log: {
+      fatal: logger.error || logger.log,
+      error: logger.error || logger.log,
+      warn: logger.warn || logger.log,
+      info: logger.log,
+      debug: logger.debug || logger.log,
+      verbose: logger.log,
+      trace: logger.log,
+      silly: logger.log
+    }
+  });
+
+  return log;
+}
+
+/**
+ * Execute a command and return the result
+ *
+ * @param {string} command - The command to execute
+ * @param {string[]} args - The command arguments
+ * @returns {Promise<{stdout: string, stderr: string, exitCode: number}>}
+ */
+function execCommand(command, args = []) {
+  return new Promise((resolve) => {
+    const child = spawn(command, args, { stdio: 'pipe', shell: false });
+
+    let stdout = '';
+    let stderr = '';
+
+    child.stdout.on('data', (data) => {
+      stdout += data.toString();
+    });
+
+    child.stderr.on('data', (data) => {
+      stderr += data.toString();
+    });
+
+    child.on('close', (exitCode) => {
+      resolve({
+        stdout: stdout.trim(),
+        stderr: stderr.trim(),
+        exitCode: exitCode || 0
+      });
+    });
+
+    child.on('error', (error) => {
+      resolve({
+        stdout: stdout.trim(),
+        stderr: error.message,
+        exitCode: 1
+      });
+    });
+  });
+}
+
+/**
+ * Check if GitHub CLI is authenticated
+ *
+ * @param {Object} options - Options
+ * @param {boolean} options.verbose - Enable verbose logging
+ * @param {Object} options.logger - Custom logger
+ * @returns {Promise<boolean>} True if authenticated
+ */
+export async function isGhAuthenticated(options = {}) {
+  const { verbose = false, logger = console } = options;
+  const log = createDefaultLogger({ verbose, logger });
+
+  log.debug(() => 'Checking GitHub CLI authentication status...');
+
+  const result = await execCommand('gh', ['auth', 'status']);
+
+  if (result.exitCode !== 0) {
+    log.debug(() => `GitHub CLI is not authenticated: ${result.stderr}`);
+    return false;
+  }
+
+  log.debug(() => 'GitHub CLI is authenticated');
+  return true;
+}
+
+/**
+ * Get GitHub username from authenticated user
+ *
+ * @param {Object} options - Options
+ * @param {boolean} options.verbose - Enable verbose logging
+ * @param {Object} options.logger - Custom logger
+ * @returns {Promise<string>} GitHub username
+ */
+export async function getGitHubUsername(options = {}) {
+  const { verbose = false, logger = console } = options;
+  const log = createDefaultLogger({ verbose, logger });
+
+  log.debug(() => 'Getting GitHub username...');
+
+  const result = await execCommand('gh', ['api', 'user', '--jq', '.login']);
+
+  if (result.exitCode !== 0) {
+    throw new Error(`Failed to get GitHub username: ${result.stderr}`);
+  }
+
+  const username = result.stdout;
+  log.debug(() => `GitHub username: ${username}`);
+
+  return username;
+}
+
+/**
+ * Get primary email from GitHub user
+ *
+ * @param {Object} options - Options
+ * @param {boolean} options.verbose - Enable verbose logging
+ * @param {Object} options.logger - Custom logger
+ * @returns {Promise<string>} Primary email address
+ */
+export async function getGitHubEmail(options = {}) {
+  const { verbose = false, logger = console } = options;
+  const log = createDefaultLogger({ verbose, logger });
+
+  log.debug(() => 'Getting GitHub primary email...');
+
+  const result = await execCommand('gh', ['api', 'user/emails', '--jq', '.[] | select(.primary==true) | .email']);
+
+  if (result.exitCode !== 0) {
+    throw new Error(`Failed to get GitHub email: ${result.stderr}`);
+  }
+
+  const email = result.stdout;
+
+  if (!email) {
+    throw new Error('No primary email found on GitHub account. Please set a primary email in your GitHub settings.');
+  }
+
+  log.debug(() => `GitHub primary email: ${email}`);
+
+  return email;
+}
+
+/**
+ * Get GitHub user information (username and primary email)
+ *
+ * @param {Object} options - Options
+ * @param {boolean} options.verbose - Enable verbose logging
+ * @param {Object} options.logger - Custom logger
+ * @returns {Promise<{username: string, email: string}>} User information
+ */
+export async function getGitHubUserInfo(options = {}) {
+  const [username, email] = await Promise.all([
+    getGitHubUsername(options),
+    getGitHubEmail(options)
+  ]);
+
+  return { username, email };
+}
+
+/**
+ * Set git config value
+ *
+ * @param {string} key - Config key (e.g., 'user.name')
+ * @param {string} value - Config value
+ * @param {Object} options - Options
+ * @param {string} options.scope - 'global' or 'local' (default: 'global')
+ * @param {boolean} options.verbose - Enable verbose logging
+ * @param {Object} options.logger - Custom logger
+ * @returns {Promise<void>}
+ */
+export async function setGitConfig(key, value, options = {}) {
+  const { scope = 'global', verbose = false, logger = console } = options;
+  const log = createDefaultLogger({ verbose, logger });
+
+  const scopeFlag = scope === 'local' ? '--local' : '--global';
+
+  log.debug(() => `Setting git config ${key} = ${value} (${scope})`);
+
+  const result = await execCommand('git', ['config', scopeFlag, key, value]);
+
+  if (result.exitCode !== 0) {
+    throw new Error(`Failed to set git config ${key}: ${result.stderr}`);
+  }
+
+  log.debug(() => `Successfully set git config ${key}`);
+}
+
+/**
+ * Get git config value
+ *
+ * @param {string} key - Config key (e.g., 'user.name')
+ * @param {Object} options - Options
+ * @param {string} options.scope - 'global' or 'local' (default: 'global')
+ * @param {boolean} options.verbose - Enable verbose logging
+ * @param {Object} options.logger - Custom logger
+ * @returns {Promise<string|null>} Config value or null if not set
+ */
+export async function getGitConfig(key, options = {}) {
+  const { scope = 'global', verbose = false, logger = console } = options;
+  const log = createDefaultLogger({ verbose, logger });
+
+  const scopeFlag = scope === 'local' ? '--local' : '--global';
+
+  log.debug(() => `Getting git config ${key} (${scope})`);
+
+  const result = await execCommand('git', ['config', scopeFlag, key]);
+
+  if (result.exitCode !== 0) {
+    log.debug(() => `Git config ${key} not set`);
+    return null;
+  }
+
+  const value = result.stdout;
+  log.debug(() => `Git config ${key} = ${value}`);
+
+  return value;
+}
+
+/**
+ * Setup git identity based on GitHub user
+ *
+ * @param {Object} options - Options
+ * @param {string} options.scope - 'global' or 'local' (default: 'global')
+ * @param {boolean} options.dryRun - Dry run mode (default: false)
+ * @param {boolean} options.verbose - Enable verbose logging (default: false)
+ * @param {Object} options.logger - Custom logger (default: console)
+ * @returns {Promise<{username: string, email: string}>} Configured identity
+ */
+export async function setupGitIdentity(options = {}) {
+  const {
+    scope = 'global',
+    dryRun = false,
+    verbose = false,
+    logger = console
+  } = options;
+
+  const log = createDefaultLogger({ verbose, logger });
+
+  log(() => 'Fetching GitHub user information...');
+
+  // Get GitHub user info
+  const { username, email } = await getGitHubUserInfo({ verbose, logger });
+
+  log(() => `GitHub user: ${username}`);
+  log(() => `GitHub email: ${email}`);
+
+  if (dryRun) {
+    log(() => '');
+    log(() => 'DRY MODE: Would configure the following:');
+    log(() => `  git config --${scope} user.name "${username}"`);
+    log(() => `  git config --${scope} user.email "${email}"`);
+    return { username, email };
+  }
+
+  // Set git config
+  log(() => '');
+  log(() => `Configuring git (${scope})...`);
+
+  await setGitConfig('user.name', username, { scope, verbose, logger });
+  await setGitConfig('user.email', email, { scope, verbose, logger });
+
+  log(() => 'Git identity configured successfully!');
+
+  return { username, email };
+}
+
+/**
+ * Verify git identity is configured correctly
+ *
+ * @param {Object} options - Options
+ * @param {string} options.scope - 'global' or 'local' (default: 'global')
+ * @param {boolean} options.verbose - Enable verbose logging
+ * @param {Object} options.logger - Custom logger
+ * @returns {Promise<{username: string|null, email: string|null}>} Current git identity
+ */
+export async function verifyGitIdentity(options = {}) {
+  const { scope = 'global', verbose = false, logger = console } = options;
+
+  const username = await getGitConfig('user.name', { scope, verbose, logger });
+  const email = await getGitConfig('user.email', { scope, verbose, logger });
+
+  return { username, email };
+}
+
+export default {
+  isGhAuthenticated,
+  getGitHubUsername,
+  getGitHubEmail,
+  getGitHubUserInfo,
+  setGitConfig,
+  getGitConfig,
+  setupGitIdentity,
+  verifyGitIdentity
+};

package/test/index.test.js

@@ -0,0 +1,114 @@
+/**
+ * Tests for gh-setup-git-identity core library
+ */
+
+import { test, assert } from 'test-anywhere';
+import {
+  isGhAuthenticated,
+  getGitHubUsername,
+  getGitHubEmail,
+  getGitHubUserInfo,
+  getGitConfig,
+  verifyGitIdentity
+} from '../src/index.js';
+
+// Note: These tests require gh to be authenticated
+// In CI, we may skip integration tests that require auth
+
+// Helper to create a silent logger for tests
+const silentLogger = {
+  log: () => {},
+  error: () => {},
+  warn: () => {},
+  debug: () => {}
+};
+
+// Test: isGhAuthenticated function exists and returns boolean
+test('isGhAuthenticated - returns a boolean', async () => {
+  const result = await isGhAuthenticated({ logger: silentLogger });
+  assert.equal(typeof result, 'boolean');
+});
+
+// Test: getGitConfig function exists
+test('getGitConfig - returns string or null', async () => {
+  const result = await getGitConfig('user.name', { logger: silentLogger });
+  assert.ok(result === null || typeof result === 'string');
+});
+
+// Test: verifyGitIdentity function exists and returns object
+test('verifyGitIdentity - returns object with username and email', async () => {
+  const result = await verifyGitIdentity({ logger: silentLogger });
+  assert.ok(typeof result === 'object');
+  assert.ok('username' in result);
+  assert.ok('email' in result);
+});
+
+// Integration tests - only run if authenticated
+test('getGitHubUsername - returns username when authenticated', async () => {
+  const isAuth = await isGhAuthenticated({ logger: silentLogger });
+  if (!isAuth) {
+    console.log('Skipping test: gh not authenticated');
+    return;
+  }
+
+  const username = await getGitHubUsername({ logger: silentLogger });
+  assert.ok(typeof username === 'string');
+  assert.ok(username.length > 0);
+});
+
+test('getGitHubEmail - returns email when authenticated', async () => {
+  const isAuth = await isGhAuthenticated({ logger: silentLogger });
+  if (!isAuth) {
+    console.log('Skipping test: gh not authenticated');
+    return;
+  }
+
+  const email = await getGitHubEmail({ logger: silentLogger });
+  assert.ok(typeof email === 'string');
+  assert.ok(email.includes('@'));
+});
+
+test('getGitHubUserInfo - returns user info when authenticated', async () => {
+  const isAuth = await isGhAuthenticated({ logger: silentLogger });
+  if (!isAuth) {
+    console.log('Skipping test: gh not authenticated');
+    return;
+  }
+
+  const info = await getGitHubUserInfo({ logger: silentLogger });
+  assert.ok(typeof info === 'object');
+  assert.ok(typeof info.username === 'string');
+  assert.ok(typeof info.email === 'string');
+  assert.ok(info.username.length > 0);
+  assert.ok(info.email.includes('@'));
+});
+
+// Test: module exports
+test('module exports all expected functions', async () => {
+  const module = await import('../src/index.js');
+
+  assert.ok(typeof module.isGhAuthenticated === 'function');
+  assert.ok(typeof module.getGitHubUsername === 'function');
+  assert.ok(typeof module.getGitHubEmail === 'function');
+  assert.ok(typeof module.getGitHubUserInfo === 'function');
+  assert.ok(typeof module.setGitConfig === 'function');
+  assert.ok(typeof module.getGitConfig === 'function');
+  assert.ok(typeof module.setupGitIdentity === 'function');
+  assert.ok(typeof module.verifyGitIdentity === 'function');
+});
+
+// Test: default export
+test('default export contains all functions', async () => {
+  const module = await import('../src/index.js');
+  const defaultExport = module.default;
+
+  assert.ok(typeof defaultExport === 'object');
+  assert.ok(typeof defaultExport.isGhAuthenticated === 'function');
+  assert.ok(typeof defaultExport.getGitHubUsername === 'function');
+  assert.ok(typeof defaultExport.getGitHubEmail === 'function');
+  assert.ok(typeof defaultExport.getGitHubUserInfo === 'function');
+  assert.ok(typeof defaultExport.setGitConfig === 'function');
+  assert.ok(typeof defaultExport.getGitConfig === 'function');
+  assert.ok(typeof defaultExport.setupGitIdentity === 'function');
+  assert.ok(typeof defaultExport.verifyGitIdentity === 'function');
+});