finos/morphir-dotnet

Morphir is a cross-platform F\# implementation of the Morphir Intermediate Representation (IR) toolchain, designed to model, validate, and generate code from domain-specific languages. It provides a pluggable pipeline architecture for processing IR structures, including optimization, type validation, and JSON serialization, alongside a runtime SDK for executing generated F\# code. The system supports migration from Elm, offers an interactive web playground, and manages a layered configuration system for CLI tooling and artifact distribution.

A new TypeValidator plugin has been added to the Morphir IR Pipeline Plugins library. This component performs static type validation on the Morphir Intermediate Representation, inferring types for literals, variables, tuples, lists, function applications, and conditional expressions. It reports type errors with source positions and accumulates all errors found during the validation process, helping users catch type mismatches early in the pipeline.

src/Morphir.IR.Pipeline.Plugins · high confidence

The Morphir.Testing module now includes an Elm-like assertion API (Assertions.Expect) that aligns with the style of morphir-elm tests, making it easier to write tests that match the structure and style of morphir-elm tests. This new module provides pipeline-friendly assertion functions such as equal, isTrue, and isFalse, which support both auto-generated and custom messages, and is built on top of the Expecto testing framework.

src/Morphir.Testing · high confidence

Adds the AOT Guru skill to the Claude Code environment, providing expert guidance on producing single-file trimmed executables and preparing code for Native AOT compilation. This update includes diagnostic scripts (aot-diagnostics.fsx, aot-analyzer.fsx, aot-test-runner.fsx) to analyze project configurations, parse build warnings, and run size-optimization test matrices, alongside documentation templates for tracking issues and workarounds. It also establishes a structured knowledge base and agent guidance to help developers resolve trimming warnings, reduce binary sizes, and adopt AOT-compatible patterns like source generators and Myriad.

.claude/skills/aot-guru · high confidence

Added the Morphir.Internal.CodeGeneration project, establishing the infrastructure for a Myriad-based code generation plugin. This includes marker attributes (GenerateJsonCodec, GenerateVisitor, GenerateLenses, GenerateActivePatterns, GenerateBuilder) and corresponding generator stubs that currently return empty output. The project integrates with the build system via MSBuild props and registers these generators through the MyriadPlugin module, laying the groundwork for future AOT-compatible, reflection-free code generation features.

src/Morphir.Internal.CodeGeneration · high confidence

A new internal project, Morphir.Internal.CodeGeneration, has been added to support code generation tasks. This location introduces configuration structures for JSON codecs, visitors, lenses, active patterns, and builders, along with default settings for each. It also provides core helper modules for managing generator configurations, applying naming policies (camelCase/PascalCase), and identifying primitive types, laying the foundation for subsequent code generation logic.

Morphir.Internal.CodeGeneration · high confidence

Morphir.Live is a new Blazor WebAssembly application that provides an interactive web-based environment for exploring Morphir models. It features a Material Design UI built with MudBlazor and a 'Try Morphir' page that integrates the Monaco code editor, allowing users to input F\# or Elm code and view mock transformation outputs. The application includes a responsive layout, routing, and a home page, serving as a client-side playground for experimenting with Morphir IR.

src/Morphir.Live · high confidence

The new \src/Morphir.SDK\ directory provides the F\# runtime library for generated Morphir code, implementing core SDK modules adapted from morphir-elm. This includes fundamental types and operations in \Basics\, \Bool\, \Char\, \Int\, and \String\, as well as functional data structures like \List\, \Dict\ (mapped to F\# Map), \Set\, \Maybe\ (Option), and \Result\. It also adds date and time handling via \LocalDate\ (DateOnly) and \LocalTime\ (TimeOnly), along with helper modules for \Decimal\ and \Tuple\. The library is built on .NET 10.0 and F\# 10.0.103, ensuring AOT compatibility and semantic alignment with the Morphir IR.

src/Morphir.SDK · high confidence

The project has migrated its build system from Just to Nuke, providing a type-safe, cross-platform C\# build orchestration with targets for compiling, testing, packaging, and publishing. To support AI-assisted development, the repository now includes comprehensive guidance files (AGENTS.md, CLAUDE.md, .cursorrules) and specialized skills for QA testing, AOT optimization, release management, and documentation. The solution structure is defined in Morphir.slnx, and the project is now licensed under Apache 2.0.

(repo-wide) · high confidence

