commitgpt 0.1.2 → 0.3.1

data/lib/commitgpt/commit_ai.rb

@@ -1,70 +1,271 @@
 # frozen_string_literal: true
 
 require "httparty"
+require "net/http"
+require "uri"
 require "json"
 require "io/console"
+require "tty-prompt"
 require_relative "string"
+require_relative "config_manager"
 
 # CommitGpt based on GPT-3
 module CommitGpt
   # Commit AI roboter based on GPT-3
   class CommitAi
-    OPENAI_API_KEY = ENV.fetch("OPENAI_API_KEY", nil)
-    def aicm
+    attr_reader :api_key, :base_url, :model, :diff_len
+
+    def initialize
+      provider_config = ConfigManager.get_active_provider_config
+      
+      if provider_config
+        @api_key = provider_config["api_key"]
+        @base_url = provider_config["base_url"]
+        @model = provider_config["model"]
+        @diff_len = provider_config["diff_len"] || 32768
+      else
+        @api_key = nil
+        @base_url = nil
+        @model = nil
+        @diff_len = 32768
+      end
+    end
+
+    def aicm(verbose: false)
       exit(1) unless welcome
       diff = git_diff || exit(1)
-      ai_commit_message = message(diff) || exit(1)
-      puts `git commit -m "#{ai_commit_message}" && echo && echo && git log -1 && echo` if confirmed
-    end
+      if verbose
+        puts "▲ Git diff (#{diff.length} chars):".cyan
+        puts diff
+        puts "\n"
+      end
 
-    private
+      loop do
+        ai_commit_message = message(diff) || exit(1)
+        action = confirm_commit(ai_commit_message)
 
-    def confirmed
-      puts "▲ Do you want to commit this message? [y/n]".magenta
+        case action
+        when :commit
+          commit_command = "git commit -m \"#{ai_commit_message}\""
+          puts "\n▲ Executing: #{commit_command}".orange
+          system(commit_command)
+          puts "\n\n"
+          puts `git log -1`
+          break
+        when :regenerate
+          puts "\n"
+          next
+        when :edit
+          prompt = TTY::Prompt.new
+          new_message = prompt.ask("Enter your commit message:")
+          if new_message && !new_message.strip.empty?
+             commit_command = "git commit -m \"#{new_message}\""
+             system(commit_command)
+             puts "\n"
+             puts `git log -1`
+          else
+             puts "▲ Commit aborted (empty message).".red
+          end
+          break
+        when :exit
+          puts "▲ Exit without commit.".yellow
+          break
+        end
+      end
+    end
 
-      use_commit_message = nil
-      use_commit_message = $stdin.getch.downcase until use_commit_message =~ /\A[yn]\z/i
+    def list_models
+      headers = {
+        "Content-Type" => "application/json",
+        "User-Agent" => "Ruby/#{RUBY_VERSION}"
+      }
+      headers["Authorization"] = "Bearer #{@api_key}" if @api_key
+
+      begin
+        response = HTTParty.get("#{@base_url}/models", headers: headers)
+        models = response["data"] || []
+        models.each { |m| puts m["id"] }
+      rescue StandardError => e
+        puts "▲ Failed to list models: #{e.message}".red
+      end
+    end
 
-      puts "\n▲ Commit message has not been commited.\n".red if use_commit_message == "n"
+    def list_models
+      headers = {
+        "Content-Type" => "application/json",
+        "User-Agent" => "Ruby/#{RUBY_VERSION}"
+      }
+      headers["Authorization"] = "Bearer #{AICM_KEY}" if AICM_KEY
 
-      use_commit_message == "y"
+      begin
+        response = HTTParty.get("#{AICM_LINK}/models", headers: headers)
+        models = response["data"] || []
+        models.each { |m| puts m["id"] }
+      rescue StandardError => e
+        puts "▲ Failed to list models: #{e.message}".red
+      end
     end
 
