V3 Core Implementation

// src/core/shared/domain/entity.tsexport 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 = [];  }}

// src/core/shared/domain/value-object.tsexport 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;  }}

// src/core/shared/domain/aggregate-root.tsexport 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();  }}

// src/core/domains/task-management/entities/task.entity.tsimport { 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();  }}

// src/core/domains/task-management/value-objects/task-id.vo.tsexport 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.tstype 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.tstype 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];  }}

// src/core/domains/task-management/services/task-scheduling.service.tsimport { 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];  }}

// src/core/domains/task-management/repositories/task.repository.tsexport 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>;}

// 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,      priority: Priority.fromString(row.priority),      status: TaskStatus.fromString(row.status),      assignedAgentId: row.assigned_agent_id,      createdAt: new Date(row.created_at),      updatedAt: new Date(row.updated_at)    });  }}

// src/core/application/use-cases/assign-task.use-case.ts@Injectable()export class AssignTaskUseCase {  constructor(    @Inject('TaskRepository') private taskRepository: ITaskRepository,    @Inject('AgentRepository') private agentRepository: IAgentRepository,    @Inject('DomainEventBus') private eventBus: DomainEventBus,    @Inject('Logger') private logger: ILogger  ) {}
  async execute(command: AssignTaskCommand): Promise<AssignTaskResult> {    try {      // 1. Validate command      await this.validateCommand(command);
      // 2. Load aggregates      const task = await this.taskRepository.findById(command.taskId);      if (!task) {        throw new TaskNotFoundError(command.taskId);      }
      const agent = await this.agentRepository.findById(command.agentId);      if (!agent) {        throw new AgentNotFoundError(command.agentId);      }
      // 3. Business logic      if (!agent.canAcceptTask(task)) {        throw new AgentCannotAcceptTaskError(command.agentId, command.taskId);      }
      task.assignTo(command.agentId);      agent.acceptTask(task.id);
      // 4. Persist changes      await Promise.all([        this.taskRepository.save(task),        this.agentRepository.save(agent)      ]);
      // 5. Publish domain events      const events = [        ...task.getUncommittedEvents(),        ...agent.getUncommittedEvents()      ];
      for (const event of events) {        await this.eventBus.publish(event);      }
      task.markEventsAsCommitted();      agent.markEventsAsCommitted();
      // 6. Return result      this.logger.info(`Task ${command.taskId.value} assigned to agent ${command.agentId}`);
      return AssignTaskResult.success({        taskId: task.id,        agentId: command.agentId,        assignedAt: new Date()      });
    } catch (error) {      this.logger.error(`Failed to assign task ${command.taskId.value}:`, error);      return AssignTaskResult.failure(error);    }  }
  private async validateCommand(command: AssignTaskCommand): Promise<void> {    if (!command.taskId) {      throw new ValidationError('Task ID is required');    }    if (!command.agentId) {      throw new ValidationError('Agent ID is required');    }  }}

// src/core/shared/infrastructure/dependency-container.tsimport { Container } from 'inversify';import { TYPES } from './types';
export class DependencyContainer {  private container: Container;
  constructor() {    this.container = new Container();    this.setupBindings();  }
  private setupBindings(): void {    // Repositories    this.container.bind<ITaskRepository>(TYPES.TaskRepository)      .to(SqliteTaskRepository)      .inSingletonScope();
    this.container.bind<IAgentRepository>(TYPES.AgentRepository)      .to(SqliteAgentRepository)      .inSingletonScope();
    // Services    this.container.bind<TaskSchedulingService>(TYPES.TaskSchedulingService)      .to(TaskSchedulingService)      .inSingletonScope();
    // Use Cases    this.container.bind<AssignTaskUseCase>(TYPES.AssignTaskUseCase)      .to(AssignTaskUseCase)      .inSingletonScope();
    // Infrastructure    this.container.bind<ILogger>(TYPES.Logger)      .to(ConsoleLogger)      .inSingletonScope();
    this.container.bind<DomainEventBus>(TYPES.DomainEventBus)      .to(InMemoryDomainEventBus)      .inSingletonScope();  }
  get<T>(serviceIdentifier: symbol): T {    return this.container.get<T>(serviceIdentifier);  }
  bind<T>(serviceIdentifier: symbol): BindingToSyntax<T> {    return this.container.bind<T>(serviceIdentifier);  }}

