coatepec 0.7.0 → 0.9.0

data/lib/coatepec/test_unit/json_reporter.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require "json"
+require "minitest"
+
+module Coatepec
+  module TestUnit
+    # A Minitest reporter that writes the run's per-test results to a JSON
+    # file in a superset of the shape RSpec's own `--format json` produces, as far
+    # as Coatepec::Spec::Result reads it -- so Result and FlakyChecker need
+    # no Minitest-specific code at all. Registered in the child by
+    # TestUnit::Adapter#run_in_process; never loaded in the warm worker.
+    class JsonReporter < ::Minitest::AbstractReporter
+      def initialize(json_path, project_root)
+        super()
+        @json_path = json_path
+        @project_root = File.join(File.expand_path(project_root), "")
+        @examples = []
+        @assertions = 0
+        @errors = 0
+        @started_at = nil
+      end
+
+      # A run begins: forget anything recorded before, so a reporter that
+      # outlives one Minitest.run never carries results into the next.
+      def start
+        @examples = []
+        @assertions = 0
+        @errors = 0
+        @started_at = ::Minitest.clock_time
+      end
+
+      # Minitest counts an assertion as it starts, so a failed assert still counts one; an error is a raise.
+      def record(result)
+        @examples << example_for(result)
+        @assertions += result.assertions
+        @errors += 1 if result.error?
+      end
+
+      # Written to a sibling and renamed so a child killed mid-write leaves
+      # either a complete document or nothing; Result.read_summary already
+      # treats a missing/empty file as "no summary".
+      def report
+        tmp_path = "#{@json_path}.tmp"
+        File.write(tmp_path, JSON.generate(document))
+        File.rename(tmp_path, @json_path)
+      ensure
+        File.delete(tmp_path) if tmp_path && File.exist?(tmp_path)
+      end
+
+      # This reporter observes; it must never flip the run's exit status.
+      def passed?
+        true
+      end
+
+      private
+
+      def document
+        { summary: summary_counts, examples: @examples }
+      end
+
+      # assertion_count and error_count are running totals; the rest are derived from the recorded examples.
+      def summary_counts
+        {
+          example_count: @examples.size,
+          failure_count: @examples.count { |e| e[:status] == "failed" },
+          error_count: @errors,
+          pending_count: @examples.count { |e| e[:status] == "pending" },
+          assertion_count: @assertions,
+          duration: @started_at ? ::Minitest.clock_time - @started_at : 0.0
+        }
+      end
+
+      def example_for(result)
+        id = "#{result.klass}##{result.name}"
+        file, line = result.source_location
+        {
+          id: id,
+          full_description: id,
+          status: status_for(result),
+          file_path: relative_path(file),
+          line_number: line
+        }
+      end
+
+      # RSpec's vocabulary: a skip is "pending" (so FlakyChecker's passed/failed
+      # counts stay meaningful), an error is "failed" -- summary.error_count keeps the distinction.
+      def status_for(result)
+        return "pending" if result.skipped?
+        return "passed" if result.passed?
+
+        "failed"
+      end
+
+      # Never emit the absolute path: same leak rails_controller avoids with
+      # Proc#to_s. Matches RSpec's "./spec/..." form for the same file.
+      def relative_path(file)
+        return nil if file.nil? || file == "unknown"
+
+        expanded = File.expand_path(file)
+        return "./#{expanded.delete_prefix(@project_root)}" if expanded.start_with?(@project_root)
+
+        File.basename(expanded)
+      end
+    end
+  end
+end

