git_auto 0.1.0

data/lib/git_auto/commands/config_command.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+require "tty-prompt"
+require "colorize"
+
+module GitAuto
+  module Commands
+    class ConfigCommand
+      def initialize
+        @prompt = TTY::Prompt.new
+        @credential_store = Config::CredentialStore.new
+        @settings = Config::Settings.new
+      end
+
+      def execute(args = [])
+        if args.empty?
+          interactive_config
+        else
+          handle_config_args(args)
+        end
+      end
+
+      private
+
+      def handle_config_args(args)
+        case args[0]
+        when "get"
+          get_setting(args[1])
+        when "set"
+          set_setting(args[1], args[2])
+        else
+          puts "❌ Unknown command: #{args[0]}".red
+          puts "Usage: git_auto config [get|set] <key> [value]"
+          exit 1
+        end
+      end
+
+      def get_setting(key)
+        if key.nil?
+          puts "❌ Missing key".red
+          puts "Usage: git_auto config get <key>"
+          exit 1
+        end
+
+        value = @settings.get(key.to_sym)
+        if value.nil?
+          puts "❌ Setting '#{key}' not found".red
+          exit 1
+        end
+
+        puts value
+      end
+
+      def set_setting(key, value)
+        if key.nil? || value.nil?
+          puts "❌ Missing key or value".red
+          puts "Usage: git_auto config set <key> <value>"
+          exit 1
+        end
+
+        @settings.set(key.to_sym, value)
+        puts "✓ Setting '#{key}' updated to '#{value}'".green
+      end
+
+      def interactive_config
+        puts "\n⚙️  GitAuto Configuration".blue
+
+        loop do
+          choice = main_menu
+          break if choice == "exit"
+
+          case choice
+          when "show"
+            display_configuration
+          when "provider"
+            configure_ai_provider
+          when "model"
+            configure_ai_model
+          when "api_key"
+            configure_api_key
+          when "style"
+            configure_commit_style
+          when "preferences"
+            configure_preferences
+          when "history"
+            configure_history_settings
+          end
+        end
+      end
+
+      def main_menu
+        @prompt.select("Choose an option:", {
+                         "📊 Show current configuration" => "show",
+                         "🤖 Configure AI provider" => "provider",
+                         "🔧 Configure AI model" => "model",
+                         "🔑 Configure API key" => "api_key",
+                         "💫 Configure commit style" => "style",
+                         "⚙️  Configure preferences" => "preferences",
+                         "📜 Configure history settings" => "history",
+                         "❌ Exit" => "exit"
+                       })
+      end
+
+      def display_configuration
+        puts "\nCurrent Configuration:".blue
+        puts "AI Provider: #{@settings.get(:ai_provider)}"
+        puts "AI Model: #{@settings.get(:ai_model)}"
+        puts "Commit Style: #{@settings.get(:commit_style)}"
+        puts "Show Diff: #{@settings.get(:show_diff)}"
+        puts "Save History: #{@settings.get(:save_history)}"
+        puts "\nPress any key to continue..."
+        @prompt.keypress
+      end
+
+      def configure_ai_provider
+        provider = @prompt.select("Choose AI provider:", {
+                                    "OpenAI (GPT-4, GPT-3.5 Turbo)" => "openai",
+                                    "Anthropic (Claude 3.5 Sonnet, Claude 3.5 Haiku)" => "claude"
+                                  })
+
+        @settings.save(ai_provider: provider)
+        puts "✓ AI provider updated to #{provider}".green
+
+        # Check if API key exists for the new provider
+        unless @credential_store.api_key_exists?(provider)
+          puts "\nNo API key found for #{provider.upcase}. Let's set it up.".blue
+          configure_api_key
+        end
+
+        # Auto-configure model after provider change
+        configure_ai_model
+      end
+
+      def configure_ai_model
+        models = Config::Settings::SUPPORTED_PROVIDERS[@settings.get(:ai_provider)][:models]
+        model_choices = models.map { |name, value| { name: name, value: value } }
+
+        model = @prompt.select("Choose AI model:", model_choices)
+        @settings.save(ai_model: model)
+        puts "✓ AI model updated to #{model}".green
+      end
+
+      def configure_api_key
+        provider = @settings.get(:ai_provider)
+        puts "\nConfiguring API key for #{provider.upcase}".blue
+
+        key = @prompt.mask("Enter your API key:")
+        @credential_store.store_api_key(key, provider)
+        puts "✓ API key updated".green
+      end
+
+      def configure_commit_style
+        style = @prompt.select("Choose commit message style:", {
+                                 "Conventional (type(scope): description)" => "conventional",
+                                 "Simple (description only)" => "simple"
+                               })
+
+        @settings.set(:commit_style, style)
+        puts "✓ Commit style updated to #{style}".green
+      end
+
+      def configure_preferences
+        show_diff = @prompt.yes?("Show diff before committing?")
+        @settings.set(:show_diff, show_diff)
+        puts "✓ Show diff preference updated".green
+      end
+
+      def configure_history_settings
+        save_history = @prompt.yes?("Save commit history for analysis?")
+        @settings.set(:save_history, save_history)
+        puts "✓ History settings updated".green
+      end
+    end
+  end
+end

