tryouts 3.4.0 → 3.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6b0f0a0ca7de83a58c4e822d127a963bb1fb08523d9146b24c8b33f8a2c12ff2
-  data.tar.gz: 2f4e61611e23176da42cc9bbf82a92a2cc1e9d6049943fd4d4827dcd2b34c84f
+  metadata.gz: ab0eb9c341b10dd5e505a3f62cc33a19a393cb294aecd756809b19c2484784f1
+  data.tar.gz: cddfd1a827b0ef37a9e69224124f2f696bbd8c2f098edbfce79b563b3017fbcd
 SHA512:
-  metadata.gz: 1505d26c47b4fb3fb75675425e6aaac3e1ba81b6f39ac8ae47622ae43acd0c19a13a16e82486663de0201f21bf7b997281744fc6d69cae6116e67065803b4a39
-  data.tar.gz: ca57f3c38348023c57f5e382fe8b45e29877393fae155a718c921550b4a2200b0fe37c1c31be4f41dcbc934527d8c6b53e74fbe88fcc574c53cbc3d765bb3534
+  metadata.gz: 066b7697b04b3501f01a0994e9d10a66c5a94d593bdfa5cb1b618bb1264f228425bd7d8b4d98cf9a555a5e23bbe002f137c943d5195ad4ce972de30f03dfac9c
+  data.tar.gz: 82390327e8da8e35d0c9eaa4557800b09bba76e065704f9d704acab45ab24dd62e97edc7aa54d8104ee50cab31a9dab321c75449386f70243674c8f2d838716a

data/README.md

@@ -1,4 +1,4 @@
-# Tryouts v3
+# Tryouts - A Ruby Testing Framework
 
 **Ruby tests that read like documentation.**
 
@@ -130,6 +130,21 @@ 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
@@ -162,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

@@ -38,19 +38,28 @@ require_relative '../lib/tryouts'
 lib_glob = File.join(Dir.pwd, '{lib,../lib,.}')
 Tryouts.update_load_path(lib_glob) if Tryouts.respond_to?(:update_load_path)
 
+# Capture original command for agent mode before ARGV gets modified
+original_command = [$0] + ARGV
+
 # Parse args and run CLI
 begin
   files, options = Tryouts::CLI.parse_args(ARGV)
 
-  # Expand files if directories are given
+  # Add original command to options for agent formatter
+  options[:original_command] = original_command
+
+  # 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

@@ -4,13 +4,42 @@ 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
+    # TOPA (Test Output Protocol for AI) Formatter
+    #
+    # Language-agnostic test output format designed for LLM context management.
+    # This formatter implements the TOPA v1.0 specification for structured,
+    # token-efficient test result communication.
+    #
+    # TOPA Features:
+    # - Language-agnostic field naming (snake_case, hierarchical)
+    # - Standardized execution context (runtime, environment, VCS)
+    # - Token budget awareness with smart truncation
+    # - Cross-platform compatibility (CI/CD, package managers)
+    # - Structured failure reporting with diffs
+    # - Protocol versioning for forward compatibility
+    #
+    # Field Specifications:
+    # - command: Exact command executed
+    # - process_id: System process identifier
+    # - runtime: Language, version, platform info
+    # - package_manager: Dependency management system
+    # - version_control: VCS branch/commit info
+    # - environment: Normalized env vars (ci_system, app_env, etc.)
+    # - test_framework: Framework name, isolation mode, parser
+    # - execution_flags: Runtime flags in normalized form
+    # - protocol: TOPA version and configuration
+    # - project: Auto-detected project type
+    # - test_discovery: File pattern matching rules
+    #
+    # Compatible with: Ruby/RSpec/Minitest, Python/pytest/unittest,
+    # JavaScript/Jest/Mocha, Java/JUnit, Go, C#/NUnit, and more.
+    #
+    # Language Adaptation Examples:
+    # Python: runtime.language=python, package_manager.name=pip/poetry/conda
+    # Node.js: runtime.language=javascript, package_manager.name=npm/yarn/pnpm
+    # Java: runtime.language=java, package_manager.name=maven/gradle
+    # Go: runtime.language=go, package_manager.name=go_modules
+    # C#: runtime.language=csharp, package_manager.name=nuget/dotnet
     class AgentFormatter
       include FormatterInterface
 
