ace-git 0.18.0

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

@@ -0,0 +1,264 @@
+# frozen_string_literal: true
+
+module Ace
+  module Git
+    module Organisms
+      # Orchestrates loading complete repository status
+      # Combines branch info, task pattern detection, and PR metadata
+      class RepoStatusLoader
+        class << self
+          # Load complete repository status
+          # @param options [Hash] Options for status loading
+          # @option options [Boolean] :include_pr Whether to fetch PR metadata (default: true)
+          # @option options [Boolean] :include_pr_activity Whether to fetch PR activity (default: true)
+          # @option options [Boolean] :include_commits Whether to fetch recent commits (default: true)
+          # @option options [Integer] :commits_limit Number of recent commits to fetch (default: 3)
+          # @option options [Integer] :timeout Timeout for network operations like PR fetch (default: network_timeout)
+          # @return [Models::RepoStatus] Complete repository status
+          def load(options = {})
+            include_pr = options.fetch(:include_pr, true)
+            include_pr_activity = options.fetch(:include_pr_activity, true)
+            include_commits = options.fetch(:include_commits, true)
+            commits_limit = options.fetch(:commits_limit, Ace::Git.commits_limit)
+            timeout = options.fetch(:timeout, Ace::Git.network_timeout)
+
+            # Get repository type and state
+            repo_type = Atoms::RepositoryChecker.repository_type
+            repo_state = Atoms::RepositoryStateDetector.detect
+
+            # Check if we can proceed
+            unless Atoms::RepositoryChecker.usable?
+              return Models::RepoStatus.new(
+                branch: nil,
+                repository_type: repo_type,
+                repository_state: repo_state
+              )
+            end
+
+            # Get branch information
+            branch_info = Molecules::BranchReader.full_info
+
+            # Extract task pattern from branch name
+            task_pattern = nil
+            if branch_info[:name] && branch_info[:name] != "HEAD"
+              task_pattern = Atoms::TaskPatternExtractor.extract(branch_info[:name])
+            end
+
+            # Fetch git status (always, it's fast and local)
+            git_status_sb = fetch_git_status
+
+            # Fetch recent commits if requested
+            recent_commits = nil
+            if include_commits && commits_limit > 0
+              recent_commits = fetch_recent_commits(limit: commits_limit)
+            end
+
+            # Fetch PR data (metadata and activity) - parallelized for performance
+            pr_metadata = nil
+            pr_activity = nil
+            if !branch_info[:detached]
+              if include_pr && include_pr_activity
+                # Both requested: use parallel fetch for ~50% speedup
+                pr_data = fetch_pr_data_parallel(
+                  current_branch: branch_info[:name],
+                  timeout: timeout
+                )
+                pr_metadata = pr_data[:pr_metadata]
+                pr_activity = pr_data[:pr_activity]
+              elsif include_pr
+                # Only PR metadata requested
+                pr_metadata = fetch_pr_metadata(timeout: timeout)
+              elsif include_pr_activity
+                # Only activity requested
+                pr_activity = fetch_pr_activity(
+                  current_branch: branch_info[:name],
+                  timeout: timeout
+                )
+              end
+            end
+
+            # Build and return status
+            Models::RepoStatus.from_data(
+              branch_info: branch_info,
+              task_pattern: task_pattern,
+              pr_metadata: pr_metadata,
+              pr_activity: pr_activity,
+              git_status_sb: git_status_sb,
+              recent_commits: recent_commits,
+              repo_type: repo_type,
+              repo_state: repo_state
+            )
+          end
+
+          # Load status for a specific PR
+          # @param pr_identifier [String] PR identifier
+          # @param options [Hash] Options
+          # @return [Models::RepoStatus] Status with PR data
+          def load_for_pr(pr_identifier, options = {})
+            timeout = options.fetch(:timeout, Ace::Git.network_timeout)
+
+            # Get basic status (skip PR activity since we're fetching a specific PR)
+            status = load(include_pr: false, include_pr_activity: false)
+
+            # Fetch specific PR metadata
+            begin
+              result = Molecules::PrMetadataFetcher.fetch_metadata(pr_identifier, timeout: timeout)
+              pr_metadata = result[:success] ? result[:metadata] : nil
+            rescue Ace::Git::Error
+              pr_metadata = nil
+            end
+
+            # Return status with PR data
+            Models::RepoStatus.from_data(
+              branch_info: {
+                name: status.branch,
+                tracking: status.tracking,
+                ahead: status.ahead,
+                behind: status.behind
+              },
+              task_pattern: status.task_pattern,
+              pr_metadata: pr_metadata,
+              repo_type: status.repository_type,
+              repo_state: status.repository_state
+            )
+          end
+
+          # Load minimal status (branch only, no PR)
+          # @return [Models::RepoStatus] Minimal status
+          def load_minimal
+            load(include_pr: false, include_pr_activity: false, include_commits: false)
+          end
+
+          private
+
+          # Fetch git status in short branch format
+          # @return [String, nil] Git status output or nil
+          def fetch_git_status
+            result = Molecules::GitStatusFetcher.fetch_status_sb
+            result[:success] ? result[:output] : nil
+          rescue
+            nil
+          end
+
+          # Fetch recent commits
+          # @param limit [Integer] Number of commits to fetch
+          # @return [Array, nil] Array of commit hashes or nil
+          def fetch_recent_commits(limit:)
+            result = Molecules::RecentCommitsFetcher.fetch(limit: limit)
+            result[:success] ? result[:commits] : nil
+          rescue
+            nil
+          end
+
+          # Fetch PR metadata for current branch
+          # @param timeout [Integer] Timeout in seconds
+          # @return [Hash, nil] PR metadata or nil
+          def fetch_pr_metadata(timeout:)
+            # First try to find PR for current branch
+            pr_number = Molecules::PrMetadataFetcher.find_pr_for_branch(timeout: timeout)
+            return nil unless pr_number
+
+            # Then fetch full metadata
+            result = Molecules::PrMetadataFetcher.fetch_metadata(pr_number, timeout: timeout)
+            result[:success] ? result[:metadata] : nil
+          rescue Ace::Git::GhNotInstalledError, Ace::Git::GhAuthenticationError
+            # gh not available, skip PR metadata
+            nil
+          rescue Ace::Git::PrNotFoundError
+            # No PR for this branch
+            nil
+          rescue Ace::Git::TimeoutError
+            # Timeout, skip PR metadata
+            nil
+          rescue
+            # Any other error, skip PR metadata
+            nil
+          end
+
+          # Fetch PR activity (recently merged and open PRs)
+          # @param current_branch [String] Current branch name to exclude from open PRs
+          # @param timeout [Integer] Timeout in seconds
+          # @return [Hash, nil] PR activity with :merged and :open arrays (symbol keys), or nil
+          #   Each PR in the arrays has string keys from JSON parsing: "number", "title", etc.
+          def fetch_pr_activity(current_branch:, timeout:)
+            merged_result = Molecules::PrMetadataFetcher.fetch_recently_merged(
+              limit: Ace::Git.merged_prs_limit,
+              timeout: timeout
+            )
+            open_result = Molecules::PrMetadataFetcher.fetch_open_prs(
+              exclude_branch: current_branch,
+              timeout: timeout
+            )
+
+            # Return nil if both failed
+            return nil unless merged_result[:success] || open_result[:success]
+
+            # Use symbol keys for outer hash, string keys for PR data (from JSON)
+            # This is documented behavior - consumers should access via pr_activity[:merged]
+            # and individual PRs via pr["number"], pr["title"], etc.
+            {
+              merged: merged_result[:success] ? merged_result[:prs] : [],
+              open: open_result[:success] ? open_result[:prs] : []
+            }
+          rescue
+            # Any error, skip PR activity
+            nil
+          end
+
+          # Fetch PR metadata and activity in a single API call for optimal performance
+          # Uses gh pr list --state all to get all PRs, then filters locally
+          # @param current_branch [String] Current branch name to match/exclude
+          # @param timeout [Integer] Timeout in seconds
+          # @return [Hash] Result with :pr_metadata and :pr_activity keys
+          def fetch_pr_data_parallel(current_branch:, timeout:)
+            # Single API call gets all recent PRs
+            result = Molecules::PrMetadataFetcher.fetch_all_prs(
+              limit: 15,  # Enough for current + merged + open
+              timeout: timeout
+            )
+
+            return {pr_metadata: nil, pr_activity: nil} unless result[:success]
+
+            prs = result[:prs]
+
+            # Find current PR (matching branch, prefer OPEN > MERGED > CLOSED)
+            branch_prs = prs.select { |pr| pr["headRefName"] == current_branch }
+            current_pr = branch_prs.min_by { |pr|
+              case pr["state"]
+              when "OPEN" then 0
+              when "MERGED" then 1
+              when "CLOSED" then 2
+              else 3
+              end
+            }
+
+            # Get merged PRs (sorted by mergedAt descending, limited)
+            merged_prs = prs
+              .select { |pr| pr["state"] == "MERGED" }
+              .sort_by { |pr| pr["mergedAt"] || "" }
+              .reverse
+              .take(Ace::Git.merged_prs_limit)
+
+            # Get open PRs (exclude current branch, limited)
+            open_prs = prs
+              .select { |pr| pr["state"] == "OPEN" && pr["headRefName"] != current_branch }
+              .take(Ace::Git.open_prs_limit)
+
+            # Build activity hash (nil if no activity to show)
+            pr_activity = nil
+            if merged_prs.any? || open_prs.any?
+              pr_activity = {merged: merged_prs, open: open_prs}
+            end
+
+            {
+              pr_metadata: current_pr,
+              pr_activity: pr_activity
+            }
+          rescue
+            {pr_metadata: nil, pr_activity: nil}
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ace/git/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Ace
+  module Git
+    VERSION = "0.18.0"
+  end
+end

