ace-git 0.23.0 → 0.24.0

data/lib/ace/git/molecules/github_issue_sync.rb

@@ -1,248 +0,0 @@
-# frozen_string_literal: true
-
-require "json"
-require "open3"
-
-module Ace
-  module Git
-    module Molecules
-      # Synchronize ACE task linkage metadata to GitHub issues.
-      class GithubIssueSync
-        class OwnershipConflict < StandardError; end
-
-        STICKY_MARKER = "<!-- ace-task:tracked -->"
-        TRACKED_LABEL = "ace:tracked"
-        TERMINAL_STATUSES = %w[done completed shipped closed cancelled skipped archived].freeze
-
-        def self.sync_task(task_id:, task_title:, task_status:, task_path:, issue_ids:, reason:, previous: nil,
-          current_issue_ids: nil)
-          current_ids = if current_issue_ids.nil?
-            Array(issue_ids).map(&:to_i).uniq
-          else
-            Array(current_issue_ids).map(&:to_i).uniq
-          end
-
-          issue_ids.each do |issue_id|
-            sync_issue(
-              issue_id: issue_id.to_i,
-              task_id: task_id,
-              task_title: task_title,
-              task_status: task_status,
-              task_path: task_path,
-              reason: reason,
-              previous: previous,
-              currently_linked: current_ids.include?(issue_id.to_i)
-            )
-          end
-
-          {success: true, synced: issue_ids.length, issues: issue_ids}
-        end
-
-        def self.sync_issue(issue_id:, task_id:, task_title:, task_status:, task_path:, reason:, previous:,
-          currently_linked:)
-          issue = fetch_issue(issue_id)
-          sticky = find_sticky_comment(issue["comments"] || [])
-
-          lines = tracked_lines(sticky&.dig("body"))
-          validate_link!(issue_id: issue_id, task_id: task_id, previous_task_id: previous&.[](:id), lines: lines) if currently_linked
-          lines = remove_previous_line(lines, previous)
-          lines = upsert_line(lines, task_id: task_id, task_title: task_title, task_path: task_path) if currently_linked
-          if lines.empty?
-            cleanup_tracking_artifacts(issue_id: issue_id, sticky: sticky, labels: issue["labels"] || [])
-            return {success: true, issue: issue_id, reason: reason}
-          end
-
-          body = render_body(lines)
-
-          if sticky
-            update_comment(issue_id: issue_id, comment: sticky, body: body)
-          else
-            create_comment(issue_id: issue_id, body: body)
-          end
-
-          ensure_label(issue_id, issue["labels"] || [])
-          if currently_linked
-            sync_lifecycle(
-              issue_id: issue_id,
-              issue_state: issue["state"],
-              task_status: task_status
-            )
-          end
-
-          {success: true, issue: issue_id, reason: reason}
-        end
-
-        def self.cleanup_tracking_artifacts(issue_id:, sticky:, labels:)
-          delete_comment(issue_id: issue_id, comment: sticky) if sticky
-          remove_label(issue_id, labels)
-        end
-
-        def self.fetch_issue(issue_id)
-          result = GhCliExecutor.execute("issue", ["view", issue_id.to_s, "--json", "state,comments,labels"])
-          raise "Failed to fetch issue #{issue_id}: #{result[:stderr]}" unless result[:success]
-
-          JSON.parse(result[:stdout])
-        rescue JSON::ParserError => e
-          raise "Failed to parse issue #{issue_id} response: #{e.message}"
-        end
-
-        def self.find_sticky_comment(comments)
-          comments.find { |comment| comment["body"].to_s.include?(STICKY_MARKER) }
-        end
-
-        def self.tracked_lines(body)
-          body.to_s.lines.map(&:rstrip).select { |line| line.start_with?("Tracked in ace-task: ") }
-        end
-
-        def self.remove_previous_line(lines, previous)
-          return lines unless previous.is_a?(Hash)
-
-          previous_id = previous[:id] || previous["id"]
-          return lines unless previous_id
-
-          lines.reject { |line| extract_task_id(line) == previous_id.to_s }
-        end
-
-        def self.upsert_line(lines, task_id:, task_title:, task_path:)
-          filtered = lines.reject { |line| extract_task_id(line) == task_id.to_s }
-          filtered << tracked_line(task_id: task_id, task_title: task_title, task_path: task_path)
-          filtered.uniq.sort
-        end
-
-        def self.tracked_line(task_id:, task_title:, task_path:)
-          "Tracked in ace-task: [#{task_id}](#{task_url(task_path)})"
-        end
-
-        def self.extract_task_id(line)
-          match = line.match(/\[([^\]]+)\]\(/)
-          match ? match[1] : nil
-        end
-
-        def self.render_body(lines)
-          ([STICKY_MARKER] + lines).join("\n")
-        end
-
-        def self.create_comment(issue_id:, body:)
-          GhCliExecutor.execute("issue", ["comment", issue_id.to_s, "--body", body]).tap do |result|
-            raise "Failed to create sticky comment for issue #{issue_id}: #{result[:stderr]}" unless result[:success]
-          end
-        end
-
-        def self.update_comment(issue_id:, comment:, body:)
-          comment_id = comment_api_id(comment)
-          GhCliExecutor.execute("api", [
-            "repos/{owner}/{repo}/issues/comments/#{comment_id}",
-            "--method", "PATCH",
-            "--field", "body=#{body}"
-          ]).tap do |result|
-            raise "Failed to update sticky comment for issue #{issue_id}: #{result[:stderr]}" unless result[:success]
-          end
-        end
-
-        def self.delete_comment(issue_id:, comment:)
-          comment_id = comment_api_id(comment)
-          GhCliExecutor.execute("api", [
-            "repos/{owner}/{repo}/issues/comments/#{comment_id}",
-            "--method", "DELETE"
-          ]).tap do |result|
-            raise "Failed to delete sticky comment for issue #{issue_id}: #{result[:stderr]}" unless result[:success]
-          end
-        end
-
-        def self.comment_api_id(comment)
-          database_id = comment["databaseId"] || comment[:databaseId]
-          return database_id.to_s if database_id.to_s.match?(/\A\d+\z/)
-
-          url = comment["url"] || comment[:url]
-          return Regexp.last_match(1) if url.to_s.match(/issuecomment-(\d+)/)
-
-          (comment["id"] || comment[:id]).to_s
-        end
-
-        def self.ensure_label(issue_id, labels)
-          return if labels.any? { |label| label["name"] == TRACKED_LABEL }
-
-          result = GhCliExecutor.execute("issue", ["edit", issue_id.to_s, "--add-label", TRACKED_LABEL])
-          raise "Failed to add #{TRACKED_LABEL} label to issue #{issue_id}: #{result[:stderr]}" unless result[:success]
-        end
-
-        def self.remove_label(issue_id, labels)
-          return unless labels.any? { |label| label["name"] == TRACKED_LABEL }
-
-          result = GhCliExecutor.execute("issue", ["edit", issue_id.to_s, "--remove-label", TRACKED_LABEL])
-          raise "Failed to remove #{TRACKED_LABEL} label from issue #{issue_id}: #{result[:stderr]}" unless result[:success]
-        end
-
-        def self.validate_link!(issue_id:, task_id:, previous_task_id: nil, lines: nil)
-          issue = fetch_issue(issue_id)
-          sticky = find_sticky_comment(issue["comments"] || [])
-          lines ||= tracked_lines(sticky&.dig("body"))
-          owners = lines.map { |line| extract_task_id(line) }.compact.uniq
-          return true if owners.empty?
-          return true if owners == [task_id.to_s]
-          return true if previous_task_id && owners == [previous_task_id.to_s]
-
-          raise OwnershipConflict, "GitHub issue ##{issue_id} is already owned by task #{owners.first}"
-        end
-
-        def self.sync_lifecycle(issue_id:, issue_state:, task_status:)
-          terminal = TERMINAL_STATUSES.include?(task_status.to_s.downcase)
-          issue_open = issue_state.to_s.upcase == "OPEN"
-
-          if terminal && issue_open
-            close_result = GhCliExecutor.execute("issue", ["close", issue_id.to_s])
-            raise "Failed to close issue #{issue_id}: #{close_result[:stderr]}" unless close_result[:success]
-          elsif !terminal && !issue_open
-            reopen_result = GhCliExecutor.execute("issue", ["reopen", issue_id.to_s])
-            raise "Failed to reopen issue #{issue_id}: #{reopen_result[:stderr]}" unless reopen_result[:success]
-          end
-        end
-
-        def self.task_url(task_path)
-          return task_path.to_s if task_path.to_s.empty?
-
-          repo_root = repo_root_path
-          relative = if repo_root && task_path.start_with?(repo_root + "/")
-            task_path.delete_prefix(repo_root + "/")
-          else
-            task_path.to_s
-          end
-
-          repo_slug = github_repo_slug
-          return relative unless repo_slug
-
-          "https://github.com/#{repo_slug}/blob/HEAD/#{relative}"
-        end
-
-        def self.repo_root_path
-          stdout, _stderr, status = Open3.capture3("git", "rev-parse", "--show-toplevel")
-          return nil unless status.success?
-
-          stdout.strip
-        rescue
-          nil
-        end
-
-        def self.github_repo_slug
-          stdout, _stderr, status = Open3.capture3("git", "remote", "get-url", "origin")
-          return nil unless status.success?
-
-          url = stdout.strip
-          return Regexp.last_match(1) if url.match(%r{github\.com[:/](.+?)(?:\.git)?$})
-
-          nil
-        rescue
-          nil
-        end
-
-        private_class_method :sync_issue, :fetch_issue, :find_sticky_comment, :tracked_lines, :remove_previous_line,
-          :upsert_line, :tracked_line, :extract_task_id, :render_body, :create_comment, :update_comment, :delete_comment,
-          :comment_api_id, :ensure_label, :remove_label, :cleanup_tracking_artifacts, :sync_lifecycle, :task_url, :repo_root_path,
-          :github_repo_slug
-      end
-
-      # Backward-compatible alias for early integration experiments.
-      IssueSync = GithubIssueSync
-    end
-  end
-end

