copy_for_ai 0.1.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e41927310321363d9badd434462197ae4fd62a28d705bbc851bcdd5e4be9f521
+  data.tar.gz: 623374e6bb274dd721ac42b6d3ed129ffe17024afc68eb8560d784744b3c23c0
+SHA512:
+  metadata.gz: 6a551348845665088b0d2f4ecd758f38b83b74be9eb5e04021ca35ddc84632018a95eb70f3181d82bd1f418a794dd0953cb115acd597724b398609fc71f4566f
+  data.tar.gz: 810b4cf6c62442ff27c0d9a959ce41876102de321b7d695a866a3f3bd485098cdc6fe228a85df0f90c2c29e9cef9b4a6ae0a653234859d7f8e80f01d2a5c9ff8

data/CHANGELOG.md

@@ -0,0 +1,26 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.1.4] - 2024-12-29
+
+### Added
+- Initial release
+- "Copy for AI" button on Rails development error pages
+- Copies error details as formatted Markdown
+- Includes error type, message, source code, stack traces, and request info
+- Compatible with Rails 7.0+ and 8.0+
+- Styled to match Rails error page aesthetics
+- Clipboard API with fallback for older browsers
+
+### Technical Details
+- Middleware-based injection (inserted before ActionDispatch::DebugExceptions)
+- Automatic detection of Rails debug error pages
+- Multiple fallback strategies for button placement
+- Development-only activation
+

data/LICENSE.txt

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 Andrew Miller
+
+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,124 @@
+# Copy for AI
+
+A Rails gem that adds a **"Copy for AI"** button to development error pages, allowing you to copy error details as formatted Markdown optimized for AI agent consumption.
+
+## Features
+
+- Adds a styled button to Rails development error pages
+- Extracts comprehensive error information:
+  - Error type and message
+  - Source code with file and line number
+  - Application stack trace
+  - Full stack trace
+  - Request details and parameters
+- Formats output as clean Markdown for easy LLM parsing
+- Zero configuration required
+- Only active in development environment
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+group :development do
+  gem 'copy_for_ai'
+end
+```
+
+And then execute:
+
+```bash
+bundle install
+```
+
+That's it! The gem automatically hooks into Rails and adds the button to error pages.
+
+## Usage
+
+1. When your Rails app encounters an error in development, you'll see the standard Rails error page
+2. Look for the **"Copy for AI"** button in the header area (near the trace toggle buttons)
+3. Click the button to copy all error details to your clipboard
+4. Paste the Markdown into your AI assistant of choice
+
+### Example Output
+
+When you click "Copy for AI", you'll get formatted Markdown like this:
+
+```markdown
+# Rails Error: NoMethodError
+
+## Error Message
+
+undefined method `foo' for nil:NilClass
+
+## Source Code
+
+**File:** `app/controllers/users_controller.rb`
+**Line:** 15
+
+​```ruby
+  def show
+    @user = User.find(params[:id])
+    @user.foo  # Error occurs here
+  end
+​```
+
+## Application Trace
+
+​```
+app/controllers/users_controller.rb:15:in `show'
+​```
+
+## Full Trace
+
+​```
+app/controllers/users_controller.rb:15:in `show'
+actionpack (7.0.0) lib/action_controller/metal/basic_implicit_render.rb:6:in `send_action'
+...
+​```
+
+## Request Details
+
+- **URL:** /users/1
+- **Method:** GET
+- **Parameters:**
+​```
+{"id"=>"1"}
+​```
+```
+
+## Configuration
+
+Currently, the gem works out of the box with no configuration needed. It automatically:
+
+- Detects Rails development environment
+- Identifies Rails error pages
+- Injects the copy button with appropriate styling
+
+## Requirements
+
+- Ruby >= 2.7.0
+- Rails 7.0+ or Rails 8.0+
+
+**Tested with:**
+- Rails 7.0, 7.1, 7.2
+- Rails 8.0
+
+## Development
+
+After checking out the repo, run `bundle install` to install dependencies.
+
+To install this gem onto your local machine, run:
+
+```bash
+bundle exec rake install
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+

