stan-language-server 0.4.4 → 0.4.6

package/README.md

@@ -10,7 +10,6 @@ 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
 
-
 ## Editor-specific configuration
 
 ### VSCode:
@@ -21,7 +20,19 @@ or [open-vsx](https://open-vsx.org/extension/wardbrian/vscode-stan-extension).
 
 ### Neovim
 
-Download the latest language server executable from [GitHub](https://github.com/tomatitito/stan-language-server/releases) and put it somewhere in your `PATH`.
+#### Mason
+
+The Stan language server is installable with
+[Mason](https://github.com/mason-org/mason.nvim) by running `:MasonInstall
+stan-language-server`.
+
+#### Manual install
+
+The language server can also be configured manually by first installing
+the language server executable. This can be done directly via `npm install -g
+stan-language-server-bin` or by downloading the latest executable from
+[GitHub](https://github.com/tomatitito/stan-language-server/releases) and putting
+it somewhere in your `PATH`.
 
 #### Neovim 0.11+ (built-in LSP)
 
@@ -95,27 +106,74 @@ and add the following to the settings file:
 ### Emacs (eglot)
 
 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`:
+add the following to your `init.el`.
+This will download the latest release the first time you load a Stan file.
 
 ```elisp
-; elgot is built in to emacs 29+, but some features work better if you use the
-;; latest version from GNU ELPA
 (require 'package)
-(add-to-list 'package-archives '("gnu" . "https://elpa.gnu.org/packages/") t)
+;; elgot is built in to emacs 29+, but some features work better if you use the
+;; latest version from GNU ELPA
+(add-to-list 'package-archives '("gnu-devel" . "https://elpa.gnu.org/devel/"))
 (package-initialize)
 
+;; work around https://debbugs.gnu.org/cgi/bugreport.cgi?bug=69423
+(assq-delete-all 'eglot package--builtins)
+(assq-delete-all 'eglot package--builtin-versions)
+
+(defcustom bmw/stan-language-server-location
+  (expand-file-name (concat "bin/stan-language-server" (car exec-suffixes)) user-emacs-directory)
+  "Location to download the stan-language-server binary to."
+  :type 'file
+  :group 'stan)
+
+(use-package url)
+
+(defun bmw/download-stan-language-server (&optional force)
+  "Download the latest copy of the stan-language-server.
+The location is determined by stan-ts-mode-language-server-location.
+Argument FORCE will make the download proceed even if the file exists."
+  (interactive "P")
+  (when (or force (not (file-exists-p bmw/stan-language-server-location)))
+    (let*
+        ((version
+          (with-temp-buffer
+            (url-insert-file-contents
+             "https://api.github.com/repos/tomatitito/stan-language-server/releases/latest")
+            (let ((json  (json-parse-buffer)))
+              (gethash "tag_name" json))))
+         (os-tag
+          (pcase system-type
+            ((or 'windows-nt 'cygwin 'ms-dos) "windows-x86_64")
+            ('darwin (concat "macos-"
+                             (if (string-match-p "aarch64\\|arm" system-configuration ) "aarch64" "x86_64") ))
+            (_  (concat "linux-"
+                        (if (string-match-p "aarch64\\|arm" system-configuration ) "arm64" "x86_64")))))
+         (url
+          (concat
+           "https://github.com/tomatitito/stan-language-server/releases/download/"
+           version
+           "/stan-ls-"
+           version
+           "-"
+           os-tag
+           (car exec-suffixes)))
+         (file bmw/stan-language-server-location))
+      (make-empty-file file t)
+      (delete-file file)
+      (url-copy-file url file)
+      (chmod file 500))))
+
 (use-package eglot
   :ensure t
-  :demand t
-  :pin gnu
-  :hook (stan-ts-mode . eglot-ensure)
+  :pin gnu-devel
+  :hook ((stan-ts-base-mode . bmw/download-stan-language-server)
+         (stan-ts-base-mode . eglot-ensure))
   :config
-  (add-to-list 'eglot-server-programs '(stan-ts-mode .
-  ("PATH/TO/stan-language-server" "--stdio"))))
+  (add-to-list
+   'eglot-server-programs
+   `(stan-ts-base-mode . (,bmw/stan-language-server-location "--stdio"))))
 ```
 
-
 ## For developers
 
 Development uses [bun](https://bun.sh/)
@@ -133,12 +191,13 @@ bun build:binary
 ```
 
 To run unit tests:
+
 ```bash
 bun test
 ```
 
 To run end-to-end tests:
+
 ```bash
 bun test:e2e
 ```
-

package/dist/handlers/completion/constraints.d.ts

@@ -0,0 +1,2 @@
+import { CompletionItem } from "vscode-languageserver";
+export declare const CONSTRAINTS: CompletionItem[];

package/dist/handlers/completion/datatypes.d.ts

@@ -0,0 +1,2 @@
+import { CompletionItem } from "vscode-languageserver";
+export declare const DATATYPES: CompletionItem[];

package/dist/handlers/completion/distributions.d.ts

@@ -0,0 +1,2 @@
+import { CompletionItem } from "vscode-languageserver";
+export declare const DISTRIBUTIONS: CompletionItem[];

package/dist/handlers/completion/functions.d.ts

@@ -0,0 +1,2 @@
+import { CompletionItem } from "vscode-languageserver";
+export declare const FUNCTIONS: CompletionItem[];

package/dist/handlers/completion/keywords.d.ts

@@ -0,0 +1,2 @@
+import { CompletionItem } from "vscode-languageserver";
+export declare const KEYWORDS: CompletionItem[];

package/dist/handlers/completion/snippets.d.ts

@@ -0,0 +1,2 @@
+import { CompletionItem } from "vscode-languageserver";
+export declare const SNIPPETS: CompletionItem[];

package/dist/handlers/completion.d.ts

@@ -1,3 +1,4 @@
 import { type CompletionParams, TextDocuments, CompletionItem } from "vscode-languageserver";
-import { TextDocument } from "vscode-languageserver-textdocument";
-export declare function handleCompletion(params: CompletionParams, documents: TextDocuments<TextDocument>): CompletionItem[];
+import { TextDocument, type Position } from "vscode-languageserver-textdocument";
+export declare const getTextUpToCursor: (text: string, position: Position) => string;
+export declare function handleCompletion(params: CompletionParams, documents: TextDocuments<TextDocument>, supportsSnippets: boolean): CompletionItem[];

package/dist/language/hover/util.d.ts

@@ -1,4 +1,4 @@
 export declare const isWordChar: (char: string) => boolean;
-export declare const isWhitespace: (char: string) => char is " " | "\n" | "\t" | "\r";
+export declare const isWhitespace: (char: string) => char is "\n" | " " | "\t" | "\r";
 export declare const previousWordBoundary: (text: string, pos: number) => number;
 export declare const wordUntilNextParenthesis: (text: string, pos: number) => number;

package/dist/server/index.js

@@ -11,25 +11,61 @@ import {
 
 // src/handlers/completion.ts
 import {
-  CompletionItemKind
+  CompletionItemKind as CompletionItemKind7
 } from "vscode-languageserver";
-
-// src/language/completion/util.ts
 import TrieSearch from "trie-search";
-var getSearchableItems = (xs, options = {}) => {
-  const searchableItem = new TrieSearch("name", options);
-  searchableItem.addAll(xs);
-  return searchableItem;
-};
-var getTextUpToCursor = (text, position) => {
-  const lines = text.split(`
-`);
-  const currentLine = lines[position.line] || "";
-  return currentLine.substring(0, position.character);
-};
 
-// src/language/completion/providers/keywords.ts
-var ALL_KEYWORDS = [
+// src/handlers/completion/constraints.ts
+import { CompletionItemKind } from "vscode-languageserver";
+function constraintToCompletionItem(constraint) {
+  return {
+    label: constraint,
+    kind: CompletionItemKind.Property
+  };
+}
+var CONSTRAINTS = ["lower", "upper", "offset", "multiplier"].map(constraintToCompletionItem);
+
+// src/handlers/completion/datatypes.ts
+import { CompletionItemKind as CompletionItemKind2 } from "vscode-languageserver";
+function datatypeToCompletionItem(datatype) {
+  return {
+    label: datatype,
+    kind: CompletionItemKind2.Class
+  };
+}
+var DATATYPES = [
+  "void",
+  "int",
+  "real",
+  "complex",
+  "vector",
+  "row_vector",
+  "matrix",
+  "complex_vector",
+  "complex_row_vector",
+  "complex_matrix",
+  "ordered",
+  "positive_ordered",
+  "simplex",
+  "unit_vector",
+  "sum_to_zero_vector",
+  "cholesky_factor_corr",
+  "cholesky_factor_cov",
+  "corr_matrix",
+  "cov_matrix",
+  "stochastic_column_matrix",
+  "stochastic_row_matrix"
+].map(datatypeToCompletionItem);
+
+// src/handlers/completion/keywords.ts
+import { CompletionItemKind as CompletionItemKind3 } from "vscode-languageserver";
+function keywordToCompletionItem(keyword) {
+  return {
+    label: keyword,
+    kind: CompletionItemKind3.Keyword
+  };
+}
+var KEYWORDS = [
   "for",
   "in",
   "while",
@@ -71,94 +107,158 @@ var ALL_KEYWORDS = [
   "tuple",
   "truncate",
   "jacobian"
-];
-var getKeywords = () => {
-  return ALL_KEYWORDS.map((keyword) => ({
-    name: keyword
-  }));
-};
-var provideKeywordCompletions = (text, position) => {
-  const textUpToCursor = getTextUpToCursor(text, position);
-  const keywords = getKeywords();
-  const searchableKeywords = getSearchableItems(keywords, {
-    splitOnRegEx: /[\s_]/g,
-    min: 0
-  });
-  const match = textUpToCursor.match(/(?:^|\s)([\w_]+)$/);
-  if (match) {
-    const keywordName = match[1] || "";
-    const completionProposals = searchableKeywords.search(keywordName);
-    return completionProposals;
-  }
-  return [];
-};
+].map(keywordToCompletionItem);
 
-// src/language/completion/providers/distributions.ts
-var provideDistributionCompletions = (text, position, distributions) => {
-  const textUpToCursor = getTextUpToCursor(text, position);
-  const distributionItems = distributions.filter((name) => name !== "").map((name) => ({ name }));
-  const searchableDistributions = getSearchableItems(distributionItems, {
-    splitOnRegEx: /[\s_]/g,
-    min: 0
-  });
-  const match = textUpToCursor.match(/.*~\s*([\w_]*)$/);
-  if (match) {
-    const distName = match[1] || "";
-    let completionProposals;
-    if (distName === "") {
-      completionProposals = distributionItems;
-    } else {
-      completionProposals = searchableDistributions.search(distName);
-    }
-    return completionProposals;
+// src/handlers/completion/snippets.ts
+import {
+  CompletionItemKind as CompletionItemKind4,
+  InsertTextFormat,
+  InsertTextMode
+} from "vscode-languageserver";
+function snippetToCompletionItem(snippet) {
+  return {
+    label: snippet.name,
+    kind: CompletionItemKind4.Snippet,
+    insertText: snippet.body.join(`
+`),
+    insertTextFormat: InsertTextFormat.Snippet,
+    insertTextMode: InsertTextMode.adjustIndentation,
+    detail: snippet.description
+  };
+}
+var SNIPPETS = [
+  {
+    name: "else",
+    body: ["else {", "   ${0:/* code */}", "}"],
+    description: "Code snippet for 'else' conditional"
+  },
+  {
+    name: "elseif",
+    body: ["else if (${1:/* condition */}) {", "   ${0:/* code */}", "}"],
+    description: "Code snippet for 'else if' conditional"
+  },
+  {
+    name: "for",
+    body: [
+      "for (${1:identifier} in ${2:collection}) {",
+      "   ${0:/* code */}",
+      "}"
+    ],
+    description: "Code snippet for 'for' loop"
+  },
+  {
+    name: "if",
+    body: ["if (${1:/* condition */}) {", "   ${0:/* code */}", "}"],
+    description: "Code snippet for 'if' conditional"
+  },
+  {
+    name: "ifelse",
+    body: [
+      "if (${1:/* condition */}) {",
+      "   ${2:/* code */}",
+      "} else {",
+      "   ${0:/* code */}",
+      "}"
+    ],
+    description: "Code snippet for 'if-else' conditional block"
+  },
+  {
+    name: "while",
+    body: ["while (${1:/* condition */}) {", "   ${0:/* code */}", "}"],
+    description: "Code snippet for 'while' loop"
+  },
+  {
+    name: "profile",
+    body: ['profile("${1:name}") {', "   ${0:/* code to be profiled */}", "}"],
+    description: "Code snippet for 'profile' block"
+  },
+  {
+    name: "data",
+    body: ["data {", "   ${0:/* ... declarations ... */}", "}"],
+    description: "Code snippet for 'data' block"
+  },
+  {
+    name: "transformed data",
+    body: [
+      "transformed data {",
+      "   ${0:/* ... declarations ... statements ... */}",
+      "}"
+    ],
+    description: "Code snippet for 'transformed data' block"
+  },
+  {
+    name: "parameters",
+    body: ["parameters {", "   ${0:/* ... declarations ... */}", "}"],
+    description: "Code snippet for 'parameters' block"
+  },
+  {
+    name: "transformed parameters",
+    body: [
+      "transformed parameters {",
+      "   ${0:/* ... declarations ... statements ... */}",
+      "}"
+    ],
+    description: "Code snippet for 'transformed parameters' block"
+  },
+  {
+    name: "model",
+    body: ["model {", "   ${0:/* ... declarations ... statements ... */}", "}"],
+    description: "Code snippet for 'model' block"
+  },
+  {
+    name: "generated quantities",
+    body: [
+      "generated quantities {",
+      "   ${0:/* ... declarations ... statements ... */}",
+      "}"
+    ],
+    description: "Code snippet for 'generated quantities' block"
+  },
+  {
+    name: "functions",
+    body: [
+      "functions {",
+      "   ${0:/* ... function declarations and definitions ... */}",
+      "}"
+    ],
+    description: "Code snippet for 'functions' block"
+  },
+  {
+    name: "include",
+    body: ['#include "${1:filename}"'],
+    description: "Code snippet for 'include' preprocessor"
+  },
+  {
+    name: "target",
+    body: ["target += ${1};"],
+    description: "Code snippet for 'target +=' statement"
+  },
+  {
+    name: "jacobian",
+    body: ["jacobian += ${1};"],
+    description: "Code snippet for 'jacobian +=' statement"
   }
-  return [];
-};
+].map(snippetToCompletionItem);
 
-// src/language/completion/providers/datatypes.ts
-var DATATYPES = [
-  "void",
-  "int",
-  "real",
-  "complex",
-  "vector",
-  "row_vector",
-  "matrix",
-  "complex_vector",
-  "complex_row_vector",
-  "complex_matrix",
-  "ordered",
-  "positive_ordered",
-  "simplex",
-  "unit_vector",
-  "sum_to_zero_vector",
-  "cholesky_factor_corr",
-  "cholesky_factor_cov",
-  "corr_matrix",
-  "cov_matrix",
-  "stochastic_column_matrix",
-  "stochastic_row_matrix"
-];
-var getDatatypes = () => {
-  return DATATYPES.map((datatype) => ({
-    name: datatype
-  }));
-};
-var provideDatatypeCompletions = (text, position) => {
-  const textUpToCursor = getTextUpToCursor(text, position);
-  const datatypes = getDatatypes();
-  const searchableDatatypes = getSearchableItems(datatypes, {
-    splitOnRegEx: /[\s_]/g,
-    min: 0
-  });
-  const match = textUpToCursor.match(/(?:^|\s)([\w_]+)$/);
-  if (match) {
-    const typeName = match[1] || "";
-    const completionProposals = searchableDatatypes.search(typeName);
-    return completionProposals;
-  }
-  return [];
+// src/handlers/completion/distributions.ts
+import { CompletionItemKind as CompletionItemKind5 } from "vscode-languageserver";
+import { dump_stan_math_distributions } from "stanc3";
+function distributionToCompletionItem(distribution) {
+  return {
+    label: distribution,
+    kind: CompletionItemKind5.Function
+  };
+}
+var getDistributions = () => {
+  const distributions = dump_stan_math_distributions().split(`
+`).map((line) => line.split(":")[0]?.trim() ?? "").filter((name) => name !== "");
+  return distributions.map(distributionToCompletionItem);
 };
+var DISTRIBUTIONS = getDistributions();
+
+// src/handlers/completion/functions.ts
+import { CompletionItemKind as CompletionItemKind6 } from "vscode-languageserver";
+import { dump_stan_math_signatures as dump_stan_math_signatures2 } from "stanc3";
 
 // src/handlers/hover.ts
 import { dump_stan_math_signatures } from "stanc3";
@@ -202,10 +302,10 @@ var wordUntilNextParenthesis = (text, pos) => {
 };
 
 // src/language/hover/distributions.ts
-import { dump_stan_math_distributions } from "stanc3";
+import { dump_stan_math_distributions as dump_stan_math_distributions2 } from "stanc3";
 var setupDistributionMap = () => {
   const distributionToFunctionMap = new Map;
-  const mathDistributions = dump_stan_math_distributions();
+  const mathDistributions = dump_stan_math_distributions2();
   const distLines = mathDistributions.split(`
 `);
   for (const line of distLines) {
@@ -358,123 +458,81 @@ async function handleHover(document, params) {
 }
 var hover_default = handleHover;
 
-// src/language/completion/providers/functions.ts
-var provideFunctionCompletions = (text, position, functionSignatures) => {
-  const textUpToCursor = getTextUpToCursor(text, position);
-  const functionNames = functionSignatures.map((line) => line.split("(", 1)[0]?.trim() ?? "").filter((name) => name !== "");
-  const allFunctionNames = [...new Set([...functionNames, ...manual_functions])];
-  const functionItems = allFunctionNames.map((name) => ({ name }));
-  const searchableFunctions = getSearchableItems(functionItems, {
-    splitOnRegEx: /[\s_]/g,
-    min: 0
-  });
+// src/handlers/completion/functions.ts
+function functionToCompletionItem(func) {
+  return {
+    label: func,
+    kind: CompletionItemKind6.Function
+  };
+}
+var getFunctions = () => {
+  const functions = dump_stan_math_signatures2().split(`
+`);
+  const functionNames = functions.map((line) => line.split("(", 1)[0]?.trim() ?? "").filter((name) => name !== "");
+  const uniqueFunctions = [...new Set([...functionNames, ...manual_functions])];
+  return uniqueFunctions.map(functionToCompletionItem);
+};
+var FUNCTIONS = getFunctions();
+
+// src/handlers/completion.ts
+var COMPLETION_TRIE = new TrieSearch("label", {
+  splitOnRegEx: /[\s_]/g,
+  min: 0
+});
+COMPLETION_TRIE.addAll([
+  ...CONSTRAINTS,
+  ...DATATYPES,
+  ...KEYWORDS,
+  ...FUNCTIONS,
+  ...SNIPPETS
+]);
+var searchWords = (textUpToCursor, supportsSnippets) => {
   const match = textUpToCursor.match(/(?:^|\s)([\w_]+)$/);
   if (match) {
-    const functionName = match[1] || "";
-    const completionProposals = searchableFunctions.search(functionName);
+    const word = match[1] || "";
+    const completionProposals = COMPLETION_TRIE.search(word);
+    if (!supportsSnippets) {
+      return completionProposals.filter((item) => item.kind !== CompletionItemKind7.Snippet);
+    }
     return completionProposals;
   }
   return [];
 };
-
-// src/language/completion/providers/constraints.ts
-var CONSTRAINTS = [
-  "lower",
-  "upper",
-  "offset",
-  "multiplier",
-  "ordered",
-  "positive_ordered",
-  "simplex",
-  "unit_vector",
-  "sum_to_zero_vector",
-  "cholesky_factor_corr",
-  "cholesky_factor_cov",
-  "corr_matrix",
-  "cov_matrix",
-  "stochastic_column_matrix",
-  "stochastic_row_matrix"
-];
-var getConstraints = () => {
-  return CONSTRAINTS.map((constraint) => ({
-    name: constraint
-  }));
-};
-var provideConstraintCompletions = (text, position) => {
-  const textUpToCursor = getTextUpToCursor(text, position);
-  const constraints = getConstraints();
-  const searchableConstraints = getSearchableItems(constraints, {
-    splitOnRegEx: /[\s_]/g,
-    min: 0
-  });
-  const match = textUpToCursor.match(/(?:^|\s)([\w_]+)$/);
+var DISTRIBUTION_TRIE = new TrieSearch("label", {
+  splitOnRegEx: /[\s_]/g,
+  min: 0
+});
+DISTRIBUTION_TRIE.addAll(DISTRIBUTIONS);
+var searchDistributions = (textUpToCursor) => {
+  const match = textUpToCursor.match(/.*~\s*([\w_]*)$/);
   if (match) {
-    const constraintName = match[1] || "";
-    const completionProposals = searchableConstraints.search(constraintName);
+    const distName = match[1] || "";
+    let completionProposals;
+    if (distName === "") {
+      completionProposals = DISTRIBUTIONS;
+    } else {
+      completionProposals = DISTRIBUTION_TRIE.search(distName);
+    }
     return completionProposals;
   }
   return [];
 };
-
-// src/handlers/completion.ts
-import {
-  dump_stan_math_distributions as dump_stan_math_distributions2,
-  dump_stan_math_signatures as dump_stan_math_signatures2
-} from "stanc3";
-function keywordToCompletionItem(keyword) {
-  return {
-    label: keyword.name,
-    kind: CompletionItemKind.Keyword
-  };
-}
-function distributionToCompletionItem(distribution) {
-  return {
-    label: distribution.name,
-    kind: CompletionItemKind.Function
-  };
-}
-function datatypeToCompletionItem(datatype) {
-  return {
-    label: datatype.name,
-    kind: CompletionItemKind.Class
-  };
-}
-function functionToCompletionItem(func) {
-  return {
-    label: func.name,
-    kind: CompletionItemKind.Function
-  };
-}
-function constraintToCompletionItem(constraint) {
-  return {
-    label: constraint.name,
-    kind: CompletionItemKind.Property
-  };
-}
-var DISTRIBUTION_DATA = dump_stan_math_distributions2().split(`
-`).map((line) => line.split(":")[0]?.trim() ?? "").filter((name) => name !== "");
-var FUNCTION_DATA = dump_stan_math_signatures2().split(`
+var getTextUpToCursor = (text, position) => {
+  const lines = text.split(`
 `);
-function handleCompletion(params, documents) {
+  const currentLine = lines[position.line] || "";
+  return currentLine.substring(0, position.character);
+};
+function handleCompletion(params, documents, supportsSnippets) {
   const document = documents.get(params.textDocument.uri);
   if (!document) {
     return [];
   }
-  const text = document.getText();
-  const position = params.position;
-  const keywords = provideKeywordCompletions(text, position);
-  const distributions = provideDistributionCompletions(text, position, DISTRIBUTION_DATA);
-  const datatypes = provideDatatypeCompletions(text, position);
-  const functions = provideFunctionCompletions(text, position, FUNCTION_DATA);
-  const constraints = provideConstraintCompletions(text, position);
-  const allItems = [
-    ...keywords.map(keywordToCompletionItem),
-    ...distributions.map(distributionToCompletionItem),
-    ...datatypes.map(datatypeToCompletionItem),
-    ...functions.map(functionToCompletionItem),
-    ...constraints.map(constraintToCompletionItem)
+  const textUpToCursor = getTextUpToCursor(document.getText(), params.position);
+  return [
+    ...searchDistributions(textUpToCursor),
+    ...searchWords(textUpToCursor, supportsSnippets)
   ];
-  return allItems;
 }
 // src/handlers/diagnostics.ts
 import {
@@ -640,7 +698,7 @@ var readIncludedFileFromFileSystem = async (filename, dirs, fileSystemReader) =>
       const localPath = join(currentDir, filename);
       const content = await fileSystemReader(localPath);
       return TextDocument.create(URI.file(localPath).toString(), "stan", 0, content);
-    } catch (error) {}
+    } catch (_error) {}
   }
   return Promise.resolve({ msg: `File not found: ${filename}` });
 };
@@ -726,12 +784,14 @@ var startLanguageServer = (connection, reader) => {
   let hasConfigurationCapability = false;
   let hasWorkspaceFolderCapability = false;
   let hasDynamicConfigurationRequestCapability = false;
+  let hasSnippetSupport = false;
   connection.onInitialize((params) => {
     connection.console.info("Initializing Stan language server...");
-    let capabilities = params.capabilities;
+    const capabilities = params.capabilities;
     hasConfigurationCapability = Boolean(capabilities.workspace?.configuration);
     hasDynamicConfigurationRequestCapability = Boolean(capabilities.workspace?.configuration && capabilities.workspace?.didChangeConfiguration?.dynamicRegistration);
     hasWorkspaceFolderCapability = Boolean(capabilities.workspace?.workspaceFolders);
+    hasSnippetSupport = Boolean(capabilities.textDocument?.completion?.completionItem?.snippetSupport);
     return {
       capabilities: {
         textDocumentSync: TextDocumentSyncKind.Incremental,
@@ -765,7 +825,7 @@ var startLanguageServer = (connection, reader) => {
     connection.console.info("Stan language server is exiting...");
   });
   let globalSettings = defaultSettings;
-  let documentSettings = new Map;
+  const documentSettings = new Map;
   connection.onDidChangeConfiguration((change) => {
     if (hasDynamicConfigurationRequestCapability) {
       documentSettings.clear();
@@ -779,11 +839,11 @@ var startLanguageServer = (connection, reader) => {
     if (!hasConfigurationCapability) {
       return Promise.resolve(globalSettings);
     }
-    let result = documentSettings.get(resource);
+    const result = documentSettings.get(resource);
     if (result !== undefined) {
       return result;
     }
-    let clientSettings = await connection.workspace.getConfiguration({
+    const clientSettings = await connection.workspace.getConfiguration({
       scopeUri: resource,
       section: SERVER_ID
     }) || {};
@@ -793,7 +853,7 @@ var startLanguageServer = (connection, reader) => {
   };
   const documents = new TextDocuments3(TextDocument2);
   connection.onCompletion((params) => {
-    return handleCompletion(params, documents);
+    return handleCompletion(params, documents, hasSnippetSupport);
   });
   const getWorkspaceFolders = async () => {
     if (hasWorkspaceFolderCapability) {

package/dist/types/common.d.ts

@@ -1,6 +1,2 @@
 import type { FileContent, Filename } from "../handlers/compilation/includes";
-export interface Position {
-    line: number;
-    character: number;
-}
 export type FileSystemReader = (filename: Filename) => Promise<FileContent>;

package/dist/types/index.d.ts

@@ -1,2 +1 @@
-export * from './common';
-export * from './completion';
+export * from "./common";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stan-language-server",
-  "version": "0.4.4",
+  "version": "0.4.6",
   "description": "Language Server Protocol implementation for the Stan probabilistic programming language",
   "main": "dist/server/index.js",
   "module": "src/server/index.ts",
@@ -47,7 +47,7 @@
   },
   "scripts": {
     "build": "bun build src/server/index.ts --outdir dist/server --packages external --target browser --format esm && tsc --emitDeclarationOnly --outDir dist",
-    "build:binary": "bun build src/server/cli.ts --drop=console --compile --outfile bin/stan-language-server",
+    "build:binary": "bun build src/server/cli.ts --compile --outfile bin/stan-language-server",
     "build:bin-package": "bun run scripts/build-bin-package.ts",
     "prepublishOnly": "bun run build",
     "version:set": "bun run scripts/set-version.ts",
@@ -72,6 +72,9 @@
     "@typescript-eslint/eslint-plugin": "8.57.1",
     "@typescript-eslint/parser": "8.57.1",
     "eslint": "10.0.3",
+    "globals": "^17.3.0",
+    "@eslint/js": "^10.0.1",
+    "typescript-eslint": "^8.57.0",
     "typescript": "5.9.3"
   },
   "dependencies": {

package/dist/__tests__/language/completion/providers/datatypes.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/__tests__/language/completion/providers/distributions.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/__tests__/language/completion/providers/functions.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/__tests__/language/completion/providers/keywords.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/__tests__/language/completion/util.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/language/completion/providers/constraints.d.ts

@@ -1,3 +0,0 @@
-import type { Constraint, Position } from "../../../types/completion";
-export declare const CONSTRAINTS: string[];
-export declare const provideConstraintCompletions: (text: string, position: Position) => Constraint[];

package/dist/language/completion/providers/datatypes.d.ts

@@ -1,3 +0,0 @@
-import type { Datatype, Position } from "../../../types/completion";
-export declare const DATATYPES: string[];
-export declare const provideDatatypeCompletions: (text: string, position: Position) => Datatype[];

package/dist/language/completion/providers/distributions.d.ts

@@ -1,2 +0,0 @@
-import type { Distribution, Position } from "../../../types/completion";
-export declare const provideDistributionCompletions: (text: string, position: Position, distributions: string[]) => Distribution[];

package/dist/language/completion/providers/functions.d.ts

@@ -1,2 +0,0 @@
-import type { StanFunction, Position } from "../../../types/completion";
-export declare const provideFunctionCompletions: (text: string, position: Position, functionSignatures: string[]) => StanFunction[];

package/dist/language/completion/providers/keywords.d.ts

@@ -1,2 +0,0 @@
-import type { Keyword, Position } from "../../../types/completion";
-export declare const provideKeywordCompletions: (text: string, position: Position) => Keyword[];

package/dist/language/completion/util.d.ts

@@ -1,4 +0,0 @@
-import TrieSearch, { type TrieSearchOptions } from "trie-search";
-import type { Searchable, Position } from "../../types/completion";
-export declare const getSearchableItems: <T extends Searchable>(xs: T[], options?: TrieSearchOptions<T>) => TrieSearch<T>;
-export declare const getTextUpToCursor: (text: string, position: Position) => string;

package/dist/types/completion.d.ts

@@ -1,15 +0,0 @@
-import type { Position } from "./common";
-export type { Position };
-export interface Searchable {
-    name: string;
-}
-export interface Distribution extends Searchable {
-}
-export interface StanFunction extends Searchable {
-}
-export interface Keyword extends Searchable {
-}
-export interface Datatype extends Searchable {
-}
-export interface Constraint extends Searchable {
-}