ace-git-commit 0.23.0

data/lib/ace/git_commit/models/commit_options.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Ace
+  module GitCommit
+    module Models
+      # CommitOptions encapsulates all options for a commit operation
+      class CommitOptions
+        attr_accessor :intention, :message, :model, :files,
+          :only_staged, :dry_run, :debug, :force, :verbose, :quiet, :no_split
+
+        def initialize(
+          intention: nil,
+          message: nil,
+          model: nil,
+          files: [],
+          only_staged: false,
+          dry_run: false,
+          debug: false,
+          force: false,
+          verbose: true,
+          quiet: false,
+          no_split: false
+        )
+          @intention = intention
+          @message = message
+          @model = model
+          @files = files || []
+          @only_staged = only_staged
+          @dry_run = dry_run
+          @debug = debug
+          @force = force
+          @verbose = verbose
+          @quiet = quiet
+          @no_split = no_split
+        end
+
+        # Check if we should use LLM generation
+        # @return [Boolean] True if LLM should be used
+        def use_llm?
+          @message.nil? || @message.empty?
+        end
+
+        # Check if specific files are targeted
+        # @return [Boolean] True if specific files provided
+        def specific_files?
+          !@files.empty?
+        end
+
+        # Check if we should stage all changes
+        # @return [Boolean] True if all changes should be staged
+        def stage_all?
+          !@only_staged && !specific_files?
+        end
+
+        # Convert to hash for debugging
+        # @return [Hash] Options as hash
+        def to_h
+          {
+            intention: @intention,
+            message: @message,
+            model: @model,
+            files: @files,
+            only_staged: @only_staged,
+            dry_run: @dry_run,
+            debug: @debug,
+            force: @force,
+            verbose: @verbose,
+            quiet: @quiet,
+            no_split: @no_split
+          }
+        end
+      end
+    end
+  end
+end

data/lib/ace/git_commit/models/split_commit_result.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Ace
+  module GitCommit
+    module Models
+      # SplitCommitResult tracks results for split commit execution
+      class SplitCommitResult
+        CommitRecord = Struct.new(:group, :sha, :status, :error, keyword_init: true)
+
+        attr_reader :records, :original_head, :rollback_error
+
+        def initialize(original_head: nil)
+          @records = []
+          @original_head = original_head
+          @rollback_error = nil
+        end
+
+        def add_success(group, sha)
+          @records << CommitRecord.new(group: group, sha: sha, status: :success, error: nil)
+        end
+
+        def add_dry_run(group)
+          @records << CommitRecord.new(group: group, sha: nil, status: :dry_run, error: nil)
+        end
+
+        def add_failure(group, error)
+          @records << CommitRecord.new(group: group, sha: nil, status: :failure, error: error)
+        end
+
+        def add_skipped(group, reason)
+          @records << CommitRecord.new(group: group, sha: nil, status: :skipped, error: reason)
+        end
+
+        def commit_shas
+          records.map(&:sha).compact
+        end
+
+        def success?
+          records.all? { |record| record.status == :success || record.status == :dry_run || record.status == :skipped }
+        end
+
+        def skipped?
+          records.any? { |record| record.status == :skipped }
+        end
+
+        def dry_run?
+          records.any? { |record| record.status == :dry_run }
+        end
+
+        def failed?
+          !success?
+        end
+
+        def mark_rollback_error(error)
+          @rollback_error = error
+        end
+      end
+    end
+  end
+end

