@aaronshaf/ger 3.0.1 → 4.0.0

package/src/cli/commands/analyze.ts

@@ -0,0 +1,284 @@
+import { Console, Effect } from 'effect'
+import chalk from 'chalk'
+import type { ChangeInfo } from '@/schemas/gerrit'
+import { ConfigService, type ConfigError, type ConfigServiceImpl } from '@/services/config'
+import { GerritApiService, type ApiError, type GerritApiServiceImpl } from '@/api/gerrit'
+import { writeFileSync } from 'node:fs'
+import { escapeXML } from '@/utils/shell-safety'
+
+export interface AnalyzeOptions {
+  startDate?: string
+  endDate?: string
+  repo?: string
+  json?: boolean
+  xml?: boolean
+  markdown?: boolean
+  csv?: boolean
+  output?: string
+}
+
+export type AnalyzeErrors = ConfigError | ApiError | Error
+
+interface RepoStats {
+  name: string
+  count: number
+}
+
+interface AuthorStats {
+  name: string
+  email: string
+  count: number
+}
+
+interface MonthStats {
+  month: string
+  count: number
+}
+
+interface AnalyticsResult {
+  totalMerged: number
+  dateRange: { start: string; end: string }
+  byRepo: readonly RepoStats[]
+  byAuthor: readonly AuthorStats[]
+  timeline: readonly MonthStats[]
+}
+
+const getDefaultStartDate = (): string => {
+  const d = new Date()
+  return `${d.getFullYear()}-01-01`
+}
+
+const getDefaultEndDate = (): string => new Date().toISOString().slice(0, 10)
+
+const getChangeMonth = (change: ChangeInfo): string => {
+  const dateStr = change.submitted ?? change.updated ?? change.created ?? ''
+  return dateStr.slice(0, 7) // YYYY-MM
+}
+
+const aggregateByRepo = (changes: readonly ChangeInfo[]): readonly RepoStats[] => {
+  const counts = new Map<string, number>()
+  for (const c of changes) {
+    counts.set(c.project, (counts.get(c.project) ?? 0) + 1)
+  }
+  return [...counts.entries()]
+    .map(([name, count]) => ({ name, count }))
+    .sort((a, b) => b.count - a.count)
+}
+
+const aggregateByAuthor = (changes: readonly ChangeInfo[]): readonly AuthorStats[] => {
+  const counts = new Map<string, { name: string; email: string; count: number }>()
+  for (const c of changes) {
+    const owner = c.owner
+    if (!owner) continue
+    const key = owner.email ?? owner.name ?? String(owner._account_id)
+    const existing = counts.get(key)
+    if (existing) {
+      existing.count++
+    } else {
+      counts.set(key, {
+        name: owner.name ?? 'Unknown',
+        email: owner.email ?? '',
+        count: 1,
+      })
+    }
+  }
+  return [...counts.values()].sort((a, b) => b.count - a.count)
+}
+
+const aggregateByMonth = (changes: readonly ChangeInfo[]): readonly MonthStats[] => {
+  const counts = new Map<string, number>()
+  for (const c of changes) {
+    const month = getChangeMonth(c)
+    counts.set(month, (counts.get(month) ?? 0) + 1)
+  }
+  return [...counts.entries()]
+    .map(([month, count]) => ({ month, count }))
+    .sort((a, b) => a.month.localeCompare(b.month))
+}
+
+const BAR_WIDTH = 30
+
+const renderBar = (count: number, max: number): string => {
+  const filled = max > 0 ? Math.round((count / max) * BAR_WIDTH) : 0
+  return '█'.repeat(filled) + '░'.repeat(BAR_WIDTH - filled)
+}
+
+const renderTerminal = (result: AnalyticsResult): string => {
+  const lines: string[] = []
+
+  lines.push('')
+  lines.push(chalk.bold.cyan('  Contribution Analytics'))
+  lines.push(chalk.dim(`  ${result.dateRange.start}  →  ${result.dateRange.end}`))
+  lines.push('')
+  lines.push(chalk.bold(`  Total merged: ${chalk.green(String(result.totalMerged))}`))
+  lines.push('')
+
+  // By Repo
+  lines.push(chalk.bold.yellow('  ── Changes by Repository ──'))
+  lines.push('')
+  const maxRepo = result.byRepo[0]?.count ?? 1
+  for (const r of result.byRepo.slice(0, 15)) {
+    const bar = renderBar(r.count, maxRepo)
+    const name = r.name.length > 35 ? `...${r.name.slice(-32)}` : r.name
+    lines.push(
+      `  ${chalk.cyan(name.padEnd(35))}  ${chalk.green(bar)}  ${chalk.bold(String(r.count))}`,
+    )
+  }
+  lines.push('')
+
+  // By Author
+  lines.push(chalk.bold.yellow('  ── Changes by Author ──'))
+  lines.push('')
+  const maxAuthor = result.byAuthor[0]?.count ?? 1
+  for (const a of result.byAuthor.slice(0, 10)) {
+    const bar = renderBar(a.count, maxAuthor)
+    const label = a.name.length > 25 ? `${a.name.slice(0, 22)}...` : a.name
+    lines.push(
+      `  ${chalk.magenta(label.padEnd(25))}  ${chalk.green(bar)}  ${chalk.bold(String(a.count))}`,
+    )
+  }
+  lines.push('')
+
+  // Timeline
+  lines.push(chalk.bold.yellow('  ── Timeline ──'))
+  lines.push('')
+  const maxMonth = Math.max(...result.timeline.map((m) => m.count), 1)
+  for (const m of result.timeline) {
+    const bar = renderBar(m.count, maxMonth)
+    lines.push(`  ${chalk.blue(m.month)}  ${chalk.green(bar)}  ${chalk.bold(String(m.count))}`)
+  }
+  lines.push('')
+
+  return lines.join('\n')
+}
+
+const renderMarkdown = (result: AnalyticsResult): string => {
+  const lines: string[] = []
+  lines.push(`# Contribution Analytics`)
+  lines.push(``)
+  lines.push(`**Date range:** ${result.dateRange.start} → ${result.dateRange.end}`)
+  lines.push(`**Total merged:** ${result.totalMerged}`)
+  lines.push(``)
+
+  lines.push(`## Changes by Repository`)
+  lines.push(``)
+  lines.push(`| Repository | Count |`)
+  lines.push(`|---|---|`)
+  for (const r of result.byRepo) lines.push(`| ${r.name} | ${r.count} |`)
+  lines.push(``)
+
+  lines.push(`## Changes by Author`)
+  lines.push(``)
+  lines.push(`| Author | Email | Count |`)
+  lines.push(`|---|---|---|`)
+  for (const a of result.byAuthor) lines.push(`| ${a.name} | ${a.email} | ${a.count} |`)
+  lines.push(``)
+
+  lines.push(`## Timeline`)
+  lines.push(``)
+  lines.push(`| Month | Count |`)
+  lines.push(`|---|---|`)
+  for (const m of result.timeline) lines.push(`| ${m.month} | ${m.count} |`)
+  lines.push(``)
+
+  return lines.join('\n')
+}
+
+const csvField = (v: string): string => `"${v.replace(/"/g, '""')}"`
+
+const renderCsv = (result: AnalyticsResult): string => {
+  const lines: string[] = []
+  lines.push('section,key,count')
+  for (const r of result.byRepo) lines.push(`repo,${csvField(r.name)},${r.count}`)
+  for (const a of result.byAuthor)
+    lines.push(`author,${csvField(`${a.name} <${a.email}>`)},${a.count}`)
+  for (const m of result.timeline) lines.push(`timeline,${csvField(m.month)},${m.count}`)
+  return lines.join('\n')
+}
+
+const renderXml = (result: AnalyticsResult): string => {
+  const lines: string[] = []
+  lines.push(`<?xml version="1.0" encoding="UTF-8"?>`)
+  lines.push(`<analytics>`)
+  lines.push(`  <total_merged>${result.totalMerged}</total_merged>`)
+  lines.push(`  <date_range start="${result.dateRange.start}" end="${result.dateRange.end}"/>`)
+
+  lines.push(`  <by_repo>`)
+  for (const r of result.byRepo) {
+    lines.push(`    <repo name="${escapeXML(r.name)}" count="${r.count}"/>`)
+  }
+  lines.push(`  </by_repo>`)
+
+  lines.push(`  <by_author>`)
+  for (const a of result.byAuthor) {
+    const escaped = a.name.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;')
+    lines.push(`    <author name="${escaped}" email="${a.email}" count="${a.count}"/>`)
+  }
+  lines.push(`  </by_author>`)
+
+  lines.push(`  <timeline>`)
+  for (const m of result.timeline) {
+    lines.push(`    <month value="${m.month}" count="${m.count}"/>`)
+  }
+  lines.push(`  </timeline>`)
+
+  lines.push(`</analytics>`)
+  return lines.join('\n')
+}
+
+export const analyzeCommand = (
+  options: AnalyzeOptions,
+): Effect.Effect<void, AnalyzeErrors, ConfigServiceImpl | GerritApiServiceImpl> =>
+  Effect.gen(function* () {
+    const startDate = options.startDate ?? getDefaultStartDate()
+    const endDate = options.endDate ?? getDefaultEndDate()
+
+    const _configService = yield* ConfigService
+    const apiService = yield* GerritApiService
+
+    const isMachineReadable =
+      options.json || options.xml || options.markdown || options.csv || options.output
+    if (!isMachineReadable) {
+      yield* Console.log(chalk.dim(`Fetching merged changes from ${startDate} to ${endDate}...`))
+    }
+
+    const changes = yield* apiService.fetchMergedChanges({
+      after: startDate,
+      before: endDate,
+      repo: options.repo,
+    })
+
+    const result: AnalyticsResult = {
+      totalMerged: changes.length,
+      dateRange: { start: startDate, end: endDate },
+      byRepo: aggregateByRepo(changes),
+      byAuthor: aggregateByAuthor(changes),
+      timeline: aggregateByMonth(changes),
+    }
+
+    let output: string
+
+    if (options.json) {
+      output = JSON.stringify(result, null, 2)
+    } else if (options.xml) {
+      output = renderXml(result)
+    } else if (options.markdown) {
+      output = renderMarkdown(result)
+    } else if (options.csv) {
+      output = renderCsv(result)
+    } else {
+      output = renderTerminal(result)
+    }
+
+    if (options.output) {
+      const outputPath = options.output
+      yield* Effect.try({
+        try: () => writeFileSync(outputPath, output, 'utf8'),
+        catch: (e) =>
+          new Error(`Failed to write output file: ${e instanceof Error ? e.message : String(e)}`),
+      })
+      yield* Console.log(chalk.green(`✓ Output written to ${options.output}`))
+    } else {
+      yield* Console.log(output)
+    }
+  })