data/lib/copy_for_ai/content_injector.rb

@@ -0,0 +1,366 @@
+# frozen_string_literal: true
+
+module CopyForAi
+  class ContentInjector
+    BUTTON_AND_SCRIPT = <<~HTML
+      <style>
+        .copy-for-ai-btn {
+          background: none;
+          color: #CC0000;
+          padding: 0;
+          cursor: pointer;
+          border: none;
+          font-family: inherit;
+          font-size: inherit;
+          text-decoration: underline;
+          display: inline;
+          transition: color 0.15s ease;
+        }
+        .copy-for-ai-btn:hover {
+          color: #990000;
+        }
+        .copy-for-ai-btn.copied {
+          color: #00AA00;
+        }
+        .copy-for-ai-floating {
+          position: fixed;
+          top: 10px;
+          right: 10px;
+          z-index: 99999;
+          background: #CC0000;
+          color: #fff;
+          padding: 8px 16px;
+          font-size: 14px;
+          border-radius: 4px;
+          box-shadow: 0 2px 8px rgba(0,0,0,0.3);
+          text-decoration: none;
+        }
+        .copy-for-ai-floating:hover {
+          background: #990000;
+        }
+        .copy-for-ai-floating.copied {
+          background: #00AA00;
+          color: #fff;
+        }
+      </style>
+      <script>
+        (function() {
+          function initCopyForAi() {
+            // Create the button
+            var btn = document.createElement('button');
+            btn.className = 'copy-for-ai-btn';
+            btn.textContent = 'Copy for AI';
+            btn.title = 'Copy error details as Markdown for AI agents';
+
+            var inserted = false;
+
+            // Strategy 1: Find the trace links and insert after the last one
+            var traceLinks = document.querySelectorAll('a');
+            var lastTraceLink = null;
+
+            for (var i = 0; i < traceLinks.length; i++) {
+              var link = traceLinks[i];
+              var text = link.textContent.toLowerCase();
+              if (text.includes('application trace') || text.includes('framework trace') || text.includes('full trace')) {
+                lastTraceLink = link;
+              }
+            }
+
+            if (lastTraceLink) {
+              // Insert right after the last trace link as a sibling
+              var separator = document.createTextNode(' | ');
+              lastTraceLink.parentNode.insertBefore(separator, lastTraceLink.nextSibling);
+              lastTraceLink.parentNode.insertBefore(btn, separator.nextSibling);
+              inserted = true;
+            }
+
+            // Strategy 2: Look for header with Rails.root info
+            if (!inserted) {
+              var allText = document.body.innerText;
+              if (allText.includes('Rails.root:')) {
+                // Find the element containing Rails.root
+                var walker = document.createTreeWalker(document.body, NodeFilter.SHOW_TEXT, null, false);
+                while (walker.nextNode()) {
+                  if (walker.currentNode.textContent.includes('Rails.root:')) {
+                    var parent = walker.currentNode.parentElement;
+                    if (parent) {
+                      parent.parentElement.insertBefore(btn, parent.nextSibling);
+                      inserted = true;
+                      break;
+                    }
+                  }
+                }
+              }
+            }
+
+            // Strategy 3: Insert after h1 or h2
+            if (!inserted) {
+              var h2 = document.querySelector('h2');
+              if (h2 && h2.parentElement) {
+                h2.parentElement.insertBefore(btn, h2.nextSibling);
+                inserted = true;
+              }
+            }
+
+            // Strategy 4: Floating button as fallback
+            if (!inserted) {
+              btn.classList.add('copy-for-ai-floating');
+              document.body.appendChild(btn);
+            }
+
+            btn.addEventListener('click', function(e) {
+              e.preventDefault();
+              var markdown = extractErrorAsMarkdown();
+              copyToClipboard(markdown, btn);
+            });
+          }
+
+          function extractErrorAsMarkdown() {
+            var lines = [];
+
+            // Extract error type from h1
+            var h1 = document.querySelector('h1');
+            var errorType = h1 ? h1.textContent.trim() : 'Unknown Error';
+
+            // Extract error message from h2
+            var h2 = document.querySelector('h2');
+            var errorMessage = h2 ? h2.textContent.trim() : '';
+
+            lines.push('# Rails Error: ' + errorType);
+            lines.push('');
+            if (errorMessage) {
+              lines.push('## Error Message');
+              lines.push('');
+              lines.push(errorMessage);
+              lines.push('');
+            }
+
+            // Extract Rails.root info
+            var bodyText = document.body.innerText;
+            var railsRootMatch = bodyText.match(/Rails\\.root:\\s*([^\\n]+)/);
+            if (railsRootMatch) {
+              lines.push('**Rails.root:** `' + railsRootMatch[1].trim() + '`');
+              lines.push('');
+            }
+
+            // Extract source code sections
+            var sourceInfo = extractSourceCode();
+            if (sourceInfo) {
+              lines.push('## Source Code');
+              lines.push('');
+              if (sourceInfo.file) {
+                lines.push('**File:** `' + sourceInfo.file + '`');
+              }
+              if (sourceInfo.line) {
+                lines.push('**Line:** ' + sourceInfo.line);
+              }
+              lines.push('');
+              if (sourceInfo.code) {
+                lines.push('```ruby');
+                lines.push(sourceInfo.code);
+                lines.push('```');
+                lines.push('');
+              }
+            }
+
+            // Extract traces
+            var traces = extractAllTraces();
+            if (traces.application) {
+              lines.push('## Application Trace');
+              lines.push('');
+              lines.push('```');
+              lines.push(traces.application);
+              lines.push('```');
+              lines.push('');
+            }
+            if (traces.framework) {
+              lines.push('## Framework Trace');
+              lines.push('');
+              lines.push('```');
+              lines.push(traces.framework);
+              lines.push('```');
+              lines.push('');
+            }
+            if (traces.full) {
+              lines.push('## Full Trace');
+              lines.push('');
+              lines.push('```');
+              lines.push(traces.full);
+              lines.push('```');
+              lines.push('');
+            }
+
+            // Extract Routes section if present (for routing errors)
+            var routesSection = extractRoutes();
+            if (routesSection) {
+              lines.push('## Available Routes');
+              lines.push('');
+              lines.push('```');
+              lines.push(routesSection);
+              lines.push('```');
+              lines.push('');
+            }
+
+            return lines.join('\\n');
+          }
+
+          function extractSourceCode() {
+            var result = {};
+
+            // Look for source extract divs
+            var sourceExtracts = document.querySelectorAll('[id*="source"], [class*="source"], .extract');
+            for (var i = 0; i < sourceExtracts.length; i++) {
+              var section = sourceExtracts[i];
+
+              // Look for file info
+              var headerText = '';
+              var headers = section.querySelectorAll('h4, h5, .info, [class*="file"]');
+              if (headers.length > 0) {
+                headerText = headers[0].textContent.trim();
+                var match = headerText.match(/([^:]+\\.rb):?(\\d+)?/);
+                if (match) {
+                  result.file = match[1].trim();
+                  if (match[2]) result.line = match[2];
+                }
+              }
+
+              // Look for code
+              var code = section.querySelector('pre, code, .code');
+              if (code) {
+                result.code = code.textContent.trim();
+                break;
+              }
+            }
+
+            return (result.code || result.file) ? result : null;
+          }
+
+          function extractAllTraces() {
+            var traces = {
+              application: null,
+              framework: null,
+              full: null
+            };
+
+            // Look for trace divs by ID
+            var appTrace = document.querySelector('#Application-Trace, #application-trace, [id*="Application"][id*="Trace"]');
+            var frameworkTrace = document.querySelector('#Framework-Trace, #framework-trace, [id*="Framework"][id*="Trace"]');
+            var fullTrace = document.querySelector('#Full-Trace, #full-trace, [id*="Full"][id*="Trace"]');
+
+            if (appTrace) {
+              var pre = appTrace.querySelector('pre, code');
+              if (pre) traces.application = pre.textContent.trim();
+            }
+            if (frameworkTrace) {
+              var pre = frameworkTrace.querySelector('pre, code');
+              if (pre) traces.framework = pre.textContent.trim();
+            }
+            if (fullTrace) {
+              var pre = fullTrace.querySelector('pre, code');
+              if (pre) traces.full = pre.textContent.trim();
+            }
+
+            // Fallback: look for any trace-related content
+            if (!traces.application && !traces.framework && !traces.full) {
+              var allPres = document.querySelectorAll('pre');
+              for (var i = 0; i < allPres.length; i++) {
+                var pre = allPres[i];
+                var text = pre.textContent;
+                // Check if it looks like a stack trace
+                if (text.includes(':in `') || text.includes('.rb:')) {
+                  if (!traces.full) {
+                    traces.full = text.trim();
+                  }
+                }
+              }
+            }
+
+            return traces;
+          }
+
+          function extractRoutes() {
+            // For routing errors, extract available routes
+            var routesTable = document.querySelector('table');
+            if (routesTable) {
+              var rows = routesTable.querySelectorAll('tr');
+              if (rows.length > 0) {
+                var routeLines = [];
+                rows.forEach(function(row) {
+                  var cells = row.querySelectorAll('th, td');
+                  if (cells.length >= 3) {
+                    routeLines.push(
+                      (cells[0].textContent.trim().padEnd(10) + ' ') +
+                      (cells[1].textContent.trim().padEnd(40) + ' ') +
+                      cells[2].textContent.trim()
+                    );
+                  }
+                });
+                if (routeLines.length > 1) { // More than just header
+                  return routeLines.slice(0, 20).join('\\n') + (rows.length > 20 ? '\\n... and more' : '');
+                }
+              }
+            }
+            return null;
+          }
+
+          function copyToClipboard(text, btn) {
+            if (navigator.clipboard && navigator.clipboard.writeText) {
+              navigator.clipboard.writeText(text).then(function() {
+                showCopiedFeedback(btn);
+              }).catch(function(err) {
+                fallbackCopy(text, btn);
+              });
+            } else {
+              fallbackCopy(text, btn);
+            }
+          }
+
+          function fallbackCopy(text, btn) {
+            var textarea = document.createElement('textarea');
+            textarea.value = text;
+            textarea.style.position = 'fixed';
+            textarea.style.left = '-9999px';
+            document.body.appendChild(textarea);
+            textarea.select();
+            try {
+              document.execCommand('copy');
+              showCopiedFeedback(btn);
+            } catch (err) {
+              alert('Failed to copy. Error details:\\n\\n' + text.substring(0, 1000));
+            }
+            document.body.removeChild(textarea);
+          }
+
+          function showCopiedFeedback(btn) {
+            var originalText = btn.textContent;
+            btn.textContent = 'Copied!';
+            btn.classList.add('copied');
+            setTimeout(function() {
+              btn.textContent = originalText;
+              btn.classList.remove('copied');
+            }, 2000);
+          }
+
+          // Initialize when DOM is ready
+          if (document.readyState === 'loading') {
+            document.addEventListener('DOMContentLoaded', initCopyForAi);
+          } else {
+            initCopyForAi();
+          }
+        })();
+      </script>
+    HTML
+
+    class << self
+      def inject(html)
+        # Inject before closing </body> tag
+        if html.include?("</body>")
+          html.sub("</body>", "#{BUTTON_AND_SCRIPT}</body>")
+        else
+          # If no body tag, append to end
+          html + BUTTON_AND_SCRIPT
+        end
+      end
+    end
+  end
+end

