commiti 1.3.0 → 1.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 751893cc1501fbd4723682605f17bcc6f0617fafe28997b398affd8e33a20d1e
-  data.tar.gz: 6b05cf37e1617655547c5e2de646dd75d07cde47d0883b70ee8eb7114242719b
+  metadata.gz: 82b26f3eb5a9606aa58e723e85a764395b485d7d84175878560173262c266615
+  data.tar.gz: 4e92dadbaf1f3fc84f15b4650b632a054aa0ddf924349590d652361964213db5
 SHA512:
-  metadata.gz: 777e2d6ddc6e40f0599abbe0ee191b819993926c5e0ca5bed79abb81407071356fa97807de031ba21dc3221a96bfa8b526765ee35a80aeee95cf9410c952214f
-  data.tar.gz: 739b300910794916477e8222b1ba2ea4f08698c337b1af10273c126a8fe8f3c619c6ed8171134cf545550e10767746b3b8d0da29f4cd203627ac7e26108edabf
+  metadata.gz: b0fe4d3e034e6c05809c8ec000b1b44eecc8de21c3d166e5f8735f96f8d718d3bcfc2472a421f540e1509c203ed91c430d99122ae128bd4cfe9824d83de93efa
+  data.tar.gz: d79d70ab801e09ab81c8d6d2e9339b01d799ff874225ec49684b21e9e55baf0b85352ebf8914e2710a3ed4a2d46496f567ca9ee7cce2106047da8129e90c5ec0

data/README.md

@@ -39,25 +39,49 @@ commiti [options]
 
 ## Configuration
 
-Commiti uses a single configuration approach: environment variables.
+Commiti uses environment variables for secrets and a checked-in project config file for text-generation styling.
 
 Set variables in your shell, CI secret manager, or local `.env` file (in your project):
 
 ```dotenv
 GOOGLE_API_KEY=your_google_ai_key
 
+# Optional: provider API tokens for API-first PR/MR creation
+# COMMITI_GITHUB_TOKEN=your_github_token
+# COMMITI_GITLAB_TOKEN=your_gitlab_token
+# COMMITI_GITBUCKET_TOKEN=your_gitbucket_token
+
 # Optional overrides:
 # COMMITI_MODEL=gemma-4-31b-it
 # COMMITI_CANDIDATES=1
 # COMMITI_BASE_BRANCH=main
 # COMMITI_NO_COPY=false
 # COMMITI_AUTO_SPLIT=false
+
+# Optional per-project prompt styling (safe YAML, no code execution):
+# COMMITI_CONFIG=.commiti.yml
 ```
 
 `GEMINI_API_KEY` is also accepted as an alias for `GOOGLE_API_KEY`.
 
 You can copy `.env.example` as a starting point.
 
+For project-specific wording and structure, add a `.commiti.yml` file at the repo root:
+
+```yaml
+text_generation:
+  commit:
+    subject_case: uppercase # uppercase, lowercase, or preserve
+  pr:
+    sections:
+      - name: Overview
+        guidance: Summarize the change in one paragraph.
+      - name: Validation
+        guidance: Describe the checks or tests that were run.
+```
+
+The file is parsed with safe YAML loading, and Commiti only accepts declarative styling settings from it.
+
 Your API key is sent directly from your local process to Google's API.
 Commiti does not store it and does not proxy requests through any Commiti server.
 Never commit `.env` to git.
@@ -113,14 +137,52 @@ Commit edit mode uses:
    - `## Motivation`
    - `## Changes Made`
    - `## Testing Notes`
-3. Builds provider compare/MR URL with prefilled title/body using query params.
-  - 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.
+3. Attempts to create and open PR/MR:
+   - **API-first path** (when token is configured):
+     - GitHub/GitBucket: creates PR via provider API and opens the created PR URL.
+     - GitLab: creates MR via provider API and opens the created MR URL.
+   - **Fallback path** (when no token, provider unsupported, or API call fails):
+     - Opens browser with prefilled PR/MR form using query parameters.
+     - If the URL would exceed safe browser/provider limits (~1800 characters), Commiti keeps the title and intelligently truncates the description to the longest text that still fits.
 4. Asks before opening browser.
 