-    def message(diff = nil)
-      prompt = "I want you to act like a git commit message writer. I will input a git diff and your job is to convert it into a useful " \
-               "commit message. Do not preface the commit with anything, use the present tense, return a complete sentence, " \
-               "and do not repeat yourself: #{diff}"
+    private
 
-      puts "▲   Generating your AI commit message...\n".gray
-      ai_commit_message = generate_commit(prompt)
-      return nil if ai_commit_message.nil?
+    def confirm_commit(message)
+      prompt = TTY::Prompt.new
+      
+      begin
+        prompt.select("Action:") do |menu|
+          menu.choice "Commit", :commit
+          menu.choice "Regenerate", :regenerate
+          menu.choice "Edit", :edit
+          menu.choice "Exit without commit", :exit
+        end
+      rescue TTY::Reader::InputInterrupt, Interrupt
+        :exit
+      end
+    end
 
-      puts "#{"▲ Commit message: ".green}git commit -am \"#{ai_commit_message}\"\n\n"
-      ai_commit_message
+    def message(diff = nil)
+      generate_commit(diff)
     end
 
     def git_diff
-      diff = `git diff --cached . ":(exclude)Gemfile.lock" ":(exclude)package-lock.json" ":(exclude)yarn.lock" ":(exclude)pnpm-lock.yaml"`.chomp
+      exclusions = '":(exclude)Gemfile.lock" ":(exclude)package-lock.json" ":(exclude)yarn.lock" ":(exclude)pnpm-lock.yaml"'
+      diff_cached = `git diff --cached . #{exclusions}`.chomp
+      diff_unstaged = `git diff . #{exclusions}`.chomp
 
-      if diff.empty?
-        puts "▲ No staged changes found. Make sure there are changes and run `git add .`".red
-        return nil
+      if !diff_unstaged.empty?
+        if !diff_cached.empty?
+          # Scenario: Mixed state (some staged, some not)
+          puts "▲ You have both staged and unstaged changes:".yellow
+          
+          staged_files = `git diff --cached --name-status . #{exclusions}`.chomp
+          unstaged_files = `git diff --name-status . #{exclusions}`.chomp
+
+          puts "\n  #{'Staged changes:'.green}"
+          puts staged_files.gsub(/^/, "    ")
+
+          puts "\n  #{'Unstaged changes:'.red}"
+          puts unstaged_files.gsub(/^/, "    ")
+          puts ""
+
+          prompt = TTY::Prompt.new
+          choice = prompt.select("How to proceed?") do |menu|
+             menu.choice "Include unstaged changes (git add .)", :add_all
+             menu.choice "Use staged changes only", :staged_only
+             menu.choice "Exit", :exit
+          end
+
+          case choice
+          when :add_all
+            puts "▲ Running git add .".yellow
+            system("git add .")
+            diff_cached = `git diff --cached . #{exclusions}`.chomp
+          when :exit
+            return nil
+          end
+        else
+          # Scenario: Only unstaged changes
+          choice = prompt_no_staged_changes
+          case choice
+          when :add_all
+            puts "▲ Running git add .".yellow
+            system("git add .")
+            diff_cached = `git diff --cached . #{exclusions}`.chomp
+            if diff_cached.empty?
+              puts "▲ Still no changes to commit.".red
+              return nil
+            end
+          when :exit
+            return nil
+          end
+        end
+      elsif diff_cached.empty?
+        # Scenario: No changes at all (staged or unstaged)
+        # Check if there are ANY unstaged files (maybe untracked?)
+        # git status --porcelain includes untracked files
+        git_status = `git status --porcelain`.chomp
+        if git_status.empty?
+           puts "▲ No changes to commit. Working tree clean.".yellow
+           return nil
+        else
+           # Only untracked files? Or ignored files?
+           # If diff_unstaged is empty but git status is not, it usually means untracked files.
+           # Let's offer to add them too.
+           choice = prompt_no_staged_changes
+           case choice
+           when :add_all
+             puts "▲ Running git add .".yellow
+             system("git add .")
+             diff_cached = `git diff --cached . #{exclusions}`.chomp
+           when :exit
+            return nil
+           end
+        end
       end
 
