@domainlang/language 0.10.0 → 0.11.0

package/src/lsp/domain-lang-refresh.ts

@@ -0,0 +1,205 @@
+import path from 'node:path';
+import { URI } from 'langium';
+import type { LangiumSharedServices } from 'langium/lsp';
+import { FileChangeType, type DidChangeWatchedFilesParams, type FileEvent } from 'vscode-languageserver-protocol';
+import type { DomainLangServices } from '../domain-lang-module.js';
+import { DomainLangIndexManager } from './domain-lang-index-manager.js';
+
+/**
+ * Categorized file change events.
+ * Only config files need explicit handling — .dlang changes are handled
+ * by Langium's built-in `DocumentBuilder.update()` → `isAffected()` pipeline,
+ * which DomainLangIndexManager enhances with transitive import dependency tracking.
+ */
+interface CategorizedChanges {
+    readonly manifestChanges: Array<{ uri: string; type: FileChangeType }>;
+    readonly lockFileChanges: Array<{ uri: string; type: FileChangeType }>;
+}
+
+export interface DomainLangRefreshHooks {
+    onManifestChanged?: (change: { uri: string; type: FileChangeType }) => Promise<void> | void;
+    onManifestDeleted?: (uri: string) => Promise<void> | void;
+}
+
+export interface DomainLangRefreshOptions {
+    dedupeWindowMs?: number;
+}
+
+export interface RefreshOutcome {
+    readonly configChanged: boolean;
+    readonly fullRebuildTriggered: boolean;
+}
+
+class RecentChangeDeduper {
+    private readonly dedupeWindowMs: number;
+    private readonly seen = new Map<string, number>();
+
+    constructor(dedupeWindowMs = 300) {
+        this.dedupeWindowMs = dedupeWindowMs;
+    }
+
+    dedupe(changes: FileEvent[]): FileEvent[] {
+        const now = Date.now();
+        const filtered: FileEvent[] = [];
+
+        for (const [key, timestamp] of this.seen.entries()) {
+            if (now - timestamp > this.dedupeWindowMs * 4) {
+                this.seen.delete(key);
+            }
+        }
+
+        for (const change of changes) {
+            const key = `${change.uri}|${change.type}`;
+            const previous = this.seen.get(key);
+            if (previous !== undefined && now - previous < this.dedupeWindowMs) {
+                continue;
+            }
+            this.seen.set(key, now);
+            filtered.push(change);
+        }
+
+        return filtered;
+    }
+}
+
+export function registerDomainLangRefresh(
+    shared: LangiumSharedServices,
+    domainLang: DomainLangServices,
+    hooks: DomainLangRefreshHooks = {},
+    options: DomainLangRefreshOptions = {}
+): { dispose(): void } {
+    const deduper = new RecentChangeDeduper(options.dedupeWindowMs);
+
+    return shared.lsp.DocumentUpdateHandler.onWatchedFilesChange(async (params: DidChangeWatchedFilesParams) => {
+        try {
+            const dedupedChanges = deduper.dedupe(params.changes);
+            if (dedupedChanges.length === 0) {
+                return;
+            }
+
+            await processWatchedFileChanges(
+                { changes: dedupedChanges },
+                shared,
+                domainLang,
+                hooks,
+            );
+        } catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.error(`Error handling watched file changes: ${message}`);
+        }
+    });
+}
+
+/**
+ * Processes watched file change events.
+ * 
+ * **Architecture:**
+ * - `.dlang` changes are handled entirely by Langium's own `DocumentBuilder.update()`
+ *   pipeline. `DomainLangIndexManager.isAffected()` provides transitive import
+ *   dependency tracking and specifier-sensitive matching, so Langium's single
+ *   `update()` call propagates changes correctly through the import graph.
+ * 
+ * - Config changes (model.yaml, model.lock) need explicit handling because Langium
+ *   ignores non-language files (they have no LangiumDocument). Config changes
+ *   invalidate caches and trigger a full rebuild of all loaded documents, routed
+ *   through the workspace lock to serialize with Langium's own updates.
+ */
+export async function processWatchedFileChanges(
+    params: DidChangeWatchedFilesParams,
+    shared: LangiumSharedServices,
+    domainLang: DomainLangServices,
+    hooks: DomainLangRefreshHooks = {}
+): Promise<RefreshOutcome> {
+    const categorized = categorizeChanges(params);
+    const hasConfigChanges = categorized.manifestChanges.length > 0
+        || categorized.lockFileChanges.length > 0;
+
+    if (!hasConfigChanges) {
+        // .dlang changes handled by Langium's update() → isAffected() pipeline.
+        // DomainLangIndexManager.isAffected() checks transitive import deps
+        // and specifier-sensitive matching — no second update() needed.
+        return { configChanged: false, fullRebuildTriggered: false };
+    }
+
+    // Config changes need explicit handling: invalidate caches, then rebuild.
+    // Route through the workspace lock to serialize with Langium's own updates.
+    const indexManager = shared.workspace.IndexManager as DomainLangIndexManager;
+
+    await shared.workspace.WorkspaceLock.write(async (token) => {
+        // 1. Invalidate caches
+        await processManifestChanges(categorized.manifestChanges, domainLang, hooks);
+        await processLockFileChanges(categorized.lockFileChanges, domainLang);
+        domainLang.imports.ImportResolver.clearCache();
+        indexManager.clearImportDependencies();
+
+        // 2. Rebuild ALL loaded documents — config changes affect all imports
+        const allDocUris = shared.workspace.LangiumDocuments.all
+            .map(doc => doc.uri)
+            .toArray();
+
+        if (allDocUris.length > 0) {
+            await shared.workspace.DocumentBuilder.update(allDocUris, [], token);
+        }
+    });
+
+    return { configChanged: true, fullRebuildTriggered: true };
+}
+
+function categorizeChanges(params: DidChangeWatchedFilesParams): CategorizedChanges {
+    const manifestChanges: Array<{ uri: string; type: FileChangeType }> = [];
+    const lockFileChanges: Array<{ uri: string; type: FileChangeType }> = [];
+
+    for (const change of params.changes) {
+        const uri = URI.parse(change.uri);
+        const fileName = path.basename(uri.path).toLowerCase();
+
+        if (fileName === 'model.yaml') {
+            manifestChanges.push({ uri: change.uri, type: change.type });
+        } else if (fileName === 'model.lock') {
+            lockFileChanges.push({ uri: change.uri, type: change.type });
+        }
+    }
+
+    return { manifestChanges, lockFileChanges };
+}
+
+async function processManifestChanges(
+    manifestChanges: Array<{ uri: string; type: FileChangeType }>,
+    domainLang: DomainLangServices,
+    hooks: DomainLangRefreshHooks,
+): Promise<void> {
+    for (const change of manifestChanges) {
+        domainLang.imports.ManifestManager.invalidateManifestCache();
+
+        // R11: Update workspace layout cache for the manifest's directory
+        const manifestDir = path.dirname(URI.parse(change.uri).fsPath);
+        domainLang.imports.ManifestManager.onManifestEvent(
+            manifestDir,
+            change.type !== FileChangeType.Deleted,
+        );
+
+        if (change.type === FileChangeType.Deleted) {
+            if (hooks.onManifestDeleted) {
+                await hooks.onManifestDeleted(change.uri);
+            }
+            continue;
+        }
+
+        if (hooks.onManifestChanged) {
+            await hooks.onManifestChanged(change);
+        }
+    }
+}
+
+async function processLockFileChanges(
+    lockFileChanges: Array<{ uri: string; type: FileChangeType }>,
+    domainLang: DomainLangServices,
+): Promise<void> {
+    for (const change of lockFileChanges) {
+        if (change.type === FileChangeType.Deleted) {
+            domainLang.imports.ManifestManager.invalidateLockCache();
+            continue;
+        }
+        await domainLang.imports.ManifestManager.refreshLockFile();
+    }
+}

