@domainlang/language 0.1.81 → 0.4.0

package/src/services/workspace-manager.ts

@@ -4,7 +4,15 @@ import YAML from 'yaml';
 import { DependencyResolver } from './dependency-resolver.js';
 import { GitUrlResolver } from './git-url-resolver.js';
 import { getGlobalOptimizer } from './performance-optimizer.js';
-import type { LockFile, LockedDependency } from './git-url-resolver.js';
+import type { 
+    LockFile, 
+    LockedDependency, 
+    ModelManifest, 
+    DependencySpec, 
+    ExtendedDependencySpec, 
+    PathAliases,
+    WorkspaceManagerOptions 
+} from './types.js';
 
 const DEFAULT_MANIFEST_FILES = [
     'model.yaml'
@@ -16,27 +24,6 @@ const DEFAULT_LOCK_FILES = [
 
 const JSON_SPACE = 2;
 
-export interface WorkspaceManagerOptions {
-    readonly autoResolve?: boolean;
-    readonly manifestFiles?: readonly string[];
-    readonly lockFiles?: readonly string[];
-}
-
-interface ManifestDependency {
-    readonly source?: string;
-    readonly version?: string;
-    readonly description?: string;
-}
-
-interface ModelManifest {
-    readonly model?: {
-        readonly name?: string;
-        readonly version?: string;
-        readonly entry?: string;
-    };
-    readonly dependencies?: Record<string, ManifestDependency>;
-}
-
 interface ManifestCache {
     readonly manifest: ModelManifest;
     readonly path: string;
@@ -108,6 +95,15 @@ export class WorkspaceManager {
         return undefined;
     }
 
+    /**
+     * Returns the parsed manifest when present, otherwise undefined.
+     * Uses cached contents when unchanged on disk.
+     */
+    async getManifest(): Promise<ModelManifest | undefined> {
+        await this.ensureInitialized();
+        return this.loadManifest();
+    }
+
     /**
      * Returns the cached lock file or triggers resolution when missing.
      */
@@ -122,12 +118,21 @@ export class WorkspaceManager {
             if (cached) {
                 this.lockFile = cached;
             } else {
+                if (this.options.allowNetwork === false) {
+                    throw new Error(
+                        'Lock file (model.lock) not found and network access is disabled.\n' +
+                        'Hint: Run \'dlang install\' to generate the lock file.'
+                    );
+                }
                 await this.generateLockFile();
             }
         }
 
         if (!this.lockFile) {
-            throw new Error('Unable to resolve workspace lock file.');
+            throw new Error(
+                'Unable to resolve workspace lock file.\n' +
+                'Hint: Ensure model.yaml exists and run \'dlang install\' to generate model.lock.'
+            );
         }
 
         return this.lockFile;
@@ -151,6 +156,41 @@ export class WorkspaceManager {
         return this.lockFile;
     }
 
+    /**
+     * Invalidates all cached data (manifest and lock file).
+     * Call this when config files change externally (e.g., from CLI commands).
+     * 
+     * After invalidation, the next call to getManifest() or getLockFile()
+     * will re-read from disk.
+     */
+    invalidateCache(): void {
+        this.manifestCache = undefined;
+        this.lockFile = undefined;
+        // Re-apply undefined to git resolver to clear its lock file
+        if (this.gitResolver) {
+            this.gitResolver.setLockFile(undefined);
+        }
+    }
+
+    /**
+     * Invalidates only the manifest cache.
+     * Call this when model.yaml changes.
+     */
+    invalidateManifestCache(): void {
+        this.manifestCache = undefined;
+    }
+
+    /**
+     * Invalidates only the lock file cache.
+     * Call this when model.lock changes.
+     */
+    invalidateLockCache(): void {
+        this.lockFile = undefined;
+        if (this.gitResolver) {
+            this.gitResolver.setLockFile(undefined);
+        }
+    }
+
     /**
      * Provides the shared git URL resolver configured with the current lock file.
      */
@@ -175,12 +215,44 @@ export class WorkspaceManager {
     }
 
     /**
-     * Resolves a manifest dependency alias to its git import string.
-     *
-     * @param aliasPath - Alias from import statement (may include subpaths)
-     * @returns Resolved git import string or undefined when alias is unknown
+     * Returns the path aliases from the manifest, if present.
      */
-    async resolveDependencyImport(aliasPath: string): Promise<string | undefined> {
+    async getPathAliases(): Promise<PathAliases | undefined> {
+        const manifest = await this.getManifest();
+        return manifest?.paths;
+    }
+
+    /**
+     * Normalizes a dependency entry to its extended form.
+     * Handles both short form (string version) and extended form (object).
+     * 
+     * In the new format, the key IS the owner/package, so source is derived from key
+     * ONLY for git dependencies (not for path-based local dependencies).
+     */
+    private normalizeDependency(key: string, dep: DependencySpec): ExtendedDependencySpec {
+        if (typeof dep === 'string') {
+            // Short form: "owner/package": "v1.0.0" or "main"
+            // Key is the source (owner/package format)
+            return { source: key, ref: dep };
+        }
+        // Extended form:
+        // - If has source: use as-is
+        // - If has path: it's a local dep, don't set source
+        // - If neither: derive source from key (owner/package becomes source)
+        if (dep.source || dep.path) {
+            return dep;
+        }
+        return { ...dep, source: key };
+    }
+
+    /**
+     * Resolves a manifest dependency to its git import string.
+     * 
+     * NEW FORMAT (PRS-010): Dependencies are keyed by owner/package directly
+     * @param specifier - Import specifier (owner/package format, may include subpaths)
+     * @returns Resolved git import string or undefined when not found
+     */
+    async resolveDependencyImport(specifier: string): Promise<string | undefined> {
         await this.ensureInitialized();
         const manifest = await this.loadManifest();
         const dependencies = manifest?.dependencies;
@@ -189,18 +261,28 @@ export class WorkspaceManager {
             return undefined;
         }
 
-        for (const [alias, dep] of Object.entries(dependencies)) {
-            if (!dep?.source) {
+        // NEW: Dependencies are keyed by owner/package (e.g., "domainlang/core")
+        // Import specifier is also owner/package, potentially with subpath
+        for (const [key, dep] of Object.entries(dependencies)) {
+            const normalized = this.normalizeDependency(key, dep);
+            
+            // Skip path-based dependencies (handled by path aliases)
+            if (normalized.path) {
+                continue;
+            }
+
+            if (!normalized.source) {
                 continue;
             }
 
-            if (aliasPath === alias || aliasPath.startsWith(`${alias}/`)) {
-                const suffix = aliasPath.slice(alias.length);
-                const version = dep.version ?? '';
-                const versionSegment = version
-                    ? (version.startsWith('@') ? version : `@${version}`)
+            // Match if specifier equals key or starts with key/
+            if (specifier === key || specifier.startsWith(`${key}/`)) {
+                const suffix = specifier.slice(key.length);
+                const ref = normalized.ref ?? '';
+                const refSegment = ref
+                    ? (ref.startsWith('@') ? ref : `@${ref}`)
                     : '';
-                return `${dep.source}${versionSegment}${suffix}`;
+                return `${normalized.source}${refSegment}${suffix}`;
             }
         }
 
@@ -208,16 +290,15 @@ export class WorkspaceManager {
     }
 
     private async performInitialization(startPath: string): Promise<void> {
-        this.workspaceRoot = await this.findWorkspaceRoot(startPath);
-        if (!this.workspaceRoot) {
-            throw new Error('Workspace root (directory with model.yaml) not found.');
-        }
+        this.workspaceRoot = await this.findWorkspaceRoot(startPath) ?? path.resolve(startPath);
 
-        this.gitResolver = new GitUrlResolver();
+        // Per PRS-010: Project-local cache at .dlang/packages/ (like node_modules)
+        const cacheDir = path.join(this.workspaceRoot, '.dlang', 'packages');
+        this.gitResolver = new GitUrlResolver(cacheDir);
         const loaded = await this.loadLockFileFromDisk();
         this.applyLockFile(loaded);
 
-        if (!this.lockFile && this.options.autoResolve !== false) {
+        if (!this.lockFile && this.options.autoResolve !== false && this.options.allowNetwork !== false) {
             await this.generateLockFile();
         }
     }
@@ -255,8 +336,8 @@ export class WorkspaceManager {
         }
 
         const lockFile = await resolver.resolveDependencies();
-    this.lockFile = lockFile;
-    this.gitResolver.setLockFile(lockFile);
+        this.lockFile = lockFile;
+        this.gitResolver.setLockFile(lockFile);
 
         // Write JSON lock file
         await this.writeJsonLockFile(lockFile);
@@ -333,6 +414,10 @@ export class WorkspaceManager {
 
             const content = await fs.readFile(manifestPath, 'utf-8');
             const manifest = (YAML.parse(content) ?? {}) as ModelManifest;
+            
+            // Validate manifest structure
+            this.validateManifest(manifest, manifestPath);
+            
             this.manifestCache = {
                 manifest,
                 path: manifestPath,
@@ -348,6 +433,111 @@ export class WorkspaceManager {
         }
     }
 
+    /**
+     * Validates manifest structure and dependency configurations.
+     * Throws detailed errors for invalid manifests.
+     * 
+     * Supports both new format (owner/package: version) and extended format.
+     */
+    private validateManifest(manifest: ModelManifest, manifestPath: string): void {
+        // Validate path aliases
+        if (manifest.paths) {
+            this.validatePathAliases(manifest.paths, manifestPath);
+        }
+
+        if (!manifest.dependencies) {
+            return; // No dependencies to validate
+        }
+
+        for (const [key, dep] of Object.entries(manifest.dependencies)) {
+            const normalized = this.normalizeDependency(key, dep);
+
+            // Validate mutually exclusive source and path
+            if (normalized.source && normalized.path) {
+                throw new Error(
+                    `Invalid dependency '${key}' in ${manifestPath}:\n` +
+                    `Cannot specify both 'source' and 'path'.\n` +
+                    `Hint: Use 'source' for git dependencies or 'path' for local workspace dependencies.`
+                );
+            }
+
+            // For string format, source is always derived from key (valid)
+            // For extended format without source or path, error
+            if (typeof dep !== 'string' && !normalized.source && !normalized.path) {
+                throw new Error(
+                    `Invalid dependency '${key}' in ${manifestPath}:\n` +
+                    `Must specify either 'source' or 'path'.\n` +
+                    `Hint: Add 'source: owner/repo' for git dependencies, or 'path: ./local/path' for local packages.`
+                );
+            }
+
+            // Validate path is relative and within workspace
+            if (normalized.path) {
+                this.validateLocalPath(normalized.path, key, manifestPath);
+            }
+
+            // Validate source has ref when specified
+            if (normalized.source && !normalized.ref) {
+                throw new Error(
+                    `Invalid dependency '${key}' in ${manifestPath}:\n` +
+                    `Git dependencies must specify a 'ref' (git reference).\n` +
+                    `Hint: Add 'ref: v1.0.0' (tag), 'ref: main' (branch), or a commit SHA.`
+                );
+            }
+        }
+    }
+
+    /**
+     * Validates path aliases for security and correctness.
+     */
+    private validatePathAliases(paths: PathAliases, manifestPath: string): void {
+        for (const [alias, targetPath] of Object.entries(paths)) {
+            // Validate alias starts with @
+            if (!alias.startsWith('@')) {
+                throw new Error(
+                    `Invalid path alias '${alias}' in ${manifestPath}:\n` +
+                    `Path aliases must start with '@'.\n` +
+                    `Hint: Rename to '@${alias}' in your model.yaml paths section.`
+                );
+            }
+
+            // Validate target path doesn't escape workspace
+            this.validateLocalPath(targetPath, alias, manifestPath);
+        }
+    }
+
+    /**
+     * Validates local path dependencies for security.
+     * Ensures paths don't escape workspace boundary.
+     */
+    private validateLocalPath(localPath: string, alias: string, manifestPath: string): void {
+        // Reject absolute paths
+        if (path.isAbsolute(localPath)) {
+            throw new Error(
+                `Invalid local path '${alias}' in ${manifestPath}:\n` +
+                `Cannot use absolute path '${localPath}'.\n` +
+                `Hint: Use relative paths (e.g., './lib', '../shared') for local dependencies.`
+            );
+        }
+
+        // Resolve path relative to manifest directory
+        const manifestDir = path.dirname(manifestPath);
+        const resolvedPath = path.resolve(manifestDir, localPath);
+        const workspaceRoot = this.workspaceRoot || manifestDir;
+
+        // Check if resolved path is within workspace
+        const relativePath = path.relative(workspaceRoot, resolvedPath);
+        if (relativePath.startsWith('..') || path.isAbsolute(relativePath)) {
+            throw new Error(
+                `Invalid local path '${alias}' in ${manifestPath}:\n` +
+                `Path '${localPath}' resolves outside workspace boundary.\n` +
+                `Resolved: ${resolvedPath}\n` +
+                `Workspace: ${workspaceRoot}\n` +
+                `Hint: Local dependencies must be within the workspace. Consider moving the dependency or using a git-based source.`
+            );
+        }
+    }
+
     private parseJsonLockFile(content: string): LockFile {
         const parsed = JSON.parse(content) as Partial<LockFile> & {
             dependencies?: Record<string, Partial<LockedDependency>>;
@@ -357,11 +547,12 @@ export class WorkspaceManager {
         const dependencies: Record<string, LockedDependency> = {};
 
         for (const [key, value] of Object.entries(parsed.dependencies ?? {})) {
-            if (!value || typeof value.version !== 'string' || typeof value.resolved !== 'string' || typeof value.commit !== 'string') {
+            if (!value || typeof value.ref !== 'string' || typeof value.resolved !== 'string' || typeof value.commit !== 'string') {
                 continue;
             }
             dependencies[key] = {
-                version: value.version,
+                ref: value.ref,
+                refType: value.refType ?? 'commit', // Default to commit for backwards compatibility
                 resolved: value.resolved,
                 commit: value.commit,
                 integrity: value.integrity,

package/src/syntaxes/domain-lang.monarch.ts

@@ -1,7 +1,7 @@
 // Monarch syntax highlighting for the domain-lang language.
 export default {
     keywords: [
-        'ACL','AntiCorruptionLayer','BBoM','BigBallOfMud','BoundedContext','CF','Classification','Conformist','ContextMap','CustomerSupplier','Decision','Domain','DomainMap','Import','Metadata','Namespace','OHS','OpenHostService','P','PL','Partnership','Policy','PublishedLanguage','Rule','SK','SeparateWays','SharedKernel','Team','Term','UpstreamDownstream','aka','archetype','as','bc','businessModel','by','classification','cmap','contains','decision','decisions','description','dmap','dom','evolution','examples','for','from','glossary','import','in','integrations','integrity','is','meta','metadata','ns','policy','relationships','rule','rules','synonyms','team','term','terminology','this','type','vision'
+        'ACL','AntiCorruptionLayer','BBoM','BigBallOfMud','BoundedContext','CF','Classification','Conformist','ContextMap','CustomerSupplier','Decision','Domain','DomainMap','Import','Metadata','Namespace','OHS','OpenHostService','P','PL','Partnership','Policy','PublishedLanguage','Rule','SK','SeparateWays','SharedKernel','Team','Term','UpstreamDownstream','aka','archetype','as','bc','businessModel','by','classification','cmap','contains','decision','decisions','description','dmap','dom','evolution','examples','for','glossary','import','in','integrations','is','meta','metadata','ns','policy','relationships','rule','rules','synonyms','team','term','terminology','this','type','vision'
     ],
     operators: [
         ',','->','.',':','<-','<->','=','><'

package/src/utils/import-utils.ts

@@ -1,129 +1,66 @@
-import fs from 'node:fs/promises';
 import path from 'node:path';
 import { URI, type LangiumDocument, type LangiumDocuments } from 'langium';
 import type { Model } from '../generated/ast.js';
-import { GitUrlParser } from '../services/git-url-resolver.js';
 import type { GitUrlResolver } from '../services/git-url-resolver.js';
 import { WorkspaceManager } from '../services/workspace-manager.js';
+import { ImportResolver } from '../services/import-resolver.js';
+import type { DomainLangServices } from '../domain-lang-module.js';
 
-// Singleton workspace manager instance
-let workspaceManager: WorkspaceManager | undefined;
+/**
+ * Lazily initialized workspace manager for standalone (non-LSP) usage.
+ * Used by import graph building when services aren't available from DI.
+ */
+let standaloneWorkspaceManager: WorkspaceManager | undefined;
+let standaloneImportResolver: ImportResolver | undefined;
+let lastInitializedDir: string | undefined;
 
 /**
- * Gets or creates the global workspace manager instance.
- * 
+ * Gets or creates a standalone import resolver for non-LSP contexts.
+ * Creates its own WorkspaceManager if not previously initialized for this directory.
+ *
+ * NOTE: In LSP contexts, prefer using services.imports.ImportResolver directly.
+ * This function exists for utilities that don't have access to the service container.
+ *
  * @param startDir - Directory to start workspace search from
- * @returns Promise resolving to the workspace manager
+ * @returns Promise resolving to the import resolver
  */
-async function getWorkspaceManager(startDir: string): Promise<WorkspaceManager> {
-  if (!workspaceManager) {
-    workspaceManager = new WorkspaceManager();
-    const root = await findWorkspaceRoot(startDir);
+async function getStandaloneImportResolver(startDir: string): Promise<ImportResolver> {
+  // Re-initialize if directory changed (workspace boundary)
+  if (lastInitializedDir !== startDir || !standaloneImportResolver) {
+    standaloneWorkspaceManager = new WorkspaceManager({ autoResolve: false, allowNetwork: false });
     try {
-      await workspaceManager.initialize(root);
+      await standaloneWorkspaceManager.initialize(startDir);
     } catch (error) {
       console.warn(`Failed to initialize workspace: ${error instanceof Error ? error.message : String(error)}`);
-      // Continue without workspace - local imports will still work
     }
+    const services = {
+      imports: { WorkspaceManager: standaloneWorkspaceManager }
+    } as DomainLangServices;
+    standaloneImportResolver = new ImportResolver(services);
+    lastInitializedDir = startDir;
   }
-  return workspaceManager;
+  return standaloneImportResolver;
 }
 
 /**
- * Gets the git URL resolver from the workspace manager.
- * 
+ * Gets the git URL resolver from a workspace manager.
+ *
  * @param startDir - Directory to start workspace search from
  * @returns Promise resolving to the git URL resolver
  */
 async function getGitResolver(startDir: string): Promise<GitUrlResolver> {
-  const manager = await getWorkspaceManager(startDir);
-  return await manager.getGitResolver();
-}
-
-/**
- * Ensures a file path has the .dlang extension.
- * 
- * @param filePath - The raw file path
- * @returns Normalized path with .dlang extension
- * @throws {Error} If path has an invalid extension
- */
-function ensureDlangExtension(filePath: string): string {
-  const ext = path.extname(filePath);
-  
-  if (!ext) {
-    return `${filePath}.dlang`;
-  }
-  
-  if (ext !== '.dlang') {
-    throw new Error(
-      `Invalid file extension: ${ext}. Expected .dlang for file: ${filePath}`
-    );
-  }
-  
-  return filePath;
-}
-
-/**
- * Resolves workspace-relative paths (starting with ~/).
- * 
- * @param importPath - Import path that may start with ~/
- * @param workspaceRoot - The workspace root directory
- * @returns Resolved absolute path
- */
-function resolveWorkspacePath(importPath: string, workspaceRoot: string): string {
-  if (importPath.startsWith('~/')) {
-    return path.join(workspaceRoot, importPath.slice(2));
-  }
-  return importPath;
-}
-
-/**
- * Finds the workspace root by looking for common workspace indicators.
- * 
- * Searches upward from the document's directory looking for:
- * - dlang.toml
- * - .git directory
- * - package.json with dlang configuration
- * 
- * @param startDir - Directory to start searching from
- * @returns Workspace root path or the start directory if not found
- */
-async function findWorkspaceRoot(startDir: string): Promise<string> {
-  let currentDir = startDir;
-  const root = path.parse(currentDir).root;
-
-  while (currentDir !== root) {
-    // Check for workspace indicators
-    const indicators = ['dlang.toml', '.git', 'package.json'];
-    
-    for (const indicator of indicators) {
-      const indicatorPath = path.join(currentDir, indicator);
-      try {
-        await fs.access(indicatorPath);
-        return currentDir; // Found workspace root
-      } catch {
-        // Continue searching
-      }
-    }
-
-    // Move up one directory
-    const parentDir = path.dirname(currentDir);
-    if (parentDir === currentDir) break; // Reached root
-    currentDir = parentDir;
-  }
-
-  // Default to start directory if no workspace root found
-  return startDir;
+  const workspaceManager = new WorkspaceManager({ autoResolve: false, allowNetwork: false });
+  await workspaceManager.initialize(startDir);
+  return workspaceManager.getGitResolver();
 }
 
 /**
  * Resolves an import path to an absolute file URI.
  * 
- * Supports:
- * - Local relative paths: ./file.dlang, ../other/file.dlang
- * - Workspace-relative paths: ~/contexts/sales.dlang
- * - Git URLs: gh:owner/repo@v1.0.0/file.dlang
- * - Full URLs: https://github.com/owner/repo/blob/v1.0.0/file.dlang
+ * Delegates to ImportResolver which implements PRS-010 semantics:
+ * - File imports (with .dlang extension): Direct file access
+ * - Module imports (no extension): Requires model.yaml in directory
+ * - External dependencies: Resolved via manifest and lock file
  * 
  * @param importingDoc - The document containing the import statement
  * @param rawImportPath - The raw import path from the import statement
@@ -135,65 +72,8 @@ export async function resolveImportPath(
   rawImportPath: string
 ): Promise<URI> {
   const baseDir = path.dirname(importingDoc.uri.fsPath);
-
-  // Handle manifest dependency aliases (friendly names)
-  const manager = await getWorkspaceManager(baseDir);
-  let gitResolver: GitUrlResolver | undefined;
-
-  try {
-    const manifestImport = await manager.resolveDependencyImport(rawImportPath);
-    if (manifestImport) {
-      gitResolver = await manager.getGitResolver();
-      return await gitResolver.resolve(manifestImport);
-    }
-  } catch {
-    // Ignore manifest resolution issues; fall back to other strategies
-  }
-
-  // Handle git URLs (shorthand or full)
-  if (GitUrlParser.isGitUrl(rawImportPath)) {
-    gitResolver = gitResolver ?? await manager.getGitResolver();
-    return await gitResolver.resolve(rawImportPath);
-  }
-
-  // Handle workspace-relative paths (~/)
-  let resolvedPath = rawImportPath;
-
-  if (rawImportPath.startsWith('~/')) {
-    const workspaceRoot = await findWorkspaceRoot(baseDir);
-    resolvedPath = resolveWorkspacePath(rawImportPath, workspaceRoot);
-  } else if (!path.isAbsolute(rawImportPath)) {
-    // Handle relative paths
-    resolvedPath = path.resolve(baseDir, rawImportPath);
-  }
-
-  // Ensure .dlang extension
-  const normalized = ensureDlangExtension(resolvedPath);
-
-  // Verify file exists
-  try {
-    await fs.access(normalized);
-  } catch {
-    throw new Error(
-      `Import file not found: ${rawImportPath} (resolved to ${normalized})`
-    );
-  }
-
-  return URI.file(normalized);
-}
-
-/**
- * Legacy function for backward compatibility.
- * Use resolveImportPath instead.
- * 
- * @deprecated Use resolveImportPath which supports git URLs and workspace paths
- */
-export async function resolveLocalImportPath(
-  importingDoc: LangiumDocument,
-  rawImportPath: string
-): Promise<string> {
-  const uri = await resolveImportPath(importingDoc, rawImportPath);
-  return uri.fsPath;
+  const resolver = await getStandaloneImportResolver(baseDir);
+  return resolver.resolveFrom(baseDir, rawImportPath);
 }
 
 /**
@@ -270,5 +150,3 @@ export async function clearGitCache(startDir: string = process.cwd()): Promise<v
   const resolver = await getGitResolver(startDir);
   return await resolver.clearCache();
 }
-
-