# Using Gemini CLI for Large Codebase Analysis

gistfile1.txt

# Using Gemini CLI for Large Codebase Analysis

When analyzing large codebases or multiple files that might exceed context limits, use the Gemini CLI with its massive
context window. Use `gemini -p` to leverage Google Gemini's large context capacity.

## File and Directory Inclusion Syntax

Use the `@` syntax to include files and directories in your Gemini prompts. The paths should be relative to WHERE you run the
  gemini command:

### Examples:

**Single file analysis:**
gemini -p "@src/main.py Explain this file's purpose and structure"

Multiple files:
gemini -p "@package.json @src/index.js Analyze the dependencies used in the code"

Entire directory:
gemini -p "@src/ Summarize the architecture of this codebase"

Multiple directories:
gemini -p "@src/ @tests/ Analyze test coverage for the source code"

Current directory and subdirectories:
gemini -p "@./ Give me an overview of this entire project"

# Or use --all_files flag:
gemini --all_files -p "Analyze the project structure and dependencies"

Implementation Verification Examples

Check if a feature is implemented:
gemini -p "@src/ @lib/ Has dark mode been implemented in this codebase? Show me the relevant files and functions"

Verify authentication implementation:
gemini -p "@src/ @middleware/ Is JWT authentication implemented? List all auth-related endpoints and middleware"

Check for specific patterns:
gemini -p "@src/ Are there any React hooks that handle WebSocket connections? List them with file paths"

Verify error handling:
gemini -p "@src/ @api/ Is proper error handling implemented for all API endpoints? Show examples of try-catch blocks"

Check for rate limiting:
gemini -p "@backend/ @middleware/ Is rate limiting implemented for the API? Show the implementation details"

Verify caching strategy:
gemini -p "@src/ @lib/ @services/ Is Redis caching implemented? List all cache-related functions and their usage"

Check for specific security measures:
gemini -p "@src/ @api/ Are SQL injection protections implemented? Show how user inputs are sanitized"

Verify test coverage for features:
gemini -p "@src/payment/ @tests/ Is the payment processing module fully tested? List all test cases"

When to Use Gemini CLI

Use gemini -p when:
- Analyzing entire codebases or large directories
- Comparing multiple large files
- Need to understand project-wide patterns or architecture
- Current context window is insufficient for the task
- Working with files totaling more than 100KB
- Verifying if specific features, patterns, or security measures are implemented
- Checking for the presence of certain coding patterns across the entire codebase

Important Notes

- Paths in @ syntax are relative to your current working directory when invoking gemini
- The CLI will include file contents directly in the context
- No need for --yolo flag for read-only analysis
- Gemini's context window can handle entire codebases that would overflow Claude's context
- When checking implementations, be specific about what you're looking for to get accurate results

## Git Bash Terminal Management

### Preventing Git Bash from Closing During Command Output

When running commands that produce long output (like Gemini CLI), Git Bash may close unexpectedly. Here are solutions:

**1. Redirect Output to File**
```bash
gemini -p "@file.csv Analyze this file" > output.txt 2>&1
```

**2. Use `tee` to Show and Save Output (Recommended)**
```bash
gemini -p "@file.csv Analyze this file" | tee gemini_output.txt
```

**3. Pause Terminal After Command**
```bash
gemini -p "@file.csv Analyze this file"; read -p "Press Enter to continue..."
```

**4. Keep Terminal Open with `exec bash`**
```bash
gemini -p "@file.csv Analyze this file"; exec bash
```

**5. Force Terminal to Stay Open**
```bash
gemini -p "@file.csv Analyze this file" && echo "Command completed" && bash
```

### Best Practice
Use a single overwriting file to avoid accumulation:
```bash
gemini -p "@file.csv Analyze this file" | tee gemini_output.txt
```

**Why this is most efficient:**
- Prevents Git Bash from closing
- Always overwrites same filename (no accumulation)
- File persists long enough to read
- Predictable location in working directory
- No manual cleanup needed
- Zero token waste on file management