ace-git 0.18.0

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

@@ -0,0 +1,253 @@
+# frozen_string_literal: true
+
+require "open3"
+require "timeout"
+
+module Ace
+  module Git
+    module Atoms
+      # Pure functions for executing git commands safely
+      # Migrated from ace-git-diff
+      #
+      # Lock Retry Behavior:
+      # - Automatically retries git commands that encounter .git/index.lock errors
+      # - Uses progressive delays: 1s, 2s, 3s, 4s (total 10s across 4 retries)
+      # - On each retry, attempts to clean orphaned locks (dead PID) or stale locks (>10s)
+      # - Configurable via lock_retry section in .ace/git/config.yml
+      # - Only git commands are retried; non-git commands fail immediately
+      #
+      # This retry logic prevents "Unable to create .git/index.lock" errors
+      # that commonly occur in multi-worktree environments or when operations
+      # are interrupted (Ctrl+C, crashes, timeouts).
+      module CommandExecutor
+        class << self
+          # Execute a command safely using array arguments to prevent command injection
+          # @param command_parts [Array<String>] Command parts to execute
+          # @param timeout [Integer] Timeout in seconds (default from config)
+          # @param env [Hash] Optional environment variables to set for the command
+          # @return [Hash] Result with output, error, and success status
+          def execute(*command_parts, timeout: Ace::Git.git_timeout, env: nil)
+            # Check if lock retry is enabled (default: true)
+            lock_retry_config = Ace::Git.config["lock_retry"]
+            lock_retry_enabled = lock_retry_config.nil? || lock_retry_config["enabled"] != false
+
+            if lock_retry_enabled && !command_parts.empty? && command_parts.first == "git"
+              execute_with_lock_retry(command_parts, timeout: timeout, env: env, config: lock_retry_config)
+            else
+              execute_once(command_parts, timeout: timeout, env: env)
+            end
+          end
+
+          private
+
+          # Execute command with lock error retry logic
+          # @param command_parts [Array<String>] Command parts to execute
+          # @param timeout [Integer] Timeout in seconds
+          # @param env [Hash] Optional environment variables
+          # @param config [Hash] Lock retry configuration
+          # @return [Hash] Result with output, error, and success status
+          def execute_with_lock_retry(command_parts, timeout:, env:, config:)
+            config ||= {}
+            # Use fetch to respect zero values (e.g., max_retries: 0 to disable retries)
+            max_retries = config.fetch("max_retries", 4)
+            stale_cleanup = config.fetch("stale_cleanup", true)
+            stale_threshold = config.fetch("stale_threshold_seconds", 10)
+
+            result = nil
+            last_lock_info = nil
+            repo_root = nil
+
+            (0..max_retries).each do |attempt|
+              result = execute_once(command_parts, timeout: timeout, env: env)
+
+              # Success or non-lock error - return immediately
+              break if result[:success] || !LockErrorDetector.lock_error_result?(result)
+
+              # Attempt lock cleanup on every retry (checks orphaned PID first, then age)
+              if stale_cleanup
+                repo_root ||= CommandExecutor.repo_root
+                if repo_root
+                  clean_result = StaleLockCleaner.clean(repo_root, stale_threshold)
+                  last_lock_info = clean_result
+                  if clean_result[:cleaned] && (ENV["ACE_DEBUG"] || ENV["DEBUG"])
+                    warn "[ace-git] #{clean_result[:message]}"
+                  end
+                end
+              end
+
+              # Sleep before retry (except on last attempt)
+              break if attempt == max_retries
+
+              # Progressive delays: 1s, 2s, 3s, 4s (total 10s across 4 retries)
+              sleep_seconds = attempt + 1
+              pid_note = last_lock_info&.dig(:pid) ? " (PID #{last_lock_info[:pid]})" : ""
+              warn "[ace-git] Lock detected#{pid_note}, waiting #{sleep_seconds}s (attempt #{attempt + 1}/#{max_retries + 1})..."
+              Kernel.sleep(sleep_seconds)
+            end
+
+            # Add retry context to error message if all retries failed
+            if !result[:success] && LockErrorDetector.lock_error_result?(result)
+              error = "Git index locked after #{max_retries + 1} attempts (#{max_retries} retries). #{result[:error]}"
+              if last_lock_info && last_lock_info[:status] == :active && last_lock_info[:pid]
+                error += " Active lock held by PID #{last_lock_info[:pid]}."
+              end
+              result[:error] = error
+            end
+
+            result
+          end
+
+          # Execute command once without retry logic
+          # @param command_parts [Array<String>] Command parts to execute
+          # @param timeout [Integer] Timeout in seconds
+          # @param env [Hash] Optional environment variables
+          # @return [Hash] Result with output, error, and success status
+          def execute_once(command_parts, timeout:, env:)
+            # Using Timeout to prevent hanging on network issues or stuck git operations
+            Timeout.timeout(timeout) do
+              # Using Open3.capture3 to avoid shell injection
+              # Arguments are passed directly as array elements, not through shell
+              # If env is provided, prepend it to the command (Open3 convention)
+              args = env ? [env, *command_parts] : command_parts
+              stdout, stderr, status = Open3.capture3(*args)
+
+              {
+                success: status.success?,
+                output: stdout,
+                error: stderr,
+                exit_code: status.exitstatus
+              }
+            end
+          rescue Timeout::Error
+            {
+              success: false,
+              output: "",
+              error: "Command timed out after #{timeout} seconds: #{command_parts.join(" ")}",
+              exit_code: -1
+            }
+          rescue => e
+            # Log backtrace for debugging when DEBUG environment variable is set
+            # This helps diagnose implementation bugs vs command failures
+            warn e.backtrace.join("\n") if ENV["DEBUG"]
+            {
+              success: false,
+              output: "",
+              error: e.message,
+              exit_code: -1
+            }
+          end
+
+          public
+
+          # Execute git diff command
+          # @param args [Array<String>] Arguments to pass to git diff
+          # @param raise_on_error [Boolean] If true, raises GitError on failure
+          # @return [String] Diff output (empty string if no changes, raises on error if raise_on_error)
+          def git_diff(*args, raise_on_error: false)
+            result = execute("git", "diff", *args)
+            if result[:success]
+              result[:output]
+            elsif raise_on_error
+              raise Ace::Git::GitError, "git diff failed: #{result[:error]}"
+            else
+              ""
+            end
+          end
+
+          # Get staged changes
+          # @return [String] Diff of staged changes
+          def staged_diff
+            result = execute("git", "diff", "--cached")
+            result[:success] ? result[:output] : ""
+          end
+
+          # Get working directory changes
+          # @return [String] Diff of working directory changes
+          def working_diff
+            result = execute("git", "diff")
+            result[:success] ? result[:output] : ""
+          end
+
+          # Check if we're in a git repository
+          # @return [Boolean] True if in a git repository
+          def in_git_repo?
+            result = execute("git", "rev-parse", "--git-dir")
+            result[:success]
+          end
+
+          # Get current branch name or commit SHA if detached
+          # @return [String, nil] Current branch name, commit SHA (if detached), or nil on error
+          def current_branch
+            result = execute("git", "rev-parse", "--abbrev-ref", "HEAD")
+            return nil unless result[:success]
+
+            branch = result[:output].strip
+            return branch unless branch == "HEAD"
+
+            # Detached HEAD - return commit SHA instead
+            sha_result = execute("git", "rev-parse", "HEAD")
+            sha_result[:success] ? sha_result[:output].strip : nil
+          end
+
+          # Get repository root path
+          # @return [String, nil] Repository root path or nil on error
+          def repo_root
+            result = execute_once(["git", "rev-parse", "--show-toplevel"], timeout: Ace::Git.git_timeout, env: nil)
+            result[:success] ? result[:output].strip : nil
+          end
+
+          # Get remote tracking branch
+          # @return [String, nil] Remote tracking branch or nil
+          def tracking_branch
+            result = execute("git", "rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}")
+            result[:success] ? result[:output].strip : nil
+          end
+
+          # Get list of changed files
+          # @param range [String] Git range to check
+          # @return [Array<String>] List of changed file paths
+          def changed_files(range = nil)
+            range = "origin/main...HEAD" if range.nil? && ref_exists?("origin/main")
+            args = ["git", "diff", "--name-only"]
+            args << range if range && !range.empty?
+
+            result = execute(*args)
+            return [] unless result[:success]
+
+            result[:output].split("\n").map(&:strip).reject(&:empty?)
+          end
+
+          # Check if there are unstaged changes
+          # @return [Boolean] True if there are unstaged changes
+          def has_unstaged_changes?
+            !working_diff.strip.empty?
+          end
+
+          # Check if there are staged changes
+          # @return [Boolean] True if there are staged changes
+          def has_staged_changes?
+            !staged_diff.strip.empty?
+          end
+
+          # Check if there are untracked changes
+          # @return [Boolean] True if there are untracked files
+          def has_untracked_changes?
+            result = execute("git", "ls-files", "--others", "--exclude-standard")
+            result[:success] && !result[:output].strip.empty?
+          end
+
+          # Check whether a git reference exists in the repository.
+          #
+          # @param ref [String] Git ref to validate
+          # @return [Boolean] True if ref resolves, false otherwise
+          def ref_exists?(ref)
+            return false if ref.nil? || ref.strip.empty?
+
+            result = execute("git", "rev-parse", "--verify", "#{ref}^{}")
+            result[:success]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require "date"
+
+module Ace
+  module Git
+    module Atoms
+      # Pure functions for resolving dates to git commits
+      # Migrated from ace-git-diff
+      module DateResolver
+        class << self
+          # Resolve a since parameter to a git commit reference
+          # @param since [String, Date] Date string, relative time, or commit SHA
+          # @param executor [Module] Command executor module (default: CommandExecutor)
+          # @return [String] Git commit reference
+          def resolve_since_to_commit(since, executor: CommandExecutor)
+            return "HEAD" if since.nil? || since.empty?
+
+            # If it looks like a commit SHA, use as-is
+            return since if commit_sha?(since)
+
+            # If it looks like a git ref (branch, tag), use as-is
+            return since if git_ref?(since)
+
+            # It's a date or relative time - find the first commit since that date
+            first_commit = find_first_commit_since(since, executor)
+            return since unless first_commit # Fallback to date string
+
+            # Get parent of first commit to include all changes since date
+            parent = get_parent_commit(first_commit, executor)
+            parent || first_commit
+          end
+
+          # Check if a string looks like a commit SHA
+          # @param ref [String] Reference to check
+          # @return [Boolean] True if looks like a commit SHA
+          def commit_sha?(ref)
+            !!(ref =~ /^[0-9a-f]{7,40}$/i)
+          end
+
+          # Check if a string looks like a git reference (branch, tag, etc)
+          # @param ref [String] Reference to check
+          # @return [Boolean] True if looks like a git ref
+          def git_ref?(ref)
+            # Check for common ref patterns:
+            # - refs/heads/*, refs/remotes/*, refs/tags/*
+            # - origin/main, upstream/develop, etc
+            # - HEAD, HEAD~1, HEAD^, etc
+            !!(ref =~ %r{^(refs/|origin/|upstream/|HEAD)}) ||
+              !!(ref =~ /^[A-Za-z][A-Za-z0-9_\-\/]*$/) # Branch or tag name
+          end
+
+          # Parse relative time strings (e.g., "7d", "1 week ago", "2 months")
+          # @param time_str [String] Time string to parse
+          # @return [String, nil] ISO date string or nil if can't parse
+          def parse_relative_time(time_str)
+            case time_str
+            when /^(\d+)d$/ # e.g., "7d"
+              days = Regexp.last_match(1).to_i
+              (Date.today - days).strftime("%Y-%m-%d")
+            when /^(\d+)\s*days?\s*ago$/i # e.g., "7 days ago"
+              days = Regexp.last_match(1).to_i
+              (Date.today - days).strftime("%Y-%m-%d")
+            when /^(\d+)\s*weeks?\s*ago$/i # e.g., "1 week ago"
+              weeks = Regexp.last_match(1).to_i
+              (Date.today - (weeks * 7)).strftime("%Y-%m-%d")
+            when /^(\d+)\s*months?\s*ago$/i # e.g., "2 months ago"
+              months = Regexp.last_match(1).to_i
+              (Date.today << months).strftime("%Y-%m-%d")
+            else
+              # Try to parse as date string
+              begin
+                Date.parse(time_str).strftime("%Y-%m-%d")
+              rescue ArgumentError
+                nil
+              end
+            end
+          end
+
+          # Format since parameter for git commands
+          # @param since [String, Date, Time] Since parameter
+          # @return [String] Formatted since string
+          def format_since(since)
+            case since
+            when Date
+              since.strftime("%Y-%m-%d")
+            when Time
+              since.strftime("%Y-%m-%d")
+            when String
+              # Try to parse relative time
+              parsed = parse_relative_time(since)
+              parsed || since
+            else
+              (Date.today - 7).strftime("%Y-%m-%d")
+            end
+          end
+
+          private
+
+          # Find the first commit since a given date
+          # @param since [String, nil] Date string or relative time
+          # @param executor [Module] Command executor
+          # @return [String, nil] First commit SHA or nil
+          def find_first_commit_since(since, executor)
+            # Handle nil/empty since parameter
+            return nil if since.nil? || since.to_s.strip.empty?
+
+            # Parse relative time if needed
+            date_str = parse_relative_time(since) || since
+
+            result = executor.execute("git", "log", "--since=#{date_str}", "--format=%H", "--reverse", "--all")
+            return nil unless result[:success]
+
+            commits = result[:output].strip.split("\n")
+            commits.first
+          end
+
+          # Get the parent commit of a given commit
+          def get_parent_commit(commit, executor)
+            result = executor.execute("git", "rev-parse", "#{commit}~1")
+            result[:success] ? result[:output].strip : nil
+          rescue
+            nil
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Ace
+  module Git
+    module Atoms
+      # Parse `git diff --numstat` output into structured entries.
+      module DiffNumstatParser
+        class << self
+          def parse(numstat_output)
+            return [] if numstat_output.nil? || numstat_output.strip.empty?
+
+            numstat_output.split("\n").map { |line| parse_line(line) }.compact
+          end
+
+          private
+
+          def parse_line(line)
+            return nil if line.nil? || line.strip.empty?
+
+            additions_raw, deletions_raw, raw_path = line.split("\t", 3)
+            return nil if raw_path.nil?
+
+            rename_info = parse_rename(raw_path)
+            binary = additions_raw == "-" && deletions_raw == "-"
+
+            {
+              path: rename_info[:to],
+              display_path: rename_info[:display],
+              additions: binary ? nil : additions_raw.to_i,
+              deletions: binary ? nil : deletions_raw.to_i,
+              binary: binary,
+              rename_from: rename_info[:from],
+              rename_to: rename_info[:to]
+            }
+          end
+
+          def parse_rename(path)
+            if path.include?(" => ")
+              from, to = expand_brace_rename(path)
+              return {
+                from: from,
+                to: to,
+                display: "#{from} -> #{to}"
+              }
+            end
+
+            {
+              from: nil,
+              to: path,
+              display: path
+            }
+          end
+
+          # Handles brace syntax: foo/{old.rb => new.rb}
+          def expand_brace_rename(path)
+            # Supports empty side of brace rename, e.g.:
+            #   tasks/{ => _archive}/file.md
+            brace_match = path.match(/\A(.*)\{(.*) => (.*)\}(.*)\z/)
+            if brace_match
+              prefix = brace_match[1]
+              from_inner = brace_match[2]
+              to_inner = brace_match[3]
+              suffix = brace_match[4]
+              return [
+                build_renamed_path(prefix, from_inner, suffix),
+                build_renamed_path(prefix, to_inner, suffix)
+              ]
+            end
+
+            # Fallback for unbraced exact renames: old.rb => new.rb (no common prefix/suffix)
+            split = path.split(" => ", 2)
+            [split[0], split[1]]
+          end
+
+          def build_renamed_path(prefix, inner, suffix)
+            "#{prefix}#{inner}#{suffix}".squeeze("/")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module Ace
+  module Git
+    module Atoms
+      # Pure functions for parsing diff output
+      # Migrated from ace-git-diff
+      module DiffParser
+        class << self
+          # Estimate the size of a diff in lines
+          # @param diff [String] The diff content
+          # @return [Integer] Number of lines
+          def count_lines(diff)
+            return 0 if diff.nil? || diff.empty?
+
+            diff.count("\n") + 1
+          end
+
+          # Count significant changes (additions and deletions)
+          # @param diff [String] The diff content
+          # @return [Hash] Statistics about the diff
+          def count_changes(diff)
+            return {additions: 0, deletions: 0, files: 0, total_changes: 0} if diff.nil? || diff.empty?
+
+            additions = 0
+            deletions = 0
+            files = 0
+
+            diff.split("\n").each do |line|
+              if file_header_line?(line)
+                files += 1
+              elsif line.start_with?("+") && !line.start_with?("+++")
+                additions += 1
+              elsif line.start_with?("-") && !line.start_with?("---")
+                deletions += 1
+              end
+            end
+
+            {
+              additions: additions,
+              deletions: deletions,
+              files: files,
+              total_changes: additions + deletions
+            }
+          end
+
+          # Check if diff exceeds a size limit
+          # @param diff [String] The diff content
+          # @param max_lines [Integer] Maximum allowed lines
+          # @return [Boolean] True if diff exceeds limit
+          def exceeds_limit?(diff, max_lines)
+            count_lines(diff) > max_lines
+          end
+
+          # Extract list of files from diff
+          # @param diff [String] The diff content
+          # @return [Array<String>] List of file paths
+          def extract_files(diff)
+            return [] if diff.nil? || diff.empty?
+
+            files = []
+            diff.split("\n").each do |line|
+              if line.start_with?("diff --git")
+                # Extract file path from "diff --git a/path b/path"
+                if line =~ /^diff --git a\/(.+) b\/(.+)$/
+                  files << Regexp.last_match(2) # Use 'b/' path (new file)
+                end
+              end
+            end
+
+            files.uniq
+          end
+
+          # Parse diff into structured data
+          # @param diff [String] The diff content
+          # @return [Hash] Parsed diff data
+          def parse(diff)
+            {
+              content: diff,
+              stats: count_changes(diff),
+              files: extract_files(diff),
+              line_count: count_lines(diff),
+              empty: diff.nil? || diff.strip.empty?
+            }
+          end
+
+          # Check if diff contains any actual changes
+          # @param diff [String] The diff content
+          # @return [Boolean] True if diff has changes
+          def has_changes?(diff)
+            return false if diff.nil? || diff.strip.empty?
+
+            # Check for addition or deletion lines
+            diff.split("\n").any? do |line|
+              (line.start_with?("+") && !line.start_with?("+++")) ||
+                (line.start_with?("-") && !line.start_with?("---"))
+            end
+          end
+
+          private
+
+          # Check if a line is a file header (starts a new file in diff)
+          def file_header_line?(line)
+            line.start_with?("diff --git")
+          end
+        end
+      end
+    end
+  end
+end