DomainLang/DomainLang

DomainLang is a domain-specific language and tooling suite for modeling software architectures using Domain-Driven Design concepts. It provides a parser, language server, and CLI to validate, query, and visualize bounded contexts and their relationships. The system supports IDE integration via a VS Code extension and a browser-based playground, enabling developers to define, check, and explore domain models with rich feedback and AI-assisted tools.

22 changes.

This period focused on the comprehensive development of the DomainLang ecosystem, introducing a full-featured Language Server Protocol implementation with advanced parsing, validation, and auto-completion capabilities. The work also established robust tooling, including a VS Code extension, a browser-based playground, and a refactored CLI, all supported by extensive test coverage and standardized development workflows.

25 changes.

This period focused on establishing the project's documentation infrastructure and expanding the CLI package with comprehensive package management and model querying capabilities. Significant effort was also directed toward increasing test coverage for the language server, SDK, and new CLI components, alongside the introduction of context map diagram generation.

A new demo application for DomainLang has been added, featuring a Vite-based build setup configured for Vue.js. The configuration includes specific shims for Node.js modules (such as fs, path, os, and child\_process) to ensure compatibility within the web bundle, and sets the development server to run on port 5173.

dsl/domain-lang/packages/demo · high confidence

The language package now includes a new context map diagram generator that renders bounded contexts as ellipses and relationships as edges with DDD community notation (upstream/downstream roles, integration patterns). A dedicated ELK layout engine is provided to automatically arrange the diagram with a top-to-bottom flow, ensuring upstream contexts appear above downstream ones. This feature enables users to visualize the architectural relationships between bounded contexts directly from the DSL.

dsl/domain-lang/packages/language/src/diagram · high confidence

The extension now renders a context map diagram in the webview, using Sprotty to display bounded contexts as ellipses with DDD community notation. The implementation includes CSS for styling nodes, edges, and labels, as well as TypeScript modules for dependency injection, view rendering, and the main entry point. This enables users to visualize relationships and interactions between bounded contexts.

dsl/domain-lang/packages/extension/src/webview · high confidence

A new example demonstrates a multi-file DomainLang project structure, including a model manifest (model.yaml) that defines package identity, path aliases for clean imports, and external package dependencies. The example includes shared vocabulary definitions (classifications, teams, metadata keys) and domain models (sales, orders, checkout, catalog) that import shared resources using the new path alias syntax.

dsl/domain-lang/examples/multi-file-project · high confidence

A new Vue.js-based demo application has been added to the DomainLang package, providing an interactive browser playground for editing and validating .dlang models. The app features a split-pane interface with a Monaco editor on the left and a structured JSON output on the right, allowing users to see real-time parsing diagnostics and AST results. To support running the language services in the browser, the demo includes shims for Node.js modules (fs, os, path, util, worker-threads, child-process) that either provide browser-compatible stubs or throw errors for unsupported operations.

dsl/domain-lang/packages/demo/src · high confidence

The language server now enforces a wide range of validation rules across the domain model. For domains, it requires a vision statement and detects circular hierarchies. For bounded contexts, it enforces a description, a domain reference, and warns about conflicting inline/block definitions for classification and team assignments. Context maps are checked for empty states, unresolved references, and duplicate relationships. Domain maps are validated for empty states and references. The model itself is checked for unique fully qualified names. Additionally, import statements are validated for resolution, manifest requirements, and cycle detection, while relationships are checked for correct placement of integration patterns (ACL, Conformist, OHS, Supplier, Customer) and duplicate entries.

dsl/domain-lang/packages/language/src/validation · high confidence

The extension now includes a diagram panel that renders DomainLang context maps in a dedicated webview, accessible via the 'DomainLang Diagram' command. Additionally, the extension registers four new Language Model tools (domainlang\_validate, domainlang\_list, domainlang\_get, and domainlang\_explain) that forward requests to the LSP server, enabling AI-assisted interactions with the domain model.

dsl/domain-lang/packages/extension/src/extension · high confidence