Added a new QA Tester skill to the Claude Code environment, providing a structured framework for quality assurance. This includes a main skill definition (SKILL.md) with playbooks for test plan design, regression testing, and issue reporting, alongside three executable F\# scripts: a quick smoke test for build and packaging sanity checks, a comprehensive regression test suite covering the full CI workflow and E2E verification, and a NuGet package validator to ensure correct structure and metadata. These tools allow users to invoke automated testing and validation directly within the development workflow.

.claude/skills/qa-tester · high confidence

The project now includes a specialized Release Manager skill (located in .claude/skills/release-manager) that automates the end-to-end release workflow for morphir-dotnet. This capability introduces F\# scripts for pre-release validation (prepare-release.fsx), deployment monitoring (monitor-release.fsx), post-release verification (validate-release.fsx), and failed release recovery (resume-release.fsx). It also adds a new monitor-pr.fsx script to track pull request checks and auto-merge. A key behavioral addition is the automated retrospective system: the skill tracks release history in a local JSON file and prompts for feedback after failures or after three consecutive successes, integrating these insights into release tracking issues to continuously improve the release process.

.claude/skills/release-manager · high confidence

Users can now construct Morphir processor pipelines using a new F\# computation expression syntax (e.g., \pipeline { parse ... uses ... stringify ... }\). This API provides an ergonomic, declarative way to define processing steps, with pipelines being immutable (frozen) by default to ensure safety, while still supporting explicit mutable modes via \Pipeline.mut\ or the \unfrozen\ keyword for scenarios requiring post-creation modification.

src/Morphir.IR.Pipeline · high confidence

The Morphir CLI now supports a layered configuration system that merges settings from global, workspace, user, and CI profiles (via TOML files), with workspace root discovery preferring Git roots. Additionally, the tooling introduces a management system for distributions, tools, and extensions, allowing users to install, activate, and manage these artifacts with a global-first approach that supports local workspace overrides.

src/Morphir.Tooling · high confidence

Added the core type definitions for the new layered configuration system in Morphir.Configuration. This includes types for CI profile modes (On, Off, Auto), cache path overrides, and the structure for configuration layers and resolution results, establishing the schema for merging global, workspace, user, and CI profiles.

Morphir.Configuration · high confidence

The Morphir.Core/IR module now includes foundational interfaces for the Intermediate Representation, specifically IName and IType, alongside a new FqName record for fully qualified naming. To support data interchange, a new Classic IR codec layer has been added, providing JSON serialization and deserialization for Classic Type and Field structures via dedicated converter factories. A static MorphirJson helper class is also introduced to expose encode/decode methods using these custom converters, ensuring type preservation during JSON operations.

src/Morphir.Core/IR · high confidence

The Morphir IR now includes a new 'Classic' model implementation in F\# that defines core structures for types, values, modules, packages, and distributions. This update adds access control mechanisms to distinguish between public and private types and values, and provides Computation Expression-based DSL builders for Modules, Packages, and Distributions to simplify the creation of IR constructs. Additionally, string serialization (toString) and parsing (fromString/fromStringStrict) capabilities have been added for FQName, Type, and Value elements.

Morphir.Models · high confidence

The Morphir.IR.Pipeline module now provides a unified, pluggable architecture for processing source files. This change introduces VFile as a virtual file object that carries content, path history, and accumulated diagnostics (Info, Warning, Error, Fatal) through transformation phases. It adds VFileTree to manage hierarchical multi-file projects, allowing recursive traversal, file lookup, and aggregate error checking. The core MorphirProcessor orchestrates the pipeline using a unified.js-inspired pattern, supporting distinct parse, transform (via Plugins), and stringify phases. The processor supports a frozen/unfrozen state model to safely share configuration templates while allowing dynamic extension of parsers, plugins, and compilers.

Morphir.IR.Pipeline · high confidence

The Morphir CLI now supports a layered configuration system that merges settings from global, workspace, user, and CI profiles, with CI environments automatically detected via standard environment variables. This change also introduces structured logging using Serilog and Microsoft.Extensions.Hosting, replacing previous console output methods to provide more consistent and parseable logs for users and automation tools.

src/Morphir · high confidence

