@aaronshaf/ger 0.3.1 → 0.3.3

package/src/cli/index.ts

@@ -30,8 +30,10 @@ import { GerritApiServiceLive } from '@/api/gerrit'
 import { ConfigServiceLive } from '@/services/config'
 import { ReviewStrategyServiceLive } from '@/services/review-strategy'
 import { GitWorktreeServiceLive } from '@/services/git-worktree'
+import { CommitHookServiceLive } from '@/services/commit-hook'
 import { abandonCommand } from './commands/abandon'
-import { buildStatusCommand } from './commands/build-status'
+import { addReviewerCommand } from './commands/add-reviewer'
+import { buildStatusCommand, BUILD_STATUS_HELP_TEXT } from './commands/build-status'
 import { commentCommand } from './commands/comment'
 import { commentsCommand } from './commands/comments'
 import { diffCommand } from './commands/diff'
@@ -39,9 +41,11 @@ import { extractUrlCommand } from './commands/extract-url'
 import { incomingCommand } from './commands/incoming'
 import { mineCommand } from './commands/mine'
 import { openCommand } from './commands/open'
+import { pushCommand, PUSH_HELP_TEXT } from './commands/push'
 import { reviewCommand } from './commands/review'
+import { searchCommand, SEARCH_HELP_TEXT } from './commands/search'
 import { setup } from './commands/setup'
-import { showCommand } from './commands/show'
+import { showCommand, SHOW_HELP_TEXT } from './commands/show'
 import { statusCommand } from './commands/status'
 import { workspaceCommand } from './commands/workspace'
 import { sanitizeCDATA } from '@/utils/shell-safety'
@@ -229,6 +233,34 @@ program
     }
   })
 
+// search command
+program
+  .command('search [query]')
+  .description('Search changes using Gerrit query syntax')
+  .option('--xml', 'XML output for LLM consumption')
+  .option('-n, --limit <number>', 'Limit results (default: 25)')
+  .addHelpText('after', SEARCH_HELP_TEXT)
+  .action(async (query, options) => {
+    const effect = searchCommand(query, options).pipe(
+      Effect.provide(GerritApiServiceLive),
+      Effect.provide(ConfigServiceLive),
+    )
+    await Effect.runPromise(effect).catch((error: unknown) => {
+      if (options.xml) {
+        console.log(`<?xml version="1.0" encoding="UTF-8"?>`)
+        console.log(`<search_result>`)
+        console.log(`  <status>error</status>`)
+        console.log(
+          `  <error><![CDATA[${error instanceof Error ? error.message : String(error)}]]></error>`,
+        )
+        console.log(`</search_result>`)
+      } else {
+        console.error('✗ Error:', error instanceof Error ? error.message : String(error))
+      }
+      process.exit(1)
+    })
+  })
+
 // workspace command
 program
   .command('workspace <change-id>')
@@ -319,6 +351,49 @@ program
     }
   })
 
+// add-reviewer command
+program
+  .command('add-reviewer <reviewers...>')
+  .description('Add reviewers to a change')
+  .option('-c, --change <change-id>', 'Change ID (required until auto-detection is implemented)')
+  .option('--cc', 'Add as CC instead of reviewer')
+  .option(
+    '--notify <level>',
+    'Notification level: none, owner, owner_reviewers, all (default: all)',
+  )
+  .option('--xml', 'XML output for LLM consumption')
+  .addHelpText(
+    'after',
+    `
+Examples:
+  $ ger add-reviewer user@example.com -c 12345          # Add a reviewer
+  $ ger add-reviewer user1@example.com user2@example.com -c 12345  # Multiple
+  $ ger add-reviewer --cc user@example.com -c 12345     # Add as CC
+  $ ger add-reviewer --notify none user@example.com -c 12345  # No email`,
+  )
+  .action(async (reviewers, options) => {
+    try {
+      const effect = addReviewerCommand(reviewers, options).pipe(
+        Effect.provide(GerritApiServiceLive),
+        Effect.provide(ConfigServiceLive),
+      )
+      await Effect.runPromise(effect)
+    } catch (error) {
+      if (options.xml) {
+        console.log(`<?xml version="1.0" encoding="UTF-8"?>`)
+        console.log(`<add_reviewer_result>`)
+        console.log(`  <status>error</status>`)
+        console.log(
+          `  <error><![CDATA[${error instanceof Error ? error.message : String(error)}]]></error>`,
+        )
+        console.log(`</add_reviewer_result>`)
+      } else {
+        console.error('✗ Error:', error instanceof Error ? error.message : String(error))
+      }
+      process.exit(1)
+    }
+  })
+
 // comments command
 program
   .command('comments <change-id>')
