rubber_duck 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 171bf433b6ed6a157adb397cb9e365b12531ef1631b06901282b870a2c9fafda
+  data.tar.gz: b2ad788c01a589196d6b502e87653935d15b04d569a78c750881b56189ff146f
+SHA512:
+  metadata.gz: b092243fc9b50c76878a8a6b396888e39e856d0e9a814be6f258dcd9b4de04f773695f4ddca00bbce89d9e304b3d686c30cb62485ac183a939a7c474f3b1b952
+  data.tar.gz: b13dca3ab57855361634f8ccf5741386f260e778dfaccccd4a8ce7f2db44d0cf08d64599b701762f1869f782a821aae19be78a7f64ddf6fa737e9a720e2d7ef4

data/MIT-LICENSE

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

data/README.md

@@ -0,0 +1,63 @@
+# RubberDuck 🦆
+
+RubberDuck is a Rails engine that provides an AI-powered debugging assistant directly on your native Rails development error pages.
+When an error occurs, a rubber duck button is injected into the page.
+Clicking it sends error details including log lines and http error to an AI service and displays a contextualized explanation in a modal.
+
+Here's an example of the view it can generate currently
+![Alt text](app/assets/images/rubber_duck/v-0-example.png)
+
+
+## Usage
+- this gem runs automatically when a standard rails error page shows. No rails commands needed!
+
+> ⚠️ **Warning**
+>
+> Be aware that this gem uses your code and server logs to be sent to the AI model. Do not hardcode sensitive values such as tokens!!
+However, the gem will not run in production, only in development
+
+## Installation
+Add this line to your application's Gemfile:
+
+> ⚠️ **Warning**
+>
+> Add this to your development gems. It will not run in production environments!
+
+```ruby
+gem "rubber_duck"
+```
+
+And then execute:
+```ruby
+bundle install
+```
+
+Or install it yourself as:
+```ruby
+gem install rubber_duck
+```
+
+Run the install generator to create the initializer file:
+```ruby
+rails generate rubber_duck:install
+```
+
+## Configuration
+Before using the gem, you need to configure your AI service API key in the initializer file located at `config/initializers/rubber_duck.rb`.
+```ruby
+  config/initializers/rubber_duck.rb
+  RubberDuck.configure do |config|
+    # Set your OpenAI API key
+    config.openai_api_key = ENV['OPENAI_API_KEY']
+
+    # (Optional) Specify a different AI model to use.
+    config.model = 'gpt-4'
+  end
+```
+Ensure you have set the `OPENAI_API_KEY` environment variable in your development environment.
+
+## Contributing
+To be determined...
+
+## License
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,8 @@
+require "bundler/setup"
+
+APP_RAKEFILE = File.expand_path("test/dummy/Rakefile", __dir__)
+load "rails/tasks/engine.rake"
+
+load "rails/tasks/statistics.rake"
+
+require "bundler/gem_tasks"

data/app/assets/javascripts/rubber_duck/modal.js

@@ -0,0 +1,83 @@
+// force align button in DOM
+document.addEventListener("DOMContentLoaded", () => {
+  const h1 = document.querySelector("h1");
+  const duck = document.getElementById("rubber-duck-container");
+
+  if (!h1 || !duck) return;
+
+  h1.style.display = "flex";
+  h1.style.alignItems = "center";
+
+  h1.appendChild(duck);
+});
+
+// create modal & API call
+(function () {
+  // 1. Load Marked (Markdown) and Prism (Syntax Highlighting) libs
+  const libs = [
+    "https://cdn.jsdelivr.net/npm/marked/marked.min.js",
+    "https://cdn.jsdelivr.net/npm/prismjs@1.29.0/prism.min.js",
+    "https://cdn.jsdelivr.net/npm/prismjs@1.29.0/components/prism-ruby.min.js", // Support for Ruby
+  ];
+
+  libs.forEach((src) => {
+    const script = document.createElement("script");
+    script.src = src;
+    document.head.appendChild(script);
+  });
+
+  // 2. Load Prism CSS for the theme
+  const link = document.createElement("link");
+  link.rel = "stylesheet";
+  link.href =
+    "https://cdn.jsdelivr.net/npm/prismjs@1.29.0/themes/prism-tomorrow.min.css";
+  document.head.appendChild(link);
+
+  const button = document.getElementById("rubber-duck-button");
+  const modal = document.getElementById("rubber-duck-modal");
+  const overlay = document.getElementById("rubber-duck-overlay");
+  const closeBtn = document.getElementById("rubber-duck-close");
+  const content = document.getElementById("rubber-duck-content");
+
+  button.addEventListener("click", async () => {
+    modal.style.display = "block";
+    overlay.style.display = "block";
+    content.innerHTML = "Analyzing error... This may take a few seconds.";
+
+    try {
+      const response = await fetch("/rubber_duck/analyze_error", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(errorData),
+      });
+      const result = await response.json();
+
+      if (result.success) {
+        content.innerHTML = window.marked.parse(result.response);
+        setTimeout(() => {
+          if (window.Prism) {
+            window.Prism.highlightAllUnder(content);
+          }
+        }, 100);
+      } else {
+        content.innerHTML =
+          '<span style="color: #DC2626;">Error: ' +
+          (result.error || "Unknown error") +
+          "</span>";
+      }
+    } catch (error) {
+      content.innerHTML =
+        '<span style="color: #DC2626;">Failed to connect: ' +
+        error.message +
+        "</span>";
+    }
+  });
+
+  function closeModal() {
+    modal.style.display = "none";
+    overlay.style.display = "none";
+  }
+
+  closeBtn.addEventListener("click", closeModal);
+  overlay.addEventListener("click", closeModal);
+})();

