@aaronshaf/ger 1.2.10 → 2.0.0

package/src/cli/register-group-commands.ts

@@ -0,0 +1,88 @@
+import type { Command } from 'commander'
+import { Effect } from 'effect'
+import { GerritApiServiceLive } from '@/api/gerrit'
+import { ConfigServiceLive } from '@/services/config'
+import { groupsCommand } from './commands/groups'
+import { groupsShowCommand } from './commands/groups-show'
+import { groupsMembersCommand } from './commands/groups-members'
+
+// Helper function to execute Effect with standard error handling
+async function executeEffect<E>(
+  effect: Effect.Effect<void, E, never>,
+  options: { xml?: boolean },
+  resultTag: string,
+): Promise<void> {
+  try {
+    await Effect.runPromise(effect)
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error)
+    if (options.xml) {
+      console.log(`<?xml version="1.0" encoding="UTF-8"?>`)
+      console.log(`<${resultTag}>`)
+      console.log(`  <status>error</status>`)
+      console.log(`  <error><![CDATA[${errorMessage}]]></error>`)
+      console.log(`</${resultTag}>`)
+    } else {
+      console.error('✗ Error:', errorMessage)
+    }
+    process.exit(1)
+  }
+}
+
+/**
+ * Register all group-related commands (groups, groups-show, groups-members)
+ */
+export function registerGroupCommands(program: Command): void {
+  // groups command
+  program
+    .command('groups')
+    .description('List Gerrit groups')
+    .option('--pattern <regex>', 'Filter groups by name pattern')
+    .option('--owned', 'Show only groups owned by you')
+    .option('--project <name>', 'Show groups for specific project')
+    .option('--user <account>', 'Show groups a user belongs to')
+    .option('--limit <n>', 'Maximum number of results (default: 25)')
+    .option('--xml', 'XML output for LLM consumption')
+    .action(async (options) => {
+      await executeEffect(
+        groupsCommand(options).pipe(
+          Effect.provide(GerritApiServiceLive),
+          Effect.provide(ConfigServiceLive),
+        ),
+        options,
+        'groups_result',
+      )
+    })
+
+  // groups-show command
+  program
+    .command('groups-show <group-id>')
+    .description('Show detailed information about a Gerrit group')
+    .option('--xml', 'XML output for LLM consumption')
+    .action(async (groupId, options) => {
+      await executeEffect(
+        groupsShowCommand(groupId, options).pipe(
+          Effect.provide(GerritApiServiceLive),
+          Effect.provide(ConfigServiceLive),
+        ),
+        options,
+        'group_detail_result',
+      )
+    })
+
+  // groups-members command
+  program
+    .command('groups-members <group-id>')
+    .description('List all members of a Gerrit group')
+    .option('--xml', 'XML output for LLM consumption')
+    .action(async (groupId, options) => {
+      await executeEffect(
+        groupsMembersCommand(groupId, options).pipe(
+          Effect.provide(GerritApiServiceLive),
+          Effect.provide(ConfigServiceLive),
+        ),
+        options,
+        'group_members_result',
+      )
+    })
+}

package/src/cli/register-reviewer-commands.ts

