Skip to content
CAI
Software that uses CAICheck a score

ContextMapper/context-mapper-dsl

59.4

Adequate · 9 November 2026

15.1k

lines of production code

Java

primary language

10

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

Add IDE support for the Tactic DDD language

The IDE module for the Tactic DDD language is now initialized, enabling language server capabilities. This change introduces the \TacticDDDLanguageIdeModule\ for registering IDE components and the \TacticDDDLanguageIdeSetup\ class, which configures the Guice injector to combine the runtime and IDE modules, allowing the language to be used within an IDE environment.

org.contextmapper.dsl.ide/src/org/contextmapper/tactic · high confidence

Added IDE support for Service Cutter Configuration DSL

The IDE module now includes support for the Service Cutter Configuration DSL, enabling language server capabilities for this specific configuration format. This change introduces the \ServiceCutterConfigurationDSLIdeModule\ and \ServiceCutterConfigurationDSLIdeSetup\ classes, which configure the Xtext infrastructure to provide IDE features (such as syntax highlighting, validation, and code completion) for Service Cutter configuration files within the editor.

org.contextmapper.dsl.ide/src/org/contextmapper/servicecutter · high confidence

Added LSP hover text support for the Context Mapper IDE

The IDE module now registers a custom hover service (CMLHoverService) to provide contextual help when users hover over elements in the editor. This change wires the hover functionality into the language server setup, enabling users to see detailed information about DSL constructs directly in their IDE interface.

org.contextmapper.dsl.ide/src/org/contextmapper/dsl/ide · high confidence

Context map generator now supports team maps and relationship labels

The Context Map generator has been upgraded to support team maps, allowing bounded contexts of type 'TEAM' to realize other bounded contexts, which are now correctly rendered in the generated diagrams. Additionally, the generator can now display optional labels on relationships, specifically the relationship name and implementation technology, providing more detailed context in the visual output. The generator also supports multiple output formats including PNG, SVG, and DOT.

org.contextmapper.dsl/src/org/contextmapper/dsl/generator/contextmap · high confidence

Expanded PlantUML diagram generation capabilities

The PlantUML generator now supports a wider variety of diagram types beyond the original class diagrams. Users can now generate state diagrams for aggregates and flows (including end states), use case diagrams with actor support, component diagrams with detailed relationship labels, and stakeholder mind maps. The generator also handles bounded context refinements, subdomain classifications, and application layer flows, providing richer visualizations of the domain model.

org.contextmapper.dsl/src/org/contextmapper/dsl/generator/plantuml · high confidence

Hover text support for CML keywords

Users can now see descriptive hover text for Context Mapping Language (CML) keywords, such as BoundedContext, ContextMap, and various DDD relationship patterns (e.g., Upstream, Downstream, Customer, Supplier, Open Host Service, Anticorruption Layer). This feature provides immediate inline documentation for these terms within the editor, helping users understand the semantic meaning of the language constructs they are using.

org.contextmapper.dsl.ide/src/org/contextmapper/dsl/ide/hover, org.contextmapper.dsl/src/org/contextmapper/dsl/hover · high confidence

Initial MDSL generator implementation with protected regions and pattern support

The MDSL generator now produces API description files that include protected regions for data types, endpoints, providers, and clients, allowing users to preserve custom modifications across regeneration cycles. It also maps CML upstream/downstream relationships to MDSL patterns (such as OHS and PL) and generates usage context comments (BACKEND\_INTEGRATION and FRONTEND\_INTEGRATION) based on these patterns.

org.contextmapper.dsl/src/org/contextmapper/dsl/generator/mdsl · high confidence

New Context Mapping DSL code formatter

A new formatter class (ContextMappingDSLFormatter) has been added to the formatting2 package, providing automatic code formatting for the Context Mapping DSL. This ensures consistent indentation, spacing, and structure for DSL elements such as ContextMaps, BoundedContexts, Flows, and Coordinations when users format their code.

org.contextmapper.dsl/src/org/contextmapper/dsl/formatting2 · high confidence

New Freemarker sample templates for reports, CSV exports, and JHipster generation

Added a new set of Freemarker template samples in the \samples/freemarker\ directory to demonstrate the generic text-file generator. These include Markdown templates for generating full domain reports, glossaries, and bounded context lists; CSV export templates for stakeholders and value registers; and JHipster JDL templates for scaffolding microservice and monolith applications from Context Mapper Language (CML) models. The entry also includes sample CML models (OnlineShopScenario and TacticDDDModelSkeleton) to serve as test inputs for these templates.

