@domainlang/language 0.10.0 → 0.12.0

package/src/diagram/context-map-layout-configurator.ts

@@ -0,0 +1,43 @@
+import type { LayoutOptions } from 'elkjs/lib/elk-api.js';
+import { DefaultLayoutConfigurator } from 'sprotty-elk/lib/elk-layout.js';
+import type { SGraph, SNode, SModelIndex, SEdge } from 'sprotty-protocol';
+
+/**
+ * ELK layout configurator for DomainLang context map diagrams.
+ *
+ * Uses the `layered` algorithm with **DOWN** direction (top-to-bottom) so
+ * upstream contexts appear above downstream contexts, matching the conventional
+ * DDD Context Map layout direction.
+ */
+export class ContextMapLayoutConfigurator extends DefaultLayoutConfigurator {
+    protected override graphOptions(_graph: SGraph, _index: SModelIndex): LayoutOptions {
+        return {
+            'elk.algorithm': 'layered',
+            'elk.direction': 'DOWN',
+            'elk.layered.nodePlacement.strategy': 'BRANDES_KOEPF',
+            'elk.spacing.nodeNode': '100',
+            'elk.layered.spacing.nodeNodeBetweenLayers': '140',
+            'elk.spacing.edgeNode': '60',
+            'elk.spacing.edgeEdge': '40',
+            // Edge routing mode is irrelevant — the webview SmoothBezierEdgeView
+            // ignores ELK routing points and computes dynamic bezier curves
+            // anchored directly to node ellipses with obstacle avoidance.
+            'elk.edgeRouting': 'POLYLINE',
+            'elk.layered.mergeEdges': 'false',
+            'elk.layered.crossingMinimization.strategy': 'LAYER_SWEEP',
+            'elk.layered.thoroughness': '7',
+        };
+    }
+
+    protected override nodeOptions(_node: SNode, _index: SModelIndex): LayoutOptions {
+        return {
+            'elk.layered.nodePlacement.bk.fixedAlignment': 'BALANCED',
+        };
+    }
+
+    protected override edgeOptions(_edge: SEdge, _index: SModelIndex): LayoutOptions {
+        return {
+            'elk.layered.priority.direction': '1',
+        };
+    }
+}

package/src/diagram/elk-layout-factory.ts