data/lib/ace/git.rb

@@ -0,0 +1,230 @@
+# frozen_string_literal: true
+
+require "ace/support/config"
+require_relative "git/version"
+
+module Ace
+  module Git
+    # Error handling pattern:
+    # - Atoms: Pure functions, raise exceptions for invalid inputs
+    # - Molecules: May return error hashes for "expected" errors (e.g., not in git repo)
+    #   or raise exceptions for unexpected failures
+    # - Organisms: Orchestrate molecules, propagate or wrap exceptions
+    # - Commands: Catch exceptions and return exit codes (0=success, 1=error)
+    #
+    # All custom exceptions inherit from Ace::Git::Error for consistent catching.
+    class Error < StandardError; end
+    class GitError < Error; end
+    class ConfigError < Error; end
+    class GhNotInstalledError < Error; end
+    class GhAuthenticationError < Error; end
+    class PrNotFoundError < Error; end
+    class TimeoutError < Error; end
+
+    # Mutex for thread-safe config initialization
+    @config_mutex = Mutex.new
+
+    # Get configuration for ace-git
+    # Follows ADR-022: Configuration Default and Override Pattern
+    # Uses Ace::Support::Config.create() for configuration cascade resolution
+    # Thread-safe: uses mutex for initialization
+    # @return [Hash] merged configuration hash
+    # @example Get current configuration
+    #   config = Ace::Git.config
+    #   puts config["default_branch"]  # => "main"
+    # @example Access nested diff config
+    #   exclude = Ace::Git.config["exclude_patterns"]
+    def self.config
+      # Fast path: return cached config if already initialized
+      return @config if defined?(@config) && @config
+
+      # Thread-safe initialization
+      @config_mutex.synchronize do
+        @config ||= load_config
+      end
+    end
+
+    # Load configuration using Ace::Support::Config cascade
+    # Resolves gem defaults from .ace-defaults/ and user overrides from .ace/
+    # @return [Hash] Merged and transformed configuration
+    def self.load_config
+      gem_root = Gem.loaded_specs["ace-git"]&.gem_dir ||
+        File.expand_path("../..", __dir__)
+
+      resolver = Ace::Support::Config.create(
+        config_dir: ".ace",
+        defaults_dir: ".ace-defaults",
+        gem_path: gem_root
+      )
+
+      # Resolve config for git namespace
+      config = resolver.resolve_namespace("git")
+
+      # Extract and flatten the git section for backward compatibility
+      raw_config = config.data["git"] || config.data
+      extract_git_config(raw_config)
+    rescue Ace::Support::Config::YamlParseError => e
+      warn "ace-git: YAML syntax error in configuration"
+      warn "  #{e.message}"
+      # Fall back to gem defaults instead of empty hash to prevent silent config erasure
+      extract_git_config(load_gem_defaults_fallback(gem_root))
+    rescue => e
+      warn "ace-git: Failed to load configuration: #{e.message}"
+      # Fall back to gem defaults instead of empty hash to prevent silent config erasure
+      gem_root = Gem.loaded_specs["ace-git"]&.gem_dir ||
+        File.expand_path("../..", __dir__)
+      extract_git_config(load_gem_defaults_fallback(gem_root))
+    end
+    private_class_method :load_config
+
+    # Load gem defaults directly as fallback when cascade resolution fails
+    # This ensures configuration is never silently erased due to YAML errors
+    # or user config issues
+    # @param gem_root [String] Path to gem root directory
+    # @return [Hash] Defaults hash or empty hash if defaults also fail
+    def self.load_gem_defaults_fallback(gem_root)
+      defaults_path = File.join(gem_root, ".ace-defaults", "git", "config.yml")
+
+      return {} unless File.exist?(defaults_path)
+
+      data = YAML.safe_load_file(defaults_path, permitted_classes: [Date], aliases: true) || {}
+      data["git"] || data
+    rescue
+      {} # Only return empty hash if even defaults fail to load
+    end
+    private_class_method :load_gem_defaults_fallback
+
+    # Extract git configuration from YAML structure
+    #
+    # BACKWARD COMPATIBILITY NOTE:
+    # This method flattens the nested `diff:` section to top-level keys.
+    # This is required because the original default_config structure used flat keys
+    # (e.g., `exclude_patterns`, `exclude_whitespace`) rather than nested `diff.exclude_patterns`.
+    # The YAML config uses `git.diff.exclude_patterns` for clarity, but internally we flatten
+    # to maintain compatibility with DiffConfig.from_hash and existing consumers.
+    #
+    # Example transformation:
+    #   git:
+    #     diff:
+    #       exclude_patterns: ["*.log"]
+    #   becomes:
+    #     { "exclude_patterns" => ["*.log"] }
+    #
+    # Keys are kept as strings for consistency with YAML loading.
+    # Use config["key"] or config.key?("key") for access.
+    #
+    # @param git_section [Hash] The git: section from YAML
+    # @return [Hash] Flattened configuration with string keys
+    def self.extract_git_config(git_section)
+      return {} if git_section.nil? || git_section.empty?
+
+      config = {}
+
+      # Normalize keys to strings for consistency
+      normalized = normalize_keys(git_section)
+
+      # Copy top-level settings
+      %w[default_branch remote verbose timeout network_timeout].each do |key|
+        config[key] = normalized[key] if normalized.key?(key)
+      end
+
+      # Flatten diff: section to top-level for backward compatibility (see note above)
+      diff_section = normalized["diff"]
+      if diff_section.is_a?(Hash)
+        normalize_keys(diff_section).each do |key, value|
+          config[key] = value
+        end
+      end
+
+      # Copy other sections as-is (rebase, pr, squash, status, lock_retry, etc.)
+      %w[rebase pr squash status lock_retry].each do |key|
+        config[key] = normalized[key] if normalized.key?(key)
+      end
+
+      config
+    end
+
+    # Normalize hash keys to strings for consistent access
+    # @param hash [Hash] Hash with potentially mixed string/symbol keys
+    # @return [Hash] Hash with string keys
+    def self.normalize_keys(hash)
+      return {} unless hash.is_a?(Hash)
+
+      hash.transform_keys(&:to_s)
+    end
+
+    # Reset configuration cache (mainly for testing)
+    # Thread-safe: uses mutex to prevent race conditions
+    def self.reset_config!
+      @config_mutex.synchronize do
+        @config = nil
+      end
+    end
+
+    # ---- Configuration Helper Methods (ADR-022 compliant) ----
+    # These read from config instead of using hardcoded constants
+
+    # Timeout for local git operations (diff, status, log)
+    # @return [Integer] Timeout in seconds (default: 30)
+    def self.git_timeout
+      config["timeout"] || 30
+    end
+
+    # Timeout for network operations (gh CLI, remote operations)
+    # @return [Integer] Timeout in seconds (default: 60)
+    def self.network_timeout
+      config["network_timeout"] || 60
+    end
+
+    # Number of recent commits to show in status output
+    # @return [Integer] Limit (default: 3)
+    def self.commits_limit
+      config.dig("status", "commits_limit") || 3
+    end
+
+    # Number of recently merged PRs to show in status output
+    # @return [Integer] Limit (default: 3)
+    def self.merged_prs_limit
+      config.dig("status", "merged_prs_limit") || 3
+    end
+
+    # Number of open PRs to show in status output
+    # @return [Integer] Limit (default: 10)
+    def self.open_prs_limit
+      config.dig("status", "open_prs_limit") || 10
+    end
+  end
+end
+
+# Require ATOM architecture components
+require_relative "git/atoms/command_executor"
+require_relative "git/atoms/pattern_filter"
+require_relative "git/atoms/diff_parser"
+require_relative "git/atoms/diff_numstat_parser"
+require_relative "git/atoms/file_grouper"
+require_relative "git/atoms/grouped_stats_formatter"
+require_relative "git/atoms/date_resolver"
+require_relative "git/atoms/task_pattern_extractor"
+require_relative "git/atoms/pr_identifier_parser"
+require_relative "git/atoms/repository_state_detector"
+require_relative "git/atoms/repository_checker"
+require_relative "git/atoms/git_scope_filter"
+require_relative "git/atoms/time_formatter"
+require_relative "git/atoms/status_formatter"
+require_relative "git/atoms/lock_error_detector"
+require_relative "git/atoms/stale_lock_cleaner"
+
+require_relative "git/molecules/diff_generator"
+require_relative "git/molecules/config_loader"
+require_relative "git/molecules/diff_filter"
+require_relative "git/molecules/branch_reader"
+require_relative "git/molecules/pr_metadata_fetcher"
+require_relative "git/molecules/recent_commits_fetcher"
+require_relative "git/molecules/git_status_fetcher"
+
+require_relative "git/organisms/diff_orchestrator"
+require_relative "git/organisms/repo_status_loader"
+
+require_relative "git/models/diff_result"
+require_relative "git/models/diff_config"
+require_relative "git/models/repo_status"