commiti 1.3.2 → 1.3.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 82b26f3eb5a9606aa58e723e85a764395b485d7d84175878560173262c266615
-  data.tar.gz: 4e92dadbaf1f3fc84f15b4650b632a054aa0ddf924349590d652361964213db5
+  metadata.gz: 7853991e7fa65bd7c35642c50b00aead27bc7b3a4c11ffec7bb38be03a9e96ca
+  data.tar.gz: a42e9fbfec33a80cf95befe00c14f3e2bd23e7d334606589e21d2e1b6ab31a6f
 SHA512:
-  metadata.gz: b0fe4d3e034e6c05809c8ec000b1b44eecc8de21c3d166e5f8735f96f8d718d3bcfc2472a421f540e1509c203ed91c430d99122ae128bd4cfe9824d83de93efa
-  data.tar.gz: d79d70ab801e09ab81c8d6d2e9339b01d799ff874225ec49684b21e9e55baf0b85352ebf8914e2710a3ed4a2d46496f567ca9ee7cce2106047da8129e90c5ec0
+  metadata.gz: 82ed71618c42e1fbb745bfc04974a754b43396f232d26923c214a34738860d0a7566c90c22caa8e60dee383d953dcce0937e908a3bd81c1d1519e4cb84b3790a
+  data.tar.gz: b45f9669306182469b502bc98a2a1754c9ad3e9320b8801ac2a72bd3f412d0d01f348e8ac75fd5a82b002f84356b9e0ebb99df9c941ac6cc4607b8f53912c2ce

data/README.md

@@ -1,5 +1,7 @@
 # Commiti
 
