commitgpt 0.2.0 → 0.3.3

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)
+      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' => 32_768,
+            '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

data/lib/commitgpt/provider_presets.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module CommitGpt
+  # Provider presets for common AI providers
+  PROVIDER_PRESETS = [
+    { label: 'Cerebras', value: 'cerebras', base_url: 'https://api.cerebras.ai/v1' },
+    { label: 'Ollama', value: 'ollama', base_url: 'http://127.0.0.1:11434/v1' },
+    { label: 'OpenAI', value: 'openai', base_url: 'https://api.openai.com/v1' },
+    { label: 'LLaMa.cpp', value: 'llamacpp', base_url: 'http://127.0.0.1:8080/v1' },
+    { label: 'LM Studio', value: 'lmstudio', base_url: 'http://127.0.0.1:1234/v1' },
+    { label: 'Llamafile', value: 'llamafile', base_url: 'http://127.0.0.1:8080/v1' },
+    { label: 'DeepSeek', value: 'deepseek', base_url: 'https://api.deepseek.com' },
+    { label: 'Groq', value: 'groq', base_url: 'https://api.groq.com/openai/v1' },
+    { label: 'Mistral', value: 'mistral', base_url: 'https://api.mistral.ai/v1' },
+    { label: 'Anthropic (Claude)', value: 'anthropic', base_url: 'https://api.anthropic.com/v1' },
+    { label: 'OpenRouter', value: 'openrouter', base_url: 'https://openrouter.ai/api/v1' },
+    { label: 'Google AI', value: 'gemini', base_url: 'https://generativelanguage.googleapis.com/v1beta/openai' }
+  ].freeze
+end

data/lib/commitgpt/setup_wizard.rb

