ai_git 0.3.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e698533dcbb5389f8ada1834ad78bbc65cbd6671e37874203de67c7376b11b51
-  data.tar.gz: 858e8d1de39b0034506da5fbd7858029e6ca77e922c551ceee4da1c2b4feb732
+  metadata.gz: 2fb023f0a7a794ab912a9502ce5155883ecad2171832690124534e4ded1ce551
+  data.tar.gz: bb16265d754dffabf9718b410d38d8f71e00cfc249e2a97ed41cc82cfefcca2c
 SHA512:
-  metadata.gz: 330b7566ca8ec91486faffd05ebefe651e543df74f39b796001d568793342cfa53689699baec35be9ec6a15b1f11505c60a06e17297e696593e752661465a6c2
-  data.tar.gz: 357d164f5a63cfb02bd173902bee1c098a3b24590a2347f33a97b0bff259c786c87aee1fca5e79937ccf7e916df9214d21cd280884370c877e520dd8dc2aea5b
+  metadata.gz: beb8cf739a17dc85da3e07bcd75dca5108e30f1aaef7249ac663435322440b0b4ada1768607e97faf15aab35cc629a01b58bacaddd491a3e71171838258ce1a0
+  data.tar.gz: 8a9e339b686103ecc350e3844f594f1b0bf0e7297e8305da1754399cfa71955c56eca197742781847213f71beb9b74e333276ca32c39b2edf81a1d5247d24155

data/README.md

@@ -2,65 +2,7 @@
 
 AI-powered Git commit messages using a local LLM
 
-## Usage
+## Documentation
 
