umple-lsp-server 0.1.0

package/out/server.js

@@ -0,0 +1,1117 @@
+"use strict";
+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 connection = (0, node_1.createConnection)(node_1.ProposedFeatures.all);
+const documents = new Map();
+const pendingValidations = new Map();
+let workspaceRoots = [];
+/**
+ * Normalize a file URI to a consistent key for the documents map.
+ * Converts URI to file path and back to ensure consistent encoding.
+ */
+function normalizeUri(uri) {
+    if (!uri.startsWith("file:")) {
+        return uri;
+    }
+    try {
+        // Convert to path and back to normalize encoding
+        const filePath = (0, url_1.fileURLToPath)(uri);
+        return (0, url_1.pathToFileURL)(filePath).toString();
+    }
+    catch {
+        return uri;
+    }
+}
+/**
+ * Get a document by URI, using normalized lookup.
+ */
+function getDocument(uri) {
+    return documents.get(normalizeUri(uri));
+}
+/**
+ * Set a document by URI, using normalized key.
+ */
+function setDocument(uri, document) {
+    documents.set(normalizeUri(uri), document);
+}
+/**
+ * Delete a document by URI, using normalized key.
+ */
+function deleteDocument(uri) {
+    documents.delete(normalizeUri(uri));
+}
+/**
+ * Safely read a file, returning null if it fails.
+ */
+function readFileSafe(filePath) {
+    try {
+        return fs.readFileSync(filePath, "utf8");
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Return the first path from candidates that exists on disk, or undefined.
+ */
+function findFile(candidates) {
+    for (const p of candidates) {
+        if (fs.existsSync(p)) {
+            return p;
+        }
+    }
+    return undefined;
+}
+let umpleSyncJarPath;
+let umpleSyncHost = "localhost";
+let umpleSyncPort = 5555;
+let umpleSyncTimeoutMs = 50000;
+let jarWarningShown = false;
+let serverProcess;
+let treeSitterWasmPath;
+let symbolIndexReady = false;
+const DEFAULT_UMPLESYNC_TIMEOUT_MS = 50000;
+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;
+    }
+    else if (process.env.UMPLESYNC_TIMEOUT_MS) {
+        const parsed = Number(process.env.UMPLESYNC_TIMEOUT_MS);
+        if (!Number.isNaN(parsed)) {
+            umpleSyncTimeoutMs = parsed;
+        }
+    }
+    else {
+        umpleSyncTimeoutMs = DEFAULT_UMPLESYNC_TIMEOUT_MS;
+    }
+    workspaceRoots = resolveWorkspaceRoots(params);
+    return {
+        capabilities: {
+            textDocumentSync: node_1.TextDocumentSyncKind.Incremental,
+            completionProvider: {
+                resolveProvider: false,
+                triggerCharacters: [" ", "."],
+            },
+            definitionProvider: true,
+        },
+    };
+});
+connection.onInitialized(async () => {
+    connection.console.info("Umple language server initialized.");
+    // Initialize tree-sitter symbol index for fast go-to-definition
+    treeSitterWasmPath =
+        process.env.UMPLE_TREE_SITTER_WASM_PATH ||
+            treeSitterWasmPath ||
+            findFile([
+                path.join(__dirname, "..", "tree-sitter-umple.wasm"), // npm package (wasm copied to server root)
+                path.join(__dirname, "..", "..", "tree-sitter-umple", "tree-sitter-umple.wasm"), // monorepo dev
+            ]);
+    if (treeSitterWasmPath && fs.existsSync(treeSitterWasmPath)) {
+        try {
+            symbolIndexReady = await symbolIndex_1.symbolIndex.initialize(treeSitterWasmPath);
+            if (symbolIndexReady) {
+                connection.console.info("Symbol index initialized with tree-sitter.");
+            }
+        }
+        catch (err) {
+            connection.console.warn(`Failed to initialize symbol index: ${err}`);
+        }
+    }
+    else {
+        connection.console.info(`Tree-sitter WASM not found at ${treeSitterWasmPath ?? "(no path configured)"}, using fallback go-to-definition.`);
+    }
+});
+// Create
+connection.onDidOpenTextDocument((params) => {
+    const document = vscode_languageserver_textdocument_1.TextDocument.create(params.textDocument.uri, params.textDocument.languageId, params.textDocument.version, params.textDocument.text);
+    setDocument(params.textDocument.uri, document);
+    scheduleValidation(document);
+    // Index current file only; imports are indexed on-demand by
+    // ensureImportsIndexed() when completion or go-to-definition is triggered
+    if (symbolIndexReady) {
+        try {
+            const filePath = (0, url_1.fileURLToPath)(params.textDocument.uri);
+            symbolIndex_1.symbolIndex.updateFile(filePath, params.textDocument.text);
+        }
+        catch {
+            // Ignore errors for non-file URIs
+        }
+    }
+});
+/**
+ * Ensure all files reachable via use statements are indexed, and return
+ * the set of reachable file paths (including the current file).
+ * Used by both completion and go-to-definition.
+ */
+function ensureImportsIndexed(docPath, text) {
+    const docDir = path.dirname(docPath);
+    const reachableFiles = collectReachableFiles(docPath, text, docDir);
+    reachableFiles.add(path.normalize(docPath));
+    for (const file of reachableFiles) {
+        // Prefer unsaved content from open editors over saved disk content
+        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);
+        }
+    }
+    return reachableFiles;
+}
+connection.onDidChangeTextDocument((params) => {
+    const document = getDocument(params.textDocument.uri);
+    if (!document) {
+        return;
+    }
+    const updated = vscode_languageserver_textdocument_1.TextDocument.update(document, params.contentChanges, params.textDocument.version);
+    setDocument(params.textDocument.uri, updated);
+    scheduleValidation(updated);
+    // Re-validate other open documents that might depend on this file
+    scheduleDependentValidation(params.textDocument.uri);
+});
+connection.onDidCloseTextDocument((params) => {
+    const normalizedUri = normalizeUri(params.textDocument.uri);
+    deleteDocument(params.textDocument.uri);
+    const pendingValidation = pendingValidations.get(normalizedUri);
+    if (pendingValidation) {
+        clearTimeout(pendingValidation);
+        pendingValidations.delete(normalizedUri);
+    }
+    connection.sendDiagnostics({ uri: params.textDocument.uri, diagnostics: [] });
+});
+connection.onCompletion(async (params) => {
+    const document = getDocument(params.textDocument.uri);
+    if (!document) {
+        return [];
+    }
+    const docPath = getDocumentFilePath(document);
+    // Determine context using dummy identifier trick
+    let context = "unknown";
+    if (docPath && symbolIndexReady) {
+        context = symbolIndex_1.symbolIndex.getCompletionContext(docPath, document.getText(), params.position.line, params.position.character);
+    }
+    // Suppress completions in comments
+    if (context === "comment") {
+        return [];
+    }
+    // Use path completion: offer .ump file names
+    if (context === "use_path") {
+        const prefix = getUsePathPrefix(document, params.position.line, params.position.character);
+        return getUseFileCompletions(document, prefix, params.position.line, params.position.character);
+    }
+    // Ensure imported files are indexed so their symbols appear in completions
+    let reachableFiles;
+    if (docPath && symbolIndexReady) {
+        reachableFiles = ensureImportsIndexed(docPath, document.getText());
+    }
+    // All other contexts: keyword + symbol completions
+    const prefix = getCompletionPrefix(document, params.position.line, params.position.character);
+    return buildCompletionsForContext(context, prefix, reachableFiles);
+});
+connection.onDefinition(async (params) => {
+    const document = getDocument(params.textDocument.uri);
+    if (!document) {
+        return [];
+    }
+    const useLocation = resolveUseDefinitionFromLine(document, params.position);
+    if (useLocation) {
+        return [useLocation];
+    }
+    // Try symbol index, filtered by reachable files
+    if (symbolIndexReady) {
+        const docPath = getDocumentFilePath(document);
+        if (!docPath) {
+            return [];
+        }
+        // Skip if cursor is inside a comment
+        if (symbolIndex_1.symbolIndex.isPositionInComment(docPath, document.getText(), params.position.line, Math.max(0, params.position.character - 1))) {
+            return [];
+        }
+        const word = getWordAtPosition(document, params.position);
+        if (word) {
+            // Ensure imports are indexed and get reachable file set
+            const reachableFiles = ensureImportsIndexed(docPath, document.getText());
+            const allSymbols = symbolIndex_1.symbolIndex.findDefinition(word);
+            // Filter symbols to only those in reachable files
+            const filteredSymbols = allSymbols.filter((sym) => reachableFiles.has(path.normalize(sym.file)));
+            if (filteredSymbols.length > 0) {
+                const results = filteredSymbols.map((sym) => {
+                    const uri = (0, url_1.pathToFileURL)(sym.file).toString();
+                    return node_1.Location.create(uri, node_1.Range.create(node_1.Position.create(sym.line, sym.column), node_1.Position.create(sym.endLine, sym.endColumn)));
+                });
+                return results;
+            }
+        }
+    }
+    // No definition found in symbol index
+    return [];
+});
+function scheduleValidation(document) {
+    const existing = pendingValidations.get(document.uri);
+    if (existing) {
+        clearTimeout(existing);
+    }
+    const handle = setTimeout(() => {
+        pendingValidations.delete(document.uri);
+        void validateTextDocument(document);
+    }, 300);
+    pendingValidations.set(document.uri, handle);
+}
+// Debounce key for dependent validation
+const dependentValidationKey = "__dependent__";
+/**
+ * Schedule re-validation for open documents that actually import the changed file.
+ * Uses a longer debounce time to avoid excessive re-validation.
+ */
+function scheduleDependentValidation(changedUri) {
+    // Clear any existing dependent validation timer
+    const existing = pendingValidations.get(dependentValidationKey);
+    if (existing) {
+        clearTimeout(existing);
+    }
+    const normalizedChangedUri = normalizeUri(changedUri);
+    const handle = setTimeout(() => {
+        pendingValidations.delete(dependentValidationKey);
+        // Get the changed file's basename for matching
+        let changedFilename = null;
+        try {
+            const changedPath = (0, url_1.fileURLToPath)(changedUri);
+            changedFilename = path.basename(changedPath);
+        }
+        catch {
+            return; // Can't process non-file URIs
+        }
+        // Re-validate open documents that import the changed file
+        for (const [uri, doc] of documents) {
+            if (uri === normalizedChangedUri || !uri.endsWith(".ump")) {
+                continue;
+            }
+            // Check if this document imports the changed file
+            if (documentImportsFile(doc, changedFilename)) {
+                scheduleValidation(doc);
+            }
+        }
+    }, 500); // Longer debounce for dependent files
+    pendingValidations.set(dependentValidationKey, handle);
+}
+/**
+ * Check if a document imports a specific file (directly or transitively).
+ */
+function documentImportsFile(document, targetFilename) {
+    const docPath = getDocumentFilePath(document);
+    if (!docPath) {
+        return false;
+    }
+    const docDir = path.dirname(docPath);
+    const reachableFiles = collectReachableFiles(docPath, document.getText(), docDir);
+    // Check if any reachable file matches the target filename
+    for (const filePath of reachableFiles) {
+        if (path.basename(filePath) === targetFilename) {
+            return true;
+        }
+    }
+    return false;
+}
+async function validateTextDocument(document) {
+    const jarPath = resolveJarPath();
+    if (!jarPath) {
+        return;
+    }
+    try {
+        const diagnostics = await runUmpleSyncAndParseDiagnostics(jarPath, document);
+        connection.sendDiagnostics({ uri: document.uri, diagnostics });
+    }
+    catch (error) {
+        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;
+        }
+        return undefined;
+    }
+    if (!fs.existsSync(umpleSyncJarPath)) {
+        if (!jarWarningShown) {
+            connection.window.showWarningMessage(`UmpleSync jar not found at ${umpleSyncJarPath}. Update the path or UMPLESYNC_JAR.`);
+            jarWarningShown = true;
+        }
+        return undefined;
+    }
+    return umpleSyncJarPath;
+}
+async function runUmpleSyncAndParseDiagnostics(jarPath, document) {
+    const docPath = getDocumentFilePath(document);
+    if (!docPath) {
+        return [];
+    }
+    // Create shadow workspace with all unsaved documents
+    const shadow = await createShadowWorkspace(docPath);
+    if (!shadow) {
+        return [];
+    }
+    try {
+        // Write current document to shadow workspace with trailing newlines
+        let text = document.getText();
+        if (!text.endsWith("\n\n")) {
+            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 tempFilename = path.basename(shadow.targetFile);
+        const documentDir = getDocumentDirectory(document);
+        return parseUmpleDiagnostics(stderr, stdout, document, tempFilename, documentDir);
+    }
+    finally {
+        await shadow.cleanup();
+    }
+}
+/**
+ * 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);
+    const documentContent = openDoc?.getText() ?? readFileSafe(documentPath);
+    if (!documentContent) {
+        return null;
+    }
+    // Create shadow directory
+    const shadowDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), "umple-shadow-"));
+    try {
+        // 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));
+        // Create directory structure and symlink/copy files
+        for (const filePath of reachableFiles) {
+            if (!fs.existsSync(filePath))
+                continue;
+            const relativePath = path.relative(documentDir, filePath);
+            const shadowPath = path.join(shadowDir, relativePath);
+            const shadowFileDir = path.dirname(shadowPath);
+            // Create directory structure
+            await fs.promises.mkdir(shadowFileDir, { recursive: true });
+            // Check if this file is open in the editor with unsaved changes
+            const uri = (0, url_1.pathToFileURL)(filePath).toString();
+            const doc = getDocument(uri);
+            if (doc) {
+                // Write unsaved content
+                await fs.promises.writeFile(shadowPath, doc.getText(), "utf8");
+            }
+            else {
+                // Symlink to original file
+                await fs.promises.symlink(filePath, shadowPath);
+            }
+        }
+        const targetFile = path.join(shadowDir, documentName);
+        return {
+            shadowDir,
+            targetFile,
+            cleanup: async () => {
+                await fs.promises.rm(shadowDir, { recursive: true, force: true });
+            },
+        };
+    }
+    catch (error) {
+        // Cleanup on error
+        await fs.promises.rm(shadowDir, { recursive: true, force: true });
+        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"));
+            }
+        });
+        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 };
+}
+/**
+ * Collect all file paths reachable via transitive use statements.
+ * Used to filter go-to-definition results to only show symbols from imported files.
+ */
+function collectReachableFiles(filePath, content, documentDir) {
+    const visited = new Set();
+    collectReachableFilesRecursive(filePath, content, documentDir, visited);
+    return visited;
+}
+/**
+ * Recursively collect reachable file paths.
+ */
+function collectReachableFilesRecursive(filePath, content, documentDir, visited) {
+    const useStatements = symbolIndex_1.symbolIndex.extractUseStatements(filePath, content);
+    for (const usePath of useStatements) {
+        // Resolve the file path
+        let resolvedPath;
+        if (path.isAbsolute(usePath)) {
+            resolvedPath = usePath;
+        }
+        else {
+            resolvedPath = path.resolve(documentDir, usePath);
+        }
+        // Ensure .ump extension
+        if (!resolvedPath.endsWith(".ump")) {
+            resolvedPath += ".ump";
+        }
+        const normalizedPath = path.normalize(resolvedPath);
+        if (visited.has(normalizedPath)) {
+            continue; // Already visited, skip to avoid cycles
+        }
+        visited.add(normalizedPath);
+        // Recursively process this file's use statements
+        if (fs.existsSync(resolvedPath)) {
+            try {
+                const fileContent = fs.readFileSync(resolvedPath, "utf8");
+                const fileDir = path.dirname(resolvedPath);
+                collectReachableFilesRecursive(resolvedPath, fileContent, fileDir, visited);
+            }
+            catch {
+                // Ignore read errors
+            }
+        }
+    }
+}
+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")) {
+        connection.console.info("Umple compile succeeded.");
+    }
+    return jsonDiagnostics;
+}
+/**
+ * Build a map of direct import filename → use statement line number.
+ * Also builds a transitive map: direct filename → set of all transitive filenames.
+ */
+function buildImportMaps(useStatements, documentDir) {
+    const directImports = new Map();
+    const transitiveMap = new Map();
+    for (const useStmt of useStatements) {
+        // Resolve the use path to a filename
+        let resolvedPath = useStmt.path;
+        if (!path.isAbsolute(resolvedPath)) {
+            resolvedPath = path.resolve(documentDir, resolvedPath);
+        }
+        if (!resolvedPath.endsWith(".ump")) {
+            resolvedPath += ".ump";
+        }
+        const filename = path.basename(resolvedPath);
+        // Map direct import filename to line
+        directImports.set(filename, useStmt.line);
+        // Collect transitive imports for this direct import
+        const transitiveFiles = new Set();
+        transitiveFiles.add(filename); // Include the direct import itself
+        collectTransitiveFilenames(resolvedPath, transitiveFiles);
+        transitiveMap.set(filename, transitiveFiles);
+    }
+    return { directImports, transitiveMap };
+}
+/**
+ * Recursively collect all filenames transitively imported by a file.
+ */
+function collectTransitiveFilenames(filePath, collected, visited = new Set()) {
+    const normalizedPath = path.normalize(filePath);
+    if (visited.has(normalizedPath)) {
+        return; // Avoid cycles
+    }
+    visited.add(normalizedPath);
+    if (!fs.existsSync(filePath)) {
+        return;
+    }
+    try {
+        const content = fs.readFileSync(filePath, "utf8");
+        const fileDir = path.dirname(filePath);
+        const useStatements = symbolIndex_1.symbolIndex.extractUseStatements(filePath, content);
+        for (const usePath of useStatements) {
+            let resolvedPath = usePath;
+            if (!path.isAbsolute(resolvedPath)) {
+                resolvedPath = path.resolve(fileDir, resolvedPath);
+            }
+            if (!resolvedPath.endsWith(".ump")) {
+                resolvedPath += ".ump";
+            }
+            const filename = path.basename(resolvedPath);
+            collected.add(filename);
+            collectTransitiveFilenames(resolvedPath, collected, visited);
+        }
+    }
+    catch {
+        // Ignore read errors
+    }
+}
+/**
+ * Find the use statement line for an error from an imported file.
+ * Returns the line number if found, or undefined if the error doesn't match any import.
+ */
+function findUseLineForError(errorFilename, directImports, transitiveMap) {
+    // Check if it's a direct import
+    if (directImports.has(errorFilename)) {
+        return directImports.get(errorFilename);
+    }
+    // Check transitive imports
+    for (const [directFilename, transitiveFiles] of transitiveMap) {
+        if (transitiveFiles.has(errorFilename)) {
+            return directImports.get(directFilename);
+        }
+    }
+    return undefined;
+}
+function parseUmpleJsonDiagnostics(stderr, document, tempFilename, documentDir) {
+    const trimmed = stderr.trim();
+    if (!trimmed) {
+        return [];
+    }
+    const jsonText = extractJson(trimmed);
+    if (!jsonText) {
+        return [];
+    }
+    try {
+        // Sanitize invalid JSON escapes from umplesync (e.g. \' is not valid JSON)
+        const sanitized = jsonText.replace(/\\'/g, "'");
+        const parsed = JSON.parse(sanitized);
+        if (!Array.isArray(parsed.results)) {
+            return [];
+        }
+        const lines = document.getText().split(/\r?\n/);
+        const diagnostics = [];
+        // Build import maps for mapping imported file errors to use statement lines
+        const docPath = getDocumentFilePath(document);
+        let directImports = new Map();
+        let transitiveMap = new Map();
+        if (docPath && documentDir) {
+            const useStatements = symbolIndex_1.symbolIndex.extractUseStatementsWithPositions(docPath, document.getText());
+            const maps = buildImportMaps(useStatements, documentDir);
+            directImports = maps.directImports;
+            transitiveMap = maps.transitiveMap;
+        }
+        for (const result of parsed.results) {
+            const severityValue = Number(result.severity ?? "3");
+            const severity = severityValue > 2
+                ? node_1.DiagnosticSeverity.Warning
+                : node_1.DiagnosticSeverity.Error;
+            // Check if error is from an imported file
+            if (result.filename && result.filename !== tempFilename) {
+                // Find the use statement line for this imported file error
+                const useLine = findUseLineForError(result.filename, directImports, transitiveMap);
+                if (useLine !== undefined) {
+                    const useLineText = lines[useLine] ?? "";
+                    const errorCode = result.errorCode
+                        ? (severity === node_1.DiagnosticSeverity.Warning ? "W" : "E") +
+                            result.errorCode
+                        : "";
+                    const message = errorCode
+                        ? `In imported file (${result.filename}:${result.line}): ${errorCode}: ${result.message}`
+                        : `In imported file (${result.filename}:${result.line}): ${result.message}`;
+                    diagnostics.push({
+                        severity,
+                        range: node_1.Range.create(node_1.Position.create(useLine, 0), node_1.Position.create(useLine, useLineText.length)),
+                        message,
+                        source: "umple",
+                    });
+                }
+                continue;
+            }
+            // Error in current file
+            const lineNumber = Math.max(Number(result.line ?? "1") - 1, 0);
+            const lineText = lines[lineNumber] ?? "";
+            const firstNonSpace = lineText.search(/\S/);
+            const startChar = firstNonSpace === -1 ? 0 : firstNonSpace;
+            const details = [
+                result.errorCode
+                    ? (severity === node_1.DiagnosticSeverity.Warning ? "W" : "E") +
+                        result.errorCode
+                    : undefined,
+                result.message,
+            ].filter(Boolean);
+            diagnostics.push({
+                severity,
+                range: node_1.Range.create(node_1.Position.create(lineNumber, startChar), node_1.Position.create(lineNumber, lineText.length)),
+                message: details.join(": "),
+                source: "umple",
+            });
+        }
+        return diagnostics;
+    }
+    catch {
+        return [];
+    }
+}
+function resolveWorkspaceRoots(params) {
+    const roots = [];
+    if (Array.isArray(params.workspaceFolders)) {
+        for (const folder of params.workspaceFolders) {
+            if (folder.uri.startsWith("file:")) {
+                try {
+                    roots.push(path.resolve((0, url_1.fileURLToPath)(folder.uri)));
+                }
+                catch {
+                    // ignore invalid workspace uri
+                }
+            }
+        }
+    }
+    if (roots.length === 0 &&
+        params.rootUri &&
+        params.rootUri.startsWith("file:")) {
+        try {
+            roots.push(path.resolve((0, url_1.fileURLToPath)(params.rootUri)));
+        }
+        catch {
+            // ignore invalid root uri
+        }
+    }
+    return roots;
+}
+function getDocumentDirectory(document) {
+    const docPath = getDocumentFilePath(document);
+    if (!docPath) {
+        return null;
+    }
+    return path.dirname(docPath);
+}
+function getDocumentFilePath(document) {
+    if (!document.uri.startsWith("file:")) {
+        return null;
+    }
+    try {
+        return (0, url_1.fileURLToPath)(document.uri);
+    }
+    catch {
+        return null;
+    }
+}
+function resolveUseDefinitionFromLine(document, position) {
+    const docPath = getDocumentFilePath(document);
+    if (!docPath) {
+        return null;
+    }
+    // Use tree-sitter to find the use path at this position
+    const usePath = symbolIndex_1.symbolIndex.getUsePathAtPosition(docPath, document.getText(), position.line, Math.max(0, position.character - 1));
+    if (!usePath) {
+        return null;
+    }
+    // Ensure .ump extension
+    let fileRef = usePath;
+    if (!fileRef.endsWith(".ump")) {
+        fileRef += ".ump";
+    }
+    const baseDir = path.dirname(docPath);
+    const targetPath = path.isAbsolute(fileRef)
+        ? fileRef
+        : path.join(baseDir, fileRef);
+    const uri = (0, url_1.pathToFileURL)(targetPath).toString();
+    return node_1.Location.create(uri, node_1.Range.create(node_1.Position.create(0, 0), node_1.Position.create(0, 0)));
+}
+function getCompletionPrefix(document, line, character) {
+    const lineText = document.getText(node_1.Range.create(node_1.Position.create(line, 0), node_1.Position.create(line, character)));
+    const match = lineText.match(/[A-Za-z_][A-Za-z0-9_]*$/);
+    return match ? match[0] : "";
+}
+/**
+ * Get the prefix for use-path completion (allows dots, slashes, underscores).
+ */
+function getUsePathPrefix(document, line, character) {
+    const lineText = document.getText(node_1.Range.create(node_1.Position.create(line, 0), node_1.Position.create(line, character)));
+    const match = lineText.match(/[A-Za-z_][A-Za-z0-9_.\/]*$/);
+    return match ? match[0] : "";
+}
+/**
+ * Get the word (identifier) at the given position.
+ * Used for go-to-definition symbol lookup.
+ */
+function getWordAtPosition(document, position) {
+    const lineText = document.getText(node_1.Range.create(node_1.Position.create(position.line, 0), node_1.Position.create(position.line + 1, 0)));
+    // Find word boundaries around the cursor
+    let start = position.character;
+    let end = position.character;
+    // Expand left to find start of word
+    while (start > 0 && /[A-Za-z0-9_]/.test(lineText[start - 1])) {
+        start--;
+    }
+    // Expand right to find end of word
+    while (end < lineText.length && /[A-Za-z0-9_]/.test(lineText[end])) {
+        end++;
+    }
+    if (start === end) {
+        return null;
+    }
+    const word = lineText.substring(start, end);
+    // Only return valid identifiers (must start with letter or underscore)
+    if (/^[A-Za-z_][A-Za-z0-9_]*$/.test(word)) {
+        return word;
+    }
+    return null;
+}
+function filterCompletions(items, prefix) {
+    if (!prefix) {
+        return items;
+    }
+    const lowerPrefix = prefix.toLowerCase();
+    return items.filter((item) => item.label.toLowerCase().startsWith(lowerPrefix));
+}
+/**
+ * Build completion items for a given tree-sitter based context.
+ * Combines context-specific keywords with symbol-based completions.
+ */
+function buildCompletionsForContext(context, prefix, reachableFiles) {
+    const items = [];
+    const seen = new Set();
+    // Helper: get symbols of a kind, filtered to reachable files
+    const getSymbols = (kind) => {
+        const all = symbolIndex_1.symbolIndex.getSymbolsByKind(kind);
+        if (!reachableFiles)
+            return all;
+        return all.filter((sym) => reachableFiles.has(path.normalize(sym.file)));
+    };
+    // Add context-specific keywords
+    const keywords = keywords_1.COMPLETION_KEYWORDS[context] ?? [];
+    for (const kw of keywords) {
+        if (!seen.has(`kw:${kw}`)) {
+            seen.add(`kw:${kw}`);
+            items.push({ label: kw, kind: node_1.CompletionItemKind.Keyword });
+        }
+    }
+    // Add symbol-based completions depending on context
+    if (symbolIndexReady) {
+        switch (context) {
+            case "top":
+                // No symbol completions at top level
+                break;
+            case "class_body": {
+                // Offer attribute modifiers and types
+                for (const mod of keywords_1.COMPLETION_KEYWORDS.attribute_modifiers) {
+                    if (!seen.has(`kw:${mod}`)) {
+                        seen.add(`kw:${mod}`);
+                        items.push({ label: mod, kind: node_1.CompletionItemKind.Keyword });
+                    }
+                }
+                for (const typ of keywords_1.COMPLETION_KEYWORDS.attribute_types) {
+                    if (!seen.has(`type:${typ}`)) {
+                        seen.add(`type:${typ}`);
+                        items.push({
+                            label: typ,
+                            kind: node_1.CompletionItemKind.TypeParameter,
+                            detail: "type",
+                        });
+                    }
+                }
+                // Offer class/interface/trait names (for isA, type references)
+                for (const sym of getSymbols("class")) {
+                    if (!seen.has(`sym:${sym.name}`)) {
+                        seen.add(`sym:${sym.name}`);
+                        items.push({
+                            label: sym.name,
+                            kind: node_1.CompletionItemKind.Class,
+                            detail: "class",
+                        });
+                    }
+                }
+                for (const sym of getSymbols("interface")) {
+                    if (!seen.has(`sym:${sym.name}`)) {
+                        seen.add(`sym:${sym.name}`);
+                        items.push({
+                            label: sym.name,
+                            kind: node_1.CompletionItemKind.Interface,
+                            detail: "interface",
+                        });
+                    }
+                }
+                for (const sym of getSymbols("trait")) {
+                    if (!seen.has(`sym:${sym.name}`)) {
+                        seen.add(`sym:${sym.name}`);
+                        items.push({
+                            label: sym.name,
+                            kind: node_1.CompletionItemKind.Class,
+                            detail: "trait",
+                        });
+                    }
+                }
+                break;
+            }
+            case "isa_type": {
+                // After "isA" keyword: only offer class/interface/trait names
+                for (const sym of getSymbols("class")) {
+                    if (!seen.has(`sym:${sym.name}`)) {
+                        seen.add(`sym:${sym.name}`);
+                        items.push({
+                            label: sym.name,
+                            kind: node_1.CompletionItemKind.Class,
+                            detail: "class",
+                        });
+                    }
+                }
+                for (const sym of getSymbols("interface")) {
+                    if (!seen.has(`sym:${sym.name}`)) {
+                        seen.add(`sym:${sym.name}`);
+                        items.push({
+                            label: sym.name,
+                            kind: node_1.CompletionItemKind.Interface,
+                            detail: "interface",
+                        });
+                    }
+                }
+                for (const sym of getSymbols("trait")) {
+                    if (!seen.has(`sym:${sym.name}`)) {
+                        seen.add(`sym:${sym.name}`);
+                        items.push({
+                            label: sym.name,
+                            kind: node_1.CompletionItemKind.Class,
+                            detail: "trait",
+                        });
+                    }
+                }
+                break;
+            }
+            case "transition_target": {
+                // After "->" in state: only offer state names
+                for (const sym of getSymbols("state")) {
+                    if (!seen.has(`sym:${sym.name}`)) {
+                        seen.add(`sym:${sym.name}`);
+                        items.push({
+                            label: sym.name,
+                            kind: node_1.CompletionItemKind.EnumMember,
+                            detail: "state",
+                        });
+                    }
+                }
+                break;
+            }
+            case "association_type": {
+                // Type position in association: only offer class names
+                for (const sym of getSymbols("class")) {
+                    if (!seen.has(`sym:${sym.name}`)) {
+                        seen.add(`sym:${sym.name}`);
+                        items.push({
+                            label: sym.name,
+                            kind: node_1.CompletionItemKind.Class,
+                            detail: "class",
+                        });
+                    }
+                }
+                break;
+            }
+            case "state_machine":
+            case "state": {
+                // Offer state names from the index
+                for (const sym of getSymbols("state")) {
+                    if (!seen.has(`sym:${sym.name}`)) {
+                        seen.add(`sym:${sym.name}`);
+                        items.push({
+                            label: sym.name,
+                            kind: node_1.CompletionItemKind.EnumMember,
+                            detail: "state",
+                        });
+                    }
+                }
+                break;
+            }
+            case "association": {
+                // Offer class names for association endpoints
+                for (const sym of getSymbols("class")) {
+                    if (!seen.has(`sym:${sym.name}`)) {
+                        seen.add(`sym:${sym.name}`);
+                        items.push({
+                            label: sym.name,
+                            kind: node_1.CompletionItemKind.Class,
+                            detail: "class",
+                        });
+                    }
+                }
+                break;
+            }
+            // depend_package, enum, method, comment, unknown: no additional symbol completions
+        }
+    }
+    return filterCompletions(items, prefix);
+}
+function getUseFileCompletions(document, prefix, line, character) {
+    const docDir = getDocumentDirectory(document);
+    if (!docDir) {
+        return [];
+    }
+    const docBasename = path.basename(getDocumentFilePath(document) ?? "");
+    let files;
+    try {
+        files = fs
+            .readdirSync(docDir)
+            .filter((f) => f.endsWith(".ump") && f !== docBasename);
+    }
+    catch {
+        return [];
+    }
+    // Replace range covers the entire prefix the user has typed
+    const replaceRange = node_1.Range.create(node_1.Position.create(line, character - prefix.length), node_1.Position.create(line, character));
+    const lowerPrefix = prefix.toLowerCase();
+    return files
+        .filter((f) => f.toLowerCase().startsWith(lowerPrefix))
+        .map((f) => ({
+        label: f,
+        kind: node_1.CompletionItemKind.File,
+        detail: "Umple file",
+        textEdit: { range: replaceRange, newText: f },
+    }));
+}
+function extractJson(text) {
+    const start = text.indexOf("{");
+    const end = text.lastIndexOf("}");
+    if (start === -1 || end === -1 || end <= start) {
+        return null;
+    }
+    return text.slice(start, end + 1);
+}
+function formatUmpleArg(filePath) {
+    return JSON.stringify(filePath);
+}
+connection.listen();
+//# sourceMappingURL=server.js.map