commitgpt 0.2.0 → 0.3.1

data/lib/commitgpt/commit_ai.rb

@@ -1,18 +1,35 @@
 # 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
-    AICM_KEY = ENV.fetch("AICM_KEY", nil)
-    AICM_LINK = ENV.fetch("AICM_LINK", "https://api.openai.com/v1")
-    AICM_DIFF_LEN = ENV.fetch("AICM_DIFF_LEN", "32768").to_i
-    AICM_MODEL = ENV.fetch("AICM_MODEL", "gpt-4o-mini")
+    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
@@ -22,8 +39,55 @@ module CommitGpt
         puts diff
         puts "\n"
       end
-      ai_commit_message = message(diff) || exit(1)
-      puts `git commit -m "#{ai_commit_message}" && echo && echo && git log -1 && echo` if confirmed
+
+      loop do
+        ai_commit_message = message(diff) || exit(1)
+        action = confirm_commit(ai_commit_message)
+
+        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
+
+    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
 
     def list_models
@@ -44,47 +108,164 @@ module CommitGpt
 
     private
 
-    def confirmed
-      puts "▲ Do you want to commit this message? [y/n]".magenta
-
-      use_commit_message = nil
-      use_commit_message = $stdin.getch.downcase until use_commit_message =~ /\A[yn]\z/i
-
-      puts "\n▲ Commit message has not been commited.\n".red if use_commit_message == "n"
-
-      use_commit_message == "y"
+    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
 
     def message(diff = nil)
-      puts "▲   Generating your AI commit message...\n".gray
-      ai_commit_message = generate_commit(diff)
-      return nil if ai_commit_message.nil?
-
-      puts "#{"▲ Commit message: ".green}git commit -am \"#{ai_commit_message}\"\n\n"
-      ai_commit_message
+      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
 
-      if diff.length > AICM_DIFF_LEN
-        puts "▲ The diff is too large (#{diff.length} chars, max #{AICM_DIFF_LEN}). Set AICM_DIFF_LEN to increase limit.".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 AICM_KEY.nil? && AICM_LINK == "https://api.openai.com/v1"
-        puts "▲ Please save your API key as an env variable by doing 'export AICM_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
 
@@ -116,45 +297,199 @@ module CommitGpt
         }
       ]
 
+      # 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: AICM_MODEL,
+        model: @model,
         messages: messages,
-        temperature: 0.7,
-        max_tokens: 300,
-        disable_reasoning: true
+        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
-        headers = {
-          "Content-Type" => "application/json",
-          "User-Agent" => "Ruby/#{RUBY_VERSION}"
-        }
-        headers["Authorization"] = "Bearer #{AICM_KEY}" if AICM_KEY
+        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
 
-        response = HTTParty.post("#{AICM_LINK}/chat/completions",
-                                 headers: headers,
-                                 body: payload.to_json)
+            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
 
-        # Check for API error response
-        if response["error"]
-          puts "▲ API Error: #{response['error']['message']}".red
-          return nil
-        end
+            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: ")
 
-        message = response.dig("choices", 0, "message")
-        # Some models (like zai-glm) use 'reasoning' instead of 'content'
-        ai_commit = message&.dig("content") || message&.dig("reasoning")
-        if ai_commit.nil?
-          puts "▲ Unexpected API response format:".red
-          puts response.inspect
-          return nil
+              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)/, "").gsub(/\A["']|["']\z/, "")
+      # 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