data/lib/git_auto/commands/history_analysis_command.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module GitAuto
+  module Commands
+    class HistoryAnalysisCommand
+      def initialize(options = {})
+        @limit = options[:limit] || 10
+        @git_service = Services::GitService.new
+        @prompt = TTY::Prompt.new
+        @spinner = TTY::Spinner.new("[:spinner] Analyzing commit history...")
+      end
+
+      def execute
+        @spinner.auto_spin
+        commits = fetch_commits
+        analysis = analyze_commits(commits)
+        @spinner.success
+        display_results(analysis)
+      rescue StandardError => e
+        puts "❌ Error analyzing commits: #{e.message}".red
+        exit 1
+      end
+
+      private
+
+      def fetch_commits
+        @git_service.get_commit_history(@limit)
+      end
+
+      def analyze_commits(commits)
+        {
+          total_commits: commits.size,
+          types: analyze_types(commits),
+          avg_length: average_message_length(commits),
+          common_patterns: find_common_patterns(commits)
+        }
+      end
+
+      def analyze_types(commits)
+        commits.each_with_object(Hash.new(0)) do |commit, types|
+          type = extract_type(commit)
+          types[type] += 1
+        end
+      end
+
+      def extract_type(commit)
+        return "conventional" if commit.match?(/^(feat|fix|docs|style|refactor|test|chore)(\(.+\))?:/)
+        return "detailed" if commit.include?("\n\n")
+
+        "simple"
+      end
+
+      def average_message_length(commits)
+        return 0 if commits.empty?
+
+        commits.sum(&:length) / commits.size
+      end
+
+      def find_common_patterns(commits)
+        words = commits.flat_map { |c| c.downcase.scan(/\w+/) }
+        words.each_with_object(Hash.new(0)) { |word, counts| counts[word] += 1 }
+          .sort_by { |_, count| -count }
+          .first(5)
+          .to_h
+      end
+
+      def display_results(analysis)
+        puts "\n📊 Commit History Analysis".blue
+        puts "Total commits analyzed: #{analysis[:total_commits]}"
+
+        puts "\n📝 Commit Types:".blue
+        analysis[:types].each do |type, count|
+          percentage = (count.to_f / analysis[:total_commits] * 100).round(1)
+          puts "#{type}: #{count} (#{percentage}%)"
+        end
+
+        puts "\n📈 Statistics:".blue
+        puts "Average message length: #{analysis[:avg_length]} characters"
+
+        puts "\n🔍 Common words:".blue
+        analysis[:common_patterns].each do |word, count|
+          puts "#{word}: #{count} times"
+        end
+      end
+    end
+  end
+end

