@oml/cli 0.7.0

package/src/commands/validate.ts

@@ -0,0 +1,226 @@
+// Copyright (c) 2026 Modelware. All rights reserved.
+
+import { normalizeNamespace } from '@oml/language';
+import { createDefaultShaclService, createOwlServices, type ShaclValidationIssue } from '@oml/owl';
+import { MarkdownPreviewRuntime, MarkdownHandlerRegistry } from '@oml/markdown';
+import chalk from 'chalk';
+import { URI } from 'langium';
+import { NodeFileSystem } from 'langium/node';
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import * as url from 'node:url';
+import { loadPreparedDatasetFromOutput, normalizeFormatExtension } from '../backend/reasoned-output.js';
+import { formatDuration } from '../util.js';
+import type { ReasonOptions } from './reason.js';
+import { reasonAction } from './reason.js';
+import { resolveCompileOutputRoot, resolveCompileWorkspaceRoot } from './compile.js';
+
+const markdownRuntime = new MarkdownPreviewRuntime(new MarkdownHandlerRegistry());
+
+export type ValidateOptions = ReasonOptions & {
+    md: string;
+};
+
+type MarkdownValidationResult = {
+    markdownFile: string;
+    blockId: string;
+    lineStart: number;
+    lineEnd: number;
+    contextModelUri?: string;
+    conforms: boolean;
+    issues: ShaclValidationIssue[];
+    error?: string;
+};
+
+export const validateAction = async (opts: ValidateOptions): Promise<void> => {
+    const workspaceRoot = resolveCompileWorkspaceRoot(opts.workspace);
+    const owlOutputRoot = resolveCompileOutputRoot(workspaceRoot, opts.owl);
+    const rdfFormat = normalizeFormatExtension(opts.format);
+    const markdownRoot = path.resolve(workspaceRoot, opts.md);
+
+    const markdownStat = await fs.stat(markdownRoot).catch(() => undefined);
+    if (!markdownStat?.isDirectory()) {
+        console.error(chalk.red(`Markdown folder does not exist: ${markdownRoot}`));
+        process.exit(1);
+    }
+
+    if (!opts.only) {
+        await reasonAction({
+            workspace: workspaceRoot,
+            owl: owlOutputRoot,
+            format: rdfFormat,
+            clean: opts.clean,
+            pretty: opts.pretty,
+            only: false,
+            checkOnly: false,
+            uniqueNamesAssumption: opts.uniqueNamesAssumption,
+            explanations: opts.explanations,
+            profile: opts.profile,
+        });
+    }
+
+    const servicesBundle = createOwlServices(NodeFileSystem);
+    await servicesBundle.Oml.shared.workspace.WorkspaceManager.initializeWorkspace([
+        { uri: URI.file(workspaceRoot).toString(), name: path.basename(workspaceRoot) }
+    ]);
+    const preparedDataset = await loadPreparedDatasetFromOutput(workspaceRoot, owlOutputRoot, rdfFormat);
+    servicesBundle.Oml.reasoning.ReasoningService.loadPreparedDataset(preparedDataset);
+    const shaclService = createDefaultShaclService(
+        servicesBundle.Oml.reasoning.ReasoningService.getSparqlService(),
+        (modelUri) => servicesBundle.Oml.reasoning.ReasoningService.ensureQueryContext(modelUri),
+        (modelUri) => servicesBundle.Oml.reasoning.ReasoningService.getContextIri(modelUri),
+    );
+
+    const validationStartedAt = Date.now();
+    const markdownFiles = await discoverMarkdownFiles(markdownRoot);
+    const results: MarkdownValidationResult[] = [];
+    for (const markdownFile of markdownFiles) {
+        const markdown = await fs.readFile(markdownFile, 'utf-8');
+        const prepared = markdownRuntime.prepare(markdown);
+        const contextModelUri = resolveContextModelUri(markdownFile, prepared.contextUri, workspaceRoot);
+        for (const block of prepared.codeBlocks) {
+            if (block.language !== 'table-editor') {
+                continue;
+            }
+            const validation = await shaclService.validateShacl(contextModelUri, block.content);
+            results.push({
+                markdownFile,
+                blockId: block.id,
+                lineStart: block.lineStart,
+                lineEnd: block.lineEnd,
+                contextModelUri,
+                conforms: validation.conforms,
+                issues: validation.issues,
+                error: validation.error,
+            });
+        }
+    }
+
+    reportValidationResults(results, workspaceRoot, markdownRoot, validationStartedAt);
+    if (results.some((result) => result.error || result.issues.length > 0 || !result.conforms)) {
+        process.exit(1);
+    }
+};
+
+async function discoverMarkdownFiles(root: string): Promise<string[]> {
+    const entries = await fs.readdir(root, { withFileTypes: true });
+    const markdownFiles: 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;
+            }
+            markdownFiles.push(...await discoverMarkdownFiles(fullPath));
+            continue;
+        }
+        if (entry.isFile() && entry.name.toLowerCase().endsWith('.md')) {
+            markdownFiles.push(fullPath);
+        }
+    }
+    return markdownFiles.sort();
+}
+
+function resolveContextModelUri(documentFile: string, contextUri: string | undefined, workspaceRoot: string): string | undefined {
+    if (!contextUri) {
+        return undefined;
+    }
+    const trimmed = contextUri.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    if (trimmed.startsWith('workspace:/')) {
+        const resolved = resolveWorkspacePath(workspaceRoot, trimmed);
+        return resolved ? url.pathToFileURL(resolved).toString() : undefined;
+    }
+    if (/^[a-z][a-z0-9+.-]*:/i.test(trimmed)) {
+        return trimmed;
+    }
+    if (trimmed.startsWith('/')) {
+        return url.pathToFileURL(path.resolve(workspaceRoot, trimmed.replace(/^\/+/, ''))).toString();
+    }
+    return url.pathToFileURL(path.resolve(path.dirname(documentFile), trimmed)).toString();
+}
+
+function resolveWorkspacePath(workspaceRoot: string, href: string): string | undefined {
+    const trimmed = href.trim();
+    if (!trimmed.startsWith('workspace:/')) {
+        return undefined;
+    }
+    return path.resolve(workspaceRoot, trimmed.slice('workspace:/'.length));
+}
+
+function reportValidationResults(
+    results: ReadonlyArray<MarkdownValidationResult>,
+    workspaceRoot: string,
+    markdownRoot: string,
+    startedAt: number
+): void {
+    if (results.length === 0) {
+        console.log(chalk.yellow(`No table-editor blocks found under ${path.relative(workspaceRoot, markdownRoot) || markdownRoot}.`));
+        return;
+    }
+
+    let issueCount = 0;
+    let errorCount = 0;
+    let failingBlockCount = 0;
+    for (const result of results) {
+        const relativeFile = path.relative(markdownRoot, result.markdownFile) || path.basename(result.markdownFile);
+        const location = relativeFile;
+        if (result.error) {
+            failingBlockCount += 1;
+            errorCount += 1;
+            console.log(chalk.red(`Violation: ${location}: ${result.error}`));
+            continue;
+        }
+        const hasIssues = result.issues.length > 0 || !result.conforms;
+        if (!hasIssues) {
+            continue;
+        }
+        failingBlockCount += 1;
+        for (const issue of result.issues) {
+            issueCount += 1;
+            const elementLabel = issue.focusNode ? shortIri(issue.focusNode) : '-';
+            const propertyLabel = issue.propertyName ?? (issue.path ? shortIri(issue.path) : '-');
+            const severityLabel = shortIri(issue.severity || 'Violation');
+            console.log(chalk.red(`${severityLabel}: ${location} element=${elementLabel} property=${propertyLabel}: ${describeIssue(issue)}`));
+        }
+        if (!result.conforms && result.issues.length === 0) {
+            issueCount += 1;
+            console.log(chalk.red(`Violation: ${location}: SHACL validation failed without detailed issues.`));
+        }
+    }
+
+    const duration = formatDuration(Date.now() - startedAt);
+    const summary = `${results.length} table-editor block(s) scanned [${duration}]`;
+    if (issueCount === 0 && errorCount === 0) {
+        console.log(chalk.green(`validate: ${summary}`));
+        return;
+    }
+    console.log(chalk.red(`validate: ${summary}; ${failingBlockCount} failing block(s), ${issueCount} issue(s), ${errorCount} error(s)`));
+}
+
+function shortIri(value: string): string {
+    const normalized = normalizeNamespace(value);
+    const hashIndex = normalized.lastIndexOf('#');
+    if (hashIndex >= 0 && hashIndex < normalized.length - 1) {
+        return normalized.slice(hashIndex + 1);
+    }
+    const slashIndex = normalized.lastIndexOf('/');
+    if (slashIndex >= 0 && slashIndex < normalized.length - 1) {
+        return normalized.slice(slashIndex + 1);
+    }
+    return normalized;
+}
+
+function describeIssue(issue: ShaclValidationIssue): string {
+    const message = issue.message.trim();
+    if (message && message !== 'Validation issue.') {
+        return message;
+    }
+    const source = issue.source ? shortIri(issue.source) : undefined;
+    if (source) {
+        return source;
+    }
+    return 'Validation issue.';
+}

