commiti 1.2.3 → 1.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 55dfe17b32ed45b600920943c16b99f39b0acff0c9c66e516db63e6fa7a0debf
-  data.tar.gz: 9f70caaeef73f63211e93bd28ae2ae69236c0e777153c48a765066a0825e4e49
+  metadata.gz: 026566db469248936e47f40faa446650926b7bb893089246a6c23a45dfaa432a
+  data.tar.gz: 251995106b1883d61cb12c00f911a4e3158d6d47e9b9d1b434d2026234dd3c2f
 SHA512:
-  metadata.gz: a627866611dcc0974b30a005814b38226833412a1789a57f4f3559c010849313731d361dd0d0e192722577e0f1353d8fa55c2bf9487c4d83bbe596e7d5a04e16
-  data.tar.gz: 0b8e9679be21a6f74ea419ffb4968f883fb564990eeab845c63f525190d459a151cebc17d2d852a3eba9f8293093107bd146e76cf37cae8087af88bd06f53e5e
+  metadata.gz: c0d857c40f016686ee37b6b7f2d1109c5d7f79a7037c0ed41d0e49e1d3556ff57ce0db9f1da3f0f26e4956840e5a7ab0376a39799f359673068542e89a11480c
+  data.tar.gz: 677c08e9d0d5ae62723f7bb3fdea97c3c3799dd5a3775b133ca5520af32a102d924863c5f733794e005b3ff82c79a22d30a7aaee578985118ec0af31cd13c8ce

data/README.md

@@ -51,6 +51,7 @@ GOOGLE_API_KEY=your_google_ai_key
 # COMMITI_CANDIDATES=1
 # COMMITI_BASE_BRANCH=main
 # COMMITI_NO_COPY=false
+# COMMITI_AUTO_SPLIT=false
 ```
 
 `GEMINI_API_KEY` is also accepted as an alias for `GOOGLE_API_KEY`.
@@ -67,10 +68,14 @@ Never commit `.env` to git.
 - `--base BRANCH` base branch for PR diff (default: `main`)
 - `--no-copy` print output only, skip clipboard copy
 - `--candidates N` generate `N` output candidates (`1`-`5`, default: `1`)
+- `--auto-split` auto-group staged changes into multiple connected commits (commit flow only)
 - `-h`, `--help` show help
 
 ## Commit Flow (`--type commit`)
 
+By default, Commiti creates a single commit from staged changes.
+Use `--auto-split` to let Commiti group connected file changes into multiple atomic commits.
+
 1. Shows `git status --short`.
 2. Asks for confirmation before staging (`git add -A`).
 3. Ensures there are staged changes.
@@ -109,7 +114,8 @@ Commit edit mode uses:
    - `## Changes Made`
    - `## Testing Notes`
 3. Builds provider compare/MR URL with prefilled title/body using query params.
-  - GitHub/GitBucket: compare URL
+  - GitHub: compare URL with `quick_pull=1` (opens the PR form directly)
+  - GitBucket: compare URL with `expand=1`
   - GitLab: new merge request URL
    - If the URL would exceed safe browser/provider limits, Commiti drops description prefill automatically and keeps the shortest usable URL.
 4. Asks before opening browser.

data/bin/commiti

@@ -6,7 +6,8 @@ require 'dotenv/load'
 require 'commiti'
 
 options = {
-  type: :commit
+  type: :commit,
+  auto_split: false
 }
 
 OptionParser.new do |opts|
@@ -35,6 +36,10 @@ OptionParser.new do |opts|
     options[:candidates] = n
   end
 
+  opts.on('--auto-split', 'Auto-group staged changes into multiple connected commits (commit flow only)') do
+    options[:auto_split] = true
+  end
+
   opts.on('-h', '--help', 'Show this help') do
     puts opts
     exit

data/lib/commiti.rb

@@ -10,12 +10,14 @@ require_relative 'services/helpers/prompt_builder'
 require_relative 'services/helpers/interactive_prompt'
 require_relative 'services/git/pr/pr_opener'
 require_relative 'services/helpers/clipboard'
