@domainlang/language 0.5.2 → 0.6.0

package/src/generated/grammar.ts

@@ -144,8 +144,7 @@ export const DomainLangGrammar = (): Grammar => loadedDomainLangGrammar ?? (load
             "elements": [
               {
                 "$type": "Keyword",
-                "value": "Domain",
-                "$comment": "/** A Domain represents a sphere of knowledge, influence, or activity. In DDD, it is the subject area to which the user applies a program. Example: Sales, Shipping, Accounting. */"
+                "value": "Domain"
               },
               {
                 "$type": "Keyword",
@@ -312,7 +311,7 @@ export const DomainLangGrammar = (): Grammar => loadedDomainLangGrammar ?? (load
       "entry": false,
       "fragment": false,
       "parameters": [],
-      "$comment": "/**\\n * Domain - A sphere of knowledge or activity in DDD.\\n * Can be nested via \`in\` to show subdomain hierarchy.\\n * The \`type\` property indicates strategic importance (Core, Supporting, Generic) per Bounded Context Canvas.\\n * Body is optional - allows header-only Domain definitions.\\n */"
+      "$comment": "/**\\n * Domain - A sphere of knowledge or activity in DDD.\\n * Can be nested via \`in\` to show subdomain hierarchy.\\n * The \`type\` property indicates strategic importance (Core, Supporting, Generic) per Bounded Context Canvas.\\n * Body is optional - allows header-only Domain definitions.\\n * \\n * [Read more on domainlang.net](https://domainlang.net/reference/language#domains)\\n */"
     },
     {
       "$type": "ParserRule",
@@ -325,8 +324,7 @@ export const DomainLangGrammar = (): Grammar => loadedDomainLangGrammar ?? (load
             "elements": [
               {
                 "$type": "Keyword",
-                "value": "BoundedContext",
-                "$comment": "/** A Bounded Context defines the boundary within which a particular domain model is defined and applicable. It is a central pattern in DDD for managing complexity. Example: SalesContext, SupportContext. */"
+                "value": "BoundedContext"
               },
               {
                 "$type": "Keyword",
@@ -879,7 +877,7 @@ export const DomainLangGrammar = (): Grammar => loadedDomainLangGrammar ?? (load
       "entry": false,
       "fragment": false,
       "parameters": [],
-      "$comment": "/**\\n * Bounded Context - A boundary within which a domain model is defined.\\n * Central pattern in DDD for managing complexity and team boundaries.\\n * Belongs to exactly ONE domain (fundamental DDD principle).\\n * Body properties can appear in any order. Validation enforces at-most-once constraint.\\n * The \`classification\` property indicates strategic importance per Bounded Context Canvas.\\n * The \`evolution\` property indicates maturity stage per Wardley Maps/BC Canvas.\\n * The \`archetype\` property indicates behavioral role per DDD archetypes (Gateway, Execution, etc).\\n */"
+      "$comment": "/**\\n * Bounded Context - A boundary within which a domain model is defined.\\n * Central pattern in DDD for managing complexity and team boundaries.\\n * Belongs to exactly ONE domain (fundamental DDD principle).\\n * Body properties can appear in any order. Validation enforces at-most-once constraint.\\n * The \`classification\` property indicates strategic importance per Bounded Context Canvas.\\n * The \`evolution\` property indicates maturity stage per Wardley Maps/BC Canvas.\\n * The \`archetype\` property indicates behavioral role per DDD archetypes (Gateway, Execution, etc).\\n * \\n * [Read more on domainlang.net](https://domainlang.net/reference/language#bounded-contexts)\\n */"
     },
     {
       "$type": "ParserRule",
@@ -959,7 +957,7 @@ export const DomainLangGrammar = (): Grammar => loadedDomainLangGrammar ?? (load
       "entry": false,
       "fragment": false,
       "parameters": [],
-      "$comment": "/**\\n * Team - People responsible for a Bounded Context or Domain.\\n * Represents organizational boundaries in DDD.\\n */"
+      "$comment": "/**\\n * Team - People responsible for a Bounded Context or Domain.\\n * Represents organizational boundaries in DDD.\\n * \\n * [Read more on domainlang.net](https://domainlang.net/reference/language#teams)\\n */"
     },
     {
       "$type": "ParserRule",
@@ -988,7 +986,7 @@ export const DomainLangGrammar = (): Grammar => loadedDomainLangGrammar ?? (load
       "entry": false,
       "fragment": false,
       "parameters": [],
-      "$comment": "/**\\n * Classification - Reusable label for categorizing elements.\\n * Examples: Core, Supporting, Generic, Strategic, Commodity, Architectural, Business, Technical.\\n */"
+      "$comment": "/**\\n * Classification - Reusable label for categorizing elements.\\n * Examples: Core, Supporting, Generic, Strategic, Commodity, Architectural, Business, Technical.\\n * \\n * [Read more on domainlang.net](https://domainlang.net/reference/language#classifications)\\n */"
     },
     {
       "$type": "ParserRule",
@@ -1017,7 +1015,7 @@ export const DomainLangGrammar = (): Grammar => loadedDomainLangGrammar ?? (load
       "entry": false,
       "fragment": false,
       "parameters": [],
-      "$comment": "/**\\n * Metadata - Defines a key that can be used in metadata blocks.\\n * Examples: Language, Framework, Database, Repository.\\n * Can be defined locally or imported from stdlib.\\n */"
+      "$comment": "/**\\n * Metadata - Defines a key that can be used in metadata blocks.\\n * Examples: Language, Framework, Database, Repository.\\n * Can be defined locally or imported from stdlib.\\n * \\n * [Read more on domainlang.net](https://domainlang.net/reference/language#metadata)\\n */"
     },
     {
       "$type": "ParserRule",
@@ -1057,8 +1055,7 @@ export const DomainLangGrammar = (): Grammar => loadedDomainLangGrammar ?? (load
             "elements": [
               {
                 "$type": "Keyword",
-                "value": "ContextMap",
-                "$comment": "/** A Context Map visualizes and documents the relationships between Bounded Contexts, including their integration patterns. */"
+                "value": "ContextMap"
               },
               {
                 "$type": "Keyword",
@@ -1193,7 +1190,7 @@ export const DomainLangGrammar = (): Grammar => loadedDomainLangGrammar ?? (load
       "entry": false,
       "fragment": false,
       "parameters": [],
-      "$comment": "/**\\n * Context Map - Visualizes relationships between Bounded Contexts.\\n * Shows integration patterns and team interactions.\\n */"
+      "$comment": "/**\\n * Context Map - Visualizes relationships between Bounded Contexts.\\n * Shows integration patterns and team interactions.\\n * \\n * [Read more on domainlang.net](https://domainlang.net/reference/language#context-maps)\\n */"
     },
     {
       "$type": "ParserRule",
@@ -1206,8 +1203,7 @@ export const DomainLangGrammar = (): Grammar => loadedDomainLangGrammar ?? (load
             "elements": [
               {
                 "$type": "Keyword",
-                "value": "DomainMap",
-                "$comment": "/** A Domain Map visualizes and documents the relationships between Domains. */"
+                "value": "DomainMap"
               },
               {
                 "$type": "Keyword",
@@ -1301,7 +1297,7 @@ export const DomainLangGrammar = (): Grammar => loadedDomainLangGrammar ?? (load
       "entry": false,
       "fragment": false,
       "parameters": [],
-      "$comment": "/**\\n * Domain Map - Visualizes relationships between Domains.\\n * Shows high-level domain organization and subdomain structure.\\n */"
+      "$comment": "/**\\n * Domain Map - Visualizes relationships between Domains.\\n * Shows high-level domain organization and subdomain structure.\\n * \\n * [Read more on domainlang.net](https://domainlang.net/reference/language#domain-maps)\\n */"
     },
     {
       "$type": "ParserRule",
@@ -1471,7 +1467,7 @@ export const DomainLangGrammar = (): Grammar => loadedDomainLangGrammar ?? (load
       "entry": false,
       "fragment": false,
       "parameters": [],
-      "$comment": "/**\\n * Relationship - Connection between two Bounded Contexts.\\n * Supports DDD integration patterns (ACL, OHS, PL, etc.) and relationship types.\\n */"
+      "$comment": "/**\\n * Relationship - Connection between two Bounded Contexts.\\n * Supports DDD integration patterns (ACL, OHS, PL, etc.) and relationship types.\\n * \\n * [Read more on domainlang.net](https://domainlang.net/reference/language#relationships)\\n */"
     },
     {
       "$type": "ParserRule",
@@ -1830,7 +1826,7 @@ export const DomainLangGrammar = (): Grammar => loadedDomainLangGrammar ?? (load
       "entry": false,
       "fragment": false,
       "parameters": [],
-      "$comment": "/**\\n * Domain Terminology - Ubiquitous language terms with definitions.\\n * Supports synonyms and examples for richer glossaries.\\n */"
+      "$comment": "/**\\n * Domain Terminology - Ubiquitous language terms with definitions.\\n * Supports synonyms and examples for richer glossaries.\\n * \\n * [Read more on domainlang.net](https://domainlang.net/reference/language#terminology)\\n */"
     },
     {
       "$type": "ParserRule",
@@ -1864,7 +1860,7 @@ export const DomainLangGrammar = (): Grammar => loadedDomainLangGrammar ?? (load
       "entry": false,
       "fragment": false,
       "parameters": [],
-      "$comment": "/**\\n * Decisions, Policies, and Business Rules.\\n * All types are interchangeable - use what reads best for your domain.\\n */"
+      "$comment": "/**\\n * Decisions, Policies, and Business Rules.\\n * All types are interchangeable - use what reads best for your domain.\\n * \\n * [Read more on domainlang.net](https://domainlang.net/reference/language#decisions-policies-rules)\\n */"
     },
     {
       "$type": "ParserRule",
@@ -1877,8 +1873,7 @@ export const DomainLangGrammar = (): Grammar => loadedDomainLangGrammar ?? (load
             "elements": [
               {
                 "$type": "Keyword",
-                "value": "Decision",
-                "$comment": "/** A documented choice or rule that affects the model or process. */"
+                "value": "Decision"
               },
               {
                 "$type": "Keyword",
@@ -1968,8 +1963,7 @@ export const DomainLangGrammar = (): Grammar => loadedDomainLangGrammar ?? (load
             "elements": [
               {
                 "$type": "Keyword",
-                "value": "Policy",
-                "$comment": "/** A business rule or guideline that governs behavior within a context. */"
+                "value": "Policy"
               },
               {
                 "$type": "Keyword",
@@ -2059,8 +2053,7 @@ export const DomainLangGrammar = (): Grammar => loadedDomainLangGrammar ?? (load
             "elements": [
               {
                 "$type": "Keyword",
-                "value": "Rule",
-                "$comment": "/** A business rule or guideline that governs behavior within a context. */"
+                "value": "Rule"
               },
               {
                 "$type": "Keyword",
@@ -2156,8 +2149,7 @@ export const DomainLangGrammar = (): Grammar => loadedDomainLangGrammar ?? (load
                 "$type": "Keyword",
                 "value": "import"
               }
-            ],
-            "$comment": "/** Imports types or namespaces from another file or module, enabling reuse and modularity. */"
+            ]
           },
           {
             "$type": "Assignment",
@@ -2193,13 +2185,12 @@ export const DomainLangGrammar = (): Grammar => loadedDomainLangGrammar ?? (load
             ],
             "cardinality": "?"
           }
-        ],
-        "$comment": "/** Imports types or namespaces from another file or module, enabling reuse and modularity. */"
+        ]
       },
       "entry": false,
       "fragment": false,
       "parameters": [],
-      "$comment": "/**\\n * Import Statement - Manifest-centric import system per PRS-010.\\n * \\n * Simplified syntax where import statements use short specifiers:\\n *   - External dependencies (from manifest): import \\"core\\" as Core\\n *   - Local files: import \\"./shared/types.dlang\\"\\n *   - Workspace-relative: import \\"~/contexts/sales.dlang\\"\\n * \\n * All resolution details (source, version, integrity) live in model.yaml manifest.\\n * Named imports and inline integrity checks have been removed per PRS-010.\\n */"
+      "$comment": "/**\\n * Import Statement - Manifest-centric import system per PRS-010.\\n * \\n * Simplified syntax where import statements use short specifiers:\\n *   - External dependencies (from manifest): import \\"core\\" as Core\\n *   - Local files: import \\"./shared/types.dlang\\"\\n *   - Workspace-relative: import \\"~/contexts/sales.dlang\\"\\n * \\n * All resolution details (source, version, integrity) live in model.yaml manifest.\\n * Named imports and inline integrity checks have been removed per PRS-010.\\n * \\n * [Read more on domainlang.net](https://domainlang.net/reference/language#imports)\\n */"
     },
     {
       "$type": "ParserRule",
@@ -2212,8 +2203,7 @@ export const DomainLangGrammar = (): Grammar => loadedDomainLangGrammar ?? (load
             "elements": [
               {
                 "$type": "Keyword",
-                "value": "Namespace",
-                "$comment": "/** Namespaces organize large models into hierarchical qualified names for symbol resolution. */"
+                "value": "Namespace"
               },
               {
                 "$type": "Keyword",
@@ -2259,7 +2249,7 @@ export const DomainLangGrammar = (): Grammar => loadedDomainLangGrammar ?? (load
       "entry": false,
       "fragment": false,
       "parameters": [],
-      "$comment": "/**\\n * Namespace Declaration - Hierarchical namespacing for organizing models.\\n * Combines package modularity with group-style nesting.\\n */"
+      "$comment": "/**\\n * Namespace Declaration - Hierarchical namespacing for organizing models.\\n * Combines package modularity with group-style nesting.\\n * \\n * [Read more on domainlang.net](https://domainlang.net/reference/language#namespaces)\\n */"
     },
     {
       "$type": "ParserRule",

package/src/index.ts

@@ -9,16 +9,22 @@ export * from './ast-augmentation.js';
 // Export centralized types (canonical source for all service types)
 export * from './services/types.js';
 
-// Export services
+// Export services (read-only for LSP - no network operations)
 export * from './services/workspace-manager.js';
-export * from './services/dependency-resolver.js';
-export * from './services/dependency-analyzer.js';
-export * from './services/governance-validator.js';
 export * from './services/import-resolver.js';
 export * from './services/relationship-inference.js';
-export * from './services/git-url-resolver.js';
 export * from './services/performance-optimizer.js';
-export * from './services/semver.js';
+
+// Export shared utilities
+export * from './utils/manifest-utils.js';
+
+// Note: The following services have been moved to CLI package:
+// - git-url-resolver.ts → @domainlang/cli/services
+// - dependency-resolver.ts → @domainlang/cli/services
+// - dependency-analyzer.ts → @domainlang/cli/services
+// - governance-validator.ts → @domainlang/cli/services
+// - semver.ts → @domainlang/cli/services
 
 // Export LSP services
 export * from './lsp/manifest-diagnostics.js';
+export { DomainLangIndexManager } from './lsp/domain-lang-index-manager.js';

package/src/lsp/domain-lang-code-actions.ts

@@ -46,16 +46,21 @@ export class DomainLangCodeActionProvider implements CodeActionProvider {
         document: LangiumDocument, 
         params: CodeActionParams
     ): MaybePromise<Array<Command | CodeAction> | undefined> {
-        const result: CodeAction[] = [];
-        const acceptor = (ca: CodeAction | undefined): void => {
-            if (ca) result.push(ca);
-        };
+        try {
+            const result: CodeAction[] = [];
+            const acceptor = (ca: CodeAction | undefined): void => {
+                if (ca) result.push(ca);
+            };
 
-        for (const diagnostic of params.context.diagnostics) {
-            this.createCodeActions(diagnostic, document, acceptor);
-        }
+            for (const diagnostic of params.context.diagnostics) {
+                this.createCodeActions(diagnostic, document, acceptor);
+            }
 
-        return result.length > 0 ? result : undefined;
+            return result.length > 0 ? result : undefined;
+        } catch (error) {
+            console.error('Error in getCodeActions:', error);
+            return undefined;
+        }
     }
 
     /**

package/src/lsp/domain-lang-completion.ts

@@ -8,6 +8,7 @@
  * - Maintainable: Clear mapping from grammar to completions
  */
 
+import type { AstNode } from 'langium';
 import { CompletionAcceptor, CompletionContext, DefaultCompletionProvider, NextFeature } from 'langium/lsp';
 import { CompletionItemKind, InsertTextFormat } from 'vscode-languageserver';
 import * as ast from '../generated/ast.js';
@@ -121,6 +122,20 @@ export class DomainLangCompletionProvider extends DefaultCompletionProvider {
         context: CompletionContext,
         next: NextFeature,
         acceptor: CompletionAcceptor
+    ): void {
+        try {
+            this.safeCompletionFor(context, next, acceptor);
+        } catch (error) {
+            console.error('Error in completionFor:', error);
+            // Fall back to default completion on error
+            super.completionFor(context, next, acceptor);
+        }
+    }
+
+    private safeCompletionFor(
+        context: CompletionContext,
+        next: NextFeature,
+        acceptor: CompletionAcceptor
     ): void {
         const node = context.node;
         if (!node) {
@@ -143,84 +158,117 @@ export class DomainLangCompletionProvider extends DefaultCompletionProvider {
             return;
         }
         
+        // Handle node-level completions
+        if (this.handleNodeCompletions(node, acceptor, context, next)) {
+            return;
+        }
+
+        // Handle container-level completions
+        const container = node.$container;
+        if (this.handleContainerCompletions(container, node, acceptor, context, next)) {
+            return;
+        }
+
+        // Let Langium handle default completions
+        super.completionFor(context, next, acceptor);
+    }
+
+    private handleNodeCompletions(
+        node: AstNode,
+        acceptor: CompletionAcceptor,
+        context: CompletionContext,
+        next: NextFeature
+    ): boolean {
         // If we're AT a BoundedContext node: only BC documentation blocks
         if (ast.isBoundedContext(node)) {
             this.addBoundedContextCompletions(node, acceptor, context);
             super.completionFor(context, next, acceptor);
-            return;
+            return true;
         }
 
         // If we're AT a Domain node: only Domain documentation blocks
         if (ast.isDomain(node)) {
             this.addDomainCompletions(node, acceptor, context);
             super.completionFor(context, next, acceptor);
-            return;
+            return true;
         }
 
         // If we're AT a ContextMap node: relationships and contains
         if (ast.isContextMap(node)) {
             this.addContextMapCompletions(node, acceptor, context);
             super.completionFor(context, next, acceptor);
-            return;
+            return true;
         }
 
         // If we're AT a DomainMap node: contains
         if (ast.isDomainMap(node)) {
             this.addDomainMapCompletions(node, acceptor, context);
             super.completionFor(context, next, acceptor);
-            return;
+            return true;
         }
 
         // If we're AT the Model or NamespaceDeclaration level: all top-level constructs
         if (ast.isModel(node) || ast.isNamespaceDeclaration(node)) {
             this.addTopLevelSnippets(acceptor, context);
             super.completionFor(context, next, acceptor);
-            return;
+            return true;
         }
 
-        const container = node.$container;
+        return false;
+    }
+
+    private handleContainerCompletions(
+        container: AstNode | undefined,
+        node: AstNode,
+        acceptor: CompletionAcceptor,
+        context: CompletionContext,
+        next: NextFeature
+    ): boolean {
+        if (!container) {
+            return false;
+        }
 
         // Inside BoundedContext body: suggest missing scalar properties and collections
         if (ast.isBoundedContext(container)) {
             this.addBoundedContextCompletions(container, acceptor, context);
             super.completionFor(context, next, acceptor);
-            return;
+            return true;
         }
 
         // Inside Domain body: suggest missing scalar properties
         if (ast.isDomain(container)) {
             this.addDomainCompletions(container, acceptor, context);
             super.completionFor(context, next, acceptor);
-            return;
+            return true;
         }
 
         // Inside ContextMap body: relationships and contains
         if (ast.isContextMap(container)) {
             this.addContextMapCompletions(container, acceptor, context);
             super.completionFor(context, next, acceptor);
-            return;
+            return true;
         }
 
         // Inside DomainMap body: contains
         if (ast.isDomainMap(container)) {
             this.addDomainMapCompletions(container, acceptor, context);
             super.completionFor(context, next, acceptor);
-            return;
+            return true;
         }
 
         if (ast.isRelationship(node) || ast.isRelationship(container)) {
             this.addRelationshipCompletions(acceptor, context);
             super.completionFor(context, next, acceptor);
-            return;
+            return true;
         }
 
         // Top level container (Model or NamespaceDeclaration): all top-level constructs
         if (ast.isModel(container) || ast.isNamespaceDeclaration(container)) {
             this.addTopLevelSnippets(acceptor, context);
+            return true;
         }
 
-        // Let Langium handle default completions
-        super.completionFor(context, next, acceptor);
+        return false;
     }
 
     private addTopLevelSnippets(acceptor: CompletionAcceptor, context: CompletionContext): void {

package/src/lsp/domain-lang-formatter.ts

@@ -9,29 +9,34 @@ import * as ast from '../generated/ast.js';
 export class DomainLangFormatter extends AbstractFormatter {
 
     protected format(node: AstNode): void {
-    // Namespace declarations
-    if (ast.isNamespaceDeclaration(node)) {
-            this.formatBlock(node);
-        }
-        
-        // Domain declarations
-        if (ast.isDomain(node)) {
-            this.formatBlock(node);
-        }
-        
-        // Bounded contexts
-        if (ast.isBoundedContext(node)) {
-            this.formatBlock(node);
-        }
-        
-        // Context maps
-        if (ast.isContextMap(node)) {
-            this.formatBlock(node);
-        }
-        
-        // Domain maps
-        if (ast.isDomainMap(node)) {
-            this.formatBlock(node);
+        try {
+            // Namespace declarations
+            if (ast.isNamespaceDeclaration(node)) {
+                this.formatBlock(node);
+            }
+            
+            // Domain declarations
+            if (ast.isDomain(node)) {
+                this.formatBlock(node);
+            }
+            
+            // Bounded contexts
+            if (ast.isBoundedContext(node)) {
+                this.formatBlock(node);
+            }
+            
+            // Context maps
+            if (ast.isContextMap(node)) {
+                this.formatBlock(node);
+            }
+            
+            // Domain maps
+            if (ast.isDomainMap(node)) {
+                this.formatBlock(node);
+            }
+        } catch (error) {
+            console.error('Error in format:', error);
+            // Continue - don't crash formatting
         }
     }