data/app/assets/stylesheets/rubber_duck/application.css

@@ -0,0 +1,15 @@
+/*
+ * This is a manifest file that'll be compiled into application.css, which will include all the files
+ * listed below.
+ *
+ * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
+ * or any plugin's vendor/assets/stylesheets directory can be referenced here using a relative path.
+ *
+ * You're free to add application-wide styles to this file and they'll appear at the bottom of the
+ * compiled file so the styles you add here take precedence over styles defined in any other CSS/SCSS
+ * files in this directory. Styles in this file should be added after the last require_* statement.
+ * It is generally better to create a new file per style scope.
+ *
+ *= require_tree .
+ *= require_self
+ */

data/app/controllers/rubber_duck/application_controller.rb

@@ -0,0 +1,4 @@
+module RubberDuck
+  class ApplicationController < ActionController::Base
+  end
+end

data/app/controllers/rubber_duck/errors_controller.rb

@@ -0,0 +1,18 @@
+module RubberDuck
+  class ErrorsController < ApplicationController
+    skip_before_action :verify_authenticity_token, only: [:analyze]
+
+    def analyze
+      unless Rails.env.development?
+        return render json: { error: "Only available in development" }, status: :forbidden
+      end
+
+      result = AiService.analyze_error(
+          exception_message: params[:exception],
+          backtrace: params[:backtrace],
+          logs: params[:logs]
+        )
+      render json: result
+    end
+  end
+end

data/app/helpers/rubber_duck/application_helper.rb

@@ -0,0 +1,4 @@
+module RubberDuck
+  module ApplicationHelper
+  end
+end

data/app/helpers/rubber_duck/errors_helper.rb

@@ -0,0 +1,4 @@
+module RubberDuck
+  module ErrorsHelper
+  end
+end

data/app/jobs/rubber_duck/application_job.rb

@@ -0,0 +1,4 @@
+module RubberDuck
+  class ApplicationJob < ActiveJob::Base
+  end
+end

data/app/mailers/rubber_duck/application_mailer.rb

@@ -0,0 +1,6 @@
+module RubberDuck
+  class ApplicationMailer < ActionMailer::Base
+    default from: "from@example.com"
+    layout "mailer"
+  end
+end

data/app/models/rubber_duck/application_record.rb

@@ -0,0 +1,5 @@
+module RubberDuck
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+  end
+end

data/app/services/rubber_duck/ai_service.rb

