simple_english 0.5.0 → 0.13.1

data/lib/simple_english/client/language_tool.rb

@@ -2,7 +2,7 @@
 
 # The LanguageTool wire protocol: form posts to /v2/check, and
 # matches mapped back to findings. Runs daemon-side (Engine calls it
-# against the inner JVM) and in tests. The se daemon client - probe,
+# against the inner native server) and in tests. The se daemon client - probe,
 # trust, boot - lives in client/daemon.rb.
 #
 # The LanguageTool namespace is shared with setup/languagetool.rb,
@@ -14,6 +14,7 @@ require "net/http"
 require "uri"
 
 require_relative "../lint/plain_text"
+require_relative "../lint/utf16"
 
 module SimpleEnglish
   module LanguageTool
@@ -71,25 +72,16 @@ module SimpleEnglish
       end
 
       def utf16_slice(text, offset, length)
-        first = utf16_index(text, offset)
-        last = utf16_index(text, offset + length)
+        first = UTF16.index(text, offset)
+        last = UTF16.index(text, offset + length)
         text[first...last]
       end
 
-      def utf16_index(text, offset)
-        units = 0
-        text.each_char.with_index do |char, index|
-          return index if units >= offset
-          units += (char.ord > 0xFFFF) ? 2 : 1
-        end
-        text.length
-      end
-
       def to_payload(payload)
         payload.is_a?(String) ? PlainText.new(payload) : payload
       end
 
-      private_class_method :to_payload, :with_context, :utf16_slice, :utf16_index
+      private_class_method :to_payload, :with_context, :utf16_slice
     end
   end
 end

data/lib/simple_english/daemon/engine.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-# The complete lint engine, daemon-side. Never call SimpleEnglish.lint_text
+# The complete lint engine, daemon-side. Never call SimpleEnglish.lint
 # here: that call probes the daemon and recurses into the server.
 # The engine reads nothing from disk: the caller captures the enabled
 # rule IDs once at daemon boot (Server.start) and passes them in.

data/lib/simple_english/daemon/server.rb

@@ -6,11 +6,9 @@
 # Failures raise typed errors (PortInUse, SetupError, InnerDied,
 # InnerTimeout). bin/se owns turning them into warnings and exit codes.
 
-require "fileutils"
 require "net/http"
 require "socket"
 require "tempfile"
-require "tmpdir"
 
 require_relative "../setup/install"
 require_relative "../client/daemon"
@@ -28,19 +26,11 @@ module SimpleEnglish
     end
 
     class InnerDied < ServerError; end
+
     class InnerTimeout < ServerError; end
 
     module_function
 
-    # LanguageTool's HTTP server has no --rulefile flag. Custom rules
-    # load from the classpath at this exact path.
-    def stage_rules(dir)
-      target = File.join(dir, "org/languagetool/rules/en/grammar_custom.xml")
-      FileUtils.mkdir_p(File.dirname(target))
-      FileUtils.cp(SimpleEnglish::LanguageTool::RULES_FILE, target)
-      target
-    end
-
     # Probes both loopback families: on IPv6-first resolvers a "localhost"
     # probe falls back to IPv4 and misses an IPv6 listener.
     def assert_port_free(port)
@@ -73,7 +63,7 @@ module SimpleEnglish
       daemon = Client.info(base_url: "http://localhost:#{port}")
       return unless daemon.is_a?(Hash)
       stop(daemon["pid"])
-      # The outer listener closes first. The inner JVM takes seconds
+      # The outer listener closes first. The inner server takes
       # longer. Both ports must free, or the next boot hits the inner
       # port and dies.
       deadline = Time.now + 10
@@ -82,7 +72,7 @@ module SimpleEnglish
               port_free?(port + 1)
     end
 
-    # Graceful only. SIGKILL skips the TERM trap and the inner JVM
+    # Graceful only. SIGKILL skips the TERM trap and the inner server
     # teardown. The orphan still holds port + 1 and breaks the next
     # boot. The pid comes off the wire, so only a positive integer is
     # TERMed: 0 signals the caller's own process group, a negative
@@ -98,9 +88,7 @@ module SimpleEnglish
     # takeover stops the old daemon: a reload that cannot boot must
     # leave the running daemon alive.
     def preflight_install(install)
-      return if File.exist?(install.server_jar) && install.java?
-      raise Install::SetupError,
-        install.java? ? install.setup_error : install.java_message
+      install.executable!
     end
     private_class_method :preflight_install
 
