ace-test-runner-e2e 0.29.0

data/lib/ace/test/end_to_end_runner/molecules/simple_display_manager.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Ace
+  module Test
+    module EndToEndRunner
+      module Molecules
+        # Line-by-line display manager for E2E test output (default mode).
+        # Optimized for piping, log capture, and agent consumption.
+        # No ANSI cursor control — each event appends a new line.
+        class SimpleDisplayManager
+          # @param scenarios [Array<Models::TestScenario>] tests to run
+          # @param output [IO] output stream
+          # @param parallel [Integer] parallelism level
+          def initialize(scenarios, output:, parallel:)
+            @scenarios = scenarios
+            @output = output
+            @parallel = parallel
+            @use_color = output.respond_to?(:tty?) && output.tty?
+            @start_time = Time.now
+          end
+
+          # Print header showing test count and parallelism
+          def initialize_display
+            package = @scenarios.first&.package || "unknown"
+            @output.puts "Discovered #{@scenarios.size} E2E tests in #{package}"
+            @output.puts "Running with parallelism: #{@parallel}" if @parallel > 1
+          end
+
+          # Print line when a test begins
+          # @param scenario [Models::TestScenario]
+          def test_started(scenario)
+            @output.puts "[started] #{scenario.test_id}: #{scenario.title}"
+          end
+
+          # Print line when a test completes
+          # @param scenario [Models::TestScenario]
+          # @param result [Models::TestResult]
+          # @param completed [Integer] number completed so far
+          # @param total [Integer] total number of tests
+          def test_completed(scenario, result, completed, total)
+            h = Atoms::DisplayHelpers
+            icon = h.color(h.status_icon(result.success?), result.success? ? :green : :red, use_color: @use_color)
+            elapsed = h.format_elapsed(result.duration)
+            tc = h.tc_count_display(result)
+
+            @output.puts "[#{completed}/#{total}] #{icon}  #{elapsed}  #{scenario.test_id}  #{result.status.upcase}#{tc}"
+          end
+
+          # Print a single-test result line (for run-single-test mode)
+          # @param result [Models::TestResult]
+          def show_single_result(result)
+            @output.puts Atoms::DisplayHelpers.format_single_result(result, use_color: @use_color)
+          end
+
+          # No-op — simple mode doesn't need refresh
+          def refresh
+          end
+
+          # Print structured summary block
+          # @param results [Array<Models::TestResult>]
+          # @param report_path [String]
+          def show_summary(results, report_path)
+            lines = Atoms::DisplayHelpers.format_summary_lines(
+              results, Time.now - @start_time, report_path, use_color: @use_color
+            )
+            lines.each { |line| @output.puts line }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ace/test/end_to_end_runner/molecules/suite_progress_display_manager.rb