package/src/cli/commands/cherry.ts

@@ -0,0 +1,268 @@
+import { execSync, spawnSync } from 'node:child_process'
+import { Console, Effect, Schema } from 'effect'
+import chalk from 'chalk'
+import { ConfigService, type ConfigError, type ConfigServiceImpl } from '@/services/config'
+import { GerritApiService, type ApiError, type GerritApiServiceImpl } from '@/api/gerrit'
+import { extractChangeNumber } from '@/utils/url-parser'
+
+export const CHERRY_HELP_TEXT = `
+Examples:
+  # Cherry-pick latest patchset
+  $ ger cherry 12345
+
+  # Cherry-pick a specific patchset
+  $ ger cherry 12345/3
+
+  # Cherry-pick by Change-ID
+  $ ger cherry If5a3ae8cb5a107e187447802358417f311d0c4b1
+
+  # Cherry-pick from URL
+  $ ger cherry https://gerrit.example.com/c/my-project/+/12345
+
+  # Stage changes without committing
+  $ ger cherry 12345 --no-commit
+
+  # Use a specific remote
+  $ ger cherry 12345 --remote upstream
+
+Notes:
+  - Fetches the change then runs git cherry-pick FETCH_HEAD
+  - Use --no-commit to stage without committing (git cherry-pick -n)`
+
+export interface CherryOptions {
+  noCommit?: boolean
+  remote?: string
+  noVerify?: boolean
+}
+
+class CherryError extends Error {
+  readonly _tag = 'CherryError' as const
+  constructor(message: string) {
+    super(message)
+    this.name = 'CherryError'
+  }
+}
+
+class NotGitRepoError extends Error {
+  readonly _tag = 'NotGitRepoError' as const
+  constructor(message: string) {
+    super(message)
+    this.name = 'NotGitRepoError'
+  }
+}
+
+class PatchsetNotFoundError extends Error {
+  readonly _tag = 'PatchsetNotFoundError' as const
+  constructor(public readonly patchset: number) {
+    super(`Patchset ${patchset} not found`)
+    this.name = 'PatchsetNotFoundError'
+  }
+}
+
+class InvalidInputError extends Error {
+  readonly _tag = 'InvalidInputError' as const
+  constructor(message: string) {
+    super(message)
+    this.name = 'InvalidInputError'
+  }
+}
+
+export type CherryErrors =
+  | ConfigError
+  | ApiError
+  | CherryError
+  | NotGitRepoError
+  | PatchsetNotFoundError
+  | InvalidInputError
+
+// Git-safe string validation — prevents command injection
+const GitSafeString = Schema.String.pipe(
+  Schema.pattern(/^[a-zA-Z0-9_\-/.]+$/),
+  Schema.annotations({ message: () => 'Invalid characters in git identifier' }),
+)
+
+// Gerrit ref validation (refs/changes/xx/xxxxx/x)
+const GerritRef = Schema.String.pipe(
+  Schema.pattern(/^refs\/changes\/\d{2}\/\d+\/\d+$/),
+  Schema.annotations({ message: () => 'Invalid Gerrit ref format' }),
+)
+
+const validateGitSafe = (
+  value: string,
+  fieldName: string,
+): Effect.Effect<string, InvalidInputError> =>
+  Schema.decodeUnknown(GitSafeString)(value).pipe(
+    Effect.mapError(() => {
+      const sanitized = value.length > 20 ? `${value.substring(0, 20)}...` : value
+      return new InvalidInputError(`${fieldName} contains invalid characters: ${sanitized}`)
+    }),
+  )
+
+const validateGerritRef = (value: string): Effect.Effect<string, InvalidInputError> =>
+  Schema.decodeUnknown(GerritRef)(value).pipe(
+    Effect.mapError(() => {
+      const sanitized = value.length > 30 ? `${value.substring(0, 30)}...` : value
+      return new InvalidInputError(`Invalid Gerrit ref format: ${sanitized}`)
+    }),
+  )
+
+interface ParsedChange {
+  changeId: string
+  patchset?: number
+}
+
+const parseChangeInput = (input: string): ParsedChange => {
+  const trimmed = input.trim()
+
+  if (trimmed.startsWith('http://') || trimmed.startsWith('https://')) {
+    const changeId = extractChangeNumber(trimmed)
+    const patchsetMatch = trimmed.match(/\/\d+\/(\d+)(?:\/|$)/)
+    if (patchsetMatch?.[1]) {
+      return { changeId, patchset: parseInt(patchsetMatch[1], 10) }
+    }
+    return { changeId }
+  }
+
+  if (trimmed.includes('/') && !trimmed.startsWith('http')) {
+    const parts = trimmed.split('/')
+    if (parts.length === 2) {
+      const [changeId, patchsetStr] = parts
+      const patchset = parseInt(patchsetStr, 10)
+      if (!Number.isNaN(patchset) && patchset > 0) {
+        return { changeId, patchset }
+      }
+      return { changeId }
+    }
+  }
+
+  return { changeId: trimmed }
+}
+
+const getGitRemotes = (): Record<string, string> => {
+  try {
+    const output = execSync('git remote -v', { encoding: 'utf8', timeout: 5000 })
+    const remotes: Record<string, string> = {}
+    for (const line of output.split('\n')) {
+      const match = line.match(/^(\S+)\s+(\S+)\s+\(fetch\)$/)
+      if (match) remotes[match[1]] = match[2]
+    }
+    return remotes
+  } catch {
+    return {}
+  }
+}
+
+const findMatchingRemote = (gerritHost: string): string | null => {
+  const remotes = getGitRemotes()
+  const gerritHostname = new URL(gerritHost).hostname
+  for (const [name, url] of Object.entries(remotes)) {
+    try {
+      let remoteHostname: string
+      if (url.startsWith('git@')) {
+        remoteHostname = url.split('@')[1].split(':')[0]
+      } else if (url.includes('://')) {
+        remoteHostname = new URL(url).hostname
+      } else {
+        continue
+      }
+      if (remoteHostname === gerritHostname) return name
+    } catch {
+      // ignore malformed URLs
+    }
+  }
+  return null
+}
+
+const isInGitRepo = (): boolean => {
+  try {
+    execSync('git rev-parse --git-dir', { encoding: 'utf8', timeout: 5000 })
+    return true
+  } catch {
+    return false
+  }
+}
+
+export const cherryCommand = (
+  changeInput: string,
+  options: CherryOptions,
+): Effect.Effect<void, CherryErrors, ConfigServiceImpl | GerritApiServiceImpl> =>
+  Effect.gen(function* () {
+    const parsed = parseChangeInput(changeInput)
+
+    if (!isInGitRepo()) {
+      return yield* Effect.fail(new NotGitRepoError('Not in a git repository'))
+    }
+
+    const configService = yield* ConfigService
+    const apiService = yield* GerritApiService
+    const credentials = yield* configService.getCredentials
+
+    const change = yield* apiService.getChange(parsed.changeId)
+
+    const revision = yield* Effect.gen(function* () {
+      if (parsed.patchset !== undefined) {
+        const patchsetNum = parsed.patchset
+        return yield* apiService
+          .getRevision(parsed.changeId, patchsetNum.toString())
+          .pipe(Effect.catchAll(() => Effect.fail(new PatchsetNotFoundError(patchsetNum))))
+      }
+
+      if (change.current_revision && change.revisions) {
+        const currentRevision = change.revisions[change.current_revision]
+        if (currentRevision) return currentRevision
+      }
+
+      return yield* apiService.getRevision(parsed.changeId, 'current')
+    })
+
+    const validatedRef = yield* validateGerritRef(revision.ref)
+    const rawRemote = options.remote ?? findMatchingRemote(credentials.host) ?? 'origin'
+    const remote = yield* validateGitSafe(rawRemote, 'remote')
+
+    yield* Console.log(chalk.bold('Cherry-picking Gerrit change'))
+    yield* Console.log(`  Change:   ${chalk.cyan(String(change._number))} — ${change.subject}`)
+    yield* Console.log(`  Patchset: ${revision._number}`)
+    yield* Console.log(`  Branch:   ${change.branch}`)
+    yield* Console.log(`  Remote:   ${remote}`)
+    yield* Console.log('')
+
+    yield* Console.log(chalk.dim(`Fetching ${validatedRef}...`))
+    yield* Effect.try({
+      try: () => {
+        const result = spawnSync('git', ['fetch', remote, validatedRef], {
+          stdio: 'inherit',
+          timeout: 60000,
+        })
+        if (result.status !== 0) throw new Error(result.stderr?.toString() ?? 'fetch failed')
+      },
+      catch: (e) =>
+        new CherryError(`Failed to fetch: ${e instanceof Error ? e.message : String(e)}`),
+    })
+
+    const cherryPickCmd = [
+      'cherry-pick',
+      ...(options.noCommit ? ['-n'] : []),
+      ...(options.noVerify ? ['--no-verify'] : []),
+      'FETCH_HEAD',
+    ]
+    yield* Console.log(
+      chalk.dim(`Running git cherry-pick ${options.noCommit ? '-n ' : ''}FETCH_HEAD...`),
+    )
+    yield* Effect.try({
+      try: () => {
+        const result = spawnSync('git', cherryPickCmd, { stdio: 'inherit', timeout: 60000 })
+        if (result.status !== 0) throw new Error(result.stderr?.toString() ?? 'cherry-pick failed')
+      },
+      catch: (e) =>
+        new CherryError(`Cherry-pick failed: ${e instanceof Error ? e.message : String(e)}`),
+    })
+
+    yield* Console.log('')
+    if (options.noCommit) {
+      yield* Console.log(
+        chalk.green('✓ Changes staged (not committed). Review then run git commit.'),
+      )
+    } else {
+      yield* Console.log(chalk.green(`✓ Cherry-picked change ${change._number} successfully`))
+    }
+  })