data/lib/coatepec/test_unit/line_filtering.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Coatepec
+  module TestUnit
+    # Makes `file:LINE` selectors work regardless of the target app's Rails/
+    # Minitest pairing. Rails installs its own Rails::LineFiltering only via
+    # Rails::TestUnitRailtie, which an app generated with --skip-test never
+    # loads; and Rails 7.1's version overrides `run`, a method Minitest 6 no
+    # longer calls (it dispatches through `run_suite` and reads
+    # options[:include], not options[:filter]). So the child always extends
+    # ActiveSupport::TestCase with the one method the *running* Minitest
+    # actually calls, composing Rails::TestUnit::Runner's recorded line
+    # filters through Rails' public compose_filter. Stacking on top of
+    # Rails' own module is idempotent: CompositeFilter#derive_named_filter
+    # unwraps an existing composite via #named_filter.
+    #
+    # Exactly one method per module, never both: on Minitest 6 a class-level
+    # `run` override intercepts an unrelated 3-argument call and raises.
+    module LineFiltering
+      MT6 = Module.new do
+        def run_suite(reporter, options = {})
+          options = options.merge(include: ::Rails::TestUnit::Runner.compose_filter(self, options[:include]))
+          super(reporter, options)
+        end
+      end
+
+      MT5 = Module.new do
+        def run(reporter, options = {})
+          options = options.merge(filter: ::Rails::TestUnit::Runner.compose_filter(self, options[:filter]))
+          super(reporter, options)
+        end
+      end
+
+      def self.module_for(minitest_version)
+        minitest_version.start_with?("6") ? MT6 : MT5
+      end
+
+      # Ruby ignores a second `extend` of a module already in the singleton
+      # ancestors, so calling this more than once per process is harmless.
+      def self.install!
+        require "rails/test_unit/runner"
+        ::ActiveSupport::TestCase.extend(module_for(::Minitest::VERSION))
+      end
+    end
+  end
+end

data/lib/coatepec/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Coatepec
-  VERSION = "0.7.0"
+  VERSION = "0.9.0"
 end

data/lib/coatepec/worker/rails_runtime.rb

@@ -8,17 +8,26 @@ module Coatepec
     # per worker process and reports its identity (pid, boot_id, versions,
     # lifecycle state) for rails_runtime_status.
     class RailsRuntime
-      attr_reader :pid, :boot_id, :boot_duration_ms, :ruby_version, :rails_version, :post_boot_thread_count
+      attr_reader :pid, :boot_id, :boot_duration_ms, :ruby_version, :rails_version, :post_boot_thread_count,
+                  :fallback_count
+
+      FALLBACK_MODES = %w[spawn_fallback spawn_after_crash].freeze
 
       def initialize(project_root)
         @project_root = project_root
         @booted = false
+        @fallback_count = 0
       end
 
       def booted?
         @booted
       end
 
+      # A guarded fork that declined or crashed ran via spawn; rails_runtime_status reports how often.
+      def record_execution_mode(mode)
+        @fallback_count += 1 if FALLBACK_MODES.include?(mode)
+      end
+
       def boot!
         started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
         ENV["RAILS_ENV"] = "test"

data/lib/coatepec/worker/server.rb

@@ -40,7 +40,7 @@ module Coatepec
 
       def execute_command(command, args)
         case command
-        when "status" then @runtime.status
+        when "status" then handle_status
         when "spec_run" then handle_spec_run(args)
         when "flaky_check" then handle_flaky_check(args)
         when "routes" then handle_routes(args)
@@ -51,6 +51,12 @@ module Coatepec
         end
       end
 
+      # spec_strategy and fallbacks are the worker's to report: it owns the platform check and the counter.
+      def handle_status
+        name = Spec::Runner.new(@project_root, rails_runtime: @runtime).strategy_name
+        @runtime.status.merge(spec_strategy: name, fallbacks: name == "guarded_fork" ? @runtime.fallback_count : nil)
+      end
+
       def handle_spec_run(args)
         Spec::Runner.new(@project_root, rails_runtime: @runtime).run(**args.transform_keys(&:to_sym))
       end
@@ -64,7 +70,8 @@ module Coatepec
       end
 
       def handle_model(args)
-        Introspection::Model.new(args.transform_keys(&:to_sym)[:name]).call
+        a = args.transform_keys(&:to_sym)
+        Introspection::Model.new(a[:name], fields: a[:fields]).call
       end
 
       def handle_controller(args)

data/lib/coatepec/worker_manager.rb

@@ -20,10 +20,12 @@ module Coatepec
       dispatch("status", {}, timeout: 30)
     end
 
-    def run_spec(paths:, example:, seed:, fail_fast:, timeout_seconds:)
+    def run_spec(paths:, example:, seed:, fail_fast:, timeout_seconds:, include_passing: false,
+                 include_stdout: "failures")
       dispatch(
         "spec_run",
-        { paths: paths, example: example, seed: seed, fail_fast: fail_fast, timeout_seconds: timeout_seconds },
+        { paths: paths, example: example, seed: seed, fail_fast: fail_fast, timeout_seconds: timeout_seconds,
+          include_passing: include_passing, include_stdout: include_stdout },
         timeout: timeout_seconds + 10
       )
     end
