rigortype 0.1.9 → 0.1.11

data/lib/rigor/cli/coverage_command.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require "optionparser"
+require "prism"
+
+require_relative "../configuration"
+require_relative "../environment"
+require_relative "../inference/precision_scanner"
+require_relative "../scope"
+require_relative "coverage_report"
+require_relative "coverage_renderer"
+
+module Rigor
+  class CLI
+    # Executes the `rigor coverage` command.
+    #
+    # Walks every Prism node in one or more files, infers its type via
+    # `Rigor::Scope#type_of`, and classifies the result into precision tiers
+    # (constant / nominal / shaped / refined / bot / dynamic_specific /
+    # dynamic_top / top).  Reports aggregate and per-file statistics so
+    # maintainers can track type-precision trends and SKILL pipelines can
+    # measure the impact of adding new constant-fold or shape-dispatch rules.
+    #
+    # Exit codes:
+    #   0  — scan complete, precision ratio ≥ threshold (or no threshold given)
+    #   1  — precision ratio < threshold, or parse errors encountered
+    #   64 — usage error
+    class CoverageCommand
+      USAGE = "Usage: rigor coverage [options] PATH..."
+
+      def initialize(argv:, out:, err:)
+        @argv = argv
+        @out = out
+        @err = err
+      end
+
+      # @return [Integer] CLI exit status.
+      def run
+        options = parse_options
+        paths = collect_paths(@argv)
+        return CLI::EXIT_USAGE if paths.nil?
+        return usage_error if paths.empty?
+
+        report = scan_paths(paths, options)
+        CoverageRenderer.new(out: @out).render(report, format: options.fetch(:format))
+        determine_exit(report, options)
+      end
+
+      private
+
+      def parse_options
+        options = { format: "text", threshold: nil, config: nil }
+
+        OptionParser.new do |opts|
+          opts.banner = USAGE
+          opts.on("--format=FORMAT", "Output format: text or json") { |v| options[:format] = v }
+          opts.on("--config=PATH", "Path to the Rigor configuration file") { |v| options[:config] = v }
+          opts.on(
+            "--threshold=RATIO", Float,
+            "Exit 1 when precision ratio is below RATIO (0.0–1.0)"
+          ) { |v| options[:threshold] = v }
+        end.parse!(@argv)
+
+        options
+      end
+
+      def collect_paths(args)
+        paths = []
+        args.each do |arg|
+          if File.directory?(arg)
+            paths.concat(Dir.glob(File.join(arg, "**/*.rb")))
+          elsif File.file?(arg)
+            paths << arg
+          else
+            @err.puts("coverage: not a file or directory: #{arg}")
+            return nil
+          end
+        end
+        paths.uniq
+      end
+
+      def usage_error
+        @err.puts("coverage: at least one path is required")
+        @err.puts(USAGE)
+        CLI::EXIT_USAGE
+      end
+
+      def scan_paths(paths, options)
+        configuration = Configuration.load(options.fetch(:config))
+        scope = Scope.empty(environment: project_environment(configuration))
+        scanner = Inference::PrecisionScanner.new(scope: scope)
+        accumulator = CoverageAccumulator.new
+
+        paths.each { |path| scan_one(path, scanner, accumulator, configuration) }
+        accumulator.to_report(paths, options)
+      end
+
+      def project_environment(configuration)
+        Environment.for_project(
+          libraries: configuration.libraries,
+          signature_paths: configuration.signature_paths
+        )
+      end
+
+      def scan_one(path, scanner, accumulator, configuration)
+        source = File.read(path)
+        parse_result = Prism.parse(source, filepath: path, version: configuration.target_ruby)
+        if parse_result.errors.any?
+          accumulator.record_parse_error(path, parse_result.errors)
+          return
+        end
+
+        accumulator.absorb(path, scanner.scan(parse_result.value))
+      end
+
+      def determine_exit(report, options)
+        return 1 unless report.parse_errors.empty?
+
+        threshold = options[:threshold]
+        return 0 if threshold.nil?
+
+        report.precision_ratio < threshold ? 1 : 0
+      end
+    end
+  end
+end

