@oml/language 0.12.0 → 0.14.0

package/src/oml/oml-document.ts

@@ -5,6 +5,7 @@ import { DefaultDocumentUpdateHandler } from 'langium/lsp';
 import type { LangiumSharedServices } from 'langium/lsp';
 import { FileChangeType, type DidChangeWatchedFilesParams } from 'vscode-languageserver';
 import { getOntologyModelIndex } from './oml-index.js';
+import { isIgnoredByOmlLsDocumentUri } from './oml-utils.js';
 
 export class OmlDocumentUpdateHandler extends DefaultDocumentUpdateHandler {
     private readonly services: LangiumSharedServices;
@@ -16,7 +17,18 @@ export class OmlDocumentUpdateHandler extends DefaultDocumentUpdateHandler {
 
     override didChangeWatchedFiles(params: DidChangeWatchedFilesParams): void {
         this.cleanDeletedOntologyDocuments(params);
-        super.didChangeWatchedFiles(params);
+        const filtered = params.changes.filter((change) => !isIgnoredByOmlLsDocumentUri(change.uri));
+        if (filtered.length === 0) {
+            return;
+        }
+        super.didChangeWatchedFiles({ changes: filtered });
+    }
+
+    override didChangeContent(change: { document: { uri: string } }): void {
+        if (isIgnoredByOmlLsDocumentUri(change.document.uri)) {
+            return;
+        }
+        super.didChangeContent(change as any);
     }
 
     private cleanDeletedOntologyDocuments(params: DidChangeWatchedFilesParams): void {

package/src/oml/oml-index.ts

@@ -3,7 +3,7 @@
 import { DocumentState, URI, type LangiumDocument } from 'langium';
 import type { LangiumSharedServices } from 'langium/lsp';
 import { isAspect, isConcept, isConceptInstance, isDescription, isOntology, isRelationEntity, isRelationInstance, isScalar } from './generated/ast.js';
-import { collectOntologyMembers, getIriForNode, isTransientEditorDocumentUri } from './oml-utils.js';
+import { collectOntologyMembers, getIriForNode } from './oml-utils.js';
 
 const OML_LABEL_IRI = 'http://opencaesar.io/oml#label';
 
@@ -39,18 +39,99 @@ export class OmlIndex {
         });
     }
 
-    resolveModelUri(identifier: string): string | undefined {
+    resolveModelUri(identifier: string, referencingDocumentUri?: string): string | undefined {
         this.ensureIndexedFromLoadedDocuments();
         const normalized = this.normalizeNamespace(identifier);
         if (!normalized) {
             return undefined;
         }
         const ontologyIri = this.ontologyIriFromNamespace(normalized);
-        const candidates = this.workspaceModelUrisByOntologyIri.get(ontologyIri);
-        if (!candidates || candidates.size !== 1) {
+        const indexedCandidates = this.workspaceModelUrisByOntologyIri.get(ontologyIri);
+        if (!indexedCandidates || indexedCandidates.size === 0) {
             return undefined;
         }
-        return [...candidates][0];
+        const candidates = new Set<string>(indexedCandidates);
+        let reference: URI | undefined;
+        if (referencingDocumentUri) {
+            try {
+                reference = URI.parse(referencingDocumentUri);
+            } catch {
+                reference = undefined;
+            }
+            if (reference && candidates.size > 0) {
+                for (const candidate of [...candidates]) {
+                    const synthesized = this.synthesizeCandidateForReferencingScheme(candidate, reference);
+                    if (synthesized) {
+                        candidates.add(synthesized);
+                    }
+                }
+            }
+        }
+        const candidateModelUris = [...candidates].sort();
+        if (candidateModelUris.length === 1) {
+            return candidateModelUris[0];
+        }
+        if (!referencingDocumentUri) {
+            return undefined;
+        }
+        if (!reference) {
+            return undefined;
+        }
+        const sameSchemeCandidates = candidateModelUris.filter((candidate) => {
+            try {
+                return URI.parse(candidate).scheme === reference.scheme;
+            } catch {
+                return false;
+            }
+        });
+        if (sameSchemeCandidates.length === 1) {
+            return sameSchemeCandidates[0];
+        }
+        return undefined;
+    }
+
+    private synthesizeCandidateForReferencingScheme(candidateModelUri: string, reference: URI): string | undefined {
+        let candidate: URI;
+        try {
+            candidate = URI.parse(candidateModelUri);
+        } catch {
+            return undefined;
+        }
+        if (candidate.scheme === reference.scheme) {
+            return undefined;
+        }
+        if (reference.scheme !== 'git' || candidate.scheme !== 'file') {
+            return undefined;
+        }
+        const refQuery = reference.query?.trim();
+        if (!refQuery) {
+            return undefined;
+        }
+        let parsedQuery: any;
+        try {
+            parsedQuery = JSON.parse(refQuery);
+        } catch {
+            return undefined;
+        }
+        if (typeof parsedQuery !== 'object' || parsedQuery === null) {
+            return undefined;
+        }
+        const ref = typeof parsedQuery.ref === 'string' ? parsedQuery.ref : undefined;
+        if (!ref) {
+            return undefined;
+        }
+        const gitQuery = JSON.stringify({
+            ...parsedQuery,
+            path: candidate.path,
+            ref,
+        });
+        return URI.from({
+            scheme: 'git',
+            authority: candidate.authority,
+            path: candidate.path,
+            query: gitQuery,
+            fragment: undefined,
+        }).toString();
     }
 
     resolveOntologyIri(modelUri: string): string | undefined {
@@ -156,9 +237,6 @@ export class OmlIndex {
         if (!namespace) {
             return;
         }
-        if (isTransientEditorDocumentUri(modelUri)) {
-            return;
-        }
         const modelUris = this.workspaceModelUrisByOntologyIri.get(ontologyIri) ?? new Set<string>();
         modelUris.add(modelUri);
         this.workspaceModelUrisByOntologyIri.set(ontologyIri, modelUris);
@@ -171,7 +249,7 @@ export class OmlIndex {
         this.removeTypesForModelUri(modelUri);
         this.removeTypeHierarchyForModelUri(modelUri);
         const root = document.parseResult?.value;
-        if (!isOntology(root) || isTransientEditorDocumentUri(modelUri)) {
+        if (!isOntology(root)) {
             return;
         }
 

package/src/oml/oml-scope.ts

@@ -208,22 +208,23 @@ export class OmlScopeProvider extends DefaultScopeProvider {
         };
     }
 
-    private findOntologyByNamespace(normalizedNamespace: string): WorkspaceOntology | undefined {
+    private findOntologyByNamespace(normalizedNamespace: string, referencingDocumentUri?: string): WorkspaceOntology | undefined {
         const index = getOntologyModelIndex(this.services.shared as LangiumSharedServices);
-        const modelUri = index.resolveModelUri(normalizedNamespace);
+        const modelUri = index.resolveModelUri(normalizedNamespace, referencingDocumentUri);
         return modelUri ? this.resolveOntologyDocument(modelUri) : undefined;
     }
 
     private resolveImports(ontology: Ontology): ResolvedImport[] {
         const imports = ((ontology as any).ownedImports ?? []) as Import[];
         const resolved: ResolvedImport[] = [];
+        const referencingDocumentUri = ontology.$document?.uri?.toString?.();
         for (const imp of imports) {
             const ns = this.getImportNamespace(imp);
             const normalized = normalizeNamespace(ns);
             if (!normalized) {
                 continue;
             }
-            const target = this.findOntologyByNamespace(normalized);
+            const target = this.findOntologyByNamespace(normalized, referencingDocumentUri);
             if (!target) {
                 continue;
             }

package/src/oml/oml-search.ts

@@ -0,0 +1,132 @@
+// Copyright (c) 2026 Modelware. All rights reserved.
+
+export interface OmlFuzzyIndexedEntry {
+    iri: string;
+    label?: string;
+    fragment: string;
+    fragmentTokens: string[];
+    labelTokens: string[];
+}
+
+export interface OmlFuzzyDiagnostics {
+    fragment: string;
+    label: string;
+    exactFragment: boolean;
+    exactLabel: boolean;
+    containsInputInFragment: boolean;
+    containsInputInLabel: boolean;
+    regexMatchFragment: boolean;
+    regexMatchLabel: boolean;
+    fragmentTokenHits: number;
+    labelTokenHits: number;
+}
+
+export function iriFragment(iri: string): string {
+    return iri.split(/[#/]/).pop() ?? '';
+}
+
+export function tokenizeForFuzzy(text: string): string[] {
+    return splitCamelCase(text)
+        .toLowerCase()
+        .split(/[^a-z0-9]+/g)
+        .map((token) => token.trim())
+        .filter((token) => token.length > 0);
+}
+
+export function buildSearchRegex(text: string, regexSource: string, useRegex: boolean): RegExp | undefined {
+    const source = useRegex ? regexSource : '';
+    if (!source) {
+        return undefined;
+    }
+    try {
+        return new RegExp(source, 'i');
+    } catch {
+        return new RegExp(escapeRegExp(text), 'i');
+    }
+}
+
+export function fuzzyDiagnostics(
+    input: string,
+    tokens: string[],
+    entry: OmlFuzzyIndexedEntry,
+    regex: RegExp | undefined,
+): OmlFuzzyDiagnostics {
+    const fragment = entry.fragment.toLowerCase();
+    const lowerLabel = (entry.label ?? '').toLowerCase();
+    const lowerInput = input.toLowerCase();
+    const exactFragment = fragment === lowerInput;
+    const exactLabel = lowerLabel === lowerInput;
+    const containsInputInFragment = fragment.includes(lowerInput);
+    const containsInputInLabel = lowerLabel.includes(lowerInput);
+    const regexMatchFragment = regex ? regex.test(entry.fragment) : false;
+    const regexMatchLabel = regex ? regex.test(entry.label ?? '') : false;
+    const fragmentTokenSet = new Set(entry.fragmentTokens);
+    const labelTokenSet = new Set(entry.labelTokens);
+    let fragmentTokenHits = 0;
+    let labelTokenHits = 0;
+    for (const token of tokens) {
+        if (fragmentTokenSet.has(token)) {
+            fragmentTokenHits += 1;
+        }
+        if (labelTokenSet.has(token)) {
+            labelTokenHits += 1;
+        }
+    }
+    return {
+        fragment,
+        label: lowerLabel,
+        exactFragment,
+        exactLabel,
+        containsInputInFragment,
+        containsInputInLabel,
+        regexMatchFragment,
+        regexMatchLabel,
+        fragmentTokenHits,
+        labelTokenHits,
+    };
+}
+
+export function fuzzyScore(
+    diagnostics: OmlFuzzyDiagnostics,
+    queryTokens: string[],
+    fragmentTokens: string[],
+    labelTokens: string[],
+    usedRegex: boolean,
+): number {
+    const fragmentSet = new Set(fragmentTokens);
+    const labelSet = new Set(labelTokens);
+    let uniqueTokenHits = 0;
+    for (const token of queryTokens) {
+        if (fragmentSet.has(token) || labelSet.has(token)) {
+            uniqueTokenHits += 1;
+        }
+    }
+    const allTokensMatchedInFragment = queryTokens.length > 0 && queryTokens.every((token) => fragmentSet.has(token));
+    let score = 0;
+    if (diagnostics.exactFragment || diagnostics.exactLabel) {
+        score += 200;
+    }
+    if (diagnostics.containsInputInFragment || diagnostics.containsInputInLabel) {
+        score += 80;
+    }
+    if (usedRegex && (diagnostics.regexMatchFragment || diagnostics.regexMatchLabel)) {
+        score += diagnostics.regexMatchFragment ? 120 : 70;
+    }
+    if (allTokensMatchedInFragment && diagnostics.fragmentTokenHits >= 2) {
+        score += 80;
+    }
+    score += uniqueTokenHits * 60;
+    score += diagnostics.fragmentTokenHits * 20;
+    score += diagnostics.labelTokenHits * 10;
+    return score;
+}
+
+function splitCamelCase(value: string): string {
+    return value
+        .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
+        .replace(/([A-Z]+)([A-Z][a-z])/g, '$1 $2');
+}
+
+function escapeRegExp(value: string): string {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}