stan-language-server 0.2.0-beta.1 → 0.3.0

package/README.md

@@ -10,45 +10,131 @@ A language server for the Stan probabilistic programming language written in Typ
 - **Code formatting**: Using the official Stan compiler
 - **Include file support**: Full `#include` resolution and compilation
 
-To install dependencies:
 
-```bash
-bun install
-```
+## Editor-specific configuration
 
-To run the language server:
+### VSCode:
 
-```bash
-bun run src/server.ts
-```
+Install the [extension](https://github.com/WardBrian/vscode-stan-extension)
+from [Marketplace](https://marketplace.visualstudio.com/items?itemName=wardbrian.vscode-stan-extension)
+or [open-vsx](https://open-vsx.org/extension/wardbrian/vscode-stan-extension).
 
-Building a binary executable:
+### Neovim
 
-```bash
-bun build server.ts --compile --outfile stan-language-server
+There are many ways to install language servers in neovim. Here is one (if you have a different or better way, consider contributing it!):
+
+Download the latest language server executable from [GitHub](https://github.com/tomatitito/stan-language-server/tags) and put it somewhere in your PATH. Then in your `nvim` config folder add `lua/lsp/init.lua` with:
+```lua
+local servers = {
+    stan_ls = "lsp.stan",
+}
+
+local function setup_server(name, config_module)
+    local config = require(config_module)
+
+    vim.api.nvim_create_autocmd("FileType", {
+        pattern = config.filetypes,
+        callback = function()
+            if #vim.lsp.get_clients({ bufnr = 0, name = name }) > 0 then
+                return
+            end
+
+            local root_dir = vim.fs.root(0, config.root_markers)
+            print(string.format("Starting %s for buffer %d with root: %s", name, vim.api.nvim_get_current_buf(),
+                root_dir or "none"))
+
+            vim.lsp.start({
+                name = name,
+                cmd = config.cmd,
+                root_dir = root_dir,
+                initialization_options = config.settings or {},
+                on_exit = function(code, signal)
+                    print(string.format("%s exited with code %d, signal %d", name, code, signal))
+                end,
+            })
+        end,
+    })
+end
+
+for server_name, config_path in pairs(servers) do
+    setup_server(server_name, config_path)
+end
+```
+
+Then in `lua/lsp/stan.lua` add the following:
+```lua
+return {
+    cmd = { "stan-language-server", "--stdio" },
+    filetypes = { "stan" },
+    root_markers = { ".git" },
+    settings = {
+        maxLineLength = 78,
+        includePaths = {},
+    },
+}
 ```
 
-## Configuration
+### Zed
+
+Install the [Stan extension](https://zed.dev/extensions/stan).
+
 ### Sublime Text 4
 
+Using [LSP for Sublime Text](https://lsp.sublimetext.io/),
+[download the latest release](https://github.com/tomatitito/stan-language-server/releases)
+and add the following to the settings file:
+
 ```json
 {
-    "clients": {
-        "stan-lsp": {
-            "enabled": true,
-            "command": ["/YOUR/PATH/TO/stan-language-server"], 
-            "selector": "source.stan | source.stanfunctions",
-            "initializationOptions": {}
-        }
-    }
+  "clients": {
+    "stan-lsp": {
+      "enabled": true,
+      "command": ["/YOUR/PATH/TO/stan-language-server", "--stdio"],
+      "selector": "source.stan | source.stanfunctions",
+      "initializationOptions": {},
+      "settings": {
+        "stan-language-server": { "includePaths": [], "maxLineLength": 78 }
+      }
+  }
 }
+
 ```
 
 ### Emacs (eglot)
 
-Assuming you are using stan-ts-mode:
+Assuming you are using [stan-ts-mode](https://github.com/WardBrian/stan-ts-mode),
+[download the latest release](https://github.com/tomatitito/stan-language-server/releases)
+and add the following to your `init.el`:
+
 ```elisp
+; elgot is built in to emacs 29+, but a similar config would work for lsp-mode
 (with-eval-after-load 'eglot
-    (add-to-list 'eglot-server-programs 
-        '(stan-ts-mode . ("/YOUR/PATH/TO/stan-language-server"))))
+    (add-to-list 'eglot-server-programs
+        '(stan-ts-mode . ("/YOUR/PATH/TO/stan-language-server" "--stdio"))))
+```
+
+
+## For developers
+
+To install dependencies:
+
+```bash
+bun install
+```
+
+Building a binary executable:
+
+```bash
+bun build:binary
+```
+
+To run unit tests:
+```bash
+bun test
+```
+
+To run end-to-end tests:
+```bash
+pip install pytest pytest-lsp
+bun build:binary && pytest tests/
 ```

package/dist/constants/index.d.ts

@@ -0,0 +1 @@
+export declare const SERVER_ID = "stan-language-server";

package/dist/handlers/compilation/compilation.d.ts

@@ -1,4 +1,10 @@
 import type { TextDocument } from "vscode-languageserver-textdocument";
-import type { TextDocuments, WorkspaceFolder, RemoteConsole } from "vscode-languageserver";
-import type { StancReturn } from "../../types/common";
-export declare function handleCompilation(document: TextDocument, documentManager: TextDocuments<TextDocument>, workspaceFolders: WorkspaceFolder[], logger: RemoteConsole): Promise<StancReturn>;
+import { type TextDocuments, type WorkspaceFolder, type RemoteConsole } from "vscode-languageserver";
+import type { FileSystemReader } from "../../types/common";
+import { type StancReturn } from "stanc3";
+export interface Settings {
+    maxLineLength: number;
+    includePaths: string[];
+}
+export declare const defaultSettings: Settings;
+export declare function handleCompilation(document: TextDocument, documentManager: TextDocuments<TextDocument>, workspaceFolders: WorkspaceFolder[], settings: Settings, logger: RemoteConsole, reader?: FileSystemReader): Promise<StancReturn>;

package/dist/handlers/compilation/includes.d.ts

@@ -1,4 +1,11 @@
 import { TextDocuments, WorkspaceFolder, type RemoteConsole } from "vscode-languageserver";
 import type { TextDocument } from "vscode-languageserver-textdocument";
-import { type Filename, type FileContent } from "../../stanc/includes";
-export declare function handleIncludes(document: TextDocument, documentManager: TextDocuments<TextDocument>, workspaceFolders: WorkspaceFolder[], logger: RemoteConsole): Promise<Record<Filename, FileContent>>;
+import type { FileSystemReader } from "../../types";
+export type Filename = string;
+export type FileContent = string;
+export type FilePathError = {
+    msg: string;
+};
+export declare function getFilenames(fileContent: string): Filename[];
+export declare function isFilePathError(value: unknown): value is FilePathError;
+export declare function handleIncludes(document: TextDocument, documentManager: TextDocuments<TextDocument>, workspaceFolders: WorkspaceFolder[], includePaths: string[], logger: RemoteConsole, reader?: FileSystemReader): Promise<Record<Filename, FileContent>>;

package/dist/handlers/diagnostics.d.ts

@@ -1,3 +1,5 @@
 import { Diagnostic, TextDocuments, WorkspaceFolder, type DocumentDiagnosticParams, type RemoteConsole } from "vscode-languageserver";
 import { TextDocument } from "vscode-languageserver-textdocument";
-export declare function handleDiagnostics(params: DocumentDiagnosticParams, documents: TextDocuments<TextDocument>, workspaceFolders: WorkspaceFolder[], logger: RemoteConsole): Promise<Diagnostic[]>;
+import type { FileSystemReader } from "../types";
+import { type Settings } from "./compilation/compilation";
+export declare function handleDiagnostics(params: DocumentDiagnosticParams, documents: TextDocuments<TextDocument>, workspaceFolders: WorkspaceFolder[], settings: Settings, logger: RemoteConsole, reader?: FileSystemReader): Promise<Diagnostic[]>;

package/dist/handlers/formatting.d.ts

@@ -1,4 +1,7 @@
 import type { DocumentFormattingParams, RemoteConsole, TextDocuments, TextEdit, WorkspaceFolder } from "vscode-languageserver";
 import type { TextDocument } from "vscode-languageserver-textdocument";
-export declare function handleFormatting(params: DocumentFormattingParams, documents: TextDocuments<TextDocument>, workspaceFolders: WorkspaceFolder[], logger: RemoteConsole): Promise<TextEdit[]>;
-export declare function getFormattingErrors(params: DocumentFormattingParams, documents: TextDocuments<TextDocument>, workspaceFolders: WorkspaceFolder[], logger: RemoteConsole): Promise<string[]>;
+import { type Settings } from "./compilation/compilation";
+import type { FileSystemReader } from "../types";
+export declare function handleFormatting(params: DocumentFormattingParams, documents: TextDocuments<TextDocument>, workspaceFolders: WorkspaceFolder[], settings: Settings, logger: RemoteConsole, reader?: FileSystemReader): Promise<TextEdit[] | {
+    errors: string[];
+}>;

package/dist/handlers/hover.d.ts

@@ -1,7 +1,5 @@
-import type { HoverParams, Hover, MarkupContent } from "vscode-languageserver";
+import type { HoverParams, Hover } from "vscode-languageserver";
 import type { TextDocument } from "vscode-languageserver-textdocument";
-type MarkupLookupMap = Map<string, MarkupContent>;
-type GetMarkupLookupMapFn = () => MarkupLookupMap;
-export declare const handleHover: (getMarkupLookupFn: GetMarkupLookupMapFn) => (document: TextDocument, params: HoverParams) => Promise<Hover | null>;
-declare const _default: (document: TextDocument, params: HoverParams) => Promise<Hover | null>;
-export default _default;
+export declare const manual_functions: string[];
+declare function handleHover(document: TextDocument, params: HoverParams): Promise<Hover | null>;
+export default handleHover;

package/dist/handlers/index.d.ts

@@ -1,4 +1,4 @@
 export { handleCompletion } from "./completion";
 export { handleDiagnostics } from "./diagnostics";
 export { default as handleHover } from "./hover";
-export { handleFormatting, getFormattingErrors } from "./formatting";
+export { handleFormatting } from "./formatting";

package/dist/language/diagnostics/provider.d.ts

@@ -1,3 +1,7 @@
-import { type StanDiagnostic } from "../../types/diagnostics";
-import type { StancReturn } from "../../types/common";
-export declare function provideDiagnostics(compilerResult: StancReturn): StanDiagnostic[];
+import type { StancReturn } from "stanc3";
+import type { Range } from "vscode-languageserver";
+export declare function provideDiagnostics(compilerResult: StancReturn): {
+    range: Range;
+    severity: string;
+    message: string;
+}[];

package/dist/server/index.d.ts

@@ -1,3 +1,4 @@
 import { type Connection } from "vscode-languageserver/node";
-declare const startLanguageServer: (connection: Connection) => void;
+import { type FileSystemReader } from "../types/common.ts";
+declare const startLanguageServer: (connection: Connection, reader?: FileSystemReader) => void;
 export default startLanguageServer;