tryouts 3.3.1 → 3.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: adb9f46213aee10ed4b9d2a1b9b8d5c9e385ea23f996445debc7458b43351512
-  data.tar.gz: 8d6abfed42e73bb340e13a62991b4855b8c0c18efa3092b4e3244a822a1612c1
+  metadata.gz: 6b0f0a0ca7de83a58c4e822d127a963bb1fb08523d9146b24c8b33f8a2c12ff2
+  data.tar.gz: 2f4e61611e23176da42cc9bbf82a92a2cc1e9d6049943fd4d4827dcd2b34c84f
 SHA512:
-  metadata.gz: 571410ed483879bd035b14c053a5c3496d51ad2248cff2534cf40fc06a72ece1aea13a7e61ae2c29b1e1f1768f19d3c5ede8c4e4a30a977c29aacb502c616988
-  data.tar.gz: 6b5186131242edf826ba44303daaee716ce1ec364683e521df5224818d796067209a9a0ae66cacc85d15796cfee92df2349372fc5df762ced52b8753e1196c0e
+  metadata.gz: 1505d26c47b4fb3fb75675425e6aaac3e1ba81b6f39ac8ae47622ae43acd0c19a13a16e82486663de0201f21bf7b997281744fc6d69cae6116e67065803b4a39
+  data.tar.gz: ca57f3c38348023c57f5e382fe8b45e29877393fae155a718c921550b4a2200b0fe37c1c31be4f41dcbc934527d8c6b53e74fbe88fcc574c53cbc3d765bb3534

data/README.md

@@ -1,17 +1,21 @@
-# Tryouts v3.1
+# Tryouts v3
 
 **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,6 +121,13 @@ 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
 ```
 
 ### Exit Codes
@@ -127,14 +138,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

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

@@ -0,0 +1,450 @@
+# 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
+
+        # 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
+        }
+      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)
+        @current_file_data[:tests] = test_count if @current_file_data
+        @total_stats[:tests] += test_count
+      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 when available
+        if @current_file_data
+          @current_file_data[:passed] = total_tests - failed_count - error_count
+        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
+
+      # 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 = []
+
+        # 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
+
+        if issues_count > 0
+          status = "FAIL: #{issues_count}/#{@total_stats[:tests]} tests"
+          details = []
+          details << "#{failed_count} failed" if failed_count > 0
+          details << "#{error_count} errors" if error_count > 0
+          status += " (#{details.join(', ')}, #{passed_count} passed)"
+        else
+          status = "PASS: #{@total_stats[:tests]} tests passed"
+        end
+
+        status += " (#{format_time(@total_stats[:elapsed])})" if @total_stats[:elapsed]
+
+        output << status
+
+        # Show which files had failures
+        files_with_issues = @collected_files.select { |f| f[:failures].any? || f[:errors].any? }
+        if files_with_issues.any?
+          output << ""
+          output << "Files with issues:"
+          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
+        end
+
+        puts output.join("\n")
+      end
+
+      def render_critical_only
+        # Only show errors (exceptions), skip assertion failures
+        critical_files = @collected_files.select { |f| f[:errors].any? }
+
+        if critical_files.empty?
+          puts "No critical errors found"
+          return
+        end
+
+        output = []
+        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 = []
+
+        # Header with overall stats
+        issues_count = @total_stats[:failures] + @total_stats[:errors]
+        passed_count = [@total_stats[:tests] - issues_count, 0].max
+
+        files_count = if @total_stats[:files].to_i > 0
+          @total_stats[:files]
+        else
+          @total_stats[:total_files] || @collected_files.size
+        end
+
+        if issues_count > 0
+          status_line = "FAIL: #{issues_count}/#{@total_stats[:tests]} tests (#{files_count} files, #{format_time(@total_stats[:elapsed])})"
+        else
+          status_line = "PASS: #{@total_stats[:tests]} tests (#{files_count} files, #{format_time(@total_stats[:elapsed])})"
+        end
+
+        # Always include status line
+        output << status_line
+        @budget.force_consume(status_line)
+
+        # Only show files with issues (unless focus is different)
+        files_to_show = case @focus_mode
+        when :failures, :first_failure
+          @collected_files.select { |f| f[:failures].any? || f[:errors].any? }
+        else
+          @collected_files.select { |f| f[:failures].any? || f[:errors].any? }
+        end
+
+        if files_to_show.any?
+          output << ""
+          @budget.consume("\n")
+
+          files_to_show.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
+        end
+
+        # Final summary line
+        summary = "Summary: #{passed_count} passed, #{@total_stats[:failures]} failed"
+        summary += ", #{@total_stats[:errors]} errors" if @total_stats[:errors] > 0
+        summary += " in #{@total_stats[:files]} files"
+
+        output << ""
+        output << summary
+
+        puts output.join("\n")
+      end
+
+      def render_file_section(file_data)
+        lines = []
+
+        # File header
+        lines << "#{file_data[:path]}:"
+
+        # 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
+    end
+  end
+end

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

@@ -11,6 +11,7 @@ class Tryouts
         @show_debug  = options.fetch(:debug, false)
         @show_trace  = options.fetch(:trace, false)
         @show_passed = options.fetch(:show_passed, true)
+        @show_stack_traces = options.fetch(:stack_traces, false) || options.fetch(:debug, false)
       end
 
       # Phase-level output - minimal for compact mode
@@ -238,10 +239,10 @@ class Tryouts
       def error_message(message, backtrace: nil)
         @stderr.puts Console.color(:red, "ERROR: #{message}")
 
-        return unless backtrace && @show_debug
+        return unless backtrace && @show_stack_traces
 
-        backtrace.first(3).each do |line|
-          @stderr.puts indent_text(line.chomp, 1)
+        Console.pretty_backtrace(backtrace, limit: 3).each do |line|
+          @stderr.puts indent_text(line, 1)
         end
       end
 

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

@@ -12,6 +12,11 @@ class Tryouts
       end
 
       def self.create_formatter(options = {})
+        # Check for agent mode first (takes precedence)
+        if options[:agent]
+          return AgentFormatter.new(options)
+        end
+
         # Map boolean flags to format symbols if format not explicitly set
         format = options[:format]&.to_sym || determine_format_from_flags(options)
 

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

@@ -10,6 +10,7 @@ class Tryouts
         super
         @show_errors        = options.fetch(:show_errors, true)
         @show_final_summary = options.fetch(:show_final_summary, true)
+        @show_stack_traces  = options.fetch(:stack_traces, false) || options.fetch(:debug, false)
         @current_file       = nil
       end
 
@@ -80,10 +81,10 @@ class Tryouts
         @stderr.puts
         @stderr.puts Console.color(:red, "ERROR: #{message}")
 
-        return unless backtrace && @show_debug
+        return unless backtrace && @show_stack_traces
 
-        backtrace.first(3).each do |line|
-          @stderr.puts "  #{line.chomp}"
+        Console.pretty_backtrace(backtrace, limit: 3).each do |line|
+          @stderr.puts "  #{line}"
         end
       end