Skip to content
CAI
Software that uses CAICheck a score

straw-hat-team/beam-monorepo

55.1

Weak · 8 November 2026

21.5k

lines of production code

Elixir

primary language

7

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

Add BEAM mascot assets and documentation

The repository now includes a dedicated \mascots\ directory containing the 'Joe' mascot, including its Adobe Illustrator source file, a preview image, and associated README files. This addition provides users with official branding assets and instructions for contributing variations under the Creative Commons Attribution 4.0 License.

mascots · high confidence

Add structured error metadata with visibility controls

Introduces \Trogon.Error.Metadata\ and \Trogon.Error.MetadataValue\ modules to manage error context with granular visibility levels (\:INTERNAL\, \:PRIVATE\, \:PUBLIC\). This allows error metadata to be structured and filtered based on who can see the information, supporting both simple string values and explicit visibility tuples, as well as integration with proto field specs for value policies.

_apps/trogon\error/lib/trogon/error · high confidence

Initial release of Trogon.Ecto package

The new Trogon.Ecto library is now available, providing extensions for Ecto including value objects, custom types, and migration helpers. This release establishes the foundational package structure with MIT licensing and standard Elixir project configuration.

_apps/trogon\ecto · high confidence

Initial release of Trogon.Proto for schema-driven Elixir code generation

The new \trogon\proto\ application provides an Elixir runtime and integration layer for the \trogon-proto\ Buf Schema Registry, shipping pre-compiled protobuf modules and compile-time macros for schema-driven code generation. It introduces \Trogon.Proto.Env\ to read proto field annotations and generate typed, secret-safe environment variable loaders with automatic type conversion, and \Trogon.Proto.Uuid.V1.UuidTemplate\ to generate deterministic UUIDv5 identity functions from versioned templates. The package also includes shared proto message contracts for Relay cursor pagination, CQRS read-your-writes consistency, structured error templates, typed UUIDs, stream identity, and object ID prefixes, configured via \buf.gen.yaml\ to generate Elixir code into \lib/\\generated\\_\.

_apps/trogon\proto · high confidence

Introduce EventStore inspector page

Adds a new EventStore inspector page to the Phoenix LiveDashboard, providing a unified interface to browse and inspect EventStore streams, events, snapshots, and subscriptions. The page includes tabbed navigation for each entity type, with tables supporting sorting, pagination, and search. Users can click into detailed modals for individual events, streams, snapshots, and subscriptions, viewing metadata, data payloads, and subscription lag trends. The implementation includes specific components for rendering data fields (handling deserialization errors gracefully), event links, and pagination, along with a Params module to manage URL state across tabs.

_apps/eventstore\_dashboard, apps/eventstore\dashboard/lib · high confidence

Introduce Trogon Credo checks for architectural and domain conventions

