@oml/server 0.14.0

package/src/lsp/language-server.ts

@@ -0,0 +1,423 @@
+// Copyright (c) 2026 Modelware. All rights reserved.
+
+import { DocumentState, URI } from 'langium';
+import { startLanguageServer } from 'langium/lsp';
+import type { DefaultSharedModuleContext } from 'langium/lsp';
+import type { Connection } from 'vscode-languageserver';
+import {
+    collectOntologyMembers,
+    getIriForNode,
+    getOntologyModelIndex,
+    iriFragment,
+    isDescription,
+    isOntology,
+    type OmlFuzzyIndexedEntry,
+    isVocabulary,
+    registerOmlCandidatesRequests,
+    registerOmlEditRequests,
+    tokenizeForFuzzy,
+} from '@oml/language';
+import { createOwlServices, detectSparqlKind, registerShaclValidationRequests } from '@oml/owl';
+import uFuzzy from '@leeoniya/ufuzzy';
+import {
+    MarkdownExecutionRequest,
+    MarkdownExecutor,
+    type MdExecuteBlocksParams,
+    type MdExecuteBlocksResult
+} from '@oml/markdown';
+import { registerDiagramRequests } from './diagram-server.js';
+import {
+    ReasoningNotifications,
+    ReasoningRequests,
+    type ActiveDocumentParams,
+    type FuzzySearchParams,
+    type FuzzySearchResult,
+    type ResolveModelUriParams,
+    type ResolveModelUriResult,
+    type SemanticChangedParams,
+    type SparqlQueryParams,
+    type SparqlQueryResult,
+    type SparqlTermDto,
+} from './protocol/reasoner-protocol.js';
+
+export interface OmlLanguageServerStartOptions {
+    fileSystem: Omit<DefaultSharedModuleContext, 'connection'>;
+    registerDiagramHandlers?: boolean;
+    suppressTransientDiagnostics?: boolean;
+    installNodeProcessHandlers?: boolean;
+}
+
+export interface OmlLanguageServerRuntime {
+    shared: any;
+    Oml: any;
+}
+
+const workspacePreloadState = new WeakMap<object, { completed: boolean; promise?: Promise<void> }>();
+
+function formatError(error: unknown, depth = 0): string {
+    if (!(error instanceof Error)) {
+        return String(error);
+    }
+
+    const indent = depth > 0 ? '\n' + '  '.repeat(depth) : '';
+    const stack = error.stack ? `${indent}${error.stack}` : `${indent}${error.message}`;
+    const cause = (error as any).cause;
+    if (cause === undefined) {
+        return stack;
+    }
+    return `${stack}\n${'  '.repeat(depth)}cause: ${formatError(cause, depth + 1)}`;
+}
+
+export function startOmlLanguageServer(connection: Connection, options: OmlLanguageServerStartOptions): OmlLanguageServerRuntime {
+    const logServerError = (scope: string, error: unknown): void => {
+        connection.console.error(`[oml] ${scope}: ${formatError(error)}`);
+    };
+
+    if (options.installNodeProcessHandlers) {
+        process.on('unhandledRejection', (reason) => {
+            logServerError('Unhandled rejection', reason);
+        });
+        process.on('uncaughtException', (error) => {
+            logServerError('Uncaught exception', error);
+        });
+    }
+
+    const sendDiagnostics = connection.sendDiagnostics.bind(connection);
+    connection.sendDiagnostics = ((params: any): Promise<void> => {
+        if (!params?.uri) {
+            return sendDiagnostics(params);
+        }
+        if (options.suppressTransientDiagnostics !== false && isTransientDiagnosticsUri(params.uri)) {
+            return sendDiagnostics({ ...params, diagnostics: [] });
+        }
+        return sendDiagnostics(params);
+    }) as any;
+
+    const { shared, Oml } = createOwlServices({ connection, ...options.fileSystem });
+
+    if (options.registerDiagramHandlers !== false) {
+        registerDiagramRequests(connection as any, shared, Oml);
+    }
+    registerOmlCandidatesRequests(connection as any, shared);
+    registerOmlEditRequests(connection as any, shared);
+    registerShaclValidationRequests(connection as any, Oml);
+
+    {
+        const reasoningService = Oml.reasoning.ReasoningService as any;
+        reasoningService.onSemanticChanged((modelUris: string[]) => {
+            const params: SemanticChangedParams = { modelUris };
+            connection.sendNotification(ReasoningNotifications.semanticChanged, params);
+        });
+    }
+    connection.onNotification(ReasoningNotifications.markDocumentActive, ({ modelUri }: ActiveDocumentParams) => {
+        const reasoningService = Oml.reasoning.ReasoningService as any;
+        reasoningService.markDocumentActive(modelUri);
+    });
+    connection.onNotification(ReasoningNotifications.markDocumentInactive, ({ modelUri }: ActiveDocumentParams) => {
+        const reasoningService = Oml.reasoning.ReasoningService as any;
+        reasoningService.markDocumentInactive(modelUri);
+    });
+    connection.onRequest(MarkdownExecutionRequest, async (params: MdExecuteBlocksParams): Promise<MdExecuteBlocksResult> => {
+        try {
+            const reasoningService = Oml.reasoning.ReasoningService as any;
+            const ontologyIndex = getOntologyModelIndex(shared as any);
+            const knownNamespaceCache = new Map<string, boolean>();
+            const isKnownOntologyIriNamespace = (ontologyIri: string): boolean => {
+                const normalized = ontologyIri.trim().replace(/[\/#]+$/, '');
+                if (!normalized) {
+                    return false;
+                }
+                const cached = knownNamespaceCache.get(normalized);
+                if (cached !== undefined) {
+                    return cached;
+                }
+                if (ontologyIndex.resolveModelUri(normalized)) {
+                    knownNamespaceCache.set(normalized, true);
+                    return true;
+                }
+                const exists = ontologyIndex.getDuplicateWorkspaceModelUris(normalized).length > 0;
+                knownNamespaceCache.set(normalized, exists);
+                return exists;
+            };
+            const executor = new MarkdownExecutor({
+                ensureContext: (modelUri) => reasoningService.ensureQueryContext(modelUri),
+                resolveContextIri: (modelUri) => reasoningService.getContextIri(modelUri),
+                countContextQuads: (modelUri) => reasoningService.countContextDatasetQuads(modelUri),
+                query: (modelUri, sparql) => reasoningService.getSparqlService().query(modelUri, sparql),
+                construct: (modelUri, sparql) => reasoningService.getSparqlService().construct(modelUri, sparql),
+                isKnownOntologyIriNamespace,
+            });
+            return await executor.executeBlocks(params);
+        } catch (error) {
+            logServerError('MarkdownExecutionRequest failed', error);
+            return {
+                results: params.blocks.map((block) => ({
+                    blockId: block.id,
+                    kind: block.kind,
+                    status: 'error',
+                    format: 'message',
+                    message: error instanceof Error ? error.message : String(error),
+                })),
+            };
+        }
+    });
+    connection.onRequest(ReasoningRequests.sparqlQuery, async (params: SparqlQueryParams): Promise<SparqlQueryResult> => {
+        try {
+            const reasoningService = Oml.reasoning.ReasoningService as any;
+            const kind = detectSparqlKind(params.sparql);
+            await reasoningService.ensureQueryContext(params.modelUri);
+            const sparqlService = reasoningService.getSparqlService();
+            if (kind === 'select') {
+                const result = await sparqlService.query(params.modelUri, params.sparql);
+                return {
+                    success: result.success,
+                    kind,
+                    warnings: result.warnings ?? [],
+                    rows: result.rows.map((row: Map<string, any>) => toRowDto(row)),
+                    error: result.error,
+                };
+            }
+            if (kind === 'ask') {
+                const result = await sparqlService.ask(params.modelUri, params.sparql);
+                return {
+                    success: result.success,
+                    kind,
+                    warnings: result.warnings ?? [],
+                    result: result.result,
+                    error: result.error,
+                };
+            }
+            if (kind === 'construct' || kind === 'describe') {
+                const result = await sparqlService.construct(params.modelUri, params.sparql);
+                return {
+                    success: result.success,
+                    kind,
+                    warnings: result.warnings ?? [],
+                    quads: result.quads.map((quad: any) => ({
+                        subject: quad.subject.value,
+                        predicate: quad.predicate.value,
+                        object: quad.object.value,
+                        graph: quad.graph.value,
+                    })),
+                    error: result.error,
+                };
+            }
+            return {
+                success: false,
+                kind: 'unknown',
+                warnings: [],
+                error: 'Unsupported or unknown SPARQL query kind.',
+            };
+        } catch (error) {
+            logServerError('oml/query failed', error);
+            return {
+                success: false,
+                kind: detectSparqlKind(params.sparql),
+                warnings: [],
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    });
+
+    connection.onRequest(ReasoningRequests.fuzzySearch, async (params: FuzzySearchParams): Promise<FuzzySearchResult> => {
+        try {
+            const text = (params.text ?? '').trim();
+            if (!text) {
+                return { success: true, candidates: [] };
+            }
+            const limit = Math.max(1, Math.min(50, params.limit ?? 12));
+            const ontologyIndex = getOntologyModelIndex(shared as any);
+            const langiumDocuments: any = shared.workspace.LangiumDocuments;
+            const allDocs = langiumDocuments.all ?? [];
+            const iterable: any[] = Array.isArray(allDocs)
+                ? allDocs
+                : (typeof allDocs?.toArray === 'function' ? allDocs.toArray() : Array.from(allDocs as Iterable<any>));
+            const modelUris: string[] = [];
+            const candidateByIri = new Map<string, { iri: string; label?: string }>();
+            for (const doc of iterable) {
+                const root = doc?.parseResult?.value;
+                if (!root || !isOntology(root) || (!isVocabulary(root) && !isDescription(root))) {
+                    continue;
+                }
+                modelUris.push(doc.uri.toString());
+                for (const member of collectOntologyMembers(root)) {
+                    const iri = getIriForNode(member);
+                    if (!iri) {
+                        continue;
+                    }
+                    candidateByIri.set(iri, { iri });
+                }
+            }
+            const labelSnapshot = ontologyIndex.getMemberLabelSnapshot(modelUris);
+            for (const [iri, label] of Object.entries(labelSnapshot)) {
+                const entry = candidateByIri.get(iri) ?? { iri };
+                entry.label = label;
+                candidateByIri.set(iri, entry);
+            }
+
+            const indexedEntries: OmlFuzzyIndexedEntry[] = [...candidateByIri.values()].map((entry) => ({
+                iri: entry.iri,
+                label: entry.label,
+                fragment: iriFragment(entry.iri),
+                fragmentTokens: tokenizeForFuzzy(iriFragment(entry.iri)),
+                labelTokens: tokenizeForFuzzy(entry.label ?? ''),
+            }));
+            const haystack = indexedEntries.map((entry) => `${entry.fragment}\n${entry.label ?? ''}\n${entry.iri}`);
+            const uf = new uFuzzy({});
+            const filtered = uf.filter(haystack, text);
+            if (!filtered || filtered.length === 0) {
+                return { success: true, candidates: [] };
+            }
+            const info = uf.info(filtered, haystack, text);
+            const order = info ? uf.sort(info, haystack, text) : null;
+            const ranked = (order ?? filtered.map((_, index) => index))
+                .map((index) => filtered[index]!)
+                .slice(0, limit);
+            const queryTokens = tokenizeForFuzzy(text).slice(0, 6);
+            const candidates = ranked.map((entryIndex, index) => {
+                const entry = indexedEntries[entryIndex]!;
+                const fragment = entry.fragment.toLowerCase();
+                const lowerLabel = (entry.label ?? '').toLowerCase();
+                const lowerInput = text.toLowerCase();
+                const fragmentTokenSet = new Set(entry.fragmentTokens);
+                const labelTokenSet = new Set(entry.labelTokens);
+                let fragmentTokenHits = 0;
+                let labelTokenHits = 0;
+                for (const token of queryTokens) {
+                    if (fragmentTokenSet.has(token)) {
+                        fragmentTokenHits += 1;
+                    }
+                    if (labelTokenSet.has(token)) {
+                        labelTokenHits += 1;
+                    }
+                }
+                return {
+                    iri: entry.iri,
+                    label: entry.label,
+                    score: ranked.length - index,
+                    diagnostics: {
+                        fragment,
+                        label: lowerLabel,
+                        exactFragment: fragment === lowerInput,
+                        exactLabel: lowerLabel === lowerInput,
+                        containsInputInFragment: fragment.includes(lowerInput),
+                        containsInputInLabel: lowerLabel.includes(lowerInput),
+                        fragmentTokenHits,
+                        labelTokenHits,
+                    },
+                };
+            });
+            return { success: true, candidates };
+        } catch (error) {
+            logServerError('oml/fuzzysearch failed', error);
+            return { success: false, candidates: [], error: error instanceof Error ? error.message : String(error) };
+        }
+    });
+
+    connection.onRequest(ReasoningRequests.resolveModelUri, async (params: ResolveModelUriParams): Promise<ResolveModelUriResult> => {
+        await ensureWorkspaceIndexed(shared);
+        const ontologyIri = typeof params?.ontologyIri === 'string' ? params.ontologyIri.trim() : '';
+        if (!ontologyIri) {
+            return {};
+        }
+        const referencingUri = typeof params?.referencingUri === 'string'
+            ? params.referencingUri.trim()
+            : undefined;
+        const normalized = normalizeOntologyIri(ontologyIri);
+        const ontologyIndex = getOntologyModelIndex(shared as any);
+        const modelUri = ontologyIndex.resolveModelUri(normalized, referencingUri);
+        if (modelUri) {
+            await ensureResolvedModelDocumentLoaded(shared, modelUri);
+        }
+        return modelUri ? { modelUri } : {};
+    });
+
+    startLanguageServer(shared, {
+        CodeActionProvider: DocumentState.IndexedReferences
+    });
+    return { shared, Oml };
+}
+
+function normalizeOntologyIri(value: string): string {
+    return value.replace(/^<|>$/g, '').replace(/[\/#]+$/, '');
+}
+
+function isTransientDiagnosticsUri(uri: string): boolean {
+    try {
+        const scheme = URI.parse(uri).scheme;
+        return scheme === 'git'
+            || scheme === 'chat-editing-text-model'
+            || scheme === 'chat-editing-snapshot-text-model'
+            || scheme === 'vscode-chat-code-block';
+    } catch {
+        return false;
+    }
+}
+
+async function ensureWorkspaceIndexed(sharedServices: any): Promise<void> {
+    const key = sharedServices as object;
+    const existing = workspacePreloadState.get(key);
+    if (existing?.completed) {
+        return;
+    }
+    if (existing?.promise) {
+        await existing.promise;
+        return;
+    }
+    const state = existing ?? { completed: false };
+    const promise = (async () => {
+        const workspace = sharedServices.workspace.WorkspaceManager;
+        const documents = sharedServices.workspace.LangiumDocuments;
+        const builder = sharedServices.workspace.DocumentBuilder;
+        await workspace.ready;
+        const folderUris = workspace.workspaceFolders ?? [];
+        const omlUris = new Set<string>();
+        for (const folder of folderUris) {
+            const entries = await workspace.searchFolder(URI.parse(folder.uri));
+            for (const entry of entries) {
+                const entryUri = entry.toString();
+                if (entryUri.toLowerCase().endsWith('.oml')) {
+                    omlUris.add(entryUri);
+                }
+            }
+        }
+        if (omlUris.size > 0) {
+            const docs = await Promise.all(
+                [...omlUris].map((uri) => documents.getOrCreateDocument(URI.parse(uri)))
+            );
+            await builder.build(docs, { validation: { categories: ['built-in', 'fast'] } });
+        }
+        state.completed = true;
+    })().finally(() => {
+        state.promise = undefined;
+    });
+    state.promise = promise;
+    workspacePreloadState.set(key, state);
+    await promise;
+}
+
+async function ensureResolvedModelDocumentLoaded(sharedServices: any, modelUri: string): Promise<void> {
+    try {
+        const documents = sharedServices.workspace.LangiumDocuments;
+        const uri = URI.parse(modelUri);
+        if (!documents.getDocument(uri)) {
+            await documents.getOrCreateDocument(uri);
+        }
+    } catch {
+        // Resolution must stay deterministic and non-throwing;
+        // loading failures are surfaced later by query/edit operations.
+    }
+}
+
+function toRowDto(row: Map<string, any>): Record<string, SparqlTermDto> {
+    const result: Record<string, SparqlTermDto> = {};
+    for (const [name, term] of row.entries()) {
+        result[name] = {
+            termType: term.termType,
+            value: term.value,
+            datatype: term.datatype,
+            language: term.language,
+        };
+    }
+    return result;
+}

package/src/lsp/protocol/browser-fs-protocol.ts

@@ -0,0 +1,21 @@
+// Copyright (c) 2026 Modelware. All rights reserved.
+
+export const FsRequests = {
+    readFile: 'oml/fs/readFile',
+    stat: 'oml/fs/stat',
+    readDirectory: 'oml/fs/readDirectory',
+    // Must match GET_WORKSPACE_FOLDERS_REQUEST in oml-workspace.ts
+    getWorkspaceFolders: 'oml/fs/getWorkspaceFolders'
+} as const;
+
+export type FsNodeType = 'file' | 'directory' | 'unknown';
+
+export interface FsStatResult {
+    type: FsNodeType;
+}
+
+export interface FsDirectoryEntry {
+    uri: string;
+    type: FsNodeType;
+}
+

package/src/lsp/protocol/reasoner-protocol.ts

@@ -0,0 +1,86 @@
+// Copyright (c) 2026 Modelware. All rights reserved.
+
+export const ReasoningNotifications = {
+    markDocumentActive: 'oml/reasoning/markDocumentActive',
+    markDocumentInactive: 'oml/reasoning/markDocumentInactive',
+    semanticChanged: 'oml/reasoning/semanticChanged',
+} as const;
+
+export const ReasoningRequests = {
+    sparqlQuery: 'oml/query',
+    fuzzySearch: 'oml/fuzzysearch',
+    resolveModelUri: 'oml/resolveModelUri',
+} as const;
+
+export interface ActiveDocumentParams {
+    modelUri: string;
+}
+
+export interface SemanticChangedParams {
+    modelUris: string[];
+}
+
+export interface ResolveModelUriParams {
+    ontologyIri: string;
+    referencingUri?: string;
+}
+
+export interface ResolveModelUriResult {
+    modelUri?: string;
+}
+
+export interface SparqlQueryParams {
+    modelUri: string;
+    sparql: string;
+}
+
+export interface FuzzySearchParams {
+    text: string;
+    limit?: number;
+}
+
+export interface FuzzySearchCandidate {
+    iri: string;
+    label?: string;
+    score: number;
+    diagnostics?: {
+        fragment: string;
+        label: string;
+        exactFragment: boolean;
+        exactLabel: boolean;
+        containsInputInFragment: boolean;
+        containsInputInLabel: boolean;
+        fragmentTokenHits: number;
+        labelTokenHits: number;
+    };
+}
+
+export interface FuzzySearchResult {
+    success: boolean;
+    candidates: FuzzySearchCandidate[];
+    error?: string;
+}
+
+export interface SparqlTermDto {
+    termType: 'NamedNode' | 'Literal' | 'BlankNode';
+    value: string;
+    datatype?: string;
+    language?: string;
+}
+
+export type SparqlRowDto = Record<string, SparqlTermDto>;
+
+export interface SparqlQueryResult {
+    success: boolean;
+    kind: 'select' | 'ask' | 'construct' | 'describe' | 'unknown';
+    warnings: string[];
+    rows?: SparqlRowDto[];
+    result?: boolean;
+    quads?: Array<{
+        subject: string;
+        predicate: string;
+        object: string;
+        graph: string;
+    }>;
+    error?: string;
+}

package/src/lsp/providers/browser-fs-provider.ts

@@ -0,0 +1,85 @@
+// Copyright (c) 2026 Modelware. All rights reserved.
+
+import type { FileSystemNode, FileSystemProvider } from 'langium';
+import { URI } from 'langium';
+import type { Connection } from 'vscode-languageserver';
+import { FsRequests, type FsDirectoryEntry, type FsStatResult } from '../protocol/browser-fs-protocol.js';
+
+const textDecoder = new TextDecoder('utf-8');
+
+class BrowserFileSystemProvider implements FileSystemProvider {
+    constructor(private readonly connection: Connection) {}
+
+    async stat(uri: URI): Promise<FileSystemNode> {
+        const result = await this.connection.sendRequest<FsStatResult | null>(FsRequests.stat, { uri: uri.toString() });
+        if (!result) {
+            throw new Error(`File not found: ${uri.toString()}`);
+        }
+        return {
+            uri,
+            isFile: result.type === 'file',
+            isDirectory: result.type === 'directory'
+        };
+    }
+
+    statSync(): FileSystemNode {
+        throw new Error('Synchronous file system access is unavailable in browser mode.');
+    }
+
+    async exists(uri: URI): Promise<boolean> {
+        try {
+            await this.stat(uri);
+            return true;
+        } catch {
+            return false;
+        }
+    }
+
+    existsSync(): boolean {
+        return false;
+    }
+
+    async readBinary(uri: URI): Promise<Uint8Array> {
+        const content = await this.readFile(uri);
+        return new TextEncoder().encode(content);
+    }
+
+    readBinarySync(): Uint8Array {
+        throw new Error('Synchronous file system access is unavailable in browser mode.');
+    }
+
+    async readFile(uri: URI): Promise<string> {
+        const content = await this.connection.sendRequest<string | Uint8Array | ArrayBuffer | null>(FsRequests.readFile, { uri: uri.toString() });
+        if (typeof content === 'string') {
+            return content;
+        }
+        if (content instanceof Uint8Array) {
+            return textDecoder.decode(content);
+        }
+        if (content instanceof ArrayBuffer) {
+            return textDecoder.decode(new Uint8Array(content));
+        }
+        throw new Error(`Unexpected readFile response for ${uri.toString()}`);
+    }
+
+    readFileSync(): string {
+        throw new Error('Synchronous file system access is unavailable in browser mode.');
+    }
+
+    async readDirectory(uri: URI): Promise<FileSystemNode[]> {
+        const entries = await this.connection.sendRequest<FsDirectoryEntry[]>(FsRequests.readDirectory, { uri: uri.toString() }) ?? [];
+        return entries.map((entry) => ({
+            uri: URI.parse(entry.uri),
+            isFile: entry.type === 'file',
+            isDirectory: entry.type === 'directory'
+        }));
+    }
+
+    readDirectorySync(): FileSystemNode[] {
+        return [];
+    }
+}
+
+export const BrowserFileSystem = (connection: Connection) => ({
+    fileSystemProvider: () => new BrowserFileSystemProvider(connection)
+});