+require_relative 'services/helpers/terminal_ui'
 require_relative 'services/helpers/spinner'
 require_relative 'services/flow_context_builder'
 require_relative 'services/message_generator'
 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 'flows/base_flow'
 require_relative 'flows/commit_flow'
 require_relative 'flows/pr_flow'

data/lib/flows/commit_flow.rb

@@ -3,6 +3,12 @@
 module Commiti
   module Flows
     class CommitFlow < BaseFlow
+      def run
+        return super unless options[:auto_split]
+
+        run_auto_split
+      end
+
       private
 
       def flow_type
@@ -24,6 +30,91 @@ module Commiti
           print_message: method(:print_message)
         )
       end
+
+      def run_auto_split
+        prepare!
+        diff = collect_diff
+        client = Commiti::GoogleClient.new(config: options)
+        selected_model = options[:model]
+        context = build_context(diff:, client:, model: selected_model)
+
+        return run_single_group_context(context:, client:, model: selected_model) if single_group?(context)
+
+        run_grouped_context(context:, client:, model: selected_model)
+      rescue StandardError
+        run_stage('Restaging uncommitted changes after failure') { Commiti::GitWriter.stage_all! }
+        raise
+      end
+
+      def single_group?(context)
+        context[:change_groups].length <= 1
+      end
+
+      def run_single_group_context(context:, client:, model:)
+        message = 'Auto-split found a single connected change group. Falling back to single commit flow.'
+        puts "\n#{Commiti::TerminalUI.status(:info, message)}"
+        Commiti::MessagePresenter.print_summarization_notice(context[:summarized_result])
+
+        message = generate_message_for_context(context:, client:, model:)
+        maybe_copy_to_clipboard(message)
+        finalize(message)
+      end
+
+      def run_grouped_context(context:, client:, model:)
+        groups = context[:change_groups]
+        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.")}"
+
+        groups.each_with_index do |group, index|
+          break if process_group(group:, index:, total: groups.length, client:, model:) == :stop
+        end
+      end
+
+      def process_group(group:, index:, total:, client:, model:)
+        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}" }
+
+        group_context = build_context(diff: group_diff(group), client:, model:)
+        Commiti::MessagePresenter.print_summarization_notice(group_context[:summarized_result])
+
+        message = generate_message_for_context(context: group_context, client:, model:)
+        maybe_copy_to_clipboard(message)
+        return :continue if finalize(message) == :committed
+
+        stop_message = "Stopping auto-split flow at group #{index + 1} because commit was skipped."
+        puts Commiti::TerminalUI.status(:warn, stop_message)
+        run_stage('Restaging remaining uncommitted changes') { Commiti::GitWriter.stage_all! }
+        :stop
+      end
+
+      def build_context(diff:, client:, model:)
+        Commiti::FlowContextBuilder.build(
+          flow_type: flow_type,
+          diff: diff,
+          client: client,
+          run_stage: method(:run_stage),
+          model: model
+        )
+      end
+
+      def generate_message_for_context(context:, client:, model:)
+        candidates = generate_candidates(
+          client: client,
+          prompt: context[:prompt],
+          diff_metadata: context[:diff_metadata],
+          model: model
+        )
+
+        select_message(candidates)
+      end
+
+      def group_diff(group)
+        group[:chunks].map { |chunk| chunk[:lines].join }.join
+      end
     end
   end
 end

data/lib/services/flow_context_builder.rb

@@ -5,6 +5,7 @@ module Commiti
     def self.build(flow_type:, diff:, client:, run_stage:, model:)
       line_chunks = Commiti::DiffParser.split_by_file_lines(diff)
       diff_metadata = Commiti::DiffParser.metadata_from_line_chunks(line_chunks)
