@aaronshaf/ger 1.2.10 → 2.0.0

package/src/services/review-strategy.ts

@@ -0,0 +1,292 @@
+import { Context, Data, Effect, Layer } from 'effect'
+import { exec } from 'node:child_process'
+import { promisify } from 'node:util'
+
+const execAsync = promisify(exec)
+
+// Shared response extraction logic for all AI tools
+const extractResponse = (stdout: string): string => {
+  // Extract response from <response> tags or use full output
+  const responseMatch = stdout.match(/<response>([\s\S]*?)<\/response>/i)
+  return responseMatch ? responseMatch[1].trim() : stdout.trim()
+}
+
+// Simple strategy focused only on review needs
+export interface ReviewStrategyErrorFields {
+  readonly message: string
+  readonly cause?: unknown
+}
+
+const ReviewStrategyErrorBase = Data.TaggedError(
+  'ReviewStrategyError',
+)<ReviewStrategyErrorFields> as unknown
+
+export class ReviewStrategyError
+  extends (ReviewStrategyErrorBase as new (
+    args: ReviewStrategyErrorFields,
+  ) => ReviewStrategyErrorFields & Error & { readonly _tag: 'ReviewStrategyError' })
+  implements Error
+{
+  readonly name = 'ReviewStrategyError'
+}
+
+// Review strategy interface - focused on specific review patterns
+export interface ReviewStrategy {
+  readonly name: string
+  readonly isAvailable: () => Effect.Effect<boolean, never>
+  readonly executeReview: (
+    prompt: string,
+    options?: { cwd?: string; systemPrompt?: string },
+  ) => Effect.Effect<string, ReviewStrategyError>
+}
+
+// Strategy implementations for different AI tools
+export const claudeCliStrategy: ReviewStrategy = {
+  name: 'Claude CLI',
+  isAvailable: () =>
+    Effect.gen(function* () {
+      const result = yield* Effect.tryPromise({
+        try: () => execAsync('which claude'),
+        catch: () => null,
+      }).pipe(Effect.orElseSucceed(() => null))
+
+      return Boolean(result && result.stdout.trim())
+    }),
+  executeReview: (prompt, options = {}) =>
+    Effect.gen(function* () {
+      const result = yield* Effect.tryPromise({
+        try: async () => {
+          const child = require('node:child_process').spawn('claude -p', {
+            shell: true,
+            stdio: ['pipe', 'pipe', 'pipe'],
+            cwd: options.cwd || process.cwd(),
+          })
+
+          child.stdin.write(prompt)
+          child.stdin.end()
+
+          let stdout = ''
+          let stderr = ''
+
+          child.stdout.on('data', (data: Buffer) => {
+            stdout += data.toString()
+          })
+
+          child.stderr.on('data', (data: Buffer) => {
+            stderr += data.toString()
+          })
+
+          return new Promise<{ stdout: string; stderr: string }>((resolve, reject) => {
+            child.on('close', (code: number) => {
+              if (code !== 0) {
+                reject(new Error(`Claude CLI exited with code ${code}: ${stderr}`))
+              } else {
+                resolve({ stdout, stderr })
+              }
+            })
+
+            child.on('error', reject)
+          })
+        },
+        catch: (error) =>
+          new ReviewStrategyError({
+            message: `Claude CLI failed: ${error instanceof Error ? error.message : String(error)}`,
+            cause: error,
+          }),
+      })
+
+      return extractResponse(result.stdout)
+    }),
+}
+
+export const geminiCliStrategy: ReviewStrategy = {
+  name: 'Gemini CLI',
+  isAvailable: () =>
+    Effect.gen(function* () {
+      const result = yield* Effect.tryPromise({
+        try: () => execAsync('which gemini'),
+        catch: () => null,
+      }).pipe(Effect.orElseSucceed(() => null))
+
+      return Boolean(result && result.stdout.trim())
+    }),
+  executeReview: (prompt, options = {}) =>
+    Effect.gen(function* () {
+      const result = yield* Effect.tryPromise({
+        try: async () => {
+          const child = require('node:child_process').spawn('gemini -p', {
+            shell: true,
+            stdio: ['pipe', 'pipe', 'pipe'],
+            cwd: options.cwd || process.cwd(),
+          })
+
+          child.stdin.write(prompt)
+          child.stdin.end()
+
+          let stdout = ''
+          let stderr = ''
+
+          child.stdout.on('data', (data: Buffer) => {
+            stdout += data.toString()
+          })
+
+          child.stderr.on('data', (data: Buffer) => {
+            stderr += data.toString()
+          })
+
+          return new Promise<{ stdout: string; stderr: string }>((resolve, reject) => {
+            child.on('close', (code: number) => {
+              if (code !== 0) {
+                reject(new Error(`Gemini CLI exited with code ${code}: ${stderr}`))
+              } else {
+                resolve({ stdout, stderr })
+              }
+            })
+
+            child.on('error', reject)
+          })
+        },
+        catch: (error) =>
+          new ReviewStrategyError({
+            message: `Gemini CLI failed: ${error instanceof Error ? error.message : String(error)}`,
+            cause: error,
+          }),
+      })
+
+      return extractResponse(result.stdout)
+    }),
+}
+
+export const openCodeCliStrategy: ReviewStrategy = {
+  name: 'OpenCode CLI',
+  isAvailable: () =>
+    Effect.gen(function* () {
+      const result = yield* Effect.tryPromise({
+        try: () => execAsync('which opencode'),
+        catch: () => null,
+      }).pipe(Effect.orElseSucceed(() => null))
+
+      return Boolean(result && result.stdout.trim())
+    }),
+  executeReview: (prompt, options = {}) =>
+    Effect.gen(function* () {
+      const result = yield* Effect.tryPromise({
+        try: async () => {
+          const child = require('node:child_process').spawn('opencode -p', {
+            shell: true,
+            stdio: ['pipe', 'pipe', 'pipe'],
+            cwd: options.cwd || process.cwd(),
+          })
+
+          child.stdin.write(prompt)
+          child.stdin.end()
+
+          let stdout = ''
+          let stderr = ''
+
+          child.stdout.on('data', (data: Buffer) => {
+            stdout += data.toString()
+          })
+
+          child.stderr.on('data', (data: Buffer) => {
+            stderr += data.toString()
+          })
+
+          return new Promise<{ stdout: string; stderr: string }>((resolve, reject) => {
+            child.on('close', (code: number) => {
+              if (code !== 0) {
+                reject(new Error(`OpenCode CLI exited with code ${code}: ${stderr}`))
+              } else {
+                resolve({ stdout, stderr })
+              }
+            })
+
+            child.on('error', reject)
+          })
+        },
+        catch: (error) =>
+          new ReviewStrategyError({
+            message: `OpenCode CLI failed: ${error instanceof Error ? error.message : String(error)}`,
+            cause: error,
+          }),
+      })
+
+      return extractResponse(result.stdout)
+    }),
+}
+
+// Review service interface using strategy pattern
+export interface ReviewStrategyServiceImpl {
+  readonly getAvailableStrategies: () => Effect.Effect<ReviewStrategy[], never>
+  readonly selectStrategy: (
+    preferredName?: string,
+  ) => Effect.Effect<ReviewStrategy, ReviewStrategyError>
+  readonly executeWithStrategy: (
+    strategy: ReviewStrategy,
+    prompt: string,
+    options?: { cwd?: string; systemPrompt?: string },
+  ) => Effect.Effect<string, ReviewStrategyError>
+}
+
+// Export the service tag with explicit type
+export const ReviewStrategyService: Context.Tag<
+  ReviewStrategyServiceImpl,
+  ReviewStrategyServiceImpl
+> = Context.GenericTag<ReviewStrategyServiceImpl>('ReviewStrategyService')
+
+export type ReviewStrategyService = Context.Tag.Identifier<typeof ReviewStrategyService>
+
+export const ReviewStrategyServiceLive: Layer.Layer<ReviewStrategyServiceImpl> = Layer.succeed(
+  ReviewStrategyService,
+  {
+    getAvailableStrategies: () =>
+      Effect.gen(function* () {
+        const strategies = [claudeCliStrategy, geminiCliStrategy, openCodeCliStrategy]
+        const available: ReviewStrategy[] = []
+
+        for (const strategy of strategies) {
+          const isAvailable = yield* strategy.isAvailable()
+          if (isAvailable) {
+            available.push(strategy)
+          }
+        }
+
+        return available
+      }),
+
+    selectStrategy: (preferredName?: string) =>
+      Effect.gen(function* () {
+        const strategies = [claudeCliStrategy, geminiCliStrategy, openCodeCliStrategy]
+        const available: ReviewStrategy[] = []
+
+        for (const strategy of strategies) {
+          const isAvailable = yield* strategy.isAvailable()
+          if (isAvailable) {
+            available.push(strategy)
+          }
+        }
+
+        if (available.length === 0) {
+          return yield* Effect.fail(
+            new ReviewStrategyError({
+              message: 'No AI tools available. Please install claude, gemini, or opencode CLI.',
+            }),
+          )
+        }
+
+        if (preferredName) {
+          const preferred = available.find((s: ReviewStrategy) =>
+            s.name.toLowerCase().includes(preferredName.toLowerCase()),
+          )
+          if (preferred) {
+            return preferred
+          }
+        }
+
+        return available[0] // Return first available
+      }),
+
+    executeWithStrategy: (strategy, prompt, options = {}) =>
+      strategy.executeReview(prompt, options),
+  },
+)

