commiti 1.2.3

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

@@ -0,0 +1,238 @@
+# frozen_string_literal: true
+
+require 'uri'
+
+module Commiti
+  module PrOpener
+    SCP_REMOTE = %r{\A(?<user>[^@]+)@(?<host>[^:\s/]+):(?<path>[^\s]+)\z}
+    MAX_PREFILLED_URL_LENGTH = 1800
+    MAX_PREFILLED_TITLE_LENGTH = 120
+
+    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(
+        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
+
+      without_body = prefilled_url(
+        remote: remote,
+        base_branch: base_branch,
+        head_branch: head_branch,
+        title: title,
+        body: body,
+        include_title: true,
+        include_body: false
+      )
+      return without_body if without_body.length <= MAX_PREFILLED_URL_LENGTH
+
+      prefilled_url(
+        remote: remote,
+        base_branch: base_branch,
+        head_branch: head_branch,
+        title: title,
+        body: body,
+        include_title: false,
+        include_body: false
+      )
+    end
+
+    def self.prefilled_url(remote:, base_branch:, head_branch:, title:, body:, include_title:, include_body:)
+      if remote[:provider] == :gitlab
+        gitlab_mr_url(
+          remote: remote,
+          base_branch: base_branch,
+          head_branch: head_branch,
+          title: title,
+          body: body,
+          include_title: include_title,
+          include_description: include_body
+        )
+      else
+        github_like_compare_url(
+          remote: remote,
+          base_branch: base_branch,
+          head_branch: head_branch,
+          title: title,
+          body: body,
+          include_title: include_title,
+          include_body: include_body
+        )
+      end
+    end
+    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' }
+      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?
+      query = URI.encode_www_form(query_params)
+
+      base = "#{remote[:web_scheme]}://#{remote[:host]}"
+      path = "#{remote[:namespace]}/#{remote[:repo]}"
+
+      "#{base}/#{path}/compare/#{encode_branch_for_path(base_branch)}...#{encode_branch_for_path(head_branch)}?#{query}"
+    end
+
+    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,
+        'merge_request[target_branch]' => base_branch
+      }
+      normalized_title = normalize_title(title)
+      query_params['merge_request[title]'] = normalized_title if include_title && !normalized_title.empty?
+      query_params['merge_request[description]'] = body.to_s if include_description && !body.to_s.empty?
+      query = URI.encode_www_form(query_params)
+
+      base = "#{remote[:web_scheme]}://#{remote[:host]}"
+      path = "#{remote[:namespace]}/#{remote[:repo]}"
+
+      "#{base}/#{path}/-/merge_requests/new?#{query}"
+    end
+
+    def self.normalize_title(title)
+      title.to_s.strip[0, MAX_PREFILLED_TITLE_LENGTH]
+    end
+    private_class_method :normalize_title
+
+    def self.encode_branch_for_path(branch)
+      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|
+        stripped = line.strip
+        if stripped == '## Summary'
+          in_summary = true
+          next
+        end
+
+        break if in_summary && stripped.start_with?('## ')
+        next unless in_summary
+        next if stripped.empty? || stripped.start_with?('-', '*')
+
+        return stripped[0, 72]
+      end
+
+      "Update #{head_branch}"
+    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
+      )
+    end
+
+    def self.extract_owner_repo(origin_url)
+      info = extract_remote_info(origin_url)
+      return nil if info.nil?
+
+      { 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/google_client.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require 'httparty'
+require 'json'
+require 'uri'
+
+module Commiti
+  class GoogleClient
+    include HTTParty
+
+    base_uri 'https://generativelanguage.googleapis.com'
+    DEFAULT_MODEL = 'gemma-4-31b-it'
+    DEFAULT_TEMPERATURE = 0.2
+    DEFAULT_TIMEOUT_SECONDS = 180
+    DEFAULT_OPEN_TIMEOUT_SECONDS = 10
+
+    def initialize(config: Commiti::ConfigLoader.load)
+      @config = config || {}
+    end
+
+    def generate(system:, user:, api_key: nil, model: nil, temperature: nil, timeout_seconds: nil, open_timeout_seconds: nil)
+      settings = request_settings(
+        api_key: api_key,
+        model: model,
+        temperature: temperature,
+        timeout_seconds: timeout_seconds,
+        open_timeout_seconds: open_timeout_seconds
+      )
+      response = generate_content(system: system, user: user, settings: settings)
+      unless response.success?
+        detail = extract_error(response.body)
+        message = "Google AI error: #{response.code}"
+        message = "#{message} - #{detail}" unless detail.empty?
+        raise message
+      end
+      extract_generated_content(response.body)
+    end
+
+    def normalize_model(model)
+      value = model.to_s.strip
+      normalized = value.sub(%r{\Amodels/}, '')
+      normalized.empty? ? DEFAULT_MODEL : normalized
+    end
+
+    def normalize_api_key(value)
+      key = value.to_s.strip
+      return key unless key.empty?
+
+      raise 'Google API key is missing. Set GOOGLE_API_KEY (or GEMINI_API_KEY) in your environment.'
+    end
+
+    def normalize_float(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)
+    rescue ArgumentError
+      fallback
+    end
+
+    def extract_error(body)
+      parsed = JSON.parse(body.to_s)
+      error = parsed['error']
+      return error['message'].to_s.strip if error.is_a?(Hash)
+      return error.to_s.strip unless error.nil?
+
+      ''
+    rescue JSON::ParserError
+      ''
+    end
+
+    def extract_content(parsed)
+      parts = parsed.dig('candidates', 0, 'content', 'parts')
+      return '' unless parts.is_a?(Array)
+
+      parts.map { |part| part['text'].to_s }.join.strip
+    end
+
+    def request_settings(api_key:, model:, temperature:, timeout_seconds:, open_timeout_seconds:)
+      {
+        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)
+      }
+    end
+
+    def extract_generated_content(body)
+      parsed = JSON.parse(body.to_s)
+      content = extract_content(parsed)
+      raise 'Google AI error: response did not include generated text' if content.empty?
+
+      content
+    rescue JSON::ParserError => e
+      raise "Google AI error: invalid JSON response (#{e.message})"
+    end
+
+    def generate_content(system:, user:, settings:)
+      self.class.post(
+        "/v1beta/models/#{URI.encode_www_form_component(settings[:model])}:generateContent",
+        query: { key: settings[:api_key] },
+        headers: { 'Content-Type' => 'application/json' },
+        timeout: settings[:timeout_seconds],
+        open_timeout: settings[:open_timeout_seconds],
+        body: request_body(system: system, user: user, settings: settings).to_json
+      )
+    end
+
+    def request_body(system:, user:, settings:)
+      {
+        systemInstruction: {
+          parts: [{ text: system.to_s }]
+        },
+        generationConfig: {
+          temperature: settings[:temperature]
+        },
+        contents: [
+          {
+            role: 'user',
+            parts: [{ text: user.to_s }]
+          }
+        ]
+      }
+    end
+  end
+end