+      change_groups = Commiti::ChangeGrouping.group(line_chunks)
 
       summarized_result = run_stage.call('Preparing diff for AI model') do
         Commiti::DiffSummarizer.summarize_if_needed(
@@ -25,6 +26,7 @@ module Commiti
 
       {
         diff_metadata: diff_metadata,
+        change_groups: change_groups,
         summarized_result: summarized_result,
         prompt: prompt
       }

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

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Commiti
+  module ChangeGrouping
+    NOISE_DIRECTORIES = %w[lib spec test app src docs].freeze
+
+    def self.group(line_chunks)
+      paths = line_chunks.map { |chunk| chunk[:path].to_s.strip }.reject(&:empty?).uniq
+      return [] if paths.empty?
+
+      components = connected_components(paths)
+      components.map.with_index(1) do |component, index|
+        {
+          id: index,
+          files: component,
+          chunks: line_chunks.select { |chunk| component.include?(chunk[:path]) }
+        }
+      end
+    end
+
+    def self.connected_components(paths)
+      visited = {}
+      ordered_components = []
+
+      paths.each do |root|
+        next if visited[root]
+
+        stack = [root]
+        visited[root] = true
+        component = []
+
+        until stack.empty?
+          current = stack.pop
+          component << current
+
+          paths.each do |candidate|
+            next if visited[candidate]
+            next unless connected?(current, candidate)
+
+            visited[candidate] = true
+            stack << candidate
+          end
+        end
+
+        ordered_components << component.sort_by { |path| paths.index(path) }
+      end
+
+      ordered_components
+    end
+    private_class_method :connected_components
+
+    def self.connected?(left, right)
+      return true if primary_namespace(left) == primary_namespace(right)
+      return true if logical_stem(left) == logical_stem(right)
+
+      left_segments = normalized_segments(left)
+      right_segments = normalized_segments(right)
+      shared_depth = [left_segments.length, right_segments.length].min
+
+      (0...shared_depth).count { |index| left_segments[index] == right_segments[index] } >= 2
+    end
+    private_class_method :connected?
+
+    def self.primary_namespace(path)
+      segments = normalized_segments(path)
+      return nil if segments.empty?
+
+      segments.first(2).join('/')
+    end
+    private_class_method :primary_namespace
+
+    def self.logical_stem(path)
+      normalized = path.to_s
+      normalized = normalized.sub(%r{\A(?:lib|spec|test|app|src)/}, '') while normalized.match?(%r{\A(?:lib|spec|test|app|src)/})
+      normalized = normalized.sub(/_spec\.[^.]+\z/, '')
+      normalized.sub(/\.[^.]+\z/, '')
+    end
+    private_class_method :logical_stem
+
+    def self.normalized_segments(path)
+      path.to_s.split('/').reject { |segment| segment.empty? || NOISE_DIRECTORIES.include?(segment) }
+    end
+    private_class_method :normalized_segments
+  end
+end

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

@@ -12,14 +12,14 @@ module Commiti
         when :yes
           errors = Commiti::InteractivePrompt.commit_message_errors(working_message)
           unless errors.empty?
-            puts "\nCurrent message needs fixes before commit:"
+            puts "\n#{Commiti::TerminalUI.status(:warn, 'Current message needs fixes before commit:')}"
             errors.each { |error| puts "- #{error}" }
 
             if Commiti::InteractivePrompt.ask_yes_no('Open editor to fix now?', default: :yes)
               edited = edit_message_until_valid(working_message)
               if edited.nil?
-                puts "\nEditor did not exit successfully. Commit skipped.\n\n"
-                return
+                puts "\n#{Commiti::TerminalUI.status(:fail, 'Editor did not exit successfully. Commit skipped.')}\n\n"
+                return :skipped
               end
 
               working_message = edited
@@ -27,26 +27,26 @@ module Commiti
               next
             end
 
-            puts "\nCommit skipped.\n\n"
-            return
+            puts "\n#{Commiti::TerminalUI.status(:warn, 'Commit skipped.')}\n\n"
+            return :skipped
           end
 
           output = run_stage.call('Writing commit') { Commiti::GitWriter.commit_with_message_file(working_message) }
           puts output unless output.to_s.strip.empty?
-          puts "\nCommit created.\n\n"
-          return
+          puts "\n#{Commiti::TerminalUI.status(:success, 'Commit created.')}\n\n"
+          return :committed
         when :edit
           edited = edit_message_until_valid(working_message)
           if edited.nil?
-            puts "\nEditor did not exit successfully.\n\n"
+            puts "\n#{Commiti::TerminalUI.status(:fail, 'Editor did not exit successfully.')}\n\n"
             next
           end
 
           working_message = edited
           print_message.call(working_message)
         else
-          puts "\nCommit skipped.\n\n"
-          return
+          puts "\n#{Commiti::TerminalUI.status(:warn, 'Commit skipped.')}\n\n"
+          return :skipped
         end
       end
     end
@@ -59,7 +59,7 @@ module Commiti
         return nil if edited.nil?
 
         if edited == working.to_s.strip
-          puts "\nNo changes detected in editor."
+          puts "\n#{Commiti::TerminalUI.status(:info, 'No changes detected in editor.')}"
           return edited unless Commiti::InteractivePrompt.ask_yes_no('Re-open editor now?', default: :yes)
 
           next
@@ -68,7 +68,7 @@ module Commiti
         errors = Commiti::InteractivePrompt.commit_message_errors(edited)
         return edited if errors.empty?
 
-        puts "\nEdited message needs fixes:"
+        puts "\n#{Commiti::TerminalUI.status(:warn, 'Edited message needs fixes:')}"
         errors.each { |error| puts "- #{error}" }
         return edited unless Commiti::InteractivePrompt.ask_yes_no('Re-open editor now?', default: :yes)
 

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

@@ -11,11 +11,11 @@ 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 "\nCurrent git status:\n\n#{status}"
+      puts "\n#{Commiti::TerminalUI.header('Current git status')}\n\n#{status}"
       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 }
