cov-loupe 3.0.0 → 4.0.0.pre

data/lib/cov_loupe/tools/validate_tool.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
 require_relative '../base_tool'
-require_relative '../model'
-require_relative '../predicate_evaluator'
+require_relative '../model/model'
+require_relative '../config/predicate_evaluator'
 
 module CovLoupe
   module Tools
@@ -10,12 +10,12 @@ module CovLoupe
       description <<~DESC
         Validates coverage data against a predicate (Ruby code that evaluates to true/false).
         Use this to enforce coverage policies programmatically.
-        Inputs: Either 'code' (Ruby string) OR 'file' (path to Ruby file), plus optional root/resultset/staleness/error_mode.
+        Inputs: Either 'code' (Ruby string) OR 'file' (path to Ruby file), plus optional root/resultset/raise_on_stale/error_mode.
         Output: JSON object {"result": Boolean} where true means policy passed, false means failed.
         On error (syntax error, file not found, etc.), returns an MCP error response.
         Security Warning: Predicates execute as arbitrary Ruby code with full system privileges.
         Examples:
-        - "Check if all files have at least 80% coverage" → {"code": "->(m) { m.all_files.all? { |f| f['percentage'] >= 80 } }"}
+        - "Check if all files have at least 80% coverage" → {"code": "->(m) { m.list.all? { |f| f['percentage'] >= 80 } }"}
         - "Run coverage policy from file" → {"file": "coverage_policy.rb"}
       DESC
 
@@ -34,36 +34,30 @@ module CovLoupe
         }
       ))
       class << self
-        def call(code: nil, file: nil, root: '.', resultset: nil, staleness: :off,
-          error_mode: 'log', server_context:)
-          with_error_handling('ValidateTool', error_mode: error_mode) do
-            # Re-use logic from ValidateCommand, but adapt for MCP return format
-            require_relative '../cli'
-
-            # Create a minimal CLI shim to reuse command logic
-            cli = CoverageCLI.new
-            cli.config.root = root
-            cli.config.resultset = resultset
-            cli.config.staleness = staleness.to_sym
-            cli.config.error_mode = error_mode.to_sym
-
-            # We need to capture the boolean result instead of letting it exit
-            # Commands::ValidateCommand is designed to exit, so we'll use the model and evaluator directly
-            # This duplicates some logic from ValidateCommand#execute but avoids the exit(status) call
-
-            model = CoverageModel.new(**cli.config.model_options)
+        def call(code: nil, file: nil, root: nil, resultset: nil, raise_on_stale: nil,
+          error_mode: 'log', output_chars: nil, server_context:)
+          # Normalize output_chars before error handling so errors also get converted
+          output_chars_sym = resolve_output_chars(output_chars, server_context)
+          with_error_handling('ValidateTool', error_mode: error_mode, output_chars: output_chars_sym) do
+            model, config = create_configured_model(
+              server_context: server_context,
+              root: root,
+              resultset: resultset,
+              raise_on_stale: raise_on_stale
+            )
 
             result = if code
               PredicateEvaluator.evaluate_code(code, model)
             elsif file
               # Resolve file path relative to root if needed
-              predicate_path = File.expand_path(file, root)
+              predicate_path = File.expand_path(file, config[:root])
               PredicateEvaluator.evaluate_file(predicate_path, model)
             else
               raise UsageError, "Either 'code' or 'file' must be provided"
             end
 
-            respond_json({ result: result }, name: 'validate_result.json', pretty: true)
+            respond_json({ result: result }, name: 'validate_result.json', pretty: true,
+              output_chars: output_chars_sym)
           end
         end
       end

data/lib/cov_loupe/tools/version_tool.rb

@@ -15,12 +15,17 @@ module CovLoupe
         type: 'object',
         additionalProperties: false,
         properties: {
-          error_mode: ERROR_MODE_PROPERTY
+          error_mode: ERROR_MODE_PROPERTY,
+          output_chars: COMMON_PROPERTIES[:output_chars]
         }
       )
       class << self