@@ -122,7 +110,7 @@ module SimpleEnglish
       args = ["--port", port.to_s]
       args.concat(["--dev-log", dev_log]) if dev_log
       pid = Client.spawn_daemon(*args)
-      # The child gives its inner JVM TIMEOUT_SECONDS to boot, and
+      # The child gives its inner server TIMEOUT_SECONDS to boot, and
       # the handshake answers only after that: wait the child's own
       # budget, not the default 90 s, or a slow boot reads as
       # failure while the child is still coming up.
@@ -145,23 +133,19 @@ module SimpleEnglish
     end
 
     def start(port: Client::DEFAULT_PORT, install: Install.from_env, log: $stderr)
-      rules_dir = Dir.mktmpdir("se-rules")
-      # The enabled IDs come from the staged file, so what LT loads
-      # and what each request enables can never diverge.
-      staged = stage_rules(rules_dir)
       enabled_rules = SimpleEnglish::LanguageTool.rule_ids
       daemon_info = {"version" => VERSION, "pid" => Process.pid,
                      "gem_digest" => Fingerprint.gem,
-                     "rules_digest" => Fingerprint.sha(File.read(staged))}
+                     "rules_digest" => Fingerprint.sha(File.read(LanguageTool::RULES_FILE))}
       # Preflight everything the replacement needs before the
       # takeover stops the old daemon.
       preflight_install(install)
       takeover(port)
       assert_port_free(port)
-      # The inner JVM lives on port + 1. Guard it too so an occupied
+      # The inner native server lives on port + 1. Guard it too so an occupied
       # inner port raises in milliseconds instead of timing out later.
       assert_port_free(port + 1)
-      # The inner JVM's stderr goes to a file so failure messages can quote
+      # The inner native server's stderr goes to a file so failure messages can quote
       # its first line. Only an explicitly opened dev log (a File) is reused
       # for that. $stderr reports path "<STDERR>", so it creates a file
       # by that name in the CWD. Anything else falls back to a temp file
@@ -174,7 +158,7 @@ module SimpleEnglish
           inner_log.close
           inner_log.path
         end
