aigcm 0.2.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1f0e2c18c6c1c820563cc9f640a319709b1cbb752fdee4464617759cd2e6f963
-  data.tar.gz: 3a74e5f33183449a690f5ae8892bd55d438cff57193eb90af1b358458f215c77
+  metadata.gz: 2cc53c8ffef5c597adb196deffc67ad3c0f89d5a47e9bcbfc617ece6f6a73600
+  data.tar.gz: 6262260bc17b80ef51b668e19a7014c8e9cd4429f22f2654b8682303fb79ea39
 SHA512:
-  metadata.gz: e203e403e07b9865c879d6bee4cedb9545fc460a8cbaa990d9257e00e49a7bf735ac5ee4bd403f2e7dd1ad4ee399734e194d49e55c723d7f184684cee8c5a548
-  data.tar.gz: 22ff6406f1aba1ab8defeac098bc1dab5b0aece00c04801c3aa4b888399a23db974ed89b0387e373a5f05e77a0a99b7834c1da8ffb95c240f926429330d6b1ba
+  metadata.gz: c5b256a8478183fd3bd53188916e36f2e48639927251ea128111f28baf0dc42910ba7104f95d9a8fd98f6f2df804ea9403eb6c8c1f179b22b1f1675979ed2e15
+  data.tar.gz: 063a9e30564ad0b791ea9707e2e57c333d9372330e4784cc4858431725ac6f0184ffa6a331cdb8651d97e50fe2d0a4e363a83cea7d96e9577251c30761069055

data/CHANGELOG.md

@@ -2,6 +2,22 @@
 
 ## [Unreleased]
 
+## [0.3.0] - 2025-12-03
+
+### Fixed
+- Added missing `amend:` parameter to `GitDiff.initialize`
+- Fixed `check_recent_commit` method signature (was receiving 2 arguments but only accepted 1)
+- Fixed `CommitMessageGenerator.initialize` to accept required `model:`, `provider:`, and `amend:` parameters
+- Removed dependency on `Aigcm.amend?` from `CommitMessageGenerator#generate` in favor of instance variable
+- Added `debug_me` as development dependency
+- Added `bundler/setup` to bin/aigcm for proper gem version loading
+- Fixed test mocks for `GitDiff` in commit message generator tests
+
+## [0.2.0] - 2025-02-09
+
+- changed gem name to aigcm
+- released gem
+
 ## [0.1.0] - 2025-02-08
 
 - changed gem name to aigc

data/COMMITS.md

