@domainlang/language 0.1.81

package/src/utils/import-utils.ts

@@ -0,0 +1,274 @@
+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';
+
+// Singleton workspace manager instance
+let workspaceManager: WorkspaceManager | undefined;
+
+/**
+ * Gets or creates the global workspace manager instance.
+ * 
+ * @param startDir - Directory to start workspace search from
+ * @returns Promise resolving to the workspace manager
+ */
+async function getWorkspaceManager(startDir: string): Promise<WorkspaceManager> {
+  if (!workspaceManager) {
+    workspaceManager = new WorkspaceManager();
+    const root = await findWorkspaceRoot(startDir);
+    try {
+      await workspaceManager.initialize(root);
+    } catch (error) {
+      console.warn(`Failed to initialize workspace: ${error instanceof Error ? error.message : String(error)}`);
+      // Continue without workspace - local imports will still work
+    }
+  }
+  return workspaceManager;
+}
+
+/**
+ * Gets the git URL resolver from the 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;
+}
+
+/**
+ * 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
+ * 
+ * @param importingDoc - The document containing the import statement
+ * @param rawImportPath - The raw import path from the import statement
+ * @returns Resolved URI to the imported file
+ * @throws {Error} If the import cannot be resolved
+ */
+export async function resolveImportPath(
+  importingDoc: LangiumDocument,
+  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;
+}
+
+/**
+ * Ensures the import graph is loaded from an entry file.
+ * 
+ * @param entryFilePath - Absolute or workspace-relative path to entry file
+ * @param langiumDocuments - The Langium documents manager
+ * @returns Set of URIs (as strings) for all documents in the import graph
+ * @throws {Error} If entry file cannot be resolved or loaded
+ */
+export async function ensureImportGraphFromEntryFile(
+  entryFilePath: string,
+  langiumDocuments: LangiumDocuments
+): Promise<Set<string>> {
+  const entryUri = URI.file(path.resolve(entryFilePath));
+  const entryDoc = await langiumDocuments.getOrCreateDocument(entryUri);
+  return ensureImportGraphFromDocument(entryDoc, langiumDocuments);
+}
+
+/**
+ * Recursively builds the import graph from a document.
+ * 
+ * @param document - The starting document
+ * @param langiumDocuments - The Langium documents manager
+ * @returns Set of URIs (as strings) for all documents in the import graph
+ */
+export async function ensureImportGraphFromDocument(
+  document: LangiumDocument,
+  langiumDocuments: LangiumDocuments
+): Promise<Set<string>> {
+  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 unknown as Model;
+    for (const imp of model.imports ?? []) {
+      if (!imp.uri) continue;
+      
+      // Use new resolveImportPath that supports git URLs
+      const resolvedUri = await resolveImportPath(doc, imp.uri);
+      const childDoc = await langiumDocuments.getOrCreateDocument(resolvedUri);
+      await visit(childDoc);
+    }
+  }
+
+  await visit(document);
+  return visited;
+}
+
+/**
+ * Gets cache statistics for git imports.
+ * 
+ * @returns Cache statistics including size and number of cached repositories
+ */
+export async function getGitCacheStats(startDir: string = process.cwd()): Promise<{
+  totalSize: number;
+  repoCount: number;
+  cacheDir: string;
+}> {
+  const resolver = await getGitResolver(startDir);
+  return await resolver.getCacheStats();
+}
+
+/**
+ * Clears the git import cache.
+ * 
+ * @param startDir - Starting directory for workspace resolution
+ * @returns Promise that resolves when cache is cleared
+ */
+export async function clearGitCache(startDir: string = process.cwd()): Promise<void> {
+  const resolver = await getGitResolver(startDir);
+  return await resolver.clearCache();
+}
+
+

package/src/validation/bounded-context.ts