-        def call(error_mode: 'log', server_context: nil, **_args)
-          with_error_handling('VersionTool', error_mode: error_mode) do
+        # NOTE: output_chars is accepted for consistency and used in error handling,
+        # though the version string itself is already ASCII-only.
+        def call(error_mode: 'log', output_chars: nil, server_context: nil, **_args)
+          # Normalize output_chars before error handling so errors also get converted
+          output_chars_sym = resolve_output_chars(output_chars, server_context)
+          with_error_handling('VersionTool', error_mode: error_mode, output_chars: output_chars_sym) do
             ::MCP::Tool::Response.new([
               { 'type' => 'text', 'text' => "CovLoupe version: #{CovLoupe::VERSION}" }
             ])

data/lib/cov_loupe/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module CovLoupe
-  VERSION = '3.0.0'
+  VERSION = '4.0.0.pre' unless defined?(CovLoupe::VERSION)
 end

data/lib/cov_loupe.rb

@@ -5,49 +5,63 @@ require 'time'
 require 'pathname'
 require 'set' # rubocop:disable Lint/RedundantRequireStatement -- Ruby >= 3.4 requires explicit require for set; RuboCop targets 3.2
 require 'optparse'
-require 'mcp'
-require 'mcp/server/transports/stdio_transport'
 
 require_relative 'cov_loupe/version'
-require_relative 'cov_loupe/app_context'
-require_relative 'cov_loupe/util'
-require_relative 'cov_loupe/errors'
-require_relative 'cov_loupe/error_handler'
-require_relative 'cov_loupe/error_handler_factory'
-require_relative 'cov_loupe/path_relativizer'
-require_relative 'cov_loupe/resultset_loader'
-require_relative 'cov_loupe/mode_detector'
-require_relative 'cov_loupe/model'
-require_relative 'cov_loupe/coverage_reporter'
-require_relative 'cov_loupe/base_tool'
-require_relative 'cov_loupe/tools/coverage_raw_tool'
-require_relative 'cov_loupe/tools/coverage_summary_tool'
-require_relative 'cov_loupe/tools/uncovered_lines_tool'
-require_relative 'cov_loupe/tools/coverage_detailed_tool'
-require_relative 'cov_loupe/tools/all_files_coverage_tool'
-require_relative 'cov_loupe/tools/coverage_totals_tool'
-require_relative 'cov_loupe/tools/coverage_table_tool'
-require_relative 'cov_loupe/tools/validate_tool'
-require_relative 'cov_loupe/tools/version_tool'
-require_relative 'cov_loupe/tools/help_tool'
-require_relative 'cov_loupe/mcp_server'
-require_relative 'cov_loupe/cli'
+require_relative 'cov_loupe/config/app_context'
+require_relative 'cov_loupe/errors/errors'
+require_relative 'cov_loupe/errors/error_handler'
+require_relative 'cov_loupe/errors/error_handler_factory'
+require_relative 'cov_loupe/paths/path_relativizer'
+require_relative 'cov_loupe/loaders/resultset_loader'
+require_relative 'cov_loupe/model/model'
+require_relative 'cov_loupe/coverage/coverage_reporter'
 
 module CovLoupe
   class << self
+    # === Context Management and Thread Safety ===
+    #
+    # CovLoupe manages configuration (logging, error handling) via `AppContext` objects.
+    # The resolution strategy is:
+    # 1. Thread-local: Use `Thread.current[:cov_loupe_context]` if set.
+    # 2. Global default: Fall back to `@internal_default_context`.
+    #
+    # This design supports both simple CLI usage (one global context) and multi-threaded
+    # library usage (per-thread contexts).
+    #
+    # Thread Safety:
+    # - `mutex` protects all reads/writes to `@internal_default_context`.
+    # - `default_log_file=` atomically updates the global default. Threads using the
+    #   default (nil thread-local context) will immediately see the new value.
+    # - `active_log_file=` creates or updates a *thread-local* context, isolating
+    #   changes to the current thread.
+    #
+    # This separation ensures that changing the global default is safe and predictable,
+    # while allowing threads to diverge when necessary without race conditions.
+
     THREAD_CONTEXT_KEY = :cov_loupe_context
+    private_constant :THREAD_CONTEXT_KEY
 
     def run(argv)
-      # Prepend environment options once at entry point
-      full_argv = extract_env_opts + argv
+      # Parse config to determine mode
+      require_relative 'cov_loupe/config/config_parser'
 