data/lib/git_auto/commands/setup_command.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require "tty-prompt"
+require "colorize"
+
+module GitAuto
+  module Commands
+    class SetupCommand
+      def initialize
+        @prompt = TTY::Prompt.new
+        @credential_store = Config::CredentialStore.new
+        @settings = Config::Settings.new
+      end
+
+      def execute
+        puts "\n🔧 Setting up GitAuto...".blue
+        puts "This wizard will help you configure GitAuto with your preferred AI provider.\n"
+
+        # Select AI provider
+        configure_ai_provider
+
+        # Configure preferences
+        configure_preferences
+
+        puts "\n✅ Setup completed successfully!".green
+        display_configuration
+      rescue StandardError => e
+        puts "\n❌ Setup failed: #{e.message}".red
+        exit 1
+      end
+
+      private
+
+      def configure_ai_provider
+        # Select provider
+        provider_choices = Config::Settings::SUPPORTED_PROVIDERS.map do |key, info|
+          { name: info[:name], value: key }
+        end
+
+        provider = @prompt.select(
+          "Choose your AI provider:",
+          provider_choices,
+          help: "(Use ↑/↓ and Enter to select)"
+        )
+
+        # Select model for the chosen provider
+        models = Config::Settings::SUPPORTED_PROVIDERS[provider][:models]
+        model_choices = models.map { |name, value| { name: name, value: value } }
+
+        model = @prompt.select(
+          "Choose the AI model:",
+          model_choices,
+          help: "More capable models may be slower but produce better results"
+        )
+
+        # Get and validate API key
+        provider_name = Config::Settings::SUPPORTED_PROVIDERS[provider][:name]
+        puts "\nℹ️  The API key will be securely stored in your system's credential store"
+        api_key = @prompt.mask("Enter your #{provider_name} API key:") do |q|
+          q.required true
+          q.validate(/\S+/, "API key cannot be empty")
+        end
+
+        # Save configuration
+        @settings.save(
+          ai_provider: provider,
+          ai_model: model
+        )
+        @credential_store.store_api_key(api_key, provider)
+
+        puts "✓ #{provider_name} configured successfully".green
+      end
+
+      def configure_preferences
+        puts "\n🔧 Configuring preferences...".blue
+
+        commit_style = select_commit_style
+        show_diff = @prompt.yes?("Show diff preview before generating commit messages?", default: true)
+        save_history = @prompt.yes?("Save commit history for pattern analysis?", default: true)
+
+        settings = { commit_style: commit_style, show_diff: show_diff, save_history: save_history }
+
+        @settings.save(settings)
+      end
+
+      def select_commit_style
+        @prompt.select(
+          "Select default commit message style:",
+          [
+            { name: "Conventional (type(scope): description)", value: "conventional" },
+            { name: "Simple (verb + description)", value: "simple" },
+            { name: "Detailed (summary + bullet points)", value: "detailed" }
+          ],
+          help: "This can be changed later using git_auto config"
+        )
+      end
+
+      def display_configuration
+        config = @settings.all
+        provider_info = Config::Settings::SUPPORTED_PROVIDERS[config[:ai_provider]]
+
+        puts "\nCurrent Configuration:"
+        puts "──────────────────────"
+        puts "AI Provider: #{provider_info[:name]} (#{config[:ai_provider]})".cyan
+        puts "Model: #{config[:ai_model]}".cyan
+        puts "Commit Style: #{config[:commit_style]}".cyan
+        puts "Show Diff: #{config[:show_diff]}".cyan
+        puts "Save History: #{config[:save_history]}".cyan
+        puts "\nYou can change these settings anytime using: git_auto config"
+      end
+    end
+  end
+end

data/lib/git_auto/config/credential_store.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require "openssl"
+require "base64"
+require "fileutils"
+require "yaml"
+
+module GitAuto
+  module Config
+    class CredentialStore
+      CREDENTIALS_FILE = File.join(File.expand_path("~/.git_auto"), "credentials.yml")
+      ENCRYPTION_KEY = ENV["GIT_AUTO_SECRET"] || "default_development_key"
+
+      def initialize
+        ensure_credentials_file
+      end
+
+      def store_api_key(key, provider)
+        credentials = load_credentials
+        credentials[provider.to_s] = encrypt(key)
+        save_credentials(credentials)
+      end
+
+      def get_api_key(provider)
+        credentials = load_credentials
+        encrypted_key = credentials[provider.to_s]
+        return nil unless encrypted_key
+
+        decrypt(encrypted_key)
+      end
+
+      def api_key_exists?(provider)
+        credentials = load_credentials
+        credentials.key?(provider.to_s)
+      end
+
+      private
+
+      def ensure_credentials_file
+        dir = File.dirname(CREDENTIALS_FILE)
+        FileUtils.mkdir_p(dir) unless File.directory?(dir)
+        FileUtils.touch(CREDENTIALS_FILE) unless File.exist?(CREDENTIALS_FILE)
+      end
+
+      def load_credentials
+        content = File.read(CREDENTIALS_FILE).strip
+        content.empty? ? {} : YAML.safe_load(content)
+      end
+
+      def save_credentials(credentials)
+        File.write(CREDENTIALS_FILE, YAML.dump(credentials))
+      end
+
+      def encrypt(text)
+        cipher = OpenSSL::Cipher.new("aes-256-cbc")
+        cipher.encrypt
+        cipher.key = Digest::SHA256.digest(ENCRYPTION_KEY)
+        iv = cipher.random_iv
+        encrypted = cipher.update(text) + cipher.final
+        Base64.strict_encode64(iv + encrypted)
+      end
+
+      def decrypt(encrypted_data)
+        encrypted = Base64.strict_decode64(encrypted_data)
+        decipher = OpenSSL::Cipher.new("aes-256-cbc")
+        decipher.decrypt
+        decipher.key = Digest::SHA256.digest(ENCRYPTION_KEY)
+        decipher.iv = encrypted[0..15]
+        decipher.update(encrypted[16..]) + decipher.final
+      end
+    end
+  end
+end

