claude-flow
Version:
Ruflo - Enterprise AI agent orchestration for Claude Code. Deploy 60+ specialized agents in coordinated swarms with self-learning, fault-tolerant consensus, vector memory, and MCP integration
197 lines • 6.68 kB
TypeScript
/**
* V3 Claude-Flow Shared Types
* Core type definitions for the 15-agent swarm coordination system
*
* Based on ADR-002 (DDD) and ADR-003 (Single Coordination Engine)
*/
export type AgentId = `agent-${number}` | string;
export type AgentRole = 'queen-coordinator' | 'security-architect' | 'security-implementer' | 'security-tester' | 'core-architect' | 'core-implementer' | 'memory-specialist' | 'swarm-specialist' | 'mcp-specialist' | 'integration-architect' | 'cli-hooks-developer' | 'neural-learning-dev' | 'tdd-test-engineer' | 'performance-engineer' | 'release-engineer';
export type AgentStatus = 'idle' | 'active' | 'blocked' | 'completed' | 'error';
export type AgentDomain = 'security' | 'core' | 'integration' | 'quality' | 'performance' | 'deployment';
export interface AgentCapability {
name: string;
description: string;
supportedTaskTypes: TaskType[];
}
export interface AgentDefinition {
id: AgentId;
role: AgentRole;
domain: AgentDomain;
description: string;
capabilities: AgentCapability[];
dependencies: AgentId[];
priority: number;
}
export interface AgentState {
id: AgentId;
role: AgentRole;
status: AgentStatus;
currentTask: TaskId | null;
completedTasks: TaskId[];
metrics: AgentMetrics;
lastHeartbeat: number;
}
export interface AgentMetrics {
tasksCompleted: number;
tasksFailed: number;
averageTaskDuration: number;
utilization: number;
startTime: number;
}
export type TaskId = `task-${string}`;
export type TaskType = 'security-audit' | 'security-fix' | 'security-test' | 'architecture-design' | 'implementation' | 'memory-optimization' | 'swarm-coordination' | 'mcp-enhancement' | 'integration' | 'cli-development' | 'neural-training' | 'test-writing' | 'benchmark' | 'deployment' | 'documentation';
export type TaskStatus = 'pending' | 'queued' | 'assigned' | 'in-progress' | 'blocked' | 'completed' | 'failed' | 'cancelled';
export type TaskPriority = 'critical' | 'high' | 'medium' | 'low';
export interface TaskDefinition {
id: TaskId;
type: TaskType;
title: string;
description: string;
assignedAgent: AgentId | null;
status: TaskStatus;
priority: TaskPriority;
dependencies: TaskId[];
blockedBy: TaskId[];
metadata: TaskMetadata;
createdAt: number;
updatedAt: number;
completedAt: number | null;
}
export interface TaskMetadata {
domain: AgentDomain;
phase: PhaseId;
estimatedDuration: number;
actualDuration: number | null;
retryCount: number;
maxRetries: number;
artifacts: string[];
tags: string[];
}
export interface TaskResult {
taskId: TaskId;
success: boolean;
output: unknown;
error: Error | null;
duration: number;
metrics: TaskResultMetrics;
}
export interface TaskResultMetrics {
linesOfCode: number;
testsWritten: number;
testsPassed: number;
coveragePercent: number;
performanceImpact: number;
}
export type PhaseId = 'phase-1-foundation' | 'phase-2-core' | 'phase-3-integration' | 'phase-4-release';
export interface PhaseDefinition {
id: PhaseId;
name: string;
description: string;
weeks: [number, number];
activeAgents: AgentId[];
goals: string[];
milestones: MilestoneDefinition[];
}
export interface MilestoneDefinition {
id: string;
name: string;
description: string;
criteria: MilestoneCriteria[];
status: MilestoneStatus;
completedAt: number | null;
}
export type MilestoneStatus = 'pending' | 'in-progress' | 'completed' | 'blocked';
export interface MilestoneCriteria {
description: string;
met: boolean;
evidence: string | null;
}
export type TopologyType = 'hierarchical-mesh' | 'mesh' | 'hierarchical' | 'centralized';
export interface SwarmConfig {
topology: TopologyType;
maxAgents: number;
messageTimeout: number;
retryAttempts: number;
healthCheckInterval: number;
loadBalancingStrategy: LoadBalancingStrategy;
}
export type LoadBalancingStrategy = 'round-robin' | 'least-loaded' | 'capability-match' | 'priority-based';
export interface SwarmState {
initialized: boolean;
topology: TopologyType;
agents: Map<AgentId, AgentState>;
tasks: Map<TaskId, TaskDefinition>;
currentPhase: PhaseId;
metrics: SwarmMetrics;
}
export interface SwarmMetrics {
totalAgents: number;
activeAgents: number;
idleAgents: number;
blockedAgents: number;
totalTasks: number;
completedTasks: number;
failedTasks: number;
pendingTasks: number;
averageTaskDuration: number;
utilization: number;
startTime: number;
lastUpdate: number;
}
export type EventType = 'agent:spawned' | 'agent:status-changed' | 'agent:task-assigned' | 'agent:task-completed' | 'agent:error' | 'task:created' | 'task:queued' | 'task:assigned' | 'task:started' | 'task:completed' | 'task:failed' | 'task:blocked' | 'swarm:initialized' | 'swarm:phase-changed' | 'swarm:milestone-reached' | 'swarm:error';
export interface SwarmEvent<T = unknown> {
id: string;
type: EventType;
timestamp: number;
source: AgentId | 'swarm';
payload: T;
}
export type EventHandler<T = unknown> = (event: SwarmEvent<T>) => void | Promise<void>;
export type MessageType = 'task_assignment' | 'task_complete' | 'task_failed' | 'dependency_ready' | 'review_request' | 'status_update' | 'heartbeat' | 'broadcast';
export interface SwarmMessage<T = unknown> {
id: string;
type: MessageType;
from: AgentId;
to: AgentId | 'broadcast';
payload: T;
timestamp: number;
correlationId: string | null;
}
export type MessageHandler<T = unknown> = (message: SwarmMessage<T>) => void | Promise<void>;
export interface PerformanceTargets {
flashAttention: {
minSpeedup: number;
maxSpeedup: number;
};
agentDbSearch: {
minSpeedup: number;
maxSpeedup: number;
};
memoryReduction: {
minPercent: number;
maxPercent: number;
};
codeReduction: {
targetLines: number;
currentLines: number;
};
startupTime: {
targetMs: number;
};
sonaLearning: {
targetMs: number;
};
}
export declare const V3_PERFORMANCE_TARGETS: PerformanceTargets;
export type DeepPartial<T> = {
[P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
};
export type AsyncCallback<T = void> = () => Promise<T>;
export interface Result<T, E = Error> {
success: boolean;
value?: T;
error?: E;
}
export declare function success<T>(value: T): Result<T>;
export declare function failure<E = Error>(error: E): Result<never, E>;
//# sourceMappingURL=types.d.ts.map