@domainlang/language 0.6.0 → 0.8.0

package/src/lsp/domain-lang-node-kind-provider.ts

@@ -0,0 +1,119 @@
+/**
+ * Custom NodeKindProvider — maps DomainLang AST types to VS Code SymbolKinds.
+ *
+ * Langium's DefaultNodeKindProvider returns `SymbolKind.Field` for everything.
+ * This override provides semantically meaningful icons for the Outline view,
+ * breadcrumbs, Go to Symbol, and completion items.
+ *
+ * @module lsp/domain-lang-node-kind-provider
+ */
+
+import { DefaultNodeKindProvider } from 'langium/lsp';
+import { CompletionItemKind, SymbolKind } from 'vscode-languageserver';
+import type { AstNode, AstNodeDescription } from 'langium';
+import {
+    isDomain,
+    isBoundedContext,
+    isTeam,
+    isClassification,
+    isMetadata,
+    isContextMap,
+    isDomainMap,
+    isNamespaceDeclaration,
+    isRelationship,
+    isDomainTerm,
+    isDecision,
+    isPolicy,
+    isBusinessRule,
+    isMetadataEntry,
+} from '../generated/ast.js';
+
+/**
+ * AST type to icon kind mapping table.
+ */
+type KindMapping = readonly [
+    guard: (node: AstNode) => boolean,
+    symbolKind: SymbolKind,
+    completionKind: CompletionItemKind
+];
+
+const KIND_MAPPINGS: readonly KindMapping[] = [
+    // Strategic design
+    [isDomain,                SymbolKind.Namespace,     CompletionItemKind.Folder],
+    [isBoundedContext,        SymbolKind.Package,       CompletionItemKind.Module],
+    
+    // Tactical design
+    [isTeam,                  SymbolKind.Interface,     CompletionItemKind.Interface],
+    [isClassification,        SymbolKind.Enum,          CompletionItemKind.Enum],
+    [isMetadata,              SymbolKind.Enum,          CompletionItemKind.Enum],
+    
+    // Architecture mapping
+    [isContextMap,            SymbolKind.Package,       CompletionItemKind.Module],
+    [isDomainMap,             SymbolKind.Package,       CompletionItemKind.Module],
+    
+    // Module system
+    [isNamespaceDeclaration,  SymbolKind.Namespace,     CompletionItemKind.Module],
+    
+    // Relationships
+    [isRelationship,          SymbolKind.Interface,         CompletionItemKind.Interface],
+    
+    // Documentation & governance
+    [isDomainTerm,            SymbolKind.Field,         CompletionItemKind.Field],
+    [isDecision,              SymbolKind.Field,         CompletionItemKind.Field],
+    [isPolicy,                SymbolKind.Field,         CompletionItemKind.Field],
+    [isBusinessRule,          SymbolKind.Field,         CompletionItemKind.Field],
+    
+    // Metadata entries
+    [isMetadataEntry,         SymbolKind.Field,         CompletionItemKind.Field],
+] as const;
+
+/**
+ * Maps DomainLang AST types to semantically appropriate SymbolKind values.
+ *
+ * Used by the DocumentSymbolProvider (outline/breadcrumbs), WorkspaceSymbolProvider,
+ * and the CompletionProvider.
+ */
+export class DomainLangNodeKindProvider extends DefaultNodeKindProvider {
+
+    override getSymbolKind(node: AstNode | AstNodeDescription): SymbolKind {
+        try {
+            const astNode = this.resolveNode(node);
+            if (!astNode) return super.getSymbolKind(node);
+
+            for (const [guard, symbolKind] of KIND_MAPPINGS) {
+                if (guard(astNode)) return symbolKind;
+            }
+            return super.getSymbolKind(node);
+        } catch (error) {
+            console.error('Error in getSymbolKind:', error);
+            return super.getSymbolKind(node);
+        }
+    }
+
+    override getCompletionItemKind(node: AstNode | AstNodeDescription): CompletionItemKind {
+        try {
+            const astNode = this.resolveNode(node);
+            if (!astNode) return super.getCompletionItemKind(node);
+
+            for (const [guard, , completionKind] of KIND_MAPPINGS) {
+                if (guard(astNode)) return completionKind;
+            }
+            return super.getCompletionItemKind(node);
+        } catch (error) {
+            console.error('Error in getCompletionItemKind:', error);
+            return super.getCompletionItemKind(node);
+        }
+    }
+
+    /**
+     * Resolves an AstNode from an AstNodeDescription (which may only have a reference).
+     * Returns the node directly if it's already an AstNode.
+     */
+    private resolveNode(node: AstNode | AstNodeDescription): AstNode | undefined {
+        if ('$type' in node) {
+            return node;
+        }
+        // AstNodeDescription — resolve if possible
+        return node.node;
+    }
+}

