@oml/cli 0.7.0

package/src/commands/compile.ts

@@ -0,0 +1,88 @@
+// 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 { normalizeFormatExtension, writeCompiledWorkspace } from '../backend/reasoned-output.js';
+import { formatDuration } from '../util.js';
+import { lintAction } from './lint.js';
+
+export type CompileOptions = {
+    workspace?: string,
+    owl?: string,
+    format?: string,
+    clean?: boolean,
+    pretty?: boolean,
+    only?: boolean
+};
+
+export const compileAction = async (opts: CompileOptions): Promise<void> => {
+    const workspaceRoot = resolveCompileWorkspaceRoot(opts.workspace);
+    const outputRoot = resolveCompileOutputRoot(workspaceRoot, opts.owl);
+    const format = normalizeFormatExtension(opts.format);
+
+    if (!opts.only) {
+        await lintAction(undefined, { workspace: workspaceRoot });
+    }
+
+    const workspaceStat = await fs.stat(workspaceRoot).catch(() => undefined);
+    if (!workspaceStat || !workspaceStat.isDirectory()) {
+        console.error(chalk.red(`Workspace folder does not exist: ${workspaceRoot}`));
+        process.exit(1);
+    }
+
+    const sourceFiles = await findOmlFiles(workspaceRoot);
+    if (sourceFiles.length === 0) {
+        console.log(chalk.yellow(`No .oml files found under ${workspaceRoot}.`));
+        return;
+    }
+
+    if (opts.clean) {
+        await fs.rm(outputRoot, { recursive: true, force: true });
+    }
+
+    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 entries = await writeCompiledWorkspace(servicesBundle.Oml, workspaceRoot, outputRoot, format, opts.pretty === true);
+
+    console.log(
+        chalk.green(
+            `compile: ${entries.length} OML file(s) converted to .${format} in ${path.relative(process.cwd(), outputRoot) || outputRoot} [${formatDuration(Date.now() - startedAt)}]`
+        )
+    );
+};
+
+export function resolveCompileWorkspaceRoot(workspace: string | undefined): string {
+    return path.resolve(workspace ?? '.');
+}
+
+export function resolveCompileOutputRoot(workspaceRoot: string, owl: string | undefined): string {
+    return path.resolve(owl ?? path.join(workspaceRoot, 'build', 'owl'));
+}
+
+async function findOmlFiles(root: string): Promise<string[]> {
+    const entries = await fs.readdir(root, { withFileTypes: true });
+    const results: string[] = [];
+
+    for (const entry of entries) {
+        const fullPath = path.join(root, entry.name);
+        if (entry.isDirectory()) {
+            if (entry.name === 'node_modules' || entry.name.startsWith('.')) {
+                continue;
+            }
+            results.push(...await findOmlFiles(fullPath));
+            continue;
+        }
+        if (entry.isFile() && entry.name.toLowerCase().endsWith('.oml')) {
+            results.push(fullPath);
+        }
+    }
+
+    return results;
+}

package/src/commands/lint.ts

@@ -0,0 +1,35 @@
+// Copyright (c) 2026 Modelware. All rights reserved.
+
+import chalk from 'chalk';
+import { createBackend } from '../backend/create-backend.js';
+import { formatDuration } from '../util.js';
+
+export type LintOptions = {
+    workspace?: string,
+    workspaceRoot?: string
+};
+
+export const lintAction = async (fileName: string | undefined, opts: LintOptions): Promise<void> => {
+    const startedAt = Date.now();
+    const workspaceRoot = opts.workspace ?? opts.workspaceRoot ?? '.';
+    const backend = createBackend();
+    try {
+        const result = await backend.validate(fileName, workspaceRoot);
+        if (result.filesChecked === 0) {
+            console.log(chalk.yellow(`No .oml files found under ${workspaceRoot}.`));
+            return;
+        }
+        if (fileName && result.warnings === 0) {
+            console.log(chalk.green('lint: no syntax or validation errors found.'));
+            return;
+        }
+        if (result.warnings > 0) {
+            console.log(chalk.yellow(`lint: ${result.filesChecked} OML file(s) checked with ${result.warnings} warning(s). [${formatDuration(Date.now() - startedAt)}]`));
+            process.exit(1);
+        } else {
+            console.log(chalk.green(`lint: ${result.filesChecked} OML file(s) checked. [${formatDuration(Date.now() - startedAt)}]`));
+        }
+    } finally {
+        await backend.dispose();
+    }
+};

package/src/commands/reason.ts

@@ -0,0 +1,79 @@
+// 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 { formatDuration } from '../util.js';
+import { compileAction, resolveCompileOutputRoot, resolveCompileWorkspaceRoot } from './compile.js';
+
+export type ReasonOptions = {
+    workspace?: string,
+    owl?: string,
+    format?: string,
+    clean?: boolean,
+    pretty?: boolean,
+    only?: boolean,
+    checkOnly?: boolean,
+    uniqueNamesAssumption?: boolean,
+    explanations?: boolean,
+    profile?: boolean
+};
+
+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) {
+        console.error(chalk.red('Cannot combine --only with --clean for reason.'));
+        process.exit(1);
+    }
+
+    if (!opts.only) {
+        await compileAction({
+            workspace: workspaceRoot,
+            owl: outputRoot,
+            format,
+            clean: opts.clean,
+            pretty: opts.pretty
+        });
+    }
+
+    const outputStat = await fs.stat(outputRoot).catch(() => undefined);
+    if (!outputStat || !outputStat.isDirectory()) {
+        console.error(chalk.red(`OWL output folder does not exist: ${outputRoot}`));
+        process.exit(1);
+    }
+
+    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) {
+            console.error(chalk.red(error.message));
+            process.exit(1);
+        }
+        throw error;
+    }
+
+    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)}]`));
+};