V3 Core Implementation

Implement a TypeScript core module for claude-flow v3 using domain-driven design.

Updated Feb 24, 2026
One-click install
npx skills add https://github.com/FrekiManagarm/dunlo --skill v3-core-implementation-frekimanagarm
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: V3 Core Implementation
Source: https://github.com/FrekiManagarm/dunlo/tree/main/.claude/skills/v3-core-implementation
Command: npx skills add https://github.com/FrekiManagarm/dunlo --skill v3-core-implementation-frekimanagarm

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

It solves the challenge of building a robust, maintainable core TypeScript architecture for claude-flow v3 that correctly organizes domain logic, application use-cases, and infrastructure concerns with reliable test coverage.

Core Features & Use Cases

  • DDD bounded contexts: Implements task-management and supporting domains with clear entities, value objects, services, repositories, and domain events.
  • Clean architecture layering: Separates shared domain primitives (Entity, ValueObject, AggregateRoot) from application use-cases and infrastructure implementations.
  • Dependency injection & event coordination: Wires repositories, services, use-cases, and a domain event bus via a configurable dependency container for modular extensibility.
  • Operational persistence & reconstitution: Provides repository interfaces plus a SQLite-backed implementation that maps rows to aggregates and reconstitutes domain objects.
  • Automated verification: Includes unit and integration tests to validate domain behavior (e.g., events emitted on state changes) and repository persistence.

Quick Start

Run the skill to implement the V3 core foundation, then immediately create the task, session, and health domain modules with entities, value objects, repositories, use-cases, dependency bindings, and accompanying 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 structure a TypeScript domain module using clean architecture and DDD?

To implement DDD core modules with tests, you organize bounded contexts using entities, value objects, aggregates, and repositories. This approach isolates domain logic, application use-cases, and infrastructure concerns to ensure maintainable TypeScript architecture.

How do I wire dependency injection for domain repositories and use-cases?

Wire dependency injection by configuring a dependency container that connects repository interfaces, services, use-cases, and a domain event bus. This modular container coordinates event publishing and enables extensible task management bounded contexts.

How do I test domain events and aggregate behavior in a TypeScript application?

Test domain events and aggregate behavior by writing unit and integration tests that validate deterministic domain logic and verify events emitted on state changes. Automated testing ensures reliable repository persistence and accurate domain object reconstitution.

What's the best way to persist and reconstitute DDD aggregates with SQLite?

Persist and reconstitute DDD aggregates by defining repository interfaces with concrete SQLite-backed implementations that map database rows to aggregates. This approach ensures reliable data mapping and accurate domain object reconstitution for task management contexts.

Do I need prior TypeScript architecture experience to use this Skill?

Yes, this Skill requires familiarity with TypeScript, domain-driven design, and clean architecture concepts. It targets advanced implementation depth, organizing entities, value objects, repositories, and dependency injection for robust task management bounded contexts.