@domainlang/language 0.9.0 → 0.11.0

package/src/main.ts

@@ -1,10 +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);
@@ -12,6 +14,17 @@ const connection = createConnection(ProposedFeatures.all);
 // Inject the shared services and language-specific services
 const { shared, DomainLang } = createDomainLangServices({ connection, ...NodeFileSystem });
 
+// 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
@@ -25,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}`);
@@ -35,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)
@@ -327,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/index.ts

@@ -142,6 +142,17 @@ export type {
     RelationshipView,
 } from './types.js';
 
+// Serializers for tool responses (browser-safe)
+export {
+    serializeNode,
+    serializeRelationship,
+    resolveName,
+    resolveMultiReference,
+    normalizeEntityType,
+    ENTITY_ALIASES,
+} from './serializers.js';
+export type { QueryEntityType, QueryEntityInput, QueryFilters } from './serializers.js';
+
 // Node.js-specific exports (will fail in browser environments)
 export { loadModel } from './loader-node.js';
 export { validateFile, validateWorkspace } from './validator.js';

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/serializers.ts

@@ -0,0 +1,213 @@
+/**
+ * AST Serialization Utilities
+ * 
+ * Converts Langium AST nodes to plain JSON objects suitable for:
+ * - LSP custom requests (JSON-RPC transport)
+ * - MCP tool responses (stdio JSON)
+ * - CLI output (JSON/YAML formats)
+ * 
+ * ## Strategy
+ * 
+ * Rather than maintaining a parallel DTO type hierarchy (DomainDto, BoundedContextDto, etc.),
+ * we use a **generic serializer** that:
+ * - Strips Langium internal properties ($container, $cstNode, $document)
+ * - Preserves $type for discriminated output
+ * - Resolves Reference<T> to referenced name strings
+ * - Resolves MultiReference<T> to arrays of names
+ * - Recursively serializes child AstNodes
+ * - Adds FQN for named elements via Query
+ * 
+ * For types with SDK-augmented properties (computed values not on raw AST),
+ * use augmentation functions that enrich the generic output.
+ * 
+ * @packageDocumentation
+ */
+
+import type { AstNode, Reference } from 'langium';
+import { isAstNode, isReference } from 'langium';
+import type { Query, RelationshipView } from './types.js';
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Types
+// ─────────────────────────────────────────────────────────────────────────────
+
+/**
+ * Canonical entity types that can be queried.
+ * Moved from CLI to SDK for sharing with LSP tools.
+ */
+export type QueryEntityType = 
+    | 'domains'
+    | 'bcs'
+    | 'teams'
+    | 'classifications'
+    | 'relationships'
+    | 'context-maps'
+    | 'domain-maps';
+
+/**
+ * All accepted entity type names, including aliases.
+ * Aliases are normalized to canonical types before query execution.
+ */
+export type QueryEntityInput = QueryEntityType
+    | 'bounded-contexts' | 'contexts'
+    | 'rels'
+    | 'cmaps'
+    | 'dmaps';
+
+/**
+ * Query filter options.
+ * Moved from CLI to SDK for sharing with LSP tools.
+ */
+export interface QueryFilters {
+    /** Filter by name (string or regex) */
+    name?: string;
+    /** Filter by fully qualified name */
+    fqn?: string;
+    /** Filter BCs by domain */
+    domain?: string;
+    /** Filter BCs by team */
+    team?: string;
+    /** Filter BCs by classification */
+    classification?: string;
+    /** Filter BCs by metadata key=value */
+    metadata?: string;
+}
+
+/**
+ * Map of entity type aliases to their canonical form.
+ */
+export const ENTITY_ALIASES: Record<string, QueryEntityType> = {
+    'bounded-contexts': 'bcs',
+    'contexts': 'bcs',
+    'rels': 'relationships',
+    'cmaps': 'context-maps',
+    'dmaps': 'domain-maps',
+};
+
+/**
+ * Normalize an entity type input (which may be an alias) to its canonical form.
+ */
+export function normalizeEntityType(input: string): QueryEntityType {
+    if (input in ENTITY_ALIASES) {
+        return ENTITY_ALIASES[input];
+    }
+    return input as QueryEntityType;
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Generic AST Serialization
+// ─────────────────────────────────────────────────────────────────────────────
+
+/**
+ * Serialize any Langium AST node to a plain JSON object.
+ * 
+ * - Strips $-prefixed internal properties ($container, $cstNode, $document)
+ * - Preserves $type for discriminated output
+ * - Resolves Reference<T> to the referenced name (string)
+ * - Resolves MultiReference<T> to an array of names
+ * - Recursively serializes child AstNode properties
+ * - Serializes arrays of AstNodes/values
+ * - Adds FQN for named elements
+ * 
+ * @param node - AST node to serialize
+ * @param query - Query instance for FQN resolution
+ * @returns Plain JSON object
+ */
+export function serializeNode(node: AstNode, query: Query): Record<string, unknown> {
+    const result: Record<string, unknown> = { $type: node.$type };
+    
+    for (const [key, value] of Object.entries(node)) {
+        // Skip Langium internals (but preserve $type)
+        if (key.startsWith('$') && key !== '$type') {
+            continue;
+        }
+        
+        if (isReference(value)) {
+            // Reference<T> → name string
+            const ref = value.ref;
+            result[key] = (ref && 'name' in ref) ? (ref as { name?: string }).name : value.$refText;
+        } else if (isAstNode(value)) {
+            // Nested AstNode → recurse
+            result[key] = serializeNode(value, query);
+        } else if (Array.isArray(value)) {
+            // Array → map each item
+            result[key] = value.map(item => {
+                if (isReference(item)) {
+                    const itemRef = item.ref;
+                    return (itemRef && 'name' in itemRef) ? (itemRef as { name?: string }).name : item.$refText;
+                } else if (isAstNode(item)) {
+                    return serializeNode(item, query);
+                } else {
+                    return item; // primitive
+                }
+            });
+        } else {
+            // Primitives pass through
+            result[key] = value;
+        }
+    }
+    
+    // Always include FQN for named elements
+    if ('name' in node && typeof (node as { name?: unknown }).name === 'string') {
+        result.fqn = query.fqn(node);
+    }
+    
+    return result;
+}
+
+/**
+ * Augment a serialized RelationshipView with computed properties.
+ * 
+ * RelationshipView is already a clean DTO (not an AstNode), but we format it
+ * consistently with other serialized types.
+ * 
+ * @param view - RelationshipView from query.relationships()
+ * @returns Serialized relationship object
+ */
+export function serializeRelationship(view: RelationshipView): Record<string, unknown> {
+    // RelationshipView.left and .right are BoundedContext (which have name property)
+    const leftName = view.left.name;
+    const rightName = view.right.name;
+    return {
+        $type: 'Relationship',
+        name: `${leftName} ${view.arrow} ${rightName}`,
+        left: leftName,
+        right: rightName,
+        arrow: view.arrow,
+        leftPatterns: view.leftPatterns,
+        rightPatterns: view.rightPatterns,
+        inferredType: view.inferredType,
+    };
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Helper: Resolve Reference
+// ─────────────────────────────────────────────────────────────────────────────
+
+/**
+ * Resolve a Reference<T> to its name string.
+ * Returns undefined if reference is unresolved.
+ * 
+ * @param ref - Reference to resolve
+ * @returns Referenced name or undefined
+ */
+export function resolveName<T extends AstNode & { name?: string }>(ref: Reference<T> | undefined): string | undefined {
+    if (!ref) return undefined;
+    return ref.ref?.name ?? ref.$refText;
+}
+
+/**
+ * Resolve a MultiReference (array of items with refs) to an array of names.
+ * Filters out unresolved references.
+ * 
+ * @param multiRef - Array of items with ref property
+ * @returns Array of resolved names
+ */
+export function resolveMultiReference<T extends { ref?: Reference<AstNode & { name?: string }> }>(
+    multiRef: T[] | undefined
+): string[] {
+    if (!multiRef) return [];
+    return multiRef
+        .map(item => item.ref?.ref?.name)
+        .filter((name): name is string => name !== undefined);
+}

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) {