@@ -40,12 +42,12 @@ module Coatepec
       )
     end
 
-    def routes(query: nil, limit: 50, offset: 0)
-      dispatch("routes", { query: query, limit: limit, offset: offset }, timeout: 30)
+    def routes(query: nil, limit: 100, offset: 0, engines: Introspection::Routes::DEFAULT_ENGINES)
+      dispatch("routes", { query: query, limit: limit, offset: offset, engines: engines }, timeout: 30)
     end
 
-    def model(name:)
-      dispatch("model", { name: name }, timeout: 30)
+    def model(name:, fields: nil)
+      dispatch("model", { name: name, fields: fields }, timeout: 30)
     end
 
     def controller(name:)

data/lib/coatepec.rb

@@ -11,9 +11,14 @@ require_relative "coatepec/worker/client"
 require_relative "coatepec/worker/rails_runtime"
 require_relative "coatepec/introspection/routes"
 require_relative "coatepec/introspection/safe_options"
+require_relative "coatepec/introspection/bounded_options"
+require_relative "coatepec/introspection/model_resolver"
 require_relative "coatepec/introspection/model"
 require_relative "coatepec/introspection/controller"
+require_relative "coatepec/spec/failure_collapser"
 require_relative "coatepec/spec/result"
+require_relative "coatepec/spec/rspec_adapter"
+require_relative "coatepec/test_unit/adapter"
 require_relative "coatepec/spec/process_strategy"
 require_relative "coatepec/spec/fork_strategy"
 require_relative "coatepec/spec/spawn_strategy"

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: coatepec
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.9.0
 platform: ruby
 authors:
 - Enrique Mogollan
 bindir: exe
 cert_chain: []
-date: 2026-09-04 00:00:00.000000000 Z
+date: 2026-09-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: railties
@@ -44,8 +44,9 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '1.0'
 description: Coatepec is a local stdio MCP sidecar that keeps an isolated Rails test
-  worker warm so coding agents can run targeted RSpec examples quickly, without exposing
-  a general Rails console.
+  worker warm so coding agents can run targeted RSpec examples quickly, check specs
+  for flakiness, and read routes, models, and controllers through structured read-only
+  Rails APIs -- without exposing a general Rails console.
 email:
 - emogollan@gmail.com
 executables:
@@ -66,24 +67,34 @@ files:
 - lib/coatepec.rb
 - lib/coatepec/cli.rb
 - lib/coatepec/errors.rb
+- lib/coatepec/introspection/bounded_options.rb
 - lib/coatepec/introspection/controller.rb
 - lib/coatepec/introspection/model.rb
+- lib/coatepec/introspection/model_resolver.rb
+- lib/coatepec/introspection/route_entries.rb
 - lib/coatepec/introspection/routes.rb
 - lib/coatepec/introspection/safe_options.rb
 - lib/coatepec/mcp.rb
+- lib/coatepec/mcp/defaults.rb
 - lib/coatepec/mcp/response.rb
 - lib/coatepec/mcp/tools.rb
 - lib/coatepec/project.rb
 - lib/coatepec/project_config.rb
 - lib/coatepec/protocol.rb
+- lib/coatepec/spec/failure_collapser.rb
 - lib/coatepec/spec/flaky_checker.rb
 - lib/coatepec/spec/fork_strategy.rb
 - lib/coatepec/spec/guarded_fork_strategy.rb
 - lib/coatepec/spec/path_policy.rb
 - lib/coatepec/spec/process_strategy.rb
 - lib/coatepec/spec/result.rb
+- lib/coatepec/spec/rspec_adapter.rb
 - lib/coatepec/spec/runner.rb
 - lib/coatepec/spec/spawn_strategy.rb
+- lib/coatepec/test_unit/adapter.rb
+- lib/coatepec/test_unit/child_entry.rb
+- lib/coatepec/test_unit/json_reporter.rb
+- lib/coatepec/test_unit/line_filtering.rb
 - lib/coatepec/version.rb
 - lib/coatepec/worker/change_detector.rb
 - lib/coatepec/worker/client.rb
@@ -115,5 +126,6 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 3.6.6
 specification_version: 4
-summary: Run targeted RSpec examples against a warm Rails test worker over MCP
+summary: Run targeted RSpec examples and introspect Rails structure over MCP, without
+  a Rails console
 test_files: []