+[![Coverage](https://img.shields.io/badge/coverage-90%25-brightgreen)](coverage/index.html) [![RSpec](https://img.shields.io/badge/rspec-passing-brightgreen)](#)
+
 AI-powered commit message and pull request description generator for Git repositories, using Google AI models.
 
 ## What It Does
@@ -100,6 +102,8 @@ Never commit `.env` to git.
 By default, Commiti creates a single commit from staged changes.
 Use `--auto-split` to let Commiti group connected file changes into multiple atomic commits.
 
+When auto-split detects multiple groups, Commiti can optionally open a quick group editor so you can move files between groups before committing.
+
 1. Shows `git status --short`.
 2. Asks for confirmation before staging (`git add -A`).
 3. Ensures there are staged changes.

data/bin/commiti

@@ -47,6 +47,12 @@ OptionParser.new do |opts|
 end.parse!
 
 begin
+  model_label = ENV.fetch('COMMITI_MODEL', Commiti::GoogleClient::DEFAULT_MODEL)
+  flow_label = options[:type] == :pr ? 'PR flow' : 'Commit flow'
+  base_label = options[:type] == :pr ? "Base: #{options[:base_branch] || 'main'}" : nil
+  meta = [flow_label, "Model: #{model_label}", base_label].compact.join(' • ')
+  puts Commiti::TerminalUI.banner(title: 'Commiti', subtitle: 'AI commit & PR generator', meta: meta)
+
   flow = if options[:type] == :pr
            Commiti::Flows::PrFlow.new(options: options)
          else

data/lib/commiti.rb

@@ -20,6 +20,7 @@ require_relative 'services/message_presenter'
 require_relative 'services/git/commit/commit_staging'
 require_relative 'services/git/commit/commit_execution'
 require_relative 'services/git/commit/change_grouping'
+require_relative 'services/git/commit/group_editor'
 require_relative 'flows/base_flow'
 require_relative 'flows/commit_flow'
 require_relative 'flows/pr_flow'

data/lib/flows/commit_flow.rb

@@ -61,7 +61,12 @@ module Commiti
       end
 
       def run_grouped_context(context:, client:, model:)
-        groups = context[:change_groups]
+        groups = Commiti::GroupEditor.edit(context[:change_groups])
+        if groups.length <= 1
+          single_context = groups.first ? build_context(diff: group_diff(groups.first), client:, model:) : context
+          return run_single_group_context(context: single_context, client:, model:)
+        end
+
         run_stage('Unstaging current index for grouped commit execution') { Commiti::GitWriter.unstage_all! }
 
         puts "\n#{Commiti::TerminalUI.status(:info, "Auto-split detected #{groups.length} connected change groups.")}"
@@ -75,8 +80,7 @@ module Commiti
         run_stage("Staging files for group #{index + 1}/#{total}") { Commiti::GitWriter.stage_files!(group[:files]) }
         return :continue unless run_stage('Checking staged changes') { Commiti::GitWriter.staged_changes? }
 
-        puts "\n#{Commiti::TerminalUI.header("Group #{index + 1}/#{total} files")}:"
-        group[:files].each { |path| puts "- #{path}" }
+        puts "\n#{Commiti::TerminalUI.panel("Group #{index + 1}/#{total} files", Commiti::TerminalUI.bullets(group[:files]))}\n"
 
         group_context = build_context(diff: group_diff(group), client:, model:)
         Commiti::MessagePresenter.print_summarization_notice(group_context[:summarized_result])

data/lib/flows/pr_flow.rb

@@ -27,7 +27,7 @@ module Commiti
         prompt_text = 'Create PR and open it in browser now?'
 
         unless Commiti::InteractivePrompt.ask_yes_no(prompt_text, default: :no)
-          puts "\nPR creation skipped.\n\n"
+          puts "\n#{Commiti::TerminalUI.status(:warn, 'PR creation skipped.')}\n\n"
           return
         end
 
@@ -66,7 +66,7 @@ module Commiti
         end
 
         run_stage('Opening browser') { Commiti::PrOpener.open_in_browser(pr_url) }
-        puts "\nOpened PR page:\n#{pr_url}\n\n"
+        puts "\n#{Commiti::TerminalUI.panel('Opened PR page', pr_url)}\n\n"
       end
     end
   end

data/lib/services/git/commit/change_grouping.rb

@@ -18,6 +18,12 @@ module Commiti
       end
     end
 
+    def self.related?(left, right)
+      return false if left.to_s.strip.empty? || right.to_s.strip.empty?
+
+      connected?(left, right)
+    end
+
     def self.connected_components(paths)
       visited = {}
       ordered_components = []

data/lib/services/git/commit/commit_execution.rb

@@ -39,7 +39,7 @@ module Commiti
       return commit_message(working_message, run_stage: run_stage) if errors.empty?
 
       puts "\n#{Commiti::TerminalUI.status(:warn, 'Current message needs fixes before commit:')}"
-      errors.each { |error| puts "- #{error}" }
+      errors.each { |error| puts Commiti::TerminalUI.bullet(error) }
 
       unless Commiti::InteractivePrompt.ask_yes_no('Open editor to fix now?', default: :yes)
         print_skip_message
@@ -88,7 +88,7 @@ module Commiti
         return edited if errors.empty?
 
         puts "\n#{Commiti::TerminalUI.status(:warn, 'Edited message needs fixes:')}"
-        errors.each { |error| puts "- #{error}" }
+        errors.each { |error| puts Commiti::TerminalUI.bullet(error) }
         return edited unless Commiti::InteractivePrompt.ask_yes_no('Re-open editor now?', default: :yes)
 
         working = edited

data/lib/services/git/commit/commit_staging.rb

@@ -11,7 +11,7 @@ module Commiti
       status = run_stage.call('Reading git status') { Commiti::GitWriter.status_short }
       raise 'No changes found in working tree.' if status.strip.empty?
 
-      puts "\n#{Commiti::TerminalUI.header('Current git status')}\n\n#{status}"
+      puts "\n#{Commiti::TerminalUI.panel('Current git status', status)}\n"
       return unless Commiti::InteractivePrompt.ask_yes_no('Run git add -A now?', default: :no)
 
       run_stage.call('Staging changes (git add -A)') { Commiti::GitWriter.stage_all! }

data/lib/services/git/commit/group_editor.rb

@@ -0,0 +1,254 @@
+# frozen_string_literal: true
+
+module Commiti
+  module GroupEditor
+    HELP_TEXT = <<~TEXT.freeze
+      Select files by number, then choose where to move them.
+
+      Examples:
+        1,3,5     (select files 1, 3, 5)
+        2-4       (select files 2 through 4)
+
+      Targets:
+        1..N move to an existing group
+        n    new group
+        a    auto-reassign (best matching group or new)
+        c    cancel
+    TEXT
+
+    def self.edit(groups)
+      return groups if groups.empty?
+      return groups unless Commiti::InteractivePrompt.ask_yes_no('Edit auto-split groups before committing?', default: :no)
+
+      working = deep_copy(groups)
+      chunk_map = build_chunk_map(working)
+      all_paths = working.flat_map { |group| group[:files] }.uniq
+      path_order = all_paths.each_with_index.to_h
+
+      puts "\n#{Commiti::TerminalUI.panel('Group editor', HELP_TEXT)}\n"
+
+      loop do
+        index_map, indexed_groups = index_groups(working)
+        print_groups(indexed_groups, total: working.length)
+
+        input = Commiti::InteractivePrompt.ask_text('Move which files? (numbers, Enter to finish)')
+        break if input.nil? || input.empty?
+
+        selected_indices = parse_indices(input, max_index: index_map.length)
+        if selected_indices.empty?
+          puts Commiti::TerminalUI.status(:warn, 'No valid file numbers selected.')
+          next
+        end
+
+        selected_paths = selected_indices.map { |index| index_map[index] }.compact
+        target = Commiti::InteractivePrompt.ask_text(
+          "Move to group [1-#{working.length}], n=new, a=auto, c=cancel"
+        ).to_s.strip.downcase
+
+        next if target.empty? || target == 'c'
+
+        case target
+        when 'a'
+          auto_reassign(working, selected_paths, chunk_map)
+        when 'n'
+          move_to_new_group(working, selected_paths, chunk_map)
+        else
+          group_index = integer_or_nil(target)
+          unless group_index && working[group_index - 1]
+            puts Commiti::TerminalUI.status(:warn, "Group #{target} does not exist.")
+            next
+          end
+
+          move_to_group(working, group_index, selected_paths)
+        end
+
+        normalize_groups(working, chunk_map, path_order)
+      end
+
+      normalize_groups(working, chunk_map, path_order)
+    end
+
+    def self.print_groups(indexed_groups, total:)
+      panels = indexed_groups.map do |group|
+        title = "Group #{group[:index]}/#{total}"
+        body = if group[:entries].empty?
+                 Commiti::TerminalUI.muted('No files')
+               else
+                 group[:entries].map { |entry| "#{entry[:index]}. #{entry[:path]}" }.join("\n")
+               end
+        Commiti::TerminalUI.panel(title, body)
+      end
+      puts "\n#{panels.join("\n\n")}\n"
+    end
+    private_class_method :print_groups
+
+    def self.index_groups(groups)
+      index_map = {}
+      indexed_groups = []
+      counter = 1
+
+      groups.each_with_index do |group, index|
+        entries = group[:files].map do |path|
+          entry = { index: counter, path: path }
+          index_map[counter] = path
+          counter += 1
+          entry
+        end
+        indexed_groups << { index: index + 1, entries: entries }
+      end
+
+      [index_map, indexed_groups]
+    end
+    private_class_method :index_groups
+
+    def self.parse_indices(text, max_index:)
+      raw = text.to_s.strip
+      return [] if raw.empty?
+
+      indices = []
+      invalid_tokens = []
+
+      raw.split(/[,\s]+/).each do |token|
+        next if token.empty?
+
+        if token.match?(/\A\d+-\d+\z/)
+          start_value, end_value = token.split('-').map(&:to_i)
+          range = start_value <= end_value ? (start_value..end_value) : (end_value..start_value)
+          indices.concat(range.to_a)
+        elsif token.match?(/\A\d+\z/)
+          indices << token.to_i
+        else
+          invalid_tokens << token
+        end
+      end
+
+      invalid_tokens.each do |token|
+        puts Commiti::TerminalUI.status(:warn, "Invalid token: #{token}")
+      end
+
+      indices = indices.uniq
+      valid = indices.select { |value| value.between?(1, max_index) }
+      (indices - valid).each do |value|
+        puts Commiti::TerminalUI.status(:warn, "File number #{value} is out of range.")
+      end
+      valid
+    end
+    private_class_method :parse_indices
+
+    def self.move_to_group(groups, group_index, paths)
+      target = groups[group_index - 1]
+      paths.each do |path|
+        remove_path_from_groups(groups, path)
+        target[:files] << path unless target[:files].include?(path)
+      end
+    end
+    private_class_method :move_to_group
+
+    def self.move_to_new_group(groups, paths, chunk_map)
+      paths.each { |path| remove_path_from_groups(groups, path) }
+      new_groups = build_groups_for_paths(paths, chunk_map)
+      groups.concat(new_groups)
+    end
+    private_class_method :move_to_new_group
+
+    def self.auto_reassign(groups, paths, chunk_map)
+      origin_groups = find_origin_groups(groups, paths)
+      paths.each { |path| remove_path_from_groups(groups, path) }
+
+      remaining = []
+      paths.each do |path|
+        excluded = origin_groups[path] ? [origin_groups[path]] : []
+        target = best_matching_group(path, groups, excluded_groups: excluded)
+        if target
+          target[:files] << path unless target[:files].include?(path)
+        else
+          remaining << path
+        end
+      end
+
+      groups.concat(build_groups_for_paths(remaining, chunk_map)) if remaining.any?
+    end
+    private_class_method :auto_reassign
+
+    def self.find_origin_groups(groups, paths)
+      origin = {}
+      groups.each do |group|
+        group[:files].each do |path|
+          origin[path] = group if paths.include?(path)
+        end
+      end
+      origin
+    end
+    private_class_method :find_origin_groups
+
+    def self.remove_path_from_groups(groups, path)
+      groups.each { |group| group[:files].delete(path) }
+    end
+    private_class_method :remove_path_from_groups
+
+    def self.best_matching_group(path, groups, excluded_groups:)
+      candidates = groups - excluded_groups
+      best = nil
+      best_score = 0
+
+      candidates.each do |group|
+        score = group[:files].count { |existing| Commiti::ChangeGrouping.related?(path, existing) }
+        next if score <= best_score
+
+        best_score = score
+        best = group
+      end
+
+      best_score.positive? ? best : nil
+    end
+    private_class_method :best_matching_group
+
+    def self.build_groups_for_paths(paths, chunk_map)
+      line_chunks = paths.map { |path| chunk_map[path] }.compact
+      return [] if line_chunks.empty?
+
+      Commiti::ChangeGrouping.group(line_chunks).map do |group|
+        {
+          id: group[:id],
+          files: group[:files],
+          chunks: group[:chunks]
+        }
+      end
+    end
+    private_class_method :build_groups_for_paths
+
+    def self.build_chunk_map(groups)
+      groups.flat_map { |group| group[:chunks] }
+            .each_with_object({}) { |chunk, acc| acc[chunk[:path]] = chunk }
+    end
+    private_class_method :build_chunk_map
+
+    def self.normalize_groups(groups, chunk_map, path_order)
+      groups.reject! { |group| group[:files].empty? }
+      groups.each do |group|
+        group[:files] = group[:files].uniq.sort_by { |path| path_order[path] || path_order.length }
+        group[:chunks] = group[:files].filter_map { |path| chunk_map[path] }
+      end
+      groups.each_with_index { |group, index| group[:id] = index + 1 }
+    end
+    private_class_method :normalize_groups
+
+    def self.integer_or_nil(value)
+      return nil unless value.to_s.match?(/\A\d+\z/)
+
+      value.to_i
+    end
+    private_class_method :integer_or_nil
+
+    def self.deep_copy(groups)
+      groups.map do |group|
+        {
+          id: group[:id],
+          files: group[:files].dup,
+          chunks: group[:chunks].map(&:dup)
+        }
+      end
+    end
+    private_class_method :deep_copy
+  end
+end

data/lib/services/helpers/interactive_prompt.rb

@@ -12,7 +12,7 @@ module Commiti
 
     def self.ask_yes_no(question, default: :no)
       suffix = default == :yes ? '[Y/n]' : '[y/N]'
-      input = read_input("#{question} #{suffix} ")
+      input = read_input("#{Commiti::TerminalUI.prompt(question)} #{Commiti::TerminalUI.muted(suffix)} ")
       return default == :yes ? :yes : nil if input.nil?
 
       value = input.strip.downcase
@@ -24,7 +24,7 @@ module Commiti
     end
 
     def self.ask_commit_action
-      input = read_input('Commit with this message? [y/e/N] ')
+      input = read_input("#{Commiti::TerminalUI.prompt('Commit with this message?')} #{Commiti::TerminalUI.muted('[y/e/N]')} ")
       return :no if input.nil?
 
       value = input.strip.downcase
@@ -38,17 +38,27 @@ module Commiti
       return 0 if count <= 1
 
       loop do
-        input = read_input("Select candidate [1-#{count}] (default: #{default}): ")
+        input = read_input(
+          "#{Commiti::TerminalUI.prompt('Select candidate')} " \
+          "#{Commiti::TerminalUI.muted("[1-#{count}] (default: #{default})")}: "
+        )
         return default - 1 if input.nil?
 
         value = input.strip
         return default - 1 if value.empty?
         return value.to_i - 1 if value.match?(/\A\d+\z/) && value.to_i.between?(1, count)
 
-        puts "Please type a number between 1 and #{count}."
+        puts Commiti::TerminalUI.status(:warn, "Please type a number between 1 and #{count}.")
       end
     end
 
+    def self.ask_text(question)
+      input = read_input("#{Commiti::TerminalUI.prompt(question)} ")
+      return nil if input.nil?
+
+      input.to_s.strip
+    end
+
     def self.edit_message(initial_message)
       # Keep the temp file closed while the external editor runs.
       # On Windows, open handles can prevent editors like Notepad from

data/lib/services/helpers/spinner.rb

@@ -16,7 +16,8 @@ module Commiti
         index = 0
         until done
           frame = Commiti::TerminalUI.color(FRAMES[index % FRAMES.length], :cyan)
-          print "\r#{frame} #{message}"
+          line = "#{frame} #{message}"
+          print "\r#{Commiti::TerminalUI.pad_right(line, Commiti::TerminalUI.width)}"
           $stdout.flush
           index += 1
           sleep INTERVAL_SECONDS
@@ -31,7 +32,8 @@ module Commiti
         done = true
         spinner_thread.join
 
-        print "\r#{final_status_line(error, message)}\n"
+        final_line = final_status_line(error, message)
+        print "\r#{Commiti::TerminalUI.pad_right(final_line, Commiti::TerminalUI.width)}\n"
         $stdout.flush
       end
 

data/lib/services/helpers/terminal_ui.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'io/console'
+
 module Commiti
   module TerminalUI
     COLORS = {
@@ -8,17 +10,39 @@ module Commiti
       yellow: 33,
       blue: 34,
       cyan: 36,
+      magenta: 35,
       gray: 90,
       bold: 1
     }.freeze
 
-    SYMBOLS = {
-      success: '✅',
-      fail: '❌',
+    UNICODE_ICONS = {
+      success: '✔',
+      fail: '✖',
       info: 'ℹ',
       warn: '⚠'
     }.freeze
 
+    ASCII_ICONS = {
+      success: '+',
+      fail: 'x',
+      info: 'i',
+      warn: '!'
+    }.freeze
+
+    UNICODE_MARKERS = {
+      prompt: '›',
+      header: '▸',
+      bullet: '•',
+      rule: '─'
+    }.freeze
+
+    ASCII_MARKERS = {
+      prompt: '>',
+      header: '>',
+      bullet: '-',
+      rule: '-'
+    }.freeze
+
     def self.supports_ansi?
       return false unless $stdout.tty?
       return false if ENV.key?('NO_COLOR')
@@ -27,6 +51,23 @@ module Commiti
       term != 'dumb'
     end
 
+    def self.supports_unicode?
+      encoding = $stdout.external_encoding || Encoding.default_external
+      encoding.name.upcase.include?('UTF-8')
+    rescue StandardError
+      false
+    end
+
+    def self.width
+      cols = IO.console&.winsize&.last
+      cols = ENV.fetch('COLUMNS', nil) if cols.nil? || cols <= 0
+      cols = cols.to_i
+      cols = 80 if cols <= 0
+      [cols, 120].min
+    rescue StandardError
+      80
+    end
+
     def self.color(text, *styles)
       return text unless supports_ansi?
 
@@ -37,22 +78,77 @@ module Commiti
     end
 
     def self.status(kind, text)
-      symbol = SYMBOLS.fetch(kind, '*')
+      symbol = icon_for(kind)
       color_style = case kind
                     when :success then :green
                     when :fail then :red
                     when :warn then :yellow
                     else :blue
                     end
-      "#{color(symbol, color_style)} #{text}"
+      "#{color(symbol, color_style, :bold)} #{text}"
     end
 
-    def self.separator(length = 60)
-      color('─' * length, :gray)
+    def self.separator(length = nil)
+      char = marker(:rule)
+      color(char * (length || width), :gray)
     end
 
     def self.header(text)
-      color(text, :bold, :cyan)
+      "#{color(marker(:header), :cyan, :bold)} #{color(text, :bold, :cyan)}"
+    end
+
+    def self.prompt(text)
+      "#{color(marker(:prompt), :cyan, :bold)} #{text}"
+    end
+
+    def self.muted(text)
+      color(text, :gray)
+    end
+
+    def self.panel(title, body)
+      [
+        separator,
+        header(title),
+        separator,
+        body.to_s.rstrip,
+        separator
+      ].join("\n")
+    end
+
+    def self.bullet(text)
+      "#{marker(:bullet)} #{text}"
+    end
+
+    def self.bullets(items)
+      items.map { |item| bullet(item) }.join("\n")
+    end
+
+    def self.pad_right(text, length)
+      padding = [length - visible_length(text), 0].max
+      "#{text}#{' ' * padding}"
+    end
+
+    def self.visible_length(text)
+      strip_ansi(text).length
+    end
+
+    def self.strip_ansi(text)
+      text.to_s.gsub(/\e\[[0-9;]*m/, '')
+    end
+
+    def self.banner(title:, subtitle: nil, meta: nil)
+      body_lines = [subtitle, meta].compact.join("\n")
+      panel(title, body_lines)
+    end
+
+    def self.icon_for(kind)
+      (supports_unicode? ? UNICODE_ICONS : ASCII_ICONS).fetch(kind, '*')
+    end
+    private_class_method :icon_for
+
+    def self.marker(kind)
+      (supports_unicode? ? UNICODE_MARKERS : ASCII_MARKERS).fetch(kind, '*')
     end
+    private_class_method :marker
   end
 end

data/lib/services/message_generator.rb

@@ -18,7 +18,7 @@ module Commiti
 
     def generate_candidates(client:, prompt:, diff_metadata:, count:, model:)
       (1..count).map do |index|
-        puts "\nGenerating candidate #{index}/#{count}..."
+        puts "\n#{Commiti::TerminalUI.status(:info, "Generating candidate #{index}/#{count}...")}"
         generate_with_quality_check(client: client, prompt: prompt, diff_metadata: diff_metadata, model: model)
       end
     end
@@ -35,8 +35,8 @@ module Commiti
       return normalize_commit_message(message, diff_metadata: diff_metadata) if reason.nil? && flow_type == :commit
       return message if reason.nil?
 
-      puts "\nGenerated output looked weak: #{reason}"
-      puts "Retrying once with stronger constraints...\n"
+      puts "\n#{Commiti::TerminalUI.status(:warn, "Generated output looked weak: #{reason}")}"
+      puts "#{Commiti::TerminalUI.status(:info, 'Retrying once with stronger constraints...')}\n"
 
       retried_message = clean_output(generate_from_client(
                                        client: client,

data/lib/services/message_presenter.rb

@@ -35,18 +35,13 @@ module Commiti
       end
     end
 
-    def self.print_message(message)
-      puts "\n#{Commiti::TerminalUI.separator}"
-      puts Commiti::TerminalUI.header('Generated output')
-      puts Commiti::TerminalUI.separator
-      puts message
-      puts "#{Commiti::TerminalUI.separator}\n"
+    def self.print_message(message, title: 'Generated output')
+      puts "\n#{Commiti::TerminalUI.panel(title, message)}\n"
     end
 
     def self.print_candidates(candidates)
       candidates.each_with_index do |candidate, index|
-        puts "\n#{Commiti::TerminalUI.header("Candidate #{index + 1}")}"
-        print_message(candidate)
+        print_message(candidate, title: "Candidate #{index + 1}")
       end
     end
     private_class_method :print_candidates

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: commiti
 version: !ruby/object:Gem::Version
-  version: 1.3.2
+  version: 1.3.3
 platform: ruby
 authors:
 - Setoju
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-05-22 00:00:00.000000000 Z
+date: 2026-05-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dotenv
@@ -61,6 +61,7 @@ files:
 - lib/services/git/commit/change_grouping.rb
 - lib/services/git/commit/commit_execution.rb
 - lib/services/git/commit/commit_staging.rb
+- lib/services/git/commit/group_editor.rb
 - lib/services/git/diff_parser.rb
 - lib/services/git/git_reader.rb
 - lib/services/git/git_writer.rb