@@ -0,0 +1,196 @@
+---
+url: https://www.conventionalcommits.org/en/v1.0.0/
+title: Conventional Commits
+description: A specification for adding human and machine readable meaning to commit messages
+access_date: 2025-07-31T20:51:29.000Z
+current_date: 2025-07-31T20:51:29.601Z
+---
+
+# Conventional Commits
+
+A specification for adding human and machine readable meaning to commit messages
+
+ Quick Summary Full Specification Contribute
+
+# Conventional Commits 1.0.0
+
+## Summary
+
+The Conventional Commits specification is a lightweight convention on top of commit messages. It provides an easy set of rules for creating an explicit commit history; which makes it easier to write automated tools on top of. This convention dovetails with SemVer, by describing the features, fixes, and breaking changes made in commit messages.
+
+The commit message should be structured as follows:
+
+---
+
+```
+<type>[optional scope]: <description>
+
+[optional body]
+
+[optional footer(s)]
+
+```
+
+---
+
+The commit contains the following structural elements, to communicate intent to the consumers of your library:
+
+1. **fix:** a commit of the _type_ `fix` patches a bug in your codebase (this correlates with `PATCH` in Semantic Versioning).
+2. **feat:** a commit of the _type_ `feat` introduces a new feature to the codebase (this correlates with `MINOR` in Semantic Versioning).
+3. **BREAKING CHANGE:** a commit that has a footer `BREAKING CHANGE:`, or appends a `!` after the type/scope, introduces a breaking API change (correlating with `MAJOR` in Semantic Versioning). A BREAKING CHANGE can be part of commits of any _type_.
+4. _types_ other than `fix:` and `feat:` are allowed, for example @commitlint/config-conventional (based on the Angular convention) recommends `build:`, `chore:`,`ci:`, `docs:`, `style:`, `refactor:`, `perf:`, `test:`, and others.
+5. _footers_ other than `BREAKING CHANGE: <description>` may be provided and follow a convention similar to git trailer format.
+
+Additional types are not mandated by the Conventional Commits specification, and have no implicit effect in Semantic Versioning (unless they include a BREAKING CHANGE). A scope may be provided to a commit’s type, to provide additional contextual information and is contained within parenthesis, e.g., `feat(parser): add ability to parse arrays`.
+
+## Examples
+
+### Commit message with description and breaking change footer
+
+```
+feat: allow provided config object to extend other configs
+
+BREAKING CHANGE: `extends` key in config file is now used for extending other config files
+
+```
+
+### Commit message with `!` to draw attention to breaking change
+
+```
+feat!: send an email to the customer when a product is shipped
+
+```
+
+### Commit message with scope and `!` to draw attention to breaking change
+
+```
+feat(api)!: send an email to the customer when a product is shipped
+
+```
+
+### Commit message with both `!` and BREAKING CHANGE footer
+
+```
+chore!: drop support for Node 6
+
+BREAKING CHANGE: use JavaScript features not available in Node 6.
+
+```
+
+### Commit message with no body
+
+```
+docs: correct spelling of CHANGELOG
+
+```
+
+### Commit message with scope
+
+```
+feat(lang): add Polish language
+
+```
+
+### Commit message with multi-paragraph body and multiple footers
+
+```
+fix: prevent racing of requests
+
+Introduce a request id and a reference to latest request. Dismiss
+incoming responses other than from latest request.
+
+Remove timeouts which were used to mitigate the racing issue but are
+obsolete now.
+
+Reviewed-by: Z
+Refs: #123
+
+```
+
+## Specification
+
+The key words “MUST”, “MUST NOT”, “REQUIRED”, “SHALL”, “SHALL NOT”, “SHOULD”, “SHOULD NOT”, “RECOMMENDED”, “MAY”, and “OPTIONAL” in this document are to be interpreted as described in RFC 2119.
+
+1. Commits MUST be prefixed with a type, which consists of a noun, `feat`, `fix`, etc., followed by the OPTIONAL scope, OPTIONAL `!`, and REQUIRED terminal colon and space.
+2. The type `feat` MUST be used when a commit adds a new feature to your application or library.
+3. The type `fix` MUST be used when a commit represents a bug fix for your application.
+4. A scope MAY be provided after a type. A scope MUST consist of a noun describing a section of the codebase surrounded by parenthesis, e.g., `fix(parser):`
+5. A description MUST immediately follow the colon and space after the type/scope prefix. The description is a short summary of the code changes, e.g., _fix: array parsing issue when multiple spaces were contained in string_.
+6. A longer commit body MAY be provided after the short description, providing additional contextual information about the code changes. The body MUST begin one blank line after the description.
+7. A commit body is free-form and MAY consist of any number of newline separated paragraphs.
+8. One or more footers MAY be provided one blank line after the body. Each footer MUST consist of a word token, followed by either a `:<space>` or `<space>#` separator, followed by a string value (this is inspired by the git trailer convention).
+9. A footer’s token MUST use `-` in place of whitespace characters, e.g., `Acked-by` (this helps differentiate the footer section from a multi-paragraph body). An exception is made for `BREAKING CHANGE`, which MAY also be used as a token.
+10. A footer’s value MAY contain spaces and newlines, and parsing MUST terminate when the next valid footer token/separator pair is observed.
+11. Breaking changes MUST be indicated in the type/scope prefix of a commit, or as an entry in the footer.
+12. If included as a footer, a breaking change MUST consist of the uppercase text BREAKING CHANGE, followed by a colon, space, and description, e.g.,_BREAKING CHANGE: environment variables now take precedence over config files_.
+13. If included in the type/scope prefix, breaking changes MUST be indicated by a`!` immediately before the `:`. If `!` is used, `BREAKING CHANGE:` MAY be omitted from the footer section, and the commit description SHALL be used to describe the breaking change.
+14. Types other than `feat` and `fix` MAY be used in your commit messages, e.g., _docs: update ref docs._
+15. The units of information that make up Conventional Commits MUST NOT be treated as case sensitive by implementors, with the exception of BREAKING CHANGE which MUST be uppercase.
+16. BREAKING-CHANGE MUST be synonymous with BREAKING CHANGE, when used as a token in a footer.
+
+## Why Use Conventional Commits
+
+* Automatically generating CHANGELOGs.
+* Automatically determining a semantic version bump (based on the types of commits landed).
+* Communicating the nature of changes to teammates, the public, and other stakeholders.
+* Triggering build and publish processes.
+* Making it easier for people to contribute to your projects, by allowing them to explore a more structured commit history.
+
+## FAQ
+
+### How should I deal with commit messages in the initial development phase?
+
+We recommend that you proceed as if you’ve already released the product. Typically _somebody_, even if it’s your fellow software developers, is using your software. They’ll want to know what’s fixed, what breaks etc.
+
+### Are the types in the commit title uppercase or lowercase?
+
+Any casing may be used, but it’s best to be consistent.
+
+### What do I do if the commit conforms to more than one of the commit types?
+
+Go back and make multiple commits whenever possible. Part of the benefit of Conventional Commits is its ability to drive us to make more organized commits and PRs.
+
+### Doesn’t this discourage rapid development and fast iteration?
+
+It discourages moving fast in a disorganized way. It helps you be able to move fast long term across multiple projects with varied contributors.
+
+### Might Conventional Commits lead developers to limit the type of commits they make because they’ll be thinking in the types provided?
+
+Conventional Commits encourages us to make more of certain types of commits such as fixes. Other than that, the flexibility of Conventional Commits allows your team to come up with their own types and change those types over time.
+
+### How does this relate to SemVer?
+
+`fix` type commits should be translated to `PATCH` releases. `feat` type commits should be translated to `MINOR` releases. Commits with `BREAKING CHANGE` in the commits, regardless of type, should be translated to `MAJOR` releases.
+
+### How should I version my extensions to the Conventional Commits Specification, e.g. `@jameswomack/conventional-commit-spec`?
+
+We recommend using SemVer to release your own extensions to this specification (and encourage you to make these extensions!)
+
+### What do I do if I accidentally use the wrong commit type?
+
+#### When you used a type that’s of the spec but not the correct type, e.g. `fix` instead of `feat`
+
+Prior to merging or releasing the mistake, we recommend using `git rebase -i` to edit the commit history. After release, the cleanup will be different according to what tools and processes you use.
+
+#### When you used a type _not_ of the spec, e.g. `feet` instead of `feat`
+
+In a worst case scenario, it’s not the end of the world if a commit lands that does not meet the Conventional Commits specification. It simply means that commit will be missed by tools that are based on the spec.
+
+### Do all my contributors need to use the Conventional Commits specification?
+
+No! If you use a squash based workflow on Git lead maintainers can clean up the commit messages as they’re merged—adding no workload to casual committers. A common workflow for this is to have your git system automatically squash commits from a pull request and present a form for the lead maintainer to enter the proper git commit message for the merge.
+
+### How does Conventional Commits handle revert commits?
+
+Reverting code can be complicated: are you reverting multiple commits? if you revert a feature, should the next release instead be a patch?
+
+Conventional Commits does not make an explicit effort to define revert behavior. Instead we leave it to tooling authors to use the flexibility of _types_ and _footers_ to develop their logic for handling reverts.
+
+One recommendation is to use the `revert` type, and a footer that references the commit SHAs that are being reverted:
+
+```
+revert: let us never again speak of the noodle incident
+
+Refs: 676104e, a215868
+
+```