-      inner = spawn_inner(install: install, port: port + 1, rules_dir: rules_dir,
+      inner = spawn_inner(install: install, port: port + 1,
         log_path: inner_log_path)
       # TCPServer.new binds synchronously: construction means ready, so
       # callers need no readiness polling. Closing the socket makes the
@@ -216,7 +200,7 @@ module SimpleEnglish
         break
       end
       monitor.kill if monitor.alive?
-      raise InnerDied, "inner LanguageTool server died. Rerun se serve." if inner_died
+      raise InnerDied, "lint engine died. Rerun se serve." if inner_died
     ensure
       if inner
         begin
@@ -227,12 +211,11 @@ module SimpleEnglish
         end
       end
       monitor&.kill if monitor&.alive?
-      FileUtils.remove_entry(rules_dir) if rules_dir
     end
 
     # Reaps the inner process and runs on_death (which stops the outer
     # server) whenever it exits, so the daemon dies instead of serving
-    # without LanguageTool behind it.
+    # without the lint engine behind it.
     def monitor_inner(pid, on_death:)
       Thread.new do
         Process.wait(pid)
@@ -240,35 +223,33 @@ module SimpleEnglish
       end
     end
 
-    # Boots the inner LanguageTool server and blocks until it answers
+    # Boots the inner native server and blocks until it answers
     # /v2/check. Raises InnerDied when it dies during startup, and
     # InnerTimeout when it never becomes ready (the child is killed and
-    # reaped first, so a failed boot leaks no JVM). Both messages quote
+    # reaped first, so a failed boot leaks no process). Both messages quote
     # the inner log's first line.
-    def spawn_inner(install:, port:, rules_dir:, log_path:)
-      raise Install::SetupError, install.setup_error unless File.exist?(install.server_jar)
-      java = install.java!
+    def spawn_inner(install:, port:, log_path:)
+      executable = install.executable!
       begin
-        pid = Process.spawn(java,
-          "-cp", [install.server_jar, rules_dir].join(File::PATH_SEPARATOR),
-          "org.languagetool.server.HTTPServer", "--port", port.to_s,
+        pid = Process.spawn(executable, "--port", port.to_s,
           out: File::NULL, err: log_path)
       rescue Errno::ENOENT
-        # The java lookup can resolve to a path that no longer exists.
-        # Quote what was resolved so the crash names its cause.
-        raise ServerError, "cannot exec #{java.inspect}."
+        raise ServerError, "cannot exec #{executable.inspect}."
       end
       ready = false
       died = false
       deadline = Time.now + SimpleEnglish::LanguageTool::TIMEOUT_SECONDS
       until ready || died || Time.now > deadline
-        # A JVM that dies instantly must not be polled for the full timeout.
+        # A process that dies instantly must not be polled for the full timeout.
         # WNOHANG reaps it here, so nothing else may wait on this pid after.
         died = !!Process.wait(pid, Process::WNOHANG)
         break if died
         begin
           Net::HTTP.post_form(URI("http://localhost:#{port}/v2/check"),
-            {"language" => "en", "text" => "a"})
+            {"language" => "en",
+             "enabledRules" => SimpleEnglish::LanguageTool.rule_ids.first,
+             "enabledOnly" => "true",
+             "text" => "a"})
           ready = true
         rescue SystemCallError
           sleep 0.5
@@ -276,13 +257,13 @@ module SimpleEnglish
       end
       if died
         raise InnerDied,
-          "inner LanguageTool server exited during startup. " \
+          "lint engine exited during startup. " \
           "First log line: #{first_log_line(log_path)}"
       end
       unless ready
         kill_and_reap(pid)
         raise InnerTimeout,
-          "inner LanguageTool server did not start " \
+          "lint engine did not start " \
           "within #{SimpleEnglish::LanguageTool::TIMEOUT_SECONDS} seconds. " \
           "First log line: #{first_log_line(log_path)}"
       end

data/lib/simple_english/lint/annotated_text.rb

@@ -9,6 +9,7 @@
 require_relative "extractor"
 require_relative "segment"
 require_relative "result"
+require_relative "utf16"
 
 module SimpleEnglish
   module AnnotatedText
@@ -21,10 +22,12 @@ module SimpleEnglish
     def build(source, spans)
       segments = []
       cursor = 0 # byte offset into source
+      stream_start = 0 # character offset into the annotation stream
       emit = lambda do |text:, content:, file_char:, interpret_as: nil|
         next if content.empty?
         segments << Segment.new(text: text, content: content, file_char: file_char,
-          stream_start: segments.sum { |s| s.content.length }, interpret_as: interpret_as)
+          stream_start: stream_start, interpret_as: interpret_as)
+        stream_start += content.length
       end
       spans = spans.sort_by(&:start_byte)
       spans.each do |span|
@@ -66,20 +69,20 @@ module SimpleEnglish
 
     # -> [line, column], both 1-based. Column in UTF-16 code units.
     def locate(result, utf16_offset)
-      char = utf16_to_char(result.stream, utf16_offset)
+      char = UTF16.index(result.stream, utf16_offset)
       segment = result.segments.find do |s|
         char >= s.stream_start && char < s.stream_start + s.content.length
       end || result.segments.last
       file_char = segment.file_char + (char - segment.stream_start)
       starts = line_starts(result.source)
       line = starts.rindex { |start| start <= file_char } + 1
-      [line, utf16_column(result.source, starts[line - 1], file_char)]
+      [line, UTF16.column(result.source, starts[line - 1], file_char)]
     end
 
     def split(comment)
       marker = comment[MARKER] || ""
       body = comment[marker.length..] || comment
-      closer = body[CLOSER] || ""
+      closer = body[CLOSER, 1] || ""
       body = body[0, body.length - closer.length] unless closer.empty?
       [marker, body, closer]
     end
@@ -96,22 +99,6 @@ module SimpleEnglish
       starts
     end
 
-    def utf16_to_char(stream, offset)
-      units = 0
-      stream.each_char.with_index do |char, index|
-        return index if units >= offset
-        units += (char.ord > 0xFFFF) ? 2 : 1
-      end
-      stream.length
-    end
-
-    def utf16_column(source, from, to)
-      units = 1
-      source[from...to].each_char { |c| units += (c.ord > 0xFFFF) ? 2 : 1 }
-      units
-    end
-
-    private_class_method :split, :char_index, :line_starts,
-      :utf16_to_char, :utf16_column
+    private_class_method :split, :char_index, :line_starts
   end
 end

data/lib/simple_english/lint/extractor.rb