The Morphir.Core library introduces a new set of Intermediate Representation (IR) structures to support access control and path handling. This includes the \AccessControlled\<T\>\ record for managing public and private value visibility, and new \Path\, \ModulePath\, and \PackageName\ types for hierarchical naming. A comprehensive \Document\ type is added to represent JSON-like data structures (primitives, arrays, objects) with type-safe serialization support via \MorphirJsonOptions\. Additionally, the \Classic.IR\ namespace now defines \Type\ and \Value\ records using discriminated unions (via Dunet) to model classic Morphir type systems, including variables, references, tuples, records, and functions, alongside a new \Attribute\ union type.

Morphir.Core · high confidence

The Morphir.Models package now includes a new 'Classic' Intermediate Representation (IR) implementation in F\#, providing type aliases, core data structures (Types, Values, Patterns, Literals), and a comprehensive Domain-Specific Language (DSL) using Computation Expressions to construct IR elements programmatically.

src/Morphir.Models · high confidence

Added the Elm-to-F\# Guru skill, providing expert guidance and automation for migrating Elm code from finos/morphir-elm to idiomatic F\# for morphir-dotnet. This includes a comprehensive pattern catalog (covering custom types, JSON encoders/decoders, opaque types, and Fun.Blazor UI migration), a set of F\# automation scripts (for module analysis, test extraction, and Myriad plugin scaffolding), and integration templates for Myriad code generation and MSBuild.

.claude/skills/elm-to-fsharp-guru · high confidence

The Morphir IR pipeline now includes two new plugins: an Optimizer that performs semantics-preserving transformations such as constant folding, dead code elimination, and identity function elimination, and a PrettyPrinter that generates human-readable IR output with configurable indentation, type annotations, and ANSI color coding.

Morphir.IR.Pipeline.Plugins · high confidence

Added a new set of JSON converters in the IR Codecs module to enable serializing and deserializing Morphir Intermediate Representation types. This includes converters for Document (supporting native JSON types and tagged formats like $uri, $uuid, $bytes), FqName (serialized as a three-element array of PackagePath, ModulePath, and LocalName), Name (with format-version-aware output using either classic arrays or kebab-case strings), Path/ModulePath/PackageName (serialized as arrays of Name arrays), and a placeholder for Type. These changes allow Morphir IR structures to be exchanged via JSON.

src/Morphir.Core/IR/Codecs · high confidence

A new Rust-based WASM plugin has been added to the integrations directory to enable the proto toolchain manager to install and manage platform-specific Morphir CLI executables. The plugin supports Linux (x64, arm64), macOS (x64, arm64), and Windows (x64), automatically detecting the host platform to generate the correct GitHub Release download URLs and handling post-installation tasks such as setting executable permissions on Unix systems. This release also includes comprehensive unit tests and BDD-style integration test documentation to verify platform detection, version resolution, and URL generation logic.

integrations · high confidence

A comprehensive template has been added to \.claude/skills/template\ to standardize the creation of new 'guru' skills. This template provides a structured starting point including \metadata.yaml\ for configuration, \SKILL.md\ for core documentation, \README.md\ for quick reference, and \MAINTENANCE.md\ for lifecycle management. It also includes directories for automation scripts (\scripts/\), reusable templates (\templates/\), and pattern catalogs (\patterns/\), ensuring consistent structure, review capabilities, and cross-agent compatibility for all new skills.

.claude/skills/template · high confidence

The scripts directory now includes a comprehensive set of new tools: platform-specific installers (install-linux.sh, install-macos.sh, install-windows.ps1) that fetch standalone executables from NuGet or GitHub releases; C\# scripts (publish-single-file.cs, publish-single-file-untrimmed.cs, generate-wolverine-code.cs) for building and publishing the Morphir CLI with optional trimming; F\# scripts (remove-claude-coauthor.fsx, validate-changelog.fsx) for commit hygiene and changelog validation; and shell/PowerShell scripts (create-architect-issues.sh, create-fsharp-backend-issues.sh, create-project-board.sh, add-to-project-106.ps1) to automate GitHub issue and project board creation. A new ScriptUtilities.cs class provides shared helpers for process execution and path resolution, and a README.md documents all available scripts and their usage.

scripts · high confidence

The \Morphir.SDK.Core\ module no longer provides the \Maybe\ monad implementation (including \Just\, \Nothing\, \map\, \andThen\, etc.) or the \Regex\ utilities (including \fromString\ and \find\), as these source files have been deleted. Additionally, the \paket.references\ file containing dependencies for \FSharp.Core\, \Microsoft.SourceLink.GitHub\, and \Microsoft.NETFramework.ReferenceAssemblies\ has been removed, indicating a shift in how this core library manages its build references.

