Implement core TypeScript modules for claude-flow v3 using domain-driven design, which organizes code around distinct responsibilities. Build task and session domains, connect storage and services, and add unit and integration tests.
中文简介正在准备中。当前显示英语简介。
Core module implementation for claude-flow v3. Implements DDD domains, clean architecture patterns, dependency injection, and modular TypeScript codebase with comprehensive testing.
安装前可以查看交给 AI 代理的指令内容。
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.
# 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")
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/
// 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 = [];
}
}
// 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;
}
}
// 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();
}
}
// 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();
}
}
// 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];
}
}
// 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];
}
}
// 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>;
}
// 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.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);
}
}
// 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"]
}
// 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');
});
});
});
// 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);
});
});
// 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();
}
}
v3-ddd-architecture - DDD architectural designv3-mcp-optimization - MCP server integrationv3-memory-unification - AgentDB repository integrationv3-swarm-coordination - Swarm domain implementation# Full core module implementation
Task("Core implementation",
"Implement all core domains with DDD patterns and comprehensive testing",
"core-implementer")
# Single domain implementation
Task("Task domain implementation",
"Implement task management domain with entities, services, and repositories",
"core-implementer")
还没有评价。欢迎分享你的使用感受。
无需登录即可发表。欢迎分享使用感受、提问，或说明在哪些环境下无法运行。
还没有评论。来写第一条吧。
Compare models available through the HuggingFace router with chat-ui configuration, research missing models, and write short English descriptions of their architecture and capabilities. Add entries to both production and development configuration files and commit the changes.
中文简介正在准备中。当前显示英语简介。
Create an Architecture Decision Record, a document for recording important design choices, with the next sequential number. It generates a Markdown template, registers the record in AgentDB, and links related decisions found through search.
中文简介正在准备中。当前显示英语简介。
Build a searchable index and relationship graph from ADRs, records of architectural decisions. Import two supported document formats, refresh existing metadata without duplicate relationships, and review summaries of statuses, missing references, and inconsistencies.
中文简介正在准备中。当前显示英语简介。
Rebuild the index of ADRs, records of architectural decisions, after files or relationship lines are deleted. It clears stored records and relationships, indexes the files still present, and checks that the final record count matches.
中文简介正在准备中。当前显示英语简介。
Review code changes against accepted Architecture Decision Records, documents that capture agreed design choices. Report violations, outdated references, compliant changes, and areas without ADR coverage, then suggest code fixes or a new decision record where appropriate.
中文简介正在准备中。当前显示英语简介。
Check saved architecture decision records (ADRs) for broken references, circular replacement relationships, and inconsistent statuses. Use the results to verify imported records or stop a CI check when selected integrity rules fail.
中文简介正在准备中。当前显示英语简介。