mpls

If you otherwise prefer to build manually from source, if you want the KaTeX math extension, or if no prebuilt binaries are available for your architecture, follow these steps:

1. Clone the repository:

   git clone https://github.com/mhersson/mpls.git
   cd mpls
   

2. Build the project:

   You can build the project using the following command:

   To include the math extension, you need to set CGO_ENABLED=1 before running this command:

   make build
   

   This command will compile the source code and create an executable.

3. Install the executable:

   You have two options to install the executable:

   • Option 1: Copy the executable to your PATH:

     After building, you can manually copy the executable to a directory that is in your system's PATH. For example:

     sudo cp mpls /usr/local/bin/
     

   • Option 2: Use make install if you are using GOPATH:

     If the GOPATH is in your PATH, you can run:

     make install
     

     This will install the executable to your $GOPATH/bin directory.

In your languages.toml

# Configured to run alongside marksman.
[[language]]
auto-format = true
language-servers = ["marksman", "mpls"]
name = "markdown"

[language-server.mpls]
command = "mpls"
args = ["--theme", "tokyonight", "--enable-emoji"]
# An example args entry showing how to specify flags with values:
# args = ["--port", "8080", "--browser", "google-chrome", "--theme", "gruvbox-dark"]

You can manually open the preview by running the command :lsp-workspace-command open-preview in Helix, and also set up a keybinding for it in your config.toml:

For example, to bind it to Ctrl-m:

[keys.normal]
"C-m" = ":lsp-workspace-command open-preview"

The nvim-lspconfig extension is the easiest way to configure mpls with Neovim. If you prefer not to install the extension, you can copy the complete configuration shown below manually to ~/.config/nvim/lsp/mpls.lua instead. Whichever method you choose, you need to enable the language server with:

-- filename: ~/.config/nvim/init.lua
vim.lsp.enable({"mpls"})

The nvim-lspconfig provides the following command to start the preview:

:LspMplsOpenPreview

Complete configuration: (Includes custom args and an optional keybinding)

-- filename: ~/.config/nvim/lsp/mpls.lua
---@type vim.lsp.Config
return {
    cmd = {
        "mpls",
        "--no-auto",
        "--theme",
        "dark",
        "--enable-emoji",
        "--enable-footnotes",
    },
    root_markers = { ".marksman.toml", ".git" },
    filetypes = { "markdown" },
    on_attach = function(client, bufnr)
        vim.api.nvim_create_autocmd("BufEnter", {
            pattern = { "*.md" },
            group = vim.api.nvim_create_augroup("lspconfig.mpls.focus", { clear = true }),
            callback = function(ctx)
                ---@diagnostic disable-next-line:param-type-mismatch
                client:notify("mpls/editorDidChangeFocus", { uri = ctx.match })
            end,
            desc = "mpls: notify buffer focus changed",
        })
        vim.api.nvim_buf_create_user_command(bufnr, "LspMplsOpenPreview", function()
            client:exec_cmd({
                title = "Preview markdown with mpls",
                command = "open-preview",
            })
        end, { desc = "Preview markdown with mpls" })
        -- Optional keybinding
        vim.keymap.set("n", "<leader>mp", "<cmd>LspMplsOpenPreview<cr>", {
            buffer = bufnr,
            desc = "Markdown Preview",
        })
    end,
}

In your config.el

(after! markdown-mode
  ;; Auto start
  (add-hook 'markdown-mode-local-vars-hook #'lsp!))

(after! lsp-mode
  (defgroup lsp-mpls nil
    "Settings for the mpls language server client."
    :group 'lsp-mode
    :link '(url-link "https://github.com/mhersson/mpls"))

  (defun mpls-open-preview ()
    "Open preview of current buffer"
    (interactive)
    (lsp-request
     "workspace/executeCommand"
     (list :command "open-preview")))

  (defcustom lsp-mpls-server-command "mpls"
    "The binary (or full path to binary) which executes the server."
    :type 'string
    :group 'lsp-mpls)

  (lsp-register-client
  (make-lsp-client :new-connection (lsp-stdio-connection
                                     (lambda ()
                                       (list
                                        (or (executable-find lsp-mpls-server-command)
                                            (lsp-package-path 'mpls)
                                            "mpls")
                                        "--theme" "nord"
                                        "--enable-emoji"
                                        )))
                    :activation-fn (lsp-activate-on "markdown")
                    :initialized-fn (lambda (workspace)
                                      (with-lsp-workspace workspace
                                        (lsp--set-configuration
                                        (lsp-configuration-section "mpls"))
                                        ))
                    ;; Priority and add-on? are not needed,
                    ;; but makes mpls work alongside other lsp servers like marksman
                    :priority 1
                    :add-on? t
                    :server-id 'mpls))

  ;; Send mpls/editorDidChangeFocus events
  (defvar last-focused-markdown-buffer nil
    "Tracks the last markdown buffer that had focus.")

  (defun send-markdown-focus-notification ()
    "Send an event when focus changes to a markdown buffer."
    (when (and (eq major-mode 'markdown-mode)
               (not (eq (current-buffer) last-focused-markdown-buffer))
               lsp--buffer-workspaces)
      (setq last-focused-markdown-buffer (current-buffer))

      ;; Get the full file path and convert it to a URI
      (let* ((file-name (buffer-file-name))
             (uri (lsp--path-to-uri file-name)))
        ;; Send notification
        (lsp-notify "mpls/editorDidChangeFocus"
                    (list :uri uri
                          :fileName file-name)))))

  (defun setup-markdown-focus-tracking ()
    "Setup tracking for markdown buffer focus changes."
    (add-hook 'buffer-list-update-hook
              (lambda ()
                (let ((current-window-buffer (window-buffer (selected-window))))
                  (when (and (eq current-window-buffer (current-buffer))
                             (eq major-mode 'markdown-mode)
                             (buffer-file-name))
                    (send-markdown-focus-notification))))))

  ;; Initialize the tracking
  (setup-markdown-focus-tracking))