aidp 0.27.0 → 0.28.0

data/lib/aidp/watch/repository_client.rb

@@ -122,6 +122,42 @@ module Aidp
 
       private
 
+      # Retry a GitHub CLI operation with exponential backoff
+      # Rescues network-related RuntimeErrors from gh CLI
+      def with_gh_retry(operation_name, max_retries: 3, initial_delay: 1.0)
+        retries = 0
+        begin
+          yield
+        rescue RuntimeError => e
+          # Only retry on network-related errors from gh CLI
+          if e.message.include?("unexpected EOF") ||
+              e.message.include?("connection") ||
+              e.message.include?("timeout") ||
+              e.message.include?("Request to https://api.github.com")
+            retries += 1
+            if retries <= max_retries
+              delay = initial_delay * (2**(retries - 1))
+              Aidp.log_warn("repository_client", "gh_retry",
+                operation: operation_name,
+                attempt: retries,
+                max_retries: max_retries,
+                delay: delay,
+                error: e.message.lines.first&.strip)
+              sleep(delay)
+              retry
+            else
+              Aidp.log_error("repository_client", "gh_retry_exhausted",
+                operation: operation_name,
+                error: e.message)
+              raise
+            end
+          else
+            # Non-network errors should not be retried
+            raise
+          end
+        end
+      end
+
       def list_issues_via_gh(labels:, state:)
         json_fields = %w[number title labels updatedAt state url assignees]
         cmd = ["gh", "issue", "list", "--repo", full_repo, "--state", state, "--json", json_fields.join(",")]
@@ -156,14 +192,16 @@ module Aidp
       end
 
       def fetch_issue_via_gh(number)