-The tool opens a browser URL only. It does not call provider APIs.
+Commiti can create PRs/MRs via provider APIs when tokens are configured, and always opens the resulting page in your browser.
+
+### Provider API Logic
+
+When you set a provider token in your configuration, Commiti uses an **API-first strategy**:
+
+**Supported Providers:**
+- **GitHub** (github.com and GitHub Enterprise): Uses GitHub REST API v3
+- **GitLab** (gitlab.com and self-hosted): Uses GitLab API v4
+- **GitBucket**: Uses GitHub-compatible API
+
+**Token Configuration:**
+```dotenv
+COMMITI_GITHUB_TOKEN=ghp_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+COMMITI_GITLAB_TOKEN=glpat-xxxxxxxxxxxxxxxxxxxxxxxxxxxx
+COMMITI_GITBUCKET_TOKEN=xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+```
+
+**API Request Flow:**
+1. Parses the Git remote URL to extract provider, host, namespace, and repository.
+2. Constructs provider-specific API endpoint and authentication headers.
+3. Sends HTTP POST request with generated PR title and description.
+4. On success (HTTP 2xx): Returns the created PR/MR URL directly.
+5. On failure: Falls back to browser prefill with a user-friendly error message explaining why.
+
+**Error Handling:**
+- **Missing token**: Falls back to browser prefill. (Info message)
+- **Unsupported provider**: Falls back to browser prefill. (Warning message)
+- **API error**: Falls back to browser prefill with error details. (Warning message)
+- **Redirect handling**: Automatically follows HTTP redirects (301, 302, 307, 308) but aborts if redirected to a different host.
+- **Network errors**: Caught and reported with fallback to browser prefill.
+
+**Advantages of API-First:**
+- Creates PR/MR immediately without manual form interaction.
+- Preserves full description text (no URL length constraints).
+- Seamlessly opens the created PR/MR for immediate review and collaboration.
+- Gracefully degrades to browser prefill if API is unavailable.
 
 ### Diff Context Protocol
 
@@ -180,7 +242,7 @@ Core services:
 - `lib/services/diff_summarization/diff_summarizer.rb`: Orchestrates large-diff summarization and summary combine.
   - `lib/services/diff_summarization/batch_runner.rb`: Runs asynchronous, batched per-file summarization jobs.
   - `lib/services/diff_summarization/fallback_builder.rb`: Builds deterministic summaries when model summarization fails or times out.
-- `lib/services/helpers/config_loader.rb`: Loads configuration from environment variables.
+- `lib/services/helpers/config_loader.rb`: Loads environment config plus secure project-level text-generation styling.
   - `lib/services/helpers/prompt_builder.rb`: Builds strict system/user prompts for commit and PR modes.
   - `lib/services/helpers/interactive_prompt.rb`: Handles confirmation prompts, candidate selection, editor loop, and commit message validation.
   - `lib/services/helpers/clipboard.rb`: Provides cross-platform clipboard support.

data/lib/commiti.rb

@@ -2,6 +2,7 @@
 
 require_relative 'services/git/git_reader'
 require_relative 'services/git/git_writer'
+require_relative 'services/text_generation_style'
 require_relative 'services/google_client'
 require_relative 'services/helpers/config_loader'
 require_relative 'services/git/diff_parser'
@@ -9,7 +10,9 @@ require_relative 'services/diff_summarization/diff_summarizer'
 require_relative 'services/helpers/prompt_builder'
 require_relative 'services/helpers/interactive_prompt'
 require_relative 'services/git/pr/pr_opener'
+require_relative 'services/git/pr/pr_creator'
 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'

data/lib/flows/base_flow.rb

@@ -18,7 +18,8 @@ module Commiti
           diff: diff,
           client: client,
           run_stage: method(:run_stage),
-          model: selected_model
+          model: selected_model,
+          text_generation_config: options[:text_generation]
         )
         Commiti::MessagePresenter.print_summarization_notice(context[:summarized_result])
 
@@ -91,7 +92,11 @@ module Commiti
       end
 
       def message_generator
-        @message_generator ||= Commiti::MessageGenerator.new(flow_type: flow_type, run_stage: method(:run_stage))
+        @message_generator ||= Commiti::MessageGenerator.new(
+          flow_type: flow_type,
+          run_stage: method(:run_stage),
+          text_generation_config: options[:text_generation]
+        )
       end
     end
   end

