MCP Gemini Server

/** * Collection of specialized prompt templates for different review scenarios. * These templates are designed to provide tailored guidance to the Gemini model * for various types of code reviews. */ /** * Base template for code reviews with placeholders for context */ export const baseReviewTemplate = `You are a senior software engineer reviewing the following code changes. {{repositoryContext}} {{focusInstructions}} Analyze the following git diff: \`\`\`diff {{diffContent}} \`\`\` Provide your code review with the following sections: 1. Summary of Changes: A brief overview of what's changing 2. Key Observations: The most important findings from your review 3. Detailed Review: File-by-file analysis of the changes 4. Recommendations: Specific suggestions for improvements 5. Questions: Any points needing clarification from the author Be concise yet thorough in your analysis.`; /** * Enhanced template for security-focused reviews */ export const securityReviewTemplate = `You are a senior security engineer with OWASP certification and extensive experience in identifying vulnerabilities in software applications. {{repositoryContext}} TASK: Perform a comprehensive security review of the following code changes, focusing on potential vulnerabilities and security risks. STEP 1: Analyze the code for common security issues: - Injection vulnerabilities (SQL, NoSQL, command injection, etc.) - Authentication and authorization flaws - Sensitive data exposure - Security misconfigurations - Cross-site scripting (XSS) and cross-site request forgery (CSRF) - Broken access control - Insecure deserialization - Using components with known vulnerabilities - Input validation issues - Cryptographic problems STEP 2: For each identified issue: - Describe the vulnerability in detail - Assess its severity (Critical, High, Medium, Low) - Explain the potential impact - Provide a concrete remediation approach with code examples Analyze the following git diff: \`\`\`diff {{diffContent}} \`\`\` Your response MUST follow this format: 1. EXECUTIVE SUMMARY: Brief overview of security posture 2. CRITICAL ISSUES: Must be fixed immediately 3. HIGH PRIORITY ISSUES: Should be fixed soon 4. MEDIUM/LOW PRIORITY ISSUES: Address when possible 5. SECURE CODING RECOMMENDATIONS: Best practices to implement`; /** * Enhanced template for performance-focused reviews */ export const performanceReviewTemplate = `You are a performance optimization expert with deep knowledge of runtime characteristics and profiling techniques. {{repositoryContext}} TASK: Perform a detailed performance analysis of the following code, identifying optimization opportunities and potential bottlenecks. STEP 1: Systematically analyze each section of code for: - Algorithm efficiency and complexity (provide Big O analysis) - Resource consumption patterns (memory, CPU, I/O) - Database query performance and optimization - Concurrency and parallelism opportunities - Caching potential and data access patterns - Unnecessary computation or redundant operations STEP 2: For each identified performance issue: - Describe the specific performance problem - Estimate the performance impact (critical, significant, moderate, minor) - Explain why it's problematic - Provide a specific optimization solution with code examples - Note any tradeoffs the optimization might introduce Analyze the following git diff: \`\`\`diff {{diffContent}} \`\`\` Your response MUST follow this format: 1. PERFORMANCE SUMMARY: Overall assessment with key metrics 2. CRITICAL BOTTLENECKS: Highest-impact issues to address first 3. SIGNIFICANT OPTIMIZATIONS: Important improvements with measurable impact 4. MINOR OPTIMIZATIONS: Small enhancements for completeness 5. MONITORING RECOMMENDATIONS: Suggestions for ongoing performance measurement`; /** * Enhanced template for architecture-focused reviews */ export const architectureReviewTemplate = `You are a senior software architect with expertise in designing scalable, maintainable software systems. {{repositoryContext}} TASK: Perform an architectural analysis of the following code changes, focusing on design patterns, component relationships, and system structure. STEP 1: Analyze the architectural aspects of the code: - Design pattern implementation and appropriateness - Component responsibilities and cohesion - Interface design and abstraction - Dependency management and coupling - Modularity and extensibility - Separation of concerns - Error handling strategies - Consistency with architectural principles STEP 2: For each architectural observation: - Describe the architectural element or decision - Analyze its impact on the overall system - Evaluate adherence to SOLID principles and other architectural best practices - Suggest improvements with rationale Analyze the following git diff: \`\`\`diff {{diffContent}} \`\`\` Your response MUST follow this format: 1. ARCHITECTURAL OVERVIEW: Summary of the code's architecture 2. STRENGTHS: Positive architectural aspects of the code 3. CONCERNS: Architectural issues or anti-patterns identified 4. REFACTORING RECOMMENDATIONS: Suggestions for architectural improvements 5. LONG-TERM CONSIDERATIONS: How these changes affect system evolution`; /** * Enhanced template for bug-focused reviews */ export const bugReviewTemplate = `You are a quality assurance engineer with expertise in identifying logic flaws and edge cases in software. {{repositoryContext}} TASK: Perform a thorough analysis of the following code changes to identify potential bugs, edge cases, and logical errors. STEP 1: Analyze the code for common bug sources: - Off-by-one errors - Null/undefined handling issues - Edge case oversights - Race conditions - Resource leaks - Error handling gaps - Typos in critical code - Incorrect assumptions - Boundary condition failures - Exception handling problems STEP 2: For each potential bug: - Describe the issue and why it's problematic - Explain the conditions under which it would occur - Assess its severity and potential impact - Provide a fix with code examples - Suggest tests that would catch the issue Analyze the following git diff: \`\`\`diff {{diffContent}} \`\`\` Your response MUST follow this format: 1. BUG RISK SUMMARY: Overview of potential issues 2. CRITICAL BUGS: Issues that could cause system failure or data corruption 3. MAJOR BUGS: Significant functional issues that need addressing 4. MINOR BUGS: Less severe issues that should be fixed 5. TEST RECOMMENDATIONS: Tests to implement to prevent similar bugs`; /** * Enhanced template for general comprehensive reviews */ export const generalReviewTemplate = `You are a senior software engineer with expertise across multiple domains including security, performance, architecture, and testing. {{repositoryContext}} TASK: Perform a comprehensive review of the following code changes, covering all aspects of software quality. I want you to follow a specific review process: STEP 1: Understand the overall purpose - Identify what problem the code is solving - Determine how it fits into the broader application STEP 2: Analyze code quality - Readability and naming conventions - Function/method size and complexity - Comments and documentation - Consistency with existing patterns STEP 3: Evaluate correctness - Potential bugs and edge cases - Error handling completeness - Test coverage adequacy STEP 4: Consider performance - Inefficient algorithms or patterns - Resource utilization concerns - Optimization opportunities STEP 5: Assess maintainability - Extensibility for future changes - Coupling and cohesion - Clear separation of concerns STEP 6: Security review - Potential vulnerabilities - Input validation issues - Security best practices Analyze the following git diff: \`\`\`diff {{diffContent}} \`\`\` Your response MUST follow this format: 1. SUMMARY: Brief overview of the changes and their purpose 2. KEY OBSERVATIONS: Most important findings (positive and negative) 3. DETAILED REVIEW: Analysis by file with specific comments 4. RECOMMENDATIONS: Prioritized suggestions for improvement 5. QUESTIONS: Any clarifications needed from the developer`; /** * Replace placeholders in a template with actual values * * @param template Template string with placeholders * @param context Context object with values to replace placeholders * @returns Processed template with placeholders replaced */ export function processTemplate( template: string, context: { repositoryContext?: string; diffContent: string; focusInstructions?: string; [key: string]: string | undefined; } ): string { let processedTemplate = template; // Replace each placeholder with its corresponding value for (const [key, value] of Object.entries(context)) { // Skip undefined values if (value === undefined) continue; // Convert the value to string if it's not already const stringValue = typeof value === "string" ? value : String(value); // Replace the placeholder with the value processedTemplate = processedTemplate.replace( new RegExp(`{{${key}}}`, "g"), stringValue ); } // Remove any remaining placeholder processedTemplate = processedTemplate.replace(/{{[^{}]+}}/g, ""); return processedTemplate; } /** * Get the appropriate template for a specific review focus * * @param reviewFocus The focus area for the review * @returns The template string for the specified focus */ export function getReviewTemplate( reviewFocus: "security" | "performance" | "architecture" | "bugs" | "general" ): string { switch (reviewFocus) { case "security": return securityReviewTemplate; case "performance": return performanceReviewTemplate; case "architecture": return architectureReviewTemplate; case "bugs": return bugReviewTemplate; case "general": default: return generalReviewTemplate; } } /** * Generate focus-specific instructions for the base template * * @param reviewFocus The focus area for the review * @returns Instruction string for the specified focus */ export function getFocusInstructions( reviewFocus: "security" | "performance" | "architecture" | "bugs" | "general" ): string { switch (reviewFocus) { case "security": return ` Focus on identifying security vulnerabilities in the code changes, such as: - Input validation issues - Authentication/authorization flaws - Data exposure risks - Injection vulnerabilities - Insecure cryptography - CSRF/XSS vectors - Any other security concerns`; case "performance": return ` Focus on identifying performance implications in the code changes, such as: - Algorithm complexity issues (O(n²) vs O(n)) - Unnecessary computations or memory usage - Database query inefficiencies - Unoptimized loops or data structures - Potential memory leaks - Resource contention issues`; case "architecture": return ` Focus on architectural aspects of the code changes, such as: - Design pattern conformance - Component responsibilities and cohesion - Dependency management - API design principles - Modularity and extensibility - Separation of concerns`; case "bugs": return ` Focus on identifying potential bugs and logical errors in the code changes, such as: - Off-by-one errors - Null/undefined handling issues - Edge case oversights - Race conditions - Error handling gaps - Typos in critical code`; case "general": default: return ` Provide a comprehensive review covering: - Code quality and readability - Potential bugs or errors - Performance implications - Security considerations - Architectural aspects - Best practices and style conventions`; } }