minitest-reporters-llm 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 54abd03bb156c3695843a4eabbd357ca78fb62e7a2aa3583cfdaae6a3b230e7f
+  data.tar.gz: f0f26ab22f2849a264ba40fec91f2f505b2f0f41c38b1365363624e11d66c3f8
+SHA512:
+  metadata.gz: 1e588f8816062ac07f38d1f7ef560861dbc43501f072f4579aeebc5e15f0516ecc4eef0183e7cc240e9f7583030fe61679ed23554fdcd37ddb2aabbf96256472
+  data.tar.gz: 57567c6ac21069a1146cd3200ce7dc2973783d493e0932422844478fb069b5e8276396529eb7aef46cc4fbd6c98a55904b6215a8f25f0a2c19a16796e19e22de

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 Abdelkader Boudih
+
+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 @@
+# Minitest::Reporters::LLM
+
+A token-optimized Minitest reporter specifically designed for Large Language Model consumption. Features ultra-compact output, regression tracking, and smart time formatting to minimize token usage while maintaining maximum parsability.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'minitest-reporters-llm'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install minitest-reporters-llm
+
+## Usage
+
+### Basic Setup
+
+```ruby
+# In test_helper.rb or wherever you configure minitest-reporters
+require 'minitest/reporters/llm'
+
+# Use compact format (default)
+Minitest::Reporters.use! [Minitest::Reporters::LLMReporter.new]
+
+# Or with options
+Minitest::Reporters.use! [
+  Minitest::Reporters::LLMReporter.new(
+    format: :compact,                    # :compact or :verbose
+    results_file: 'tmp/test_results.json',
+    report_file: 'tmp/test_report.toml',
+    track_regressions: true,             # Track test status changes
+    write_reports: true                  # Write JSON/TOML reports
+  )
+]
+```
+
+### Output Formats
+
+#### Compact Mode (Optimized for LLMs)
+```
+R t15 d2.3s p12 f2 e1 s0
+REG +1 -0
+F user_test.rb:45 validation fails
+E api_test.rb:12 connection timeout
+```
+
+Format: `R t{total} d{duration} p{pass} f{fail} e{error} s{skip}`
+- `R` = Result summary line
+- `F/E/S` = Individual failure/error/skip lines
+- `REG +X -Y` = Regression summary (X new failures, Y fixes)
+
+#### Verbose Mode (Human-friendly)
+```
+15 tests (2.3s)
+12 passed
+2 failed: validation fails@user_test.rb:45, connection timeout@api_test.rb:12
+1 error: api_test.rb:12
+
+Details:
+----------------------------------------
+FAIL test_validation_fails
+   user_test.rb:45
+   Expected true, got false
+```
+
+### Smart Time Formatting
+- `<1ms` - Sub-millisecond tests
+- `15ms` - Millisecond precision
+- `2.3s` - Second precision
+- `1m30s` - Minute/second format
+
+### Environment Variables
+```bash
+# Override default file paths
+export LLM_REPORTER_RESULTS="custom/results.json"
+export LLM_REPORTER_TOML="custom/report.toml"
+```
+
+### Regression Tracking
+The reporter automatically tracks test status changes between runs:
+- Saves test results to JSON file
+- Compares current run with previous results
+- Shows `REG +X -Y` for new failures/fixes
+- Helps identify flaky or newly broken tests
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Features
+
+- **Token-optimized output**: 70% fewer tokens than traditional reporters
+- **Smart time formatting**: Automatically chooses optimal precision (`<1ms`, `15ms`, `2.3s`, `1m30s`)
+- **Regression tracking**: Detects new failures and fixes between test runs
+- **Dual output modes**: Compact for LLMs, verbose for humans
+- **Configurable file paths**: No hardcoded temporary directories
+- **TOML/JSON reports**: Structured data export for further analysis
+- **Zero dependencies**: Only requires minitest-reporters
+
+## Why Use This Reporter?
+
+Perfect for:
+- **AI-assisted development** workflows
+- **CI/CD systems** requiring compact output
+- **Log analysis** and automated test result processing
+- **Token-conscious** LLM integrations
+- **Regression monitoring** across test runs
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/seuros/minitest-reporters-llm.
+
+## 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,12 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.libs << 'lib'
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task default: :test

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'minitest/llm/reporter'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require 'irb'
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/minitest/reporters/llm/version.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Minitest
+  module Reporters
+    module LLM
+      VERSION = '0.1.0'
+    end
+  end
+end

