@monoes/monomindcli 1.10.54 → 1.10.55

package/.claude/skills/core-implementation/SKILL.md

@@ -1,892 +0,0 @@
----
-name: core-implementation
-description: "Core module implementation for monomind. Implements DDD domains, clean architecture patterns, dependency injection, and modular TypeScript codebase with comprehensive testing."
-triggers:
-  - implement domain entity
-  - DDD implementation
-  - add repository
-  - create use case
-  - bounded context implementation
-  - domain model
-  - value object
-  - aggregate root
----
-
-# Core Implementation
-
-## What This Skill Does
-
-Implements the core TypeScript modules for monomind 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
-│   │   ├── monomind-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");
-  }
-
-  static fromString(value: string): TaskStatus {
-    const valid: TaskStatusType[] = ["pending", "assigned", "in_progress", "completed", "failed"];
-    if (!valid.includes(value as TaskStatusType)) {
-      throw new Error(`Invalid TaskStatus value: "${value}"`);
-    }
-    return new TaskStatus(value as TaskStatusType);
-  }
-
-  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");
-  }
-
-  static fromString(value: string): Priority {
-    const valid: PriorityLevel[] = ["low", "medium", "high", "critical"];
-    if (!valid.includes(value as PriorityLevel)) {
-      throw new Error(`Invalid Priority value: "${value}"`);
-    }
-    return new Priority(value as PriorityLevel);
-  }
-
-  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,
-      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),
-    });
-  }
-}
-```
-
-## Application Layer
-
-### Use Case Implementation
-
-```typescript
-// 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");
-    }
-  }
-}
-```
-
-## Dependency Injection Setup
-
-### Container Configuration
-
-```typescript
-// src/core/shared/infrastructure/dependency-container.ts
-import { 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);
-  }
-}
-```
-
-## Modern TypeScript Configuration
-
-### Strict TypeScript Setup
-
-```json
-// tsconfig.json
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "lib": ["ES2022"],
-    "module": "NodeNext",
-    "moduleResolution": "NodeNext",
-    "declaration": true,
-    "outDir": "./dist",
-    "strict": true,
-    "exactOptionalPropertyTypes": true,
-    "noImplicitReturns": true,
-    "noFallthroughCasesInSwitch": true,
-    "noUncheckedIndexedAccess": true,
-    "noImplicitOverride": true,
-    "experimentalDecorators": true,
-    "emitDecoratorMetadata": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "resolveJsonModule": true,
-    "esModuleInterop": true,
-    "allowSyntheticDefaultImports": true,
-    "baseUrl": ".",
-    "paths": {
-      "@/*": ["src/*"],
-      "@core/*": ["src/core/*"],
-      "@shared/*": ["src/core/shared/*"],
-      "@domains/*": ["src/core/domains/*"]
-    }
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist", "**/*.test.ts", "**/*.spec.ts"]
-}
-```
-
-## Testing Implementation
-
-### Domain Unit Tests
-
-```typescript
-// src/core/domains/task-management/__tests__/entities/task.entity.test.ts
-describe("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",
-      );
-    });
-  });
-});
-```
-
-### Integration Tests
-
-```typescript
-// src/core/domains/task-management/__tests__/integration/task-repository.integration.test.ts
-describe("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);
-  });
-});
-```
-
-## Performance Optimizations
-
-### Entity Caching
-
-```typescript
-// 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();
-  }
-}
-```
-
-## Success Metrics
-
-- [ ] **Domain Isolation**: 100% clean dependency boundaries
-- [ ] **Test Coverage**: >90% unit test coverage for domain logic
-- [ ] **Type Safety**: Strict TypeScript compilation with zero any types
-- [ ] **Performance**: <50ms average use case execution time
-- [ ] **Memory Efficiency**: <100MB heap usage for core domains
-- [ ] **Plugin Architecture**: Modular domain loading capability
-
-## Related Skills
-
-- `ddd-architecture` - DDD architectural design
-- `mcp-optimization` - MCP server integration
-- `memory-unification` - AgentDB repository integration
-- `swarm-coordination` - Swarm domain implementation
-
-## Usage Examples
-
-### Complete Core Implementation
-
-```bash
-# Full core module implementation
-Task("Core implementation",
-     "Implement all core domains with DDD patterns and comprehensive testing",
-     "core-implementer")
-```
-
-### Domain-Specific Implementation
-
-```bash
-# Single domain implementation
-Task("Task domain implementation",
-     "Implement task management domain with entities, services, and repositories",
-     "core-implementer")
-```