@aaronshaf/ger 0.3.1 → 0.3.3

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/search.ts

@@ -0,0 +1,162 @@
+import { Effect } from 'effect'
+import { type ApiError, GerritApiService } from '@/api/gerrit'
+import type { ChangeInfo } from '@/schemas/gerrit'
+import { colors, formatDate } from '@/utils/formatters'
+import { escapeXML, sanitizeCDATA } from '@/utils/shell-safety'
+import { getStatusIndicators } from '@/utils/status-indicators'
+
+export const SEARCH_HELP_TEXT = `
+Examples:
+  # Search for all open changes (default)
+  $ ger search
+
+  # Search for your open changes
+  $ ger search "owner:self status:open"
+
+  # Search for changes by a specific user
+  $ ger search "owner:john@example.com"
+
+  # Search by project
+  $ ger search "project:my-project status:open"
+
+  # Search with date filters
+  $ ger search "owner:self after:2025-01-01"
+  $ ger search "status:merged age:7d"
+
+  # Combine filters
+  $ ger search "owner:self status:merged before:2025-06-01"
+
+  # Limit results
+  $ ger search "project:my-project" -n 10
+
+Common query operators:
+  owner:USER        Changes owned by USER (use 'self' for yourself)
+  status:STATE      open, merged, abandoned, closed
+  project:NAME      Changes in a specific project
+  branch:NAME       Changes targeting a branch
+  age:TIME          Time since last update (e.g., 1d, 2w, 1mon)
+  before:DATE       Changes modified before date (YYYY-MM-DD)
+  after:DATE        Changes modified after date (YYYY-MM-DD)
+  is:wip            Work-in-progress changes
+  is:submittable    Changes ready to submit
+  reviewer:USER     Changes where USER is a reviewer
+  label:NAME=VALUE  Filter by label (e.g., label:Code-Review+2)
+
+Full query syntax: https://gerrit-review.googlesource.com/Documentation/user-search.html`
+
+interface SearchOptions {
+  xml?: boolean
+  limit?: string
+}
+
+// Group changes by project for better organization
+const groupChangesByProject = (changes: readonly ChangeInfo[]) => {
+  const grouped = new Map<string, ChangeInfo[]>()
+
+  for (const change of changes) {
+    const project = change.project
+    const existing = grouped.get(project) ?? []
+    existing.push(change)
+    grouped.set(project, existing)
+  }
+
+  // Sort projects alphabetically and changes by updated date
+  return Array.from(grouped.entries())
+    .sort(([a], [b]) => a.localeCompare(b))
+    .map(([project, projectChanges]) => ({
+      project,
+      changes: projectChanges.sort((a, b) => {
+        const dateA = a.updated ? new Date(a.updated).getTime() : 0
+        const dateB = b.updated ? new Date(b.updated).getTime() : 0
+        return dateB - dateA
+      }),
+    }))
+}
+
+export const searchCommand = (
+  query: string | undefined,
+  options: SearchOptions,
+): Effect.Effect<void, ApiError, GerritApiService> =>
+  Effect.gen(function* () {
+    const gerritApi = yield* GerritApiService
+
+    // Build the final query with limit if specified
+    let finalQuery = query || 'is:open'
+    const parsedLimit = options.limit ? parseInt(options.limit, 10) : 25
+    const limit = Number.isNaN(parsedLimit) || parsedLimit < 1 ? 25 : parsedLimit
+    if (!finalQuery.includes('limit:')) {
+      finalQuery = `${finalQuery} limit:${limit}`
+    }
+
+    const changes = yield* gerritApi.listChanges(finalQuery)
+
+    // Group changes by project (used by both output formats)
+    const groupedChanges = changes.length > 0 ? groupChangesByProject(changes) : []
+
+    if (options.xml) {
+      // XML output
+      const xmlOutput = [
+        '<?xml version="1.0" encoding="UTF-8"?>',
+        '<search_results>',
+        `  <query><![CDATA[${sanitizeCDATA(finalQuery)}]]></query>`,
+        `  <count>${changes.length}</count>`,
+      ]
+
+      if (changes.length > 0) {
+        xmlOutput.push('  <changes>')
+
+        for (const { project, changes: projectChanges } of groupedChanges) {
+          xmlOutput.push(`    <project name="${escapeXML(project)}">`)
+          for (const change of projectChanges) {
+            xmlOutput.push('      <change>')
+            xmlOutput.push(`        <number>${change._number}</number>`)
+            xmlOutput.push(
+              `        <subject><![CDATA[${sanitizeCDATA(change.subject)}]]></subject>`,
+            )
+            xmlOutput.push(`        <status>${escapeXML(change.status)}</status>`)
+            xmlOutput.push(`        <owner>${escapeXML(change.owner?.name ?? 'Unknown')}</owner>`)
+            xmlOutput.push(`        <branch>${escapeXML(change.branch)}</branch>`)
+            if (change.updated && change.updated.trim() !== '') {
+              xmlOutput.push(`        <updated>${escapeXML(change.updated)}</updated>`)
+            }
+            if (change.owner?.email) {
+              xmlOutput.push(`        <owner_email>${escapeXML(change.owner.email)}</owner_email>`)
+            }
+            xmlOutput.push('      </change>')
+          }
+          xmlOutput.push('    </project>')
+        }
+
+        xmlOutput.push('  </changes>')
+      }
+
+      xmlOutput.push('</search_results>')
+      console.log(xmlOutput.join('\n'))
+    } else {
+      // Pretty output (default)
+      if (changes.length === 0) {
+        console.log(`${colors.yellow}No changes found${colors.reset}`)
+        return
+      }
+
+      console.log(`${colors.blue}Search results (${changes.length})${colors.reset}\n`)
+
+      for (const { project, changes: projectChanges } of groupedChanges) {
+        console.log(`${colors.gray}${project}${colors.reset}`)
+
+        for (const change of projectChanges) {
+          const indicators = getStatusIndicators(change)
+          const statusPart = indicators.length > 0 ? `${indicators.join(' ')} ` : ''
+          const dateStr = change.updated ? ` • ${formatDate(change.updated)}` : ''
+
+          console.log(
+            `  ${statusPart}${colors.yellow}#${change._number}${colors.reset} ${change.subject}`,
+          )
+          console.log(
+            `    ${colors.gray}by ${change.owner?.name ?? 'Unknown'} • ${change.status}${dateStr}${colors.reset}`,
+          )
+        }
+        console.log() // Empty line between projects
+      }
+    }
+  })

package/src/cli/commands/show.ts

@@ -9,6 +9,26 @@ import { formatDate } from '@/utils/formatters'
 import { getChangeIdFromHead, GitError, NoChangeIdError } from '@/utils/git-commit'
 import { writeFileSync } from 'node:fs'
 
+export const SHOW_HELP_TEXT = `
+Examples:
+  # Show specific change (using change number)
+  $ ger show 392385
+
+  # Show specific change (using Change-ID)
+  $ ger show If5a3ae8cb5a107e187447802358417f311d0c4b1
+
+  # Auto-detect Change-ID from HEAD commit
+  $ ger show
+  $ ger show --xml
+  $ ger show --json
+
+  # Extract build failure URL with jq
+  $ ger show 392090 --json | jq -r '.messages[] | select(.message | contains("Build Failed")) | .message' | grep -oP 'https://[^\\s]+'
+
+Note: When no change-id is provided, it will be automatically extracted from the
+      Change-ID footer in your HEAD commit. You must be in a git repository with
+      a commit that has a Change-ID.`
+
 interface ShowOptions {
   xml?: boolean
   json?: boolean