@@ -0,0 +1,83 @@
+/**
+ * ELK layout engine factory for DomainLang diagrams.
+ *
+ * Encapsulates the ELK construction, factory wiring, and Sprotty-ELK layout
+ * engine instantiation so that both the VS Code extension (via the LSP server
+ * DI module) and the CLI (for standalone diagram export) can reuse the same
+ * layout logic without embedding the setup inline.
+ *
+ * @module diagram/elk-layout-factory
+ */
+import * as ElkBundled from 'elkjs/lib/elk.bundled.js';
+import type { ELK } from 'elkjs/lib/elk-api.js';
+import {
+    DefaultElementFilter,
+    ElkLayoutEngine,
+    type ElkFactory,
+    type IElementFilter,
+    type ILayoutConfigurator,
+} from 'sprotty-elk/lib/elk-layout.js';
+import type { IModelLayoutEngine } from 'sprotty-protocol';
+import { ContextMapLayoutConfigurator } from './context-map-layout-configurator.js';
+
+/** @internal Handles the dual ESM/CJS export shape of the bundled ELK module. */
+type ElkConstructor = new (args?: { algorithms?: string[] }) => ELK;
+const _elkConstructor: ElkConstructor = (
+    (ElkBundled as unknown as { default?: ElkConstructor }).default
+    ?? (ElkBundled as unknown as ElkConstructor)
+);
+
+/**
+ * Creates an {@link ElkFactory} that produces a new bundled ELK instance
+ * pre-configured for the `layered` algorithm.
+ *
+ * Use this in Langium's DI module (`layout.ElkFactory`) or directly in the
+ * CLI when running the layout engine standalone.
+ */
+export function createElkFactory(): ElkFactory {
+    return () => new _elkConstructor({ algorithms: ['layered'] });
+}
+
+/**
+ * Creates the full set of objects required to run the ELK layout engine for
+ * DomainLang context-map diagrams.
+ *
+ * Returns the three collaborators that together constitute a complete
+ * `IModelLayoutEngine`:
+ * - `elkFactory` — produces the ELK worker instance
+ * - `elementFilter` — controls which model elements are laid out
+ * - `layoutConfigurator` — supplies algorithm-specific ELK options
+ *
+ * Callers that use Langium DI should register these individually via the
+ * `layout` service group.  Callers that operate outside of DI (e.g. the CLI)
+ * can call {@link createElkLayoutEngine} for a fully assembled engine.
+ */
+export function createElkLayoutComponents(): {
+    elkFactory: ElkFactory;
+    elementFilter: IElementFilter;
+    layoutConfigurator: ILayoutConfigurator;
+} {
+    return {
+        elkFactory: createElkFactory(),
+        elementFilter: new DefaultElementFilter(),
+        layoutConfigurator: new ContextMapLayoutConfigurator(),
+    };
+}
+
+/**
+ * Creates a fully assembled {@link IModelLayoutEngine} for DomainLang
+ * context-map diagrams using the bundled ELK engine.
+ *
+ * Intended for use outside of Langium's DI container — for example, in the
+ * CLI when generating standalone SVG or image exports.
+ *
+ * @example
+ * ```typescript
+ * const layoutEngine = createElkLayoutEngine();
+ * const laidOutModel = await layoutEngine.layout(rootModel);
+ * ```
+ */
+export function createElkLayoutEngine(): IModelLayoutEngine {
+    const { elkFactory, elementFilter, layoutConfigurator } = createElkLayoutComponents();
+    return new ElkLayoutEngine(elkFactory, elementFilter, layoutConfigurator) as IModelLayoutEngine;
+}

package/src/domain-lang-module.ts

@@ -16,13 +16,18 @@ import { DomainLangFormatter } from './lsp/domain-lang-formatter.js';
 import { DomainLangHoverProvider } from './lsp/hover/domain-lang-hover.js';
 import { DomainLangCompletionProvider } from './lsp/domain-lang-completion.js';
 import { DomainLangCodeActionProvider } from './lsp/domain-lang-code-actions.js';
+import { DomainLangCodeLensProvider } from './lsp/domain-lang-code-lens-provider.js';
 import { DomainLangNodeKindProvider } from './lsp/domain-lang-node-kind-provider.js';
 import { DomainLangDocumentSymbolProvider } from './lsp/domain-lang-document-symbol-provider.js';
+import { SprottyDefaultModule, SprottySharedModule } from 'langium-sprotty';
+import type { IDiagramGenerator, IModelLayoutEngine } from 'sprotty-protocol';
 import { ImportResolver } from './services/import-resolver.js';
-import { WorkspaceManager } from './services/workspace-manager.js';
+import { ManifestManager } from './services/workspace-manager.js';
 import { PackageBoundaryDetector } from './services/package-boundary-detector.js';
 import { DomainLangWorkspaceManager } from './lsp/domain-lang-workspace-manager.js';
 import { DomainLangIndexManager } from './lsp/domain-lang-index-manager.js';