This release adds a collection of custom Credo checks to enforce architectural and domain conventions across projects. Key additions include checks for Commanded aggregates (ensuring state is only constructed via the framework's \apply/2\ or allowed constructors, and that commands remain deterministic by forbidding direct calls to time/randomness sources), error ownership (ensuring errors are built only by their defining context), and design rules (enforcing application dependency graphs, module cardinality, and namespace boundaries). The package also includes an AST pattern helper to simplify check implementation and provides a base module for organizing these checks under the \Trogon.Credo\ namespace.

_apps/trogon\credo/lib · high confidence

Introduce Trogon TypeProvider for type-to-struct mapping

The new Trogon TypeProvider library enables mapping string type names to Elixir struct modules, supporting both explicit registration via \register\_type/2\ and automatic registration of Protobuf messages via \register\_protobuf\_message/1\. It allows importing type mappings between providers and includes a Mix task (\mix trogon.type\_provider.list\) to inspect registered mappings, ensuring that only valid struct modules are registered and providing clear error handling for unregistered types.

_apps/trogon\typeprovider/lib · high confidence

Introduce Trogon.Commanded library with DDD primitives and consistency policies

This change introduces the new \Trogon.Commanded\ library, providing a suite of macros and behaviors to extend the Commanded package for Domain-Driven Design, Event Sourcing, and CQRS. It adds \Aggregate\, \Command\, \Event\, and \Entity\ modules that simplify defining domain structures with automatic identifier and identity prefix handling. A new \CommandRouter\ includes a \register\_transaction\_script\ macro to streamline command-to-handler wiring with a default stateless lifespan. The library also introduces \ConsistencyPolicy\ with \MinVersionPolicy\ and \ExactVersionPolicy\ to manage read-after-write guarantees in eventually consistent systems, alongside \Enum\ support for proto-driven enums and serializers for JSONB and Protobuf event storage.

_apps/trogon\commanded/lib · high confidence

Introduce Trogon.Configurable for merged configuration management

The new Trogon.Configurable library allows Elixir modules to consolidate configuration from three sources with a clear precedence: static defaults defined at compile time, environment-specific values from the OTP application, and runtime overrides passed at the call site. By using the \use Trogon.Configurable\ macro, modules gain a \get\_config/1\ function that merges these sources, ensuring that runtime parameters take final precedence over environment settings, which in turn override static defaults. This standardizes configuration handling for libraries and application modules, reducing duplicated merge logic and preventing silent value loss across different configuration layers.

_apps/trogon\configurable · high confidence

Introduce Trogon.Credo as a shared library for versioned Credo checks

The new trogon\_credo package allows teams to distribute custom Credo checks as a versioned Hex dependency rather than copying them between repositories. It provides a set of check modules and Credo plugins (such as for Ecto, Oban, and Commanded) that enforce architectural and library-specific conventions. Users can enable specific checks or plugins in their .credo.exs configuration, ensuring a single source of truth for linting rules across multiple projects.

_apps/trogon\credo · high confidence

Introduce Trogon.Dispatcher as a compile-time command and query dispatcher

The new \trogon\_dispatcher\ application provides a compile-time, in-process, stateless, and synchronous dispatcher for Elixir. It allows host applications to register command and query structs with \register\_message\ and compose middleware pipelines using \middleware\ and \import\_dispatcher\. The dispatcher resolves routing at compile time, ensuring that duplicate registrations, missing handlers, or dispatcher cycles fail the build rather than causing runtime errors. It supports Rack-style wrapping middleware, emits \:telemetry\ spans for every dispatch, and includes optional OpenTelemetry integration for distributed tracing. The library is designed to own cross-cutting concerns like routing, middleware composition, and observability without imposing architectural opinions on the domain.

_apps/trogon\dispatcher · high confidence

Introduce Trogon.Ecto package with custom Ecto types and validation helpers

This release adds the \trogon\_ecto\ library, providing a suite of new Ecto parameterized types including \DurationType\ (persisting as ISO 8601 strings, maps, or native PostgreSQL intervals), \BoundedString\ (enforcing character limits with optional truncation), \Enum\ (generating typed enum structs), and Kubernetes-style map types (\StringMap\, \LabelMap\, \AnnotationMap\) for validating key-value pairs. It also introduces \Trogon.Ecto.Changeset\ helpers for validating unset fields and flattening nested changeset errors into \FieldViolation\ structs for API reporting, along with \Trogon.Ecto.Migration\ helpers for standardizing column definitions and \Trogon.Ecto.Repo\ for simplified transaction result handling.

_apps/trogon\ecto/lib · high confidence

Introduce Trogon.Test shared ExUnit toolkit with global state mocks and AI formatter

The new \trogon\_test\ app provides a shared ExUnit toolkit that enables async-safe tests by mocking global state (application environment, clock, timers, tasks, and random number generation) via Mox, allowing tests to control these dependencies without leaking state or requiring serialization. It includes a \Trogon.Test.AIFormatter\ that outputs a compact, non-truncated plain-text report of test failures (including diffs for maps/lists and stacktraces) designed for AI agents to parse, alongside standard test helpers and behaviors for the mocked modules.

_apps/trogon\test · high confidence

Introduce Trogon.TypeProvider for compile-time string-to-struct mapping

The new Trogon.TypeProvider package enables zero-runtime-overhead mapping between string identifiers and Elixir struct modules by generating efficient pattern-matching functions at compile time. It supports registering individual types, applying prefixes, and importing type definitions from other providers, which simplifies serialization and deserialization in event-driven architectures. The package also includes support for registering Protobuf messages, allowing seamless integration with Protocol Buffers alongside standard Elixir structs.

_apps/trogon\typeprovider · high confidence

Introduce structured error handling with Trogon.Error

Added the \Trogon.Error\ module, implementing a standardized error type system for Elixir applications. This change introduces a consistent way to define errors using domain and reason identifiers, Google RPC-compatible status codes, and visibility levels (internal, private, public). It supports static error messages defined at compile time and dynamic instance-specific metadata, ensuring predictable error contracts for API consumers and consistent logging.

_apps/trogon\error/lib/trogon · high confidence

Introduce type-safe ObjectId and UnionObjectId types with Ecto and Protocol support

This change introduces the \Trogon.ObjectId\ macro for defining type-safe, domain-specific identifiers that combine a human-readable prefix with a value, and \Trogon.UnionObjectId\ for discriminated unions of multiple ObjectId types. These types implement \Ecto.Type\ for direct use in schemas (including support for autogenerated primary keys via \autogenerate\), \Phoenix.Param\, \Phoenix.HTML.Safe\, and JSON encoders (\Jason.Encoder\ and \JSON.Encoder\) for serialization, and provide validation options (UUID, integer, or custom functions). The \UnionObjectId\ specifically allows combining distinct ObjectId types into a single field while preserving type safety and handling storage format prefixes for correct parsing.

_apps/trogon\_object\id/lib · high confidence

Introduction of the Trogon.Error structured error library

The \apps/trogon\_error\ directory has been added to the project, introducing a new structured error library for Elixir. This library allows applications to define errors as typed values with domain-scoped identity, metadata, and visibility controls, supporting Google RPC-compatible status codes and localization. The addition includes the core application structure, configuration files (\.formatter.exs\, \.gitignore\), licensing, and documentation (README, CHANGELOG), establishing the foundation for consistent, machine-parseable error handling across the system.

_apps/trogon\error · high confidence

New proto-based macros for environment loading, error templates, and deterministic UUIDs

This change introduces three new compile-time macros in the \trogon\_proto\ library that generate Elixir code from Protocol Buffer definitions. The \Trogon.Proto.Env\ macro generates typed structs and \from\_env/0\ functions to load and validate environment variables, supporting steps like splitting, trimming, and decoding, while automatically masking secret fields in logs. The \Trogon.Proto.Error\ module provides infrastructure to extract error template metadata (domain, reason, code, visibility) from proto message extensions, enabling consistent error reporting. Additionally, the \Trogon.Proto.Uuid.V1.UuidTemplate\ macro generates deterministic UUIDv5 functions based on proto-defined templates, allowing for fast, pre-computed identity generation from structured data.

_apps/trogon\proto/lib/trogon/proto · high confidence

Release of Trogon.ObjectId 0.3.0 with Phoenix and JSON protocol support

The Trogon.ObjectId package has been updated to version 0.3.0, introducing support for Phoenix.Param, Phoenix.HTML.Safe, and JSON.Encoder protocols. This allows ObjectId structs to be seamlessly converted to strings in Phoenix views and encoded/decoded in JSON payloads, in addition to the existing Ecto type callbacks and string conversion capabilities. The package provides type-safe, prefixed object IDs (e.g., "user\_abc-123") as distinct structs to prevent runtime confusion between different ID types.

_apps/trogon\_object\id · high confidence

Removals

Removal of legacy DDD macro helpers (Aggregate, Command, Entity, Event, ValueObject)

The library has removed the \OnePiece.Commanded.Aggregate\, \Command\, \Entity\, \Event\, and \ValueObject\ modules, which previously provided \use\ macros to define Domain-Driven Design structures by wrapping Ecto schemas. This change eliminates the convenience macros that automatically set up primary keys, derived encoders, and helper functions like \new/1\ for commands and events. Users relying on these specific macros for defining aggregates, commands, entities, events, or value objects will need to migrate to the library's current approach, likely involving direct Ecto schema usage or alternative provided behaviors.

_apps/one\_piece\commanded/lib · high confidence

Removal of legacy documentation and tooling files

The \CHANGELOG.md\, \README.md\, \.tool-versions\, and \priv/plts/.gitkeep\ files have been deleted from the \apps/one\_piece\_commanded\ application. This cleanup removes historical version records, user-facing documentation, and local tooling configuration files that are no longer part of the active codebase structure.

_apps/one\_piece\commanded · high confidence

Removal of one\_piece\_result application

The one\_piece\_result application has been removed from the codebase. This change deletes the application's configuration file (.tool-versions), its documentation (README.md), and its placeholder file (priv/plts/.gitkeep), effectively eliminating the component that previously handled t:OnePiece.Result.t/0 responses.

_apps/one\_piece\result · high confidence

Behavioural changes

1 commit (0 fixes) modifying .config

A change to existing behaviour in .config — 1 commit, 2 files: “ci: audit Hex package owners (\#546)” (refs \#546).

.config · medium confidence · unverified

App renamed to Trogon.Commanded with new formatter and documentation

The application has been renamed from \one\_piece\_commanded\ to \Trogon.Commanded\, reflected in the directory structure, \.gitignore\, and \LICENSE\ files. A new \.formatter.exs\ file has been added to configure Elixir code formatting, including specific macro registrations like \register\_type\ and \polymorphic\_embeds\_one\. Additionally, a \CHANGELOG.md\ and \README.md\ have been introduced to document the library's history and its role as an opinionated extension layer for the Commanded framework, supporting Domain-Driven Design and Event Sourcing in Elixir.

_apps/trogon\commanded · high confidence

Environment loading now reports all missing or invalid variables in a single error

The Trogon Proto environment loader has been updated to aggregate all configuration failures into a single error report. Previously, users might have encountered errors one variable at a time; now, when environment variables are missing or invalid, the system raises a \LoadError\ that lists every problematic variable and its specific reason (missing or invalid) at once. This allows users to identify and fix all configuration issues in a single pass rather than iteratively.

_apps/trogon\proto/lib/trogon/proto/env · high confidence

Regenerated protobuf modules for v1alpha1 domain contracts

The generated Elixir protobuf modules in apps/trogon\proto/lib/\\generated\\_ have been regenerated to reflect the v1alpha1 API definitions. This update introduces new message and enum types across several domain areas, including Actor identification, Consistency guarantees (MinVersion/ExactVersion), generic Content blobs, and Environment variable handling (including Base64 decoding, splitting, trimming, and visibility controls). It also adds shared error contracts with canonical gRPC error codes and visibility options, Hierarchy NodeId definitions, NATS Micro service options, Cursor-based Pagination and PageInfo structures for Relay-style queries, and UUID generation namespaces and options. These generated modules provide the underlying data structures and descriptors for the platform's domain APIs.

_apps/trogon\proto/lib/\\generated\\_ · high confidence_

Renamed from OnePiece.Result to Trogon.Result with enhanced type specifications

The result handling library has been renamed from OnePiece.Result to Trogon.Result, requiring users to update module aliases and function calls (e.g., from OnePiece.Result.ok/1 to Trogon.Result.ok/1). Additionally, the Result module now uses enhanced, specific type specifications for its ok and err types, improving type safety and documentation clarity for composed result pipelines.

_apps/trogon\result · high confidence

Test environment configuration for Trogon modules

The main configuration file now applies specific settings when running in the test environment. It configures Trogon.Proto.Env to use a mock system adapter, sets the application context for Trogon.Configurable to a test mock, and defines seeded values for Trogon.Test to ensure isolated test execution.

config · high confidence

Test coverage

2 commits adding/updating tests in apps/eventstore\_dashboard/test; Added test coverage for Trogon.Commanded core components; Added test coverage for the Trogon TypeProvider; Added test fixtures for Trogon Proto validation and environment loading; Added test fixtures for proto-driven identity and stream prefixes; Added test suite and support infrastructure for Trogon.Ecto; Added test suite for Trogon Credo linting rules; Added test suite for Trogon Error handling and metadata; Added test suite for Trogon.ObjectId and UnionObjectId; Added test support files for Protobuf message definitions; Added test support fixtures for Trogon.Proto.Env; Added test support for mocking system environment variables; Added test support modules for CommandRouter example; Added test support modules for Commanded integration testing; Added tests for CommandHandlerCase test support; Added tests for UUID template generation and validation; Added tests for environment variable loading and error template extraction; Removed test support module CommandHandlerCase.

Dependencies

Umbrella restructure and dependency updates

The project has been rebranded from OnePiece to BeamMonorepo, renaming the umbrella root and several internal packages (e.g., one\_piece\_commanded to trogon\_typeprovider, one\_piece\_result to trogon\_result). This change also introduces new packages (eventstore\_dashboard, trogon\_credo, trogon\_ecto, trogon\_error, trogon\_object\_id, trogon\_proto) and updates core dependencies, including Ecto to \~\> 3.12/3.14, Commanded to \~\> 1.2/1.4, Phoenix to \~\> 1.7, and various dev tools like ex\_doc, credo, and dialyxir to their latest versions.

(dependencies) · high confidence

Housekeeping

Initial project scaffolding and documentation

The repository has been initialized with standard BEAM/Elixir configuration files, including \.credo.exs\ for code linting, \.dialyzer\_ignore.exs\ for type checking exclusions, \.formatter.exs\ with a 120-character line length, and \.tool-versions\ specifying Elixir 1.20 and Erlang 28.3. A MIT \LICENSE\ file has been added, and the \README.md\ has been updated to describe the project as a monorepo for event-sourced libraries (such as \trogon\_error\, \trogon\_commanded\, and \trogon\_object\_id\) rather than a placeholder.

(repo-wide) · 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

This is the PUBLIC form of this artifact. Findings are listed in full, but the details of SECURITY findings — which rule fired, in which file, on which line, and how to fix it — are deliberately withheld, and any secret-scanner results are excluded entirely. Where detail is absent here it was REMOVED FOR PUBLICATION; it is not missing from the analysis. The complete artifact is available from the repository owner.

Score

  • CAI 56 → 55 (-1.1)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.2) — scores are not directly comparable.

Lenses

  • Code Health 98 → 98 (+0.0)
  • Architecture 98 → 98 (+0.2)
  • Maturity 40 → 39 (-0.9)
  • Readiness 47 → 49 (+2.0)
  • Security 85 → 76 (-8.9)
  • Domain Modelling 100 → 100 (+0.0)

Resolved (5)

  • Duplicated block (10–18 lines × 2) (apps/eventstore_dashboard/lib/event_store_dashboard/components/streams_table.ex)
  • Off-boarding risk: anonymized user #1
  • Off-boarding risk: anonymized user #2
  • Workflow token permissions not restricted (.github/workflows/cd.yml)
  • Workflow token permissions not restricted (.github/workflows/docs.yml)

New (6)

  • Documentation: no build, run or usage example (README.md)
  • Duplicated block (10–14 lines × 2) (apps/eventstore_dashboard/lib/event_store_dashboard/components/streams_table.ex)
  • Further sole-owners (lower concentration)
  • Low: security finding (details withheld)
  • Medium: security finding (details withheld)
  • Off-boarding risk: anonymized user #1

Changes since last survey

  • 18 commits — 16 feature/other, 2 fixes

By area

  • .github/workflows — 7 commits
  • apps/eventstore_dashboard — 3 commits
  • (root) — 1 commit
  • .config/mise — 1 commit
  • apps/trogon_commanded — 1 commit
  • apps/trogon_credo — 1 commit
  • apps/trogon_dispatcher — 1 commit
  • apps/trogon_error — 1 commit
  • apps/trogon_proto — 1 commit
  • apps/trogon_result — 1 commit

Notable commits

  • fix: fix(deps): bump plug_crypto to 2.2.1 (#547)
  • fix: fix(eventstore_dashboard): estimate unfiltered table totals via pg_class.reltuples, with a ~ hint (#458)
  • change: chore(deps): bump actions/create-github-app-token from 3.2.0 to 3.3.0 (#541)
  • change: chore(deps): bump jdx/mise-action from 5.2.1 to 5.2.2 (#552)
  • change: chore(master): release eventstore_dashboard 0.2.4 (#561)
  • change: chore(master): release trogon_credo 0.11.0 (#539)
  • change: chore(trogon_commanded): bold only the lead sentence of each README intro paragraph (#556)
  • change: chore(trogon_error): bold only the lead sentence of each README intro paragraph (#557)
  • change: chore(trogon_proto): bold only the lead sentence of each README intro paragraph (#558)
  • change: chore(trogon_result): bold only the lead sentence of each README intro paragraph (#559)
  • change: chore: drop the maintainers field Hex no longer reads (#549)
  • change: ci(cd): publish to Hex with workload identity (#543)
  • change: ci(docs): list every package in the docs publish workflow (#545)
  • change: ci(release): read the releaser key from Secret Manager instead of a GitHub secret (#542)
  • change: ci: audit Hex package owners (#546)
  • change: ci: move the shared Elixir workflows to v2.0.0 (#560)
  • change: ci: pin the Hex publish actions to v1.10.0 (#544)
  • change: test(trogon_dispatcher): match the dispatch span by name in the context propagation test (#548)

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

Survey your own repository

straw-hat-team/beam-monorepo 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 8 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 bd37f0f73daed1cc7a6d8d123025ec3a0d7bc98a — 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-45ab2cab63de.