@aaronshaf/ger 0.1.0 → 0.1.1

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/ai-enhanced.ts

@@ -79,12 +79,12 @@ export const AiServiceEnhanced = Layer.effect(
         return responseMatch[1].trim()
       })
 
-    const runPrompt = (prompt: string, input: string) =>
+    const runPrompt = (prompt: string, input: string = '', options: { cwd?: string } = {}) =>
       Effect.gen(function* () {
         const tool = yield* detectAiTool()
 
         // Prepare the command based on the tool
-        const fullInput = `${prompt}\n\n${input}`
+        const fullInput = input ? `${prompt}\n\n${input}` : prompt
         let command: string
 
         switch (tool) {
@@ -114,6 +114,7 @@ export const AiServiceEnhanced = Layer.effect(
             const child = require('node:child_process').spawn(command, {
               shell: true,
               stdio: ['pipe', 'pipe', 'pipe'],
+              cwd: options.cwd || process.cwd(),
             })
 
             // Write input to stdin

package/src/services/ai.ts

@@ -25,7 +25,8 @@ export class AiService extends Context.Tag('AiService')<
   {
     readonly runPrompt: (
       prompt: string,
-      input: string,
+      input?: string,
+      options?: { cwd?: string },
     ) => Effect.Effect<string, AiServiceError | NoAiToolFoundError | AiResponseParseError>
     readonly detectAiTool: () => Effect.Effect<string, NoAiToolFoundError>
     readonly extractResponseTag: (output: string) => Effect.Effect<string, AiResponseParseError>
@@ -76,7 +77,7 @@ export const AiServiceLive = Layer.succeed(
         return responseMatch[1].trim()
       }),
 
-    runPrompt: (prompt: string, input: string) =>
+    runPrompt: (prompt: string, input: string = '', options: { cwd?: string } = {}) =>
       Effect.gen(function* () {
         const tool = yield* Effect.gen(function* () {
           // Try to detect available AI tools in order of preference
@@ -101,7 +102,7 @@ export const AiServiceLive = Layer.succeed(
         })
 
         // Prepare the command based on the tool
-        const fullInput = `${prompt}\n\n${input}`
+        const fullInput = input ? `${prompt}\n\n${input}` : prompt
         let command: string
 
         switch (tool) {
@@ -127,6 +128,7 @@ export const AiServiceLive = Layer.succeed(
             const child = require('node:child_process').spawn(command, {
               shell: true,
               stdio: ['pipe', 'pipe', 'pipe'],
+              cwd: options.cwd || process.cwd(),
             })
 
             // Write input to stdin
@@ -168,9 +170,15 @@ export const AiServiceLive = Layer.succeed(
         const responseMatch = result.stdout.match(/<response>([\s\S]*?)<\/response>/i)
 
         if (!responseMatch || !responseMatch[1]) {
+          // Enhanced error message with truncated output for debugging
+          const truncatedOutput =
+            result.stdout.length > 500
+              ? result.stdout.substring(0, 500) + '...[truncated]'
+              : result.stdout
+
           return yield* Effect.fail(
             new AiResponseParseError({
-              message: 'No <response> tag found in AI output',
+              message: `No <response> tag found in AI output. Raw output: ${truncatedOutput}`,
               rawOutput: result.stdout,
             }),
           )

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)

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
+}