@@ -25,16 +25,60 @@ module SimpleEnglish
       ".cc" => "cpp",
       ".cxx" => "cpp",
       ".hpp" => "cpp",
-      ".h" => "cpp"
+      ".h" => "cpp",
+      ".c" => "c",
+      ".m" => "objc",
+      ".php" => "php",
+      ".swift" => "swift",
+      ".scala" => "scala",
+      ".ex" => "elixir",
+      ".exs" => "elixir",
+      ".lua" => "lua",
+      ".dart" => "dart",
+      ".pl" => "perl",
+      ".pm" => "perl",
+      ".r" => "r",
+      ".sql" => "sql",
+      ".hs" => "haskell",
+      ".zig" => "zig",
+      ".toml" => "toml",
+      ".ini" => "ini",
+      ".mk" => "makefile",
+      ".html" => "html",
+      ".htm" => "html",
+      ".xml" => "xml"
     }.freeze
 
+    # Dockerfile and Makefile carry no extension, and the variants
+    # keep the language: Dockerfile.dev, Makefile.dev.
+    NAME_LANGUAGES = {
+      "Dockerfile" => "dockerfile",
+      "Makefile" => "makefile",
+      "makefile" => "makefile",
+      "GNUmakefile" => "makefile"
+    }.freeze
+
+    PROSE_EXTENSIONS = [".md"].freeze
+
     module_function
 
     # nil for files we do not lint.
     def language_for(path)
+      name = File.basename(path)
+      return NAME_LANGUAGES[name] if NAME_LANGUAGES[name]
+      return "dockerfile" if name.start_with?("Dockerfile.")
+      return "makefile" if name.start_with?("Makefile.")
       EXTENSION_LANGUAGES[File.extname(path)]
     end
 
+    # true when the path is a file this linter owns: Markdown, stdin,
+    # or a supported code language. Everything else is skipped, so a
+    # single explicit path behaves like directory expansion (cli.rb).
+    def lintable?(path)
+      path == "-" || PROSE_EXTENSIONS.include?(File.extname(path)) ||
+        !language_for(path).nil?
+    end
+
     def comment_spans(source, language)
       require "tree_sitter_language_pack"
       root = TreeSitterLanguagePack.get_parser(language).parse(source).root_node
@@ -51,8 +95,11 @@ module SimpleEnglish
       spans.sort_by!(&:start_byte)
     end
 
+    # The xml grammar names the node "Comment", so the kind check
+    # reads case-insensitive.
     def comment?(node)
-      node.kind.end_with?("comment") && !node.kind.start_with?("non")
+      kind = node.kind.downcase
+      kind.end_with?("comment") && !kind.start_with?("non")
     end
 
     private_class_method :comment?

data/lib/simple_english/lint/lint_plan.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-# One decision, two callers: the CLI (SimpleEnglish.lint_file) and
+# One decision, two callers: the CLI (SimpleEnglish.lint) and
 # the daemon (Engine.lint) must agree on what kind of lint an input
 # is. The CLI decides to skip comment-free files without a boot.
 # The daemon decides again on its side of the wire. Both call this

data/lib/simple_english/lint/linter.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module SimpleEnglish
+  module Linter
+    module_function
+
+    def lint_file(path, config: Config.load)
+      return [] if Config.ignore?(config, path) || !Extractor.lintable?(path)
+      lint_text(File.read(path, encoding: "UTF-8"), language: Extractor.language_for(path), config: config, path: path)
+    end
+
+    def lint_text(text, language: nil, config: Config.load, path: nil)
+      findings = SimpleEnglish.lint(text, language: language)
+      findings && Config.filter(config, findings, path: path)
+    end
+  end
+end

data/lib/simple_english/lint/markdown.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "paragraph"
+require_relative "utf16"
 
 # Markdown stripping and paragraph splitting. Block structure comes
 # from the tree-sitter Markdown grammar shipped with the pack the
@@ -42,16 +43,12 @@ module SimpleEnglish
       # Width-preserving replacements keep LanguageTool positions aligned
       # with the source.
       line
