claude-flow 3.28.0 → 3.29.0

package/v3/@claude-flow/shared/dist/types/swarm.types.js

@@ -0,0 +1,65 @@
+/**
+ * V3 Swarm Types
+ * Modernized type system for swarm coordination
+ */
+/**
+ * Topology configuration presets
+ */
+export const TopologyPresets = {
+    hierarchical: {
+        topology: 'hierarchical',
+        coordination: {
+            consensusRequired: false,
+            timeoutMs: 5000,
+            retryPolicy: { maxRetries: 3, backoffMs: 1000 }
+        }
+    },
+    mesh: {
+        topology: 'mesh',
+        coordination: {
+            consensusRequired: true,
+            timeoutMs: 10000,
+            retryPolicy: { maxRetries: 5, backoffMs: 500 }
+        }
+    },
+    ring: {
+        topology: 'ring',
+        coordination: {
+            consensusRequired: true,
+            timeoutMs: 8000,
+            retryPolicy: { maxRetries: 4, backoffMs: 750 }
+        }
+    },
+    star: {
+        topology: 'star',
+        coordination: {
+            consensusRequired: false,
+            timeoutMs: 3000,
+            retryPolicy: { maxRetries: 2, backoffMs: 500 }
+        }
+    },
+    adaptive: {
+        topology: 'adaptive',
+        autoScale: {
+            enabled: true,
+            minAgents: 1,
+            maxAgents: 20,
+            scaleUpThreshold: 0.8,
+            scaleDownThreshold: 0.3
+        },
+        coordination: {
+            consensusRequired: true,
+            timeoutMs: 10000,
+            retryPolicy: { maxRetries: 5, backoffMs: 500 }
+        }
+    },
+    'hierarchical-mesh': {
+        topology: 'hierarchical-mesh',
+        coordination: {
+            consensusRequired: true,
+            timeoutMs: 8000,
+            retryPolicy: { maxRetries: 4, backoffMs: 750 }
+        }
+    }
+};
+//# sourceMappingURL=swarm.types.js.map

package/v3/@claude-flow/shared/dist/types/task.types.d.ts

@@ -0,0 +1,178 @@
+/**
+ * V3 Task Types
+ * Modernized type system with strict TypeScript
+ */
+import type { ITask, ITaskResult, TaskStatus, TaskPriority } from '../core/interfaces/task.interface.js';
+/**
+ * Task creation input
+ */
+export interface TaskInput {
+    type: string;
+    description: string;
+    priority?: number | TaskPriority;
+    timeout?: number;
+    assignedAgent?: string;
+    input?: Record<string, unknown>;
+    metadata?: TaskMetadata;
+}
+/**
+ * Task metadata for additional context
+ */
+export interface TaskMetadata {
+    requiredCapabilities?: string[];
+    retryCount?: number;
+    maxRetries?: number;
+    critical?: boolean;
+    parentTaskId?: string;
+    childTaskIds?: string[];
+    tags?: string[];
+    deadline?: Date;
+    estimatedDuration?: number;
+    source?: string;
+    [key: string]: unknown;
+}
+/**
+ * Task execution context
+ */
+export interface TaskExecutionContext {
+    task: ITask;
+    agentId: string;
+    startTime: Date;
+    timeout: number;
+    attempt: number;
+    maxAttempts: number;
+}
+/**
+ * Task execution result - extended
+ */
+export interface TaskExecutionResult extends ITaskResult {
+    context: TaskExecutionContext;
+    logs?: string[];
+    artifacts?: TaskArtifact[];
+}
+/**
+ * Task artifact - file or data produced by task
+ */
+export interface TaskArtifact {
+    id: string;
+    name: string;
+    type: 'file' | 'data' | 'log' | 'metric';
+    path?: string;
+    data?: unknown;
+    size?: number;
+    createdAt: Date;
+}
+/**
+ * Task queue configuration
+ */
+export interface TaskQueueConfig {
+    maxSize: number;
+    priorityLevels: number;
+    defaultTimeout: number;
+    batchSize: number;
+    processingInterval: number;
+}
+/**
+ * Task assignment strategy configuration
+ */
+export interface TaskAssignmentConfig {
+    strategy: 'round-robin' | 'least-loaded' | 'capability-match' | 'priority-based' | 'custom';
+    loadBalancing: boolean;
+    stickyAssignment: boolean;
+    capabilityWeight: number;
+    loadWeight: number;
+    priorityWeight: number;
+}
+/**
+ * Task retry policy
+ */
+export interface TaskRetryPolicy {
+    maxRetries: number;
+    backoffMs: number;
+    backoffMultiplier: number;
+    maxBackoffMs: number;
+    retryableErrors?: string[];
+    nonRetryableErrors?: string[];
+}
+/**
+ * Task filter for queries
+ */
+export interface TaskFilter {
+    status?: TaskStatus | TaskStatus[];
+    type?: string | string[];
+    assignedAgent?: string;
+    priority?: number | {
+        min?: number;
+        max?: number;
+    };
+    createdAfter?: Date;
+    createdBefore?: Date;
+    tags?: string[];
+    hasParent?: boolean;
+    parentTaskId?: string;
+}
+/**
+ * Task sort options
+ */
+export interface TaskSortOptions {
+    field: 'priority' | 'createdAt' | 'startedAt' | 'completedAt' | 'status';
+    direction: 'asc' | 'desc';
+}
+/**
+ * Task query options
+ */
+export interface TaskQueryOptions {
+    filter?: TaskFilter;
+    sort?: TaskSortOptions;
+    limit?: number;
+    offset?: number;
+}
+/**
+ * Task event payloads
+ */
+export interface TaskEventPayloads {
+    'task:created': {
+        task: ITask;
+    };
+    'task:assigned': {
+        taskId: string;
+        agentId: string;
+    };
+    'task:started': {
+        taskId: string;
+        agentId: string;
+        startTime: Date;
+    };
+    'task:completed': {
+        taskId: string;
+        result: ITaskResult;
+    };
+    'task:failed': {
+        taskId: string;
+        error: Error;
+        retryable: boolean;
+    };
+    'task:cancelled': {
+        taskId: string;
+        reason: string;
+    };
+    'task:timeout': {
+        taskId: string;
+        timeoutMs: number;
+    };
+    'task:retry': {
+        taskId: string;
+        attempt: number;
+        maxAttempts: number;
+        error: Error;
+    };
+}
+/**
+ * Priority value conversion
+ */
+export declare function priorityToNumber(priority: number | TaskPriority): number;
+/**
+ * Priority number to label
+ */
+export declare function numberToPriority(value: number): TaskPriority;
+//# sourceMappingURL=task.types.d.ts.map