data/lib/services/helpers/clipboard.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Commiti
+  module Clipboard
+    def self.copy(text)
+      case platform
+      when :mac
+        IO.popen('pbcopy', 'w') { |io| io.write(text) }
+        true
+      when :linux
+        if command_exists?('xclip')
+          IO.popen('xclip -selection clipboard', 'w') { |io| io.write(text) }
+          true
+        elsif command_exists?('xsel')
+          IO.popen('xsel --clipboard --input', 'w') { |io| io.write(text) }
+          true
+        else
+          false # no clipboard tool found
+        end
+      when :windows
+        IO.popen('clip', 'w') { |io| io.write(text) }
+        true
+      else
+        false
+      end
+    end
+
+    def self.platform
+      if RUBY_PLATFORM.include?('darwin')
+        :mac
+      elsif RUBY_PLATFORM.include?('linux')
+        :linux
+      elsif RUBY_PLATFORM.include?('mingw') || RUBY_PLATFORM.include?('mswin')
+        :windows
+      else
+        :unknown
+      end
+    end
+
+    def self.command_exists?(cmd)
+      system('which', cmd, out: File::NULL, err: File::NULL)
+    end
+  end
+end

data/lib/services/helpers/config_loader.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Commiti
+  class ConfigLoader
+    DEFAULT_CONFIG = {
+      google_api_key: nil,
+      model: Commiti::GoogleClient::DEFAULT_MODEL,
+      candidates: 1,
+      base_branch: 'main',
+      no_copy: false,
+      temperature: Commiti::GoogleClient::DEFAULT_TEMPERATURE,
+      timeout_seconds: Commiti::GoogleClient::DEFAULT_TIMEOUT_SECONDS,
+      open_timeout_seconds: Commiti::GoogleClient::DEFAULT_OPEN_TIMEOUT_SECONDS
+    }.freeze
+
+    # Loads configuration from environment variables.
+    # Keys are returned as symbols with parsed values.
+    def self.load(env: ENV)
+      {
+        google_api_key: google_api_key_from_env(env),
+        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]),
+        no_copy: boolean_or_default(env.fetch('COMMITI_NO_COPY', nil), DEFAULT_CONFIG[:no_copy]),
+        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])
+      }
+    end
+
+    def self.google_api_key_from_env(env)
+      present_or_nil(env.fetch('GOOGLE_API_KEY', nil)) ||
+        present_or_nil(env.fetch('GEMINI_API_KEY', nil)) ||
+        present_or_nil(env.fetch('GOOGLE_GENERATIVE_AI_API_KEY', nil))
+    end
+    private_class_method :google_api_key_from_env
+
+    def self.present_or_nil(value)
+      normalized = value.to_s.strip
+      normalized.empty? ? nil : normalized
+    end
+    private_class_method :present_or_nil
+
+    def self.present_or_default(value, fallback)
+      present_or_nil(value) || fallback
+    end
+    private_class_method :present_or_default
+
+    def self.integer_or_default(value, fallback)
+      return fallback if value.nil? || value.to_s.strip.empty?
+
+      Integer(value)
+    rescue ArgumentError
+      fallback
+    end
+    private_class_method :integer_or_default
+
+    def self.float_or_default(value, fallback)
+      return fallback if value.nil? || value.to_s.strip.empty?
+
+      Float(value)
+    rescue ArgumentError
+      fallback
+    end
+    private_class_method :float_or_default
+
+    def self.boolean_or_default(value, fallback)
+      return fallback if value.nil? || value.to_s.strip.empty?
+
+      normalized = value.to_s.strip.downcase
+      return true if %w[1 true yes on].include?(normalized)
+      return false if %w[0 false no off].include?(normalized)
+
+      fallback
+    end
+    private_class_method :boolean_or_default
+  end
+end

