commiti 1.3.0 → 1.3.2

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

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

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 require 'uri'
+require_relative 'remote_parser'
+require_relative 'browser_opener'
 
 module Commiti
   module PrOpener
@@ -8,42 +10,120 @@ module Commiti
     MAX_PREFILLED_URL_LENGTH = 1800
     MAX_PREFILLED_TITLE_LENGTH = 120
 
+    extend PrRemoteParser
+
     def self.compare_url(origin_url:, base_branch:, head_branch:, title:, body:)
       remote = extract_remote_info(origin_url)
       raise 'Supported providers for browser PR opening are GitHub, GitLab, and GitBucket.' if remote.nil?
 
-      full_url = prefilled_url(
+      compare_url_candidates(
         remote: remote,
         base_branch: base_branch,
         head_branch: head_branch,
         title: title,
-        body: body,
-        include_title: true,
-        include_body: true
-      )
-      return full_url if full_url.length <= MAX_PREFILLED_URL_LENGTH
+        body: body
+      ).find { |url| url.length <= MAX_PREFILLED_URL_LENGTH } || compare_url_candidates(
+        remote: remote,
+        base_branch: base_branch,
+        head_branch: head_branch,
+        title: title,
+        body: body
+      ).last
+    end
 
-      without_body = prefilled_url(
+    def self.compare_url_candidates(remote:, base_branch:, head_branch:, title:, body:)
+      truncated_body = truncate_body_to_fit(
         remote: remote,
         base_branch: base_branch,
         head_branch: head_branch,
         title: title,
-        body: body,
-        include_title: true,
-        include_body: false
+        body: body
       )
-      return without_body if without_body.length <= MAX_PREFILLED_URL_LENGTH
 
-      prefilled_url(
+      [
+        prefilled_url(
+          remote: remote,
+          base_branch: base_branch,
+          head_branch: head_branch,
+          title: title,
+          body: body,
+          include_title: true,
+          include_body: true
+        ),
+        prefilled_url(
+          remote: remote,
+          base_branch: base_branch,
+          head_branch: head_branch,
+          title: title,
+          body: truncated_body,
+          include_title: true,
+          include_body: !truncated_body.to_s.empty?
+        ),
+        prefilled_url(
+          remote: remote,
+          base_branch: base_branch,
+          head_branch: head_branch,
+          title: title,
+          body: body,
+          include_title: true,
+          include_body: false
+        ),
+        prefilled_url(
+          remote: remote,
+          base_branch: base_branch,
+          head_branch: head_branch,
+          title: title,
+          body: body,
+          include_title: false,
+          include_body: false
+        )
+      ]
+    end
+    private_class_method :compare_url_candidates
+
+    def self.truncate_body_to_fit(remote:, base_branch:, head_branch:, title:, body:)
+      text = body.to_s
+      return '' if text.empty?
+
+      full_url = prefilled_url(
         remote: remote,
         base_branch: base_branch,
         head_branch: head_branch,
         title: title,
-        body: body,
-        include_title: false,
-        include_body: false
+        body: text,
+        include_title: true,
+        include_body: true
       )
+      return text if full_url.length <= MAX_PREFILLED_URL_LENGTH
+
+      low = 0
+      high = text.length
+      best = ''
+
+      while low <= high
+        mid = (low + high) / 2
+        candidate_body = text[0, mid]
+        candidate_url = prefilled_url(
+          remote: remote,
+          base_branch: base_branch,
+          head_branch: head_branch,
+          title: title,
+          body: candidate_body,
+          include_title: true,
+          include_body: !candidate_body.empty?
+        )
+
+        if candidate_url.length <= MAX_PREFILLED_URL_LENGTH
+          best = candidate_body
+          low = mid + 1
+        else
+          high = mid - 1
+        end
+      end
+
+      best
     end
+    private_class_method :truncate_body_to_fit
 
     def self.prefilled_url(remote:, base_branch:, head_branch:, title:, body:, include_title:, include_body:)
       if remote[:provider] == :gitlab
@@ -115,68 +195,6 @@ module Commiti
       URI.encode_www_form_component(branch.to_s).gsub('+', '%20')
     end
 
-    def self.extract_remote_info(origin_url)
-      remote_text = origin_url.to_s.strip
-      return nil if remote_text.empty?
-
-      parsed = parse_uri_remote(remote_text) || parse_scp_remote(remote_text)
-      return nil if parsed.nil?
-
-      normalized = normalize_repo_path(parsed[:path])
-      return nil if normalized.nil?
-
-      provider = detect_provider(parsed[:host])
-      return nil if provider.nil?
-
-      {
-        provider: provider,
-        host: parsed[:host],
-        web_scheme: parsed[:web_scheme],
-        namespace: normalized[:namespace],
-        repo: normalized[:repo]
-      }
-    end
-
-    def self.parse_uri_remote(remote_text)
-      uri = URI.parse(remote_text)
-      return nil unless uri.is_a?(URI::HTTP) || uri.is_a?(URI::HTTPS) || uri.scheme == 'ssh'
-      return nil if uri.host.to_s.strip.empty?
-
-      web_scheme = uri.is_a?(URI::HTTP) || uri.is_a?(URI::HTTPS) ? uri.scheme : 'https'
-      { host: uri.host, path: uri.path, web_scheme: web_scheme }
-    rescue URI::InvalidURIError
-      nil
-    end
-
-    def self.parse_scp_remote(remote_text)
-      match = remote_text.match(SCP_REMOTE)
-      return nil if match.nil?
-
-      { host: match[:host], path: match[:path], web_scheme: 'https' }
-    end
-
-    def self.normalize_repo_path(raw_path)
-      clean = raw_path.to_s.strip
-      clean = clean.sub(%r{\A/+}, '').sub(%r{/+\z}, '')
-      clean = clean.sub(/\.git\z/, '')
-      segments = clean.split('/').reject(&:empty?)
-      return nil if segments.length < 2
-
-      {
-        namespace: segments[0..-2].join('/'),
-        repo: segments[-1]
-      }
-    end
-
-    def self.detect_provider(host)
-      normalized = host.to_s.downcase
-      return :gitlab if normalized.include?('gitlab')
-      return :gitbucket if normalized.include?('gitbucket')
-      return :github if normalized.include?('github')
-
-      nil
-    end
-
     def self.suggest_title(pr_body, head_branch:)
       in_summary = false
       pr_body.to_s.each_line do |line|
@@ -197,34 +215,7 @@ module Commiti
     end
 
     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
-
-      true
-    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
-      )
+      Commiti::PrBrowserOpener.open_in_browser(url)
     end
 
     def self.extract_owner_repo(origin_url)
@@ -233,13 +224,5 @@ module Commiti
 
       { owner: info[:namespace], repo: info[:repo] }
     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/remote_parser.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require 'uri'
+
+module Commiti
+  module PrRemoteParser
+    SCP_REMOTE = %r{\A(?<user>[^@]+)@(?<host>[^:\s/]+):(?<path>[^\s]+)\z}
+
+    def extract_remote_info(origin_url)
+      remote_text = origin_url.to_s.strip
+      return nil if remote_text.empty?
+
+      parsed = parse_uri_remote(remote_text) || parse_scp_remote(remote_text)
+      return nil if parsed.nil?
+
+      normalized = normalize_repo_path(parsed[:path])
+      return nil if normalized.nil?
+
+      provider = detect_provider(parsed[:host])
+      return nil if provider.nil?
+
+      {
+        provider: provider,
+        host: parsed[:host],
+        web_scheme: parsed[:web_scheme],
+        namespace: normalized[:namespace],
+        repo: normalized[:repo]
+      }
+    end
+
+    private
+
+    def parse_uri_remote(remote_text)
+      uri = URI.parse(remote_text)
+      return nil unless uri.is_a?(URI::HTTP) || uri.is_a?(URI::HTTPS) || uri.scheme == 'ssh'
+      return nil if uri.host.to_s.strip.empty?
+
+      web_scheme = uri.is_a?(URI::HTTP) || uri.is_a?(URI::HTTPS) ? uri.scheme : 'https'
+      { host: uri.host, path: uri.path, web_scheme: web_scheme }
+    rescue URI::InvalidURIError
+      nil
+    end
+
+    def parse_scp_remote(remote_text)
+      match = remote_text.match(SCP_REMOTE)
+      return nil if match.nil?
+
+      { host: match[:host], path: match[:path], web_scheme: 'https' }
+    end
+
+    def normalize_repo_path(raw_path)
+      clean = raw_path.to_s.strip
+      clean = clean.sub(%r{\A/+}, '').sub(%r{/+\z}, '')
+      clean = clean.sub(/\.git\z/, '')
+      segments = clean.split('/').reject(&:empty?)
+      return nil if segments.length < 2
+
+      {
+        namespace: segments[0..-2].join('/'),
+        repo: segments[-1]
+      }
+    end
+
+    def detect_provider(host)
+      normalized = host.to_s.downcase
+      return :gitlab if normalized.include?('gitlab')
+      return :gitbucket if normalized.include?('gitbucket')
+      return :github if normalized.include?('github')
+
+      nil
+    end
+  end
+end

data/lib/services/google_client.rb

@@ -49,18 +49,10 @@ module Commiti
       raise 'Google API key is missing. Set GOOGLE_API_KEY (or GEMINI_API_KEY) in your environment.'
     end
 
-    def normalize_float(value, fallback)
+    def normalize_numeric(value, fallback)
       return fallback if value.nil? || value.to_s.strip.empty?
 
-      Float(value)
-    rescue ArgumentError
-      fallback
-    end
-
-    def normalize_integer(value, fallback)
-      return fallback if value.nil? || value.to_s.strip.empty?
-
-      Integer(value)
+      yield(value)
     rescue ArgumentError
       fallback
     end
@@ -87,9 +79,10 @@ module Commiti
       {
         api_key: normalize_api_key(api_key || @config[:google_api_key]),
         model: normalize_model(model || @config[:model]),
-        temperature: normalize_float(temperature || @config[:temperature], DEFAULT_TEMPERATURE),
-        timeout_seconds: normalize_integer(timeout_seconds || @config[:timeout_seconds], DEFAULT_TIMEOUT_SECONDS),
-        open_timeout_seconds: normalize_integer(open_timeout_seconds || @config[:open_timeout_seconds], DEFAULT_OPEN_TIMEOUT_SECONDS)
+        temperature: normalize_numeric(temperature || @config[:temperature], DEFAULT_TEMPERATURE) { |raw| Float(raw) },
+        timeout_seconds: normalize_numeric(timeout_seconds || @config[:timeout_seconds], DEFAULT_TIMEOUT_SECONDS) { |raw| Integer(raw) },
+        open_timeout_seconds: normalize_numeric(open_timeout_seconds || @config[:open_timeout_seconds],
+                                                DEFAULT_OPEN_TIMEOUT_SECONDS) { |raw| Integer(raw) }
       }
     end
 

data/lib/services/helpers/clipboard.rb

@@ -6,22 +6,18 @@ module Commiti
       case platform
       when :mac
         IO.popen('pbcopy', 'w') { |io| io.write(text) }
-        true
+        :copied
       when :linux
         if command_exists?('xclip')
           IO.popen('xclip -selection clipboard', 'w') { |io| io.write(text) }
-          true
+          :copied
         elsif command_exists?('xsel')
           IO.popen('xsel --clipboard --input', 'w') { |io| io.write(text) }
-          true
-        else
-          false # no clipboard tool found
+          :copied
         end
       when :windows
         IO.popen('clip', 'w') { |io| io.write(text) }
-        true
-      else
-        false
+        :copied
       end
     end
 

data/lib/services/helpers/config_loader.rb

@@ -1,9 +1,17 @@
 # frozen_string_literal: true
 
+require 'yaml'
+require_relative '../text_generation_style'
+
 module Commiti
   class ConfigLoader
+    DEFAULT_TEXT_GENERATION_CONFIG = Commiti::TextGenerationStyle::DEFAULT_CONFIG
+
     DEFAULT_CONFIG = {
       google_api_key: nil,
+      github_token: nil,
+      gitlab_token: nil,
+      gitbucket_token: nil,
       model: Commiti::GoogleClient::DEFAULT_MODEL,
       candidates: 1,
       base_branch: 'main',
@@ -11,14 +19,18 @@ module Commiti
       auto_split: false,
       temperature: Commiti::GoogleClient::DEFAULT_TEMPERATURE,
       timeout_seconds: Commiti::GoogleClient::DEFAULT_TIMEOUT_SECONDS,
-      open_timeout_seconds: Commiti::GoogleClient::DEFAULT_OPEN_TIMEOUT_SECONDS
+      open_timeout_seconds: Commiti::GoogleClient::DEFAULT_OPEN_TIMEOUT_SECONDS,
+      text_generation: DEFAULT_TEXT_GENERATION_CONFIG
     }.freeze
 
     # Loads configuration from environment variables.
     # Keys are returned as symbols with parsed values.
-    def self.load(env: ENV)
-      {
+    def self.load(env: ENV, cwd: Dir.pwd)
+      DEFAULT_CONFIG.merge(
         google_api_key: google_api_key_from_env(env),
+        github_token: present_or_nil(env.fetch('COMMITI_GITHUB_TOKEN', nil)),
+        gitlab_token: present_or_nil(env.fetch('COMMITI_GITLAB_TOKEN', nil)),
+        gitbucket_token: present_or_nil(env.fetch('COMMITI_GITBUCKET_TOKEN', nil)),
         model: present_or_default(env.fetch('COMMITI_MODEL', nil), DEFAULT_CONFIG[:model]),
         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]),
@@ -27,9 +39,34 @@ module Commiti
         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),