data/lib/git_auto/config/settings.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "fileutils"
+
+module GitAuto
+  module Config
+    class Settings
+      CONFIG_DIR = File.expand_path("~/.git_auto")
+      CONFIG_FILE = File.join(CONFIG_DIR, "config.yml")
+
+      SUPPORTED_PROVIDERS = {
+        "claude" => {
+          name: "Anthropic (Claude 3.5 Sonnet, Claude 3.5 Haiku)",
+          models: {
+            "Claude 3.5 Sonnet" => "claude-3-5-sonnet-latest",
+            "Claude 3.5 Haiku" => "claude-3-5-haiku-latest"
+          }
+        },
+        "openai" => {
+          name: "OpenAI (GPT-4o, GPT-4o mini)",
+          models: {
+            "GPT-4o" => "gpt-4o",
+            "GPT-4o mini" => "gpt-4o-mini"
+          }
+        }
+      }.freeze
+
+      DEFAULT_SETTINGS = {
+        commit_style: "conventional",
+        ai_provider: "openai",
+        ai_model: "gpt-4o",
+        show_diff: true,
+        save_history: true,
+        max_retries: 3
+      }.freeze
+
+      def initialize
+        ensure_config_dir
+        @settings = load_settings
+      end
+
+      def save(options = {})
+        validate_settings!(options)
+        @settings = @settings.merge(options)
+        File.write(CONFIG_FILE, YAML.dump(@settings))
+      end
+
+      def get(key)
+        @settings[key.to_sym]
+      end
+
+      def all
+        @settings
+      end
+
+      def provider_info
+        SUPPORTED_PROVIDERS[get(:ai_provider)]
+      end
+
+      def available_models
+        provider_info[:models]
+      end
+
+      private
+
+      def ensure_config_dir
+        FileUtils.mkdir_p(CONFIG_DIR)
+      end
+
+      def load_settings
+        return DEFAULT_SETTINGS.dup unless File.exist?(CONFIG_FILE)
+
+        user_settings = YAML.load_file(CONFIG_FILE) || {}
+        DEFAULT_SETTINGS.merge(user_settings)
+      rescue StandardError
+        DEFAULT_SETTINGS.dup
+      end
+
+      def validate_settings!(options)
+        if options[:ai_provider] && !SUPPORTED_PROVIDERS.key?(options[:ai_provider])
+          raise Error, "Unsupported AI provider. Available providers: #{SUPPORTED_PROVIDERS.keys.join(", ")}"
+        end
+
+        return unless options[:ai_model]
+
+        provider = options[:ai_provider] || get(:ai_provider)
+        available_models = SUPPORTED_PROVIDERS[provider][:models]
+        return if available_models.values.include?(options[:ai_model])
+
+        raise Error, "Unsupported model for #{provider}. Available models: #{available_models.keys.join(", ")}"
+      end
+    end
+  end
+end

data/lib/git_auto/errors.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module GitAuto
+  module Errors
+    class Error < StandardError; end
+    class MissingAPIKeyError < Error; end
+    class EmptyDiffError < Error; end
+    class RateLimitError < Error; end
+    class APIError < Error; end
+    class InvalidProviderError < Error; end
+  end
+end