data/lib/services/helpers/interactive_prompt.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require 'io/console'
+require 'shellwords'
+require 'tempfile'
+require 'tty-reader'
+
+module Commiti
+  module InteractivePrompt
+    COMMIT_SUBJECT_MAX_LENGTH = 100
+    COMMIT_PREFIX = /\A(feat|fix|chore|refactor|docs|style|test|perf|ci|build|revert)(\([^)]+\))?!?:\s+\S/i
+
+    def self.ask_yes_no(question, default: :no)
+      suffix = default == :yes ? '[Y/n]' : '[y/N]'
+      input = read_input("#{question} #{suffix} ")
+      return default == :yes if input.nil?
+
+      value = input.strip.downcase
+      return true if %w[y yes].include?(value)
+      return false if %w[n no].include?(value)
+      return default == :yes if value.empty?
+
+      false
+    end
+
+    def self.ask_commit_action
+      input = read_input('Commit with this message? [y/e/N] ')
+      return :no if input.nil?
+
+      value = input.strip.downcase
+      return :yes if %w[y yes].include?(value)
+      return :edit if %w[e edit].include?(value)
+
+      :no
+    end
+
+    def self.ask_candidate_selection(count, default: 1)
+      return 0 if count <= 1
+
+      loop do
+        input = read_input("Select candidate [1-#{count}] (default: #{default}): ")
+        return default - 1 if input.nil?
+
+        value = input.strip
+        return default - 1 if value.empty?
+        return value.to_i - 1 if value.match?(/\A\d+\z/) && value.to_i.between?(1, count)
+
+        puts "Please type a number between 1 and #{count}."
+      end
+    end
+
+    def self.edit_message(initial_message)
+      # Keep the temp file closed while the external editor runs.
+      # On Windows, open handles can prevent editors like Notepad from
+      # saving in place, which can make edits appear to be ignored.
+      file = Tempfile.new(['commiti-msg', '.txt'])
+      begin
+        file.write("#{initial_message.to_s.rstrip}\n")
+        file.flush
+        file.close
+
+        command = editor_command
+        success = system(*command, file.path)
+        return nil unless success
+
+        File.read(file.path, mode: 'r:bom|utf-8').strip
+      ensure
+        file.unlink
+      end
+    end
+
+    def self.commit_message_errors(message)
+      cleaned = message.to_s.strip
+      return ['Message cannot be empty.'] if cleaned.empty?
+
+      first_line = cleaned.lines.first.to_s.strip
+      errors = []
+      errors << 'First line must start with a conventional commit type (feat:, fix:, etc.).' unless first_line.match?(COMMIT_PREFIX)
+      errors << "First line should be #{COMMIT_SUBJECT_MAX_LENGTH} characters or fewer." if first_line.length > COMMIT_SUBJECT_MAX_LENGTH
+      errors
+    end
+
+    def self.editor_command
+      preferred = ENV.fetch('VISUAL', nil)
+      preferred = ENV.fetch('EDITOR', nil) if preferred.to_s.strip.empty?
+
+      if preferred.to_s.strip.empty?
+        return ['notepad'] if windows?
+
+        return ['vi']
+      end
+
+      command = Shellwords.split(preferred)
+      command << '--wait' if code_editor_command?(command.first) && !command.include?('--wait')
+
+      command
+    end
+
+    def self.code_editor_command?(exe)
+      name = File.basename(exe.to_s).downcase
+      ['code', 'code.cmd', 'code.exe', 'codium', 'codium.cmd', 'codium.exe'].include?(name)
+    end
+
+    def self.windows?
+      RUBY_PLATFORM.include?('mingw') || RUBY_PLATFORM.include?('mswin')
+    end
+
+    def self.read_input(prompt)
+      if io_console_available?
+        reader.read_line(prompt)
+      else
+        print prompt
+        $stdin.gets
+      end
+    rescue Interrupt
+      nil
+    end
+
+    def self.reader
+      @reader ||= TTY::Reader.new
+    end
+
+    def self.io_console_available?
+      !IO.console.nil?
+    rescue StandardError
+      false
+    end
+  end
+end