@@ -0,0 +1,99 @@
+import type { ValidationAcceptor } from 'langium';
+import type { BoundedContext } from '../generated/ast.js';
+import { ValidationMessages, buildCodeDescription } from './constants.js';
+
+/**
+ * Validates that a bounded context has a description.
+ * 
+ * @param bc - The bounded context to validate
+ * @param accept - The validation acceptor for reporting issues
+ */
+function validateBoundedContextHasDescription(
+    bc: BoundedContext, 
+    accept: ValidationAcceptor
+): void {
+    if (!bc.description) {
+        accept('warning', ValidationMessages.BOUNDED_CONTEXT_NO_DESCRIPTION(bc.name), { 
+            node: bc,
+            keyword: 'BoundedContext',
+            codeDescription: buildCodeDescription('language.md', 'bounded-contexts')
+        });
+    }
+}
+
+/**
+ * Validates that a bounded context belongs to a domain.
+ * A BoundedContext must have a 'for Domain' clause.
+ * 
+ * @param bc - The bounded context to validate
+ * @param accept - The validation acceptor for reporting issues
+ */
+function validateBoundedContextHasDomain(
+    bc: BoundedContext,
+    accept: ValidationAcceptor
+): void {
+    if (!bc.domain) {
+        accept('warning', ValidationMessages.BOUNDED_CONTEXT_NO_DOMAIN(bc.name), {
+            node: bc,
+            keyword: 'for',
+            codeDescription: buildCodeDescription('language.md', 'bounded-contexts')
+        });
+    }
+}
+
+/**
+ * Validates conflicts between inline and block classification assignment.
+ * Warns when both inline ('as') and block ('classification:') are used.
+ * Inline values take precedence per PRS-008.
+ *
+ * FR-9.2: Inline/Block Conflict Validation
+ */
+function validateBoundedContextClassificationConflict(
+    bc: BoundedContext,
+    accept: ValidationAcceptor
+): void {
+    if (bc.classification.length > 1) {
+        const inlineClassificationName = bc.classification[0].ref?.name;
+        const blockClassificationName = bc.classification[1].ref?.name;
+
+        // Warn if defined multiple times
+        accept('warning', ValidationMessages.BOUNDED_CONTEXT_CLASSIFICATION_CONFLICT(bc.name, inlineClassificationName, blockClassificationName), {
+            node: bc,
+            property: 'classification',
+            index: 1,
+            codeDescription: buildCodeDescription('language.md', 'bounded-contexts')
+        });
+    }
+}
+
+/**
+ * Validates conflicts between inline and block team assignment.
+ * Warns when both inline ('by') and block ('team:') are used.
+ * Inline values take precedence per PRS-008.
+ *
+ * FR-2.3: Inline/Block Conflict Validation
+ */
+function validateBoundedContextTeamConflict(
+    bc: BoundedContext,
+    accept: ValidationAcceptor
+): void {
+    if (bc.team.length > 1) {
+        const inlineTeamName = bc.team[0].ref?.name;
+        const blockTeamName = bc.team[1].ref?.name;
+
+        // Warn if defined multiple times
+        accept('warning', ValidationMessages.BOUNDED_CONTEXT_TEAM_CONFLICT(bc.name, inlineTeamName, blockTeamName), {
+            node: bc,
+            property: 'team',
+            index: 1,
+            codeDescription: buildCodeDescription('language.md', 'bounded-contexts')
+        });
+    }
+}
+
+export const boundedContextChecks = [
+    validateBoundedContextHasDescription,
+    validateBoundedContextHasDomain,
+    validateBoundedContextClassificationConflict,
+    validateBoundedContextTeamConflict
+];

package/src/validation/classification.ts

@@ -0,0 +1,5 @@
+import type { ValidationCheck } from 'langium';
+import type { Classification } from '../generated/ast.js';
+
+// No validation checks needed for classifications currently
+export const classificationChecks: ValidationCheck<Classification>[] = []; 

package/src/validation/constants.ts