+import { DomainLangContextMapDiagramGenerator } from './diagram/context-map-diagram-generator.js';
+import { createElkLayoutEngine } from './diagram/elk-layout-factory.js';
 
 /**
  * Declaration of custom services - add your own service classes here.
@@ -30,7 +35,7 @@ import { DomainLangIndexManager } from './lsp/domain-lang-index-manager.js';
 export type DomainLangAddedServices = {
     imports: {
         ImportResolver: ImportResolver,
-        WorkspaceManager: WorkspaceManager,
+        ManifestManager: ManifestManager,
         PackageBoundaryDetector: PackageBoundaryDetector
     },
     references: {
@@ -40,8 +45,13 @@ export type DomainLangAddedServices = {
         Formatter: DomainLangFormatter,
         HoverProvider: DomainLangHoverProvider,
         CompletionProvider: DomainLangCompletionProvider,
+        CodeLensProvider: DomainLangCodeLensProvider,
         CodeActionProvider: DomainLangCodeActionProvider
-    }
+    },
+    diagram: {
+        DiagramGenerator: IDiagramGenerator,
+        ModelLayoutEngine: IModelLayoutEngine
+    },
 }
 
 /**
@@ -68,7 +78,7 @@ const DomainLangSharedModule: Module<LangiumSharedServices, PartialLangiumShared
 export const DomainLangModule: Module<DomainLangServices, PartialLangiumServices & DomainLangAddedServices> = {
     imports: {
         ImportResolver: (services) => new ImportResolver(services),
-        WorkspaceManager: () => new WorkspaceManager({ autoResolve: false, allowNetwork: false }),
+        ManifestManager: () => new ManifestManager({ autoResolve: false, allowNetwork: false }),
         PackageBoundaryDetector: () => new PackageBoundaryDetector()
     },
     references: {
@@ -80,9 +90,14 @@ export const DomainLangModule: Module<DomainLangServices, PartialLangiumServices
         Formatter: () => new DomainLangFormatter(),
         HoverProvider: (services) => new DomainLangHoverProvider(services),
         CompletionProvider: (services) => new DomainLangCompletionProvider(services),
+        CodeLensProvider: () => new DomainLangCodeLensProvider(),
         CodeActionProvider: () => new DomainLangCodeActionProvider(),
         DocumentSymbolProvider: (services) => new DomainLangDocumentSymbolProvider(services)
     },
+    diagram: {
+        DiagramGenerator: (services) => new DomainLangContextMapDiagramGenerator(services as never),
+        ModelLayoutEngine: () => createElkLayoutEngine(),
+    },
 };
 
 /**
@@ -107,11 +122,13 @@ export function createDomainLangServices(context: DefaultSharedModuleContext): {
     const shared = inject(
         createDefaultSharedModule(context),
         DomainLangGeneratedSharedModule,
-        DomainLangSharedModule
+        DomainLangSharedModule,
+        SprottySharedModule as never
     );
     const DomainLang = inject(
         createDefaultModule({ shared }),
         DomainLangGeneratedModule,
+        SprottyDefaultModule as never,
         DomainLangModule
     );
     shared.ServiceRegistry.register(DomainLang);

package/src/index.ts

@@ -14,6 +14,8 @@ export * from './services/workspace-manager.js';
 export * from './services/import-resolver.js';
 export * from './services/relationship-inference.js';
 export * from './services/performance-optimizer.js';
+export * from './services/lsp-logger.js';
+export * from './services/lsp-runtime-settings.js';
 
 // Export shared utilities
 export * from './utils/manifest-utils.js';
@@ -28,4 +30,10 @@ export * from './utils/manifest-utils.js';
 // Export LSP services
 export * from './lsp/manifest-diagnostics.js';
 export { DomainLangIndexManager } from './lsp/domain-lang-index-manager.js';
+export { registerDomainLangRefresh, processWatchedFileChanges } from './lsp/domain-lang-refresh.js';
 export { registerToolHandlers } from './lsp/tool-handlers.js';
+
+// Export diagram services (reusable by CLI and extension)
+export { DomainLangContextMapDiagramGenerator } from './diagram/context-map-diagram-generator.js';
+export { ContextMapLayoutConfigurator } from './diagram/context-map-layout-configurator.js';
+export { createElkLayoutEngine, createElkFactory } from './diagram/elk-layout-factory.js';

package/src/lsp/domain-lang-code-lens-provider.ts

@@ -0,0 +1,54 @@
+import { AstUtils, type LangiumDocument } from 'langium';
+import type { CodeLens, CodeLensParams } from 'vscode-languageserver';
+import { isContextMap, type ContextMap, type Model } from '../generated/ast.js';
+
+const OPEN_DIAGRAM_COMMAND = 'domainlang.diagram.open';
+
+/**
+ * Provides contextual code lenses for context map diagram actions.
+ */
+export class DomainLangCodeLensProvider {
+    async provideCodeLens(document: LangiumDocument, _params: CodeLensParams): Promise<CodeLens[]> {
+        try {
+            const model = (document as LangiumDocument<Model>).parseResult?.value;
+            if (!model) {
+                return [];
+            }
+
+            const contextMaps: ContextMap[] = [];
+
+            if (isContextMap(model)) {
+                contextMaps.push(model);
+            }
+
+            for (const node of AstUtils.streamAllContents(model)) {
+                if (isContextMap(node)) {
+                    contextMaps.push(node);
+                }
+            }
+
+            return contextMaps.flatMap((contextMap) => {
+                const range = contextMap.$cstNode?.range;
+                if (!range) {
+                    return [];
+                }
+
+                return [{
+                    range: {
+                        start: { line: range.start.line, character: 0 },
+                        end: { line: range.start.line, character: 0 },
+                    },
+                    command: {
+                        title: 'Open diagram',
+                        command: OPEN_DIAGRAM_COMMAND,
+                        arguments: [{
+                            uri: document.uri.toString(),
+                        }],
+                    },
+                }];
+            });
+        } catch {
+            return [];
+        }
+    }
+}

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

