moflo 4.8.19 → 4.8.20

package/src/@claude-flow/shared/dist/types/index.js

@@ -0,0 +1,17 @@
+/**
+ * V3 Types - Public API
+ * Modernized type system for claude-flow v3
+ */
+// Agent types
+export * from './agent.types.js';
+// Task types
+export * from './task.types.js';
+// Swarm types
+export * from './swarm.types.js';
+// Memory types
+export * from './memory.types.js';
+// MCP types
+export * from './mcp.types.js';
+// Re-export core interfaces for convenience
+export * from '../core/interfaces/index.js';
+//# sourceMappingURL=index.js.map

package/src/@claude-flow/shared/dist/types/mcp.types.d.ts

@@ -0,0 +1,266 @@
+/**
+ * V3 MCP Types
+ * Model Context Protocol type definitions
+ * Aligned with ADR-005 (MCP-first API design)
+ */
+/**
+ * MCP tool definition
+ */
+export interface MCPTool {
+    name: string;
+    description: string;
+    inputSchema: MCPInputSchema;
+    handler: MCPToolHandler;
+}
+/**
+ * MCP input schema (JSON Schema)
+ */
+export interface MCPInputSchema {
+    type: 'object';
+    properties: Record<string, MCPPropertySchema>;
+    required?: string[];
+    additionalProperties?: boolean;
+}
+/**
+ * MCP property schema
+ */
+export interface MCPPropertySchema {
+    type: 'string' | 'number' | 'boolean' | 'array' | 'object';
+    description?: string;
+    enum?: unknown[];
+    default?: unknown;
+    items?: MCPPropertySchema;
+    properties?: Record<string, MCPPropertySchema>;
+    required?: string[];
+}
+/**
+ * MCP tool handler
+ */
+export type MCPToolHandler = (params: Record<string, unknown>) => Promise<MCPToolResult>;
+/**
+ * MCP tool result
+ */
+export interface MCPToolResult {
+    content: MCPContent[];
+    isError?: boolean;
+}
+/**
+ * MCP content types
+ */
+export type MCPContent = MCPTextContent | MCPImageContent | MCPResourceContent;
+/**
+ * MCP text content
+ */
+export interface MCPTextContent {
+    type: 'text';
+    text: string;
+}
+/**
+ * MCP image content
+ */
+export interface MCPImageContent {
+    type: 'image';
+    data: string;
+    mimeType: string;
+}
+/**
+ * MCP resource content
+ */
+export interface MCPResourceContent {
+    type: 'resource';
+    resource: {
+        uri: string;
+        mimeType?: string;
+        text?: string;
+        blob?: string;
+    };
+}
+/**
+ * MCP server configuration
+ */
+export interface MCPServerConfig {
+    name: string;
+    version: string;
+    transport: MCPTransportConfig;
+    tools?: MCPTool[];
+    resources?: MCPResource[];
+    prompts?: MCPPrompt[];
+    capabilities?: MCPCapabilities;
+}
+/**
+ * MCP transport configuration
+ */
+export interface MCPTransportConfig {
+    type: 'stdio' | 'http' | 'websocket';
+    port?: number;
+    host?: string;
+    path?: string;
+}
+/**
+ * MCP resource definition
+ */
+export interface MCPResource {
+    uri: string;
+    name: string;
+    description?: string;
+    mimeType?: string;
+    handler: () => Promise<MCPResourceContent['resource']>;
+}
+/**
+ * MCP prompt definition
+ */
+export interface MCPPrompt {
+    name: string;
+    description?: string;
+    arguments?: MCPPromptArgument[];
+    handler: (args: Record<string, string>) => Promise<MCPPromptResult>;
+}
+/**
+ * MCP prompt argument
+ */
+export interface MCPPromptArgument {
+    name: string;
+    description?: string;
+    required?: boolean;
+}
+/**
+ * MCP prompt result
+ */
+export interface MCPPromptResult {
+    messages: MCPPromptMessage[];
+}
+/**
+ * MCP prompt message
+ */
+export interface MCPPromptMessage {
+    role: 'user' | 'assistant';
+    content: MCPContent;
+}
+/**
+ * MCP capabilities
+ */
+export interface MCPCapabilities {
+    tools?: boolean;
+    resources?: boolean;
+    prompts?: boolean;
+    logging?: boolean;
+    experimental?: Record<string, boolean>;
+}
+/**
+ * MCP request types
+ */
+export type MCPRequest = MCPInitializeRequest | MCPToolCallRequest | MCPResourceReadRequest | MCPPromptGetRequest | MCPListRequest;
+/**
+ * MCP initialize request
+ */
+export interface MCPInitializeRequest {
+    method: 'initialize';
+    params: {
+        protocolVersion: string;
+        capabilities: MCPCapabilities;
+        clientInfo: {
+            name: string;
+            version: string;
+        };
+    };
+}
+/**
+ * MCP tool call request
+ */
+export interface MCPToolCallRequest {
+    method: 'tools/call';
+    params: {
+        name: string;
+        arguments: Record<string, unknown>;
+    };
+}
+/**
+ * MCP resource read request
+ */
+export interface MCPResourceReadRequest {
+    method: 'resources/read';
+    params: {
+        uri: string;
+    };
+}
+/**
+ * MCP prompt get request
+ */
+export interface MCPPromptGetRequest {
+    method: 'prompts/get';
+    params: {
+        name: string;
+        arguments?: Record<string, string>;
+    };
+}
+/**
+ * MCP list request
+ */
+export interface MCPListRequest {
+    method: 'tools/list' | 'resources/list' | 'prompts/list';
+    params?: Record<string, unknown>;
+}
+/**
+ * MCP response types
+ */
+export interface MCPResponse<T = unknown> {
+    id: string | number;
+    result?: T;
+    error?: MCPError;
+}
+/**
+ * MCP error
+ */
+export interface MCPError {
+    code: number;
+    message: string;
+    data?: unknown;
+}
+/**
+ * MCP event payloads
+ */
+export interface MCPEventPayloads {
+    'mcp:initialized': {
+        serverName: string;
+        version: string;
+        capabilities: MCPCapabilities;
+    };
+    'mcp:tool:called': {
+        toolName: string;
+        arguments: Record<string, unknown>;
+        duration: number;
+        success: boolean;
+    };
+    'mcp:resource:read': {
+        uri: string;
+        mimeType?: string;
+        size: number;
+    };
+    'mcp:prompt:executed': {
+        promptName: string;
+        arguments: Record<string, string>;
+        messageCount: number;
+    };
+    'mcp:error': {
+        error: MCPError;
+        request?: MCPRequest;
+    };
+    'mcp:shutdown': {
+        reason: string;
+    };
+}
+/**
+ * MCP server status
+ */
+export interface MCPServerStatus {
+    running: boolean;
+    transport: MCPTransportConfig['type'];
+    connectedClients: number;
+    toolsRegistered: number;
+    resourcesRegistered: number;
+    promptsRegistered: number;
+    requestsHandled: number;
+    errorsCount: number;
+    uptime: number;
+}
+//# sourceMappingURL=mcp.types.d.ts.map