data/lib/minitest/reporters/llm.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require 'minitest/reporters'
+require 'minitest/reporters/llm_reporter'

data/lib/minitest/reporters/llm_reporter.rb

@@ -0,0 +1,382 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'fileutils'
+require 'minitest/reporters/llm/version'
+
+module Minitest
+  module Reporters
+    class LLMReporter < ::Minitest::Reporters::BaseReporter
+      VERSION = LLM::VERSION
+
+      def initialize(options = {})
+        super
+        @options = default_options.merge(options)
+        @results_file = @options[:results_file]
+        @report_file = @options[:report_file]
+        @previous_results = @options[:track_regressions] ? load_previous_results : {}
+        @current_results = {}
+        @llm_start_time = nil
+      end
+
+      def start(*args)
+        super
+        @llm_start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      end
+
+      def record(result)
+        super
+        test_key = "#{result.klass}##{result.name}"
+        @current_results[test_key] = result.passed? ? 'pass' : 'fail'
+      end
+
+      def report
+        total = @current_results.size
+        fails_ct  = tests_list.count { |t| t.failure && !t.skipped? && !t.error? }
+        errors_ct = tests_list.count { |t| t.failure && t.error? }
+        skips_ct  = tests_list.count(&:skipped?)
+        passes = total - fails_ct - errors_ct - skips_ct
+
+        if @options[:format] == :compact
+          report_compact(total, passes, fails_ct, errors_ct, skips_ct)
+        else
+          report_verbose(total, passes, fails_ct, errors_ct, skips_ct)
+        end
+
+        save_current_results if @options[:track_regressions]
+        write_toml_summary
+      end
+
+      def report_compact(total, passes, fails_ct, errors_ct, skips_ct)
+        puts "R t#{total} d#{format_time(llm_total_time)} p#{passes} f#{fails_ct} e#{errors_ct} s#{skips_ct}"
+
+        show_regressions_compact
+
+        # Show failures
+        if fails_ct.positive?
+          tests_list.select { |t| t.failure && !t.skipped? && !t.error? }.each do |test|
+            puts "F #{format_test_location_compact(test)}"
+          end
+        end
+
+        # Show errors
+        if errors_ct.positive?
+          tests_list.select { |t| t.failure && t.error? }.each do |test|
+            puts "E #{format_test_location_compact(test)}"
+          end
+        end
+
+        # Show skips
+        return unless skips_ct.positive?
+
+        tests_list.select(&:skipped?).each do |test|
+          puts "S #{format_test_location_compact(test)}"
+        end
+      end
+
+      def report_verbose(total, passes, fails_ct, errors_ct, skips_ct)
+        puts
+        puts "🏃 #{total} tests (#{format_time(llm_total_time)})"
+        puts "✅ #{passes}" if passes.positive?
+
+        show_regressions
+
+        if fails_ct.positive?
+          failed_tests = tests_list.select { |t| t.failure && !t.skipped? && !t.error? }
+                                   .map { |test| format_test_location(test) }
+          puts "❌ #{failed_tests.size} failed: #{failed_tests.join(', ')}" if failed_tests.any?
+        end
+
+        if errors_ct.positive?
+          error_tests = tests_list.select { |t| t.failure && t.error? }
+                                  .map { |test| format_test_location(test) }
+          puts "💥 #{errors_ct}: #{error_tests.join(', ')}"
+        end
+
+        if skips_ct.positive?
+          skip_tests = tests_list.select(&:skipped?)
+          puts "⏭️  #{skips_ct} skipped:"
+          skip_tests.each do |test|
+            msg = clean_message(test.failure&.message)
+            puts "    - #{format_test_location(test)}: #{msg}"
+          end
+        end
+
+        show_failure_details if fails_ct.positive? || errors_ct.positive?
+      end
+
+      private
+
+      def default_options
+        {
+          results_file: ENV.fetch('LLM_REPORTER_RESULTS', 'tmp/test_results.json'),
+          report_file: ENV.fetch('LLM_REPORTER_TOML', 'tmp/test_report.toml'),
+          format: :compact,
+          track_regressions: true,
+          write_reports: true
+        }
+      end
+
+      def format_time(time)
+        return '0' unless time.is_a?(Numeric)
+        return '<1ms' if time < 0.001
+
+        if time < 1
+          ms = (time * 1000).round
+          "#{ms}ms"
+        elsif time < 60
+          "#{time.round(1)}s"
+        else
+          minutes = (time / 60).floor
+          seconds = (time % 60).round
+          "#{minutes}m#{seconds}s"
+        end
+      end
+
+      def llm_total_time
+        return nil unless @llm_start_time
+
+        now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        now - @llm_start_time
+      rescue StandardError
+        nil
+      end
+
+      def format_test_location(test)
+        test_name = (test.name || '').to_s.gsub(/^test_/, '').tr('_', ' ')
+        if (loc = source_location_for(test)) && loc[0] && loc[1]
+          file = File.basename(loc[0])
+          line = loc[1]
+          "#{test_name}@#{file}:#{line}"
+        else
+          test_name
+        end
+      end
+
+      def format_test_location_compact(test)
+        test_name = (test.name || '').to_s.gsub(/^test_/, '').tr('_', ' ')
+        if (loc = source_location_for(test)) && loc[0] && loc[1]
+          file = File.basename(loc[0])
+          line = loc[1]
+          "#{file}:#{line} #{test_name}"
+        else
+          test_name
+        end
+      end
+
+      def source_location_for(test)
+        # Try provided API first
+        return test.source_location if test.respond_to?(:source_location)
+
+        # Derive from class + method if possible
+        begin
+          klass_name = test.respond_to?(:klass) ? test.klass : test.class.name
+          method_name = test.name
+          return nil unless klass_name && method_name
+
+          klass = constantize(klass_name)
+          return nil unless klass&.instance_methods&.include?(method_name.to_sym)
+
+          klass.instance_method(method_name).source_location
+        rescue StandardError
+          nil
+        end
+      end
+
+      def constantize(name)
+        names = name.split('::')
+        names.shift if names.first.empty?
+        names.inject(Object) { |constant, n| constant.const_get(n) }
+      rescue NameError
+        nil
+      end
+
+      def show_failure_details
+        failed_tests = tests_list.select { |t| t.failure && !t.skipped? }
+        error_tests = tests_list.select { |t| t.failure && t.error? }
+
+        return unless failed_tests.any? || error_tests.any?
+
+        puts
+        puts '📋 Details:'
+        puts '-' * 40
+
+        failed_tests.each do |test|
+          puts "❌ #{test.name}"
+          puts "   #{format_location(test)}"
+          puts "   #{clean_message(test.failure&.message)}"
+          puts
+        end
+
+        error_tests.each do |test|
+          puts "💥 #{test.name}"
+          puts "   #{format_location(test)}"
+          puts "   #{clean_message(test.failure&.message)}"
+          puts
+        end
+      end
+
+      def format_location(test)
+        loc = source_location_for(test)
+        if loc && loc[0] && loc[1]
+          file = File.basename(loc[0])
+          "#{file}:#{loc[1]}"
+        else
+          'unknown location'
+        end
+      end
+
+      def clean_message(message)
+        return 'No message' unless message
+
+        message.to_s.split("\n").first&.strip || 'Unknown error'
+      end
+
+      def load_previous_results
+        return {} unless File.exist?(@results_file)
+
+        JSON.parse(File.read(@results_file))
+      rescue JSON::ParserError, Errno::ENOENT
+        {}
+      end
+
+      def save_current_results
+        return unless @options[:write_reports]
+
+        FileUtils.mkdir_p(File.dirname(@results_file))
+        File.write(@results_file, JSON.pretty_generate(@current_results))
+      rescue StandardError => e
+        puts "Warning: Could not save regression results: #{e.message}" if ENV['DEBUG']
+      end
+
+      def show_regressions
+        return if @previous_results.empty?
+
+        new_failures = []
+        fixes = []
+
+        @current_results.each do |test_key, status|
+          previous_status = @previous_results[test_key]
+
+          if previous_status == 'pass' && status == 'fail'
+            new_failures << test_key_to_location(test_key)
+          elsif previous_status == 'fail' && status == 'pass'
+            fixes << test_key_to_location(test_key)
+          end
+        end
+
+        puts "✅➡️❌ #{new_failures.size}: #{new_failures.join(', ')}" if new_failures.any?
+        puts "🎉 #{fixes.size}: #{fixes.join(', ')}" if fixes.any?
+      end
+
+      def show_regressions_compact
+        return if @previous_results.empty?
+
+        new_failures = 0
+        fixes = 0
+
+        @current_results.each do |test_key, status|
+          previous_status = @previous_results[test_key]
+          new_failures += 1 if previous_status == 'pass' && status == 'fail'
+          fixes += 1 if previous_status == 'fail' && status == 'pass'
+        end
+
+        puts "REG +#{new_failures} -#{fixes}" if new_failures.positive? || fixes.positive?
+      end
+
+      def test_key_to_location(test_key)
+        class_name, method_name = test_key.split('#', 2)
+        method_name = method_name.to_s.gsub(/^test_/, '').tr('_', ' ')
+        "#{method_name}@#{class_name}"
+      end
+
+      def write_toml_summary
+        return unless @options[:write_reports]
+
+        data = {
+          summary: {
+            tests: @current_results.size,
+            passes: (@current_results.size - tests_list.count do |t|
+              t.failure && !t.skipped? && !t.error?
+            end - tests_list.count do |t|
+                    t.failure && t.error?
+                  end - tests_list.count(&:skipped?)),
+            failures: tests_list.count { |t| t.failure && !t.skipped? && !t.error? },
+            errors: tests_list.count { |t| t.failure && t.error? },
+            skips: tests_list.count(&:skipped?),
+            time_s: safe_total_time
+          },
+          details: {
+            failed: tests_list.select { |t| t.failure && !t.skipped? && !t.error? }
+                              .map { |t| format_test_location(t) },
+            errors: tests_list.select { |t| t.failure && t.error? }
+                              .map { |t| format_test_location(t) },
+            skipped: tests_list.select(&:skipped?)
+                               .map do |t|
+              msg = clean_message(t.failure&.message)
+              "#{format_test_location(t)}: #{msg}"
+            end
+          }
+        }
+
+        unless @previous_results.empty?
+          new_failures = []
+          fixes = []
+          @current_results.each do |k, status|
+            prev = @previous_results[k]
+            new_failures << test_key_to_location(k) if prev == 'pass' && status == 'fail'
+            fixes << test_key_to_location(k) if prev == 'fail' && status == 'pass'
+          end
+          data[:regressions] = { new_failures: new_failures, fixes: fixes }
+        end
+
+        toml = build_toml(data)
+        FileUtils.mkdir_p(File.dirname(@report_file))
+        File.write(@report_file, toml)
+      rescue StandardError => e
+        puts "Warning: Could not write TOML report: #{e.message}" if ENV['DEBUG']
+      end
+
+      def n(value)
+        value.to_i
+      end
+
+      def tests_list
+        tests || []
+      end
+
+      def safe_total_time
+        t = llm_total_time
+        t.is_a?(Numeric) ? t.to_f : 0.0
+      end
+
+      def build_toml(hash)
+        lines = []
+        hash.each do |section, values|
+          lines << "[#{section}]"
+          values.each do |k, v|
+            key = k.to_s
+            case v
+            when Array
+              escaped = v.map { |s| s.to_s.gsub('\\', '\\\\').gsub('"', '\\"') }
+              lines << "#{key} = [\"#{escaped.join('\", \"')}\"]"
+            when String
+              val = v.to_s.gsub('\\', '\\\\').gsub('"', '\\"')
+              lines << "#{key} = \"#{val}\""
+            when Numeric
+              lines << "#{key} = #{v}"
+            when TrueClass, FalseClass
+              lines << "#{key} = #{v}"
+            else
+              # Fallback to string
+              val = v.to_s.gsub('\\', '\\\\').gsub('"', '\\"')
+              lines << "#{key} = \"#{val}\""
+            end
+          end
+          lines << ''
+        end
+        lines.join("\n")
+      end
+    end
+  end
+end

