ace-review 0.49.0

data/lib/ace/review/molecules/gh_cli_executor.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require "open3"
+require "timeout"
+
+module Ace
+  module Review
+    module Molecules
+      # Safely execute gh CLI commands with error handling
+      class GhCliExecutor
+        # Default timeout for gh CLI operations
+        DEFAULT_GH_TIMEOUT = 30
+
+        # Execute a gh CLI command
+        #
+        # @param subcommand [String] The gh subcommand (e.g., "pr", "api")
+        # @param args [Array<String>] Arguments to pass to the subcommand
+        # @param options [Hash] Additional options
+        # @option options [Integer] :timeout Timeout in seconds (default: from config or 30)
+        # @return [Hash] Result with :success, :stdout, :stderr, :exit_code
+        def self.execute(subcommand, args = [], options = {})
+          check_installed
+
+          timeout_seconds = options[:timeout] ||
+            Ace::Review.get("defaults", "gh_timeout") ||
+            DEFAULT_GH_TIMEOUT
+          command = ["gh", subcommand] + args
+
+          run_command(command, timeout_seconds)
+        rescue Timeout::Error
+          raise Ace::Review::Errors::GhNetworkError, "gh command timed out after #{timeout_seconds} seconds"
+        end
+
+        # Check if gh CLI is installed
+        #
+        # @return [Boolean] true if installed
+        # @raise [GhCliNotInstalledError] if not installed
+        def self.check_installed
+          result = execute_simple("--version")
+          result[:success]
+        rescue Ace::Review::Errors::GhCliNotInstalledError
+          raise
+        end
+
+        # Check if user is authenticated with GitHub
+        #
+        # @return [Hash] Auth status with :authenticated, :username
+        # @raise [GhAuthenticationError] if not authenticated
+        def self.check_authenticated
+          result = execute_simple("auth", ["status"])
+
+          if result[:success]
+            # Extract username from stderr (gh auth status outputs to stderr)
+            username = extract_username(result[:stderr])
+            {
+              authenticated: true,
+              username: username
+            }
+          else
+            raise Ace::Review::Errors::GhAuthenticationError
+          end
+        end
+
+        # Default timeout for simple operations
+        DEFAULT_SIMPLE_TIMEOUT = 10
+
+        # Execute a simple gh command without error checking
+        # Used internally to avoid infinite recursion in check_installed
+        #
+        # @param command [String] The gh subcommand
+        # @param args [Array<String>] Arguments
+        # @param timeout_seconds [Integer] Timeout in seconds (default: from config or 10)
+        # @return [Hash] Result hash
+        def self.execute_simple(command, args = [], timeout_seconds = nil)
+          timeout_seconds ||= Ace::Review.get("defaults", "gh_simple_timeout") || DEFAULT_SIMPLE_TIMEOUT
+          cmd = ["gh", command] + args
+          run_command(cmd, timeout_seconds)
+        rescue Timeout::Error
+          {
+            success: false,
+            stdout: "",
+            stderr: "Command timed out",
+            exit_code: 1
+          }
+        end
+
+        # Extract username from gh auth status output
+        #
+        # @param output [String] Output from gh auth status
+        # @return [String, nil] Username if found
+        def self.extract_username(output)
+          # gh auth status output format: "✓ Logged in to github.com as username ..."
+          match = output.match(/Logged in to .+ as (\S+)/)
+          match ? match[1] : nil
+        end
+
+        # Execute a command with timeout and error handling
+        # Private helper to reduce duplication between execute and execute_simple
+        #
+        # @param command [Array<String>] Full command array including "gh"
+        # @param timeout_seconds [Integer] Timeout in seconds
+        # @return [Hash] Result with :success, :stdout, :stderr, :exit_code
+        # @raise [GhCliNotInstalledError] if gh is not installed
+        # @raise [Timeout::Error] if command times out (caller should handle)
+        def self.run_command(command, timeout_seconds)
+          stdout_str, stderr_str, status = Timeout.timeout(timeout_seconds) do
+            Open3.capture3(*command)
+          end
+
+          {
+            success: status.success?,
+            stdout: stdout_str,
+            stderr: stderr_str,
+            exit_code: status.exitstatus
+          }
+        rescue Errno::ENOENT
+          raise Ace::Review::Errors::GhCliNotInstalledError
+        end
+
+        private_class_method :execute_simple, :extract_username, :run_command
+      end
+    end
+  end
+end

data/lib/ace/review/molecules/gh_comment_poster.rb

