@domainlang/language 0.1.82 → 0.4.1

package/src/lsp/manifest-diagnostics.ts

@@ -0,0 +1,290 @@
+/**
+ * Manifest Diagnostics Service for DomainLang.
+ * 
+ * Provides LSP diagnostics for model.yaml files by integrating the ManifestValidator
+ * with the VS Code language server protocol.
+ * 
+ * This service:
+ * - Validates model.yaml files using ManifestValidator
+ * - Converts ManifestDiagnostic to LSP Diagnostic format
+ * - Sends diagnostics to the LSP connection
+ * 
+ * @module
+ */
+
+import type { Connection } from 'vscode-languageserver';
+import { Diagnostic, DiagnosticSeverity, Position, Range } from 'vscode-languageserver-types';
+import YAML, { type Document as YAMLDocument, type YAMLMap, type Pair, isMap, isPair, isScalar } from 'yaml';
+import { ManifestValidator, type ManifestDiagnostic, type ManifestSeverity } from '../validation/manifest.js';
+import type { ModelManifest } from '../services/types.js';
+
+/**
+ * Service for validating model.yaml and sending diagnostics via LSP.
+ */
+export class ManifestDiagnosticsService {
+    private readonly validator = new ManifestValidator();
+    private connection: Connection | undefined;
+
+    /**
+     * Sets the LSP connection for sending diagnostics.
+     * Must be called before validateAndSendDiagnostics.
+     */
+    setConnection(connection: Connection): void {
+        this.connection = connection;
+    }
+
+    /**
+     * Validates a model.yaml file and sends diagnostics to the LSP connection.
+     * 
+     * @param manifestUri - URI of the model.yaml file
+     * @param content - Raw YAML content of the file
+     * @param options - Validation options
+     */
+    async validateAndSendDiagnostics(
+        manifestUri: string,
+        content: string,
+        options?: { requirePublishable?: boolean }
+    ): Promise<void> {
+        if (!this.connection) {
+            return; // No connection, skip diagnostics
+        }
+
+        const diagnostics = this.validate(content, options);
+        
+        await this.connection.sendDiagnostics({
+            uri: manifestUri,
+            diagnostics
+        });
+    }
+
+    /**
+     * Validates manifest content and returns LSP diagnostics.
+     * 
+     * @param content - Raw YAML content
+     * @param options - Validation options
+     * @returns Array of LSP diagnostics
+     */
+    validate(
+        content: string,
+        options?: { requirePublishable?: boolean }
+    ): Diagnostic[] {
+        // Parse YAML to get both the manifest object and source map
+        let yamlDoc: YAMLDocument.Parsed;
+        let manifest: ModelManifest;
+        
+        try {
+            yamlDoc = YAML.parseDocument(content);
+            
+            // Check for YAML parse errors (they're in the errors array, not thrown)
+            if (yamlDoc.errors && yamlDoc.errors.length > 0) {
+                return yamlDoc.errors.map(err => ({
+                    severity: DiagnosticSeverity.Error,
+                    range: this.yamlErrorToRange(err, content),
+                    message: `YAML parse error: ${err.message}`,
+                    source: 'domainlang'
+                }));
+            }
+            
+            manifest = (yamlDoc.toJSON() ?? {}) as ModelManifest;
+        } catch (error) {
+            // Fallback for unexpected errors
+            const message = error instanceof Error ? error.message : 'Invalid YAML syntax';
+            return [{
+                severity: DiagnosticSeverity.Error,
+                range: Range.create(Position.create(0, 0), Position.create(0, 1)),
+                message: `YAML parse error: ${message}`,
+                source: 'domainlang'
+            }];
+        }
+
+        // Run manifest validation
+        const result = this.validator.validate(manifest, options);
+        
+        // Convert to LSP diagnostics with source locations
+        return result.diagnostics.map(diag => 
+            this.toVSCodeDiagnostic(diag, yamlDoc)
+        );
+    }
+
+    /**
+     * Converts a YAML error to an LSP Range.
+     */
+    private yamlErrorToRange(err: YAML.YAMLError, _content: string): Range {
+        if (err.linePos && err.linePos.length >= 1) {
+            const startPos = err.linePos[0];
+            const startLine = startPos.line - 1; // YAML uses 1-based lines
+            const startCol = startPos.col - 1;   // YAML uses 1-based columns
+            const endPos = err.linePos.length >= 2 ? err.linePos[1] : undefined;
+            const endLine = endPos ? endPos.line - 1 : startLine;
+            const endCol = endPos ? endPos.col - 1 : startCol + 1;
+            return Range.create(
+                Position.create(startLine, startCol),
+                Position.create(endLine, endCol)
+            );
+        }
+        return Range.create(Position.create(0, 0), Position.create(0, 1));
+    }
+
+    /**
+     * Clears diagnostics for a manifest file.
+     * Call this when the file is closed or deleted.
+     */
+    async clearDiagnostics(manifestUri: string): Promise<void> {
+        if (!this.connection) {
+            return;
+        }
+
+        await this.connection.sendDiagnostics({
+            uri: manifestUri,
+            diagnostics: []
+        });
+    }
+
+    /**
+     * Converts a ManifestDiagnostic to an LSP Diagnostic.
+     */
+    private toVSCodeDiagnostic(
+        diag: ManifestDiagnostic,
+        yamlDoc: YAMLDocument.Parsed
+    ): Diagnostic {
+        const range = this.findRangeForPath(diag.path, yamlDoc);
+        
+        let message = diag.message;
+        if (diag.hint) {
+            message += `\nHint: ${diag.hint}`;
+        }
+
+        return {
+            severity: this.toVSCodeSeverity(diag.severity),
+            range,
+            message,
+            source: 'domainlang',
+            code: diag.code
+        };
+    }
+
+    /**
+     * Converts ManifestSeverity to LSP DiagnosticSeverity.
+     */
+    private toVSCodeSeverity(severity: ManifestSeverity): DiagnosticSeverity {
+        switch (severity) {
+            case 'error':
+                return DiagnosticSeverity.Error;
+            case 'warning':
+                return DiagnosticSeverity.Warning;
+            case 'info':
+                return DiagnosticSeverity.Information;
+            default:
+                return DiagnosticSeverity.Warning;
+        }
+    }
+
+    /**
+     * Finds the source range for a YAML path like "dependencies.core.version".
+     * Returns a fallback range at start of file if path not found.
+     */
+    private findRangeForPath(path: string, yamlDoc: YAMLDocument.Parsed): Range {
+        const fallback = Range.create(Position.create(0, 0), Position.create(0, 1));
+        
+        if (!yamlDoc.contents || !isMap(yamlDoc.contents)) {
+            return fallback;
+        }
+
+        const parts = path.split('.');
+        let currentNode: unknown = yamlDoc.contents;
+
+        for (const part of parts) {
+            if (!isMap(currentNode)) {
+                return fallback;
+            }
+            
+            const mapNode = currentNode as YAMLMap;
+            const item = mapNode.items.find((pair): pair is Pair => 
+                isPair(pair) && isScalar(pair.key) && String(pair.key.value) === part
+            );
+
+            if (!item) {
+                return fallback;
+            }
+
+            // If this is the last part, return the range of the key
+            if (part === parts[parts.length - 1]) {
+                const keyNode = item.key;
+                if (isScalar(keyNode) && keyNode.range) {
+                    const [start, end] = keyNode.range;
+                    return this.offsetsToRange(start, end, yamlDoc.toString());
+                }
+            }
+
+            currentNode = item.value;
+        }
+
+        return fallback;
+    }
+
+    /**
+     * Converts byte offsets to a VS Code Range using line/column calculation.
+     */
+    private offsetsToRange(startOffset: number, endOffset: number, content: string): Range {
+        const lines = content.split('\n');
+        let currentOffset = 0;
+        let startLine = 0;
+        let startCol = 0;
+        let endLine = 0;
+        let endCol = 0;
+        let foundStart = false;
+        let foundEnd = false;
+
+        for (let lineNum = 0; lineNum < lines.length && !foundEnd; lineNum++) {
+            const lineLength = lines[lineNum].length + 1; // +1 for newline
+
+            if (!foundStart && currentOffset + lineLength > startOffset) {
+                startLine = lineNum;
+                startCol = startOffset - currentOffset;
+                foundStart = true;
+            }
+
+            if (!foundEnd && currentOffset + lineLength >= endOffset) {
+                endLine = lineNum;
+                endCol = endOffset - currentOffset;
+                foundEnd = true;
+            }
+
+            currentOffset += lineLength;
+        }
+
+        return Range.create(
+            Position.create(startLine, startCol),
+            Position.create(endLine, endCol)
+        );
+    }
+}
+
+/**
+ * Singleton instance for use across the language server.
+ */
+let manifestDiagnosticsService: ManifestDiagnosticsService | undefined;
+
+/**
+ * Gets or creates the manifest diagnostics service singleton.
+ */
+export function getManifestDiagnosticsService(): ManifestDiagnosticsService {
+    if (!manifestDiagnosticsService) {
+        manifestDiagnosticsService = new ManifestDiagnosticsService();
+    }
+    return manifestDiagnosticsService;
+}
+
+/**
+ * Helper to validate a manifest URI with the given content.
+ * Convenience function for use in file watchers.
+ */
+export async function validateManifestFile(
+    connection: Connection,
+    manifestUri: string,
+    content: string
+): Promise<void> {
+    const service = getManifestDiagnosticsService();
+    service.setConnection(connection);
+    await service.validateAndSendDiagnostics(manifestUri, content);
+}