@@ -0,0 +1,124 @@
+/**
+ * Validation message constants for DomainLang.
+ * 
+ * Centralizes all validation messages to ensure consistency
+ * and facilitate internationalization in the future.
+ * 
+ * Messages follow VS Code conventions:
+ * - Clear problem statement
+ * - Brief DDD context explaining why it matters
+ * - Inline example showing the fix
+ * - Clickable documentation link via CodeDescription
+ */
+
+import type { CodeDescription } from 'vscode-languageserver-types';
+
+// ============================================================================
+// Documentation Link Utilities
+// ============================================================================
+
+const REPO_BASE = 'https://github.com/larsbaunwall/DomainLang/blob/main';
+const DOCS_BASE = `${REPO_BASE}/dsl/domain-lang/docs`;
+
+/**
+ * Builds a documentation URL for error messages.
+ * @param docPath - Relative path from docs/ folder
+ * @param anchor - Optional section anchor (without #)
+ */
+const buildDocLink = (docPath: string, anchor?: string): string => 
+    `${DOCS_BASE}/${docPath}${anchor ? `#${anchor}` : ''}`;
+
+/**
+ * Creates a CodeDescription for clickable documentation links in VS Code.
+ * @param docPath - Relative path from docs/ folder
+ * @param anchor - Optional section anchor (without #)
+ */
+export const buildCodeDescription = (docPath: string, anchor?: string): CodeDescription => ({
+    href: buildDocLink(docPath, anchor)
+});
+
+// ============================================================================
+// Enhanced Validation Messages
+// ============================================================================
+
+export const ValidationMessages = {
+    /**
+     * Warning message when a domain lacks a vision statement.
+     * @param name - The name of the domain
+     */
+    DOMAIN_NO_VISION: (name: string) => 
+        `Domain '${name}' is missing a vision statement.`,
+    
+    /**
+     * Warning message when a bounded context lacks a description.
+     * @param name - The name of the bounded context
+     */
+    BOUNDED_CONTEXT_NO_DESCRIPTION: (name: string) => 
+        `Bounded Context '${name}' is missing a description.`,
+    
+    /**
+     * Warning message when a bounded context lacks a domain reference.
+     * @param name - The name of the bounded context
+     */
+    BOUNDED_CONTEXT_NO_DOMAIN: (name: string) =>
+        `Bounded Context '${name}' must belong to a domain. Use 'for DomainName'.`,
+    
+    /**
+     * Warning when classification is specified both inline and in a block.
+     * Inline value takes precedence.
+     * @param bcName - The name of the bounded context
+     * @param inlineClassification - The inline classification name (from 'as')
+     * @param blockClassification - The block classification name (from 'classification:')
+     */
+    BOUNDED_CONTEXT_CLASSIFICATION_CONFLICT: (bcName: string, inlineClassification?: string, blockClassification?: string) =>
+        `Classification specified both inline${inlineClassification ? ` ('as ${inlineClassification}')` : ''} and in block${blockClassification ? ` ('classification: ${blockClassification}')` : ''}. Inline value takes precedence.`,
+    
+    /**
+     * Warning when team is specified both inline and in a block.
+     * Inline value takes precedence.
+     * @param bcName - The name of the bounded context
+     * @param inlineTeam - The inline team name (from 'by')
+     * @param blockTeam - The block team name (from 'team:')
+     */
+    BOUNDED_CONTEXT_TEAM_CONFLICT: (bcName: string, inlineTeam?: string, blockTeam?: string) =>
+        `Team specified both inline${inlineTeam ? ` ('by ${inlineTeam}')` : ''} and in block${blockTeam ? ` ('team: ${blockTeam}')` : ''}. Inline value takes precedence.`,
+    
+    /**
+     * Error message when an element is defined multiple times.
+     * @param fqn - The fully qualified name of the duplicate element
+     */
+    DUPLICATE_ELEMENT: (fqn: string) => 
+        `Duplicate element: '${fqn}' is already defined.`,
+
+    // ========================================================================
+    // Integration Pattern & Relationship Validation
+    // ========================================================================
+
+    /**
+     * Warning when SharedKernel pattern uses incorrect arrow direction.
+     * SharedKernel requires bidirectional relationship.
+     */
+    SHARED_KERNEL_MUST_BE_BIDIRECTIONAL: (leftContext: string, rightContext: string, arrow: string) =>
+        `SharedKernel between '${leftContext}' and '${rightContext}' requires bidirectional arrow '<->', not '${arrow}'.`,
+
+    /**
+     * Warning when Anti-Corruption Layer is on the wrong side of relationship.
+     * ACL should protect the consuming context (downstream).
+     */
+    ACL_ON_WRONG_SIDE: (context: string, side: 'left' | 'right') =>
+        `Anti-Corruption Layer (ACL) on '${context}' should be on downstream (consuming) side, not ${side} side.`,
+
+    /**
+     * Warning when Conformist pattern is on the wrong side.
+     * Conformist accepts upstream model without translation.
+     */
+    CONFORMIST_ON_WRONG_SIDE: (context: string, side: 'left' | 'right') =>
+        `Conformist (CF) on '${context}' should be on downstream (consuming) side, not ${side} side.`,
+
+    /**
+     * Info message when relationship has too many integration patterns.
+     * Suggests possible syntax confusion.
+     */
+    TOO_MANY_PATTERNS: (count: number, side: 'left' | 'right') =>
+        `Too many integration patterns (${count}) on ${side} side. Typically use 1-2 patterns per side.`
+} as const;