@@ -0,0 +1,317 @@
+# frozen_string_literal: true
+
+require 'tty-prompt'
+require 'httparty'
+require 'timeout'
+require_relative 'config_manager'
+require_relative 'provider_presets'
+require_relative 'string'
+
+module CommitGpt
+  # Interactive setup wizard for configuring AI providers
+  class SetupWizard
+    def initialize
+      @prompt = TTY::Prompt.new
+    end
+
+    # Main entry point for setup
+    def run
+      ConfigManager.ensure_config_dir
+      ConfigManager.generate_default_configs unless ConfigManager.config_exists?
+
+      provider_choice = select_provider
+      configure_provider(provider_choice)
+    end
+
+    # Switch to a different configured provider
+    def switch_provider
+      configured = ConfigManager.configured_providers
+
+      if configured.empty?
+        puts "▲ No providers configured. Please run 'aicm setup' first.".red
+        return
+      end
+
+      choices = configured.map do |p|
+        preset = PROVIDER_PRESETS.find { |pr| pr[:value] == p['name'] }
+        { name: preset ? preset[:label] : p['name'], value: p['name'] }
+      end
+
+      selected = @prompt.select('Choose your provider:', choices)
+
+      # Get current config for this provider
+      config = ConfigManager.load_config
+      provider = config['providers'].find { |p| p['name'] == selected }
+
+      # Fetch models and let user select
+      models = fetch_models_with_timeout(provider['base_url'], provider['api_key'])
+      return if models.nil?
+
+      model = select_model(models, provider['model'])
+
+      # Prompt for diff length
+      diff_len = prompt_diff_len(provider['diff_len'] || 32_768)
+
+      # Update config
+      ConfigManager.update_provider(selected, { 'model' => model, 'diff_len' => diff_len })
+      reset_provider_inference_params(selected)
+      ConfigManager.set_active_provider(selected)
+
+      preset = PROVIDER_PRESETS.find { |pr| pr[:value] == selected }
+      provider_label = preset ? preset[:label] : selected
+
+      puts "\nModel selected: #{model}".green
+      puts "Setup complete ✅  You're now using #{provider_label}.".green
+    end
+
+    # Change model for the active provider
+    def change_model
+      provider_config = ConfigManager.get_active_provider_config
+
+      if provider_config.nil? || provider_config['api_key'].nil? || provider_config['api_key'].empty?
+        puts "▲ No active provider configured. Please run 'aicm setup'.".red
+        return
+      end
+
+      # Fetch models and let user select
+      models = fetch_models_with_timeout(provider_config['base_url'], provider_config['api_key'])
+      return if models.nil?
+
+      model = select_model(models, provider_config['model'])
+
+      # Update config
+      ConfigManager.update_provider(provider_config['name'], { 'model' => model })
+      reset_provider_inference_params(provider_config['name'])
+
+      puts "\nModel selected: #{model}".green
+    end
+
+    private
+
+    # Select provider from list
+    def select_provider
+      config = ConfigManager.load_config
+      configured = config ? (config['providers'] || []) : []
+
+      choices = PROVIDER_PRESETS.map do |preset|
+        # Check if this provider already has an API key
+        provider_config = configured.find { |p| p['name'] == preset[:value] }
+        has_key = provider_config && provider_config['api_key'] && !provider_config['api_key'].empty?
+
+        label = preset[:label]
+        label = "✅ #{label}" if has_key
+        label = "#{label} (recommended)" if preset[:value] == 'cerebras'
+        label = "#{label} (local)" if %w[ollama llamacpp lmstudio llamafile].include?(preset[:value])
+
+        { name: label, value: preset[:value] }
+      end
+
+      choices << { name: 'Custom (OpenAI-compatible)', value: 'custom' }
+
+      @prompt.select('Choose your AI provider:', choices, per_page: 15)
+    end
+
+    # Configure selected provider
+    def configure_provider(provider_name)
+      if provider_name == 'custom'
+        configure_custom_provider
+        return
+      end
+
+      preset = PROVIDER_PRESETS.find { |p| p[:value] == provider_name }
+      base_url = preset[:base_url]
+      provider_label = preset[:label]
+
+      # Get existing API key if any
+      config = ConfigManager.load_config
+      existing_provider = config['providers'].find { |p| p['name'] == provider_name } if config
+
+      # Prompt for API key
+      api_key = prompt_api_key(provider_label, existing_provider&.dig('api_key'))
+      return if api_key.nil? # User cancelled
+
+      # Fetch models with timeout
+      models = fetch_models_with_timeout(base_url, api_key)
+      return if models.nil?
+
+      # Let user select model
+      model = select_model(models, existing_provider&.dig('model'))
+
+      # Prompt for diff length
+      diff_len = prompt_diff_len(existing_provider&.dig('diff_len') || 32_768)
+
+      # Save configuration
+      ConfigManager.update_provider(
+        provider_name,
+        { 'model' => model, 'diff_len' => diff_len },
+        { 'api_key' => api_key }
+      )
+      ConfigManager.set_active_provider(provider_name)
+
+      puts "\nModel selected: #{model}".green
+      puts "✅ Setup complete! You're now using #{provider_label}.".green
+    end
+
+    # Configure custom provider
+    def configure_custom_provider
+      provider_name = @prompt.ask('Enter provider name:') do |q|
+        q.required true
+        q.modify :strip, :down
+      end
+
+      base_url = @prompt.ask('Enter base URL:') do |q|
+        q.required true
+        q.default 'http://localhost:8080/v1'
+      end
+
+      api_key = @prompt.mask('Enter your API key (optional):') { |q| q.echo false }
+
+      # Fetch models
+      models = fetch_models_with_timeout(base_url, api_key)
+      return if models.nil?
+
+      model = select_model(models)
+      diff_len = prompt_diff_len(32_768)
+
+      # Add to presets dynamically (just for this session)
+      # Save to config
+      config = ConfigManager.load_config || { 'providers' => [], 'active_provider' => '' }
+
+      # Add or update provider in main config
+      existing = config['providers'].find { |p| p['name'] == provider_name }
+      if existing
+        existing.merge!({ 'model' => model, 'diff_len' => diff_len, 'base_url' => base_url })
+      else
+        config['providers'] << {
+          'name' => provider_name,
+          'model' => model,
+          'diff_len' => diff_len,
+          'base_url' => base_url
+        }
+      end
+      config['active_provider'] = provider_name
+      ConfigManager.save_main_config(config)
+
+      # Update local config
+      local_config = if File.exist?(ConfigManager.local_config_path)
+                       YAML.load_file(ConfigManager.local_config_path)
+                     else
+                       { 'providers' => [] }
+                     end
+
+      local_existing = local_config['providers'].find { |p| p['name'] == provider_name }
+      if local_existing
+        local_existing['api_key'] = api_key
+      else
+        local_config['providers'] << { 'name' => provider_name, 'api_key' => api_key }
+      end
+      ConfigManager.save_local_config(local_config)
+
+      puts "\nModel selected: #{model}".green
+      puts "✅ Setup complete! You're now using #{provider_name}.".green
+    end
+
+    # Prompt for API key
+    def prompt_api_key(_provider_name, existing_key)
+      message = if existing_key && !existing_key.empty?
+                  'Enter your API key (press Enter to keep existing):'
+                else
+                  'Enter your API key:'
+                end
+
+      key = @prompt.mask(message) { |q| q.echo false }
+
+      # If user pressed Enter and there's an existing key, use it
+      if key.empty? && existing_key && !existing_key.empty?
+        existing_key
+      else
+        key
+      end
+    end
+
+    # Fetch models from provider with timeout
+    def fetch_models_with_timeout(base_url, api_key)
+      puts 'Fetching available models...'.gray
+
+      models = nil
+      begin
+        Timeout.timeout(5) do
+          headers = {
+            'Content-Type' => 'application/json',
+            'User-Agent' => "Ruby/#{RUBY_VERSION}"
+          }
+          headers['Authorization'] = "Bearer #{api_key}" if api_key && !api_key.empty?
+
+          response = HTTParty.get("#{base_url}/models", headers: headers)
+
+          if response.code == 200
+            models = response['data'] || []
+            models = models.map { |m| m['id'] }.compact.sort
+          else
+            puts "▲ Failed to fetch models: HTTP #{response.code}".red
+            return nil
+          end
+        end
+      rescue Timeout::Error
+        puts '▲ Connection timeout (5s). Please check your network, base_url, and api_key.'.red
+        exit(0)
+      rescue StandardError => e
+        puts "▲ Error fetching models: #{e.message}".red
+        exit(0)
+      end
+
+      if models.nil? || models.empty?
+        puts '▲ No models found. Please check your configuration.'.red
+        exit(0)
+      end
+
+      models
+    end
+
+    # Let user select a model
+    def select_model(models, current_model = nil)
+      choices = models.map { |m| { name: m, value: m } }
+      choices << { name: 'Custom model name...', value: :custom }
+
+      # Set default to current model if it exists
+      default_index = if current_model && models.include?(current_model)
+                        models.index(current_model) + 1 # +1 for 1-based index
+                      else
+                        1
+                      end
+
+      selected = @prompt.select('Choose your model:', choices, per_page: 15, default: default_index)
+
+      if selected == :custom
+        @prompt.ask('Enter custom model name:') do |q|
+          q.required true
+          q.modify :strip
+        end
+      else
+        selected
+      end
+    end
+
+    # Prompt for diff length
+    def prompt_diff_len(default = 32_768)
+      answer = @prompt.ask('Set the maximum diff length (Bytes) for generating commit message:') do |q|
+        q.default default.to_s
+        q.convert :int
+      end
+
+      answer || default
+    end
+
+    def reset_provider_inference_params(provider_name)
+      config = YAML.load_file(ConfigManager.main_config_path)
+      return unless config && config['providers']
+
+      provider = config['providers'].find { |p| p['name'] == provider_name }
+      if provider
+        provider.delete('can_disable_reasoning')
+        provider.delete('max_tokens')
+        ConfigManager.save_main_config(config)
+      end
+    end
+  end
+end

