claude-flow 3.25.6 → 3.26.0

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

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

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

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

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

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

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