package/src/test-utils/mock-generator.ts

@@ -0,0 +1,138 @@
+import type { Schema } from '@effect/schema'
+import type { ChangeInfo, FileDiffContent, FileInfo, RevisionInfoType } from '@/schemas/gerrit'
+
+export const generateMockChange = (
+  overrides?: Partial<Schema.Schema.Type<typeof ChangeInfo>>,
+): Schema.Schema.Type<typeof ChangeInfo> => {
+  const base: Schema.Schema.Type<typeof ChangeInfo> = {
+    id: 'myProject~master~I8473b95934b5732ac55d26311a706c9c2bde9940',
+    project: 'myProject',
+    branch: 'master',
+    change_id: 'I8473b95934b5732ac55d26311a706c9c2bde9940',
+    subject: 'Implementing new feature',
+    status: 'NEW' as const,
+    created: '2023-12-01 10:00:00.000000000',
+    updated: '2023-12-01 15:30:00.000000000',
+    insertions: 25,
+    deletions: 3,
+    _number: 12345,
+    owner: {
+      _account_id: 1000096,
+      name: 'John Developer',
+      email: 'john@example.com',
+      username: 'jdeveloper',
+    },
+  }
+
+  return { ...base, ...overrides }
+}
+
+export const generateMockFiles = (): Record<string, Schema.Schema.Type<typeof FileInfo>> => {
+  return {
+    'src/main.ts': {
+      status: 'M' as const,
+      lines_inserted: 15,
+      lines_deleted: 3,
+      size_delta: 120,
+      size: 1200,
+    },
+    'tests/main.test.ts': {
+      status: 'A' as const,
+      lines_inserted: 45,
+      lines_deleted: 0,
+      size_delta: 450,
+      size: 450,
+    },
+  }
+}
+
+export const generateMockFileDiff = (): Schema.Schema.Type<typeof FileDiffContent> => {
+  return {
+    content: [
+      {
+        ab: ['function main() {', '  console.log("Hello, world!")'],
+      },
+      {
+        a: ['  return 0'],
+        b: ['  return process.exit(0)'],
+      },
+      {
+        ab: ['}'],
+      },
+    ],
+    change_type: 'MODIFIED' as const,
+    diff_header: ['--- a/src/main.ts', '+++ b/src/main.ts'],
+  }
+}
+
+export const generateMockAccount = () => ({
+  _account_id: 1000096,
+  name: 'Test User',
+  email: 'test@example.com',
+  username: 'testuser',
+})
+
+/**
+ * Generate mock revision data to be included in ChangeInfo
+ * Used when simulating API responses with CURRENT_REVISION option
+ */
+export const generateMockRevision = (
+  patchsetNumber = 1,
+  sha = '54795ce71b351480c887e92aa0e5b9a57aef58ab',
+): RevisionInfoType => ({
+  kind: 'REWORK',
+  _number: patchsetNumber,
+  created: '2023-12-01 10:00:00.000000000',
+  uploader: {
+    _account_id: 1000096,
+    name: 'John Developer',
+    email: 'john@example.com',
+  },
+  ref: `refs/changes/${String(Math.floor(12345 % 100)).padStart(2, '0')}/12345/${patchsetNumber}`,
+  fetch: {
+    http: {
+      url: 'https://gerrit.example.com/myProject',
+      ref: `refs/changes/${String(Math.floor(12345 % 100)).padStart(2, '0')}/12345/${patchsetNumber}`,
+    },
+  },
+  commit: {
+    commit: sha,
+    parents: [
+      {
+        commit: 'parent-sha-1234567890abcdef',
+        subject: 'Parent commit',
+      },
+    ] as const,
+    author: {
+      name: 'John Developer',
+      email: 'john@example.com',
+      date: '2023-12-01 10:00:00.000000000',
+    },
+    committer: {
+      name: 'John Developer',
+      email: 'john@example.com',
+      date: '2023-12-01 10:00:00.000000000',
+    },
+    subject: 'Implementing new feature',
+    message: 'Implementing new feature\n\nThis is the full commit message.',
+  },
+})
+
+/**
+ * Generate mock change with revision data (simulates API response with CURRENT_REVISION option)
+ */
+export const generateMockChangeWithRevision = (
+  overrides?: Partial<Schema.Schema.Type<typeof ChangeInfo>>,
+  patchsetNumber = 1,
+): Schema.Schema.Type<typeof ChangeInfo> => {
+  const sha = '54795ce71b351480c887e92aa0e5b9a57aef58ab'
+  const revision = generateMockRevision(patchsetNumber, sha)
+
+  return generateMockChange({
+    current_revision: sha,
+    revisions: {
+      [sha]: revision,
+    },
+    ...overrides,
+  })
+}