data/lib/rigor/cli/coverage_renderer.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Rigor
+  class CLI
+    # Renders a `CoverageReport` as terminal-friendly text or JSON.
+    class CoverageRenderer
+      TIER_LABELS = {
+        constant: "constant",
+        nominal: "nominal",
+        shaped: "shaped (Tuple/Hash/Range/generic)",
+        refined: "refined",
+        bot: "bot (unreachable)",
+        dynamic_specific: "dynamic — partial info",
+        dynamic_top: "dynamic — opaque (untyped)",
+        top: "top"
+      }.freeze
+
+      def initialize(out:)
+        @out = out
+      end
+
+      def render(report, format:)
+        case format
+        when "text" then render_text(report)
+        when "json" then render_json(report)
+        else raise OptionParser::InvalidArgument, "unsupported format: #{format}"
+        end
+      end
+
+      private
+
+      def render_text(report)
+        render_text_header(report)
+        render_text_summary(report)
+        render_text_tier_table(report)
+        render_text_per_file(report) if report.per_file.size > 1
+        render_text_parse_errors(report)
+      end
+
+      def render_text_header(report)
+        n = report.files.size
+        suffix = n == 1 ? "" : "s"
+        @out.puts("Type coverage: #{n} file#{suffix}")
+        report.files.first(5).each { |f| @out.puts("  - #{f}") }
+        @out.puts("  ... (#{n - 5} more)") if n > 5
+        @out.puts
+      end
+
+      def render_text_summary(report)
+        g = report.grand_total
+        p = report.precise_count
+        o = report.opaque_count
+        @out.puts("Summary:")
+        @out.puts("  files processed:      #{report.files.size - report.parse_errors.size}")
+        @out.puts("  parse errors:         #{report.parse_errors.size}")
+        @out.puts("  expressions typed:    #{g}")
+        @out.puts("  precise:              #{p}#{pct(p, g)}")
+        @out.puts("  dynamic (opaque):     #{o}#{pct(o, g)}")
+        @out.puts("  precision ratio:      #{(report.precision_ratio * 100).round(2)}%")
+        @out.puts
+      end
+
+      def render_text_tier_table(report)
+        @out.puts("Tier breakdown:")
+        g = report.grand_total
+        Inference::PrecisionScanner::TIERS.each do |tier|
+          n = report.tier_count(tier)
+          next if n.zero?
+
+          label = TIER_LABELS.fetch(tier, tier.to_s).ljust(36)
+          @out.puts("  #{label} #{n.to_s.rjust(7)}#{pct(n, g)}")
+        end
+        @out.puts
+      end
+
+      def render_text_per_file(report)
+        @out.puts("Per-file breakdown:")
+        width = report.per_file.map { |e| e[:file].size }.max || 0
+        report.per_file.sort_by { |e| e[:result].precision_ratio }.each do |entry|
+          r = entry[:result]
+          next if r.total.zero?
+
+          ratio_str = "#{(r.precision_ratio * 100).round(1)}%".rjust(6)
+          @out.puts("  #{entry[:file].ljust(width)}  #{ratio_str}  (#{r.precise_count}/#{r.total})")
+        end
+        @out.puts
+      end
+
+      def render_text_parse_errors(report)
+        return if report.parse_errors.empty?
+
+        @out.puts("Parse errors:")
+        report.parse_errors.each do |entry|
+          @out.puts("  #{entry[:file]}: #{entry[:errors].join('; ')}")
+        end
+      end
+
+      def render_json(report)
+        @out.puts(JSON.pretty_generate(json_payload(report)))
+      end
+
+      def json_payload(report)
+        g = report.grand_total
+        {
+          summary: json_summary(report, g),
+          by_tier: tier_payload(g) { |tier| report.tier_count(tier) },
+          by_file: report.per_file.map { |e| file_payload(e) },
+          parse_errors: report.parse_errors.map { |e| { file: e[:file], errors: e[:errors] } }
+        }
+      end
+
+      def json_summary(report, grand_total)
+        g = grand_total
+        dsc = report.total.dynamic_specific_count
+        {
+          files_processed: report.files.size - report.parse_errors.size,
+          parse_errors: report.parse_errors.size,
+          expressions_typed: g,
+          precise_count: report.precise_count,
+          precise_ratio: ratio_f(report.precision_ratio),
+          dynamic_opaque_count: report.opaque_count,
+          dynamic_opaque_ratio: ratio_f(report.opaque_ratio),
+          dynamic_specific_count: dsc,
+          dynamic_specific_ratio: ratio_f(dsc.fdiv(g.nonzero? || 1))
+        }
+      end
+
+      def tier_payload(grand_total)
+        g = grand_total
+        Inference::PrecisionScanner::TIERS.to_h do |tier|
+          n = yield tier
+          [tier, { count: n, ratio: ratio_f(n.fdiv(g.nonzero? || 1)) }]
+        end
+      end
+
+      def file_payload(entry)
+        r = entry[:result]
+        {
+          file: entry[:file],
+          expressions_typed: r.total,
+          precise_count: r.precise_count,
+          precise_ratio: ratio_f(r.precision_ratio),
+          dynamic_opaque_count: r.opaque_count,
+          dynamic_opaque_ratio: ratio_f(r.opaque_ratio),
+          by_tier: tier_payload(r.total) { |tier| r.tier_counts.fetch(tier, 0) }
+        }
+      end
+
+      def pct(numerator, denominator)
+        return "" if denominator.zero?
+
+        " (#{(numerator.fdiv(denominator) * 100).round(1)}%)"
+      end
+
+      def ratio_f(val)
+        val.round(4)
+      end
+    end
+  end
+end

