tryouts 3.3.2 → 3.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b8d7c33ad6377a7fb1c64c83e24e643c434643aa09e5451ad42bbe80c65b9c9d
-  data.tar.gz: 89cfe371c0fd575614a56702c904d0c5140db2a3a2af41d22777e459de1f4d8a
+  metadata.gz: 7b692cc3a63ac86e060b52e77c246305be0f209dbf06b31b1b08deefbc06434a
+  data.tar.gz: 156e86aa4bde377aa2158f3a059983a6fe5f58796f71545c9895a9b57668b126
 SHA512:
-  metadata.gz: 174645930ab03bc8332e415e9dde67e6c261a66ec2aa4f5572a31841a339cb244d15da75f6d314e3e2ec2d987fb5439e03c34d35d244b37d8b81a7e5b4dbc55d
-  data.tar.gz: 524ded2d4d670ed5fce810ef363faaba2459e56979fc13e61cdd7fbad6a3cffe2cadef7e7c8f1be0901ed1d26b44185f05f8be524c0ebe60a76e3bb841be5b37
+  metadata.gz: d289a9b5ccd6694bd63fe4ca2a0c8aaf610d702e74380bf4975ae78ffaf377d0f82a9ec481dbc51105de9f3b07681c32eaa8a1c3566a1eebd0a861796eaff1e3
+  data.tar.gz: a0db3ebf76b5a291e6ea9d81f1f6e268a95320d28040a10f2225171b221f04bb2ed525bae3f79785d50f4269eb7c9be1dec242012bbca0a6d4588ac9e7fdd362

data/README.md

@@ -1,17 +1,21 @@
-# Tryouts v3.1
+# Tryouts - A Ruby Testing Framework
 
 **Ruby tests that read like documentation.**
 
 A modern test framework for Ruby that uses comments to define expectations. Tryouts are meant to double as documentation, so the Ruby code should be plain and reminiscent of real code.
 
+> [!NOTE]
+> **Agent-Optimized Output**: Tryouts includes specialized output modes for LLM consumption with `--agent` flag, providing structured, token-efficient test results that are 60-80% smaller than traditional output while preserving debugging context.
+
 > [!WARNING]
-> Version 3.0+ uses Ruby's Prism parser and pattern matching, requiring Ruby 3.4+
+> Version 3.0+ uses Ruby's Prism parser and pattern matching, requiring Ruby 3.2+
 
 ## Key Features
 
 - **Documentation-style tests** using comment-based expectations (`#=>`)
 - **Great expectation syntax** for more expressive assertions (`#==>` for true, `#=/=>` for false, `#=:>` for class/module)
 - **Framework integration** write with tryouts syntax, run with RSpec or Minitest
+- **Agent-optimized output** structured, token-efficient output for LLM consumption
 - **Enhanced error reporting** with line numbers and context
 
 ## Installation
@@ -117,8 +121,30 @@ try -v    # verbose (includes source code and return values)
 try -q    # quiet mode
 try -f    # show failures only
 try -D    # debug mode
