aidp 0.24.0 → 0.26.0

data/lib/aidp/watch/review_processor.rb

@@ -0,0 +1,266 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "json"
+require "time"
+
+require_relative "../message_display"
+require_relative "reviewers/senior_dev_reviewer"
+require_relative "reviewers/security_reviewer"
+require_relative "reviewers/performance_reviewer"
+
+module Aidp
+  module Watch
+    # Handles the aidp-review label trigger by performing multi-persona code review
+    # and posting categorized findings back to the PR.
+    class ReviewProcessor
+      include Aidp::MessageDisplay
+
+      # Default label names
+      DEFAULT_REVIEW_LABEL = "aidp-review"
+
+      COMMENT_HEADER = "## 🤖 AIDP Code Review"
+
+      attr_reader :review_label
+
+      def initialize(repository_client:, state_store:, provider_name: nil, project_dir: Dir.pwd, label_config: {}, verbose: false)
+        @repository_client = repository_client
+        @state_store = state_store
+        @provider_name = provider_name
+        @project_dir = project_dir
+        @verbose = verbose
+
+        # Load label configuration
+        @review_label = label_config[:review_trigger] || label_config["review_trigger"] || DEFAULT_REVIEW_LABEL
+
+        # Initialize reviewers
+        @reviewers = [
+          Reviewers::SeniorDevReviewer.new(provider_name: provider_name),
+          Reviewers::SecurityReviewer.new(provider_name: provider_name),
+          Reviewers::PerformanceReviewer.new(provider_name: provider_name)
+        ]
+      end
+
+      def process(pr)
+        number = pr[:number]
+
+        if @state_store.review_processed?(number)
+          display_message("ℹ️  Review for PR ##{number} already posted. Skipping.", type: :muted)
+          return
+        end
+
+        display_message("🔍 Reviewing PR ##{number} (#{pr[:title]})", type: :info)
+
+        # Fetch PR details
+        pr_data = @repository_client.fetch_pull_request(number)
+        files = @repository_client.fetch_pull_request_files(number)
+        diff = @repository_client.fetch_pull_request_diff(number)
+
+        # Run reviews in parallel (conceptually - actual implementation is sequential)
+        review_results = run_reviews(pr_data: pr_data, files: files, diff: diff)
+
+        # Log review results
+        log_review(number, review_results)
+
+        # Format and post comment
+        comment_body = format_review_comment(pr: pr_data, review_results: review_results)
+        @repository_client.post_comment(number, comment_body)
+
+        display_message("💬 Posted review comment for PR ##{number}", type: :success)
+        @state_store.record_review(number, {
+          timestamp: Time.now.utc.iso8601,
+          reviewers: review_results.map { |r| r[:persona] },
+          total_findings: review_results.sum { |r| r[:findings].length }
+        })
+
+        # Remove review label after processing
+        begin
+          @repository_client.remove_labels(number, @review_label)
+          display_message("🏷️  Removed '#{@review_label}' label after review", type: :info)
+        rescue => e
+          display_message("⚠️  Failed to remove review label: #{e.message}", type: :warn)
+        end
+      rescue => e
+        display_message("❌ Review failed: #{e.message}", type: :error)
+        Aidp.log_error("review_processor", "Review failed", pr: number, error: e.message, backtrace: e.backtrace&.first(10))
+
+        # Post error comment
+        error_comment = <<~COMMENT
+          #{COMMENT_HEADER}
+
+          ❌ Automated review failed: #{e.message}
+
+          Please review manually or retry by re-adding the `#{@review_label}` label.
+        COMMENT
+        begin
+          @repository_client.post_comment(number, error_comment)
+        rescue
+          nil
+        end
+      end
+
+      private
+
+      def run_reviews(pr_data:, files:, diff:)
+        results = []
+
+        @reviewers.each do |reviewer|
+          display_message("  Running #{reviewer.persona_name} review...", type: :muted) if @verbose
+
+          begin
+            result = reviewer.review(pr_data: pr_data, files: files, diff: diff)
+            results << result
+
+            findings_count = result[:findings].length
+            display_message("  ✓ #{reviewer.persona_name}: #{findings_count} findings", type: :muted) if @verbose
+          rescue => e
+            display_message("  ✗ #{reviewer.persona_name} failed: #{e.message}", type: :warn)
+            Aidp.log_error("review_processor", "Reviewer failed", reviewer: reviewer.persona_name, error: e.message)
+            # Continue with other reviewers
+          end
+        end
+
+        results
+      end
+
+      def format_review_comment(pr:, review_results:)
+        parts = []
+        parts << COMMENT_HEADER
+        parts << ""
+        parts << "Automated multi-persona code review for PR ##{pr[:number]}"
+        parts << ""
+
+        # Collect all findings by severity
+        all_findings = collect_findings_by_severity(review_results)
+
+        if all_findings.empty?
+          parts << "✅ **No issues found!** All reviewers approved the changes."
+          parts << ""
+          parts << "_The code looks good from architecture, security, and performance perspectives._"
+        else
+          parts << "### Summary"
+          parts << ""
+          parts << "| Severity | Count |"
+          parts << "|----------|-------|"
+          parts << "| 🔴 High Priority | #{all_findings[:high].length} |"
+          parts << "| 🟠 Major | #{all_findings[:major].length} |"
+          parts << "| 🟡 Minor | #{all_findings[:minor].length} |"
+          parts << "| ⚪ Nit | #{all_findings[:nit].length} |"
+          parts << ""
+
+          # Add findings by severity
+          if all_findings[:high].any?
+            parts << "### 🔴 High Priority Issues"
+            parts << ""
+            parts << format_findings(all_findings[:high])
+            parts << ""
+          end
+
+          if all_findings[:major].any?
+            parts << "### 🟠 Major Issues"
+            parts << ""
+            parts << format_findings(all_findings[:major])
+            parts << ""
+          end
+
+          if all_findings[:minor].any?
+            parts << "### 🟡 Minor Improvements"
+            parts << ""
+            parts << format_findings(all_findings[:minor])
+            parts << ""
+          end
+
+          if all_findings[:nit].any?
+            parts << "<details>"
+            parts << "<summary>⚪ Nit-picks (click to expand)</summary>"
+            parts << ""
+            parts << format_findings(all_findings[:nit])
+            parts << ""
+            parts << "</details>"
+            parts << ""
+          end
+        end
+
+        # Add reviewer attribution
+        parts << "---"
+        parts << "_Reviewed by: #{review_results.map { |r| r[:persona] }.join(", ")}_"
+
+        parts.join("\n")
+      end
+
+      def collect_findings_by_severity(review_results)
+        findings = {high: [], major: [], minor: [], nit: []}
+
+        review_results.each do |result|
+          persona = result[:persona]
+          result[:findings].each do |finding|
+            severity = finding["severity"]&.to_sym || :minor
+            findings[severity] << finding.merge("reviewer" => persona)
+          end
+        end
+
+        findings
+      end
+
+      def format_findings(findings)
+        findings.map do |finding|
+          parts = []
+
+          # Header with category and reviewer
+          header = "**#{finding["category"]}**"
+          header += " (#{finding["reviewer"]})" if finding["reviewer"]
+          parts << header
+
+          # Location if available
+          if finding["file"]
+            location = "`#{finding["file"]}"
+            location += ":#{finding["line"]}" if finding["line"]
+            location += "`"
+            parts << location
+          end
+
+          # Message
+          parts << finding["message"]
+
+          # Suggestion if available
+          if finding["suggestion"]
+            parts << ""
+            parts << "<details>"
+            parts << "<summary>💡 Suggested fix</summary>"
+            parts << ""
+            parts << "```suggestion"
+            parts << finding["suggestion"]
+            parts << "```"
+            parts << "</details>"
+          end
+
+          parts.join("\n")
+        end.join("\n\n")
+      end
+
+      def log_review(pr_number, review_results)
+        log_dir = File.join(@project_dir, ".aidp", "logs", "pr_reviews")
+        FileUtils.mkdir_p(log_dir)
+
+        log_file = File.join(log_dir, "pr_#{pr_number}_#{Time.now.utc.strftime("%Y%m%d_%H%M%S")}.json")
+
+        log_data = {
+          pr_number: pr_number,
+          timestamp: Time.now.utc.iso8601,
+          reviews: review_results.map do |result|
+            {
+              persona: result[:persona],
+              findings_count: result[:findings].length,
+              findings: result[:findings]
+            }
+          end
+        }
+
+        File.write(log_file, JSON.pretty_generate(log_data))
+        display_message("📝 Review log saved to #{log_file}", type: :muted) if @verbose
+      rescue => e
+        display_message("⚠️  Failed to save review log: #{e.message}", type: :warn)
+      end
+    end
+  end
+end