-#### Requirements
-
-- [llama.cpp](https://github.com/ggml-org/llama.cpp) running locally (e.g. `./llama-server --port 8080`)
-
-#### Install
-
-```bash
-gem install ai_git
-```
-
-#### Environment Variables
-
-| Variable | Description | Default |
-|----------|-------------|---------|
-| `AI_GIT_MODEL_NAME` | Model name | `ggml-org/gemma-4-E4B-it-GGUF:Q8_0` |
-| `AI_GIT_BASE_URL` | Base URL of the llama.cpp server | `http://127.0.0.1:8080` |
-| `NO_COLOR` | Disable colored terminal output when set | — |
-
-Run `ai_git config` to see exactly which model, URL and endpoint are resolved from your environment.
-
-ai_git talks to a local [llama.cpp](https://github.com/ggml-org/llama.cpp) server over its OpenAI-compatible
-`/v1/chat/completions` endpoint. No API key is needed.
-
-##### Example
-
-```bash
-# Start llama.cpp's server, then run ai_git with defaults
-./llama-server --port 8080
-ai_git
-
-# Or point at a custom model/port
-export AI_GIT_MODEL_NAME=my-model
-export AI_GIT_BASE_URL=http://127.0.0.1:8081
-```
-
-#### Run
-
-```bash
-git add <files>
-ai_git
-```
-
-`ai_git` generates a commit message from your staged changes, commits, and
-pushes to the current branch's upstream — no prompts, no flags.
-
-#### Subcommands
-
-| Subcommand | Description |
-|------------|-------------|
-| `ai_git` | Generate a commit message, commit, and push staged files |
-| `ai_git config` | Show the resolved provider configuration |
-| `ai_git --help` | Show usage |
-| `ai_git --version` | Print version |
-
-## Development
-
-```bash
-gem build ai_git.gemspec
-gem install ./ai_git-$(ruby -r./lib/ai_git/version -e 'print AIGit::VERSION').gem
-```
+- [Usage](doc/USAGE.md) — requirements, install, configuration, flags, and privacy
+- [Release](doc/RELEASE.md) — how a version is tagged and published to RubyGems

data/bin/ai_git

@@ -1,5 +1,16 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
+# bin/ai_git
+#
+# @purpose      Executable entry point for the ai_git CLI: load the library and
+#               hand ARGV to AIGit.start.
+# @exports      ai_git: the `config` subcommand and the -n/--dry-run, --no-push,
+#               -y/--yes, -f/--force, -h/--help, -v/--version flags.
+# @dependencies lib/ai_git: supplies AIGit.start and AIGit::UI.error.
+# @sideEffects  Runs the whole CLI; exits 130 on interrupt and 1 on any other
+#               error, after printing the message to stderr.
+# @notes        Catches StandardError only, so the string messages the library
+#               raises surface as one clean line instead of a backtrace.
 
 require_relative "../lib/ai_git"
 

data/doc/RELEASE.md

@@ -0,0 +1,77 @@
+# Release
+
+`ai_git` is published to [RubyGems](https://rubygems.org/gems/ai_git) by
+`.github/workflows/release.yml`, which runs on every push to `master` that
+touches `lib/ai_git/version.rb`. The workflow authenticates with
+[trusted publishing](https://guides.rubygems.org/trusted-publishing/): GitHub
+mints a short-lived OIDC token, RubyGems exchanges it for a single-use API key
+scoped to this gem. No API key is stored in the repository, and the push
+satisfies the `rubygems_mfa_required` flag set in `ai_git.gemspec` without an
+interactive MFA prompt.
+
+## One-time setup
+
+1. **RubyGems** — profile → the `ai_git` gem → *Trusted publishers* → *Create*:
+
+   | Field | Value |
+   |-------|-------|
+   | Repository owner | `kaiquekandykoga` |
+   | Repository name | `ai_git` |
+   | Workflow filename | `release.yml` |
+   | Environment | `release` |
+
+2. **GitHub** — Settings → Environments → `release`. It is created on the first
+   workflow run; add required reviewers there to gate each publish behind a
+   manual approval.
+
+The values must match the workflow exactly. Renaming the workflow file or the
+environment invalidates the publisher and the push is rejected.
+
+## Cutting a release
+
+1. Bump `AIGit::VERSION` in `lib/ai_git/version.rb`.
+2. Commit the bump and push it to `master`.
+
+That is the whole procedure. The push starts the workflow, which tags and
+publishes on its own — there is no tag to create by hand.
+
+## What the workflow does
+
+1. Checks out `master` with its full history and tags, on Ruby 4.0.
+2. Reads `AIGit::VERSION` and looks for the matching `v<version>` tag. If the
+   tag already exists the version was not bumped — the change to `version.rb`
+   was a comment or a header edit — and every later step is skipped, so the
+   run is a no-op rather than a failure.
+3. Installs the bundle, then runs `rake test` and `rubocop`. A failure here
+   stops the run before anything is tagged or published.
+4. Creates the annotated `v<version>` tag and pushes it.
+5. Runs `rubygems/release-gem@v1`, which configures the OIDC credentials, runs
+   `bundle exec rake release` (build, `guard_clean`, `gem push`), attaches a
+   sigstore attestation, and waits for the version to appear on RubyGems. The
+   tag from step 4 already exists, so the release task skips tagging and goes
+   straight to the gem push.
+
+A failure before step 5 publishes nothing. If the run fails after the tag is
+pushed, delete the tag (`git push origin :refs/tags/v1.0.0`) and re-run the
+workflow from the Actions tab — `workflow_dispatch` is enabled for exactly
+that case.
+
+## Verifying
+
+The gem is live when the version shows up on
+[rubygems.org/gems/ai_git/versions](https://rubygems.org/gems/ai_git/versions),
+which the last step of the workflow waits for. Locally:
+
+```bash
+gem list -r ai_git --all
+```
+
+## Publishing by hand
+
+Only needed if the workflow is unavailable. This is the path that prompts for
+MFA:
+
+```bash
+gem build ai_git.gemspec
+gem push ai_git-1.0.0.gem
+```

data/doc/USAGE.md

@@ -0,0 +1,107 @@
+# Usage
+
+## Requirements
+
+- [llama.cpp](https://github.com/ggml-org/llama.cpp) running locally (e.g. `./llama-server --port 8080`)
+
+## Install
+
+```bash
+gem install ai_git
+```
+
+## Configuration
+
+Settings live in a YAML file at `~/.ai_git/config.yml` (`config.yaml` is read
+too). The file is optional — without it every setting falls back to its
+default.
+
+```yaml
+# ~/.ai_git/config.yml
+model_name: ggml-org/gemma-4-E4B-it-GGUF:Q8_0
+base_url: http://127.0.0.1:8080
+no_color: false
+```
+
+| Setting | Description | Default |
+|---------|-------------|---------|
+| `model_name` | Model name | `ggml-org/gemma-4-E4B-it-GGUF:Q8_0` |
+| `base_url` | Base URL of the llama.cpp server | `http://127.0.0.1:8080` |
+| `no_color` | Disable colored terminal output | `false` |
+
+An unknown key or a malformed value fails the run with an error naming the
+file, so a typo never silently leaves the default in place.
+
+Run `ai_git config` to see exactly which model, URL and endpoint are resolved,
+and which file they came from.
+
+ai_git talks to a local [llama.cpp](https://github.com/ggml-org/llama.cpp) server over its OpenAI-compatible
+`/v1/chat/completions` endpoint. No API key is needed.
+
+### Example
+
+```bash
+# Start llama.cpp's server, then run ai_git with defaults
+./llama-server --port 8080
+ai_git
+
+# Or point at a custom model/port
+mkdir -p ~/.ai_git
+cat > ~/.ai_git/config.yml <<'YAML'
+model_name: my-model
+base_url: http://127.0.0.1:8081
+YAML
+```
+
+## Run
+
+```bash
+git add <files>
+ai_git
+```
+
+`ai_git` generates a commit message from your staged changes, then asks what to
+do with it:
+
+```
+Commit this message? [A]ccept / [e]dit / [r]egenerate / [q]uit:
+```
+
+Accepting commits and pushes to `origin`. The prompt only appears on a
+terminal — piped or scripted runs stay unattended, as does `--yes`.
+
+## Flags
+
+| Flag | Description |
+|------|-------------|
+| `-n`, `--dry-run` | Print the generated message and change nothing |
+| `--no-push` | Commit locally without pushing |
+| `-y`, `--yes` | Skip the confirmation prompt (unattended) |
+| `-f`, `--force` | Proceed despite secret or remote-server warnings |
+
+```bash
+ai_git --dry-run     # see what it would write, commit nothing
+ai_git --no-push     # commit locally, publish later yourself
+```
+
+## Privacy
+
+The **full staged diff is sent to the configured `base_url`** as part of the
+prompt. The default is your own machine (`http://127.0.0.1:8080`), and nothing
+leaves it. Point `base_url` at another host and ai_git warns before every run;
+plain `http://` to a non-loopback host is refused outright unless you pass
+`--force`.
+
+Before generating, ai_git also checks the staged change for credentials —
+`.env` files, private keys, AWS/GitHub/Slack-shaped tokens — and refuses to
+send them without `--force`. It is a guard, not a guarantee: review what you
+stage.
+
+## Subcommands
+
+| Subcommand | Description |
+|------------|-------------|
+| `ai_git` | Generate a commit message, commit, and push staged files |
+| `ai_git config` | Show the resolved provider configuration |
+| `ai_git --help` | Show usage |
+| `ai_git --version` | Print version |

data/lib/ai_git/ai_client.rb

@@ -1,4 +1,22 @@
 # frozen_string_literal: true
+# lib/ai_git/ai_client.rb
+#
+# @purpose      Talk to the OpenAI-compatible chat endpoint: post the prompt,
+#               retry transient failures, and strip the model's wrapping from
+#               the reply.
+# @exports      AIGit::AIClient: READ_TIMEOUT_SECONDS, OPEN_TIMEOUT_SECONDS,
+#               MAX_ATTEMPTS, RETRY_BASE_DELAY, TRANSIENT_STATUSES,
+#               RETRYABLE_ERRORS, .complete, .sanitize.
+# @dependencies ai_git/config: supplies the base URL, endpoint, and provider
+#               name used in requests and error messages;
+#               json: encodes the request body and parses the response;
+#               net/http, uri: perform the HTTP POST.
+# @sideEffects  Makes network requests to the configured base URL; sleeps
+#               between retries; raises a string message on failure.
+# @notes        Retries with exponential backoff on the listed connection
+#               errors and status codes only; any other status raises at once.
+#               Sanitizing also unescapes a reply whose only newlines are
+#               literal backslash-n, which some models emit.
 
 require "json"
 require "net/http"
@@ -13,7 +31,6 @@ module AIGit
     READ_TIMEOUT_SECONDS = 120
     OPEN_TIMEOUT_SECONDS = 10
 
-    # Transient failures worth retrying with backoff.
     MAX_ATTEMPTS      = 3
     RETRY_BASE_DELAY  = 0.5
     TRANSIENT_STATUSES = [408, 425, 429, 500, 502, 503, 504].freeze
@@ -22,10 +39,11 @@ module AIGit
       Net::OpenTimeout, Net::ReadTimeout, SocketError, EOFError
     ].freeze
 
-    OUTPUT_NOISE_PREFIXES = /^(Here|Output|Generated|Based on|The changes)/i.freeze
-    OUTPUT_NOISE_HEADERS  = /^(Here is|The (commit message|review) is|```|json|markdown)/i.freeze
+    PREAMBLE_PREFIXES = /\A(here|output|generated|based\son|the\schanges|
+                          the\s(commit\smessage|review)\sis|json|markdown)\b/ix.freeze
+    CODE_FENCE = /\A`{3,}/.freeze
+    ESCAPED_MESSAGE = /\A[^\n]*\\n\\n[^\n]*\z/.freeze
 
-    # Sends `prompt` to the local llama.cpp server and returns the cleaned text body.
     def complete(prompt:, model_name:, temperature:)
       sanitize(openai_complete(prompt, model_name, temperature))
     end
@@ -111,17 +129,37 @@ module AIGit
     end
 
     def sanitize(text)
-      cleaned = text.to_s
-                    .gsub(OUTPUT_NOISE_HEADERS, "")
-                    .gsub(/^>\s*/, "")
-                    .gsub(/\\n/, "\n")
-                    .strip
-
-      cleaned.lines
-             .map(&:strip)
-             .reject { |line| line.match?(OUTPUT_NOISE_PREFIXES) }
-             .join("\n")
-             .strip
+      lines = unescape_newlines(text.to_s)
+              .lines
+              .map { |line| line.rstrip.sub(/\A>\s*/, "") }
+
+      strip_preamble(strip_code_fences(lines)).join("\n").strip
+    end
+
+    def unescape_newlines(text)
+      return text unless text.match?(ESCAPED_MESSAGE)
+
+      text.gsub(/\\n/, "\n")
+    end
+
+    def strip_code_fences(lines)
+      lines = lines.drop_while { |line| line.strip.empty? }
+
+      if lines.first&.match?(CODE_FENCE)
+        unfenced = lines.first.sub(CODE_FENCE, "").strip
+        unfenced.empty? ? lines.shift : lines[0] = unfenced
+      end
+
+      lines.pop while lines.last && (lines.last.strip.empty? || lines.last.strip.match?(CODE_FENCE))
+      lines
+    end
+
+    def strip_preamble(lines)
+      lines.drop_while { |line| line.strip.empty? || preamble?(line) }
+    end
+
+    def preamble?(line)
+      line.strip.match?(PREAMBLE_PREFIXES)
     end
   end
 end

data/lib/ai_git/commands/config.rb

@@ -1,4 +1,19 @@
 # frozen_string_literal: true
+# lib/ai_git/commands/config.rb
+#
+# @purpose      Implement the `config` subcommand: print the resolved provider
+#               settings and the file they come from, so the user can see what
+#               the tool will talk to.
+# @exports      AIGit::Commands::Config: .call, .resolved_rows, .config_file.
+# @dependencies ai_git/config: supplies every value printed and the path of
+#               the config file;
+#               ai_git/ai_client: supplies the read timeout shown;
+#               ai_git/ui: formats the heading and the key/value lines.
+# @sideEffects  Writes the resolved configuration to stdout; raises a string
+#               when the config file cannot be resolved.
+# @notes        Every value is resolved before the first line is printed, so a
+#               broken config file reports its error instead of a half-printed
+#               listing.
 
 require_relative "../ai_client"
 require_relative "../config"
@@ -6,20 +21,34 @@ require_relative "../ui"
 
 module AIGit
   module Commands
-    # `ai_git config` — print the resolved provider configuration so users can
-    # see exactly which provider, model, URL and key will be used.
     module Config
       module_function
 
       def call(_argv = [])
-        cfg = AIGit::Config
+        rows = resolved_rows(AIGit::Config)
 
         AIGit::UI.heading("ai_git configuration")
-        AIGit::UI.kv("Provider", cfg.provider)
-        AIGit::UI.kv("Model", cfg.model_name)
-        AIGit::UI.kv("Base URL", cfg.base_url)
-        AIGit::UI.kv("Endpoint", cfg.endpoint)
-        AIGit::UI.kv("Read timeout", "#{AIGit::AIClient::READ_TIMEOUT_SECONDS}s")
+        rows.each { |key, value| AIGit::UI.kv(key, value) }
+      end
+
+      def resolved_rows(cfg)
+        [
+          ["Provider", cfg.provider],
+          ["Model", cfg.model_name],
+          ["Base URL", cfg.base_url],
+          ["Endpoint", cfg.endpoint],
+          ["Read timeout", "#{AIGit::AIClient::READ_TIMEOUT_SECONDS}s"],
+          ["Config file", config_file(cfg)]
+        ]
+      end
+
+      def config_file(cfg)
+        return cfg.config_path if cfg.config_path
+
+        dir = cfg.config_dir
+        return "(no home directory)" if dir.nil?
+
+        "#{File.join(dir, AIGit::Config::CONFIG_FILENAMES.first)} (not found)"
       end
     end
   end

data/lib/ai_git/commands/default.rb

@@ -1,8 +1,31 @@
 # frozen_string_literal: true
+# lib/ai_git/commands/default.rb
+#
+# @purpose      Implement the default subcommand end to end: guard the staged
+#               diff, generate a commit message, confirm it, then commit and
+#               push.
+# @exports      AIGit::Commands::Default: .call, .run, .generate_commit_message,
+#               .normalize_message, .build_prompt.
+# @dependencies ai_git/options: parses the flags .call receives;
+#               ai_git/git: reads the staged tree, commits, and pushes;
+#               ai_git/secrets: screens the diff before it leaves the machine;
+#               ai_git/config: supplies the model name and base-URL checks;
+#               ai_git/ai_client: generates the message;
+#               ai_git/prompt: runs the interactive confirmation and editor;
+#               ai_git/ui: prints the header, the message, and the outcome.
+# @sideEffects  Reads the repository, commits, pushes to origin, makes network
+#               requests, spawns the editor, and writes to stdout and stderr;
+#               raises a string on any refusal.
+# @notes        Refuses to send the diff over plain http to a non-loopback host
+#               or to send likely secrets, unless --force is passed. The
+#               confirmation prompt is skipped unless both streams are a tty.
 
 require_relative "../ai_client"
 require_relative "../config"
 require_relative "../git"
+require_relative "../options"
+require_relative "../prompt"
+require_relative "../secrets"
 require_relative "../ui"
 
 module AIGit
@@ -20,12 +43,16 @@ module AIGit
         )
 
         message = normalize_message(message)
-        message.empty? ? "chore: update code" : message
+        raise empty_response_error if message.empty?
+
+        message
+      end
+
+      def empty_response_error
+        "#{AIGit::Config.provider} returned an empty commit message. " \
+          "Check the model name and that the server is loaded (see `ai_git config`), then retry."
       end
 
-      # Keep the commit body readable: collapse runs of blank lines to a single
-      # one and guarantee a blank line after the title so git sees a proper
-      # subject/body split (otherwise `git log --oneline` mashes them together).
       def normalize_message(message)
         text = message.to_s.gsub(/\n{3,}/, "\n\n").strip
         lines = text.lines.map(&:chomp)
@@ -35,39 +62,122 @@ module AIGit
         lines.join("\n").gsub(/\n{3,}/, "\n\n").strip
       end
 
-      def call(_argv = [])
-        provider = AIGit::Config.provider
-        model_name = AIGit::Config.model_name
+      def call(argv = [])
+        options = AIGit::Options.parse(argv)
+        return puts(AIGit::USAGE) if options.help?
 
         staged = AIGit::Git.staged_files
-        abort "Error: No staged files. Use `git add` first." if staged.to_s.strip.empty?
+        raise "No staged files. Use `git add` first." if staged.strip.empty?
 
+        run(staged, options)
+      end
+
+      def run(staged, options)
         diff = AIGit::Git.diff
         branch = AIGit::Git.current_branch
+        model_name = AIGit::Config.model_name
 
-        print_header(provider, model_name, staged, branch)
+        check_base_url!(options)
+        check_secrets!(staged, diff, options)
+
+        print_header(AIGit::Config.provider, model_name, staged, branch)
 
         started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        message = resolve_message(diff, model_name, options)
+        return AIGit::UI.info("Aborted. Nothing committed.") if message.nil?
+
+        return dry_run_summary(branch, options) if options.dry_run?
 
-        AIGit::UI.info(AIGit::UI.bold("Generating commit message…"))
-        message = generate_commit_message(diff, model_name)
-        print_message(message)
+        commit_and_push(message, branch, options)
+        AIGit::UI.kv("Done in", format("%.1fs", Process.clock_gettime(Process::CLOCK_MONOTONIC) - started))
+      end
+
+      def resolve_message(diff, model_name, options)
+        loop do
+          AIGit::UI.info(AIGit::UI.bold("Generating commit message…"))
+          message = generate_commit_message(diff, model_name)
+          print_message(message)
+
+          return message unless confirm?(options)
+
+          case AIGit::Prompt.ask_action
+          when :accept then return message
+          when :edit then return edited_message(message)
+          when :abort then return nil
+          end
+        end
+      end
 
+      def confirm?(options)
+        !options.dry_run? && !options.assume_yes? && AIGit::Prompt.interactive?
+      end
+
+      def edited_message(message)
+        edited = normalize_message(AIGit::Prompt.edit(message))
+        raise "Aborted: the edited commit message is empty." if edited.empty?
+
+        print_message(edited)
+        edited
+      end
+
+      def commit_and_push(message, branch, options)
         AIGit::Git.commit_with_message(message)
         AIGit::UI.success("Committed.")
 
+        return AIGit::UI.info(AIGit::UI.dim("Skipped push (--no-push).")) unless options.push?
+
+        return AIGit::UI.warning("Detached HEAD: skipping push. Commit is local only.") if branch.nil?
+
         AIGit::Git.push_current_branch
         AIGit::UI.success("Pushed to origin/#{branch}.")
+      end
+
+      def dry_run_summary(branch, options)
+        outcome =
+          if !options.push?
+            "would commit only"
+          elsif branch.nil?
+            "would commit only (detached HEAD)"
+          else
+            "would commit and push to origin/#{branch}"
+          end
+
+        AIGit::UI.info(AIGit::UI.dim("Dry run: nothing changed, #{outcome}."))
+      end
+
+      def check_base_url!(options)
+        return if AIGit::Config.loopback_base_url?
+
+        host = AIGit::Config.base_uri.host
+
+        if AIGit::Config.insecure_remote_base_url? && !options.force?
+          raise "Refusing to send the staged diff unencrypted to #{host} over http. " \
+                "Use https, a loopback address, or pass --force."
+        end
 
-        elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - started
-        AIGit::UI.kv("Done in", format("%.1fs", elapsed))
+        AIGit::UI.warning("Warning: the full staged diff will be sent to #{AIGit::Config.base_url} (not this machine).")
+      end
+
+      def check_secrets!(staged, diff, options)
+        findings = AIGit::Secrets.scan(staged, diff)
+
+        findings[:warnings].each { |finding| AIGit::UI.warning("Warning: #{finding}.") }
+
+        blocking = findings[:blocking]
+        return if blocking.empty?
+
+        blocking.each { |finding| AIGit::UI.warning("Possible secret: #{finding}.") }
+        return if options.force?
+
+        raise "Refusing to send possible secrets to #{AIGit::Config.provider}. " \
+              "Unstage these files or pass --force."
       end
 
       def print_header(provider, model_name, staged, branch)
         AIGit::UI.kv("AI Provider", provider)
         AIGit::UI.kv("Model", model_name)
         AIGit::UI.kv("Staged Files", staged.to_s.strip.gsub("\n", ", "))
-        AIGit::UI.kv("Branch", branch)
+        AIGit::UI.kv("Branch", branch || "(detached HEAD)")
         puts
       end
 
@@ -92,20 +202,20 @@ module AIGit
 
           STRICT OUTPUT FORMAT (follow exactly):
 
-          <short imperative title, max 72 chars>
+          <short imperative title, max 72 chars, summarizing the main change>
 
           <blank line>
 
-          ## Summary
-          <2–4 bullet points covering the most important changes. Each bullet starts with a verb.>
-
-          ## Why
-          <1–3 sentences explaining the motivation or context behind the change. Omit if the reason is obvious.>
+          <body written as plain prose paragraphs, no headers, no bullet points, no tags.
+          Explain why the change is necessary and what problem it solves, how it addresses
+          the issue at a high level (do not recount line-by-line code changes, those are
+          visible in the diff), and any side effects or tradeoffs reviewers should know about.>
 
           RULES:
           - Title line: short, specific, imperative mood (e.g. "Add JWT login with refresh token support"). Avoid vague titles like "Update stuff" or "Fix bug".
-          - Summary bullets: describe WHAT changed, not HOW the code looks. Focus on behaviour and impact.
-          - Why section: explain the problem being solved or the goal being achieved. Skip if it adds no value.
+          - Body: plain prose only. No markdown headers, no bullet points, no bold/italics, no tags.
+          - Body: explain WHY the change is necessary and WHAT problem it solves, then HOW it addresses the issue at a high level. Do not describe the code line by line.
+          - Body: mention side effects or tradeoffs only if they exist and matter to a reviewer.
           - No filler phrases ("this commit", "this PR", "as per discussion").
           - No line should exceed 72 characters.
 
@@ -113,27 +223,28 @@ module AIGit
 
           Add JWT-based login with refresh token support
 
-          ## Summary
-          - Implement login endpoint with access and refresh token issuance
-          - Add token refresh route with rotation and expiry validation
-          - Protect private routes via middleware that verifies access tokens
-          - Store refresh tokens using encrypted HTTP-only cookies
+          Users were being logged out on every page reload because sessions
+          were not persisted across requests. This made the app unusable for
+          any workflow longer than a single page view.
+
+          Introduces a login endpoint that issues short-lived access tokens
+          alongside long-lived refresh tokens, plus a refresh route that
+          rotates tokens on use. Refresh tokens are stored in encrypted
+          HTTP-only cookies so the client never handles them directly.
 
-          ## Why
-          Users were being logged out on every page reload. Refresh tokens allow
-          sessions to persist securely without requiring re-authentication.
+          Adds a new middleware layer on private routes, so any route not
+          yet wired to it remains unauthenticated until migrated.
 
           ---
 
           Prevent nil crash when user preferences are missing
 
-          ## Summary
-          - Add nil guard in ReportGenerator#process before accessing preferences
-          - Fall back to system defaults when preferences object is absent
+          Reports were raising NoMethodError in production for accounts
+          created before the preferences feature shipped, since those
+          accounts have no preferences record at all.
 
-          ## Why
-          Reports were raising NoMethodError in production for users created
-          before the preferences feature shipped.
+          Falls back to system defaults whenever a user's preferences are
+          absent, so report generation no longer assumes the record exists.
 
           ---
 

data/lib/ai_git/config.rb

@@ -1,4 +1,28 @@
 # frozen_string_literal: true
+# lib/ai_git/config.rb
+#
+# @purpose      Resolve the model provider settings from the defaults and the
+#               user's YAML config file, and judge whether the base URL is safe
+#               to send to.
+# @exports      AIGit::Config: PROVIDER, DEFAULT_MODEL, DEFAULT_BASE_URL,
+#               ENDPOINT, LOOPBACK_HOST, CONFIG_DIR_NAME, CONFIG_FILENAMES,
+#               SETTING_KEYS, TRUTHY_VALUES, .provider, .config_dir,
+#               .config_path, .settings, .reset!, .model_name, .base_url,
+#               .no_color?, .endpoint, .base_uri, .valid_uri?,
+#               .loopback_base_url?, .insecure_remote_base_url?.
+# @dependencies uri: parses and validates the configured base URL;
+#               yaml: parses ~/.ai_git/config.yml.
+# @sideEffects  Reads ~/.ai_git/config.yml on first use and memoizes it;
+#               raises a string on a malformed file, an unknown setting, or a
+#               malformed URL.
+# @notes        The file is read once per process, so .reset! exists to drop the
+#               memo. An unknown key raises rather than being ignored, so a
+#               typo never silently leaves the default in place. Only a loopback
+#               host keeps the diff on this machine, so every other host counts
+#               as remote for the plain-http refusal.
+
+require "uri"
+require "yaml"
 
 module AIGit
   module Config
@@ -6,6 +30,11 @@ module AIGit
     DEFAULT_MODEL = "ggml-org/gemma-4-E4B-it-GGUF:Q8_0"
     DEFAULT_BASE_URL = "http://127.0.0.1:8080"
     ENDPOINT = "/v1/chat/completions"
+    LOOPBACK_HOST = /\A(localhost|127(\.\d{1,3}){3}|::1|0:0:0:0:0:0:0:1)\z/i.freeze
+    CONFIG_DIR_NAME = ".ai_git"
+    CONFIG_FILENAMES = %w[config.yml config.yaml].freeze
+    SETTING_KEYS = %w[model_name base_url no_color].freeze
+    TRUTHY_VALUES = [true, "true", "yes", "on", "1"].freeze
 
     module_function
 
@@ -13,16 +42,107 @@ module AIGit
       PROVIDER
     end
 
+    def config_dir
+      File.join(Dir.home, CONFIG_DIR_NAME)
+    rescue ArgumentError
+      nil
+    end
+
+    def config_path
+      dir = config_dir
+      return nil if dir.nil?
+
+      CONFIG_FILENAMES.map { |name| File.join(dir, name) }.find { |path| File.file?(path) }
+    end
+
+    def settings
+      @settings ||= load_settings
+    end
+
+    def reset!
+      @settings = nil
+    end
+
+    def load_settings
+      path = config_path
+      return {} if path.nil?
+
+      validate_settings(parse_file(path), path)
+    end
+
+    def parse_file(path)
+      YAML.safe_load_file(path) || {}
+    rescue Psych::SyntaxError => e
+      raise "Invalid YAML in #{path}: #{e.message}"
+    rescue SystemCallError => e
+      raise "Cannot read #{path}: #{e.message}"
+    end
+
+    def validate_settings(data, path)
+      raise "Invalid config in #{path}: expected a mapping of settings." unless data.is_a?(Hash)
+
+      data = data.transform_keys(&:to_s)
+      unknown = data.keys - SETTING_KEYS
+      return data if unknown.empty?
+
+      raise "Unknown setting#{'s' if unknown.length > 1} in #{path}: #{unknown.join(', ')}. " \
+            "Known settings: #{SETTING_KEYS.join(', ')}."
+    end
+
+    def string_setting(key, default)
+      value = settings[key]
+      return default if value.nil?
+
+      raise "Invalid #{key} in #{config_path}: expected a non-empty string." unless string_value?(value)
+
+      value.strip
+    end
+
+    def string_value?(value)
+      value.is_a?(String) && !value.strip.empty?
+    end
+
     def model_name
-      ENV["AI_GIT_MODEL_NAME"] || DEFAULT_MODEL
+      string_setting("model_name", DEFAULT_MODEL)
     end
 
     def base_url
-      ENV["AI_GIT_BASE_URL"] || DEFAULT_BASE_URL
+      string_setting("base_url", DEFAULT_BASE_URL)
+    end
+
+    def no_color?
+      value = settings["no_color"]
+      value = value.downcase if value.is_a?(String)
+      TRUTHY_VALUES.include?(value)
     end
 
     def endpoint
       ENDPOINT
     end
+
+    def base_uri
+      uri = URI.parse(base_url)
+      raise invalid_base_url_error unless valid_uri?(uri)
+
+      uri
+    rescue URI::InvalidURIError
+      raise invalid_base_url_error
+    end
+
+    def invalid_base_url_error
+      "Invalid base_url #{base_url.inspect}: expected an http(s) URL. See `ai_git config`."
+    end
+
+    def valid_uri?(uri)
+      %w[http https].include?(uri.scheme) && !uri.host.to_s.empty?
+    end
+
+    def loopback_base_url?
+      base_uri.host.to_s.delete("[]").match?(LOOPBACK_HOST)
+    end
+
+    def insecure_remote_base_url?
+      !loopback_base_url? && base_uri.scheme == "http"
+    end
   end
 end

data/lib/ai_git/git.rb

@@ -1,4 +1,17 @@
 # frozen_string_literal: true
+# lib/ai_git/git.rb
+#
+# @purpose      Wrap the git porcelain this tool drives: inspect the staged
+#               tree, then commit and push on the user's behalf.
+# @exports      AIGit::Git: NOT_A_REPOSITORY, MAX_ERROR_DETAIL, .repository?,
+#               .ensure_repository!, .staged_files, .diff, .current_branch,
+#               .detached_head?, .commit_with_message, .push_current_branch.
+# @dependencies git: every operation shells out to the binary;
+#               open3: captures stdout, stderr, and exit status together;
+#               tempfile: holds the commit message passed to `git commit -F`.
+# @sideEffects  Spawns git subprocesses; writes a tempfile; mutates the
+#               repository and the remote on commit and push.
+# @notes        Raises a bare string message; bin/ai_git renders it and exits 1.
 
 require "open3"
 require "tempfile"
@@ -7,39 +20,65 @@ module AIGit
   module Git
     module_function
 
+    NOT_A_REPOSITORY = "Not a git repository (or any of the parent directories)."
+    MAX_ERROR_DETAIL = 500
+
+    def repository?
+      _stdout, _stderr, status = Open3.capture3("git", "rev-parse", "--git-dir")
+      status.success?
+    end
+
+    def ensure_repository!
+      raise NOT_A_REPOSITORY unless repository?
+    end
+
     def staged_files
-      `git diff --cached --name-only`
+      ensure_repository!
+      capture("git", "diff", "--cached", "--name-only")
     end
 
     def diff
-      `git diff --cached`
+      ensure_repository!
+      capture("git", "diff", "--cached")
     end
 
     def current_branch
-      `git rev-parse --abbrev-ref HEAD`.chomp
+      ensure_repository!
+      stdout, _stderr, status = Open3.capture3("git", "symbolic-ref", "--quiet", "--short", "HEAD")
+      return nil unless status.success?
+
+      branch = stdout.chomp
+      branch.empty? ? nil : branch
     end
 
-    # Run a command with arguments as an array — no shell, so values are not
-    # interpolated or word-split. Accepts either:
-    #   run_command("git", "status")                  (single string of args)
-    #   run_command("git", "commit", "-m", message)   (variadic args, preferred)
-    def run_command(cmd, *args)
-      argv =
-        if args.length == 1 && args.first.is_a?(String)
-          args.first.split
-        else
-          args.map(&:to_s)
-        end
+    def detached_head?
+      current_branch.nil?
+    end
 
-      _stdout, stderr, status = Open3.capture3(cmd, *argv)
+    def capture(*argv)
+      stdout, stderr, status = Open3.capture3(*argv)
+      return stdout if status.success?
+
+      raise command_error(argv, stderr, status)
+    end
+
+    def run_command(cmd, *args)
+      argv = [cmd, *args.map(&:to_s)]
+      _stdout, stderr, status = Open3.capture3(*argv)
 
       return if status.success?
 
-      raise "Command failed: #{cmd} #{argv.join(' ')} (exit #{status.exitstatus})#{stderr.empty? ? '' : "\n#{stderr}"}"
+      raise command_error(argv, stderr, status)
+    end
+
+    def command_error(argv, stderr, status)
+      detail = stderr.to_s.strip
+      detail = "#{detail[0, MAX_ERROR_DETAIL]}…" if detail.length > MAX_ERROR_DETAIL
+      header = "Command failed: #{argv.join(' ')} (exit #{status.exitstatus})"
+
+      detail.empty? ? header : "#{header}\n#{detail}"
     end
 
-    # Commit using a temp file so the message can contain anything (quotes,
-    # backticks, dollar signs) without shell-escaping concerns.
     def commit_with_message(message)
       Tempfile.create("ai_git_commit_msg") do |file|
         file.write(message)

data/lib/ai_git/options.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+# lib/ai_git/options.rb
+#
+# @purpose      Parse the default command's flags into a value object that the
+#               command queries instead of re-reading the argument vector.
+# @exports      AIGit::Options: .parse, #dry_run?, #push?, #assume_yes?,
+#               #force?, #help?, and the matching accessors.
+# @sideEffects  None.
+# @notes        An unrecognized argument raises rather than being ignored, so a
+#               mistyped flag never silently commits and pushes.
+
+module AIGit
+  class Options
+    attr_accessor :dry_run, :push, :assume_yes, :force, :help
+
+    def initialize
+      @dry_run = false
+      @push = true
+      @assume_yes = false
+      @force = false
+      @help = false
+    end
+
+    def self.parse(argv)
+      argv.to_a.each_with_object(new) do |arg, options|
+        case arg
+        when "-n", "--dry-run" then options.dry_run = true
+        when "--no-push"       then options.push = false
+        when "-y", "--yes"     then options.assume_yes = true
+        when "-f", "--force"   then options.force = true
+        when "-h", "--help"    then options.help = true
+        else raise "Unknown option: #{arg}. Run `ai_git --help` for usage."
+        end
+      end
+    end
+
+    def dry_run?
+      @dry_run
+    end
+
+    def push?
+      @push
+    end
+
+    def assume_yes?
+      @assume_yes
+    end
+
+    def force?
+      @force
+    end
+
+    def help?
+      @help
+    end
+  end
+end

data/lib/ai_git/prompt.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+# lib/ai_git/prompt.rb
+#
+# @purpose      Own the interactive confirmation step: ask what to do with the
+#               generated message, and open the user's editor on request.
+# @exports      AIGit::Prompt: ACTIONS, QUESTION, .interactive?, .ask_action,
+#               .edit.
+# @dependencies ai_git/ui: bolds the question before it is printed;
+#               shellwords: splits $VISUAL or $EDITOR into command and args;
+#               tempfile: holds the message the editor opens.
+# @sideEffects  Reads stdin and writes to stdout; spawns the editor process;
+#               writes a tempfile; reads $VISUAL and $EDITOR.
+# @notes        A closed stdin, where gets returns nil, is treated as an abort
+#               so a piped run never blocks waiting on an answer.
+
+require "shellwords"
+require "tempfile"
+
+require_relative "ui"
+
+module AIGit
+  module Prompt
+    module_function
+
+    ACTIONS = {
+      "" => :accept, "a" => :accept, "accept" => :accept, "y" => :accept, "yes" => :accept,
+      "e" => :edit, "edit" => :edit,
+      "r" => :regenerate, "regen" => :regenerate, "regenerate" => :regenerate,
+      "q" => :abort, "quit" => :abort, "n" => :abort, "no" => :abort, "abort" => :abort
+    }.freeze
+
+    QUESTION = "Commit this message? [A]ccept / [e]dit / [r]egenerate / [q]uit: "
+
+    def interactive?
+      $stdin.tty? && $stdout.tty?
+    end
+
+    def ask_action
+      loop do
+        $stdout.print AIGit::UI.bold(QUESTION)
+        $stdout.flush
+
+        answer = $stdin.gets
+        return :abort if answer.nil?
+
+        action = ACTIONS[answer.strip.downcase]
+        return action if action
+
+        AIGit::UI.info("Please answer a, e, r or q.")
+      end
+    end
+
+    def edit(message)
+      editor = ENV["VISUAL"] || ENV["EDITOR"]
+      raise "Cannot edit: set $EDITOR or $VISUAL first." if editor.to_s.strip.empty?
+
+      Tempfile.create(["ai_git_commit_msg", ".txt"]) do |file|
+        file.write(message)
+        file.flush
+
+        raise "Editor #{editor} exited with an error." unless system(*Shellwords.split(editor), file.path)
+
+        File.read(file.path)
+      end
+    end
+  end
+end

data/lib/ai_git/secrets.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+# lib/ai_git/secrets.rb
+#
+# @purpose      Screen the staged paths and diff for credentials before the
+#               diff leaves the machine, splitting blocking hits from warnings.
+# @exports      AIGit::Secrets: RISKY_PATHS, RISKY_CONTENT,
+#               SUSPICIOUS_ASSIGNMENT, .scan.
+# @sideEffects  None.
+# @notes        Only added lines are scanned: removing a secret is not a leak.
+#               A bare key/secret/password assignment warns rather than blocks,
+#               because the pattern also matches ordinary code.
+
+module AIGit
+  module Secrets
+    module_function
+
+    RISKY_PATHS = {
+      "an environment file" => %r{(\A|/)\.env(\.[^/]+)?\z},
+      "an SSH private key" => %r{(\A|/)id_(rsa|dsa|ecdsa|ed25519)\z},
+      "a private key file" => /\.(pem|key|p12|pfx|jks|keystore)\z/i,
+      "a credentials file" => %r{(\A|/)(credentials|\.netrc|\.npmrc|\.pypirc|\.htpasswd)\z},
+      "a secrets file" => %r{(\A|/)secrets?\.(ya?ml|json|toml)\z}i
+    }.freeze
+
+    RISKY_CONTENT = {
+      "a private key block" => /-----BEGIN [A-Z ]*PRIVATE KEY-----/,
+      "an AWS access key id" => /\bAKIA[0-9A-Z]{16}\b/,
+      "a GitHub token" => /\b(gh[posur]_[A-Za-z0-9]{16,}|github_pat_[A-Za-z0-9_]{20,})\b/,
+      "an OpenAI-style API key" => /\bsk-[A-Za-z0-9_-]{20,}\b/,
+      "a Slack token" => /\bxox[abprs]-[A-Za-z0-9-]{10,}\b/,
+      "a Google API key" => /\bAIza[0-9A-Za-z_-]{35}\b/
+    }.freeze
+
+    SUSPICIOUS_ASSIGNMENT = /
+      \b(api[_-]?key|secret|password|passwd|token|access[_-]?key)\b
+      \s*[:=]\s*["'][^"']{8,}["']
+    /ix.freeze
+
+    def scan(staged_files, diff)
+      { blocking: blocking_findings(staged_files, diff), warnings: warning_findings(diff) }
+    end
+
+    def blocking_findings(staged_files, diff)
+      paths = staged_files.to_s.lines.map(&:strip).reject(&:empty?)
+      added = added_lines(diff)
+
+      findings = paths.flat_map do |path|
+        RISKY_PATHS.filter_map { |label, pattern| "#{path} looks like #{label}" if path.match?(pattern) }
+      end
+
+      findings + RISKY_CONTENT.filter_map do |label, pattern|
+        "added lines contain what looks like #{label}" if added.match?(pattern)
+      end
+    end
+
+    def warning_findings(diff)
+      return [] unless added_lines(diff).match?(SUSPICIOUS_ASSIGNMENT)
+
+      ["added lines assign a value to a key/secret/password/token name"]
+    end
+
+    def added_lines(diff)
+      diff.to_s.lines.select { |line| line.start_with?("+") && !line.start_with?("+++") }.join
+    end
+  end
+end

data/lib/ai_git/ui.rb

@@ -1,8 +1,21 @@
 # frozen_string_literal: true
+# lib/ai_git/ui.rb
+#
+# @purpose      Render every line the CLI prints, adding ANSI color only when
+#               the terminal and the configuration both allow it.
+# @exports      AIGit::UI: CODES, .color?, .no_color?, .paint, .bold, .dim,
+#               .kv, .heading, .info, .success, .warning, .error.
+# @dependencies ai_git/config: supplies the no_color setting from
+#               ~/.ai_git/config.yml.
+# @sideEffects  Writes to stdout and stderr; inspects $stdout.tty?.
+# @notes        Color is off whenever the config file sets no_color or stdout
+#               is not a terminal, so piped output stays plain. A config file
+#               that fails to load also turns color off rather than raising, so
+#               that error itself can still be printed.
+
+require_relative "config"
 
 module AIGit
-  # Terminal output helpers: ANSI colors (auto-disabled when output is not a
-  # TTY or NO_COLOR is set) and key/value lines.
   module UI
     module_function
 
@@ -10,15 +23,18 @@ module AIGit
       bold: 1, dim: 2, red: 31, green: 32, yellow: 33, blue: 34, cyan: 36, gray: 90
     }.freeze
 
-    # Colors are on only for an interactive terminal and when the user has not
-    # opted out via NO_COLOR (https://no-color.org) or AI_GIT_NO_COLOR.
     def color?
-      return false if ENV["NO_COLOR"] && !ENV["NO_COLOR"].empty?
-      return false if ENV["AI_GIT_NO_COLOR"] && !ENV["AI_GIT_NO_COLOR"].empty?
+      return false if no_color?
 
       $stdout.tty?
     end
 
+    def no_color?
+      AIGit::Config.no_color?
+    rescue StandardError
+      true
+    end
+
     def paint(text, *styles)
       return text.to_s unless color?
 
@@ -52,6 +68,10 @@ module AIGit
       puts paint(text, :green)
     end
 
+    def warning(text)
+      warn paint(text, :yellow)
+    end
+
     def error(text)
       $stderr.puts paint(text, :red) # rubocop:disable Style/StderrPuts
     end

data/lib/ai_git/version.rb

@@ -1,5 +1,11 @@
 # frozen_string_literal: true
+# lib/ai_git/version.rb
+#
+# @purpose      Hold the single source of truth for the gem's version number,
+#               read by the gemspec, the CLI, and the release check.
+# @exports      AIGit::VERSION.
+# @sideEffects  None.
 
 module AIGit
-  VERSION = "0.3.0"
+  VERSION = "1.0.1"
 end

data/lib/ai_git.rb

@@ -1,4 +1,17 @@
 # frozen_string_literal: true
+# lib/ai_git.rb
+#
+# @purpose      Library entry point and CLI router: load every component, then
+#               dispatch the argument vector to the matching subcommand.
+# @exports      AIGit: SUBCOMMANDS, HELP_FLAGS, VERSION_FLAGS, USAGE, .start.
+# @dependencies ai_git/version, ai_git/config, ai_git/ui, ai_git/ai_client,
+#               ai_git/git: the components the subcommands build on;
+#               ai_git/commands/default, ai_git/commands/config: the two
+#               subcommands .start dispatches to.
+# @sideEffects  Prints usage or the version to stdout; warns and exits 1 on an
+#               unknown subcommand; .start runs the selected subcommand.
+# @notes        A first argument starting with "-" is left in place for the
+#               default command's parser, so bare flags need no subcommand.
 
 require_relative "ai_git/version"
 require_relative "ai_git/config"
@@ -20,20 +33,30 @@ module AIGit
   VERSION_FLAGS = %w[-v --version].freeze
 
   USAGE = <<~USAGE
-    Usage: ai_git [subcommand]
+    Usage: ai_git [subcommand] [options]
 
     Subcommands:
       (none)    Generate a commit message, commit, and push staged files
       config    Show the resolved provider configuration
 
-    Flags:
+    Options:
+      -n, --dry-run  Print the generated message and change nothing
+          --no-push  Commit locally without pushing
+      -y, --yes      Skip the confirmation prompt (unattended)
+      -f, --force    Proceed despite secret or remote-server warnings
       -h, --help     Show this message
       -v, --version  Print version
 
-    Environment variables:
-      AI_GIT_MODEL_NAME    Override the default model
-      AI_GIT_BASE_URL      Override the default base URL
-      NO_COLOR             Disable colored output
+    On a terminal ai_git asks before committing: accept, edit, regenerate or
+    quit. Piped or scripted runs commit and push unattended.
+
+    Configuration (~/.ai_git/config.yml, or config.yaml):
+      model_name: ggml-org/gemma-4-E4B-it-GGUF:Q8_0   Model to prompt
+      base_url: http://127.0.0.1:8080                 llama.cpp server
+      no_color: true                                  Disable colored output
+
+    Run `ai_git config` to see the resolved settings and the file they
+    come from.
   USAGE
 
   def start(args)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ai_git
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 1.0.1
 platform: ruby
 authors:
 - Kaíque Kandy Koga
@@ -19,12 +19,17 @@ files:
 - LICENSE
 - README.md
 - bin/ai_git
+- doc/RELEASE.md
+- doc/USAGE.md
 - lib/ai_git.rb
 - lib/ai_git/ai_client.rb
 - lib/ai_git/commands/config.rb
 - lib/ai_git/commands/default.rb
 - lib/ai_git/config.rb
 - lib/ai_git/git.rb
+- lib/ai_git/options.rb
+- lib/ai_git/prompt.rb
+- lib/ai_git/secrets.rb
 - lib/ai_git/ui.rb
 - lib/ai_git/version.rb
 homepage: https://github.com/kaiquekandykoga/ai_git
@@ -48,7 +53,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.10
+rubygems_version: 4.0.16
 specification_version: 4
 summary: AI-powered Git commit messages using a local LLM
 test_files: []