package/src/main.ts

@@ -0,0 +1,5 @@
+// Copyright (c) 2026 Modelware. All rights reserved.
+
+import { runCli } from './cli.js';
+
+void runCli();

package/src/update.ts

@@ -0,0 +1,103 @@
+// Copyright (c) 2026 Modelware. All rights reserved.
+
+import chalk from 'chalk';
+
+const CLI_PACKAGE_NAME = '@oml/cli';
+const CLI_PACKAGE_URL = 'https://registry.npmjs.org/@oml%2fcli';
+const UPDATE_CHECK_TIMEOUT_MS = 1_200;
+
+interface NpmPackageResponse {
+    'dist-tags'?: {
+        latest?: unknown
+    }
+}
+
+interface ParsedVersion {
+    major: number
+    minor: number
+    patch: number
+    prerelease: string | undefined
+}
+
+export async function notifyIfCliUpdateAvailable(currentVersion: string): Promise<void> {
+    if (!shouldCheckForUpdates()) {
+        return;
+    }
+
+    try {
+        const latestVersion = await fetchLatestCliVersion();
+        if (latestVersion === undefined || compareVersions(latestVersion, currentVersion) <= 0) {
+            return;
+        }
+
+        const updateCommand = `npm install -g ${CLI_PACKAGE_NAME}@latest`;
+        console.error(chalk.yellow(
+            `A newer ${CLI_PACKAGE_NAME} release is available (${currentVersion} -> ${latestVersion}).`
+        ));
+        console.error(chalk.yellow(`Update with: ${updateCommand}`));
+    } catch {
+        // Ignore update check failures so the CLI command remains unaffected.
+    }
+}
+
+function shouldCheckForUpdates(): boolean {
+    if (process.env.CI !== undefined) {
+        return false;
+    }
+    if (process.env.OML_NO_UPDATE_NOTIFIER === '1') {
+        return false;
+    }
+    return process.stderr.isTTY;
+}
+
+async function fetchLatestCliVersion(): Promise<string | undefined> {
+    const response = await fetch(CLI_PACKAGE_URL, {
+        headers: { accept: 'application/json' },
+        signal: AbortSignal.timeout(UPDATE_CHECK_TIMEOUT_MS)
+    });
+    if (!response.ok) {
+        return undefined;
+    }
+
+    const body = await response.json() as NpmPackageResponse;
+    const latest = body['dist-tags']?.latest;
+    return typeof latest === 'string' ? latest : undefined;
+}
+
+function compareVersions(leftVersion: string, rightVersion: string): number {
+    const left = parseVersion(leftVersion);
+    const right = parseVersion(rightVersion);
+
+    if (left.major !== right.major) {
+        return left.major - right.major;
+    }
+    if (left.minor !== right.minor) {
+        return left.minor - right.minor;
+    }
+    if (left.patch !== right.patch) {
+        return left.patch - right.patch;
+    }
+    if (left.prerelease === right.prerelease) {
+        return 0;
+    }
+    if (left.prerelease === undefined) {
+        return 1;
+    }
+    if (right.prerelease === undefined) {
+        return -1;
+    }
+    return left.prerelease.localeCompare(right.prerelease);
+}
+
+function parseVersion(version: string): ParsedVersion {
+    const match = /^(?<major>\d+)\.(?<minor>\d+)\.(?<patch>\d+)(?:-(?<prerelease>[0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/.exec(version);
+    if (match?.groups === undefined) {
+        throw new Error(`Invalid CLI version '${version}'.`);
+    }
+    return {
+        major: Number.parseInt(match.groups.major, 10),
+        minor: Number.parseInt(match.groups.minor, 10),
+        patch: Number.parseInt(match.groups.patch, 10),
+        prerelease: match.groups.prerelease
+    };
+}

package/src/util.ts

@@ -0,0 +1,83 @@
+// Copyright (c) 2026 Modelware. All rights reserved.
+
+import type { AstNode, LangiumCoreServices, LangiumDocument } from 'langium';
+import chalk from 'chalk';
+import * as path from 'node:path';
+import * as fs from 'node:fs';
+import { URI } from 'langium';
+
+export async function extractDocument(fileName: string, services: LangiumCoreServices, workspaceRoot?: string): Promise<LangiumDocument> {
+    const extensions = services.LanguageMetaData.fileExtensions;
+    if (!extensions.includes(path.extname(fileName))) {
+        console.error(chalk.yellow(`Please choose a file with one of these extensions: ${extensions}.`));
+        process.exit(1);
+    }
+
+    if (!fs.existsSync(fileName)) {
+        console.error(chalk.red(`File ${fileName} does not exist.`));
+        process.exit(1);
+    }
+
+    if (workspaceRoot) {
+        const resolvedRoot = path.resolve(workspaceRoot);
+        await services.shared.workspace.WorkspaceManager.initializeWorkspace([
+            { uri: URI.file(resolvedRoot).toString(), name: path.basename(resolvedRoot) }
+        ]);
+    }
+
+    const document = await services.shared.workspace.LangiumDocuments.getOrCreateDocument(URI.file(path.resolve(fileName)));
+    await services.shared.workspace.DocumentBuilder.build([document], { validation: true });
+
+    const diagnostics = document.diagnostics ?? [];
+    const validationErrors = diagnostics.filter(e => e.severity === 1);
+    if (validationErrors.length > 0) {
+        console.error(chalk.red(`There are validation errors in ${path.resolve(fileName)}:`));
+        for (const validationError of validationErrors) {
+            console.error(chalk.red(
+                `line ${validationError.range.start.line + 1}: ${validationError.message} [${document.textDocument.getText(validationError.range)}]`
+            ));
+        }
+        process.exit(1);
+    }
+
+    const validationWarnings = diagnostics.filter(e => e.severity === 2);
+    if (validationWarnings.length > 0) {
+        console.warn(chalk.yellow(`Validation warnings in ${path.resolve(fileName)}:`));
+        for (const validationWarning of validationWarnings) {
+            console.warn(chalk.yellow(
+                `line ${validationWarning.range.start.line + 1}: ${validationWarning.message} [${document.textDocument.getText(validationWarning.range)}]`
+            ));
+        }
+    }
+
+    return document;
+}
+
+export async function extractAstNode<T extends AstNode>(fileName: string, services: LangiumCoreServices, workspaceRoot?: string): Promise<T> {
+    return (await extractDocument(fileName, services, workspaceRoot)).parseResult?.value as T;
+}
+
+interface FilePathData {
+    destination: string,
+    name: string
+}
+
+export function extractDestinationAndName(filePath: string, destination: string | undefined): FilePathData {
+    filePath = path.basename(filePath, path.extname(filePath)).replace(/[.-]/g, '');
+    return {
+        destination: destination ?? path.join(path.dirname(filePath), 'generated'),
+        name: path.basename(filePath)
+    };
+}
+
+export function formatDuration(elapsedMs: number): string {
+    if (elapsedMs < 1_000) {
+        return `${elapsedMs}ms`;
+    }
+    if (elapsedMs < 60_000) {
+        return `${(elapsedMs / 1_000).toFixed(1)}s`;
+    }
+    const minutes = Math.floor(elapsedMs / 60_000);
+    const seconds = ((elapsedMs % 60_000) / 1_000).toFixed(1);
+    return `${minutes}m ${seconds}s`;
+}