V3 Core Implementation
Core module implementation for claude-flow v3. Implements DDD domains, clean architecture patterns, dependency injection, and modular TypeScript codebase with comprehensive testing.
Install / Use
npx skills add spencermarx/open-code-review --skill v3-core-implementationInstalls into whichever agent you are using.
SKILL.md
Installable skill definition
Quality Score
Category
Development & EngineeringSupported Platforms
Our assessment of V3 Core Implementation
V3 Core Implementation scores 86/100 on our quality scale, 2300th of 4,716 Development & Engineering skills we index (top 49%).
Its SKILL.md is 21 KB long, well organised into 37 sections with 18 code examples: a thorough specification that gives an agent plenty to work with.
It has 368 GitHub stars, a meaningful sign that others use it.
Maintenance, license and trust
- The repository was last updated about 4 months ago. That is recent enough to be usable, but agent tooling moves fast, so check the instructions against your agent's current version.
- Our last check on 2026-11-03 found the source still online.
- It is released under the Apache-2.0 license, a permissive license that allows use, modification and commercial use with attribution.
- Its trust signals score 98/100, with no cautions. These come from repository metadata, not a code audit — read the skill file before letting an agent act on it.
Safety scan
No issues foundOur scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful.
AI review by kimi-k2.7-code on 2026-10-07. Automated pattern scan on 2026-10-07. It catches known dangerous patterns, not every risk — read a skill before letting an agent act on it.
V3 Core Implementation compared with similar skills
All 4 of these similar skills score higher than V3 Core Implementation; compare them before choosing.
| Skill | Score | Stars | Updated | Format |
|---|---|---|---|---|
| V3 Core Implementation (this skill)by spencermarx | 86 | 368 | 4mo ago | SKILL.md |
| taste-skillby Leonxlnx | 100 | 118.9k | 11d ago | CLAUDE.md |
| hyperframesby heygen-com | 100 | 87.1k | today | CLAUDE.md |
| rufloby ruvnet | 100 | 82.1k | today | CLAUDE.md |
| headroomby headroomlabs-ai | 100 | 80.2k | today | CLAUDE.md |
Frequently asked questions
- How do I install V3 Core Implementation?
- Run
npx skills add spencermarx/open-code-review --skill "V3 Core Implementation". The install tabs above show the steps for each supported agent. - Which AI agents does V3 Core Implementation work with?
- It is written for Claude Code, as a SKILL.md file. Other agents that read the same format can often use it too.
- Is V3 Core Implementation safe to use?
- Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful. It is Apache-2.0-licensed and scores 98/100 on trust signals. Skills are instructions an agent will follow, so read the file before installing it and do not approve commands you do not understand.
- Is V3 Core Implementation still maintained?
- The repository was last updated about 4 months ago. That is recent enough to be usable, but agent tooling moves fast, so check the instructions against your agent's current version.
Skill content
View source on GitHubname: "V3 Core Implementation" description: "Core module implementation for claude-flow v3. Implements DDD domains, clean architecture patterns, dependency injection, and modular TypeScript codebase with comprehensive testing."
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
# 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
// 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
// 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
// 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
// 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
// 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
// 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
// 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
// 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)
});
}
}
Truncated for display — read the full file on GitHub.
Related Skills
taste-skill
118.9kAgent skills that give coding agents taste: art direction, reference images and a browser check instead of generic AI pages
hyperframes
87.1kAI video you can actually edit. HyperFrames is a free, open-source AI video editor. Describe any video and get a real project you can change down to the frame.
ruflo
82.1k🌊 The original agent harness. Deploy intelligent multi-player swarms, coordinate autonomous workflows, and build conversational AI systems. Features adaptive memory, self-learning intelligence, federation, vector RAG integration, and native Claude Code / Codex / Hermes and many more Integrated
headroom
80.2kCompress tool outputs, logs, files, and RAG chunks before they reach the LLM. 20% fewer tokens for coding agents, 60-95% fewer tokens for JSON, same answers. Library, proxy, MCP server.
Languages
Trust signals
From repository metadata: license, adoption, age and documentation. Not a code audit — see the Safety scan above for what the skill file itself contains.
