@aaronshaf/ger 0.1.1 → 0.1.4

package/bun.lock

@@ -11,18 +11,18 @@
         "chalk": "^5.6.0",
         "cli-table3": "^0.6.5",
         "commander": "^14.0.0",
-        "effect": "^3.17.8",
+        "effect": "^3.17.9",
         "signal-exit": "3.0.7",
       },
       "devDependencies": {
-        "@biomejs/biome": "^2.2.0",
+        "@biomejs/biome": "^2.2.2",
         "@types/node": "^24.3.0",
         "ast-grep": "^0.1.0",
-        "bun-types": "^1.2.20",
+        "bun-types": "^1.2.21",
         "husky": "^9.1.7",
         "lint-staged": "^16.1.5",
         "msw": "^2.10.5",
-        "oxlint": "^1.12.0",
+        "oxlint": "^1.13.0",
         "typescript": "^5.9.2",
       },
       "peerDependencies": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aaronshaf/ger",
-  "version": "0.1.1",
+  "version": "0.1.4",
   "module": "index.ts",
   "type": "module",
   "bin": {

package/src/cli/commands/review.ts

@@ -1,5 +1,5 @@
 import { Effect, pipe, Schema, Layer } from 'effect'
-import { AiService } from '@/services/ai'
+import { ReviewStrategyService, type ReviewStrategy } from '@/services/review-strategy'
 import { commentCommandWithInput } from './comment'
 import { Console } from 'effect'
 import { type ApiError, GerritApiService } from '@/api/gerrit'
@@ -89,6 +89,8 @@ interface ReviewOptions {
   comment?: boolean
   yes?: boolean
   prompt?: string
+  provider?: string
+  systemPrompt?: string
 }
 
 // Schema for validating AI-generated inline comments
@@ -314,21 +316,28 @@ const promptUser = (message: string): Effect.Effect<boolean, never> =>
 
 export const reviewCommand = (changeId: string, options: ReviewOptions = {}) =>
   Effect.gen(function* () {
-    const aiService = yield* AiService
+    const reviewStrategy = yield* ReviewStrategyService
     const gitService = yield* GitWorktreeService
 
-    // Load default prompts first
+    // Load default prompts
     const prompts = yield* loadDefaultPrompts
 
     // Validate preconditions
     yield* gitService.validatePreconditions()
 
-    // Check for AI tool availability
-    yield* Console.log('→ Checking for AI tool availability...')
-    const aiTool = yield* aiService
-      .detectAiTool()
-      .pipe(Effect.catchTag('NoAiToolFoundError', (error) => Effect.fail(new Error(error.message))))
-    yield* Console.log(`✓ Found AI tool: ${aiTool}`)
+    // Check for available AI strategies
+    yield* Console.log('→ Checking AI tool availability...')
+    const availableStrategies = yield* reviewStrategy.getAvailableStrategies()
+
+    if (availableStrategies.length === 0) {
+      return yield* Effect.fail(
+        new Error('No AI tools available. Please install claude, gemini, or codex CLI.'),
+      )
+    }
+
+    // Select strategy based on user preference
+    const selectedStrategy = yield* reviewStrategy.selectStrategy(options.provider)
+    yield* Console.log(`✓ Using AI tool: ${selectedStrategy.name}`)
 
     // Load custom review prompt if provided
     let userReviewPrompt = prompts.defaultReviewPrompt
@@ -379,36 +388,39 @@ export const reviewCommand = (changeId: string, options: ReviewOptions = {}) =>
               changedFiles,
             )
 
+            // Run inline review using selected strategy
             if (options.debug) {
-              yield* Console.log('[DEBUG] Running AI for inline comments...')
+              yield* Console.log(`[DEBUG] Running inline review with ${selectedStrategy.name}`)
               yield* Console.log(`[DEBUG] Working directory: ${worktreeInfo.path}`)
             }
 
-            // Run inline review with worktree as working directory
-            const inlineResponse = yield* aiService
-              .runPrompt(inlinePrompt, '', { cwd: worktreeInfo.path })
+            const inlineResponse = yield* reviewStrategy
+              .executeWithStrategy(selectedStrategy, inlinePrompt, {
+                cwd: worktreeInfo.path,
+                systemPrompt: options.systemPrompt || prompts.inlineReviewSystemPrompt,
+              })
               .pipe(
-                Effect.catchTag('AiResponseParseError', (error) =>
+                Effect.catchTag('ReviewStrategyError', (error) =>
                   Effect.gen(function* () {
-                    yield* Console.error(`✗ Failed to parse AI response: ${error.message}`)
-                    yield* Console.error('Raw AI output:')
-                    yield* Console.error('-'.repeat(80))
-                    yield* Console.error(error.rawOutput || 'No output captured')
-                    yield* Console.error('-'.repeat(80))
-                    return yield* Effect.fail(error)
+                    yield* Console.error(`✗ Inline review failed: ${error.message}`)
+                    return yield* Effect.fail(new Error(error.message))
                   }),
                 ),
-                Effect.catchTag('AiServiceError', (error) =>
-                  Effect.die(new Error(`AI service error: ${error.message}`)),
-                ),
               )
 
             if (options.debug) {
-              yield* Console.log(`[DEBUG] Inline response:\n${inlineResponse}`)
+              yield* Console.log(`[DEBUG] Inline review completed`)
+              yield* Console.log(`[DEBUG] Response length: ${inlineResponse.length} chars`)
             }
 
-            // Response is already extracted by runPrompt
-            const extractedInlineResponse = inlineResponse
+            // Response content is ready for parsing
+            const extractedInlineResponse = inlineResponse.trim()
+
+            if (options.debug) {
+              yield* Console.log(
+                `[DEBUG] Extracted response for parsing:\n${extractedInlineResponse}`,
+              )
+            }
 
             // Parse JSON array from response
             const inlineCommentsArray = yield* Effect.tryPromise({
@@ -418,8 +430,9 @@ export const reviewCommand = (changeId: string, options: ReviewOptions = {}) =>
               Effect.catchAll((error) =>
                 Effect.gen(function* () {
                   yield* Console.error(`✗ Failed to parse inline comments JSON: ${error}`)
+                  yield* Console.error(`Raw extracted response: "${extractedInlineResponse}"`)
                   if (!options.debug) {
-                    yield* Console.error('Run with --debug to see raw AI output')
+                    yield* Console.error('Run with --debug to see full AI output')
                   }
                   return yield* Effect.fail(error)
                 }),
@@ -459,35 +472,32 @@ export const reviewCommand = (changeId: string, options: ReviewOptions = {}) =>
               changedFiles,
             )
 
+            // Run overall review using selected strategy
             if (options.debug) {
-              yield* Console.log('[DEBUG] Running AI for overall review...')
+              yield* Console.log(`[DEBUG] Running overall review with ${selectedStrategy.name}`)
             }
 
-            // Run overall review
-            const overallResponse = yield* aiService
-              .runPrompt(overallPrompt, '', { cwd: worktreeInfo.path })
+            const overallResponse = yield* reviewStrategy
+              .executeWithStrategy(selectedStrategy, overallPrompt, {
+                cwd: worktreeInfo.path,
+                systemPrompt: options.systemPrompt || prompts.overallReviewSystemPrompt,
+              })
               .pipe(
-                Effect.catchTag('AiResponseParseError', (error) =>
+                Effect.catchTag('ReviewStrategyError', (error) =>
                   Effect.gen(function* () {
-                    yield* Console.error(`✗ Failed to parse AI response: ${error.message}`)
-                    yield* Console.error('Raw AI output:')
-                    yield* Console.error('-'.repeat(80))
-                    yield* Console.error(error.rawOutput || 'No output captured')
-                    yield* Console.error('-'.repeat(80))
-                    return yield* Effect.fail(error)
+                    yield* Console.error(`✗ Overall review failed: ${error.message}`)
+                    return yield* Effect.fail(new Error(error.message))
                   }),
                 ),
-                Effect.catchTag('AiServiceError', (error) =>
-                  Effect.die(new Error(`AI service error: ${error.message}`)),
-                ),
               )
 
             if (options.debug) {
-              yield* Console.log(`[DEBUG] Overall response:\n${overallResponse}`)
+              yield* Console.log(`[DEBUG] Overall review completed`)
+              yield* Console.log(`[DEBUG] Response length: ${overallResponse.length} chars`)
             }
 
-            // Response is already extracted by runPrompt
-            const extractedOverallResponse = overallResponse
+            // Response content is ready for use
+            const extractedOverallResponse = overallResponse.trim()
 
             // Handle overall review output/posting
             yield* handleOverallReview(extractedOverallResponse, changeId, options)
@@ -549,8 +559,6 @@ const handleInlineComments = (
         } else {
           yield* Console.log('→ Inline comments not posted')
         }
-      } else {
-        yield* Console.log('\n→ No valid inline comments to post')
       }
     }
   })

package/src/cli/index.ts

@@ -25,7 +25,7 @@ import { Command } from 'commander'
 import { Effect } from 'effect'
 import { GerritApiServiceLive } from '@/api/gerrit'
 import { ConfigServiceLive } from '@/services/config'
-import { AiServiceLive } from '@/services/ai-enhanced'
+import { ReviewStrategyServiceLive } from '@/services/review-strategy'
 import { GitWorktreeServiceLive } from '@/services/git-worktree'
 import { abandonCommand } from './commands/abandon'
 import { commentCommand } from './commands/comment'
@@ -368,10 +368,15 @@ program
   .option('-y, --yes', 'Skip confirmation prompts when posting comments')
   .option('--debug', 'Show debug output including AI responses')
   .option('--prompt <file>', 'Path to custom review prompt file (e.g., ~/prompts/review.md)')
+  .option(
+    '--provider <provider>',
+    'Preferred AI provider (claude-sdk, claude, gemini, codex, opencode)',
+  )
+  .option('--system-prompt <prompt>', 'Custom system prompt for the AI')
   .addHelpText(
     'after',
     `
-This command uses AI (claude, llm, or opencode CLI) to review a Gerrit change.
+This command uses AI (Claude SDK, claude CLI, gemini CLI, codex CLI, or opencode CLI) to review a Gerrit change.
 It performs a two-stage review process:
 
 1. Generates inline comments for specific code issues
@@ -382,7 +387,7 @@ Use --comment to post the review to Gerrit (with confirmation prompts).
 Use --comment --yes to post without confirmation.
 
 Requirements:
-  - One of these AI tools must be installed: claude, llm, or opencode
+  - One of these AI tools must be available: Claude SDK (ANTHROPIC_API_KEY), claude CLI, gemini CLI, codex CLI, or opencode CLI
   - Gerrit credentials must be configured (run 'ger setup' first)
 
 Examples:
@@ -406,8 +411,10 @@ Examples:
         yes: options.yes,
         debug: options.debug,
         prompt: options.prompt,
+        provider: options.provider,
+        systemPrompt: options.systemPrompt,
       }).pipe(
-        Effect.provide(AiServiceLive),
+        Effect.provide(ReviewStrategyServiceLive),
         Effect.provide(GerritApiServiceLive),
         Effect.provide(ConfigServiceLive),
         Effect.provide(GitWorktreeServiceLive),

package/src/services/review-strategy.ts

@@ -0,0 +1,308 @@
+import { Context, Data, Effect, Layer } from 'effect'
+import { Console } from 'effect'
+import { exec } from 'node:child_process'
+import { promisify } from 'node:util'
+
+const execAsync = promisify(exec)
+
+// Simple strategy focused only on review needs
+export class ReviewStrategyError extends Data.TaggedError('ReviewStrategyError')<{
+  message: string
+  cause?: unknown
+}> {}
+
+// 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,
+          }),
+      })
+
+      // Extract response from <response> tags or use full output
+      const responseMatch = result.stdout.match(/<response>([\s\S]*?)<\/response>/i)
+      return responseMatch ? responseMatch[1].trim() : result.stdout.trim()
+    }),
+}
+
+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 result.stdout.trim()
+    }),
+}
+
+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 result.stdout.trim()
+    }),
+}
+
+export const codexCliStrategy: ReviewStrategy = {
+  name: 'Codex CLI',
+  isAvailable: () =>
+    Effect.gen(function* () {
+      const result = yield* Effect.tryPromise({
+        try: () => execAsync('which codex'),
+        catch: () => null,
+      }).pipe(Effect.orElseSucceed(() => null))
+
+      return Boolean(result && result.stdout.trim())
+    }),
+  executeReview: (prompt, options = {}) =>
+    Effect.gen(function* () {
+      const command = `codex exec "${prompt.replace(/"/g, '\\"')}"`
+
+      const result = yield* Effect.tryPromise({
+        try: () => execAsync(command, { cwd: options.cwd }),
+        catch: (error) =>
+          new ReviewStrategyError({
+            message: `Codex CLI failed: ${error instanceof Error ? error.message : String(error)}`,
+            cause: error,
+          }),
+      })
+
+      return result.stdout.trim()
+    }),
+}
+
+// Review service using strategy pattern
+export class ReviewStrategyService extends Context.Tag('ReviewStrategyService')<
+  ReviewStrategyService,
+  {
+    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 const ReviewStrategyServiceLive = Layer.succeed(
+  ReviewStrategyService,
+  ReviewStrategyService.of({
+    getAvailableStrategies: () =>
+      Effect.gen(function* () {
+        const strategies = [
+          claudeCliStrategy,
+          geminiCliStrategy,
+          openCodeCliStrategy,
+          codexCliStrategy,
+        ]
+        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,
+          codexCliStrategy,
+        ]
+        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 codex 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),
+  }),
+)