data/lib/copy_for_ai/middleware.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require_relative "content_injector"
+
+module CopyForAi
+  class Middleware
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      status, headers, response = @app.call(env)
+
+      # Only modify error responses (4xx and 5xx) with HTML content
+      if error_response?(status) && html_response?(headers)
+        body = extract_body(response)
+
+        # Check if this is a Rails debug error page
+        if rails_error_page?(body)
+          modified_body = ContentInjector.inject(body)
+          headers["Content-Length"] = modified_body.bytesize.to_s
+          response = [modified_body]
+        end
+      end
+
+      [status, headers, response]
+    end
+
+    private
+
+    def error_response?(status)
+      status >= 400 && status < 600
+    end
+
+    def html_response?(headers)
+      content_type = headers["Content-Type"] || headers["content-type"] || ""
+      content_type.include?("text/html")
+    end
+
+    def extract_body(response)
+      body = +""
+      response.each { |part| body << part }
+      response.close if response.respond_to?(:close)
+      body
+    end
+
+    def rails_error_page?(body)
+      # Check for Rails debug error page markers - be more flexible
+      # Rails 7+ uses different markers than older versions
+      has_trace_links = body.include?("Application Trace") ||
+                        body.include?("Framework Trace") ||
+                        body.include?("Full Trace") ||
+                        body.include?("Full trace")
+
+      has_error_markers = body.include?("Rails.root:") ||
+                          body.include?("ActionController::RoutingError") ||
+                          body.include?("id=\"container\"") ||
+                          body.include?("id=\"traces\"")
+
+      has_trace_links && has_error_markers
+    end
+  end
+end