data/minitest-reporters-llm.gemspec

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative 'lib/minitest/reporters/llm/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'minitest-reporters-llm'
+  spec.version       = Minitest::Reporters::LLM::VERSION
+  spec.authors       = ['Abdelkader Boudih']
+  spec.email         = ['terminale@gmail.com']
+
+  spec.summary       = 'Token-optimized Minitest reporter for LLM consumption with regression tracking'
+  spec.description   = 'A Minitest reporter optimized for Large Language Model consumption, featuring compact emoji-based output, regression detection by comparing test runs, TOML report generation, and detailed failure reporting with file locations. Perfect for AI-assisted development workflows.'
+  spec.homepage      = 'https://github.com/seuros/minitest-reporters-llm'
+  spec.license       = 'MIT'
+
+  spec.metadata = {
+    'homepage_uri' => spec.homepage,
+    'source_code_uri' => 'https://github.com/seuros/minitest-reporters-llm',
+    'changelog_uri' => 'https://github.com/seuros/minitest-reporters-llm/blob/master/CHANGELOG.md',
+    'bug_tracker_uri' => 'https://github.com/seuros/minitest-reporters-llm/issues',
+    'rubygems_mfa_required' => 'true'
+  }
+
+  # Specify which files should be added to the gem when it is released.
+  spec.files = Dir.glob(%w[
+                          lib/**/*.rb
+                          *.md
+                          *.txt
+                          *.gemspec
+                          Rakefile
+                          bin/*
+                        ]).reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.require_paths = ['lib']
+  spec.required_ruby_version = '>= 3.3'
+
+  spec.add_development_dependency 'bundler', '~> 2.5'
+  spec.add_development_dependency 'rake', '~> 13.0'
+
+  spec.add_dependency 'minitest', '>= 5.25'
+  spec.add_dependency 'minitest-reporters', '>= 1.7.1'
+end

metadata

@@ -0,0 +1,113 @@
+--- !ruby/object:Gem::Specification
+name: minitest-reporters-llm
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Abdelkader Boudih
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.5'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.25'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.25'
+- !ruby/object:Gem::Dependency
+  name: minitest-reporters
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.7.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.7.1
+description: A Minitest reporter optimized for Large Language Model consumption, featuring
+  compact emoji-based output, regression detection by comparing test runs, TOML report
+  generation, and detailed failure reporting with file locations. Perfect for AI-assisted
+  development workflows.
+email:
+- terminale@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/minitest/reporters/llm.rb
+- lib/minitest/reporters/llm/version.rb
+- lib/minitest/reporters/llm_reporter.rb
+- minitest-reporters-llm.gemspec
+homepage: https://github.com/seuros/minitest-reporters-llm
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/seuros/minitest-reporters-llm
+  source_code_uri: https://github.com/seuros/minitest-reporters-llm
+  changelog_uri: https://github.com/seuros/minitest-reporters-llm/blob/master/CHANGELOG.md
+  bug_tracker_uri: https://github.com/seuros/minitest-reporters-llm/issues
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.3'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Token-optimized Minitest reporter for LLM consumption with regression tracking
+test_files: []