@domainlang/language 0.10.0 → 0.11.0

package/src/services/workspace-manager.ts

@@ -1,5 +1,6 @@
 import path from 'node:path';
 import fs from 'node:fs/promises';
+import { createHash } from 'node:crypto';
 import YAML from 'yaml';
 import { getGlobalOptimizer } from './performance-optimizer.js';
 import { fileExists as checkFileExists, findWorkspaceRoot as findWorkspaceRootUtil } from '../utils/manifest-utils.js';
@@ -24,7 +25,8 @@ const DEFAULT_LOCK_FILES = [
 interface ManifestCache {
     readonly manifest: ModelManifest;
     readonly path: string;
-    readonly mtimeMs: number;
+    /** SHA-256 content hash for reliable change detection (PRS-017 R5) */
+    readonly contentHash: string;
 }
 
 interface LoadedLockFile {
@@ -65,7 +67,7 @@ interface WorkspaceContext {
  * - Read manifest configuration (path aliases, dependencies)
  * - Read lock file (to resolve cached package locations)
  */
-export class WorkspaceManager {
+export class ManifestManager {
     private readonly manifestFiles: readonly string[];
     private readonly lockFiles: readonly string[];
     
@@ -80,6 +82,14 @@ export class WorkspaceManager {
      * Avoids repeated directory tree walking for the same paths.
      */
     private readonly pathToRootCache = new Map<string, string>();
+
+    /**
+     * PRS-017 R11: Cached set of directories known to contain a manifest file.
+     * Populated during `findWorkspaceRoot()` walks and updated incrementally
+     * when manifest creation/deletion events arrive via `onManifestEvent()`.
+     * Prevents redundant filesystem walks for paths already explored.
+     */
+    private readonly knownManifestDirs = new Set<string>();
     
     /**
      * The currently active workspace root (set by last initialize() call).
@@ -158,7 +168,7 @@ export class WorkspaceManager {
      */
     getWorkspaceRoot(): string {
         if (!this.activeRoot) {
-            throw new Error('WorkspaceManager not initialized. Call initialize() first.');
+            throw new Error('ManifestManager not initialized. Call initialize() first.');
         }
         return this.activeRoot;
     }
@@ -172,7 +182,7 @@ export class WorkspaceManager {
      */
     getCacheDir(): string {
         if (!this.activeRoot) {
-            throw new Error('WorkspaceManager not initialized. Call initialize() first.');
+            throw new Error('ManifestManager not initialized. Call initialize() first.');
         }
         
         // If workspace root is inside .dlang/packages, find the project root
@@ -320,6 +330,28 @@ export class WorkspaceManager {
         }
     }
 
+    /**
+     * PRS-017 R11: Incrementally updates the workspace layout cache
+     * when a manifest file is created or deleted.
+     *
+     * @param manifestDir - Directory where the manifest was created/deleted
+     * @param created - true if manifest was created, false if deleted
+     */
+    onManifestEvent(manifestDir: string, created: boolean): void {
+        const normalized = path.resolve(manifestDir);
+        if (created) {
+            this.knownManifestDirs.add(normalized);
+        } else {
+            this.knownManifestDirs.delete(normalized);
+            // Invalidate path-to-root cache entries that pointed to this dir
+            for (const [startPath, root] of this.pathToRootCache) {
+                if (root === normalized) {
+                    this.pathToRootCache.delete(startPath);
+                }
+            }
+        }
+    }
+
     /**
      * Returns the path aliases from the manifest, if present.
      */
@@ -437,7 +469,7 @@ export class WorkspaceManager {
             }
         }
         
-        throw new Error('WorkspaceManager not initialized. Call initialize() first.');
+        throw new Error('ManifestManager not initialized. Call initialize() first.');
     }
 
     private async loadLockFileFromDisk(root?: string): Promise<LoadedLockFile | undefined> {
@@ -498,13 +530,16 @@ export class WorkspaceManager {
         manifestPath: string, 
         context: WorkspaceContext | undefined
     ): Promise<ModelManifest> {
-        const stat = await fs.stat(manifestPath);
+        // PRS-017 R5: Use content hash instead of mtime for reliable change detection.
+        // Content hashing is immune to mtime skew after git operations or on NFS.
+        const content = await fs.readFile(manifestPath, 'utf-8');
+        const contentHash = this.computeHash(content);
+
         if (context?.manifestCache?.path === manifestPath &&
-            context.manifestCache.mtimeMs === stat.mtimeMs) {
+            context.manifestCache.contentHash === contentHash) {
             return context.manifestCache.manifest;
         }
 
-        const content = await fs.readFile(manifestPath, 'utf-8');
         const manifest = (YAML.parse(content) ?? {}) as ModelManifest;
         
         // Validate manifest structure
@@ -514,7 +549,7 @@ export class WorkspaceManager {
             context.manifestCache = {
                 manifest,
                 path: manifestPath,
-                mtimeMs: stat.mtimeMs,
+                contentHash,
             };
         }
         return manifest;
@@ -690,11 +725,14 @@ export class WorkspaceManager {
     /**
      * Finds workspace root by walking up from startPath looking for model.yaml.
      * Uses configurable manifest files if specified in constructor options.
+     * PRS-017 R11: Consults `knownManifestDirs` before hitting the filesystem.
      */
     private async findWorkspaceRoot(startPath: string): Promise<string | undefined> {
         // Use shared utility for default case (single manifest file)
         if (this.manifestFiles.length === 1 && this.manifestFiles[0] === 'model.yaml') {
-            return findWorkspaceRootUtil(startPath);
+            const result = await findWorkspaceRootUtil(startPath);
+            if (result) this.knownManifestDirs.add(result);
+            return result;
         }
 
         // Custom logic for multiple or non-default manifest files
@@ -702,7 +740,13 @@ export class WorkspaceManager {
         const { root } = path.parse(current);
 
         while (true) {
+            // R11: Check cached knowledge first
+            if (this.knownManifestDirs.has(current)) {
+                return current;
+            }
+
             if (await this.containsManifest(current)) {
+                this.knownManifestDirs.add(current);
                 return current;
             }
 
@@ -727,4 +771,12 @@ export class WorkspaceManager {
         }
         return false;
     }
+
+    /**
+     * Computes a SHA-256 hex digest of the given content.
+     * Used for content-hash based cache validation (PRS-017 R5).
+     */
+    private computeHash(content: string): string {
+        return createHash('sha256').update(content).digest('hex');
+    }
 }

package/src/utils/import-utils.ts

@@ -1,7 +1,7 @@
 import path from 'node:path';
 import { URI, type LangiumDocument, type LangiumDocuments } from 'langium';
 import type { Model } from '../generated/ast.js';
-import { WorkspaceManager } from '../services/workspace-manager.js';
+import { ManifestManager } from '../services/workspace-manager.js';
 import { ImportResolver } from '../services/import-resolver.js';
 import type { DomainLangServices } from '../domain-lang-module.js';
 
@@ -13,13 +13,13 @@ import type { DomainLangServices } from '../domain-lang-module.js';
  * These singletons exist only for backwards compatibility with callers
  * that haven't been updated to pass through DI services.
  */
-let standaloneWorkspaceManager: WorkspaceManager | undefined;
+let standaloneManifestManager: ManifestManager | undefined;
 let standaloneImportResolver: ImportResolver | undefined;
 let lastInitializedDir: string | undefined;
 
 /**
  * Gets or creates a standalone import resolver for non-LSP contexts.
- * Creates its own WorkspaceManager if not previously initialized for this directory.
+ * Creates its own ManifestManager if not previously initialized for this directory.
  *
  * @deprecated Prefer using services.imports.ImportResolver directly.
  * @param startDir - Directory to start workspace search from
@@ -28,14 +28,14 @@ let lastInitializedDir: string | undefined;
 async function getStandaloneImportResolver(startDir: string): Promise<ImportResolver> {
   // Re-initialize if directory changed (workspace boundary)
   if (lastInitializedDir !== startDir || !standaloneImportResolver) {
-    standaloneWorkspaceManager = new WorkspaceManager();
+    standaloneManifestManager = new ManifestManager();
     try {
-      await standaloneWorkspaceManager.initialize(startDir);
+      await standaloneManifestManager.initialize(startDir);
     } catch (error) {
       console.warn(`Failed to initialize workspace: ${error instanceof Error ? error.message : String(error)}`);
     }
     const services = {
-      imports: { WorkspaceManager: standaloneWorkspaceManager }
+      imports: { ManifestManager: standaloneManifestManager }
     } as DomainLangServices;
     standaloneImportResolver = new ImportResolver(services);
     lastInitializedDir = startDir;

package/src/validation/constants.ts

@@ -35,6 +35,7 @@ export const IssueCodes = {
     ImportAbsolutePath: 'import-absolute-path',
     ImportEscapesWorkspace: 'import-escapes-workspace',
     ImportUnresolved: 'import-unresolved',
+    ImportCycleDetected: 'import-cycle-detected',
     
     // Domain Issues
     DomainNoVision: 'domain-no-vision',
@@ -283,6 +284,14 @@ export const ValidationMessages = {
         `Cannot resolve import '${uri}'.\n` +
         `Hint: Check that the file exists and the path is correct.`,
 
+    /**
+     * Error when an import creates a cycle in the dependency graph.
+     * @param cycleDisplay - Human-readable cycle path (e.g., "a.dlang → b.dlang → a.dlang")
+     */
+    IMPORT_CYCLE_DETECTED: (cycleDisplay: string) =>
+        `Import cycle detected: ${cycleDisplay}.\n` +
+        `Hint: Break the cycle by extracting shared definitions into a separate file.`,
+
     // ========================================================================
     // Context Map & Domain Map Validation
     // ========================================================================

package/src/validation/import.ts

@@ -4,8 +4,10 @@ import type { ValidationAcceptor, ValidationChecks, LangiumDocument } from 'lang
 import { Cancellation } from 'langium';
 import type { DomainLangAstType, ImportStatement } from '../generated/ast.js';
 import type { DomainLangServices } from '../domain-lang-module.js';
-import type { WorkspaceManager } from '../services/workspace-manager.js';
+import type { ManifestManager } from '../services/workspace-manager.js';
 import type { ImportResolver } from '../services/import-resolver.js';
+import { ImportResolutionError } from '../services/import-resolver.js';
+import type { DomainLangIndexManager } from '../lsp/domain-lang-index-manager.js';
 import type { ExtendedDependencySpec, ModelManifest, LockFile } from '../services/types.js';
 import { ValidationMessages, buildCodeDescription, IssueCodes } from './constants.js';
 
@@ -13,28 +15,35 @@ import { ValidationMessages, buildCodeDescription, IssueCodes } from './constant
  * Validates import statements in DomainLang.
  *
  * Uses async validators (Langium 4.x supports MaybePromise<void>) to leverage
- * the shared WorkspaceManager service with its cached manifest/lock file reading.
+ * the shared ManifestManager service with its cached manifest/lock file reading.
  *
  * Checks:
  * - All import URIs resolve to existing files
  * - External imports require manifest + alias
  * - Local path dependencies stay inside workspace  
  * - Lock file exists for external dependencies
+ * - Import cycles are detected and reported (PRS-017 R3)
  */
 export class ImportValidator {
-    private readonly workspaceManager: WorkspaceManager;
+    private readonly workspaceManager: ManifestManager;
     private readonly importResolver: ImportResolver;
+    private readonly indexManager: DomainLangIndexManager | undefined;
 
     constructor(services: DomainLangServices) {
-        this.workspaceManager = services.imports.WorkspaceManager;
+        this.workspaceManager = services.imports.ManifestManager;
         this.importResolver = services.imports.ImportResolver;
+        // IndexManager is in shared services — cast to DomainLangIndexManager for cycle detection
+        const indexMgr = services.shared.workspace.IndexManager;
+        this.indexManager = 'getCycleForDocument' in indexMgr
+            ? indexMgr as DomainLangIndexManager
+            : undefined;
     }
 
     /**
      * Validates an import statement asynchronously.
      *
      * Langium validators can return MaybePromise<void>, enabling async operations
-     * like reading manifests via the shared, cached WorkspaceManager.
+     * like reading manifests via the shared, cached ManifestManager.
      */
     async checkImportPath(
         imp: ImportStatement,
@@ -52,6 +61,9 @@ export class ImportValidator {
             return;
         }
 
+        // PRS-017 R3: Check for import cycles detected during indexing
+        this.checkImportCycle(document, imp, accept);
+
         // First, verify the import resolves to a valid file
         // This catches renamed/moved/deleted files immediately
         const resolveError = await this.validateImportResolves(imp, document, accept);
@@ -162,13 +174,21 @@ export class ImportValidator {
             }
             
             return false;
-        } catch {
-            // Resolution failed - report as unresolved import
-            accept('error', ValidationMessages.IMPORT_UNRESOLVED(imp.uri), {
+        } catch (error: unknown) {
+            // R8: Use structured error properties for precise diagnostics
+            const message = error instanceof ImportResolutionError && error.hint
+                ? `${ValidationMessages.IMPORT_UNRESOLVED(imp.uri)}: ${error.hint}`
+                : ValidationMessages.IMPORT_UNRESOLVED(imp.uri);
+
+            accept('error', message, {
                 node: imp,
                 property: 'uri',
                 codeDescription: buildCodeDescription('language.md', 'imports'),
-                data: { code: IssueCodes.ImportUnresolved, uri: imp.uri }
+                data: {
+                    code: IssueCodes.ImportUnresolved,
+                    uri: imp.uri,
+                    ...(error instanceof ImportResolutionError && { reason: error.reason }),
+                }
             });
             return true;
         }
@@ -316,7 +336,7 @@ export class ImportValidator {
                 });
             }
         } catch (error) {
-            // WorkspaceManager not initialized - skip workspace boundary check
+            // ManifestManager not initialized - skip workspace boundary check
             // This can happen for standalone files without model.yaml
             console.warn(`Could not validate workspace boundary for path dependency: ${error}`);
         }
@@ -360,7 +380,7 @@ export class ImportValidator {
                 });
             }
         } catch (error) {
-            // WorkspaceManager not initialized - log warning but continue
+            // ManifestManager not initialized - log warning but continue
             console.warn(`Could not validate cached package for ${alias}: ${error}`);
         }
     }
@@ -385,12 +405,47 @@ export class ImportValidator {
             return false;
         }
     }
+
+    // --- PRS-017 R3: Import cycle detection ---
+
+    /**
+     * Reports a warning if the current document is part of an import cycle.
+     *
+     * Cycle data is populated during indexing by DomainLangIndexManager.
+     * This method reads the pre-computed cycles and emits a diagnostic
+     * on the import statement contributing to the cycle.
+     */
+    private checkImportCycle(
+        document: LangiumDocument,
+        imp: ImportStatement,
+        accept: ValidationAcceptor
+    ): void {
+        if (!this.indexManager) return;
+
+        const cycle = this.indexManager.getCycleForDocument(document.uri.toString());
+        if (!cycle || cycle.length === 0) return;
+
+        // Build human-readable cycle display using basenames
+        const cycleDisplay = cycle
+            .map(uri => {
+                const parts = uri.split('/');
+                return parts.at(-1) ?? uri;
+            })
+            .join(' → ');
+
+        accept('warning', ValidationMessages.IMPORT_CYCLE_DETECTED(cycleDisplay), {
+            node: imp,
+            property: 'uri',
+            codeDescription: buildCodeDescription('language.md', 'imports'),
+            data: { code: IssueCodes.ImportCycleDetected }
+        });
+    }
 }
 
 /**
  * Creates validation checks for import statements.
  *
- * Returns async validators that leverage the shared WorkspaceManager
+ * Returns async validators that leverage the shared ManifestManager
  * for cached manifest/lock file reading.
  */
 export function createImportChecks(services: DomainLangServices): ValidationChecks<DomainLangAstType> {