data/lib/flows/commit_flow.rb

@@ -51,7 +51,8 @@ module Commiti
       end
 
       def run_single_group_context(context:, client:, model:)
-        puts "\nAuto-split found a single connected change group. Falling back to single commit flow."
+        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:)
@@ -63,7 +64,7 @@ module Commiti
         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."
+        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
@@ -74,7 +75,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 "\nGroup #{index + 1}/#{total} files:"
+        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:)
@@ -84,7 +85,8 @@ module Commiti
         maybe_copy_to_clipboard(message)
         return :continue if finalize(message) == :committed
 
-        puts "Stopping auto-split flow at group #{index + 1} because commit was skipped."
+        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

data/lib/flows/pr_flow.rb

@@ -20,25 +20,53 @@ module Commiti
       end
 
       def maybe_open_pr_page(description, base_branch)
-        pr_url = run_stage('Preparing prefilled PR URL') do
-          head_branch = Commiti::GitWriter.current_branch
-          origin_url = Commiti::GitWriter.origin_url
-          title = Commiti::PrOpener.suggest_title(description, head_branch: head_branch)
-          Commiti::PrOpener.compare_url(
+        head_branch = Commiti::GitWriter.current_branch
+        origin_url = Commiti::GitWriter.origin_url
+        title = Commiti::PrOpener.suggest_title(description, head_branch: head_branch)
+
+        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"
+          return
+        end
+
+        api_result = run_stage('Creating PR/MR via provider API (if token configured)') do
+          Commiti::PrCreator.create(
             origin_url: origin_url,
             base_branch: base_branch,
             head_branch: head_branch,
             title: title,
-            body: description
+            body: description,
+            config: options
           )
         end
 
-        if Commiti::InteractivePrompt.ask_yes_no('Open prefilled PR page in browser now?', default: :no)
-          run_stage('Opening browser') { Commiti::PrOpener.open_in_browser(pr_url) }
-          puts "\nOpened PR page:\n#{pr_url}\n\n"
-        else
-          puts "\nPR URL:\n#{pr_url}\n\n"
+        pr_url = api_result[:url]
+
+        if pr_url.nil?
+          case api_result[:reason]
+          when :missing_token
+            puts "\n#{Commiti::TerminalUI.status(:info, "No #{api_result[:provider]} token configured; using browser prefill fallback.")}"
+          when :unsupported_provider
+            puts "\n#{Commiti::TerminalUI.status(:warn, 'Provider API is unsupported; using browser prefill fallback.')}"
+          when :api_error
+            puts "\n#{Commiti::TerminalUI.status(:warn, "PR API create failed: #{api_result[:error]}. Using browser prefill fallback.")}"
+          end
+
+          pr_url = run_stage('Preparing prefilled PR URL') do
+            Commiti::PrOpener.compare_url(
+              origin_url: origin_url,
+              base_branch: base_branch,
+              head_branch: head_branch,
+              title: title,
+              body: description
+            )
+          end
         end
+
+        run_stage('Opening browser') { Commiti::PrOpener.open_in_browser(pr_url) }
+        puts "\nOpened PR page:\n#{pr_url}\n\n"
       end
     end
   end

data/lib/services/diff_summarization/fallback_builder.rb

@@ -12,49 +12,88 @@ module Commiti
 
       def fallback_summary(diff, chunks: nil)
         parsed_chunks = chunks || Commiti::DiffParser.split_by_file(diff)
-        files = []
+        files = file_stats_for(parsed_chunks)
+        return diff.to_s[0, FALLBACK_BYTES] if files.empty?
 
-        parsed_chunks.each do |chunk|
-          current = {
-            path: chunk[:path].to_s,
-            additions: 0,
-            deletions: 0,
-            status: 'modified'
-          }
+        render_fallback_summary(files)
+      end
 
-          chunk[:diff].to_s.each_line do |line|
-            stripped = line.strip
-            current[:status] = 'added' if stripped.start_with?('new file mode')
-            current[:status] = 'deleted' if stripped.start_with?('deleted file mode')
-            current[:status] = 'renamed' if stripped.start_with?('rename from ') || stripped.start_with?('rename to ')
+      private
 
-            next if line.start_with?('diff --git ', '+++', '---', '@@')
+      def file_stats_for(chunks)
+        chunks.map { |chunk| file_stats_for_chunk(chunk) }
+      end
+
+      def file_stats_for_chunk(chunk)
+        status, additions, deletions = file_status_and_counts(chunk[:diff])
+        {
+          path: chunk[:path].to_s,
+          additions: additions,
+          deletions: deletions,
+          status: status
+        }
+      end
 
-            current[:additions] += 1 if line.start_with?('+')
-            current[:deletions] += 1 if line.start_with?('-')
-          end
+      def file_status_and_counts(diff_text)
+        status = 'modified'
+        additions = 0
+        deletions = 0
 
-          files << current
+        diff_text.to_s.each_line do |line|
+          status = detect_status(line, current: status)
+          next if metadata_line?(line)
+
+          additions += 1 if line.start_with?('+')
+          deletions += 1 if line.start_with?('-')
         end
 
-        return diff.to_s[0, FALLBACK_BYTES] if files.empty?
+        [status, additions, deletions]
+      end
+
+      def detect_status(line, current:)
+        stripped = line.strip
+        return 'added' if stripped.start_with?('new file mode')
+        return 'deleted' if stripped.start_with?('deleted file mode')
+        return 'renamed' if stripped.start_with?('rename from ') || stripped.start_with?('rename to ')
 
-        lines = []
-        lines << '### Diff Overview'
-        lines << "- Total files changed: #{files.length}"
-        lines << ''
+        current
+      end
+
+      def metadata_line?(line)
+        line.start_with?('diff --git ', '+++', '---', '@@')
+      end
+
+      def render_fallback_summary(files)
+        summary_lines = [
+          '### Diff Overview',
+          "- Total files changed: #{files.length}",
+          ''
+        ]
+
+        append_file_sections(summary_lines, files)
+        append_truncation_notice(summary_lines, files)
 
+        summary_lines.join("\n").strip
+      end
+
+      def append_file_sections(summary_lines, files)
         files.first(MAX_FILES_IN_SUMMARY).each do |file|
-          lines << "### #{file[:path]}"
-          lines << "- Status: #{file[:status]}"
-          lines << "- Added lines: #{file[:additions]}"
-          lines << "- Removed lines: #{file[:deletions]}"
-          lines << ''
+          summary_lines.concat(render_file_section(file))
         end
+      end
 
-        lines << "...and #{files.length - MAX_FILES_IN_SUMMARY} more files" if files.length > MAX_FILES_IN_SUMMARY
+      def append_truncation_notice(summary_lines, files)
+        summary_lines << "...and #{files.length - MAX_FILES_IN_SUMMARY} more files" if files.length > MAX_FILES_IN_SUMMARY
+      end
 
-        lines.join("\n").strip
+      def render_file_section(file)
+        [
+          "### #{file[:path]}",
+          "- Status: #{file[:status]}",
+          "- Added lines: #{file[:additions]}",
+          "- Removed lines: #{file[:deletions]}",
+          ''
+        ]
       end
     end
   end

data/lib/services/flow_context_builder.rb

@@ -2,7 +2,7 @@
 
 module Commiti
   module FlowContextBuilder
-    def self.build(flow_type:, diff:, client:, run_stage:, model:)
+    def self.build(flow_type:, diff:, client:, run_stage:, model:, text_generation_config: nil)
       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)