// src/core/domains/task-management/__tests__/entities/task.entity.test.tsdescribe('Task Entity', () => {  let task: Task;
  beforeEach(() => {    task = Task.create('Test task', Priority.medium());  });
  describe('creation', () => {    it('should create task with pending status', () => {      expect(task.status.isPending()).toBe(true);      expect(task.description).toBe('Test task');      expect(task.priority.equals(Priority.medium())).toBe(true);    });
    it('should generate unique ID', () => {      const task1 = Task.create('Task 1', Priority.low());      const task2 = Task.create('Task 2', Priority.low());
      expect(task1.id.equals(task2.id)).toBe(false);    });  });
  describe('assignment', () => {    it('should assign to agent and change status', () => {      const agentId = 'agent-123';
      task.assignTo(agentId);
      expect(task.assignedAgentId).toBe(agentId);      expect(task.status.isAssigned()).toBe(true);    });
    it('should emit TaskAssignedEvent when assigned', () => {      const agentId = 'agent-123';
      task.assignTo(agentId);
      const events = task.getUncommittedEvents();      expect(events).toHaveLength(1);      expect(events[0]).toBeInstanceOf(TaskAssignedEvent);    });
    it('should not allow assignment of completed task', () => {      task.assignTo('agent-123');      task.complete(TaskResult.success('done'));
      expect(() => task.assignTo('agent-456'))        .toThrow('Cannot assign completed task');    });  });});

// src/core/domains/task-management/__tests__/integration/task-repository.integration.test.tsdescribe('TaskRepository Integration', () => {  let repository: SqliteTaskRepository;  let db: Database;
  beforeEach(async () => {    db = new Database(':memory:');    await setupTasksTable(db);    repository = new SqliteTaskRepository(db, new ConsoleLogger());  });
  afterEach(async () => {    await db.close();  });
  it('should save and retrieve task', async () => {    const task = Task.create('Test task', Priority.high());
    await repository.save(task);    const retrieved = await repository.findById(task.id);
    expect(retrieved).toBeDefined();    expect(retrieved!.id.equals(task.id)).toBe(true);    expect(retrieved!.description).toBe('Test task');    expect(retrieved!.priority.equals(Priority.high())).toBe(true);  });
  it('should find pending tasks ordered by priority', async () => {    const lowTask = Task.create('Low priority', Priority.low());    const highTask = Task.create('High priority', Priority.high());
    await repository.save(lowTask);    await repository.save(highTask);
    const pending = await repository.findPendingTasks();
    expect(pending).toHaveLength(2);    expect(pending[0].id.equals(highTask.id)).toBe(true); // High priority first    expect(pending[1].id.equals(lowTask.id)).toBe(true);  });});

// src/core/shared/infrastructure/entity-cache.ts@Injectable()export class EntityCache<T extends Entity<any>> {  private cache = new Map<string, { entity: T; timestamp: number }>();  private readonly ttl: number = 300000; // 5 minutes
  set(id: string, entity: T): void {    this.cache.set(id, { entity, timestamp: Date.now() });  }
  get(id: string): T | null {    const cached = this.cache.get(id);    if (!cached) return null;
    // Check TTL    if (Date.now() - cached.timestamp > this.ttl) {      this.cache.delete(id);      return null;    }
    return cached.entity;  }
  invalidate(id: string): void {    this.cache.delete(id);  }
  clear(): void {    this.cache.clear();  }}