-        .gsub(/`[^`]*`/) { |code| "X" * utf16_length(code) }
+        .gsub(/`[^`]*`/) { |code| "X" * UTF16.length(code) }
         .sub(/\A\#{1,6} /) { |marker| " " * marker.length }
     end
 
     def spaces_for(text)
-      " " * utf16_length(text)
-    end
-
-    def utf16_length(text)
-      text.each_char.sum { |char| (char.ord > 0xFFFF) ? 2 : 1 }
+      " " * UTF16.length(text)
     end
 
     # A vertical list is not one paragraph: each list item is its own.
@@ -115,7 +112,7 @@ module SimpleEnglish
       TreeSitterLanguagePack.get_parser("markdown").parse(text).root_node
     end
 
-    private_class_method :strip_line, :spaces_for, :utf16_length, :node_rows,
+    private_class_method :strip_line, :spaces_for, :node_rows,
       :blank_rows, :each_node, :inside_list_item?, :parse
   end
 end

data/lib/simple_english/lint/utf16.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+# UTF-16 code-unit arithmetic. LanguageTool is a Java service, and
+# Java strings count UTF-16 code units: an astral-plane character
+# counts as two. Every offset crossing the LT wire goes through
+# here.
+
+module SimpleEnglish
+  module UTF16
+    module_function
+
+    # The character index in text where the offsetth code unit
+    # falls.
+    def index(text, offset)
+      units = 0
+      text.each_char.with_index do |char, index|
+        return index if units >= offset
+        units += (char.ord > 0xFFFF) ? 2 : 1
+      end
+      text.length
+    end
+
+    # The code-unit length of text.
+    def length(text)
+      text.each_char.sum { |char| (char.ord > 0xFFFF) ? 2 : 1 }
+    end
+
+    # The 1-based code-unit column of the character at index to.
+    def column(source, from, to)
+      length(source[from...to]) + 1
+    end
+  end
+end

data/lib/simple_english/model_context_protocol.rb

@@ -15,7 +15,7 @@ module SimpleEnglish
 
     module_function
 
-    def run(io: $stdin, out: $stdout, linter: method(:default_linter))
+    def run(io: $stdin, out: $stdout, linter: Linter)
       # A piped stdout buffers until 4 KB or EOF. An MCP client keeps
       # stdin open while it waits for the answer, so an unflushed
       # response never arrives and the client drops the server.
@@ -26,6 +26,7 @@ module SimpleEnglish
         begin
           request = JSON.parse(line)
         rescue JSON::ParserError
+          out.puts JSON.generate(error(nil, -32700, "Parse error"))
           next
         end
         next unless request.is_a?(Hash)
@@ -41,15 +42,6 @@ module SimpleEnglish
       end
     end
 
-    # The CLI's lint pipeline as a callable: .simple-english.yml decides
-    # which paths and rules count, then the daemon lints the file.
-    def default_linter(path)
-      config = SimpleEnglish::Config.load
-      return [] if SimpleEnglish::Config.ignore?(config, path)
-      findings = SimpleEnglish.lint_file(path)
-      findings.nil? ? nil : SimpleEnglish::Config.filter(config, path, findings)
-    end
-
     def respond(request, linter:)
       return nil unless request.key?("id")
       id = request.fetch("id")
@@ -59,6 +51,7 @@ module SimpleEnglish
       params = {} unless params.is_a?(Hash)
       case method
       when "initialize" then ok(id, initialize_result(params["protocolVersion"]))
+      when "ping" then ok(id, {})
       when "tools/list" then ok(id, {"tools" => [lint_tool]})
       when "tools/call" then tools_call(id, params, linter)
       else error(id, -32601, "Method not found: #{method}")
@@ -80,12 +73,14 @@ module SimpleEnglish
         "description" =>
           "Lint Markdown prose and code comments against plain-English rules " \
           "(short sentences, active voice, no jargon, no filler). " \
-          "Input: a file path. Returns one line per finding, or 'clean' when " \
+          "Input: a file path, or Markdown text. Returns one line per finding, or 'clean' when " \
           "nothing is flagged. Fix the findings, then call again until clean.",
         "inputSchema" => {
           "type" => "object",
-          "properties" => {"path" => {"type" => "string", "description" => "File to lint"}},
-          "required" => ["path"]
+          "properties" => {
+            "path" => {"type" => "string", "description" => "File to lint"},
+            "text" => {"type" => "string", "description" => "Markdown text to lint instead of a file"}
+          }
         }
       }
     end
@@ -96,12 +91,16 @@ module SimpleEnglish
       arguments = params["arguments"]
       arguments = {} unless arguments.is_a?(Hash)
       path = arguments["path"]