package/src/lsp/domain-lang-workspace-manager.ts

@@ -2,6 +2,7 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import { DefaultWorkspaceManager, URI, UriUtils, type FileSystemNode, type LangiumDocument, type LangiumSharedCoreServices, type WorkspaceFolder } from 'langium';
 import type { CancellationToken } from 'vscode-languageserver-protocol';
+import type { Connection } from 'vscode-languageserver';
 import { ensureImportGraphFromDocument } from '../utils/import-utils.js';
 import { findManifestsInDirectories } from '../utils/manifest-utils.js';
 import type { ImportResolver } from '../services/import-resolver.js';
@@ -56,6 +57,12 @@ import type { DomainLangServices } from '../domain-lang-module.js';
 export class DomainLangWorkspaceManager extends DefaultWorkspaceManager {
     private readonly sharedServices: LangiumSharedCoreServices;
 
+    /**
+     * LSP connection for progress reporting (PRS-017 R7).
+     * Optional because the workspace manager can run in non-LSP contexts.
+     */
+    private readonly connection: Connection | undefined;
+
     /**
      * DI-injected import resolver. Set via late-binding because
      * WorkspaceManager (shared module) is created before ImportResolver (language module).
@@ -66,6 +73,9 @@ export class DomainLangWorkspaceManager extends DefaultWorkspaceManager {
     constructor(services: LangiumSharedCoreServices) {
         super(services);
         this.sharedServices = services;
+        // Attempt to access connection from LSP services (cast to full shared services)
+        const lspServices = services as { lsp?: { Connection?: Connection } };
+        this.connection = lspServices.lsp?.Connection;
     }
 
     /**
@@ -90,6 +100,8 @@ export class DomainLangWorkspaceManager extends DefaultWorkspaceManager {
     }
 
     protected override async loadAdditionalDocuments(folders: WorkspaceFolder[], collector: (document: LangiumDocument) => void): Promise<void> {
+        const progress = await this.createProgress('DomainLang: Indexing workspace');
+
         // Find ALL model.yaml files in workspace (supports mixed mode)
         const manifestInfos = await this.findAllManifestsInFolders(folders);
         
@@ -98,9 +110,14 @@ export class DomainLangWorkspaceManager extends DefaultWorkspaceManager {
             manifestInfos.map(m => path.dirname(m.manifestPath))
         );
 
+        progress?.report(`Found ${manifestInfos.length} module(s)`);
+
         // Mode A or Mode C: Load each module's entry + import graph
+        let moduleIdx = 0;
         for (const manifestInfo of manifestInfos) {
+            moduleIdx++;
             try {
+                progress?.report(`Loading module ${moduleIdx}/${manifestInfos.length}`);
                 const entryUri = URI.file(manifestInfo.entryPath);
                 const entryDoc = await this.langiumDocuments.getOrCreateDocument(entryUri);
                 collector(entryDoc);
@@ -134,7 +151,9 @@ export class DomainLangWorkspaceManager extends DefaultWorkspaceManager {
 
         // Load standalone .dlang files in workspace root folders
         // These are files NOT covered by any module's import graph
+        progress?.report('Loading standalone files');
         await this.loadStandaloneFiles(folders, moduleDirectories, collector);
+        progress?.done();
     }
 
     /**
@@ -307,4 +326,30 @@ export class DomainLangWorkspaceManager extends DefaultWorkspaceManager {
         await visit(document);
         return visited;
     }
+
+    // --- PRS-017 R7: Progress reporting ---
+
+    /**
+     * Creates an LSP work-done progress reporter.
+     * Returns undefined in non-LSP contexts (no connection).
+     */
+    private async createProgress(title: string): Promise<{ report(message: string): void; done(): void } | undefined> {
+        if (!this.connection) return undefined;
+
+        try {
+            const reporter = await this.connection.window.createWorkDoneProgress();
+            reporter.begin(title);
+            return {
+                report: (message: string) => {
+                    reporter.report(message);
+                },
+                done: () => {
+                    reporter.done();
+                }
+            };
+        } catch {
+            // Client may not support progress — degrade gracefully
+            return undefined;
+        }
+    }
 }

