@aaronshaf/ger 2.0.10 → 3.0.1

package/src/services/review-strategy.ts

@@ -1,292 +0,0 @@
-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),
-  },
-)