@aaronshaf/ger 1.2.10 → 2.0.0

package/src/cli/commands/vote.ts

@@ -0,0 +1,119 @@
+import { Effect } from 'effect'
+import { type ApiError, GerritApiService } from '@/api/gerrit'
+import type { ReviewInput } from '@/schemas/gerrit'
+
+interface VoteOptions {
+  codeReview?: number
+  verified?: number
+  label?: string[]
+  message?: string
+  xml?: boolean
+}
+
+/**
+ * Casts votes on a Gerrit change with optional comment message.
+ *
+ * Supports standard labels (Code-Review, Verified) and custom labels.
+ * At least one label must be provided.
+ *
+ * @param changeId - Change number or Change-ID to vote on
+ * @param options - Configuration options
+ * @param options.codeReview - Code-Review vote value (-2 to +2)
+ * @param options.verified - Verified vote value (-1 to +1)
+ * @param options.label - Custom label name-value pairs
+ * @param options.message - Optional comment message with the vote
+ * @param options.xml - Whether to output in XML format for LLM consumption
+ * @returns Effect that completes when votes are cast
+ */
+export const voteCommand = (
+  changeId?: string,
+  options: VoteOptions = {},
+): 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 vote <change-id> --code-review <value> [--verified <value>]')
+      return
+    }
+
+    // Build labels object from options
+    const labels: Record<string, number> = {}
+
+    if (options.codeReview !== undefined) {
+      labels['Code-Review'] = options.codeReview
+    }
+
+    if (options.verified !== undefined) {
+      labels['Verified'] = options.verified
+    }
+
+    // Parse custom labels (format: --label <name> <value>)
+    if (options.label && options.label.length > 0) {
+      // Labels come in pairs: [name1, value1, name2, value2, ...]
+      if (options.label.length % 2 !== 0) {
+        console.error('✗ Invalid label format: labels must be provided as name-value pairs')
+        console.error('  Usage: --label <name> <value> [--label <name> <value> ...]')
+        return
+      }
+
+      for (let i = 0; i < options.label.length; i += 2) {
+        const labelName = options.label[i]
+        const labelValue = options.label[i + 1]
+        if (labelName && labelValue) {
+          const numValue = Number.parseInt(labelValue, 10)
+          if (Number.isNaN(numValue)) {
+            console.error(`✗ Invalid label value for ${labelName}: ${labelValue}`)
+            console.error('  Label values must be integers')
+            return
+          }
+          labels[labelName] = numValue
+        }
+      }
+    }
+
+    // Check if at least one label is provided
+    if (Object.keys(labels).length === 0) {
+      console.error('✗ At least one label is required')
+      console.error(
+        '  Usage: ger vote <change-id> --code-review <value> [--verified <value>] [--label <name> <value>]',
+      )
+      return
+    }
+
+    // Build ReviewInput
+    const reviewInput: ReviewInput = {
+      labels,
+      ...(options.message && { message: options.message }),
+    }
+
+    // Post the review
+    yield* gerritApi.postReview(changeId, reviewInput)
+
+    // Output success
+    if (options.xml) {
+      console.log(`<?xml version="1.0" encoding="UTF-8"?>`)
+      console.log(`<vote_result>`)
+      console.log(`  <status>success</status>`)
+      console.log(`  <change_id>${changeId}</change_id>`)
+      console.log(`  <labels>`)
+      for (const [name, value] of Object.entries(labels)) {
+        console.log(`    <label name="${name}">${value}</label>`)
+      }
+      console.log(`  </labels>`)
+      if (options.message) {
+        console.log(`  <message><![CDATA[${options.message}]]></message>`)
+      }
+      console.log(`</vote_result>`)
+    } else {
+      console.log(`✓ Voted on change ${changeId}`)
+      for (const [name, value] of Object.entries(labels)) {
+        const sign = value >= 0 ? '+' : ''
+        console.log(`  ${name}: ${sign}${value}`)
+      }
+      if (options.message) {
+        console.log(`  Message: ${options.message}`)
+      }
+    }
+  })

package/src/cli/commands/workspace.ts