samples · high confidence

New Freemarker templating engine and helper methods for code generation

A new Freemarker-based text generator (FreemarkerTextGenerator) has been added to the DSL, enabling users to generate custom text outputs from Context Map models using FreeMarker templates. This generator exposes model data (such as bounded contexts, domains, stakeholders, and use cases) and registers several custom helper methods for templates: instanceOf (type checking), getType (extracting complex type names), filterBoundedContexts (filtering out TEAM contexts), filterStructuralBoundedContexts (an alias for the same), and filterTeams (filtering for TEAM contexts). It also provides a class map for direct access to DSL types within templates.

org.contextmapper.dsl/src/org/contextmapper/dsl/generator/freemarker · high confidence

New LSP architectural refactoring commands for stakeholders, values, and context splitting

The IDE now exposes a comprehensive set of new architectural refactoring commands via the Language Server Protocol, allowing users to apply complex domain-model transformations directly from their editor. This update adds command handlers for managing stakeholders and values (including adding ethical value assessments, creating stakeholder groups, assigning values to stakeholders, wrapping values in clusters, and creating value registers for bounded contexts) alongside a broad suite of context-splitting and aggregation refactors (such as splitting bounded contexts by features, owners, or subdomains; deriving frontend/backend systems; extracting shared kernels; merging aggregates or contexts; and suspending partnerships). These commands bridge the IDE UI with the underlying semantic refactoring engine, enabling automated structural changes to the CML model.

org.contextmapper.dsl.ide/src/org/contextmapper/dsl/ide/commands/impl/refactoring · high confidence

New LSP command service for CML refactoring and generation

The IDE now exposes a comprehensive set of Context Mapping Language (CML) operations through the Language Server Protocol. This change introduces a new command registry and service that allows clients (such as VS Code or Eclipse) to trigger architectural refactoring actions—like splitting bounded contexts by features or owners, extracting aggregates, and merging contexts—as well as code generation commands for Context Maps, PlantUML, and Sketch Miner. Additionally, quickfix capabilities, such as splitting user stories by verb, are now available via LSP, enabling users to perform these transformations directly from their editor without relying on standalone API calls.

org.contextmapper.dsl.ide/src/org/contextmapper/dsl/ide/commands · high confidence

New LSP-based generation commands for Context Mapper

This change introduces a new set of IDE commands that allow users to trigger code and diagram generation directly through the Language Server Protocol (LSP). The diff adds an abstract base command and specific implementations for generating Context Maps (with support for team clustering and formatting options), MDSL service contracts, PlantUML diagrams, Sketch Miner text, and generic Freemarker-based text files. These commands enable generation workflows within the LSP client environment, handling parameters such as output formats, dimensions, and template URIs.

org.contextmapper.dsl.ide/src/org/contextmapper/dsl/ide/commands/impl/generation · high confidence

New ServiceCutter Configuration DSL for defining service boundaries

Users can now define ServiceCutter configurations using a new domain-specific language (DSL). This addition introduces a grammar for specifying use cases (including latency requirements and entity reads/writes), compatibility characteristics (such as availability, consistency, and security criticality), and structural groupings like aggregates, entities, and security zones. The change includes the necessary runtime modules, scoping providers, and formatters to support this new configuration syntax, enabling users to model their service architecture structure explicitly.

org.contextmapper.dsl/src/org/contextmapper/servicecutter · high confidence

New Sketch Miner converters for Coordination and Flow models

The Sketch Miner generator now includes dedicated converters to translate Context Mapper DSL Coordination and Flow structures into the Sketch Miner visual model. Coordination2SketchMinerConverter maps coordination steps to sequential task lists, while Flow2SketchMinerConverter handles complex flow logic—including parallel gateways, inclusive alternatives, and event-driven steps—by constructing appropriate task sequences and splitting/merging fragments. This enables users to generate accurate Sketch Miner diagrams from both coordination and flow-based context mapping models.

org.contextmapper.dsl/src/org/contextmapper/dsl/generator/sketchminer/converter · high confidence

New Tactic DDD DSL for modeling bounded context internals

Context Mapper introduces a new Domain-Specific Language (DSL) for modeling the internal structure of Bounded Contexts using Tactic Domain-Driven Design patterns. This addition allows users to define services, resources, consumers, and domain objects with specific tactical elements such as state transitions, event publishing, and repository operations. The implementation includes the Xtext grammar, runtime module, and scoping providers necessary to parse and validate these tactical models, enabling more detailed architectural design within bounded contexts.