data/lib/commitgpt/string.rb

@@ -21,4 +21,8 @@ class String
   def cyan
     "\e[36m#{self}\e[0m"
   end
+
+  def yellow
+    "\e[33m#{self}\e[0m"
+  end
 end

data/lib/commitgpt/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module CommitGpt
-  VERSION = "0.2.0"
+  VERSION = '0.3.3'
 end

data/lib/commitgpt.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require_relative "commitgpt/version"
-require_relative "commitgpt/commit_ai"
+require_relative 'commitgpt/version'
+require_relative 'commitgpt/commit_ai'
 
 module CommitGpt
   class Error < StandardError; end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: commitgpt
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.3
 platform: ruby
 authors:
 - Peng Zhang
@@ -15,28 +15,42 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.18'
+        version: '0.24'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.18'
+        version: '0.24'
 - !ruby/object:Gem::Dependency
   name: thor
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.2'
+        version: '1.4'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.2'
+        version: '1.4'
+- !ruby/object:Gem::Dependency
+  name: tty-prompt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.23'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.23'
 description: A CLI that writes your git commit messages for you with AI. Never write
   a commit message again.
 email:
@@ -46,20 +60,16 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
-- ".rspec"
-- ".rubocop.yml"
-- CHANGELOG.md
-- CODE_OF_CONDUCT.md
-- Gemfile
-- Gemfile.lock
 - LICENSE
-- LICENSE.txt
 - README.md
-- Rakefile
 - bin/aicm
+- commitgpt.gemspec
 - lib/commitgpt.rb
 - lib/commitgpt/cli.rb
 - lib/commitgpt/commit_ai.rb
+- lib/commitgpt/config_manager.rb
+- lib/commitgpt/provider_presets.rb
+- lib/commitgpt/setup_wizard.rb
 - lib/commitgpt/string.rb
 - lib/commitgpt/version.rb
 homepage: https://github.com/ZPVIP/commitgpt
@@ -69,6 +79,7 @@ metadata:
   homepage_uri: https://github.com/ZPVIP/commitgpt
   source_code_uri: https://github.com/ZPVIP/commitgpt
   changelog_uri: https://github.com/ZPVIP/commitgpt/blob/master/CHANGELOG.md
+  rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
 - lib

data/.rspec

@@ -1,3 +0,0 @@
---format documentation
---color
---require spec_helper

data/.rubocop.yml

@@ -1,19 +0,0 @@
-AllCops:
-  TargetRubyVersion: 2.6
-
-Style/StringLiterals:
-  Enabled: true
-  EnforcedStyle: double_quotes
-
-Style/StringLiteralsInInterpolation:
-  Enabled: true
-  EnforcedStyle: double_quotes
-
-Layout/LineLength:
-  Max: 160
-
-MethodLength:
-  Max: 20
-
-Metrics/BlockLength:
-  Max: 100

data/CHANGELOG.md

@@ -1,5 +0,0 @@
-## [Unreleased]
-
-## [0.1.0] - 2023-02-14
-
-- Initial release