@@ -374,28 +449,7 @@ program
   )
   .option('--xml', 'XML output for LLM consumption')
   .option('--json', 'JSON output for programmatic consumption')
-  .addHelpText(
-    'after',
-    `
-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.`,
-  )
+  .addHelpText('after', SHOW_HELP_TEXT)
   .action(async (changeId, options) => {
     try {
       const effect = showCommand(changeId, options).pipe(
@@ -430,56 +484,7 @@ program
   .option('-i, --interval <seconds>', 'Refresh interval in seconds (default: 10)', '10')
   .option('--timeout <seconds>', 'Maximum wait time in seconds (default: 1800 / 30min)', '1800')
   .option('--exit-status', 'Exit with non-zero status if build fails')
-  .addHelpText(
-    'after',
-    `
-This command parses Gerrit change messages to determine build status.
-It looks for "Build Started" messages and subsequent verification labels.
-
-Output is JSON with a "state" field that can be:
-  - pending: No build has started yet
-  - running: Build started but no verification yet
-  - success: Build completed with Verified+1
-  - failure: Build completed with Verified-1
-  - not_found: Change does not exist
-
-Exit codes:
-  - 0: Default for all states (like gh run watch)
-  - 1: Only when --exit-status is used AND build fails
-  - 2: Timeout reached in watch mode
-  - 3: API/network errors
-
-Examples:
-  # Single check (current behavior)
-  $ ger build-status 392385
-  {"state":"success"}
-
-  # Watch until completion (outputs JSON on each poll)
-  $ ger build-status 392385 --watch
-  {"state":"pending"}
-  {"state":"running"}
-  {"state":"running"}
-  {"state":"success"}
-
-  # Watch with custom interval (check every 5 seconds)
-  $ ger build-status --watch --interval 5
-
-  # Watch with custom timeout (60 minutes)
-  $ ger build-status --watch --timeout 3600
-
-  # Exit with code 1 on failure (for CI/CD pipelines)
-  $ ger build-status --watch --exit-status && deploy.sh
-
-  # Trigger notification when done (like gh run watch pattern)
-  $ ger build-status --watch && notify-send 'Build is done!'
-
-  # Parse final state in scripts
-  $ ger build-status --watch | tail -1 | jq -r '.state'
-  success
-
-Note: When no change-id is provided, it will be automatically extracted from the
-      Change-ID footer in your HEAD commit.`,
-  )
+  .addHelpText('after', BUILD_STATUS_HELP_TEXT)
   .action(async (changeId, cmdOptions) => {
     try {
       const effect = buildStatusCommand(changeId, {
@@ -570,6 +575,42 @@ Note:
     }
   })
 
+// push command
+program
+  .command('push')
+  .description('Push commits to Gerrit for code review')
+  .option('-b, --branch <branch>', 'Target branch (default: auto-detect)')
+  .option('-t, --topic <topic>', 'Set change topic')
+  .option('-r, --reviewer <email...>', 'Add reviewer(s)')
+  .option('--cc <email...>', 'Add CC recipient(s)')
+  .option('--wip', 'Mark as work-in-progress')
+  .option('--ready', 'Mark as ready for review')
+  .option('--hashtag <tag...>', 'Add hashtag(s)')
+  .option('--private', 'Mark change as private')
+  .option('--draft', 'Alias for --wip')
+  .option('--dry-run', 'Show what would be pushed without pushing')
+  .addHelpText('after', PUSH_HELP_TEXT)
+  .action(async (options) => {
+    try {
+      const effect = pushCommand({
+        branch: options.branch,
+        topic: options.topic,
+        reviewer: options.reviewer,
+        cc: options.cc,
+        wip: options.wip,
+        ready: options.ready,
+        hashtag: options.hashtag,
+        private: options.private,
+        draft: options.draft,
+        dryRun: options.dryRun,
+      }).pipe(Effect.provide(CommitHookServiceLive), Effect.provide(ConfigServiceLive))
+      await Effect.runPromise(effect)
+    } catch (error) {
+      console.error('Error:', error instanceof Error ? error.message : String(error))
+      process.exit(1)
+    }
+  })
+
 // review command
 program
   .command('review <change-id>')

package/src/schemas/gerrit.ts

@@ -444,6 +444,49 @@ export const DiffCommandOptions: Schema.Schema<{
 })
 export type DiffCommandOptions = Schema.Schema.Type<typeof DiffCommandOptions>
 
+// Reviewer schemas
+export const ReviewerInput: Schema.Schema<{
+  readonly reviewer: string
+  readonly state?: 'REVIEWER' | 'CC' | 'REMOVED'
+  readonly confirmed?: boolean
+  readonly notify?: 'NONE' | 'OWNER' | 'OWNER_REVIEWERS' | 'ALL'
+}> = Schema.Struct({
+  reviewer: Schema.String,
+  state: Schema.optional(Schema.Literal('REVIEWER', 'CC', 'REMOVED')),
+  confirmed: Schema.optional(Schema.Boolean),
+  notify: Schema.optional(Schema.Literal('NONE', 'OWNER', 'OWNER_REVIEWERS', 'ALL')),
+})
+export type ReviewerInput = Schema.Schema.Type<typeof ReviewerInput>
+
+const ReviewerAccountInfo = Schema.Struct({
+  _account_id: Schema.Number,
+  name: Schema.optional(Schema.String),
+  email: Schema.optional(Schema.String),
+})
+
+export const ReviewerResult: Schema.Schema<{
+  readonly input: string
+  readonly reviewers?: ReadonlyArray<{
+    readonly _account_id: number
+    readonly name?: string
+    readonly email?: string
+  }>
+  readonly ccs?: ReadonlyArray<{
+    readonly _account_id: number
+    readonly name?: string
+    readonly email?: string
+  }>
+  readonly error?: string
+  readonly confirm?: boolean
+}> = Schema.Struct({
+  input: Schema.String,
+  reviewers: Schema.optional(Schema.Array(ReviewerAccountInfo)),
+  ccs: Schema.optional(Schema.Array(ReviewerAccountInfo)),
+  error: Schema.optional(Schema.String),
+  confirm: Schema.optional(Schema.Boolean),
+})
+export type ReviewerResult = Schema.Schema.Type<typeof ReviewerResult>
+
 // API Response schemas
 export const GerritError: Schema.Schema<{
   readonly message: string

package/src/services/commit-hook.ts

@@ -0,0 +1,314 @@
+import { Effect, Context, Layer, Console, pipe } from 'effect'
+import { Schema } from 'effect'
+import * as fs from 'node:fs'
+import * as path from 'node:path'
+import { execSync, spawnSync } from 'node:child_process'
+import { ConfigService, type ConfigServiceImpl } from '@/services/config'
+
+// Error types
+//
+// NOTE: The `as unknown` casts below are a workaround for Effect Schema's TaggedError
+// type inference limitations. Schema.TaggedError returns a complex union type that
+// doesn't directly satisfy the class extension pattern we need. The cast allows us
+// to extend the schema as a class while maintaining the tagged error behavior.
+// This pattern is used consistently across the codebase for Effect Schema errors.
+// See: https://effect.website/docs/schema/basic-usage#tagged-errors
+
+export interface HookInstallErrorFields {
+  readonly message: string
+  readonly cause?: unknown
+}
+
+const HookInstallErrorSchema = Schema.TaggedError<HookInstallErrorFields>()('HookInstallError', {
+  message: Schema.String,
+  cause: Schema.optional(Schema.Unknown),
+}) as unknown
+
+export class HookInstallError
+  extends (HookInstallErrorSchema as new (
+    args: HookInstallErrorFields,
+  ) => HookInstallErrorFields & Error & { readonly _tag: 'HookInstallError' })
+  implements Error
+{
+  readonly name = 'HookInstallError'
+}
+
+export interface MissingChangeIdErrorFields {
+  readonly message: string
+}
+
+const MissingChangeIdErrorSchema = Schema.TaggedError<MissingChangeIdErrorFields>()(
+  'MissingChangeIdError',
+  {
+    message: Schema.String,
+  },
+) as unknown
+
+export class MissingChangeIdError
+  extends (MissingChangeIdErrorSchema as new (
+    args: MissingChangeIdErrorFields,
+  ) => MissingChangeIdErrorFields & Error & { readonly _tag: 'MissingChangeIdError' })
+  implements Error
+{
+  readonly name = 'MissingChangeIdError'
+}
+
+export interface NotGitRepoErrorFields {
+  readonly message: string
+}
+
+const NotGitRepoErrorSchema = Schema.TaggedError<NotGitRepoErrorFields>()('NotGitRepoError', {
+  message: Schema.String,
+}) as unknown
+
+export class NotGitRepoError
+  extends (NotGitRepoErrorSchema as new (
+    args: NotGitRepoErrorFields,
+  ) => NotGitRepoErrorFields & Error & { readonly _tag: 'NotGitRepoError' })
+  implements Error
+{
+  readonly name = 'NotGitRepoError'
+}
+
+export type CommitHookError = HookInstallError | MissingChangeIdError | NotGitRepoError
+
+/** Regex pattern to match Gerrit Change-Id in commit messages */
+export const CHANGE_ID_PATTERN: RegExp = /^Change-Id: I[0-9a-f]{40}$/m
+
+// Get .git directory path (handles both regular repos and worktrees)
+export const getGitDir = (): string => {
+  try {
+    return execSync('git rev-parse --git-dir', { encoding: 'utf8' }).trim()
+  } catch {
+    throw new Error('Not in a git repository')
+  }
+}
+
+// Get absolute .git directory path
+export const getGitDirAbsolute = (): string => {
+  try {
+    return execSync('git rev-parse --absolute-git-dir', { encoding: 'utf8' }).trim()
+  } catch {
+    throw new Error('Not in a git repository')
+  }
+}
+
+// Check if commit-msg hook exists and is executable
+export const hasCommitMsgHook = (): boolean => {
+  try {
+    const gitDir = getGitDir()
+    const hookPath = path.join(gitDir, 'hooks', 'commit-msg')
+
+    if (!fs.existsSync(hookPath)) {
+      return false
+    }
+
+    // Check if file is executable
+    const stats = fs.statSync(hookPath)
+    // Check owner execute bit (0o100)
+    return (stats.mode & 0o100) !== 0
+  } catch {
+    return false
+  }
+}
+
+// Check if a commit has a Change-Id in its message
+export const commitHasChangeId = (commit: string = 'HEAD'): boolean => {
+  try {
+    const result = spawnSync('git', ['log', '-1', '--format=%B', commit], { encoding: 'utf8' })
+    if (result.status !== 0) {
+      return false
+    }
+    return CHANGE_ID_PATTERN.test(result.stdout)
+  } catch {
+    return false
+  }
+}
+
+// Get the hooks directory path
+export const getHooksDir = (): string => {
+  const gitDir = getGitDir()
+  return path.join(gitDir, 'hooks')
+}
+
+// Service interface
+export interface CommitHookServiceImpl {
+  readonly hasHook: () => Effect.Effect<boolean, NotGitRepoError>
+  readonly hasChangeId: (commit?: string) => Effect.Effect<boolean, NotGitRepoError>
+  readonly installHook: () => Effect.Effect<
+    void,
+    HookInstallError | NotGitRepoError,
+    ConfigServiceImpl
+  >
+  readonly ensureChangeId: () => Effect.Effect<
+    void,
+    HookInstallError | MissingChangeIdError | NotGitRepoError,
+    ConfigServiceImpl
+  >
+  readonly amendWithChangeId: () => Effect.Effect<void, HookInstallError | NotGitRepoError>
+}
+
+const CommitHookServiceImplLive: CommitHookServiceImpl = {
+  hasHook: () =>
+    Effect.try({
+      try: () => hasCommitMsgHook(),
+      catch: () => new NotGitRepoError({ message: 'Not in a git repository' }),
+    }),
+
+  hasChangeId: (commit = 'HEAD') =>
+    Effect.try({
+      try: () => commitHasChangeId(commit),
+      catch: () => new NotGitRepoError({ message: 'Not in a git repository' }),
+    }),
+
+  installHook: () =>
+    Effect.gen(function* () {
+      const configService = yield* ConfigService
+
+      // Get config to find Gerrit host
+      const config = yield* pipe(
+        configService.getCredentials,
+        Effect.mapError(
+          (e) => new HookInstallError({ message: `Failed to get config: ${e.message}` }),
+        ),
+      )
+
+      // Try to get hook via HTTP first (most reliable)
+      const normalizedHost = config.host.replace(/\/$/, '')
+      const hookUrl = `${normalizedHost}/tools/hooks/commit-msg`
+
+      yield* Console.log(`Installing commit-msg hook from ${config.host}...`)
+
+      const hookContent = yield* Effect.tryPromise({
+        try: async () => {
+          const response = await fetch(hookUrl)
+          if (!response.ok) {
+            throw new Error(`Failed to fetch hook: ${response.status} ${response.statusText}`)
+          }
+          return response.text()
+        },
+        catch: (error) =>
+          new HookInstallError({
+            message: `Failed to download commit-msg hook from ${hookUrl}: ${error}`,
+            cause: error,
+          }),
+      })
+
+      // Validate hook content (should be a shell script)
+      if (!hookContent.startsWith('#!')) {
+        yield* Effect.fail(
+          new HookInstallError({
+            message: 'Downloaded hook does not appear to be a valid script',
+          }),
+        )
+      }
+
+      // Get hooks directory and ensure it exists
+      const hooksDir = yield* Effect.try({
+        try: () => getHooksDir(),
+        catch: () => new NotGitRepoError({ message: 'Not in a git repository' }),
+      })
+
+      yield* Effect.try({
+        try: () => {
+          if (!fs.existsSync(hooksDir)) {
+            fs.mkdirSync(hooksDir, { recursive: true })
+          }
+        },
+        catch: (error) =>
+          new HookInstallError({
+            message: `Failed to create hooks directory: ${error}`,
+            cause: error,
+          }),
+      })
+
+      // Write hook file
+      const hookPath = path.join(hooksDir, 'commit-msg')
+
+      yield* Effect.try({
+        try: () => {
+          fs.writeFileSync(hookPath, hookContent, { mode: 0o755 })
+        },
+        catch: (error) =>
+          new HookInstallError({
+            message: `Failed to write commit-msg hook: ${error}`,
+            cause: error,
+          }),
+      })
+
+      yield* Console.log('commit-msg hook installed successfully')
+    }),
+
+  ensureChangeId: () =>
+    Effect.gen(function* () {
+      // Check if HEAD already has a Change-Id (using pure function directly)
+      if (commitHasChangeId()) {
+        return
+      }
+
+      // Check if hook is installed (using pure function directly)
+      if (!hasCommitMsgHook()) {
+        // Install hook and amend commit
+        yield* CommitHookServiceImplLive.installHook()
+        yield* CommitHookServiceImplLive.amendWithChangeId()
+      } else {
+        // Hook exists but commit doesn't have Change-Id
+        // This means the commit was created without the hook or hook failed
+        yield* Effect.fail(
+          new MissingChangeIdError({
+            message:
+              'Commit is missing Change-Id. The commit-msg hook is installed but did not run.\n' +
+              'Please amend your commit: git commit --amend',
+          }),
+        )
+      }
+    }),
+
+  amendWithChangeId: () =>
+    Effect.gen(function* () {
+      yield* Console.log('Amending commit to add Change-Id...')
+
+      yield* Effect.try({
+        try: () => {
+          // Use --no-edit to keep the same message, hook will add Change-Id
+          const result = spawnSync('git', ['commit', '--amend', '--no-edit'], {
+            encoding: 'utf8',
+            stdio: ['inherit', 'pipe', 'pipe'],
+          })
+
+          if (result.status !== 0) {
+            throw new Error(result.stderr || 'git commit --amend failed')
+          }
+        },
+        catch: (error) =>
+          new HookInstallError({
+            message: `Failed to amend commit: ${error}`,
+            cause: error,
+          }),
+      })
+
+      // Verify Change-Id was added
+      const hasId = commitHasChangeId()
+      if (!hasId) {
+        yield* Effect.fail(
+          new HookInstallError({
+            message: 'Failed to add Change-Id to commit. Hook may not be working correctly.',
+          }),
+        )
+      }
+
+      yield* Console.log('Change-Id added to commit')
+    }),
+}
+
+// Export service tag
+export const CommitHookService: Context.Tag<CommitHookServiceImpl, CommitHookServiceImpl> =
+  Context.GenericTag<CommitHookServiceImpl>('CommitHookService')
+
+export type CommitHookService = Context.Tag.Identifier<typeof CommitHookService>
+
+// Export service layer
+export const CommitHookServiceLive: Layer.Layer<CommitHookServiceImpl> = Layer.succeed(
+  CommitHookService,
+  CommitHookServiceImplLive,
+)