ace-git 0.18.0

data/lib/ace/git/models/repo_status.rb

@@ -0,0 +1,202 @@
+# frozen_string_literal: true
+
+module Ace
+  module Git
+    module Models
+      # Data structure representing repository status
+      # Includes branch info, task pattern, PR metadata, and repository state
+      class RepoStatus
+        attr_reader :branch, :tracking, :ahead, :behind, :task_pattern,
+          :pr_metadata, :pr_activity, :git_status_sb, :recent_commits,
+          :repository_type, :repository_state
+
+        # @param branch [String] Current branch name
+        # @param tracking [String, nil] Remote tracking branch
+        # @param ahead [Integer] Commits ahead of remote
+        # @param behind [Integer] Commits behind remote
+        # @param task_pattern [String, nil] Detected task pattern from branch
+        # @param pr_metadata [Hash, nil] PR metadata if available
+        # @param pr_activity [Hash, nil] PR activity (merged and open PRs)
+        # @param git_status_sb [String, nil] Output of git status -sb
+        # @param recent_commits [Array, nil] Recent commits array
+        # @param repository_type [Symbol] :normal, :detached, :bare, :worktree, :not_git
+        # @param repository_state [Symbol] :clean, :dirty, :rebasing, :merging
+        def initialize(
+          branch:,
+          tracking: nil,
+          ahead: 0,
+          behind: 0,
+          task_pattern: nil,
+          pr_metadata: nil,
+          pr_activity: nil,
+          git_status_sb: nil,
+          recent_commits: nil,
+          repository_type: :normal,
+          repository_state: :clean
+        )
+          @branch = branch
+          @tracking = tracking
+          @ahead = ahead
+          @behind = behind
+          @task_pattern = task_pattern
+          @pr_metadata = pr_metadata
+          @pr_activity = pr_activity
+          @git_status_sb = git_status_sb
+          @recent_commits = recent_commits
+          @repository_type = repository_type
+          @repository_state = repository_state
+        end
+
+        # Check if branch is detached
+        # @return [Boolean] True if detached HEAD
+        def detached?
+          branch == "HEAD" || repository_type == :detached
+        end
+
+        # Check if tracking remote
+        # @return [Boolean] True if has tracking branch
+        def tracking?
+          !tracking.nil? && !tracking.empty?
+        end
+
+        # Check if up to date with remote
+        # @return [Boolean] True if no ahead/behind
+        def up_to_date?
+          ahead == 0 && behind == 0
+        end
+
+        # Check if has associated PR
+        # @return [Boolean] True if PR metadata present
+        def has_pr?
+          !pr_metadata.nil? && !pr_metadata.empty?
+        end
+
+        # Check if has detected task pattern
+        # @return [Boolean] True if task pattern found
+        def has_task_pattern?
+          !task_pattern.nil? && !task_pattern.empty?
+        end
+
+        # Check if has PR activity data
+        # @return [Boolean] True if any merged or open PRs present
+        def has_pr_activity?
+          return false if pr_activity.nil?
+
+          merged = pr_activity[:merged] || pr_activity["merged"] || []
+          open = pr_activity[:open] || pr_activity["open"] || []
+          !merged.empty? || !open.empty?
+        end
+
+        # Check if has recent commits data
+        # @return [Boolean] True if recent commits present
+        def has_recent_commits?
+          !recent_commits.nil? && !recent_commits.empty?
+        end
+
+        # Check if has git status output
+        # @return [Boolean] True if git status output present
+        def has_git_status?
+          !git_status_sb.nil? && !git_status_sb.empty?
+        end
+
+        # Check if repository is clean
+        # @return [Boolean] True if no uncommitted changes
+        def clean?
+          repository_state == :clean
+        end
+
+        # Count dirty files from git status output
+        # @return [Integer] Number of dirty files (non-branch lines in git status -sb)
+        def dirty_file_count
+          return 0 unless has_git_status?
+
+          git_status_sb.lines.count { |l| !l.start_with?("##") }
+        end
+
+        # Get tracking status description
+        # @return [String] Human-readable status
+        def tracking_status
+          return "no tracking branch" unless tracking?
+
+          if up_to_date?
+            "up to date"
+          elsif ahead > 0 && behind > 0
+            "#{ahead} ahead, #{behind} behind"
+          elsif ahead > 0
+            "#{ahead} ahead"
+          else
+            "#{behind} behind"
+          end
+        end
+
+        # Convert to hash
+        # @return [Hash] Hash representation
+        def to_h
+          {
+            branch: branch,
+            tracking: tracking,
+            ahead: ahead,
+            behind: behind,
+            up_to_date: up_to_date?,
+            task_pattern: task_pattern,
+            pr_metadata: pr_metadata,
+            pr_activity: pr_activity,
+            git_status_sb: git_status_sb,
+            recent_commits: recent_commits,
+            repository_type: repository_type,
+            repository_state: repository_state,
+            detached: detached?,
+            has_pr: has_pr?,
+            has_pr_activity: has_pr_activity?,
+            has_recent_commits: has_recent_commits?,
+            has_git_status: has_git_status?,
+            has_task_pattern: has_task_pattern?,
+            clean: clean?,
+            dirty_files: dirty_file_count
+          }
+        end
+
+        # Convert to JSON
+        # @return [String] JSON representation
+        def to_json(*args)
+          to_h.to_json(*args)
+        end
+
+        # Generate markdown output
+        # @return [String] Markdown-formatted status
+        # @note Delegates to Atoms::StatusFormatter for ATOM pattern compliance
+        def to_markdown
+          Atoms::StatusFormatter.to_markdown(self)
+        end
+
+        # Create from loaded data
+        # @param branch_info [Hash] Branch information
+        # @param task_pattern [String, nil] Detected task pattern
+        # @param pr_metadata [Hash, nil] PR metadata
+        # @param pr_activity [Hash, nil] PR activity (merged and open PRs)
+        # @param git_status_sb [String, nil] Output of git status -sb
+        # @param recent_commits [Array, nil] Recent commits array
+        # @param repo_type [Symbol] Repository type
+        # @param repo_state [Symbol] Repository state
+        # @return [RepoStatus] New instance
+        def self.from_data(branch_info:, task_pattern: nil, pr_metadata: nil,
+          pr_activity: nil, git_status_sb: nil, recent_commits: nil,
+          repo_type: :normal, repo_state: :clean)
+          new(
+            branch: branch_info[:name] || branch_info["name"],
+            tracking: branch_info[:tracking] || branch_info["tracking"],
+            ahead: branch_info[:ahead] || branch_info["ahead"] || 0,
+            behind: branch_info[:behind] || branch_info["behind"] || 0,
+            task_pattern: task_pattern,
+            pr_metadata: pr_metadata,
+            pr_activity: pr_activity,
+            git_status_sb: git_status_sb,
+            recent_commits: recent_commits,
+            repository_type: repo_type,
+            repository_state: repo_state
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Ace
+  module Git
+    module Molecules
+      # Reads git branch information
+      # Consolidated from ace-review GitBranchReader (adapted to use CommandExecutor)
+      class BranchReader
+        class << self
+          # Get current git branch name or commit SHA if detached
+          # @param executor [Module] Command executor
+          # @return [String|nil] branch name, commit SHA (if detached), or nil if not in git repo
+          def current_branch(executor: Atoms::CommandExecutor)
+            executor.current_branch
+          end
+
+          # Check if HEAD is detached
+          # @param executor [Module] Command executor
+          # @return [Boolean] true if HEAD is detached
+          def detached?(executor: Atoms::CommandExecutor)
+            result = executor.execute("git", "rev-parse", "--abbrev-ref", "HEAD")
+            return false unless result[:success]
+
+            result[:output].strip == "HEAD"
+          end
+
+          # Get remote tracking branch
+          # @param executor [Module] Command executor
+          # @return [String|nil] tracking branch name or nil
+          def tracking_branch(executor: Atoms::CommandExecutor)
+            executor.tracking_branch
+          end
+
+          # Get remote tracking status (ahead/behind counts)
+          # @param executor [Module] Command executor
+          # @return [Hash] { ahead: Integer, behind: Integer }
+          def tracking_status(executor: Atoms::CommandExecutor)
+            result = executor.execute("git", "rev-list", "--left-right", "--count", "@{upstream}...HEAD")
+
+            unless result[:success]
+              return {ahead: 0, behind: 0, error: "No tracking branch or not in git repo"}
+            end
+
+            parts = result[:output].strip.split(/\s+/)
+            {
+              ahead: parts[1].to_i,
+              behind: parts[0].to_i
+            }
+          end
+
+          # Get full branch information
+          # @param executor [Module] Command executor
+          # @return [Hash] Branch information
+          def full_info(executor: Atoms::CommandExecutor)
+            branch = current_branch(executor: executor)
+
+            return {error: "Not in git repository or no branch"} if branch.nil?
+
+            tracking = tracking_branch(executor: executor)
+            status = tracking_status(executor: executor)
+
+            {
+              name: branch,
+              detached: detached?(executor: executor),
+              tracking: tracking,
+              ahead: status[:ahead],
+              behind: status[:behind],
+              up_to_date: status[:ahead] == 0 && status[:behind] == 0,
+              status_description: format_status(status[:ahead], status[:behind])
+            }
+          end
+
+          # Format tracking status as human-readable string
+          # @param ahead [Integer] Commits ahead of remote
+          # @param behind [Integer] Commits behind remote
+          # @return [String] Status description
+          def format_status(ahead, behind)
+            if ahead == 0 && behind == 0
+              "up to date"
+            elsif ahead > 0 && behind > 0
+              "#{ahead} ahead, #{behind} behind"
+            elsif ahead > 0
+              "#{ahead} ahead"
+            else
+              "#{behind} behind"
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require "ace/support/config"
+
+module Ace
+  module Git
+    module Molecules
+      # Load and merge diff configuration from cascade
+      # Follows ADR-022: Configuration Default and Override Pattern
+      # Uses Config.merge() for consistent merge strategy support
+      # Migrated from ace-git-diff
+      class ConfigLoader
+        class << self
+          # Load configuration using ace-config cascade with deep merge
+          # Priority: instance_config merged over global config (which is already defaults + user)
+          # @param instance_config [Hash] Instance-level configuration (highest priority)
+          # @return [Models::DiffConfig] Merged configuration
+          def load(instance_config = {})
+            # Get global config from ace-git (already merged defaults + user per ADR-022)
+            global_config = Ace::Git.config || {}
+
+            # Extract diff config from the global config (handles diff: namespace)
+            global_diff_config = extract_diff_config(global_config)
+
+            # Use Config.merge() for consistent merge strategy support
+            # This enables future per-key merge strategies via _merge directive
+            config_hash = Ace::Support::Config::Models::Config.new(global_diff_config, source: "git_global")
+              .merge(instance_config)
+              .to_h
+
+            Models::DiffConfig.from_hash(config_hash)
+          end
+
+          # Load configuration for a specific gem integration
+          # Priority: instance_config > gem_config > global_config (all deep merged)
+          # @param gem_config [Hash] Gem-specific configuration
+          # @param instance_config [Hash] Instance-level overrides
+          # @return [Models::DiffConfig] Merged configuration
+          def load_for_gem(gem_config, instance_config = {})
+            # Start with global config (already merged defaults + user per ADR-022)
+            global_config = Ace::Git.config || {}
+
+            # Extract diff config from global (handles diff: namespace)
+            global_diff_config = extract_diff_config(global_config)
+            gem_diff_config = extract_diff_config(gem_config)
+
+            # Use Config.merge() cascade: global -> gem -> instance
+            # This enables future per-key merge strategies via _merge directive
+            config_hash = Ace::Support::Config::Models::Config.new(global_diff_config, source: "git_global")
+              .merge(gem_diff_config)
+              .merge(instance_config)
+              .to_h
+
+            Models::DiffConfig.from_hash(config_hash)
+          end
+
+          # Extract diff configuration from various config formats
+          # Supports both diff: key and legacy/direct formats
+          # When config contains both top-level diff keys AND a nested diff: section,
+          # merges them (nested overrides top-level) to preserve defaults
+          # @param config [Hash] Configuration hash
+          # @return [Hash] Extracted diff configuration
+          def extract_diff_config(config)
+            return {} if config.nil? || config.empty?
+
+            # First, collect any top-level diff keys (flattened defaults)
+            diff_keys = %w[exclude_patterns exclude_whitespace exclude_renames
+              exclude_moves max_lines ranges paths since format timeout grouped_stats]
+            diff_sym_keys = diff_keys.map(&:to_sym)
+
+            top_level_diff = {}
+            diff_keys.each { |k| top_level_diff[k] = config[k] if config.key?(k) }
+            diff_sym_keys.each { |k| top_level_diff[k.to_s] = config[k] if config.key?(k) }
+
+            # Check for explicit diff: key (nested under git: from config cascade)
+            if config.key?("diff") || config.key?(:diff)
+              diff_config = config["diff"] || config[:diff]
+              if diff_config.is_a?(Hash)
+                # Merge nested diff over top-level using Config.merge()
+                return Ace::Support::Config::Models::Config.new(top_level_diff, source: "git_diff_extract")
+                    .merge(diff_config)
+                    .to_h
+              end
+            end
+
+            # Return top-level diff keys if we found any
+            return top_level_diff unless top_level_diff.empty?
+
+            # Check for legacy diffs: array format
+            if config.key?("diffs") || config.key?(:diffs)
+              diffs = config["diffs"] || config[:diffs]
+              return {"ranges" => Array(diffs)} if diffs
+            end
+
+            # Check for legacy filters format (ace-docs)
+            if config.key?("filters") || config.key?(:filters)
+              filters = config["filters"] || config[:filters]
+              return {"paths" => Array(filters)} if filters
+            end
+
+            # No diff config found
+            {}
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Ace
+  module Git
+    module Molecules
+      # Apply filtering to diff output based on configuration
+      # Migrated from ace-git-diff
+      class DiffFilter
+        class << self
+          # Filter diff content based on configuration
+          # @param diff [String] Raw diff content
+          # @param config [Models::DiffConfig] Diff configuration
+          # @return [String] Filtered diff content
+          def filter(diff, config)
+            return "" if diff.nil? || diff.empty?
+            return diff if config.exclude_patterns.empty?
+
+            # Convert glob patterns to regex
+            regex_patterns = Atoms::PatternFilter.glob_to_regex(config.exclude_patterns)
+
+            # Apply pattern filtering
+            filtered = Atoms::PatternFilter.filter_diff_by_patterns(diff, regex_patterns)
+
+            # Check if exceeds max lines
+            if config.max_lines && Atoms::DiffParser.exceeds_limit?(filtered, config.max_lines)
+              truncate(filtered, config.max_lines)
+            else
+              filtered
+            end
+          end
+
+          # Apply only path-based filtering (no size limits)
+          # @param diff [String] Raw diff content
+          # @param exclude_patterns [Array<String>] Glob patterns to exclude
+          # @return [String] Filtered diff content
+          def filter_by_patterns(diff, exclude_patterns)
+            return diff if diff.nil? || diff.empty? || exclude_patterns.empty?
+
+            regex_patterns = Atoms::PatternFilter.glob_to_regex(exclude_patterns)
+            Atoms::PatternFilter.filter_diff_by_patterns(diff, regex_patterns)
+          end
+
+          # Apply include patterns (only show matching files)
+          # @param diff [String] Raw diff content
+          # @param include_patterns [Array<String>] Glob patterns to include
+          # @return [String] Filtered diff content
+          def filter_by_includes(diff, include_patterns)
+            return diff if diff.nil? || diff.empty? || include_patterns.nil? || include_patterns.empty?
+
+            lines = diff.split("\n")
+            filtered_lines = []
+            include_current_file = false
+
+            lines.each do |line|
+              # Check if this is a file header
+              if Atoms::PatternFilter.file_header?(line)
+                file_path = Atoms::PatternFilter.extract_file_path(line)
+                # Include file if it matches any include pattern
+                include_current_file = Atoms::PatternFilter.matches_include?(file_path, include_patterns)
+                filtered_lines << line if include_current_file
+              elsif include_current_file
+                filtered_lines << line
+              end
+            end
+
+            filtered_lines.join("\n")
+          end
+
+          # Truncate diff to maximum number of lines
+          # @param diff [String] Diff content
+          # @param max_lines [Integer] Maximum lines to keep
+          # @return [String] Truncated diff with note
+          def truncate(diff, max_lines)
+            return diff if diff.nil? || diff.empty?
+
+            lines = diff.split("\n")
+            return diff if lines.length <= max_lines
+
+            truncated = lines[0...max_lines].join("\n")
+            truncated + "\n\n... (diff truncated at #{max_lines} lines)"
+          end
+
+          # Get filtering statistics
+          # @param original [String] Original diff
+          # @param filtered [String] Filtered diff
+          # @return [Hash] Statistics about filtering
+          def stats(original, filtered)
+            original_stats = Atoms::DiffParser.count_changes(original)
+            filtered_stats = Atoms::DiffParser.count_changes(filtered)
+
+            {
+              original: original_stats,
+              filtered: filtered_stats,
+              files_removed: original_stats[:files] - filtered_stats[:files],
+              lines_removed: Atoms::DiffParser.count_lines(original) - Atoms::DiffParser.count_lines(filtered)
+            }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+module Ace
+  module Git
+    module Molecules
+      # Generate diffs using git commands with configuration options
+      # Migrated from ace-git-diff
+      class DiffGenerator
+        class << self
+          # Generate diff based on configuration
+          # @param config [Models::DiffConfig] Diff configuration
+          # @param executor [Module] Command executor (default: Atoms::CommandExecutor)
+          # @return [String] Raw diff output
+          def generate(config, executor: Atoms::CommandExecutor)
+            # Handle special cases first
+            return executor.staged_diff if config.format == :staged
+            return executor.working_diff if config.format == :working
+
+            # Determine what to diff
+            range = determine_range(config, executor)
+
+            # Build git diff command
+            cmd_parts = build_command(range, config)
+
+            # Execute with configured timeout
+            result = executor.execute(*cmd_parts, timeout: config.timeout)
+            handle_result(result, cmd_parts)
+          end
+
+          # Generate `git diff --numstat` output for structured file statistics.
+          # Uses the same range/path/flags logic as the main diff generation path.
+          # @param config [Models::DiffConfig] Diff configuration
+          # @param executor [Module] Command executor (default: Atoms::CommandExecutor)
+          # @return [String] Numstat output
+          def generate_numstat(config, executor: Atoms::CommandExecutor)
+            range = determine_range(config, executor)
+            cmd_parts = build_numstat_command(range, config)
+            result = executor.execute(*cmd_parts, timeout: config.timeout)
+            handle_result(result, cmd_parts)
+          end
+
+          # Generate diff for a specific range
+          # @param range [String] Git range (e.g., "HEAD~5..HEAD", "origin/main...HEAD")
+          # @param config [Models::DiffConfig] Configuration options
+          # @param executor [Module] Command executor
+          # @return [String] Diff output
+          def generate_for_range(range, config, executor: Atoms::CommandExecutor)
+            cmd_parts = build_command(range, config)
+            result = executor.execute(*cmd_parts, timeout: config.timeout)
+            handle_result(result, cmd_parts)
+          end
+
+          # Generate diff since a date or commit
+          # @param since [String] Date or commit reference
+          # @param config [Models::DiffConfig] Configuration options
+          # @param executor [Module] Command executor
+          # @return [String] Diff output
+          def generate_since(since, config, executor: Atoms::CommandExecutor)
+            # Resolve since to commit
+            since_ref = Atoms::DateResolver.resolve_since_to_commit(since, executor: executor)
+            range = "#{since_ref}..HEAD"
+
+            generate_for_range(range, config, executor: executor)
+          end
+
+          # Get staged diff with configuration
+          # @param config [Models::DiffConfig] Configuration options
+          # @param executor [Module] Command executor
+          # @return [String] Staged diff output
+          def staged(config, executor: Atoms::CommandExecutor)
+            cmd_parts = build_command("--cached", config)
+            result = executor.execute(*cmd_parts, timeout: config.timeout)
+            handle_result(result, cmd_parts)
+          end
+
+          # Get working directory diff with configuration
+          # @param config [Models::DiffConfig] Configuration options
+          # @param executor [Module] Command executor
+          # @return [String] Working diff output
+          def working(config, executor: Atoms::CommandExecutor)
+            cmd_parts = build_command(nil, config)
+            result = executor.execute(*cmd_parts, timeout: config.timeout)
+            handle_result(result, cmd_parts)
+          end
+
+          private
+
+          # Handle command execution result, raising error on failure
+          # @param result [Hash] Command execution result with :success, :output, :error keys
+          # @param cmd_parts [Array<String>] Command that was executed (for error messages)
+          # @return [String] Command output on success
+          # @raise [Ace::Git::GitError] When command fails
+          def handle_result(result, cmd_parts = nil)
+            if result[:success]
+              result[:output]
+            else
+              error_msg = result[:error].to_s.strip
+              error_msg = "Unknown git error" if error_msg.empty?
+              # Include the failed command for easier debugging
+              cmd_str = cmd_parts ? " (#{cmd_parts.join(" ")})" : ""
+              raise Ace::Git::GitError, "Git command failed#{cmd_str}: #{error_msg}"
+            end
+          end
+
+          # Determine what range to diff based on configuration and git state
+          def determine_range(config, executor)
+            # If ranges specified in config, use first non-empty one
+            # Empty/blank ranges are treated as "no range" (working tree diff)
+            non_empty_ranges = config.ranges.reject { |r| r.nil? || r.strip.empty? }
+            return non_empty_ranges.first if non_empty_ranges.any?
+
+            # If since specified, convert to range
+            if config.since
+              since_ref = Atoms::DateResolver.resolve_since_to_commit(config.since, executor: executor)
+              return "#{since_ref}..HEAD"
+            end
+
+            # Smart default: check if there are unstaged or staged changes
+            return nil if executor.has_unstaged_changes?
+            return "--cached" if executor.has_staged_changes?
+
+            # Default: branch diff against origin/main or tracking branch
+            tracking = executor.tracking_branch
+            if tracking
+              return "#{tracking}...HEAD" if executor.respond_to?(:ref_exists?) && executor.ref_exists?(tracking)
+            end
+
+            return "origin/main...HEAD" if executor.respond_to?(:ref_exists?) && executor.ref_exists?("origin/main")
+            return "HEAD~1..HEAD" if executor.respond_to?(:ref_exists?) && executor.ref_exists?("HEAD~1")
+
+            nil
+          end
+
+          # Build git diff command with configuration options
+          def build_command(range, config)
+            build_git_diff_command(range, config)
+          end
+
+          def build_numstat_command(range, config)
+            build_git_diff_command(range, config, "--numstat")
+          end
+
+          def build_git_diff_command(range, config, *extra_flags)
+            cmd_parts = ["git", "diff"]
+            cmd_parts.concat(extra_flags)
+            cmd_parts.concat(config.git_flags)
+            cmd_parts << range if range
+
+            if config.paths.any?
+              cmd_parts << "--"
+              cmd_parts.concat(config.paths)
+            end
+
+            cmd_parts
+          end
+        end
+      end
+    end
+  end
+end