ace-git 0.18.0

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Ace
+  module Git
+    module Molecules
+      # Fetches git status information via system command
+      # Uses git status -sb for compact, familiar output
+      #
+      # Note: Moved from Atoms to Molecules per ATOM architecture -
+      # executing system commands is I/O, which belongs in Molecules layer.
+      module GitStatusFetcher
+        class << self
+          # Fetch git status in short branch format
+          # @param executor [CommandExecutor] Command executor (default: CommandExecutor)
+          # @return [Hash] Result with :success, :output, :error
+          def fetch_status_sb(executor: Atoms::CommandExecutor)
+            # Disable color to ensure clean output for LLM context
+            result = executor.execute("git", "-c", "color.status=false", "status", "-sb")
+
+            if result[:success]
+              {success: true, output: result[:output].strip}
+            else
+              {success: false, output: "", error: result[:error]}
+            end
+          rescue => e
+            {success: false, output: "", error: e.message}
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,286 @@
+# 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
+        ].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"],
+              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

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Ace
+  module Git
+    module Molecules
+      # Fetches recent commits from the repository
+      # Returns commit hashes and subjects in oneline format
+      module RecentCommitsFetcher
+        class << self
+          # Fetch recent commits
+          # @param limit [Integer] Number of commits to fetch (default: 3)
+          # @param executor [CommandExecutor] Command executor
+          # @return [Hash] Result with :success, :commits array, :error
+          def fetch(limit: 3, executor: Atoms::CommandExecutor)
+            return {success: true, commits: []} if limit <= 0
+
+            result = executor.execute(
+              "git", "log",
+              "-#{limit}",
+              "--format=%h %s"
+            )
+
+            if result[:success]
+              commits = parse_commits(result[:output])
+              {success: true, commits: commits}
+            else
+              {success: false, commits: [], error: result[:error]}
+            end
+          rescue => e
+            {success: false, commits: [], error: e.message}
+          end
+
+          private
+
+          # Parse git log output into structured array
+          # @param output [String] Git log output
+          # @return [Array<Hash>] Array of commit hashes with :hash and :subject
+          def parse_commits(output)
+            return [] if output.nil? || output.empty?
+
+            output.strip.split("\n").map do |line|
+              hash, *subject_parts = line.split(" ")
+              {
+                hash: hash,
+                subject: subject_parts.join(" ")
+              }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ace/git/organisms/diff_orchestrator.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+module Ace
+  module Git
+    module Organisms
+      # Orchestrates the complete diff workflow (NO caching per task decisions)
+      # Migrated from ace-git-diff
+      class DiffOrchestrator
+        class << self
+          # Generate diff with full workflow: config -> generate -> filter -> result
+          # @param options [Hash] Options for diff generation
+          # @option options [String] :since Date or commit to diff from
+          # @option options [Array<String>] :ranges Git ranges to diff
+          # @option options [Array<String>] :paths Path patterns to include
+          # @option options [Array<String>] :exclude_patterns Patterns to exclude
+          # @option options [Boolean] :exclude_whitespace Exclude whitespace changes
+          # @option options [Boolean] :exclude_renames Exclude renames
+          # @option options [Symbol] :format Output format (:diff or :summary)
+          # @return [Models::DiffResult] Complete diff result
+          def generate(options = {})
+            # Load configuration
+            config = Molecules::ConfigLoader.load(options)
+
+            # Short-circuit for grouped_stats — only numstat needed, skip full diff
+            if config.format == :grouped_stats
+              return build_grouped_stats_result(config, nil, filtered: !config.exclude_patterns.empty?)
+            end
+
+            # Generate raw diff
+            raw_diff = Molecules::DiffGenerator.generate(config)
+
+            # Filter diff
+            filtered_diff = Molecules::DiffFilter.filter(raw_diff, config)
+
+            # Parse and create result
+            parsed = Atoms::DiffParser.parse(filtered_diff)
+
+            Models::DiffResult.from_parsed(
+              parsed,
+              metadata: {
+                config: config.to_h,
+                generated_at: Time.now.iso8601,
+                filtered: !config.exclude_patterns.empty?
+              },
+              filtered: !config.exclude_patterns.empty?
+            )
+          end
+
+          # Generate diff from configuration hash
+          # @param config_hash [Hash] Configuration from YAML or other source
+          # @return [Models::DiffResult] Complete diff result
+          def from_config(config_hash)
+            diff_config = Molecules::ConfigLoader.extract_diff_config(config_hash)
+            generate(diff_config)
+          end
+
+          # Generate diff for a specific range
+          # @param range [String] Git range (e.g., "HEAD~5..HEAD")
+          # @param options [Hash] Additional options
+          # @return [Models::DiffResult] Complete diff result
+          def for_range(range, options = {})
+            generate(options.merge(ranges: [range]))
+          end
+
+          # Generate diff since a date or commit
+          # @param since [String] Date or commit reference
+          # @param options [Hash] Additional options
+          # @return [Models::DiffResult] Complete diff result
+          def since(since, options = {})
+            generate(options.merge(since: since))
+          end
+
+          # Generate staged diff
+          # @param options [Hash] Additional options
+          # @return [Models::DiffResult] Complete diff result
+          def staged(options = {})
+            generate(options.merge(format: :staged))
+          end
+
+          # Generate working directory diff
+          # @param options [Hash] Additional options
+          # @return [Models::DiffResult] Complete diff result
+          def working(options = {})
+            generate(options.merge(format: :working))
+          end
+
+          # Generate diff with smart defaults (based on git state)
+          # @param options [Hash] Additional options
+          # @return [Models::DiffResult] Complete diff result
+          def smart(options = {})
+            # Use empty config to trigger smart default behavior in DiffGenerator
+            generate(options)
+          end
+
+          # Generate raw (unfiltered) diff
+          # @param options [Hash] Options for diff generation
+          # @return [Models::DiffResult] Unfiltered diff result
+          def raw(options = {})
+            # Temporarily override exclude patterns to be empty
+            options_with_no_filtering = options.merge(exclude_patterns: [])
+            generate(options_with_no_filtering)
+          end
+
+          # Generate diff and save to file
+          # @param output_path [String] Path to save the diff
+          # @param options [Hash] Options for diff generation
+          # @return [String] Path to the saved file
+          def save_to_file(output_path, options = {})
+            result = generate(options)
+
+            # Create parent directories if needed
+            require "fileutils"
+            FileUtils.mkdir_p(File.dirname(output_path)) unless File.dirname(output_path) == "."
+
+            # Write content to file
+            File.write(output_path, result.content)
+
+            output_path
+          end
+
+          # Generate diff and save to file (with explicit format)
+          # @param output_path [String] Path to save the diff
+          # @param format [Symbol] Format (:diff or :summary)
+          # @param options [Hash] Options for diff generation
+          # @return [String] Path to the saved file
+          def save_with_format(output_path, format: :diff, **options)
+            options_with_format = options.merge(format: format)
+            save_to_file(output_path, options_with_format)
+          end
+
+          private
+
+          def build_grouped_stats_result(config, parsed_diff, filtered:)
+            numstat_output = Molecules::DiffGenerator.generate_numstat(config)
+            entries = Atoms::DiffNumstatParser.parse(numstat_output)
+            filtered_entries = filter_entries(entries, config.exclude_patterns)
+            grouped = Atoms::FileGrouper.group(
+              filtered_entries,
+              layers: config.grouped_stats_layers,
+              dotfile_groups: config.grouped_stats_dotfile_groups
+            )
+            content = Atoms::GroupedStatsFormatter.format(grouped, collapse_above: config.grouped_stats_collapse_above)
+            totals = grouped[:total]
+
+            Models::DiffResult.new(
+              content: content,
+              stats: {
+                additions: totals[:additions],
+                deletions: totals[:deletions],
+                files: totals[:files],
+                total_changes: totals[:additions] + totals[:deletions],
+                line_count: parsed_diff&.[](:line_count)
+              },
+              files: grouped[:files],
+              metadata: {
+                config: config.to_h,
+                generated_at: Time.now.iso8601,
+                filtered: filtered,
+                grouped_stats: grouped.merge(collapse_above: config.grouped_stats_collapse_above)
+              },
+              filtered: filtered
+            )
+          end
+
+          def filter_entries(entries, exclude_patterns)
+            return entries if exclude_patterns.nil? || exclude_patterns.empty?
+
+            patterns = Atoms::PatternFilter.glob_to_regex(exclude_patterns)
+            entries.reject do |entry|
+              Atoms::PatternFilter.should_exclude?(entry[:path], patterns) ||
+                (entry[:rename_from] && Atoms::PatternFilter.should_exclude?(entry[:rename_from], patterns))
+            end
+          end
+        end
+      end
+    end
+  end
+end