package/src/lsp/domain-lang-scope-provider.ts

@@ -0,0 +1,250 @@
+/**
+ * DomainLang Scope Provider
+ *
+ * Implements import-based scoping with alias support and package-boundary transitive imports.
+ *
+ * **Key Concepts (per ADR-003):**
+ * - Elements are only visible if defined in current document OR explicitly imported
+ * - Import aliases control visibility: `import "pkg" as ddd` makes types visible as `ddd.*` only
+ * - Package-boundary transitive imports: External packages (.dlang/packages/) can re-export
+ * - Local file imports remain non-transitive (explicit dependencies only)
+ *
+ * **Why this matters:**
+ * Without this, Langium's DefaultScopeProvider would make ALL indexed documents visible
+ * in the global scope, which would:
+ * 1. Allow referencing elements that haven't been imported
+ * 2. Make the import system meaningless
+ * 3. Create confusion about dependencies between files
+ *
+ * @see https://langium.org/docs/recipes/scoping/ for Langium scoping patterns
+ * @see ADR-003 for alias and package-boundary design decisions
+ */
+
+import type {
+    AstNodeDescription,
+    LangiumDocument,
+    ReferenceInfo,
+    Scope,
+    Stream
+} from 'langium';
+import {
+    AstUtils,
+    DefaultScopeProvider,
+    EMPTY_SCOPE,
+    MapScope,
+    stream
+} from 'langium';
+import type { DomainLangServices } from '../domain-lang-module.js';
+import type { DomainLangIndexManager } from './domain-lang-index-manager.js';
+import type { PackageBoundaryDetector } from '../services/package-boundary-detector.js';
+import type { ImportInfo } from '../services/types.js';
+
+/**
+ * Custom scope provider that restricts cross-file references to imported documents only.
+ *
+ * Extends Langium's DefaultScopeProvider to override the global scope computation.
+ */
+export class DomainLangScopeProvider extends DefaultScopeProvider {
+    /**
+     * Reference to IndexManager for getting resolved imports with aliases.
+     */
+    private readonly domainLangIndexManager: DomainLangIndexManager;
+
+    /**
+     * Detects package boundaries for transitive import resolution.
+     */
+    private readonly packageBoundaryDetector: PackageBoundaryDetector;
+
+    constructor(services: DomainLangServices) {
+        super(services);
+        this.domainLangIndexManager = services.shared.workspace.IndexManager as DomainLangIndexManager;
+        this.packageBoundaryDetector = services.imports.PackageBoundaryDetector;
+    }
+
+    /**
+     * Override getGlobalScope to implement alias-scoped and package-boundary transitive imports.
+     *
+     * The default Langium behavior includes ALL documents in the workspace.
+     * We restrict and transform scope to:
+     * 1. The current document's own exported symbols
+     * 2. Symbols from directly imported documents (with alias prefixing)
+     * 3. Symbols from package-boundary transitive imports (external packages only)
+     *
+     * @param referenceType - The AST type being referenced
+     * @param context - Information about the reference
+     * @returns A scope containing only visible elements
+     */
+    protected override getGlobalScope(referenceType: string, context: ReferenceInfo): Scope {
+        try {
+            const document = AstUtils.getDocument(context.container);
+            if (!document) {
+                return EMPTY_SCOPE;
+            }
+
+            const descriptions = this.computeVisibleDescriptions(referenceType, document);
+            return new MapScope(descriptions);
+        } catch (error) {
+            console.error('Error in getGlobalScope:', error);
+            return EMPTY_SCOPE;
+        }
+    }
+
+    /**
+     * Computes all visible descriptions for a document, including:
+     * - Current document's own symbols
+     * - Direct imports (with alias prefixing)
+     * - Package-boundary transitive imports
+     *
+     * @param referenceType - The AST type being referenced
+     * @param document - The document making the reference
+     * @returns Stream of visible descriptions
+     */
+    private computeVisibleDescriptions(
+        referenceType: string,
+        document: LangiumDocument
+    ): Stream<AstNodeDescription> {
+        const docUri = document.uri.toString();
+        const allVisibleDescriptions: AstNodeDescription[] = [];
+
+        // 1. Always include current document's own symbols
+        const ownDescriptions = this.indexManager.allElements(referenceType)
+            .filter(desc => desc.documentUri.toString() === docUri);
+        allVisibleDescriptions.push(...ownDescriptions.toArray());
+
+        // 2. Get import info (with aliases)
+        const importInfo = this.domainLangIndexManager.getImportInfo(docUri);
+
+        // Track which documents we've already included to avoid duplicates
+        const processedUris = new Set<string>([docUri]);
+
+        // 3. Process each direct import
+        for (const imp of importInfo) {
+            if (!imp.resolvedUri || processedUris.has(imp.resolvedUri)) {
+                continue;
+            }
+
+            // Add descriptions from the directly imported document
+            this.addDescriptionsFromImport(
+                imp,
+                referenceType,
+                processedUris,
+                allVisibleDescriptions
+            );
+
+            // 4. Check for package-boundary transitive imports
+            this.addPackageBoundaryTransitiveImports(
+                imp,
+                referenceType,
+                document,
+                processedUris,
+                allVisibleDescriptions
+            );
+        }
+
+        return stream(allVisibleDescriptions);
+    }
+
+    /**
+     * Adds descriptions from a single import, applying alias prefixing if needed.
+     *
+     * @param imp - Import information (specifier, alias, resolved URI)
+     * @param referenceType - The AST type being referenced
+     * @param processedUris - Set of already-processed URIs to avoid duplicates
+     * @param output - Array to append visible descriptions to
+     */
+    private addDescriptionsFromImport(
+        imp: ImportInfo,
+        referenceType: string,
+        processedUris: Set<string>,
+        output: AstNodeDescription[]
+    ): void {
+        const descriptions = this.indexManager.allElements(referenceType)
+            .filter(desc => desc.documentUri.toString() === imp.resolvedUri);
+
+        if (imp.alias) {
+            // With alias: prefix all names with alias
+            // Example: CoreDomain → ddd.CoreDomain
+            for (const desc of descriptions) {
+                output.push(this.createAliasedDescription(desc, imp.alias));
+            }
+        } else {
+            // Without alias: use original names
+            output.push(...descriptions.toArray());
+        }
+
+        processedUris.add(imp.resolvedUri);
+    }
+
+    /**
+     * Adds package-boundary transitive imports for external packages.
+     *
+     * When document A imports package document B (e.g., index.dlang),
+     * and B imports internal package files C, D, etc. (same package root),
+     * then A can see types from C, D, etc. (package re-exports).
+     *
+     * Local file imports remain non-transitive.
+     *
+     * @param imp - Import information for the direct import
+     * @param referenceType - The AST type being referenced
+     * @param currentDocument - The document making the reference
+     * @param processedUris - Set of already-processed URIs to avoid duplicates
+     * @param output - Array to append visible descriptions to
+     */
+    private addPackageBoundaryTransitiveImports(
+        imp: ImportInfo,
+        referenceType: string,
+        currentDocument: LangiumDocument,
+        processedUris: Set<string>,
+        output: AstNodeDescription[]
+    ): void {
+        // Get the imports of the imported document (B's imports)
+        const transitiveImports = this.domainLangIndexManager.getImportInfo(imp.resolvedUri);
+
+        for (const transitiveImp of transitiveImports) {
+            if (!transitiveImp.resolvedUri || processedUris.has(transitiveImp.resolvedUri)) {
+                continue;
+            }
+
+            // Check if both documents are in the same external package
+            // (package boundary = same commit directory within .dlang/packages/)
+            const samePackage = this.packageBoundaryDetector.areInSamePackageSync(
+                imp.resolvedUri,
+                transitiveImp.resolvedUri
+            );
+
+            if (samePackage) {
+                // Within package boundary: include transitive imports
+                // Apply the top-level import's alias (if any)
+                this.addDescriptionsFromImport(
+                    {
+                        specifier: transitiveImp.specifier,
+                        alias: imp.alias, // Use the top-level import's alias
+                        resolvedUri: transitiveImp.resolvedUri
+                    },
+                    referenceType,
+                    processedUris,
+                    output
+                );
+            }
+        }
+    }
+
+    /**
+     * Creates an alias-prefixed version of a description.
+     *
+     * Example: CoreDomain with alias "ddd" → ddd.CoreDomain
+     *
+     * @param original - Original description
+     * @param alias - Import alias to prefix with
+     * @returns New description with prefixed name
+     */
+    private createAliasedDescription(
+        original: AstNodeDescription,
+        alias: string
+    ): AstNodeDescription {
+        return {
+            ...original,
+            name: `${alias}.${original.name}`
+        };
+    }
+}

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