-      # Accounting for GPT-3's input req of 4k tokens (approx 8k chars)
-      if diff.length > 8000
-        puts "▲ The diff is too large to write a commit message.".red
-        return nil
+      diff = diff_cached
+
+      if diff.length > @diff_len
+        choice = prompt_diff_handling(diff.length, @diff_len)
+        case choice
+        when :truncate
+          puts "▲ Truncating diff to #{@diff_len} chars...".yellow
+          diff = diff[0...@diff_len]
+        when :unlimited
+          puts "▲ Using full diff (#{diff.length} chars)...".yellow
+        when :exit
+          return nil
+        end
       end
 
       diff
     end
 
+    def prompt_no_staged_changes
+      puts "▲ No staged changes found (but unstaged/untracked files exist).".yellow
+      prompt = TTY::Prompt.new
+      begin
+        prompt.select("Choose an option:") do |menu|
+          menu.choice "Run 'git add .' to stage all changes", :add_all
+          menu.choice "Exit (stage files manually)", :exit
+        end
+      rescue TTY::Reader::InputInterrupt, Interrupt
+        :exit
+      end
+    end
+
+    def prompt_diff_handling(current_len, max_len)
+      puts "▲ The diff is too large (#{current_len} chars, max #{max_len}).".yellow
+      prompt = TTY::Prompt.new
+      begin
+        prompt.select("Choose an option:") do |menu|
+          menu.choice "Use first #{max_len} characters to generate commit message", :truncate
+          menu.choice "Use unlimited characters (may fail or be slow)", :unlimited
+          menu.choice "Exit", :exit
+        end
+      rescue TTY::Reader::InputInterrupt, Interrupt
+        :exit
+      end
+    end
+
     def welcome
       puts "\n▲ Welcome to AI Commits!".green
 
-      if OPENAI_API_KEY.nil?
-        puts "▲ Please save your OpenAI API key as an env variable by doing 'export OPENAI_API_KEY=YOUR_API_KEY'".red
+      # Check if config exists
+      unless ConfigManager.config_exists?
+        puts "▲ Configuration not found. Generating default config...".yellow
+        ConfigManager.generate_default_configs
+        puts "▲ Please run 'aicm setup' to configure your provider.".red
+        return false
+      end
+
+      # Check if active provider is configured
+      if @api_key.nil? || @api_key.empty?
+        puts "▲ No active provider configured. Please run 'aicm setup'.".red
+        return false
+      end
+
+      if @model.nil? || @model.empty?
+        puts "▲ No model selected. Please run 'aicm setup'.".red
         return false
       end
 
@@ -78,27 +279,217 @@ module CommitGpt
       true
     end
 
-    def generate_commit(prompt = "")
+    def generate_commit(diff = "")
+      messages = [
+        {
+          role: "system",
+          content: "Generate a concise git commit message title in present tense that precisely describes the key changes in the following code diff. Focus on what was changed, not just file names. Provide only the title, no description or body. " \
+                   "Message language: English. Rules:\n" \
+                   "- Commit message must be a maximum of 100 characters.\n" \
+                   "- Exclude anything unnecessary such as translation. Your entire response will be passed directly into git commit.\n" \
+                   "- IMPORTANT: Do not include any explanations, introductions, or additional text. Do not wrap the commit message in quotes or any other formatting. The commit message must not exceed 100 characters. Respond with ONLY the commit message text. \n" \
+                   "- Be specific: include concrete details (package names, versions, functionality) rather than generic statements. \n" \
+                   "- Return ONLY the commit message, nothing else."
+        },
+        {
+          role: "user",
+          content: "Generate a commit message for the following git diff:\n\n#{diff}"
+        }
+      ]
+
+      # Check config for disable_reasoning support (default true if not set)
+      provider_config = ConfigManager.get_active_provider_config
+      can_disable_reasoning = provider_config.key?("can_disable_reasoning") ? provider_config["can_disable_reasoning"] : true
+      # Get configured max_tokens or default to 2000
+      configured_max_tokens = provider_config["max_tokens"] || 2000
+
       payload = {
-        model: "text-davinci-003", prompt: prompt, temperature: 0.7, top_p: 1,
-        frequency_penalty: 0, presence_penalty: 0, max_tokens: 200, stream: false, n: 1
+        model: @model,
+        messages: messages,
+        temperature: 0.5,
+        stream: true
       }
 