data/lib/rigor/cli/coverage_report.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Rigor
+  class CLI
+    # Aggregated precision-coverage report assembled by `CoverageCommand`.
+    # Holds per-file breakdowns and accumulated totals; consumed by
+    # `CoverageRenderer` for text and JSON output.
+    class CoverageReport < Data.define(
+      :files,
+      :parse_errors,
+      :per_file,
+      :total
+    )
+      # Sum of all per-file totals.
+      def grand_total
+        total.total
+      end
+
+      def precise_count
+        total.precise_count
+      end
+
+      def opaque_count
+        total.opaque_count
+      end
+
+      def precision_ratio
+        total.precision_ratio
+      end
+
+      def opaque_ratio
+        total.opaque_ratio
+      end
+
+      def tier_count(tier)
+        total.tier_counts.fetch(tier, 0)
+      end
+    end
+
+    # Mutable accumulator used while scanning files.
+    class CoverageAccumulator
+      require_relative "../inference/precision_scanner"
+
+      def initialize
+        @per_file = []
+        @parse_errors = []
+        # Accumulated totals across all files.
+        @total_total = 0
+        @total_tier_counts = Inference::PrecisionScanner::TIERS.to_h { |t| [t, 0] }
+      end
+
+      def absorb(path, file_result)
+        @per_file << { file: path, result: file_result }
+        @total_total += file_result.total
+        file_result.tier_counts.each { |tier, n| @total_tier_counts[tier] += n }
+      end
+
+      def record_parse_error(path, errors)
+        @parse_errors << { file: path, errors: errors.map(&:message) }
+      end
+
+      def to_report(files, _options)
+        CoverageReport.new(
+          files: files,
+          parse_errors: @parse_errors,
+          per_file: @per_file,
+          total: Inference::PrecisionScanner::FileResult.new(
+            total: @total_total,
+            tier_counts: @total_tier_counts
+          )
+        )
+      end
+    end
+  end
+end

data/lib/rigor/cli/mcp_command.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "optionparser"
+
+module Rigor
+  class CLI
+    # Executes the `rigor mcp` command.
+    #
+    # Starts a long-running MCP (Model Context Protocol) server over stdio.
+    # The server exposes Rigor's analysis tools as MCP tool calls over a
+    # newline-delimited JSON-RPC 2.0 stream. See ADR-33.
+    #
+    # Slice 1 ships the stdio transport with seven read-only tools:
+    # rigor_check, rigor_type_of, rigor_triage, rigor_annotate,
+    # rigor_sig_gen, rigor_explain, rigor_coverage.
+    class McpCommand
+      USAGE = "Usage: rigor mcp [options]"
+
+      def initialize(argv:, out:, err:)
+        @argv = argv
+        @out = out
+        @err = err
+      end
+
+      # @return [Integer] CLI exit status.
+      def run
+        options = parse_options
+        return CLI::EXIT_USAGE if options == :usage_error
+
+        transport = options.fetch(:transport)
+        unless transport == "stdio"
+          @err.puts("rigor mcp: unsupported transport: #{transport.inspect} (only `stdio` is supported in v1)")
+          return CLI::EXIT_USAGE
+        end
+
+        require_relative "../mcp"
+        require_relative "../version"
+
+        server = MCP::Server.new(config_path: options.fetch(:config), err: $stderr)
+        loop_runner = MCP::Loop.new(input: $stdin, output: $stdout, server: server)
+        loop_runner.run
+        0
+      end
+
+      private
+
+      def parse_options
+        options = { transport: "stdio", config: nil }
+
+        parser = OptionParser.new do |opts|
+          opts.banner = USAGE
+          opts.on("--transport=NAME",
+                  "Transport (default: stdio; only stdio is supported in v1)") do |value|
+            options[:transport] = value
+          end
+          opts.on("--config=PATH",
+                  "Session-level default config path (individual tool calls may override)") do |value|
+            options[:config] = value
+          end
+        end
+        parser.parse!(@argv)
+        options
+      rescue OptionParser::ParseError => e
+        @err.puts(e.message)
+        @err.puts(USAGE)
+        :usage_error
+      end
+    end
+  end
+end