@@ -21,7 +21,8 @@ module Commiti
         diff: summarized_result[:content],
         summarized: summarized_result[:summarized],
         raw_diff: diff,
-        diff_metadata: diff_metadata
+        diff_metadata: diff_metadata,
+        style_config: text_generation_config
       )
 
       {

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

@@ -10,47 +10,66 @@ module Commiti
 
         case action
         when :yes
-          errors = Commiti::InteractivePrompt.commit_message_errors(working_message)
-          unless errors.empty?
-            puts "\nCurrent 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 :skipped
-              end
-
-              working_message = edited
-              print_message.call(working_message)
-              next
-            end
-
-            puts "\nCommit skipped.\n\n"
-            return :skipped
-          end
+          result, next_message = handle_yes_action(
+            working_message,
+            run_stage: run_stage,
+            print_message: print_message
+          )
+          return result if result
 
-          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 :committed
+          working_message = next_message
         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"
+          print_skip_message
           return :skipped
         end
       end
     end
 
+    def self.handle_yes_action(working_message, run_stage:, print_message:)
+      errors = Commiti::InteractivePrompt.commit_message_errors(working_message)
+      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}" }
+
+      unless Commiti::InteractivePrompt.ask_yes_no('Open editor to fix now?', default: :yes)
+        print_skip_message
+        return [:skipped, nil]
+      end
+
+      edited = edit_message_until_valid(working_message)
+      if edited.nil?
+        puts "\n#{Commiti::TerminalUI.status(:fail, 'Editor did not exit successfully. Commit skipped.')}\n\n"
+        return [:skipped, nil]
+      end
+
+      print_message.call(edited)
+      [nil, edited]
+    end
+    private_class_method :handle_yes_action
+
+    def self.commit_message(message, run_stage:)
+      output = run_stage.call('Writing commit') { Commiti::GitWriter.commit_with_message_file(message) }
+      puts output unless output.to_s.strip.empty?
+      puts "\n#{Commiti::TerminalUI.status(:success, 'Commit created.')}\n\n"
+      [:committed, nil]
+    end
+    private_class_method :commit_message
+
+    def self.print_skip_message
+      puts "\n#{Commiti::TerminalUI.status(:warn, 'Commit skipped.')}\n\n"
+    end
+    private_class_method :print_skip_message
+
     def self.edit_message_until_valid(initial_message)
       working = initial_message
 
