copy_for_ai 0.1.4 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e41927310321363d9badd434462197ae4fd62a28d705bbc851bcdd5e4be9f521
-  data.tar.gz: 623374e6bb274dd721ac42b6d3ed129ffe17024afc68eb8560d784744b3c23c0
+  metadata.gz: 609491e473023a0d9d124026197d92c931c6b69c53d9ee66eecdb1364bd42157
+  data.tar.gz: 344352c8e5cfd6c80859ddacf088e173793067665f7f40bddb135718c20675b8
 SHA512:
-  metadata.gz: 6a551348845665088b0d2f4ecd758f38b83b74be9eb5e04021ca35ddc84632018a95eb70f3181d82bd1f418a794dd0953cb115acd597724b398609fc71f4566f
-  data.tar.gz: 810b4cf6c62442ff27c0d9a959ce41876102de321b7d695a866a3f3bd485098cdc6fe228a85df0f90c2c29e9cef9b4a6ae0a653234859d7f8e80f01d2a5c9ff8
+  metadata.gz: b147e890cd27790effdf054f3f30821dd221c6e830b66d8313270d15a1262bc0e514bd130a77e8c09bd5e91695163e2f717bd4d9cad06b9b6d46698f5f06efd0
+  data.tar.gz: 733e82ba8e9bbdc43226544a68b3f2dc566c6bb74f8626cb7d6caf902f7fd6949282e3c0f189ba53a27e65d8b8096848e86e3f7f73f1423a7cf90c2f29af000d

data/CHANGELOG.md