data/lib/rigor/cli.rb

@@ -28,8 +28,11 @@ module Rigor
       "diff" => :run_diff,
       "sig-gen" => :run_sig_gen,
       "lsp" => :run_lsp,
+      "mcp" => :run_mcp,
       "baseline" => :run_baseline,
-      "triage" => :run_triage
+      "triage" => :run_triage,
+      "coverage" => :run_coverage,
+      "playground" => :run_playground
     }.freeze
 
     def self.start(argv = ARGV, out: $stdout, err: $stderr)
@@ -81,7 +84,7 @@ module Rigor
       buffer = resolve_buffer_binding(options)
       return EXIT_USAGE if buffer == :usage_error
 
-      configuration = Configuration.load(options.fetch(:config))
+      configuration = load_check_configuration(options)
       cache_root = configuration.cache_path
       handle_clear_cache(cache_root) if options.fetch(:clear_cache)
 
@@ -118,7 +121,7 @@ module Rigor
         return false
       end
 
-      baseline = Analysis::Baseline.load(path)
+      baseline = Analysis::Baseline.load(path, project_root: Dir.pwd)
       return false if baseline.nil? || baseline.empty?
 
       drifted = baseline.audit(raw_diagnostics).reject { |row| row.status == :within }
@@ -161,7 +164,7 @@ module Rigor
       path = resolve_baseline_path(configuration, options)
       return result if path.nil?
 
-      baseline = Analysis::Baseline.load(path)
+      baseline = Analysis::Baseline.load(path, project_root: Dir.pwd)
       return result if baseline.nil?
 
       surfaced, silenced_count = baseline.filter(result.diagnostics)
@@ -281,7 +284,16 @@ module Rigor
         baseline: :unset,
         # ADR-22 slice 5 — `--baseline-strict` CI gate: fail the
         # run on any baseline drift, in either direction.
-        baseline_strict: false
+        baseline_strict: false,
+        # ADR-32 WD10 carry-over — `--treat-all-as-inline-rbs`
+        # forces the `rigor-rbs-inline` plugin into the loaded
+        # plugin set with `require_magic_comment: false` so a
+        # single ad-hoc `rigor check` invocation treats every
+        # analysed file as inline-RBS without the user editing
+        # `.rigor.yml`. Intended for single-file / ad-hoc CI use;
+        # ordinary projects should configure the plugin in
+        # `.rigor.yml`.
+        treat_all_as_inline_rbs: false
       }
       parser = OptionParser.new do |opts| # rubocop:disable Metrics/BlockLength
         opts.banner = "Usage: rigor check [options] [paths]"
@@ -319,11 +331,56 @@ module Rigor
                 "ADR-22: fail the run on any baseline drift (CI gate)") do
           options[:baseline_strict] = true
         end
+        opts.on("--treat-all-as-inline-rbs",
+                "ADR-32: force-load rigor-rbs-inline with require_magic_comment: false") do
+          options[:treat_all_as_inline_rbs] = true
+        end
       end
       parser.parse!(@argv)
       options
     end
 