data/README.md

@@ -1,7 +1,37 @@
 # aigcm
 
 The **AI git commit message** generator.
-ƒ
+
+See the [change log](./CHANGELOG.md) for recent changes.
+
+<!-- Tocer[start]: Auto-generated, don't remove. -->
+
+## Table of Contents
+
+  - [Overview](#overview)
+  - [Features](#features)
+  - [Installation](#installation)
+  - [Usage](#usage)
+    - [Options](#options)
+    - [Examples](#examples)
+  - [Advanced Usage](#advanced-usage)
+    - [Defaults](#defaults)
+         - [Model](#model)
+         - [Style Guide](#style-guide)
+    - [Private Repos](#private-repos)
+         - [Private Repo Check Limitation](#private-repo-check-limitation)
+    - [Style Guide Example](#style-guide-example)
+  - [API Key Configuration](#api-key-configuration)
+  - [Last Thoughts](#last-thoughts)
+    - [Support Custom Workflows](#support-custom-workflows)
+    - [Non-deterministic Nature of LLMs](#non-deterministic-nature-of-llms)
+  - [Development](#development)
+  - [Contributing](#contributing)
+  - [License](#license)
+
+<!-- Tocer[finish]: Auto-generated, don't remove. -->
+
+
 ## Overview
 
 **aigcm** is a Ruby gem designed to generate high-quality commit messages for git diffs. It leverages AI to analyze changes in your codebase and create concise, meaningful commit messages following best practices.
@@ -15,19 +45,7 @@ The **AI git commit message** generator.
 
 ## Installation
 
-Add this line to your application's Gemfile:
-
-```ruby
-gem 'aigcm'
-```
-
-And then execute:
-
-```shell
-bundle install
-```
-
-Or install it yourself as:
+`aigcm` is a CLI tool deployed as a gem.
 
 ```shell
 gem install aigcm
@@ -43,6 +61,7 @@ aigcm [options] [ref]
 
 ### Options
 
+- `-h, --help`: Display options available.
 - `-a, --amend`: Amend the last commit.
 - `-c, --context=CONTEXT`: Extra context beyond the diff.
 - `-d, --dry`: Dry run the command without making any changes.
@@ -67,21 +86,45 @@ When your commit is related to a specific JIRA ticket:
    aigcm -m MODEL -c "Resolved issues as per JIRA ticket JIRA-1234"
    ```
 
-   Including the JIRA ticket helps relate the commit to external tracking systems.
+Including the JIRA ticket helps relate the commit to external tracking systems.
 
 Including multiple context strings:
    ```shell
    aigcm -m MODEL -c "Refactored for performance" -c "JIRA-1234"
    ```
 
-   Multiple context strings can be added by repeating the `-c` option.
+Multiple context strings can be added by repeating the `-c` option.
 
 Using environment variables in context:
    ```shell
    aigcm -c "Put the work ticket as the first entry on the subject line" -c "Ticket: $TICKET"
    ```
 
-   This allows you to dynamically include environment variables in your commit message.
+This allows you to dynamically include the value of environment variables in your commit message.
+
+## Advanced Usage
+
+### Defaults
+
+There are two important defaults of which you should be aware.  The model controls how much it costs for aigcm to write the commit message for you.  The style guide impacts how well the commit message is written.
+
+#### Model
+
+If you do not specify a model `aigcm` attempts to use `gpt-4o-mini` from OpenAI.  If you want to use a different model or different provider the best way to do that is to create a shell alias like `alias aigcm='\aigcm --model o3-mini'` or `aigcm='\aigcm --model deepseek-r1 --provider ollama`
+
+#### Style Guide
+
+If you do not have a style guide named `COMMITS.md` in the root directory of your repo's working directory AND you do not specify a path to a style guid file using the `--style` option THEN `aigcm` will use its own default style guide.  To print to STDOUT the default style guide use the `--default` option. 
+
+### Private Repos
+
+When you specify a model or provider which is not associated with localhost processing, this gem issue an ERROR message when it is operating in a private repository.  There are lots of security officiers and bosses who just do not want even a `git diff` to be shared outside of their control regardless of whether the provider "crosses their heart and hopes to die" that they do not use the data you send them.
+
+You can by-pass this check by using the option `--force-external` or my simply using a model/provider combination that you process locally on your computer.
+
+#### Private Repo Check Limitation
+
+This gem uses the `gh` command to determine if the repo is private.  This means 1) your repo needs to be hosted on Github; and 2) you need to have the `gh` command installed on your machine AND logged into Github.  If any one of these conditions is not true, then the gem may terminate with an exception.
 
 ### Style Guide Example
 
@@ -99,19 +142,48 @@ This would be a simple style guide:
 - Have fun. Be creative. Add ASCII art if you feel like it.
 ```
 
+## API Key Configuration
+
+Bring your own API keys to the LLM providers.  This gem uses the generic `ai_client` gem to access LLM APIs.  If you are using a model processed on your localhost, you most likely will not need an API key.  If however, you are using an external provider then you need to acquire an API key from that provider.
+
+The API key should be set in a system environment variable (envar) that has the pattern <provider>_API_KEY.
+
+The following table shows a small sample of the providers supported, the envar required to be set and a link to the place to acquire an API key for the provider.
+
+| Provider Link | envar Name |
+| --- | --- |
+| [Anthropic](https://www.anthropic.com/) | ANTHROPIC_API_KEY |
+| [OpenAI](https://platform.openai.com/signup) | OPENAI_API_KEY |
+| [OpenRouter](https://openrouter.ai/) | OPENROUTER_API_KEY |
+| etc ... | ?_API_KEY |
+
+Note that OpenRouter supports lots of models from many providers.
+
 ## Last Thoughts
 
+### Support Custom Workflows
+
 This gem saves its commit message in the file `.aigcm_msg` at the root directory of the repository.  Its there even if you do a `--dry` run.  This could be handy if you want to incorporate `aigcm` into some larger workflow.
 
 Remember that the style guide can be extended using one or more `--context` strings.  For example you could create a shell alias like this:
 
-```
+```shell
 alias gc='aigcm -c "JIRA $JIRA_TICKET"'
 ```
 
+### Non-deterministic Nature of LLMs
+
+Given the same input an LLM may not (most likely will not) give you the same output as it did before.  This is why we like them.  This is also why we hate them.
+
+When you do a dry run against a set of staged changes using the `--dry` option `aigcm` will print to STDOUT a commit message.  It will also save that same commit message in the file `.aigcm_msg` in the root of your working directory.  The commit will not be made because its a "dry run."
+
+If you wait longer than 1 minute to run `aigcm` without the `--dry` option it will generate a new commit message which likely will be different than the one you read during the dry run.  However, if you run again without the dry run option in less than a minute `aigcm` will use its previous commit message on the assumption that you liked it.
+
+Don't forget that if you make a commit and then decide that you need to change the commit message there is always the `--amend` option available.
+
 ## Development
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests.
+After checking out the repo, run `rake test` to run the tests.  Make sure that all of the tests are passing.
 
 To install this gem onto your local machine, run `bundle exec rake install`.
 

data/bin/aigcm

@@ -1,5 +1,7 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
-require_relative '../lib/aigcm'
+require "bundler/setup"
+require_relative "../lib/aigcm"
 
 Aigcm.run

data/lib/aigcm/commit_message_generator.rb

@@ -1,8 +1,7 @@
-
 require "net/http"
 require "json"
 require "open3"
-require "ai_client"
+require "ruby_llm"
 
 module Aigcm
   class CommitMessageGenerator
@@ -10,17 +9,23 @@ module Aigcm
 
     MAX_DIFF_SIZE = 4000 # Characters
 
-    def initialize(model:, provider:, max_tokens:, force_external:)
+    def initialize(model:, provider:, max_tokens:, force_external: false, amend: false)
+      @model = model
+      @provider = provider
+      @max_tokens = max_tokens
       @force_external = force_external
-      validate_model_provider_combination(model)
+      @amend = amend
+      infer_provider_from_model
       check_provider_availability
 
-      @client = AiClient.new(model, provider: provider)
+      configure_ruby_llm
+      @chat = RubyLLM.chat(model: @model)
     rescue StandardError => e
       raise Error, "Failed to initialize AI client: #{e.message}"
     end
 
-    def generate(diff, style_guide, context = [])
+    def generate(style_guide, context = [])
+      diff = GitDiff.new(dir: Dir.pwd, amend: @amend).generate_diff
       return "No changes to commit" if diff.strip.empty?
 
       check_repository_privacy unless @force_external
@@ -34,8 +39,8 @@ module Aigcm
       prompt = build_prompt(diff, style_guide, processed_context)
 
       begin
-        response = @client.chat(prompt)
-        response.to_s.strip
+        response = @chat.ask(prompt)
+        response.content.strip
       rescue StandardError => e
         "Error generating commit message: #{e.message}"
       end
@@ -43,11 +48,40 @@ module Aigcm
 
     private
 
-    def validate_model_provider_combination(model)
-      client = AiClient.new(model)
-      @provider = client.provider
-    rescue ArgumentError => e
-      raise Error, "Invalid model/provider combination: #{e.message}"
+    def infer_provider_from_model
+      return if @provider
+
+      model_lower = @model.to_s.downcase
+      @provider = if model_lower.include?('gpt') || model_lower.include?('o1') || model_lower.include?('o3')
+                    :openai
+                  elsif model_lower.include?('claude')
+                    :anthropic
+                  elsif model_lower.include?('gemini')
+                    :google
+                  elsif model_lower.include?('mistral') || model_lower.include?('mixtral')
+                    :mistral
+                  elsif model_lower.include?('llama') || model_lower.include?('qwen') || model_lower.include?('deepseek')
+                    :ollama
+                  else
+                    :openai
+                  end
+    end
+
+    def configure_ruby_llm
+      RubyLLM.configure do |config|
+        case @provider
+        when :ollama
+          config.ollama_api_base = 'http://localhost:11434/v1'
+        when :openai
+          config.openai_api_key = ENV.fetch('OPENAI_API_KEY', nil)
+        when :anthropic
+          config.anthropic_api_key = ENV.fetch('ANTHROPIC_API_KEY', nil)
+        when :google
+          config.gemini_api_key = ENV.fetch('GEMINI_API_KEY', nil)
+        when :mistral
+          config.mistral_api_key = ENV.fetch('MISTRAL_API_KEY', nil)
+        end
+      end
     end
 
     def check_provider_availability

data/lib/aigcm/options.rb

@@ -0,0 +1,58 @@
+require 'optparse'
+
+module Aigcm
+  class Options
+    def self.parse
+      options = {
+        amend: false,
+        context: [],
+        dry: false,
+        model: 'gpt-4o-mini',
+        provider: nil,
+        force_external: false,
+        style: nil
+      }
+
+      OptionParser.new do |opts|
+        opts.banner = "Usage: aigcm [options] [ref]"
+
+        opts.on("-a", "--amend", "Amend the last commit") { options[:amend] = true }
+
+        opts.on("-cCONTEXT", "--context=CONTEXT", "Extra context beyond the diff") do |context|
+          options[:context] << context
+        end
+
+        opts.on("-d", "--dry", "Dry run the command") { options[:dry] = true }
+
+        opts.on("-mMODEL", "--model=MODEL", "The model to use") { |model| options[:model] = model }
+
+        opts.on("--provider=PROVIDER", "Specify the provider (ollama, openai, anthropic, etc)") do |provider|
+          provider = provider.to_sym
+          unless [:ollama, :openai, :anthropic, :google, :mistral].include?(provider)
+            puts "Invalid provider specified. Valid providers are: ollama, openai, anthropic, google, mistral"
+            exit 1
+          end
+          options[:provider] = provider
+        end
+
+        opts.on("--force-external", "Force using external AI provider even for private repos") {
+          options[:force_external] = true
+        }
+
+        opts.on("-sSTYLE", "--style=STYLE", "Path to the style guide file") { |style| options[:style] = style }
+
+        opts.on("--default", "Print the default style guide and exit") do
+          puts "\nDefault Style Guide:"
+          puts "-------------------"
+          puts StyleGuide::DEFAULT_GUIDE
+          exit
+        end
+
+        opts.on("--version", "Show version") { puts Aigcm::VERSION; exit }
+
+      end.parse!
+
+      options
+    end
+  end
+end

data/lib/aigcm/style_guide.rb

@@ -42,9 +42,9 @@ __END__
 • Use Imperative Mood: Phrase commands as direct actions (e.g., "Add feature" instead of "Added feature").
 
 2. Provide a Detailed Body:
-• Seperate the body from the subject line with a blank line.
+• Separate the body from the subject line with a blank line.
 • Explain the Reason: Clearly articulate the rationale for the change rather than just summarizing the modification.
 • Wrap Body Text at <%= Aigcm::StyleGuide::LINE_MAX %> Characters: Ensure that the body text wraps at <%= Aigcm::StyleGuide::LINE_MAX %> characters per line.
 
 3. Reference Issues/Tickets:
-• Include relevant issue numbers, ticket IDs and/or references when they are provided.  Dp not invent your own reference.  Use what has been provided.
+• Include relevant issue numbers, ticket IDs and/or references when they are provided.  Do not invent your own reference.  Use what has been provided.

data/lib/aigcm/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Aigcm
-  VERSION = "0.2.0"
+  VERSION = "0.3.1"
 end

data/lib/aigcm.rb

@@ -1,16 +1,15 @@
-# lib/aigcm.rb
-
 require 'debug_me'
 include DebugMe
 
 require 'optparse'
-require 'ai_client'
+require 'ruby_llm'
 require 'time'
 
 require_relative 'aigcm/version'
 require_relative 'aigcm/git_diff'
 require_relative 'aigcm/commit_message_generator'
 require_relative 'aigcm/style_guide'
+require_relative 'aigcm/options'
 
 module Aigcm
   COMMIT_MESSAGE_FILE = '.aigcm_msg'
@@ -18,129 +17,102 @@ module Aigcm
 
   class Error < StandardError; end
 
-  def self.run(test_mode: false)
-    dir = Dir.pwd
-    options = parse_options
-
-    if options[:amend]
-      system('git commit --amend')
-      return
-    end
-
-    commit_message = check_recent_commit(dir)
+  class << self
+    attr_reader :parsed_options
 
-    # Generate a new commit message if not reusing an existing one
-    commit_message ||= generate_commit_message(dir, options)
-
-    perform_commit(dir, commit_message, options)
-
-  rescue OptionParser::InvalidOption => e
-    STDERR.puts "Error: '#{e.message}'"
-    exit 1
-  rescue GitDiff::Error => e
-    puts "Git error: #{e.message}"
-    exit 1
-  rescue StandardError => e
-    puts "Error: #{e.message}"
-    exit 1
-  end
+    def run(test_mode: false)
+      @parsed_options = Options.parse
 
-  private_class_method def self.parse_options
-    options = {
-      amend: false,
-      context: [],
-      dry: false,
-      model: 'gpt-4o-mini',
-      provider: nil,
-      force_external: false,
-      style: nil
-    }
+      dir = Dir.pwd
 
-    OptionParser.new do |opts|
-      opts.banner = "Usage: aigcm [options] [ref]"
-
-      opts.on("-a", "--amend", "Amend the last commit") { options[:amend] = true }
-
-      opts.on("-cCONTEXT", "--context=CONTEXT", "Extra context beyond the diff") do |context|
-        options[:context] << context
+      if amend?
+        system('git commit --amend')
+        return
       end
 
-      opts.on("-d", "--dry", "Dry run the command") { options[:dry] = true }
+      commit_message = check_recent_commit(dir, dry?)
 
-      opts.on("-mMODEL", "--model=MODEL", "The model to use") { |model| options[:model] = model }
+      # Generate a new commit message if not reusing an existing one
+      commit_message ||= generate_commit_message(dir)
 
-      opts.on("--provider=PROVIDER", "Specify the provider (ollama, openai, anthropic, etc)") do |provider|
-        provider = provider.to_sym
-        unless [:ollama, :openai, :anthropic, :google, :mistral].include?(provider)
-          puts "Invalid provider specified. Valid providers are: ollama, openai, anthropic, google, mistral"
-          exit 1
-        end
-        options[:provider] = provider
-      end
+      perform_commit(dir, commit_message)
 
-      opts.on("--force-external", "Force using external AI provider even for private repos") {
-        options[:force_external] = true
-      }
+    rescue OptionParser::InvalidOption => e
+      STDERR.puts "Error: '#{e.message}'"
+      exit 1
+    rescue GitDiff::Error => e
+      puts "Git error: #{e.message}"
+      exit 1
+    rescue StandardError => e
+      puts "Error: #{e.message}"
+      exit 1
+    end
 
-      opts.on("-sSTYLE", "--style=STYLE", "Path to the style guide file") { |style| options[:style] = style }
+    def dry?
+      parsed_options[:dry]
+    end
 
-      opts.on("--default", "Print the default style guide and exit") do
-        puts "\nDefault Style Guide:"
-        puts "-------------------"
-        puts StyleGuide::DEFAULT_GUIDE
-        exit
-      end
+    def amend?
+      parsed_options[:amend]
+    end
 
-      opts.on("--version", "Show version") { puts Aigcm::VERSION; exit }
+    def model
+      parsed_options[:model]
+    end
 
-    end.parse!
+    def provider
+      parsed_options[:provider]
+    end
 
-    options
-  end
+    private
 
-  private_class_method def self.check_recent_commit(dir)
-    commit_file_path = File.join(dir, COMMIT_MESSAGE_FILE)
+    def check_recent_commit(dir, dry_run)
+      commit_file_path = File.join(dir, COMMIT_MESSAGE_FILE)
 
-    if File.exist?(commit_file_path)
-      file_mod_time = File.mtime(commit_file_path)
-      current_time = Time.now
-      if (current_time - file_mod_time).to_i < RECENT_THRESHOLD
-        return File.read(commit_file_path)
+      if File.exist?(commit_file_path)
+        file_mod_time = File.mtime(commit_file_path)
+        current_time = Time.now
+        if (current_time - file_mod_time).to_i < RECENT_THRESHOLD
+          return nil if dry_run # Skip time check in dry run mode
+          return File.read(commit_file_path)
+        end
       end
-    end
 
-    nil
-  end
+      nil
+    end
 
-  private_class_method def self.generate_commit_message(dir, options)
-    diff_generator = GitDiff.new(dir: dir, commit_hash: ARGV.shift, amend: options[:amend])
-    diff = diff_generator.generate_diff
-
-    style_guide = StyleGuide.load(dir, options[:style])
-    generator = CommitMessageGenerator.new(
-      model: options[:model],
-      provider: options[:provider],
-      max_tokens: 1000,
-      force_external: options[:force_external]
-    )
-
-    commit_message = generator.generate(diff, style_guide, options[:context])
-    File.write(File.join(dir, COMMIT_MESSAGE_FILE), commit_message)
-    commit_message
-  end
+    def generate_commit_message(dir)
+      commit_hash = ARGV.shift # This may be nil
+      diff_generator = GitDiff.new(dir: dir, commit_hash: commit_hash, amend: amend?)
+      diff = diff_generator.generate_diff
+
+      style_guide = StyleGuide.load(dir, parsed_options[:style])
+      generator = CommitMessageGenerator.new(
+        model: model,
+        provider: provider,
+        max_tokens: 1000,
+        force_external: parsed_options[:force_external],
+        amend: amend?
+      )
+
+      commit_message = generator.generate(style_guide, parsed_options[:context])
+      File.write(File.join(dir, COMMIT_MESSAGE_FILE), commit_message)
+      commit_message
+    end
 
-  private_class_method def self.perform_commit(dir, commit_message, options)
-    commit_file_path = File.join(dir, COMMIT_MESSAGE_FILE)
-
-    if options[:dry]
-      puts "\nDry run - would generate commit message:"
-      puts "-"*StyleGuide::LINE_MAX
-      puts commit_message
-      puts "-"*StyleGuide::LINE_MAX
-      puts
-    else
-      File.write(commit_file_path, commit_message)
-      system("git commit --edit -F #{commit_file_path}")
+    def perform_commit(dir, commit_message)
+      commit_file_path = File.join(dir, COMMIT_MESSAGE_FILE)
+
+      if dry?
+        puts "\nDry run - would generate commit message:"
+        puts "-"*StyleGuide::LINE_MAX
+        puts commit_message
+        puts "-"*StyleGuide::LINE_MAX
+        puts
+      else
+        File.write(commit_file_path, commit_message)
+        system("git commit --edit -F #{commit_file_path}")
+      end
     end
   end
 end

metadata

@@ -1,28 +1,28 @@
 --- !ruby/object:Gem::Specification
 name: aigcm
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.1
 platform: ruby
 authors:
 - Dewayne VanHoozer
 bindir: bin
 cert_chain: []
-date: 2025-02-09 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: ai_client
+  name: ruby_llm
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.4.0
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.4.0
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -79,16 +79,27 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.21'
+- !ruby/object:Gem::Dependency
+  name: debug_me
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: |
-  `aigcm` generates meaningful git commit messages using artificial
-  intelligence. It supports multiple AI providers including OpenAI,
-  Anthropic, Google, and local models via Ollama. The gem
-  automatically detects private repositories and defaults to using
-  local models for security. It integrates seamlessly with git
-  workflows and supports various commit scenarios including amending
-  commits and handling staged changes. The gem follows conventional
-  commit message formats and allows customization of commit message
-  styles through configuration.
+  An advanced AI-powered git commit message generator. It leverages
+  multiple AI providers including OpenAI, Anthropic, Google, and
+  local models via Ollama to create meaningful and contextual commit
+  messages. This gem streamlines the commit process, ensuring
+  consistent and informative version control practices across
+  projects.
 email:
 - dvanhoozer@gmail.com
 executables:
@@ -98,6 +109,7 @@ extra_rdoc_files: []
 files:
 - ".envrc"
 - CHANGELOG.md
+- COMMITS.md
 - LICENSE.txt
 - README.md
 - Rakefile
@@ -105,6 +117,7 @@ files:
 - lib/aigcm.rb
 - lib/aigcm/commit_message_generator.rb
 - lib/aigcm/git_diff.rb
+- lib/aigcm/options.rb
 - lib/aigcm/style_guide.rb
 - lib/aigcm/version.rb
 - sig/aicommit.rbs
@@ -130,7 +143,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.3
+rubygems_version: 4.0.0.dev
 specification_version: 4
 summary: AI-powered git commit message generator
 test_files: []