@@ -0,0 +1,223 @@
+# frozen_string_literal: true
+
+module Ace
+  module Test
+    module EndToEndRunner
+      module Molecules
+        # Animated ANSI table display manager for suite-level E2E test output (--progress mode).
+        # Updates test rows in place using cursor movement escape codes.
+        # Modeled on ProgressDisplayManager for visual consistency.
+        class SuiteProgressDisplayManager
+          # @param test_queue [Array<Hash>] flat list of {package:, test_file:} items
+          # @param output [IO] output stream
+          # @param use_color [Boolean] enable ANSI color
+          # @param pkg_width [Integer] column width for package names
+          # @param name_width [Integer] column width for test names
+          def initialize(test_queue, output:, use_color:, pkg_width:, name_width:)
+            @test_queue = test_queue
+            @output = output
+            @use_color = use_color
+            @pkg_width = pkg_width
+            @name_width = name_width
+            @start_time = Time.now
+            @last_refresh = Time.at(0)
+
+            # Build row map: "package:test_file" => line number
+            @rows = {}
+            @states = {}      # key => :waiting | :running | :completed
+            @results = {}     # key => result hash
+            @started_at = {}  # key => Time
+
+            @test_queue.each_with_index do |item, index|
+              key = row_key(item[:package], item[:test_file])
+              @rows[key] = index + 5  # account for header lines (sep + title + sep + blank)
+              @states[key] = :waiting
+            end
+          end
+
+          # Clear screen, print header, pre-render all rows as "waiting", print footer
+          # @param total_tests [Integer]
+          # @param pkg_count [Integer]
+          def show_header(total_tests, pkg_count)
+            dh = Atoms::DisplayHelpers
+
+            # Clear screen (preserves scrollback)
+            @output.print "\033[H\033[J"
+
+            @output.puts dh.double_separator
+            @output.puts "  ACE E2E Test Suite - Running #{total_tests} tests across #{pkg_count} packages"
+            @output.puts dh.double_separator
+            @output.puts
+
+            # Pre-render all rows in waiting state
+            @test_queue.each do |item|
+              print_row(item[:package], item[:test_file])
+            end
+
+            @output.puts
+            @output.puts
+            # Guard against empty queue: default to current line if no rows
+            @footer_line = @rows.values.max + 3 if @rows.values.any?
+            update_footer
+          end
+
+          # Update row to "running" state
+          # @param package [String]
+          # @param test_file [String]
+          def test_started(package, test_file)
+            key = row_key(package, test_file)
+            @states[key] = :running
+            @started_at[key] = Time.now
+            print_row(package, test_file)
+            update_footer
+          end
+
+          # Update row to completed state with result
+          # @param result [Hash] with :status, :passed_cases, :total_cases
+          # @param package [String]
+          # @param test_file [String]
+          # @param elapsed [Numeric] seconds
+          def test_completed(result, package, test_file, elapsed)
+            key = row_key(package, test_file)
+            @states[key] = :completed
+            @results[key] = result.merge(elapsed: elapsed)
+            print_row(package, test_file)
+            update_footer
+          end
+
+          # Refresh running rows to update elapsed timers + footer
+          # Throttled to ~4Hz — the poll loop runs at 10Hz but redraws are expensive
+          def refresh
+            now = Time.now
+            return if now - @last_refresh < REFRESH_INTERVAL
+
+            @last_refresh = now
+
+            @states.each do |key, state|
+              next unless state == :running
+
+              item = find_item(key)
+              print_row(item[:package], item[:test_file]) if item
+            end
+            update_footer
+          end
+
+          # Move past the table area and print summary
+          # @param results [Hash] with :total, :passed, :failed, :errors, :packages
+          # @param duration [Numeric] total elapsed seconds
+          def show_summary(results, duration)
+            move_to_line((@footer_line || 6) + 1)
+            @output.puts
+
+            failed_details = collect_failed_details(results)
+
+            lines = Atoms::DisplayHelpers.format_suite_summary(
+              {
+                total: results[:total],
+                passed: results[:passed],
+                failed: results[:failed],
+                errors: results[:errors],
+                total_cases: results[:total_cases] || 0,
+                passed_cases: results[:passed_cases] || 0,
+                duration: duration,
+                failed_details: failed_details
+              },
+              use_color: @use_color
+            )
+
+            lines.each { |line| @output.puts line }
+          end
+
+          private
+
+          def row_key(package, test_file)
+            "#{package}:#{test_file}"
+          end
+
+          def find_item(key)
+            @test_queue.find { |item| row_key(item[:package], item[:test_file]) == key }
+          end
+
+          def extract_test_name(test_file)
+            File.basename(File.dirname(test_file))
+          end
+
+          def print_row(package, test_file)
+            dh = Atoms::DisplayHelpers
+            key = row_key(package, test_file)
+            line = @rows[key]
+            state = @states[key]
+            test_name = extract_test_name(test_file)
+
+            move_to_line(line)
+            @output.print "\033[K" # clear line
+
+            pkg_col = package.ljust(@pkg_width)
+            name_col = test_name.ljust(@name_width)
+
+            case state
+            when :waiting
+              icon = dh.color(dh.waiting_icon, :gray, use_color: @use_color)
+              elapsed = "      -"
+              @output.print "#{icon}  #{elapsed}  #{pkg_col}  #{name_col}  waiting"
+
+            when :running
+              icon = dh.color(dh.running_icon, :cyan, use_color: @use_color)
+              secs = Time.now - (@started_at[key] || Time.now)
+              elapsed = dh.format_suite_elapsed(secs)
+              @output.print "#{icon}  #{elapsed}  #{pkg_col}  #{name_col}  running"
+
+            when :completed
+              result = @results[key]
+              success = result[:status] == "pass"
+              icon = dh.color(dh.status_icon(success), success ? :green : :red, use_color: @use_color)
+              elapsed = dh.format_suite_elapsed(result[:elapsed])
+
+              cases_str = ""
+              if result[:total_cases] && result[:total_cases] > 0
+                cases_str = "#{result[:passed_cases]}/#{result[:total_cases]} cases"
+              end
+
+              @output.print "#{icon}  #{elapsed}  #{pkg_col}  #{name_col}  #{cases_str}"
+            end
+          end
+
+          def update_footer
+            return unless @footer_line
+
+            move_to_line(@footer_line)
+            @output.print "\033[K"
+
+            active = @states.count { |_, s| s == :running }
+            completed = @states.count { |_, s| s == :completed }
+            waiting = @states.count { |_, s| s == :waiting }
+
+            @output.print "Active: #{active} | Completed: #{completed} | Waiting: #{waiting}"
+          end
+
+          def move_to_line(line)
+            @output.print "\033[#{line};1H"
+          end
+
+          def collect_failed_details(results)
+            failed_details = []
+            results[:packages].each do |package, test_results|
+              test_results.each do |result|
+                next if result[:status] == "pass"
+
+                test_name = result[:test_name] || "unknown"
+                cases = if result[:total_cases] && result[:total_cases] > 0
+                  "#{result[:passed_cases]}/#{result[:total_cases]} cases"
+                else
+                  result[:error] || result[:summary] || "failed"
+                end
+                failed_details << {package: package, test_name: test_name, cases: cases}
+              end
+            end
+            failed_details
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ace/test/end_to_end_runner/molecules/suite_report_writer.rb

