@domainlang/language 0.5.2 → 0.7.0

package/src/main.ts

@@ -1,8 +1,9 @@
 import { startLanguageServer } from 'langium/lsp';
 import { NodeFileSystem } from 'langium/node';
-import { createConnection, ProposedFeatures } from 'vscode-languageserver/node.js';
+import { createConnection, ProposedFeatures, FileChangeType } 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 { URI } from 'langium';
 
 // Create a connection to the client
@@ -11,29 +12,269 @@ const connection = createConnection(ProposedFeatures.all);
 // Inject the shared services and language-specific services
 const { shared, DomainLang } = createDomainLangServices({ connection, ...NodeFileSystem });
 
-// Initialize workspace on connection
-connection.onInitialize(async (params) => {
-    const workspaceRoot = params.rootUri ? URI.parse(params.rootUri).fsPath : undefined;
+// 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
+shared.lsp.LanguageServer.onInitialize((params) => {
+    // Use workspaceFolders (preferred) over deprecated rootUri
+    const folders = params.workspaceFolders;
+    const workspaceRoot = folders?.[0]?.uri
+        ? URI.parse(folders[0].uri).fsPath
+        : undefined;
     
     if (workspaceRoot) {
-        try {
-            // Initialize workspace manager
-            const workspaceManager = DomainLang.imports.WorkspaceManager;
-            await workspaceManager.initialize(workspaceRoot);
-            console.warn(`DomainLang workspace initialized: ${workspaceRoot}`);
-        } catch (error) {
+        // Initialize workspace manager synchronously (just sets root path)
+        // Heavy work happens in initializeWorkspace() called by Langium later
+        const workspaceManager = DomainLang.imports.WorkspaceManager;
+        workspaceManager.initialize(workspaceRoot).catch(error => {
             const message = error instanceof Error ? error.message : String(error);
             console.warn(`Failed to initialize workspace: ${message}`);
             // Continue without workspace - local imports will still work
+        });
+        console.warn(`DomainLang workspace root: ${workspaceRoot}`);
+    }
+});
+
+// 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();
+            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);
     
-    return {
-        capabilities: {
-            // Language server capabilities are configured by Langium
+    // 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}`);
+    }
+}
 
 // Optionally start from a single entry file and follow imports.
 // Configure via env DOMAINLANG_ENTRY (absolute or workspace-relative path)
@@ -63,7 +304,8 @@ if (entryFile) {
     };
 
     // Initial load from entry file, then start the server
-    reloadFromEntry().finally(() => startLanguageServer(shared));
+    await reloadFromEntry();
+    startLanguageServer(shared);
 
     // Any change within the loaded graph should trigger a reload from the entry
     shared.workspace.TextDocuments.onDidChangeContent(async (event) => {

package/src/services/import-resolver.ts

@@ -1,35 +1,110 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
-import { URI, type LangiumDocument } from 'langium';
+import { DocumentState, SimpleCache, WorkspaceCache, URI, type LangiumDocument, type LangiumSharedCoreServices } from 'langium';
 import { WorkspaceManager } from './workspace-manager.js';
 import type { DomainLangServices } from '../domain-lang-module.js';
 import type { LockFile } from './types.js';
 
+/**
+ * Cache interface for import resolution.
+ * Uses WorkspaceCache in LSP mode (clears on ANY document change) or SimpleCache in standalone mode.
+ */
+type ResolverCache = WorkspaceCache<string, URI> | SimpleCache<string, URI>;
+
 /**
  * ImportResolver resolves import statements using manifest-centric rules (PRS-010).
  *
  * Import Types (PRS-010):
  * - Local relative: ./path, ../path → Directory-first resolution
  * - Path aliases: @/path, @alias/path → Configurable in model.yaml paths section
- * - External: owner/package → Manifest dependencies
+ * - External: dependency key → Manifest dependencies (key can be owner/package or an alias that maps to source)
  *
  * Directory-First Resolution:
  * - ./types → ./types/index.dlang → ./types.dlang
  * - Module entry defaults to index.dlang (no model.yaml required)
+ * 
+ * Caching Strategy (uses Langium standard infrastructure):
+ * - LSP mode: Uses `WorkspaceCache` - clears on ANY document change in workspace
+ *   This is necessary because file moves/deletes affect resolution of OTHER documents
+ * - Standalone mode: Uses `SimpleCache` - manual invalidation via clearCache()
+ * 
+ * Why WorkspaceCache (not DocumentCache)?
+ * - DocumentCache only invalidates when the KEYED document changes
+ * - But import resolution can break when IMPORTED files are moved/deleted
+ * - Example: index.dlang imports @domains → domains/index.dlang
+ *   If domains/index.dlang is moved, index.dlang's cache entry must be cleared
+ *   DocumentCache wouldn't clear it (index.dlang didn't change)
+ *   WorkspaceCache clears on ANY change, ensuring correct re-resolution
+ * 
+ * @see https://langium.org/docs/recipes/caching/ for Langium caching patterns
  */
 export class ImportResolver {
     private readonly workspaceManager: WorkspaceManager;
+    /**
+     * Workspace-level cache for resolved import URIs.
+     * In LSP mode: WorkspaceCache - clears when ANY document changes (correct for imports)
+     * In standalone mode: SimpleCache - manual invalidation via clearCache()
+     */
+    private readonly resolverCache: ResolverCache;
 
+    /**
+     * Creates an ImportResolver.
+     * 
+     * @param services - DomainLang services. If `services.shared` is present, uses WorkspaceCache
+     *                   for automatic invalidation. Otherwise uses SimpleCache for standalone mode.
+     */
     constructor(services: DomainLangServices) {
         this.workspaceManager = services.imports.WorkspaceManager;
+        
+        // Use Langium's WorkspaceCache when shared services are available (LSP mode)
+        // Fall back to SimpleCache for standalone utilities (SDK, CLI)
+        const shared = (services as DomainLangServices & { shared?: LangiumSharedCoreServices }).shared;
+        if (shared) {
+            // LSP mode: WorkspaceCache with DocumentState.Linked
+            // 
+            // This follows the standard pattern used by TypeScript, rust-analyzer, gopls:
+            // - Cache is valid for a "workspace snapshot"
+            // - Invalidates after a batch of changes completes linking (debounced ~300ms)
+            // - Invalidates immediately on file deletion
+            // - Does NOT invalidate during typing (would be too expensive)
+            //
+            // DocumentState.Linked is the right phase because:
+            // - Import resolution is needed during linking
+            // - By the time linking completes, we know which files exist
+            // - File renames appear as delete+create, triggering immediate invalidation
+            this.resolverCache = new WorkspaceCache(shared, DocumentState.Linked);
+        } else {
+            // Standalone mode: simple key-value cache, manual invalidation
+            this.resolverCache = new SimpleCache<string, URI>();
+        }
+    }
+
+    /**
+     * Clears the entire import resolution cache.
+     * In LSP mode, this is also triggered automatically by WorkspaceCache on any document change.
+     * Call explicitly when model.yaml or model.lock changes.
+     */
+    clearCache(): void {
+        this.resolverCache.clear();
     }
 
     /**
      * Resolve an import specifier relative to a Langium document.
+     * Results are cached using WorkspaceCache (clears on any workspace change).
      */
     async resolveForDocument(document: LangiumDocument, specifier: string): Promise<URI> {
+        // Cache key combines document URI + specifier for uniqueness
+        const cacheKey = `${document.uri.toString()}|${specifier}`;
+        const cached = this.resolverCache.get(cacheKey);
+        if (cached) {
+            return cached;
+        }
+
+        // Resolve and cache
         const baseDir = path.dirname(document.uri.fsPath);
-        return this.resolveFrom(baseDir, specifier);
+        const result = await this.resolveFrom(baseDir, specifier);
+        this.resolverCache.set(cacheKey, result);
+        return result;
     }
 
     /**
@@ -121,7 +196,10 @@ export class ImportResolver {
     /**
      * Resolves an external dependency via manifest.
      * 
-     * NEW FORMAT (PRS-010): Import specifier is owner/package format.
+        * Import specifier is a dependency key from model.yaml.
+        * - Recommended: key is owner/package.
+        * - Optional: key is an alias with an explicit source.
+     * The LSP only resolves to cached packages - no network calls.
      */
     private async resolveExternalDependency(specifier: string): Promise<URI> {
         const manifest = await this.workspaceManager.getManifest();
@@ -143,19 +221,20 @@ export class ImportResolver {
             );
         }
 
-        const mapped = await this.workspaceManager.resolveDependencyImport(specifier);
-        if (!mapped) {
+        // Use WorkspaceManager to resolve from cache (read-only, no network)
+        const resolved = await this.workspaceManager.resolveDependencyPath(specifier);
+        if (!resolved) {
             throw new Error(
-                `Dependency '${specifier}' not found in model.yaml.\n` +
+                `Dependency '${specifier}' not found in model.yaml or not installed.\n` +
                 `Hint: Add it to your dependencies:\n` +
                 `  dependencies:\n` +
                 `    ${specifier}:\n` +
-                `      ref: v1.0.0`
+                `      ref: v1.0.0\n` +
+                `Then run 'dlang install' to fetch it.`
             );
         }
 
-        const git = await this.workspaceManager.getGitResolver();
-        return git.resolve(mapped, { allowNetwork: false });
+        return URI.file(resolved);
     }
 
     /**
@@ -284,8 +363,8 @@ async function assertFileExists(filePath: string, original: string): Promise<voi
         await fs.access(filePath);
     } catch {
         throw new Error(
-            `Import file not found: '${original}'.\\n` +
-            `Resolved path: ${filePath}\\n` +
+            `Import file not found: '${original}'.\n` +
+            `Resolved path: ${filePath}\n` +
             `Hint: Check that the file exists and the path is correct.`
         );
     }

package/src/services/types.ts

@@ -187,8 +187,8 @@ export interface LockedDependency {
  * @example
  * ```yaml
  * paths:
- *   "@/": "./src/"
- *   "@shared/": "./libs/shared/"
+ *   "@": "./src"
+ *   "@shared": "./libs/shared"
  * ```
  */
 export type PathAliases = Readonly<Record<string, string>>;