aidp 0.24.0 → 0.25.0

data/lib/aidp/watch/repository_client.rb

@@ -79,6 +79,35 @@ module Aidp
         add_labels(number, *new_labels) unless new_labels.empty?
       end
 
+      def most_recent_label_actor(number)
+        gh_available? ? most_recent_label_actor_via_gh(number) : nil
+      end
+
+      # PR-specific operations
+      def fetch_pull_request(number)
+        gh_available? ? fetch_pull_request_via_gh(number) : fetch_pull_request_via_api(number)
+      end
+
+      def fetch_pull_request_diff(number)
+        gh_available? ? fetch_pull_request_diff_via_gh(number) : fetch_pull_request_diff_via_api(number)
+      end
+
+      def fetch_pull_request_files(number)
+        gh_available? ? fetch_pull_request_files_via_gh(number) : fetch_pull_request_files_via_api(number)
+      end
+
+      def fetch_ci_status(number)
+        gh_available? ? fetch_ci_status_via_gh(number) : fetch_ci_status_via_api(number)
+      end
+
+      def post_review_comment(number, body, commit_id: nil, path: nil, line: nil)
+        gh_available? ? post_review_comment_via_gh(number, body, commit_id: commit_id, path: path, line: line) : post_review_comment_via_api(number, body, commit_id: commit_id, path: path, line: line)
+      end
+
+      def list_pull_requests(labels: [], state: "open")
+        gh_available? ? list_pull_requests_via_gh(labels: labels, state: state) : list_pull_requests_via_api(labels: labels, state: state)
+      end
+
       private
 
       def list_issues_via_gh(labels:, state:)
@@ -254,6 +283,357 @@ module Aidp
         end
       end
 