package/src/@claude-flow/shared/dist/types/mcp.types.js

@@ -0,0 +1,7 @@
+/**
+ * V3 MCP Types
+ * Model Context Protocol type definitions
+ * Aligned with ADR-005 (MCP-first API design)
+ */
+export {};
+//# sourceMappingURL=mcp.types.js.map

package/src/@claude-flow/shared/dist/types/memory.types.d.ts

@@ -0,0 +1,236 @@
+/**
+ * V3 Memory Types
+ * Modernized type system for memory management
+ * Aligned with AgentDB integration (ADR-006, ADR-009)
+ */
+import type { IMemoryEntry, MemoryType, IVectorSearchParams } from '../core/interfaces/memory.interface.js';
+/**
+ * Memory backend type
+ */
+export type MemoryBackendType = 'sqlite' | 'agentdb' | 'hybrid' | 'redis' | 'memory';
+/**
+ * Memory backend configuration
+ */
+export interface MemoryBackendConfig {
+    type: MemoryBackendType;
+    path?: string;
+    maxSize?: number;
+    ttlMs?: number;
+    sqlite?: {
+        filename?: string;
+        inMemory?: boolean;
+        wal?: boolean;
+    };
+    agentdb?: {
+        dimensions?: number;
+        indexType?: 'hnsw' | 'flat' | 'ivf';
+        efConstruction?: number;
+        m?: number;
+        quantization?: 'none' | 'scalar' | 'product';
+    };
+    redis?: {
+        host?: string;
+        port?: number;
+        password?: string;
+        db?: number;
+        keyPrefix?: string;
+    };
+    hybrid?: {
+        sqliteConfig?: MemoryBackendConfig['sqlite'];
+        agentdbConfig?: MemoryBackendConfig['agentdb'];
+        vectorThreshold?: number;
+    };
+}
+/**
+ * Memory store options
+ */
+export interface MemoryStoreOptions {
+    ttlMs?: number;
+    type?: MemoryType;
+    tags?: string[];
+    embedding?: number[];
+    overwrite?: boolean;
+}
+/**
+ * Memory retrieve options
+ */
+export interface MemoryRetrieveOptions {
+    includeExpired?: boolean;
+    updateAccessTime?: boolean;
+}
+/**
+ * Memory list options
+ */
+export interface MemoryListOptions {
+    type?: MemoryType;
+    tags?: string[];
+    limit?: number;
+    offset?: number;
+    sortBy?: 'createdAt' | 'updatedAt' | 'key';
+    sortOrder?: 'asc' | 'desc';
+}
+/**
+ * Memory search options (for vector search)
+ */
+export interface MemorySearchOptions extends IVectorSearchParams {
+    includeMetadata?: boolean;
+    rerank?: boolean;
+    rerankModel?: string;
+}
+/**
+ * Memory batch operation
+ */
+export interface MemoryBatchOperation {
+    operation: 'store' | 'update' | 'delete';
+    key: string;
+    value?: unknown;
+    options?: MemoryStoreOptions;
+}
+/**
+ * Memory batch result
+ */
+export interface MemoryBatchResult {
+    successful: string[];
+    failed: Array<{
+        key: string;
+        error: Error;
+    }>;
+    duration: number;
+}
+/**
+ * Memory statistics
+ */
+export interface MemoryStats {
+    totalEntries: number;
+    totalSizeBytes: number;
+    memoryUsageMb: number;
+    entriesByType: Record<MemoryType, number>;
+    oldestEntry?: Date;
+    newestEntry?: Date;
+    avgEntrySize: number;
+    cacheHitRate?: number;
+    vectorCount?: number;
+    indexSize?: number;
+}
+/**
+ * Memory bank statistics
+ */
+export interface MemoryBankStats {
+    bankId: string;
+    agentId: string;
+    entryCount: number;
+    sizeMb: number;
+    createdAt: Date;
+    lastAccess: Date;
+}
+/**
+ * Pattern for ReasoningBank integration
+ */
+export interface LearnedPattern {
+    id: string;
+    sessionId: string;
+    task: string;
+    input: string;
+    output: string;
+    reward: number;
+    success: boolean;
+    critique?: string;
+    tokensUsed?: number;
+    latencyMs?: number;
+    createdAt: Date;
+    embedding?: number[];
+}
+/**
+ * Pattern search result
+ */
+export interface PatternSearchResult {
+    pattern: LearnedPattern;
+    score: number;
+    relevance: number;
+}
+/**
+ * Memory event payloads
+ */
+export interface MemoryEventPayloads {
+    'memory:stored': {
+        entry: IMemoryEntry;
+        isNew: boolean;
+    };
+    'memory:retrieved': {
+        key: string;
+        found: boolean;
+        latencyMs: number;
+    };
+    'memory:updated': {
+        entry: IMemoryEntry;
+        previousValue: unknown;
+    };
+    'memory:deleted': {
+        key: string;
+        entry: IMemoryEntry;
+    };
+    'memory:cleared': {
+        entriesRemoved: number;
+    };
+    'memory:pruned': {
+        entriesRemoved: number;
+        durationMs: number;
+    };
+    'memory:search:completed': {
+        query: IVectorSearchParams;
+        resultCount: number;
+        latencyMs: number;
+    };
+    'memory:bank:created': {
+        bankId: string;
+        agentId: string;
+    };
+    'memory:bank:closed': {
+        bankId: string;
+        agentId: string;
+        entriesCount: number;
+    };
+}
+/**
+ * Cache configuration
+ */
+export interface CacheConfig {
+    enabled: boolean;
+    maxSize: number;
+    ttlMs: number;
+    strategy: 'lru' | 'lfu' | 'fifo';
+    warmupKeys?: string[];
+}
+/**
+ * Vector index configuration
+ */
+export interface VectorIndexConfig {
+    type: 'hnsw' | 'flat' | 'ivf';
+    dimensions: number;
+    metric: 'cosine' | 'euclidean' | 'dot';
+    hnsw?: {
+        m: number;
+        efConstruction: number;
+        efSearch: number;
+    };
+    ivf?: {
+        nlist: number;
+        nprobe: number;
+    };
+    quantization?: {
+        enabled: boolean;
+        bits: 4 | 8 | 16;
+        type: 'scalar' | 'product';
+    };
+}
+/**
+ * Flash Attention configuration (2.49x-7.47x speedup)
+ */
+export interface FlashAttentionConfig {
+    enabled: boolean;
+    blockSize: number;
+    headDim: number;
+    causal: boolean;
+    softmaxScale?: number;
+}
+//# sourceMappingURL=memory.types.d.ts.map