package/v3/@claude-flow/shared/dist/types/task.types.js

@@ -0,0 +1,32 @@
+/**
+ * V3 Task Types
+ * Modernized type system with strict TypeScript
+ */
+/**
+ * Priority value conversion
+ */
+export function priorityToNumber(priority) {
+    if (typeof priority === 'number') {
+        return Math.max(0, Math.min(100, priority));
+    }
+    switch (priority) {
+        case 'critical': return 100;
+        case 'high': return 75;
+        case 'medium': return 50;
+        case 'low': return 25;
+        default: return 50;
+    }
+}
+/**
+ * Priority number to label
+ */
+export function numberToPriority(value) {
+    if (value >= 90)
+        return 'critical';
+    if (value >= 70)
+        return 'high';
+    if (value >= 40)
+        return 'medium';
+    return 'low';
+}
+//# sourceMappingURL=task.types.js.map

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

@@ -0,0 +1,197 @@
+/**
+ * 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

package/v3/@claude-flow/shared/dist/types.js

@@ -0,0 +1,21 @@
+/**
+ * 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 const V3_PERFORMANCE_TARGETS = {
+    flashAttention: { minSpeedup: 2.49, maxSpeedup: 7.47 },
+    agentDbSearch: { minSpeedup: 150, maxSpeedup: 12500 },
+    memoryReduction: { minPercent: 50, maxPercent: 75 },
+    codeReduction: { targetLines: 5000, currentLines: 15000 },
+    startupTime: { targetMs: 500 },
+    sonaLearning: { targetMs: 0.05 }
+};
+export function success(value) {
+    return { success: true, value };
+}
+export function failure(error) {
+    return { success: false, error };
+}
+//# sourceMappingURL=types.js.map

package/v3/@claude-flow/shared/dist/utils/secure-logger.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Secure Logger Utility
+ *
+ * Provides sanitized error logging that strips sensitive information
+ * before logging to prevent information disclosure.
+ *
+ * Security features:
+ * - Removes stack traces in production
+ * - Sanitizes file paths to prevent internal structure disclosure
+ * - Filters sensitive keys from error objects
+ * - Truncates long messages to prevent log injection
+ *
+ * @module @claude-flow/shared/utils/secure-logger
+ */
+interface LoggerConfig {
+    /** Environment mode */
+    environment: 'development' | 'production' | 'test';
+    /** Maximum message length */
+    maxMessageLength: number;
+    /** Whether to include stack traces */
+    includeStackTrace: boolean;
+    /** Sensitive keys to filter */
+    sensitiveKeys: string[];
+    /** Path patterns to sanitize */
+    pathPatterns: RegExp[];
+}
+export declare class SecureLogger {
+    private config;
+    private prefix;
+    constructor(prefix?: string, config?: Partial<LoggerConfig>);
+    /**
+     * Log an info message
+     */
+    info(message: string, data?: Record<string, unknown>): void;
+    /**
+     * Log a warning message
+     */
+    warn(message: string, data?: Record<string, unknown>): void;
+    /**
+     * Log an error (sanitized for security)
+     */
+    error(message: string, error?: unknown): void;
+    /**
+     * Log debug message (only in development)
+     */
+    debug(message: string, data?: Record<string, unknown>): void;
+    /**
+     * Create a child logger with a sub-prefix
+     */
+    child(subPrefix: string): SecureLogger;
+}
+/**
+ * Create a secure logger instance
+ */
+export declare function createSecureLogger(prefix?: string, config?: Partial<LoggerConfig>): SecureLogger;
+/**
+ * Default logger instance
+ */
+export declare const logger: SecureLogger;
+/**
+ * Sanitize an error for safe logging/display
+ */
+export declare function sanitizeErrorForLogging(error: unknown): Record<string, unknown>;
+/**
+ * Sanitize a message for safe logging/display
+ */
+export declare function sanitizeMessageForLogging(message: string): string;
+export default SecureLogger;
+//# sourceMappingURL=secure-logger.d.ts.map