The language server and grammar have been significantly restructured to support richer domain modeling. The grammar now defines a unified \Model\ entry point and allows flexible ordering of top-level elements (Domains, BoundedContexts, Teams, Classifications, Metadata). A new \Metadata\ construct enables key-value metadata assignments on elements. The language module (\domain-lang-module.ts\) has been expanded to register new services including \PackageBoundaryDetector\, \ImportResolver\, and \ManifestManager\. The LSP implementation now supports document symbols, code lenses, hover, completion, and code actions. Additionally, the system enforces strict import graph tracking with debounced reloading and validates that the \DOMAINLANG\_ENTRY\ environment variable does not escape the workspace root for security. The \ast-augmentation.ts\ file adds \inferredKind\ properties to relationship types to support SDK inference.

dsl/domain-lang/packages/language/src · high confidence

The hover provider for the DomainLang language server has been refactored to provide richer, structured hover information. A new \DomainLangHoverProvider\ replaces the previous implementation, delegating content generation to specialized builder functions in \hover-builders.ts\ for domains, bounded contexts, and other DSL constructs. Additionally, a new \domain-lang-keywords.ts\ file defines explanations for all language keywords, enabling consistent hover documentation for keywords across the language.

dsl/domain-lang/packages/language/src/lsp/hover · high confidence

The examples directory now includes new sample files that demonstrate advanced DomainLang capabilities. The metadata feature is showcased in metadata-local-definition.dlang and metadata-polyglot.dlang, which show how to define and apply local metadata keys for technology stacks and operational concerns. Import aliasing is demonstrated in import-alias-test-main.dlang and import-alias-test-shared.dlang, illustrating how to import shared declarations with aliases for cleaner context references. Multi-reference scenarios are covered in multi-reference-demo.dlang, showing how to handle same-named elements across different scopes and namespaces. Additionally, other.dlang demonstrates cross-file imports and context relationships. These examples collectively illustrate the updated grammar and supported patterns for building complex domain models.

dsl/domain-lang/examples · high confidence

The site's VitePress configuration has been established, defining the site title, description, and metadata (including favicon and Open Graph tags). The navigation structure is now in place, featuring links to the Home, Guide, Reference, and Resources sections, as well as external links to the VS Code extension and npm packages. The sidebar organizes content into Modeling concepts, Tools & AI, and Reference categories. Additionally, a custom syntax highlighting grammar for DomainLang is included, and the base URL is configured to be dynamic based on the VITEPRESS\_BASE environment variable.

site/.vitepress · high confidence

The DomainLang VS Code extension is now available, providing full editor support for the .dlang syntax. Users gain syntax highlighting, IntelliSense with keyword and cross-reference completion, real-time validation, hover documentation, and go-to-definition features for modeling domains and bounded contexts. The extension also exposes four AI tools (domainlang\_validate, domainlang\_list, domainlang\_get, domainlang\_explain) for use with VS Code Copilot and agents. The package is licensed under Apache 2.0.

dsl/domain-lang/packages/extension · high confidence

The extension now launches the Domain language server via a new main entry point that wires up LSP services, registers custom tool handlers for language model integration, and sets up Sprotty-based diagram generation and selection handlers. It also configures manifest diagnostics for model.yaml files and applies LSP runtime settings for tracing and logging.

dsl/domain-lang/packages/extension/src/language · high confidence

The documentation site now includes interactive railroad diagrams for syntax rules. Users can browse, search, and filter grammar rules by category, with clickable diagrams that allow zooming, panning, and navigation between related rules directly in the docs.

site/.vitepress/theme · high confidence

Added new services to the CLI for managing packages and dependencies: a credential provider for GitHub authentication, a dependency resolver that discovers and resolves transitive dependencies with a 'Latest Wins' strategy, a dependency analyzer for visualizing and analyzing dependency relationships, a governance validator to enforce organizational policies, an install service with integrity verification and frozen/force modes, a package cache for local storage, and a package downloader. These services use HTTP-based operations and are intended for CLI contexts only, not the LSP.

dsl/domain-lang/packages/cli/src/services · high confidence

The SDK now provides a read-only, query-focused API for traversing DomainLang models with O(1) lookups and fluent chains. Users can load models via \loadModel\ (Node.js) or \loadModelFromText\ (browser-safe), then query domains, bounded contexts, teams, and relationships using a fluent builder. The SDK augments AST nodes with computed properties like \effectiveClassification\, \effectiveTeam\, and \fqn\, and exposes pattern matching helpers for integration patterns. Additionally, file and workspace validation capabilities are now available via \validateFile\ and \validateWorkspace\ for CLI and Node.js environments.

