ace-git-commit 0.23.0

data/lib/ace/git_commit/molecules/path_resolver.rb

@@ -0,0 +1,365 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+module Ace
+  module GitCommit
+    module Molecules
+      # PathResolver handles path resolution and filtering for commits
+      class PathResolver
+        attr_reader :last_error
+
+        # Status codes for renames and copies in git porcelain format
+        RENAME_STATUS = "R"
+        COPY_STATUS = "C"
+
+        private_constant :RENAME_STATUS, :COPY_STATUS
+
+        def initialize(git_executor)
+          @git = git_executor
+          @last_error = nil
+        end
+
+        # Resolve paths to actual file lists
+        # Expands directories, glob patterns to files within them
+        # @param paths [Array<String>] Paths (files, directories, or glob patterns)
+        # @return [Array<String>] List of files
+        def resolve_paths(paths)
+          return [] if paths.nil? || paths.empty?
+
+          resolved = []
+          paths.each do |path|
+            if glob_pattern?(path)
+              # Expand glob pattern to matching tracked files
+              files = expand_glob_pattern(path)
+              resolved.concat(files)
+            elsif File.directory?(path)
+              # Get all tracked files in directory
+              files = files_in_path(path)
+              resolved.concat(files)
+            elsif File.exist?(path)
+              # Single file
+              resolved << path
+            else
+              # Path doesn't exist - we'll validate later
+              resolved << path
+            end
+          end
+
+          resolved.uniq.sort
+        end
+
+        # Filter files to only those within specified paths
+        # @param all_files [Array<String>] All files
+        # @param allowed_paths [Array<String>] Allowed paths
+        # @return [Array<String>] Filtered files
+        def filter_by_paths(all_files, allowed_paths)
+          return all_files if allowed_paths.nil? || allowed_paths.empty?
+
+          all_files.select do |file|
+            allowed_paths.any? { |path| file_in_path?(file, path) }
+          end
+        end
+
+        # Get all tracked files within specified path
+        # @param path [String] Path to search
+        # @return [Array<String>] List of tracked files
+        def files_in_path(path)
+          result = @git.execute("ls-files", path)
+          result.strip.split("\n").reject(&:empty?)
+        rescue GitError => e
+          @last_error = e.message
+          []
+        end
+
+        # Get modified files within specified paths
+        # @param paths [Array<String>] Paths to check
+        # @param staged [Boolean] Check staged or unstaged changes
+        # @return [Array<String>] Modified files
+        def modified_files_in_paths(paths, staged: false)
+          return [] if paths.nil? || paths.empty?
+
+          args = ["diff", "--name-only"]
+          args << "--cached" if staged
+
+          modified = []
+          paths.each do |path|
+            result = @git.execute(*args, path)
+            files = result.strip.split("\n").reject(&:empty?)
+            modified.concat(files)
+          end
+
+          modified.uniq.sort
+        rescue GitError => e
+          @last_error = e.message
+          []
+        end
+
+        # Validate that paths exist or have git changes (deleted/renamed files)
+        # @param paths [Array<String>] Paths to validate
+        # @return [Hash] Validation result with :valid and :invalid paths
+        def validate_paths(paths)
+          return {valid: [], invalid: []} if paths.nil? || paths.empty?
+
+          valid = []
+          invalid = []
+          git_changed_paths = nil # Lazy load
+          git_changed_set = nil   # Pre-computed Set for O(1) lookups
+
+          paths.each do |path|
+            if File.exist?(path)
+              valid << path
+            else
+              # Check if path has git changes (deleted, renamed)
+              git_changed_paths ||= paths_with_git_changes
+              git_changed_set ||= git_changed_paths.map { |p| p.chomp("/") }.to_set
+              if path_has_git_changes?(path, git_changed_paths, git_changed_set)
+                valid << path
+              else
+                invalid << path
+              end
+            end
+          end
+
+          {valid: valid, invalid: invalid}
+        end
+
+        # Check if all paths exist or have git changes (deleted/renamed files)
+        # @param paths [Array<String>] Paths to check
+        # @return [Boolean] True if all paths are valid
+        def all_paths_exist?(paths)
+          return true if paths.nil? || paths.empty?
+          result = validate_paths(paths)
+          result[:invalid].empty?
+        end
+
+        # Check if path contains glob pattern characters
+        # @param path [String] Path to check
+        # @return [Boolean] True if path is a glob pattern
+        def glob_pattern?(path)
+          # Check for common glob metacharacters
+          path.include?("*") || path.include?("?") || path.include?("[") || path.include?("{")
+        end
+
+        # Check if pattern is a simple (non-recursive) glob pattern
+        # Simple globs like *.rb only match at current directory level
+        # @param pattern [String] Pattern to check
+        # @return [Boolean] True if pattern is a simple glob (not recursive)
+        def simple_glob_pattern?(pattern)
+          glob_pattern?(pattern) && !pattern.include?("**")
+        end
+
+        # Suggest a recursive alternative for simple glob patterns
+        # @param pattern [String] Pattern to analyze
+        # @return [String, nil] Suggested recursive pattern, or nil if not applicable
+        def suggest_recursive_pattern(pattern)
+          return nil unless simple_glob_pattern?(pattern)
+
+          # For patterns starting with *, prepend **/ for recursive matching
+          # e.g., "*.rb" -> "**/*.rb"
+          return "**/#{pattern}" if pattern.start_with?("*")
+
+          # For patterns with subdirectory like "dir/*.rb", insert **/ before the glob part
+          # e.g., "dir/*.rb" -> "dir/**/*.rb"
+          if pattern.include?("/")
+            # Find the last directory separator before the glob portion
+            last_slash = pattern.rindex("/")
+            dir_part = pattern[0..last_slash]
+            glob_part = pattern[(last_slash + 1)..]
+            return "#{dir_part}**/#{glob_part}" if glob_part.include?("*")
+          end
+
+          nil
+        end
+
+        # Check if path is within repository boundaries
+        # @param path [String] Path to check
+        # @return [Boolean] True if path is within repository
+        def within_repository?(path)
+          return false unless File.exist?(path)
+
+          expanded = File.expand_path(path)
+          repo_root = @git.execute("rev-parse", "--show-toplevel").strip
+          expanded.start_with?(File.expand_path(repo_root))
+        rescue GitError => e
+          @last_error = e.message
+          false
+        end
+
+        private
+
+        # Expand glob pattern to matching committable files
+        # Uses Dir.glob for filesystem matching, then filters by git-tracked AND untracked files
+        # This includes both tracked files and new untracked files (excludes gitignored)
+        # @param pattern [String] Glob pattern
+        # @return [Array<String>] List of matching committable files
+        def expand_glob_pattern(pattern)
+          # First, expand glob pattern on filesystem
+          filesystem_matches = Dir.glob(pattern, File::FNM_PATHNAME | File::FNM_DOTMATCH)
+
+          # Remove . and .. entries
+          filesystem_matches.reject! { |f| f.end_with?("/.", "/..") }
+
+          # Filter to only files (exclude directories)
+          filesystem_matches.select! { |f| File.file?(f) }
+
+          # Get all committable files (tracked + untracked, excluding gitignored)
+          committable_files = get_committable_files
+
+          # Return intersection: files that match glob AND are committable
+          filesystem_matches & committable_files
+        rescue => e
+          @last_error = "Failed to expand glob pattern '#{pattern}': #{e.message}"
+          []
+        end
+
+        # Get all tracked files in the repository, with caching
+        # @return [Array<String>] List of all git-tracked files
+        def get_all_tracked_files
+          return @tracked_files if @tracked_files
+
+          result = @git.execute("ls-files")
+          @tracked_files = result.strip.split("\n").reject(&:empty?)
+        rescue GitError => e
+          @last_error = e.message
+          @tracked_files = [] # Cache empty array on error
+        end
+
+        # Get untracked files (not ignored), with caching
+        # @return [Array<String>] List of untracked files
+        def get_untracked_files
+          return @untracked_files if @untracked_files
+
+          result = @git.execute("ls-files", "--others", "--exclude-standard")
+          @untracked_files = result.strip.split("\n").reject(&:empty?)
+        rescue GitError => e
+          @last_error = e.message
+          @untracked_files = [] # Cache empty array on error
+        end
+
+        # Get all files that can be committed (tracked + untracked)
+        # This includes tracked files with changes AND new untracked files
+        # @return [Array<String>] List of committable files
+        def get_committable_files
+          tracked = get_all_tracked_files
+          untracked = get_untracked_files
+          (tracked + untracked).uniq
+        end
+
+        # Get list of paths with git changes (deleted, renamed, modified)
+        # Uses -z flag for NUL-terminated output to avoid quoting issues
+        # Memoized to avoid multiple git status calls within the same resolver instance
+        # @return [Array<String>] List of paths with git changes
+        def paths_with_git_changes
+          return @git_changed_paths if @git_changed_paths
+
+          result = @git.execute("status", "--porcelain", "-z")
+          @git_changed_paths = parse_porcelain_z_output(result)
+        rescue GitError => e
+          @last_error = e.message
+          @git_changed_paths = [] # Cache empty array on error
+        end
+
+        # Parse NUL-terminated porcelain format output
+        # Format: XY path\0 or for renames/copies: XY old_path\0new_path\0
+        # @param output [String] Raw git status --porcelain -z output
+        # @return [Array<String>] List of paths
+        def parse_porcelain_z_output(output)
+          paths = []
+          entries = output.split("\0")
+
+          i = 0
+          while i < entries.length
+            entry = entries[i]
+            i += 1
+            next if entry.empty?
+
+            # Status is first 2 chars, then space, then path
+            status = entry[0..1]
+            path = entry[3..-1]
+
+            # Check for rename (R) or copy (C) status - next entry is the new path
+            if status.include?(RENAME_STATUS) || status.include?(COPY_STATUS)
+              paths << path  # Old path
+              paths << entries[i] if i < entries.length  # New path
+              i += 1
+            elsif path
+              paths << path
+            end
+          end
+          paths.compact
+        end
+
+        # Check if a path has git changes
+        # @param path [String] Path to check
+        # @param git_changed_paths [Array<String>] List of paths with git changes
+        # @param changed_set [Set<String>] Pre-computed Set of normalized paths for O(1) lookups
+        # @return [Boolean] True if path has git changes
+        def path_has_git_changes?(path, git_changed_paths, changed_set)
+          # Normalize and strip trailing slashes for consistent comparison
+          normalized = normalize_to_repo_relative(path).chomp("/")
+
+          # Check exact match first (O(1))
+          return true if changed_set.include?(normalized)
+
+          # Check if any changed path is within this directory
+          git_changed_paths.any? do |changed|
+            changed.chomp("/").start_with?("#{normalized}/")
+          end
+        end
+
+        # Normalize path to repo-relative form
+        # Handles: ./path, absolute paths, trailing slashes
+        # @param path [String] Path to normalize
+        # @return [String] Repo-relative path
+        def normalize_to_repo_relative(path)
+          # Remove trailing slashes for normalization
+          clean = path.chomp("/")
+
+          # Remove leading ./ prefix
+          clean = clean.sub(%r{^\./}, "")
+
+          # Handle absolute paths by making them relative to repo root
+          if clean.start_with?("/")
+            repo_root = fetch_repo_root
+            if repo_root
+              if clean == repo_root
+                # Exact repo root match returns '.' for current directory
+                clean = "."
+              elsif clean.start_with?("#{repo_root}/")
+                clean = clean.sub("#{repo_root}/", "")
+              end
+            end
+          end
+
+          clean
+        end
+
+        # Fetch and memoize repository root path
+        # @return [String, nil] Repository root path or nil on error
+        def fetch_repo_root
+          return @repo_root if defined?(@repo_root)
+          @repo_root = @git.execute("rev-parse", "--show-toplevel").strip
+        rescue GitError
+          @repo_root = nil
+        end
+
+        # Check if file is within path
+        # @param file [String] File path
+        # @param path [String] Directory or file path
+        # @return [Boolean] True if file is in path
+        def file_in_path?(file, path)
+          # Handle exact file match
+          return true if file == path
+
+          # Normalize path by removing trailing slash for comparison
+          normalized_path = path.chomp("/")
+
+          # Use Pathname for robust directory checking
+          # Ascend through file's directory hierarchy and check for path match
+          Pathname.new(file).ascend.any? { |p| p.to_s == normalized_path }
+        end
+      end
+    end
+  end
+end

