rspec-agents 0.1.0

data/lib/rspec/agents/prompt_builders/user_simulation.rb

@@ -0,0 +1,131 @@
+require "erb"
+
+module RSpec
+  module Agents
+    module PromptBuilders
+      # Builds prompts for simulating user messages
+      class UserSimulation < Base
+        DEFAULT_TEMPLATE_PATH = File.expand_path("../templates/user_simulation.erb", __dir__)
+
+        class << self
+          # Build a user simulation prompt
+          #
+          # @param config [SimulatorConfig] Simulator configuration
+          # @param conversation [Conversation] Current conversation state
+          # @param current_topic [Topic, nil] Current topic (for topic-specific overrides)
+          # @return [String] The complete prompt
+          def build(config, conversation, current_topic: nil)
+            effective_config = current_topic ? config.for_topic(current_topic.name) : config
+            template_path = effective_config.template || DEFAULT_TEMPLATE_PATH
+
+            render_template(template_path, effective_config, conversation)
+          end
+
+          # Parse the response (typically just the raw text)
+          #
+          # @param response [LLM::Response] The LLM response
+          # @return [String] The user message
+          def parse(response)
+            text = response.respond_to?(:text) ? response.text : response.to_s
+            # Clean up any quotes or prefixes the LLM might add
+            text.strip
+                .gsub(/^["']|["']$/, "")
+                .gsub(/^User:\s*/i, "")
+                .strip
+          end
+
+          private
+
+          def render_template(template_path, config, conversation)
+            template_content = File.read(template_path)
+            erb = ERB.new(template_content, trim_mode: "-")
+
+            # Variables available in the template
+            system_section = build_system_section(config)
+            conversation_section = build_conversation_section(conversation)
+            rules_section = build_rules_section(config, conversation)
+            turn_count = conversation.turns.count
+
+            erb.result(binding)
+          end
+
+          def build_system_section(config)
+            parts = ["## Your Role"]
+            parts << "You are pretending to be a user testing an AI agent."
+            parts << "Approach this naturally, as a human user would."
+            parts << ""
+
+            role_items = config.effective_role
+            if role_items.any?
+              parts << "### Character"
+              parts.concat(role_items)
+              parts << ""
+            end
+
+            personality_items = config.effective_personality
+            if personality_items.any?
+              parts << "### Personality"
+              parts.concat(personality_items)
+              parts << ""
+            end
+
+            context_items = config.effective_context
+            if context_items.any?
+              parts << "### Context"
+              parts.concat(context_items)
+              parts << ""
+            end
+
+            if config.goal
+              parts << "### Goal"
+              parts << "Your goal is: #{config.goal}"
+              parts << ""
+            end
+
+            parts.join("\n")
+          end
+
+          def build_conversation_section(conversation)
+            if conversation.messages.empty?
+              return "## Conversation So Far\nThis is the start of the conversation. Send your opening message."
+            end
+
+            parts = ["## Conversation So Far"]
+            conversation.messages.each do |msg|
+              # Flip roles: in conversation, "agent" is who user is talking to
+              display_role = msg.role == :agent ? "Agent" : "You"
+              parts << "#{display_role}: #{msg.content}"
+            end
+
+            parts.join("\n")
+          end
+
+          def build_rules_section(config, conversation)
+            rules = config.rules || []
+            return "" if rules.empty?
+
+            parts = ["## Rules to Follow"]
+
+            rules.each do |rule|
+              case rule[:type]
+              when :should
+                parts << "- You SHOULD: #{rule[:text]}"
+              when :should_not
+                parts << "- You should NOT: #{rule[:text]}"
+              when :dynamic
+                # Evaluate dynamic rule
+                if rule[:block]
+                  last_turn = conversation.turns.last
+                  dynamic_text = rule[:block].call(last_turn&.agent_response, conversation)
+                  parts << "- #{dynamic_text}" if dynamic_text
+                end
+              end
+            end
+
+            parts.join("\n")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rspec/agents/runners/headless_runner.rb

@@ -0,0 +1,272 @@
+# frozen_string_literal: true
+
+require "rspec/core"
+require "stringio"
+require "digest"
+require "json"
+
+module RSpec
+  module Agents
+    module Runners
+      # In-worker RSpec execution that emits events via EventBus.
+      # Used by parallel_spec_worker to run specs in subprocess with event streaming.
+      #
+      # All events (both RSpec lifecycle and conversation events) flow through
+      # the EventBus, which RpcNotifyObserver forwards to the controller.
+      #
+      # Event flow:
+      #   RSpec notification → HeadlessRunner → EventBus#publish(typed event)
+      #   Conversation turn  → Conversation   → EventBus#publish(typed event)
+      #   EventBus           → RpcNotifyObserver → JSON over RPC socket
+      #
+      class HeadlessRunner
+        # RSpec notifications we subscribe to
+        NOTIFICATIONS = [
+          :start,
+          :example_group_started,
+          :example_group_finished,
+          :example_started,
+          :example_passed,
+          :example_failed,
+          :example_pending,
+          :stop,
+          :dump_summary
+        ].freeze
+
+        # @param rpc_output [IO] Output stream for RPC notifications (socket)
+        def initialize(rpc_output:)
+          @rpc_output = rpc_output
+          @example_count = 0
+          @failure_count = 0
+        end
+
+        # Run the specified examples
+        #
+        # @param example_ids [Array<String>] RSpec example IDs (e.g., "spec/file.rb[1:1]")
+        # @return [Hash] Result with exit_code, example_count, failure_count
+        def run(example_ids)
+          @example_count = 0
+          @failure_count = 0
+
+          # Create isolated EventBus for this worker (NOT the singleton)
+          @event_bus = IsolatedEventBus.new
+
+          # Set up RPC forwarding - all events go through this observer
+          Observers::RpcNotifyObserver.new(
+            rpc_output: @rpc_output,
+            event_bus:  @event_bus
+          )
+
+          # Reset RSpec state for clean run
+          RSpec.reset
+          RSpec.configuration.reset
+
+          # Re-register DSL after reset (reset wipes out config.include calls)
+          RSpec::Agents.setup_rspec!
+
+          # Enable focus filtering (fit/fdescribe/fcontext)
+          # This must be set after RSpec.reset since reset clears all configuration
+          RSpec.configuration.filter_run_when_matching :focus
+
+          # Configure output streams
+          null_output = StringIO.new
+          RSpec.configuration.output_stream = null_output
+          RSpec.configuration.error_stream = $stderr
+
+          # Parse options with example filter
+          options = RSpec::Core::ConfigurationOptions.new(example_ids)
+          options.configure(RSpec.configuration)
+
+          # Re-suppress output after options configure
+          RSpec.configuration.output_stream = null_output
+          RSpec.configuration.formatters.clear
+
+          # Register ourselves as a listener for RSpec lifecycle events
+          RSpec.configuration.reporter.register_listener(self, *NOTIFICATIONS)
+
+          # Inject event bus into test context for Conversation to find
+          Thread.current[:rspec_agents_event_bus] = @event_bus
+
+          # Run specs
+          runner = RSpec::Core::Runner.new(options)
+          exit_code = runner.run($stderr, null_output)
+
+          # Clean up thread-locals
+          Thread.current[:rspec_agents_event_bus] = nil
+          Thread.current[:rspec_agents_example_id] = nil
+
+          {
+            exit_code:     exit_code,
+            example_count: @example_count,
+            failure_count: @failure_count
+          }
+        end
+
+        # --- RSpec Notification Handlers ---
+        # Each handler creates a typed event and publishes it through the EventBus
+
+        def start(notification)
+          @event_bus.publish(Events::SuiteStarted.new(
+            example_count: notification.count,
+            load_time:     notification.load_time,
+            seed:          RSpec.configuration.seed,
+            time:          Time.now
+          ))
+        end
+
+        def example_group_started(notification)
+          group = notification.group
+          @event_bus.publish(Events::GroupStarted.new(
+            description: group.description,
+            file_path:   group.metadata[:file_path],
+            line_number: group.metadata[:line_number],
+            time:        Time.now
+          ))
+        end
+
+        def example_group_finished(notification)
+          group = notification.group
+          @event_bus.publish(Events::GroupFinished.new(
+            description: group.description,
+            time:        Time.now
+          ))
+        end
+
+        def example_started(notification)
+          example = notification.example
+          @example_count += 1
+
+          # Generate stable example ID and store in thread-local
+          stable_id_obj = build_stable_example_id(example)
+          example_id = stable_id_obj&.hash_value || generate_example_id(example)
+          Thread.current[:rspec_agents_example_id] = example_id
+          Thread.current[:rspec_agents_stable_id] = stable_id_obj&.to_s
+
+          scenario = example.metadata[:rspec_agents_scenario]
+          @event_bus.publish(Events::ExampleStarted.new(
+            example_id:       example_id,
+            stable_id:        stable_id_obj&.to_s,
+            canonical_path:   stable_id_obj&.canonical_path,
+            description:      example.description,
+            full_description: example.full_description,
+            location:         example.location,
+            scenario:         scenario,
+            time:             Time.now
+          ))
+        end
+
+        def example_passed(notification)
+          example_id = Thread.current[:rspec_agents_example_id]
+          stable_id = Thread.current[:rspec_agents_stable_id]
+          Thread.current[:rspec_agents_example_id] = nil
+          Thread.current[:rspec_agents_stable_id] = nil
+          example = notification.example
+
+          @event_bus.publish(Events::ExamplePassed.new(
+            example_id:       example_id,
+            stable_id:        stable_id,
+            description:      example.description,
+            full_description: example.full_description,
+            duration:         example.execution_result.run_time,
+            time:             Time.now
+          ))
+        end
+
+        def example_failed(notification)
+          example_id = Thread.current[:rspec_agents_example_id]
+          stable_id = Thread.current[:rspec_agents_stable_id]
+          Thread.current[:rspec_agents_example_id] = nil
+          Thread.current[:rspec_agents_stable_id] = nil
+          example = notification.example
+          @failure_count += 1
+
+          @event_bus.publish(Events::ExampleFailed.new(
+            example_id:       example_id,
+            stable_id:        stable_id,
+            description:      example.description,
+            full_description: example.full_description,
+            location:         example.location,
+            duration:         example.execution_result.run_time,
+            message:          extract_failure_message(notification),
+            backtrace:        extract_backtrace(notification),
+            time:             Time.now
+          ))
+        end
+
+        def example_pending(notification)
+          example_id = Thread.current[:rspec_agents_example_id]
+          stable_id = Thread.current[:rspec_agents_stable_id]
+          Thread.current[:rspec_agents_example_id] = nil
+          Thread.current[:rspec_agents_stable_id] = nil
+          example = notification.example
+
+          @event_bus.publish(Events::ExamplePending.new(
+            example_id:       example_id,
+            stable_id:        stable_id,
+            description:      example.description,
+            full_description: example.full_description,
+            message:          example.execution_result.pending_message,
+            time:             Time.now
+          ))
+        end
+
+        def stop(_notification)
+          @event_bus.publish(Events::SuiteStopped.new(
+            time: Time.now
+          ))
+        end
+
+        def dump_summary(notification)
+          @event_bus.publish(Events::SuiteSummary.new(
+            duration:      notification.duration,
+            example_count: notification.example_count,
+            failure_count: notification.failure_count,
+            pending_count: notification.pending_count,
+            time:          Time.now
+          ))
+        end
+
+        private
+
+        def generate_example_id(example)
+          Digest::SHA256.hexdigest(example.full_description)[0, 12]
+        end
+
+        def build_stable_example_id(example)
+          scenario = example.metadata[:rspec_agents_scenario]
+          StableExampleId.generate(example, scenario: scenario)
+        rescue => e
+          # Fall back gracefully if stable ID generation fails
+          warn "[HeadlessRunner] Failed to generate stable example ID: #{e.message}"
+          nil
+        end
+
+        def extract_failure_message(notification)
+          if notification.respond_to?(:exception) && notification.exception
+            notification.exception.message
+          elsif notification.example.execution_result.exception
+            notification.example.execution_result.exception.message
+          end
+        end
+
+        def extract_backtrace(notification)
+          backtrace = if notification.respond_to?(:formatted_backtrace)
+                        notification.formatted_backtrace
+                      elsif notification.example.execution_result.exception
+                        notification.example.execution_result.exception.backtrace
+                      end
+          filter_backtrace(backtrace)
+        end
+
+        def filter_backtrace(backtrace)
+          return nil unless backtrace
+
+          # Include only lines from the current working directory (application code)
+          # This matches RSpec's backtrace_inclusion_patterns approach
+          app_path = Dir.getwd
+          backtrace.select { |line| line.start_with?(app_path) }.first(10)
+        end
+      end
+    end
+  end
+end

data/lib/rspec/agents/runners/parallel_terminal_runner.rb

@@ -0,0 +1,220 @@
+# frozen_string_literal: true
+
+require "async"
+require "fileutils"
+require_relative "../parallel/ui/ui_factory"
+
+module RSpec
+  module Agents
+    module Runners
+      # CLI-focused parallel runner with formatted terminal output.
+      # Thin adapter over SpecExecutor that handles UI display and output serialization.
+      #
+      # Supports three output modes:
+      # - Interactive: Full-screen TUI with tabs and progress bar
+      # - Interleaved: Simple streaming output with worker prefixes (CI-friendly)
+      # - Quiet: Dot progress with log files
+      #
+      # @example Basic usage
+      #   runner = ParallelTerminalRunner.new(worker_count: 4)
+      #   exit_code = runner.run(["spec/"])
+      #
+      # @example With explicit UI mode
+      #   runner = ParallelTerminalRunner.new(worker_count: 4, ui_mode: :interactive)
+      #   runner.run(["spec/"])
+      #
+      class ParallelTerminalRunner
+        COLORS = {
+          red:    "\e[31m",
+          green:  "\e[32m",
+          yellow: "\e[33m",
+          blue:   "\e[34m",
+          cyan:   "\e[36m",
+          dim:    "\e[2m",
+          white:  "\e[37m",
+          reset:  "\e[0m"
+        }.freeze
+
+        # @param worker_count [Integer] Number of parallel workers
+        # @param fail_fast [Boolean] Stop on first failure
+        # @param output [IO] Output stream (default: $stdout)
+        # @param color [Boolean, nil] Force color on/off (default: auto-detect)
+        # @param json_path [String, nil] Path to save JSON run data
+        # @param html_path [String, nil] Path to save HTML report
+        # @param ui_mode [Symbol, nil] Output mode (:interactive, :interleaved, :quiet)
+        def initialize(worker_count:, fail_fast: false, output: $stdout, color: nil,
+                       json_path: nil, html_path: nil, ui_mode: nil)
+          @worker_count = worker_count
+          @fail_fast = fail_fast
+          @output = output
+          @color = color.nil? ? output.respond_to?(:tty?) && output.tty? : color
+          @mutex = Mutex.new
+          @json_path = json_path
+          @html_path = html_path
+
+          @ui = Parallel::UI::UIFactory.create(
+            mode:   ui_mode,
+            output: output,
+            color:  @color
+          )
+
+          # Track which worker is running which example
+          @example_to_worker = {} # example_id => worker_index
+        end
+
+        # Run specs and return exit code
+        # @param paths [Array<String>] Spec files or directories
+        # @return [Integer] Exit code (0 = success, 1 = failures)
+        def run(paths)
+          executor = ParallelSpecExecutor.new(
+            worker_count: @worker_count,
+            fail_fast:    @fail_fast
+          )
+
+          # Build example_id -> worker mapping from discovery
+          # This needs to be done before execution to route events to the right worker
+          begin
+            examples = Parallel::ExampleDiscovery.discover(paths)
+            partitions = Parallel::Partitioner.partition(examples, @worker_count)
+
+            partitions.each_with_index do |worker_examples, worker_index|
+              next if worker_examples.nil? || worker_examples.empty?
+              worker_examples.each do |ex|
+                @example_to_worker[ex.id] = worker_index
+              end
+            end
+          rescue Parallel::ExampleDiscovery::DiscoveryError => e
+            @output.puts colorize("Error: #{e.message}", :red)
+            return 1
+          end
+
+          # Wire up event handling
+          executor.on_event { |type, event| route_event_to_ui(type, event) }
+          executor.on_progress { |c, t, f| @ui.on_progress(completed: c, total: t, failures: f) }
+
+          # Start UI
+          @ui.on_run_started(worker_count: @worker_count, example_count: examples.size)
+          @ui.start_input_handling
+
+          begin
+            # Execute - Async block returns the result of the block
+            result = Async do |task|
+              executor.execute(paths, task: task)
+            end.wait
+
+            # Notify UI of completion
+            @ui.on_run_finished(results: result)
+
+            # Print summary
+            print_summary(result)
+            if @ui.failures.any?
+              print_failures
+              print_failed_examples_filter
+            end
+
+            # Save outputs
+            save_outputs(executor.run_data) if @json_path || @html_path
+
+            result&.success? ? 0 : 1
+          ensure
+            @ui.stop_input_handling
+            @ui.cleanup
+          end
+        end
+
+        private
+
+        def route_event_to_ui(type, event)
+          # Get worker index from example_id
+          example_id = event.respond_to?(:example_id) ? event.example_id : nil
+          worker = example_id ? @example_to_worker[example_id] : 0
+          worker ||= 0
+
+          case type
+          when "ExampleStarted"
+            @ui.on_example_started(worker: worker, event: event)
+          when "ExamplePassed", "ExampleFailed", "ExamplePending"
+            @ui.on_example_finished(worker: worker, event: event)
+          when "GroupStarted", "GroupFinished"
+            @ui.on_group_event(worker: worker, event: event)
+          when "UserMessage", "AgentResponse", "ToolCallCompleted", "TopicChanged"
+            @ui.on_conversation_event(worker: worker, event: event)
+          end
+        end
+
+        def print_summary(result)
+          @output.puts
+
+          return unless result
+
+          parts = ["#{result.example_count} example#{"s" unless result.example_count == 1}"]
+
+          if result.failure_count > 0
+            parts << colorize("#{result.failure_count} failure#{"s" unless result.failure_count == 1}", :red)
+          else
+            parts << colorize("0 failures", :green)
+          end
+
+          if result.error
+            @output.puts colorize("Error: #{result.error}", :red)
+          end
+
+          @output.puts parts.join(", ")
+          @output.puts
+        end
+
+        def print_failures
+          failures = @ui.failures
+          return if failures.empty?
+
+          @output.puts colorize("Failures:", :red)
+          @output.puts
+
+          failures.each_with_index do |event, i|
+            @output.puts "  #{i + 1}) #{event.full_description || event.description}"
+            @output.puts "     #{colorize(event.message, :red)}" if event.message
+            if event.backtrace&.any?
+              event.backtrace.first(3).each do |line|
+                @output.puts "     #{colorize(line, :dim)}"
+              end
+            end
+            @output.puts
+          end
+        end
+
+        def print_failed_examples_filter
+          failures = @ui.failures
+          return if failures.empty?
+
+          @output.puts colorize("Failed examples:", :red)
+          @output.puts
+
+          failures.each do |event|
+            location = event.location
+            description = event.full_description || event.description
+            @output.puts colorize("bin/rspec-agents #{location}", :red) + " " + colorize("# #{description}", :dim)
+          end
+          @output.puts
+        end
+
+        def colorize(text, color)
+          return text unless @color
+          "#{COLORS[color]}#{text}#{COLORS[:reset]}"
+        end
+
+        def save_outputs(run_data)
+          return unless run_data
+
+          if @json_path
+            FileUtils.mkdir_p(File.dirname(@json_path))
+            Serialization::JsonFile.write(@json_path, run_data)
+          end
+
+          if @html_path
+            Serialization::TestSuiteRenderer.render(run_data, output_path: @html_path)
+          end
+        end
+      end
+    end
+  end
+end