@oml/server 0.14.0

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

@@ -0,0 +1,134 @@
+// Copyright (c) 2026 Modelware. All rights reserved.
+
+import type { FileSystemNode, FileSystemProvider } from 'langium';
+import { URI } from 'langium';
+import { NodeFileSystemProvider } from 'langium/node';
+import type { Connection } from 'vscode-languageserver';
+import { FsRequests, type FsDirectoryEntry, type FsStatResult } from '../protocol/browser-fs-protocol.js';
+
+const textDecoder = new TextDecoder('utf-8');
+
+/**
+ * Hybrid file system provider that handles both local files and Live Share (vsls://) URIs.
+ * For local files, uses Node's fs module directly.
+ * For vsls:// URIs, proxies requests through the LSP connection to VS Code.
+ */
+class HybridFileSystemProvider implements FileSystemProvider {
+    private readonly nodeProvider: NodeFileSystemProvider;
+
+    constructor(private readonly connection: Connection) {
+        this.nodeProvider = new NodeFileSystemProvider();
+    }
+
+    private isRemoteScheme(uri: URI): boolean {
+        return uri.scheme === 'vsls'
+            || uri.scheme === 'vscode-remote'
+            || uri.scheme === 'git';
+    }
+
+    async stat(uri: URI): Promise<FileSystemNode> {
+        if (this.isRemoteScheme(uri)) {
+            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'
+            };
+        }
+        return this.nodeProvider.stat(uri);
+    }
+
+    statSync(uri: URI): FileSystemNode {
+        if (this.isRemoteScheme(uri)) {
+            throw new Error(`Synchronous file system access unavailable for remote URIs: ${uri.toString()}`);
+        }
+        return this.nodeProvider.statSync(uri);
+    }
+
+    async exists(uri: URI): Promise<boolean> {
+        try {
+            await this.stat(uri);
+            return true;
+        } catch {
+            return false;
+        }
+    }
+
+    existsSync(uri: URI): boolean {
+        if (this.isRemoteScheme(uri)) {
+            return false;
+        }
+        return this.nodeProvider.existsSync(uri);
+    }
+
+    async readBinary(uri: URI): Promise<Uint8Array> {
+        if (this.isRemoteScheme(uri)) {
+            const content = await this.readFile(uri);
+            return new TextEncoder().encode(content);
+        }
+        return this.nodeProvider.readBinary(uri);
+    }
+
+    readBinarySync(uri: URI): Uint8Array {
+        if (this.isRemoteScheme(uri)) {
+            throw new Error(`Synchronous file system access unavailable for remote URIs: ${uri.toString()}`);
+        }
+        return this.nodeProvider.readBinarySync(uri);
+    }
+
+    async readFile(uri: URI): Promise<string> {
+        if (this.isRemoteScheme(uri)) {
+            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(`Failed to read file: ${uri.toString()}`);
+        }
+        return this.nodeProvider.readFile(uri);
+    }
+
+    readFileSync(uri: URI): string {
+        if (this.isRemoteScheme(uri)) {
+            throw new Error(`Synchronous file system access unavailable for remote URIs: ${uri.toString()}`);
+        }
+        return this.nodeProvider.readFileSync(uri);
+    }
+
+    async readDirectory(uri: URI): Promise<FileSystemNode[]> {
+        if (this.isRemoteScheme(uri)) {
+            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'
+            }));
+        }
+        return this.nodeProvider.readDirectory(uri);
+    }
+
+    readDirectorySync(uri: URI): FileSystemNode[] {
+        if (this.isRemoteScheme(uri)) {
+            return [];
+        }
+        return this.nodeProvider.readDirectorySync(uri);
+    }
+}
+
+export const HybridFileSystem = (connection: Connection) => ({
+    fileSystemProvider: () => new HybridFileSystemProvider(connection)
+});

package/src/rest/export.ts

