ace-git 0.18.0

data/lib/ace/git/atoms/file_grouper.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+module Ace
+  module Git
+    module Atoms
+      # Group parsed numstat entries by package/layer/root buckets.
+      module FileGrouper
+        DEFAULT_LAYERS = %w[lib test handbook].freeze
+
+        class << self
+          def group(entries, layers: DEFAULT_LAYERS, dotfile_groups: [])
+            normalized_layers = Array(layers).map(&:to_s)
+            groups = {}
+
+            Array(entries).each do |entry|
+              group_key, layer_key, display_path = classify(entry, normalized_layers)
+              groups[group_key] ||= initialize_group(group_key)
+              group = groups[group_key]
+              group[:layers][layer_key] ||= initialize_layer(layer_key)
+
+              normalized_entry = entry.merge(display_path: display_path)
+              add_to_group(group, group[:layers][layer_key], normalized_entry)
+            end
+
+            ordered_groups = sort_groups(groups.values, dotfile_groups)
+            ordered_groups.each { |group| group[:layers] = sort_layers(group[:layers], normalized_layers) }
+
+            {
+              groups: ordered_groups,
+              total: {
+                additions: ordered_groups.sum { |g| g[:additions] },
+                deletions: ordered_groups.sum { |g| g[:deletions] },
+                files: ordered_groups.sum { |g| g[:file_count] }
+              },
+              files: ordered_groups.flat_map { |g| g[:layers].flat_map { |l| l[:files].map { |f| f[:path] } } }
+            }
+          end
+
+          private
+
+          def initialize_group(name)
+            {
+              name: name,
+              additions: 0,
+              deletions: 0,
+              file_count: 0,
+              layers: {}
+            }
+          end
+
+          def initialize_layer(name)
+            {
+              name: name,
+              additions: 0,
+              deletions: 0,
+              file_count: 0,
+              files: []
+            }
+          end
+
+          def add_to_group(group, layer, entry)
+            adds = entry[:additions] || 0
+            dels = entry[:deletions] || 0
+
+            group[:additions] += adds
+            group[:deletions] += dels
+            group[:file_count] += 1
+
+            layer[:additions] += adds
+            layer[:deletions] += dels
+            layer[:file_count] += 1
+            layer[:files] << entry
+          end
+
+          def classify(entry, layers)
+            path = entry[:path].to_s
+            segments = path.split("/")
+            top = segments.first
+
+            if top&.start_with?("ace-") || (top&.start_with?(".") && segments.length > 1)
+              group_name = "#{top}/"
+              layer = resolve_layer(segments[1], layers)
+              prefix = (layer == "other/" || layer == "root/") ? top : [top, layer.delete_suffix("/")].join("/")
+              [group_name, layer, relativize_entry(entry, prefix)]
+            else
+              ["./", "root/", entry[:display_path]]
+            end
+          end
+
+          def relativize_entry(entry, prefix)
+            return entry[:display_path] if prefix.nil? || prefix.empty?
+
+            if entry[:rename_from] && entry[:rename_to]
+              from = trim_prefix(entry[:rename_from], prefix)
+              to = trim_prefix(entry[:rename_to], prefix)
+              return "#{from} -> #{to}"
+            end
+
+            trim_prefix(entry[:display_path], prefix)
+          end
+
+          def trim_prefix(path, prefix)
+            return path if path.nil? || prefix.nil? || prefix.empty?
+
+            path.start_with?("#{prefix}/") ? path.delete_prefix("#{prefix}/") : path
+          end
+
+          def resolve_layer(segment, layers)
+            return "root/" if segment.nil? || segment.empty?
+
+            layers.include?(segment) ? "#{segment}/" : "other/"
+          end
+
+          def sort_groups(groups, dotfile_groups)
+            configured_dot = Array(dotfile_groups).map { |name| name.to_s.end_with?("/") ? name.to_s : "#{name}/" }
+            dot_index = configured_dot.each_with_index.to_h
+
+            groups.sort_by do |group|
+              name = group[:name]
+              if name == "./"
+                [2, 0, name]
+              elsif name.start_with?("ace-")
+                [0, 0, name]
+              elsif name.start_with?(".")
+                [1, dot_index.fetch(name, 9_999), name]
+              else
+                [1, 9_999, name]
+              end
+            end
+          end
+
+          def sort_layers(layers_hash, configured_layers)
+            layer_order = configured_layers.each_with_index.map { |layer, idx| ["#{layer}/", idx] }.to_h
+            ordered = layers_hash.values.sort_by do |layer|
+              key = layer[:name]
+              if key == "root/"
+                [0, 0, key]
+              elsif key == "other/"
+                [2, 0, key]
+              else
+                [1, layer_order.fetch(key, 9_999), key]
+              end
+            end
+
+            ordered.each { |layer| layer[:files].sort_by! { |file| file[:display_path] } }
+            ordered
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ace/git/atoms/git_scope_filter.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Ace
+  module Git
+    module Atoms
+      # Filters files by git status (staged, tracked, changed)
+      # Consolidated from ace-search GitScopeFilter (adapted to use CommandExecutor)
+      module GitScopeFilter
+        class << self
+          # Get files based on git scope
+          # @param scope [Symbol] :staged, :tracked, or :changed
+          # @param executor [Module] Command executor (default: CommandExecutor)
+          # @return [Array<String>] List of file paths
+          def get_files(scope, executor: CommandExecutor)
+            case scope
+            when :staged
+              get_staged_files(executor: executor)
+            when :tracked
+              get_tracked_files(executor: executor)
+            when :changed
+              get_changed_files(executor: executor)
+            else
+              []
+            end
+          end
+
+          # Get staged files
+          # @param executor [Module] Command executor
+          # @return [Array<String>] List of staged file paths
+          def get_staged_files(executor: CommandExecutor)
+            result = executor.execute("git", "diff", "--cached", "--name-only")
+            return [] unless result[:success]
+
+            result[:output].lines.map(&:strip).reject(&:empty?)
+          end
+
+          # Get tracked files
+          # @param executor [Module] Command executor
+          # @return [Array<String>] List of tracked file paths
+          def get_tracked_files(executor: CommandExecutor)
+            result = executor.execute("git", "ls-files")
+            return [] unless result[:success]
+
+            result[:output].lines.map(&:strip).reject(&:empty?)
+          end
+
+          # Get changed files (modified, not staged)
+          # @param executor [Module] Command executor
+          # @return [Array<String>] List of changed file paths
+          def get_changed_files(executor: CommandExecutor)
+            result = executor.execute("git", "diff", "--name-only")
+            return [] unless result[:success]
+
+            result[:output].lines.map(&:strip).reject(&:empty?)
+          end
+
+          # Get both staged and changed files (all uncommitted)
+          # @param executor [Module] Command executor
+          # @return [Array<String>] List of all uncommitted file paths
+          def get_uncommitted_files(executor: CommandExecutor)
+            (get_staged_files(executor: executor) + get_changed_files(executor: executor)).uniq
+          end
+
+          # Check if in git repository
+          # @param executor [Module] Command executor
+          # @return [Boolean] True if in git repository
+          def in_git_repo?(executor: CommandExecutor)
+            executor.in_git_repo?
+          end
+
+          # Get files changed between two refs
+          # @param from_ref [String] Start reference (e.g., "origin/main")
+          # @param to_ref [String] End reference (default: "HEAD")
+          # @param executor [Module] Command executor
+          # @return [Array<String>] List of changed file paths
+          def get_files_between(from_ref, to_ref = "HEAD", executor: CommandExecutor)
+            result = executor.execute("git", "diff", "--name-only", "#{from_ref}...#{to_ref}")
+            return [] unless result[:success]
+
+            result[:output].lines.map(&:strip).reject(&:empty?)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Ace
+  module Git
+    module Atoms
+      # Pure functions for fetching git status information
+      # Uses git status -sb for compact, familiar output
+      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: 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/atoms/grouped_stats_formatter.rb