-        fields = %w[number title body comments labels state assignees url updatedAt author]
-        cmd = ["gh", "issue", "view", number.to_s, "--repo", full_repo, "--json", fields.join(",")]
+        with_gh_retry("fetch_issue") do
+          fields = %w[number title body comments labels state assignees url updatedAt author]
+          cmd = ["gh", "issue", "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?
+          stdout, stderr, status = Open3.capture3(*cmd)
+          raise "GitHub CLI error: #{stderr.strip}" unless status.success?
 
-        data = JSON.parse(stdout)
-        normalize_issue_detail(data)
+          data = JSON.parse(stdout)
+          normalize_issue_detail(data)
+        end
       rescue JSON::ParserError => e
         raise "Failed to parse GitHub CLI issue response: #{e.message}"
       end
@@ -240,6 +278,33 @@ module Aidp
       end
 
       def create_pull_request_via_gh(title:, body:, head:, base:, issue_number:, draft: false, assignee: nil)
+        Aidp.log_debug(
+          "repository_client",
+          "preparing_gh_pr_create",
+          repo: full_repo,
+          head: head,
+          base: base,
+          draft: draft,
+          assignee: assignee,
+          issue_number: issue_number,
+          gh_available: gh_available?,
+          title_length: title.length,
+          body_length: body.length
+        )
+
+        unless gh_available?
+          error_msg = "GitHub CLI (gh) is not available - cannot create PR"
+          Aidp.log_error(
+            "repository_client",
+            "gh_cli_not_available",
+            repo: full_repo,
+            head: head,
+            base: base,
+            message: error_msg
+          )
+          raise error_msg
+        end
+
         cmd = [
           "gh", "pr", "create",
           "--repo", full_repo,
@@ -251,8 +316,56 @@ module Aidp
         cmd += ["--draft"] if draft
         cmd += ["--assignee", assignee] if assignee
 
+        Aidp.log_debug(
+          "repository_client",
+          "executing_gh_pr_create",
+          repo: full_repo,
+          head: head,
+          base: base,
+          draft: draft,
+          assignee: assignee,
+          command: cmd.join(" ")
+        )
+
         stdout, stderr, status = Open3.capture3(*cmd)
-        raise "Failed to create PR via gh: #{stderr.strip}" unless status.success?
+
+        Aidp.log_debug(
+          "repository_client",
+          "gh_pr_create_result",
+          repo: full_repo,
+          success: status.success?,
+          exit_code: status.exitstatus,
+          stdout_length: stdout.length,
+          stderr_length: stderr.length,
+          stdout_preview: stdout[0, 200],
+          stderr: stderr
+        )
+
+        unless status.success?
+          Aidp.log_error(
+            "repository_client",
+            "gh_pr_create_failed",
+            repo: full_repo,
+            head: head,
+            base: base,
+            issue_number: issue_number,
+            exit_code: status.exitstatus,
+            stderr: stderr,
+            stdout: stdout,
+            command: cmd.join(" ")
+          )
+          raise "Failed to create PR via gh: #{stderr.strip}"
+        end
+
+        Aidp.log_info(
+          "repository_client",
+          "gh_pr_create_success",
+          repo: full_repo,
+          head: head,
+          base: base,
+          issue_number: issue_number,
+          output_preview: stdout[0, 200]
+        )
 
         stdout.strip
       end
@@ -476,14 +589,19 @@ module Aidp
         cmd = ["gh", "api", "repos/#{full_repo}/commits/#{head_sha}/check-runs", "--jq", "."]
         stdout, _stderr, status = Open3.capture3(*cmd)
 
-        if status.success?
+        check_runs = if status.success?
           data = JSON.parse(stdout)
-          check_runs = data["check_runs"] || []
-          normalize_ci_status(check_runs, head_sha)
+          data["check_runs"] || []
         else
-          # Fallback to status checks
-          {sha: head_sha, state: "unknown", checks: []}
+          Aidp.log_warn("repository_client", "Failed to fetch check runs", sha: head_sha)
+          []
         end
+
+        # Also fetch commit statuses (for OAuth apps, webhooks, etc.)
+        commit_statuses = fetch_commit_statuses_via_gh(head_sha)
+
+        # Combine and normalize both check runs and commit statuses
+        normalize_ci_status_combined(check_runs, commit_statuses, head_sha)
       rescue => e
         Aidp.log_warn("repository_client", "Failed to fetch CI status", error: e.message)
         {sha: nil, state: "unknown", checks: []}
@@ -501,13 +619,19 @@ module Aidp
           http.request(request)
         end
 
-        if response.code == "200"
+        check_runs = if response.code == "200"
           data = JSON.parse(response.body)
-          check_runs = data["check_runs"] || []
-          normalize_ci_status(check_runs, head_sha)
+          data["check_runs"] || []
         else
-          {sha: head_sha, state: "unknown", checks: []}
+          Aidp.log_warn("repository_client", "Failed to fetch check runs via API", sha: head_sha, code: response.code)
+          []
         end
+
+        # Also fetch commit statuses (for OAuth apps, webhooks, etc.)
+        commit_statuses = fetch_commit_statuses_via_api(head_sha)
+
+        # Combine and normalize both check runs and commit statuses
+        normalize_ci_status_combined(check_runs, commit_statuses, head_sha)
       rescue => e
         Aidp.log_warn("repository_client", "Failed to fetch CI status", error: e.message)
         {sha: nil, state: "unknown", checks: []}
@@ -660,6 +784,85 @@ module Aidp
         }
       end
 
+      def fetch_commit_statuses_via_gh(head_sha)
+        cmd = ["gh", "api", "repos/#{full_repo}/commits/#{head_sha}/status", "--jq", "."]
+        stdout, _stderr, status = Open3.capture3(*cmd)
+
+        if status.success?
+          data = JSON.parse(stdout)
+          data["statuses"] || []
+        else
+          Aidp.log_debug("repository_client", "No commit statuses found", sha: head_sha)
+          []
+        end
+      rescue => e
+        Aidp.log_warn("repository_client", "Failed to fetch commit statuses", error: e.message, sha: head_sha)
+        []
+      end
+
+      def fetch_commit_statuses_via_api(head_sha)
+        uri = URI("https://api.github.com/repos/#{full_repo}/commits/#{head_sha}/status")
+        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)
+          data["statuses"] || []
+        else
+          Aidp.log_debug("repository_client", "No commit statuses found via API", sha: head_sha, code: response.code)
+          []
+        end
+      rescue => e
+        Aidp.log_warn("repository_client", "Failed to fetch commit statuses via API", error: e.message, sha: head_sha)
+        []
+      end
+
+      def normalize_ci_status_combined(check_runs, commit_statuses, head_sha)
+        # Convert commit statuses to same format as check runs for unified processing
+        # normalize_ci_status expects string keys, so we use string keys here
+        checks_from_statuses = commit_statuses.map do |status|
+          {
+            "name" => status["context"],
+            "status" => (status["state"] == "pending") ? "in_progress" : "completed",
+            "conclusion" => normalize_commit_status_to_conclusion(status["state"]),
+            "details_url" => status["target_url"],
+            "output" => status["description"] ? {"summary" => status["description"]} : nil
+          }
+        end
+
+        # Combine check runs and converted commit statuses
+        # check_runs should already have string keys from API/CLI responses
+        all_checks = check_runs + checks_from_statuses
+
+        Aidp.log_debug("repository_client", "combined_ci_checks",
+          check_run_count: check_runs.length,
+          commit_status_count: commit_statuses.length,
+          total_checks: all_checks.length)
+
+        # Use existing normalize logic
+        normalize_ci_status(all_checks, head_sha)
+      end
+
+      def normalize_commit_status_to_conclusion(state)
+        # Map commit status states to check run conclusions
+        # Commit status states: error, failure, pending, success
+        # Check run conclusions: success, failure, neutral, cancelled, timed_out, action_required, skipped, stale
+        case state
+        when "success"
+          "success"
+        when "failure"
+          "failure"
+        when "error"
+          "failure" # Treat error as failure for consistency
+        when "pending", nil
+          nil # pending means not completed yet
+        end
+      end
+
       def normalize_ci_status(check_runs, head_sha)
         checks = check_runs.map do |run|
           {
@@ -671,17 +874,42 @@ module Aidp
           }
         end
 