src/Morphir.SDK.Core · high confidence

The legacy implementation files for the Morphir.IR module have been removed, including the main library code (Library.fs), assembly metadata (AssemblyInfo.fs), and the initial Name type definition (Name.fs). Additionally, the project's dependency references (paket.references) for FSharp.Core, Microsoft.SourceLink.GitHub, and Microsoft.NETFramework.ReferenceAssemblies have been deleted, indicating a cleanup or restructuring of this specific module's codebase.

src/Morphir.IR · high confidence

The local testing helper module in src/Morphir.SDK.Testing/Testing.fs has been removed, along with its dependency reference to Expecto. This eliminates the custom thin wrapper that previously exposed Expecto functions (such as describe, test, and equal) directly from the SDK testing namespace, meaning consumers must now reference the underlying Expecto library directly for these testing utilities.

src/Morphir.SDK.Testing · high confidence

New internal helper methods have been added to simplify common operations within the Morphir core library. Collection utilities now include methods to join items into strings with custom separators and delimiters, as well as deconstruction support for immutable lists to easily access the head and tail elements. String handling has been enhanced with a capitalization helper and a parser that splits text into Morphir-compatible words using regex matching.

src/Morphir.Core/Internals · high confidence

The repository now automatically runs validation and formatting checks before every commit. A new Husky pre-commit hook executes \dotnet husky run\, which triggers two tasks defined in \task-runner.json\: a changelog validation script (\scripts/validate-changelog.fsx\) and a pre-commit formatting target via the build script (\build.sh\ or \build.cmd\). This ensures that code changes meet quality standards and that the changelog is properly formatted before being committed.

.husky · high confidence

The Morphir.Tool package now includes a dedicated entry point (Program.cs) that serves as the executable interface for the dotnet tool. This new file delegates all command-line processing directly to the main Morphir.Program.Main method, effectively separating the tool's execution layer from the core application logic while maintaining the existing command behavior.

src/Morphir.Tool · high confidence

The project's build orchestration has been replaced with Nuke, providing a strongly-typed, cross-platform C\# build system. This change introduces new targets for CI simulation (linting, testing), comprehensive package validation for NuGet libraries and CLI tools, and automated publishing to NuGet.org and local feeds. It also adds support for building and packaging a Proto WASM plugin and running end-to-end tests against various executable types.

build · high confidence

The documentation source files in docsSrc have been cleaned up by removing several Markdown content files (Background, How Tos, Getting Started) and associated frontend assets (JavaScript for hot-reloading, theme toggling, and dropdowns, plus CSS styles and a dark-mode Bootstrap theme). This change eliminates the previous documentation structure and its client-side interactivity features.

docsSrc, docsTool · high confidence

Added AOT and Trimming E2E Test Suites; Added Cucumber step definitions for Document and Classic IR JSON serialization tests; Added build validation tests for Morphir NuGet packages; Added component tests for the Morphir Live Index page; Added end-to-end tests for Morphir CLI executable behavior; Added placeholder for Morphir test data directory; Added scratch script to test F\# operator associativity; Added test coverage for Morphir IR Pipeline Plugins; Added tests for IR serialization, Name/Path handling, and Document codecs; Added tests for Morphir CLI configuration, artifact management, and IR verification; Added tests for configuration merging and code generation generators; Added tests for the Morphir IR Classic model in F\#; Added unit and property-based tests for Morphir SDK core modules; Added unit tests for Morphir IR JSON codecs; Added unit tests for StringExtensions; Added unit tests for the Morphir IR Pipeline infrastructure; New E2E test infrastructure for executable discovery and log filtering; Removal of legacy F\# test suites and references.

This change introduces the foundational project structure and dependency management for the Morphir .NET codebase, targeting .NET 10. It establishes central package version management via Directory.Packages.props, defining versions for key libraries including LanguageExt (5.0.0-beta-77), Serilog (4.3.1), MudBlazor (8.15.0), and various JSON and testing frameworks. The diff adds .NET project files (csproj/fsproj) for core modules (Morphir.Core, Morphir.Models, Morphir.SDK), tooling (Morphir.Tool, Morphir.Tooling), the live Blazor demo (Morphir.Live), and the Nuke-based build system. It also configures test projects using TUnit, Reqnroll, and Expecto, and sets up documentation dependencies (Hugo/Docsy) and a Rust WASM plugin.