data/lib/ace/git/molecules/pr_metadata_fetcher.rb

@@ -1,288 +0,0 @@
-# frozen_string_literal: true
-
-require "json"
-
-module Ace
-  module Git
-    module Molecules
-      # Fetch PR metadata via gh CLI
-      # Consolidated from ace-bundle GhPrExecutor and ace-review GhPrFetcher
-      class PrMetadataFetcher
-        # Error message patterns from gh CLI
-        PR_NOT_FOUND_PATTERN = /not found|Could not resolve/i
-        AUTH_ERROR_PATTERN = /authentication|Unauthorized|not logged in|auth login/i
-
-        # Valid characters for PR identifiers (owner/repo#number format)
-        # Allows: alphanumeric, hyphens, underscores, dots, forward slashes, hash, at, colon
-        # This prevents shell metacharacters from reaching command execution
-        VALID_IDENTIFIER_PATTERN = /\A[\w\/.\-#@:]+\z/
-
-        # Fields to fetch for PR metadata
-        # Extracted as constant for maintainability
-        PR_FIELDS = %w[
-          number
-          state
-          isDraft
-          title
-          author
-          headRefName
-          baseRefName
-          url
-          isCrossRepository
-          headRepositoryOwner
-          headRefOid
-          mergeCommit
-        ].freeze
-
-        class << self
-          # Check if gh CLI is installed
-          # @return [Boolean] True if gh is installed
-          def gh_installed?
-            result = Atoms::CommandExecutor.execute("gh", "--version")
-            result[:success]
-          end
-
-          # Check if gh CLI is authenticated
-          # @return [Boolean] True if authenticated
-          def gh_authenticated?
-            result = Atoms::CommandExecutor.execute("gh", "auth", "status")
-            result[:success]
-          end
-
-          # Fetch PR diff content
-          # @param identifier [String] PR identifier (number, URL, or owner/repo#number)
-          # @param timeout [Integer] Timeout in seconds (default from config)
-          # @return [Hash] Result with :success, :diff, :error
-          def fetch_diff(identifier, timeout: Ace::Git.network_timeout)
-            parsed = Atoms::PrIdentifierParser.parse(identifier)
-            raise ArgumentError, "Invalid PR identifier: #{identifier}" if parsed.nil?
-
-            # Validate identifier characters before command execution (defense in depth)
-            validate_identifier_characters(parsed.gh_format)
-
-            result = execute_gh_command(["gh", "pr", "diff", parsed.gh_format], timeout: timeout)
-
-            if result[:success]
-              {
-                success: true,
-                diff: result[:output],
-                identifier: parsed.gh_format,
-                source: build_source_label(parsed)
-              }
-            else
-              handle_error(result[:error], parsed.gh_format)
-            end
-          rescue Errno::ENOENT
-            raise Ace::Git::GhNotInstalledError, "GitHub CLI (gh) not installed. Install with: brew install gh"
-          end
-
-          # Fetch PR metadata (state, draft status, title, etc.)
-          # @param identifier [String] PR identifier
-          # @param timeout [Integer] Timeout in seconds (default from config)
-          # @return [Hash] Result with :success, :metadata, :error
-          def fetch_metadata(identifier, timeout: Ace::Git.network_timeout)
-            parsed = Atoms::PrIdentifierParser.parse(identifier)
-            raise ArgumentError, "Invalid PR identifier: #{identifier}" if parsed.nil?
-
-            # Validate identifier characters before command execution (defense in depth)
-            validate_identifier_characters(parsed.gh_format)
-
-            result = execute_gh_command(
-              ["gh", "pr", "view", parsed.gh_format, "--json", PR_FIELDS.join(",")],
-              timeout: timeout
-            )
-
-            if result[:success]
-              metadata = JSON.parse(result[:output])
-              {
-                success: true,
-                metadata: metadata,
-                identifier: parsed.gh_format,
-                parsed: {number: parsed.number, repo: parsed.repo}
-              }
-            else
-              handle_error(result[:error], parsed.gh_format)
-            end
-          rescue JSON::ParserError => e
-            {
-              success: false,
-              error: "Failed to parse PR metadata: #{e.message}"
-            }
-          rescue Errno::ENOENT
-            raise Ace::Git::GhNotInstalledError, "GitHub CLI (gh) not installed. Install with: brew install gh"
-          end
-
-          # Fetch both diff and metadata
-          # @param identifier [String] PR identifier
-          # @param timeout [Integer] Timeout in seconds (default from config)
-          # @return [Hash] Result with :success, :diff, :metadata, :error
-          def fetch_pr(identifier, timeout: Ace::Git.network_timeout)
-            diff_result = fetch_diff(identifier, timeout: timeout)
-            return diff_result unless diff_result[:success]
-
-            metadata_result = fetch_metadata(identifier, timeout: timeout)
-            return metadata_result unless metadata_result[:success]
-
-            {
-              success: true,
-              diff: diff_result[:diff],
-              metadata: metadata_result[:metadata],
-              identifier: diff_result[:identifier],
-              source: diff_result[:source]
-            }
-          end
-
-          # Find PR number for current branch
-          # @param timeout [Integer] Timeout in seconds (default from config)
-          # @return [String|nil] PR number or nil
-          def find_pr_for_branch(timeout: Ace::Git.network_timeout)
-            result = execute_gh_command(
-              ["gh", "pr", "view", "--json", "number"],
-              timeout: timeout
-            )
-
-            return nil unless result[:success]
-
-            data = JSON.parse(result[:output])
-            data["number"]&.to_s
-          rescue JSON::ParserError, Errno::ENOENT
-            nil
-          end
-
-          # Fetch recently merged PRs
-          # @param limit [Integer] Maximum number of PRs to return (default from config)
-          # @param timeout [Integer] Timeout in seconds
-          # @return [Hash] Result with :success, :prs array, or :error
-          def fetch_recently_merged(limit: Ace::Git.merged_prs_limit, timeout: Ace::Git.network_timeout)
-            result = execute_gh_command(
-              ["gh", "pr", "list", "--state", "merged", "--limit", limit.to_s,
-                "--json", "number,title,mergedAt,author"],
-              timeout: timeout
-            )
-
-            if result[:success]
-              prs = JSON.parse(result[:output])
-              {success: true, prs: prs}
-            else
-              {success: false, error: result[:error], prs: []}
-            end
-          rescue JSON::ParserError => e
-            {success: false, error: "Failed to parse merged PRs: #{e.message}", prs: []}
-          rescue Errno::ENOENT
-            {success: false, error: "GitHub CLI (gh) not installed", prs: []}
-          end
-
-          # Fetch open PRs
-          # @param exclude_branch [String, nil] Branch name to exclude from results
-          # @param limit [Integer] Maximum number of PRs to return (default from config)
-          # @param timeout [Integer] Timeout in seconds
-          # @return [Hash] Result with :success, :prs array, or :error
-          def fetch_open_prs(exclude_branch: nil, limit: Ace::Git.open_prs_limit, timeout: Ace::Git.network_timeout)
-            result = execute_gh_command(
-              ["gh", "pr", "list", "--state", "open", "--limit", limit.to_s,
-                "--json", "number,title,author,headRefName"],
-              timeout: timeout
-            )
-
-            if result[:success]
-              prs = JSON.parse(result[:output])
-              # Filter out current branch if specified
-              if exclude_branch
-                prs = prs.reject { |pr| pr["headRefName"] == exclude_branch }
-              end
-              {success: true, prs: prs}
-            else
-              {success: false, error: result[:error], prs: []}
-            end
-          rescue JSON::ParserError => e
-            {success: false, error: "Failed to parse open PRs: #{e.message}", prs: []}
-          rescue Errno::ENOENT
-            {success: false, error: "GitHub CLI (gh) not installed", prs: []}
-          end
-
-          # Fetch all recent PRs in a single call for optimal performance
-          # Returns open, merged, and closed PRs - caller filters by state locally
-          # @param limit [Integer] Maximum PRs to fetch (default: 15, enough for typical use)
-          # @param timeout [Integer] Timeout in seconds
-          # @return [Hash] Result with :success, :prs array, or :error
-          def fetch_all_prs(limit: 15, timeout: Ace::Git.network_timeout)
-            result = execute_gh_command(
-              ["gh", "pr", "list", "--state", "all", "--limit", limit.to_s,
-                "--json", "number,title,state,mergedAt,author,headRefName,isDraft,baseRefName,url,headRefOid,mergeCommit"],
-              timeout: timeout
-            )
-
-            if result[:success]
-              prs = JSON.parse(result[:output])
-              {success: true, prs: prs}
-            else
-              {success: false, error: result[:error], prs: []}
-            end
-          rescue JSON::ParserError => e
-            {success: false, error: "Failed to parse PR list: #{e.message}", prs: []}
-          rescue Errno::ENOENT
-            {success: false, error: "GitHub CLI (gh) not installed", prs: []}
-          end
-
-          private
-
-          # Environment variables for consistent gh CLI output across all locales
-          GH_ENV = {"LC_ALL" => "C"}.freeze
-
-          # Execute gh command with timeout via CommandExecutor
-          # @param args [Array<String>] Command arguments
-          # @param timeout [Integer] Timeout in seconds
-          # @return [Hash] Result with :success, :output, :error, :exit_code
-          def execute_gh_command(args, timeout:)
-            # Delegate to CommandExecutor with LC_ALL=C for consistent output format
-            # regardless of user's locale settings
-            result = Atoms::CommandExecutor.execute(*args, timeout: timeout, env: GH_ENV)
-
-            # Check for timeout (CommandExecutor returns exit_code: -1 with timeout message)
-            if result[:exit_code] == -1 && result[:error]&.include?("timed out")
-              raise Ace::Git::TimeoutError, "gh command timed out after #{timeout}s: #{args.join(" ")}"
-            end
-
-            result
-          end
-
-          def build_source_label(parsed)
-            if parsed.repo
-              "pr:#{parsed.repo}##{parsed.number}"
-            else
-              "pr:#{parsed.number}"
-            end
-          end
-
-          # Validate identifier characters to prevent shell metacharacter injection
-          # Defense in depth - Open3.capture3 with array args is already safe,
-          # but this adds explicit validation as a secondary security layer
-          # @param identifier [String] Identifier to validate
-          # @raise [ArgumentError] If identifier contains invalid characters
-          def validate_identifier_characters(identifier)
-            return if identifier.nil? || identifier.empty?
-
-            unless identifier.match?(VALID_IDENTIFIER_PATTERN)
-              raise ArgumentError, "Invalid identifier characters: #{identifier}"
-            end
-          end
-
-          def handle_error(error_message, identifier)
-            error_str = error_message.to_s
-
-            if error_str.match?(PR_NOT_FOUND_PATTERN)
-              raise Ace::Git::PrNotFoundError, "PR not found: #{identifier}"
-            elsif error_str.match?(AUTH_ERROR_PATTERN)
-              raise Ace::Git::GhAuthenticationError, "Not authenticated with GitHub. Run: gh auth login"
-            else
-              {
-                success: false,
-                error: "gh pr command failed: #{error_str}"
-              }
-            end
-          end
-        end
-      end
-    end
-  end
-end