@@ -0,0 +1,200 @@
+import { execSync, spawnSync } from 'node:child_process'
+import * as fs from 'node:fs'
+import * as path from 'node:path'
+import { Effect } from 'effect'
+import { type ApiError, GerritApiService } from '@/api/gerrit'
+import { type ConfigError, ConfigService } from '@/services/config'
+
+interface WorkspaceOptions {
+  xml?: boolean
+}
+
+const parseChangeSpec = (changeSpec: string): { changeId: string; patchset?: string } => {
+  const parts = changeSpec.split(':')
+  return {
+    changeId: parts[0],
+    patchset: parts[1],
+  }
+}
+
+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+\(fetch\)$/)
+      if (match) {
+        remotes[match[1]] = match[2]
+      }
+    }
+
+    return remotes
+  } catch {
+    return {}
+  }
+}
+
+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 {
+      // Handle both HTTP and SSH URLs
+      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
+}
+
+const isInGitRepo = (): boolean => {
+  try {
+    execSync('git rev-parse --git-dir', { encoding: 'utf8' })
+    return true
+  } catch {
+    return false
+  }
+}
+
+const getRepoRoot = (): string => {
+  try {
+    return execSync('git rev-parse --show-toplevel', { encoding: 'utf8' }).trim()
+  } catch {
+    throw new Error('Not in a git repository')
+  }
+}
+
+export const workspaceCommand = (
+  changeSpec: string,
+  options: WorkspaceOptions,
+): Effect.Effect<void, ApiError | ConfigError | Error, GerritApiService | ConfigService> =>
+  Effect.gen(function* () {
+    // Check if we're in a git repo
+    if (!isInGitRepo()) {
+      throw new Error(
+        'Not in a git repository. Please run this command from within a git repository.',
+      )
+    }
+
+    const repoRoot = getRepoRoot()
+    const { changeId, patchset } = parseChangeSpec(changeSpec)
+
+    // Get Gerrit credentials and find matching remote
+    const configService = yield* ConfigService
+    const credentials = yield* configService.getCredentials
+    const matchingRemote = findMatchingRemote(credentials.host)
+
+    if (!matchingRemote) {
+      throw new Error(`No git remote found matching Gerrit host: ${credentials.host}`)
+    }
+
+    // Get change details from Gerrit
+    const gerritApi = yield* GerritApiService
+    const change = yield* gerritApi.getChange(changeId)
+
+    // Determine patchset to use
+    const targetPatchset = patchset || 'current'
+    const revision = yield* gerritApi.getRevision(changeId, targetPatchset)
+
+    // Create workspace directory name - validate to prevent path traversal
+    const workspaceName = change._number.toString()
+    // Validate workspace name contains only digits
+    if (!/^\d+$/.test(workspaceName)) {
+      throw new Error(`Invalid change number: ${workspaceName}`)
+    }
+    const workspaceDir = path.join(repoRoot, '.ger', workspaceName)
+
+    // Check if worktree already exists
+    if (fs.existsSync(workspaceDir)) {
+      if (options.xml) {
+        console.log(`<?xml version="1.0" encoding="UTF-8"?>`)
+        console.log(`<workspace>`)
+        console.log(`  <path>${workspaceDir}</path>`)
+        console.log(`  <exists>true</exists>`)
+        console.log(`</workspace>`)
+      } else {
+        console.log(`✓ Workspace already exists at: ${workspaceDir}`)
+        console.log(`  Run: cd ${workspaceDir}`)
+      }
+      return
+    }
+
+    // Ensure .ger directory exists
+    const gerDir = path.join(repoRoot, '.ger')
+    if (!fs.existsSync(gerDir)) {
+      fs.mkdirSync(gerDir, { recursive: true })
+    }
+
+    // Fetch the change ref
+    const changeRef = revision.ref
+    if (!options.xml) {
+      console.log(`Fetching change ${change._number}: ${change.subject}`)
+    }
+
+    try {
+      // Use spawnSync with array to prevent command injection
+      const fetchResult = spawnSync('git', ['fetch', matchingRemote, changeRef], {
+        encoding: 'utf8',
+        cwd: repoRoot,
+      })
+      if (fetchResult.status !== 0) {
+        throw new Error(fetchResult.stderr || 'Git fetch failed')
+      }
+    } catch (error) {
+      throw new Error(`Failed to fetch change: ${error}`)
+    }
+
+    // Create worktree
+    if (!options.xml) {
+      console.log(`Creating worktree at: ${workspaceDir}`)
+    }
+
+    try {
+      // Use spawnSync with array to prevent command injection
+      const worktreeResult = spawnSync('git', ['worktree', 'add', workspaceDir, 'FETCH_HEAD'], {
+        encoding: 'utf8',
+        cwd: repoRoot,
+      })
+      if (worktreeResult.status !== 0) {
+        throw new Error(worktreeResult.stderr || 'Git worktree add failed')
+      }
+    } catch (error) {
+      throw new Error(`Failed to create worktree: ${error}`)
+    }
+
+    if (options.xml) {
+      console.log(`<?xml version="1.0" encoding="UTF-8"?>`)
+      console.log(`<workspace>`)
+      console.log(`  <path>${workspaceDir}</path>`)
+      console.log(`  <change_number>${change._number}</change_number>`)
+      console.log(`  <subject><![CDATA[${change.subject}]]></subject>`)
+      console.log(`  <created>true</created>`)
+      console.log(`</workspace>`)
+    } else {
+      console.log(`✓ Workspace created successfully!`)
+      console.log(`  Run: cd ${workspaceDir}`)
+    }
+  })

package/src/cli/index.ts

@@ -0,0 +1,53 @@
+#!/usr/bin/env bun
+
+// Check Bun version requirement
+const MIN_BUN_VERSION = '1.2.0'
+const bunVersion = Bun.version
+
+function compareSemver(a: string, b: string): number {
+  const parseVersion = (v: string) => v.split('.').map((n) => parseInt(n, 10))
+  const [aMajor, aMinor = 0, aPatch = 0] = parseVersion(a)
+  const [bMajor, bMinor = 0, bPatch = 0] = parseVersion(b)
+
+  if (aMajor !== bMajor) return aMajor - bMajor
+  if (aMinor !== bMinor) return aMinor - bMinor
+  return aPatch - bPatch
+}
+
+if (compareSemver(bunVersion, MIN_BUN_VERSION) < 0) {
+  console.error(`✗ Error: Bun version ${MIN_BUN_VERSION} or higher is required`)
+  console.error(`  Current version: ${bunVersion}`)
+  console.error(`  Please upgrade Bun: bun upgrade`)
+  process.exit(1)
+}
+
+import { Command } from 'commander'
+import { readFileSync } from 'node:fs'
+import { join, dirname } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { registerCommands } from './register-commands'
+
+// Read version from package.json
+function getVersion(): string {
+  try {
+    // Get the directory of the current module
+    const __filename = fileURLToPath(import.meta.url)
+    const __dirname = dirname(__filename)
+
+    // Navigate up to the project root and read package.json
+    const packageJsonPath = join(__dirname, '..', '..', 'package.json')
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'))
+    return packageJson.version || '0.0.0'
+  } catch {
+    // Fallback version if package.json can't be read
+    return '0.0.0'
+  }
+}
+
+const program = new Command()
+
+program.name('ger').description('LLM-centric Gerrit CLI tool').version(getVersion())
+
+registerCommands(program)
+
+program.parse(process.argv)