org.contextmapper.dsl/src/org/contextmapper/tactic/dsl · high confidence

New Value Impact Map generator for PlantUML mindmaps

Added a new generator that produces PlantUML mindmap diagrams from Context Mapper value elicitation data. The implementation maps value registers, clusters, and stakeholder consequences into a structured model (SystemOfInterest, Stakeholder, Value) and renders them via a FreeMarker template, visualizing priorities, impacts, demonstrators, and positive/negative consequences with color-coded nodes.

_org.contextmapper.dsl/src/org/contextmapper/dsl/generator/plantuml/value\_impact\mapping · high confidence

New and expanded code generators for Context Mapper

The generator package now includes several new output generators and refactored base classes. A new XMIGenerator allows exporting the CML model to XMI format. The PlantUMLGenerator has been expanded to produce a wider variety of diagrams, including use-case diagrams, sequence diagrams for use-case interactions, stakeholder maps, value-impact maps, and state diagrams for aggregates and flows, in addition to the existing class and component diagrams. New generators have been added for MDSL contracts (MDSLContractsGenerator), Sketch Miner files (SketchMinerGenerator), and arbitrary text content via Freemarker templates (GenericContentGenerator). The ContextMapGenerator now supports additional labels for relationship names and implementation technologies, and the generator architecture has been standardized with new abstract base classes (AbstractContextMapGenerator, AbstractContextMappingModelGenerator, AbstractFreemarkerTextCreator) to support these capabilities.

org.contextmapper.dsl/src/org/contextmapper/dsl/generator · high confidence

New architectural refactorings for Context Mapping Language models

This update introduces a suite of new architectural refactorings for Context Mapper Language (CML) models, implemented in the \org.contextmapper.dsl.refactoring\ package. Users can now automatically derive Bounded Contexts from Subdomains or User Requirements, split Feature Bounded Contexts into Frontend and Backend systems, and manage symmetric relationships by extracting Shared Kernels, suspending Partnerships, or toggling between Partnership and Shared Kernel types. The refactoring engine also includes helpers to update exposed aggregates when contexts are split and utilities to add ethical value assessments to user stories, providing automated support for rapid OOAD and context mapping evolution.

org.contextmapper.dsl/src/org/contextmapper/dsl/refactoring · high confidence

New formatter for Tactic DDD DSL model elements

A new \TacticDDDLanguageFormatter\ has been introduced to define how Tactic DDD DSL models are unparsed and formatted. This formatter applies specific indentation, spacing, and newline rules for core domain concepts including Entities, DomainEvents, CommandEvents, ValueObjects, Enums, Services, and their constituent attributes, references, and operations. Users will see consistent, structured formatting when their CML files are processed or displayed by tools relying on this formatter.

org.contextmapper.dsl/src/org/contextmapper/tactic/dsl/formatting2 · high confidence

New quickfixes for missing bounded contexts, story splitting, and value object extraction

Users now have access to several new quickfixes in the Context Mapper Language (CML) editor. If a reference to a Bounded Context cannot be resolved, the 'Create a Bounded Context' quickfix automatically generates the missing context in the model. User stories can be refined using the 'Split Story by Verb/Operation' quickfix, which breaks a single story into multiple features based on standard CRUD verbs (create, read, update, delete). Additionally, domain modeling is supported by the 'Extract Value Object' quickfix, which refactors an identifier attribute on a Domain Object into a dedicated Value Object with an 'id' attribute and updates the parent object's references accordingly.

org.contextmapper.dsl/src/org/contextmapper/dsl/quickfixes · high confidence

New refactoring actions for stakeholders, values, and bounded contexts

The IDE now exposes several new refactoring actions via the language server, allowing users to automatically generate or restructure domain model elements. Users can now add Ethical Value Assessments to user stories, create stakeholders for user story roles, and assign values to stakeholders. Additionally, new actions allow creating value registers for bounded contexts, moving stakeholders into groups, and wrapping values in clusters. These actions are implemented as IDE code actions that trigger specific server-side refactoring commands.

org.contextmapper.dsl.ide/src/org/contextmapper/dsl/ide/actions/impl · high confidence

New standalone API for programmatic Context Mapper usage

The standalone package now provides a dedicated API (\StandaloneContextMapperAPI\) and its implementation (\StandaloneContextMapper\) to allow Context Mapper to be used as a library outside of the IDE. This includes helper classes like \ContextMapperStandaloneSetup\ for obtaining the API instance and \FileSystemHelper\ for managing file system access and generation output paths. Users can now load, create, and persist CML models, apply semantic refactorings, and invoke generators programmatically via this new interface.

