@domainlang/language 0.10.0 → 0.12.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/lsp/tool-handlers.ts

@@ -337,54 +337,68 @@ function executeListQuery(
     entityType: QueryEntityType,
     filters: QueryFilters
 ): Record<string, unknown>[] {
-    switch (entityType) {
-        case 'domains': {
-            let builder = query.domains();
-            if (filters.name) builder = builder.withName(filters.name);
-            if (filters.fqn) builder = builder.withFqn(filters.fqn);
-            return builder.toArray().map((d) => serializeNode(d, query));
-        }
-        case 'bcs': {
-            let builder = query.boundedContexts();
-            if (filters.domain) builder = builder.inDomain(filters.domain);
-            if (filters.team) builder = builder.withTeam(filters.team);
-            if (filters.classification)
-                builder = builder.withClassification(filters.classification);
-            if (filters.metadata) {
-                const [key, value] = filters.metadata.split('=');
-                builder = builder.withMetadata(key, value);
-            }
-            if (filters.name) builder = builder.withName(filters.name) as ReturnType<Query['boundedContexts']>;
-            if (filters.fqn) builder = builder.withFqn(filters.fqn) as ReturnType<Query['boundedContexts']>;
-            return builder.toArray().map((bc) => serializeNode(bc, query));
-        }
-        case 'teams': {
-            let builder = query.teams();
-            if (filters.name) builder = builder.withName(filters.name);
-            return builder.toArray().map((t) => serializeNode(t, query));
-        }
-        case 'classifications': {
-            let builder = query.classifications();
-            if (filters.name) builder = builder.withName(filters.name);
-            return builder.toArray().map((c) => serializeNode(c, query));
-        }
-        case 'relationships': {
-            const rels = query.relationships().toArray();
-            return rels.map((r) => serializeRelationship(r));
-        }
-        case 'context-maps': {
-            let builder = query.contextMaps();
-            if (filters.name) builder = builder.withName(filters.name);
-            return builder.toArray().map((cm) => serializeNode(cm, query));
-        }
-        case 'domain-maps': {
-            let builder = query.domainMaps();
-            if (filters.name) builder = builder.withName(filters.name);
-            return builder.toArray().map((dm) => serializeNode(dm, query));
-        }
-        default:
-            return [];
+    const handlers: Record<QueryEntityType, (activeQuery: Query, activeFilters: QueryFilters) => Record<string, unknown>[]> = {
+        domains: listDomains,
+        bcs: listBoundedContexts,
+        teams: listTeams,
+        classifications: listClassifications,
+        relationships: listRelationships,
+        'context-maps': listContextMaps,
+        'domain-maps': listDomainMaps,
+    };
+
+    return handlers[entityType](query, filters);
+}
+
+function listDomains(query: Query, filters: QueryFilters): Record<string, unknown>[] {
+    let builder = query.domains();
+    if (filters.name) builder = builder.withName(filters.name);
+    if (filters.fqn) builder = builder.withFqn(filters.fqn);
+    return builder.toArray().map((domain) => serializeNode(domain, query));
+}
+
+function listBoundedContexts(query: Query, filters: QueryFilters): Record<string, unknown>[] {
+    let builder = query.boundedContexts();
+    if (filters.domain) builder = builder.inDomain(filters.domain);
+    if (filters.team) builder = builder.withTeam(filters.team);
+    if (filters.classification) {
+        builder = builder.withClassification(filters.classification);
     }
+    if (filters.metadata) {
+        const [key, value] = filters.metadata.split('=');
+        builder = builder.withMetadata(key, value);
+    }
+    if (filters.name) builder = builder.withName(filters.name) as ReturnType<Query['boundedContexts']>;
+    if (filters.fqn) builder = builder.withFqn(filters.fqn) as ReturnType<Query['boundedContexts']>;
+    return builder.toArray().map((boundedContext) => serializeNode(boundedContext, query));
+}
+
+function listTeams(query: Query, filters: QueryFilters): Record<string, unknown>[] {
+    let builder = query.teams();
+    if (filters.name) builder = builder.withName(filters.name);
+    return builder.toArray().map((team) => serializeNode(team, query));
+}
+
+function listClassifications(query: Query, filters: QueryFilters): Record<string, unknown>[] {
+    let builder = query.classifications();
+    if (filters.name) builder = builder.withName(filters.name);
+    return builder.toArray().map((classification) => serializeNode(classification, query));
+}
+
+function listRelationships(query: Query, _filters: QueryFilters): Record<string, unknown>[] {
+    return query.relationships().toArray().map((relationship) => serializeRelationship(relationship));
+}
+
+function listContextMaps(query: Query, filters: QueryFilters): Record<string, unknown>[] {
+    let builder = query.contextMaps();
+    if (filters.name) builder = builder.withName(filters.name);
+    return builder.toArray().map((contextMap) => serializeNode(contextMap, query));
+}
+
+function listDomainMaps(query: Query, filters: QueryFilters): Record<string, unknown>[] {
+    let builder = query.domainMaps();
+    if (filters.name) builder = builder.withName(filters.name);
+    return builder.toArray().map((domainMap) => serializeNode(domainMap, query));
 }
 
 /**