@@ -0,0 +1,97 @@
+import type { Command } from 'commander'
+import { Effect } from 'effect'
+import { GerritApiServiceLive } from '@/api/gerrit'
+import { ConfigServiceLive } from '@/services/config'
+import { addReviewerCommand } from './commands/add-reviewer'
+import { removeReviewerCommand } from './commands/remove-reviewer'
+
+// Helper function to execute Effect with standard error handling
+async function executeEffect<E>(
+  effect: Effect.Effect<void, E, never>,
+  options: { xml?: boolean },
+  resultTag: string,
+): Promise<void> {
+  try {
+    await Effect.runPromise(effect)
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error)
+    if (options.xml) {
+      console.log(`<?xml version="1.0" encoding="UTF-8"?>`)
+      console.log(`<${resultTag}>`)
+      console.log(`  <status>error</status>`)
+      console.log(`  <error><![CDATA[${errorMessage}]]></error>`)
+      console.log(`</${resultTag}>`)
+    } else {
+      console.error('✗ Error:', errorMessage)
+    }
+    process.exit(1)
+  }
+}
+
+/**
+ * Register all reviewer-related commands (add-reviewer, remove-reviewer)
+ */
+export function registerReviewerCommands(program: Command): void {
+  // add-reviewer command
+  program
+    .command('add-reviewer <reviewers...>')
+    .description('Add reviewers or groups to a change')
+    .option('-c, --change <change-id>', 'Change ID (required until auto-detection is implemented)')
+    .option('--cc', 'Add as CC instead of reviewer')
+    .option('--group', 'Add as group instead of individual reviewer')
+    .option(
+      '--notify <level>',
+      'Notification level: none, owner, owner_reviewers, all (default: all)',
+    )
+    .option('--xml', 'XML output for LLM consumption')
+    .addHelpText(
+      'after',
+      `
+Examples:
+  $ ger add-reviewer user@example.com -c 12345          # Add a reviewer
+  $ ger add-reviewer user1@example.com user2@example.com -c 12345  # Multiple
+  $ ger add-reviewer --cc user@example.com -c 12345     # Add as CC
+  $ ger add-reviewer --group project-reviewers -c 12345 # Add a group
+  $ ger add-reviewer --group admins --cc -c 12345       # Add group as CC
+  $ ger add-reviewer --notify none user@example.com -c 12345  # No email`,
+    )
+    .action(async (reviewers, options) => {
+      await executeEffect(
+        addReviewerCommand(reviewers, options).pipe(
+          Effect.provide(GerritApiServiceLive),
+          Effect.provide(ConfigServiceLive),
+        ),
+        options,
+        'add_reviewer_result',
+      )
+    })
+
+  // remove-reviewer command
+  program
+    .command('remove-reviewer <reviewers...>')
+    .description('Remove reviewers from a change')
+    .option('-c, --change <change-id>', 'Change ID (required until auto-detection is implemented)')
+    .option(
+      '--notify <level>',
+      'Notification level: none, owner, owner_reviewers, all (default: all)',
+    )
+    .option('--xml', 'XML output for LLM consumption')
+    .addHelpText(
+      'after',
+      `
+Examples:
+  $ ger remove-reviewer user@example.com -c 12345          # Remove a reviewer
+  $ ger remove-reviewer user1@example.com user2@example.com -c 12345  # Multiple
+  $ ger remove-reviewer --notify none user@example.com -c 12345  # No email`,
+    )
+    .action(async (reviewers, options) => {
+      await executeEffect(
+        removeReviewerCommand(reviewers, options).pipe(
+          Effect.provide(GerritApiServiceLive),
+          Effect.provide(ConfigServiceLive),
+        ),
+        options,
+        'remove_reviewer_result',
+      )
+    })
+}

package/src/prompts/default-review.md

@@ -0,0 +1,86 @@
+# Engineering Code Review - Signal Over Noise
+
+You are conducting a technical code review for experienced engineers. **PRIORITY: Find actual problems, not generate busy work.**
+
+## Core Principles
+
+**SIGNAL > NOISE**: Only comment on issues that materially impact correctness, security, performance, or maintainability. Silence is better than noise.
+
+**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)
+
+### 1. CRITICAL ISSUES (Must Fix)
+- **Correctness**: Logic errors, race conditions, data corruption risks
+- **Security**: Authentication bypasses, injection vulnerabilities, data exposure
+- **Data Loss**: Operations that could destroy or corrupt user data
+- **Breaking Changes**: Incompatible API/schema changes without migration
+- **Production Impact**: Issues that would cause outages or severe degradation
+
+### 2. SIGNIFICANT CONCERNS (Should Fix)
+- **Performance**: Memory leaks, N+1 queries, inefficient algorithms
+- **Error Handling**: Missing error cases, silent failures, poor recovery
+- **Resource Management**: Unclosed connections, file handles, cleanup issues
+- **Type Safety**: Unsafe casts, missing validation, schema mismatches
+- **Concurrency**: Deadlock risks, thread safety issues, synchronization problems
+
+### 3. CODE QUALITY (Consider Fixing)
+- **Architecture**: Design pattern violations, coupling issues, abstraction leaks
+- **Maintainability**: Complex logic without justification, unclear naming
+- **Testing**: Missing test coverage for critical paths, brittle test design
+- **Documentation**: Misleading comments, missing API documentation
+- **Best Practices**: Framework misuse, anti-patterns, deprecated APIs
+
+### 4. MINOR IMPROVEMENTS (Optional)
+- **Consistency**: Deviations from established patterns without reason
+- **Efficiency**: Minor optimization opportunities
+- **Clarity**: Code that works but could be more readable
+- **Future-Proofing**: Anticipating likely future requirements
+
+## 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
+
+## Before Commenting, Ask Yourself
+
+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
+
+## Output 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
+
+**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
+
+## Success Metrics
+
+- **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