-      if ModeDetector.cli_mode?(full_argv)
-        # CLI mode: pass merged argv to CoverageCLI
+      begin
+        # Prepend environment options once at entry point
+        full_argv = extract_env_opts + argv
+        config = ConfigParser.parse(full_argv.dup)
+      rescue OptionParser::ParseError, ConfigurationError => e
+        warn "Error: #{e.message}"
+        warn "Run 'cov-loupe --help' for usage information."
+        exit 2
+      end
+
+      if config.mode == :cli
+        # CLI mode: load CLI components only
+        require_relative 'cov_loupe/loaders/all_cli'
         CoverageCLI.new.run(full_argv)
       else
-        # MCP server mode: parse config once from full_argv
-        require_relative 'cov_loupe/config_parser'
-        config = ConfigParser.parse(full_argv)
+        # MCP server mode: load MCP server components only
+        require_relative 'cov_loupe/loaders/all_mcp'
 
         if config.log_file == 'stdout'
           raise ConfigurationError,
@@ -57,7 +71,7 @@ module CovLoupe
 
         handler = ErrorHandlerFactory.for_mcp_server(error_mode: config.error_mode)
         context = create_context(error_handler: handler, log_target: config.log_file,
-          mode: :mcp)
+          mode: :mcp, app_config: config)
         with_context(context) { MCPServer.new(context: context).run }
       end
     end
@@ -74,11 +88,12 @@ module CovLoupe
       Thread.current[THREAD_CONTEXT_KEY] || default_context
     end
 
-    def create_context(error_handler:, log_target: nil, mode: :library)
+    def create_context(error_handler:, log_target: nil, mode: :library, app_config: nil)
       AppContext.new(
         error_handler: error_handler,
         log_target: log_target.nil? ? default_context.log_target : log_target,
-        mode: mode
+        mode: mode,
+        app_config: app_config
       )
     end
 
@@ -87,13 +102,11 @@ module CovLoupe
     end
 
     def default_log_file=(value)
-      previous_default = default_context
-      @default_context = previous_default.with_log_target(value)
-      active = Thread.current[THREAD_CONTEXT_KEY]
-      if active.nil? || active.log_target == previous_default.log_target
-        Thread.current[THREAD_CONTEXT_KEY] = @default_context
+      mutex.synchronize do
+        previous_default = internal_default_context
+        @internal_default_context = previous_default.with(log_target: value)
       end
-      value # rubocop:disable Lint/Void -- return assigned log target for symmetry
+      value # rubocop:disable Lint/Void -- Setter should return assigned value for direct calls.
     end
 
     def active_log_file
@@ -103,11 +116,11 @@ module CovLoupe
     def active_log_file=(value)
       current = Thread.current[THREAD_CONTEXT_KEY]
       Thread.current[THREAD_CONTEXT_KEY] = if current
-        current.with_log_target(value)
+        current.with(log_target: value)
       else
-        default_context.with_log_target(value)
+        base = mutex.synchronize { internal_default_context }
+        base.with(log_target: value)
       end
-      value # rubocop:disable Lint/Void -- return assigned log target for symmetry
     end
 
     def error_handler
@@ -115,26 +128,41 @@ module CovLoupe
     end
 
     def error_handler=(handler)
-      @default_context = default_context.with_error_handler(handler)
+      mutex.synchronize do
+        previous_default = internal_default_context
+        @internal_default_context = previous_default.with(error_handler: handler)
+      end
+    end
+
+    def logger
+      context.logger
+    end
+
+    # Returns true if running on Windows (mingw, mswin, cygwin).
+    def windows?
+      return @windows if defined?(@windows)
+
+      @windows = RUBY_PLATFORM.match?(/mingw|mswin|cygwin/)
+    end
+
+    private def mutex
+      @mutex ||= Mutex.new
     end
 
     private def default_context
-      @default_context ||= AppContext.new(
+      mutex.synchronize { internal_default_context }
+    end
+
+    private def internal_default_context
+      @internal_default_context ||= AppContext.new(
         error_handler: ErrorHandlerFactory.for_cli,
         log_target: nil
       )
     end
 
     private def extract_env_opts
-      require 'shellwords'
-      opts_string = ENV['COV_LOUPE_OPTS']
-      return [] unless opts_string && !opts_string.empty?
-
-      begin
-        Shellwords.split(opts_string)
-      rescue ArgumentError
-        [] # Ignore parsing errors
-      end
+      require_relative 'cov_loupe/option_parsers/env_options_parser'
+      OptionParsers::EnvOptionsParser.new.parse_env_opts
     end
   end
 end