dsl/domain-lang/packages/language/src/sdk · high confidence

The CLI now supports a suite of new commands for managing project dependencies and exploring domain models. Users can now add, remove, update, and check for outdated dependencies using the new \add\, \remove\, \update\, \upgrade\, and \outdated\ commands. Additionally, the \install\ command handles dependency resolution and locking, while the \query\ command allows users to search and filter domain models. The \cache-clear\ command provides a way to manage the local package cache, and the \help\ command has been updated to list all available commands. These changes are supported by a new \command-runner\ infrastructure that unifies execution across rich (Ink) and non-rich modes.

dsl/domain-lang/packages/cli/src/commands · high confidence

The language service layer now includes dedicated modules for import resolution, graph traversal, and runtime configuration. Import resolution is handled by a new \ImportResolver\ that supports local, alias, and external package imports with a per-document cache to avoid redundant resolution. A new \ImportGraph\ service recursively builds the dependency graph from an entry file. To support these services, the codebase adds a structured logger (\lsp-logger\), runtime settings for enabling trace/info logs, and utility functions for reading and validating \model.yaml\ manifests. Additionally, a \PackageBoundaryDetector\ identifies external package boundaries for scoping, and a \PerformanceOptimizer\ caches lock file and manifest data.

dsl/domain-lang/packages/language/src/services · high confidence

The Language Server Protocol implementation for DomainLang is now fully realized with new providers for code actions, code lenses, completion, document symbols, formatting, indexing, node kinds, and scoping. Users get quick-fix code actions for import validation errors, context-aware code completions with snippet templates, and enriched document symbols with DDD-specific detail text. The scope provider enforces import-based scoping with alias support and package-boundary transitive imports, ensuring elements are only visible if explicitly imported. The index manager tracks import dependencies and detects cycles, while the formatter handles indentation and newlines for block-based constructs.

dsl/domain-lang/packages/language/src/lsp · high confidence

The CLI now includes a comprehensive set of new UI components for the terminal interface, including a responsive Header with ASCII art branding, a Banner for status messages, a Footer showing version and working directory, and utility components like Spinner, ProgressBar, Table, and StatusMessage. A new theming system using semantic color tokens and a theme manager allows for dynamic color support. Additionally, shared React hooks (useCommand, useFirstRun) and a FileSystemService abstraction are introduced to manage command lifecycle and first-run detection.

dsl/domain-lang/packages/cli/src/ui · high confidence

A new script, postprocess-railroad.mjs, was added to the language package's scripts directory. This script processes the SVG railroad diagrams generated by Langium, stripping hardcoded colors to support VitePress dark mode and adding CSS classes for styling. It also generates a manifest.json containing rule categories and extracts rule descriptions from JSDoc comments in the grammar file, enabling better organization and documentation of the DSL's syntax.

dsl/domain-lang/packages/language/scripts · high confidence

The CLI now uses a centralized \exit-codes\ module that defines typed, semantic exit codes (e.g., \VALIDation\_ERROR\, \PARSes\_ERROR\) for CI/CD integration, replacing ad-hoc numeric codes. A new \runDirect\ utility replaces per-command runner functions, providing a single generic implementation that handles JSON, quiet, and error formatting for non-Ink modes. Output mode detection (\output-mode.ts\) now supports \--json\, \--quiet\, and \--no-color\ flags, enabling programmatic consumption and CI-friendly minimal output.

dsl/domain-lang/packages/cli/src/utils · medium confidence

The CLI entry point (main.ts) has been rewritten to use yargs for command-line argument parsing and routing, replacing the previous implementation. The new code integrates the Ink library to render a rich terminal user interface when appropriate, while falling back to direct output for JSON or quiet modes. It also implements a custom help screen and error handling that suggests using 'dlang help' for available commands.

dsl/domain-lang/packages/cli/src · high confidence

The dsl/domain-lang/.husky directory now includes new pre-commit and commit-msg hooks. The pre-commit hook runs 'npm test' before each commit, while the commit-msg hook enforces commit message formatting using commitlint, ensuring all commits adhere to the project's style guide.

dsl/domain-lang/.husky · high confidence

The root README now features a responsive logo that adapts to light and dark themes, includes badges for CI status, code coverage, security rating, and vulnerabilities from SonarQube, and displays a prerelease warning. The site footer and documentation also include the thinkability sponsorship logo.