+      if can_disable_reasoning
+        payload[:disable_reasoning] = true
+        payload[:max_tokens] = 300
+      else
+        payload[:max_tokens] = configured_max_tokens
+      end
+
+      # Initial UI feedback (only on first try)
+      puts "....... Generating your AI commit message ......".gray unless defined?(@is_retrying) && @is_retrying
+
+      full_content = ""
+      full_reasoning = ""
+      printed_reasoning = false
+      printed_content_prefix = false
+      stop_stream = false
+      
+      uri = URI("#{@base_url}/chat/completions")
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = (uri.scheme == "https")
+      http.read_timeout = 120
+
+      request = Net::HTTP::Post.new(uri)
+      request["Content-Type"] = "application/json"
+      request["Authorization"] = "Bearer #{@api_key}" if @api_key
+      request.body = payload.to_json
+
       begin
-        response = HTTParty.post("https://api.openai.com/v1/completions",
-                                 headers: { "Authorization" => "Bearer #{OPENAI_API_KEY}",
-                                            "Content-Type" => "application/json", "User-Agent" => "Ruby/#{RUBY_VERSION}" },
-                                 body: payload.to_json)
+        http.request(request) do |response|
+          if response.code != "200"
+            # Parse error body
+            error_body = response.read_body 
+            result = JSON.parse(error_body) rescue nil
+            
+            error_msg = if result
+                          result.dig("error", "message") || result["error"] || result["message"]
+                        else
+                          error_body
+                        end
 
-        puts "#{response.inspect}\n"
+            if error_msg.nil? || error_msg.to_s.strip.empty?
+              error_msg = "HTTP #{response.code}"
+              error_msg += " Raw: #{error_body}" unless error_body.to_s.strip.empty?
+            end
+            
+            if can_disable_reasoning && (error_msg =~ /parameter|reasoning|unsupported/i || response.code == "400")
+               puts "▲ Provider does not support 'disable_reasoning'. Updating config and retrying...".yellow
+               ConfigManager.update_provider(provider_config["name"], { "can_disable_reasoning" => false })
+               @is_retrying = true
+               return generate_commit(diff)
+            else
+               puts "▲ API Error: #{error_msg}".red
+               return nil
+            end
+          end
+          
+          # Process Streaming Response
+          buffer = ""
+          response.read_body do |chunk|
+            break if stop_stream
 
-        ai_commit = response["choices"][0]["text"]
-      rescue StandardError
-        puts "▲ There was an error with the OpenAI API. Please try again later.".red
+            buffer += chunk
+            while (line_end = buffer.index("\n"))
+              line = buffer.slice!(0, line_end + 1).strip
+              next if line.empty?
+              next unless line.start_with?("data: ")
+
+              data_str = line[6..-1]
+              next if data_str == "[DONE]"
+
+              begin
+                data = JSON.parse(data_str)
+                delta = data.dig("choices", 0, "delta")
+                next unless delta
+
+                # Handle Reasoning
+                reasoning_chunk = delta["reasoning_content"] || delta["reasoning"]
+                if reasoning_chunk && !reasoning_chunk.empty?
+                  unless printed_reasoning
+                     puts "\nThinking...".gray
+                  end
+                  print reasoning_chunk.gray
+                  full_reasoning += reasoning_chunk
+                  printed_reasoning = true
+                  $stdout.flush
+                end
+
+                # Handle Content
+                content_chunk = delta["content"]
+                if content_chunk && !content_chunk.empty?
+                  if printed_reasoning && !printed_content_prefix
+                    puts "" # Newline after reasoning block
+                  end
+                  
+                  unless printed_content_prefix
+                    print "\n▲ Commit message: git commit -am \"".green
+                    printed_content_prefix = true
+                  end
+                  
+                  # Prevent infinite loops/repetitive garbage
+                  if full_content.length + content_chunk.length > 300
+                    stop_stream = true
+                    break
+                  end
+
+                  print content_chunk.green
+                  full_content += content_chunk
+                  $stdout.flush
+                end
+                
+                # Handle Usage (some providers send usage at the end)
+                if data["usage"]
+                   @last_usage = data["usage"]
+                end
+
+              rescue JSON::ParserError
+                # Partial JSON, wait for more data
+              end
+            end
+          end
+        end
+      rescue StandardError => e
+        puts "▲ Error: #{e.message}".red
         return nil
       end