@@ -22,6 +51,9 @@ class Tryouts
         @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
@@ -42,7 +74,8 @@ class Tryouts
           tests: 0,
           failures: [],
           errors: [],
-          passed: 0
+          passed: 0,
+          context_info: context_info  # Store context info for later display
         }
       end
 
@@ -56,19 +89,47 @@ class Tryouts
       end
 
       def file_parsed(_file_path, test_count:, setup_present: false, teardown_present: false)
-        @current_file_data[:tests] = test_count if @current_file_data
+        if @current_file_data
+          @current_file_data[:tests] = test_count
+        end
         @total_stats[:tests] += test_count
       end
 
-      def file_result(_file_path, total_tests:, failed_count:, error_count:, elapsed_time: nil)
+      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 when available
-        if @current_file_data
-          @current_file_data[:passed] = total_tests - failed_count - error_count
+        # 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
 
@@ -135,6 +196,14 @@ class Tryouts
         @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
         {
@@ -209,50 +278,71 @@ class Tryouts
       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
-          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)"
+          status_parts << "FAIL: #{issues_count}/#{@total_stats[:tests]} tests (#{details.join(', ')}, #{passed_count} passed)"
         else
-          status = "PASS: #{@total_stats[:tests]} tests passed"
+          # Agent doesn't need output in the positive case (i.e. for passing
+          # tests). It just fills out the context window.
         end
 
-        status += " (#{format_time(@total_stats[:elapsed])})" if @total_stats[:elapsed]
+        status_parts << "(#{format_time(@total_stats[:elapsed])})" if @total_stats[:elapsed]
 
-        output << status
+        output << status_parts.join(" ")
+
+        # Always show file information for agent context
+        output << ""
 
-        # 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:"
+          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")
+        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?
-          puts "No critical errors found"
+          output << "No critical errors found"
+          puts output.join("\n")
           return
         end
 
-        output = []
         output << "CRITICAL: #{critical_files.size} file#{'s' if critical_files.size != 1} with errors"
         output << ""
 
@@ -283,39 +373,21 @@ class Tryouts
       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)
+        # Add execution context header for agent clarity
+        output << render_execution_context
+        output << ""
 
-        # 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
+        # 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
 
-        if files_to_show.any?
-          output << ""
-          @budget.consume("\n")
+        # Show files with issues only
+        files_with_issues = @collected_files.select { |f| f[:failures].any? || f[:errors].any? }
 
-          files_to_show.each do |file_data|
+        if files_with_issues.any?
+          files_with_issues.each do |file_data|
             break unless @budget.has_budget?
 
             file_section = render_file_section(file_data)
@@ -329,14 +401,15 @@ class Tryouts
               @budget.consume(file_section)
             end
           end
+          output << ""
         end
 
         # Final summary line
-        summary = "Summary: #{passed_count} passed, #{@total_stats[:failures]} failed"
-        summary += ", #{@total_stats[:errors]} errors" if @total_stats[:errors] > 0
+        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 << ""
         output << summary
 
         puts output.join("\n")
@@ -348,6 +421,20 @@ class Tryouts
         # 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
@@ -445,6 +532,199 @@ class Tryouts
           "#{seconds.round(2)}s"
         end
       end