package/src/main.ts

@@ -1,11 +1,12 @@
 import { startLanguageServer } from 'langium/lsp';
 import { NodeFileSystem } from 'langium/node';
-import { createConnection, ProposedFeatures, FileChangeType } from 'vscode-languageserver/node.js';
+import { createConnection, ProposedFeatures } from 'vscode-languageserver/node.js';
 import { createDomainLangServices } from './domain-lang-module.js';
 import { ensureImportGraphFromEntryFile } from './utils/import-utils.js';
-import { DomainLangIndexManager } from './lsp/domain-lang-index-manager.js';
+import { registerDomainLangRefresh } from './lsp/domain-lang-refresh.js';
 import { registerToolHandlers } from './lsp/tool-handlers.js';
 import { URI } from 'langium';
+import { setLspRuntimeSettings } from './services/lsp-runtime-settings.js';
 
 // Create a connection to the client
 const connection = createConnection(ProposedFeatures.all);
@@ -16,6 +17,14 @@ const { shared, DomainLang } = createDomainLangServices({ connection, ...NodeFil
 // Register custom LSP request handlers for VS Code Language Model Tools (PRS-015)
 registerToolHandlers(connection, shared);
 
+shared.lsp.LanguageServer.onInitialize((params) => {
+    applyLspSettings(params.initializationOptions);
+});
+
+connection.onDidChangeConfiguration((params) => {
+    applyLspSettings(params.settings);
+});
+
 // Initialize workspace manager when language server initializes
 // Uses Langium's LanguageServer.onInitialize hook (not raw connection handler)
 // This integrates properly with Langium's initialization flow
@@ -29,7 +38,7 @@ shared.lsp.LanguageServer.onInitialize((params) => {
     if (workspaceRoot) {
         // Initialize workspace manager synchronously (just sets root path)
         // Heavy work happens in initializeWorkspace() called by Langium later
-        const workspaceManager = DomainLang.imports.WorkspaceManager;
+        const workspaceManager = DomainLang.imports.ManifestManager;
         workspaceManager.initialize(workspaceRoot).catch(error => {
             const message = error instanceof Error ? error.message : String(error);
             console.warn(`Failed to initialize workspace: ${message}`);
@@ -39,247 +48,7 @@ shared.lsp.LanguageServer.onInitialize((params) => {
     }
 });
 
-// Handle file changes for model.yaml and model.lock (PRS-010)
-// Uses Langium's built-in file watcher which already watches **/* in workspace
-// This invalidates caches when config files change externally
-shared.lsp.DocumentUpdateHandler?.onWatchedFilesChange(async (params) => {
-    try {
-        await handleFileChanges(params, DomainLang.imports.WorkspaceManager, shared, DomainLang);
-    } catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        console.error(`Error handling file change notification: ${message}`);
-        // Continue - don't crash the server
-    }
-});
-
-/** Categorized file changes */
-interface CategorizedChanges {
-    manifestChanged: boolean;
-    lockFileChanged: boolean;
-    changedDlangUris: Set<string>;
-    deletedDlangUris: Set<string>;
-    createdDlangUris: Set<string>;
-}
-
-/**
- * Categorizes file changes by type.
- */
-function categorizeChanges(
-    params: { changes: Array<{ uri: string; type: number }> },
-    workspaceManager: typeof DomainLang.imports.WorkspaceManager,
-    langServices: typeof DomainLang,
-    indexManager: DomainLangIndexManager
-): CategorizedChanges {
-    const result: CategorizedChanges = {
-        manifestChanged: false,
-        lockFileChanged: false,
-        changedDlangUris: new Set(),
-        deletedDlangUris: new Set(),
-        createdDlangUris: new Set()
-    };
-
-    for (const change of params.changes) {
-        const uri = URI.parse(change.uri);
-        const fileName = uri.path.split('/').pop() ?? '';
-        const uriString = change.uri;
-
-        if (fileName === 'model.yaml') {
-            console.warn(`model.yaml changed: ${uriString}`);
-            workspaceManager.invalidateManifestCache();
-            langServices.imports.ImportResolver.clearCache();
-            indexManager.clearImportDependencies();
-            result.manifestChanged = true;
-        } else if (fileName === 'model.lock') {
-            console.warn(`model.lock changed: ${uriString}`);
-            langServices.imports.ImportResolver.clearCache();
-            indexManager.clearImportDependencies();
-            result.lockFileChanged = true;
-        } else if (fileName.endsWith('.dlang')) {
-            if (change.type === FileChangeType.Deleted) {
-                result.deletedDlangUris.add(uriString);
-                console.warn(`DomainLang file deleted: ${uriString}`);
-            } else if (change.type === FileChangeType.Created) {
-                result.createdDlangUris.add(uriString);
-                console.warn(`DomainLang file created: ${uriString}`);
-            } else {
-                result.changedDlangUris.add(uriString);
-                console.warn(`DomainLang file changed: ${uriString}`);
-            }
-        }
-    }
-
-    return result;
-}
-
-/**
- * Rebuilds documents that depend on changed/deleted/created .dlang files.
- */
-async function rebuildAffectedDocuments(
-    changes: CategorizedChanges,
-    indexManager: DomainLangIndexManager,
-    sharedServices: typeof shared,
-    langServices: typeof DomainLang
-): Promise<void> {
-    const hasChanges = changes.changedDlangUris.size > 0 || 
-                       changes.deletedDlangUris.size > 0 || 
-                       changes.createdDlangUris.size > 0;
-    if (!hasChanges) {
-        return;
-    }
-
-    // CRITICAL: Clear ImportResolver cache BEFORE rebuilding.
-    // The WorkspaceCache only clears AFTER linking, but resolution happens
-    // DURING linking. Without this, stale cached resolutions would be used.
-    langServices.imports.ImportResolver.clearCache();
-
-    const affectedUris = collectAffectedDocuments(changes, indexManager);
-
-    if (affectedUris.size === 0) {
-        return;
-    }
-
-    console.warn(`Rebuilding ${affectedUris.size} documents affected by file changes`);
-
-    const langiumDocuments = sharedServices.workspace.LangiumDocuments;
-    const affectedDocs: URI[] = [];
-
-    for (const uriString of affectedUris) {
-        const uri = URI.parse(uriString);
-        if (langiumDocuments.hasDocument(uri)) {
-            affectedDocs.push(uri);
-            indexManager.markForReprocessing(uriString);
-        }
-    }
-
-    const deletedUriObjects = [...changes.deletedDlangUris].map(u => URI.parse(u));
-    if (affectedDocs.length > 0 || deletedUriObjects.length > 0) {
-        await sharedServices.workspace.DocumentBuilder.update(affectedDocs, deletedUriObjects);
-    }
-}
-
-/**
- * Collects all document URIs that should be rebuilt based on the changes.
- * 
- * Uses targeted matching to avoid expensive full rebuilds:
- * - For edits: rebuild documents that import the changed file (by resolved URI)
- * - For all changes: rebuild documents whose import specifiers match the path
- * 
- * The specifier matching handles renamed/moved/created files by comparing
- * import specifiers against path segments (filename, parent/filename, etc.).
- */
-function collectAffectedDocuments(
-    changes: CategorizedChanges,
-    indexManager: DomainLangIndexManager
-): Set<string> {
-    const allChangedUris = new Set([
-        ...changes.changedDlangUris, 
-        ...changes.deletedDlangUris,
-        ...changes.createdDlangUris
-    ]);
-    
-    // Get documents affected by resolved URI changes (edits to imported files)
-    const affectedByUri = indexManager.getAllAffectedDocuments(allChangedUris);
-    
-    // Get documents with import specifiers that match changed paths
-    // This catches:
-    // - File moves/renames: specifiers that previously resolved but now won't
-    // - File creations: specifiers that previously failed but might now resolve
-    // Uses fuzzy matching on path segments rather than rebuilding all imports
-    const affectedBySpecifier = indexManager.getDocumentsWithPotentiallyAffectedImports(allChangedUris);
-    
-    return new Set([...affectedByUri, ...affectedBySpecifier]);
-}
-
-/**
- * Handles all file changes including .dlang files, model.yaml, and model.lock.
- * 
- * For .dlang files: rebuilds all documents that import the changed file.
- * For config files: invalidates caches and rebuilds workspace as needed.
- */
-async function handleFileChanges(
-    params: { changes: Array<{ uri: string; type: number }> },
-    workspaceManager: typeof DomainLang.imports.WorkspaceManager,
-    sharedServices: typeof shared,
-    langServices: typeof DomainLang
-): Promise<void> {
-    const indexManager = sharedServices.workspace.IndexManager as DomainLangIndexManager;
-
-    // Categorize and process changes
-    const changes = categorizeChanges(params, workspaceManager, langServices, indexManager);
-
-    // Handle lock file changes
-    if (changes.lockFileChanged) {
-        const lockChange = params.changes.find(c => c.uri.endsWith('model.lock'));
-        if (lockChange) {
-            await handleLockFileChange(lockChange, workspaceManager);
-        }
-    }
-
-    // Rebuild documents affected by .dlang file changes
-    await rebuildAffectedDocuments(changes, indexManager, sharedServices, langServices);
-
-    // Handle config file changes
-    if (changes.manifestChanged || changes.lockFileChanged) {
-        await rebuildWorkspace(sharedServices, workspaceManager, changes.manifestChanged);
-    }
-}
-
-/**
- * Handles lock file creation, change, or deletion.
- */
-async function handleLockFileChange(
-    change: { uri: string; type: number },
-    workspaceManager: typeof DomainLang.imports.WorkspaceManager
-): Promise<void> {
-    if (change.type === FileChangeType.Changed || change.type === FileChangeType.Created) {
-        await workspaceManager.refreshLockFile();
-    } else if (change.type === FileChangeType.Deleted) {
-        workspaceManager.invalidateLockCache();
-    }
-}
-
-/**
- * Rebuilds the workspace after config file changes.
- * Uses incremental strategy: only full rebuild if dependencies changed.
- * 
- * @param sharedServices - Shared Langium services
- * @param workspaceManager - Workspace manager for manifest access
- * @param manifestChanged - Whether model.yaml changed (vs just model.lock)
- */
-async function rebuildWorkspace(
-    sharedServices: typeof shared,
-    workspaceManager: typeof DomainLang.imports.WorkspaceManager,
-    manifestChanged: boolean
-): Promise<void> {
-    try {
-        // If only lock file changed, caches are already invalidated - no rebuild needed
-        // Lock file changes mean resolved versions changed, but import resolver cache is cleared
-        // Documents will re-resolve imports on next access
-        if (!manifestChanged) {
-            console.warn('Lock file changed - caches invalidated, no rebuild needed');
-            return;
-        }
-
-        // For manifest changes, check if dependencies section actually changed
-        // If only metadata changed (name, version, etc.), no rebuild needed
-        const manifest = await workspaceManager.getManifest();
-        const hasDependencies = manifest?.dependencies && Object.keys(manifest.dependencies).length > 0;
-        
-        if (!hasDependencies) {
-            console.warn('Manifest changed but has no dependencies - skipping rebuild');
-            return;
-        }
-
-        // Dependencies exist and manifest changed - do full rebuild
-        const documents = sharedServices.workspace.LangiumDocuments.all.toArray();
-        const uris = documents.map(doc => doc.uri);
-        await sharedServices.workspace.DocumentBuilder.update([], uris);
-        console.warn(`Workspace rebuilt: ${documents.length} documents revalidated`);
-    } catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        console.error(`Failed to rebuild workspace: ${message}`);
-    }
-}
+registerDomainLangRefresh(shared, DomainLang);
 
 // Optionally start from a single entry file and follow imports.
 // Configure via env DOMAINLANG_ENTRY (absolute or workspace-relative path)
@@ -331,3 +100,26 @@ if (entryFile) {
     // No entry file configured: start normally
     startLanguageServer(shared);
 }
+
+function applyLspSettings(settings: unknown): void {
+    const lsp = extractLspSettings(settings);
+    setLspRuntimeSettings({
+        traceImports: lsp.traceImports,
+        infoLogs: lsp.infoLogs,
+    });
+}
+
+function extractLspSettings(source: unknown): { traceImports: boolean; infoLogs: boolean } {
+    const root = isRecord(source) ? source : {};
+    const domainlang = isRecord(root.domainlang) ? root.domainlang : root;
+    const lsp = isRecord(domainlang.lsp) ? domainlang.lsp : {};
+
+    return {
+        traceImports: typeof lsp.traceImports === 'boolean' ? lsp.traceImports : false,
+        infoLogs: typeof lsp.infoLogs === 'boolean' ? lsp.infoLogs : false,
+    };
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+    return typeof value === 'object' && value !== null;
+}

package/src/sdk/loader-node.ts

@@ -77,7 +77,7 @@ export async function loadModel(
     
     // Initialize workspace if directory provided
     if (options?.workspaceDir) {
-        const workspaceManager = services.imports.WorkspaceManager;
+        const workspaceManager = services.imports.ManifestManager;
         await workspaceManager.initialize(options.workspaceDir);
     }
     

package/src/sdk/validator.ts

@@ -130,8 +130,8 @@ export async function validateFile(
 
     // Initialize workspace with the specified directory or file's directory
     const workspaceDir = options.workspaceDir ?? dirname(absolutePath);
-    const workspaceManager = services.imports.WorkspaceManager;
-    await workspaceManager.initialize(workspaceDir);
+    const manifestManager = services.imports.ManifestManager;
+    await manifestManager.initialize(workspaceDir);
 
     // Load and parse the document
     const uri = URI.file(absolutePath);
@@ -152,17 +152,21 @@ export async function validateFile(
     const allDocuments = Array.from(shared.workspace.LangiumDocuments.all);
     await shared.workspace.DocumentBuilder.build(allDocuments, { validation: true });
 
-    // Collect diagnostics from the entry document
-    const diagnostics = document.diagnostics ?? [];
+    // Collect diagnostics from all loaded documents (entry + imports)
     const errors: ValidationDiagnostic[] = [];
     const warnings: ValidationDiagnostic[] = [];
 
-    for (const diagnostic of diagnostics) {
-        const validationDiag = toValidationDiagnostic(diagnostic, absolutePath);
-        if (diagnostic.severity === 1) {
-            errors.push(validationDiag);
-        } else if (diagnostic.severity === 2) {
-            warnings.push(validationDiag);
+    for (const doc of allDocuments) {
+        const diagnostics = doc.diagnostics ?? [];
+        const diagnosticFile = doc.uri.fsPath;
+
+        for (const diagnostic of diagnostics) {
+            const validationDiag = toValidationDiagnostic(diagnostic, diagnosticFile);
+            if (diagnostic.severity === 1) {
+                errors.push(validationDiag);
+            } else if (diagnostic.severity === 2) {
+                warnings.push(validationDiag);
+            }
         }
     }
 
@@ -262,18 +266,18 @@ export async function validateWorkspace(
     const servicesObj = createDomainLangServices(NodeFileSystem);
     const shared = servicesObj.shared;
     const services = servicesObj.DomainLang;
-    const workspaceManager = services.imports.WorkspaceManager;
+    const manifestManager = services.imports.ManifestManager;
 
     try {
         // Initialize workspace - this will find and load model.yaml
-        await workspaceManager.initialize(absolutePath);
+        await manifestManager.initialize(absolutePath);
     } catch (error) {
         const message = error instanceof Error ? error.message : String(error);
         throw new Error(`Failed to initialize workspace at ${workspaceDir}: ${message}`);
     }
 
     // Get the manifest to find the entry file
-    const manifest = await workspaceManager.getManifest();
+    const manifest = await manifestManager.getManifest();
     let entryFile = 'index.dlang';
     
     if (manifest?.model?.entry) {