+    # ADR-32 WD10 carry-over — wraps `Configuration.load` so the
+    # CLI's `--treat-all-as-inline-rbs` flag can inject a
+    # `rigor-rbs-inline` plugin entry with
+    # `require_magic_comment: false` into the loaded plugin
+    # set. Re-runs the include-aware YAML load and applies the
+    # injection before `Configuration.new` so the new entry
+    # follows the normal coercion path. A pre-existing
+    # `rigor-rbs-inline` entry (by gem name or `id: rbs-inline`)
+    # is removed first so the synthesised entry's
+    # `require_magic_comment: false` wins unconditionally.
+    def load_check_configuration(options)
+      return Configuration.load(options.fetch(:config)) unless options.fetch(:treat_all_as_inline_rbs)
+
+      path = options.fetch(:config) || Configuration.discover
+      data = path && File.exist?(path) ? Configuration.load_with_includes(path) : {}
+      data = data.dup
+      data["plugins"] = inject_treat_all_as_inline_rbs(Array(data["plugins"]))
+      Configuration.new(Configuration::DEFAULTS.merge(data))
+    end
+
+    def inject_treat_all_as_inline_rbs(entries)
+      filtered = entries.reject { |entry| rigor_rbs_inline_entry?(entry) }
+      filtered + [{
+        "gem" => "rigor-rbs-inline",
+        "id" => "rbs-inline",
+        "config" => { "require_magic_comment" => false }
+      }]
+    end
+
+    def rigor_rbs_inline_entry?(entry)
+      case entry
+      when String
+        entry == "rigor-rbs-inline"
+      when Hash
+        string_keyed = entry.to_h { |k, v| [k.to_s, v] }
+        string_keyed["gem"] == "rigor-rbs-inline" || string_keyed["id"] == "rbs-inline"
+      else
+        false
+      end
+    end
+
     def handle_clear_cache(cache_root)
       if File.directory?(cache_root)
         FileUtils.rm_rf(cache_root)
@@ -516,6 +573,12 @@ module Rigor
       LspCommand.new(argv: @argv, out: @out, err: @err).run
     end
 
+    def run_mcp
+      require_relative "cli/mcp_command"
+
+      McpCommand.new(argv: @argv, out: @out, err: @err).run
+    end
+
     def run_baseline
       require_relative "cli/baseline_command"
 
@@ -528,6 +591,23 @@ module Rigor
       CLI::TriageCommand.new(argv: @argv, out: @out, err: @err).run
     end
 
+    def run_coverage
+      require_relative "cli/coverage_command"
+
+      CLI::CoverageCommand.new(argv: @argv, out: @out, err: @err).run
+    end
+
+    def run_playground
+      begin
+        require "rigor/playground"
+      rescue LoadError
+        @err.puts "rigor playground requires the rigor-playground gem."
+        @err.puts "Install it with: gem install rigor-playground"
+        return EXIT_USAGE
+      end
+      Rigor::CLI::PlaygroundCommand.new(@argv[1..], @out, @err).run
+    end
+
     def write_result(result, format)
       case format
       when "json"
@@ -570,7 +650,10 @@ module Rigor
           diff       Compare current diagnostics to a saved baseline JSON
           sig-gen    Emit RBS skeletons inferred from .rb sources (ADR-14)
           lsp        Run the Rigor Language Server (LSP) over stdio
+          mcp        Run the Rigor MCP server over stdio (ADR-33)
           triage     Summarise diagnostics: distribution, hotspots, hints (ADR-23)
+          coverage   Report type-precision coverage (precise vs Dynamic ratio)
+          playground Start the browser playground (requires rigor-playground gem)
           version    Print the Rigor version
           help       Print this help
       HELP

data/lib/rigor/environment/rbs_loader.rb

@@ -56,7 +56,7 @@ module Rigor
         # run. The gem stubs are intentionally read-only and
         # appended LAST so user-supplied `signature_paths` win on
         # name conflicts.
-        def build_env_for(libraries:, signature_paths:)
+        def build_env_for(libraries:, signature_paths:, virtual_rbs: [])
           rbs_loader = RBS::EnvironmentLoader.new
           libraries.each do |library|
             next unless rbs_loader.has_library?(library: library, version: nil)
@@ -70,7 +70,36 @@ module Rigor
           vendored_gem_sig_paths.each do |path|
             rbs_loader.add(path: path) if path.directory?
           end