@@ -59,7 +78,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 +87,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"
+      puts "\n#{Commiti::TerminalUI.status(:success, 'Staged changes with git add -A.')}\n"
     end
     private_class_method :maybe_stage_changes
 
@@ -26,7 +26,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! }
-        puts "\nStaged changes with git add -A.\n"
+        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_reader.rb

@@ -124,34 +124,44 @@ module Commiti
       output = +''
       return output if max_bytes <= 0
 
+      header_lines, hunks = partition_chunk_lines(lines)
+      append_lines_with_limit(output, header_lines, max_bytes: max_bytes)
+      return output if hunks.empty?
+
+      append_hunks_with_limit(output, hunks, max_bytes: max_bytes)
+      output
+    end
+
+    def self.partition_chunk_lines(lines)
       header_lines = []
       hunks = []
       current_hunk = nil
-      in_hunks = false
 
       lines.each do |line|
         if line.start_with?('@@')
-          in_hunks = true
           current_hunk = [line]
           hunks << current_hunk
-          next
-        end
-
-        if in_hunks
+        elsif current_hunk
           current_hunk << line
         else
           header_lines << line
         end
       end
 
-      header_lines.each do |line|
+      [header_lines, hunks]
+    end
+    private_class_method :partition_chunk_lines
+
+    def self.append_lines_with_limit(output, lines, max_bytes:)
+      lines.each do |line|
         break if output.bytesize + line.bytesize > max_bytes
 
         output << line
       end
+    end
+    private_class_method :append_lines_with_limit
 
-      return output if hunks.empty?
-
+    def self.append_hunks_with_limit(output, hunks, max_bytes:)
       hunks.each do |hunk|
         hunk_text = hunk.join
         if output.bytesize + hunk_text.bytesize <= max_bytes
@@ -159,20 +169,20 @@ module Commiti
           next
         end
 
-        hunk_header = hunk.first
-        break if output.bytesize + hunk_header.bytesize > max_bytes
-
-        output << hunk_header
-        hunk[1..].to_a.each do |line|
-          break if output.bytesize + line.bytesize > max_bytes
-
-          output << line
-        end
+        append_partial_hunk(output, hunk, max_bytes: max_bytes)
         break
       end
+    end
+    private_class_method :append_hunks_with_limit
 
-      output
+    def self.append_partial_hunk(output, hunk, max_bytes:)
+      hunk_header = hunk.first
+      return if output.bytesize + hunk_header.bytesize > max_bytes
+
+      output << hunk_header
+      append_lines_with_limit(output, hunk[1..].to_a, max_bytes: max_bytes)
     end
+    private_class_method :append_partial_hunk
 
     def self.append_notice(clipped_diff, max_bytes:)
       safe_clipped = clipped_diff.to_s