gemini-cli-integration

name	gemini-cli-integration
description	Use the gemini-cli-integration skill PROACTIVELY when analyzing large codebases, multiple files, or directories. Leverages Google Gemini's massive context window with @ syntax for file inclusion to handle comprehensive codebase analysis, implementation verification, and architectural understanding.

Gemini CLI Plugin for Large Codebase Analysis

Use the Gemini CLI with its massive context window when analyzing large codebases or multiple files that might exceed context limits.

Core Usage

Execute gemini -p with the @ syntax to include files and directories. Paths are relative to the current working directory.

File Inclusion Patterns

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 recursively:

gemini -p "@./ Give me an overview of this entire project"

Alternative to @ syntax:

gemini --all_files -p "Analyze the project structure and dependencies"

Implementation Verification Workflows

Feature Implementation Analysis

Verify specific features are implemented across the codebase:

# Check for feature implementation
gemini -p "@src/ @lib/ Has dark mode been implemented in this codebase? Show me the relevant files and functions"

# Authentication verification
gemini -p "@src/ @middleware/ Is JWT authentication implemented? List all auth-related endpoints and middleware"

# Pattern detection
gemini -p "@src/ Are there any React hooks that handle WebSocket connections? List them with file paths"

Security and Quality Assurance

Verify security measures and coding standards:

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

# Security measures
gemini -p "@src/ @api/ Are SQL injection protections implemented? Show how user inputs are sanitized"

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

Infrastructure and Testing

Check infrastructure components and test coverage:

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

# Test coverage analysis
gemini -p "@src/payment/ @tests/ Is the payment processing module fully tested? List all test cases"

Advanced CLI Options

For advanced usage scenarios, leverage additional CLI options:

Safety and Approval Modes

# Auto-approve edit tools only (safer than full YOLO)
gemini --approval-mode auto_edit -p "@src/ Refactor this code for better performance"

# Full auto-approval (use with caution)
gemini --approval-mode yolo -p "@src/ @tests/ Update all tests to use new syntax"

# Specify allowed tools for selective automation
gemini --allowed-tools edit,read -p "@src/ Review and fix syntax issues"

Session Management

# Resume previous analysis sessions
gemini --resume latest -p "@src/ Continue the security analysis we started"

# List available sessions
gemini --list-sessions

# Delete old sessions
gemini --delete-session 3

Model and Output Configuration

# Specify Pro model for difficult analysis
gemini --model gemini-2.5-pro -p "@src/ Analyze this code architecture"

# JSON output for programmatic processing
gemini --output-format json -p "@src/ List all API endpoints" > endpoints.json

# Include additional directories beyond current workspace
gemini --include-directories ../shared-lib -p "@src/ Analyze dependencies"

Extensions and MCP Integration

# Use specific extensions for enhanced analysis
gemini --extensions security-testing -p "@src/ Perform security analysis"

# List available extensions
gemini --list-extensions

# Use specific MCP servers for specialized tools
gemini --allowed-mcp-server-names code-analyzer -p "@src/ Deep code analysis"

When to Use This Skill

Use gemini with appropriate options when:

• Context limitations: Analyzing entire codebases or large directories that exceed standard context windows
• Multi-file comparison: Comparing multiple large files simultaneously
• Architecture understanding: Need to understand project-wide patterns or architectural decisions
• File size considerations: Working with files totaling more than 100KB
• Implementation verification: Verifying if specific features, patterns, or security measures are implemented
• Pattern analysis: Checking for the presence of certain coding patterns across the entire codebase
• Automated workflows: Using approval modes for batch operations or refactoring tasks
• Session continuity: Resuming complex analyses across multiple sessions
• Specialized analysis: Leveraging extensions or MCP servers for domain-specific insights

Best Practices

• Specific queries: Be specific about what you're looking for to get accurate results
• Path management: Remember that paths in @ syntax are relative to your current working directory
• Content inclusion: The CLI includes file contents directly in the context
• Safety considerations: Use appropriate approval modes - avoid --yolo for destructive operations
• Context awareness: Gemini's context window can handle entire codebases that would overflow Claude's context
• Session utilization: Use session management for complex, multi-step analyses
• Extension leverage: Utilize appropriate extensions for domain-specific analysis

Reference Documentation

For complete CLI option reference, see references/gemini-cli-help which contains:

• All available commands and options
• Detailed parameter descriptions
• Extension management commands
• MCP server configuration options

Query Optimization

For best results, structure queries with:

1. Clear scope: Specify exactly what files/directories to analyze
2. Specific objectives: Clearly state what you're looking for
3. Expected format: Request specific output formats when helpful
4. Context scope: Include relevant files while excluding unnecessary ones to maintain focus
5. Tool selection: Use --allowed-tools to restrict to specific operations when appropriate
6. Output formatting: Leverage --output-format json for programmatic processing of results