+        Aidp.log_debug("repository_client", "normalize_ci_status",
+          check_count: checks.length,
+          checks: checks.map { |c| {name: c[:name], status: c[:status], conclusion: c[:conclusion]} })
+
         # Determine overall state
-        state = if checks.any? { |c| c[:conclusion] == "failure" }
+        # CRITICAL: Empty check list should be "unknown", not "success"
+        # This guard must come FIRST to prevent vacuous truth from [].all? { condition }
+        state = if checks.empty?
+          Aidp.log_debug("repository_client", "ci_status_empty", message: "No checks found")
+          "unknown"
+        elsif checks.any? { |c| c[:conclusion] == "failure" }
+          failing_checks = checks.select { |c| c[:conclusion] == "failure" }
+          Aidp.log_debug("repository_client", "ci_status_failure",
+            failing_count: failing_checks.length,
+            failing_checks: failing_checks.map { |c| c[:name] })
           "failure"
         elsif checks.any? { |c| c[:status] != "completed" }
+          pending_checks = checks.select { |c| c[:status] != "completed" }
+          Aidp.log_debug("repository_client", "ci_status_pending",
+            pending_count: pending_checks.length,
+            pending_checks: pending_checks.map { |c| {name: c[:name], status: c[:status]} })
           "pending"
         elsif checks.all? { |c| c[:conclusion] == "success" }
+          Aidp.log_debug("repository_client", "ci_status_success",
+            success_count: checks.length)
           "success"
         else
+          non_success_checks = checks.reject { |c| c[:conclusion] == "success" }
+          Aidp.log_debug("repository_client", "ci_status_unknown",
+            non_success_count: non_success_checks.length,
+            non_success_checks: non_success_checks.map { |c| {name: c[:name], conclusion: c[:conclusion]} })
           "unknown"
         end
 