@@ -0,0 +1,72 @@
+require "faraday"
+require "json"
+
+module RubberDuck
+  class AiService
+    class << self
+      def analyze_error(exception_message:, backtrace:, logs:)
+        return { error: "No API key configured" } unless RubberDuck.configuration.openai_api_key
+        prompt = build_prompt(exception_message, backtrace, logs)
+
+        begin
+          response = call_openai(prompt)
+          { success: true, response: response }
+        rescue => e
+          { success: false, error: e.message }
+        end
+      end
+
+      private
+
+      def build_prompt(exception, backtrace, logs)
+        <<~PROMPT
+          INSTRUCTIONS:
+          - Keep verbosity at the minimum.
+          - Keep your response concise and actionable.
+          - Always return every single code snippet inside triple backticks with a language tag.
+          - Do not add <ul> or <li> tags.
+          You are a helpful Ruby on Rails debugging assistant. A developer encountered this error:
+          ERROR: #{exception}
+          BACKTRACE:
+          #{backtrace&.first(10)&.join("\n") || "No backtrace available"}
+          RECENT LOGS:
+          #{logs || "No logs available"}
+          OBJECTIVE:
+          1. Explain what this error means in simple terms
+          2. Explain the HTTP error in simple terms if any available
+          3. Identify the likely causes
+          4. Suggest specific fixes
+        PROMPT
+      end
+
+      def call_openai(prompt)
+        conn = Faraday.new(url: "https://api.openai.com") do |f|
+          f.request :json
+          f.response :json
+          f.adapter Faraday.default_adapter
+        end
+        response = conn.post("/v1/responses") do |req|
+          req.headers["Authorization"] = "Bearer #{RubberDuck.configuration.openai_api_key}"
+          req.headers["Content-Type"] = "application/json"
+          req.body = {
+            model: RubberDuck.configuration.model || "gpt-5-nano",
+            input: prompt,
+            text: {
+            format: {
+              type: "text"
+            },
+            verbosity: "low"
+            },
+            reasoning: {
+              effort: "low"
+            }
+          }
+        end
+        ## debug output
+        # puts "======> OpenAI Response Body: #{response.body.inspect}"
+        ##
+        response.body.dig("output", 1, "content", 0, "text")
+      end
+    end
+  end
+end

data/app/views/layouts/rubber_duck/application.html.erb

@@ -0,0 +1,17 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Rubber duck</title>
+  <%= csrf_meta_tags %>
+  <%= csp_meta_tag %>
+
+  <%= yield :head %>
+
+  <%= stylesheet_link_tag    "rubber_duck/application", media: "all" %>
+</head>
+<body>
+
+<%= yield %>
+
+</body>
+</html>

data/app/views/rubber_duck/_button.html.erb

@@ -0,0 +1,11 @@
+<div id="rubber-duck-container" style="display: flex; margin-left: 20px;">
+  <button id="rubber-duck-button" style="background: #8f9cc9; color: white; border: none; padding: 8px 16px; border-radius: 6px; font-size: 14px; font-weight: 600; cursor: pointer; box-shadow: 0 4px 6px rgba(0,0,0,0.1);">
+    🦆 RubberDuck
+  </button>
+  <div id="rubber-duck-modal" style="display: none; position: fixed; top: 50%; left: 50%; transform: translate(-50%, -50%); background: white; padding: 24px; border-radius: 12px; box-shadow: 0 20px 25px rgba(0,0,0,0.2); max-width: 600px; max-height: 80vh; overflow-y: auto; z-index: 10001;">
+    <h3 style="margin: 0 0 16px 0; color: #1F2937;"><%= @model_name.capitalize %> Analysis</h3>
+    <div id="rubber-duck-content" style="color: #4B5563; line-height: 1.6;">Analyzing...</div>
+    <button id="rubber-duck-close" style="margin-top: 16px; background: #E5E7EB; color: #374151; border: none; padding: 8px 16px; border-radius: 6px; cursor: pointer;">Close</button>
+  </div>
+  <div id="rubber-duck-overlay" style="display: none; position: fixed; top: 0; left: 0; right: 0; bottom: 0; background: rgba(0,0,0,0.5); z-index: 10000;"></div>
+</div>

data/config/initializers/rubber_duck.rb

@@ -0,0 +1,13 @@
+RubberDuck.configure do |config|
+	# Get your API key from https://platform.openai.com
+	config.openai_api_key = ENV["OPENAI_API_KEY"]
+
+	# Model to use
+	config.model = "gpt-4o-mini"
+
+	# Enable/disable the helper
+	config.enabled = true
+
+	# Number of log lines to send to AI for context
+	config.log_lines = 50
+end

data/config/routes.rb

@@ -0,0 +1,3 @@
+RubberDuck::Engine.routes.draw do
+  post "/analyze_error", to: "errors#analyze"
+end

data/lib/generators/rubber_duck/install_generator.rb

@@ -0,0 +1,40 @@
+require "rails/generators"
+
+module RubberDuck
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      source_root File.expand_path("templates", __dir__)
+
+			def create_initializer_file
+				create_file "config/initializers/rubber_duck.rb", <<~CONTENT
+					RubberDuck.configure do |config|
+						# Get your API key from https://platform.openai.com
+						config.openai_api_key = ENV["OPENAI_API_KEY"]
+					
+						# Model to use
+						config.model = "gpt-5-nano"
+					
+						# Enable/disable the helper
+						config.enabled = true
+					
+						# Number of log lines to send to AI for context
+						config.log_lines = 50
+					end
+				CONTENT
+			end
+
+			def add_route
+				say "Adding engine mount point to routes.rb", :green
+				route "mount RubberDuck::Engine => '/rubber_duck'"
+			end
+
+			def show_instructions
+				say "\n✅ RubberDuck installed!", :green
+				say "\nNext steps:"
+				say "  1. Add OPENAI_API_KEY to your .env file"
+				say "  2. Restart your Rails server"
+				say "  3. Trigger an error and look for the 'Ask AI' button\n"
+			end
+    end
+  end
+end