@@ -1,7 +1,11 @@
+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 { ensureImportGraphFromDocument } from '../utils/import-utils.js';
 import { findManifestsInDirectories } from '../utils/manifest-utils.js';
+import type { ImportResolver } from '../services/import-resolver.js';
+import type { DomainLangServices } from '../domain-lang-module.js';
 
 /**
  * Langium WorkspaceManager override implementing manifest-centric import loading per PRS-010.
@@ -52,11 +56,26 @@ import { findManifestsInDirectories } from '../utils/manifest-utils.js';
 export class DomainLangWorkspaceManager extends DefaultWorkspaceManager {
     private readonly sharedServices: LangiumSharedCoreServices;
 
+    /**
+     * DI-injected import resolver. Set via late-binding because
+     * WorkspaceManager (shared module) is created before ImportResolver (language module).
+     * Falls back to standalone ensureImportGraphFromDocument when not set.
+     */
+    private importResolver: ImportResolver | undefined;
+
     constructor(services: LangiumSharedCoreServices) {
         super(services);
         this.sharedServices = services;
     }
 
+    /**
+     * Late-binds the language-specific services after DI initialization.
+     * Called from `createDomainLangServices()` after the language module is created.
+     */
+    setLanguageServices(services: DomainLangServices): void {
+        this.importResolver = services.imports.ImportResolver;
+    }
+
     override shouldIncludeEntry(entry: FileSystemNode): boolean {
         // Prevent auto-including .dlang files; we'll load via entry/import graph
         const name = UriUtils.basename(entry.uri);
@@ -74,9 +93,10 @@ export class DomainLangWorkspaceManager extends DefaultWorkspaceManager {
         // Find ALL model.yaml files in workspace (supports mixed mode)
         const manifestInfos = await this.findAllManifestsInFolders(folders);
         
-        if (manifestInfos.length === 0) {
-            return; // Pure Mode B: no manifests, all files loaded on-demand
-        }
+        // Track directories covered by manifests to avoid loading their files as standalone
+        const moduleDirectories = new Set(
+            manifestInfos.map(m => path.dirname(m.manifestPath))
+        );
 
         // Mode A or Mode C: Load each module's entry + import graph
         for (const manifestInfo of manifestInfos) {
@@ -90,7 +110,7 @@ export class DomainLangWorkspaceManager extends DefaultWorkspaceManager {
                     validation: true
                 });
 
-                const uris = await ensureImportGraphFromDocument(entryDoc, this.langiumDocuments);
+                const uris = await this.loadImportGraph(entryDoc);
                 const importedDocs: LangiumDocument[] = [];
                 for (const uriString of uris) {
                     const uri = URI.parse(uriString);
@@ -111,6 +131,128 @@ export class DomainLangWorkspaceManager extends DefaultWorkspaceManager {
                 // Continue with other modules - partial failure is acceptable
             }
         }
+
+        // Load standalone .dlang files in workspace root folders
+        // These are files NOT covered by any module's import graph
+        await this.loadStandaloneFiles(folders, moduleDirectories, collector);
+    }
+
+    /**
+     * Loads standalone .dlang files from workspace folders recursively.
+     * 
+     * Skips:
+     * - Module directories (directories with model.yaml) - loaded via import graph
+     * - `.dlang/packages` directory - package cache managed by CLI
+     * 
+     * @param folders - Workspace folders to scan
+     * @param moduleDirectories - Set of directories containing model.yaml (to skip)
+     * @param collector - Document collector callback
+     */
+    private async loadStandaloneFiles(
+        folders: WorkspaceFolder[],
+        moduleDirectories: Set<string>,
+        collector: (document: LangiumDocument) => void
+    ): Promise<void> {
+        const standaloneDocs: LangiumDocument[] = [];
+
+        for (const folder of folders) {
+            const folderPath = URI.parse(folder.uri).fsPath;
+            const docs = await this.loadDlangFilesRecursively(folderPath, moduleDirectories, collector);
+            standaloneDocs.push(...docs);
+        }
+
+        // Build all standalone documents in batch for performance
+        if (standaloneDocs.length > 0) {
+            await this.sharedServices.workspace.DocumentBuilder.build(standaloneDocs, {
+                validation: true
+            });
+        }
+    }
+
+    /**
+     * Recursively loads .dlang files from a directory.
+     * Skips module directories and the .dlang/packages cache.
+     */
+    private async loadDlangFilesRecursively(
+        dirPath: string,
+        moduleDirectories: Set<string>,
+        collector: (document: LangiumDocument) => void
+    ): Promise<LangiumDocument[]> {
+        // Skip module directories - they're loaded via import graph
+        if (moduleDirectories.has(dirPath)) {
+            return [];
+        }
+
+        // Skip .dlang/packages - package cache managed by CLI
+        const baseName = path.basename(dirPath);
+        const parentName = path.basename(path.dirname(dirPath));
+        if (baseName === 'packages' && parentName === '.dlang') {
+            return [];
+        }
+        // Also skip the .dlang directory itself (contains packages cache)
+        if (baseName === '.dlang') {
+            return [];
+        }
+
+        const docs: LangiumDocument[] = [];
+
+        try {
+            const entries = await fs.readdir(dirPath, { withFileTypes: true });
+            
+            for (const entry of entries) {
+                const entryPath = path.join(dirPath, entry.name);
+
+                if (entry.isDirectory()) {
+                    // Recurse into subdirectories
+                    const subDocs = await this.loadDlangFilesRecursively(entryPath, moduleDirectories, collector);
+                    docs.push(...subDocs);
+                } else if (this.isDlangFile(entry)) {
+                    const doc = await this.tryLoadDocument(dirPath, entry.name, collector);
+                    if (doc) {
+                        docs.push(doc);
+                    }
+                }
+            }
+        } catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.warn(`Failed to read directory ${dirPath}: ${message}`);
+        }
+
+        return docs;
+    }
+
+    /**
+     * Checks if a directory entry is a .dlang file.
+     */
+    private isDlangFile(entry: { isFile(): boolean; name: string }): boolean {
+        return entry.isFile() && entry.name.toLowerCase().endsWith('.dlang');
+    }
+
+    /**
+     * Attempts to load a document, returning undefined on failure.
+     */
+    private async tryLoadDocument(
+        folderPath: string,
+        fileName: string,
+        collector: (document: LangiumDocument) => void
+    ): Promise<LangiumDocument | undefined> {
+        const filePath = path.join(folderPath, fileName);
+        const uri = URI.file(filePath);
+        
+        // Skip if already loaded (e.g., through imports)
+        if (this.langiumDocuments.hasDocument(uri)) {
+            return undefined;
+        }
+
+        try {
+            const doc = await this.langiumDocuments.getOrCreateDocument(uri);
+            collector(doc);
+            return doc;
+        } catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.warn(`Failed to load standalone file ${filePath}: ${message}`);
+            return undefined;
+        }
     }
 
     /**
@@ -124,4 +266,45 @@ export class DomainLangWorkspaceManager extends DefaultWorkspaceManager {
         const directories = folders.map(f => URI.parse(f.uri).fsPath);
         return findManifestsInDirectories(directories);
     }
+
+    /**
+     * Recursively builds the import graph from a document.
+     * Uses the DI-injected ImportResolver when available,
+     * falling back to the standalone utility.
+     *
+     * @param document - The starting document
+     * @returns Set of URIs (as strings) for all documents in the import graph
+     */
+    private async loadImportGraph(document: LangiumDocument): Promise<Set<string>> {
+        if (!this.importResolver) {
+            // Fallback to standalone utility when DI isn't wired
+            return ensureImportGraphFromDocument(document, this.langiumDocuments);
+        }
+
+        const resolver = this.importResolver;
+        const langiumDocuments = this.langiumDocuments;
+        const visited = new Set<string>();
+
+        async function visit(doc: LangiumDocument): Promise<void> {
+            const uriString = doc.uri.toString();
+            if (visited.has(uriString)) return;
+            visited.add(uriString);
+
+            const model = doc.parseResult.value as { imports?: Array<{ uri?: string }> };
+            for (const imp of model.imports ?? []) {
+                if (!imp.uri) continue;
+
+                try {
+                    const resolvedUri = await resolver.resolveForDocument(doc, imp.uri);
+                    const childDoc = await langiumDocuments.getOrCreateDocument(resolvedUri);
+                    await visit(childDoc);
+                } catch {
+                    // Import resolution failed — validation will report the error
+                }
+            }
+        }
+
+        await visit(document);
+        return visited;
+    }
 }