+
+      def render_execution_context
+        context_lines = []
+        context_lines << "EXECUTION_CONTEXT:"
+
+        # Command that was executed
+        if @options[:original_command]
+          command_str = @options[:original_command].join(' ')
+          context_lines << "  command: #{command_str}"
+        end
+
+        # Compact system info on one line when possible
+        context_lines << "  pid: #{Process.pid} | pwd: #{Dir.pwd}"
+
+        # Runtime - compact format
+        platform = RUBY_PLATFORM.gsub(/darwin\d+/, 'darwin')  # Simplify darwin25 -> darwin
+        context_lines << "  runtime: ruby #{RUBY_VERSION} (#{platform})"
+
+        # Package manager - only if present, compact format
+        if defined?(Bundler)
+          context_lines << "  package_manager: bundler #{Bundler::VERSION}"
+        end
+
+        # Version control - compact single line with timeout protection
+        git_info = safe_git_info
+        if git_info[:branch] && git_info[:commit] && !git_info[:branch].empty? && !git_info[:commit].empty?
+          context_lines << "  vcs: git #{git_info[:branch]}@#{git_info[:commit]}"
+        end
+
+        # Environment - only non-defaults
+        env_vars = build_environment_context
+        if env_vars.any?
+          # Compact key=value format
+          env_str = env_vars.map { |k, v| "#{k}=#{v}" }.join(', ')
+          context_lines << "  environment: #{env_str}"
+        end
+
+        # Test framework - compact critical info only
+        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
+
+        isolation = shared_context ? 'shared' : 'isolated'
+        context_lines << "  test_framework: #{framework} (#{isolation})"
+
+        # Execution flags - only if non-standard
+        flags = build_execution_flags
+        if flags.any?
+          context_lines << "  flags: #{flags.join(', ')}"
+        end
+
+        # TOPA protocol - compact
+        context_lines << "  protocol: TOPA v1.0 | focus: #{@focus_mode} | limit: #{@budget.limit}"
+
+        # File count being tested
+        if @collected_files && @collected_files.any?
+          context_lines << "  files_under_test: #{@collected_files.size}"
+        elsif @total_stats[:files] && @total_stats[:files] > 0
+          context_lines << "  files_under_test: #{@total_stats[:files]}"
+        end
+
+        # 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
+
+      # Build environment context with language-agnostic keys
+      def build_environment_context
+        env_vars = {}
+
+        # CI/CD detection - prioritize most specific
+        if ENV['GITHUB_ACTIONS']
+          env_vars['CI'] = 'github'
+        elsif ENV['GITLAB_CI']
+          env_vars['CI'] = 'gitlab'
+        elsif ENV['JENKINS_URL']
+          env_vars['CI'] = 'jenkins'
+        elsif ENV['CI']
+          env_vars['CI'] = 'true'
+        end
+
+        # Runtime environment - only if not default
+        if ENV['RAILS_ENV'] && ENV['RAILS_ENV'] != 'development'
+          env_vars['ENV'] = ENV['RAILS_ENV']
+        elsif ENV['RACK_ENV'] && ENV['RACK_ENV'] != 'development'
+          env_vars['ENV'] = ENV['RACK_ENV']
+        elsif ENV['NODE_ENV'] && ENV['NODE_ENV'] != 'development'
+          env_vars['ENV'] = ENV['NODE_ENV']
+        end
+
+        # Coverage - simplified
+        env_vars['COV'] = '1' if ENV['COVERAGE'] || ENV['SIMPLECOV']
+
+        # Test seed for reproducibility
+        env_vars['SEED'] = ENV['SEED'] if ENV['SEED']
+
+        env_vars
+      end
+
+      # Build execution flags in language-agnostic format
+      def build_execution_flags
+        flags = []
+        flags << "verbose" if @options[:verbose]
+        flags << "fails-only" if @options[:fails_only]
+        flags << "debug" if @options[:debug]
+        flags << "traces" if @options[:stack_traces] && !@options[:debug]  # debug implies traces
+        flags << "parallel" if @options[:parallel]
+        flags << "line-spec" if @options[:line_spec]
+        flags << "strict" if @options[:strict]
+        flags << "quiet" if @options[:quiet]
+        flags
+      end
+
+      # Get test discovery patterns in language-agnostic format
+      def get_test_discovery_patterns
+        patterns = []
+
+        # Ruby/Tryouts patterns
+        patterns.concat([
+          "**/*_try.rb",
+          "**/*.try.rb",
+          "try/**/*.rb",
+          "tryouts/**/*.rb"
+        ])
+
+        # TOPA-compatible patterns for other languages:
+        # Python: ["**/*_test.py", "**/test_*.py", "tests/**/*.py"]
+        # JavaScript: ["**/*.test.js", "**/*.spec.js", "__tests__/**/*.js"]
+        # Java: ["**/*Test.java", "**/Test*.java", "src/test/**/*.java"]
+        # Go: ["**/*_test.go"]
+        # C#: ["**/*Test.cs", "**/*Tests.cs"]
+        # PHP: ["**/*Test.php", "tests/**/*.php"]
+        # Rust: ["**/*_test.rs", "tests/**/*.rs"]
+
+        patterns
+      end
+
+      private
+
+      # Safely get git information with timeout protection
+      def safe_git_info
+        # Check if we're in a git repository
+        return {} unless File.directory?('.git') || system('git rev-parse --git-dir >/dev/null 2>&1')
+
+        require 'timeout'
+
+        Timeout.timeout(2) do
+          branch = `git rev-parse --abbrev-ref HEAD 2>/dev/null`.strip
+          commit = `git rev-parse --short HEAD 2>/dev/null`.strip
+
+          # Validate output to prevent injection
+          branch = nil unless branch =~ /\A[\w\-\/\.]+\z/
+          commit = nil unless commit =~ /\A[a-f0-9]+\z/i
+
+          { branch: branch, commit: commit }
+        end
+      rescue Timeout::Error, StandardError
+        # Return empty hash on any error (timeout, permission, etc.)
+        {}
+      end
     end
   end
 end

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