@@ -0,0 +1,277 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "yaml"
+require "ace/llm"
+require "ace/llm/query_interface"
+
+module Ace
+  module Test
+    module EndToEndRunner
+      module Molecules
+        # Writes a suite-level final report aggregating all test results
+        #
+        # Uses LLM synthesis to generate rich reports with root cause analysis,
+        # friction insights, and improvement suggestions. Falls back to a static
+        # template on LLM failure.
+        class SuiteReportWriter
+          # @param config [Hash, nil] Configuration hash (reads reporting.model and reporting.timeout)
+          def initialize(config: nil)
+            reporting = (config || {}).dig("reporting") || {}
+            @model = reporting["model"] || "glite"
+            @timeout = reporting["timeout"] || 60
+          end
+
+          # Write a suite-level final report
+          #
+          # @param results [Array<Models::TestResult>] Test results (ordered)
+          # @param scenarios [Array<Models::TestScenario>] Corresponding scenarios
+          # @param package [String] Package name (e.g., "ace-lint")
+          # @param timestamp [String] Timestamp ID for this run
+          # @param base_dir [String] Base directory for cache output
+          # @return [String] Path to the written report file
+          def write(results, scenarios, package:, timestamp:, base_dir:)
+            cache_dir = File.join(base_dir, ".ace-local", "test-e2e")
+            FileUtils.mkdir_p(cache_dir)
+
+            report_path = File.join(cache_dir, "#{timestamp}-final-report.md")
+
+            overall_status = compute_status(results)
+            executed_at = Time.now.utc.strftime("%Y-%m-%dT%H:%M:%SZ")
+
+            content = synthesize_report(
+              results, scenarios,
+              package: package,
+              timestamp: timestamp,
+              overall_status: overall_status,
+              executed_at: executed_at
+            )
+
+            File.write(report_path, content)
+            report_path
+          end
+
+          private
+
+          # Attempt LLM synthesis, falling back to static template
+          def synthesize_report(results, scenarios, package:, timestamp:, overall_status:, executed_at:)
+            results_data = build_results_data(results, scenarios)
+
+            prompt_builder = Atoms::SuiteReportPromptBuilder.new
+            user_prompt = prompt_builder.build(
+              results_data,
+              package: package,
+              timestamp: timestamp,
+              overall_status: overall_status,
+              executed_at: executed_at
+            )
+
+            response = Ace::LLM::QueryInterface.query(
+              @model,
+              user_prompt,
+              system: Atoms::SuiteReportPromptBuilder::SYSTEM_PROMPT,
+              timeout: @timeout,
+              temperature: 0.3
+            )
+
+            total_passed = results.sum(&:passed_count)
+            total_tc = results.sum(&:total_count)
+            validate_overall_line(response[:text], total_passed, total_tc)
+          rescue => e
+            # LLM failed — fall back to static report
+            warn "Warning: LLM synthesis failed (#{e.class}: #{e.message}), using static report" if ENV["DEBUG"]
+            executed_date = Time.now.utc.strftime("%Y-%m-%d")
+            total_passed = results.sum(&:passed_count)
+            total_failed = results.sum(&:failed_count)
+            total_tc = results.sum(&:total_count)
+
+            build_static_report(
+              results, scenarios,
+              package: package,
+              timestamp: timestamp,
+              overall_status: overall_status,
+              executed_at: executed_at,
+              executed_date: executed_date,
+              total_passed: total_passed,
+              total_failed: total_failed,
+              total_tc: total_tc
+            )
+          end
+
+          # Read summary and experience report content from each result's report dir
+          def build_results_data(results, scenarios)
+            results.each_with_index.map do |result, i|
+              scenario = scenarios[i]
+              report_dir = result.report_dir
+
+              summary_content = read_report_file(report_dir, "summary.r.md")
+              experience_content = read_report_file(report_dir, "experience.r.md")
+
+              {
+                test_id: result.test_id,
+                title: scenario.title,
+                status: result.status,
+                passed: result.passed_count,
+                failed: result.failed_count,
+                total: result.total_count,
+                test_cases: result.test_cases,
+                report_dir_name: report_dir ? File.basename(report_dir) : nil,
+                summary_content: summary_content,
+                experience_content: experience_content
+              }
+            end
+          end
+
+          # Safely read a report file, returning nil if missing
+          def read_report_file(report_dir, filename)
+            return nil unless report_dir
+
+            path = File.join(report_dir, filename)
+            return nil unless File.exist?(path)
+
+            File.read(path)
+          end
+
+          # Validate the LLM-generated Overall line against deterministic totals.
+          # If the LLM hallucinated wrong numbers, replace the line with correct values.
+          def validate_overall_line(report_text, expected_passed, expected_total)
+            expected_pct = (expected_total > 0) ? (expected_passed * 100.0 / expected_total).round(0) : 0
+            correct_line = "**Overall:** #{expected_passed}/#{expected_total} test cases passed (#{expected_pct}%)"
+
+            # Match patterns like "**Overall:** X/Y test cases passed (Z%)"
+            overall_pattern = /\*\*Overall:\*\*\s*\d+\/\d+\s+test cases passed\s*\(\d+%\)/
+
+            if report_text.match?(overall_pattern)
+              report_text.gsub(overall_pattern, correct_line)
+            else
+              # No Overall line found — append the correct one after the summary table
+              "#{report_text.rstrip}\n\n#{correct_line}\n"
+            end
+          end
+
+          def compute_status(results)
+            # Filter out skipped tests for status computation
+            executed = results.reject(&:skipped?)
+            return "skip" if executed.empty?
+
+            if executed.all?(&:success?)
+              "pass"
+            elsif executed.any?(&:success?)
+              "partial"
+            else
+              "fail"
+            end
+          end
+
+          # Static fallback report (original template-based approach)
+          def build_static_report(results, scenarios, package:, timestamp:, overall_status:,
+            executed_at:, executed_date:, total_passed:, total_failed:, total_tc:)
+            total_skipped = results.count(&:skipped?)
+
+            parts = []
+            parts << build_frontmatter(
+              timestamp: timestamp, package: package, overall_status: overall_status,
+              tests_run: results.size, executed_at: executed_at, skipped: total_skipped
+            )
+            parts << build_header(package: package, tests_run: results.size, executed_date: executed_date, skipped: total_skipped)
+            parts << build_summary_table(results, scenarios)
+            parts << build_overall_line(total_passed: total_passed, total_tc: total_tc)
+            parts << build_failed_section(results, scenarios) if results.any?(&:failed?)
+            parts << build_reports_section(results, scenarios)
+            parts.join("\n")
+          end
+
+          def build_frontmatter(timestamp:, package:, overall_status:, tests_run:, executed_at:, skipped: 0)
+            skipped_line = (skipped > 0) ? "\nskipped: #{skipped}" : ""
+            <<~FRONTMATTER
+              ---
+              suite-id: #{timestamp}
+              package: #{package}
+              status: #{overall_status}
+              tests-run: #{tests_run}#{skipped_line}
+              executed: #{executed_at}
+              ---
+            FRONTMATTER
+          end
+
+          def build_header(package:, tests_run:, executed_date:, skipped: 0)
+            skipped_info = (skipped > 0) ? " (#{skipped} skipped)" : ""
+            <<~HEADER
+              # E2E Test Suite Report
+
+              **Package:** #{package}
+              **Tests:** #{tests_run}#{skipped_info}
+              **Executed:** #{executed_date}
+            HEADER
+          end
+
+          def build_summary_table(results, scenarios)
+            rows = results.each_with_index.map do |result, i|
+              scenario = scenarios[i]
+              status_label = result.status.capitalize
+              passed = result.skipped? ? "-" : result.passed_count.to_s
+              failed = result.skipped? ? "-" : result.failed_count.to_s
+              total = result.skipped? ? "-" : result.total_count.to_s
+              "| #{result.test_id} | #{scenario.title} | #{status_label} | #{passed} | #{failed} | #{total} |"
+            end
+
+            <<~TABLE
+              ## Summary
+
+              | Test ID | Title | Status | Passed | Failed | Total |
+              |---------|-------|--------|--------|--------|-------|
+              #{rows.join("\n")}
+            TABLE
+          end
+
+          def build_overall_line(total_passed:, total_tc:)
+            pct = (total_tc > 0) ? (total_passed * 100.0 / total_tc).round(0) : 0
+            "**Overall:** #{total_passed}/#{total_tc} test cases passed (#{pct}%)\n"
+          end
+
+          def build_failed_section(results, scenarios)
+            parts = ["\n## Failed Tests\n"]
+
+            results.each_with_index do |result, i|
+              next if result.success? || result.skipped?
+
+              scenario = scenarios[i]
+              parts << "### #{result.test_id}: #{scenario.title} (#{result.passed_count}/#{result.total_count})\n"
+
+              failed_tcs = result.test_cases.select { |tc| tc[:status] == "fail" }
+              if failed_tcs.any?
+                parts << "**Failed Test Cases:**"
+                failed_tcs.each do |tc|
+                  parts << "- #{tc[:id]}: #{tc[:description]}"
+                end
+                parts << ""
+              end
+
+              if result.report_dir
+                parts << "**Report:** #{result.report_dir}\n"
+              end
+            end
+
+            parts.join("\n")
+          end
+
+          def build_reports_section(results, scenarios)
+            rows = results.each_with_index.map do |result, i|
+              dir = result.report_dir ? File.basename(result.report_dir) : "N/A"
+              "| #{result.test_id} | #{dir} |"
+            end
+
+            <<~SECTION
+
+              ## Reports
+
+              | Test ID | Reports Folder |
+              |---------|----------------|
+              #{rows.join("\n")}
+            SECTION
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ace/test/end_to_end_runner/molecules/suite_simple_display_manager.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module Ace
+  module Test
+    module EndToEndRunner
+      module Molecules
+        # Line-by-line display manager for suite-level E2E test output (default mode).
+        # Extracted from SuiteOrchestrator to match the display manager pattern
+        # used by TestOrchestrator (SimpleDisplayManager / ProgressDisplayManager).
+        class SuiteSimpleDisplayManager
+          # @param test_queue [Array<Hash>] flat list of {package:, test_file:} items
+          # @param output [IO] output stream
+          # @param use_color [Boolean] enable ANSI color
+          # @param pkg_width [Integer] column width for package names
+          # @param name_width [Integer] column width for test names
+          def initialize(test_queue, output:, use_color:, pkg_width:, name_width:)
+            @test_queue = test_queue
+            @output = output
+            @use_color = use_color
+            @pkg_width = pkg_width
+            @name_width = name_width
+          end
+
+          # Print suite header with separator, title, separator
+          # @param total_tests [Integer]
+          # @param pkg_count [Integer]
+          def show_header(total_tests, pkg_count)
+            dh = Atoms::DisplayHelpers
+            @output.puts dh.double_separator
+            @output.puts "  ACE E2E Test Suite - Running #{total_tests} tests across #{pkg_count} packages"
+            @output.puts dh.double_separator
+            @output.puts
+          end
+
+          # No-op — simple mode doesn't show start events
+          def test_started(_package, _test_file)
+          end
+
+          # Print a columnar result line
+          # @param result [Hash] with :status, :passed_cases, :total_cases
+          # @param package [String]
+          # @param test_file [String]
+          # @param elapsed [Numeric] seconds
+          def test_completed(result, package, test_file, elapsed)
+            dh = Atoms::DisplayHelpers
+            success = result[:status] == "pass"
+            icon = dh.color(dh.status_icon(success), success ? :green : :red, use_color: @use_color)
+            test_name = extract_test_name(test_file)
+
+            cases_str = ""
+            if result[:total_cases] && result[:total_cases] > 0
+              cases_str = "#{result[:passed_cases]}/#{result[:total_cases]} cases"
+            end
+
+            line = dh.format_suite_test_line(
+              icon, elapsed, package, test_name, cases_str,
+              pkg_width: @pkg_width, name_width: @name_width
+            )
+            @output.puts line
+          end
+
+          # No-op — simple mode doesn't need refresh
+          def refresh
+          end
+
+          # Print structured summary block
+          # @param results [Hash] with :total, :passed, :failed, :errors, :packages
+          # @param duration [Numeric] total elapsed seconds
+          def show_summary(results, duration)
+            failed_details = collect_failed_details(results)
+
+            lines = Atoms::DisplayHelpers.format_suite_summary(
+              {
+                total: results[:total],
+                passed: results[:passed],
+                failed: results[:failed],
+                errors: results[:errors],
+                total_cases: results[:total_cases] || 0,
+                passed_cases: results[:passed_cases] || 0,
+                duration: duration,
+                failed_details: failed_details
+              },
+              use_color: @use_color
+            )
+
+            lines.each { |line| @output.puts line }
+          end
+
+          private
+
+          def extract_test_name(test_file)
+            File.basename(File.dirname(test_file))
+          end
+
+          def collect_failed_details(results)
+            failed_details = []
+            results[:packages].each do |package, test_results|
+              test_results.each do |result|
+                next if result[:status] == "pass"
+
+                test_name = result[:test_name] || "unknown"
+                cases = if result[:total_cases] && result[:total_cases] > 0
+                  "#{result[:passed_cases]}/#{result[:total_cases]} cases"
+                else
+                  result[:error] || result[:summary] || "failed"
+                end
+                failed_details << {package: package, test_name: test_name, cases: cases}
+              end
+            end
+            failed_details
+          end
+        end
+      end
+    end
+  end
+end