org.contextmapper.dsl/src/org/contextmapper/dsl/standalone · high confidence

Sketch Miner integration for visualizing flows and coordination

The Sketch Miner generator now produces direct links to BPMN sketches for both CML Flow definitions and Coordination models. This change introduces a new LZString compression utility to encode model data into URL-safe strings, alongside model classes (Task, TaskSequence, SketchMinerModel) and a Freemarker template that formats the output for the Sketch Miner tool. Users can now click generated links to instantly view their process flows and coordination logic in the Sketch Miner interface.

org.contextmapper.dsl/src/org/contextmapper/dsl/generator/sketchminer · high confidence

Support for importing and resolving CML model dependencies

The CML language now supports importing other CML model files. This change introduces a new import resolution mechanism that allows a root CML model to reference and include external models. Consequently, the tooling can now resolve domain objects, subdomains, and bounded contexts across these imported files, ensuring that analysis and transformations consider the full scope of the context map rather than just the single file.

org.contextmapper.dsl/src/org/contextmapper/dsl/cml · high confidence

Behavioural changes

Centralized code actions and quick fixes in the IDE

The IDE now uses a unified action registry to provide refactoring commands (such as splitting bounded contexts or extracting aggregates) and validation quick fixes directly through the language server. This change consolidates how these features are exposed, ensuring they are available in LSP-compatible editors like VS Code, and includes specific quick fixes to open flows and coordinations in Sketch Miner or split user stories by verb.

org.contextmapper.dsl.ide/src/org/contextmapper/dsl/ide/actions · high confidence

Comprehensive semantic validation for Context Mapper Language models

The CML validation engine now enforces a wide range of semantic rules to ensure model correctness. Aggregates are restricted to a single aggregate root and a single state enum. Bounded context relationships are validated to prevent self-references and enforce correct Customer-Supplier role constraints (e.g., prohibiting Open Host Service for upstreams). Context maps must contain all referenced contexts, and exposed aggregates must belong to their upstream context. Team semantics are enforced, ensuring only teams can realize other bounded contexts and own aggregates. Uniqueness is guaranteed for names of bounded contexts, domains, subdomains, modules, aggregates, services, use cases, flows, and coordinations. Application flows and coordination steps are validated to ensure commands, operations, and services are defined within the correct context and that state transitions reference valid aggregate states.

org.contextmapper.dsl/src/org/contextmapper/dsl/validation · high confidence

Discontinuation of Eclipse plugin and migration to Java 17 with Gradle

The project has discontinued the Eclipse plugin, shifting focus to the Language Server (LSP) for VS Code and a standalone library. To support this, the build environment has been upgraded to Java 17 and Gradle 8, and the repository has been renamed to context-mapper-dsl. Users should now install the VS Code extension or use the standalone library via Maven/Gradle, as the Eclipse update site is no longer maintained.

(repo-wide) · high confidence

Enforce scoping rules between Bounded Contexts and Domains

The DSL now prevents domain objects in a Domain from referencing domain objects in a Bounded Context, and vice versa. This is implemented via a new CMLScopingHelper and an updated ContextMappingDSLScopeProvider that filter out invalid cross-boundary references during code completion and validation.

org.contextmapper.dsl/src/org/contextmapper/dsl/scoping · high confidence

Improved error messaging for refactoring serialization failures

When a refactoring operation fails during serialization, users now receive a clearer, user-friendly error message instead of raw internal exceptions. This change introduces a new \RefactoringSerializationException\ that specifically handles cases where a refactoring creates a new domain object with a name that already exists, explaining that serialization is not possible due to ambiguous references. This helps users understand why their model changes could not be saved and how to resolve naming conflicts.

org.contextmapper.dsl/src/org/contextmapper/dsl/exception · high confidence

Improved refactoring error handling to prevent empty CML files

The IDE now handles serialization exceptions during refactorings more robustly. Previously, serialization failures could result in empty CML files being saved. The new WorkspaceEditRecorder implementation catches these exceptions and throws a specific RefactoringSerializationException, ensuring that invalid states do not corrupt the user's model files.

org.contextmapper.dsl.ide/src/org/contextmapper/dsl/ide/edit · high confidence

New exception types for MDSL generator input validation