-          RBS::Environment.from_loader(rbs_loader).resolve_type_names
+          env = RBS::Environment.from_loader(rbs_loader)
+          add_virtual_rbs(env, virtual_rbs)
+          env.resolve_type_names
+        end
+
+        # ADR-32 WD4 — merge synthesised-from-source RBS strings
+        # into the freshly-built environment. Each entry is a
+        # `[virtual_filename, rbs_source]` pair. `virtual_filename`
+        # is purely for diagnostic provenance (RBS parse errors
+        # cite it) — it is not a real file path. Per WD6 the
+        # synthesizer-emit path is responsible for catching its
+        # own parse errors and returning `nil` rather than
+        # garbage; this method assumes its input is parseable
+        # and only rescues `RBS::ParsingError` as a fail-soft.
+        def add_virtual_rbs(env, virtual_rbs)
+          return if virtual_rbs.nil? || virtual_rbs.empty?
+
+          virtual_rbs.each do |filename, content|
+            next if content.nil? || content.empty?
+
+            buffer = ::RBS::Buffer.new(name: filename.to_s, content: content.to_s)
+            _, directives, decls = ::RBS::Parser.parse_signature(buffer)
+            source = ::RBS::Source::RBS.new(buffer, directives || [], decls || [])
+            env.add_source(source)
+          rescue ::RBS::BaseError
+            # WD6 fail-soft: a single broken virtual RBS contribution
+            # does not pull the whole env down. The plugin layer
+            # records a `source-rbs-synthesis-failed` info diagnostic
+            # in slice 2; here we just skip the entry.
+          end
         end
 
         # Per-gem `data/vendored_gem_sigs/<gem>/` directories that
@@ -95,7 +124,7 @@ module Rigor
         end
       end
 
-      attr_reader :libraries, :signature_paths, :cache_store
+      attr_reader :libraries, :signature_paths, :cache_store, :virtual_rbs
 
       # @param libraries [Array<String, Symbol>] stdlib library names to
       #   load on top of core (e.g., `["pathname", "json"]`). Empty by
@@ -114,10 +143,18 @@ module Rigor
       #   reflection artefacts). Pass `nil` (the default) to skip
       #   the cache entirely; the runner threads its own Store
       #   through here when caching is enabled.
-      def initialize(libraries: [], signature_paths: [], cache_store: nil)
+      # @param virtual_rbs [Array<[String, String]>] ADR-32 WD4 —
+      #   `[virtual_filename, rbs_source]` pairs synthesised from
+      #   project source by a plugin's
+      #   `Manifest#source_rbs_synthesizer`. Merged into the env
+      #   after `signature_paths:` and the vendored stubs. Pass
+      #   `[]` (the default) when no synthesizer-emitting plugin
+      #   is loaded.
+      def initialize(libraries: [], signature_paths: [], cache_store: nil, virtual_rbs: [])
         @libraries = libraries.map(&:to_s).freeze
         @signature_paths = signature_paths.map { |p| Pathname(p) }.freeze
         @cache_store = cache_store
+        @virtual_rbs = virtual_rbs.map { |name, content| [name.to_s.dup.freeze, content.to_s.dup.freeze].freeze }.freeze
         # Per-loader memoization bucket. Held as a single
         # mutable Hash so the loader instance itself can be
         # `.freeze`d (per ADR-15 reflection-facade contract)
@@ -642,7 +679,11 @@ module Rigor
       end
 
       def build_env
-        self.class.build_env_for(libraries: @libraries, signature_paths: @signature_paths)
+        self.class.build_env_for(
+          libraries: @libraries,
+          signature_paths: @signature_paths,
+          virtual_rbs: @virtual_rbs
+        )
       end
 
       def build_instance_definition(class_name)

data/lib/rigor/environment/reporters.rb

@@ -29,11 +29,12 @@ module Rigor
     # return nil, and the consumer sites short-circuit on
     # `reporter.nil?`.
     class Reporters
-      attr_accessor :rbs_extended, :boundary_cross
+      attr_accessor :rbs_extended, :boundary_cross, :source_rbs_synthesis
 
-      def initialize(rbs_extended: nil, boundary_cross: nil)
+      def initialize(rbs_extended: nil, boundary_cross: nil, source_rbs_synthesis: nil)
         @rbs_extended = rbs_extended
         @boundary_cross = boundary_cross
+        @source_rbs_synthesis = source_rbs_synthesis
       end
     end
   end