commiti 1.3.1 → 1.3.3

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/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

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Commiti
+  module PrBrowserOpener
+    def self.open_in_browser(url)
+      success = if windows?
+                  open_windows_browser(url)
+                elsif mac?
+                  system('open', url)
+                else
+                  system('xdg-open', url)
+                end
+
+      raise 'Failed to open browser for PR URL.' unless success
+
+      nil
+    end
+
+    def self.open_windows_browser(url)
+      cleaned_url = url.to_s.strip.sub(/\A\\+/, '')
+
+      # Prefer shell protocol handler. This bypasses cmd/explorer parsing of '&'.
+      return true if system('rundll32', 'url.dll,FileProtocolHandler', cleaned_url)
+
+      # PowerShell fallback, passing URL as an argument to avoid command parsing.
+      system(
+        'powershell',
+        '-NoProfile',
+        '-Command',
+        '$u=$args[0]; Start-Process -FilePath $u',
+        '--',
+        cleaned_url
+      )
+    end
+
+    def self.windows?
+      RUBY_PLATFORM.include?('mingw') || RUBY_PLATFORM.include?('mswin')
+    end
+
+    def self.mac?
+      RUBY_PLATFORM.include?('darwin')
+    end
+  end
+end

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

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'net/http'
+require 'uri'
+require_relative 'remote_parser'
+
+module Commiti
+  module PrCreator
+    extend PrRemoteParser
+
+    def self.create(origin_url:, base_branch:, head_branch:, title:, body:, config:)
+      remote = extract_remote_info(origin_url)
+      return { url: nil, reason: :unsupported_provider } if remote.nil?
+
+      token = token_for_provider(remote[:provider], config)
+      return { url: nil, reason: :missing_token, provider: remote[:provider] } if token.nil?
+
+      url = case remote[:provider]
+            when :github, :gitbucket
+              create_github_like_pr(remote: remote, base_branch: base_branch, head_branch: head_branch,
+                                    title: title, body: body, token: token)
+            when :gitlab
+              create_gitlab_mr(remote: remote, base_branch: base_branch, head_branch: head_branch,
+                               title: title, body: body, token: token)
+            end
+
+      return { url: nil, reason: :unsupported_provider } if url.nil?
+
+      { url: url, reason: :created }
+    rescue StandardError => e
+      { url: nil, reason: :api_error, provider: remote && remote[:provider], error: e.message }
+    end
+
+    def self.create_github_like_pr(remote:, base_branch:, head_branch:, title:, body:, token:)
+      uri = github_api_uri(remote, "/repos/#{remote[:namespace]}/#{remote[:repo]}/pulls")
+      payload = {
+        title: title.to_s,
+        head: head_branch.to_s,
+        base: base_branch.to_s,
+        body: body.to_s
+      }
+
+      response = post_json(
+        uri,
+        payload,
+        {
+          'Authorization' => "token #{token}",
+          'Accept' => 'application/vnd.github+json'
+        }
+      )
+
+      parsed = parse_json(response)
+      url = parsed['html_url']
+      raise 'PR API response did not include html_url.' if url.to_s.strip.empty?
+
+      url
+    end
+    private_class_method :create_github_like_pr
+
+    # github.com uses api.github.com; GitHub Enterprise uses /api/v3 on the same host.
+    def self.github_api_uri(remote, path)
+      base = if remote[:host].to_s.downcase == 'github.com'
+               'https://api.github.com'
+             else
+               "#{remote[:web_scheme]}://#{remote[:host]}/api/v3"
+             end
+
+      URI("#{base}#{path}")
+    end
+    private_class_method :github_api_uri
+
+    def self.create_gitlab_mr(remote:, base_branch:, head_branch:, title:, body:, token:)
+      encoded_project = URI.encode_www_form_component("#{remote[:namespace]}/#{remote[:repo]}")
+      uri = URI("#{remote_base(remote)}/api/v4/projects/#{encoded_project}/merge_requests")
+      payload = {
+        source_branch: head_branch.to_s,
+        target_branch: base_branch.to_s,
+        title: title.to_s,
+        description: body.to_s
+      }
+
+      response = post_json(
+        uri,
+        payload,
+        {
+          'PRIVATE-TOKEN' => token,
+          'Accept' => 'application/json'
+        }
+      )
+
+      parsed = parse_json(response)
+      url = parsed['web_url']
+      raise 'MR API response did not include web_url.' if url.to_s.strip.empty?
+
+      url
+    end
+    private_class_method :create_gitlab_mr
+
+    def self.post_json(uri, payload, headers, redirect_limit: 5)
+      raise 'Too many redirects' if redirect_limit.zero?
+
+      request = Net::HTTP::Post.new(uri)
+      request['Content-Type'] = 'application/json'
+      headers.each { |k, v| request[k] = v }
+      request.body = JSON.generate(payload)
+
+      Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == 'https') do |http|
+        response = http.request(request)
+        code = response.code.to_i
+
+        if [301, 302, 307, 308].include?(code)
+          location = response['Location'].to_s.strip
+          raise 'Redirect with no Location header' if location.empty?
+
+          new_uri = URI(location)
+          new_uri = URI("#{uri.scheme}://#{uri.host}#{location}") unless new_uri.host
+
+          # Never follow to a different host — that means the API pushed us to the web UI
+          raise "API redirected to a different host (#{new_uri.host}), check namespace/repo in origin URL" \
+            if new_uri.host != uri.host
+
+          return post_json(new_uri, payload, headers, redirect_limit: redirect_limit - 1)
+        end
+
+        return response if code.between?(200, 299)
+
+        parsed = parse_json(response)
+        errors = parsed['errors']&.map { |e| e.slice('field', 'code', 'message').values.join(': ') }&.join(', ')
+        base_msg = parsed['message'] || parsed['error'] || response.body.to_s.strip
+        detail = errors ? "#{base_msg} — #{errors}" : base_msg
+        raise "PR API request failed (HTTP #{code}): #{detail}"
+      end
+    end
+    private_class_method :post_json
+
+    def self.parse_json(response)
+      JSON.parse(response.body.to_s)
+    rescue JSON::ParserError
+      {}
+    end
+    private_class_method :parse_json
+
+    def self.remote_base(remote)
+      "#{remote[:web_scheme]}://#{remote[:host]}"
+    end
+    private_class_method :remote_base
+
+    def self.token_for_provider(provider, config)
+      case provider
+      when :github
+        present_or_nil(config[:github_token])
+      when :gitlab
+        present_or_nil(config[:gitlab_token])
+      when :gitbucket
+        present_or_nil(config[:gitbucket_token])
+      end
+    end
+    private_class_method :token_for_provider
+
+    def self.present_or_nil(value)
+      normalized = value.to_s.strip
+      normalized.empty? ? nil : normalized
+    end
+    private_class_method :present_or_nil
+  end
+end