@@ -0,0 +1,205 @@
+# frozen_string_literal: true
+
+require "tempfile"
+
+module Ace
+  module Review
+    module Molecules
+      # Post review comments to GitHub PR
+      class GhCommentPoster
+        # Post a review comment to a PR
+        #
+        # @param pr_identifier [String] PR identifier
+        # @param review_text [String] Review content
+        # @param options [Hash] Posting options
+        # @option options [Boolean] :dry_run Don't actually post (default: false)
+        # @option options [Hash] :metadata Review metadata (preset, model, timestamp)
+        # @return [Hash] Result with :success, :comment_url, :preview, :error
+        def self.post_comment(pr_identifier, review_text, options = {})
+          # Parse identifier using ace-git
+          parsed = Ace::Git::Atoms::PrIdentifierParser.parse(pr_identifier)
+          gh_format = parsed.gh_format
+
+          # Check PR state before posting
+          state_check = check_pr_state(gh_format)
+          return state_check unless state_check[:success]
+
+          # Format comment with metadata
+          formatted_comment = format_review_comment(review_text, options[:metadata] || {})
+
+          # Handle dry run
+          if options[:dry_run]
+            return {
+              success: true,
+              dry_run: true,
+              preview: formatted_comment,
+              pr_identifier: gh_format
+            }
+          end
+
+          # Post comment via gh CLI
+          result = post_via_gh(gh_format, formatted_comment)
+
+          if result[:success]
+            comment_url = extract_comment_url(result[:stdout], parsed.to_h)
+            {
+              success: true,
+              comment_url: comment_url,
+              pr_identifier: gh_format
+            }
+          else
+            {
+              success: false,
+              error: "Failed to post comment: #{result[:stderr]}"
+            }
+          end
+        rescue Ace::Review::Errors::GhCliNotInstalledError, Ace::Review::Errors::GhAuthenticationError
+          raise
+        rescue => e
+          {
+            success: false,
+            error: "Failed to post comment: #{e.message}"
+          }
+        end
+
+        # Check if PR is in a state that allows comments
+        #
+        # @param gh_format [String] PR identifier in gh format
+        # @return [Hash] Result with :success or :error
+        def self.check_pr_state(gh_format)
+          # Fetch PR metadata
+          result = Ace::Review::Molecules::GhCliExecutor.execute(
+            "pr",
+            ["view", gh_format, "--json", "state,number"]
+          )
+
+          unless result[:success]
+            return {
+              success: false,
+              error: "Failed to check PR state: #{result[:stderr]}"
+            }
+          end
+
+          metadata = JSON.parse(result[:stdout])
+          state = metadata["state"]
+          number = metadata["number"]
+
+          # Check if state allows posting
+          unless state == "OPEN"
+            raise Ace::Review::Errors::PrStateError.new(number, state.downcase)
+          end
+
+          {success: true}
+        rescue JSON::ParserError => e
+          {
+            success: false,
+            error: "Failed to parse PR state: #{e.message}"
+          }
+        end
+
+        # Format review comment with metadata header
+        #
+        # @param review_text [String] Raw review content
+        # @param metadata [Hash] Review metadata
+        # @option metadata [String] :preset Review preset name
+        # @option metadata [String] :model LLM model used
+        # @option metadata [String] :timestamp Generation timestamp
+        # @return [String] Formatted comment
+        def self.format_review_comment(review_text, metadata = {})
+          header = "## Code Review - ace-review\n\n"
+
+          if metadata[:preset]
+            header += "**Preset**: #{metadata[:preset]}\n"
+          end
+
+          if metadata[:model]
+            header += "**Model**: #{metadata[:model]}\n"
+          end
+
+          if metadata[:timestamp]
+            header += "**Generated**: #{metadata[:timestamp]}\n"
+          end
+
+          header += "\n" unless metadata.empty?
+
+          # Sanitize review text (escape any problematic characters)
+          sanitized_review = sanitize_markdown(review_text)
+
+          header + sanitized_review
+        end
+
+        # Sanitize markdown content to prevent formatting issues
+        #
+        # Ensures code fences are properly closed and wraps content in a
+        # collapsible details tag to contain any formatting issues.
+        #
+        # @param content [String] Content to sanitize
+        # @return [String] Sanitized and wrapped content
+        def self.sanitize_markdown(content)
+          sanitized = content.to_s
+
+          # Ensure code fences are closed
+          # Count occurrences of code fence markers (```)
+          fence_count = sanitized.scan(/^```/).count
+          if fence_count.odd?
+            # Unclosed code fence - close it
+            sanitized += "\n```\n"
+          end
+
+          # Wrap in collapsible details to contain any formatting issues
+          <<~MARKDOWN
+            <details>
+            <summary><b>📋 Full Review</b> (click to expand)</summary>
+
+            #{sanitized}
+
+            </details>
+          MARKDOWN
+        end
+
+        # Post comment via gh CLI using a temp file for the body
+        #
+        # @param gh_format [String] PR identifier in gh format
+        # @param comment_body [String] Comment content
+        # @return [Hash] Result from gh CLI
+        def self.post_via_gh(gh_format, comment_body)
+          # Write comment to temp file (gh pr comment reads from file)
+          Tempfile.create(["review-comment", ".md"]) do |file|
+            file.write(comment_body)
+            file.flush
+
+            # Post using gh pr comment
+            Ace::Review::Molecules::GhCliExecutor.execute(
+              "pr",
+              ["comment", gh_format, "--body-file", file.path]
+            )
+          end
+        end
+
+        # Extract comment URL from gh CLI output
+        #
+        # @param output [String] gh CLI stdout
+        # @param parsed [Hash] Parsed PR identifier with :repo (owner/repo format), :number
+        # @return [String] Comment URL
+        def self.extract_comment_url(output, parsed)
+          # gh pr comment returns the comment URL on success
+          # Format: https://github.com/owner/repo/pull/123#issuecomment-123456
+          url_match = output.match(%r{(https://[^\s]+)})
+
+          if url_match
+            url_match[1]
+          else
+            # Fallback: construct URL from parsed identifier
+            # ace-git's ParseResult provides :repo in "owner/repo" combined format
+            repo = parsed[:repo] || parsed[:gh_format].to_s.split("#").first
+            number = parsed[:number]
+            "https://github.com/#{repo}/pull/#{number}"
+          end
+        end
+
+        private_class_method :check_pr_state, :format_review_comment, :sanitize_markdown,
+          :post_via_gh, :extract_comment_url
+      end
+    end
+  end
+end

data/lib/ace/review/molecules/gh_comment_resolver.rb

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Ace
+  module Review
+    module Molecules
+      # Resolve PR comments by replying and/or resolving threads
+      # Used by the review-pr workflow to mark feedback as addressed
+      class GhCommentResolver
+        # Reply to a PR with a comment indicating a fix
+        #
+        # @param pr_identifier [String] PR identifier (number, URL, or owner/repo#number)
+        # @param commit_sha [String] Commit SHA that addresses the feedback
+        # @param message [String, nil] Optional custom message (default: "Fixed in {sha}")
+        # @param options [Hash] Options
+        # @option options [Integer] :timeout Timeout in seconds (default: 30)
+        # @return [Hash] Result with :success, :comment_url, :error
+        def self.reply(pr_identifier, commit_sha, message: nil, options: {})
+          # Guard: require either commit_sha or custom message
+          if (commit_sha.nil? || commit_sha.to_s.strip.empty?) && (message.nil? || message.strip.empty?)
+            return {success: false, error: "Commit SHA or message required"}
+          end
+
+          # Parse identifier using ace-git
+          parsed = Ace::Git::Atoms::PrIdentifierParser.parse(pr_identifier)
+          gh_format = parsed.gh_format
+
+          # Build message
+          short_sha = commit_sha.to_s[0..6]
+          body = message || "Fixed in #{short_sha}"
+
+          # Default timeout
+          timeout = options[:timeout] || 30
+
+          # Post comment using gh CLI
+          result = Ace::Review::Molecules::GhCliExecutor.execute(
+            "pr",
+            ["comment", gh_format, "--body", body],
+            timeout: timeout
+          )
+
+          if result[:success]
+            # Try to extract comment URL from output
+            comment_url = extract_comment_url(result[:stdout])
+            {
+              success: true,
+              comment_url: comment_url,
+              message: body
+            }
+          else
+            {
+              success: false,
+              error: "Failed to post reply: #{result[:stderr]}"
+            }
+          end
+        rescue Ace::Review::Errors::GhCliNotInstalledError, Ace::Review::Errors::GhAuthenticationError
+          raise
+        rescue => e
+          {
+            success: false,
+            error: "Failed to post reply: #{e.message}"
+          }
+        end
+
+        # Valid thread ID pattern (GitHub GraphQL node IDs)
+        # PRRT_ = Pull Request Review Thread
+        THREAD_ID_PATTERN = /\APRRT_[A-Za-z0-9_-]+\z/
+
+        # Resolve a review thread by thread ID using GitHub GraphQL API
+        #
+        # Note: This requires the thread's node ID (starts with "PRRT_")
+        # which can be obtained from the GhPrCommentFetcher results
+        #
+        # @param thread_id [String] GraphQL node ID of the review thread (e.g., "PRRT_abc123")
+        # @param options [Hash] Options
+        # @option options [Integer] :timeout Timeout in seconds (default: 30)
+        # @return [Hash] Result with :success, :resolved, :error
+        def self.resolve_thread(thread_id, options: {})
+          return {success: false, error: "Thread ID required"} if thread_id.nil? || thread_id.empty?
+
+          # Validate thread_id format to prevent GraphQL injection
+          unless thread_id.match?(THREAD_ID_PATTERN)
+            return {success: false, error: "Invalid thread ID format. Expected PRRT_xxx pattern."}
+          end
+
+          # Default timeout
+          timeout = options[:timeout] || 30
+
+          # Build and execute GraphQL mutation
+          mutation = build_resolve_thread_mutation(thread_id)
+
+          # Execute via gh api graphql
+          result = Ace::Review::Molecules::GhCliExecutor.execute(
+            "api",
+            ["graphql", "-f", "query=#{mutation}"],
+            timeout: timeout
+          )
+
+          if result[:success]
+            begin
+              response = JSON.parse(result[:stdout])
+              is_resolved = response.dig("data", "resolveReviewThread", "thread", "isResolved")
+
+              if is_resolved
+                {success: true, resolved: true}
+              elsif response["errors"]
+                {success: false, error: response["errors"].first["message"]}
+              else
+                {success: false, error: "Thread not resolved"}
+              end
+            rescue JSON::ParserError => e
+              {success: false, error: "Failed to parse response: #{e.message}"}
+            end
+          else
+            {
+              success: false,
+              error: "Failed to resolve thread: #{result[:stderr]}"
+            }
+          end
+        rescue Ace::Review::Errors::GhCliNotInstalledError, Ace::Review::Errors::GhAuthenticationError
+          raise
+        rescue => e
+          {
+            success: false,
+            error: "Failed to resolve thread: #{e.message}"
+          }
+        end
+
+        # Reply to PR and resolve thread in one operation
+        #
+        # @param pr_identifier [String] PR identifier
+        # @param thread_id [String, nil] Thread ID to resolve (optional)
+        # @param commit_sha [String] Commit SHA that addresses the feedback
+        # @param message [String, nil] Optional custom message
+        # @param options [Hash] Options
+        # @return [Hash] Result with :success, :reply_result, :resolve_result, :error
+        def self.reply_and_resolve(pr_identifier, commit_sha, thread_id: nil, message: nil, options: {})
+          results = {success: true}
+
+          # Step 1: Reply with commit reference
+          reply_result = reply(pr_identifier, commit_sha, message: message, options: options)
+          results[:reply_result] = reply_result
+
+          unless reply_result[:success]
+            results[:success] = false
+            results[:error] = reply_result[:error]
+            return results
+          end
+
+          # Step 2: Resolve thread if thread_id provided
+          if thread_id && !thread_id.empty?
+            resolve_result = resolve_thread(thread_id, options: options)
+            results[:resolve_result] = resolve_result
+
+            # Thread resolution failure is not fatal - reply succeeded
+            unless resolve_result[:success]
+              results[:partial] = true
+              results[:warning] = "Reply posted but thread not resolved: #{resolve_result[:error]}"
+            end
+          end
+
+          results
+        end
+
+        private
+
+        # Build GraphQL mutation for resolving a review thread
+        #
+        # @param thread_id [String] Thread ID (validated before calling)
+        # @return [String] GraphQL mutation query
+        def self.build_resolve_thread_mutation(thread_id)
+          <<~GRAPHQL
+            mutation {
+              resolveReviewThread(input: {threadId: "#{thread_id}"}) {
+                thread {
+                  isResolved
+                }
+              }
+            }
+          GRAPHQL
+        end
+
+        # Extract comment URL from gh CLI output
+        #
+        # @param output [String] gh CLI stdout
+        # @return [String, nil] Comment URL or nil
+        def self.extract_comment_url(output)
+          return nil if output.nil? || output.empty?
+
+          # gh pr comment outputs the URL of the created comment
+          output.strip if output.include?("github.com")
+        end
+
+        private_class_method :build_resolve_thread_mutation, :extract_comment_url
+      end
+    end
+  end
+end