data/lib/git_auto/formatters/diff_formatter.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module GitAuto
+  module Formatters
+    class DiffFormatter
+      def format(diff)
+        return "No changes" if diff.empty?
+
+        formatted = []
+        current_file = nil
+
+        diff.each_line do |line|
+          case line
+          when /^diff --git/
+            current_file = extract_file_name(line)
+            formatted << "\nChanges in #{current_file}:"
+          when /^index |^---|\+\+\+/
+            next # Skip index and file indicator lines
+          when /^@@ .* @@/
+            formatted << format_hunk_header(line)
+          when /^\+/
+            formatted << "Added: #{line[1..].strip}"
+          when /^-/
+            formatted << "Removed: #{line[1..].strip}"
+          when /^ /
+            formatted << "Context: #{line.strip}" unless line.strip.empty?
+          end
+        end
+
+        formatted.join("\n")
+      end
+
+      private
+
+      def extract_file_name(line)
+        line.match(%r{b/(.+)$})[1]
+      end
+
+      def format_hunk_header(line)
+        match = line.match(/@@ -(\d+),?(\d*) \+(\d+),?(\d*) @@(.*)/)
+        return line unless match
+
+        line_info = "@ #{match[1]}-#{match[3]}"
+        context = match[5].strip
+        "\nSection #{line_info} #{context}"
+      end
+    end
+  end
+end

data/lib/git_auto/formatters/diff_summarizer.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module GitAuto
+  module Formatters
+    class DiffSummarizer
+      FileChange = Struct.new(:name, :additions, :deletions, :key_changes)
+
+      def summarize(diff)
+        return "No changes" if diff.empty?
+
+        file_changes = parse_diff(diff)
+        generate_summary(file_changes)
+      end
+
+      private
+
+      def parse_diff(diff)
+        changes = {}
+        current_file = nil
+        current_changes = nil
+
+        diff.each_line do |line|
+          case line
+          when /^diff --git/
+            changes[current_file] = current_changes if current_file
+            current_file = extract_file_name(line)
+            current_changes = FileChange.new(current_file, 0, 0, [])
+          when /^\+(?!\+\+)/
+            next if current_changes.nil?
+
+            current_changes.additions += 1
+            content = line[1..].strip
+            current_changes.key_changes << "+#{content}" if key_change?(content)
+          when /^-(?!--)/
+            next if current_changes.nil?
+
+            current_changes.deletions += 1
+            content = line[1..].strip
+            current_changes.key_changes << "-#{content}" if key_change?(content)
+          end
+        end
+
+        # Add the last file's changes
+        changes[current_file] = current_changes if current_file
+
+        changes
+      end
+
+      def generate_summary(changes)
+        return "No changes" if changes.empty?
+
+        total_additions = 0
+        total_deletions = 0
+        summary = []
+
+        summary << "[Summary: Changes across #{changes.size} files]"
+
+        changes.each_value do |change|
+          total_additions += change.additions
+          total_deletions += change.deletions
+        end
+
+        summary << "Total: +#{total_additions} lines added, -#{total_deletions} lines removed"
+        summary << "\nFiles modified:"
+
+        changes.each_value do |change|
+          summary << "- #{change.name}:"
+          if change.key_changes.any?
+            change.key_changes.take(5).each do |key_change|
+              summary << "  #{key_change}"
+            end
+            summary << "  [...#{change.key_changes.size - 5} more changes omitted...]" if change.key_changes.size > 5
+          else
+            summary << "  #{change.additions} additions, #{change.deletions} deletions"
+          end
+        end
+
+        summary << "\n[Note: Some context and minor changes have been omitted for brevity]"
+        summary.join("\n")
+      end
+
+      def extract_file_name(line)
+        line.match(%r{b/(.+)$})[1]
+      end
+
+      def key_change?(line)
+        # Consider a change "key" if it matches certain patterns
+        return true if line.match?(/^(class|module|def|private|protected|public)/)
+        return true if line.match?(/^[A-Z][A-Za-z0-9_]*\s*=/) # Constants
+        return true if line.match?(/^\s*attr_(reader|writer|accessor)/)
+        return true if line.match?(/^\s*validates?/)
+        return true if line.match?(/^\s*has_(many|one|and_belongs_to_many)/)
+        return true if line.match?(/^\s*belongs_to/)
+
+        false
+      end
+    end
+  end
+end