@dot-agent/language-server 0.4.1 → 0.5.0-alpha.2

package/AGENTS.md

@@ -10,17 +10,19 @@ A standalone [Language Server Protocol](https://microsoft.github.io/language-ser
 
 All structural analysis is performed on **tree-sitter ASTs** (not regex). `parser.js` owns the WASM parser lifecycle, document cache, and the helper functions that feature modules use to traverse parse trees.
 
+The package is **ESM** (`"type": "module"` in `package.json`). All files use `import`/`export` — no `require()` or `module.exports`.
+
 ---
 
 ## Module responsibilities
 
 | File | Responsibility |
 |------|---------------|
-| `server.js` | LSP wiring — creates the connection, awaits `initParsers()` in `onInitialize`, registers all `connection.onXxx()` handlers, delegates to `features/` |
+| `server.js` | LSP wiring — creates the connection, awaits `initParsers()` and `bpInit()` in `onInitialize`, registers all `connection.onXxx()` handlers, delegates to `features/` |
 | `parser.js` | Tree-sitter engine — WASM initialization, per-document AST cache, and shared traversal helpers |
 | `features/hover.js` | Hover documentation for all DSL keywords (static lookup, no tree traversal) |
 | `features/completions.js` | Context-aware completions using `getContextNode` and `nodesOfType` for name lookups |
-| `features/diagnostics.js` | Linting — dangling transitions, dead-end interact (AST), undeclared types (AST) |
+| `features/diagnostics.js` | Thin adapter — delegates to `lintDescription`/`lintBehavior` from `@dot-agent/compiler`, maps `LintMessage[]` → LSP `Diagnostic[]` |
 | `features/definition.js` | Go-to-definition via `state_decl` / `type_decl` node lookup |
 | `features/references.js` | Find all references via `transition_stmt`, `intent_trigger`, `type_ref` traversal |
 | `features/rename.js` | Rename symbol — same traversal as references, produces `TextEdit[]` |
@@ -96,26 +98,43 @@ Add shared helpers here — never duplicate tree traversal logic across feature
 Production dependencies:
 - `vscode-languageserver` and `vscode-languageserver-textdocument` — LSP protocol implementation
 - `web-tree-sitter` — WASM-based tree-sitter runtime
-- `@dot-agent/tree-sitter` — Agent and Flow grammar WASM binaries
+- `@dot-agent/tree-sitter` — Agent and Behavior grammar WASM binaries
+- `@dot-agent/compiler` — Linting (`lintDescription`, `lintBehavior`). Do not reimplement lint rules locally; always delegate to the compiler.
+- `@dot-agent/behavior-parser` — FSM WASM; used directly in `server.js` for `agent/behaviorGraph` (returns SCXML string via `get_graph(text)`).
 
-Do not add framework dependencies, bundlers, or anything that requires a build step on the language-server side. The server must start with a bare `node server.js --stdio` once the WASM binaries are in `@dot-agent/tree-sitter/dist/`.
+Do not add framework dependencies, bundlers, or anything that requires a build step on the language-server side. The server must start with a bare `node server.js --stdio`.
 
-The grammar WASM binaries are built by running `npm run build` in the `tree-sitter-agent` package (requires Emscripten). When published to npm, `dist/` is included in the package and no build is needed.
+The grammar WASM binaries are built by running `npm run build` in the `tree-sitter-agent` package (requires Emscripten). When published to npm, `dist/` is included in the package and no build is needed. The compiler must be built (`npm run build` in `packages/compiler/`) before the language-server can use it in the monorepo.
 
 ---
 
 ## Async lifecycle rule
 
-`web-tree-sitter` initializes asynchronously. The `onInitialize` handler is the only safe place to call `await initParsers()`:
+`web-tree-sitter` and `@dot-agent/behavior-parser` initialize asynchronously. The `onInitialize` handler is the only safe place to call both:
 
 ```js
 connection.onInitialize(async () => {
-    await initParsers();   // blocks until both WASMs are loaded
+    await initParsers();   // tree-sitter WASMs (agent + behavior grammars)
+    await bpInit();        // behavior-parser WASM (FSM parser + get_graph)
     return { capabilities: { ... } };
 });
 ```
 
-No feature handler will fire before `initialize` completes, so this guarantees parsers are ready before any `onHover`, `onCompletion`, etc. request arrives. Never call `initParsers()` outside `onInitialize`.
+No feature handler will fire before `initialize` completes, so this guarantees all WASMs are ready before any request arrives. Never call these outside `onInitialize`.
+
+---
+
+## `agent/behaviorGraph` custom request
+
+Returns a **SCXML string** (W3C State Chart XML) generated by the behavior-parser WASM from the document text. The VS Code extension consumes this to render a state diagram.
+
+```js
+connection.onRequest('agent/behaviorGraph', ({ uri }) => {
+    const doc = documents.get(uri)
+    if (!doc || doc.languageId !== 'behavior') return null
+    return get_graph(doc.getText())  // → SCXML string
+})
+```
 
 ---
 

package/features/completions.js

@@ -14,10 +14,8 @@
  * limitations under the License.
  */
 
-'use strict';
-
-const { CompletionItemKind } = require('vscode-languageserver');
-const { nodesOfType, positionToOffset, getContextNode } = require('../parser');
+import { CompletionItemKind } from 'vscode-languageserver';
+import { nodesOfType, positionToOffset, getContextNode } from '../parser.js';
 
 const BEHAVIOR_TOP_KW   = ['state', 'merge', 'on event', 'on intent', 'on offtopic'];
 const BEHAVIOR_BLOCK_KW = ['guide', 'teach', 'goal', 'interact', 'run', 'transition', 'set', 'if', 'else', 'end', 'after', 'parallel', 'apply', 'remove', 'on intent', 'on offtopic', 'on failure', 'on success'];
@@ -38,7 +36,7 @@ function nearestAncestor(node, types) {
     return null;
 }
 
-function provideCompletions(langId, tree, text, position) {
+export function provideCompletions(langId, tree, text, position) {
     const lines = text.split('\n');
     const line = lines[position.line] || '';
     const before = line.slice(0, position.character);
@@ -108,5 +106,3 @@ function provideCompletions(langId, tree, text, position) {
 
     return [];
 }
-
-module.exports = { provideCompletions };

package/features/definition.js

@@ -14,12 +14,10 @@
  * limitations under the License.
  */
 
-'use strict';
-
-const fs = require('fs');
-const { fileURLToPath, pathToFileURL } = require('url');
-const path = require('path');
-const { nodesOfType, nodeToRange, wordAtPosition, parseText } = require('../parser');
+import { readFileSync } from 'fs';
+import { fileURLToPath, pathToFileURL } from 'url';
+import { resolve, dirname } from 'path';
+import { nodesOfType, nodeToRange, wordAtPosition, parseText } from '../parser.js';
 
 // Busca recursiva de state_decl em arquivos mergeados.
 // visited (Set<absPath>) evita loops em grafos de merge circulares.
@@ -28,23 +26,23 @@ function findStateInMerges(tree, docDir, word, visited = new Set()) {
         const pathNode = mergeNode.childForFieldName('path');
         if (!pathNode) continue;
         const filename = pathNode.text.replace(/^"|"$/g, '');
-        const absPath = path.resolve(docDir, filename);
+        const absPath = resolve(docDir, filename);
         if (visited.has(absPath)) continue;
         visited.add(absPath);
         let mergedText;
-        try { mergedText = fs.readFileSync(absPath, 'utf8'); } catch { continue; }
+        try { mergedText = readFileSync(absPath, 'utf8'); } catch { continue; }
         const mergedTree = parseText('behavior', mergedText);
         if (!mergedTree) continue;
         const found = nodesOfType(mergedTree, 'state_decl')
             .find(n => n.childForFieldName('name')?.text === word);
         if (found) return { uri: pathToFileURL(absPath).toString(), range: nodeToRange(found) };
-        const sub = findStateInMerges(mergedTree, path.dirname(absPath), word, visited);
+        const sub = findStateInMerges(mergedTree, dirname(absPath), word, visited);
         if (sub) return sub;
     }
     return null;
 }
 
-function provideDefinition(langId, tree, text, uri, position) {
+export function provideDefinition(langId, tree, text, uri, position) {
     if (!tree) return null;
 
     const { word } = wordAtPosition(text, position.line, position.character);
@@ -55,7 +53,7 @@ function provideDefinition(langId, tree, text, uri, position) {
             .find(n => n.childForFieldName('name')?.text === word);
         if (local) return { uri, range: nodeToRange(local) };
         try {
-            const docDir = path.dirname(fileURLToPath(uri));
+            const docDir = dirname(fileURLToPath(uri));
             return findStateInMerges(tree, docDir, word) ?? null;
         } catch { return null; }
     }
@@ -70,5 +68,3 @@ function provideDefinition(langId, tree, text, uri, position) {
 
     return null;
 }
-
-module.exports = { provideDefinition };

package/features/diagnostics.js

@@ -14,199 +14,103 @@
  * limitations under the License.
  */
 
-'use strict';
-
-const fs = require('fs');
-const { fileURLToPath } = require('url');
-const path = require('path');
-const { DiagnosticSeverity } = require('vscode-languageserver');
-const { nodesOfType, nodeToRange, parseText } = require('../parser');
-
-const STRICT_BLOCK_TYPES = {
-    input_block:        'input',
-    output_block:       'output',
-    requires_block:     'requires',
-    capabilities_block: 'capabilities',
-};
-
-function diagnoseDescription(tree, text) {
-    const diagnostics = [];
-
-    // ── Strict block validation ───────────────────────────────────────────────
-    const declaredTypes = new Set(
-        nodesOfType(tree, 'type_decl')
-            .map(n => n.childForFieldName('name')?.text)
-            .filter(Boolean)
-    );
-
-    for (const [blockType, blockName] of Object.entries(STRICT_BLOCK_TYPES)) {
-        for (const blockNode of nodesOfType(tree, blockType)) {
-            // Syntax errors inside the block
-            for (const errorNode of blockNode.descendantsOfType('ERROR')) {
-                diagnostics.push({
-                    range: nodeToRange(errorNode),
-                    message: `Syntax error in '${blockName}' block. Expected: Type or Type "Description", or compact: Type1, Type2.`,
-                    severity: DiagnosticSeverity.Error,
-                    source: 'description-dsl',
-                });
-            }
-
-            // Undeclared type references (semantic warning)
-            if (declaredTypes.size > 0) {
-                for (const typeRefNode of blockNode.descendantsOfType('type_ref')) {
-                    const idNode = typeRefNode.firstNamedChild;
-                    if (!idNode) continue;
-                    const typeName = idNode.text;
-                    if (!declaredTypes.has(typeName)) {
-                        diagnostics.push({
-                            range: nodeToRange(idNode),
-                            message: `Type '${typeName}' is not declared in this file (assuming native or external).`,
-                            severity: DiagnosticSeverity.Warning,
-                            source: 'description-dsl',
-                        });
-                    }
-                }
-            }
-        }
-    }
-
-    return diagnostics;
+import { lintBehavior, lintDescription, consolidate, parseBehaviorFile } from '@dot-agent/compiler';
+import { DiagnosticSeverity } from 'vscode-languageserver';
+import { fileURLToPath } from 'url';
+import { dirname, relative } from 'node:path';
+import { findMergeRoot, findAgentRoot } from '../merge-graph.js';
+
+function toDiagnostic(msg) {
+    const severity =
+        msg.severity === 'error'   ? DiagnosticSeverity.Error :
+        msg.severity === 'warning' ? DiagnosticSeverity.Warning :
+        msg.severity === 'info'    ? DiagnosticSeverity.Information :
+                                     DiagnosticSeverity.Hint;
+    const text = msg.hint
+        ? `[${msg.code}] ${msg.message} (${msg.hint})`
+        : `[${msg.code}] ${msg.message}`;
+    return {
+        range: {
+            start: { line: msg.line - 1, character: msg.col - 1 },
+            end:   { line: msg.line - 1, character: msg.col - 1 },
+        },
+        message: text,
+        severity,
+        source: 'dot-agent',
+    };
 }
 
-// Coleta recursivamente todos os state names declarados nos arquivos mergeados.
-// visited (Set<absPath>) evita loops em grafos de merge circulares.
-function collectMergedStates(tree, docDir, definedStates, visited = new Set()) {
-    for (const mergeNode of nodesOfType(tree, 'merge_decl')) {
-        const pathNode = mergeNode.childForFieldName('path');
-        if (!pathNode) continue;
-        const filename = pathNode.text.replace(/^"|"$/g, '');
-        const absPath = path.resolve(docDir, filename);
-        if (visited.has(absPath)) continue;
-        visited.add(absPath);
-        let mergedText;
-        try { mergedText = fs.readFileSync(absPath, 'utf8'); } catch { continue; }
-        const mergedTree = parseText('behavior', mergedText);
-        if (!mergedTree) continue;
-        nodesOfType(mergedTree, 'state_decl').forEach(n => {
-            const name = n.childForFieldName('name')?.text;
-            if (name) definedStates.add(name);
-        });
-        collectMergedStates(mergedTree, path.dirname(absPath), definedStates, visited);
-    }
+function hasMerge(text) {
+    return /^\s*merge\s+/m.test(text);
 }
 
-// Coleta erros de sintaxe (nós ERROR e MISSING) para que a causa real apareça
-// sublinhada no editor, e não apenas o efeito colateral (ex.: "state not defined").
-// Reporta apenas o ERROR mais externo de cada ramo, e tokens MISSING (ex.: falta 'to').
-function collectSyntaxErrors(root, diagnostics) {
-    const seen = new Set();
+export async function diagnose(uri, langId, text) {
+    if (langId !== 'description' && langId !== 'behavior') return [];
+    let filePath;
+    try {
+        filePath = fileURLToPath(uri);
+    } catch {
+        filePath = uri;
+    }
 
-    function push(node, message) {
-        const key = `${node.startIndex}:${node.endIndex}:${message}`;
-        if (seen.has(key)) return;
-        seen.add(key);
-        diagnostics.push({
-            range: nodeToRange(node),
-            message,
-            severity: DiagnosticSeverity.Error,
-            source: 'behavior-dsl',
-        });
+    if (langId === 'description') {
+        const msgs = await lintDescription(text, filePath);
+        return msgs.map(toDiagnostic);
     }
 
-    function walk(node) {
-        if (node.isMissing) {
-            push(node, `Syntax error: missing '${node.type}'.`);
-            return;
-        }
-        if (node.type === 'ERROR') {
-            // Reporta o ERROR mais profundo (folha) para apontar o token preciso,
-            // em vez do span externo que pode embrulhar o bloco inteiro.
-            const hasNestedError = node.descendantsOfType('ERROR').some(e => e.id !== node.id);
-            if (!hasNestedError) {
-                const snippet = node.text.replace(/\s+/g, ' ').trim().slice(0, 40);
-                push(node, snippet ? `Syntax error near '${snippet}'.` : 'Syntax error.');
-                return;
+    // Agent root = nearest ancestor directory (bounded by the client's
+    // workspace folder) with a *.description file — same convention pack.ts
+    // uses to define an agent bundle. Falls back to the file's own directory
+    // when no manifest is found, e.g. a lone .behavior file opened outside
+    // an agent.
+    const agentRoot = (await findAgentRoot(dirname(filePath))) ?? dirname(filePath);
+    const entryFile = relative(agentRoot, filePath);
+
+    // behavior: run consolidated lint when the file uses merge declarations
+    if (!hasMerge(text)) {
+        // This file has no merge of its own, but it might be a fragment that
+        // another file merges in (e.g. a shared sub-flow). Walk merge edges
+        // backward within the agent root to find that root and borrow its
+        // consolidated state set, so cross-file transitions don't show as
+        // dangling (E005) and this fragment isn't wrongly held to whole-tree
+        // rules like E016 (init required) that only make sense at the root.
+        const root = await findMergeRoot(agentRoot, entryFile);
+        if (root) {
+            try {
+                const { mergedText } = await consolidate(agentRoot, root);
+                const externalStates = new Set((parseBehaviorFile(mergedText).ok?.states ?? []).map(s => s.name));
+                const msgs = await lintBehavior(text, filePath, filePath, false, externalStates, mergedText);
+                return msgs.map(toDiagnostic);
+            } catch {
+                // root's own merge chain is broken — fall back to local-only lint below
             }
-            // tem ERROR aninhado → desce para reportar o(s) mais específico(s)
         }
-        for (const child of node.children) walk(child);
+        const msgs = await lintBehavior(text, filePath, filePath, true);
+        return msgs.map(toDiagnostic);
     }
 
-    walk(root);
-}
-
-function diagnoseBehavior(tree, docUri) {
-    const diagnostics = [];
-
-    // ── Rule 0: Syntax errors (ERROR / MISSING nodes) ─────────────────────────
-    collectSyntaxErrors(tree.rootNode, diagnostics);
-
-    // ── Rule 1: Dangling transitions ──────────────────────────────────────────
-    const definedStates = new Set(
-        nodesOfType(tree, 'state_decl')
-            .map(n => n.childForFieldName('name')?.text)
-            .filter(Boolean)
-    );
-
-    // Enriquecer com estados de arquivos mergeados (recursivo, anti-loop)
+    // multi-file behavior: attempt consolidation to surface E012/E013/E014/E015/E016.
+    // Local diagnostics still run against this file's own `text` — never the
+    // merged blob — so positions stay correct; `mergedText` is only consulted
+    // for whole-tree facts (E015/E016/W014) and W001/W009 reachability.
+    const consolidationDiags = [];
+    let mergedText;
+    let isConsolidated = false;
     try {
-        const docDir = path.dirname(fileURLToPath(docUri));
-        collectMergedStates(tree, docDir, definedStates);
-    } catch { /* URI inválida ou sem acesso — diagnostica apenas com estados locais */ }
-
-    function checkTransitionTarget(stateNode) {
-        if (!stateNode) return;
-        const target = stateNode.text;
-        if (!definedStates.has(target)) {
-            const external = target.includes('.');
-            diagnostics.push({
-                range: nodeToRange(stateNode),
-                message: external
-                    ? `State '${target}' is not defined locally (assuming external flow reference).`
-                    : `State '${target}' is not defined in this file.`,
-                severity: external ? DiagnosticSeverity.Warning : DiagnosticSeverity.Error,
-                source: 'behavior-dsl',
-            });
-        }
-    }
-
-    for (const n of nodesOfType(tree, 'transition_stmt')) {
-        checkTransitionTarget(n.childForFieldName('state'));
-    }
-
-    // ── Rule 2: Dead-end interact (now redundant but kept for safety) ────────────
-    // With the new grammar, oriented_state_body requires repeat1(handlers),
-    // so dead-end interact is structurally impossible. But kept for edge cases.
-    for (const interactNode of nodesOfType(tree, 'interact_stmt')) {
-        let ancestor = interactNode.parent;
-        while (ancestor && ancestor.type !== 'oriented_state_body' && ancestor.type !== 'state_decl') {
-            ancestor = ancestor.parent;
-        }
-        if (!ancestor) continue;
-
-        // With new grammar: oriented_state_body always has handlers after interact (repeat1)
-        // So this check should never trigger, but kept for robustness
-        const hasHandlers = ancestor.descendantsOfType('intent_handler').length +
-                           ancestor.descendantsOfType('offtopic_handler').length > 0;
-
-        if (!hasHandlers) {
-            diagnostics.push({
-                range: nodeToRange(interactNode),
-                message: "This state calls interact but has no handlers (on intent/offtopic). This will trap the agent.",
-                severity: DiagnosticSeverity.Warning,
-                source: 'behavior-dsl',
+        ({ mergedText } = await consolidate(agentRoot, entryFile));
+        isConsolidated = true;
+    } catch (err) {
+        const m = /^(E\d+):\s*(.+)/.exec(err.message);
+        if (m) {
+            consolidationDiags.push({
+                range: { start: { line: 0, character: 0 }, end: { line: 0, character: 0 } },
+                message: `[${m[1]}] ${m[2]}`,
+                severity: DiagnosticSeverity.Error,
+                source: 'dot-agent',
             });
         }
     }
 
-    return diagnostics;
-}
-
-function diagnose(langId, tree, text, uri) {
-    if (!tree) return [];
-    if (langId === 'description') return diagnoseDescription(tree, text);
-    if (langId === 'behavior')  return diagnoseBehavior(tree, uri);
-    return [];
+    const msgs = await lintBehavior(text, filePath, filePath, isConsolidated, undefined, mergedText);
+    return [...consolidationDiags, ...msgs.map(toDiagnostic)];
 }
-
-module.exports = { diagnose };

package/features/formatting.js

@@ -14,8 +14,6 @@
  * limitations under the License.
  */
 
-'use strict';
-
 const BLOCK_HEADERS = /^(on\s+(intent|offtopic|failure|success)|if|else|after|parallel)\b/;
 const TOP_LEVEL_LINE = /^(state|merge)\s|^on\s+event\b/;
 
@@ -76,10 +74,8 @@ function formatDescription(text) {
     return edits;
 }
 
-function format(langId, text) {
+export function format(langId, text) {
     if (langId === 'behavior') return formatBehavior(text);
     if (langId === 'description') return formatDescription(text);
     return [];
 }
-
-module.exports = { format };

package/features/hover.js

@@ -14,9 +14,7 @@
  * limitations under the License.
  */
 
-'use strict';
-
-const { MarkupKind } = require('vscode-languageserver');
+import { MarkupKind } from 'vscode-languageserver';
 
 const DESCRIPTION_DOCS = {
     'agent':        '**`agent name`**\n\nDeclares a new agent. The central node of the manifest.',
@@ -60,7 +58,7 @@ const BEHAVIOR_DOCS = {
     'success':     '**`on success`**\n\nOptional success handler block inside a `parallel` statement.',
 };
 
-function provideHover(langId, text, position) {
+export function provideHover(langId, text, position) {
     const lines = text.split('\n');
     const line = lines[position.line] || '';
     const ch = position.character;
@@ -84,5 +82,3 @@ function provideHover(langId, text, position) {
         },
     };
 }
-
-module.exports = { provideHover };

package/features/links.js

@@ -14,11 +14,9 @@
  * limitations under the License.
  */
 
-'use strict';
-
-const { fileURLToPath, pathToFileURL } = require('url');
-const path = require('path');
-const { nodesOfType, nodeToRange } = require('../parser');
+import { fileURLToPath, pathToFileURL } from 'url';
+import { resolve, dirname } from 'path';
+import { nodesOfType, nodeToRange } from '../parser.js';
 
 // Detecta se um nó bare_string representa um caminho de arquivo.
 // Usa o subtipo do tree-sitter (filename) como primeira fonte de verdade;
@@ -30,12 +28,12 @@ function isFilename(node) {
     return /^[a-zA-Z0-9_-]+(\.[a-zA-Z0-9_-]+)+$/.test(node.text.replace(/^"|"$/g, ''));
 }
 
-function provideDocumentLinks(langId, tree, docUri) {
+export function provideDocumentLinks(langId, tree, docUri) {
     if (!tree) return [];
 
     let docDir;
     try {
-        docDir = path.dirname(fileURLToPath(docUri));
+        docDir = dirname(fileURLToPath(docUri));
     } catch {
         return [];
     }
@@ -47,7 +45,7 @@ function provideDocumentLinks(langId, tree, docUri) {
         if (!filename) return;
         links.push({
             range: nodeToRange(fileNode),
-            target: pathToFileURL(path.resolve(docDir, filename)).toString(),
+            target: pathToFileURL(resolve(docDir, filename)).toString(),
         });
     }
 
@@ -91,5 +89,3 @@ function provideDocumentLinks(langId, tree, docUri) {
 
     return links;
 }
-
-module.exports = { provideDocumentLinks };

package/features/references.js

@@ -14,11 +14,9 @@
  * limitations under the License.
  */
 
-'use strict';
+import { nodesOfType, nodeToRange, wordAtPosition } from '../parser.js';
 
-const { nodesOfType, nodeToRange, wordAtPosition } = require('../parser');
-
-function provideReferences(langId, tree, text, uri, position) {
+export function provideReferences(langId, tree, text, uri, position) {
     if (!tree) return [];
 
     const { word } = wordAtPosition(text, position.line, position.character);
@@ -56,5 +54,3 @@ function provideReferences(langId, tree, text, uri, position) {
 
     return locations;
 }
-
-module.exports = { provideReferences };

package/features/rename.js

@@ -14,11 +14,9 @@
  * limitations under the License.
  */
 
-'use strict';
+import { nodesOfType, nodeToRange, wordAtPosition } from '../parser.js';
 
-const { nodesOfType, nodeToRange, wordAtPosition } = require('../parser');
-
-function provideRenameEdits(langId, tree, text, uri, position, newName) {
+export function provideRenameEdits(langId, tree, text, uri, position, newName) {
     if (!tree) return null;
 
     const { word: oldName } = wordAtPosition(text, position.line, position.character);
@@ -57,5 +55,3 @@ function provideRenameEdits(langId, tree, text, uri, position, newName) {
     if (edits.length === 0) return null;
     return { changes: { [uri]: edits } };
 }
-
-module.exports = { provideRenameEdits };

package/features/symbols.js

@@ -14,14 +14,12 @@
  * limitations under the License.
  */
 
-'use strict';
-
-const { nodesOfType, nodeToRange } = require('../parser');
+import { nodesOfType, nodeToRange } from '../parser.js';
 
 // DocumentSymbol kind constants (LSP spec §3.17.5)
 const Kind = { Class: 5, Struct: 23, Event: 24 };
 
-function provideDocumentSymbols(langId, tree) {
+export function provideDocumentSymbols(langId, tree) {
     if (!tree) return [];
     const symbols = [];
 
@@ -74,5 +72,3 @@ function provideDocumentSymbols(langId, tree) {
 
     return symbols;
 }
-
-module.exports = { provideDocumentSymbols };