package/src/utils/change-id.test.ts

@@ -0,0 +1,98 @@
+import { describe, expect, test } from 'bun:test'
+import {
+  isChangeId,
+  isChangeNumber,
+  isValidChangeIdentifier,
+  normalizeChangeIdentifier,
+  getIdentifierType,
+} from './change-id'
+
+describe('change-id utilities', () => {
+  describe('isChangeId', () => {
+    test('returns true for valid Change-ID format', () => {
+      expect(isChangeId('If5a3ae8cb5a107e187447802358417f311d0c4b1')).toBe(true)
+      expect(isChangeId('I0123456789abcdef0123456789abcdef01234567')).toBe(true)
+    })
+
+    test('returns false for invalid Change-ID format', () => {
+      expect(isChangeId('392385')).toBe(false)
+      expect(isChangeId('if5a3ae8cb5a107e187447802358417f311d0c4b1')).toBe(false) // lowercase 'i'
+      expect(isChangeId('If5a3ae8cb5a107e187447802358417f311d0c4b')).toBe(false) // too short
+      expect(isChangeId('If5a3ae8cb5a107e187447802358417f311d0c4b11')).toBe(false) // too long
+      expect(isChangeId('Gf5a3ae8cb5a107e187447802358417f311d0c4b1')).toBe(false) // wrong prefix
+    })
+  })
+
+  describe('isChangeNumber', () => {
+    test('returns true for numeric strings', () => {
+      expect(isChangeNumber('392385')).toBe(true)
+      expect(isChangeNumber('12345')).toBe(true)
+      expect(isChangeNumber('1')).toBe(true)
+    })
+
+    test('returns false for non-numeric strings', () => {
+      expect(isChangeNumber('If5a3ae8cb5a107e187447802358417f311d0c4b1')).toBe(false)
+      expect(isChangeNumber('abc')).toBe(false)
+      expect(isChangeNumber('123abc')).toBe(false)
+      expect(isChangeNumber('')).toBe(false)
+    })
+  })
+
+  describe('isValidChangeIdentifier', () => {
+    test('returns true for valid change numbers', () => {
+      expect(isValidChangeIdentifier('392385')).toBe(true)
+      expect(isValidChangeIdentifier('12345')).toBe(true)
+    })
+
+    test('returns true for valid Change-IDs', () => {
+      expect(isValidChangeIdentifier('If5a3ae8cb5a107e187447802358417f311d0c4b1')).toBe(true)
+      expect(isValidChangeIdentifier('I0123456789abcdef0123456789abcdef01234567')).toBe(true)
+    })
+
+    test('returns false for invalid identifiers', () => {
+      expect(isValidChangeIdentifier('abc')).toBe(false)
+      expect(isValidChangeIdentifier('I123')).toBe(false)
+      expect(isValidChangeIdentifier('')).toBe(false)
+    })
+  })
+
+  describe('normalizeChangeIdentifier', () => {
+    test('returns trimmed change number', () => {
+      expect(normalizeChangeIdentifier('392385')).toBe('392385')
+      expect(normalizeChangeIdentifier(' 392385 ')).toBe('392385')
+    })
+
+    test('returns trimmed Change-ID', () => {
+      expect(normalizeChangeIdentifier('If5a3ae8cb5a107e187447802358417f311d0c4b1')).toBe(
+        'If5a3ae8cb5a107e187447802358417f311d0c4b1',
+      )
+      expect(normalizeChangeIdentifier(' If5a3ae8cb5a107e187447802358417f311d0c4b1 ')).toBe(
+        'If5a3ae8cb5a107e187447802358417f311d0c4b1',
+      )
+    })
+
+    test('throws error for invalid identifiers', () => {
+      expect(() => normalizeChangeIdentifier('abc')).toThrow(/Invalid change identifier/)
+      expect(() => normalizeChangeIdentifier('I123')).toThrow(/Invalid change identifier/)
+      expect(() => normalizeChangeIdentifier('')).toThrow(/Invalid change identifier/)
+    })
+  })
+
+  describe('getIdentifierType', () => {
+    test('returns "change-number" for numeric strings', () => {
+      expect(getIdentifierType('392385')).toBe('change-number')
+      expect(getIdentifierType(' 12345 ')).toBe('change-number')
+    })
+
+    test('returns "change-id" for Change-ID format', () => {
+      expect(getIdentifierType('If5a3ae8cb5a107e187447802358417f311d0c4b1')).toBe('change-id')
+      expect(getIdentifierType(' If5a3ae8cb5a107e187447802358417f311d0c4b1 ')).toBe('change-id')
+    })
+
+    test('returns "invalid" for invalid identifiers', () => {
+      expect(getIdentifierType('abc')).toBe('invalid')
+      expect(getIdentifierType('I123')).toBe('invalid')
+      expect(getIdentifierType('')).toBe('invalid')
+    })
+  })
+})