data/lib/rubber_duck/configuration.rb

@@ -0,0 +1,26 @@
+module RubberDuck
+  class Configuration
+    attr_accessor :openai_api_key, :model, :enabled, :log_lines
+
+    def initialize
+      @openai_api_key = nil
+      @model = "gpt-5-nano"
+      @enabled = true
+      @log_lines = 50
+    end
+  end
+  class << self
+
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(configuration)
+    end
+
+    def reset_configuration!
+      @configuration = Configuration.new
+    end
+  end
+end

data/lib/rubber_duck/engine.rb

@@ -0,0 +1,13 @@
+require "rubber_duck/middleware"
+module RubberDuck
+  class Engine < ::Rails::Engine
+    isolate_namespace RubberDuck
+    # config.app_middleware.use RubberDuck::Middleware
+    config.app_middleware.insert_before ActionDispatch::ShowExceptions, RubberDuck::Middleware
+
+    # Middleware injects UI on error pages
+    # initializer "rubber_duck.middleware" do |app|
+    #   app.middleware.use RubberDuck::Middleware if Rails.env.development?
+    # end
+  end
+end

data/lib/rubber_duck/middleware.rb

@@ -0,0 +1,140 @@
+require "rack/utils"
+require "erb"
+
+module RubberDuck
+  class Middleware
+    def initialize(app)
+      @app = app
+      @model_name = RubberDuck.configuration.model
+    end
+
+    def call(env)
+      status, headers, response = @app.call(env)
+
+      # Debug logging
+      # Rails.logger.info "RubberDuck: status=#{status}, content_type=#{headers['Content-Type']}, dev=#{Rails.env.development?}, enabled=#{RubberDuck.configuration.enabled}"
+
+      # Only intercept in development mode
+      if should_inject?(env, status, headers)
+        # Rails.logger.info "RubberDuck: Replacing response with custom error page"
+        return inject_button_response(env, status, headers, response)
+      end
+
+      [ status, headers, response ]
+    end
+
+    private
+
+    def should_inject?(env, status, headers)
+      # Check if this is an error response
+      return false unless Rails.env.development?
+      return false unless RubberDuck.configuration.enabled
+      return false unless status >= 400
+
+      # ONLY inject if request for HTML
+      # accept_header = env["HTTP_ACCEPT"].to_s
+      # return false unless accept_header.include?("text/html")
+
+      # Ignore specific background noise
+      # path = env["PATH_INFO"].to_s
+      # return false if path.match?(/\.(ico|json|map|png|jpg|js|css)$/)
+
+      true
+    end
+
+    def inject_button_response(env, status, headers, response)
+      # Read original response body
+      original_body = ""
+      response.each { |part| original_body << part }
+      response.close if response.respond_to?(:close)
+
+      # Rails.logger.info "RubberDuck: Original body size: #{original_body.bytesize}"
+      # Rails.logger.info "RubberDuck: Has </body>?: #{original_body.include?('</body>')}"
+
+      # Don't inject if not HTML
+      unless original_body.include?('<html') || original_body.include?('</body>')
+        # Rails.logger.info "RubberDuck: Not HTML, skipping injection"
+        return [ status, headers, [ original_body ] ]
+      end
+
+      exception = env["action_dispatch.exception"]
+      modified_body = inject_button_into_html(original_body, exception, env, status)
+
+      # Rails.logger.info "RubberDuck: Modified body size: #{modified_body.bytesize}"
+      # Rails.logger.info "RubberDuck: Button injected?: #{modified_body.include?('rubber-duck-button')}"
+
+      headers["Content-Type"] = "text/html; charset=utf-8"
+      headers["Content-Length"] = modified_body.bytesize.to_s
+      headers["X-RubberDuck-Handled"] = "true"
+
+      [ status, headers, [ modified_body ] ]
+    end
+
+    def inject_button_into_html(html, exception, env, status)
+      gem_path = Gem.loaded_specs['rubber_duck'].full_gem_path
+      # button_html = ApplicationController.render(
+      #   partial: "rubber_duck/button",
+      #   locals: {
+      #     model_name: @model_name
+      #   }
+      # )
+      partial_path = File.join(gem_path, 'app/views/rubber_duck/_button.html.erb')
+      partial_content = File.read(partial_path)
+      button_html = ERB.new(partial_content).result(binding)
+
+      logs = capture_logs
+      error_data_script = build_error_data_script(exception, env, status, logs)
+
+      # Load JS from file
+      modal_js = File.read(File.join(gem_path, 'app/assets/javascripts/rubber_duck/modal.js'))
+
+      injection = <<~HTML
+        <div>
+          #{button_html}
+        </div>
+        <script>
+         #{error_data_script}
+         #{modal_js}
+        </script>
+      HTML
+
+      # Inject before </body> if exists, otherwise append
+      if html =~ /<\/header>/i
+        html.sub(/<\/header>/i, "#{injection}</header>")
+      else
+        html + injection
+      end
+    end
+
+    def build_error_data_script(exception, env, status, logs)
+      # Prepare the data object in Ruby
+      data = if exception
+        {
+          exception: exception.message,
+          backtrace: exception.backtrace&.first(10) || [],
+          logs: logs
+        }
+      else
+        {
+          status: status,
+          path: env["PATH_INFO"],
+          logs: logs
+        }
+      end
+
+      # Inject it as a single, globally accessible JSON object
+      <<~JS
+        window.errorData = #{data.to_json};
+      JS
+    end
+
+    def capture_logs
+      log_file = Rails.root.join("log", "development.log")
+      return "Logs not available" unless File.exist?(log_file)
+      lines = File.readlines(log_file).last(RubberDuck.configuration.log_lines)
+      lines.join
+    rescue => e
+      "Error reading logs: #{e.message}"
+    end
+  end
+end

