rampart-core 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 682f667118536ae6d0cf6abad03bb538ff90be199a23e84c7e974e77fb3b6e64
+  data.tar.gz: 8abec9aef51617a79947b093e324d3abc5ea69d77cd3ca8980cafc11be26baea
+SHA512:
+  metadata.gz: 712c02a299f9c124a6777419fb6ff78cced66b27a968124612829f4481a88a74b1e5bc48b03e66df25d6b70932510512f63e49f69a2f12453f2d3cdcf1162492
+  data.tar.gz: c5dd7eeec8abd6eec76ab832e97bf8967b96a27cfd3a071bd546cd99a926c3061df0cf9c646e9982758217c5e7a900693bd5c020bb9b194e8178b355098769ca

data/LICENSE

@@ -0,0 +1,191 @@
+Apache License
+Version 2.0, January 2004
+http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+Copyright 2025 Rampart Team
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+

data/README.md

@@ -0,0 +1,296 @@
+# Rampart: Architecture on Rails
+
+An Architecture-as-Code toolkit designed to bring disciplined, maintainable architecture to Rails applications—without abandoning the productivity of the monolith.
+
+---
+
+## Overview
+
+### What problem does Rampart solve?
+
+Organizations choose Rails because it's fast. A small team can ship features at remarkable speed, and the monolith keeps things simple.
+
+Then the organization grows. A handful of developers become a hundred. Many teams work across many parts of the codebase. The original architects leave—and even those who stay can no longer keep the whole picture in their heads. Without explicit boundaries, entropy takes hold. The codebase becomes a big ball of mud: tangled dependencies, unclear ownership, and changes that ripple unpredictably across the system.
+
+The company adopts AI-assisted development hoping to accelerate delivery, only to discover it makes everything worse. AI tools generate code quickly but don't understand architectural intent. They hallucinate dependencies, flatten carefully designed layers, and ignore boundaries—introducing structural inconsistencies faster than teams can catch them.
+
+Rampart addresses both the scaling challenge and the AI challenge by providing:
+
+- **Declarative architecture blueprints** that serve as the single source of truth for system structure
+- **Nine curated architectural patterns**—centered on Domain-Driven Design and Hexagonal Architecture—that maximize both team autonomy and code clarity
+- **AI-native design** with machine-readable formats that enable AI agents to understand and respect architectural boundaries
+- **A Terraform-like workflow** for designing, scaffolding, validating, and evolving architecture over time
+
+### What are the core goals of Rampart?
+
+**Goal 1 — Bounded Context & Stream-Aligned Team Effectiveness**
+
+Teams should be able to deliver end-to-end features *within a single bounded context* with minimal coordination across contexts.
+
+**Goal 2 — Human & AI Code Clarity**
+
+Code should be predictable, structured, and easy for both humans and AIs to understand, navigate, and maintain.
+
+### Does Rampart replace Rails?
+
+No. Rampart is not a Rails rewrite or alternative. It works *with* Rails, not against it.
+
+Rampart provides architectural discipline on top of Rails. It enforces structure for bounded contexts, domain models, and application layers while remaining deliberately agnostic about testing frameworks, linters, ORMs, and other peripheral concerns.
+
+### Is there another tool that already does this?
+
+No. While several tools address pieces of this problem, none provide the full Architecture-as-Code lifecycle that Rampart offers.
+
+Below are important capability gaps that current tools do not fill, along with examples of tools that come closest but still fall short:
+
+| Missing Capability                                                            | Most Similar Tools                                       | Why They Fall Short                                                                                                                                                         |
+| ----------------------------------------------------------------------------- | -------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| **A single authoritative, version-controlled architecture blueprint**         | Structurizr, PlantUML, C4 model tools                    | These generate diagrams or model visualizations, but do not serve as living, enforced architectural specifications or a system of record.                                   |
+| **Planning + structural change workflow (similar to Terraform plan)**         | OpenAPI/AsyncAPI (for API planning), Backstage templates | OpenAPI only covers API layers; Backstage handles service metadata, not domain structure or architectural decisions. No tool plans architectural scaffolding or migrations. |
+| **Sync between architecture and code, including drift detection**             | ArchUnit, dependency-analysis tools, SonarQube           | These can detect certain code smells or dependency violations but cannot compare code to a declarative architecture model or enforce layered/domain boundaries.             |
+| **DDD-native domain modeling (bounded contexts, aggregates, ports/adapters)** | ContextMapper (academic), Structurizr DSL                | These express relationships conceptually but lack Rails integration, scaffolding, JSON blueprints, or synchronization with real codebases.                                  |
+| **Architecture-guided scaffolding without generating business logic**         | Rails generators, JHipster                               | Generators scaffold code quickly but do not encode or enforce architectural boundaries; they cannot evolve designs over time or keep architecture synchronized.             |
+| **Migration planning from legacy codebases into modern architecture**         | vFunction (for Java), monolith decomposition tools       | Focused on technical decomposition or microservices extraction, not DDD-based restructuring, JSON blueprints, or Rails codebases.                                           |
+| **AI-native architecture understanding and enforcement**                      | None                                                     | No current tool provides machine-parseable architecture blueprints designed specifically for LLM agents to use while writing or modifying code.                             |
+
+**The gap**: While certain tools overlap partially with Rampart's goals, none provide a full Architecture-as-Code lifecycle with DDD semantics, scaffolding, drift detection, and AI-native integration.
+
+### Where is Rampart opinionated?
+
+Rampart enforces specific architectural choices where clarity and consistency are essential:
+
+- **The Nine Architecture Patterns**: DDD bounded contexts, Hexagonal Architecture layering, use case modeling, and event-driven patterns represent the canonical way to structure Rampart applications
+- **Monorepo Structure**: All bounded contexts must reside in a single monorepo for centralized architecture governance
+- **Rails Engine Implementation**: Bounded contexts must be implemented as Rails engines for clear module boundaries. (In the future, it will support microservices)
+- **JSON for Architecture Blueprints**: Blueprints use JSON (not YAML) for AI-safety and deterministic parsing
+- **Dry-rb Foundation**: Built on the dry-rb ecosystem for type safety, immutability, and functional patterns
+- **Packwerk Static Analysis**: Enforces layer boundaries (domain/application/infrastructure) and cross-context dependencies
+- **Rspec Fitness Function Enforcement**: RSpec shared specs verify runtime dependency boundaries, base class contracts, immutability, and JSON blueprint synchronization
+
+### Where is Rampart unopinionated?
+
+Teams bring their own preferences for:
+
+- Code formatters and linters (StandardRB, RuboCop, etc.)
+- ORMs and databases (ActiveRecord, ROM, Sequel)
+- Web frameworks (Rails, Hanami, Sinatra)
+- Background job processors (Sidekiq, GoodJob, etc.)
+
+---
+
+## Architecture & Design
+
+### What architecture patterns does Rampart use?
+
+Rampart provides nine enforceable, AI-friendly architecture patterns:
+
+1. **Domain-Driven Design** — Align software models with business domains using bounded contexts and tactical patterns
+2. **Hexagonal Architecture** — Isolate domain logic from infrastructure through ports and adapters
+3. **Clean Architecture / Onion** — Enforce strict dependency direction with framework-independent core
+4. **Modular Monolith / Vertical Slices** — Organize code into autonomous vertical slices within a single deployable
+5. **Lightweight CQRS & Task-Based Interfaces** — Separate read/write models with intent-revealing commands
+6. **Domain Events & Event-Driven Modeling** — Decouple bounded contexts through immutable business facts
+7. **Architecture Fitness Functions** — Validate architectural rules programmatically in CI/CD
+8. **Functional Core / Imperative Shell** — Keep domain logic pure and side-effect-free
+9. **C4 Model (Inside-the-Box)** — Visualize system structure at multiple levels of abstraction
+
+For detailed explanations, anti-patterns, and implementation guidance, see [Architecture Philosophy](docs/rampart_architecture_philosophy.md).
+
+### How does Rampart work with AI tools?
+
+Rampart takes a two-pronged approach to AI-assisted development:
+
+**1. Prompt-Driven Guidance** — Rampart ships **prompt files** that encode architectural knowledge:
+- `architecture.prompt.md` — Guides the design of `architecture.json` through collaborative dialogue
+- `planning.prompt.md` — Guides spec completion for capabilities, gathering functional and technical requirements
+
+Running `rampart init` installs these as slash commands (`/rampart.architect` and `/rampart.plan`) for both Cursor and Claude Code.
+
+**2. Validation & Enforcement** — Rampart validates that code adheres to architecture:
+- **Post-hoc verification** — After code changes, Packwerk and RSpec architecture specs confirm the architecture remains intact
+- **Drift detection** — `rampart sync` identifies divergence between code and `architecture.json`
+- **Blame-free feedback** — When violations are detected, Rampart provides actionable guidance for correction
+
+This dual approach means AI agents are guided proactively through prompts, then verified through enforcement tools.
+
+### How is Rampart like Terraform?
+
+Rampart can be viewed as a "Terraform for application architecture":
+
+| Terraform Concept    | Rampart Equivalent                                        |
+| -------------------- | --------------------------------------------------------- |
+| Resource definitions | Use cases, events, domain objects, adapters               |
+| Dependency graph     | Event flows, inter-BC relationships, C4 components        |
+| Validate             | Fitness functions (Packwerk + RSpec)                      |
+| Plan                 | Spec generation (`rampart spec`) + prompt-guided planning |
+| Apply                | Prompt-guided spec completion + implementation            |
+| State file           | Rampart architecture JSON blueprints                      |
+| Import               | Legacy extraction (`rampart extract`)                     |
+
+For the complete Terraform analogy, see [Architecture Philosophy](docs/rampart_architecture_philosophy.md#311-the-terraform-analogy).
+
+---
+
+## Getting Started
+
+### How do I install the Rampart gem?
+
+```ruby
+gem 'rampart', path: '../rampart'  # For local development
+```
+
+Or from a gem server (when published):
+
+```ruby
+gem 'rampart'
+```
+
+### What functionality does the gem provide?
+
+The Rampart gem provides base classes for implementing DDD and Hexagonal Architecture patterns:
+
+- **Domain layer primitives** — Aggregates, entities, value objects, domain events, and domain services with built-in immutability and type safety
+- **Application layer patterns** — Commands, queries, and application services for use case orchestration
+- **Port abstractions** — Base classes for defining and implementing hexagonal ports and adapters
+- **Type system** — Built on dry-types for runtime validation with monadic error handling via dry-monads
+
+### How do I use the Rampart CLI?
+
+Install the CLI (requires [Bun](https://bun.sh)):
+
+```bash
+cd rampart/cli && bun install
+```
+
+Then run with:
+
+```bash
+bun run rampart --help
+```
+
+### What features does the Rampart CLI provide?
+
+The Rampart CLI manages the full architecture lifecycle:
+
+- **Initialize & scaffold** — Bootstrap projects with `rampart init`, create bounded contexts, and generate DDD directory structures
+- **Generate specs** — `rampart spec` reads `architecture.json` and generates spec templates for each capability
+- **Validate & sync** — Detect drift between code and architecture definitions with `rampart sync`
+- **Migrate legacy** — Extract domain models and create phased migration plans for existing codebases
+
+For complete CLI documentation, see [Features](docs/rampart_features.md#cli-tools-).
+
+
+### What does a typical Rampart project look like?
+
+```
+project-root/
+├── architecture/
+│   ├── system.json           # System-level manifest
+│   ├── catalog/              # Per-bounded-context directory
+│   │   ├── architecture.json
+│   │   ├── browse_catalog.spec.md
+│   │   └── manage_catalog.spec.md
+│   └── payments/
+│       ├── architecture.json
+│       └── ...
+├── prompts/
+│   ├── architecture.prompt.md   # Guides architecture.json design
+│   └── planning.prompt.md       # Guides spec completion
+├── docs/
+│   ├── diagrams/             # Architecture diagrams
+│   │   ├── catalog_architecture.md
+│   │   └── images/
+├── engines/
+│   ├── catalog/              # Bounded context as Rails engine
+│   └── payments/
+└── apps/
+    └── web/                  # Rails app
+```
+
+Each engine follows the DDD/Hexagonal structure while respecting Rails conventions:
+
+```
+engines/catalog/                 # "Catalog" bounded context
+├── app/
+│   ├── controllers/catalog      # Controller infrastructure
+│   ├── models/catalog           # ActiveRecord infrastructure
+│   │
+│   ├── domain/catalog/          # Domain layer
+│   │   ├── aggregates/
+│   │   ├── entities/
+│   │   ├── value_objects/
+│   │   ├── events/
+│   │   ├── services/
+│   │   └── ports/
+│   │
+│   ├── application/catalog/     # Application layer
+│   │   ├── services/
+│   │   ├── commands/
+│   │   └── queries/
+│   │
+│   └── infrastructure/catalog/  # Infrastructure layer (except Rails infrastructure as noted above)
+│       ├── persistence/
+│       │   ├── mappers/
+│       │   └── repositories/
+│       ├── http/
+│       │   └── serializers/
+│       ├── adapters/
+│       └── wiring/
+```
+
+For complete project structure details, see [System Overview](docs/rampart_system.md).
+
+### Can I see some example code snippets?
+
+```ruby
+# Domain Layer - Pure Ruby
+class Order < Rampart::Domain::AggregateRoot
+  attribute :id, Types::String
+  attribute :items, Types::Array.default([].freeze)
+  
+  def add_item(product, quantity)
+    updated_items = items + [LineItem.new(product: product, quantity: quantity)]
+    self.class.new(**attributes.merge(items: updated_items))
+  end
+end
+
+# Application Layer - Use Cases
+class CreateOrderService < Rampart::Application::Service
+  include Dry::Monads[:result]
+  
+  def call(command)
+    order = Order.create(id: generate_id, customer_id: command.customer_id)
+    persisted = @order_repo.save(order)
+    Success(persisted)
+  end
+end
+
+# Infrastructure Layer - Adapters
+class SqlOrderRepository < Rampart::Ports::SecondaryPort
+  def save(order)
+    OrderMapper.to_record(order).save!
+    order
+  end
+end
+```
+
+---
+
+## Learning More
+
+### Where can I find documentation?
+
+- **[Architecture Philosophy](docs/rampart_architecture_philosophy.md)** - Core principles, patterns, and anti-patterns
+- **[User Guide](docs/rampart_user_guide.md)** - Day-to-day usage and best practices
+- **[Features](docs/rampart_features.md)** - Complete feature list, CLI tools, and implementation details
+- **[System Overview](docs/rampart_system.md)** - System architecture and component relationships
+
+### Is there a demo application?
+
+**[Cats-as-a-Service](https://github.com/pcaplan/cats-as-a-service)** - A complete Rails + Next.js e-commerce application demonstrating Rampart patterns in practice with bounded context engines, clean architecture, and DDD tactical patterns.
+
+---
+
+## License
+
+Apache License 2.0

data/lib/rampart/application/command.rb

@@ -0,0 +1,15 @@
+require "dry-struct"
+
+module Rampart
+  module Application
+    # Base DTO for CQRS command objects.
+    # Commands represent task-based, intent-revealing write operations
+    # (e.g., ShipOrder, ArchiveCustomCat) and should wrap all inputs needed
+    # to perform a single business action. Dry::Struct gives immutability
+    # and coarse type validation so command handlers receive predictable data.
+    class Command < Dry::Struct
+      transform_keys(&:to_sym)
+    end
+  end
+end
+

data/lib/rampart/application/query.rb

@@ -0,0 +1,15 @@
+require "dry-struct"
+
+module Rampart
+  module Application
+    # Base DTO for CQRS queries.
+    # Queries capture read-only concerns such as pagination or filters
+    # and can be tailored for optimized projections without touching
+    # the domain model. Dry::Struct ensures query parameters are coerced
+    # to the expected types before they reach query handlers.
+    class Query < Dry::Struct
+      transform_keys(&:to_sym)
+    end
+  end
+end
+

data/lib/rampart/application/service.rb

@@ -0,0 +1,26 @@
+require "dry-monads"
+
+module Rampart
+  module Application
+    # Base class for application services (use cases).
+    #
+    # Services should include their bounded context's Import module for
+    # automatic dependency injection via dry-auto_inject.
+    #
+    # Example:
+    #   class CatListingService < Rampart::Application::Service
+    #     include CatContent::Import[:cat_listing_repo, :id_generator, :clock, :transaction, :event_bus]
+    #
+    #     def create(command)
+    #       # Dependencies are automatically injected as @cat_listing_repo, etc.
+    #       @transaction.call do
+    #         # ...
+    #       end
+    #     end
+    #   end
+    class Service
+      include Dry::Monads[:result]
+    end
+  end
+end
+

data/lib/rampart/application/transaction.rb

@@ -0,0 +1,15 @@
+module Rampart
+  module Application
+    class Transaction
+      def initialize(adapter)
+        @adapter = adapter
+      end
+
+      def call(&block)
+        @adapter.call(&block)
+      end
+    end
+  end
+end
+
+

data/lib/rampart/domain/aggregate_root.rb

@@ -0,0 +1,13 @@
+module Rampart
+  module Domain
+    class AggregateRoot < Entity
+      # Aggregates are immutable. Domain methods return new instances instead of mutating state.
+      # Application services publish events after persistence rather than accumulating them here.
+      #
+      # Example:
+      #   def publish
+      #     self.class.new(**attributes.merge(visibility: Visibility.public))
+      #   end
+    end
+  end
+end

data/lib/rampart/domain/domain_event.rb

@@ -0,0 +1,24 @@
+require "dry-struct"
+require "securerandom"
+
+module Rampart
+  module Domain
+    # Domain events record meaningful business changes that already happened.
+    # Aggregates remain immutable and side-effect free; application services publish events
+    # after persisting new aggregate state. Events are past-tense, immutable Dry::Structs
+    # with versioning baked in.
+    class DomainEvent < Dry::Struct
+      # Schema version enables event evolution without breaking consumers.
+      # Increment when adding/removing/renaming attributes.
+      SCHEMA_VERSION = 1
+
+      attribute :event_id, Types::String.default { SecureRandom.uuid }
+      attribute :occurred_at, Types::Time.default { Time.now }
+      attribute :schema_version, Types::Integer.default { self::SCHEMA_VERSION }
+
+      def event_type
+        self.class.name
+      end
+    end
+  end
+end

data/lib/rampart/domain/domain_exception.rb

@@ -0,0 +1,15 @@
+module Rampart
+  module Domain
+    class DomainException < StandardError
+      attr_reader :code, :context
+
+      def initialize(message, code: nil, context: {})
+        @code = code
+        @context = context
+        super(message)
+      end
+    end
+  end
+end
+
+

data/lib/rampart/domain/domain_service.rb

@@ -0,0 +1,10 @@
+module Rampart
+  module Domain
+    class DomainService
+      # Base class for domain services
+      # Domain services contain domain logic that doesn't naturally fit within an entity or value object
+    end
+  end
+end
+
+

data/lib/rampart/domain/entity.rb

@@ -0,0 +1,20 @@
+require "dry-struct"
+
+module Rampart
+  module Domain
+    class Entity < Dry::Struct
+      # Entities have identity and can be compared by id
+      def ==(other)
+        other.is_a?(self.class) && other.id == id
+      end
+      
+      alias_method :eql?, :==
+      
+      def hash
+        [self.class, id].hash
+      end
+    end
+  end
+end
+
+