@@ -0,0 +1,118 @@
+// Copyright (c) 2026 Modelware. All rights reserved.
+
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { checkConsistency, type ConsistencyResult } from '@oml/reasoner';
+
+type RdfFormat = 'ttl' | 'trig' | 'nt' | 'nq' | 'n3';
+
+type WorkspaceOwlEntry = { modelUri: string; ontologyIri: string; owlPath: string };
+
+export type RestExportContext = {
+    workspaceRoot: string;
+    ensureInitialized: () => Promise<void>;
+    ensureWorkspaceCurrent: () => Promise<void>;
+    writeWorkspaceAssertedOwl: (
+        outputDir: string,
+        format: RdfFormat,
+        pretty: boolean,
+    ) => Promise<WorkspaceOwlEntry[]>;
+    exportAssertedWorkspace: (params: Record<string, unknown>) => Promise<Record<string, unknown>>;
+};
+
+function normalizeRdfFormat(value: string | undefined): RdfFormat {
+    if (!value) {
+        return 'ttl';
+    }
+    const normalized = value.trim().toLowerCase();
+    if (normalized === 'trig' || normalized === 'nt' || normalized === 'nq' || normalized === 'n3') {
+        return normalized;
+    }
+    return 'ttl';
+}
+
+export async function exportAssertedWorkspace(client: RestExportContext, params: Record<string, unknown>): Promise<Record<string, unknown>> {
+    await client.ensureInitialized();
+    await client.ensureWorkspaceCurrent();
+    const workspaceRoot = path.resolve(client.workspaceRoot);
+    const outputFromOptions = typeof params.outputDir === 'string' && params.outputDir.trim().length > 0
+        ? params.outputDir.trim()
+        : (typeof params.owl === 'string' && params.owl.trim().length > 0 ? params.owl.trim() : 'build/owl');
+    const outputDir = path.resolve(
+        workspaceRoot,
+        outputFromOptions,
+    );
+    const format = normalizeRdfFormat(typeof params.format === 'string' ? params.format : undefined);
+    const pretty = params.pretty === true;
+    if (params.clean === true) {
+        await fs.rm(outputDir, { recursive: true, force: true });
+    }
+    await fs.mkdir(outputDir, { recursive: true });
+    const filesWritten = (await client.writeWorkspaceAssertedOwl(outputDir, format, pretty)).length;
+    return { success: true, filesWritten, outputDir, format, pretty };
+}
+
+export async function exportWorkspace(client: RestExportContext, params: Record<string, unknown>): Promise<Record<string, unknown>> {
+    await client.ensureInitialized();
+    await client.ensureWorkspaceCurrent();
+    const assertedExportResult = await client.exportAssertedWorkspace({
+        outputDir: params.outputDir ?? params.owl,
+        format: params.format,
+        pretty: params.pretty,
+        clean: params.clean,
+    });
+    const format = normalizeRdfFormat(typeof params.format === 'string' ? params.format : undefined);
+    const outputDir = String(assertedExportResult.outputDir ?? '');
+    const explanation = params.explanation !== false;
+    const uniqueNamesAssumption = params.uniqueNamesAssumption === true;
+    const profile = params.profile === true;
+    const timeout = typeof params.timeout === 'number' && Number.isFinite(params.timeout) && params.timeout > 0
+        ? Math.floor(params.timeout)
+        : 120_000;
+    const entries = await client.writeWorkspaceAssertedOwl(outputDir, format, params.pretty === true);
+    const results: Array<{ modelUri: string; ontologyIri: string; result?: ConsistencyResult; error?: string }> = [];
+    const failed: Array<{ modelUri: string; error: string }> = [];
+    for (const entry of entries) {
+        try {
+            const result = await checkConsistency({
+                input: entry.owlPath,
+                inputRoot: outputDir,
+                explanations: explanation,
+                uniqueNamesAssumption,
+                checkOnly: false,
+                profile,
+                timeout,
+            });
+            results.push({
+                modelUri: entry.modelUri,
+                ontologyIri: entry.ontologyIri,
+                result,
+            });
+        } catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            failed.push({ modelUri: entry.modelUri, error: message || 'reason failed' });
+            results.push({
+                modelUri: entry.modelUri,
+                ontologyIri: entry.ontologyIri,
+                error: message || 'reason failed',
+            });
+        }
+    }
+    const reasonResult = {
+        success: failed.length === 0,
+        ontologiesReasoned: entries.length,
+        inconsistent: results
+            .filter((entry) => entry.result && entry.result.consistent === false)
+            .map((entry) => ({
+                modelUri: entry.modelUri,
+                validationWarnings: entry.result?.reports ?? [],
+            })),
+        failed,
+        results,
+    };
+    return {
+        success: assertedExportResult.success === true && reasonResult.success === true,
+        assertedExport: assertedExportResult,
+        reason: reasonResult,
+    };
+}

package/src/rest/routes.ts