@@ -7,6 +7,21 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.2.0] - 2024-12-29
+
+### Added
+- **Format selector**: Choose between TOON, Markdown, or Plaintext output formats
+- **TOON format** (default): Token-efficient format optimized for LLM consumption
+  - Based on [TOON specification](https://github.com/toon-format/toon)
+  - Reduces token usage compared to Markdown
+- **Markdown format**: Rich formatting with headers and code blocks
+- **Plaintext format**: Simple text output for maximum compatibility
+- Format preference persisted in localStorage
+
+### Changed
+- Default output format changed from Markdown to TOON
+- Refactored JavaScript to use structured error data extraction
+
 ## [0.1.4] - 2024-12-29
 
 ### Added

data/README.md

@@ -1,17 +1,18 @@
 # 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.
+A Rails gem that adds a **"Copy for AI"** button to development error pages, allowing you to copy error details in formats optimized for AI agent consumption.
 
 ## Features
 
 - Adds a styled button to Rails development error pages
+- **Multiple output formats**: TOON (default), Markdown, or Plaintext
 - 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
+  - Available routes (for routing errors)
+- Format preference saved in localStorage
 - Zero configuration required
 - Only active in development environment
 
@@ -36,64 +37,77 @@ That's it! The gem automatically hooks into Rails and adds the button to error p
 ## 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
+2. Look for the **"Copy for AI"** button next to the trace toggle links
+3. Select your preferred format from the dropdown (TOON, MD, or TXT)
+4. Click the button to copy all error details to your clipboard
+5. Paste into your AI assistant of choice
 
-### Example Output
+## Output Formats
 
-When you click "Copy for AI", you'll get formatted Markdown like this:
+### TOON (Default)
 
-```markdown
-# Rails Error: NoMethodError
+[TOON](https://github.com/toon-format/toon) (Token-Oriented Object Notation) is a compact, human-readable format designed for LLM prompts. It reduces token usage while remaining easy to parse.
 
-## Error Message
+```
+error_type: Routing Error
+error_message: "No route matches [GET] \\"/asdf\\""
+rails_root: /Users/dev/myapp
 
-undefined method `foo' for nil:NilClass
+application_trace:
+  app/controllers/users_controller.rb:15:in `show'
 
-## Source Code
+full_trace:
+  app/controllers/users_controller.rb:15:in `show'
+  actionpack (7.0.0) lib/action_controller/metal/basic_implicit_render.rb:6
+```
+
+### Markdown
 
-**File:** `app/controllers/users_controller.rb`
-**Line:** 15
+Rich formatting with headers and code blocks:
 
-​```ruby
-  def show
-    @user = User.find(params[:id])
-    @user.foo  # Error occurs here
-  end
-​```
+```markdown
+# Rails Error: Routing Error
+
+## Error Message
+
+No route matches [GET] "/asdf"
+
+**Rails.root:** `/Users/dev/myapp`
 
 ## Application Trace
 
-​```
+\`\`\`
 app/controllers/users_controller.rb:15:in `show'
-​```
+\`\`\`
+```
 
-## Full Trace
+### Plaintext
 
-​```
+Simple text format for maximum compatibility:
+
+```
+RAILS ERROR: Routing Error
+==================================================
+
+ERROR MESSAGE:
+No route matches [GET] "/asdf"
+
+RAILS ROOT: /Users/dev/myapp
+
+APPLICATION 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
+## Why TOON?
+
+TOON format offers significant token savings compared to Markdown while remaining human-readable and easy for LLMs to parse. This means:
 
-Currently, the gem works out of the box with no configuration needed. It automatically:
+- **Lower API costs** when using paid LLM APIs
+- **More context** can fit in the same token window
+- **Faster responses** due to reduced input size
 
-- Detects Rails development environment
-- Identifies Rails error pages
-- Injects the copy button with appropriate styling
+Learn more at [toonformat.dev](https://toonformat.dev).
 
 ## Requirements
 
@@ -108,6 +122,12 @@ Currently, the gem works out of the box with no configuration needed. It automat
 
 After checking out the repo, run `bundle install` to install dependencies.
 
+Run the test suite:
+
+```bash
+bundle exec rspec
+```
+
 To install this gem onto your local machine, run:
 
 ```bash
@@ -121,4 +141,3 @@ 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

@@ -4,6 +4,9 @@ module CopyForAi
   class ContentInjector
     BUTTON_AND_SCRIPT = <<~HTML
       <style>
+        .copy-for-ai-container {
+          display: inline;
+        }
         .copy-for-ai-btn {
           background: none;
           color: #CC0000;
@@ -22,35 +25,97 @@ module CopyForAi
         .copy-for-ai-btn.copied {
           color: #00AA00;
         }
+        .copy-for-ai-format-select {
+          background: #333;
+          color: #CC0000;
+          border: 1px solid #555;
+          border-radius: 3px;
+          padding: 1px 4px;
+          font-size: 11px;
+          font-family: inherit;
+          cursor: pointer;
+          margin-left: 4px;
+          vertical-align: baseline;
+        }
+        .copy-for-ai-format-select:hover {
+          border-color: #CC0000;
+        }
+        .copy-for-ai-format-select:focus {
+          outline: none;
+          border-color: #CC0000;
+        }
         .copy-for-ai-floating {
           position: fixed;
           top: 10px;
           right: 10px;
           z-index: 99999;
-          background: #CC0000;
-          color: #fff;
-          padding: 8px 16px;
-          font-size: 14px;
+          background: #222;
+          padding: 8px 12px;
           border-radius: 4px;
           box-shadow: 0 2px 8px rgba(0,0,0,0.3);
+        }
+        .copy-for-ai-floating .copy-for-ai-btn {
+          background: #CC0000;
+          color: #fff;
+          padding: 4px 12px;
+          border-radius: 3px;
           text-decoration: none;
         }
-        .copy-for-ai-floating:hover {
+        .copy-for-ai-floating .copy-for-ai-btn:hover {
           background: #990000;
+          color: #fff;
         }
-        .copy-for-ai-floating.copied {
+        .copy-for-ai-floating .copy-for-ai-btn.copied {
           background: #00AA00;
-          color: #fff;
+        }
+        .copy-for-ai-floating .copy-for-ai-format-select {
+          background: #444;
+          margin-left: 8px;
         }
       </style>
       <script>
         (function() {
+          var currentFormat = localStorage.getItem('copyForAiFormat') || 'toon';
+
           function initCopyForAi() {
+            // Create container
+            var container = document.createElement('span');
+            container.className = 'copy-for-ai-container';
+
             // 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';
+            btn.title = 'Copy error details for AI agents';
+
+            // Create format selector
+            var select = document.createElement('select');
+            select.className = 'copy-for-ai-format-select';
+            select.title = 'Select output format';
+
+            var formats = [
+              { value: 'toon', label: 'TOON' },
+              { value: 'markdown', label: 'MD' },
+              { value: 'plaintext', label: 'TXT' }
+            ];
+
+            formats.forEach(function(fmt) {
+              var option = document.createElement('option');
+              option.value = fmt.value;
+              option.textContent = fmt.label;
+              if (fmt.value === currentFormat) {
+                option.selected = true;
+              }
+              select.appendChild(option);
+            });
+
+            select.addEventListener('change', function() {
+              currentFormat = select.value;
+              localStorage.setItem('copyForAiFormat', currentFormat);
+            });
+
+            container.appendChild(btn);
+            container.appendChild(select);
 
             var inserted = false;
 
@@ -67,10 +132,9 @@ module CopyForAi
             }
 
             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);
+              lastTraceLink.parentNode.insertBefore(container, separator.nextSibling);
               inserted = true;
             }
 
@@ -78,13 +142,12 @@ module CopyForAi
             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);
+                      parent.parentElement.insertBefore(container, parent.nextSibling);
                       inserted = true;
                       break;
                     }
@@ -93,110 +156,233 @@ module CopyForAi
               }
             }
 
-            // Strategy 3: Insert after h1 or h2
+            // Strategy 3: Insert after h2
             if (!inserted) {
               var h2 = document.querySelector('h2');
               if (h2 && h2.parentElement) {
-                h2.parentElement.insertBefore(btn, h2.nextSibling);
+                h2.parentElement.insertBefore(container, h2.nextSibling);
                 inserted = true;
               }
             }
 
-            // Strategy 4: Floating button as fallback
+            // Strategy 4: Floating container as fallback
             if (!inserted) {
-              btn.classList.add('copy-for-ai-floating');
-              document.body.appendChild(btn);
+              container.classList.add('copy-for-ai-floating');
+              document.body.appendChild(container);
             }
 
             btn.addEventListener('click', function(e) {
               e.preventDefault();
-              var markdown = extractErrorAsMarkdown();
-              copyToClipboard(markdown, btn);
+              var errorData = extractErrorData();
+              var output;
+
+              switch (currentFormat) {
+                case 'toon':
+                  output = formatAsToon(errorData);
+                  break;
+                case 'markdown':
+                  output = formatAsMarkdown(errorData);
+                  break;
+                case 'plaintext':
+                  output = formatAsPlaintext(errorData);
+                  break;
+                default:
+                  output = formatAsToon(errorData);
+              }
+
+              copyToClipboard(output, btn);
             });
           }
 
-          function extractErrorAsMarkdown() {
-            var lines = [];
+          function extractErrorData() {
+            var data = {
+              errorType: '',
+              errorMessage: '',
+              railsRoot: '',
+              source: null,
+              traces: { application: null, framework: null, full: null },
+              routes: null
+            };
 
             // Extract error type from h1
             var h1 = document.querySelector('h1');
-            var errorType = h1 ? h1.textContent.trim() : 'Unknown Error';
+            data.errorType = h1 ? h1.textContent.trim() : 'Unknown Error';
 
             // Extract error message from h2
             var h2 = document.querySelector('h2');
-            var errorMessage = h2 ? h2.textContent.trim() : '';
+            data.errorMessage = h2 ? h2.textContent.trim() : '';
+
+            // Extract Rails.root info
+            var bodyText = document.body.innerText;
+            var railsRootMatch = bodyText.match(/Rails\\.root:\\s*([^\\n]+)/);
+            if (railsRootMatch) {
+              data.railsRoot = railsRootMatch[1].trim();
+            }
+
+            // Extract source code
+            data.source = extractSourceCode();
+
+            // Extract traces
+            data.traces = extractAllTraces();
+
+            // Extract routes
+            data.routes = extractRoutes();
+
+            return data;
+          }
+
+          // ===== TOON FORMAT =====
+          function formatAsToon(data) {
+            var lines = [];
+
+            // Error info as simple key-value pairs
+            lines.push('error_type: ' + data.errorType);
+            if (data.errorMessage) {
+              lines.push('error_message: ' + escapeForToon(data.errorMessage));
+            }
+            if (data.railsRoot) {
+              lines.push('rails_root: ' + data.railsRoot);
+            }
+
+            // Source code
+            if (data.source) {
+              lines.push('');
+              lines.push('source:');
+              if (data.source.file) {
+                lines.push('  file: ' + data.source.file);
+              }
+              if (data.source.line) {
+                lines.push('  line: ' + data.source.line);
+              }
+              if (data.source.code) {
+                lines.push('  code: |');
+                data.source.code.split('\\n').forEach(function(codeLine) {
+                  lines.push('    ' + codeLine);
+                });
+              }
+            }
+
+            // Traces - use compact array notation
+            if (data.traces.application) {
+              lines.push('');
+              lines.push('application_trace:');
+              formatTraceForToon(data.traces.application).forEach(function(t) {
+                lines.push('  ' + t);
+              });
+            }
+            if (data.traces.framework) {
+              lines.push('');
+              lines.push('framework_trace:');
+              formatTraceForToon(data.traces.framework).forEach(function(t) {
+                lines.push('  ' + t);
+              });
+            }
+            if (data.traces.full) {
+              lines.push('');
+              lines.push('full_trace:');
+              formatTraceForToon(data.traces.full).forEach(function(t) {
+                lines.push('  ' + t);
+              });
+            }
+
+            // Routes
+            if (data.routes) {
+              lines.push('');
+              lines.push('available_routes:');
+              data.routes.split('\\n').slice(0, 15).forEach(function(route) {
+                lines.push('  ' + route.trim());
+              });
+            }
 
-            lines.push('# Rails Error: ' + errorType);
+            return lines.join('\\n');
+          }
+
+          function formatTraceForToon(trace) {
+            if (!trace) return [];
+            return trace.split('\\n').slice(0, 25).map(function(line) {
+              return line.trim();
+            }).filter(function(line) {
+              return line.length > 0;
+            });
+          }
+
+          function escapeForToon(str) {
+            // If string contains special chars, wrap in quotes
+            if (str.includes('\\n') || str.includes(':') || str.includes('"')) {
+              return '"' + str.replace(/"/g, '\\\\"').replace(/\\n/g, ' ') + '"';
+            }
+            return str;
+          }
+
+          // ===== MARKDOWN FORMAT =====
+          function formatAsMarkdown(data) {
+            var lines = [];
+
+            lines.push('# Rails Error: ' + data.errorType);
             lines.push('');
-            if (errorMessage) {
+
+            if (data.errorMessage) {
               lines.push('## Error Message');
               lines.push('');
-              lines.push(errorMessage);
+              lines.push(data.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() + '`');
+            if (data.railsRoot) {
+              lines.push('**Rails.root:** `' + data.railsRoot + '`');
               lines.push('');
             }
 
-            // Extract source code sections
-            var sourceInfo = extractSourceCode();
-            if (sourceInfo) {
+            if (data.source) {
               lines.push('## Source Code');
               lines.push('');
-              if (sourceInfo.file) {
-                lines.push('**File:** `' + sourceInfo.file + '`');
+              if (data.source.file) {
+                lines.push('**File:** `' + data.source.file + '`');
               }
-              if (sourceInfo.line) {
-                lines.push('**Line:** ' + sourceInfo.line);
+              if (data.source.line) {
+                lines.push('**Line:** ' + data.source.line);
               }
               lines.push('');
-              if (sourceInfo.code) {
+              if (data.source.code) {
                 lines.push('```ruby');
-                lines.push(sourceInfo.code);
+                lines.push(data.source.code);
                 lines.push('```');
                 lines.push('');
               }
             }
 
-            // Extract traces
-            var traces = extractAllTraces();
-            if (traces.application) {
+            if (data.traces.application) {
               lines.push('## Application Trace');
               lines.push('');
               lines.push('```');
-              lines.push(traces.application);
+              lines.push(data.traces.application);
               lines.push('```');
               lines.push('');
             }
-            if (traces.framework) {
+
+            if (data.traces.framework) {
               lines.push('## Framework Trace');
               lines.push('');
               lines.push('```');
-              lines.push(traces.framework);
+              lines.push(data.traces.framework);
               lines.push('```');
               lines.push('');
             }
-            if (traces.full) {
+
+            if (data.traces.full) {
               lines.push('## Full Trace');
               lines.push('');
               lines.push('```');
-              lines.push(traces.full);
+              lines.push(data.traces.full);
               lines.push('```');
               lines.push('');
             }
 
-            // Extract Routes section if present (for routing errors)
-            var routesSection = extractRoutes();
-            if (routesSection) {
+            if (data.routes) {
               lines.push('## Available Routes');
               lines.push('');
               lines.push('```');
-              lines.push(routesSection);
+              lines.push(data.routes);
               lines.push('```');
               lines.push('');
             }
@@ -204,19 +390,82 @@ module CopyForAi
             return lines.join('\\n');
           }
 
+          // ===== PLAINTEXT FORMAT =====
+          function formatAsPlaintext(data) {
+            var lines = [];
+
+            lines.push('RAILS ERROR: ' + data.errorType);
+            lines.push('='.repeat(50));
+            lines.push('');
+
+            if (data.errorMessage) {
+              lines.push('ERROR MESSAGE:');
+              lines.push(data.errorMessage);
+              lines.push('');
+            }
+
+            if (data.railsRoot) {
+              lines.push('RAILS ROOT: ' + data.railsRoot);
+              lines.push('');
+            }
+
+            if (data.source) {
+              lines.push('SOURCE CODE:');
+              if (data.source.file) {
+                lines.push('File: ' + data.source.file);
+              }
+              if (data.source.line) {
+                lines.push('Line: ' + data.source.line);
+              }
+              if (data.source.code) {
+                lines.push('');
+                lines.push(data.source.code);
+              }
+              lines.push('');
+            }
+
+            if (data.traces.application) {
+              lines.push('APPLICATION TRACE:');
+              lines.push('-'.repeat(30));
+              lines.push(data.traces.application);
+              lines.push('');
+            }
+
+            if (data.traces.framework) {
+              lines.push('FRAMEWORK TRACE:');
+              lines.push('-'.repeat(30));
+              lines.push(data.traces.framework);
+              lines.push('');
+            }
+
+            if (data.traces.full) {
+              lines.push('FULL TRACE:');
+              lines.push('-'.repeat(30));
+              lines.push(data.traces.full);
+              lines.push('');
+            }
+
+            if (data.routes) {
+              lines.push('AVAILABLE ROUTES:');
+              lines.push('-'.repeat(30));
+              lines.push(data.routes);
+              lines.push('');
+            }
+
+            return lines.join('\\n');
+          }
+
+          // ===== HELPER FUNCTIONS =====
           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 headerText = headers[0].textContent.trim();
                 var match = headerText.match(/([^:]+\\.rb):?(\\d+)?/);
                 if (match) {
                   result.file = match[1].trim();
@@ -224,7 +473,6 @@ module CopyForAi
                 }
               }
 
-              // Look for code
               var code = section.querySelector('pre, code, .code');
               if (code) {
                 result.code = code.textContent.trim();
@@ -242,7 +490,6 @@ module CopyForAi
               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"]');
@@ -260,13 +507,11 @@ module CopyForAi
               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();
@@ -279,7 +524,6 @@ module CopyForAi
           }
 
           function extractRoutes() {
-            // For routing errors, extract available routes
             var routesTable = document.querySelector('table');
             if (routesTable) {
               var rows = routesTable.querySelectorAll('tr');
@@ -295,7 +539,7 @@ module CopyForAi
                     );
                   }
                 });
-                if (routeLines.length > 1) { // More than just header
+                if (routeLines.length > 1) {
                   return routeLines.slice(0, 20).join('\\n') + (rows.length > 20 ? '\\n... and more' : '');
                 }
               }

data/lib/copy_for_ai/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: copy_for_ai
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.2.0
 platform: ruby
 authors:
 - Andrew Miller