@oml/cli 0.13.0 → 0.14.1

package/src/commands/reason.ts

@@ -1,77 +1,90 @@
 // Copyright (c) 2026 Modelware. All rights reserved.
 
-import { createOmlServices } from '@oml/language';
 import chalk from 'chalk';
-import { NodeFileSystem } from 'langium/node';
-import { URI } from 'langium';
-import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
-import { buildWorkspaceDocuments, collectWorkspaceOntologyEntries, normalizeFormatExtension, OntologyInconsistencyError, reasonWorkspaceOntologies } from '../backend/reasoned-output.js';
 import { failCli } from '../cli-error.js';
 import { formatDuration } from '../util.js';
-import { compileAction, resolveCompileOutputRoot, resolveCompileWorkspaceRoot } from './compile.js';
+import { restPost } from './server/rest.js';
+import { formatLintSummary, printLintDiagnostics, type LintPayload } from './lint.js';
 
 export type ReasonOptions = {
-    workspace?: string,
-    owl?: string,
-    format?: string,
-    clean?: boolean,
-    pretty?: boolean,
     only?: boolean,
-    checkOnly?: boolean,
-    uniqueNamesAssumption?: boolean,
-    explanations?: boolean,
-    profile?: boolean
+    explanation?: boolean,
+    authToken?: string
 };
 
 export const reasonAction = async (opts: ReasonOptions): Promise<void> => {
-    const workspaceRoot = resolveCompileWorkspaceRoot(opts.workspace);
-    const outputRoot = resolveCompileOutputRoot(workspaceRoot, opts.owl);
-    const format = normalizeFormatExtension(opts.format);
-    if (opts.only && opts.clean) {
-        failCli(chalk.red('Cannot combine --only with --clean for reason.'));
-    }
+    const startedAt = Date.now();
+    const result = await restPost<{
+        success: boolean;
+        ontologiesReasoned: number;
+        elapsedMs?: number;
+        totalElapsedMs?: number;
+        inconsistent: Array<{ modelUri: string; validationWarnings: string[] }>;
+        failed: Array<{ modelUri: string; error: string }>;
+        validate?: {
+            success: boolean;
+            filesChecked: number;
+            errors: number;
+            warnings: number;
+            elapsedMs?: number;
+            lint?: LintPayload;
+            error?: string;
+        };
+    }>('/v0/reason', opts as unknown as Record<string, unknown>, opts.authToken);
 
-    if (!opts.only) {
-        await compileAction({
-            workspace: workspaceRoot,
-            owl: outputRoot,
-            format,
-            clean: opts.clean,
-            pretty: opts.pretty
-        });
+    if (result.validate?.lint) {
+        const lint = result.validate.lint;
+        if (lint.filesChecked <= 0) {
+            console.log(chalk.yellow('No .oml files found in server workspace.'));
+        } else {
+            printLintDiagnostics(lint);
+            const lintElapsedMs = typeof lint.elapsedMs === 'number' && Number.isFinite(lint.elapsedMs) && lint.elapsedMs >= 0
+                ? lint.elapsedMs
+                : Date.now() - startedAt;
+            const lintSummary = formatLintSummary(lint, lintElapsedMs);
+            if (lint.errors > 0) {
+                failCli(chalk.red(lintSummary));
+            }
+            if (lint.warnings > 0) {
+                failCli(chalk.yellow(lintSummary));
+            }
+            console.log(chalk.green(lintSummary));
+        }
     }
 
-    const outputStat = await fs.stat(outputRoot).catch(() => undefined);
-    if (!outputStat || !outputStat.isDirectory()) {
-        failCli(chalk.red(`OWL output folder does not exist: ${outputRoot}`));
+    if (result.validate && result.validate.success) {
+        if (result.validate.filesChecked === 0) {
+            console.log(chalk.yellow('No markdown/table-editor targets found in server workspace.'));
+        } else {
+            const validateElapsedMs = typeof result.validate.elapsedMs === 'number'
+                && Number.isFinite(result.validate.elapsedMs)
+                && result.validate.elapsedMs >= 0
+                ? result.validate.elapsedMs
+                : Date.now() - startedAt;
+            console.log(chalk.green(`validate: ${result.validate.filesChecked} item(s) checked. [${formatDuration(validateElapsedMs)}]`));
+        }
     }
 
-    const startedAt = Date.now();
-    const servicesBundle = createOmlServices(NodeFileSystem);
-    await servicesBundle.Oml.shared.workspace.WorkspaceManager.initializeWorkspace([
-        { uri: URI.file(workspaceRoot).toString(), name: path.basename(workspaceRoot) }
-    ]);
-    const documents = await buildWorkspaceDocuments(servicesBundle.Oml, workspaceRoot, true);
-    const entries = collectWorkspaceOntologyEntries(documents, outputRoot, format);
-    let result;
-    try {
-        result = await reasonWorkspaceOntologies(entries, {
-            outputRoot,
-            format,
-            pretty: opts.pretty ?? false,
-            explanations: opts.explanations ?? true,
-            uniqueNamesAssumption: opts.uniqueNamesAssumption ?? true,
-            checkOnly: opts.checkOnly ?? false,
-            profile: opts.profile ?? false,
-        });
-    } catch (error) {
-        if (error instanceof OntologyInconsistencyError) {
-            failCli(chalk.red(error.message));
+    if (!result.success) {
+        for (const item of result.failed) {
+            const modelUri = String(item.modelUri ?? '').trim();
+            console.log(chalk.red(`reason failed: ${modelUri || '<workspace>'}: ${item.error}`));
+        }
+        for (const item of result.inconsistent) {
+            const warnings = item.validationWarnings.length > 0 ? ` warnings=${item.validationWarnings.join('; ')}` : '';
+            console.log(chalk.red(`reason inconsistency detected: ${item.modelUri}.${warnings}`));
         }
-        throw error;
+        failCli(chalk.red(result.validate?.error?.trim() || 'reason failed.'));
+    }
+
+    if (result.ontologiesReasoned === 0) {
+        console.log(chalk.yellow(`No .oml files found under ${path.resolve('.')}.`));
+        return;
     }
 
-    const action = opts.checkOnly ? 'checked in' : 'generated in';
-    console.log(chalk.green(`reason: ${result.ontologiesReasoned} ontology file(s) ${action} ${path.relative(process.cwd(), outputRoot) || outputRoot} [${formatDuration(Date.now() - startedAt)}]`));
+    const reasonElapsedMs = typeof result.elapsedMs === 'number' && Number.isFinite(result.elapsedMs) && result.elapsedMs >= 0
+        ? result.elapsedMs
+        : Date.now() - startedAt;
+    console.log(chalk.green(`reason: ${result.ontologiesReasoned} ontology file(s) checked [${formatDuration(reasonElapsedMs)}]`));
 };