+      
+      # Close the quote
+      puts "\"".green if printed_content_prefix
+
+      # Post-processing Logic (Retry if empty content)
+      if (full_content.nil? || full_content.strip.empty?) && (full_reasoning && !full_reasoning.strip.empty?)
+          if can_disable_reasoning
+              puts "\n▲ Model returned reasoning despite 'disable_reasoning: true'. Updating config and retrying...".yellow
+              ConfigManager.update_provider(provider_config["name"], { "can_disable_reasoning" => false })
+              @is_retrying = true
+              return generate_commit(diff)
+          else
+              puts "\n▲ Model output truncated (Reasoning consumed all #{configured_max_tokens} tokens).".red
+              prompt = TTY::Prompt.new
+              choice = prompt.select("Choose an action:") do |menu|
+                menu.choice "Double max_tokens to #{configured_max_tokens * 2}", :double
+                menu.choice "Set custom max_tokens...", :custom
+                menu.choice "Abort", :abort
+              end
+
+              new_max = case choice
+                        when :double
+                          configured_max_tokens * 2
+                        when :custom
+                          prompt.ask("Enter new max_tokens:", convert: :int)
+                        when :abort
+                          return nil
+                        end
+              
+              if new_max
+                 puts "▲ Updating max_tokens to #{new_max} and retrying...".yellow
+                 ConfigManager.update_provider(provider_config["name"], { "max_tokens" => new_max })
+                 @is_retrying = true
+                 return generate_commit(diff)
+              end
+              return nil
+          end
+      end
+
+      if full_content.empty? && full_reasoning.empty?
+        puts "▲ No response from AI.".red
+        return nil
+      end
+      
+      # Print usage info if available (saved from stream or approximated)
+      if defined?(@last_usage) && @last_usage
+        puts "\n...... Tokens: #{@last_usage['total_tokens']} (Prompt: #{@last_usage['prompt_tokens']}, Completion: #{@last_usage['completion_tokens']})\n\n".gray
+        @last_usage = nil
+      end
+
+      # Reset retrying flag
+      @is_retrying = false
 