data/lib/ace/git_commit/molecules/split_commit_executor.rb

@@ -0,0 +1,272 @@
+# frozen_string_literal: true
+
+module Ace
+  module GitCommit
+    module Molecules
+      # SplitCommitExecutor performs sequential commits with rollback support
+      class SplitCommitExecutor
+        # Reference the default scope name constant
+        DEFAULT_SCOPE_NAME = Ace::Support::Config::Models::ConfigGroup::DEFAULT_SCOPE_NAME
+        def initialize(git_executor:, diff_analyzer:, file_stager:, message_generator:)
+          @git = git_executor
+          @diff_analyzer = diff_analyzer
+          @file_stager = file_stager
+          @message_generator = message_generator
+        end
+
+        # Execute split commits
+        # @param groups [Array<Models::CommitGroup>] Commit groups
+        # @param options [Models::CommitOptions] Options
+        # @return [Models::SplitCommitResult] Result
+        def execute(groups, options)
+          original_head = current_head
+          result = Models::SplitCommitResult.new(original_head: original_head)
+
+          # Pre-generate all messages in batch if using LLM (includes ordering)
+          if options.use_llm?
+            batch_result = generate_batch_messages(groups, options)
+            ordered_groups, messages = reorder_groups_by_llm(groups, batch_result)
+          else
+            ordered_groups = groups
+            messages = Array.new(groups.length) { options.message }
+          end
+
+          ordered_groups.each_with_index do |group, index|
+            label = group.scope_name.to_s.empty? ? DEFAULT_SCOPE_NAME : group.scope_name
+            puts "[#{index + 1}/#{ordered_groups.length}] Committing #{label} changes..." unless options.quiet
+
+            unless @file_stager.stage_paths(group.files, quiet: options.quiet)
+              error_msg = @file_stager.last_error || "Failed to stage files"
+              result.add_failure(group, error_msg)
+              unless options.quiet
+                warn "✗ Failed to stage files for scope '#{label}':"
+                warn "  #{error_msg}"
+              end
+              rollback_to(original_head, result, options)
+              return result
+            end
+
+            # Check if all files were gitignored - skip commit for this group
+            if @file_stager.all_files_skipped?
+              unless options.quiet
+                puts "✓ No files to commit for scope '#{label}' (all gitignored)"
+              end
+              result.add_skipped(group, "All files gitignored")
+              next
+            end
+
+            message = messages[index]
+
+            if options.dry_run
+              show_group_dry_run(message, group)
+              result.add_dry_run(group)
+              next
+            end
+
+            commit_sha = perform_commit(message, options)
+            result.add_success(group, commit_sha)
+          rescue GitError => e
+            scope_label = group.scope_name.to_s.empty? ? DEFAULT_SCOPE_NAME : group.scope_name
+            error_msg = "Failed to commit scope '#{scope_label}': #{e.message}"
+            result.add_failure(group, error_msg)
+            unless options.quiet
+              warn "✗ #{error_msg}"
+            end
+            rollback_to(original_head, result, options)
+            return result
+          end
+
+          result
+        end
+
+        private
+
+        def generate_batch_messages(groups, options)
+          puts "Generating commit messages for #{groups.length} scopes..." unless options.quiet
+
+          # Collect context for all groups using read-only diffs
+          # IMPORTANT: We use get_all_diff with file paths instead of staging files
+          # This preserves any user-selected hunks from partial staging (git add -p)
+          groups_context = groups.map do |group|
+            # Get diff for specific files without modifying the index
+            diff = @diff_analyzer.get_all_diff(group.files)
+            files = group.files
+
+            # Extract config values using normalized access
+            config = normalize_config_keys(group.config)
+            {
+              scope_name: group.scope_name,
+              diff: diff,
+              files: files,
+              type_hint: config["type_hint"],
+              description: config["description"],
+              model: config["model"]
+            }
+          end
+
+          # Check if all groups use the same model (can batch) or need segmentation
+          models_used = groups_context.map { |ctx| ctx[:model] }.compact.uniq
+          cli_model = options.model
+
+          if cli_model
+            # CLI flag overrides all group models - can batch
+            config_override = {"model" => cli_model}
+            return @message_generator.generate_batch(
+              groups_context,
+              intention: options.intention,
+              config: config_override
+            )
+          elsif models_used.length <= 1
+            # All groups use same model (or no model) - can batch
+            config_override = models_used.first ? {"model" => models_used.first} : {}
+            return @message_generator.generate_batch(
+              groups_context,
+              intention: options.intention,
+              config: config_override
+            )
+          end
+
+          # Different models per scope - generate sequentially by model
+          generate_segmented_by_model(groups_context, options.intention)
+        rescue Error => e
+          warn "[ace-git-commit] Batch generation failed, falling back to per-scope generation: #{e.message}" unless options.quiet
+          generate_per_scope_messages(groups_context, options)
+        end
+
+        # Generate messages segmented by model when groups have different model configs
+        def generate_segmented_by_model(groups_context, intention)
+          messages_by_scope = {}
+
+          # Group contexts by their model
+          by_model = groups_context.group_by { |ctx| ctx[:model] || "default" }
+
+          by_model.each do |model, contexts|
+            config_override = (model == "default") ? {} : {"model" => model}
+            result = @message_generator.generate_batch(
+              contexts,
+              intention: intention,
+              config: config_override
+            )
+
+            # Map messages back to scope names
+            result[:order].each_with_index do |scope, idx|
+              messages_by_scope[scope] = result[:messages][idx]
+            end
+          end
+
+          # Rebuild in original order
+          ordered_messages = groups_context.map { |ctx| messages_by_scope[ctx[:scope_name]] }
+          {messages: ordered_messages, order: groups_context.map { |ctx| ctx[:scope_name] }}
+        end
+
+        # Normalize config keys to strings for consistent access
+        def normalize_config_keys(config)
+          return {} unless config.is_a?(Hash)
+
+          config.transform_keys(&:to_s)
+        end
+
+        def reorder_groups_by_llm(groups, batch_result)
+          messages = batch_result[:messages]
+          order = batch_result[:order]
+
+          # Align groups with messages using the order array
+          # batch_result[:order] contains scope names matching batch_result[:messages]
+          groups_by_scope = groups.to_h { |g| [g.scope_name, g] }
+          aligned_groups = order.map { |scope| groups_by_scope[scope] }.compact
+
+          # Handle any groups that weren't in the LLM response (fallback)
+          missing_groups = groups.reject { |g| order.include?(g.scope_name) }
+          aligned_groups.concat(missing_groups)
+
+          # Extend messages array for missing groups by mapping from scope->message.
+          message_by_scope = order.each_with_index.to_h { |scope, idx| [scope, messages[idx]] }
+          aligned_messages = aligned_groups.map { |g| message_by_scope[g.scope_name] }
+          if aligned_messages.any?(&:nil?)
+            missing = aligned_groups.each_with_index.filter_map { |g, idx| g.scope_name if aligned_messages[idx].nil? }
+            raise Error, "Missing generated message(s) for scope(s): #{missing.join(", ")}"
+          end
+
+          # Always sort by commit type - more reliable than LLM ordering
+          sort_by_commit_type(aligned_groups, aligned_messages)
+        end
+
+        def generate_per_scope_messages(groups_context, options)
+          messages = groups_context.map do |ctx|
+            config = {}
+            config["model"] = options.model if options.model
+            config["model"] = ctx[:model] if options.model.nil? && ctx[:model]
+
+            @message_generator.generate(
+              ctx[:diff],
+              intention: options.intention,
+              files: ctx[:files],
+              config: config
+            )
+          end
+
+          {messages: messages, order: groups_context.map { |ctx| ctx[:scope_name] }}
+        end
+
+        def sort_by_commit_type(groups, messages)
+          # Type priority: feat/fix first, then refactor/test, then chore, then docs last
+          type_priority = {
+            "feat" => 0, "fix" => 1, "refactor" => 2, "test" => 3,
+            "perf" => 4, "chore" => 5, "style" => 6, "docs" => 7
+          }
+
+          # Pair groups with messages and extract types
+          pairs = groups.zip(messages).map do |group, msg|
+            type = msg.to_s.match(/^(\w+)[(:]/)&.[](1) || "chore"
+            {group: group, message: msg, type: type, priority: type_priority[type] || 5}
+          end
+
+          # Sort by priority
+          sorted = pairs.sort_by { |p| [p[:priority], p[:group].scope_name] }
+
+          [sorted.map { |p| p[:group] }, sorted.map { |p| p[:message] }]
+        end
+
+        def show_group_dry_run(message, group)
+          puts "-" * 40
+          puts "Scope: #{group.scope_name}"
+          puts "Files:"
+          group.files.each { |file| puts "  #{file}" }
+          puts "\nMessage:"
+          puts message
+          puts "-" * 40
+        end
+
+        def perform_commit(message, options)
+          puts "Committing..." unless options.quiet
+          @git.execute("commit", "-m", message)
+          commit_sha = @git.execute("rev-parse", "HEAD").strip
+
+          unless options.quiet
+            summarizer = Molecules::CommitSummarizer.new(@git)
+            summary = summarizer.summarize(commit_sha)
+            puts summary
+          end
+
+          commit_sha
+        end
+
+        def current_head
+          @git.execute("rev-parse", "HEAD").strip
+        rescue GitError
+          nil
+        end
+
+        def rollback_to(original_head, result, options)
+          return if original_head.nil?
+
+          @git.execute("reset", "--soft", original_head)
+          puts "Rolled back split commit operation." unless options.quiet
+        rescue GitError => e
+          result.mark_rollback_error(e.message)
+          warn "Rollback failed: #{e.message}"
+        end
+      end
+    end
+  end
+end