claude-flow-novice 2.0.6 → 2.0.8

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

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

package/dist/src/swarm/types.js

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

@@ -0,0 +1,56 @@
+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

@@ -0,0 +1,214 @@
+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

@@ -0,0 +1,10 @@
+/**
+ * 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/index.js";
+// TodoWrite Integration
+export { isValidationEnabled, getIntegrationConfig, validateTodoWrite, parseValidationFlags, displayValidationHelp, todoWriteWithValidation, createValidationMiddleware, getValidationStatus } from "./todowrite-integration/index.js";

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

@@ -0,0 +1,259 @@
+/**
+ * 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;
+    }
+};