kotoshu-lsp 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8896f868dc8b62b6c4b009a8a66c7f1f1f66345c1810d7ead58c1ac6b92a22ed
-  data.tar.gz: dae5536d6035f67546136f12ffe1fc52d602bdffc8dd5eeba120fec2313c4cd7
+  metadata.gz: 7af47ef2f73700181e352546f4e00ab0df3480bb4b1d96e3a60c2afe71ceb5da
+  data.tar.gz: 66a3bc0f8e1ad17e0bf63c0e221974034d05974f6d78da92757efb1d57aa57b3
 SHA512:
-  metadata.gz: 81369a5e80fd0fe94e41aa1baef80a8d099f6e5e26b6c8a67ead93ddd4b7ec6242e1aea5604419a9aaf9586f748acd12d8793a8afd15e9a12fc15288cffb4d3f
-  data.tar.gz: 8cf8d948c812075b068479e25737a0d43999831f2dea87a018d6d62fe8c1049d96bb27076f88173ed91d4bd4ae1939669d768402ee9e8ce8e5c215c14014d909
+  metadata.gz: d41c5c06ed3ed8cb2158ecc7b8882c42cda0aa8b43d6a9b52902e5826067a492ed424a1ac5a38bec91be2fa82e7834db8fe01430c1696af5d8d9a133e0eef83f
+  data.tar.gz: 032c0037ccdb4daceae90d850accde1666ceb35f31057272928375a752db48584930b17f87d421f8bb6eb39b69b0e24955a7294f7814538bdfe9d8b75321d421

data/LICENSE

@@ -0,0 +1,26 @@
+BSD 2-Clause License
+
+Copyright (c) 2025-2026, Kotoshu contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+

data/README.md

