claude-flow-novice 2.0.4 → 2.0.5

package/dist/src/swarm/strategies/strategy-metrics-patch.js

@@ -1,2 +0,0 @@
-// Patch for StrategyMetrics interface
-export { };

package/dist/src/swarm/types.js

@@ -1,52 +0,0 @@
-/**
- * Comprehensive types and interfaces for the swarm system
- */ // ===== TYPE GUARDS =====
-export function isAgentId(obj) {
-    return obj && typeof obj.id === 'string' && typeof obj.swarmId === 'string';
-}
-export function isTaskId(obj) {
-    return obj && typeof obj.id === 'string' && typeof obj.swarmId === 'string';
-}
-export function isSwarmEvent(obj) {
-    return obj && typeof obj.id === 'string' && typeof obj.type === 'string';
-}
-export function isTaskDefinition(obj) {
-    return obj && isTaskId(obj.id) && typeof obj.type === 'string';
-}
-export function isAgentState(obj) {
-    return obj && isAgentId(obj.id) && typeof obj.status === 'string';
-}
-// ===== CONSTANTS =====
-export const SWARM_CONSTANTS = {
-    // Timeouts
-    DEFAULT_TASK_TIMEOUT: 5 * 60 * 1000,
-    DEFAULT_AGENT_TIMEOUT: 30 * 1000,
-    DEFAULT_HEARTBEAT_INTERVAL: 10 * 1000,
-    // Limits
-    MAX_AGENTS_PER_SWARM: 100,
-    MAX_TASKS_PER_AGENT: 10,
-    MAX_RETRIES: 3,
-    // Quality thresholds
-    MIN_QUALITY_THRESHOLD: 0.7,
-    DEFAULT_QUALITY_THRESHOLD: 0.8,
-    HIGH_QUALITY_THRESHOLD: 0.9,
-    // Performance targets
-    DEFAULT_THROUGHPUT_TARGET: 10,
-    DEFAULT_LATENCY_TARGET: 1000,
-    DEFAULT_RELIABILITY_TARGET: 0.95,
-    // Resource limits
-    DEFAULT_MEMORY_LIMIT: 512 * 1024 * 1024,
-    DEFAULT_CPU_LIMIT: 1.0,
-    DEFAULT_DISK_LIMIT: 1024 * 1024 * 1024
-};
-// ===== EXPORTS =====
-export default {
-    // Type exports are handled by TypeScript
-    SWARM_CONSTANTS,
-    // Utility functions
-    isAgentId,
-    isTaskId,
-    isSwarmEvent,
-    isTaskDefinition,
-    isAgentState
-};

package/dist/src/swarm/workers/copy-worker.js

@@ -1,56 +0,0 @@
-import { parentPort, workerData } from "worker_threads";
-import * as fs from "node:fs/promises";
-import * as path from "path";
-import { createHash } from "crypto";
-async function copyFile(file) {
-    try {
-        // Ensure destination directory exists
-        const destDir = path.dirname(file.destPath);
-        await fs.mkdir(destDir, {
-            recursive: true
-        });
-        // Copy the file
-        await fs.copyFile(file.sourcePath, file.destPath);
-        // Preserve permissions if requested
-        if (file.permissions) {
-            await fs.chmod(file.destPath, file.permissions);
-        }
-        let hash;
-        // Calculate hash if verification is requested
-        if (file.verify) {
-            const content = await fs.readFile(file.destPath);
-            hash = createHash('sha256').update(content).digest('hex');
-        }
-        return {
-            success: true,
-            file: file.sourcePath,
-            hash
-        };
-    } catch (error) {
-        return {
-            success: false,
-            file: file.sourcePath,
-            error: error instanceof Error ? error.message : String(error)
-        };
-    }
-}
-async function main() {
-    const data = workerData;
-    if (!parentPort) {
-        throw new Error('This script must be run as a worker thread');
-    }
-    for (const file of data.files){
-        const result = await copyFile(file);
-        parentPort.postMessage(result);
-    }
-}
-// Run the worker
-main().catch((error)=>{
-    if (parentPort) {
-        parentPort.postMessage({
-            success: false,
-            file: 'worker',
-            error: error instanceof Error ? error.message : String(error)
-        });
-    }
-});

