@aaronshaf/ger 1.2.11 → 2.0.0

package/src/cli/commands/push.ts

@@ -0,0 +1,430 @@
+import { execSync, spawnSync } from 'node:child_process'
+import { Console, Effect } from 'effect'
+import chalk from 'chalk'
+import { ConfigService, type ConfigError, type ConfigServiceImpl } from '@/services/config'
+import {
+  CommitHookService,
+  NotGitRepoError,
+  type HookInstallError,
+  type MissingChangeIdError,
+  type CommitHookServiceImpl,
+} from '@/services/commit-hook'
+
+/** Help text for push command - exported to keep index.ts under line limit */
+export const PUSH_HELP_TEXT = `
+Examples:
+  # Basic push to auto-detected target branch
+  $ ger push
+
+  # Push to specific branch
+  $ ger push -b master
+  $ ger push --branch feature/foo
+
+  # With topic
+  $ ger push -t my-feature
+
+  # With reviewers (can be repeated)
+  $ ger push -r alice@example.com -r bob@example.com
+
+  # With CC
+  $ ger push --cc manager@example.com
+
+  # Work in progress
+  $ ger push --wip
+
+  # Mark ready for review
+  $ ger push --ready
+
+  # Add hashtag
+  $ ger push --hashtag bugfix
+
+  # Combine options
+  $ ger push -b master -t refactor-auth -r alice@example.com --wip
+
+  # Dry run (show what would be pushed)
+  $ ger push --dry-run
+
+Note:
+  - Auto-installs commit-msg hook if missing
+  - Auto-detects target branch from tracking branch or defaults to main/master
+  - Supports all standard Gerrit push options`
+
+export interface PushOptions {
+  branch?: string
+  topic?: string
+  reviewer?: string[]
+  cc?: string[]
+  wip?: boolean
+  ready?: boolean
+  hashtag?: string[]
+  private?: boolean
+  draft?: boolean
+  dryRun?: boolean
+}
+
+// Custom error for push-specific failures
+export class PushError extends Error {
+  readonly _tag = 'PushError'
+  constructor(message: string) {
+    super(message)
+    this.name = 'PushError'
+  }
+}
+
+export type PushErrors =
+  | ConfigError
+  | HookInstallError
+  | MissingChangeIdError
+  | NotGitRepoError
+  | PushError
+
+/** Basic email validation pattern */
+const EMAIL_PATTERN = /^[^\s@]+@[^\s@]+\.[^\s@]+$/
+
+/** Validate email addresses for reviewer/cc options */
+export const validateEmails = (emails: string[] | undefined, fieldName: string): void => {
+  if (!emails) return
+  for (const email of emails) {
+    if (!EMAIL_PATTERN.test(email)) {
+      throw new PushError(
+        `Invalid email address for ${fieldName}: "${email}"\n` + `Expected format: user@domain.com`,
+      )
+    }
+  }
+}
+
+// Get git remotes
+const getGitRemotes = (): Record<string, string> => {
+  try {
+    const output = execSync('git remote -v', { encoding: 'utf8' })
+    const remotes: Record<string, string> = {}
+
+    for (const line of output.split('\n')) {
+      const match = line.match(/^(\S+)\s+(\S+)\s+\(push\)$/)
+      if (match) {
+        remotes[match[1]] = match[2]
+      }
+    }
+
+    return remotes
+  } catch {
+    return {}
+  }
+}
+
+// Find remote matching Gerrit host
+const findMatchingRemote = (gerritHost: string): string | null => {
+  const remotes = getGitRemotes()
+
+  // Parse gerrit host
+  const gerritUrl = new URL(gerritHost)
+  const gerritHostname = gerritUrl.hostname
+
+  // Check each remote
+  for (const [name, url] of Object.entries(remotes)) {
+    try {
+      let remoteHostname: string
+
+      if (url.startsWith('git@') || url.includes('://')) {
+        if (url.startsWith('git@')) {
+          // SSH format: git@hostname:project
+          remoteHostname = url.split('@')[1].split(':')[0]
+        } else {
+          // HTTP format
+          const remoteUrl = new URL(url)
+          remoteHostname = remoteUrl.hostname
+        }
+
+        if (remoteHostname === gerritHostname) {
+          return name
+        }
+      }
+    } catch {
+      // Ignore malformed URLs
+    }
+  }
+
+  return null
+}
+
+// Check if we're in a git repo
+const isInGitRepo = (): boolean => {
+  try {
+    execSync('git rev-parse --git-dir', { encoding: 'utf8' })
+    return true
+  } catch {
+    return false
+  }
+}
+
+// Get current branch name
+const getCurrentBranch = (): string | null => {
+  try {
+    const branch = execSync('git symbolic-ref --short HEAD', { encoding: 'utf8' }).trim()
+    return branch || null
+  } catch {
+    return null
+  }
+}
+
+// Get tracking branch for current branch
+const getTrackingBranch = (): string | null => {
+  try {
+    // Get the upstream branch reference
+    const upstream = execSync('git rev-parse --abbrev-ref @{upstream}', {
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim()
+
+    // Extract branch name (remove remote prefix like "origin/")
+    const parts = upstream.split('/')
+    if (parts.length > 1) {
+      return parts.slice(1).join('/')
+    }
+    return upstream
+  } catch {
+    return null
+  }
+}
+
+// Check if a remote branch exists
+const remoteBranchExists = (remote: string, branch: string): boolean => {
+  try {
+    execSync(`git rev-parse --verify ${remote}/${branch}`, {
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+    })
+    return true
+  } catch {
+    return false
+  }
+}
+
+// Detect target branch with fallback strategy
+const detectTargetBranch = (remote: string): string => {
+  // 1. Try tracking branch
+  const tracking = getTrackingBranch()
+  if (tracking) {
+    return tracking
+  }
+
+  // 2. Check if origin/main exists
+  if (remoteBranchExists(remote, 'main')) {
+    return 'main'
+  }
+
+  // 3. Check if origin/master exists
+  if (remoteBranchExists(remote, 'master')) {
+    return 'master'
+  }
+
+  // 4. Final fallback
+  return 'master'
+}
+
+// Build Gerrit push refspec with options
+export const buildPushRefspec = (branch: string, options: PushOptions): string => {
+  let refspec = `refs/for/${branch}`
+  const params: string[] = []
+
+  if (options.topic) {
+    params.push(`topic=${encodeURIComponent(options.topic)}`)
+  }
+
+  // --draft is an alias for --wip; both map to Gerrit's 'wip' push option
+  if (options.wip || options.draft) {
+    params.push('wip')
+  }
+
+  if (options.ready) {
+    params.push('ready')
+  }
+
+  if (options.private) {
+    params.push('private')
+  }
+
+  if (options.reviewer) {
+    for (const reviewer of options.reviewer) {
+      params.push(`r=${reviewer}`)
+    }
+  }
+
+  if (options.cc) {
+    for (const cc of options.cc) {
+      params.push(`cc=${cc}`)
+    }
+  }
+
+  if (options.hashtag) {
+    for (const tag of options.hashtag) {
+      params.push(`hashtag=${encodeURIComponent(tag)}`)
+    }
+  }
+
+  if (params.length > 0) {
+    refspec += '%' + params.join(',')
+  }
+
+  return refspec
+}
+
+// Parse push output to extract change URL
+const extractChangeUrl = (output: string): string | null => {
+  // Gerrit push output format: "remote: https://gerrit.example.com/c/project/+/12345"
+  const urlMatch = output.match(/remote:\s+(https?:\/\/\S+\/c\/\S+\/\+\/\d+)/)
+  if (urlMatch) {
+    return urlMatch[1]
+  }
+
+  return null
+}
+
+export const pushCommand = (
+  options: PushOptions,
+): Effect.Effect<void, PushErrors, ConfigServiceImpl | CommitHookServiceImpl> =>
+  Effect.gen(function* () {
+    // Validate email addresses early
+    yield* Effect.try({
+      try: () => {
+        validateEmails(options.reviewer, 'reviewer')
+        validateEmails(options.cc, 'cc')
+      },
+      catch: (e) => (e instanceof PushError ? e : new PushError(String(e))),
+    })
+
+    // Check if we're in a git repo
+    if (!isInGitRepo()) {
+      return yield* Effect.fail(new NotGitRepoError({ message: 'Not in a git repository' }))
+    }
+
+    // Get config for Gerrit host
+    const configService = yield* ConfigService
+    const credentials = yield* configService.getCredentials
+
+    // Find matching remote
+    const remote = findMatchingRemote(credentials.host)
+    if (!remote) {
+      return yield* Effect.fail(
+        new PushError(
+          `No git remote found matching Gerrit host: ${credentials.host}\n` +
+            `Please ensure your git remote points to the Gerrit server.`,
+        ),
+      )
+    }
+
+    // Ensure commit has Change-Id (installs hook if needed)
+    const commitHookService = yield* CommitHookService
+    yield* commitHookService.ensureChangeId()
+
+    // Determine target branch
+    const targetBranch = options.branch || detectTargetBranch(remote)
+
+    // Build refspec
+    const refspec = buildPushRefspec(targetBranch, options)
+
+    // Current branch info
+    const currentBranch = getCurrentBranch() || 'HEAD'
+
+    // Display what we're doing
+    if (options.dryRun) {
+      yield* Console.log(chalk.yellow('Dry run mode - no changes will be pushed\n'))
+    }
+
+    yield* Console.log(chalk.bold('Pushing to Gerrit'))
+    yield* Console.log(`  Remote: ${remote} (${credentials.host})`)
+    yield* Console.log(`  Branch: ${currentBranch} -> ${targetBranch}`)
+
+    if (options.topic) {
+      yield* Console.log(`  Topic: ${options.topic}`)
+    }
+    if (options.reviewer && options.reviewer.length > 0) {
+      yield* Console.log(`  Reviewers: ${options.reviewer.join(', ')}`)
+    }
+    if (options.cc && options.cc.length > 0) {
+      yield* Console.log(`  CC: ${options.cc.join(', ')}`)
+    }
+    if (options.wip || options.draft) {
+      yield* Console.log(`  Status: ${chalk.yellow('Work-in-Progress')}`)
+    }
+    if (options.ready) {
+      yield* Console.log(`  Status: ${chalk.green('Ready for Review')}`)
+    }
+    if (options.hashtag && options.hashtag.length > 0) {
+      yield* Console.log(`  Hashtags: ${options.hashtag.join(', ')}`)
+    }
+
+    yield* Console.log('')
+
+    // Build git push command
+    const args = ['push']
+    if (options.dryRun) {
+      args.push('--dry-run')
+    }
+    args.push(remote)
+    args.push(`HEAD:${refspec}`)
+
+    // Execute push
+    const result = spawnSync('git', args, {
+      encoding: 'utf8',
+      stdio: ['inherit', 'pipe', 'pipe'],
+    })
+
+    // Combine stdout and stderr (git push writes to stderr)
+    const output = (result.stdout || '') + (result.stderr || '')
+
+    if (result.status !== 0) {
+      // Parse common errors
+      if (output.includes('no new changes')) {
+        yield* Console.log(chalk.yellow('No new changes to push'))
+        return
+      }
+
+      if (output.includes('Permission denied') || output.includes('authentication failed')) {
+        return yield* Effect.fail(
+          new PushError(
+            'Authentication failed. Please check your credentials with: ger status\n' +
+              'You may need to regenerate your HTTP password in Gerrit settings.',
+          ),
+        )
+      }
+
+      if (output.includes('prohibited by Gerrit')) {
+        return yield* Effect.fail(
+          new PushError(
+            'Push rejected by Gerrit. Common causes:\n' +
+              '  - Missing permissions for the target branch\n' +
+              '  - Branch may be read-only\n' +
+              '  - Change-Id may be in use by another change',
+          ),
+        )
+      }
+
+      return yield* Effect.fail(new PushError(`Push failed:\n${output}`))
+    }
+
+    // Success - try to extract change URL
+    const changeUrl = extractChangeUrl(output)
+
+    yield* Console.log(chalk.green('Push successful!'))
+
+    if (changeUrl) {
+      yield* Console.log(`\n  ${chalk.cyan(changeUrl)}`)
+    }
+
+    // Show the raw output for additional info
+    if (output.includes('remote:')) {
+      const remoteLines = output
+        .split('\n')
+        .filter((line) => line.startsWith('remote:'))
+        .map((line) => line.replace('remote:', '').trim())
+        .filter((line) => line.length > 0)
+
+      if (remoteLines.length > 0) {
+        yield* Console.log('\nGerrit response:')
+        for (const line of remoteLines) {
+          yield* Console.log(`  ${line}`)
+        }
+      }
+    }
+  })

package/src/cli/commands/rebase.ts

@@ -0,0 +1,52 @@
+import { Effect } from 'effect'
+import { type ApiError, GerritApiService } from '@/api/gerrit'
+
+interface RebaseOptions {
+  base?: string
+  xml?: boolean
+}
+
+/**
+ * Rebases a Gerrit change onto the target branch or specified base.
+ *
+ * @param changeId - Change number or Change-ID to rebase
+ * @param options - Configuration options
+ * @param options.base - Optional base revision to rebase onto (default: target branch HEAD)
+ * @param options.xml - Whether to output in XML format for LLM consumption
+ * @returns Effect that completes when the change is rebased
+ */
+export const rebaseCommand = (
+  changeId?: string,
+  options: RebaseOptions = {},
+): Effect.Effect<void, ApiError, GerritApiService> =>
+  Effect.gen(function* () {
+    const gerritApi = yield* GerritApiService
+
+    if (!changeId || changeId.trim() === '') {
+      console.error('✗ Change ID is required')
+      console.error('  Usage: ger rebase <change-id> [--base <ref>]')
+      return
+    }
+
+    // Perform the rebase - this returns the rebased change info
+    const change = yield* gerritApi.rebaseChange(changeId, { base: options.base })
+
+    if (options.xml) {
+      console.log(`<?xml version="1.0" encoding="UTF-8"?>`)
+      console.log(`<rebase_result>`)
+      console.log(`  <status>success</status>`)
+      console.log(`  <change_number>${change._number}</change_number>`)
+      console.log(`  <subject><![CDATA[${change.subject}]]></subject>`)
+      console.log(`  <branch>${change.branch}</branch>`)
+      if (options.base) {
+        console.log(`  <base><![CDATA[${options.base}]]></base>`)
+      }
+      console.log(`</rebase_result>`)
+    } else {
+      console.log(`✓ Rebased change ${change._number}: ${change.subject}`)
+      console.log(`  Branch: ${change.branch}`)
+      if (options.base) {
+        console.log(`  Base: ${options.base}`)
+      }
+    }
+  })

package/src/cli/commands/remove-reviewer.ts

@@ -0,0 +1,123 @@
+import { Effect } from 'effect'
+import { type ApiError, GerritApiService } from '@/api/gerrit'
+import { escapeXML, sanitizeCDATA } from '@/utils/shell-safety'
+
+interface RemoveReviewerOptions {
+  change?: string
+  notify?: string
+  xml?: boolean
+}
+
+type NotifyLevel = 'NONE' | 'OWNER' | 'OWNER_REVIEWERS' | 'ALL'
+
+const VALID_NOTIFY_LEVELS: ReadonlyArray<NotifyLevel> = ['NONE', 'OWNER', 'OWNER_REVIEWERS', 'ALL']
+
+const isValidNotifyLevel = (value: string): value is NotifyLevel =>
+  VALID_NOTIFY_LEVELS.some((level) => level === value)
+
+const outputXmlError = (message: string): void => {
+  console.log(`<?xml version="1.0" encoding="UTF-8"?>`)
+  console.log(`<remove_reviewer_result>`)
+  console.log(`  <status>error</status>`)
+  console.log(`  <error><![CDATA[${sanitizeCDATA(message)}]]></error>`)
+  console.log(`</remove_reviewer_result>`)
+}
+
+class ValidationError extends Error {
+  readonly _tag = 'ValidationError'
+}
+
+export const removeReviewerCommand = (
+  reviewers: string[],
+  options: RemoveReviewerOptions = {},
+): Effect.Effect<void, ApiError | ValidationError, GerritApiService> =>
+  Effect.gen(function* () {
+    const gerritApi = yield* GerritApiService
+
+    const changeId = options.change
+
+    if (!changeId) {
+      const message =
+        'Change ID is required. Use -c <change-id> or run from a branch with an active change.'
+      if (options.xml) {
+        outputXmlError(message)
+      } else {
+        console.error(`✗ ${message}`)
+      }
+      return yield* Effect.fail(new ValidationError(message))
+    }
+
+    if (reviewers.length === 0) {
+      const message = 'At least one reviewer is required.'
+      if (options.xml) {
+        outputXmlError(message)
+      } else {
+        console.error(`✗ ${message}`)
+      }
+      return yield* Effect.fail(new ValidationError(message))
+    }
+
+    let notify: NotifyLevel | undefined
+    if (options.notify) {
+      const upperNotify = options.notify.toUpperCase()
+      if (!isValidNotifyLevel(upperNotify)) {
+        const message = `Invalid notify level: ${options.notify}. Valid values: none, owner, owner_reviewers, all`
+        if (options.xml) {
+          outputXmlError(message)
+        } else {
+          console.error(`✗ ${message}`)
+        }
+        yield* Effect.fail(new ValidationError(message))
+        return
+      }
+      notify = upperNotify
+    }
+
+    const results: Array<{ reviewer: string; success: boolean; error?: string }> = []
+
+    for (const reviewer of reviewers) {
+      const result = yield* Effect.either(
+        gerritApi.removeReviewer(changeId, reviewer, notify ? { notify } : undefined),
+      )
+
+      if (result._tag === 'Left') {
+        const error = result.left
+        const message = 'message' in error ? String(error.message) : String(error)
+        results.push({ reviewer, success: false, error: message })
+        continue
+      }
+
+      results.push({ reviewer, success: true })
+    }
+
+    if (options.xml) {
+      console.log(`<?xml version="1.0" encoding="UTF-8"?>`)
+      console.log(`<remove_reviewer_result>`)
+      console.log(`  <change_id>${escapeXML(changeId)}</change_id>`)
+      console.log(`  <reviewers>`)
+      for (const r of results) {
+        if (r.success) {
+          console.log(`    <reviewer status="removed">`)
+          console.log(`      <input>${escapeXML(r.reviewer)}</input>`)
+          console.log(`    </reviewer>`)
+        } else {
+          console.log(`    <reviewer status="failed">`)
+          console.log(`      <input>${escapeXML(r.reviewer)}</input>`)
+          console.log(`      <error><![CDATA[${sanitizeCDATA(r.error ?? '')}]]></error>`)
+          console.log(`    </reviewer>`)
+        }
+      }
+      console.log(`  </reviewers>`)
+      const allSuccess = results.every((r) => r.success)
+      console.log(`  <status>${allSuccess ? 'success' : 'partial_failure'}</status>`)
+      console.log(`</remove_reviewer_result>`)
+    } else {
+      for (const r of results) {
+        if (r.success) {
+          console.log(`✓ Removed ${r.reviewer}`)
+        } else {
+          console.error(`✗ Failed to remove ${r.reviewer}: ${r.error}`)
+        }
+      }
+    }
+  })

package/src/cli/commands/restore.ts

@@ -0,0 +1,50 @@
+import { Effect } from 'effect'
+import { type ApiError, GerritApiService } from '@/api/gerrit'
+
+interface RestoreOptions {
+  message?: string
+  xml?: boolean
+}
+
+/**
+ * Restores an abandoned Gerrit change to NEW status.
+ *
+ * @param changeId - Change number or Change-ID to restore
+ * @param options - Configuration options
+ * @param options.message - Optional restoration message
+ * @param options.xml - Whether to output in XML format for LLM consumption
+ * @returns Effect that completes when the change is restored
+ */
+export const restoreCommand = (
+  changeId?: string,
+  options: RestoreOptions = {},
+): Effect.Effect<void, ApiError, GerritApiService> =>
+  Effect.gen(function* () {
+    const gerritApi = yield* GerritApiService
+
+    if (!changeId || changeId.trim() === '') {
+      console.error('✗ Change ID is required')
+      console.error('  Usage: ger restore <change-id>')
+      return
+    }
+
+    // Perform the restore - this returns the restored change info
+    const change = yield* gerritApi.restoreChange(changeId, options.message)
+
+    if (options.xml) {
+      console.log(`<?xml version="1.0" encoding="UTF-8"?>`)
+      console.log(`<restore_result>`)
+      console.log(`  <status>success</status>`)
+      console.log(`  <change_number>${change._number}</change_number>`)
+      console.log(`  <subject><![CDATA[${change.subject}]]></subject>`)
+      if (options.message) {
+        console.log(`  <message><![CDATA[${options.message}]]></message>`)
+      }
+      console.log(`</restore_result>`)
+    } else {
+      console.log(`✓ Restored change ${change._number}: ${change.subject}`)
+      if (options.message) {
+        console.log(`  Message: ${options.message}`)
+      }
+    }
+  })