umple-lsp-server 0.1.1 → 0.2.1

package/out/server.js

@@ -113,7 +113,7 @@ connection.onInitialize((params) => {
             textDocumentSync: node_1.TextDocumentSyncKind.Incremental,
             completionProvider: {
                 resolveProvider: false,
-                triggerCharacters: [" ", "."],
+                triggerCharacters: ["/"],
             },
             definitionProvider: true,
         },
@@ -210,65 +210,193 @@ connection.onCompletion(async (params) => {
         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);
+    if (!docPath || !symbolIndexReady) {
+        return [];
+    }
+    const text = document.getText();
+    const { line, character } = params.position;
+    // 1. Get completion info from LookaheadIterator + scope query
+    const info = symbolIndex_1.symbolIndex.getCompletionInfo(text, line, character);
+    // 2. Suppress completions
+    if (info.isComment || info.isDefinitionName) {
+        return [];
+    }
+    if (info.symbolKinds === "suppress") {
+        return [];
+    }
+    // 3. Ensure imported files are indexed
+    const reachableFiles = ensureImportsIndexed(docPath, text);
+    const items = [];
+    const seen = new Set();
+    // 4. Normalize symbolKinds: use_path → file completions + mixset symbols
+    //    "/" trigger outside use_path is suppressed
+    let symbolKinds = info.symbolKinds;
+    if (symbolKinds === "use_path") {
+        for (const item of getUseFileCompletions(document, info.prefix, line, character)) {
+            seen.add(item.label);
+            items.push(item);
+        }
+        // Path prefix (contains /) → only file completions, no keywords/mixsets
+        if (info.prefix.includes("/")) {
+            return items;
+        }
+        symbolKinds = ["mixset"];
     }
-    // Suppress completions in comments
-    if (context === "comment") {
+    else if (params.context?.triggerCharacter === "/") {
         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);
+    // 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",
+                });
+            }
+        }
     }
-    // Ensure imported files are indexed so their symbols appear in completions
-    let reachableFiles;
-    if (docPath && symbolIndexReady) {
-        reachableFiles = ensureImportsIndexed(docPath, document.getText());
+    // 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;
     }
-    // All other contexts: keyword + symbol completions
-    const prefix = getCompletionPrefix(document, params.position.line, params.position.character);
-    return buildCompletionsForContext(context, prefix, reachableFiles);
+    // 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,
+                    });
+                }
+            }
+        }
+    }
+    return items;
 });
 connection.onDefinition(async (params) => {
     const document = getDocument(params.textDocument.uri);
     if (!document) {
         return [];
     }
-    const useLocation = resolveUseDefinitionFromLine(document, params.position);
-    if (useLocation) {
-        return [useLocation];
+    if (!symbolIndexReady) {
+        return [];
     }
-    // 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))) {
+    const docPath = getDocumentFilePath(document);
+    if (!docPath) {
+        return [];
+    }
+    const token = symbolIndex_1.symbolIndex.getTokenAtPosition(docPath, document.getText(), params.position.line, params.position.character);
+    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)) {
             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;
-            }
-        }
+        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 reachableFiles = ensureImportsIndexed(docPath, document.getText());
+    // For container-scoped kinds, try scoped lookup first (with inheritance), then global fallback
+    const containerKinds = new Set([
+        "attribute",
+        "method",
+        "template",
+        "state",
+    ]);
+    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))));
     }
-    // No definition found in symbol index
     return [];
 });
 function scheduleValidation(document) {
@@ -579,6 +707,10 @@ function collectReachableFiles(filePath, content, documentDir) {
 function collectReachableFilesRecursive(filePath, content, documentDir, visited) {
     const useStatements = symbolIndex_1.symbolIndex.extractUseStatements(filePath, content);
     for (const usePath of useStatements) {
+        // Skip mixset names (no .ump extension = not a file reference)
+        if (!usePath.endsWith(".ump")) {
+            continue;
+        }
         // Resolve the file path
         let resolvedPath;
         if (path.isAbsolute(usePath)) {
@@ -587,10 +719,6 @@ function collectReachableFilesRecursive(filePath, content, documentDir, visited)
         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
@@ -638,14 +766,15 @@ function buildImportMaps(useStatements, documentDir) {
     const directImports = new Map();
     const transitiveMap = new Map();
     for (const useStmt of useStatements) {
+        // Skip mixset names (no .ump extension = not a file reference)
+        if (!useStmt.path.endsWith(".ump")) {
+            continue;
+        }
         // 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);
@@ -674,13 +803,14 @@ function collectTransitiveFilenames(filePath, collected, visited = new Set()) {
         const fileDir = path.dirname(filePath);
         const useStatements = symbolIndex_1.symbolIndex.extractUseStatements(filePath, content);
         for (const usePath of useStatements) {
+            // Skip mixset names (no .ump extension = not a file reference)
+            if (!usePath.endsWith(".ump")) {
+                continue;
+            }
             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);
@@ -831,276 +961,101 @@ function getDocumentFilePath(document) {
         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.
+ * Map a SymbolKind to the appropriate LSP CompletionItemKind.
  */
-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;
+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;
     }
-    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;
+    // Split prefix into directory part and filename filter
+    const lastSlash = prefix.lastIndexOf("/");
+    const dirPart = lastSlash >= 0 ? prefix.substring(0, lastSlash + 1) : "";
+    const filePart = lastSlash >= 0 ? prefix.substring(lastSlash + 1) : prefix;
+    // Resolve target directory
+    const targetDir = path.resolve(docDir, dirPart);
+    let entries;
     try {
-        files = fs
-            .readdirSync(docDir)
-            .filter((f) => f.endsWith(".ump") && f !== docBasename);
+        entries = fs.readdirSync(targetDir, { withFileTypes: true });
     }
     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 },
-    }));
+    const docBasename = path.basename(getDocumentFilePath(document) ?? "");
+    const isSameDir = path.normalize(targetDir) === path.normalize(docDir);
+    const lowerFilter = filePart.toLowerCase();
+    // Replace range covers only the filePart (after the last '/').
+    // The dirPart is already in the document and stays untouched.
+    // This ensures VS Code filters items against the filePart, not the full prefix.
+    const replaceRange = node_1.Range.create(node_1.Position.create(line, character - filePart.length), node_1.Position.create(line, character));
+    const items = [];
+    for (const entry of entries) {
+        const name = entry.name;
+        // Skip hidden files/dirs
+        if (name.startsWith("."))
+            continue;
+        if (entry.isDirectory()) {
+            const label = name + "/";
+            if (!label.toLowerCase().startsWith(lowerFilter))
+                continue;
+            items.push({
+                label,
+                kind: node_1.CompletionItemKind.Folder,
+                detail: "Directory",
+                textEdit: { range: replaceRange, newText: label },
+                // Re-trigger completions after inserting folder name
+                command: {
+                    title: "Continue completion",
+                    command: "editor.action.triggerSuggest",
+                },
+            });
+        }
+        else if (name.endsWith(".ump")) {
+            // Skip current file if listing the same directory
+            if (isSameDir && name === docBasename)
+                continue;
+            if (!name.toLowerCase().startsWith(lowerFilter))
+                continue;
+            items.push({
+                label: name,
+                kind: node_1.CompletionItemKind.File,
+                detail: "Umple file",
+                textEdit: { range: replaceRange, newText: name },
+            });
+        }
+    }
+    return items;
 }
 function extractJson(text) {
     const start = text.indexOf("{");