@@ -0,0 +1,233 @@
+# frozen_string_literal: true
+
+module Ace
+  module Git
+    module Atoms
+      # Render grouped numstat data to aligned plain text or markdown.
+      module GroupedStatsFormatter
+        LAYER_ICONS = {
+          "lib/" => "🧱",
+          "test/" => "🧪",
+          "handbook/" => "📚"
+        }.freeze
+
+        class << self
+          def format(grouped_data, markdown: false, collapse_above: 5)
+            groups = grouped_data[:groups] || []
+            total = grouped_data[:total] || {additions: 0, deletions: 0, files: 0}
+            return "" if total[:files].to_i.zero?
+
+            markdown ? format_markdown(groups, total, collapse_above) : format_plain(groups, total)
+          end
+
+          private
+
+          def format_plain(groups, total)
+            lines = []
+            lines << total_line(total)
+            lines << ""
+
+            groups.each do |group|
+              lines.concat(render_group_plain(group))
+              lines << ""
+            end
+
+            trim_trailing_blank(lines).join("\n")
+          end
+
+          def format_markdown(groups, total, collapse_above)
+            lines = []
+            lines << "```text"
+            lines << total_line(total)
+            lines << "```"
+            lines << ""
+
+            groups.each do |group|
+              if group[:file_count] > collapse_above
+                lines << "<details>"
+                lines << "<summary>#{group[:name]} (#{inline_totals(group)}) - #{group[:file_count]} files</summary>"
+                lines << ""
+                lines << "```text"
+                render_group_plain(group).each { |line| lines << line }
+                lines << "```"
+                lines << "</details>"
+              else
+                lines << "```text"
+                render_group_plain(group).each { |line| lines << line }
+                lines << "```"
+              end
+              lines << ""
+            end
+
+            trim_trailing_blank(lines).join("\n")
+          end
+
+          def render_group_plain(group)
+            lines = []
+            lines << header_line(
+              additions: group[:additions],
+              deletions: group[:deletions],
+              file_count: group[:file_count],
+              icon: nil,
+              label: group[:name]
+            )
+
+            Array(group[:layers]).each do |layer|
+              unless skip_layer_header?(group, layer)
+                icon, label = layer_header_parts(layer[:name], group_name: group[:name])
+                lines << header_line(
+                  additions: layer[:additions],
+                  deletions: layer[:deletions],
+                  file_count: layer[:file_count],
+                  icon: icon,
+                  label: label
+                )
+              end
+              Array(layer[:files]).each_with_index do |file, idx|
+                prev_file = layer[:files][idx - 1] if idx > 0
+                lines << "#{stats_block(file[:additions], file[:deletions], binary: file[:binary])}#{FILE_INDENT}#{file_line(file, prev_file: prev_file)}"
+              end
+            end
+
+            trim_trailing_blank(lines)
+          end
+
+          def total_line(total)
+            "#{stats_block(total[:additions], total[:deletions])}#{files_label(total[:files])}total"
+          end
+
+          def file_line(file, prev_file: nil)
+            suffix = file[:binary] ? " (binary)" : ""
+            path = squashed_path(file[:display_path], prev_file&.dig(:display_path))
+            "#{path}#{suffix}"
+          end
+
+          def squashed_path(path, prev_path)
+            if path.include?(" -> ")
+              return compact_rename_path(path) if prev_path.nil? || !prev_path.include?(" -> ")
+
+              return squashed_rename_path(path, prev_path)
+            end
+
+            return path unless prev_path
+
+            # Don't compare directory of a rename path — it's not a real filesystem dir
+            return path if prev_path.include?(" -> ")
+
+            curr_dir = File.dirname(path)
+            prev_dir = File.dirname(prev_path)
+
+            return path if curr_dir == "." || curr_dir != prev_dir
+
+            ".../#{File.basename(path)}"
+          end
+
+          # Squash consecutive renames that share from_dir and to_dir.
+          # "atoms/old.rb -> atoms/new.rb" becomes "      old.rb ->       new.rb"
+          def squashed_rename_path(path, prev_path)
+            return path unless prev_path.include?(" -> ")
+
+            from, to = path.split(" -> ", 2)
+            prev_from, prev_to = prev_path.split(" -> ", 2)
+
+            from_dir = File.dirname(from)
+            to_dir = File.dirname(to)
+
+            return path unless from_dir == File.dirname(prev_from) && to_dir == File.dirname(prev_to)
+            return path if from_dir == "." || to_dir == "."
+
+            "#{" " * (from_dir.length + 1)}#{File.basename(from)} -> #{" " * (to_dir.length + 1)}#{File.basename(to)}"
+          end
+
+          # Compact shared leading path in a single rename:
+          # "a/b/old.rb -> a/b/new.rb" => "a/b/old.rb -> new.rb"
+          # "a/b/file -> a/b/_archive/file" => "a/b/file -> _archive/file"
+          def compact_rename_path(path)
+            from, to = path.split(" -> ", 2)
+            return path if from.nil? || to.nil?
+
+            from_segments = from.split("/")
+            to_segments = to.split("/")
+            common_segments = []
+
+            while !from_segments.empty? && !to_segments.empty? && from_segments.first == to_segments.first
+              common_segments << from_segments.shift
+              to_segments.shift
+            end
+
+            return path if common_segments.empty?
+
+            common_prefix = common_segments.join("/") + "/"
+            from_tail = from.delete_prefix(common_prefix)
+            to_tail = to.delete_prefix(common_prefix)
+            "#{common_prefix}#{from_tail} -> #{to_tail}"
+          end
+
+          # Width of a rendered stats block: "%5s, %5s" = 12 chars
+          STATS_WIDTH = 12
+          # Separator replacing "   N files   " on file lines (= 3 + 2 + 9 = 14 chars)
+          FILES_COLUMN_WIDTH = 14
+          ICON_COLUMN = 3
+          FILE_INDENT = " " * (FILES_COLUMN_WIDTH + ICON_COLUMN)
+
+          def stats_block(additions, deletions, binary: false)
+            return " " * STATS_WIDTH if binary
+
+            plus = stat_label(additions, "+")
+            minus = stat_label(deletions, "-")
+            Kernel.format("%5s, %5s", plus.to_s, minus.to_s)
+          end
+
+          # "   NN files   " — always 14 chars (3 + %2d + 9), aligns name column
+          def files_label(count)
+            Kernel.format("   %2d files   ", count.to_i)
+          end
+
+          def stat_label(value, prefix)
+            return nil if value.nil?
+
+            "#{prefix}#{value}"
+          end
+
+          def inline_totals(group)
+            add = group[:additions].to_i.positive? ? "+#{group[:additions]}" : "+0"
+            del = group[:deletions].to_i.positive? ? "-#{group[:deletions]}" : "-0"
+            "#{add}, #{del}"
+          end
+
+          def layer_header_parts(name, group_name:)
+            layer = name.to_s
+            label = (layer == "other/" && group_name.to_s != "./") ? "" : layer
+            [LAYER_ICONS[layer], label]
+          end
+
+          def icon_column(icon)
+            return " " * ICON_COLUMN if icon.nil?
+
+            "#{icon} "
+          end
+
+          def header_line(additions:, deletions:, file_count:, icon:, label:)
+            "#{stats_block(additions, deletions)}#{files_label(file_count)}#{icon_column(icon)}#{label}"
+          end
+
+          def skip_layer_header?(group, layer)
+            group_name = group[:name].to_s
+            layer_name = layer[:name].to_s
+
+            return true if group_name == "./" && layer_name == "root/"
+
+            group[:additions].to_i == layer[:additions].to_i &&
+              group[:deletions].to_i == layer[:deletions].to_i &&
+              group[:file_count].to_i == layer[:file_count].to_i
+          end
+
+          def trim_trailing_blank(lines)
+            lines.pop while lines.last == ""
+            lines
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ace/git/atoms/lock_error_detector.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Ace
+  module Git
+    module Atoms
+      # Pure functions for detecting git index lock errors from command output
+      #
+      # Git operations can fail with "Unable to create .git/index.lock" errors
+      # when:
+      # - Previous git operations were interrupted (Ctrl+C, crashes, timeouts)
+      # - Multiple concurrent operations contend for the same lock
+      # - Agents are blocked mid-operation leaving orphan lock files
+      #
+      # This detector identifies these errors so retry logic can handle them.
+      module LockErrorDetector
+        # Git error patterns that indicate index lock issues
+        # These patterns appear in stderr when git cannot acquire the lock
+        # Covers various git versions and platforms
+        LOCK_ERROR_PATTERNS = [
+          /Unable to create.*index\.lock.*File exists/i,
+          /fatal:\s*cannot create.*index\.lock/i,
+          /Another git process seems to be running/i,
+          /git.*index\.lock.*exists/i,
+          /could not open.*index\.lock/i,
+          /unable to create.*index\.lock/i,
+          /lock file.*index\.lock.*already exists/i
+        ].freeze
+
+        # Exit code 128 often indicates lock issues across different git versions
+        LOCK_EXIT_CODE = 128
+
+        class << self
+          # Detect if a git error is related to index lock issues
+          #
+          # @param stderr [String] The error output from a git command
+          # @return [Boolean] true if the error indicates a lock issue
+          #
+          # @example Detect lock error
+          #   lock_error?("fatal: Unable to create '.git/index.lock': File exists.")
+          #   # => true
+          #
+          # @example Non-lock error
+          #   lock_error?("error: pathspec 'unknown' did not match")
+          #   # => false
+          def lock_error?(stderr)
+            return false if stderr.nil? || stderr.empty?
+
+            LOCK_ERROR_PATTERNS.any? { |pattern| pattern.match?(stderr) }
+          end
+
+          # Check if git command result indicates a lock error
+          #
+          # @param result [Hash] Result hash from CommandExecutor.execute
+          # @return [Boolean] true if the result indicates a lock error
+          #
+          # @example Check result hash
+          #   result = { success: false, error: "fatal: Unable to create...", exit_code: 128 }
+          #   lock_error_result?(result)
+          #   # => true
+          def lock_error_result?(result)
+            return false if result.nil? || result[:success]
+            return false if result[:error].nil? || result[:error].empty?
+
+            # Primary check: known lock error patterns
+            return true if lock_error?(result[:error])
+
+            # Fallback: exit code 128 with "lock" keyword in error
+            # Handles edge cases from different git versions/locales
+            if result[:exit_code] == LOCK_EXIT_CODE && result[:error] =~ /lock/i
+              return true
+            end
+
+            false
+          end
+        end
+      end
+    end
+  end
+end