(dependencies) · high confidence

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

• CAI 54 → 54 (+0.0)
• Rubric changed (rubric-2026.09.15 → rubric-2026.10.1) — scores are not directly comparable.

• Code Health 70 → 70 (+0.0)
• Architecture 96 → 96 (+0.0)
• Maturity 78 → 78 (+0.0)
• Readiness 48 → 48 (+0.0)
• Security 74 → 74 (+0.0)
• Accessibility 56 → 56 (+0.0)
• Performance 54 → 54 (+0.0)

• Documentation: no installation or build instructions (README.md)
• Documentation: no usage examples (README.md)
• Documentation: written for insiders (docs/design/fsharp-frontend-document-tree.md)
• Helper methods within ConfigResolverTests use inconsistent naming patterns for their purpose. IsSome is a verb phrase describing a boolean check (likely on an F# option), while CreateResolver is a verb phrase describing object construction. While both are verbs, IsSome is a generic functional pattern name that doesn't describe what is being checked (e.g., IsConfigResolved or HasValue), whereas CreateResolver is descriptive. More critically, IsSome is a helper for testing F# options, but its name is too generic and doesn't reflect the specific context of the config resolution being tested, unlike CreateResolver which is clear.
• Hotspot: src/Morphir.IR.Pipeline.Plugins/Optimizer.fs (src/Morphir.IR.Pipeline.Plugins/Optimizer.fs)
• Hotspot: src/Morphir.IR.Pipeline.Plugins/PrettyPrinter.fs (src/Morphir.IR.Pipeline.Plugins/PrettyPrinter.fs)
• Hotspot: src/Morphir.IR.Pipeline.Plugins/TypeValidator.fs (src/Morphir.IR.Pipeline.Plugins/TypeValidator.fs)
• Off-boarding risk: anonymized user #1
• The concept of retrieving the current Runtime Identifier (RID) is named inconsistently. RuntimeIdentifier.GetArchComponent uses 'ArchComponent' (likely Architecture Component) while RuntimeIdentifier.GetCurrentRid and the test helper NativeAOTCompilationSteps.GetCurrentRid use 'GetCurrentRid'. 'Rid' is the standard .NET term, making 'ArchComponent' ambiguous and inconsistent with the rest of the codebase.
• redundant comment (src/Morphir.Core/Classic/IR/Codecs/ClassicTypeJsonConverterFactory.cs)
• redundant comment (src/Morphir.Core/Classic/IR/Codecs/ClassicTypeJsonConverterFactory.cs)
• redundant comment (tests/Morphir.Tooling.Tests/Integration/CLI/CliTestHelper.cs)

• Off-boarding risk: anonymized user #1
• Repeated repair: src/Morphir.Tooling/Program.cs (src/Morphir.Tooling/Program.cs)
• The method GetArchComponent appears to be a helper or internal accessor for the architecture component of a Runtime Identifier, while GetCurrentRid returns the full Runtime Identifier string. While they serve different roles (one returns a component, the other the full ID), the naming convention for the 'current' context is inconsistent. GetCurrentRid implies a getter for the current state, whereas GetArchComponent is a generic getter. If GetArchComponent is intended to get the architecture part of the current RID, it should likely follow the GetCurrent... pattern or be named GetArch to match the brevity of GetCurrentRid. However, given GetCurrentRid is the primary accessor, GetArchComponent is likely a distinct helper. A more significant inconsistency is found in the test helpers vs production code naming for 'RID'.
• The method GetCurrentRid is implemented in both the production infrastructure class Morphir.Tooling.Infrastructure.RuntimeIdentifier and the test step class Morphir.E2E.Tests.Features.AOT.NativeAOTCompilationSteps. While the test method is likely a helper to get the current RID for assertions, having the same name in a test class as a production method can be confusing if the test helper is not clearly marked as such (e.g., GetExpectedRid or GetActualRid). However, since one is a test helper and the other is production code, this is a minor style issue rather than a semantic inconsistency. A stronger inconsistency is the duplication of logic/naming where the test helper duplicates the production method's name exactly, potentially implying they are the same thing, whereas the test helper might be wrapping or asserting against it.

• Containers 0 added · 1 removed · contexts 0 added · 2 removed · edges 0 added · 0 removed

• cli:Morphir.Tooling

• Morphir.Configuration
• build

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

finos/morphir-dotnet 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.