git_auto 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 18b1522d4ba03cddfe1536bb6ee06cab7b12c7b3368c1883ebda20825c89673f
+  data.tar.gz: 62e9d5d3a7f0b89292ed993ab601a63fa91134abb49ecda8bbbc349384a3aff8
+SHA512:
+  metadata.gz: e3ee6ea8c6e9de921c13bb63b0c5d0e9232754b3cca4c39d1bc2de4b6cabb54ad1f0800ced7cafbaa60a13f22d5b5cd0ebff85541912c5b7dd670fd8d0982f86
+  data.tar.gz: a9f369e2008ed297e21fa88f049ba36ed3446ad72ecdc845537bcd20529c947bc31df69fc7195b554ff7b094ce139ff8717735b9b3b5124099ab86292b3a7bce

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2024-12-12
+
+- Initial release

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 Guillermo Diaz
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,113 @@
+# GitAuto 🤖✨
+
+> AI-powered commit messages that make sense
+
+GitAuto is a Ruby gem that streamlines your git workflow by automatically generating meaningful commit messages using AI. Say goodbye to generic commit messages and hello to clear, consistent, and informative descriptions of your changes.
+
+## Features 🚀
+
+- 🎯 **Intelligent Analysis**: Automatically analyzes your staged changes
+- 💡 **Smart Generation**: Creates conventional commit messages that actually make sense
+- 🎨 **Beautiful CLI**: Interactive and colorful command-line interface
+- 📋 **Clipboard Integration**: Easy copying of generated messages
+- 🔍 **Diff Preview**: Optional preview of changes before message generation
+- 📝 **Message History**: Keeps track of your commit messages
+- 🤖 **AI Providers**: Supports multiple AI providers:
+  - OpenAI (GPT-4o, GPT-4o mini)
+  - Anthropic (Claude 3.5 Sonnet, Claude 3.5 Haiku)
+- 🔒 **Secure Storage**: Your API keys are encrypted using AES-256-CBC and stored securely
+
+## Installation 💎
+
+```bash
+gem install git_auto
+```
+
+Or add to your Gemfile:
+
+```ruby
+gem 'git_auto'
+```
+
+## Usage 🛠️
+
+1. Stage your changes as usual:
+```bash
+git add .
+```
+
+2. Generate a commit message:
+```bash
+git-auto commit
+```
+
+3. Review, edit if needed, and confirm!
+
+## Setup and Configuration 🔧
+
+### Initial Setup
+
+Run the setup wizard to configure GitAuto:
+```bash
+git-auto setup
+```
+This will guide you through:
+- Setting up your preferred AI provider
+- Configuring your API keys (stored securely with AES-256-CBC encryption)
+- Setting default preferences
+
+### Configuration Management
+
+Manage your settings anytime with:
+```bash
+git-auto config
+```
+
+This allows you to:
+- Update API keys
+- Change AI provider settings
+- Modify default behaviors
+- View current configuration
+
+### Security 🔐
+
+GitAuto takes security seriously:
+- API keys are encrypted using AES-256-CBC encryption
+- Keys are stored in your system's user directory (`~/.git_auto/credentials.yml`)
+- You can set a custom encryption key via `GIT_AUTO_SECRET` environment variable
+
+### Environment Variables
+
+GitAuto can also be configured through environment variables:
+
+- `OPENAI_API_KEY`: Your OpenAI API key for message generation
+- `GIT_AUTO_MODEL`: OpenAI model to use (default: gpt-3.5-turbo)
+- `GIT_AUTO_SECRET`: Custom encryption key for storing API keys (optional)
+
+## Requirements ⚙️
+
+- Ruby >= 3.0.0
+- Git repository with staged changes
+
+## Screenshots 📸
+
+*Coming soon...*
+
+## Roadmap 🗺️
+
+Here's what we're planning for future releases:
+
+- 🤖 Support for Google Gemini AI
+- 📝 Automatic PR description generation
+- More exciting features coming soon!
+
+## Contributing 🤝
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/diazgdev/git_auto.
+
+## License 📄
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+---
+Made with ❤️ by [Guillermo Diaz](https://github.com/diazgdev)

data/exe/git_auto

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "git_auto"
+require "git_auto/cli"
+
+GitAuto::CLI.start(ARGV)

data/lib/git_auto/cli.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require "thor"
+require "tty-prompt"
+require "colorize"
+
+module GitAuto
+  class CLI < Thor
+    def self.exit_on_failure?
+      true
+    end
+
+    # Add version information
+    map ["--version", "-v"] => :version
+    desc "--version, -v", "Print version"
+    def version
+      puts "git_auto version #{GitAuto::VERSION}"
+    end
+
+    desc "setup", "Configure GitAuto settings and API keys"
+    long_desc <<-LONGDESC
+      Interactive setup wizard for GitAuto.
+
+      This will guide you through:
+      * Selecting an AI provider (Claude or OpenAI)
+      * Configuring your API key
+      * Setting commit message preferences
+      * Configuring other options
+    LONGDESC
+    def setup
+      Commands::SetupCommand.new.execute
+    end
+
+    desc "config [get|set] [key] [value]", "View or update configuration"
+    long_desc <<-LONGDESC
+      Manage GitAuto configuration.
+
+      Examples:
+        git_auto config                    # Interactive configuration
+        git_auto config get               # Show all settings
+        git_auto config get ai_provider   # Show specific setting
+        git_auto config set ai_model gpt-4 # Update specific setting
+    LONGDESC
+    def config(*args)
+      Commands::ConfigCommand.new.execute(args)
+    end
+
+    desc "commit", "Generate AI-powered commit message"
+    method_option :style, type: :string, desc: "Commit message style (conventional, simple, detailed)"
+    method_option :scope, type: :string, desc: "Commit scope for conventional style"
+    method_option :preview, type: :boolean, desc: "Show diff preview before committing"
+    long_desc <<-LONGDESC
+      Generate an AI-powered commit message for your staged changes.
+
+      Examples:
+        git_auto commit                    # Use default style
+        git_auto commit --style simple     # Use simple style
+        git_auto commit --style conventional --scope api  # Specify scope
+    LONGDESC
+    def commit
+      Commands::CommitMessageCommand.new(options).execute
+    end
+
+    desc "analyze", "Analyze commit history patterns"
+    method_option :limit, type: :numeric, default: 10, desc: "Number of commits to analyze"
+    method_option :save, type: :boolean, desc: "Save patterns for future commits"
+    long_desc <<-LONGDESC
+      Analyze your repository's commit history to learn patterns and improve future commit messages.
+
+      Examples:
+        git_auto analyze              # Analyze last 10 commits
+        git_auto analyze --limit 50   # Analyze last 50 commits
+        git_auto analyze --save       # Save patterns for future use
+    LONGDESC
+    def analyze
+      Commands::HistoryAnalysisCommand.new(options).execute
+    end
+  end
+end

data/lib/git_auto/commands/commit_message_command.rb

@@ -0,0 +1,315 @@
+# frozen_string_literal: true
+
+require "tty-prompt"
+require "tty-spinner"
+require "colorize"
+require "clipboard"
+require_relative "../formatters/diff_formatter"
+require_relative "../formatters/message_formatter"
+require_relative "../validators/commit_message_validator"
+
+module GitAuto
+  module Commands
+    class CommitMessageCommand
+      def initialize(options = {})
+        @options = options.dup
+        @prompt = TTY::Prompt.new
+        @spinner = TTY::Spinner.new("[:spinner] :message...")
+        @settings = Config::Settings.new
+        @git_service = Services::GitService.new
+        @ai_service = Services::AIService.new(@settings)
+        @history_service = Services::HistoryService.new
+        @retry_count = 0
+      end
+
+      def execute
+        # Get repository status
+        status = @git_service.repository_status
+        validate_repository(status)
+
+        # Get and validate changes
+        diff = @git_service.get_staged_diff
+        validate_changes(diff)
+
+        # Show diff preview if requested
+        show_diff_preview(diff) if show_preview?
+
+        # Generate commit message
+        message = generate_commit_message(diff)
+
+        # Handle the generated message
+        handle_message(message, diff)
+      rescue StandardError => e
+        puts "\n❌ Error: #{e.message}".red
+        exit 1
+      end
+
+      private
+
+      # Repository and Change Validation Methods
+      def validate_repository(status)
+        return if status[:is_clean] || status[:has_staged_changes]
+
+        puts "ℹ️  Status:".blue
+        puts "  Branch: #{status[:branch]}"
+        puts "  Staged files: #{status[:staged_files].join(", ")}"
+        puts "\n❌ No changes staged for commit. Use 'git add' to stage changes.".red
+        exit 1
+      end
+
+      def validate_changes(diff)
+        return unless diff.empty?
+
+        puts "❌ No staged changes found. Use 'git add' first.".red
+        exit 1
+      end
+
+      # Preview Methods
+      def show_preview?
+        @options[:preview] || @settings.get(:show_diff)
+      end
+
+      def show_diff_preview(diff)
+        puts "\n📄 Changes to be committed:".blue
+        puts Formatters::DiffFormatter.new.format(diff)
+
+        return if @prompt.yes?("Continue with these changes?")
+
+        puts "Operation cancelled.".yellow
+        exit 0
+      end
+
+      # Message Generation Methods
+      def generate_commit_message(diff, options = @options)
+        style = get_commit_style
+        scope = options[:scope]
+
+        if style == "conventional" && scope.nil?
+          # Show recent scopes for reference
+          patterns = @history_service.analyze_patterns(20)
+          if patterns && patterns[:scopes]&.any?
+            puts "\n📊 Recently used scopes:".blue
+            patterns[:scopes].each do |scope, count|
+              puts "  #{scope}: #{count} times"
+            end
+          end
+
+          generate_message_with_style(diff, style, nil)
+
+        else
+          generate_message_with_style(diff, style, scope)
+        end
+      end
+
+      def get_commit_style
+        @options[:style] || @settings.get(:commit_style)
+      end
+
+      def generate_message_with_style(diff, style, scope)
+        @spinner.update(message: "Generating commit message...")
+        @spinner.auto_spin
+        message = @ai_service.generate_commit_message(diff, style: style, scope: scope)
+        @spinner.success("✓ Message generated".green)
+        message
+      end
+
+      # Message Handling Methods
+      def handle_message(message, diff)
+        formatted = Formatters::MessageFormatter.new.format(message)
+        validation = validate_message(message)
+        display_message_and_validation(formatted, validation)
+
+        loop do
+          choice = prompt_user_action
+          break if handle_user_choice(choice, message, diff, validation)
+        end
+      end
+
+      def validate_message(message)
+        validator = Validators::CommitMessageValidator.new
+        validator.validate(message)
+      end
+
+      def display_message_and_validation(formatted_message, validation)
+        puts "\n📝 Generated commit message:".blue
+        puts formatted_message
+
+        display_validation_errors(validation[:errors]) if validation[:errors].any?
+
+        return unless validation[:warnings].any?
+
+        display_validation_warnings(validation[:warnings])
+      end
+
+      def display_validation_errors(errors)
+        puts "\n❌ Validation errors:".red
+        validator = Validators::CommitMessageValidator.new
+        errors.each { |error| puts validator.format_error(error) }
+        puts "\nPlease edit the message to fix these errors.".yellow
+      end
+
+      def display_validation_warnings(warnings)
+        puts "\n⚠️  Suggestions:".yellow
+        validator = Validators::CommitMessageValidator.new
+        warnings.each { |warning| puts validator.format_warning(warning) }
+      end
+
+      def prompt_user_action
+        @prompt.select("Choose an action:", {
+                         "✅ Accept and commit" => :accept,
+                         "✏️  Edit message" => :edit,
+                         "📋 Copy to clipboard" => :copy,
+                         "👀 Show diff" => :diff,
+                         "📊 Show patterns" => :patterns,
+                         "🔄 Generate new message" => :retry,
+                         "❌ Cancel" => :cancel
+                       })
+      end
+
+      # User Action Handling Methods
+      def handle_user_choice(choice, message, diff, validation)
+        case choice
+        when :accept
+          handle_accept_action(message, diff, validation)
+        when :edit
+          handle_edit_action(message)
+          false
+        when :copy
+          handle_copy_action(message)
+          false
+        when :diff
+          show_diff_preview(diff)
+          false
+        when :patterns
+          show_commit_patterns
+          false
+        when :retry
+          handle_retry_action(diff)
+          false
+        when :cancel
+          cancel_operation
+        end
+      end
+
+      def handle_accept_action(message, diff, validation)
+        if validation[:errors].any?
+          puts "\n❌ Cannot commit: Please fix validation errors first.".red
+          new_message = edit_message(message)
+          handle_message(new_message, diff)
+          return true
+        end
+        accept_message(message, diff)
+        true
+      end
+
+      def handle_edit_action(message)
+        new_message = edit_message(message)
+        puts "\n📝 Updated message:".blue
+        puts Formatters::MessageFormatter.new.format(new_message)
+      end
+
+      def handle_copy_action(message)
+        Clipboard.copy(message)
+        puts "✓ Copied to clipboard".green
+      end
+
+      def handle_retry_action(diff)
+        @retry_count += 1
+
+        # Create a new options hash for this retry
+        retry_options = @options.transform_keys(&:to_s)
+        retry_options["creativity"] = [(retry_options["creativity"].to_f + 0.1), 1.0].min if retry_options["creativity"]
+        retry_options["retry_attempt"] = @retry_count
+
+        new_message = generate_commit_message(diff, retry_options)
+        puts "\n📝 New message (Attempt #{@retry_count}):".blue
+        formatted = Formatters::MessageFormatter.new.format(new_message)
+        puts formatted
+
+        # Validate the message
+        validation = validate_message(new_message)
+        display_message_and_validation(formatted, validation) if validation[:errors].any? || validation[:warnings].any?
+
+        handle_message(new_message, diff)
+      end
+
+      # Pattern Analysis Methods
+      def show_commit_patterns
+        puts "\n📊 Analyzing commit patterns...".blue
+        patterns = @history_service.analyze_patterns
+        return unless patterns
+
+        display_pattern_section(patterns[:styles], "Commit Styles")
+        display_pattern_section(patterns[:types], "Common Types")
+        display_pattern_section(patterns[:scopes], "Frequent Scopes", count_format: true)
+        display_pattern_section(patterns[:common_phrases], "Common Phrases", count_format: true)
+
+        wait_for_user_input
+      end
+
+      def display_pattern_section(data, title, count_format: false)
+        return unless data&.any?
+
+        puts "\n#{title}:".cyan
+        display_pattern_items(data, count_format)
+      end
+
+      def display_pattern_items(items, count_format)
+        items.each do |key, value|
+          formatted_value = format_pattern_value(value, count_format)
+          puts "  #{key}: #{formatted_value}"
+        end
+      end
+
+      def format_pattern_value(value, count_format)
+        if count_format
+          "#{value} times"
+        else
+          "#{value}%"
+        end
+      end
+
+      def wait_for_user_input
+        puts "\nPress any key to continue..."
+        @prompt.keypress
+      end
+
+      # Utility Methods
+      def edit_message(message)
+        puts "\nEdit your commit message:"
+        puts "Enter your commit message (press Ctrl+D or Ctrl+Z to finish)".light_black
+        editor_input = $stdin.gets
+        editor_input&.strip || message
+      end
+
+      def accept_message(message, diff)
+        @spinner.update(message: "Creating commit...")
+        @spinner.auto_spin
+        # Ensure we only use the first line
+        message = message.split("\n").first.strip
+        @git_service.commit(message)
+        @spinner.success("✓ Commit created successfully!".green)
+
+        # Save to history if enabled
+        save_to_history(message, diff)
+      end
+
+      def save_to_history(message, diff)
+        return unless @settings.get(:save_history)
+
+        metadata = {
+          files: @git_service.get_staged_files,
+          diff_size: diff.length,
+          style: @options[:style] || @settings.get(:commit_style)
+        }
+
+        @history_service.save_commit(message, metadata)
+      end
+
+      def cancel_operation
+        puts "Operation cancelled.".yellow
+        exit 0
+      end
+    end
+  end
+end