(repo-wide) · high confidence

The DomainLang package now includes a comprehensive set of configuration files that define how the project is built, linted, and tested. This includes ESLint and TypeScript compiler settings that enforce strict code quality, a Vitest configuration that sets up code coverage reporting for SonarQube integration, and a commitlint configuration to enforce conventional commit messages. These changes standardize the development workflow, ensuring consistent code style, automated quality checks, and reliable test coverage metrics for the language, CLI, and extension packages.

dsl/domain-lang · high confidence

Added UI component tests for the CLI; Added comprehensive linking tests for cross-reference resolution; Added comprehensive parsing tests for domain language features; Added comprehensive test coverage for CLI services; Added comprehensive test coverage for the DomainLang SDK; Added comprehensive tests for manifest utility functions; Added comprehensive unit tests for CLI commands; Added end-to-end tests for import resolution and caching; Added integration tests for CLI commands; Added resilience tests for import parsing and standalone file handling; Added snapshot tests for CLI help and validate commands; Added test coverage for language model tools and diagram panel; Added test utilities for CLI components; Added tests for context map diagram generation; Added tests for multi-target reference resolution; Consolidates and standardizes test infrastructure for the domain language; Expanded LSP test coverage for core language features; Expanded validation test coverage for domain language features; Test coverage for import-based scoping and reference resolution; Updated help command snapshot for clarity.

The project's npm dependencies have been upgraded to their latest major versions, including Vitest 4, TypeScript 6, ESLint 10, and @typescript-eslint 8. The language package has been upgraded to Langium 4.2.0, and the CLI package now targets Node.js 22. Additionally, the site dependencies have been updated to VitePress 1.6.3 and Vue 3.5.13.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 28 → 55 (+27.3)
• Rubric changed (rubric-2026.08.18 → rubric-2026.08.19) — scores are not directly comparable.

• Code Health 82 (new)
• Architecture 99 (new)
• Maturity 13 → 70 (+57.0)
• Readiness 15 → 56 (+40.6)
• Security 100 → 40 (-60.0)
• Domain Modelling 100 (new)

• Dependency hygiene not measured — no supported dependency manifest was read
• No automated tests
• No tests found
• bus factor not measured — no commits were sampled
• early-stage repository — too little history to judge knowledge freshness
• single-commit history — no usable git history window to measure hotspots

• Change coupling: domain-lang-formatter.ts ↔ domain-lang-scope.ts (dsl/domain-lang/packages/language/src/lsp/domain-lang-formatter.ts)
• Change coupling: import-graph.ts ↔ performance-optimizer.ts (dsl/domain-lang/packages/language/src/services/import-graph.ts)
• Change coupling: import-graph.ts ↔ workspace-manager.ts (dsl/domain-lang/packages/language/src/services/import-graph.ts)
• Coverage not included — suite not readable by the collector
• Critical CVE: [GHSA redacted] (dsl/domain-lang/package-lock.json)
• Critical CVE: [GHSA redacted] (dsl/domain-lang/package-lock.json)
• Dependency hygiene not measured — dependency manifest found but not parsed for hygiene
• FileTooLong: lsp/domain-lang-completion.ts (dsl/domain-lang/packages/language/src/lsp/domain-lang-completion.ts)
• High CVE: [GHSA redacted] (dsl/domain-lang/package-lock.json)
• High CVE: [GHSA redacted] (dsl/domain-lang/package-lock.json)
• High CVE: [GHSA redacted] (dsl/domain-lang/package-lock.json)
• High CVE: [GHSA redacted] (dsl/domain-lang/package-lock.json)
• High CVE: [GHSA redacted] (dsl/domain-lang/package-lock.json)
• High CVE: [GHSA redacted] (dsl/domain-lang/package-lock.json)
• High CVE: [GHSA redacted] (dsl/domain-lang/package-lock.json)
• High CVE: [GHSA redacted] (dsl/domain-lang/package-lock.json)
• High CVE: [GHSA redacted] (dsl/domain-lang/package-lock.json)
• High CVE: [GHSA redacted] (dsl/domain-lang/package-lock.json)
• High CVE: [GHSA redacted] (dsl/domain-lang/package-lock.json)
• High CVE: [GHSA redacted] (dsl/domain-lang/package-lock.json)
• …and 66 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

DomainLang/DomainLang was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.