data/lib/ace/git_commit/models/stage_result.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Ace
+  module GitCommit
+    module Models
+      # StageResult represents the outcome of staging a file or set of files
+      class StageResult
+        attr_reader :file_path, :success, :error_message, :file_size, :status
+
+        def initialize(file_path:, success:, error_message: nil, file_size: nil, status: nil)
+          @file_path = file_path
+          @success = success
+          @error_message = error_message
+          @file_size = file_size
+          @status = status # :modified, :new, :deleted, etc.
+        end
+
+        # Check if staging was successful
+        # @return [Boolean] True if successful
+        def success?
+          @success
+        end
+
+        # Check if this is a large file (>50MB)
+        # @return [Boolean] True if file is large
+        def large_file?
+          return false unless @file_size
+          @file_size > 50 * 1024 * 1024 # 50MB in bytes
+        end
+
+        # Get a human-readable file size
+        # @return [String] File size with unit
+        def human_file_size
+          return nil unless @file_size
+
+          if @file_size < 1024
+            "#{@file_size} B"
+          elsif @file_size < 1024 * 1024
+            "#{(@file_size / 1024.0).round(1)} KB"
+          elsif @file_size < 1024 * 1024 * 1024
+            "#{(@file_size / (1024.0 * 1024.0)).round(2)} MB"
+          else
+            "#{(@file_size / (1024.0 * 1024.0 * 1024.0)).round(2)} GB"
+          end
+        end
+
+        # Get status indicator emoji
+        # @return [String] Status emoji
+        def status_indicator
+          if success?
+            "✓"
+          else
+            "✗"
+          end
+        end
+
+        # Convert to hash for debugging
+        # @return [Hash] Result as hash
+        def to_h
+          {
+            file_path: @file_path,
+            success: @success,
+            error_message: @error_message,
+            file_size: @file_size,
+            status: @status
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module Ace
+  module GitCommit
+    module Molecules
+      # CommitGrouper groups files by effective configuration
+      class CommitGrouper
+        # Reference the default scope name constant
+        DEFAULT_SCOPE_NAME = Ace::Support::Config::Models::ConfigGroup::DEFAULT_SCOPE_NAME
+        def initialize(file_config_resolver: nil)
+          @file_config_resolver = file_config_resolver || default_config_resolver
+        end
+
+        # Group files by scope name and config signature
+        # Files with the same scope name but different configs are kept separate
+        # @param files [Array<String>] File paths (relative)
+        # @param project_root [String, nil] Project root path for scope name derivation
+        # @return [Array<Models::CommitGroup>] Grouped commits
+        def group(files, project_root: nil)
+          groups = {}
+
+          Array(files).each do |file|
+            resolved = @file_config_resolver.resolve(file, namespace: "git", filename: "commit", project_root: project_root)
+            # .ace/ config files always group into "ace-config" scope
+            scope_name = if ace_config_file?(file)
+              "ace-config"
+            else
+              # Derive scope name: use path-based derivation for distributed configs,
+              # otherwise keep the resolved name (path rule name or DEFAULT_SCOPE_NAME)
+              derive_scope_name(resolved.source, resolved.name, project_root)
+            end
+            # Group by scope_name AND config signature to prevent merging scopes with different configs
+            # Exception: DEFAULT_SCOPE_NAME always groups together regardless of config (to avoid duplicates)
+            # For path rules: use rule_config for grouping (ignores cascade differences like per-package model)
+            # For distributed configs: use full config (package-specific configs matter)
+            grouping_config = resolved.rule_config || resolved.config
+            config_sig = Models::CommitGroup.signature_for(grouping_config)
+            key = (scope_name == DEFAULT_SCOPE_NAME) ? scope_name : "#{scope_name}::#{config_sig}"
+
+            group = groups[key] ||= Models::CommitGroup.new(
+              scope_name: scope_name,
+              source: resolved.source,
+              config: resolved.config,
+              files: []
+            )
+
+            group.add_file(file)
+          end
+
+          groups.values.each { |group| group.files.sort! }
+          groups.values.sort_by { |group| sort_key(group) }
+        end
+
+        # Derive scope name from config source path
+        # For distributed configs (package/.ace/), derive from path
+        # For path rules or root config, keep the resolved name
+        # @param source_path [String, nil] Full path to config file (may be compound "path1 -> path2")
+        # @param resolved_name [String] Name from FileConfigResolver (path rule name or DEFAULT_SCOPE_NAME)
+        # @param project_root [String, nil] Project root path
+        # @return [String] Scope name
+        def derive_scope_name(source_path, resolved_name, project_root)
+          # Path rule names take precedence over distributed config derivation
+          # This ensures inherited rules like "ace-config" are preserved
+          return resolved_name if resolved_name && resolved_name != DEFAULT_SCOPE_NAME
+
+          return resolved_name unless source_path && project_root
+
+          # Filter to only .ace/ paths (ignore .ace-defaults completely for scope derivation)
+          # .ace-defaults provides default VALUES only, not SCOPE
+          ace_sources = source_path.split(" -> ").reject { |p| p.include?(".ace-defaults") }
+          return resolved_name if ace_sources.empty?
+
+          primary_source = ace_sources.first
+
+          # Remove project root prefix to get relative path
+          relative = primary_source.sub("#{project_root}/", "")
+
+          # If still absolute or unchanged, keep resolved name
+          return resolved_name if relative == primary_source || relative.start_with?("/")
+
+          # Check if this is a distributed config (package/.ace/)
+          # "ace-bundle/.ace/git/commit.yml" → ["ace-bundle", "git/commit.yml"]
+          # ".ace/git/commit.yml" → ["", "git/commit.yml"] (root config)
+          parts = relative.split("/.ace/")
+          package_name = parts.first
+
+          # If empty or starts with .ace, it's root config - keep resolved name (path rule or default)
+          return resolved_name if package_name.nil? || package_name.empty? || package_name.start_with?(".ace")
+
+          # This is a distributed config - derive scope from package path
+          package_name
+        end
+
+        # Check if a file path is inside a .ace/ directory
+        def ace_config_file?(file)
+          file.include?("/.ace/") || file.start_with?(".ace/")
+        end
+
+        private
+
+        def default_config_resolver
+          gem_root = Gem.loaded_specs["ace-git-commit"]&.gem_dir ||
+            File.expand_path("../../../..", __dir__)
+
+          Ace::Support::Config::Molecules::FileConfigResolver.new(
+            config_dir: ".ace",
+            defaults_dir: ".ace-defaults",
+            gem_path: gem_root
+          )
+        end
+
+        def sort_key(group)
+          name = group.scope_name.to_s
+          if name.empty? || name == DEFAULT_SCOPE_NAME || name == "no package"
+            [1, name]
+          else
+            [0, name]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Ace
+  module GitCommit
+    module Molecules
+      # CommitSummarizer generates human-readable commit summaries
+      # using git's native formatting commands
+      class CommitSummarizer
+        def initialize(git_executor)
+          @git = git_executor
+        end
+
+        # Generate a formatted summary for a commit
+        # @param commit_sha [String] The commit SHA to summarize (e.g., "HEAD", "abc123")
+        # @return [String] Formatted commit summary with hash, message, and file stats
+        def summarize(commit_sha)
+          # Get commit info: hash (refs) message
+          commit_line = @git.execute("log", "--oneline", commit_sha, "-1").strip
+
+          # Get file stats
+          stats = get_commit_stats(commit_sha)
+
+          # Combine with newline
+          "#{commit_line}\n#{stats}"
+        end
+
+        private
+
+        # Get file statistics for a commit
+        # Handles both regular commits and first commits (no parent)
+        # @param commit_sha [String] The commit SHA
+        # @return [String] File statistics from git diff --stat
+        def get_commit_stats(commit_sha)
+          # Try diff against parent first (normal case)
+          @git.execute("diff", "--stat", "#{commit_sha}~1", commit_sha, capture_stderr: true)
+        rescue GitError
+          # If no parent (first commit), use git show
+          @git.execute("show", "--stat", "--format=", commit_sha)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module Ace
+  module GitCommit
+    module Molecules
+      # DiffAnalyzer analyzes git diffs and extracts information for commit message generation
+      class DiffAnalyzer
+        def initialize(git_executor)
+          @git = git_executor
+        end
+
+        # Get the diff for staged changes
+        # @param files [Array<String>, nil] Specific files to diff
+        # @return [String] The diff output
+        def get_staged_diff(files = nil)
+          args = ["diff", "--cached"]
+          args += ["--"] + files if files && !files.empty?
+          @git.execute(*args)
+        end
+
+        # Get the diff for all changes (staged and unstaged)
+        # @param files [Array<String>, nil] Specific files to diff
+        # @return [String] The diff output
+        def get_all_diff(files = nil)
+          args = ["diff", "HEAD"]
+          args += ["--"] + files if files && !files.empty?
+          @git.execute(*args)
+        rescue GitError
+          # If HEAD doesn't exist (new repo), get all changes
+          get_unstaged_diff(files)
+        end
+
+        # Get the diff for unstaged changes
+        # @param files [Array<String>, nil] Specific files to diff
+        # @return [String] The diff output
+        def get_unstaged_diff(files = nil)
+          args = ["diff"]
+          args += ["--"] + files if files && !files.empty?
+          @git.execute(*args)
+        end
+
+        # Get list of changed files
+        # @param staged_only [Boolean] Only staged files
+        # @return [Array<String>] List of file paths
+        def changed_files(staged_only: false)
+          if staged_only
+            @git.execute("diff", "--cached", "--name-only").strip.split("\n")
+          else
+            # Get all changed files (staged, unstaged, and untracked)
+            staged = @git.execute("diff", "--cached", "--name-only").strip.split("\n")
+            unstaged = @git.execute("diff", "--name-only").strip.split("\n")
+            untracked = @git.execute("ls-files", "--others", "--exclude-standard").strip.split("\n")
+            (staged + unstaged + untracked).uniq
+          end
+        end
+
+        # Analyze diff to extract summary information
+        # @param diff [String] The diff to analyze
+        # @return [Hash] Summary with :files_changed, :insertions, :deletions
+        def analyze_diff(diff)
+          files = []
+          insertions = 0
+          deletions = 0
+
+          diff.lines.each do |line|
+            if line.start_with?("+++")
+              # Extract file path from +++ line
+              file = line.sub(/^\+\+\+ b\//, "").strip
+              files << file unless file == "/dev/null"
+            elsif line.start_with?("+") && !line.start_with?("+++")
+              insertions += 1
+            elsif line.start_with?("-") && !line.start_with?("---")
+              deletions += 1
+            end
+          end
+
+          {
+            files_changed: files.uniq,
+            insertions: insertions,
+            deletions: deletions
+          }
+        end
+
+        # Detect the scope from changed files
+        # @param files [Array<String>] List of file paths
+        # @return [String, nil] Detected scope or nil
+        def detect_scope(files)
+          return nil if files.empty?
+
+          # Check if all files are in a specific directory/component
+          if files.all? { |f| f.start_with?("ace-") }
+            # All files in a specific ace gem
+            gem = files.first.split("/").first
+            return gem
+          end
+
+          # Check common patterns
+          if files.all? { |f| f.match?(%r{(^|/)test/}) || f.match?(%r{(^|/)spec/}) }
+            return "test"
+          elsif files.all? { |f| f.end_with?(".md") }
+            return "docs"
+          elsif files.all? { |f| f.include?("config") }
+            return "config"
+          end
+
+          nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+module Ace
+  module GitCommit
+    module Molecules
+      # FileStager handles staging files for commit
+      class FileStager
+        attr_reader :last_error, :last_skipped_files
+
+        def initialize(git_executor, gitignore_checker: nil)
+          @git = git_executor
+          @gitignore_checker = gitignore_checker || Atoms::GitignoreChecker.new
+          @last_error = nil
+          @last_skipped_files = []
+          @had_valid_files = false
+        end
+
+        # Stage specific files
+        # @param files [Array<String>] Files to stage
+        # @return [Boolean] True if successful
+        def stage_files(files)
+          return false if files.nil? || files.empty?
+
+          @last_error = nil
+          @git.execute("add", *files)
+          true
+        rescue GitError => e
+          @last_error = e.message
+          false
+        end
+
+        # Stage all changes in the repository
+        # @return [Boolean] True if successful
+        def stage_all
+          @last_error = nil
+          @git.execute("add", "-A")
+          true
+        rescue GitError => e
+          @last_error = e.message
+          false
+        end
+
+        # Unstage specific files
+        # @param files [Array<String>] Files to unstage
+        # @return [Boolean] True if successful
+        def unstage_files(files)
+          return false if files.nil? || files.empty?
+
+          @git.execute("reset", "HEAD", *files)
+          true
+        rescue GitError
+          # If HEAD doesn't exist (new repo), use rm --cached
+          @git.execute("rm", "--cached", *files)
+          true
+        end
+
+        # Get list of staged files
+        # Uses --no-renames to ensure deleted files from directory renames are included
+        # @return [Array<String>] List of staged file paths
+        def staged_files
+          @git.execute("diff", "--cached", "--name-only", "--no-renames").strip.split("\n")
+        end
+
+        # Check if specific files are staged
+        # @param files [Array<String>] Files to check
+        # @return [Boolean] True if all files are staged
+        def files_staged?(files)
+          staged = staged_files
+          files.all? { |f| staged.include?(f) }
+        end
+
+        # Stage only files within specified paths
+        # Resets staging area first, then stages only files in paths
+        # @param paths [Array<String>] Paths to stage (files or directories)
+        # @param quiet [Boolean] Suppress output about skipped files
+        # @return [Boolean] True if successful (including when all files skipped)
+        def stage_paths(paths, quiet: false)
+          return false if paths.nil? || paths.empty?
+
+          @last_error = nil
+          @last_skipped_files = []
+          @had_valid_files = false
+
+          begin
+            # Categorize paths: valid (not gitignored), force_add (gitignored but tracked), skipped (gitignored and untracked)
+            result = @gitignore_checker.categorize_paths(paths, @git)
+
+            # Track skipped files (gitignored and not tracked)
+            if result[:skipped].any?
+              @last_skipped_files = result[:skipped]
+              unless quiet
+                warn "⚠ Skipping gitignored files (not tracked):"
+                result[:skipped].each do |info|
+                  if info[:pattern]
+                    warn "  #{info[:path]}"
+                    warn "  (matches pattern: #{info[:pattern]})"
+                  else
+                    warn "  #{info[:path]}"
+                  end
+                end
+              end
+            end
+
+            # Combine valid paths and force_add paths
+            # Force add paths need -f flag because they're in gitignored locations but are tracked
+            normal_paths = result[:valid]
+            force_add_paths = result[:force_add].map { |f| f[:path] }
+
+            all_paths = normal_paths + force_add_paths
+
+            # If all files are skipped (gitignored and untracked), return success
+            if all_paths.empty?
+              return true
+            end
+
+            @had_valid_files = true
+
+            # Reset staging area to clear everything
+            @git.execute("reset", "--quiet")
+
+            # Stage normal files (retry with -f if path is ignored)
+            normal_paths.each do |path|
+              @git.execute("add", path)
+            rescue GitError => e
+              # If git says path is ignored but we expected it to work, try force add
+              if e.message.include?("ignored by one of your .gitignore files")
+                @git.execute("add", "-f", path)
+              else
+                raise
+              end
+            end
+
+            # Stage tracked files in gitignored locations with force flag
+            force_add_paths.each do |path|
+              @git.execute("add", "-f", path)
+            end
+
+            true
+          rescue GitError => e
+            @last_error = e.message
+            false
+          end
+        end
+
+        # Check if the last stage_paths call had all files gitignored
+        # @return [Boolean] True if all files were skipped due to gitignore
+        def all_files_skipped?
+          @last_skipped_files.any? && !@had_valid_files && @last_error.nil?
+        end
+      end
+    end
+  end
+end