@cloudpftc/opencode-orchestrator 3.5.15

package/v3/@claude-flow/shared/dist/core/interfaces/agent.interface.d.ts

@@ -0,0 +1,200 @@
+/**
+ * V3 Agent Interfaces
+ * Domain-Driven Design - Agent Lifecycle Bounded Context
+ */
+/**
+ * Agent status in the system
+ */
+export type AgentStatus = 'spawning' | 'active' | 'idle' | 'busy' | 'error' | 'terminated';
+/**
+ * Agent type classification
+ */
+export type AgentType = 'coder' | 'reviewer' | 'tester' | 'researcher' | 'planner' | 'architect' | 'coordinator' | 'security' | 'performance' | 'custom';
+/**
+ * Agent capability declaration
+ */
+export interface IAgentCapability {
+    name: string;
+    level: 'basic' | 'intermediate' | 'advanced' | 'expert';
+    description?: string;
+}
+/**
+ * Agent configuration for spawning
+ */
+export interface IAgentConfig {
+    readonly id: string;
+    readonly name: string;
+    readonly type: AgentType | string;
+    capabilities: string[];
+    maxConcurrentTasks: number;
+    priority: number;
+    timeout?: number;
+    retryPolicy?: {
+        maxRetries: number;
+        backoffMs: number;
+        backoffMultiplier: number;
+    };
+    resources?: {
+        maxMemoryMb?: number;
+        maxCpuPercent?: number;
+    };
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Core agent entity
+ */
+export interface IAgent {
+    readonly id: string;
+    readonly name: string;
+    readonly type: AgentType | string;
+    readonly config: IAgentConfig;
+    readonly createdAt: Date;
+    status: AgentStatus;
+    currentTaskCount: number;
+    lastActivity: Date;
+    sessionId?: string;
+    terminalId?: string;
+    memoryBankId?: string;
+    metrics?: {
+        tasksCompleted: number;
+        tasksFailed: number;
+        avgTaskDuration: number;
+        errorCount: number;
+        uptime: number;
+    };
+    health?: {
+        status: 'healthy' | 'degraded' | 'unhealthy';
+        lastCheck: Date;
+        issues?: string[];
+    };
+}
+/**
+ * Agent session for tracking active work
+ */
+export interface IAgentSession {
+    readonly id: string;
+    readonly agentId: string;
+    readonly startTime: Date;
+    status: 'active' | 'idle' | 'terminated';
+    terminalId: string;
+    memoryBankId: string;
+    lastActivity: Date;
+    endTime?: Date;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Agent pool for managing multiple agents
+ */
+export interface IAgentPool {
+    /**
+     * Add an agent to the pool
+     */
+    add(agent: IAgent): void;
+    /**
+     * Remove an agent from the pool
+     */
+    remove(agentId: string): boolean;
+    /**
+     * Get an agent by ID
+     */
+    get(agentId: string): IAgent | undefined;
+    /**
+     * Get all agents in the pool
+     */
+    getAll(): IAgent[];
+    /**
+     * Get agents by status
+     */
+    getByStatus(status: AgentStatus): IAgent[];
+    /**
+     * Get agents by type
+     */
+    getByType(type: AgentType | string): IAgent[];
+    /**
+     * Get available agents (can accept more tasks)
+     */
+    getAvailable(): IAgent[];
+    /**
+     * Get pool size
+     */
+    size(): number;
+    /**
+     * Check if pool has capacity
+     */
+    hasCapacity(maxSize: number): boolean;
+    /**
+     * Clear all agents
+     */
+    clear(): void;
+}
+/**
+ * Agent lifecycle manager interface
+ */
+export interface IAgentLifecycleManager {
+    /**
+     * Spawn a new agent
+     */
+    spawn(config: IAgentConfig): Promise<IAgent>;
+    /**
+     * Spawn multiple agents in parallel
+     */
+    spawnBatch(configs: IAgentConfig[]): Promise<Map<string, IAgent>>;
+    /**
+     * Terminate an agent
+     */
+    terminate(agentId: string, reason?: string): Promise<void>;
+    /**
+     * Terminate all agents
+     */
+    terminateAll(reason?: string): Promise<void>;
+    /**
+     * Restart an agent
+     */
+    restart(agentId: string): Promise<IAgent>;
+    /**
+     * Update agent configuration
+     */
+    updateConfig(agentId: string, config: Partial<IAgentConfig>): Promise<void>;
+    /**
+     * Get agent by ID
+     */
+    getAgent(agentId: string): IAgent | undefined;
+    /**
+     * Get all agents
+     */
+    getAllAgents(): IAgent[];
+    /**
+     * Get active agents count
+     */
+    getActiveCount(): number;
+    /**
+     * Check agent health
+     */
+    checkHealth(agentId: string): Promise<IAgent['health']>;
+}
+/**
+ * Agent registry for type definitions
+ */
+export interface IAgentRegistry {
+    /**
+     * Register an agent type with default config
+     */
+    register(type: string, defaultConfig: Partial<IAgentConfig>): void;
+    /**
+     * Unregister an agent type
+     */
+    unregister(type: string): boolean;
+    /**
+     * Get default config for a type
+     */
+    getDefaultConfig(type: string): Partial<IAgentConfig> | undefined;
+    /**
+     * Get all registered types
+     */
+    getRegisteredTypes(): string[];
+    /**
+     * Check if a type is registered
+     */
+    isRegistered(type: string): boolean;
+}
+//# sourceMappingURL=agent.interface.d.ts.map

package/v3/@claude-flow/shared/dist/core/interfaces/agent.interface.js

@@ -0,0 +1,6 @@
+/**
+ * V3 Agent Interfaces
+ * Domain-Driven Design - Agent Lifecycle Bounded Context
+ */
+export {};
+//# sourceMappingURL=agent.interface.js.map

package/v3/@claude-flow/shared/dist/core/interfaces/coordinator.interface.d.ts

@@ -0,0 +1,310 @@
+/**
+ * V3 Coordinator Interfaces
+ * Domain-Driven Design - Coordination Bounded Context
+ * Aligned with ADR-003 (Single Coordination Engine)
+ */
+import type { ITask, ITaskResult } from './task.interface.js';
+import type { IAgent, IAgentConfig } from './agent.interface.js';
+/**
+ * Swarm topology types
+ */
+export type SwarmTopology = 'hierarchical' | 'mesh' | 'ring' | 'star' | 'adaptive' | 'hierarchical-mesh';
+/**
+ * Coordination status
+ */
+export type CoordinationStatus = 'initializing' | 'ready' | 'coordinating' | 'degraded' | 'error' | 'shutdown';
+/**
+ * Swarm configuration
+ */
+export interface ISwarmConfig {
+    topology: SwarmTopology;
+    maxAgents: number;
+    autoScale?: {
+        enabled: boolean;
+        minAgents: number;
+        maxAgents: number;
+        scaleUpThreshold: number;
+        scaleDownThreshold: number;
+    };
+    coordination?: {
+        consensusRequired: boolean;
+        timeoutMs: number;
+        retryPolicy: {
+            maxRetries: number;
+            backoffMs: number;
+        };
+    };
+    communication?: {
+        protocol: 'events' | 'messages' | 'shared-memory';
+        batchSize: number;
+        flushIntervalMs: number;
+    };
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Swarm state
+ */
+export interface ISwarmState {
+    readonly id: string;
+    readonly topology: SwarmTopology;
+    readonly createdAt: Date;
+    status: CoordinationStatus;
+    agentCount: number;
+    taskCount: number;
+    metrics?: {
+        throughput: number;
+        latencyMs: number;
+        successRate: number;
+        resourceUtilization: number;
+    };
+}
+/**
+ * Coordinator interface - unified coordination engine
+ */
+export interface ICoordinator {
+    /**
+     * Initialize the coordinator
+     */
+    initialize(): Promise<void>;
+    /**
+     * Shutdown the coordinator
+     */
+    shutdown(): Promise<void>;
+    /**
+     * Initialize a swarm with configuration
+     */
+    initializeSwarm(config: ISwarmConfig): Promise<ISwarmState>;
+    /**
+     * Get swarm state
+     */
+    getSwarmState(): ISwarmState | undefined;
+    /**
+     * Assign a task to an agent
+     */
+    assignTask(task: ITask, agentId: string): Promise<void>;
+    /**
+     * Get tasks assigned to an agent
+     */
+    getAgentTasks(agentId: string): Promise<ITask[]>;
+    /**
+     * Get task count for an agent
+     */
+    getAgentTaskCount(agentId: string): Promise<number>;
+    /**
+     * Cancel a task
+     */
+    cancelTask(taskId: string): Promise<void>;
+    /**
+     * Report task completion
+     */
+    reportTaskComplete(taskId: string, result: ITaskResult): Promise<void>;
+    /**
+     * Get coordination health status
+     */
+    getHealthStatus(): Promise<{
+        healthy: boolean;
+        error?: string;
+        metrics?: Record<string, number>;
+    }>;
+    /**
+     * Perform maintenance tasks
+     */
+    performMaintenance(): Promise<void>;
+}
+/**
+ * Coordination manager interface - higher-level orchestration
+ */
+export interface ICoordinationManager extends ICoordinator {
+    /**
+     * Register an agent with the coordinator
+     */
+    registerAgent(agent: IAgent): Promise<void>;
+    /**
+     * Unregister an agent
+     */
+    unregisterAgent(agentId: string): Promise<void>;
+    /**
+     * Get all registered agents
+     */
+    getRegisteredAgents(): IAgent[];
+    /**
+     * Request agent consensus on a decision
+     */
+    requestConsensus(topic: string, options: unknown[], timeout?: number): Promise<unknown>;
+    /**
+     * Broadcast message to all agents
+     */
+    broadcast(message: unknown): Promise<void>;
+    /**
+     * Send message to specific agent
+     */
+    sendToAgent(agentId: string, message: unknown): Promise<void>;
+    /**
+     * Acquire a distributed lock
+     */
+    acquireLock(resourceId: string, agentId: string, timeout?: number): Promise<boolean>;
+    /**
+     * Release a distributed lock
+     */
+    releaseLock(resourceId: string, agentId: string): Promise<void>;
+    /**
+     * Check for deadlocks
+     */
+    detectDeadlocks(): Promise<{
+        detected: boolean;
+        agents?: string[];
+        resources?: string[];
+    }>;
+}
+/**
+ * Health status for components
+ */
+export interface IHealthStatus {
+    status: 'healthy' | 'degraded' | 'unhealthy';
+    components: Record<string, IComponentHealth>;
+    timestamp: Date;
+}
+/**
+ * Component health details
+ */
+export interface IComponentHealth {
+    name: string;
+    status: 'healthy' | 'degraded' | 'unhealthy';
+    lastCheck: Date;
+    error?: string;
+    metrics?: Record<string, number>;
+}
+/**
+ * Health monitor interface
+ */
+export interface IHealthMonitor {
+    /**
+     * Start health monitoring
+     */
+    start(): void;
+    /**
+     * Stop health monitoring
+     */
+    stop(): void;
+    /**
+     * Get current health status
+     */
+    getStatus(): Promise<IHealthStatus>;
+    /**
+     * Register a health check
+     */
+    registerCheck(name: string, check: () => Promise<{
+        healthy: boolean;
+        error?: string;
+        metrics?: Record<string, number>;
+    }>): void;
+    /**
+     * Unregister a health check
+     */
+    unregisterCheck(name: string): void;
+    /**
+     * Get health history
+     */
+    getHistory(limit?: number): IHealthStatus[];
+    /**
+     * Subscribe to health changes
+     */
+    onHealthChange(callback: (status: IHealthStatus) => void): () => void;
+}
+/**
+ * Metrics collector interface
+ */
+export interface IMetricsCollector {
+    /**
+     * Start metrics collection
+     */
+    start(): void;
+    /**
+     * Stop metrics collection
+     */
+    stop(): void;
+    /**
+     * Record a metric value
+     */
+    record(name: string, value: number, tags?: Record<string, string>): void;
+    /**
+     * Increment a counter
+     */
+    increment(name: string, value?: number, tags?: Record<string, string>): void;
+    /**
+     * Record a timing
+     */
+    timing(name: string, durationMs: number, tags?: Record<string, string>): void;
+    /**
+     * Get current metrics
+     */
+    getMetrics(): Record<string, {
+        value: number;
+        count: number;
+        avg: number;
+        min: number;
+        max: number;
+    }>;
+    /**
+     * Reset all metrics
+     */
+    reset(): void;
+}
+/**
+ * Orchestrator metrics structure
+ */
+export interface IOrchestratorMetrics {
+    uptime: number;
+    totalAgents: number;
+    activeAgents: number;
+    totalTasks: number;
+    completedTasks: number;
+    failedTasks: number;
+    queuedTasks: number;
+    avgTaskDuration: number;
+    memoryUsage: NodeJS.MemoryUsage;
+    cpuUsage: NodeJS.CpuUsage;
+    timestamp: Date;
+}
+/**
+ * Main orchestrator interface - facade for all orchestration capabilities
+ */
+export interface IOrchestrator {
+    /**
+     * Initialize the orchestrator
+     */
+    initialize(): Promise<void>;
+    /**
+     * Shutdown the orchestrator
+     */
+    shutdown(): Promise<void>;
+    /**
+     * Get health status
+     */
+    getHealthStatus(): Promise<IHealthStatus>;
+    /**
+     * Get orchestrator metrics
+     */
+    getMetrics(): Promise<IOrchestratorMetrics>;
+    /**
+     * Spawn a new agent
+     */
+    spawnAgent(config: IAgentConfig): Promise<IAgent>;
+    /**
+     * Terminate an agent
+     */
+    terminateAgent(agentId: string, reason?: string): Promise<void>;
+    /**
+     * Submit a task
+     */
+    submitTask(task: ITask): Promise<ITaskResult>;
+    /**
+     * Get task by ID
+     */
+    getTask(taskId: string): Promise<ITask | undefined>;
+    /**
+     * Cancel a task
+     */
+    cancelTask(taskId: string): Promise<void>;
+}
+//# sourceMappingURL=coordinator.interface.d.ts.map

package/v3/@claude-flow/shared/dist/core/interfaces/coordinator.interface.js

@@ -0,0 +1,7 @@
+/**
+ * V3 Coordinator Interfaces
+ * Domain-Driven Design - Coordination Bounded Context
+ * Aligned with ADR-003 (Single Coordination Engine)
+ */
+export {};
+//# sourceMappingURL=coordinator.interface.js.map