@@ -0,0 +1,95 @@
+# kotoshu-lsp
+
+Language Server Protocol server wrapping the [Kotoshu](https://github.com/kotoshu/kotoshu) spell checker.
+
+## Status
+
+MVP. Implements `initialize`, `textDocument/didOpen|didChange|didClose`,
+`textDocument/publishDiagnostics`, `textDocument/codeAction`,
+`textDocument/hover`. Wraps `Kotoshu.check` directly.
+
+Lives in the `kotoshu/` workspace as a sibling of the `kotoshu` library
+gem. See `TODO.impl/60-lsp-server.md` for the full plan.
+
+## Install
+
+```bash
+gem install kotoshu-lsp
+# or from source:
+cd kotoshu-lsp && bundle install && bundle exec rake install
+```
+
+Requires the `kotoshu` gem (auto-installed as a runtime dep).
+
+## Editor wiring
+
+### Neovim (built-in LSP)
+
+```lua
+require('lspconfig').kotoshu.setup({
+  cmd = { 'kotoshu-lsp' },
+  filetypes = { 'text', 'markdown', 'asciidoc' },
+})
+```
+
+If `lspconfig` does not yet have a `kotoshu` entry, wire it manually:
+
+```lua
+vim.lsp.start({
+  name = 'kotoshu',
+  cmd = { 'kotoshu-lsp' },
+  root_dir = vim.fs.dirname(vim.fs.find({ '.git' }, { upward = true })[1]),
+})
+```
+
+### VS Code
+
+Install the `kotoshu-lsp` extension (when published — `61-editor-ecosystem.md`).
+Or wire it manually via `languageServerExample` extension boilerplate
+with ` LanguageId: ['plaintext', 'markdown']` and
+`command: 'kotoshu-lsp'`.
+
+### Emacs (`lsp-mode`)
+
+```elisp
+(with-eval-after-load 'lsp-mode
+  (add-to-list 'lsp-language-id-configuration
+               '(text-mode . "plaintext"))
+  (lsp-register-client
+   (make-lsp-client :new-connection (lsp-stdio-connection '("kotoshu-lsp"))
+                    :activation-fn (lsp-activate-on "plaintext" "markdown")
+                    :server-id 'kotoshu)))
+```
+
+### Emacs (`eglot`)
+
+```elisp
+(add-to-list 'eglot-server-programs
+             '((text-mode markdown-mode) . ("kotoshu-lsp")))
+```
+
+## Configuration
+
+| Env var | Default | Purpose |
+|---|---|---|
+| `KOTOSHU_LSP_LOG` | unset | Path to write a per-session log |
+| `KOTOSHU_LSP_LOG_LEVEL` | `info` | `debug` / `info` / `warn` / `error` |
+| `KOTOSHU_OFFLINE` | unset | Never trigger downloads; misspelled words still flagged against cached dictionaries |
+
+## Protocol surface
+
+| Method | Status |
+|---|---|
+| `initialize` | ✅ |
+| `initialized` / `shutdown` / `exit` | ✅ |
+| `textDocument/didOpen` | ✅ publishes diagnostics |
+| `textDocument/didChange` (full sync) | ✅ republishes |
+| `textDocument/didClose` | ✅ clears diagnostics |
+| `textDocument/publishDiagnostics` | ✅ one diag per misspelled word, top-N suggestions in `data.suggestions` |
+| `textDocument/codeAction` | ✅ one quickfix per suggestion + add-to-personal-dictionary |
+| `textDocument/hover` | ✅ shows top-N suggestions on a flagged word |
+| `textDocument/completion` | not implemented (returns `nil`) |
+
+## License
+
+BSD-2-Clause, same as Kotoshu.

data/exe/kotoshu-lsp

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
+require "kotoshu/lsp"
+
+Kotoshu::Lsp.run

data/lib/kotoshu/lsp/server.rb

@@ -0,0 +1,513 @@
+# frozen_string_literal: true
+
+require "logger"
+require "json"
+require "kotoshu"
+
+module Kotoshu
+  module Lsp
+    module Protocol
+      DIAGNOSTIC_SEVERITY = {
+        error: 1,
+        warning: 2,
+        information: 3,
+        hint: 4
+      }.freeze
+
+      COMPLETION_TRIGGER_KIND = { invoked: 0, character: 2 }.freeze
+
+      module_function
+
+      def range_from_offsets(text, start_offset, end_offset)
+        line_start = line_of(text, start_offset)
+        char_start = start_offset - line_begin(text, start_offset)
+        line_end = line_of(text, end_offset)
+        char_end = end_offset - line_begin(text, end_offset)
+        {
+          start: { line: line_start, character: char_start },
+          end:   { line: line_end, character: char_end }
+        }
+      end
+
+      def line_of(text, offset)
+        text[0...offset].count("\n")
+      end
+
+      def line_begin(text, offset)
+        return 0 if offset <= 0
+
+        last_nl = text.rindex("\n", offset - 1)
+        last_nl ? last_nl + 1 : 0
+      end
+    end
+
+    class DocumentStore
+      def initialize
+        @docs = {}
+        @mutex = Mutex.new
+      end
+
+      def set(uri, text, language_id = nil)
+        @mutex.synchronize do
+          @docs[uri] = { text: text, language_id: language_id, version: 0 }
+        end
+      end
+
+      def update(uri, text, version: nil)
+        @mutex.synchronize do
+          doc = @docs[uri]
+          return unless doc
+
+          doc[:text] = text
+          doc[:version] = version if version
+        end
+      end
+
+      def remove(uri)
+        @mutex.synchronize { @docs.delete(uri) }
+      end
+
+      def get(uri)
+        @mutex.synchronize { @docs[uri] }
+      end
+
+      def text(uri)
+        doc = get(uri)
+        doc ? doc[:text] : nil
+      end
+
+      # All open [uri, document] pairs, snapshot under the lock.
+      def each_open
+        @mutex.synchronize { @docs.dup.each { |uri, doc| yield(uri, doc) } }
+      end
+    end
+
+    class Checker
+      def initialize(logger:)
+        @logger = logger
+        @spellcheckers = {}
+        @spellcheckers_mutex = Mutex.new
+        @personal_dictionary_words = Set.new
+        @personal_dictionary_mtime = nil
+      end
+
+      def reset
+        @spellcheckers_mutex.synchronize { @spellcheckers.clear }
+      end
+
+      def check(text, language:)
+        Kotoshu.reset_spellchecker if @spellcheckers.empty?
+
+        checker = checker_for(language)
+        return empty_result(text) unless checker
+
+        result = checker.check(text)
+        filter_personal_dictionary(result)
+        result
+      rescue Kotoshu::ResourceNotSetupError => e
+        @logger.warn("resource not set up for #{language}: #{e.message}")
+        nil
+      rescue StandardError => e
+        @logger.error("check failed: #{e.class}: #{e.message}")
+        nil
+      end
+
+      private
+
+      def checker_for(language)
+        @spellcheckers_mutex.synchronize do
+          @spellcheckers[language] ||= begin
+            bundle = Kotoshu::ResourceManager.resolve(language: language)
+            Kotoshu::Spellchecker.new(resource_bundle: bundle)
+          rescue Kotoshu::ResourceNotSetupError
+            Kotoshu.setup(language)
+            bundle = Kotoshu::ResourceManager.resolve(language: language)
+            Kotoshu::Spellchecker.new(resource_bundle: bundle)
+          end
+        end
+      rescue StandardError => e
+        @logger.warn("could not resolve checker for #{language}: #{e.message}")
+        nil
+      end
+
+      def empty_result(_text)
+        Kotoshu::Models::Result::DocumentResult.success
+      end
+
+      # Words in the user personal dictionary (~/.config/kotoshu/
+      # personal.dic, KOTOSHU_PERSONAL_DIC override) never surface as
+      # diagnostics. Reloaded whenever the file mtime changes, so
+      # additions from the CLI or an editor take effect on the next
+      # check without a server restart.
+      def filter_personal_dictionary(result)
+        return result unless result.respond_to?(:errors) && result.errors
+
+        personal = personal_dictionary_words
+        return result if personal.empty?
+
+        result.errors.reject! { |err| personal.include?(err.word.to_s.downcase) }
+        result
+      end
+
+      def personal_dictionary_words
+        path = Kotoshu::PersonalDictionary.file_path
+        mtime = File.exist?(path) ? File.mtime(path) : nil
+        if mtime != @personal_dictionary_mtime
+          @personal_dictionary_words =
+            if mtime
+              Kotoshu::PersonalDictionary.words.map(&:downcase).to_set
+            else
+              Set.new
+            end
+          @personal_dictionary_mtime = mtime
+        end
+        @personal_dictionary_words
+      end
+    end
+
+    class DiagnosticsBuilder
+      MAX_SUGGESTIONS_PER_DIAG = 5
+
+      def self.from_result(document_result, full_text, source: "kotoshu")
+        return [] unless document_result&.errors
+
+        document_result.errors.map do |err|
+          from_word_error(err, full_text, source: source)
+        end
+      end
+
+      def self.from_word_error(word_error, full_text, source: "kotoshu")
+        start_offset = word_error.position || 0
+        end_offset = start_offset + word_error.word.length
+        range = Protocol.range_from_offsets(full_text, start_offset, end_offset)
+        suggestions = word_error.suggestions.first(MAX_SUGGESTIONS_PER_DIAG).map(&:word)
+
+        {
+          range: range,
+          severity: Protocol::DIAGNOSTIC_SEVERITY[:warning],
+          code: "misspelled",
+          source: source,
+          message: "Misspelled word: #{word_error.word}",
+          data: { suggestions: suggestions }
+        }
+      end
+    end
+
+    class Server
+      ADD_TO_PERSONAL_DICTIONARY_COMMAND = "kotoshu.addToPersonalDictionary"
+
+      CAPABILITIES = {
+        textDocumentSync: { openClose: true, change: 1, save: false },
+        completionProvider: { resolveProvider: false, triggerCharacters: [] },
+        codeActionProvider: true,
+        hoverProvider: true,
+        executeCommandProvider: { commands: [ADD_TO_PERSONAL_DICTIONARY_COMMAND] }
+      }.freeze
+
+      attr_reader :documents, :checker
+
+      def initialize(input: $stdin, output: $stdout, logger: nil)
+        @input = input
+        @output = output
+        @logger = logger || self.class.default_logger
+        @documents = DocumentStore.new
+        @checker = Checker.new(logger: @logger)
+        @shutdown_requested = false
+        @output_mutex = Mutex.new
+      end
+
+      def self.default_logger
+        log_path = ENV.fetch("KOTOSHU_LSP_LOG", nil)
+        logger = log_path ? Logger.new(File.open(log_path, "a")) : Logger.new(IO::NULL)
+        logger.level = ENV.fetch("KOTOSHU_LSP_LOG_LEVEL", "info").to_i
+        logger
+      end
+
+      def run
+        @logger.info("kotoshu-lsp server starting")
+        loop do
+          message = read_message
+          break if message.nil?
+          break if @shutdown_requested && message["method"] != "exit"
+
+          handle(message)
+        end
+        @logger.info("kotoshu-lsp server exiting")
+      rescue Interrupt
+        @logger.info("interrupted")
+      rescue StandardError => e
+        @logger.error("fatal: #{e.class}: #{e.message}")
+        @logger.error(e.backtrace.first(15).join("\n"))
+        raise
+      end
+
+      private
+
+      def handle(message)
+        method_name = message["method"]
+        params = message["params"] || {}
+        id = message["id"]
+
+        case method_name
+        when "initialize" then respond(id, handle_initialize(params))
+        when "initialized" then log(:info, "client initialized")
+        when "shutdown" then @shutdown_requested = true; respond(id, nil)
+        when "exit" then @shutdown_requested = true
+        when "textDocument/didOpen" then handle_did_open(params)
+        when "textDocument/didChange" then handle_did_change(params)
+        when "textDocument/didClose" then handle_did_close(params)
+        when "textDocument/codeAction" then respond(id, handle_code_action(params))
+        when "textDocument/hover" then respond(id, handle_hover(params))
+        when "textDocument/completion" then respond(id, nil)
+        when "workspace/executeCommand" then respond(id, handle_execute_command(params))
+        else
+          respond_error(id, -32601, "Method not found: #{method_name}") if id
+        end
+      end
+
+      def handle_initialize(params)
+        {
+          capabilities: CAPABILITIES,
+          serverInfo: { name: "kotoshu-lsp", version: Kotoshu::VERSION }
+        }
+      end
+
+      def handle_did_open(params)
+        td = params["textDocument"] || {}
+        uri = td["uri"]
+        text = td["text"] || ""
+        language_id = td["languageId"]
+        @documents.set(uri, text, language_id)
+
+        publish_diagnostics(uri, text, language_id_for(uri, language_id))
+      end
+
+      def handle_did_change(params)
+        td = params["textDocument"] || {}
+        uri = td["uri"]
+        changes = params["contentChanges"] || []
+        new_text = changes.last&.fetch("text")
+        return unless new_text
+
+        @documents.update(uri, new_text, version: td["version"])
+        doc = @documents.get(uri)
+        publish_diagnostics(uri, new_text, language_id_for(uri, doc&.fetch(:language_id, nil)))
+      end
+
+      def handle_did_close(params)
+        uri = (params["textDocument"] || {})["uri"]
+        @documents.remove(uri)
+        send_notification("textDocument/publishDiagnostics", { uri: uri, diagnostics: [] })
+      end
+
+      def publish_diagnostics(uri, text, language)
+        result = @checker.check(text, language: language)
+        diagnostics = result ? DiagnosticsBuilder.from_result(result, text) : []
+        send_notification("textDocument/publishDiagnostics",
+                          { uri: uri, diagnostics: diagnostics })
+      end
+
+      # Server-side execution of the add-to-personal-dictionary
+      # quickfix. Clients that implement the command locally (the VS
+      # Code extension does) shadow this; every other LSP client gets
+      # it for free. Adding republishes diagnostics for all open
+      # documents so the word stops being flagged immediately.
+      def handle_execute_command(params)
+        case params["command"]
+        when ADD_TO_PERSONAL_DICTIONARY_COMMAND
+          uri, range = params["arguments"] || []
+          word = personal_word_at(uri, range)
+          return nil unless word && !word.empty?
+
+          Kotoshu::PersonalDictionary.add_word(word)
+          @checker.reset
+          republish_all_diagnostics
+          nil
+        else
+          nil
+        end
+      end
+
+      def personal_word_at(uri, range)
+        text = @documents.text(uri)
+        return nil unless text && range.is_a?(Hash)
+
+        start = range["start"] || {}
+        offset = offset_for_position(text, start["line"] || 0, start["character"] || 0)
+        return nil unless offset
+
+        word_at(text, offset)
+      end
+
+      def republish_all_diagnostics
+        @documents.each_open do |uri, doc|
+          language = language_id_for(uri, doc[:language_id])
+          publish_diagnostics(uri, doc[:text] || "", language)
+        end
+      end
+
+      def handle_code_action(params)
+        td = params["textDocument"] || {}
+        uri = td["uri"]
+        context = params["context"] || {}
+        range = params["range"] || {}
+
+        diags = context["diagnostics"] || []
+        actions = []
+        diags.each do |diag|
+          suggestions = (diag["data"] && diag["data"]["suggestions"]) || []
+          suggestions.each_with_index do |word, idx|
+            actions << code_action_replace(uri, diag["range"], word, idx.zero?)
+          end
+          actions << code_action_add_to_personal_dict(uri, diag["range"])
+        end
+        actions
+      end
+
+      def code_action_replace(uri, range, replacement, preferred)
+        action = {
+          title: "Kotoshu: change to \"#{replacement}\"",
+          kind: "quickfix",
+          edit: {
+            changes: { uri => [{ range: range, newText: replacement }] }
+          }
+        }
+        action[:isPreferred] = true if preferred
+        action
+      end
+
+      def code_action_add_to_personal_dict(uri, range)
+        {
+          title: "Kotoshu: add word to personal dictionary",
+          kind: "quickfix",
+          command: {
+            title: "Add to personal dictionary",
+            command: ADD_TO_PERSONAL_DICTIONARY_COMMAND,
+            arguments: [uri, range]
+          }
+        }
+      end
+
+      def handle_hover(params)
+        td = params["textDocument"] || {}
+        uri = td["uri"]
+        pos = params["position"] || {}
+        text = @documents.text(uri)
+        return nil unless text
+
+        offset = offset_for_position(text, pos["line"] || 0, pos["character"] || 0)
+        return nil unless offset
+
+        word = word_at(text, offset)
+        return nil unless word && !word.empty?
+
+        result = @checker.check(word, language: language_id_for(uri, @documents.get(uri)&.fetch(:language_id, nil)))
+        err = result&.errors&.first
+        return nil unless err
+
+        {
+          contents: [
+            "Misspelled: `#{err.word}`",
+            "Suggestions: #{err.suggestions.first(5).map(&:word).join(', ')}"
+          ]
+        }
+      end
+
+      def word_at(text, offset)
+        return "" if offset >= text.length || offset.negative?
+
+        start = offset
+        start -= 1 while start > 0 && word_char?(text[start - 1])
+        finish = offset
+        finish += 1 while finish < text.length && word_char?(text[finish])
+        text[start...finish]
+      end
+
+      def word_char?(char)
+        char =~ /[A-Za-z']/
+      end
+
+      def offset_for_position(text, line, character)
+        line_starts = [0]
+        text.each_char.with_index do |c, i|
+          line_starts << (i + 1) if c == "\n"
+        end
+        return nil unless line < line_starts.size
+
+        line_starts[line] + character
+      end
+
+      def language_id_for(uri, language_id)
+        return language_id if language_id && language_id != "plaintext"
+
+        ext = File.extname(uri || "").delete_prefix(".").downcase
+        EXTENSION_TO_LANG.fetch(ext, nil) || "en"
+      end
+
+      EXTENSION_TO_LANG = {
+        "md" => "en", "markdown" => "en", "txt" => "en",
+        "asciidoc" => "en", "adoc" => "en", "ad" => "en",
+        "rb" => "en", "py" => "en", "js" => "en", "ts" => "en",
+        "go" => "en", "rs" => "en", "java" => "en"
+      }.freeze
+
+      def read_message
+        headers = read_headers
+        return nil if headers.empty?
+
+        content_length = headers["content-length"].to_i
+        return nil if content_length.zero?
+
+        body = @input.read(content_length)
+        return nil unless body
+
+        JSON.parse(body)
+      rescue JSON::ParserError => e
+        @logger.error("malformed JSON message: #{e.message}")
+        retry
+      end
+
+      def read_headers
+        headers = {}
+        loop do
+          line = @input.gets
+          return headers if line.nil?
+          line = line.chomp
+          break if line.empty?
+
+          key, value = line.split(":", 2)
+          headers[key.strip.downcase] = value.strip if value
+        end
+        headers
+      end
+
+      def respond(id, result)
+        return unless id
+
+        send_message({ jsonrpc: "2.0", id: id, result: result })
+      end
+
+      def respond_error(id, code, message)
+        send_message({ jsonrpc: "2.0", id: id, error: { code: code, message: message } })
+      end
+
+      def send_notification(method, params)
+        send_message({ jsonrpc: "2.0", method: method, params: params })
+      end
+
+      def send_message(hash)
+        payload = JSON.generate(hash)
+        header = "Content-Length: #{payload.bytesize}\r\n\r\n"
+        @output_mutex.synchronize do
+          @output.write(header)
+          @output.write(payload)
+          @output.flush
+        end
+      end
+
+      def log(level, message)
+        @logger.public_send(level, message)
+      end
+    end
+  end
+end

data/lib/kotoshu/lsp/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Kotoshu
+  module Lsp
+    VERSION = "0.1.1"
+  end
+end

data/lib/kotoshu/lsp.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative "lsp/version"
+require_relative "lsp/server"
+
+module Kotoshu
+  module Lsp
+    def self.run(input: $stdin, output: $stdout, logger: nil)
+      server = Server.new(input: input, output: output, logger: logger)
+      server.run
+    end
+  end
+end

metadata

@@ -1,13 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kotoshu-lsp
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Ribose Inc.
+autorequire:
 bindir: exe
 cert_chain: []
-date: 1980-01-02 00:00:00.000000000 Z
+date: 2026-09-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: kotoshu
@@ -28,10 +29,17 @@ description: Wraps the Kotoshu gem with a JSON-RPC LSP server so every LSP-capab
   code actions, and hover.
 email:
 - open.source@ribose.com
-executables: []
+executables:
+- kotoshu-lsp
 extensions: []
 extra_rdoc_files: []
-files: []
+files:
+- LICENSE
+- README.md
+- exe/kotoshu-lsp
+- lib/kotoshu/lsp.rb
+- lib/kotoshu/lsp/server.rb
+- lib/kotoshu/lsp/version.rb
 homepage: https://github.com/kotoshu/kotoshu-lsp
 licenses:
 - BSD-2-Clause
@@ -40,6 +48,7 @@ metadata:
   source_code_uri: https://github.com/kotoshu/kotoshu-lsp/tree/main
   changelog_uri: https://github.com/kotoshu/kotoshu-lsp/blob/main/CHANGELOG.md
   rubygems_mfa_required: 'true'
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -54,7 +63,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.16
+rubygems_version: 3.5.22
+signing_key:
 specification_version: 4
 summary: Language Server Protocol server for the Kotoshu spell checker
 test_files: []