@@ -16,7 +16,7 @@ import { CompletionItemKind, CompletionList, InsertTextFormat, TextEdit } from '
 import type { CancellationToken, CompletionItem, CompletionParams } from 'vscode-languageserver-protocol';
 import * as ast 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 { ModelManifest, DependencySpec } from '../services/types.js';
 
 /**
@@ -124,7 +124,7 @@ const TOP_LEVEL_SNIPPETS = [
 ] as const;
 
 export class DomainLangCompletionProvider extends DefaultCompletionProvider {
-    private readonly workspaceManager: WorkspaceManager;
+    private readonly workspaceManager: ManifestManager;
 
     override readonly completionOptions = {
         triggerCharacters: ['.']
@@ -132,7 +132,7 @@ export class DomainLangCompletionProvider extends DefaultCompletionProvider {
 
     constructor(services: DomainLangServices) {
         super(services);
-        this.workspaceManager = services.imports.WorkspaceManager;
+        this.workspaceManager = services.imports.ManifestManager;
     }
 
     /**

package/src/lsp/domain-lang-document-symbol-provider.ts

@@ -147,8 +147,8 @@ export class DomainLangDocumentSymbolProvider extends DefaultDocumentSymbolProvi
         const cstNode = rel.$cstNode;
         if (!cstNode) return undefined;
 
-        const left = isThisRef(rel.left) ? 'this' : rel.left?.link?.ref?.name ?? '?';
-        const right = isThisRef(rel.right) ? 'this' : rel.right?.link?.ref?.name ?? '?';
+        const left = isThisRef(rel.left) ? 'this' : rel.left?.link?.$refText ?? '?';
+        const right = isThisRef(rel.right) ? 'this' : rel.right?.link?.$refText ?? '?';
         const name = `${left} → ${right}`;
 
         const range = CstUtils.toDocumentSegment(cstNode).range;
@@ -168,7 +168,7 @@ export class DomainLangDocumentSymbolProvider extends DefaultDocumentSymbolProvi
         const cstNode = meta.$cstNode;
         if (!cstNode) return undefined;
 
-        const name = meta.key?.ref?.name ?? 'unknown';
+        const name = meta.key?.$refText ?? 'unknown';
         const range = CstUtils.toDocumentSegment(cstNode).range;
 
         return DocumentSymbol.create(
@@ -197,8 +197,8 @@ export class DomainLangDocumentSymbolProvider extends DefaultDocumentSymbolProvi
     /** Builds BC detail: "BC for DomainName — description". */
     private getBcDetail(node: BoundedContext): string | undefined {
         const parts: string[] = [];
-        if (node.domain?.ref?.name) {
-            parts.push(`BC for ${node.domain.ref.name}`);
+        if (node.domain?.$refText) {
+            parts.push(`BC for ${node.domain.$refText}`);
         }
         if (node.description) {
             parts.push(node.description);