data/lib/aidp/watch/reviewers/base_reviewer.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+require_relative "../../provider_manager"
+require_relative "../../harness/config_manager"
+
+module Aidp
+  module Watch
+    module Reviewers
+      # Base class for all PR reviewers
+      class BaseReviewer
+        attr_reader :provider_name, :persona_name, :focus_areas
+
+        def initialize(provider_name: nil)
+          @provider_name = provider_name
+          @persona_name = self.class::PERSONA_NAME
+          @focus_areas = self.class::FOCUS_AREAS
+        end
+
+        # Review the PR and return findings
+        # @param pr_data [Hash] PR metadata (number, title, body, etc.)
+        # @param files [Array<Hash>] Changed files with patches
+        # @param diff [String] Full diff content
+        # @return [Hash] Review findings with structure:
+        #   {
+        #     persona: String,
+        #     findings: [
+        #       {
+        #         severity: "high|major|minor|nit",
+        #         category: String,
+        #         message: String,
+        #         file: String (optional),
+        #         line: Integer (optional),
+        #         suggestion: String (optional)
+        #       }
+        #     ]
+        #   }
+        def review(pr_data:, files:, diff:)
+          raise NotImplementedError, "Subclasses must implement #review"
+        end
+
+        protected
+
+        def provider
+          @provider ||= begin
+            provider_name = @provider_name || detect_default_provider
+            Aidp::ProviderManager.get_provider(provider_name, use_harness: false)
+          end
+        end
+
+        def detect_default_provider
+          config_manager = Aidp::Harness::ConfigManager.new(Dir.pwd)
+          config_manager.default_provider || "anthropic"
+        rescue
+          "anthropic"
+        end
+
+        def system_prompt
+          <<~PROMPT
+            You are #{@persona_name}, reviewing a pull request.
+
+            Your focus areas are:
+            #{@focus_areas.map { |area| "- #{area}" }.join("\n")}
+
+            Review the code changes and provide structured feedback in the following JSON format:
+            {
+              "findings": [
+                {
+                  "severity": "high|major|minor|nit",
+                  "category": "Brief category (e.g., 'Security', 'Performance', 'Logic Error')",
+                  "message": "Detailed explanation of the issue",
+                  "file": "path/to/file.rb",
+                  "line": 42,
+                  "suggestion": "Optional: Suggested fix or improvement"
+                }
+              ]
+            }
+
+            Severity levels:
+            - high: Critical issues that must be fixed (security vulnerabilities, data loss, crashes)
+            - major: Significant problems that should be addressed (incorrect logic, performance issues)
+            - minor: Improvements that would be good to have (code quality, maintainability)
+            - nit: Stylistic or trivial suggestions (formatting, naming)
+
+            Focus on actionable, specific feedback. If no issues are found, return an empty findings array.
+          PROMPT
+        end
+
+        def analyze_with_provider(user_prompt)
+          full_prompt = "#{system_prompt}\n\n#{user_prompt}"
+          response = provider.send_message(prompt: full_prompt)
+          content = response.to_s.strip
+
+          # Extract JSON from response (handle code fences)
+          json_content = extract_json(content)
+
+          # Parse JSON response
+          parsed = JSON.parse(json_content)
+          parsed["findings"] || []
+        rescue JSON::ParserError => e
+          Aidp.log_error("reviewer", "Failed to parse provider response", persona: @persona_name, error: e.message, content: content)
+          []
+        rescue => e
+          Aidp.log_error("reviewer", "Review failed", persona: @persona_name, error: e.message)
+          []
+        end
+
+        def extract_json(text)
+          # Try to extract JSON from code fences or find JSON object
+          # Avoid regex to prevent ReDoS - use simple string operations
+          return text if text.start_with?("{") && text.end_with?("}")
+
+          # Extract from code fence using string operations
+          fence_start = text.index("```json")
+          if fence_start
+            json_start = text.index("{", fence_start)
+            fence_end = text.index("```", fence_start + 7)
+            if json_start && fence_end && json_start < fence_end
+              json_end = text.rindex("}", fence_end - 1)
+              return text[json_start..json_end] if json_end && json_end > json_start
+            end
+          end
+
+          # Find JSON object using string operations
+          first_brace = text.index("{")
+          last_brace = text.rindex("}")
+          if first_brace && last_brace && last_brace > first_brace
+            text[first_brace..last_brace]
+          else
+            text
+          end
+        end
+
+        def build_review_prompt(pr_data:, files:, diff:)
+          <<~PROMPT
+            Review this pull request from your expertise perspective:
+
+            **PR ##{pr_data[:number]}: #{pr_data[:title]}**
+
+            #{pr_data[:body]}
+
+            **Changed Files (#{files.length}):**
+            #{files.map { |f| "- #{f[:filename]} (+#{f[:additions]}/-#{f[:deletions]})" }.join("\n")}
+
+            **Diff:**
+            ```diff
+            #{truncate_diff(diff, max_lines: 500)}
+            ```
+
+            Please review the changes and provide your findings in JSON format.
+          PROMPT
+        end
+
+        def truncate_diff(diff, max_lines: 500)
+          lines = diff.lines
+          if lines.length > max_lines
+            lines.first(max_lines).join + "\n... (diff truncated, #{lines.length - max_lines} more lines)"
+          else
+            diff
+          end
+        end
+      end
+    end
+  end
+end

data/lib/aidp/watch/reviewers/performance_reviewer.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require_relative "base_reviewer"
+
+module Aidp
+  module Watch
+    module Reviewers
+      # Performance Reviewer - focuses on performance issues and optimizations
+      class PerformanceReviewer < BaseReviewer
+        PERSONA_NAME = "Performance Analyst"
+        FOCUS_AREAS = [
+          "Algorithm complexity (O(n) vs O(n²), etc.)",
+          "Database query optimization (N+1 queries, missing indexes)",
+          "Memory allocation and garbage collection pressure",
+          "Blocking I/O operations",
+          "Inefficient data structures",
+          "Unnecessary computations or redundant work",
+          "Caching opportunities",
+          "Resource leaks (connections, file handles, etc.)",
+          "Concurrent access patterns",
+          "Network round-trips and latency"
+        ].freeze
+
+        def review(pr_data:, files:, diff:)
+          user_prompt = build_performance_prompt(pr_data: pr_data, files: files, diff: diff)
+          findings = analyze_with_provider(user_prompt)
+
+          {
+            persona: PERSONA_NAME,
+            findings: findings
+          }
+        end
+
+        private
+
+        def build_performance_prompt(pr_data:, files:, diff:)
+          base_prompt = build_review_prompt(pr_data: pr_data, files: files, diff: diff)
+
+          <<~PROMPT
+            #{base_prompt}
+
+            **Additional Performance Focus:**
+            Pay special attention to:
+            1. Loop complexity and nested iterations
+            2. Database queries (look for N+1 patterns, missing eager loading)
+            3. Memory allocations in hot paths
+            4. I/O operations (file, network, database) - are they batched?
+            5. Synchronous operations that could be asynchronous
+            6. Large data structures being copied or traversed repeatedly
+            7. Missing caching opportunities
+            8. Resource pooling and connection management
+            9. Lazy loading vs eager loading trade-offs
+            10. Potential bottlenecks under high load
+
+            Mark performance issues as:
+            - "high" if they could cause timeouts, out-of-memory errors, or severe degradation
+            - "major" if they significantly impact response time or resource usage
+            - "minor" for optimizations that would improve efficiency
+            - "nit" for micro-optimizations with negligible impact
+          PROMPT
+        end
+      end
+    end
+  end
+end

data/lib/aidp/watch/reviewers/security_reviewer.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require_relative "base_reviewer"
+
+module Aidp
+  module Watch
+    module Reviewers
+      # Security Reviewer - focuses on security vulnerabilities and risks
+      class SecurityReviewer < BaseReviewer
+        PERSONA_NAME = "Security Specialist"
+        FOCUS_AREAS = [
+          "Injection vulnerabilities (SQL, command, XSS, etc.)",
+          "Authentication and authorization flaws",
+          "Sensitive data exposure",
+          "Insecure deserialization",
+          "Security misconfiguration",
+          "Insufficient logging and monitoring",
+          "Insecure dependencies",
+          "Secrets and credentials in code",
+          "Input validation and sanitization",
+          "OWASP Top 10 vulnerabilities"
+        ].freeze
+
+        def review(pr_data:, files:, diff:)
+          user_prompt = build_security_prompt(pr_data: pr_data, files: files, diff: diff)
+          findings = analyze_with_provider(user_prompt)
+
+          {
+            persona: PERSONA_NAME,
+            findings: findings
+          }
+        end
+
+        private
+
+        def build_security_prompt(pr_data:, files:, diff:)
+          base_prompt = build_review_prompt(pr_data: pr_data, files: files, diff: diff)
+
+          <<~PROMPT
+            #{base_prompt}
+
+            **Additional Security Focus:**
+            Pay special attention to:
+            1. User input handling and validation
+            2. Database queries and potential SQL injection
+            3. File operations and path traversal risks
+            4. Authentication and session management
+            5. Cryptographic operations and key management
+            6. API endpoints and their access controls
+            7. Third-party dependencies and their security posture
+            8. Environment variables and configuration
+            9. Logging of sensitive information
+            10. Command execution and shell injection risks
+
+            Mark any security issues as "high" severity if they could lead to:
+            - Unauthorized access or privilege escalation
+            - Data breach or exposure of sensitive information
+            - Remote code execution
+            - Denial of service
+          PROMPT
+        end
+      end
+    end
+  end
+end

data/lib/aidp/watch/reviewers/senior_dev_reviewer.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative "base_reviewer"
+
+module Aidp
+  module Watch
+    module Reviewers
+      # Senior Developer Reviewer - focuses on correctness, architecture, and best practices
+      class SeniorDevReviewer < BaseReviewer
+        PERSONA_NAME = "Senior Developer"
+        FOCUS_AREAS = [
+          "Code correctness and logic errors",
+          "Architecture and design patterns",
+          "API design and consistency",
+          "Error handling and edge cases",
+          "Code maintainability and readability",
+          "Testing coverage and quality",
+          "Documentation completeness"
+        ].freeze
+
+        def review(pr_data:, files:, diff:)
+          user_prompt = build_review_prompt(pr_data: pr_data, files: files, diff: diff)
+          findings = analyze_with_provider(user_prompt)
+
+          {
+            persona: PERSONA_NAME,
+            findings: findings
+          }
+        end
+      end
+    end
+  end
+end