umple-lsp-server 0.2.1 → 0.2.4

package/out/server.js

@@ -2,18 +2,106 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const child_process_1 = require("child_process");
 const fs = require("fs");
-const net = require("net");
 const os = require("os");
 const path = require("path");
 const url_1 = require("url");
 const node_1 = require("vscode-languageserver/node");
 const vscode_languageserver_textdocument_1 = require("vscode-languageserver-textdocument");
-const keywords_1 = require("./keywords");
 const symbolIndex_1 = require("./symbolIndex");
+const resolver_1 = require("./resolver");
+const completionBuilder_1 = require("./completionBuilder");
+const hoverBuilder_1 = require("./hoverBuilder");
+const documentSymbolBuilder_1 = require("./documentSymbolBuilder");
+const formatter_1 = require("./formatter");
 const connection = (0, node_1.createConnection)(node_1.ProposedFeatures.all);
 const documents = new Map();
 const pendingValidations = new Map();
 let workspaceRoots = [];
+const rootScanStates = new Map();
+/**
+ * Check if the workspace use-graph is ready for the root containing a file.
+ * Returns true if the root's scan is complete, false if scanning or idle.
+ * Files outside all workspace roots return true (local-only scope is acceptable).
+ */
+function isUseGraphReadyForFile(filePath) {
+    const normalized = path.normalize(filePath);
+    for (const [root, state] of rootScanStates) {
+        if (normalized.startsWith(root))
+            return state === "ready";
+    }
+    // File outside all workspace roots — no graph needed, local scope is fine
+    return true;
+}
+/**
+ * Async cooperative directory scanner. Discovers .ump files without blocking
+ * the event loop. Uses fs.promises.readdir with yielding every 100 directories.
+ */
+async function discoverUmpFilesAsync(root) {
+    const results = [];
+    const queue = [root];
+    const skipDirs = new Set(["node_modules", ".git", "out", ".test-out", "build", "dist"]);
+    let processed = 0;
+    while (queue.length > 0) {
+        const dir = queue.pop();
+        let entries;
+        try {
+            entries = await fs.promises.readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            continue; // permission denied, etc.
+        }
+        for (const entry of entries) {
+            const full = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                if (!skipDirs.has(entry.name)) {
+                    queue.push(full);
+                }
+            }
+            else if (entry.name.endsWith(".ump")) {
+                results.push(path.normalize(full));
+            }
+        }
+        // Yield every 100 directories to keep the server responsive
+        if (++processed % 100 === 0) {
+            await new Promise((r) => setTimeout(r, 0));
+        }
+    }
+    return results;
+}
+/**
+ * Async cooperative use-graph population for a workspace root.
+ * Discovers .ump files, extracts use statements (tree-sitter parse, no symbol extraction),
+ * and populates the import graph. Skips already-indexed files.
+ */
+async function scanWorkspaceRootAsync(root, getOpenDocContent) {
+    rootScanStates.set(root, "scanning");
+    try {
+        const files = await discoverUmpFilesAsync(root);
+        for (let i = 0; i < files.length; i++) {
+            const filePath = files[i];
+            // Skip already-indexed files (edges are fresh from didOpen/didChange)
+            if (symbolIndex_1.symbolIndex.isFileIndexed(filePath))
+                continue;
+            // Prefer open document content over disk
+            const content = getOpenDocContent(filePath) ?? readFileSafe(filePath);
+            if (!content)
+                continue;
+            // Extract use statements and update import graph edges only
+            const uses = symbolIndex_1.symbolIndex.extractUseStatements(filePath, content);
+            symbolIndex_1.symbolIndex.updateUseGraphEdges(filePath, uses);
+            // Yield every 50 files
+            if (i % 50 === 0) {
+                await new Promise((r) => setTimeout(r, 0));
+            }
+        }
+        rootScanStates.set(root, "ready");
+        connection.console.info(`Workspace use-graph ready for: ${root}`);
+    }
+    catch (err) {
+        rootScanStates.set(root, "idle");
+        connection.console.warn(`Workspace use-graph scan failed for ${root}: ${err}`);
+    }
+}
 /**
  * Normalize a file URI to a consistent key for the documents map.
  * Converts URI to file path and back to ensure consistent encoding.
@@ -72,29 +160,17 @@ function findFile(candidates) {
     return undefined;
 }
 let umpleSyncJarPath;
-let umpleSyncHost = "localhost";
-let umpleSyncPort = 5555;
-let umpleSyncTimeoutMs = 50000;
+let umpleSyncTimeoutMs = 30000;
 let jarWarningShown = false;
-let serverProcess;
 let treeSitterWasmPath;
 let symbolIndexReady = false;
-const DEFAULT_UMPLESYNC_TIMEOUT_MS = 50000;
+const DEFAULT_UMPLESYNC_TIMEOUT_MS = 30000;
+// Track in-flight validations so we can abort stale ones
+const inFlightValidations = new Map();
 connection.onInitialize((params) => {
     const initOptions = params.initializationOptions;
     umpleSyncJarPath =
         initOptions?.umpleSyncJarPath || process.env.UMPLESYNC_JAR_PATH;
-    umpleSyncHost =
-        initOptions?.umpleSyncHost || process.env.UMPLESYNC_HOST || "localhost";
-    if (typeof initOptions?.umpleSyncPort === "number") {
-        umpleSyncPort = initOptions.umpleSyncPort;
-    }
-    else if (process.env.UMPLESYNC_PORT) {
-        const parsed = Number(process.env.UMPLESYNC_PORT);
-        if (!Number.isNaN(parsed)) {
-            umpleSyncPort = parsed;
-        }
-    }
     if (typeof initOptions?.umpleSyncTimeoutMs === "number") {
         umpleSyncTimeoutMs = initOptions.umpleSyncTimeoutMs;
     }
@@ -113,9 +189,16 @@ connection.onInitialize((params) => {
             textDocumentSync: node_1.TextDocumentSyncKind.Incremental,
             completionProvider: {
                 resolveProvider: false,
-                triggerCharacters: ["/"],
+                triggerCharacters: ["/", "."],
             },
             definitionProvider: true,
+            referencesProvider: true,
+            renameProvider: {
+                prepareProvider: true,
+            },
+            hoverProvider: true,
+            documentSymbolProvider: true,
+            documentFormattingProvider: true,
         },
     };
 });
@@ -134,6 +217,20 @@ connection.onInitialized(async () => {
             symbolIndexReady = await symbolIndex_1.symbolIndex.initialize(treeSitterWasmPath);
             if (symbolIndexReady) {
                 connection.console.info("Symbol index initialized with tree-sitter.");
+                // Start async workspace use-graph scan (non-blocking, cooperative)
+                if (workspaceRoots.length > 0) {
+                    for (const root of workspaceRoots) {
+                        rootScanStates.set(root, "idle");
+                        scanWorkspaceRootAsync(root, (filePath) => {
+                            const uri = (0, url_1.pathToFileURL)(filePath).toString();
+                            return getDocument(uri)?.getText();
+                        });
+                    }
+                    // Register file watcher for .ump files to keep the use-graph fresh
+                    connection.client.register(node_1.DidChangeWatchedFilesNotification.type, {
+                        watchers: [{ globPattern: "**/*.ump" }],
+                    });
+                }
             }
         }
         catch (err) {
@@ -154,7 +251,7 @@ connection.onDidOpenTextDocument((params) => {
     if (symbolIndexReady) {
         try {
             const filePath = (0, url_1.fileURLToPath)(params.textDocument.uri);
-            symbolIndex_1.symbolIndex.updateFile(filePath, params.textDocument.text);
+            symbolIndex_1.symbolIndex.indexFile(filePath, params.textDocument.text);
         }
         catch {
             // Ignore errors for non-file URIs
@@ -190,6 +287,14 @@ connection.onDidChangeTextDocument((params) => {
     }
     const updated = vscode_languageserver_textdocument_1.TextDocument.update(document, params.contentChanges, params.textDocument.version);
     setDocument(params.textDocument.uri, updated);
+    // Keep the symbol index current so the clean baseline stays fresh.
+    // Without this, state symbols added during clean edits would be lost
+    // when the file later enters an errored state (error preservation
+    // would use a stale clean snapshot).
+    const changedPath = getDocumentFilePath(updated);
+    if (changedPath && symbolIndexReady) {
+        symbolIndex_1.symbolIndex.updateFile(changedPath, updated.getText());
+    }
     scheduleValidation(updated);
     // Re-validate other open documents that might depend on this file
     scheduleDependentValidation(params.textDocument.uri);
@@ -202,8 +307,43 @@ connection.onDidCloseTextDocument((params) => {
         clearTimeout(pendingValidation);
         pendingValidations.delete(normalizedUri);
     }
+    // Abort any in-flight validation so stale results aren't published after close
+    const inFlight = inFlightValidations.get(normalizedUri);
+    if (inFlight) {
+        inFlight.abort();
+        inFlightValidations.delete(normalizedUri);
+    }
     connection.sendDiagnostics({ uri: params.textDocument.uri, diagnostics: [] });
 });
+// ── File watcher: keep workspace use-graph fresh for unopened files ──────────
+connection.onDidChangeWatchedFiles((params) => {
+    if (!symbolIndexReady)
+        return;
+    for (const change of params.changes) {
+        let filePath;
+        try {
+            filePath = path.normalize((0, url_1.fileURLToPath)(change.uri));
+        }
+        catch {
+            continue;
+        }
+        // Skip files that are open in the editor — their edges are managed by didOpen/didChange
+        if (getDocument(change.uri))
+            continue;
+        if (change.type === node_1.FileChangeType.Deleted) {
+            // File deleted — remove its import graph edges
+            symbolIndex_1.symbolIndex.removeImportEdges(filePath);
+        }
+        else {
+            // Created or Changed — update use-graph edges from disk content
+            const content = readFileSafe(filePath);
+            if (content) {
+                const uses = symbolIndex_1.symbolIndex.extractUseStatements(filePath, content);
+                symbolIndex_1.symbolIndex.updateUseGraphEdges(filePath, uses);
+            }
+        }
+    }
+});
 connection.onCompletion(async (params) => {
     const document = getDocument(params.textDocument.uri);
     if (!document) {
@@ -245,170 +385,344 @@ connection.onCompletion(async (params) => {
     else if (params.context?.triggerCharacter === "/") {
         return [];
     }
-    // 5a. Keywords from LookaheadIterator
-    for (const kw of info.keywords) {
-        if (!seen.has(kw)) {
-            seen.add(kw);
-            items.push({ label: kw, kind: node_1.CompletionItemKind.Keyword });
-        }
-    }
-    // 5b. Operators from LookaheadIterator
-    for (const op of info.operators) {
-        if (!seen.has(op)) {
-            seen.add(op);
-            items.push({ label: op, kind: node_1.CompletionItemKind.Operator });
-        }
-    }
-    // 5c. Built-in types (when in type-compatible scope)
-    if (Array.isArray(symbolKinds) &&
-        symbolKinds.some((k) => ["class", "interface", "trait", "enum"].includes(k))) {
-        for (const typ of keywords_1.BUILTIN_TYPES) {
-            if (!seen.has(typ)) {
-                seen.add(typ);
-                items.push({
-                    label: typ,
-                    kind: node_1.CompletionItemKind.TypeParameter,
-                    detail: "type",
-                });
-            }
-        }
-    }
-    // 5d. Constraint scope: only own attributes (Umple E28)
-    if (symbolKinds === "own_attribute" && info.enclosingClass) {
-        const symbols = symbolIndex_1.symbolIndex
-            .getSymbols({ container: info.enclosingClass, kind: "attribute" })
-            .filter((s) => reachableFiles.has(path.normalize(s.file)));
-        for (const sym of symbols) {
-            if (!seen.has(sym.name)) {
-                seen.add(sym.name);
-                items.push({
-                    label: sym.name,
-                    kind: symbolKindToCompletionKind("attribute"),
-                    detail: "attribute",
-                });
-            }
-        }
-        return items;
-    }
-    // 5e. Symbol completions from index (scoped to reachable files)
-    if (Array.isArray(symbolKinds)) {
-        for (const symKind of symbolKinds) {
-            let symbols;
-            // Scoped lookups for container-aware kinds
-            if (symKind === "attribute" && info.enclosingClass) {
-                symbols = symbolIndex_1.symbolIndex
-                    .getSymbols({
-                    container: info.enclosingClass,
-                    kind: "attribute",
-                    inherited: true,
-                })
-                    .filter((s) => reachableFiles.has(path.normalize(s.file)));
-            }
-            else if (symKind === "state" && info.enclosingStateMachine) {
-                symbols = symbolIndex_1.symbolIndex
-                    .getSymbols({ container: info.enclosingStateMachine, kind: "state" })
-                    .filter((s) => reachableFiles.has(path.normalize(s.file)));
-            }
-            else if (symKind === "template" && info.enclosingClass) {
-                symbols = symbolIndex_1.symbolIndex
-                    .getSymbols({ container: info.enclosingClass, kind: "template" })
-                    .filter((s) => reachableFiles.has(path.normalize(s.file)));
-            }
-            else {
-                symbols = symbolIndex_1.symbolIndex
-                    .getSymbols({ kind: symKind })
-                    .filter((s) => reachableFiles.has(path.normalize(s.file)));
-            }
-            for (const sym of symbols) {
-                if (!seen.has(sym.name)) {
-                    seen.add(sym.name);
-                    items.push({
-                        label: sym.name,
-                        kind: symbolKindToCompletionKind(symKind),
-                        detail: symKind,
-                    });
-                }
-            }
+    else if (params.context?.triggerCharacter === ".") {
+        if (!info.dottedStatePrefix)
+            return [];
+        // Dot-state completion: return only child state names, skip all
+        // generic phases (keywords, operators, types, other symbol kinds).
+        const childNames = info.enclosingStateMachine
+            ? symbolIndex_1.symbolIndex.getChildStateNames(info.dottedStatePrefix, info.enclosingStateMachine, reachableFiles)
+            : [];
+        return childNames.map((name) => ({
+            label: name,
+            kind: (0, completionBuilder_1.symbolKindToCompletionKind)("state"),
+            detail: "state",
+            sortText: `0_${name}`,
+        }));
+    }
+    // 5. Build semantic completion items (keywords, operators, types, symbols)
+    const semanticItems = (0, completionBuilder_1.buildSemanticCompletionItems)(info, symbolKinds, symbolIndex_1.symbolIndex, reachableFiles);
+    // Merge use_path items (if any) with semantic items, deduplicating
+    for (const item of semanticItems) {
+        if (!seen.has(item.label)) {
+            seen.add(item.label);
+            items.push(item);
         }
     }
     return items;
 });
+// ── Shared symbol resolution (used by go-to-def and hover) ──────────────────
+/**
+ * Resolve symbol(s) at a given position. Thin wrapper around the shared
+ * resolver that handles reachable-file computation from the document context.
+ */
+function resolveSymbolAtPosition(docPath, content, line, col) {
+    const reachableFiles = ensureImportsIndexed(docPath, content);
+    return (0, resolver_1.resolveSymbolAtPosition)(symbolIndex_1.symbolIndex, docPath, content, line, col, reachableFiles);
+}
 connection.onDefinition(async (params) => {
     const document = getDocument(params.textDocument.uri);
-    if (!document) {
-        return [];
-    }
-    if (!symbolIndexReady) {
+    if (!document || !symbolIndexReady)
         return [];
-    }
     const docPath = getDocumentFilePath(document);
-    if (!docPath) {
+    if (!docPath)
         return [];
-    }
     const token = symbolIndex_1.symbolIndex.getTokenAtPosition(docPath, document.getText(), params.position.line, params.position.character);
-    if (!token) {
+    if (!token)
         return [];
-    }
     // use statement with .ump extension: resolve as file reference
     if (token.word.endsWith(".ump")) {
         const baseDir = path.dirname(docPath);
         const targetPath = path.isAbsolute(token.word)
             ? token.word
             : path.join(baseDir, token.word);
-        if (!fs.existsSync(targetPath)) {
+        if (!fs.existsSync(targetPath))
             return [];
-        }
         return [
             node_1.Location.create((0, url_1.pathToFileURL)(targetPath).toString(), node_1.Range.create(node_1.Position.create(0, 0), node_1.Position.create(0, 0))),
         ];
     }
-    // Symbol lookup, filtered by reachable files
+    const resolved = resolveSymbolAtPosition(docPath, document.getText(), params.position.line, params.position.character);
+    if (!resolved || resolved.symbols.length === 0)
+        return [];
+    return resolved.symbols.map((sym) => node_1.Location.create((0, url_1.pathToFileURL)(sym.file).toString(), node_1.Range.create(node_1.Position.create(sym.line, sym.column), node_1.Position.create(sym.endLine, sym.endColumn))));
+});
+// ── Find References ──────────────────────────────────────────────────────────
+connection.onReferences(async (params) => {
+    const document = getDocument(params.textDocument.uri);
+    if (!document || !symbolIndexReady)
+        return [];
+    const docPath = getDocumentFilePath(document);
+    if (!docPath)
+        return [];
+    // 1. Identify symbol (full declaration set)
+    const resolved = resolveSymbolAtPosition(docPath, document.getText(), params.position.line, params.position.character);
+    if (!resolved || resolved.symbols.length === 0)
+        return [];
+    // 2. Index forward-reachable files (fast, import-chain only — no workspace crawl).
+    //
+    // Scope model: references searches the current file, forward-reachable imports,
+    // and reverse importers known to the import graph. The import graph is populated
+    // by: (1) didOpen/didChange for open files, (2) async background workspace scan
+    // on init, (3) file watcher events for disk changes. This avoids synchronous
+    // workspace-wide crawling on the request path. References is best-effort — it
+    // uses whatever graph state is available without blocking.
     const reachableFiles = ensureImportsIndexed(docPath, document.getText());
-    // For container-scoped kinds, try scoped lookup first (with inheritance), then global fallback
-    const containerKinds = new Set([
+    // 3. Compute search scope: declaration files + forward-reachable + known reverse importers
+    const declFiles = new Set(resolved.symbols.map((s) => path.normalize(s.file)));
+    const reverseImporters = symbolIndex_1.symbolIndex.getReverseImporters(declFiles);
+    const filesToSearch = new Set([...declFiles, ...reachableFiles, ...reverseImporters]);
+    // Ensure reverse importers are fully indexed
+    for (const file of reverseImporters) {
+        if (!symbolIndex_1.symbolIndex.isFileIndexed(file)) {
+            const uri = (0, url_1.pathToFileURL)(file).toString();
+            const openDoc = getDocument(uri);
+            if (openDoc) {
+                symbolIndex_1.symbolIndex.updateFile(file, openDoc.getText());
+            }
+            else if (fs.existsSync(file)) {
+                symbolIndex_1.symbolIndex.indexFile(file);
+            }
+        }
+    }
+    // 4. Find references
+    const refs = symbolIndex_1.symbolIndex.findReferences(resolved.symbols, filesToSearch, params.context.includeDeclaration);
+    // 5. Convert to Location[]
+    return refs.map((r) => node_1.Location.create((0, url_1.pathToFileURL)(r.file).toString(), node_1.Range.create(node_1.Position.create(r.line, r.column), node_1.Position.create(r.endLine, r.endColumn))));
+});
+// ── Rename ───────────────────────────────────────────────────────────────────
+const RENAMEABLE_KINDS = new Set([
+    "class",
+    "interface",
+    "trait",
+    "enum",
+    "mixset",
+    "attribute",
+    "const",
+    "state",
+    "statemachine",
+    "tracecase",
+]);
+function isUnambiguousRename(symbols) {
+    if (symbols.length <= 1)
+        return symbols.length === 1;
+    // All symbols must share the same kind
+    const kind = symbols[0].kind;
+    if (!symbols.every((s) => s.kind === kind))
+        return false;
+    // State: must share same statePath (different paths = different states)
+    if (kind === "state") {
+        const refPath = symbols[0].statePath?.join(".");
+        return symbols.every((s) => s.statePath?.join(".") === refPath);
+    }
+    // Container-scoped kinds: must share container + name
+    const containerScoped = new Set([
         "attribute",
+        "const",
         "method",
         "template",
-        "state",
+        "statemachine",
     ]);
-    const isScoped = token.kinds?.some((k) => containerKinds.has(k));
-    let container;
-    if (isScoped) {
-        container = token.kinds?.some((k) => k === "state")
-            ? token.enclosingStateMachine
-            : token.enclosingClass;
-    }
-    let filteredSymbols = [];
-    if (container) {
-        filteredSymbols = symbolIndex_1.symbolIndex
-            .getSymbols({
-            name: token.word,
-            kind: token.kinds ?? undefined,
-            container,
-            inherited: true,
-        })
-            .filter((s) => reachableFiles.has(path.normalize(s.file)));
-    }
-    if (filteredSymbols.length === 0) {
-        filteredSymbols = symbolIndex_1.symbolIndex
-            .getSymbols({ name: token.word, kind: token.kinds ?? undefined })
-            .filter((s) => reachableFiles.has(path.normalize(s.file)));
-    }
-    if (filteredSymbols.length > 0) {
-        return filteredSymbols.map((sym) => node_1.Location.create((0, url_1.pathToFileURL)(sym.file).toString(), node_1.Range.create(node_1.Position.create(sym.line, sym.column), node_1.Position.create(sym.endLine, sym.endColumn))));
-    }
-    return [];
+    if (containerScoped.has(kind)) {
+        const { container, name } = symbols[0];
+        return symbols.every((s) => s.container === container && s.name === name);
+    }
+    // Top-level mergeable kinds (class, interface, trait, enum, mixset):
+    // same name = partial definitions of the same entity
+    const name = symbols[0].name;
+    return symbols.every((s) => s.name === name);
+}
+connection.onPrepareRename(async (params) => {
+    const document = getDocument(params.textDocument.uri);
+    if (!document || !symbolIndexReady)
+        return null;
+    const docPath = getDocumentFilePath(document);
+    if (!docPath)
+        return null;
+    // Full semantic resolution
+    const resolved = resolveSymbolAtPosition(docPath, document.getText(), params.position.line, params.position.character);
+    if (!resolved || resolved.symbols.length === 0)
+        return null;
+    // Kind must be in the renameable set
+    if (!RENAMEABLE_KINDS.has(resolved.symbols[0].kind))
+        return null;
+    // Identity must be unambiguous
+    if (!isUnambiguousRename(resolved.symbols))
+        return null;
+    // Get precise identifier range
+    const range = symbolIndex_1.symbolIndex.getNodeRangeAtPosition(docPath, document.getText(), params.position.line, params.position.character);
+    if (!range)
+        return null;
+    return {
+        range: node_1.Range.create(node_1.Position.create(range.startLine, range.startColumn), node_1.Position.create(range.endLine, range.endColumn)),
+        placeholder: resolved.token.word,
+    };
+});
+connection.onRenameRequest(async (params) => {
+    const document = getDocument(params.textDocument.uri);
+    if (!document || !symbolIndexReady)
+        return null;
+    const docPath = getDocumentFilePath(document);
+    if (!docPath)
+        return null;
+    // Validate new name is a legal identifier
+    if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(params.newName))
+        return null;
+    // 1. Full semantic resolution (same checks as prepareRename)
+    const resolved = resolveSymbolAtPosition(docPath, document.getText(), params.position.line, params.position.character);
+    if (!resolved || resolved.symbols.length === 0)
+        return null;
+    if (!RENAMEABLE_KINDS.has(resolved.symbols[0].kind))
+        return null;
+    if (!isUnambiguousRename(resolved.symbols))
+        return null;
+    // Check workspace use-graph readiness for the DECLARATION files' roots.
+    // Rename must not return partial WorkspaceEdits — if any declaration's
+    // root is still scanning, fail explicitly rather than silently miss importers.
+    // (Checked after resolution so we know which roots actually matter.)
+    for (const sym of resolved.symbols) {
+        if (!isUseGraphReadyForFile(sym.file)) {
+            connection.window.showWarningMessage("Workspace scan in progress. Please try rename again in a moment.");
+            return null;
+        }
+    }
+    // 2. Index forward-reachable files (fast, import-chain only — no workspace crawl).
+    // Same scope model as references: current file + forward imports + known reverse
+    // importers. See onReferences comment for full rationale.
+    const reachableFiles = ensureImportsIndexed(docPath, document.getText());
+    // 3. Compute search scope: declaration files + forward-reachable + known reverse importers
+    const declFiles = new Set(resolved.symbols.map((s) => path.normalize(s.file)));
+    const reverseImporters = symbolIndex_1.symbolIndex.getReverseImporters(declFiles);
+    const filesToSearch = new Set([...declFiles, ...reachableFiles, ...reverseImporters]);
+    // Ensure reverse importers are fully indexed
+    for (const file of reverseImporters) {
+        if (!symbolIndex_1.symbolIndex.isFileIndexed(file)) {
+            const uri = (0, url_1.pathToFileURL)(file).toString();
+            const openDoc = getDocument(uri);
+            if (openDoc) {
+                symbolIndex_1.symbolIndex.updateFile(file, openDoc.getText());
+            }
+            else if (fs.existsSync(file)) {
+                symbolIndex_1.symbolIndex.indexFile(file);
+            }
+        }
+    }
+    // 4. Find ALL references including declarations
+    const refs = symbolIndex_1.symbolIndex.findReferences(resolved.symbols, filesToSearch, true);
+    // 5. Build WorkspaceEdit
+    const changes = {};
+    for (const r of refs) {
+        const uri = (0, url_1.pathToFileURL)(r.file).toString();
+        if (!changes[uri])
+            changes[uri] = [];
+        changes[uri].push(node_1.TextEdit.replace(node_1.Range.create(node_1.Position.create(r.line, r.column), node_1.Position.create(r.endLine, r.endColumn)), params.newName));
+    }
+    return { changes };
+});
+// ── Hover ───────────────────────────────────────────────────────────────────
+connection.onHover(async (params) => {
+    const document = getDocument(params.textDocument.uri);
+    if (!document || !symbolIndexReady)
+        return null;
+    const docPath = getDocumentFilePath(document);
+    if (!docPath)
+        return null;
+    const resolved = resolveSymbolAtPosition(docPath, document.getText(), params.position.line, params.position.character);
+    if (!resolved || resolved.symbols.length === 0)
+        return null;
+    const sym = resolved.symbols[0];
+    const markdown = (0, hoverBuilder_1.buildHoverMarkdown)(sym, resolved.symbols, {
+        getTree: (fp) => symbolIndex_1.symbolIndex.getTree(fp),
+        getIsAParents: (name) => symbolIndex_1.symbolIndex.getIsAParents(name),
+    });
+    if (!markdown)
+        return null;
+    return { contents: { kind: "markdown", value: markdown } };
+});
+// ── Document Symbols (Outline) ──────────────────────────────────────────────
+connection.onDocumentSymbol(async (params) => {
+    const document = getDocument(params.textDocument.uri);
+    if (!document || !symbolIndexReady)
+        return [];
+    const docPath = getDocumentFilePath(document);
+    if (!docPath)
+        return [];
+    symbolIndex_1.symbolIndex.updateFile(docPath, document.getText());
+    return (0, documentSymbolBuilder_1.buildDocumentSymbolTree)(symbolIndex_1.symbolIndex.getFileSymbols(docPath));
+});
+// ── Formatting ──────────────────────────────────────────────────────────────
+connection.onDocumentFormatting(async (params) => {
+    const document = getDocument(params.textDocument.uri);
+    if (!document)
+        return [];
+    const docPath = getDocumentFilePath(document);
+    if (!docPath || !symbolIndexReady)
+        return [];
+    symbolIndex_1.symbolIndex.updateFile(docPath, document.getText());
+    const tree = symbolIndex_1.symbolIndex.getTree(docPath);
+    if (!tree)
+        return [];
+    let text = document.getText();
+    const originalText = text;
+    // Phase 0: expand compact state blocks (may insert newlines)
+    const expandedText = (0, formatter_1.expandCompactStates)(text, tree);
+    let formatTree = tree;
+    if (expandedText !== text) {
+        // Temporarily index expanded text to get a parsed tree.
+        // We restore the original text at the end to avoid corrupting
+        // the live index (the editor document hasn't changed yet).
+        symbolIndex_1.symbolIndex.updateFile(docPath, expandedText);
+        formatTree = symbolIndex_1.symbolIndex.getTree(docPath);
+        text = expandedText;
+    }
+    // Phase 1-2: formatting passes on the (possibly expanded) text
+    const edits = [
+        ...(0, formatter_1.computeIndentEdits)(text, params.options, formatTree),
+        ...(0, formatter_1.fixTransitionSpacing)(text, formatTree),
+        ...(0, formatter_1.fixAssociationSpacing)(text, formatTree),
+        ...(0, formatter_1.normalizeTopLevelBlankLines)(text, formatTree),
+    ];
+    // Apply edits internally to produce final text
+    const lines = text.split("\n");
+    const lineOffsets = [];
+    let offset = 0;
+    for (const line of lines) {
+        lineOffsets.push(offset);
+        offset += line.length + 1;
+    }
+    const toOffset = (line, col) => (lineOffsets[line] ?? text.length) + col;
+    const sorted = [...edits].sort((a, b) => toOffset(b.range.start.line, b.range.start.character) -
+        toOffset(a.range.start.line, a.range.start.character));
+    let finalText = text;
+    for (const edit of sorted) {
+        const start = toOffset(edit.range.start.line, edit.range.start.character);
+        const end = toOffset(edit.range.end.line, edit.range.end.character);
+        finalText = finalText.substring(0, start) + edit.newText + finalText.substring(end);
+    }
+    // Restore the live index to the original document text if we mutated it
+    if (expandedText !== originalText) {
+        symbolIndex_1.symbolIndex.updateFile(docPath, originalText);
+    }
+    // Return single whole-document replace
+    if (finalText === originalText)
+        return [];
+    const lastLine = document.lineCount - 1;
+    const lastChar = (originalText.split("\n")[lastLine] ?? "").length;
+    return [
+        node_1.TextEdit.replace(node_1.Range.create(node_1.Position.create(0, 0), node_1.Position.create(lastLine, lastChar)), finalText),
+    ];
 });
 function scheduleValidation(document) {
-    const existing = pendingValidations.get(document.uri);
+    const uriKey = normalizeUri(document.uri);
+    const existing = pendingValidations.get(uriKey);
     if (existing) {
         clearTimeout(existing);
     }
     const handle = setTimeout(() => {
-        pendingValidations.delete(document.uri);
+        pendingValidations.delete(uriKey);
         void validateTextDocument(document);
     }, 300);
-    pendingValidations.set(document.uri, handle);
+    pendingValidations.set(uriKey, handle);
 }
 // Debounce key for dependent validation
 const dependentValidationKey = "__dependent__";
@@ -470,33 +784,57 @@ async function validateTextDocument(document) {
     if (!jarPath) {
         return;
     }
+    const uriKey = normalizeUri(document.uri);
+    const docVersion = document.version;
+    // Abort any in-flight validation for this document
+    const previous = inFlightValidations.get(uriKey);
+    if (previous) {
+        previous.abort();
+    }
+    const abortController = new AbortController();
+    inFlightValidations.set(uriKey, abortController);
     try {
-        const diagnostics = await runUmpleSyncAndParseDiagnostics(jarPath, document);
+        const diagnostics = await runUmpleSyncAndParseDiagnostics(jarPath, document, abortController.signal);
+        if (abortController.signal.aborted) {
+            return;
+        }
+        // Drop stale results if the document has been edited since we started
+        const current = getDocument(document.uri);
+        if (!current || current.version !== docVersion) {
+            return;
+        }
         connection.sendDiagnostics({ uri: document.uri, diagnostics });
     }
     catch (error) {
+        if (abortController.signal.aborted) {
+            return;
+        }
+        const current = getDocument(document.uri);
+        if (!current || current.version !== docVersion) {
+            return;
+        }
         connection.console.error(`Diagnostics failed: ${String(error)}`);
         connection.sendDiagnostics({ uri: document.uri, diagnostics: [] });
     }
-}
-function resolveJarPath() {
-    if (!umpleSyncJarPath) {
-        if (!jarWarningShown) {
-            connection.window.showWarningMessage("UmpleSync jar path not set. Configure initializationOptions.umpleSyncJarPath or UMPLESYNC_JAR.");
-            jarWarningShown = true;
+    finally {
+        if (inFlightValidations.get(uriKey) === abortController) {
+            inFlightValidations.delete(uriKey);
         }
-        return undefined;
     }
-    if (!fs.existsSync(umpleSyncJarPath)) {
+}
+function resolveJarPath() {
+    if (!umpleSyncJarPath || !fs.existsSync(umpleSyncJarPath)) {
         if (!jarWarningShown) {
-            connection.window.showWarningMessage(`UmpleSync jar not found at ${umpleSyncJarPath}. Update the path or UMPLESYNC_JAR.`);
+            connection.window.showWarningMessage("Umple diagnostics are disabled: umplesync.jar was not found. " +
+                "Completion and go-to-definition still work. " +
+                "Reload the window to retry.");
             jarWarningShown = true;
         }
         return undefined;
     }
     return umpleSyncJarPath;
 }
-async function runUmpleSyncAndParseDiagnostics(jarPath, document) {
+async function runUmpleSyncAndParseDiagnostics(jarPath, document, signal) {
     const docPath = getDocumentFilePath(document);
     if (!docPath) {
         return [];
@@ -513,8 +851,7 @@ async function runUmpleSyncAndParseDiagnostics(jarPath, document) {
             text = text.replace(/\n?$/, "\n\n");
         }
         await fs.promises.writeFile(shadow.targetFile, text, "utf8");
-        const commandLine = `-generate nothing ${formatUmpleArg(shadow.targetFile)}`;
-        const { stdout, stderr } = await sendUmpleSyncCommand(jarPath, commandLine);
+        const { stdout, stderr } = await runUmpleDirect(jarPath, shadow.targetFile, signal);
         const tempFilename = path.basename(shadow.targetFile);
         const documentDir = getDocumentDirectory(document);
         return parseUmpleDiagnostics(stderr, stdout, document, tempFilename, documentDir);
@@ -523,13 +860,39 @@ async function runUmpleSyncAndParseDiagnostics(jarPath, document) {
         await shadow.cleanup();
     }
 }
+/**
+ * Run umplesync.jar directly as a subprocess (one process per request).
+ * This is simpler and more reliable than the socket server approach —
+ * no persistent state, no stuck connections between requests.
+ */
+function runUmpleDirect(jarPath, filePath, signal) {
+    return new Promise((resolve, reject) => {
+        if (signal?.aborted) {
+            reject(new Error("aborted"));
+            return;
+        }
+        (0, child_process_1.execFile)("java", ["-jar", jarPath, "-generate", "nothing", filePath], { signal, timeout: umpleSyncTimeoutMs, maxBuffer: 10 * 1024 * 1024 }, (error, stdout, stderr) => {
+            if (signal?.aborted) {
+                reject(new Error("aborted"));
+                return;
+            }
+            // Umplesync writes diagnostics to stderr and exits 0 on compile errors.
+            // Any non-null error here is a real execution failure (java not found,
+            // corrupt jar, runtime crash, timeout kill) — reject unconditionally.
+            if (error) {
+                reject(error);
+                return;
+            }
+            resolve({ stdout, stderr });
+        });
+    });
+}
 /**
  * Create a shadow workspace with only the files needed for compilation:
  * the current document and all files it imports via `use` statements.
  */
 async function createShadowWorkspace(documentPath) {
     const documentDir = path.dirname(documentPath);
-    const documentName = path.basename(documentPath);
     // Get document content (from open doc or disk)
     const fileUri = (0, url_1.pathToFileURL)(documentPath).toString();
     const openDoc = getDocument(fileUri);
@@ -543,12 +906,18 @@ async function createShadowWorkspace(documentPath) {
         // Find only files reachable via use statements (lazy approach)
         const reachableFiles = collectReachableFiles(documentPath, documentContent, documentDir);
         // Also include the current document
-        reachableFiles.add(path.normalize(documentPath));
+        const normalizedDocPath = path.normalize(documentPath);
+        reachableFiles.add(normalizedDocPath);
+        // Compute a common ancestor directory so all relative paths stay inside
+        // the shadow workspace (no "../" escapes). Always include the document
+        // path in the ancestor calculation even if it doesn't exist on disk,
+        // since we always write it to the shadow workspace.
+        const allForBase = Array.from(reachableFiles);
+        const baseDir = findCommonAncestor(allForBase);
+        const allPaths = allForBase.filter((f) => fs.existsSync(f));
         // Create directory structure and symlink/copy files
-        for (const filePath of reachableFiles) {
-            if (!fs.existsSync(filePath))
-                continue;
-            const relativePath = path.relative(documentDir, filePath);
+        for (const filePath of allPaths) {
+            const relativePath = path.relative(baseDir, filePath);
             const shadowPath = path.join(shadowDir, relativePath);
             const shadowFileDir = path.dirname(shadowPath);
             // Create directory structure
@@ -565,7 +934,10 @@ async function createShadowWorkspace(documentPath) {
                 await fs.promises.symlink(filePath, shadowPath);
             }
         }
-        const targetFile = path.join(shadowDir, documentName);
+        const targetFile = path.join(shadowDir, path.relative(baseDir, normalizedDocPath));
+        // Ensure target directory exists (document may not be on disk,
+        // so the symlink/copy loop above may not have created it)
+        await fs.promises.mkdir(path.dirname(targetFile), { recursive: true });
         return {
             shadowDir,
             targetFile,
@@ -580,117 +952,28 @@ async function createShadowWorkspace(documentPath) {
         throw error;
     }
 }
-async function sendUmpleSyncCommand(jarPath, commandLine) {
-    try {
-        return await connectAndSend(commandLine);
-    }
-    catch (error) {
-        if (!isConnectionError(error)) {
-            throw error;
-        }
-        const started = await startUmpleSyncServer(jarPath);
-        if (!started) {
-            throw error;
-        }
-        for (let attempt = 0; attempt < 5; attempt += 1) {
-            try {
-                return await connectAndSend(commandLine);
-            }
-            catch (retryError) {
-                if (!isConnectionError(retryError)) {
-                    throw retryError;
-                }
-                await delay(150);
-            }
-        }
-        throw error;
-    }
-}
-// Send command to UmpleSync.jar socket server and receive the output
-function connectAndSend(commandLine) {
-    return new Promise((resolve, reject) => {
-        const socket = new net.Socket();
-        const chunks = [];
-        let settled = false;
-        const finishSuccess = (raw) => {
-            if (settled) {
-                return;
-            }
-            settled = true;
-            const { stdout, stderr } = splitUmpleSyncOutput(raw);
-            resolve({ stdout, stderr });
-        };
-        const finishError = (err) => {
-            if (settled) {
-                return;
-            }
-            settled = true;
-            socket.destroy();
-            reject(err);
-        };
-        socket.setEncoding("utf8");
-        socket.setTimeout(umpleSyncTimeoutMs);
-        socket.on("data", (chunk) => {
-            if (typeof chunk === "string") {
-                chunks.push(chunk);
-            }
-            else {
-                chunks.push(chunk.toString("utf8"));
+/**
+ * Find the deepest common ancestor directory of a list of file paths.
+ * Used to ensure all shadow workspace relative paths stay positive (no "../").
+ */
+function findCommonAncestor(filePaths) {
+    if (filePaths.length === 0) {
+        return os.tmpdir();
+    }
+    const dirs = filePaths.map((f) => path.dirname(path.normalize(f)));
+    const segments = dirs[0].split(path.sep);
+    let commonLength = segments.length;
+    for (let i = 1; i < dirs.length; i++) {
+        const parts = dirs[i].split(path.sep);
+        commonLength = Math.min(commonLength, parts.length);
+        for (let j = 0; j < commonLength; j++) {
+            if (segments[j] !== parts[j]) {
+                commonLength = j;
+                break;
             }
-        });
-        socket.on("end", () => {
-            finishSuccess(chunks.join(""));
-        });
-        socket.on("error", (err) => {
-            const error = err instanceof Error ? err : new Error(String(err));
-            finishError(error);
-        });
-        socket.on("timeout", () => {
-            finishError(new Error("umplesync socket timeout"));
-        });
-        socket.connect(umpleSyncPort, umpleSyncHost, () => {
-            socket.end(commandLine);
-        });
-    });
-}
-async function startUmpleSyncServer(jarPath) {
-    if (serverProcess) {
-        return true;
-    }
-    return new Promise((resolve) => {
-        const child = (0, child_process_1.spawn)("java", ["-jar", jarPath, "-server", String(umpleSyncPort)], {
-            detached: true,
-            stdio: "ignore",
-        });
-        child.on("error", (err) => {
-            connection.console.error(`Failed to start umplesync: ${String(err)}`);
-            resolve(false);
-        });
-        child.unref();
-        serverProcess = child;
-        resolve(true);
-    });
-}
-function splitUmpleSyncOutput(raw) {
-    let stdout = "";
-    let stderr = "";
-    let index = 0;
-    while (index < raw.length) {
-        const start = raw.indexOf("ERROR!!", index);
-        if (start === -1) {
-            stdout += raw.slice(index);
-            break;
-        }
-        stdout += raw.slice(index, start);
-        const end = raw.indexOf("!!ERROR", start + 7);
-        if (end === -1) {
-            stderr += raw.slice(start + 7);
-            break;
         }
-        stderr += raw.slice(start + 7, end);
-        index = end + 7;
     }
-    return { stdout, stderr };
+    return segments.slice(0, commonLength).join(path.sep) || path.sep;
 }
 /**
  * Collect all file paths reachable via transitive use statements.
@@ -737,20 +1020,6 @@ function collectReachableFilesRecursive(filePath, content, documentDir, visited)
         }
     }
 }
-function isConnectionError(error) {
-    if (!error || typeof error !== "object") {
-        return false;
-    }
-    const maybeError = error;
-    return (maybeError.code === "ECONNREFUSED" ||
-        maybeError.code === "ECONNRESET" ||
-        maybeError.code === "EPIPE" ||
-        maybeError.code === "ETIMEDOUT" ||
-        (maybeError.message || "").includes("umplesync socket timeout"));
-}
-function delay(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
 function parseUmpleDiagnostics(stderr, stdout, document, tempFilename, documentDir) {
     const jsonDiagnostics = parseUmpleJsonDiagnostics(stderr, document, tempFilename, documentDir);
     if (jsonDiagnostics.length === 0 && stdout.includes("Success")) {
@@ -961,39 +1230,6 @@ function getDocumentFilePath(document) {
         return null;
     }
 }
-/**
- * Map a SymbolKind to the appropriate LSP CompletionItemKind.
- */
-function symbolKindToCompletionKind(kind) {
-    switch (kind) {
-        case "class":
-            return node_1.CompletionItemKind.Class;
-        case "interface":
-            return node_1.CompletionItemKind.Interface;
-        case "trait":
-            return node_1.CompletionItemKind.Class;
-        case "enum":
-            return node_1.CompletionItemKind.Enum;
-        case "state":
-            return node_1.CompletionItemKind.EnumMember;
-        case "statemachine":
-            return node_1.CompletionItemKind.Enum;
-        case "attribute":
-            return node_1.CompletionItemKind.Field;
-        case "method":
-            return node_1.CompletionItemKind.Method;
-        case "association":
-            return node_1.CompletionItemKind.Reference;
-        case "mixset":
-            return node_1.CompletionItemKind.Module;
-        case "requirement":
-            return node_1.CompletionItemKind.Reference;
-        case "template":
-            return node_1.CompletionItemKind.Property;
-        default:
-            return node_1.CompletionItemKind.Text;
-    }
-}
 function getUseFileCompletions(document, prefix, line, character) {
     const docDir = getDocumentDirectory(document);
     if (!docDir) {
@@ -1065,8 +1301,5 @@ function extractJson(text) {
     }
     return text.slice(start, end + 1);
 }
-function formatUmpleArg(filePath) {
-    return JSON.stringify(filePath);
-}
 connection.listen();
 //# sourceMappingURL=server.js.map