-      ai_commit.gsub(/(\r\n|\n|\r)/, "")
+      # Take only the first non-empty line to avoid repetition or multi-line garbage
+      first_line = full_content.split("\n").map(&:strip).reject(&:empty?).first
+      first_line&.gsub(/\A["']|["']\z/, "") || ""
     end
   end
 end

data/lib/commitgpt/config_manager.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "fileutils"
+require_relative "provider_presets"
+require_relative "string"
+
+module CommitGpt
+  # Manages configuration files for CommitGPT
+  class ConfigManager
+    class << self
+      # Get the config directory path
+      def config_dir
+        File.expand_path("~/.config/commitgpt")
+      end
+
+      # Get main config file path
+      def main_config_path
+        File.join(config_dir, "config.yml")
+      end
+
+      # Get local config file path
+      def local_config_path
+        File.join(config_dir, "config.local.yml")
+      end
+
+      # Ensure config directory exists
+      def ensure_config_dir
+        FileUtils.mkdir_p(config_dir) unless Dir.exist?(config_dir)
+      end
+
+      # Check if config files exist
+      def config_exists?
+        File.exist?(main_config_path)
+      end
+
+      # Load and merge configuration files
+      def load_config
+        return nil unless config_exists?
+
+        main_config = YAML.load_file(main_config_path) || {}
+        local_config = File.exist?(local_config_path) ? YAML.load_file(local_config_path) : {}
+
+        merge_configs(main_config, local_config)
+      end
+
+      # Get active provider configuration
+      def get_active_provider_config
+        config = load_config
+        return nil if config.nil? || config["active_provider"].nil?
+
+        active_provider = config["active_provider"]
+        providers = config["providers"] || []
+
+        providers.find { |p| p["name"] == active_provider }
+      end
+
+      # Save main config
+      def save_main_config(config)
+        ensure_config_dir
+        File.write(main_config_path, config.to_yaml)
+      end
+
+      # Save local config
+      def save_local_config(config)
+        ensure_config_dir
+        File.write(local_config_path, config.to_yaml)
+      end
+
+      # Generate default configuration files
+      def generate_default_configs
+        ensure_config_dir
+
+        # Generate main config with all providers but empty models
+        providers = PROVIDER_PRESETS.map do |preset|
+          {
+            "name" => preset[:value],
+            "model" => "",
+            "diff_len" => 32768,
+            "base_url" => preset[:base_url]
+          }
+        end
+
+        main_config = {
+          "providers" => providers,
+          "active_provider" => ""
+        }
+
+        # Generate local config with empty API keys
+        local_providers = PROVIDER_PRESETS.map do |preset|
+          {
+            "name" => preset[:value],
+            "api_key" => ""
+          }
+        end
+
+        local_config = {
+          "providers" => local_providers
+        }
+
+        save_main_config(main_config)
+        save_local_config(local_config)
+
+        # Remind user to add config.local.yml to .gitignore
+        puts "▲ Generated default configuration files.".green
+        puts "▲ Remember to add ~/.config/commitgpt/config.local.yml to your .gitignore".yellow
+      end
+
+      # Get list of configured providers (with API keys)
+      def configured_providers
+        config = load_config
+        return [] if config.nil?
+
+        providers = config["providers"] || []
+        providers.select { |p| p["api_key"] && !p["api_key"].empty? }
+      end
+
+      # Update provider configuration
+      def update_provider(provider_name, main_attrs = {}, local_attrs = {})
+        # Update main config
+        main_config = YAML.load_file(main_config_path)
+        provider = main_config["providers"].find { |p| p["name"] == provider_name }
+        provider&.merge!(main_attrs)
+        save_main_config(main_config)
+
+        # Update local config
+        local_config = File.exist?(local_config_path) ? YAML.load_file(local_config_path) : { "providers" => [] }
+        local_provider = local_config["providers"].find { |p| p["name"] == provider_name }
+        if local_provider
+          local_provider.merge!(local_attrs)
+        else
+          local_config["providers"] << { "name" => provider_name }.merge(local_attrs)
+        end
+        save_local_config(local_config)
+      end
+
+      # Set active provider
+      def set_active_provider(provider_name)
+        main_config = YAML.load_file(main_config_path)
+        main_config["active_provider"] = provider_name
+        save_main_config(main_config)
+      end
+
+      private
+
+      # Merge main config with local config (local overrides main)
+      def merge_configs(main_config, local_config)
+        result = main_config.dup
+
+        # Merge provider-specific settings
+        main_providers = main_config["providers"] || []
+        local_providers = local_config["providers"] || []
+
+        merged_providers = main_providers.map do |main_provider|
+          local_provider = local_providers.find { |lp| lp["name"] == main_provider["name"] }
+          local_provider ? main_provider.merge(local_provider) : main_provider
+        end
+
+        result["providers"] = merged_providers
+        result
+      end
+    end
+  end
+end