v3-core-implementation

# V3 Core Implementation ## What This Skill Does Implements the core TypeScript modules for claude-flow v3 following Domain-Driven Design principles, clean architecture patterns, and modern TypeScript best practices with comprehensive test coverage. ## Quick Start ```bash # Initialize core implementation Task("Core foundation", "Set up DDD domain structure and base classes", "core-implementer") # Domain implementation (parallel) Task("Task domain", "Implement task management domain with entities and services", "core-implementer") Task("Session domain", "Implement session management domain", "core-implementer") Task("Health domain", "Implement health monitoring domain", "core-implementer") ``` ## Core Implementation Architecture ### Domain Structure ``` src/ ├── core/ │ ├── kernel/ # Microkernel pattern │ │ ├── claude-flow-kernel.ts │ │ ├── domain-registry.ts │ │ └── plugin-loader.ts │ │ │ ├── domains/ # DDD Bounded Contexts │ │ ├── task-management/ │ │ │ ├── entities/ │ │ │ ├── value-objects/ │ │ │ ├── services/ │ │ │ ├── repositories/ │ │ │ └── events/ │ │ │ │ │ ├── session-management/ │ │ ├── health-monitoring/ │ │ ├── lifecycle-management/ │ │ └── event-coordination/ │ │ │ ├── shared/ # Shared kernel │ │ ├── domain/ │ │ │ ├── entity.ts │ │ │ ├── value-object.ts │ │ │ ├── domain-event.ts │ │ │ └── aggregate-root.ts │ │ │ │ │ ├── infrastructure/ │ │ │ ├── event-bus.ts │ │ │ ├── dependency-container.ts │ │ │ └── logger.ts │ │ │ │ │ └── types/ │ │ ├── common.ts │ │ ├── errors.ts │ │ └── interfaces.ts │ │ │ └── application/ # Application services │ ├── use-cases/ │ ├── commands/ │ ├── queries/ │ └── handlers/ ``` ## Base Domain Classes ### Entity Base Class ```typescript // src/core/shared/domain/entity.ts export abstract class Entity<T> { protected readonly _id: T; private _domainEvents: DomainEvent[] = []; constructor(id: T) { this._id = id; } get id(): T { return this._id; } public equals(object?: Entity<T>): boolean { if (object == null || object == undefined) { return false; } if (this === object) { return true; } if (!(object instanceof Entity)) { return false; } return this._id === object._id; } protected addDomainEvent(domainEvent: DomainEvent): void { this._domainEvents.push(domainEvent); } public getUncommittedEvents(): DomainEvent[] { return this._domainEvents; } public markEventsAsCommitted(): void { this._domainEvents = []; } } ``` ### Value Object Base Class ```typescript // src/core/shared/domain/value-object.ts export abstract class ValueObject<T> { protected readonly props: T; constructor(props: T) { this.props = Object.freeze(props); } public equals(object?: ValueObject<T>): boolean { if (object == null || object == undefined) { return false; } if (this === object) { return true; } return JSON.stringify(this.props) === JSON.stringify(object.props); } get value(): T { return this.props; } } ``` ### Aggregate Root ```typescript // src/core/shared/domain/aggregate-root.ts export abstract class AggregateRoot<T> extends Entity<T> { private _version: number = 0; get version(): number { return this._version; } protected incrementVersion(): void { this._version++; } public applyEvent(event: DomainEvent): void { this.addDomainEvent(event); this.incrementVersion(); } } ``` ## Task Management Domain Implementation ### Task Entity ```typescript // src/core/domains/task-management/entities/task.entity.ts import { AggregateRoot } from "../../../shared/domain/aggregate-root"; import { TaskId } from "../value-objects/task-id.vo"; import { TaskStatus } from "../value-objects/task-status.vo"; import { Priority } from "../value-objects/priority.vo"; import { TaskAssignedEvent } from "../events/task-assigned.event"; interface TaskProps { id: TaskId; description: string; priority: Priority; status: TaskStatus; assignedAgentId?: string; createdAt: Date; updatedAt: Date; } export class Task extends AggregateRoot<TaskId> { private props: TaskProps; private constructor(props: TaskProps) { super(props.id); this.props = props; } static create(description: string, priority: Priority): Task { const task = new Task({ id: TaskId.create(), description, priority, status: TaskStatus.pending(), createdAt: new Date(), updatedAt: new Date(), }); return task; } static reconstitute(props: TaskProps): Task { return new Task(props); } public assignTo(agentId: string): void { if (this.props.status.equals(TaskStatus.completed())) { throw new Error("Cannot assign completed task"); } this.props.assignedAgentId = agentId; this.props.status = TaskStatus.assigned(); this.props.updatedAt = new Date(); this.applyEvent( new TaskAssignedEvent(this.id.value, agentId, this.props.priority), ); } public complete(result: TaskResult): void { if (!this.props.assignedAgentId) { throw new Error("Cannot complete unassigned task"); } this.props.status = TaskStatus.completed(); this.props.updatedAt = new Date(); this.applyEvent( new TaskCompletedEvent(this.id.value, result, this.calculateDuration()), ); } // Getters get description(): string { return this.props.description; } get priority(): Priority { return this.props.priority; } get status(): TaskStatus { return this.props.status; } get assignedAgentId(): string | undefined { return this.props.assignedAgentId; } get createdAt(): Date { return this.props.createdAt; } get updatedAt(): Date { return this.props.updatedAt; } private calculateDuration(): number { return this.props.updatedAt.getTime() - this.props.createdAt.getTime(); } } ``` ### Task Value Objects ```typescript // src/core/domains/task-management/value-objects/task-id.vo.ts export class TaskId extends ValueObject<string> { private constructor(value: string) { super({ value }); } static create(): TaskId { return new TaskId(crypto.randomUUID()); } static fromString(id: string): TaskId { if (!id || id.length === 0) { throw new Error("TaskId cannot be empty"); } return new TaskId(id); } get value(): string { return this.props.value; } } // src/core/domains/task-management/value-objects/task-status.vo.ts type TaskStatusType = | "pending" | "assigned" | "in_progress" | "completed" | "failed"; export class TaskStatus extends ValueObject<TaskStatusType> { private constructor(status: TaskStatusType) { super({ value: status }); } static pending(): TaskStatus { return new TaskStatus("pending"); } static assigned(): TaskStatus { return new TaskStatus("assigned"); } static inProgress(): TaskStatus { return new TaskStatus("in_progress"); } static completed(): TaskStatus { return new TaskStatus("completed"); } static failed(): TaskStatus { return new TaskStatus("failed"); } get value(): TaskStatusType { return this.props.value; } public isPending(): boolean { return this.value === "pending"; } public isAssigned(): boolean { return this.value === "assigned"; } public isInProgress(): boolean { return this.value === "in_progress"; } public isCompleted(): boolean { return this.value === "completed"; } public isFailed(): boolean { return this.value === "failed"; } } // src/core/domains/task-management/value-objects/priority.vo.ts type PriorityLevel = "low" | "medium" | "high" | "critical"; export class Priority extends ValueObject<PriorityLevel> { private constructor(level: PriorityLevel) { super({ value: level }); } static low(): Priority { return new Priority("low"); } static medium(): Priority { return new Priority("medium"); } static high(): Priority { return new Priority("high"); } static critical(): Priority { return new Priority("critical"); } get value(): PriorityLevel { return this.props.value; } public getNumericValue(): number { const priorities = { low: 1, medium: 2, high: 3, critical: 4 }; return priorities[this.value]; } } ``` ## Domain Services ### Task Scheduling Service ```typescript // src/core/domains/task-management/services/task-scheduling.service.ts import { Injectable } from "../../../shared/infrastructure/dependency-container"; import { Task } from "../entities/task.entity"; import { Priority } from "../value-objects/priority.vo"; @Injectable() export class TaskSchedulingService { public prioritizeTasks(tasks: Task[]): Task[] { return tasks.sort( (a, b) => b.priority.getNumericValue() - a.priority.getNumericValue(), ); } public canSchedule(task: Task, agentCapacity: number): boolean { if (agentCapacity <= 0) return false; // Critical tasks always schedulable if (task.priority.equals(Priority.critical())) return true; // Other logic based on capacity return true; } public calculateEstimatedDuration(task: Task): number { // Simple heuristic - would use ML in real implementation const baseTime = 300000; // 5 minutes const priorityMultiplier = { low: 0.5, medium: 1.0, high: 1.5, critical: 2.0, }; return baseTime * priorityMultiplier[task.priority.value]; } } ``` ## Repository Interfaces & Implementations ### Task Repository Interface ```typescript // src/core/domains/task-management/repositories/task.repository.ts export interface ITaskRepository { save(task: Task): Promise<void>; findById(id: TaskId): Promise<Task | null>; findByAgentId(agentId: string): Promise<Task[]>; findByStatus(status: TaskStatus): Promise<Task[]>; findPendingTasks(): Promise<Task[]>; delete(id: TaskId): Promise<void>; } ``` ### SQLite Implementation ```typescript // src/core/domains/task-management/repositories/sqlite-task.repository.ts @Injectable() export class SqliteTaskRepository implements ITaskRepository { constructor( @Inject("Database") private db: Database, @Inject("Logger") private logger: ILogger, ) {} async save(task: Task): Promise<void> { const sql = ` INSERT OR REPLACE INTO tasks ( id, description, priority, status, assigned_agent_id, created_at, updated_at ) VALUES (?, ?, ?, ?, ?, ?, ?) `; await this.db.run(sql, [ task.id.value, task.description, task.priority.value, task.status.value, task.assignedAgentId, task.createdAt.toISOString(), task.updatedAt.toISOString(), ]); this.logger.debug(`Task saved: ${task.id.value}`); } async findById(id: TaskId): Promise<Task | null> { const sql = "SELECT * FROM tasks WHERE id = ?"; const row = await this.db.get(sql, [id.value]); return row ? this.mapRowToTask(row) : null; } async findPendingTasks(): Promise<Task[]> { const sql = "SELECT * FROM tasks WHERE status = ? ORDER BY priority DESC, created_at ASC"; const rows = await this.db.all(sql, ["pending"]); return rows.map((row) => this.mapRowToTask(row)); } private mapRowToTask(row: any): Task { return Task.reconstitute({ id: TaskId.fromString(row.id), description: row.description,