-      puts "\nStaged changes with git add -A.\n"
+      run_stage.call('Staging changes (git add -A)') { Commiti::GitWriter.stage_all! }
+      puts "\n#{Commiti::TerminalUI.status(:success, 'Staged changes with git add -A.')}\n"
     end
     private_class_method :maybe_stage_changes
 
@@ -25,8 +25,8 @@ module Commiti
 
       if Commiti::InteractivePrompt.ask_yes_no('No staged changes found. Stage all changes now with git add -A?',
                                                default: :yes)
-        run_stage.call('Staging changes (git add -A)') { Commiti::GitWriter.stage_all }
-        puts "\nStaged changes with git add -A.\n"
+        run_stage.call('Staging changes (git add -A)') { Commiti::GitWriter.stage_all! }
+        puts "\n#{Commiti::TerminalUI.status(:success, 'Staged changes with git add -A.')}\n"
       end
 
       staged = run_stage.call('Checking staged changes') { Commiti::GitWriter.staged_changes? }

data/lib/services/git/git_writer.rb

@@ -19,11 +19,28 @@ module Commiti
       !out.strip.empty?
     end
 
-    def self.stage_all
+    def self.stage_all!
       out, err, status = Open3.capture3('git', 'add', '-A')
       raise "git add failed: #{err.strip.empty? ? out.strip : err.strip}" unless status.success?
 
-      true
+      out
+    end
+
+    def self.unstage_all!
+      out, err, status = Open3.capture3('git', 'reset')
+      raise "git reset failed: #{err.strip.empty? ? out.strip : err.strip}" unless status.success?
+
+      out
+    end
+
+    def self.stage_files!(paths)
+      normalized = Array(paths).map(&:to_s).map(&:strip).reject(&:empty?).uniq
+      return '' if normalized.empty?
+
+      out, err, status = Open3.capture3('git', 'add', '--', *normalized)
+      raise "git add failed: #{err.strip.empty? ? out.strip : err.strip}" unless status.success?
+
+      out
     end
 
     def self.commit_with_message_file(message)

data/lib/services/git/pr/pr_opener.rb

@@ -71,7 +71,9 @@ module Commiti
     private_class_method :prefilled_url
 
     def self.github_like_compare_url(remote:, base_branch:, head_branch:, title:, body:, include_title: true, include_body: true)
-      query_params = { 'expand' => '1' }
+      query_params = {
+        github_compare_prefill_param(remote[:provider]) => '1'
+      }
       normalized_title = normalize_title(title)
       query_params['title'] = normalized_title if include_title && !normalized_title.empty?
       query_params['body'] = body.to_s if include_body && !body.to_s.empty?
@@ -83,6 +85,11 @@ module Commiti
       "#{base}/#{path}/compare/#{encode_branch_for_path(base_branch)}...#{encode_branch_for_path(head_branch)}?#{query}"
     end
 