The MDSL generator now introduces specific exception classes to provide clearer feedback when input models are invalid or unsupported. Users will now see distinct errors for missing context maps, missing CML models, or features that are not yet supported, rather than generic application exceptions.

org.contextmapper.dsl/src/org/contextmapper/dsl/generator/exception · high confidence

New validation rules and error codes for the Tactic DSL

The Tactic DSL now includes a new validation layer that enforces naming conventions and structural constraints. Users will see warnings if service, repository, or domain object names do not start with an uppercase letter, or if attributes and parameters do not start with a lowercase letter. The validator also flags logical inconsistencies, such as properties marked as both 'not changeable' and 'required', or keys marked as 'required'. Additionally, it enforces correct usage of reference properties like 'cache', 'inverse', 'databaseJoinTable', and 'databaseJoinColumn' based on cardinality and directionality. A new syntax error provider also gives clearer guidance when reserved keywords are used as identifiers.

org.contextmapper.dsl/src/org/contextmapper/tactic/dsl/validation · high confidence

Fixes

Fixes CML serialization order issues during refactoring

The DSL now correctly handles the serialization of Context Mapping Language (CML) files when elements are reordered or refactored. Previously, refactoring operations could produce invalid CML files because the parser expected a strict order of root elements (ContextMap, BoundedContext, Domain, UseCases). This change introduces a custom PDA (Pushdown Automaton) utility that sets an unordered sequence strategy, allowing the parser to accept root elements in any order and ensuring that model integrity is maintained during edits.

org.contextmapper.dsl/src/org/contextmapper/dsl · high confidence

Test coverage

Added base test class for CML language server tests; Added base test class for LSP command tests; Added integration test fixtures for Context Map generator; Added integration test fixtures for PlantUML diagram generation; Added integration test fixtures for Service Cutter decomposition; Added integration test fixtures for Sketch Miner flow scenarios; Added integration test fixtures for quickfix scenarios; Added integration test for NoEObjectDescriptionException handling; Added integration test for bounded context resolving; Added integration tests for FreeMarker template functions; Added integration tests for MDSL generator application flows and model edge cases; Added integration tests for PlantUML diagram generators; Added integration tests for subdomain resolution with imported files; Added standalone integration test fixtures for Context Mapper DSL; Added test coverage for Context Mapper DSL parsing and validation; Added tests for CML hover text support; Added tests for CML language server refactoring commands; Added tests for IDE quickfixes and Sketch Miner integration; Added tests for LSP generation commands; Added tests for language server code actions; Expanded integration test coverage for architectural refactorings.

Dependencies

Gradle wrapper updated to version 9.8.2

The project now uses Gradle 9.8.2 for builds, specified in the newly added gradle-wrapper.properties file. This ensures consistent build environments by downloading the specific Gradle distribution automatically.

gradle · high confidence

Migrate build system from Maven to Gradle

The project has switched its build infrastructure from Maven to Gradle, introducing a multi-module structure with \build.gradle\ files for the DSL, IDE, and test modules. This migration updates the Java target to version 17 and upgrades the Xtext framework to version 2.42.0. Additionally, the build now publishes artifacts to the Maven Central Portal and integrates JaCoCo for test coverage reporting.

(dependencies) · high confidence

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

How this codebase got here

Score

  • CAI 60 → 59 (-0.1)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.2) — scores are not directly comparable.

Lenses

  • Code Health 70 → 70 (+0.0)
  • Architecture 94 → 91 (-3.0)
  • Maturity 71 → 70 (-0.1)
  • Readiness 46 → 46 (+0.0)
  • Security 71 → 71 (+0.0)

New (5)

  • Off-boarding risk: anonymized user #1
  • Outdated (compile): org.jacoco:org.jacoco.agent
  • Outdated (compile): org.jacoco:org.jacoco.ant
  • Outdated (compile): org.jacoco:org.jacoco.core
  • Outdated (compile): org.jacoco:org.jacoco.report

Changes since last survey

  • 1 commits — 0 feature/other, 1 fixes

By area

  • org.contextmapper.dsl.tests/src — 1 commit

Notable commits

  • fix: Fix MDSL generation with empty protected regions (#219) (#389)

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

Survey your own repository

ContextMapper/context-mapper-dsl 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.

About this page

  • The score is its most recent published measurement, taken on 9 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit 682b14d37b7c52eebbb7768a8db313bb42a9165c — the exact code this score is about.
  • Scored under rubric-2026.11.2 — the same rubric and the same method as every other entry in this index.
  • Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.3+preprod-b921b700395b.