@@ -0,0 +1,135 @@
+## IMMEDIATE TASK: ANALYZE CODE AND GENERATE INLINE COMMENTS
+
+**YOU MUST ANALYZE THE PROVIDED CODE CHANGES RIGHT NOW AND GENERATE INLINE COMMENTS.**
+
+**CRITICAL OUTPUT REQUIREMENT:**
+- 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
+- **EMPTY ARRAY IS PERFECTLY VALID** for clean code without issues
+- No other text before or after the tags
+
+**GERRIT FORMATTING RULES FOR YOUR MESSAGE CONTENT:**
+- Each message starts with "🤖 " (robot emoji and space)
+- Use CAPS for emphasis, NOT markdown bold or italic
+- Reference code using quotes: 'variable' or "function()"
+- NO backticks (`) in your message text
+- Keep explanations clear and concise
+
+**START YOUR ANALYSIS NOW. DO NOT ASK QUESTIONS. DO NOT WAIT FOR MORE INPUT.**
+
+## JSON Structure for Inline Comments
+
+The JSON array must contain inline comment objects with these fields:
+
+### Required Fields
+- "file": **Complete file path** as shown in the diff (e.g., "app/controllers/users_controller.rb", not just "users_controller.rb")
+- "message": Your comment text (MUST start with "🤖 ")
+
+### Line Specification (MUST use one approach)
+- "line": For single-line comments (integer line number - REQUIRED for single line comments)
+- "range": For multi-line comments (object with):
+  - "start_line": First line of the issue (integer)
+  - "end_line": Last line of the issue (integer)
+  - "start_character": Optional column start (integer)
+  - "end_character": Optional column end (integer)
+
+**CRITICAL LINE NUMBER RULES:**
+1. **ALWAYS use final file line numbers, NEVER diff line numbers**
+2. Line numbers must match the NEW version of the file after all changes
+3. Use `git show HEAD:path/to/file` or examine the final file to get correct line numbers
+4. If you see "+50" in a diff, the actual line number is NOT 50 - check the final file
+5. Every comment MUST have either "line" OR "range". Comments without valid line numbers will be rejected.
+
+### Optional Fields
+- "side": "REVISION" (new code, default) or "PARENT" (original code)
+
+**VERIFICATION STEP**: Before adding any comment, verify the line number by checking the final file content to ensure your line number points to the exact code you're commenting on.
+
+## Comment Quality Guidelines
+
+1. **Be Specific**: Reference exact variables, functions, or patterns
+2. **Explain Impact**: What could go wrong and why it matters
+3. **Suggest Fixes**: Provide actionable corrections when possible
+4. **Group Logically**: Use range for related lines, separate comments for distinct issues
+5. **Prioritize**: Comment on significant issues, not style preferences
+
+## Example Output Formats
+
+### Example 1: Mixed Single and Multi-line Comments
+<response>
+[
+  {"file": "app/controllers/auth/validator.rb", "line": 45, "message": "🤖 Missing validation for email format - accepts invalid emails like 'user@'. Use a proper email regex or validation library."},
+  {"file": "app/controllers/auth/validator.rb", "line": 67, "message": "🤖 Password strength check allows common passwords. Consider checking against a common password list."},
+  {"file": "lib/database/connection.rb", "range": {"start_line": 23, "end_line": 35}, "message": "🤖 Database connection retry logic has exponential backoff but no maximum retry limit. This could retry indefinitely on persistent failures. Add a max retry count."},
+  {"file": "app/controllers/api/users_controller.rb", "line": 89, "message": "🤖 SQL injection vulnerability: Query uses string concatenation with userId. Use parameterized queries with ActiveRecord methods.", "side": "REVISION"}
+]
+</response>
+
+### Example 2: Critical Security Issues
+<response>
+[
+  {"file": "app/middleware/authentication_middleware.rb", "line": 34, "message": "🤖 Authentication bypass: Debug header check allows skipping auth. This MUST be removed before production."},
+  {"file": "lib/utils/crypto_helper.rb", "range": {"start_line": 12, "end_line": 18}, "message": "🤖 Weak encryption: MD5 is cryptographically broken. Use bcrypt for password hashing."},
+  {"file": "app/controllers/api/files_controller.rb", "line": 156, "message": "🤖 Path traversal vulnerability: User input directly used in file path without sanitization. An attacker could access files outside intended directory using '../'."}
+]
+</response>
+
+## Priority Guidelines for Inline Comments
+
+### 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 TASK INSTRUCTION
+
+**ANALYZE THE CODE CHANGES NOW AND OUTPUT YOUR INLINE COMMENTS IMMEDIATELY.**
+
+Your output format must be:
+```
+<response>
+[]
+</response>
+```
+(Empty array for clean code - this is GOOD!)
+
+OR:
+
+```
+<response>
+[{"file": "auth.js", "line": 42, "message": "🤖 SQL injection vulnerability: query uses string concatenation"}]
+</response>
+```
+(Only comment on real problems)
+
+**CRITICAL 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
+
+**DO YOUR ANALYSIS NOW. STOP ASKING QUESTIONS. GENERATE THE REVIEW.**

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

@@ -0,0 +1,206 @@
+## Review Structure and Formatting
+
+### Section Headers (Use Only What's Relevant)
+
+Use CAPS for section headers. Include ONLY sections where you have substantive content:
+
+- OVERALL ASSESSMENT - High-level verdict and summary
+- CRITICAL ISSUES - Must be fixed before merge
+- SIGNIFICANT CONCERNS - Should be addressed 
+- CODE QUALITY - Improvements for maintainability
+- SECURITY ASSESSMENT - Security-specific findings
+- PERFORMANCE ANALYSIS - Performance implications
+- TEST COVERAGE - Testing observations
+- ARCHITECTURE NOTES - Design and pattern feedback
+- RECOMMENDATIONS - Actionable suggestions
+
+### Gerrit Formatting Requirements
+
+Gerrit uses a LIMITED markdown subset. Follow these rules EXACTLY:
+
+- NO markdown bold (**text**) or italic (*text*) - use CAPS for emphasis
+- NO headers with # or ## - use CAPS section titles
+- NO backticks (`) for code - use quotes 'code' or "code" for inline
+- Code blocks: Start EACH line with exactly 4 spaces, add blank lines before and after
+- Bullet points: Use * or - at line start
+- Block quotes: Start line with > 
+- Reference files as path/to/file.ext:123 (with line numbers)
+- Always add blank lines between sections for readability
+- Keep code blocks simple and well-spaced
+
+**CRITICAL GERRIT FORMATTING RULES:**
+
+1. NEVER start regular text lines with spaces - this creates unintended code blocks!
+2. Only use 4 leading spaces when showing actual code examples
+3. Regular text should start at column 1 (no indentation)
+4. When explaining something after a bullet point, don't indent - start a new line
+5. Use blank lines to separate sections and improve readability
+
+WRONG (creates code blocks):
+* Issue with authentication
+  This explanation will become a code block due to leading spaces
+
+CORRECT:
+* Issue with authentication
+This explanation stays as regular text
+
+### Content Guidelines
+
+1. Start with the most important findings
+2. Group related issues together
+3. Be specific with file paths and line numbers
+4. Explain the "why" behind each issue
+5. Provide actionable fixes or alternatives
+6. Use concrete examples when helpful
+
+## CRITICAL OUTPUT REQUIREMENT
+
+**YOUR ENTIRE OUTPUT MUST BE WRAPPED IN <response></response> TAGS.**
+
+**IMMEDIATE TASK**: Analyze the code changes provided below and write a comprehensive engineering review.
+
+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 Gemini: "🤖 Gemini (1.5 Pro)" or "🤖 Gemini (1.5 Flash)"
+- For clean code: "No significant issues found. Change is ready for merge."
+- For problematic code: Focus only on critical/important issues, skip minor concerns
+
+**YOU MUST ANALYZE THE PROVIDED CODE CHANGES AND WRITE A REVIEW NOW.**
+
+## Example Output Format
+
+<response>
+🤖 Claude (Sonnet 4)
+
+OVERALL ASSESSMENT
+
+This change successfully implements the new authentication flow with proper error handling and test coverage. However, there are critical security concerns and performance issues that need addressing before merge.
+
+CRITICAL ISSUES
+
+1. SQL Injection Vulnerability - src/api/users.ts:45
+
+The query construction uses string concatenation with user input:
+
+    const query = "SELECT * FROM users WHERE id = " + userId
+
+This allows SQL injection attacks. Use parameterized queries:
+
+    const query = "SELECT * FROM users WHERE id = $1"
+    const result = await db.query(query, [userId])
+
+2. Authentication Bypass - src/middleware/auth.ts:78-82
+
+The token validation can be bypassed when 'debug' header is present:
+
+    if (req.headers.debug) return next()
+
+This MUST be removed from production code.
+
+SIGNIFICANT CONCERNS
+
+Resource Leak - src/services/cache.ts:156
+
+The Redis connection is created but never closed on error:
+
+* Connection opens on line 145
+* Error path at line 156 doesn't call client.disconnect()
+* This will exhaust connection pool over time
+
+Add proper cleanup in a finally block:
+
+    try {
+        await client.connect()
+        // ... operations
+    } finally {
+        await client.disconnect()
+    }
+
+PERFORMANCE ANALYSIS
+
+- N+1 Query Pattern in src/api/posts.ts:234-248
+Loading comments for each post individually causes N+1 queries.
+Consider using a single query with JOIN or batch loading.
+
+- Unbounded Memory Usage in src/utils/processor.ts:89
+Loading entire dataset into memory without pagination.
+For large datasets, this will cause OOM errors.
+
+TEST COVERAGE
+
+- Missing error path tests for the new authentication flow
+- No integration tests for the rate limiting middleware
+- Edge cases around token expiry not covered
+
+RECOMMENDATIONS
+
+1. Add rate limiting to authentication endpoints
+2. Implement request validation using a schema library
+3. Add monitoring for the new cache layer
+4. Consider adding database transaction support for multi-step operations
+
+The security issues are blocking and must be fixed. The performance concerns should be addressed before this scales to production load.
+</response>
+
+## Review Tone and Approach
+
+1. **Be Direct but Constructive**
+- State issues clearly without hedging
+- Explain impact and provide solutions
+- Focus on the code, not the coder
+
+2. **Prioritize Effectively**
+- Lead with blocking issues
+- Group related problems
+- Don't bury critical findings
+
+3. **Provide Value**
+- Every comment should help improve the code
+- 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
+
+**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  
+- Keep code blocks simple and readable
+- Add proper spacing for readability
+- NEVER indent regular text - start all non-code text at column 1
+- Only code examples should have leading spaces (exactly 4)
+
+## TASK SUMMARY
+
+**ANALYZE THE CODE CHANGES PROVIDED ABOVE AND WRITE YOUR ENGINEERING REVIEW IMMEDIATELY.**
+
+Do not ask for clarification. Do not wait for more input. Analyze the provided code changes, git history, and changed files, then write your review following the format requirements above.