@aaronshaf/ger 0.1.0 → 0.1.3

package/src/cli/index.ts

@@ -25,7 +25,8 @@ 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'
 import { commentsCommand } from './commands/comments'
@@ -367,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
@@ -381,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:
@@ -405,10 +411,13 @@ 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),
       )
       await Effect.runPromise(effect)
     } catch (error) {

package/src/prompts/default-review.md

@@ -1,22 +1,23 @@
-# Code Review Guidelines
+# Engineering Code Review - Signal Over Noise
 
-You are reviewing a Gerrit change set. Provide thorough, constructive feedback focused on technical excellence and maintainability.
+You are conducting a technical code review for experienced engineers. **PRIORITY: Find actual problems, not generate busy work.**
 
-## Review Philosophy
+## Core Principles
 
-1. **Understand First, Critique Second**
-   - Fully comprehend the author's intent before identifying issues
-   - Read COMPLETE files, not just diffs
-   - Check if apparent issues are handled elsewhere in the change
-   - Consider the broader architectural context
-   - Verify you're reviewing the LATEST patchset version
+**SIGNAL > NOISE**: Only comment on issues that materially impact correctness, security, performance, or maintainability. Silence is better than noise.
 
-2. **Be Direct and Constructive**
-   - Focus on substantive technical concerns
-   - Explain WHY something is problematic, not just what
-   - Provide actionable suggestions when identifying issues
-   - Assume the author has domain expertise
-   - Ask clarifying questions when intent is unclear
+**NO PRAISE NEEDED**: Don't compliment good code. Engineers expect competent code by default.
+
+**EMPTY RESPONSES ARE VALID**: Small changes without issues should result in empty inline comments. The overall review can simply note "No significant issues found."
+
+**FOCUS ON REAL PROBLEMS**: 
+- Bugs that will cause runtime failures
+- Security vulnerabilities 
+- Performance bottlenecks
+- Architectural mistakes
+- Missing error handling
+
+**ASSUME COMPETENCE**: The author is an experienced engineer who made intentional decisions. Question only when you see genuine problems.
 
 ## Review Categories (Priority Order)
 
@@ -47,34 +48,39 @@ You are reviewing a Gerrit change set. Provide thorough, constructive feedback f
 - **Clarity**: Code that works but could be more readable
 - **Future-Proofing**: Anticipating likely future requirements
 
-## What NOT to Review
+## What NOT to Review (Common Time Wasters)
+
+- **Code style/formatting**: Handled by automated tools
+- **Personal preferences**: Different != wrong
+- **Compliments**: "Looks good!" wastes everyone's time
+- **Nitpicks**: Minor wording, variable names, spacing
+- **Micro-optimizations**: Unless there's a proven performance problem
+- **Already working code**: If it works and isn't broken, don't fix it
+- **Suggestions for "better" approaches**: Only if current approach has concrete problems
 
-- **Already Fixed**: Issues resolved in the current patchset
-- **Style Preferences**: Formatting that doesn't impact readability
-- **Micro-Optimizations**: Unless performance is a stated goal
-- **Personal Preferences**: Unless they violate team standards
-- **Out of Scope**: Issues in unchanged code (unless directly relevant)
+## Before Commenting, Ask Yourself
 
-## Context Requirements
+1. **Will this cause a runtime failure?** → Critical issue, comment required
+2. **Will this create a security vulnerability?** → Critical issue, comment required  
+3. **Will this significantly harm performance?** → Important issue, comment required
+4. **Will this make the code unmaintainable?** → Consider commenting
+5. **Is this just a different way to solve the same problem?** → Skip it
 
-Before commenting, verify:
-1. The issue still exists in the current patchset
-2. The fix wouldn't break other functionality
-3. Your understanding of the code's purpose is correct
-4. The issue isn't intentional or documented
-5. The concern is worth the author's time to address
+## Output Guidelines
 
-## Inline Comment Guidelines
+**INLINE COMMENTS**: Only for specific line-level issues. Empty array is perfectly valid.
+- Start with "🤖 "
+- Be direct: "This will cause X bug" not "Consider maybe perhaps changing this"
+- Provide specific fixes when possible
 
-- Start each comment with "🤖 " (robot emoji with space)
-- Be specific about file paths and line numbers
-- Group related issues when they share a root cause
-- Provide concrete examples or corrections when helpful
-- Use questions for clarification, statements for clear issues
+**OVERALL REVIEW**: Required even if no inline comments.
+- For clean code: "No significant issues found. Change is ready."
+- For problematic code: Focus on the most important issues only
+- Skip the pleasantries, get to the point
 
-## Remember
+## Success Metrics
 
-- The goal is to improve code quality while respecting the author's time
-- Focus on issues that matter for correctness, security, and maintainability
-- Your review should help ship better code, not perfect code
-- When in doubt, phrase feedback as a question rather than a mandate
+- **Good review**: Finds 1-3 real issues that would cause problems
+- **Great review**: Catches a critical bug before production
+- **Bad review**: 10+ nitpicky comments about style preferences
+- **Terrible review**: "Great job! LGTM!" with zero value added

package/src/prompts/system-inline-review.md

@@ -3,7 +3,7 @@
 **YOUR ENTIRE OUTPUT MUST BE WRAPPED IN <response></response> TAGS.**
 **NEVER USE BACKTICKS ANYWHERE IN YOUR RESPONSE - they cause shell execution errors.**
 
-Output ONLY a JSON array wrapped in response tags. No other text before or after the tags.
+Output ONLY a JSON array wrapped in response tags. **EMPTY ARRAY IS PERFECTLY VALID** for clean code without issues. No other text before or after the tags.
 
 ## JSON Structure for Inline Comments
 
@@ -59,30 +59,55 @@ Line numbers refer to the final file (REVISION), not the diff.
 
 ## Priority Guidelines for Inline Comments
 
-### ALWAYS Comment On
-- Security vulnerabilities (injection, auth bypass, data exposure)
-- Data corruption or loss risks
-- Logic errors that produce wrong results
-- Resource leaks (memory, connections, handles)
-- Race conditions and concurrency bugs
-
-### USUALLY Comment On
-- Missing error handling for likely failure cases
-- Performance problems (N+1 queries, unbounded loops)
-- Type safety issues and invalid casts
-- Missing input validation
-- Incorrect API usage
-
-### RARELY Comment On
-- Style preferences (unless egregious)
-- Minor optimizations without measurement
-- Alternative approaches that are equivalent
-- Issues in unchanged code
-- Formatting (unless it obscures logic)
+### ALWAYS Comment On (Real Problems Only)
+- **Bugs**: Logic errors, null pointer risks, incorrect algorithms
+- **Security**: Injection vulnerabilities, auth bypasses, data leaks
+- **Crashes**: Unhandled exceptions, resource exhaustion, infinite loops
+- **Data loss**: Operations that corrupt or lose user data
+
+### SOMETIMES Comment On (If Significant)
+- **Performance**: N+1 queries, memory leaks, algorithmic complexity issues
+- **Error handling**: Missing try/catch for operations that commonly fail
+- **Type safety**: Dangerous casts, missing validation for external input
+
+### NEVER Comment On (Time Wasters)
+- **Style/formatting**: Let automated tools handle this
+- **Working code**: If it functions correctly, leave it alone  
+- **Personal preferences**: "I would have done this differently"
+- **Nitpicks**: Variable names, spacing, minor wording
+- **Compliments**: Don't waste time praising obvious competence
+
+## GIT REPOSITORY ACCESS
+
+You are running in a git repository with full access to:
+- git diff, git show, git log for understanding changes and context
+- git blame for code ownership and history
+- All project files for architectural understanding
+- Use these commands to provide comprehensive, accurate reviews
 
 ## FINAL REMINDER
 
-Your ENTIRE output must be a JSON array wrapped in <response></response> tags.
-Every message must start with "🤖 ".
-Never use backticks in your response.
-Focus on substantial technical issues, not preferences.
+**CRITICAL: Your ENTIRE output must be a JSON array wrapped in <response></response> tags.**
+
+Example formats:
+```
+<response>
+[]
+</response>
+```
+(Empty array for clean code - this is GOOD!)
+
+```
+<response>
+[{"file": "auth.js", "line": 42, "message": "🤖 SQL injection vulnerability: query uses string concatenation"}]
+</response>
+```
+(Only comment on real problems)
+
+**REQUIREMENTS**:
+- Every message must start with "🤖 "
+- Never use backticks in your response
+- Empty arrays are encouraged for clean code
+- Focus on bugs, security, crashes - ignore style preferences  
+- Use git commands to understand context before commenting
+- NO TEXT OUTSIDE THE <response></response> TAGS

package/src/prompts/system-overall-review.md

@@ -41,11 +41,10 @@ Gerrit uses a LIMITED markdown subset. Follow these rules EXACTLY:
 
 **YOUR ENTIRE OUTPUT MUST BE WRAPPED IN <response></response> TAGS.**
 
-The review content inside the response tags should start with "🤖 [Your Tool Name] ([Your Model])" followed by your analysis. For example:
+Start with "🤖 [Your Tool Name] ([Your Model])" then provide a **CONCISE** engineering assessment. Examples:
 - If you are Claude Sonnet 4: "🤖 Claude (Sonnet 4)"
-- If you are GPT-4: "🤖 OpenAI (GPT-4)" 
-- If you are Llama: "🤖 Llama (70B)"
-- etc.
+- For clean code: "No significant issues found. Change is ready for merge."
+- For problematic code: Focus only on critical/important issues, skip minor concerns
 
 ## Example Output Format
 
@@ -139,14 +138,40 @@ The security issues are blocking and must be fixed. The performance concerns sho
    - Skip trivial issues unless they indicate patterns
    - Include concrete fix suggestions
 
+## GIT REPOSITORY ACCESS
+
+You are running in a git repository with full access to:
+- git diff, git show, git log for understanding changes and context
+- git blame for code ownership and history
+- All project files for architectural understanding
+- Use these commands to explore the codebase and provide comprehensive reviews
+
 ## FINAL REMINDER
 
-Your ENTIRE output must be wrapped in <response></response> tags.
-Start with "🤖 [Your Tool Name] ([Your Model])" then proceed with your analysis.
-Use Gerrit's limited markdown format - NO backticks, NO markdown bold/italic.
+**CRITICAL: Your ENTIRE output must be wrapped in <response></response> tags.**
+
+Example format:
+```
+<response>
+🤖 Claude (Sonnet 4)
+
+OVERALL ASSESSMENT
+
+Your review content here...
+</response>
+```
+
+MANDATORY REQUIREMENTS:
+- Start with "🤖 [Your Tool Name] ([Your Model])" 
+- Be CONCISE - engineers value brevity over verbosity
+- For clean code, simply state "No significant issues found"
+- Focus on material problems, skip style preferences and compliments
+- Use Gerrit's limited markdown format - NO backticks, NO markdown bold/italic  
+- Use git commands to understand context before writing review
+- NO TEXT OUTSIDE THE <response></response> TAGS
 
 CRITICAL FORMATTING RULES:
 - Add blank lines between sections and before/after code blocks
-- Use exactly 4 spaces to start each line of code blocks
+- Use exactly 4 spaces to start each line of code blocks  
 - Keep code blocks simple and readable
 - Add proper spacing for readability

package/src/services/git-worktree.ts

@@ -0,0 +1,297 @@
+import { Effect, Console, pipe, Layer, Context } from 'effect'
+import { Schema } from 'effect'
+import * as os from 'node:os'
+import * as path from 'node:path'
+import * as fs from 'node:fs/promises'
+import { spawn } from 'node:child_process'
+
+// Error types
+export class WorktreeCreationError extends Schema.TaggedError<WorktreeCreationError>()(
+  'WorktreeCreationError',
+  {
+    message: Schema.String,
+    cause: Schema.optional(Schema.Unknown),
+  },
+) {}
+
+export class PatchsetFetchError extends Schema.TaggedError<PatchsetFetchError>()(
+  'PatchsetFetchError',
+  {
+    message: Schema.String,
+    cause: Schema.optional(Schema.Unknown),
+  },
+) {}
+
+export class DirtyRepoError extends Schema.TaggedError<DirtyRepoError>()('DirtyRepoError', {
+  message: Schema.String,
+}) {}
+
+export class NotGitRepoError extends Schema.TaggedError<NotGitRepoError>()('NotGitRepoError', {
+  message: Schema.String,
+}) {}
+
+export type GitError = WorktreeCreationError | PatchsetFetchError | DirtyRepoError | NotGitRepoError
+
+// Worktree info
+export interface WorktreeInfo {
+  path: string
+  changeId: string
+  originalCwd: string
+  timestamp: number
+  pid: number
+}
+
+// Git command runner with Effect
+const runGitCommand = (
+  args: string[],
+  options: { cwd?: string } = {},
+): Effect.Effect<string, GitError, never> =>
+  Effect.async<string, GitError, never>((resume) => {
+    const child = spawn('git', args, {
+      cwd: options.cwd || process.cwd(),
+      stdio: ['ignore', 'pipe', 'pipe'],
+    })
+
+    let stdout = ''
+    let stderr = ''
+
+    child.stdout?.on('data', (data) => {
+      stdout += data.toString()
+    })
+
+    child.stderr?.on('data', (data) => {
+      stderr += data.toString()
+    })
+
+    child.on('close', (code) => {
+      if (code === 0) {
+        resume(Effect.succeed(stdout.trim()))
+      } else {
+        const errorMessage = `Git command failed: git ${args.join(' ')}\nStderr: ${stderr}`
+
+        // Classify error based on command and output
+        if (args[0] === 'worktree' && args[1] === 'add') {
+          resume(Effect.fail(new WorktreeCreationError({ message: errorMessage })))
+        } else if (args[0] === 'fetch' || args[0] === 'checkout') {
+          resume(Effect.fail(new PatchsetFetchError({ message: errorMessage })))
+        } else {
+          resume(Effect.fail(new WorktreeCreationError({ message: errorMessage })))
+        }
+      }
+    })
+
+    child.on('error', (error) => {
+      resume(
+        Effect.fail(
+          new WorktreeCreationError({
+            message: `Failed to spawn git: ${error.message}`,
+            cause: error,
+          }),
+        ),
+      )
+    })
+  })
+
+// Check if current directory is a git repository
+const validateGitRepo = (): Effect.Effect<void, NotGitRepoError, never> =>
+  pipe(
+    runGitCommand(['rev-parse', '--git-dir']),
+    Effect.mapError(
+      () => new NotGitRepoError({ message: 'Current directory is not a git repository' }),
+    ),
+    Effect.map(() => undefined),
+  )
+
+// Check if working directory is clean
+const validateCleanRepo = (): Effect.Effect<void, DirtyRepoError, never> =>
+  pipe(
+    runGitCommand(['status', '--porcelain']),
+    Effect.mapError(() => new DirtyRepoError({ message: 'Failed to check repository status' })),
+    Effect.flatMap((output) =>
+      output.trim() === ''
+        ? Effect.succeed(undefined)
+        : Effect.fail(
+            new DirtyRepoError({
+              message:
+                'Working directory has uncommitted changes. Please commit or stash changes before review.',
+            }),
+          ),
+    ),
+  )
+
+// Generate unique worktree path
+const generateWorktreePath = (changeId: string): string => {
+  const timestamp = Date.now()
+  const pid = process.pid
+  const uniqueId = `${changeId}-${timestamp}-${pid}`
+  return path.join(os.homedir(), '.ger', 'worktrees', uniqueId)
+}
+
+// Ensure .ger directory exists
+const ensureGerDirectory = (): Effect.Effect<void, never, never> =>
+  Effect.tryPromise({
+    try: async () => {
+      const gerDir = path.join(os.homedir(), '.ger', 'worktrees')
+      await fs.mkdir(gerDir, { recursive: true })
+    },
+    catch: () => undefined, // Ignore errors, will fail later if directory can't be created
+  }).pipe(Effect.catchAll(() => Effect.succeed(undefined)))
+
+// Build Gerrit refspec for change
+const buildRefspec = (changeNumber: string, patchsetNumber: number = 1): string => {
+  // Extract change number from changeId if it contains non-numeric characters
+  const numericChangeNumber = changeNumber.replace(/\D/g, '')
+  return `refs/changes/${numericChangeNumber.slice(-2)}/${numericChangeNumber}/${patchsetNumber}`
+}
+
+// Get the current HEAD commit hash to avoid branch conflicts
+const getCurrentCommit = (): Effect.Effect<string, GitError, never> =>
+  pipe(
+    runGitCommand(['rev-parse', 'HEAD']),
+    Effect.map((output) => output.trim()),
+    Effect.catchAll(() =>
+      // Fallback: try to get commit from default branch
+      pipe(
+        runGitCommand(['rev-parse', 'origin/main']),
+        Effect.catchAll(() => runGitCommand(['rev-parse', 'origin/master'])),
+        Effect.catchAll(() => Effect.succeed('HEAD')),
+      ),
+    ),
+  )
+
+// Get latest patchset number for a change
+const getLatestPatchsetNumber = (
+  changeId: string,
+): Effect.Effect<number, PatchsetFetchError, never> =>
+  pipe(
+    runGitCommand(['ls-remote', 'origin', `refs/changes/*/${changeId.replace(/\D/g, '')}/*`]),
+    Effect.mapError(
+      (error) =>
+        new PatchsetFetchError({ message: `Failed to get patchset info: ${error.message}` }),
+    ),
+    Effect.map((output) => {
+      const lines = output.split('\n').filter((line) => line.trim())
+      if (lines.length === 0) {
+        return 1 // Default to patchset 1 if no refs found
+      }
+
+      // Extract patchset numbers and return the highest
+      const patchsetNumbers = lines
+        .map((line) => {
+          const match = line.match(/refs\/changes\/\d+\/\d+\/(\d+)$/)
+          return match ? parseInt(match[1], 10) : 0
+        })
+        .filter((num) => num > 0)
+
+      return patchsetNumbers.length > 0 ? Math.max(...patchsetNumbers) : 1
+    }),
+  )
+
+// GitWorktreeService implementation
+export interface GitWorktreeServiceImpl {
+  validatePreconditions: () => Effect.Effect<void, GitError, never>
+  createWorktree: (changeId: string) => Effect.Effect<WorktreeInfo, GitError, never>
+  fetchAndCheckoutPatchset: (worktreeInfo: WorktreeInfo) => Effect.Effect<void, GitError, never>
+  cleanup: (worktreeInfo: WorktreeInfo) => Effect.Effect<void, never, never>
+  getChangedFiles: () => Effect.Effect<string[], GitError, never>
+}
+
+const GitWorktreeServiceImplLive: GitWorktreeServiceImpl = {
+  validatePreconditions: () =>
+    Effect.gen(function* () {
+      yield* validateGitRepo()
+      yield* validateCleanRepo()
+      yield* Console.log('✓ Git repository validation passed')
+    }),
+
+  createWorktree: (changeId: string) =>
+    Effect.gen(function* () {
+      yield* Console.log(`→ Creating worktree for change ${changeId}...`)
+
+      // Get current commit hash to avoid branch conflicts
+      const currentCommit = yield* getCurrentCommit()
+      yield* Console.log(`→ Using base commit: ${currentCommit.substring(0, 7)}`)
+
+      // Ensure .ger directory exists
+      yield* ensureGerDirectory()
+
+      // Generate unique path
+      const worktreePath = generateWorktreePath(changeId)
+      const originalCwd = process.cwd()
+
+      // Create worktree using commit hash (no branch conflicts)
+      yield* runGitCommand(['worktree', 'add', '--detach', worktreePath, currentCommit])
+
+      const worktreeInfo: WorktreeInfo = {
+        path: worktreePath,
+        changeId,
+        originalCwd,
+        timestamp: Date.now(),
+        pid: process.pid,
+      }
+
+      yield* Console.log(`✓ Worktree created at ${worktreePath}`)
+      return worktreeInfo
+    }),
+
+  fetchAndCheckoutPatchset: (worktreeInfo: WorktreeInfo) =>
+    Effect.gen(function* () {
+      yield* Console.log(`→ Fetching and checking out patchset for ${worktreeInfo.changeId}...`)
+
+      // Get latest patchset number
+      const patchsetNumber = yield* getLatestPatchsetNumber(worktreeInfo.changeId)
+      const refspec = buildRefspec(worktreeInfo.changeId, patchsetNumber)
+
+      yield* Console.log(`→ Using refspec: ${refspec}`)
+
+      // Fetch the change
+      yield* runGitCommand(['fetch', 'origin', refspec], { cwd: worktreeInfo.path })
+
+      // Checkout FETCH_HEAD
+      yield* runGitCommand(['checkout', 'FETCH_HEAD'], { cwd: worktreeInfo.path })
+
+      yield* Console.log(`✓ Checked out patchset ${patchsetNumber} for ${worktreeInfo.changeId}`)
+    }),
+
+  cleanup: (worktreeInfo: WorktreeInfo) =>
+    Effect.gen(function* () {
+      yield* Console.log(`→ Cleaning up worktree for ${worktreeInfo.changeId}...`)
+
+      // Always restore original working directory first
+      try {
+        process.chdir(worktreeInfo.originalCwd)
+      } catch (error) {
+        yield* Console.warn(`Warning: Could not restore original directory: ${error}`)
+      }
+
+      // Attempt to remove worktree (don't fail if this doesn't work)
+      yield* pipe(
+        runGitCommand(['worktree', 'remove', '--force', worktreeInfo.path]),
+        Effect.catchAll((error) =>
+          Effect.gen(function* () {
+            yield* Console.warn(`Warning: Could not remove worktree: ${error.message}`)
+            yield* Console.warn(`Manual cleanup may be required: ${worktreeInfo.path}`)
+          }),
+        ),
+      )
+
+      yield* Console.log(`✓ Cleanup completed for ${worktreeInfo.changeId}`)
+    }),
+
+  getChangedFiles: () =>
+    Effect.gen(function* () {
+      // Get list of changed files in current worktree
+      const output = yield* runGitCommand(['diff', '--name-only', 'HEAD~1'])
+      const files = output.split('\n').filter((file) => file.trim())
+      return files
+    }),
+}
+
+// Export service tag for dependency injection
+export class GitWorktreeService extends Context.Tag('GitWorktreeService')<
+  GitWorktreeService,
+  GitWorktreeServiceImpl
+>() {}
+
+// Export service layer
+export const GitWorktreeServiceLive = Layer.succeed(GitWorktreeService, GitWorktreeServiceImplLive)