ace-git 0.18.0

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

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+module Ace
+  module Git
+    module Atoms
+      # Pure functions for pattern matching and filtering
+      # Migrated from ace-git-diff
+      module PatternFilter
+        # Maximum cache size to prevent unbounded memory growth in long-running processes
+        MAX_CACHE_SIZE = 100
+
+        # Cache for compiled regex patterns (performance optimization)
+        # Key: sorted pattern array joined by "|", Value: Array of compiled Regexp
+        # Uses FIFO eviction: oldest inserted entry removed when cache exceeds MAX_CACHE_SIZE
+        # Note: Ruby hashes preserve insertion order, so shift removes the oldest entry
+        @pattern_cache = {}
+        @cache_mutex = Mutex.new
+
+        class << self
+          # Convert glob patterns to regex patterns
+          # Uses caching for performance when same patterns are used repeatedly
+          # @param glob_patterns [Array<String>] Glob patterns like "test/**/*"
+          # @return [Array<Regexp>] Regex patterns for matching
+          def glob_to_regex(glob_patterns)
+            return [] if glob_patterns.nil? || glob_patterns.empty?
+
+            # Generate cache key from sorted patterns
+            cache_key = glob_patterns.sort.join("|")
+
+            # Check cache first (thread-safe read)
+            PatternFilter.instance_variable_get(:@cache_mutex).synchronize do
+              cache = PatternFilter.instance_variable_get(:@pattern_cache)
+              return cache[cache_key] if cache.key?(cache_key)
+
+              # Evict oldest entry if cache is full (FIFO eviction)
+              cache.shift if cache.size >= MAX_CACHE_SIZE
+
+              # Compile patterns and cache
+              patterns = glob_patterns.map { |pattern| compile_glob_pattern(pattern) }
+              cache[cache_key] = patterns
+              patterns
+            end
+          end
+
+          # Clear the pattern cache (mainly for testing)
+          def clear_cache!
+            PatternFilter.instance_variable_get(:@cache_mutex).synchronize do
+              PatternFilter.instance_variable_get(:@pattern_cache).clear
+            end
+          end
+
+          # Check if a file path should be excluded based on patterns
+          # @param file_path [String] Path to check
+          # @param patterns [Array<Regexp>] Regex patterns to match against
+          # @return [Boolean] True if path matches any exclude pattern
+          def should_exclude?(file_path, patterns)
+            return false if file_path.nil? || file_path.empty?
+            return false if patterns.nil? || patterns.empty?
+
+            patterns.any? { |pattern| file_path.match?(pattern) }
+          end
+
+          # Check if a line is a file header in git diff format
+          # @param line [String] Line to check
+          # @return [Boolean] True if line is a file header
+          def file_header?(line)
+            return false if line.nil? || line.empty?
+
+            line.start_with?("diff --git", "+++", "---") ||
+              line.match?(/^index [a-f0-9]+\.\.[a-f0-9]+/)
+          end
+
+          # Extract file path from diff header line
+          # @param line [String] Diff header line
+          # @return [String] Extracted file path or empty string
+          def extract_file_path(line)
+            return "" if line.nil? || line.empty?
+
+            case line
+            when /^diff --git a\/(.+) b\/(.+)$/
+              Regexp.last_match(2) # Use the 'b/' path (new file path)
+            when /^\+\+\+ b\/(.+)$/
+              Regexp.last_match(1)
+            when /^--- a\/(.+)$/
+              Regexp.last_match(1)
+            else
+              ""
+            end
+          end
+
+          # Filter paths from diff output based on exclude patterns
+          # @param diff [String] The diff content
+          # @param exclude_patterns [Array<Regexp>] Patterns to exclude
+          # @return [String] Filtered diff content
+          def filter_diff_by_patterns(diff, exclude_patterns)
+            return "" if diff.nil? || diff.empty?
+            return diff if exclude_patterns.nil? || exclude_patterns.empty?
+
+            lines = diff.split("\n")
+            filtered_lines = []
+            skip_until_next_file = false
+
+            lines.each do |line|
+              # Check if this is a file header
+              if file_header?(line)
+                file_path = extract_file_path(line)
+                if should_exclude?(file_path, exclude_patterns)
+                  skip_until_next_file = true
+                else
+                  skip_until_next_file = false
+                  filtered_lines << line
+                end
+              elsif !skip_until_next_file
+                filtered_lines << line
+              end
+            end
+
+            filtered_lines.join("\n")
+          end
+
+          # Match a path against include patterns (glob)
+          # @param file_path [String] Path to check
+          # @param include_patterns [Array<String>] Glob patterns to include
+          # @return [Boolean] True if path matches any include pattern
+          def matches_include?(file_path, include_patterns)
+            return true if include_patterns.nil? || include_patterns.empty?
+            return false if file_path.nil? || file_path.empty?
+
+            regex_patterns = glob_to_regex(include_patterns)
+            regex_patterns.any? { |pattern| file_path.match?(pattern) }
+          end
+
+          private
+
+          # Compile a single glob pattern to regex
+          # @param pattern [String] Glob pattern
+          # @return [Regexp] Compiled regex
+          def compile_glob_pattern(pattern)
+            # Escape special regex characters except glob wildcards
+            regex_str = Regexp.escape(pattern)
+
+            # Convert escaped glob patterns to regex
+            regex_str = regex_str
+              .gsub('\\*\\*/', ".*")     # **/ → .* (zero or more segments)
+              .gsub('\\*\\*', ".*")       # ** → .* (zero or more segments)
+              .gsub('\\*', "[^/]*")       # * → [^/]* (within segment)
+              .gsub('\\?', ".")           # ? → . (single char)
+
+            # Anchor to start of path
+            Regexp.new("^#{regex_str}")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Ace
+  module Git
+    module Atoms
+      # Parse PR identifiers into structured format
+      #
+      # Supports three formats:
+      # - Simple number: "123"
+      # - Qualified reference: "owner/repo#456"
+      # - GitHub URL: "https://github.com/owner/repo/pull/789"
+      #
+      # Consolidated from ace-bundle PrIdentifierParser
+      module PrIdentifierParser
+        # Parsed PR identifier result
+        ParseResult = Data.define(:number, :repo, :gh_format)
+
+        # Parse a PR identifier string
+        #
+        # Returns nil for nil/empty input (no PR specified), raises ArgumentError for
+        # invalid formats. This design allows callers to distinguish between "no PR"
+        # (nil input -> nil result) and "invalid PR" (bad format -> exception).
+        #
+        # @param input [String, Integer] PR identifier
+        # @return [ParseResult, nil] Parsed identifier with number, repo, and gh_format,
+        #   or nil if input is nil/empty
+        # @raise [ArgumentError] if identifier format is invalid (non-empty but malformed)
+        #
+        # @example Simple number
+        #   parse(123)
+        #   # => ParseResult(number: "123", repo: nil, gh_format: "123")
+        #
+        # @example Qualified reference
+        #   parse("owner/repo#456")
+        #   # => ParseResult(number: "456", repo: "owner/repo", gh_format: "owner/repo#456")
+        #
+        # @example GitHub URL
+        #   parse("https://github.com/owner/repo/pull/789")
+        #   # => ParseResult(number: "789", repo: "owner/repo", gh_format: "owner/repo#789")
+        #
+        # @example Nil/empty input
+        #   parse(nil)   # => nil
+        #   parse("")    # => nil
+        #   parse("  ")  # => nil
+        # Maximum length for PR identifier to prevent ReDoS attacks
+        # GitHub URLs are typically under 200 chars, this provides generous margin
+        MAX_IDENTIFIER_LENGTH = 256
+
+        def self.parse(input)
+          return nil if input.nil?
+
+          input_str = input.to_s.strip
+          return nil if input_str.empty?
+
+          # Validate length to prevent ReDoS attacks on regex patterns
+          if input_str.length > MAX_IDENTIFIER_LENGTH
+            raise ArgumentError, "PR identifier too long (max #{MAX_IDENTIFIER_LENGTH} characters)"
+          end
+
+          case input_str
+          when /^(\d+)$/
+            # Simple PR number: "123"
+            number = ::Regexp.last_match(1)
+            # Reject zero: GitHub PR numbers are positive integers starting from 1
+            raise ArgumentError, "Invalid PR identifier format: #{input_str}" if number.to_i.zero?
+            # Normalize to canonical form (strip leading zeros) for consistent gh_format
+            canonical_number = number.to_i.to_s
+            ParseResult.new(number: canonical_number, repo: nil, gh_format: canonical_number)
+
+          when /^(?<repo>[a-zA-Z0-9_\-.]+\/[a-zA-Z0-9_\-.]+)#(?<number>\d+)$/
+            # Qualified reference: "owner/repo#456"
+            # GitHub owner/repo names: alphanumeric, hyphens, underscores, dots only
+            match = ::Regexp.last_match
+            ParseResult.new(number: match[:number], repo: match[:repo], gh_format: "#{match[:repo]}##{match[:number]}")
+
+          when %r{github\.com/(?<repo>[^/]+/[^/]+)/pull/(?<number>\d+)}
+            # GitHub URL: "https://github.com/owner/repo/pull/789"
+            match = ::Regexp.last_match
+            ParseResult.new(number: match[:number], repo: match[:repo], gh_format: "#{match[:repo]}##{match[:number]}")
+
+          else
+            raise ArgumentError, "Invalid PR identifier format: #{input_str}"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Ace
+  module Git
+    module Atoms
+      # Check repository status: detached HEAD, bare repo, nested worktree
+      # Pure function that uses CommandExecutor for git commands
+      module RepositoryChecker
+        class << self
+          # Check if in a git repository
+          # @param executor [Module] Command executor
+          # @return [Boolean] True if in git repo
+          def in_git_repo?(executor: CommandExecutor)
+            executor.in_git_repo?
+          end
+
+          # Check if HEAD is detached
+          # @param executor [Module] Command executor
+          # @return [Boolean] True if HEAD is detached
+          def detached_head?(executor: CommandExecutor)
+            return false unless in_git_repo?(executor: executor)
+
+            result = executor.execute("git", "symbolic-ref", "-q", "HEAD")
+            # If symbolic-ref fails, HEAD is detached
+            !result[:success]
+          end
+
+          # Check if repository is bare
+          # @param executor [Module] Command executor
+          # @return [Boolean] True if bare repository
+          def bare_repository?(executor: CommandExecutor)
+            return false unless in_git_repo?(executor: executor)
+
+            result = executor.execute("git", "rev-parse", "--is-bare-repository")
+            result[:success] && result[:output].strip == "true"
+          end
+
+          # Check if current directory is in a git worktree (not main repo)
+          # @param executor [Module] Command executor
+          # @return [Boolean] True if in worktree
+          def in_worktree?(executor: CommandExecutor)
+            return false unless in_git_repo?(executor: executor)
+
+            # Get git directory and common directory
+            git_dir = executor.execute("git", "rev-parse", "--git-dir")
+            return false unless git_dir[:success]
+
+            git_path = git_dir[:output].strip
+
+            # In worktrees, git-dir contains "worktrees/"
+            git_path.include?("/worktrees/")
+          end
+
+          # Get repository type description
+          # @param executor [Module] Command executor
+          # @return [Symbol] :normal, :detached, :bare, :worktree, :not_git
+          def repository_type(executor: CommandExecutor)
+            return :not_git unless in_git_repo?(executor: executor)
+            return :bare if bare_repository?(executor: executor)
+            return :worktree if in_worktree?(executor: executor)
+            return :detached if detached_head?(executor: executor)
+
+            :normal
+          end
+
+          # Get human-readable repository status
+          # @param executor [Module] Command executor
+          # @return [String] Status description
+          def status_description(executor: CommandExecutor)
+            case repository_type(executor: executor)
+            when :normal
+              "normal repository"
+            when :detached
+              "detached HEAD state"
+            when :bare
+              "bare repository"
+            when :worktree
+              "git worktree"
+            else
+              "not a git repository"
+            end
+          end
+
+          # Check if repository is in a usable state for typical git operations
+          # @param executor [Module] Command executor
+          # @return [Boolean] True if usable
+          def usable?(executor: CommandExecutor)
+            return false unless in_git_repo?(executor: executor)
+            return false if bare_repository?(executor: executor)
+
+            true
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Ace
+  module Git
+    module Atoms
+      # Detect repository state: clean, dirty, rebasing, merging
+      # Pure function that uses CommandExecutor for git commands
+      module RepositoryStateDetector
+        class << self
+          # Detect current repository state
+          # @param executor [Module] Command executor (default: CommandExecutor)
+          # @return [Symbol] One of :clean, :dirty, :rebasing, :merging, :unknown
+          def detect(executor: CommandExecutor)
+            return :unknown unless executor.in_git_repo?
+
+            # Check for rebase in progress
+            return :rebasing if rebasing?(executor: executor)
+
+            # Check for merge in progress
+            return :merging if merging?(executor: executor)
+
+            # Check for uncommitted changes
+            return :dirty if dirty?(executor: executor)
+
+            :clean
+          end
+
+          # Check if repository is in a clean state
+          # @param executor [Module] Command executor
+          # @return [Boolean] True if clean
+          def clean?(executor: CommandExecutor)
+            detect(executor: executor) == :clean
+          end
+
+          # Check if repository has uncommitted changes
+          # @param executor [Module] Command executor
+          # @return [Boolean] True if dirty
+          def dirty?(executor: CommandExecutor)
+            # Check git status for changes
+            result = executor.execute("git", "status", "--porcelain")
+            return false unless result[:success]
+
+            !result[:output].strip.empty?
+          end
+
+          # Check if repository is in rebase state
+          # @param executor [Module] Command executor
+          # @return [Boolean] True if rebasing
+          def rebasing?(executor: CommandExecutor)
+            # Check for rebase-apply or rebase-merge directories
+            git_dir = executor.execute("git", "rev-parse", "--git-dir")
+            return false unless git_dir[:success]
+
+            git_path = git_dir[:output].strip
+            File.exist?(File.join(git_path, "rebase-apply")) ||
+              File.exist?(File.join(git_path, "rebase-merge"))
+          end
+
+          # Check if repository is in merge state
+          # @param executor [Module] Command executor
+          # @return [Boolean] True if merging
+          def merging?(executor: CommandExecutor)
+            # Check for MERGE_HEAD file
+            git_dir = executor.execute("git", "rev-parse", "--git-dir")
+            return false unless git_dir[:success]
+
+            git_path = git_dir[:output].strip
+            File.exist?(File.join(git_path, "MERGE_HEAD"))
+          end
+
+          # Get human-readable state description
+          # @param executor [Module] Command executor
+          # @return [String] State description
+          def state_description(executor: CommandExecutor)
+            case detect(executor: executor)
+            when :clean
+              "clean (no uncommitted changes)"
+            when :dirty
+              "dirty (uncommitted changes)"
+            when :rebasing
+              "rebasing in progress"
+            when :merging
+              "merge in progress"
+            else
+              "unknown state"
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,247 @@
+# frozen_string_literal: true
+
+module Ace
+  module Git
+    module Atoms
+      # Pure functions for detecting and cleaning stale git index lock files
+      #
+      # Git index.lock files can become stale when:
+      # - Previous git operations were interrupted (Ctrl+C, crashes, timeouts)
+      # - Agents are blocked mid-operation leaving orphan lock files
+      #
+      # A stale lock is one that hasn't been modified recently (>10 seconds by default),
+      # indicating the owning process is no longer active.
+      #
+      # Lock File Format:
+      # Git lock files contain the PID and hostname of the process that created them.
+      # We use PID-based detection (checking if owning process is still running) as
+      # the primary method, with age-based detection as a fallback for edge cases
+      # (remote mounts, containers where PID check may not work).
+      module StaleLockCleaner
+        class << self
+          # Extract PID from a git lock file
+          #
+          # Git lock files contain the PID on the first line, optionally followed by hostname.
+          # @param lock_path [String] Path to the lock file
+          # @return [Integer, nil] PID if present and positive, otherwise nil
+          def lock_pid(lock_path)
+            content = File.read(lock_path)
+            pid = content.to_s.split.first.to_i
+            (pid > 0) ? pid : nil
+          rescue Errno::ENOENT
+            nil
+          rescue
+            nil
+          end
+
+          # Check if a process exists (signal 0 = check only)
+          # @param pid [Integer] Process ID
+          # @return [Boolean] true if process exists, false if not
+          def process_active?(pid)
+            Process.kill(0, pid)
+            true
+          rescue Errno::ESRCH
+            false
+          rescue Errno::EPERM
+            true
+          end
+
+          # Check if a lock file is stale (older than threshold)
+          #
+          # @param lock_path [String] Path to the lock file
+          # @param threshold_seconds [Integer] Age threshold in seconds (default: 10)
+          # @return [Boolean] true if the lock file is stale
+          #
+          # @example Fresh lock (active process)
+          #   File.utime(Time.now - 30, Time.now - 30, lock_path)
+          #   stale?(lock_path, 60)  # => false
+          #
+          # @example Stale lock (orphaned)
+          #   File.utime(Time.now - 120, Time.now - 120, lock_path)
+          #   stale?(lock_path, 60)  # => true
+          def stale?(lock_path, threshold_seconds = 10)
+            age_seconds = Time.now - File.mtime(lock_path)
+            age_seconds > threshold_seconds
+          rescue Errno::ENOENT
+            false
+          end
+
+          # Check if lock file is orphaned (owning process no longer exists)
+          #
+          # Git lock files contain the PID of the process that created them.
+          # If that process no longer exists, the lock is orphaned and safe to delete.
+          #
+          # @param lock_path [String] Path to the lock file
+          # @return [Boolean] true if the lock is orphaned (PID doesn't exist)
+          #
+          # @example Orphaned lock (process crashed)
+          #   File.write(lock_path, "99999")  # Non-existent PID
+          #   orphaned?(lock_path)  # => true
+          #
+          # @example Active lock (process running)
+          #   File.write(lock_path, Process.pid.to_s)
+          #   orphaned?(lock_path)  # => false
+          def orphaned?(lock_path)
+            pid = lock_pid(lock_path)
+            return false unless pid
+
+            !process_active?(pid)
+          end
+
+          # Find index.lock file for a repository
+          #
+          # @param repo_path [String] Path to the git repository
+          # @return [String, nil] Path to the index.lock file or nil if not found
+          #
+          # @example In main repo
+          #   find_lock_file("/path/to/repo")
+          #   # => "/path/to/repo/.git/index.lock"
+          #
+          # @example In worktree
+          #   find_lock_file("/path/to/worktree")
+          #   # => "/path/to/worktree/.git/index.lock"
+          def find_lock_file(repo_path)
+            return nil if repo_path.nil? || repo_path.empty?
+
+            # First try to find .git directory
+            git_dir = File.join(repo_path, ".git")
+
+            # If .git is a file (worktree), read the gitdir path
+            if File.file?(git_dir)
+              git_file_path = git_dir
+              git_dir_content = File.read(git_file_path)
+              # Worktree .git files contain: "gitdir: /path/to/main/.git/worktrees/..."
+              # Use greedy match to capture full path including spaces, trim trailing whitespace
+              if git_dir_content =~ /^gitdir:\s*(.+)\s*$/
+                raw_git_dir = Regexp.last_match(1).strip
+                # Handle relative paths by expanding from .git file location
+                git_dir = File.expand_path(raw_git_dir, File.dirname(git_file_path))
+              else
+                return nil
+              end
+            end
+
+            # Check if git directory exists
+            return nil unless File.directory?(git_dir)
+
+            # Return path to index.lock
+            lock_path = File.join(git_dir, "index.lock")
+            File.exist?(lock_path) ? lock_path : nil
+          rescue
+            nil
+          end
+
+          # Clean a lock file if it is orphaned (dead PID) or stale (old age)
+          #
+          # Uses PID-based detection first (instant), then falls back to age-based
+          # detection for edge cases (remote mounts, containers).
+          #
+          # @param repo_path [String] Path to the git repository
+          # @param threshold_seconds [Integer] Age threshold for stale detection
+          # @return [Hash] Result with :success, :cleaned, :message
+          #
+          # @example Cleaned orphaned lock (dead PID)
+          #   clean("/path/to/repo", 60)
+          #   # => { success: true, cleaned: true, message: "Removed orphaned lock..." }
+          #
+          # @example Cleaned stale lock (old age)
+          #   clean("/path/to/repo", 60)
+          #   # => { success: true, cleaned: true, message: "Removed stale lock..." }
+          #
+          # @example No lock to clean
+          #   clean("/path/to/repo", 60)
+          #   # => { success: true, cleaned: false, message: "No lock found" }
+          #
+          # @example Lock is active (PID running, fresh)
+          #   clean("/path/to/repo", 60)
+          #   # => { success: true, cleaned: false, message: "Lock is active..." }
+          def clean(repo_path, threshold_seconds = 10)
+            lock_path = find_lock_file(repo_path)
+
+            if lock_path.nil?
+              return {success: true, cleaned: false, status: :missing, pid: nil, age_seconds: nil,
+                      message: "No lock file found"}
+            end
+
+            # Security check: ensure lock file is a regular file, not a symlink
+            # This prevents accidental deletion of symlink targets, which could be
+            # exploited to cause data loss or security issues.
+            if File.symlink?(lock_path)
+              return {success: false, cleaned: false, status: :symlink, pid: nil, age_seconds: nil,
+                      message: "Lock file is a symlink, refusing to delete: #{lock_path}"}
+            end
+
+            # Safety check: ensure it's a regular file (not directory or device)
+            unless File.file?(lock_path)
+              return {success: false, cleaned: false, status: :invalid, pid: nil, age_seconds: nil,
+                      message: "Lock path is not a regular file: #{lock_path}"}
+            end
+
+            pid = lock_pid(lock_path)
+            age_seconds = begin
+              Time.now - File.mtime(lock_path)
+            rescue
+              nil
+            end
+
+            pid_active = pid ? process_active?(pid) : false
+
+            # Check PID-based activity first
+            if pid_active
+              return {
+                success: true,
+                cleaned: false,
+                status: :active,
+                pid: pid,
+                age_seconds: age_seconds,
+                message: "Lock file is active (PID running, < #{threshold_seconds}s old)"
+              }
+            end
+
+            # Orphaned PID should be removed immediately
+            if pid && !pid_active
+              File.delete(lock_path)
+              return {
+                success: true,
+                cleaned: true,
+                status: :orphaned,
+                pid: pid,
+                age_seconds: age_seconds,
+                message: "Removed orphaned lock file (dead PID): #{lock_path}"
+              }
+            end
+
+            # Fallback to age-based stale detection
+            if stale?(lock_path, threshold_seconds)
+              File.delete(lock_path)
+              return {
+                success: true,
+                cleaned: true,
+                status: :stale,
+                pid: pid,
+                age_seconds: age_seconds,
+                message: "Removed stale lock file: #{lock_path}"
+              }
+            end
+
+            {
+              success: true,
+              cleaned: false,
+              status: :unknown,
+              pid: pid,
+              age_seconds: age_seconds,
+              message: "Lock file present but status unclear (< #{threshold_seconds}s old)"
+            }
+          rescue Errno::ENOENT
+            # Handle TOCTOU race: lock file was deleted between check and delete
+            {success: true, cleaned: false, status: :missing, pid: nil, age_seconds: nil,
+             message: "Lock file already removed"}
+          rescue => e
+            {success: false, cleaned: false, status: :error, pid: nil, age_seconds: nil,
+             message: "Failed to clean lock: #{e.message}"}
+          end
+        end
+      end
+    end
+  end
+end