@oml/cli 0.19.3 → 0.20.0

package/src/commands/export.ts

@@ -14,12 +14,10 @@ export type ExportOptions = {
     authToken?: string;
 };
 
-type ExportPayload = {
+type OwlPayload = {
     success: boolean;
-    filesWritten: number;
     outputDir: string;
-    format: 'ttl' | 'trig' | 'nt' | 'nq' | 'n3';
-    pretty: boolean;
+    files: Array<{ path: string; imports: string[] }>;
     filesChecked?: number;
     errors?: number;
     warnings?: number;
@@ -38,10 +36,10 @@ function normalizeRdfFormat(value: string | undefined): 'ttl' | 'trig' | 'nt' |
 export const exportAction = async (opts: ExportOptions): Promise<void> => {
     const startedAt = Date.now();
     const format = normalizeRdfFormat(opts.format);
-    const result = await restPost<ExportPayload>(
+    const result = await restPost<OwlPayload>(
         '/v0/export',
         {
-            owl: opts.owl,
+            owl: opts.owl ?? 'build/owl',
             format,
             pretty: opts.pretty === true,
         } as Record<string, unknown>,
@@ -65,12 +63,12 @@ export const exportAction = async (opts: ExportOptions): Promise<void> => {
         warnings: Number(result.warnings ?? 0),
         problems: result.problems,
     });
-    if (result.filesWritten <= 0) {
+    if (result.files.length === 0) {
         console.log(chalk.yellow('No .oml files found in server workspace.'));
         return;
     }
 
     console.log(chalk.green(
-        `export: ${result.filesWritten} OML file(s) exported in ${path.relative(process.cwd(), result.outputDir) || result.outputDir} [${formatDuration(Date.now() - startedAt)}]`
+        `export: ${result.files.length} OML file(s) exported in ${path.relative(process.cwd(), result.outputDir) || result.outputDir} [${formatDuration(Date.now() - startedAt)}]`
     ));
 };

package/src/commands/reason.ts

@@ -1,6 +1,6 @@
 // Copyright (c) 2026 Modelware. All rights reserved.
 
-import { checkConsistency } from '@oml/reasoner';
+import { checkConsistency, checkConsistencyBatch } from '@oml/reasoner';
 import chalk from 'chalk';
 import * as fs from 'node:fs/promises';
 import * as os from 'node:os';
@@ -8,57 +8,47 @@ import * as path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { failCli } from '../cli-error.js';
 import { formatDuration } from '../util.js';
-import { printLintDiagnostics, type LintPayload, type LintProblem } from './lint.js';
+import { printLintDiagnostics, type LintProblem } from './lint.js';
 import { restPost } from './server/rest.js';
 
-type RdfFormat = 'ttl' | 'trig' | 'nt' | 'nq' | 'n3';
-
 export type ReasonOptions = {
     owl?: string;
-    format?: RdfFormat | string;
+    format?: string;
     pretty?: boolean;
     explanation?: boolean;
     uniqueNamesAssumption?: boolean;
     profile?: boolean;
+    hoist?: boolean;
     timeout?: number;
     authToken?: string;
 };
 
-type AssertionsPayload = {
+type ExportFile = {
+    path: string;
+    imports: string[];
+};
+
+type ExportPayload = {
     success: boolean;
     error?: string;
-    format?: RdfFormat;
+    outputDir: string;
     filesChecked?: number;
     errors?: number;
     warnings?: number;
     problems?: LintProblem[];
-    files: Array<{
-        modelUri: string;
-        ontologyIri: string;
-        content: string;
-    }>;
+    files: ExportFile[];
 };
 
-const OWL_IMPORTS_IRI = '<http://www.w3.org/2002/07/owl#imports>';
-
-function normalizeRdfFormat(value: string | undefined): RdfFormat {
-    const normalized = String(value ?? 'ttl').trim().toLowerCase();
-    if (normalized === 'trig' || normalized === 'nt' || normalized === 'nq' || normalized === 'n3') {
-        return normalized;
-    }
-    return 'ttl';
-}
-
-function prettyPrintRdf(serialized: string, format: RdfFormat): string {
+/** Add a blank line between top-level statements for ttl/trig readability. */
+function prettyPrintRdf(serialized: string, format: string): string {
     if (format !== 'ttl' && format !== 'trig') {
         return serialized;
     }
     const lines = serialized.split('\n');
     const out: string[] = [];
     for (let i = 0; i < lines.length; i += 1) {
-        const line = lines[i];
-        out.push(line);
-        if (line.trim().endsWith('.')) {
+        out.push(lines[i]);
+        if (lines[i].trim().endsWith('.')) {
             const next = lines[i + 1];
             if (next !== undefined && next.trim().length > 0) {
                 out.push('');
@@ -68,225 +58,244 @@ function prettyPrintRdf(serialized: string, format: RdfFormat): string {
     return out.join('\n');
 }
 
-function extractImports(serialized: string): string[] {
-    const imports = new Set<string>();
-    const statementPattern = /(?:<http:\/\/www\.w3\.org\/2002\/07\/owl#imports>|owl:imports)\s+([^;.]*)[;.]/gms;
-    let statementMatch: RegExpExecArray | null;
-    while ((statementMatch = statementPattern.exec(serialized)) !== null) {
-        const tail = statementMatch[1] ?? '';
-        const iriPattern = /<([^>]+)>/g;
-        let iriMatch: RegExpExecArray | null;
-        while ((iriMatch = iriPattern.exec(tail)) !== null) {
-            const iri = iriMatch[1]?.trim();
-            if (iri) {
-                imports.add(iri);
-            }
-        }
-    }
-    // Handle compact single-line N-Triples cases defensively.
-    if (imports.size === 0 && serialized.includes(OWL_IMPORTS_IRI)) {
-        const linePattern = /<http:\/\/www\.w3\.org\/2002\/07\/owl#imports>\s+<([^>]+)>/g;
-        let lineMatch: RegExpExecArray | null;
-        while ((lineMatch = linePattern.exec(serialized)) !== null) {
-            const iri = lineMatch[1]?.trim();
-            if (iri) {
-                imports.add(iri);
-            }
-        }
-    }
-    return Array.from(imports);
+function resolveEntailmentsPath(uri: string): string {
+    const trimmed = uri.trim();
+    return trimmed.startsWith('file://') ? fileURLToPath(trimmed) : trimmed;
 }
 
-function sortFilesLeafToRoot(
-    files: AssertionsPayload['files'],
-): AssertionsPayload['files'] {
-    const filesByOntologyIri = new Map<string, AssertionsPayload['files'][number]>();
-    for (const file of files) {
-        filesByOntologyIri.set(file.ontologyIri, file);
-    }
-
-    const importsByOntologyIri = new Map<string, string[]>();
-    for (const file of files) {
-        importsByOntologyIri.set(file.ontologyIri, extractImports(file.content));
-    }
-
-    const sorted: AssertionsPayload['files'] = [];
+function sortFilesLeafToRoot(files: ExportFile[]): ExportFile[] {
+    const byPath = new Map<string, ExportFile>(files.map(f => [f.path, f]));
+    const sorted: ExportFile[] = [];
     const state = new Map<string, 0 | 1 | 2>();
-    const sortedRoots = [...filesByOntologyIri.keys()].sort((a, b) => a.localeCompare(b));
-    const visit = (ontologyIri: string): void => {
-        const current = state.get(ontologyIri) ?? 0;
-        if (current === 2) {
-            return;
-        }
-        if (current === 1) {
-            return;
-        }
-        state.set(ontologyIri, 1);
-        for (const importedIri of importsByOntologyIri.get(ontologyIri) ?? []) {
-            if (filesByOntologyIri.has(importedIri)) {
-                visit(importedIri);
-            }
-        }
-        state.set(ontologyIri, 2);
-        const file = filesByOntologyIri.get(ontologyIri);
-        if (file) {
-            sorted.push(file);
+    const visit = (p: string): void => {
+        if ((state.get(p) ?? 0) !== 0) return;
+        state.set(p, 1);
+        for (const imp of byPath.get(p)?.imports ?? []) {
+            visit(imp);
         }
+        state.set(p, 2);
+        const f = byPath.get(p);
+        if (f) sorted.push(f);
     };
+    for (const p of [...byPath.keys()].sort()) visit(p);
+    return sorted;
+}
 
-    for (const ontologyIri of sortedRoots) {
-        visit(ontologyIri);
+function collectClosure(start: string, byPath: Map<string, ExportFile>, into: Set<string>): void {
+    const stack = [start];
+    while (stack.length > 0) {
+        const p = stack.pop() as string;
+        if (into.has(p)) continue;
+        into.add(p);
+        for (const imp of byPath.get(p)?.imports ?? []) stack.push(imp);
     }
-    return sorted;
 }
 
-function resolveEntailmentsPath(uri: string): string {
-    const trimmed = uri.trim();
-    if (trimmed.startsWith('file://')) {
-        return fileURLToPath(trimmed);
+function closureFiles(start: string, byPath: Map<string, ExportFile>): ExportFile[] {
+    const seen = new Set<string>();
+    collectClosure(start, byPath, seen);
+    const result: ExportFile[] = [];
+    for (const p of seen) {
+        const f = byPath.get(p);
+        if (f) result.push(f);
     }
-    return trimmed;
+    return result;
 }
 
-function ontologyIriToTempPath(ontologyIri: string, format: RdfFormat): string {
-    try {
-        const iri = new URL(ontologyIri);
-        const rawPath = iri.pathname.replace(/\/+$/, '');
-        const segments = rawPath.split('/').filter(Boolean);
-        const stem = segments.at(-1) || 'index';
-        const dirSegs = iri.host ? [iri.host, ...segments.slice(0, -1)] : segments.slice(0, -1);
-        return dirSegs.length > 0 ? path.join(...dirSegs, `${stem}.${format}`) : `${stem}.${format}`;
-    } catch {
-        return ontologyIri.replace(/[^a-zA-Z0-9_/-]/g, '_') + '.' + format;
+/**
+ * Files imported by no other file (maximal nodes of the import graph).
+ * Checking only these establishes consistency of every file: OWL-DL
+ * consistency is monotonic, so a consistent import closure proves every
+ * imported (subset) ontology is consistent too. The roots' closures cover
+ * every file, so this is sufficient — and far cheaper than reasoning each
+ * file's closure independently.
+ */
+function computeConsistencyRoots(files: ExportFile[]): ExportFile[] {
+    const byPath = new Map<string, ExportFile>(files.map(f => [f.path, f]));
+    const imported = new Set<string>();
+    for (const f of files) {
+        for (const imp of f.imports) imported.add(imp);
     }
+    const roots = files.filter(f => !imported.has(f.path));
+    // Guard against import cycles whose component is imported by nobody outside
+    // it: make sure every file is in some root's closure, else add it directly.
+    const covered = new Set<string>();
+    for (const root of roots) collectClosure(root.path, byPath, covered);
+    const uncovered = files.filter(f => !covered.has(f.path));
+    return sortFilesLeafToRoot([...roots, ...uncovered]);
+}
+
+function resolveTimeout(opts: ReasonOptions): number {
+    return typeof opts.timeout === 'number' && Number.isFinite(opts.timeout) && opts.timeout > 0
+        ? Math.floor(opts.timeout)
+        : 120_000;
 }
 
-function modelUriToRelativePath(modelUri: string | undefined): string {
-    const trimmed = (modelUri ?? '').trim();
-    if (trimmed.startsWith('file://')) {
-        const absolute = fileURLToPath(trimmed);
-        const relative = path.relative(process.cwd(), absolute);
-        return relative.length > 0 ? relative : path.basename(absolute);
+/**
+ * A root's import closure is inconsistent. Reason its closure file-by-file,
+ * leaf-to-root, to find the first file whose own closure is inconsistent —
+ * the precise point where the inconsistency is introduced.
+ */
+async function localizeInconsistency(
+    root: ExportFile,
+    byPath: Map<string, ExportFile>,
+    workDir: string,
+    opts: ReasonOptions,
+): Promise<{ file: ExportFile; result: Record<string, unknown> } | undefined> {
+    const closure = sortFilesLeafToRoot(closureFiles(root.path, byPath));
+    for (const file of closure) {
+        const result = await checkConsistency({
+            input: path.join(workDir, file.path),
+            inputRoot: workDir,
+            explanations: opts.explanation === true,
+            uniqueNamesAssumption: opts.uniqueNamesAssumption !== false,
+            checkOnly: true,
+            profile: false,
+            timeout: resolveTimeout(opts),
+        });
+        if (!result.consistent) {
+            return { file, result: result as unknown as Record<string, unknown> };
+        }
     }
-    return trimmed;
+    return undefined;
 }
 
 export const reasonAction = async (opts: ReasonOptions): Promise<void> => {
     const startedAt = Date.now();
-    const outputFormat = normalizeRdfFormat(opts.format);
+    const persistDir = typeof opts.owl === 'string' && opts.owl.trim().length > 0
+        ? path.resolve(opts.owl.trim())
+        : undefined;
+    const format = opts.format ?? 'ttl';
     const pretty = opts.pretty === true;
-    const assertions = await restPost<AssertionsPayload>(
-        '/v0/assertions',
-        { format: outputFormat, pretty } as Record<string, unknown>,
+    // Always reason inside a private temp dir and only promote it to the user's
+    // output directory on full success, so a failed/inconsistent run never leaves
+    // partial or internally-inconsistent artifacts behind in persistDir.
+    const workDir = await fs.mkdtemp(path.join(os.tmpdir(), 'oml-reason-'));
+    const exported = await restPost<ExportPayload>(
+        '/v0/export',
+        { owl: workDir, format, pretty } as Record<string, unknown>,
         opts.authToken,
     );
-    if (!assertions.success) {
+    if (!exported.success) {
+        await fs.rm(workDir, { recursive: true, force: true });
         printLintDiagnostics({
             success: false,
-            filesChecked: Number(assertions.filesChecked ?? 0),
-            errors: Number(assertions.errors ?? 0),
-            warnings: Number(assertions.warnings ?? 0),
-            problems: assertions.problems,
-        } satisfies LintPayload);
-        const summary = assertions.error?.trim() || 'reason failed.';
-        failCli(chalk.red(summary));
+            filesChecked: Number(exported.filesChecked ?? 0),
+            errors: Number(exported.errors ?? 0),
+            warnings: Number(exported.warnings ?? 0),
+            problems: exported.problems,
+        });
+        failCli(chalk.red(exported.error?.trim() || 'reason failed.'));
     }
     printLintDiagnostics({
         success: true,
-        filesChecked: Number(assertions.filesChecked ?? 0),
-        errors: Number(assertions.errors ?? 0),
-        warnings: Number(assertions.warnings ?? 0),
-        problems: assertions.problems,
-    } satisfies LintPayload);
-    if (assertions.files.length === 0) {
+        filesChecked: Number(exported.filesChecked ?? 0),
+        errors: Number(exported.errors ?? 0),
+        warnings: Number(exported.warnings ?? 0),
+        problems: exported.problems,
+    });
+    if (exported.files.length === 0) {
+        await fs.rm(workDir, { recursive: true, force: true });
         console.log(chalk.yellow(`No .oml files found under ${path.resolve('.')}.`));
         return;
     }
 
-    const outputDir = typeof opts.owl === 'string' && opts.owl.trim().length > 0
-        ? path.resolve(opts.owl.trim())
-        : undefined;
-    const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'oml-reason-cli-'));
-    if (outputDir) {
-        await fs.rm(outputDir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
-    }
-    const orderedFiles = sortFilesLeafToRoot(assertions.files);
-    let firstInconsistent: { file: AssertionsPayload['files'][number]; result: Record<string, unknown> } | undefined;
-    let firstFailure: { modelUri: string; error: string } | undefined;
+    const byPath = new Map<string, ExportFile>(exported.files.map(f => [f.path, f]));
+    // Check-only runs reason just the import-graph roots (consistency is
+    // monotonic, so the roots' closures prove every file consistent). Persisting
+    // entailments needs per-file output, so it still reasons every file.
+    const checkOnly = persistDir === undefined;
+    const targets = checkOnly
+        ? computeConsistencyRoots(exported.files)
+        : sortFilesLeafToRoot(exported.files);
+    let firstInconsistent: { file: ExportFile; result: Record<string, unknown> } | undefined;
+    let firstFailure: { path: string; error: string } | undefined;
     let entailmentsProduced = 0;
     try {
-        for (const file of orderedFiles) {
-            const target = path.join(tempRoot, ontologyIriToTempPath(file.ontologyIri, outputFormat));
-            await fs.mkdir(path.dirname(target), { recursive: true });
-            await fs.writeFile(target, prettyPrintRdf(file.content, outputFormat), 'utf-8');
-        }
-        for (const file of orderedFiles) {
-            const target = path.join(tempRoot, ontologyIriToTempPath(file.ontologyIri, outputFormat));
-            try {
-                const result = await checkConsistency({
-                    input: target,
-                    inputRoot: tempRoot,
-                    explanations: opts.explanation === true,
-                    uniqueNamesAssumption: opts.uniqueNamesAssumption !== false,
-                    checkOnly: outputDir === undefined,
-                    profile: opts.profile === true,
-                    timeout: typeof opts.timeout === 'number' && Number.isFinite(opts.timeout) && opts.timeout > 0
-                        ? Math.floor(opts.timeout)
-                        : 120_000,
-                });
-                if (!result.consistent) {
-                    firstInconsistent = {
-                        file,
-                        result: result as unknown as Record<string, unknown>,
-                    };
+        // Reason all targets in a single reasoner process: one JVM and one shared
+        // parse cache for the whole batch, instead of spawning a process and
+        // re-parsing every import closure per file.
+        const batchResults = await checkConsistencyBatch({
+            inputs: targets.map(f => path.join(workDir, f.path)),
+            inputRoot: workDir,
+            // Skip tracing on the batch scan; explanations are produced during
+            // localization on the culprit file instead.
+            explanations: false,
+            uniqueNamesAssumption: opts.uniqueNamesAssumption !== false,
+            checkOnly,
+            // Hoist shared entailments when persisting; targets are already
+            // ordered leaf-to-root, which hoisting requires. Ignored for
+            // check-only runs (no entailments are materialized).
+            hoist: opts.hoist === true && !checkOnly,
+            profile: opts.profile === true,
+            timeout: Math.max(opts.timeout ?? 0, 1_800_000),
+        });
+        const resultByInput = new Map(batchResults.map(r => [r.input, r]));
+
+        // Walk targets in leaf-to-root order so the first problem reported is the
+        // earliest (most-imported) point of failure or inconsistency.
+        for (const file of targets) {
+            const input = path.join(workDir, file.path);
+            const result = resultByInput.get(input);
+            if (!result) {
+                firstFailure = { path: file.path, error: 'Reasoner produced no result for this file.' };
+                break;
+            }
+            if (typeof result.error === 'string' && result.error.length > 0) {
+                firstFailure = { path: file.path, error: result.error };
+                break;
+            }
+            if (!result.consistent) {
+                firstInconsistent = checkOnly
+                    ? (await localizeInconsistency(file, byPath, workDir, opts))
+                        ?? { file, result: result as unknown as Record<string, unknown> }
+                    : { file, result: result as unknown as Record<string, unknown> };
+                break;
+            }
+            if (persistDir) {
+                if (typeof result.entailmentsUri !== 'string' || result.entailmentsUri.trim().length === 0) {
+                    firstFailure = { path: file.path, error: 'Reasoner returned a consistent result but did not provide entailments URI.' };
                     break;
                 }
-                if (outputDir) {
-                    if (typeof result.entailmentsUri !== 'string' || result.entailmentsUri.trim().length === 0) {
-                        throw new Error('Reasoner returned a consistent result but did not provide entailments URI.');
-                    }
-                    if (pretty) {
-                        const entailmentsPath = resolveEntailmentsPath(result.entailmentsUri);
-                        const entailmentsContent = await fs.readFile(entailmentsPath, 'utf-8');
-                        await fs.writeFile(entailmentsPath, prettyPrintRdf(entailmentsContent, outputFormat), 'utf-8');
-                    }
-                    entailmentsProduced += 1;
+                if (pretty) {
+                    const entailmentsPath = resolveEntailmentsPath(result.entailmentsUri);
+                    const entailmentsContent = await fs.readFile(entailmentsPath, 'utf-8');
+                    await fs.writeFile(entailmentsPath, prettyPrintRdf(entailmentsContent, format), 'utf-8');
                 }
-            } catch (error) {
-                firstFailure = {
-                    modelUri: file.modelUri,
-                    error: error instanceof Error ? error.message : String(error),
-                };
-                break;
+                entailmentsProduced += 1;
             }
         }
-    } finally {
-        if (outputDir && !firstFailure && !firstInconsistent) {
-            await fs.mkdir(outputDir, { recursive: true });
-            await fs.cp(tempRoot, outputDir, { recursive: true, force: true });
+        // Promote temp output to the user's directory only on a fully successful run.
+        if (persistDir && !firstFailure && !firstInconsistent) {
+            await fs.rm(persistDir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
+            await fs.mkdir(persistDir, { recursive: true });
+            await fs.cp(workDir, persistDir, { recursive: true, force: true });
         }
-        await fs.rm(tempRoot, { recursive: true, force: true });
+    } catch (error) {
+        firstFailure = firstFailure ?? {
+            path: '(batch)',
+            error: error instanceof Error ? error.message : String(error),
+        };
+    } finally {
+        await fs.rm(workDir, { recursive: true, force: true });
     }
 
     if (firstFailure) {
-        const modelUri = String(firstFailure.modelUri ?? '').trim() || '<workspace>';
-        failCli(chalk.red(`reason failed: ${modelUri}: ${firstFailure.error}`));
+        failCli(chalk.red(`reason failed: ${firstFailure.path}: ${firstFailure.error}`));
     }
     if (firstInconsistent) {
-        const where = modelUriToRelativePath(firstInconsistent.file.modelUri)
-            || firstInconsistent.file.ontologyIri.trim()
-            || '<unknown>';
+        const where = firstInconsistent.file.path;
         if (opts.explanation === true) {
             failCli(chalk.red(`Inconsistency found in: ${where}\n${JSON.stringify(firstInconsistent.result, null, 2)}`));
         }
         failCli(chalk.red(`Inconsistency found in: ${where}`));
     }
 
-    if (outputDir) {
+    if (persistDir) {
         console.log(chalk.green(
-            `reason: ${assertions.files.length} ontology file(s) reasoned in ${path.relative(process.cwd(), outputDir) || outputDir} (${entailmentsProduced} entailment artifact file(s) written) [${formatDuration(Date.now() - startedAt)}]`
+            `reason: ${exported.files.length} ontology file(s) reasoned in ${path.relative(process.cwd(), persistDir) || persistDir} (${entailmentsProduced} entailment artifact file(s) written) [${formatDuration(Date.now() - startedAt)}]`
         ));
         return;
     }
-    console.log(chalk.green(`reason: ${assertions.files.length} ontology file(s) checked [${formatDuration(Date.now() - startedAt)}]`));
+    console.log(chalk.green(`reason: ${exported.files.length} ontology file(s) checked via ${targets.length} import root(s) [${formatDuration(Date.now() - startedAt)}]`));
 };