package/src/validation/domain-lang-validator.ts

@@ -0,0 +1,33 @@
+import { modelChecks } from './model.js';
+import { domainChecks } from './domain.js';
+import { boundedContextChecks } from './bounded-context.js';
+import { classificationChecks } from './classification.js';
+import { metadataChecks } from './metadata.js';
+import { contextMapChecks, domainMapChecks } from './maps.js';
+import { relationshipChecks } from './relationships.js';
+import { createImportChecks } from './import.js';
+import type { ValidationChecks } from 'langium';
+import type { DomainLangAstType } from '../generated/ast.js';
+import { DomainLangServices } from '../domain-lang-module.js';
+
+export function registerValidationChecks(services: DomainLangServices): void {
+    const registry = services.validation.ValidationRegistry;
+    
+    // Get import checks
+    const importChecks = createImportChecks(services);
+    
+    // Compose the pipeline for each type
+    const pipeline: ValidationChecks<DomainLangAstType> = {
+        Model: modelChecks,
+        Domain: domainChecks,
+        BoundedContext: boundedContextChecks,
+        Classification: classificationChecks,
+        ContextMap: contextMapChecks,
+        DomainMap: domainMapChecks,
+        Metadata: metadataChecks.Metadata,
+        ImportStatement: importChecks.ImportStatement,
+        Relationship: relationshipChecks,
+    };
+    
+    registry.register(pipeline);
+} 

package/src/validation/domain.ts

@@ -0,0 +1,24 @@
+import type { ValidationAcceptor } from 'langium';
+import type { Domain } from '../generated/ast.js';
+import { ValidationMessages, buildCodeDescription } from './constants.js';
+
+/**
+ * Validates that a domain has a vision statement.
+ * 
+ * @param domain - The domain to validate
+ * @param accept - The validation acceptor for reporting issues
+ */
+function validateDomainHasVision(
+    domain: Domain, 
+    accept: ValidationAcceptor
+): void {
+    if (!domain.vision) {
+        accept('warning', ValidationMessages.DOMAIN_NO_VISION(domain.name), { 
+            node: domain,
+            keyword: 'Domain',
+            codeDescription: buildCodeDescription('language.md', 'domain-vision')
+        });
+    }
+}
+
+export const domainChecks = [validateDomainHasVision];