package/dist/src/validators/epic-config-schema.js

@@ -1,214 +0,0 @@
-import Ajv from "ajv";
-import addFormats from "ajv-formats";
-const ajv = new Ajv({
-    allErrors: true,
-    strict: false
-});
-addFormats(ajv);
-// JSON schema for sprint configuration
-const sprintSchema = {
-    type: 'object',
-    required: [
-        'sprintId',
-        'name',
-        'description',
-        'taskType'
-    ],
-    properties: {
-        sprintId: {
-            type: 'string',
-            pattern: '^[a-zA-Z0-9\\-_]{1,50}$',
-            minLength: 1,
-            maxLength: 50
-        },
-        name: {
-            type: 'string',
-            minLength: 1,
-            maxLength: 200
-        },
-        description: {
-            type: 'string',
-            minLength: 1,
-            maxLength: 5000
-        },
-        taskType: {
-            type: 'string',
-            enum: [
-                'implementation',
-                'testing',
-                'documentation',
-                'refactoring',
-                'security',
-                'performance',
-                'research',
-                'deployment'
-            ]
-        },
-        maxIterations: {
-            type: 'integer',
-            minimum: 1,
-            maximum: 100,
-            nullable: true
-        },
-        dependencies: {
-            type: 'array',
-            items: {
-                type: 'string',
-                pattern: '^[a-zA-Z0-9\\-_]{1,50}$'
-            },
-            maxItems: 20,
-            nullable: true
-        }
-    },
-    additionalProperties: false
-};
-// JSON schema for phase configuration
-const phaseSchema = {
-    type: 'object',
-    required: [
-        'phaseId',
-        'name',
-        'file'
-    ],
-    properties: {
-        phaseId: {
-            type: 'string',
-            pattern: '^[a-zA-Z0-9\\-_]{1,50}$',
-            minLength: 1,
-            maxLength: 50
-        },
-        name: {
-            type: 'string',
-            minLength: 1,
-            maxLength: 200
-        },
-        file: {
-            type: 'string',
-            minLength: 1,
-            maxLength: 500,
-            pattern: '^[^<>:"|?*\\x00-\\x1F]+$'
-        },
-        description: {
-            type: 'string',
-            minLength: 1,
-            maxLength: 5000,
-            nullable: true
-        },
-        sprints: {
-            type: 'array',
-            items: sprintSchema,
-            maxItems: 100,
-            nullable: true
-        },
-        dependencies: {
-            type: 'array',
-            items: {
-                type: 'string',
-                pattern: '^[a-zA-Z0-9\\-_]{1,50}$'
-            },
-            maxItems: 20,
-            nullable: true
-        }
-    },
-    additionalProperties: false
-};
-// JSON schema for epic configuration
-export const epicConfigSchema = {
-    type: 'object',
-    required: [
-        'epicId',
-        'name',
-        'phases'
-    ],
-    properties: {
-        epicId: {
-            type: 'string',
-            pattern: '^[a-zA-Z0-9\\-_]{1,50}$',
-            minLength: 1,
-            maxLength: 50
-        },
-        name: {
-            type: 'string',
-            minLength: 1,
-            maxLength: 200
-        },
-        description: {
-            type: 'string',
-            minLength: 1,
-            maxLength: 10000,
-            nullable: true
-        },
-        phases: {
-            type: 'array',
-            items: phaseSchema,
-            minItems: 1,
-            maxItems: 50
-        },
-        metadata: {
-            type: 'object',
-            properties: {
-                createdAt: {
-                    type: 'string',
-                    format: 'date-time',
-                    nullable: true
-                },
-                author: {
-                    type: 'string',
-                    maxLength: 100,
-                    nullable: true
-                },
-                version: {
-                    type: 'string',
-                    pattern: '^\\d+\\.\\d+\\.\\d+$',
-                    nullable: true
-                }
-            },
-            nullable: true,
-            additionalProperties: false
-        }
-    },
-    additionalProperties: false
-};
-// Compiled validators
-export const validateEpicConfig = ajv.compile(epicConfigSchema);
-export const validatePhaseConfig = ajv.compile(phaseSchema);
-export const validateSprintConfig = ajv.compile(sprintSchema);
-/**
- * Validates epic configuration with detailed error reporting
- * @throws Error with validation details if invalid
- */ export function validateAndThrow(config, validator) {
-    if (!validator(config)) {
-        const errors = validator.errors?.map((err)=>{
-            const path = err.instancePath || 'root';
-            return `  - ${path}: ${err.message}`;
-        }).join('\n');
-        throw new Error(`Invalid configuration:\n${errors}\n\n` + `This helps prevent:\n` + `  - CVE-2025-005: Malformed JSON injection\n` + `  - Prototype pollution attacks\n` + `  - Path traversal vulnerabilities`);
-    }
-}
-/**
- * Sanitize object keys to prevent prototype pollution
- */ export function sanitizeObjectKeys(obj) {
-    if (obj === null || typeof obj !== 'object') {
-        return obj;
-    }
-    if (Array.isArray(obj)) {
-        return obj.map(sanitizeObjectKeys);
-    }
-    const sanitized = {};
-    const dangerousKeys = [
-        '__proto__',
-        'constructor',
-        'prototype'
-    ];
-    for (const key of Object.keys(obj)){
-        // Skip dangerous keys
-        if (dangerousKeys.includes(key)) {
-            console.warn(`[SECURITY] Blocked dangerous key: ${key}`);
-            continue;
-        }
-        sanitized[key] = sanitizeObjectKeys(obj[key]);
-    }
-    // Explicitly set __proto__ to null to prevent prototype pollution
-    Object.setPrototypeOf(sanitized, null);
-    return sanitized;
-}

