llm_optimizer 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e68575c7d9fba996b2efeb9dd559635bba72316322b75a1f43b0e6b2a5e28fce
-  data.tar.gz: b8b3f8e06da0d860af65a192b3a4fb16bfe8110fd3eca69d328fd5ef71471571
+  metadata.gz: d382e2ae48971edae81c24fa4e05bbacf9394c04dabed28b0277ca429e75a98d
+  data.tar.gz: d807840237cf09e8b271063660242ae1c460b682425a50389c60f396b086e2c4
 SHA512:
-  metadata.gz: 6679cbc09844d71e3c42e74e313d5366bcafbfdeb7e6625a6f0ad591bb8fc98687ba3040a6c54703388bc81be614fd9095d5f71eb0b3eac80fdf0c43299445ee
-  data.tar.gz: '095e4ac8ef5f45240f9d0d5068cf462d66900258765d184f1e25b2e9233c782d5363a248dc178167ad83055fa0d6a006bb2631a83e94c482fcd03fed947c41d4'
+  metadata.gz: 8cac9e17c1f243c17d997e799daf25d886b329c09e83c84d9151f55abbb50d36a7e1b486171e401a645443022bb4de05e4430d0e303e05587dd1b244eda18cbe
+  data.tar.gz: 598b000eabc6a4c0000b3b9bd2162231c619d7618653ca6356948b623f0524db048c7b1f9a8a589905c6b611a10fe6bdc42e7490b432fe8f6047b75dcc35038a

data/.overcommit.yml

@@ -0,0 +1,17 @@
+gemfile: Gemfile
+
+PreCommit:
+  RuboCop:
+    enabled: true
+    on_warn: fail
+    command: ["bundle", "exec", "rubocop"]
+    description: "Check RuboCop offenses"
+
+  MiniTest:
+    enabled: true
+    description: "Run Minitest suite"
+    required_executable: "bundle"
+    command: ["bundle", "exec", "rake", "test"]
+    include:
+      - "lib/**/*.rb"
+      - "test/**/*.rb"

data/CHANGELOG.md

@@ -7,6 +7,23 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.1.1] - 2026-04-10
+
+### Fixed
+- RuboCop offenses across all source and test files
+- `missing keyword: :_model` error in test lambdas — use `**_kwargs` pattern
+- HistoryManager summarization tests failing due to keyword argument mismatch
+- Suppress third-party gem warnings in test output
+
+### Added
+- Full unit test suite with positive and negative scenarios (Minitest + Mocha)
+- Mock JSON fixtures for OpenAI embedding API responses
+- `CONTRIBUTING.md` with fork setup, issue guidelines, PR checklist, and overcommit instructions
+- Pre-commit hooks via overcommit (RuboCop + Minitest)
+- Rails generator: `rails generate llm_optimizer:install`
+- `embedding_caller` and `llm_caller` injectable lambdas — no forced provider dependency
+- `logger` gem explicit dependency for Ruby 3.5+ compatibility
+
 ## [0.1.0] - 2026-04-10
 
 ### Added

data/CONTRIBUTING.md