package/src/sdk/index.ts

@@ -123,6 +123,4 @@ export type {
     LoadOptions,
     BcQueryBuilder,
     RelationshipView,
-    AugmentedBoundedContext,
-    AugmentedDomain,
 } from './types.js';

package/src/sdk/loader-node.ts

@@ -25,14 +25,16 @@ import { isModel } from '../generated/ast.js';
 import { createDomainLangServices } from '../domain-lang-module.js';
 import type { LoadOptions, QueryContext } from './types.js';
 import { fromModel, augmentModel } from './query.js';
+import { ensureImportGraphFromDocument } from '../utils/import-utils.js';
 
 /**
  * Loads a DomainLang model from a file on disk.
  * 
  * **Node.js only** - uses file system APIs.
  * 
- * Note: This loads a single file. For multi-file models with imports,
- * consider using the WorkspaceManager or hosting an LSP server.
+ * Supports multi-file models with imports: all imported files are
+ * automatically loaded and linked. Use `documents` in the result
+ * to see all loaded files.
  * 
  * @param entryFile - Path to the entry .dlang file
  * @param options - Optional load configuration
@@ -43,13 +45,16 @@ import { fromModel, augmentModel } from './query.js';
  * ```typescript
  * import { loadModel } from '@domainlang/language/sdk/loader-node';
  * 
- * const { query, model } = await loadModel('./domains.dlang', {
+ * const { query, model, documents } = await loadModel('./domains.dlang', {
  *   workspaceDir: process.cwd()
  * });
  * 
+ * // Query spans all imported files
  * for (const bc of query.boundedContexts()) {
  *   console.log(bc.name);
  * }
+ * 
+ * console.log(`Loaded ${documents.length} files`);
  * ```
  */
 export async function loadModel(
@@ -89,9 +94,19 @@ export async function loadModel(
     
     // Register document and build it
     shared.workspace.LangiumDocuments.addDocument(document);
-    await shared.workspace.DocumentBuilder.build([document], { validation: true });
+    await shared.workspace.DocumentBuilder.build([document], { validation: false });
+    
+    // Traverse import graph to load all imported files
+    const importedUris = await ensureImportGraphFromDocument(
+        document, 
+        shared.workspace.LangiumDocuments
+    );
     
-    // Wait for document to be fully processed
+    // Build all imported documents with validation
+    const allDocuments = Array.from(shared.workspace.LangiumDocuments.all);
+    await shared.workspace.DocumentBuilder.build(allDocuments, { validation: true });
+    
+    // Wait for entry document to be fully processed
     if (document.state < DocumentState.Validated) {
         throw new Error(`Document not fully processed: ${absolutePath}`);
     }
@@ -112,11 +127,16 @@ export async function loadModel(
         throw new Error(`Document root is not a Model: ${entryFile}`);
     }
     
-    // Augment AST nodes with SDK properties
-    augmentModel(model);
+    // Augment AST nodes with SDK properties for all loaded models
+    for (const doc of allDocuments) {
+        const docModel = doc.parseResult.value;
+        if (isModel(docModel)) {
+            augmentModel(docModel);
+        }
+    }
     
-    // Collect all document URIs
-    const documentUris: URI[] = Array.from(shared.workspace.LangiumDocuments.all).map(doc => doc.uri);
+    // Collect all document URIs from the import graph
+    const documentUris: URI[] = Array.from(importedUris).map(uriStr => URI.parse(uriStr));
     
     return {
         model,

package/src/sdk/types.ts

@@ -305,29 +305,6 @@ export interface RelationshipView {
     readonly astNode: Relationship;
 }
 
-/**
- * Augmented BoundedContext with SDK-resolved properties.
- * These properties are computed during model loading using precedence rules.
- * 
- * Property names follow the PRS design: natural names that "just work" with
- * IDE autocomplete. Use `resolved*` prefix to avoid conflicts with existing
- * AST properties while maintaining discoverability.
- * 
- * @deprecated Since SDK now uses module augmentation in ast-augmentation.ts,
- * this type alias is only kept for backwards compatibility. Use BoundedContext
- * directly after importing the SDK.
- */
-export type AugmentedBoundedContext = BoundedContext;
-
-/**
- * Augmented Domain with SDK-resolved properties.
- * 
- * @deprecated Since SDK now uses module augmentation in ast-augmentation.ts,
- * this type alias is only kept for backwards compatibility. Use Domain
- * directly after importing the SDK.
- */
-export type AugmentedDomain = Domain;
-
 /**
  * Internal index structure for O(1) lookups.
  * Not exported from public API.

package/src/services/dependency-analyzer.ts

@@ -8,42 +8,12 @@
  * - Version policy enforcement
  */
 
-import type { LockFile } from './git-url-resolver.js';
+import type { LockFile, DependencyTreeNode, ReverseDependency, VersionPolicy } from './types.js';
 import path from 'node:path';
 import fs from 'node:fs/promises';
 import os from 'node:os';
 import YAML from 'yaml';
-
-export interface DependencyTreeNode {
-    /** Package identifier */
-    packageKey: string;
-    /** Locked version */
-    version: string;
-    /** Commit hash */
-    commit: string;
-    /** Direct dependencies */
-    dependencies: DependencyTreeNode[];
-    /** Depth in tree (0 = root) */
-    depth: number;
-}
-
-export interface ReverseDependency {
-    /** Package that depends on the target */
-    dependentPackage: string;
-    /** Version of the dependent package */
-    version: string;
-    /** Type: direct or transitive */
-    type: 'direct' | 'transitive';
-}
-
-export interface VersionPolicy {
-    /** Policy name: latest, stable, or specific version */
-    policy: 'latest' | 'stable' | 'pinned';
-    /** Resolved version */
-    version: string;
-    /** Available versions for policy */
-    availableVersions?: string[];
-}
+import { sortVersionsDescending, isPreRelease } from './semver.js';
 
 /**
  * Analyzes dependency relationships and provides visualization/analysis tools.
@@ -109,7 +79,7 @@ export class DependencyAnalyzer {
         if (visited.has(packageKey)) {
             return {
                 packageKey,
-                version: locked.version,
+                ref: locked.ref,
                 commit: locked.commit,
                 dependencies: [], // Don't recurse into already visited
                 depth,
@@ -133,7 +103,7 @@ export class DependencyAnalyzer {
 
         return {
             packageKey,
-            version: locked.version,
+            ref: locked.ref,
             commit: locked.commit,
             dependencies: children,
             depth,
@@ -168,7 +138,7 @@ export class DependencyAnalyzer {
                     if (dep.source === targetPackage) {
                         reverseDeps.push({
                             dependentPackage: 'root',
-                            version: 'workspace',
+                            ref: 'workspace',
                             type: 'direct',
                         });
                     }
@@ -190,7 +160,7 @@ export class DependencyAnalyzer {
             if (packageDeps[targetPackage]) {
                 reverseDeps.push({
                     dependentPackage: packageKey,
-                    version: locked.version,
+                    ref: locked.ref,
                     type: 'direct',
                 });
             }
@@ -207,11 +177,11 @@ export class DependencyAnalyzer {
 
         const formatNode = (node: DependencyTreeNode, prefix: string, isLast: boolean): void => {
             const branch = isLast ? '└── ' : '├── ';
-            const versionStr = options.showCommits
-                ? `${node.version} (${node.commit.substring(0, 7)})`
-                : node.version;
+            const refStr = options.showCommits
+                ? `${node.ref} (${node.commit.substring(0, 7)})`
+                : node.ref;
             
-            lines.push(`${prefix}${branch}${node.packageKey}@${versionStr}`);
+            lines.push(`${prefix}${branch}${node.packageKey}@${refStr}`);
 
             const childPrefix = prefix + (isLast ? '    ' : '│   ');
             node.dependencies.forEach((child, index) => {
@@ -273,38 +243,38 @@ export class DependencyAnalyzer {
     }
 
     /**
-     * Resolves version policies (latest, stable) to concrete versions.
+     * Resolves ref policies (latest, stable) to concrete refs.
      */
     async resolveVersionPolicy(
-        packageKey: string,
+        _packageKey: string,
         policy: string,
-        availableVersions: string[]
+        availableRefs: string[]
     ): Promise<VersionPolicy> {
         if (policy === 'latest') {
-            // Return the most recent version
-            const sorted = this.sortVersions(availableVersions);
+            // Return the most recent ref
+            const sorted = sortVersionsDescending(availableRefs);
             return {
                 policy: 'latest',
-                version: sorted[0] || 'main',
-                availableVersions: sorted,
+                ref: sorted[0] || 'main',
+                availableRefs: sorted,
             };
         }
 
         if (policy === 'stable') {
-            // Return the most recent stable version (exclude pre-release)
-            const stable = availableVersions.filter(v => !this.isPreRelease(v));
-            const sorted = this.sortVersions(stable);
+            // Return the most recent stable ref (exclude pre-release)
+            const stable = availableRefs.filter(v => !isPreRelease(v));
+            const sorted = sortVersionsDescending(stable);
             return {
                 policy: 'stable',
-                version: sorted[0] || 'main',
-                availableVersions: sorted,
+                ref: sorted[0] || 'main',
+                availableRefs: sorted,
             };
         }
 
-        // Pinned version
+        // Pinned ref
         return {
             policy: 'pinned',
-            version: policy,
+            ref: policy,
         };
     }
 
@@ -348,34 +318,4 @@ export class DependencyAnalyzer {
             return {};
         }
     }
-
-    /**
-     * Sorts versions in descending order (newest first).
-     */
-    private sortVersions(versions: string[]): string[] {
-        return versions.sort((a, b) => {
-            // Simple lexicographic sort (good enough for basic semver)
-            // Production: use semver library
-            const aParts = a.replace(/^v/, '').split('.').map(Number);
-            const bParts = b.replace(/^v/, '').split('.').map(Number);
-
-            for (let i = 0; i < Math.max(aParts.length, bParts.length); i++) {
-                const aNum = aParts[i] || 0;
-                const bNum = bParts[i] || 0;
-                if (aNum !== bNum) {
-                    return bNum - aNum; // Descending
-                }
-            }
-
-            return 0;
-        });
-    }
-
-    /**
-     * Checks if a version is a pre-release.
-     */
-    private isPreRelease(version: string): boolean {
-        const clean = version.replace(/^v/, '');
-        return /-(alpha|beta|rc|pre|dev)/.test(clean);
-    }
 }