@aaronshaf/ger 0.1.0 → 0.1.3

package/src/services/review-strategy.ts

@@ -0,0 +1,373 @@
+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)
+
+// Dynamic import for Claude SDK
+const getClaudeSDK = () =>
+  Effect.tryPromise({
+    try: () => import('@anthropic-ai/claude-code'),
+    catch: () => null,
+  }).pipe(Effect.orElseSucceed(() => null))
+
+// 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()
+    }),
+}
+
+export const claudeSDKStrategy: ReviewStrategy = {
+  name: 'Claude SDK',
+  isAvailable: () =>
+    Effect.gen(function* () {
+      const sdk = yield* getClaudeSDK()
+
+      // Check if we have ANTHROPIC_API_KEY
+      const hasApiKey = Boolean(process.env.ANTHROPIC_API_KEY)
+
+      return Boolean(sdk && hasApiKey)
+    }),
+  executeReview: (prompt, options = {}) =>
+    Effect.gen(function* () {
+      const sdk = yield* getClaudeSDK()
+
+      if (!sdk) {
+        return yield* Effect.fail(
+          new ReviewStrategyError({
+            message: 'Claude SDK not available',
+          }),
+        )
+      }
+
+      const result = yield* Effect.tryPromise({
+        try: async () => {
+          const messages = []
+
+          for await (const message of sdk.query({
+            prompt,
+            options: {
+              maxTurns: 3,
+              customSystemPrompt:
+                options.systemPrompt ||
+                'You are a code review expert. Analyze code changes and provide constructive feedback.',
+              allowedTools: ['Read', 'Grep', 'Glob'],
+              cwd: options.cwd,
+            },
+          })) {
+            if (message.type === 'result' && message.subtype === 'success') {
+              return message.result
+            }
+          }
+
+          throw new Error('No result received from Claude SDK')
+        },
+        catch: (error) =>
+          new ReviewStrategyError({
+            message: `Claude SDK failed: ${error instanceof Error ? error.message : String(error)}`,
+            cause: error,
+          }),
+      })
+
+      return result
+    }),
+}
+
+// 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 = [
+          claudeSDKStrategy,
+          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 = [
+          claudeSDKStrategy,
+          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),
+  }),
+)

package/src/utils/review-formatters.ts

@@ -0,0 +1,89 @@
+import type { ChangeInfo, CommentInfo, MessageInfo } from '@/schemas/gerrit'
+import { sanitizeCDATA, escapeXML } from '@/utils/shell-safety'
+
+export const formatChangeAsXML = (change: ChangeInfo): string[] => {
+  const lines: string[] = []
+  lines.push(`  <change>`)
+  lines.push(`    <id>${escapeXML(change.change_id)}</id>`)
+  lines.push(`    <number>${change._number}</number>`)
+  lines.push(`    <subject><![CDATA[${sanitizeCDATA(change.subject)}]]></subject>`)
+  lines.push(`    <status>${escapeXML(change.status)}</status>`)
+  lines.push(`    <project>${escapeXML(change.project)}</project>`)
+  lines.push(`    <branch>${escapeXML(change.branch)}</branch>`)
+  lines.push(`    <owner>`)
+  if (change.owner?.name) {
+    lines.push(`      <name><![CDATA[${sanitizeCDATA(change.owner.name)}]]></name>`)
+  }
+  if (change.owner?.email) {
+    lines.push(`      <email>${escapeXML(change.owner.email)}</email>`)
+  }
+  lines.push(`    </owner>`)
+  lines.push(`    <created>${escapeXML(change.created || '')}</created>`)
+  lines.push(`    <updated>${escapeXML(change.updated || '')}</updated>`)
+  lines.push(`  </change>`)
+  return lines
+}
+
+export const formatCommentsAsXML = (comments: readonly CommentInfo[]): string[] => {
+  const lines: string[] = []
+  lines.push(`  <comments>`)
+  lines.push(`    <count>${comments.length}</count>`)
+  for (const comment of comments) {
+    lines.push(`    <comment>`)
+    if (comment.id) lines.push(`      <id>${escapeXML(comment.id)}</id>`)
+    if (comment.path) {
+      lines.push(`      <path><![CDATA[${sanitizeCDATA(comment.path)}]]></path>`)
+    }
+    if (comment.line) lines.push(`      <line>${comment.line}</line>`)
+    if (comment.author?.name) {
+      lines.push(`      <author><![CDATA[${sanitizeCDATA(comment.author.name)}]]></author>`)
+    }
+    if (comment.updated) lines.push(`      <updated>${escapeXML(comment.updated)}</updated>`)
+    if (comment.message) {
+      lines.push(`      <message><![CDATA[${sanitizeCDATA(comment.message)}]]></message>`)
+    }
+    if (comment.unresolved) lines.push(`      <unresolved>true</unresolved>`)
+    lines.push(`    </comment>`)
+  }
+  lines.push(`  </comments>`)
+  return lines
+}
+
+export const formatMessagesAsXML = (messages: readonly MessageInfo[]): string[] => {
+  const lines: string[] = []
+  lines.push(`  <messages>`)
+  lines.push(`    <count>${messages.length}</count>`)
+  for (const message of messages) {
+    lines.push(`    <message>`)
+    lines.push(`      <id>${escapeXML(message.id)}</id>`)
+    if (message.author?.name) {
+      lines.push(`      <author><![CDATA[${sanitizeCDATA(message.author.name)}]]></author>`)
+    }
+    if (message.author?._account_id) {
+      lines.push(`      <author_id>${message.author._account_id}</author_id>`)
+    }
+    lines.push(`      <date>${escapeXML(message.date)}</date>`)
+    if (message._revision_number) {
+      lines.push(`      <revision>${message._revision_number}</revision>`)
+    }
+    if (message.tag) {
+      lines.push(`      <tag>${escapeXML(message.tag)}</tag>`)
+    }
+    lines.push(`      <message><![CDATA[${sanitizeCDATA(message.message)}]]></message>`)
+    lines.push(`    </message>`)
+  }
+  lines.push(`  </messages>`)
+  return lines
+}
+
+export const flattenComments = (
+  commentsMap: Record<string, readonly CommentInfo[]>,
+): CommentInfo[] => {
+  const comments: CommentInfo[] = []
+  for (const [path, fileComments] of Object.entries(commentsMap)) {
+    for (const comment of fileComments) {
+      comments.push({ ...comment, path })
+    }
+  }
+  return comments
+}