package/src/cli/commands/failures.ts

@@ -0,0 +1,74 @@
+import { Console, Effect } from 'effect'
+import type { MessageInfo } from '@/schemas/gerrit'
+import { ConfigService, type ConfigError, type ConfigServiceImpl } from '@/services/config'
+import { GerritApiService, type ApiError, type GerritApiServiceImpl } from '@/api/gerrit'
+
+export interface FailuresOptions {
+  json?: boolean
+  xml?: boolean
+}
+
+export type FailuresErrors = ConfigError | ApiError
+
+const JENKINS_LINK_RE =
+  /https:\/\/jenkins\.inst-ci\.net\/job\/Canvas\/job\/[^/]+\/\d+\/\/build-summary-report\//
+
+const isServiceCloudJenkins = (msg: MessageInfo): boolean => {
+  const author = msg.author
+  if (!author) return false
+  const name = (author.name ?? author.username ?? author.email ?? '').toLowerCase()
+  return name.includes('service cloud jenkins')
+}
+
+const findMostRecentFailureLink = (messages: readonly MessageInfo[]): string | null => {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const msg = messages[i]
+    if (!isServiceCloudJenkins(msg)) continue
+    if (!msg.message.includes('Verified-1')) continue
+    const match = JENKINS_LINK_RE.exec(msg.message)
+    if (match) return match[0]
+  }
+  return null
+}
+
+export const failuresCommand = (
+  changeId: string,
+  options: FailuresOptions,
+): Effect.Effect<void, FailuresErrors, ConfigServiceImpl | GerritApiServiceImpl> =>
+  Effect.gen(function* () {
+    const _config = yield* ConfigService
+    const api = yield* GerritApiService
+
+    const messages = yield* api.getMessages(changeId)
+    const link = findMostRecentFailureLink(messages)
+
+    if (!link) {
+      if (options.json) {
+        yield* Console.log(JSON.stringify({ status: 'not_found', change_id: changeId }, null, 2))
+      } else if (options.xml) {
+        yield* Console.log(`<?xml version="1.0" encoding="UTF-8"?>`)
+        yield* Console.log(`<failures>`)
+        yield* Console.log(`  <status>not_found</status>`)
+        yield* Console.log(`  <change_id>${changeId}</change_id>`)
+        yield* Console.log(`</failures>`)
+      } else {
+        yield* Console.log('No build failure links found from Service Cloud Jenkins')
+      }
+      return
+    }
+
+    if (options.json) {
+      yield* Console.log(
+        JSON.stringify({ status: 'found', change_id: changeId, url: link }, null, 2),
+      )
+    } else if (options.xml) {
+      yield* Console.log(`<?xml version="1.0" encoding="UTF-8"?>`)
+      yield* Console.log(`<failures>`)
+      yield* Console.log(`  <status>found</status>`)
+      yield* Console.log(`  <change_id>${changeId}</change_id>`)
+      yield* Console.log(`  <url>${link}</url>`)
+      yield* Console.log(`</failures>`)
+    } else {
+      yield* Console.log(link)
+    }
+  })