@@ -0,0 +1,117 @@
+// Copyright (c) 2026 Modelware. All rights reserved.
+
+export const REST_ROUTES = [
+    { method: 'POST', path: '/v0/query', operationId: 'query' },
+    { method: 'POST', path: '/v0/update', operationId: 'update' },
+    { method: 'POST', path: '/v0/fuzzysearch', operationId: 'fuzzysearch' },
+    { method: 'POST', path: '/v0/lint', operationId: 'lint' },
+    { method: 'POST', path: '/v0/reason', operationId: 'reason' },
+    { method: 'POST', path: '/v0/validate', operationId: 'validate' },
+    { method: 'POST', path: '/v0/render', operationId: 'render' },
+    { method: 'POST', path: '/v0/export', operationId: 'export' },
+] as const;
+
+export type RestRoute = (typeof REST_ROUTES)[number];
+
+export type RestRouteClient = {
+    queryWorkspace: (body: Record<string, unknown>) => Promise<Record<string, unknown>>;
+    updateWorkspace: (body: Record<string, unknown>) => Promise<unknown>;
+    fuzzySearchWorkspace: (body: Record<string, unknown>) => Promise<Record<string, unknown>>;
+    lintWorkspace: (body: Record<string, unknown>) => Promise<unknown>;
+    reasonWorkspace: (body: Record<string, unknown>) => Promise<Record<string, unknown>>;
+    validateWorkspace: (body: Record<string, unknown>) => Promise<Record<string, unknown>>;
+    exportWorkspace: (body: Record<string, unknown>) => Promise<Record<string, unknown>>;
+    renderWorkspace: (body: Record<string, unknown>) => Promise<Record<string, unknown>>;
+};
+
+export async function dispatchRestRoute(
+    method: string,
+    pathname: string,
+    body: Record<string, unknown>,
+    client: RestRouteClient,
+): Promise<{ operationId: string; result: unknown } | undefined> {
+    if (method !== 'POST') {
+        return undefined;
+    }
+    if (pathname === '/v0/query') {
+        return { operationId: 'query', result: await client.queryWorkspace(body) };
+    }
+    if (pathname === '/v0/update') {
+        return { operationId: 'update', result: await client.updateWorkspace(body) };
+    }
+    if (pathname === '/v0/fuzzysearch') {
+        return { operationId: 'fuzzysearch', result: await client.fuzzySearchWorkspace(body) };
+    }
+    if (pathname === '/v0/lint') {
+        return { operationId: 'lint', result: await client.lintWorkspace(body) };
+    }
+    if (pathname === '/v0/reason') {
+        return { operationId: 'reason', result: await client.reasonWorkspace(body) };
+    }
+    if (pathname === '/v0/validate') {
+        return { operationId: 'validate', result: await client.validateWorkspace(body) };
+    }
+    if (pathname === '/v0/export') {
+        return { operationId: 'export', result: await client.exportWorkspace(body) };
+    }
+    if (pathname === '/v0/render') {
+        return { operationId: 'render', result: await client.renderWorkspace(body) };
+    }
+    return undefined;
+}
+
+export function createOpenApiSpec(httpHost: string, httpPort: number): Record<string, unknown> {
+    const paths: Record<string, unknown> = {
+        '/health': {
+            get: {
+                summary: 'Health check',
+                responses: {
+                    '200': {
+                        description: 'Service health',
+                    },
+                },
+            },
+        },
+        '/v0/models': {
+            get: {
+                summary: 'List OML model files under the configured workspace root',
+                responses: {
+                    '200': { description: 'Workspace model file list' },
+                },
+            },
+        },
+    };
+
+    for (const route of REST_ROUTES) {
+        paths[route.path] = {
+            post: {
+                summary: `Invoke ${route.operationId}`,
+                operationId: route.operationId,
+                requestBody: {
+                    required: false,
+                    content: {
+                        'application/json': {
+                            schema: { type: 'object', additionalProperties: true },
+                        },
+                    },
+                },
+                responses: {
+                    '200': { description: 'Successful OML response' },
+                    '400': { description: 'Invalid request' },
+                    '500': { description: 'Server error' },
+                },
+            },
+        };
+    }
+
+    return {
+        openapi: '3.0.3',
+        info: {
+            title: 'OML REST Server',
+            version: '1.0.0',
+            description: 'HTTP/JSON interface for OML server operations.',
+        },
+        servers: [{ url: `http://${httpHost}:${httpPort}` }],
+        paths,
+    };
+}