+    def self.github_compare_prefill_param(provider)
+      provider == :github ? 'quick_pull' : 'expand'
+    end
+    private_class_method :github_compare_prefill_param
+
     def self.gitlab_mr_url(remote:, base_branch:, head_branch:, title:, body:, include_title: true, include_description: true)
       query_params = {
         'merge_request[source_branch]' => head_branch,

data/lib/services/helpers/config_loader.rb

@@ -8,6 +8,7 @@ module Commiti
       candidates: 1,
       base_branch: 'main',
       no_copy: false,
+      auto_split: false,
       temperature: Commiti::GoogleClient::DEFAULT_TEMPERATURE,
       timeout_seconds: Commiti::GoogleClient::DEFAULT_TIMEOUT_SECONDS,
       open_timeout_seconds: Commiti::GoogleClient::DEFAULT_OPEN_TIMEOUT_SECONDS
@@ -22,6 +23,7 @@ module Commiti
         candidates: integer_or_default(env.fetch('COMMITI_CANDIDATES', nil), DEFAULT_CONFIG[:candidates]),
         base_branch: present_or_default(env.fetch('COMMITI_BASE_BRANCH', nil), DEFAULT_CONFIG[:base_branch]),
         no_copy: boolean_or_default(env.fetch('COMMITI_NO_COPY', nil), DEFAULT_CONFIG[:no_copy]),
+        auto_split: boolean_or_default(env.fetch('COMMITI_AUTO_SPLIT', nil), DEFAULT_CONFIG[:auto_split]),
         temperature: float_or_default(env.fetch('COMMITI_MODEL_TEMPERATURE', nil), DEFAULT_CONFIG[:temperature]),
         timeout_seconds: integer_or_default(env.fetch('COMMITI_MODEL_TIMEOUT_SECONDS', nil), DEFAULT_CONFIG[:timeout_seconds]),
         open_timeout_seconds: integer_or_default(env.fetch('COMMITI_MODEL_OPEN_TIMEOUT_SECONDS', nil),

data/lib/services/helpers/spinner.rb

@@ -5,13 +5,8 @@ module Commiti
     FRAMES = ['|', '/', '-', '\\'].freeze
     INTERVAL_SECONDS = 0.1
 
-    def self.run(message)
-      unless $stdout.tty?
-        puts "#{message}..."
-        result = yield
-        puts "[done] #{message}"
-        return result
-      end
+    def self.run(message, &block)
+      return run_without_spinner(message, &block) unless $stdout.tty?
 
       done = false
       error = nil
@@ -20,7 +15,7 @@ module Commiti
       spinner_thread = Thread.new do
         index = 0
         until done
-          frame = FRAMES[index % FRAMES.length]
+          frame = Commiti::TerminalUI.color(FRAMES[index % FRAMES.length], :cyan)
           print "\r#{frame} #{message}"
           $stdout.flush
           index += 1
@@ -29,15 +24,14 @@ module Commiti
       end
 
       begin
-        result = yield
+        result = block.call
       rescue StandardError => e
         error = e
       ensure
         done = true
         spinner_thread.join
 
-        status = error.nil? ? '[done]' : '[fail]'
-        print "\r#{status} #{message}\n"
+        print "\r#{final_status_line(error, message)}\n"
         $stdout.flush
       end
 
@@ -45,5 +39,19 @@ module Commiti
 
       result
     end
+
+    def self.run_without_spinner(message, &block)
+      puts Commiti::TerminalUI.status(:info, "#{message}...")
+      result = block.call
+      puts Commiti::TerminalUI.status(:success, message)
+      result
+    end
+    private_class_method :run_without_spinner
+
+    def self.final_status_line(error, message)
+      kind = error.nil? ? :success : :fail
+      Commiti::TerminalUI.status(kind, message)
+    end
+    private_class_method :final_status_line
   end
 end

data/lib/services/helpers/terminal_ui.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Commiti
+  module TerminalUI
+    COLORS = {
+      green: 32,
+      red: 31,
+      yellow: 33,
+      blue: 34,
+      cyan: 36,
+      gray: 90,
+      bold: 1
+    }.freeze
+
+    SYMBOLS = {
+      success: '✅',
+      fail: '❌',
+      info: 'ℹ',
+      warn: '⚠'
+    }.freeze
+
+    def self.supports_ansi?
+      return false unless $stdout.tty?
+      return false if ENV.key?('NO_COLOR')
+
+      term = ENV.fetch('TERM', '').downcase
+      term != 'dumb'
+    end
+
+    def self.color(text, *styles)
+      return text unless supports_ansi?
+
+      codes = styles.filter_map { |style| COLORS[style] }
+      return text if codes.empty?
+
+      "\e[#{codes.join(';')}m#{text}\e[0m"
+    end
+
+    def self.status(kind, text)
+      symbol = SYMBOLS.fetch(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}"
+    end
+
+    def self.separator(length = 60)
+      color('─' * length, :gray)
+    end
+
+    def self.header(text)
+      color(text, :bold, :cyan)
+    end
+  end
+end

data/lib/services/message_presenter.rb

@@ -4,9 +4,9 @@ module Commiti
   module MessagePresenter
     def self.print_summarization_notice(summarized_result)
       if summarized_result[:fallback_reason]
-        puts "\n#{summarized_result[:fallback_reason]}\n"
+        puts "\n#{Commiti::TerminalUI.status(:warn, summarized_result[:fallback_reason])}\n"
       elsif summarized_result[:summarized]
-        puts "\nDiff is large - summarizing first to preserve system prompt focus...\n"
+        puts "\n#{Commiti::TerminalUI.status(:info, 'Diff is large — summarizing first to preserve prompt focus.')}\n"
       end
     end
 
@@ -19,7 +19,7 @@ module Commiti
       print_candidates(candidates)
       selected_index = Commiti::InteractivePrompt.ask_candidate_selection(candidates.length)
       selected_message = candidates[selected_index]
-      puts "\nUsing candidate #{selected_index + 1}."
+      puts "\n#{Commiti::TerminalUI.status(:info, "Using candidate #{selected_index + 1}.")}"
       print_message(selected_message)
       selected_message
     end
@@ -29,21 +29,23 @@ module Commiti
 
       copied = run_stage.call('Copying output to clipboard') { Commiti::Clipboard.copy(message) }
       if copied
-        puts "Copied to clipboard!\n\n"
+        puts "#{Commiti::TerminalUI.status(:success, 'Copied output to clipboard!')}\n\n"
       else
-        puts "Clipboard not available. Install xclip: sudo apt install xclip\n\n"
+        puts "#{Commiti::TerminalUI.status(:warn, 'Clipboard unavailable. Install xclip: sudo apt install xclip')}\n\n"
       end
     end
 
     def self.print_message(message)
-      puts "\n#{'─' * 60}"
+      puts "\n#{Commiti::TerminalUI.separator}"
+      puts Commiti::TerminalUI.header('Generated output')
+      puts Commiti::TerminalUI.separator
       puts message
-      puts "#{'─' * 60}\n"
+      puts "#{Commiti::TerminalUI.separator}\n"
     end
 
     def self.print_candidates(candidates)
       candidates.each_with_index do |candidate, index|
-        puts "\nCandidate #{index + 1}:"
+        puts "\n#{Commiti::TerminalUI.header("Candidate #{index + 1}")}"
         print_message(candidate)
       end
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: commiti
 version: !ruby/object:Gem::Version
-  version: 1.2.3
+  version: 1.3.1
 platform: ruby
 authors:
 - Setoju
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-05-18 00:00:00.000000000 Z
+date: 2026-05-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dotenv
@@ -58,6 +58,7 @@ files:
 - lib/services/diff_summarization/diff_summarizer.rb
 - lib/services/diff_summarization/fallback_builder.rb
 - lib/services/flow_context_builder.rb
+- lib/services/git/commit/change_grouping.rb
 - lib/services/git/commit/commit_execution.rb
 - lib/services/git/commit/commit_staging.rb
 - lib/services/git/diff_parser.rb
@@ -70,6 +71,7 @@ files:
 - lib/services/helpers/interactive_prompt.rb
 - lib/services/helpers/prompt_builder.rb
 - lib/services/helpers/spinner.rb
+- lib/services/helpers/terminal_ui.rb
 - lib/services/message_generator.rb
 - lib/services/message_presenter.rb
 homepage: https://github.com/setoju/commiti