package/src/utils/review-prompt-builder.ts

@@ -0,0 +1,111 @@
+import { Effect } from 'effect'
+import { type ApiError, GerritApiService } from '@/api/gerrit'
+import type { CommentInfo, MessageInfo } from '@/schemas/gerrit'
+import { flattenComments } from '@/utils/review-formatters'
+
+export const buildEnhancedPrompt = (
+  userPrompt: string,
+  systemPrompt: string,
+  changeId: string,
+  changedFiles: string[],
+): Effect.Effect<string, ApiError, GerritApiService> =>
+  Effect.gen(function* () {
+    const gerritApi = yield* GerritApiService
+
+    const change = yield* gerritApi.getChange(changeId)
+    const commentsMap = yield* gerritApi.getComments(changeId)
+    const messages = yield* gerritApi.getMessages(changeId)
+
+    const comments = flattenComments(commentsMap)
+
+    const promptLines: string[] = []
+
+    // System prompt FIRST - critical for response format instructions
+    promptLines.push(systemPrompt.trim())
+    promptLines.push('')
+
+    // User custom prompt (if provided)
+    if (userPrompt.trim()) {
+      promptLines.push('ADDITIONAL INSTRUCTIONS FROM USER:')
+      promptLines.push('===================================')
+      promptLines.push(userPrompt.trim())
+      promptLines.push('')
+    }
+
+    // Change metadata section
+    promptLines.push('CHANGE INFORMATION')
+    promptLines.push('==================')
+    promptLines.push(`Change ID: ${change.change_id}`)
+    promptLines.push(`Number: ${change._number}`)
+    promptLines.push(`Subject: ${change.subject}`)
+    promptLines.push(`Project: ${change.project}`)
+    promptLines.push(`Branch: ${change.branch}`)
+    promptLines.push(`Status: ${change.status}`)
+    if (change.owner?.name) {
+      promptLines.push(`Author: ${change.owner.name}`)
+    }
+    promptLines.push('')
+
+    // Existing comments section
+    if (comments.length > 0) {
+      promptLines.push('EXISTING COMMENTS')
+      promptLines.push('=================')
+      for (const comment of comments) {
+        const author = comment.author?.name || 'Unknown'
+        const date = comment.updated || 'Unknown date'
+        const location = comment.path
+          ? `${comment.path}${comment.line ? `:${comment.line}` : ''}`
+          : 'General'
+        promptLines.push(`[${author}] on ${location} (${date}):`)
+        promptLines.push(`  ${comment.message}`)
+        if (comment.unresolved) {
+          promptLines.push('  ⚠️ UNRESOLVED')
+        }
+        promptLines.push('')
+      }
+    }
+
+    // Review messages section
+    if (messages.length > 0) {
+      promptLines.push('REVIEW ACTIVITY')
+      promptLines.push('===============')
+      for (const message of messages) {
+        const author = message.author?.name || 'Unknown'
+        const cleanMessage = message.message.trim()
+
+        // Skip very short automated messages
+        if (
+          cleanMessage.length >= 10 &&
+          !cleanMessage.includes('Build') &&
+          !cleanMessage.includes('Patch')
+        ) {
+          promptLines.push(`[${author}] ${message.date}:`)
+          promptLines.push(`  ${cleanMessage}`)
+          promptLines.push('')
+        }
+      }
+    }
+
+    // Changed files section
+    promptLines.push('CHANGED FILES')
+    promptLines.push('=============')
+    for (const file of changedFiles) {
+      promptLines.push(`- ${file}`)
+    }
+    promptLines.push('')
+
+    // Git capabilities section
+    promptLines.push('GIT CAPABILITIES')
+    promptLines.push('================')
+    promptLines.push('You are running in a git repository with full access to:')
+    promptLines.push('- git diff, git show, git log for understanding changes')
+    promptLines.push('- git blame for code ownership context')
+    promptLines.push('- All project files for architectural understanding')
+    promptLines.push('- Use these tools to provide comprehensive review')
+    promptLines.push('')
+
+    promptLines.push('Focus your review on the changed files listed above, but feel free to')
+    promptLines.push('examine related files, tests, and project structure as needed.')
+
+    return promptLines.join('\n')
+  })