@@ -0,0 +1,228 @@
+# Contributing to llm_optimizer
+
+Thanks for taking the time to contribute. This document covers everything you need to get set up, raise issues, and submit pull requests.
+
+## Table of Contents
+
+- [Setting Up the Repo](#setting-up-the-repo)
+- [Running Tests and Linting](#running-tests-and-linting)
+- [Pre-commit Hooks with Overcommit](#pre-commit-hooks-with-overcommit)
+- [Raising an Issue](#raising-an-issue)
+- [Submitting a Pull Request](#submitting-a-pull-request)
+- [Code Style](#code-style)
+- [Commit Message Guidelines](#commit-message-guidelines)
+
+---
+
+## Setting Up the Repo
+
+**1. Fork the repository**
+
+Click "Fork" on [github.com/arunkumarry/llm_optimizer](https://github.com/arunkumarry/llm_optimizer).
+
+**2. Clone your fork**
+
+```bash
+git clone https://github.com/<your-username>/llm_optimizer.git
+cd llm_optimizer
+```
+
+**3. Add the upstream remote**
+
+```bash
+git remote add upstream https://github.com/arunkumarry/llm_optimizer.git
+```
+
+**4. Install dependencies**
+
+```bash
+bundle install
+```
+
+**5. Verify everything works**
+
+```bash
+bundle exec rake test
+bundle exec rubocop
+```
+
+Both should pass before you start making changes.
+
+---
+
+## Running Tests and Linting
+
+```bash
+# Run the full test suite
+bundle exec rake test
+
+# Run RuboCop
+bundle exec rubocop
+
+# Run both (default rake task)
+bundle exec rake
+```
+
+Add tests for any new behaviour you introduce. Tests live in `test/unit/`.
+
+---
+
+## Pre-commit Hooks with Overcommit
+
+This repo uses [overcommit](https://github.com/sds/overcommit) to run RuboCop and the test suite before every commit.
+
+**Install the hooks after cloning:**
+
+```bash
+bundle exec overcommit --install
+bundle exec overcommit --sign
+```
+
+Every `git commit` will now automatically run RuboCop and the test suite. If either fails, the commit is blocked.
+
+**Bypass for a WIP commit:**
+
+```bash
+git commit --no-verify -m "wip: work in progress"
+```
+
+Re-enable checks before opening a PR — all hooks must pass.
+
+**Note on rebasing:** If overcommit hooks cause issues during `git pull --rebase`, uninstall them first:
+
+```bash
+bundle exec overcommit --uninstall
+git pull --rebase origin main
+bundle exec overcommit --install
+bundle exec overcommit --sign
+```
+
+---
+
+## Raising an Issue
+
+Search [existing issues](https://github.com/arunkumarry/llm_optimizer/issues) before opening a new one.
+
+**Bug reports should include:**
+- Ruby version (`ruby -v`)
+- Gem version (`bundle exec gem list llm_optimizer`)
+- Minimal reproduction script
+- Expected vs actual behaviour
+- Full error message and backtrace
+
+**Feature requests should include:**
+- The problem you're solving
+- What the API should look like
+- Alternatives you've considered
+
+Use labels: `bug`, `enhancement`, `question`, or `documentation`.
+
+---
+
+## Submitting a Pull Request
+
+**1. Sync with upstream before starting**
+
+```bash
+git fetch upstream
+git rebase upstream/main
+```
+
+**2. Create a branch**
+
+```bash
+git checkout -b feature/your-feature-name
+# or
+git checkout -b fix/issue-description
+```
+
+Branch naming:
+- `feature/` — new functionality
+- `fix/` — bug fixes
+- `docs/` — documentation only
+- `refactor/` — no behaviour change
+- `test/` — test additions or fixes
+
+**3. Make your changes**
+
+- Write tests for new behaviour — PRs without tests won't be merged
+- Keep changes focused — one concern per PR
+- Update `CHANGELOG.md` under `[Unreleased]`
+
+**4. Ensure all checks pass**
+
+```bash
+bundle exec rake
+```
+
+**5. Push and open a PR**
+
+```bash
+git push origin feature/your-feature-name
+```
+
+Open a PR against `main` on GitHub.
+
+**PR description should include:**
+- What the PR does and why
+- Link to the related issue (`Closes #42`)
+- How to test it manually if applicable
+- Any breaking changes clearly called out
+
+**PR checklist:**
+- [ ] Tests added or updated
+- [ ] `bundle exec rake` passes locally
+- [ ] `CHANGELOG.md` updated under `[Unreleased]`
+- [ ] No unrelated changes included
+
+---
+
+## Code Style
+
+RuboCop is configured in `.rubocop.yml`. Run before committing:
+
+```bash
+bundle exec rubocop
+
+# Auto-fix safe offenses
+bundle exec rubocop -a
+```
+
+Key conventions:
+- Double-quoted strings
+- `# frozen_string_literal: true` in every file
+- No monkey-patching without explicit opt-in
+- Errors handled gracefully — never let the optimizer break the app
+
+---
+
+## Commit Message Guidelines
+
+Follow [Conventional Commits](https://www.conventionalcommits.org/):
+
+```
+<type>: <short description>
+
+[optional body explaining why]
+
+[optional footer: Closes #issue]
+```
+
+Types: `feat`, `fix`, `docs`, `refactor`, `test`, `chore`
+
+Examples:
+```
+feat: add embedding_caller config for custom providers
+fix: handle nil model in raw_llm_call fallback
+docs: update README with per-call config example
+test: add negative scenarios for SemanticCache lookup
+chore: add overcommit pre-commit hooks
+```
+
+Subject line under 72 characters. Body explains *why*, not *what*.
+
+---
+
+## Questions?
+
+Open a [GitHub Discussion](https://github.com/arunkumarry/llm_optimizer/discussions) or file an issue with the `question` label.

data/README.md

@@ -234,6 +234,9 @@ Generate the Rails initializer in a target app:
 rails generate llm_optimizer:install
 ```
 
+## Contribution
+See [CONTRIBUTING.md](https://github.com/arunkumarry/llm_optimizer/blob/main/CONTRIBUTING.md)
+
 ## License
 
 MIT

data/lib/generators/llm_optimizer/templates/initializer.rb

@@ -24,8 +24,8 @@ LlmOptimizer.configure do |config|
   # --- Tuning ---
   config.similarity_threshold = 0.96   # cosine similarity cutoff for a cache hit
   config.token_budget         = 4000   # token limit before history summarization kicks in
-  config.cache_ttl            = 86400  # cache entry TTL in seconds (default: 24h)
-  config.timeout_seconds      = 5      # timeout for embedding / external API calls
+  config.cache_ttl            = 86_400 # cache entry TTL in seconds (default: 24h)
+  config.timeout_seconds      = 5 # timeout for embedding / external API calls
 
   # --- Logging ---
   config.logger        = Rails.logger
@@ -52,9 +52,9 @@ LlmOptimizer.configure do |config|
   #     RubyLLM.chat(model: model, provider: provider, assume_model_exists: true) }
   #   end
   #
-  config.llm_caller = ->(prompt, model:) {
+  config.llm_caller = lambda { |_prompt, **_kwargs|
     raise NotImplementedError, "[llm_optimizer] llm_caller is not configured. " \
-      "Edit config/initializers/llm_optimizer.rb and wire it to your LLM client."
+                               "Edit config/initializers/llm_optimizer.rb and wire it to your LLM client."
   }
 
   # --- Embeddings caller (optional) ---

data/lib/llm_optimizer/compressor.rb

@@ -40,7 +40,7 @@ module LlmOptimizer
 
     def remove_stop_words(text)
       stop_set = STOP_WORDS.to_set
-      words = text.split(" ")
+      words = text.split
       words.reject { |w| stop_set.include?(w.downcase) }.join(" ")
     end
   end

data/lib/llm_optimizer/configuration.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "logger"
-require "set"
 
 module LlmOptimizer
   class Configuration
@@ -43,7 +42,7 @@ module LlmOptimizer
       @logger               = Logger.new($stdout)
       @debug_logging        = false
       @timeout_seconds      = 5
-      @cache_ttl            = 86400
+      @cache_ttl            = 86_400
       @llm_caller           = nil
       @embedding_caller     = nil
     end
@@ -56,7 +55,7 @@ module LlmOptimizer
       self
     end
 
-    def method_missing(name, *args, &block)
+    def method_missing(name, *args, &)
       key = name.to_s.chomp("=").to_sym
       raise ConfigurationError, "Unknown configuration key: #{key}" unless KNOWN_KEYS.include?(key)
 

data/lib/llm_optimizer/embedding_client.rb

@@ -29,8 +29,11 @@ module LlmOptimizer
     private
 
     def embed_via_openai(text)
-      api_key = ENV["OPENAI_API_KEY"]
-      raise EmbeddingError, "OPENAI_API_KEY is not set and no embedding_caller configured" if api_key.nil? || api_key.empty?
+      api_key = ENV.fetch("OPENAI_API_KEY", nil)
+      if api_key.nil? || api_key.empty?
+        raise EmbeddingError,
+              "OPENAI_API_KEY is not set and no embedding_caller configured"
+      end
 
       uri  = URI(OPENAI_ENDPOINT)
       body = JSON.generate({ model: @model, input: text })

data/lib/llm_optimizer/history_manager.rb

@@ -18,7 +18,7 @@ module LlmOptimizer
     def process(messages)
       return messages if estimate_tokens(messages) <= @token_budget
 
-      count      = [SUMMARIZE_COUNT, messages.length].min
+      count = [SUMMARIZE_COUNT, messages.length].min
       to_summarize = messages.first(count)
       remainder    = messages.drop(count)
 
@@ -32,7 +32,8 @@ module LlmOptimizer
 
     def summarize(messages)
       conversation = messages.map { |m| "#{m[:role] || m["role"]}: #{m[:content] || m["content"]}" }.join("\n")
-      prompt = "Summarize the following conversation history concisely, preserving key facts and decisions:\n\n#{conversation}"
+      prompt = "Summarize the following conversation history concisely, " \
+               "preserving key facts and decisions:\n\n#{conversation}"
 
       @llm_caller.call(prompt, model: @simple_model)
     rescue StandardError => e

data/lib/llm_optimizer/model_router.rb

@@ -12,7 +12,7 @@ module LlmOptimizer
 
     def route(prompt)
       # explicit override
-      return @config.route_to if @config.route_to == :simple || @config.route_to == :complex
+      return @config.route_to if %i[simple complex].include?(@config.route_to)
 
       # fenced code block
       return :complex if CODE_BLOCK_RE.match?(prompt)

data/lib/llm_optimizer/optimize_result.rb

@@ -3,7 +3,6 @@
 module LlmOptimizer
   OptimizeResult = Struct.new(
     :response, :model, :model_tier, :cache_status,
-    :original_tokens, :compressed_tokens, :latency_ms, :messages,
-    keyword_init: true
+    :original_tokens, :compressed_tokens, :latency_ms, :messages
   )
 end

data/lib/llm_optimizer/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module LlmOptimizer
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

data/lib/llm_optimizer.rb

@@ -37,13 +37,13 @@ module LlmOptimizer
 
   # Warns about misconfigured options rather than failing silently at call time.
   def self.validate_configuration!(config)
-    if config.use_semantic_cache && config.embedding_caller.nil?
-      config.logger.warn(
-        "[llm_optimizer] use_semantic_cache is true but no embedding_caller is configured. " \
-        "Semantic caching will be skipped. Set config.embedding_caller to enable it."
-      )
-      config.use_semantic_cache = false
-    end
+    return unless config.use_semantic_cache && config.embedding_caller.nil?
+
+    config.logger.warn(
+      "[llm_optimizer] use_semantic_cache is true but no embedding_caller is configured. " \
+      "Semantic caching will be skipped. Set config.embedding_caller to enable it."
+    )
+    config.use_semantic_cache = false
   end
 
   # Returns the current global Configuration, lazy-initializing if nil.
@@ -59,11 +59,11 @@ module LlmOptimizer
 
   # Opt-in client wrapping
   module WrapperModule
-    def chat(params, &block)
+    def chat(params, &)
       prompt = params[:messages] || params[:prompt]
       optimized = LlmOptimizer.optimize(prompt)
       params = params.merge(messages: optimized.messages, model: optimized.model)
-      super(params, &block)
+      super
     end
   end
 
@@ -80,7 +80,7 @@ module LlmOptimizer
   # options hash keys mirror Configuration attr_accessors and are merged over
   # the global config for this call only.  An optional block is yielded a
   # per-call Configuration for fine-grained control.
-  def self.optimize(prompt, options = {}, &block)
+  def self.optimize(prompt, options = {})
     start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
 
     # Resolve per-call configuration — only pass known config keys
@@ -88,6 +88,7 @@ module LlmOptimizer
     call_config.merge!(configuration)
     options.each do |k, v|
       next unless LlmOptimizer::Configuration::KNOWN_KEYS.include?(k.to_sym)
+
       call_config.public_send(:"#{k}=", v)
     end
     yield call_config if block_given?
@@ -118,8 +119,8 @@ module LlmOptimizer
     if call_config.use_semantic_cache
       begin
         emb_client = EmbeddingClient.new(
-          model:            call_config.embedding_model,
-          timeout_seconds:  call_config.timeout_seconds,
+          model: call_config.embedding_model,
+          timeout_seconds: call_config.timeout_seconds,
           embedding_caller: call_config.embedding_caller
         )
         embedding = emb_client.embed(prompt)
@@ -136,14 +137,14 @@ module LlmOptimizer
                      original_tokens: original_tokens, compressed_tokens: compressed_tokens,
                      latency_ms: latency_ms, prompt: original_prompt, response: cached)
             return OptimizeResult.new(
-              response:          cached,
-              model:             model,
-              model_tier:        model_tier,
-              cache_status:      :hit,
-              original_tokens:   original_tokens,
+              response: cached,
+              model: model,
+              model_tier: model_tier,
+              cache_status: :hit,
+              original_tokens: original_tokens,
               compressed_tokens: compressed_tokens,
-              latency_ms:        latency_ms,
-              messages:          options[:messages]
+              latency_ms: latency_ms,
+              messages: options[:messages]
             )
           end
         end
@@ -159,7 +160,7 @@ module LlmOptimizer
     if call_config.manage_history && messages
       llm_caller = ->(p, model:) { raw_llm_call(p, model: model) }
       history_mgr = HistoryManager.new(
-        llm_caller:   llm_caller,
+        llm_caller: llm_caller,
         simple_model: call_config.simple_model,
         token_budget: call_config.token_budget
       )
@@ -188,16 +189,15 @@ module LlmOptimizer
              latency_ms: latency_ms, prompt: original_prompt, response: response)
 
     OptimizeResult.new(
-      response:          response,
-      model:             model,
-      model_tier:        model_tier,
-      cache_status:      :miss,
-      original_tokens:   original_tokens,
+      response: response,
+      model: model,
+      model_tier: model_tier,
+      cache_status: :miss,
+      original_tokens: original_tokens,
       compressed_tokens: compressed_tokens,
-      latency_ms:        latency_ms,
-      messages:          messages
+      latency_ms: latency_ms,
+      messages: messages
     )
-
   rescue EmbeddingError => e
     # Treat embedding failures as cache miss — continue to raw LLM call
     logger = configuration.logger
@@ -205,30 +205,29 @@ module LlmOptimizer
     latency_ms = elapsed_ms(start)
     response   = raw_llm_call(original_prompt, model: nil, config: configuration)
     OptimizeResult.new(
-      response:          response,
-      model:             nil,
-      model_tier:        nil,
-      cache_status:      :miss,
-      original_tokens:   original_tokens || 0,
+      response: response,
+      model: nil,
+      model_tier: nil,
+      cache_status: :miss,
+      original_tokens: original_tokens || 0,
       compressed_tokens: nil,
-      latency_ms:        latency_ms,
-      messages:          options[:messages]
+      latency_ms: latency_ms,
+      messages: options[:messages]
     )
-
   rescue LlmOptimizer::Error, StandardError => e
     logger = configuration.logger
     logger.error("[llm_optimizer] #{e.class}: #{e.message}\n#{e.backtrace&.first(5)&.join("\n")}")
     latency_ms = elapsed_ms(start)
     response   = raw_llm_call(original_prompt, model: nil, config: configuration)
     OptimizeResult.new(
-      response:          response,
-      model:             nil,
-      model_tier:        nil,
-      cache_status:      :miss,
-      original_tokens:   original_tokens || 0,
+      response: response,
+      model: nil,
+      model_tier: nil,
+      cache_status: :miss,
+      original_tokens: original_tokens || 0,
       compressed_tokens: nil,
-      latency_ms:        latency_ms,
-      messages:          options[:messages]
+      latency_ms: latency_ms,
+      messages: options[:messages]
     )
   end
 
@@ -239,8 +238,11 @@ module LlmOptimizer
 
     def raw_llm_call(prompt, model:, config: nil)
       caller = config&.llm_caller || @_current_llm_caller
-      raise ConfigurationError,
-            "No llm_caller configured. Set it via LlmOptimizer.configure { |c| c.llm_caller = ->(prompt, model:) { ... } }" unless caller
+      unless caller
+        raise ConfigurationError,
+              "No llm_caller configured. " \
+              "Set it via LlmOptimizer.configure { |c| c.llm_caller = ->(prompt, model:) { ... } }"
+      end
 
       caller.call(prompt, model: model)
     end
@@ -251,7 +253,6 @@ module LlmOptimizer
 
     def emit_log(logger, config, cache_status:, model_tier:, original_tokens:,
                  compressed_tokens:, latency_ms:, prompt:, response:)
-
       logger.info(
         "[llm_optimizer] { cache_status: #{cache_status.inspect}, " \
         "model_tier: #{model_tier.inspect}, " \
@@ -260,9 +261,9 @@ module LlmOptimizer
         "latency_ms: #{latency_ms.inspect} }"
       )
 
-      if config.debug_logging
-        logger.debug("[llm_optimizer] prompt=#{prompt.inspect} response=#{response.inspect}")
-      end
+      return unless config.debug_logging
+
+      logger.debug("[llm_optimizer] prompt=#{prompt.inspect} response=#{response.inspect}")
     end
 
     def build_redis(redis_url)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: llm_optimizer
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - arun kumar
@@ -10,19 +10,19 @@ cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: redis
+  name: logger
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: '1.6'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: '1.6'
 - !ruby/object:Gem::Dependency
   name: msgpack
   requirement: !ruby/object:Gem::Requirement
@@ -38,58 +38,74 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '1.7'
 - !ruby/object:Gem::Dependency
-  name: logger
+  name: redis
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.6'
+        version: '5.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.6'
+        version: '5.0'
 - !ruby/object:Gem::Dependency
-  name: prop_check
+  name: mocha
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '2.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '2.0'
 - !ruby/object:Gem::Dependency
-  name: mocha
+  name: overcommit
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '0.65'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
-description: llm_optimizer reduces LLM API costs by up to 80% through semantic caching
-  (Redis + vector similarity), intelligent model routing, token pruning, and conversation
-  history summarization. Strictly opt-in and non-invasive.
+        version: '0.65'
+- !ruby/object:Gem::Dependency
+  name: prop_check
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: llm_optimizer reduces LLM API costs by up to 80% through semantic caching,
+  intelligent model routing, token pruning, and conversation history summarization.
+  Strictly opt-in and non-invasive.
 email:
 - arunr.rubydev@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".overcommit.yml"
 - CHANGELOG.md
 - CODE_OF_CONDUCT.md
+- CONTRIBUTING.md
 - LICENSE.txt
 - README.md
 - Rakefile
@@ -114,6 +130,7 @@ metadata:
   homepage_uri: https://github.com/arunkumarry/llm_optimizer
   source_code_uri: https://github.com/arunkumarry/llm_optimizer/tree/main
   changelog_uri: https://github.com/arunkumarry/llm_optimizer/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
 - lib