+
+# Agent-optimized output for LLMs
+try --agent                              # structured, token-efficient output
+try --agent --agent-focus summary        # show only counts and problem files
+try --agent --agent-focus first-failure  # show first failure per file
+try --agent --agent-focus critical       # show only errors/exceptions
+try --agent --agent-limit 1000          # limit output to 1000 tokens
 ```
 
+#### Why Not Pipe Test Output Directly to AI?
+
+Raw test output creates several problems when working with AI assistants:
+
+- **Token bloat**: Verbose formatting wastes 60-80% of your context window on styling
+- **Signal vs noise**: Important failures get buried in passing test details and framework boilerplate
+- **Inconsistent parsing**: AI struggles with varying output formats across different test runs
+- **Context overflow**: Large test suites exceed AI token limits, truncating critical information
+
+#### TOPA: A Better Approach
+
+Tryouts' `--agent` mode inspired the development of **TOPA (Test Output Protocol for AI)** - a standardized format optimized for AI analysis. The [tpane](https://github.com/delano/tpane) tool implements this protocol, transforming any test framework's output into structured, token-efficient formats.
+
+Instead of overwhelming AI with raw output, TOPA provides clean semantic data focusing on what actually needs attention - failures, errors, and actionable context.
+
 ### Exit Codes
 
 - `0`: All tests pass
@@ -127,14 +153,14 @@ try -D    # debug mode
 
 ## Requirements
 
-- **Ruby >= 3.2+** (for Prism parser and pattern matching)
+- **Ruby >= 3.2** (for Prism parser and pattern matching)
 - **RSpec** or **Minitest** (optional, for framework integration)
 
 ## Modern Architecture (v3+)
 
 ### Core Components
 
-- **Prism Parser**: Inhouse Ruby parsing with pattern matching for line classification
+- **Prism Parser**: Native Ruby parsing with pattern matching for line classification
 - **Data Structures**: Immutable `Data.define` classes for test representation
 - **Framework Translators**: Convert tryouts to RSpec/Minitest format
 - **CLI**: Modern command-line interface with framework selection
@@ -151,8 +177,8 @@ For real-world usage examples, see:
 
 This version of Tryouts was developed with assistance from AI tools. The following tools provided significant help with architecture design, code generation, and documentation:
 
-- **Claude Sonnet 4** - Architecture design, code generation, and documentation
-- **Claude Desktop & Claude Code** - Interactive development sessions and debugging
+- **Claude Sonnet 4, Opus 4.1** - Architecture design, code generation, and documentation
+- **Claude Desktop & Claude Code (Max plan)** - Interactive development sessions and debugging
 - **GitHub Copilot** - Code completion and refactoring assistance
 - **Qodo Merge Pro** - Code review and quality improvements
 

data/exe/try

@@ -42,15 +42,18 @@ Tryouts.update_load_path(lib_glob) if Tryouts.respond_to?(:update_load_path)
 begin
   files, options = Tryouts::CLI.parse_args(ARGV)
 
-  # Expand files if directories are given
+  # Expand files if directories are given, preserving line specs
   expanded_files = []
   files.each do |file_or_dir|
-    if File.directory?(file_or_dir)
+    # Parse line spec from the argument
+    path_part, line_spec = Tryouts::CLI::LineSpecParser.parse(file_or_dir)
+
+    if File.directory?(path_part)
       # If it's a directory, find all *_try.rb and *.try.rb files within it
-      dir_files = Dir.glob(['**/*_try.rb', '**/*.try.rb'], base: file_or_dir)
-      expanded_files.concat(dir_files.map { |f| File.join(file_or_dir, f) })
+      dir_files = Dir.glob(['**/*_try.rb', '**/*.try.rb'], base: path_part)
+      expanded_files.concat(dir_files.map { |f| File.join(path_part, f) })
     else
-      # If it's a file, add it as-is
+      # If it's a file, add it as-is (with line spec if present)
       expanded_files << file_or_dir
     end
   end

data/lib/tryouts/cli/formatters/agent.rb

@@ -0,0 +1,576 @@
+# lib/tryouts/cli/formatters/agent.rb
+
+require_relative 'token_budget'
+
+class Tryouts
+  class CLI
+    # Agent-optimized formatter designed for LLM context management
+    # Features:
+    # - Token budget awareness
+    # - Structured YAML-like output
+    # - No redundant file paths
+    # - Smart truncation
+    # - Hierarchical organization
+    class AgentFormatter
+      include FormatterInterface
+
+      def initialize(options = {})
+        super
+        @budget = TokenBudget.new(options[:agent_limit] || TokenBudget::DEFAULT_LIMIT)
+        @focus_mode = options[:agent_focus] || :failures
+        @collected_files = []
+        @current_file_data = nil
+        @total_stats = { files: 0, tests: 0, failures: 0, errors: 0, elapsed: 0 }
+        @output_rendered = false
+        @options = options  # Store all options for execution context display
+        @all_warnings = []  # Store warnings globally for execution details
+        @syntax_errors = []  # Store syntax errors for execution details
+
+        # No colors in agent mode for cleaner parsing
+        @use_colors = false
+      end
+
+      # Phase-level output - collect data, don't output immediately
+      def phase_header(message, file_count: nil)
+        # Store file count for later use, but only store actual file count
+        if file_count && message.include?("FILES")
+          @total_stats[:files] = file_count
+        end
+      end
+
+      # File-level operations - start collecting file data
+      def file_start(file_path, context_info: {})
+        @current_file_data = {
+          path: relative_path(file_path),
+          tests: 0,
+          failures: [],
+          errors: [],
+          passed: 0,
+          context_info: context_info  # Store context info for later display
+        }
+      end
+
+      def file_end(file_path, context_info: {})
+        # Finalize current file data
+        if @current_file_data
+          @collected_files << @current_file_data
+          @current_file_data = nil
+        end
+        # REMOVED: No longer attempts to render here to avoid premature output
+      end
+
+      def file_parsed(_file_path, test_count:, setup_present: false, teardown_present: false)
+        if @current_file_data
+          @current_file_data[:tests] = test_count
+        end
+        @total_stats[:tests] += test_count
+      end
+
+      def parser_warnings(file_path, warnings:)
+        return if warnings.empty? || !@options.fetch(:warnings, true)
+
+        # Store warnings globally for execution details and per-file
+        warnings.each do |warning|
+          warning_data = {
+            type: warning.type.to_s,
+            message: warning.message,
+            line: warning.line_number,
+            suggestion: warning.suggestion,
+            file: relative_path(file_path)
+          }
+          @all_warnings << warning_data
+        end
+
+        # Also store in current file data for potential future use
+        if @current_file_data
+          @current_file_data[:warnings] = @all_warnings.select { |w| w[:file] == relative_path(file_path) }
+        end
+      end
+
+      def file_result(file_path, total_tests:, failed_count:, error_count:, elapsed_time: nil)
+        # Always update global totals
+        @total_stats[:failures] += failed_count
+        @total_stats[:errors] += error_count
+        @total_stats[:elapsed] += elapsed_time if elapsed_time
+
+        # Update per-file data - file_result is called AFTER file_end, so data is in @collected_files
+        relative_file_path = relative_path(file_path)
+        file_data = @collected_files.find { |f| f[:path] == relative_file_path }
+
+        if file_data
+          file_data[:passed] = total_tests - failed_count - error_count
+          # Also ensure tests count is correct if it wasn't set properly earlier
+          file_data[:tests] ||= total_tests
+        end
+      end
+
+
+      # Test-level operations - collect failure data
+      def test_result(result_packet)
+        return unless @current_file_data
+
+        # For summary mode, we still need to collect failures for counting, just don't build detailed data
+        if result_packet.failed? || result_packet.error?
+          if @focus_mode == :summary
+            # Just track counts for summary
+            if result_packet.error?
+              @current_file_data[:errors] << { basic: true }
+            else
+              @current_file_data[:failures] << { basic: true }
+            end
+          else
+            # Build detailed failure data for other modes
+            failure_data = build_failure_data(result_packet)
+
+            if result_packet.error?
+              @current_file_data[:errors] << failure_data
+            else
+              @current_file_data[:failures] << failure_data
+            end
+
+            # Mark truncation for first-failure mode (handle limiting in render phase)
+            if (@focus_mode == :first_failure || @focus_mode == :'first-failure') &&
+               (@current_file_data[:failures].size + @current_file_data[:errors].size) > 1
+              @current_file_data[:truncated] = true
+            end
+          end
+        end
+      end
+
+      # Summary operations - reliable trigger for rendering
+      def batch_summary(failure_collector)
+        # This becomes the single, reliable trigger for rendering
+        grand_total(
+          total_tests: @total_stats[:tests],
+          failed_count: @collected_files.sum { |f| f[:failures].size },
+          error_count: @collected_files.sum { |f| f[:errors].size },
+          successful_files: @collected_files.size - @collected_files.count { |f| f[:failures].any? || f[:errors].any? },
+          total_files: @collected_files.size,
+          elapsed_time: @total_stats[:elapsed]
+        ) unless @output_rendered
+      end
+
+      def grand_total(total_tests:, failed_count:, error_count:, successful_files:, total_files:, elapsed_time:)
+        return if @output_rendered  # Prevent double rendering
+
+        @total_stats.merge!(
+          tests: total_tests,
+          failures: failed_count,
+          errors: error_count,
+          successful_files: successful_files,
+          total_files: total_files,
+          elapsed: elapsed_time
+        )
+
+        # Now render all collected data
+        render_agent_output
+        @output_rendered = true
+      end
+
+      def error_message(message, backtrace: nil)
+        # Store syntax errors for display in execution details
+        @syntax_errors << {
+          message: message,
+          backtrace: backtrace
+        }
+      end
+
+      # Override live status - not needed for agent mode
+      def live_status_capabilities
+        {
+          supports_coordination: false,
+          output_frequency: :none,
+          requires_tty: false
+        }
+      end
+
+      private
+
+      def build_failure_data(result_packet)
+        test_case = result_packet.test_case
+
+        failure_data = {
+          line: (test_case.first_expectation_line || test_case.line_range&.first || 0) + 1,
+          test: test_case.description.to_s.empty? ? 'unnamed test' : test_case.description.to_s
+        }
+
+        case result_packet.status
+        when :error
+          error = result_packet.error
+          failure_data[:error] = error ? "#{error.class.name}: #{error.message}" : 'unknown error'
+        when :failed
+          if result_packet.expected_results.any? && result_packet.actual_results.any?
+            expected = @budget.smart_truncate(result_packet.first_expected, max_tokens: 25)
+            actual = @budget.smart_truncate(result_packet.first_actual, max_tokens: 25)
+            failure_data[:expected] = expected
+            failure_data[:got] = actual
+
+            # Add diff for strings if budget allows
+            if result_packet.first_expected.is_a?(String) &&
+               result_packet.first_actual.is_a?(String) &&
+               @budget.has_budget?
+              failure_data[:diff] = generate_simple_diff(result_packet.first_expected, result_packet.first_actual)
+            end
+          else
+            failure_data[:reason] = 'test failed'
+          end
+        end
+
+        failure_data
+      end
+
+      def generate_simple_diff(expected, actual)
+        return nil unless @budget.remaining > 100  # Only if we have decent budget left
+
+        # Simple line-by-line diff
+        exp_lines = expected.split("\n")
+        act_lines = actual.split("\n")
+
+        diff_lines = []
+        diff_lines << "- #{act_lines.first}" if act_lines.any?
+        diff_lines << "+ #{exp_lines.first}" if exp_lines.any?
+
+        diff_result = diff_lines.join("\n")
+        return @budget.fit_text(diff_result) if @budget.would_exceed?(diff_result)
+        diff_result
+      end
+
+      def render_agent_output
+        case @focus_mode
+        when :summary
+          render_summary_only
+        when :critical
+          render_critical_only
+        else
+          render_full_structured
+        end
+      end
+
+      def render_summary_only
+        output = []
+
+        # Add execution context header for agent clarity
+        output << render_execution_context
+        output << ""
+
+        # Count failures manually from collected file data (same as other render methods)
+        failed_count = @collected_files.sum { |f| f[:failures].size }
+        error_count = @collected_files.sum { |f| f[:errors].size }
+        issues_count = failed_count + error_count
+        passed_count = [@total_stats[:tests] - issues_count, 0].max
+
+        status_parts = []
+        if issues_count > 0
+          details = []
+          details << "#{failed_count} failed" if failed_count > 0
+          details << "#{error_count} errors" if error_count > 0
+          status_parts << "FAIL: #{issues_count}/#{@total_stats[:tests]} tests (#{details.join(', ')}, #{passed_count} passed)"
+        else
+          # Agent doesn't need output in the positive case (i.e. for passing
+          # tests). It just fills out the context window.
+        end
+
+        status_parts << "(#{format_time(@total_stats[:elapsed])})" if @total_stats[:elapsed]
+
+        output << status_parts.join(" ")
+
+        # Always show file information for agent context
+        output << ""
+
+        files_with_issues = @collected_files.select { |f| f[:failures].any? || f[:errors].any? }
+        if files_with_issues.any?
+          output << "Files:"
+          files_with_issues.each do |file_data|
+            issue_count = file_data[:failures].size + file_data[:errors].size
+            output << "  #{file_data[:path]}: #{issue_count} issue#{'s' if issue_count != 1}"
+          end
+        elsif @collected_files.any?
+          # Show files that were processed successfully
+          output << "Files:"
+          @collected_files.each do |file_data|
+            # Use the passed count from file_result if available, otherwise calculate
+            passed_tests = file_data[:passed] ||
+                          ((file_data[:tests] || 0) - file_data[:failures].size - file_data[:errors].size)
+            output << "  #{file_data[:path]}: #{passed_tests} test#{'s' if passed_tests != 1} passed"
+          end
+        end
+
+        puts output.join("\n") if output.any?
+      end
+
+      def render_critical_only
+        # Only show errors (exceptions), skip assertion failures
+        critical_files = @collected_files.select { |f| f[:errors].any? }
+
+        output = []
+
+        # Add execution context header for agent clarity
+        output << render_execution_context
+        output << ""
+
+        if critical_files.empty?
+          output << "No critical errors found"
+          puts output.join("\n")
+          return
+        end
+
+        output << "CRITICAL: #{critical_files.size} file#{'s' if critical_files.size != 1} with errors"
+        output << ""
+
+        critical_files.each do |file_data|
+          unless @budget.has_budget?
+            output << "... (truncated due to token limit)"
+            break
+          end
+
+          output << "#{file_data[:path]}:"
+
+          file_data[:errors].each do |error|
+            error_line = "  L#{error[:line]}: #{error[:error]}"
+            if @budget.would_exceed?(error_line)
+              output << @budget.fit_text(error_line)
+            else
+              output << error_line
+              @budget.consume(error_line)
+            end
+          end
+
+          output << ""
+        end
+
+        puts output.join("\n")
+      end
+
+      def render_full_structured
+        output = []
+
+        # Add execution context header for agent clarity
+        output << render_execution_context
+        output << ""
+
+        # Count actual failures from collected data
+        failed_count = @collected_files.sum { |f| f[:failures].size }
+        error_count = @collected_files.sum { |f| f[:errors].size }
+        issues_count = failed_count + error_count
+        passed_count = [@total_stats[:tests] - issues_count, 0].max
+
+        # Show files with issues only
+        files_with_issues = @collected_files.select { |f| f[:failures].any? || f[:errors].any? }
+
+        if files_with_issues.any?
+          files_with_issues.each do |file_data|
+            break unless @budget.has_budget?
+
+            file_section = render_file_section(file_data)
+            if @budget.would_exceed?(file_section)
+              # Try to fit what we can
+              truncated = @budget.fit_text(file_section, preserve_suffix: "\n  ... (truncated)")
+              output << truncated if truncated.length > 20  # Only if meaningful content remains
+              break
+            else
+              output << file_section
+              @budget.consume(file_section)
+            end
+          end
+          output << ""
+        end
+
+        # Final summary line
+        summary = "Summary: \n"
+        summary += "#{passed_count} testcases passed, #{failed_count} failed"
+        summary += ", #{error_count} errors" if error_count > 0
+        summary += " in #{@total_stats[:files]} files"
+
+        output << summary
+
+        puts output.join("\n")
+      end
+
+      def render_file_section(file_data)
+        lines = []
+
+        # File header
+        lines << "#{file_data[:path]}:"
+
+        # Check if file has any issues
+        has_issues = file_data[:failures].any? || file_data[:errors].any?
+
+        # If no issues, show success summary
+        if !has_issues
+          # Use the passed count from file_result if available, otherwise calculate
+          passed_tests = file_data[:passed] ||
+                        ((file_data[:tests] || 0) - file_data[:failures].size - file_data[:errors].size)
+
+
+          lines << "  ✓ #{passed_tests} test#{'s' if passed_tests != 1} passed"
+          return lines.join("\n")
+        end
+
+        # For first-failure mode, only show first error or failure
+        if @focus_mode == :first_failure || @focus_mode == :'first-failure'
+          shown_count = 0
+
+          # Show first error
+          if file_data[:errors].any? && shown_count == 0
+            error = file_data[:errors].first
+            lines << "  L#{error[:line]}: #{error[:error]}"
+            lines << "    Test: #{error[:test]}" if error[:test] != 'unnamed test'
+            shown_count += 1
+          end
+
+          # Show first failure if no error was shown
+          if file_data[:failures].any? && shown_count == 0
+            failure = file_data[:failures].first
+            line_parts = ["  L#{failure[:line]}:"]
+
+            if failure[:expected] && failure[:got]
+              line_parts << "expected #{failure[:expected]}, got #{failure[:got]}"
+            elsif failure[:reason]
+              line_parts << failure[:reason]
+            end
+
+            lines << line_parts.join(' ')
+            lines << "    Test: #{failure[:test]}" if failure[:test] != 'unnamed test'
+
+            # Add diff if available and budget allows
+            if failure[:diff] && @budget.remaining > 50
+              lines << "    Diff:"
+              failure[:diff].split("\n").each { |diff_line| lines << "      #{diff_line}" }
+            end
+          end
+
+          # Show truncation notice
+          total_issues = file_data[:errors].size + file_data[:failures].size
+          if total_issues > 1
+            lines << "  ... (#{total_issues - 1} more failures not shown)"
+          end
+        else
+          # Normal mode - show all errors and failures
+          # Errors first (more critical)
+          file_data[:errors].each do |error|
+            next if error[:basic]  # Skip basic entries from summary mode
+            lines << "  L#{error[:line]}: #{error[:error]}"
+            lines << "    Test: #{error[:test]}" if error[:test] != 'unnamed test'
+          end
+
+          # Then failures
+          file_data[:failures].each do |failure|
+            next if failure[:basic]  # Skip basic entries from summary mode
+            line_parts = ["  L#{failure[:line]}:"]
+
+            if failure[:expected] && failure[:got]
+              line_parts << "expected #{failure[:expected]}, got #{failure[:got]}"
+            elsif failure[:reason]
+              line_parts << failure[:reason]
+            end
+
+            lines << line_parts.join(' ')
+            lines << "    Test: #{failure[:test]}" if failure[:test] != 'unnamed test'
+
+            # Add diff if available and budget allows
+            if failure[:diff] && @budget.remaining > 50
+              lines << "    Diff:"
+              failure[:diff].split("\n").each { |diff_line| lines << "      #{diff_line}" }
+            end
+          end
+
+          # Show truncation notice if applicable
+          if file_data[:truncated]
+            lines << "  ... (more failures not shown)"
+          end
+        end
+
+        lines.join("\n")
+      end
+
+      def relative_path(file_path)
+        # Remove leading path components to save tokens
+        path = Pathname.new(file_path).relative_path_from(Pathname.pwd).to_s
+        # If relative path is longer, use just filename
+        path.include?('../') ? File.basename(file_path) : path
+      rescue
+        File.basename(file_path)
+      end
+
+      def format_time(seconds)
+        return '0ms' unless seconds
+
+        if seconds < 0.001
+          "#{(seconds * 1_000_000).round}μs"
+        elsif seconds < 1
+          "#{(seconds * 1000).round}ms"
+        else
+          "#{seconds.round(2)}s"
+        end
+      end
+
+      def render_execution_context
+        context_lines = []
+        context_lines << "EXECUTION DETAILS:"
+
+        # Framework and context mode
+        framework = @options[:framework] || :direct
+        shared_context = if @options.key?(:shared_context)
+          @options[:shared_context]
+        else
+          # Apply framework defaults
+          case framework
+          when :rspec, :minitest
+            false
+          else
+            true  # direct/tryouts defaults to shared
+          end
+        end
+
+        context_lines << "  Framework: #{framework}"
+        context_lines << "  Context mode: #{shared_context ? 'shared (variables persist across test cases)' : 'fresh (each test case isolated)'}"
+
+        # Parser type
+        parser = @options[:parser] || :enhanced
+        context_lines << "  Parser: #{parser}"
+
+        # Other relevant flags
+        flags = []
+        flags << "verbose" if @options[:verbose]
+        flags << "fails-only" if @options[:fails_only]
+        flags << "debug" if @options[:debug]
+        flags << "stack-traces" if @options[:stack_traces]
+        flags << "parallel(#{@options[:parallel_threads] || 'auto'})" if @options[:parallel]
+        flags << "line-spec" if @options[:line_spec]
+
+        context_lines << "  Flags: #{flags.any? ? flags.join(', ') : 'none'}" if flags.any?
+
+        # Agent-specific settings
+        context_lines << "  Agent mode: focus=#{@focus_mode}, limit=#{@budget.limit} tokens"
+
+        # Add syntax errors if any (these prevent test execution)
+        if @syntax_errors.any?
+          context_lines << ""
+          context_lines << "Syntax Errors:"
+          @syntax_errors.each do |error|
+            # Clean up the error message to remove redundant prefixes
+            clean_message = error[:message].gsub(/^ERROR:\s*/i, '').strip
+            context_lines << "  #{clean_message}"
+            if error[:backtrace] && @options[:debug]
+              error[:backtrace].first(3).each do |trace|
+                context_lines << "    #{trace}"
+              end
+            end
+          end
+        end
+
+        # Add warnings if any
+        if @all_warnings.any? && @options.fetch(:warnings, true)
+          context_lines << ""
+          context_lines << "Parser Warnings:"
+          @all_warnings.each do |warning|
+            context_lines << "  #{warning[:file]}:#{warning[:line]}: #{warning[:message]}"
+            context_lines << "    #{warning[:suggestion]}" if warning[:suggestion]
+          end
+        end
+
+        context_lines.join("\n")
+      end
+    end
+  end
+end