commiti 1.2.3 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 55dfe17b32ed45b600920943c16b99f39b0acff0c9c66e516db63e6fa7a0debf
-  data.tar.gz: 9f70caaeef73f63211e93bd28ae2ae69236c0e777153c48a765066a0825e4e49
+  metadata.gz: 751893cc1501fbd4723682605f17bcc6f0617fafe28997b398affd8e33a20d1e
+  data.tar.gz: 6b05cf37e1617655547c5e2de646dd75d07cde47d0883b70ee8eb7114242719b
 SHA512:
-  metadata.gz: a627866611dcc0974b30a005814b38226833412a1789a57f4f3559c010849313731d361dd0d0e192722577e0f1353d8fa55c2bf9487c4d83bbe596e7d5a04e16
-  data.tar.gz: 0b8e9679be21a6f74ea419ffb4968f883fb564990eeab845c63f525190d459a151cebc17d2d852a3eba9f8293093107bd146e76cf37cae8087af88bd06f53e5e
+  metadata.gz: 777e2d6ddc6e40f0599abbe0ee191b819993926c5e0ca5bed79abb81407071356fa97807de031ba21dc3221a96bfa8b526765ee35a80aeee95cf9410c952214f
+  data.tar.gz: 739b300910794916477e8222b1ba2ea4f08698c337b1af10273c126a8fe8f3c619c6ed8171134cf545550e10767746b3b8d0da29f4cd203627ac7e26108edabf

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

@@ -16,6 +16,7 @@ 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,89 @@ 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:)
+        puts "\nAuto-split found a single connected change group. Falling back to single commit flow."
+        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 "\nAuto-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 "\nGroup #{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
+
+        puts "Stopping auto-split flow at group #{index + 1} because commit was skipped."
+        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

@@ -19,7 +19,7 @@ module Commiti
               edited = edit_message_until_valid(working_message)
               if edited.nil?
                 puts "\nEditor did not exit successfully. Commit skipped.\n\n"
-                return
+                return :skipped
               end
 
               working_message = edited
@@ -28,13 +28,13 @@ module Commiti
             end
 
             puts "\nCommit skipped.\n\n"
-            return
+            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
+          return :committed
         when :edit
           edited = edit_message_until_valid(working_message)
           if edited.nil?
@@ -46,7 +46,7 @@ module Commiti
           print_message.call(working_message)
         else
           puts "\nCommit skipped.\n\n"
-          return
+          return :skipped
         end
       end
     end

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

@@ -14,7 +14,7 @@ module Commiti
       puts "\nCurrent 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 }
+      run_stage.call('Staging changes (git add -A)') { Commiti::GitWriter.stage_all! }
       puts "\nStaged changes with git add -A.\n"
     end
     private_class_method :maybe_stage_changes
@@ -25,7 +25,7 @@ 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 }
+        run_stage.call('Staging changes (git add -A)') { Commiti::GitWriter.stage_all! }
         puts "\nStaged changes with git add -A.\n"
       end
 

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),

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: commiti
 version: !ruby/object:Gem::Version
-  version: 1.2.3
+  version: 1.3.0
 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