data/lib/rubber_duck/version.rb

@@ -0,0 +1,3 @@
+module RubberDuck
+  VERSION = "0.1.0"
+end

data/lib/rubber_duck.rb

@@ -0,0 +1,8 @@
+require "rubber_duck/version"
+require "rubber_duck/configuration"
+require "rubber_duck/middleware"
+require "rubber_duck/engine"
+
+module RubberDuck
+  # Your code goes here...
+end

data/lib/tasks/rubber_duck_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :rubber_duck do
+#   # Task goes here
+# end

metadata

@@ -0,0 +1,123 @@
+--- !ruby/object:Gem::Specification
+name: rubber_duck
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Emmanuel Vernet
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '8.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 8.0.2.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '8.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 8.0.2.1
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: dotenv-rails
+  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: This gem allows the Rails developer to avoid switching context from Rails
+  error pages during development. When getting an error, you can send the error and
+  logs to an AI model of your choice and get a response to help you understand or
+  pin point the issue while avoiding copy pasting code or logs into an external AI
+  window. Perfect for those who prefer to code with minimal AI presence in their editor
+  of choice!
+email:
+- vernet.emmanuel@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- app/assets/images/rubber_duck/v-0-example.png
+- app/assets/javascripts/rubber_duck/modal.js
+- app/assets/stylesheets/rubber_duck/application.css
+- app/controllers/rubber_duck/application_controller.rb
+- app/controllers/rubber_duck/errors_controller.rb
+- app/helpers/rubber_duck/application_helper.rb
+- app/helpers/rubber_duck/errors_helper.rb
+- app/jobs/rubber_duck/application_job.rb
+- app/mailers/rubber_duck/application_mailer.rb
+- app/models/rubber_duck/application_record.rb
+- app/services/rubber_duck/ai_service.rb
+- app/views/layouts/rubber_duck/application.html.erb
+- app/views/rubber_duck/_button.html.erb
+- config/initializers/rubber_duck.rb
+- config/routes.rb
+- lib/generators/rubber_duck/install_generator.rb
+- lib/rubber_duck.rb
+- lib/rubber_duck/configuration.rb
+- lib/rubber_duck/engine.rb
+- lib/rubber_duck/middleware.rb
+- lib/rubber_duck/version.rb
+- lib/tasks/rubber_duck_tasks.rake
+homepage: https://github.com/EmmanuelVernet/rubber_duck
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/EmmanuelVernet/rubber_duck
+  source_code_uri: https://github.com/EmmanuelVernet/rubber_duck
+  changelog_uri: https://github.com/EmmanuelVernet/rubber_duck/releases
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: RubberDuck is a Developer error helper gem to help you analyze errors with
+  AI in Rails
+test_files: []