simple_english 0.4.2 → 0.13.1

data/lib/simple_english/client/daemon.rb

@@ -141,8 +141,8 @@ module SimpleEnglish
       # Preflight everything the spawn needs: a missing prerequisite
       # must fail fast with the real blocker named, not spawn a
       # doomed child and wait out 90 s.
-      unless File.exist?(install.server_jar) && install.java?
-        warn(install.java? ? install.setup_error : install.java_message)
+      unless install.executable?
+        warn install.setup_error
         return false
       end
       # One boot at a time: a concurrent lint that also found the
@@ -153,7 +153,7 @@ module SimpleEnglish
       with_spawn_lock do
         daemon = info
         unless daemon
-          warn "se: daemon not running; starting it (first lint takes ~15s)..."
+          warn "se: daemon not running; starting it (first lint may take a few seconds)..."
           spawn_daemon
           daemon = wait_for { info }
         end
@@ -185,10 +185,9 @@ module SimpleEnglish
         "(#{VERSION}). #{fix} Linting against it meanwhile."
     end
 
-    # A per-user lock keyed by the port, independent of the
-    # installation cache: daemon ownership is scoped to the port,
-    # so two lints with different SE_CACHE_DIR values still
-    # coordinate. flock releases when the block ends, even on
+    # A per-user lock keyed by the port: daemon ownership is scoped
+    # to the port, so concurrent lints coordinate across installs.
+    # flock releases when the block ends, even on
     # failure.
     def with_spawn_lock
       dir = File.join(Dir.home, ".cache", "simple_english")

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/finding.rb

@@ -5,5 +5,20 @@
 # daemon can have a start column without an end position.
 
 module SimpleEnglish
-  Finding = Struct.new(:line, :column, :end_line, :end_column, :rule, :message)
+  Finding = Struct.new(:line, :column, :end_line, :end_column, :rule, :message) do
+    # One finding as a text line: `path:line:col-end: [rule] message`.
+    # The CLI text output, the MCP tool, and the hook feedback all share
+    # this format. Keep them in step by rendering through this method.
+    def to_line(path)
+      location = "#{path}:#{line}"
+      if column
+        location += ":#{column}"
+        if end_line && end_column
+          finish = (end_line == line) ? end_column : "#{end_line}:#{end_column}"
+          location += "-#{finish}"
+        end
+      end
+      "#{location}: [#{rule}] #{message}"
+    end
+  end
 end

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

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require "json"
+
+# MCP JSON-RPC server for the lint engine. `respond` is pure: request
+# Hash in, response Hash or nil (notifications) out. `run` drives it
+# over stdio, one JSON-RPC message per line. Protocol facts:
+# integrations/verification.md.
+
+module SimpleEnglish
+  module ModelContextProtocol
+    SUPPORTED_VERSIONS = ["2025-06-18", "2025-03-26", "2024-11-05"].freeze
+    LATEST_VERSION = "2025-06-18"
+    SERVER_NAME = "simple-english"
+
+    module_function
+
+    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.
+      out.sync = true
+      while (line = io.gets)
+        line = line.strip
+        next if line.empty?
+        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)
+        response =
+          begin
+            respond(request, linter: linter)
+          rescue => e
+            # A broken tool call (unreadable file, daemon hiccup) must not
+            # kill the loop: answer it, then serve the next line.
+            request.key?("id") ? error(request["id"], -32603, "lint failed: #{e.class}: #{e.message}") : nil
+          end
+        out.puts JSON.generate(response) if response
+      end
+    end
+
+    def respond(request, linter:)
+      return nil unless request.key?("id")
+      id = request.fetch("id")
+      method = request["method"]
+      return error(id, -32600, "Invalid Request") unless method.is_a?(String)
+      params = request["params"]
+      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}")
+      end
+    end
+
+    def initialize_result(requested_version)
+      version = SUPPORTED_VERSIONS.include?(requested_version) ? requested_version : LATEST_VERSION
+      {
+        "protocolVersion" => version,
+        "capabilities" => {"tools" => {}},
+        "serverInfo" => {"name" => SERVER_NAME, "version" => SimpleEnglish::VERSION}
+      }
+    end
+
+    def lint_tool
+      {
+        "name" => "lint",
+        "description" =>
+          "Lint Markdown prose and code comments against plain-English rules " \
+          "(short sentences, active voice, no jargon, no filler). " \
+          "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"},
+            "text" => {"type" => "string", "description" => "Markdown text to lint instead of a file"}
+          }
+        }
+      }
+    end
+
+    def tools_call(id, params, linter)
+      tool = params["name"]
+      return error(id, -32602, "Unknown tool: #{tool}") unless tool == "lint"
+      arguments = params["arguments"]
+      arguments = {} unless arguments.is_a?(Hash)
+      path = arguments["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
+          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
+      if findings.nil?
+        # A tool error, not a protocol error: clients show the text to the
+        # 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(text ? "-" : path, findings)}], "isError" => false})
+      end
+    end
+
+    def render(path, findings)
+      return "clean" if findings.empty?
+      findings.map { |finding| finding.to_line(path) }.join("\n")
+    end
+
+    def tool_error(text)
+      {"content" => [{"type" => "text", "text" => text}], "isError" => true}
+    end
+
+    def ok(id, result)
+      {"jsonrpc" => "2.0", "id" => id, "result" => result}
+    end
+
+    def error(id, code, message)
+      {"jsonrpc" => "2.0", "id" => id, "error" => {"code" => code, "message" => message}}
+    end
+  end
+end