-      return ok(id, tool_error("the path argument is required.")) if path.nil? || path.to_s.empty?
-      return ok(id, tool_error("#{path} is a directory. Give one file.")) if File.directory?(path)
-      return ok(id, tool_error("file not found: #{path}")) unless File.exist?(path)
+      text = arguments["text"]
+      return ok(id, tool_error("give the path or the text, not both.")) if path && text
+      unless text
+        return ok(id, tool_error("the path or text argument is required.")) if path.nil? || path.to_s.empty?
+        return ok(id, tool_error("#{path} is a directory. Give one file.")) if File.directory?(path)
+        return ok(id, tool_error("file not found: #{path}")) unless File.exist?(path)
+      end
       findings =
         begin
-          linter.call(path)
+          text ? linter.lint_text(text) : linter.lint_file(path)
         rescue SimpleEnglish::Config::ConfigError => e
           return ok(id, tool_error("invalid .simple-english.yml: #{e.message}"))
         end
@@ -110,7 +109,7 @@ module SimpleEnglish
         # model, and this message is the one that tells it how to recover.
         ok(id, tool_error("the se daemon did not answer. Run `se serve --detached` and retry."))
       else
-        ok(id, {"content" => [{"type" => "text", "text" => render(path, findings)}], "isError" => false})
+        ok(id, {"content" => [{"type" => "text", "text" => render(text ? "-" : path, findings)}], "isError" => false})
       end
     end
 

data/lib/simple_english/setup/config.rb

@@ -1,13 +1,14 @@
 # frozen_string_literal: true
 
 # .simple-english.yml: ignore (path globs, matched against the paths
-# given on the command line) and disabled-rules (rule IDs dropped
-# from every file). Loaded from the CWD.
+# given on the command line), disabled-rules (rule IDs dropped
+# from every file), and rule-ignores (a rule dropped only on the
+# listed path globs, fired everywhere else). Loaded from the CWD.
 
 module SimpleEnglish
   module Config
     ConfigError = Class.new(StandardError)
-    DEFAULT = {ignore: [], disabled_rules: []}.freeze
+    DEFAULT = {ignore: [], disabled_rules: [], rule_ignores: {}}.freeze
 
     module_function
 
@@ -17,18 +18,33 @@ module SimpleEnglish
       require "yaml"
       data = YAML.safe_load_file(file) || {}
       {ignore: Array(data["ignore"]),
-       disabled_rules: Array(data["disabled-rules"])}
+       disabled_rules: Array(data["disabled-rules"]),
+       rule_ignores: load_rule_ignores(data["rule-ignores"])}
     rescue Psych::SyntaxError => e
       raise ConfigError, ".simple-english.yml: #{e.message}"
     end
 
+    # Loose like the other keys: a rule ID with no entry means the
+    # rule fires everywhere, so a wrong ID surfaces its findings
+    # instead of hiding them.
+    def load_rule_ignores(data)
+      return {} unless data.is_a?(Hash)
+      data.to_h { |rule, globs| [rule, Array(globs)] }
+    end
+
     # Hooks pass absolute paths while ignore globs are written
     # relative to the repo root (the CWD). Match both forms.
     # realpath because CWD may be a symlink-resolved path while the
     # caller's string still carries the symlink (TMPDIR on macOS).
     def ignore?(config, path)
+      path_matches?(config[:ignore], path)
+    end
+
+    def path_matches?(globs, path)
       candidates = [path, relative_candidate(path)].compact
-      candidates.any? { |candidate| config[:ignore].any? { |pattern| matches?(pattern, candidate) } }
+      globs.any? do |pattern|
+        candidates.any? { |candidate| matches?(pattern, candidate) }
+      end
     end
 
     def relative_candidate(path)
@@ -54,10 +70,16 @@ module SimpleEnglish
       end.join("/") + "\\z")
     end
 
-    def filter(config, path, findings)
-      return [] if ignore?(config, path)
+    # rule-ignores needs the finding's file, which findings do not
+    # carry, so the caller passes path in. A nil path (stdin, MCP
+    # text) has no path to match, so every rule fires.
+    def filter(config, findings, path: nil)
       disabled = config[:disabled_rules]
-      findings.reject { |finding| disabled.include?(finding.rule) }
+      rule_ignores = config[:rule_ignores] || {}
+      findings.reject do |finding|
+        disabled.include?(finding.rule) ||
+          (path && path_matches?(rule_ignores[finding.rule] || [], path))
+      end
     end
   end
 end