package/src/@claude-flow/shared/dist/types/memory.types.js

@@ -0,0 +1,7 @@
+/**
+ * V3 Memory Types
+ * Modernized type system for memory management
+ * Aligned with AgentDB integration (ADR-006, ADR-009)
+ */
+export {};
+//# sourceMappingURL=memory.types.js.map

package/src/@claude-flow/shared/dist/types/swarm.types.d.ts

@@ -0,0 +1,186 @@
+/**
+ * V3 Swarm Types
+ * Modernized type system for swarm coordination
+ */
+import type { ISwarmConfig, ISwarmState, SwarmTopology, CoordinationStatus } from '../core/interfaces/coordinator.interface.js';
+import type { IAgent } from '../core/interfaces/agent.interface.js';
+/**
+ * Swarm initialization options
+ */
+export interface SwarmInitOptions extends ISwarmConfig {
+    name?: string;
+    description?: string;
+    initialAgents?: string[];
+    warmup?: boolean;
+    warmupTasks?: number;
+}
+/**
+ * Swarm initialization result
+ */
+export interface SwarmInitResult {
+    state: ISwarmState;
+    agents: IAgent[];
+    startupTime: number;
+    ready: boolean;
+}
+/**
+ * Swarm scaling options
+ */
+export interface SwarmScaleOptions {
+    targetSize: number;
+    agentType?: string;
+    timeout?: number;
+    graceful?: boolean;
+}
+/**
+ * Swarm scaling result
+ */
+export interface SwarmScaleResult {
+    previousSize: number;
+    currentSize: number;
+    agentsAdded: string[];
+    agentsRemoved: string[];
+    duration: number;
+    success: boolean;
+}
+/**
+ * Swarm coordination message
+ */
+export interface SwarmMessage<T = unknown> {
+    id: string;
+    type: string;
+    source: string;
+    target?: string | 'broadcast';
+    payload: T;
+    timestamp: Date;
+    correlationId?: string;
+    replyTo?: string;
+    ttl?: number;
+}
+/**
+ * Swarm consensus request
+ */
+export interface ConsensusRequest<T = unknown> {
+    topic: string;
+    options: T[];
+    requiredVotes: number | 'majority' | 'all';
+    timeout: number;
+    voters?: string[];
+}
+/**
+ * Swarm consensus response
+ */
+export interface ConsensusResponse<T = unknown> {
+    topic: string;
+    decision: T | null;
+    votes: Map<string, T>;
+    consensus: boolean;
+    votingDuration: number;
+    participatingAgents: string[];
+}
+/**
+ * Distributed lock state
+ */
+export interface DistributedLock {
+    resourceId: string;
+    holderId: string;
+    acquiredAt: Date;
+    expiresAt: Date;
+    renewCount: number;
+}
+/**
+ * Lock acquisition result
+ */
+export interface LockAcquisitionResult {
+    acquired: boolean;
+    lock?: DistributedLock;
+    waitTime?: number;
+    error?: Error;
+}
+/**
+ * Deadlock detection result
+ */
+export interface DeadlockDetectionResult {
+    detected: boolean;
+    agents: string[];
+    resources: string[];
+    cycle?: string[][];
+    suggestedResolution?: string;
+}
+/**
+ * Swarm metrics
+ */
+export interface SwarmMetrics {
+    topology: SwarmTopology;
+    status: CoordinationStatus;
+    agentCount: number;
+    activeAgentCount: number;
+    taskCount: number;
+    completedTasks: number;
+    failedTasks: number;
+    throughput: number;
+    avgLatencyMs: number;
+    p95LatencyMs: number;
+    p99LatencyMs: number;
+    successRate: number;
+    resourceUtilization: number;
+    messagesSent: number;
+    messagesReceived: number;
+    consensusRounds: number;
+    locksAcquired: number;
+    deadlocksDetected: number;
+    uptime: number;
+    timestamp: Date;
+}
+/**
+ * Swarm event payloads
+ */
+export interface SwarmEventPayloads {
+    'swarm:initialized': {
+        state: ISwarmState;
+        config: ISwarmConfig;
+    };
+    'swarm:scaled': {
+        result: SwarmScaleResult;
+    };
+    'swarm:topology:changed': {
+        previousTopology: SwarmTopology;
+        currentTopology: SwarmTopology;
+    };
+    'swarm:status:changed': {
+        previousStatus: CoordinationStatus;
+        currentStatus: CoordinationStatus;
+    };
+    'swarm:message:sent': {
+        message: SwarmMessage;
+    };
+    'swarm:message:received': {
+        message: SwarmMessage;
+    };
+    'swarm:consensus:started': {
+        request: ConsensusRequest;
+    };
+    'swarm:consensus:completed': {
+        response: ConsensusResponse;
+    };
+    'swarm:lock:acquired': {
+        lock: DistributedLock;
+    };
+    'swarm:lock:released': {
+        resourceId: string;
+        holderId: string;
+        duration: number;
+    };
+    'swarm:deadlock:detected': {
+        result: DeadlockDetectionResult;
+    };
+    'swarm:shutdown': {
+        reason: string;
+        graceful: boolean;
+    };
+}
+/**
+ * Topology configuration presets
+ */
+export declare const TopologyPresets: Record<SwarmTopology, Partial<ISwarmConfig>>;
+//# sourceMappingURL=swarm.types.d.ts.map