V3 Core Implementation

Implements DDD domains, clean architecture, and dependency injection for TypeScript codebases.

1|Updated Jun 3, 2026
One-click install
npx skills add https://github.com/KentwareDemo/RuView --skill v3-core-implementation-kentwaredemo
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: V3 Core Implementation
Source: https://github.com/KentwareDemo/RuView/tree/main/.claude/skills/v3-core-implementation
Command: npx skills add https://github.com/KentwareDemo/RuView --skill v3-core-implementation-kentwaredemo

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill requires inversify.

What problem does it solve? Building a modular TypeScript backend without clear architectural boundaries leads to tangled code, untestable business logic, and fragile dependencies. This Skill provides a complete blueprint for implementing core modules using Domain-Driven Design, clean architecture, and dependency injection. ## Core Features & Use Cases - DDD Domain Modeling: Provides base classes for Entities, Value Objects, and Aggregate Roots, plus a full task-management domain example with entities, value objects, domain services, and events. - Repository & Use Case Patterns: Includes repository interfaces with SQLite implementations and application-layer use cases that orchestrate aggregates and publish domain events. - Dependency Injection & Testing: Configures an Inversify-based container, strict TypeScript settings, entity caching, and unit/integration test patterns. - Use Case: When scaffolding the core of claude-flow v3, use this Skill to generate the task, session, and health domains with clean dependency boundaries and over 90% test coverage targets. ## Quick Start Ask the AI to implement the core domains for claude-flow v3 following DDD patterns with entities, repositories, use cases, and comprehensive tests.

Frequently Asked Questions about V3 Core Implementation

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I implement Domain-Driven Design in TypeScript?▼

Start with base classes for Entity, ValueObject, and AggregateRoot, then organize code into bounded contexts under a domains directory. Each domain contains entities, value objects, services, repositories, and events, with use cases in an application layer orchestrating the aggregates.

How to structure a clean architecture TypeScript project?▼

Separate code into core domains, a shared kernel with base domain classes and infrastructure, and an application layer with use cases, commands, and queries. Use path aliases like @core and @domains in tsconfig to enforce clean import boundaries.

What dependency injection library works with TypeScript decorators?▼

Inversify works with TypeScript decorators when experimentalDecorators and emitDecoratorMetadata are enabled in tsconfig. Bind interfaces to implementations in a container using symbols as service identifiers, then resolve dependencies through constructor injection.

How do I test DDD entities and repositories?▼

Unit test entities by verifying state transitions and emitted domain events, such as checking that assigning a task changes its status and raises a TaskAssignedEvent. For repositories, run integration tests against an in-memory SQLite database to validate save and query behavior.

When should I use the repository pattern with SQLite?▼

Use the repository pattern when domain logic must stay independent of persistence details. Define an interface like ITaskRepository in the domain, then provide a SQLite implementation that maps database rows back to reconstituted aggregates.