package/dist/src/validators/index.js

@@ -1,10 +0,0 @@
-/**
- * Validators Module
- *
- * Provides validation functionality for enforcing best practices and detecting anti-patterns.
- *
- * @module validators
- */ // TodoWrite Batching Validator
-export { TodoWriteValidator, getGlobalValidator, resetGlobalValidator } from "./todowrite-batching-validator";
-// TodoWrite Integration
-export { isValidationEnabled, getIntegrationConfig, validateTodoWrite, parseValidationFlags, displayValidationHelp, todoWriteWithValidation, createValidationMiddleware, getValidationStatus } from "./todowrite-integration";

package/dist/src/validators/swarm-init-validator.js

@@ -1,259 +0,0 @@
-/**
- * Swarm Initialization Validator
- *
- * Validates that swarm initialization is performed before spawning multiple agents.
- * Ensures proper coordination and prevents inconsistent implementations across agents.
- *
- * @module validators/swarm-init-validator
- */ import { Logger } from "../core/logger.js";
-const DEFAULT_CONFIG = {
-    requireSwarmForMultiAgent: true,
-    minAgentsRequiringSwarm: 2,
-    meshTopologyMaxAgents: 7,
-    hierarchicalTopologyMinAgents: 8
-};
-/**
- * Validates swarm initialization before agent spawning
- *
- * @param agentCount - Number of agents to spawn
- * @param swarmStatus - Current swarm status (optional, will check environment if not provided)
- * @param config - Validator configuration
- * @returns Validation result with error messages and suggestions
- *
- * @example
- * ```typescript
- * const result = await validateSwarmInit(3);
- * if (!result.valid) {
- *   console.error(result.error);
- *   console.log(result.suggestion);
- * }
- * ```
- */ export async function validateSwarmInit(agentCount, swarmStatus, config = {}) {
-    const logger = new Logger('SwarmInitValidator');
-    const cfg = {
-        ...DEFAULT_CONFIG,
-        ...config
-    };
-    // Single agent spawning doesn't require swarm
-    if (agentCount < cfg.minAgentsRequiringSwarm) {
-        return {
-            valid: true
-        };
-    }
-    // Check if swarm is required for this agent count
-    if (!cfg.requireSwarmForMultiAgent) {
-        logger.warn('Swarm validation is disabled in configuration');
-        return {
-            valid: true
-        };
-    }
-    // Get swarm status
-    const status = swarmStatus || await getSwarmStatus();
-    // Validate swarm is initialized
-    if (!status.initialized) {
-        const topology = agentCount <= cfg.meshTopologyMaxAgents ? 'mesh' : 'hierarchical';
-        return {
-            valid: false,
-            error: createErrorMessage(agentCount),
-            suggestion: createSuggestion(agentCount, topology),
-            topology,
-            maxAgents: agentCount
-        };
-    }
-    // Validate topology matches agent count
-    const topologyValidation = validateTopology(agentCount, status, cfg);
-    if (!topologyValidation.valid) {
-        return topologyValidation;
-    }
-    // Validate max agents capacity
-    if (status.maxAgents && agentCount > status.maxAgents) {
-        return {
-            valid: false,
-            error: `Cannot spawn ${agentCount} agents. Swarm configured for maximum ${status.maxAgents} agents.`,
-            suggestion: `Reinitialize swarm with increased maxAgents:\n  npx claude-flow-novice swarm init --topology ${status.topology} --max-agents ${agentCount}`
-        };
-    }
-    logger.info(`Swarm validation passed for ${agentCount} agents`);
-    return {
-        valid: true
-    };
-}
-/**
- * Validates that topology matches agent count requirements
- */ function validateTopology(agentCount, status, config) {
-    const expectedTopology = agentCount <= config.meshTopologyMaxAgents ? 'mesh' : 'hierarchical';
-    if (status.topology && status.topology !== expectedTopology) {
-        return {
-            valid: false,
-            error: `Topology mismatch: ${agentCount} agents require '${expectedTopology}' topology, but swarm is using '${status.topology}'.`,
-            suggestion: `Reinitialize swarm with correct topology:\n  npx claude-flow-novice swarm init --topology ${expectedTopology} --max-agents ${agentCount}`,
-            topology: expectedTopology,
-            maxAgents: agentCount
-        };
-    }
-    return {
-        valid: true
-    };
-}
-/**
- * Creates error message for missing swarm initialization
- */ function createErrorMessage(agentCount) {
-    return `
-❌ SWARM INITIALIZATION REQUIRED
-
-You are attempting to spawn ${agentCount} agents without initializing swarm.
-
-Without swarm coordination:
-  • Agents work independently with no shared context
-  • Results may be inconsistent (e.g., 3 different JWT secret solutions)
-  • No consensus validation or Byzantine fault tolerance
-  • Memory coordination is disabled
-
-This violates the mandatory coordination requirements in CLAUDE.md.
-`.trim();
-}
-/**
- * Creates suggestion message with fix command
- */ function createSuggestion(agentCount, topology) {
-    return `
-Fix:
-1. Initialize swarm first:
-   npx claude-flow-novice swarm init --topology ${topology} --max-agents ${agentCount}
-
-2. Then spawn agents:
-   [Your agent spawning command]
-
-Topology Selection:
-  • mesh: 2-7 agents (peer-to-peer coordination)
-  • hierarchical: 8+ agents (coordinator-led structure)
-
-See CLAUDE.md section "Swarm Initialization" for coordination requirements.
-`.trim();
-}
-/**
- * Gets current swarm status from environment or MCP server
- */ async function getSwarmStatus() {
-    const logger = new Logger('SwarmInitValidator');
-    // Check environment variables
-    const swarmId = process.env['CLAUDE_SWARM_ID'];
-    if (!swarmId) {
-        return {
-            initialized: false
-        };
-    }
-    // Try to get status from MCP server via swarm coordinator
-    try {
-        // Import dynamically to avoid circular dependencies
-        const { getSwarmCoordinator } = await import("../coordination/swarm-coordinator-factory.js").catch(()=>({
-                getSwarmCoordinator: null
-            }));
-        if (getSwarmCoordinator) {
-            const coordinator = getSwarmCoordinator();
-            if (coordinator) {
-                const status = coordinator.getSwarmStatus();
-                return {
-                    initialized: true,
-                    swarmId,
-                    activeAgents: status.agents.total,
-                    maxAgents: status.agents.total
-                };
-            }
-        }
-    } catch (error) {
-        logger.debug('Could not get swarm status from coordinator', error);
-    }
-    // If we have a swarm ID but can't get details, assume initialized
-    return {
-        initialized: true,
-        swarmId
-    };
-}
-/**
- * Validates swarm initialization and throws error if invalid
- *
- * This is a convenience wrapper for validateSwarmInit that throws on validation failure.
- * Use this in CLI commands where you want to halt execution on validation errors.
- *
- * @param agentCount - Number of agents to spawn
- * @param swarmStatus - Current swarm status (optional)
- * @param config - Validator configuration
- * @throws Error if validation fails
- *
- * @example
- * ```typescript
- * try {
- *   await requireSwarmInit(3);
- *   // Proceed with spawning agents
- * } catch (error) {
- *   console.error(error.message);
- *   process.exit(1);
- * }
- * ```
- */ export async function requireSwarmInit(agentCount, swarmStatus, config) {
-    const result = await validateSwarmInit(agentCount, swarmStatus, config);
-    if (!result.valid) {
-        const errorMessage = `${result.error}\n\n${result.suggestion}`;
-        throw new Error(errorMessage);
-    }
-}
-/**
- * Gets recommended topology for agent count
- *
- * @param agentCount - Number of agents
- * @param config - Validator configuration
- * @returns Recommended topology
- */ export function getRecommendedTopology(agentCount, config = {}) {
-    const cfg = {
-        ...DEFAULT_CONFIG,
-        ...config
-    };
-    return agentCount <= cfg.meshTopologyMaxAgents ? 'mesh' : 'hierarchical';
-}
-/**
- * Checks if swarm initialization is required for agent count
- *
- * @param agentCount - Number of agents
- * @param config - Validator configuration
- * @returns true if swarm initialization is required
- */ export function isSwarmRequired(agentCount, config = {}) {
-    const cfg = {
-        ...DEFAULT_CONFIG,
-        ...config
-    };
-    return cfg.requireSwarmForMultiAgent && agentCount >= cfg.minAgentsRequiringSwarm;
-}
-/**
- * Validates swarm configuration before initialization
- *
- * @param topology - Requested topology
- * @param maxAgents - Maximum number of agents
- * @param config - Validator configuration
- * @returns Validation result
- */ export function validateSwarmConfig(topology, maxAgents, config = {}) {
-    const cfg = {
-        ...DEFAULT_CONFIG,
-        ...config
-    };
-    // Validate topology matches max agents
-    const recommendedTopology = getRecommendedTopology(maxAgents, config);
-    if (topology !== recommendedTopology) {
-        return {
-            valid: false,
-            error: `Topology '${topology}' is not optimal for ${maxAgents} agents.`,
-            suggestion: `Recommended topology: '${recommendedTopology}'\n  • mesh: 2-${cfg.meshTopologyMaxAgents} agents\n  • hierarchical: ${cfg.hierarchicalTopologyMinAgents}+ agents`,
-            topology: recommendedTopology,
-            maxAgents
-        };
-    }
-    return {
-        valid: true
-    };
-}
-/**
- * Factory for creating a swarm coordinator factory module
- * This is a placeholder that will be replaced with actual implementation
- */ export const SwarmCoordinatorFactory = {
-    getSwarmCoordinator () {
-        return null;
-    }
-};