@@ -33,6 +33,10 @@ class Tryouts
         # Default: no output
       end
 
+      def parser_warnings(file_path, warnings:)
+        # Default: no output - override in specific formatters
+      end
+
       def file_execution_start(file_path, test_count:, context_mode:)
         # Default: no output
       end
@@ -151,7 +155,7 @@ class Tryouts
       end
 
       def separator(style = :light)
-        width = @options.fetch(:line_width, 70)
+        width = @options.fetch(:line_width, 60)
         case style
         when :heavy
           '=' * width

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

@@ -44,9 +44,20 @@ class Tryouts
         @stderr.puts indent_text("Parsed #{test_count} tests#{suffix}", 1)
       end
 
+      def parser_warnings(file_path, warnings:)
+        return if warnings.empty? || !@options.fetch(:warnings, true)
+
+        @stderr.puts
+        @stderr.puts Console.color(:yellow, "Warnings:")
+        warnings.each do |warning|
+          @stderr.puts "  #{Console.pretty_path(file_path)}:#{warning.line_number}: #{warning.message}"
+        end
+      end
+
       def file_execution_start(file_path, test_count:, context_mode:)
         pretty_path = Console.pretty_path(file_path)
-        @stderr.puts "#{pretty_path}: #{test_count} tests"
+        puts
+        puts "#{pretty_path}: #{test_count} tests"
       end
 
       # Summary operations - show failure summary
@@ -204,7 +215,6 @@ class Tryouts
 
       def grand_total(total_tests:, failed_count:, error_count:, successful_files:, total_files:, elapsed_time:)
         @stderr.puts
-        @stderr.puts '=' * 50
 
         issues_count = failed_count + error_count
         if issues_count > 0
@@ -219,8 +229,8 @@ class Tryouts
 
         time_str = format_timing(elapsed_time)
 
-        @stderr.puts "Total: #{result}#{time_str}"
-        @stderr.puts "Files: #{successful_files} of #{total_files} successful"
+        @stderr.puts "#{result}#{time_str}"
+        @stderr.puts "#{successful_files} of #{total_files} files passed"
       end
 
       # Debug and diagnostic output - minimal in compact mode

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

@@ -57,6 +57,10 @@ class Tryouts
         )
       end
 
+      def parser_warnings(file_path, warnings:)
+        @formatter.parser_warnings(file_path, warnings: warnings)
+      end
+
       def file_execution_start(file_path, test_count, context_mode)
         @formatter.file_execution_start(
           file_path,