+        Aidp.log_debug("repository_client", "ci_status_determined", sha: head_sha, state: state)
+
         {
           sha: head_sha,
           state: state,

data/lib/aidp/watch/review_processor.rb

@@ -5,6 +5,8 @@ require "json"
 require "time"
 
 require_relative "../message_display"
+require_relative "github_state_extractor"
+require_relative "implementation_verifier"
 require_relative "reviewers/senior_dev_reviewer"
 require_relative "reviewers/security_reviewer"
 require_relative "reviewers/performance_reviewer"
@@ -23,9 +25,10 @@ module Aidp
 
       attr_reader :review_label
 
-      def initialize(repository_client:, state_store:, provider_name: nil, project_dir: Dir.pwd, label_config: {}, verbose: false, reviewers: nil)
+      def initialize(repository_client:, state_store:, provider_name: nil, project_dir: Dir.pwd, label_config: {}, verbose: false, reviewers: nil, verifier: nil)
         @repository_client = repository_client
         @state_store = state_store
+        @state_extractor = GitHubStateExtractor.new(repository_client: repository_client)
         @provider_name = provider_name
         @project_dir = project_dir
         @verbose = verbose
@@ -33,6 +36,12 @@ module Aidp
         # Load label configuration
         @review_label = label_config[:review_trigger] || label_config["review_trigger"] || DEFAULT_REVIEW_LABEL
 
+        # Initialize verifier (allow dependency injection for testing)
+        @verifier = verifier || ImplementationVerifier.new(
+          repository_client: repository_client,
+          project_dir: project_dir
+        )
+
         # Initialize reviewers (allow dependency injection for testing)
         @reviewers = reviewers || [
           Reviewers::SeniorDevReviewer.new(provider_name: provider_name),
@@ -44,7 +53,8 @@ module Aidp
       def process(pr)
         number = pr[:number]
 
-        if @state_store.review_processed?(number)
+        # Check if review already completed via GitHub comments
+        if @state_extractor.review_completed?(pr)
           display_message("ℹ️  Review for PR ##{number} already posted. Skipping.", type: :muted)
           return
         end
@@ -56,6 +66,9 @@ module Aidp
         files = @repository_client.fetch_pull_request_files(number)
         diff = @repository_client.fetch_pull_request_diff(number)
 
+        # Check if PR is linked to an issue - if so, run implementation verification
+        verification_result = check_implementation_completeness(pr_data)
+
         # Run reviews in parallel (conceptually - actual implementation is sequential)
         review_results = run_reviews(pr_data: pr_data, files: files, diff: diff)
 
@@ -63,7 +76,11 @@ module Aidp
         log_review(number, review_results)
 
         # Format and post comment
-        comment_body = format_review_comment(pr: pr_data, review_results: review_results)
+        comment_body = format_review_comment(
+          pr: pr_data,
+          review_results: review_results,
+          verification_result: verification_result
+        )
         @repository_client.post_comment(number, comment_body)
 
         display_message("💬 Posted review comment for PR ##{number}", type: :success)
@@ -84,19 +101,14 @@ module Aidp
         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
+        # Record failure state internally but DON'T post error to GitHub
+        # (per issue #280 - error messages should never appear on issues)
+        @state_store.record_review(number, {
+          status: "error",
+          error: e.message,
+          error_class: e.class.name,
+          timestamp: Time.now.utc.iso8601
+        })
       end
 
       private
@@ -123,13 +135,82 @@ module Aidp
         results
       end
 
-      def format_review_comment(pr:, review_results:)
+      def check_implementation_completeness(pr_data)
+        # Extract linked issue from PR description
+        issue_number = @state_extractor.extract_linked_issue(pr_data[:body])
+
+        unless issue_number
+          display_message("  ℹ️  No linked issue found - skipping implementation verification", type: :muted) if @verbose
+          return nil
+        end
+
+        display_message("  🔗 Found linked issue ##{issue_number} - verifying implementation...", type: :info) if @verbose
+
+        begin
+          # Fetch the linked issue
+          issue = @repository_client.fetch_issue(issue_number)
+
+          # Check if a worktree exists for this PR branch
+          working_dir = find_or_use_worktree(pr_data[:head_ref])
+
+          # Run verification
+          result = @verifier.verify(issue: issue, working_dir: working_dir)
+
+          if result[:verified]
+            display_message("  ✅ Implementation verified complete", type: :success) if @verbose
+          else
+            display_message("  ⚠️  Implementation appears incomplete", type: :warn)
+          end
+
+          result
+        rescue => e
+          display_message("  ⚠️  Verification check failed: #{e.message}", type: :warn)
+          Aidp.log_error("review_processor", "Verification failed", issue: issue_number, error: e.message)
+          nil
+        end
+      end
+
+      def find_or_use_worktree(branch)
+        # Check if a worktree already exists for this branch
+        existing = Aidp::Worktree.find_by_branch(branch: branch, project_dir: @project_dir)
+
+        if existing && existing[:active]
+          display_message("  🔄 Using existing worktree for branch: #{branch}", type: :muted) if @verbose
+          return existing[:path]
+        end
+
+        # Otherwise, use the main project directory
+        # (assuming the branch is checked out in the main directory)
+        @project_dir
+      end
+
+      def format_review_comment(pr:, review_results:, verification_result: nil)
         parts = []
         parts << COMMENT_HEADER
         parts << ""
         parts << "Automated multi-persona code review for PR ##{pr[:number]}"
         parts << ""
 
+        # Add verification results if present
+        if verification_result
+          if verification_result[:verified]
+            parts << "### ✅ Implementation Verification"
+            parts << ""
+            parts << "_Implementation successfully verified against linked issue requirements._"
+          else
+            parts << "### ⚠️ Implementation Incomplete"
+            parts << ""
+            parts << "**This PR appears to be incomplete based on the linked issue requirements:**"
+            parts << ""
+            verification_result[:reasons]&.each do |reason|
+              parts << "- #{reason}"
+            end
+            parts << ""
+            parts << "**Suggested Action:** Add the `aidp-request-changes` label if you'd like AIDP to help complete the implementation."
+          end
+          parts << ""
+        end
+
         # Collect all findings by severity
         all_findings = collect_findings_by_severity(review_results)
 

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

@@ -43,7 +43,7 @@ module Aidp
         def provider
           @provider ||= begin
             provider_name = @provider_name || detect_default_provider
-            Aidp::ProviderManager.get_provider(provider_name, use_harness: false)
+            Aidp::ProviderManager.get_provider(provider_name)
           end
         end