data/lib/copy_for_ai/railtie.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative "middleware"
+
+module CopyForAi
+  class Railtie < Rails::Railtie
+    initializer "copy_for_ai.add_middleware", after: :load_config_initializers do |app|
+      # Only add middleware in development environment
+      if Rails.env.development?
+        # Insert BEFORE DebugExceptions so we can see the error page response
+        # that DebugExceptions generates
+        begin
+          app.middleware.insert_before ActionDispatch::DebugExceptions, CopyForAi::Middleware
+        rescue
+          # Fallback: insert at the beginning
+          app.middleware.insert 0, CopyForAi::Middleware
+        end
+      end
+    end
+  end
+end

data/lib/copy_for_ai/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module CopyForAi
+  VERSION = "0.1.4"
+end

data/lib/copy_for_ai.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require_relative "copy_for_ai/version"
+require_relative "copy_for_ai/railtie" if defined?(Rails::Railtie)
+
+module CopyForAi
+  class Error < StandardError; end
+end

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification
+name: copy_for_ai
+version: !ruby/object:Gem::Version
+  version: 0.1.4
+platform: ruby
+authors:
+- Andrew Miller
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2025-12-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+- !ruby/object:Gem::Dependency
+  name: actionpack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+description: A Rails gem that adds a 'Copy for AI' button to development error pages,
+  allowing you to copy error details as formatted Markdown for easy consumption by
+  AI agents.
+email:
+- andrew@example.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- lib/copy_for_ai.rb
+- lib/copy_for_ai/content_injector.rb
+- lib/copy_for_ai/middleware.rb
+- lib/copy_for_ai/railtie.rb
+- lib/copy_for_ai/version.rb
+homepage: https://github.com/andrewmiller/copy_for_ai
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/andrewmiller/copy_for_ai
+  source_code_uri: https://github.com/andrewmiller/copy_for_ai
+  changelog_uri: https://github.com/andrewmiller/copy_for_ai/blob/main/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.9
+signing_key:
+specification_version: 4
+summary: Copy Rails error messages in AI-friendly format
+test_files: []