-                                                 DEFAULT_CONFIG[:open_timeout_seconds])
-      }
+                                                 DEFAULT_CONFIG[:open_timeout_seconds]),
+        text_generation: load_text_generation_config(env: env, cwd: cwd)
+      )
+    end
+
+    def self.load_text_generation_config(env:, cwd:)
+      config_path = configured_path(env: env, cwd: cwd)
+      project_config = read_yaml_config(config_path)
+      Commiti::TextGenerationStyle.normalize(project_config)
+    end
+    private_class_method :load_text_generation_config
+
+    def self.configured_path(env:, cwd:)
+      configured = present_or_nil(env.fetch('COMMITI_CONFIG', nil))
+      path = configured || File.join(cwd, '.commiti.yml')
+      File.expand_path(path, cwd)
+    end
+    private_class_method :configured_path
+
+    def self.read_yaml_config(path)
+      return {} unless File.file?(path)
+
+      raw = YAML.safe_load_file(path, permitted_classes: [], permitted_symbols: [], aliases: false)
+      raw.is_a?(Hash) ? raw : {}
+    rescue StandardError
+      {}
     end
+    private_class_method :read_yaml_config
 
     def self.google_api_key_from_env(env)
       present_or_nil(env.fetch('GOOGLE_API_KEY', nil)) ||