+      def most_recent_label_actor_via_gh(number)
+        # Use GitHub GraphQL API via gh cli to fetch the most recent label event actor
+        query = <<~GRAPHQL
+          query($owner: String!, $repo: String!, $number: Int!) {
+            repository(owner: $owner, name: $repo) {
+              issue(number: $number) {
+                timelineItems(last: 100, itemTypes: [LABELED_EVENT]) {
+                  nodes {
+                    ... on LabeledEvent {
+                      createdAt
+                      actor {
+                        login
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        GRAPHQL
+
+        cmd = [
+          "gh", "api", "graphql",
+          "-f", "query=#{query}",
+          "-F", "owner=#{owner}",
+          "-F", "repo=#{repo}",
+          "-F", "number=#{number}"
+        ]
+
+        stdout, stderr, status = Open3.capture3(*cmd)
+        unless status.success?
+          Aidp.log_warn("repository_client", "Failed to fetch label events via GraphQL", error: stderr.strip)
+          return nil
+        end
+
+        data = JSON.parse(stdout)
+        events = data.dig("data", "repository", "issue", "timelineItems", "nodes") || []
+
+        # Filter out events without actors and sort by createdAt to get most recent
+        valid_events = events.select { |event| event.dig("actor", "login") }
+        return nil if valid_events.empty?
+
+        most_recent = valid_events.max_by { |event| event["createdAt"] }
+        most_recent.dig("actor", "login")
+      rescue JSON::ParserError => e
+        Aidp.log_warn("repository_client", "Failed to parse GraphQL response", error: e.message)
+        nil
+      rescue => e
+        Aidp.log_warn("repository_client", "Unexpected error fetching label actor", error: e.message)
+        nil
+      end
+
+      # PR operations via gh CLI
+      def list_pull_requests_via_gh(labels:, state:)
+        json_fields = %w[number title labels updatedAt state url headRefName baseRefName]
+        cmd = ["gh", "pr", "list", "--repo", full_repo, "--state", state, "--json", json_fields.join(",")]
+        labels.each do |label|
+          cmd += ["--label", label]
+        end
+
+        stdout, stderr, status = Open3.capture3(*cmd)
+        unless status.success?
+          warn("GitHub CLI PR list failed: #{stderr}")
+          return []
+        end
+
+        JSON.parse(stdout).map { |raw| normalize_pull_request(raw) }
+      rescue JSON::ParserError => e
+        warn("Failed to parse GH CLI PR list response: #{e.message}")
+        []
+      end
+
+      def list_pull_requests_via_api(labels:, state:)
+        label_param = labels.join(",")
+        uri = URI("https://api.github.com/repos/#{full_repo}/pulls?state=#{state}")
+        uri.query = [uri.query, "labels=#{URI.encode_www_form_component(label_param)}"].compact.join("&") unless label_param.empty?
+
+        response = Net::HTTP.get_response(uri)
+        return [] unless response.code == "200"
+
+        JSON.parse(response.body).map { |raw| normalize_pull_request_api(raw) }
+      rescue => e
+        warn("GitHub API PR list failed: #{e.message}")
+        []
+      end
+
+      def fetch_pull_request_via_gh(number)
+        fields = %w[number title body labels state url headRefName baseRefName commits author mergeable]
+        cmd = ["gh", "pr", "view", number.to_s, "--repo", full_repo, "--json", fields.join(",")]
+
+        stdout, stderr, status = Open3.capture3(*cmd)
+        raise "GitHub CLI error: #{stderr.strip}" unless status.success?
+
+        data = JSON.parse(stdout)
+        normalize_pull_request_detail(data)
+      rescue JSON::ParserError => e
+        raise "Failed to parse GitHub CLI PR response: #{e.message}"
+      end
+
+      def fetch_pull_request_via_api(number)
+        uri = URI("https://api.github.com/repos/#{full_repo}/pulls/#{number}")
+        response = Net::HTTP.get_response(uri)
+        raise "GitHub API error (#{response.code})" unless response.code == "200"
+
+        data = JSON.parse(response.body)
+        normalize_pull_request_detail_api(data)
+      end
+
+      def fetch_pull_request_diff_via_gh(number)
+        cmd = ["gh", "pr", "diff", number.to_s, "--repo", full_repo]
+        stdout, stderr, status = Open3.capture3(*cmd)
+        raise "Failed to fetch PR diff via gh: #{stderr.strip}" unless status.success?
+
+        stdout
+      end
+
+      def fetch_pull_request_diff_via_api(number)
+        uri = URI("https://api.github.com/repos/#{full_repo}/pulls/#{number}")
+        request = Net::HTTP::Get.new(uri)
+        request["Accept"] = "application/vnd.github.v3.diff"
+
+        response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
+          http.request(request)
+        end
+
+        raise "GitHub API diff failed (#{response.code})" unless response.code == "200"
+        response.body
+      end
+
+      def fetch_pull_request_files_via_gh(number)
+        # Use gh api to fetch changed files
+        cmd = ["gh", "api", "repos/#{full_repo}/pulls/#{number}/files", "--jq", "."]
+        stdout, stderr, status = Open3.capture3(*cmd)
+        raise "Failed to fetch PR files via gh: #{stderr.strip}" unless status.success?
+
+        JSON.parse(stdout).map { |file| normalize_pr_file(file) }
+      rescue JSON::ParserError => e
+        raise "Failed to parse PR files response: #{e.message}"
+      end
+
+      def fetch_pull_request_files_via_api(number)
+        uri = URI("https://api.github.com/repos/#{full_repo}/pulls/#{number}/files")
+        response = Net::HTTP.get_response(uri)
+        raise "GitHub API files failed (#{response.code})" unless response.code == "200"
+
+        JSON.parse(response.body).map { |file| normalize_pr_file(file) }
+      rescue JSON::ParserError => e
+        raise "Failed to parse PR files response: #{e.message}"
+      end
+
+      def fetch_ci_status_via_gh(number)
+        # Fetch PR to get the head SHA
+        pr_data = fetch_pull_request_via_gh(number)
+        head_sha = pr_data[:head_sha]
+
+        # Fetch check runs for the commit
+        cmd = ["gh", "api", "repos/#{full_repo}/commits/#{head_sha}/check-runs", "--jq", "."]
+        stdout, _stderr, status = Open3.capture3(*cmd)
+
+        if status.success?
+          data = JSON.parse(stdout)
+          check_runs = data["check_runs"] || []
+          normalize_ci_status(check_runs, head_sha)
+        else
+          # Fallback to status checks
+          {sha: head_sha, state: "unknown", checks: []}
+        end
+      rescue => e
+        Aidp.log_warn("repository_client", "Failed to fetch CI status", error: e.message)
+        {sha: nil, state: "unknown", checks: []}
+      end
+
+      def fetch_ci_status_via_api(number)
+        pr_data = fetch_pull_request_via_api(number)
+        head_sha = pr_data[:head_sha]
+
+        uri = URI("https://api.github.com/repos/#{full_repo}/commits/#{head_sha}/check-runs")
+        request = Net::HTTP::Get.new(uri)
+        request["Accept"] = "application/vnd.github.v3+json"
+
+        response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
+          http.request(request)
+        end
+
+        if response.code == "200"
+          data = JSON.parse(response.body)
+          check_runs = data["check_runs"] || []
+          normalize_ci_status(check_runs, head_sha)
+        else
+          {sha: head_sha, state: "unknown", checks: []}
+        end
+      rescue => e
+        Aidp.log_warn("repository_client", "Failed to fetch CI status", error: e.message)
+        {sha: nil, state: "unknown", checks: []}
+      end
+
+      def post_review_comment_via_gh(number, body, commit_id: nil, path: nil, line: nil)
+        if path && line && commit_id
+          # Note: gh CLI doesn't support inline comments directly, so we use the API
+          # For inline comments, we need to use the GitHub API
+          post_review_comment_via_api(number, body, commit_id: commit_id, path: path, line: line)
+        else
+          # Post general review comment
+          cmd = ["gh", "pr", "comment", number.to_s, "--repo", full_repo, "--body", body]
+          stdout, stderr, status = Open3.capture3(*cmd)
+          raise "Failed to post review comment via gh: #{stderr.strip}" unless status.success?
+
+          stdout.strip
+        end
+      end
+
+      def post_review_comment_via_api(number, body, commit_id: nil, path: nil, line: nil)
+        uri, request = if path && line && commit_id
+          # Post inline review comment
+          review_uri = URI("https://api.github.com/repos/#{full_repo}/pulls/#{number}/reviews")
+          review_request = Net::HTTP::Post.new(review_uri)
+          review_request["Content-Type"] = "application/json"
+          review_request["Accept"] = "application/vnd.github.v3+json"
+
+          review_data = {
+            body: body,
+            event: "COMMENT",
+            comments: [
+              {
+                path: path,
+                line: line,
+                body: body
+              }
+            ]
+          }
+
+          review_request.body = JSON.dump(review_data)
+          [review_uri, review_request]
+        else
+          # Post general comment on the PR
+          comment_uri = URI("https://api.github.com/repos/#{full_repo}/issues/#{number}/comments")
+          comment_request = Net::HTTP::Post.new(comment_uri)
+          comment_request["Content-Type"] = "application/json"
+          comment_request.body = JSON.dump({body: body})
+          [comment_uri, comment_request]
+        end
+
+        response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
+          http.request(request)
+        end
+
+        error_msg = (path && line && commit_id) ? "GitHub API review comment failed (#{response.code}): #{response.body}" : "GitHub API comment failed (#{response.code})"
+        raise error_msg unless response.code.start_with?("2")
+
+        response.body
+      end
+
+      # Normalization methods for PRs
+      def normalize_pull_request(raw)
+        {
+          number: raw["number"],
+          title: raw["title"],
+          labels: Array(raw["labels"]).map { |label| label.is_a?(Hash) ? label["name"] : label },
+          updated_at: raw["updatedAt"],
+          state: raw["state"],
+          url: raw["url"],
+          head_ref: raw["headRefName"],
+          base_ref: raw["baseRefName"]
+        }
+      end
+
+      def normalize_pull_request_api(raw)
+        {
+          number: raw["number"],
+          title: raw["title"],
+          labels: Array(raw["labels"]).map { |label| label["name"] },
+          updated_at: raw["updated_at"],
+          state: raw["state"],
+          url: raw["html_url"],
+          head_ref: raw.dig("head", "ref"),
+          base_ref: raw.dig("base", "ref")
+        }
+      end
+
+      def normalize_pull_request_detail(raw)
+        {
+          number: raw["number"],
+          title: raw["title"],
+          body: raw["body"] || "",
+          author: raw.dig("author", "login") || raw["author"],
+          labels: Array(raw["labels"]).map { |label| label.is_a?(Hash) ? label["name"] : label },
+          state: raw["state"],
+          url: raw["url"],
+          head_ref: raw["headRefName"],
+          base_ref: raw["baseRefName"],
+          head_sha: raw.dig("commits", 0, "oid") || raw["headRefOid"],
+          mergeable: raw["mergeable"]
+        }
+      end
+
+      def normalize_pull_request_detail_api(raw)
+        {
+          number: raw["number"],
+          title: raw["title"],
+          body: raw["body"] || "",
+          author: raw.dig("user", "login"),
+          labels: Array(raw["labels"]).map { |label| label["name"] },
+          state: raw["state"],
+          url: raw["html_url"],
+          head_ref: raw.dig("head", "ref"),
+          base_ref: raw.dig("base", "ref"),
+          head_sha: raw.dig("head", "sha"),
+          mergeable: raw["mergeable"]
+        }
+      end
+
+      def normalize_pr_file(raw)
+        {
+          filename: raw["filename"],
+          status: raw["status"],
+          additions: raw["additions"],
+          deletions: raw["deletions"],
+          changes: raw["changes"],
+          patch: raw["patch"]
+        }
+      end
+
+      def normalize_ci_status(check_runs, head_sha)
+        checks = check_runs.map do |run|
+          {
+            name: run["name"],
+            status: run["status"],
+            conclusion: run["conclusion"],
+            details_url: run["details_url"],
+            output: run["output"]
+          }
+        end
+
+        # Determine overall state
+        state = if checks.any? { |c| c[:conclusion] == "failure" }
+          "failure"
+        elsif checks.any? { |c| c[:status] != "completed" }
+          "pending"
+        elsif checks.all? { |c| c[:conclusion] == "success" }
+          "success"
+        else
+          "unknown"
+        end
+
+        {
+          sha: head_sha,
+          state: state,
+          checks: checks
+        }
+      end
+
       def normalize_issue(raw)
         {
           number: raw["number"],

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