package/src/utils/change-id.ts

@@ -0,0 +1,63 @@
+/**
+ * Utilities for handling Gerrit change identifiers
+ * Supports both numeric change numbers (e.g., "392385") and Change-IDs (e.g., "If5a3ae8cb5a107e187447802358417f311d0c4b1")
+ */
+
+/**
+ * Validates if a string is a valid Gerrit Change-ID format
+ * Change-IDs start with 'I' followed by a 40-character SHA-1 hash
+ */
+export function isChangeId(value: string): boolean {
+  return /^I[0-9a-f]{40}$/.test(value)
+}
+
+/**
+ * Validates if a string is a numeric change number
+ */
+export function isChangeNumber(value: string): boolean {
+  return /^\d+$/.test(value)
+}
+
+/**
+ * Validates if a string is either a valid Change-ID or change number
+ */
+export function isValidChangeIdentifier(value: string): boolean {
+  return isChangeId(value) || isChangeNumber(value)
+}
+
+/**
+ * Normalizes a change identifier for use with Gerrit API
+ * Gerrit API accepts both formats, so we just validate and return as-is
+ *
+ * @param value - Either a numeric change number or a Change-ID
+ * @returns The normalized identifier
+ * @throws Error if the identifier is invalid
+ */
+export function normalizeChangeIdentifier(value: string): string {
+  const trimmed = value.trim()
+
+  if (!isValidChangeIdentifier(trimmed)) {
+    throw new Error(
+      `Invalid change identifier: "${value}". Expected either a numeric change number (e.g., "392385") or a Change-ID starting with "I" (e.g., "If5a3ae8cb5a107e187447802358417f311d0c4b1")`,
+    )
+  }
+
+  return trimmed
+}
+
+/**
+ * Gets a user-friendly description of what type of identifier was provided
+ */
+export function getIdentifierType(value: string): 'change-number' | 'change-id' | 'invalid' {
+  const trimmed = value.trim()
+
+  if (isChangeNumber(trimmed)) {
+    return 'change-number'
+  }
+
+  if (isChangeId(trimmed)) {
+    return 'change-id'
+  }
+
+  return 'invalid'
+}