claude-flow 3.25.6 → 3.26.1

package/v3/@claude-flow/guidance/dist/wasm-kernel.js

@@ -1,158 +0,0 @@
-/**
- * WASM Kernel Host Bridge
- *
- * Layer B: Node host runtime that calls into the Rust WASM kernel (Layer A).
- * All WASM calls go through this bridge. If the WASM module fails to load,
- * the bridge transparently falls back to the JavaScript implementations.
- *
- * Key rule: The host calls the kernel once per event with a batch payload,
- * not thousands of tiny calls.
- *
- * @module @claude-flow/guidance/wasm-kernel
- */
-import { createHash, createHmac } from 'node:crypto';
-// ============================================================================
-// WASM Loader
-// ============================================================================
-let wasmModule = null;
-let loadAttempted = false;
-function tryLoadWasm() {
-    if (loadAttempted)
-        return wasmModule;
-    loadAttempted = true;
-    try {
-        // Dynamic require — works in Node.js, gracefully fails elsewhere
-        const path = new URL('../wasm-pkg/guidance_kernel.js', import.meta.url);
-        // Use createRequire for ESM compatibility
-        const { createRequire } = require('node:module');
-        const requireFn = createRequire(import.meta.url);
-        wasmModule = requireFn(path.pathname);
-        // Initialize kernel
-        if (wasmModule && typeof wasmModule.kernel_init === 'function') {
-            wasmModule.kernel_init();
-        }
-    }
-    catch {
-        // WASM not available — fall back to JS
-        wasmModule = null;
-    }
-    return wasmModule;
-}
-// ============================================================================
-// JS Fallback Implementations
-// ============================================================================
-function jsSha256(input) {
-    return createHash('sha256').update(input).digest('hex');
-}
-function jsHmacSha256(key, input) {
-    return createHmac('sha256', key).update(input).digest('hex');
-}
-function jsContentHash(jsonInput) {
-    try {
-        const parsed = JSON.parse(jsonInput);
-        const sorted = sortKeys(parsed);
-        return jsSha256(JSON.stringify(sorted));
-    }
-    catch {
-        return jsSha256(jsonInput);
-    }
-}
-function sortKeys(value) {
-    if (value === null || typeof value !== 'object')
-        return value;
-    if (Array.isArray(value))
-        return value.map(sortKeys);
-    const sorted = {};
-    for (const key of Object.keys(value).sort()) {
-        sorted[key] = sortKeys(value[key]);
-    }
-    return sorted;
-}
-// ============================================================================
-// Kernel singleton
-// ============================================================================
-let kernelInstance = null;
-/**
- * Get the WASM kernel instance. Automatically falls back to JS if WASM is
- * unavailable. Thread-safe (single initialization).
- */
-export function getKernel() {
-    if (kernelInstance)
-        return kernelInstance;
-    const wasm = tryLoadWasm();
-    if (wasm) {
-        kernelInstance = {
-            available: true,
-            version: wasm.kernel_init(),
-            sha256: (input) => wasm.sha256(input),
-            hmacSha256: (key, input) => wasm.hmac_sha256(key, input),
-            contentHash: (jsonInput) => wasm.content_hash(jsonInput),
-            signEnvelope: (key, envelopeJson) => wasm.sign_envelope(key, envelopeJson),
-            verifyChain: (chainJson, key) => wasm.verify_chain(chainJson, key),
-            scanSecrets: (content) => {
-                const json = wasm.scan_secrets(content);
-                try {
-                    return JSON.parse(json);
-                }
-                catch {
-                    return [];
-                }
-            },
-            detectDestructive: (command) => {
-                const result = wasm.detect_destructive(command);
-                return result === '' ? null : result;
-            },
-            batchProcess: (ops) => {
-                const json = wasm.batch_process(JSON.stringify(ops));
-                try {
-                    return JSON.parse(json);
-                }
-                catch {
-                    return [];
-                }
-            },
-        };
-    }
-    else {
-        // JS fallback — identical outputs, just slower
-        kernelInstance = {
-            available: false,
-            version: 'js-fallback',
-            sha256: jsSha256,
-            hmacSha256: jsHmacSha256,
-            contentHash: jsContentHash,
-            signEnvelope: jsHmacSha256,
-            verifyChain: () => {
-                // Chain verification requires full envelope parsing — not implemented
-                // in JS fallback because the ProofChain class already does it.
-                throw new Error('verifyChain not available in JS fallback; use ProofChain.verifyChain()');
-            },
-            scanSecrets: () => {
-                // Gate scanning in JS fallback defers to EnforcementGates class
-                throw new Error('scanSecrets not available in JS fallback; use EnforcementGates');
-            },
-            detectDestructive: () => {
-                throw new Error('detectDestructive not available in JS fallback; use EnforcementGates');
-            },
-            batchProcess: () => {
-                throw new Error('batchProcess requires WASM kernel');
-            },
-        };
-    }
-    return kernelInstance;
-}
-/**
- * Check if the WASM kernel is available without initializing it.
- */
-export function isWasmAvailable() {
-    return getKernel().available;
-}
-/**
- * Reset the kernel instance (for testing).
- */
-export function resetKernel() {
-    kernelInstance = null;
-    wasmModule = null;
-    loadAttempted = false;
-}
-//# sourceMappingURL=wasm-kernel.js.map

package/v3/@claude-flow/shared/dist/core/config/defaults.d.ts

@@ -1,41 +0,0 @@
-/**
- * V3 Default Configuration Values
- */
-import type { AgentConfig, TaskConfig, SwarmConfig, MemoryConfig, MCPServerConfig, OrchestratorConfig, SystemConfig } from './schema.js';
-/**
- * Default agent configuration
- */
-export declare const defaultAgentConfig: Partial<AgentConfig>;
-/**
- * Default task configuration
- */
-export declare const defaultTaskConfig: Partial<TaskConfig>;
-/**
- * Default swarm configuration (core version)
- */
-export declare const defaultSwarmConfigCore: SwarmConfig;
-/**
- * Default memory configuration (hybrid backend - ADR-009)
- */
-export declare const defaultMemoryConfig: MemoryConfig;
-/**
- * Default MCP server configuration
- */
-export declare const defaultMCPServerConfig: MCPServerConfig;
-/**
- * Default orchestrator configuration
- */
-export declare const defaultOrchestratorConfig: OrchestratorConfig;
-/**
- * Default full system configuration
- */
-export declare const defaultSystemConfig: SystemConfig;
-/**
- * Agent type presets
- */
-export declare const agentTypePresets: Record<string, Partial<AgentConfig>>;
-/**
- * Get merged configuration with defaults
- */
-export declare function mergeWithDefaults<T extends Record<string, unknown>>(config: Partial<T>, defaults: T): T;
-//# sourceMappingURL=defaults.d.ts.map

package/v3/@claude-flow/shared/dist/core/config/defaults.js

@@ -1,186 +0,0 @@
-/**
- * V3 Default Configuration Values
- */
-/**
- * Default agent configuration
- */
-export const defaultAgentConfig = {
-    capabilities: [],
-    maxConcurrentTasks: 5,
-    priority: 50,
-    retryPolicy: {
-        maxRetries: 3,
-        backoffMs: 1000,
-        backoffMultiplier: 2,
-    },
-};
-/**
- * Default task configuration
- */
-export const defaultTaskConfig = {
-    priority: 50,
-    metadata: {
-        maxRetries: 3,
-    },
-};
-/**
- * Default swarm configuration (core version)
- */
-export const defaultSwarmConfigCore = {
-    topology: 'hierarchical-mesh',
-    maxAgents: 20,
-    autoScale: {
-        enabled: false,
-        minAgents: 1,
-        maxAgents: 20,
-        scaleUpThreshold: 0.8,
-        scaleDownThreshold: 0.3,
-    },
-    coordination: {
-        consensusRequired: false,
-        timeoutMs: 10000,
-        retryPolicy: {
-            maxRetries: 3,
-            backoffMs: 500,
-        },
-    },
-    communication: {
-        protocol: 'events',
-        batchSize: 10,
-        flushIntervalMs: 100,
-    },
-};
-/**
- * Default memory configuration (hybrid backend - ADR-009)
- */
-export const defaultMemoryConfig = {
-    type: 'hybrid',
-    path: './data/memory',
-    sqlite: {
-        inMemory: false,
-        wal: true,
-    },
-    agentdb: {
-        dimensions: 1536,
-        indexType: 'hnsw',
-        efConstruction: 200,
-        m: 16,
-        quantization: 'none',
-    },
-    hybrid: {
-        vectorThreshold: 100,
-    },
-};
-/**
- * Default MCP server configuration
- */
-export const defaultMCPServerConfig = {
-    name: 'claude-flow',
-    version: '3.0.0',
-    transport: {
-        type: 'stdio',
-    },
-    capabilities: {
-        tools: true,
-        resources: true,
-        prompts: true,
-        logging: true,
-    },
-};
-/**
- * Default orchestrator configuration
- */
-export const defaultOrchestratorConfig = {
-    session: {
-        persistSessions: true,
-        dataDir: './data',
-        sessionRetentionMs: 3600000, // 1 hour
-    },
-    health: {
-        checkInterval: 30000, // 30 seconds
-        historyLimit: 100,
-        degradedThreshold: 1,
-        unhealthyThreshold: 2,
-    },
-    lifecycle: {
-        maxConcurrentAgents: 20,
-        spawnTimeout: 30000, // 30 seconds
-        terminateTimeout: 10000, // 10 seconds
-        maxSpawnRetries: 3,
-    },
-};
-/**
- * Default full system configuration
- */
-export const defaultSystemConfig = {
-    orchestrator: defaultOrchestratorConfig,
-    memory: defaultMemoryConfig,
-    mcp: defaultMCPServerConfig,
-    swarm: defaultSwarmConfigCore,
-};
-/**
- * Agent type presets
- */
-export const agentTypePresets = {
-    coder: {
-        type: 'coder',
-        capabilities: ['code', 'debug', 'refactor', 'test'],
-        maxConcurrentTasks: 3,
-        priority: 70,
-    },
-    reviewer: {
-        type: 'reviewer',
-        capabilities: ['review', 'analyze', 'suggest'],
-        maxConcurrentTasks: 5,
-        priority: 60,
-    },
-    tester: {
-        type: 'tester',
-        capabilities: ['test', 'validate', 'benchmark'],
-        maxConcurrentTasks: 4,
-        priority: 65,
-    },
-    researcher: {
-        type: 'researcher',
-        capabilities: ['research', 'analyze', 'summarize'],
-        maxConcurrentTasks: 3,
-        priority: 50,
-    },
-    planner: {
-        type: 'planner',
-        capabilities: ['plan', 'organize', 'decompose'],
-        maxConcurrentTasks: 2,
-        priority: 80,
-    },
-    architect: {
-        type: 'architect',
-        capabilities: ['design', 'architecture', 'patterns'],
-        maxConcurrentTasks: 2,
-        priority: 85,
-    },
-    coordinator: {
-        type: 'coordinator',
-        capabilities: ['coordinate', 'delegate', 'monitor'],
-        maxConcurrentTasks: 10,
-        priority: 90,
-    },
-    security: {
-        type: 'security',
-        capabilities: ['audit', 'scan', 'validate', 'secure'],
-        maxConcurrentTasks: 3,
-        priority: 95,
-    },
-    performance: {
-        type: 'performance',
-        capabilities: ['benchmark', 'optimize', 'profile'],
-        maxConcurrentTasks: 2,
-        priority: 70,
-    },
-};
-/**
- * Get merged configuration with defaults
- */
-export function mergeWithDefaults(config, defaults) {
-    return { ...defaults, ...config };
-}
-//# sourceMappingURL=defaults.js.map

package/v3/@claude-flow/shared/dist/core/config/index.d.ts

@@ -1,8 +0,0 @@
-/**
- * V3 Configuration - Public API
- */
-export * from './schema.js';
-export * from './validator.js';
-export * from './defaults.js';
-export * from './loader.js';
-//# sourceMappingURL=index.d.ts.map

package/v3/@claude-flow/shared/dist/core/config/index.js

@@ -1,12 +0,0 @@
-/**
- * V3 Configuration - Public API
- */
-// Schemas
-export * from './schema.js';
-// Validation
-export * from './validator.js';
-// Defaults
-export * from './defaults.js';
-// Loader
-export * from './loader.js';
-//# sourceMappingURL=index.js.map

package/v3/@claude-flow/shared/dist/core/config/loader.d.ts

@@ -1,45 +0,0 @@
-/**
- * V3 Configuration Loader
- * Load configuration from various sources
- */
-import type { SystemConfig } from './schema.js';
-/**
- * Configuration source type
- */
-export type ConfigSource = 'file' | 'env' | 'default' | 'merged';
-/**
- * Loaded configuration with metadata
- */
-export interface LoadedConfig {
-    config: SystemConfig;
-    source: ConfigSource;
-    path?: string;
-    warnings?: string[];
-}
-/**
- * Configuration loader class
- */
-export declare class ConfigLoader {
-    private searchPaths;
-    constructor(additionalPaths?: string[]);
-    /**
-     * Load configuration from all sources
-     */
-    load(): Promise<LoadedConfig>;
-    /**
-     * Load configuration from specific file
-     */
-    loadFromFile(filePath: string): Promise<LoadedConfig>;
-    /**
-     * Deep merge objects
-     */
-    private deepMerge;
-}
-/**
- * Load configuration (convenience function)
- */
-export declare function loadConfig(options?: {
-    paths?: string[];
-    file?: string;
-}): Promise<LoadedConfig>;
-//# sourceMappingURL=loader.d.ts.map

package/v3/@claude-flow/shared/dist/core/config/loader.js

@@ -1,238 +0,0 @@
-/**
- * V3 Configuration Loader
- * Load configuration from various sources
- */
-import { readFile } from 'fs/promises';
-import { join, resolve } from 'path';
-import { existsSync } from 'fs';
-import { validateSystemConfig } from './validator.js';
-import { defaultSystemConfig, mergeWithDefaults } from './defaults.js';
-/**
- * Configuration file names to search for
- */
-const CONFIG_FILE_NAMES = [
-    'claude-flow.config.json',
-    'claude-flow.config.js',
-    'claude-flow.json',
-    '.claude-flow.json',
-];
-/**
- * Find configuration file in directory
- */
-async function findConfigFile(directory) {
-    for (const name of CONFIG_FILE_NAMES) {
-        const path = join(directory, name);
-        if (existsSync(path)) {
-            return path;
-        }
-    }
-    return null;
-}
-/**
- * Load configuration from JSON file
- */
-async function loadJsonConfig(path) {
-    const content = await readFile(path, 'utf8');
-    return JSON.parse(content);
-}
-/**
- * Load configuration from environment variables
- */
-function loadEnvConfig() {
-    const config = {};
-    // Orchestrator settings
-    if (process.env.CLAUDE_FLOW_MAX_AGENTS) {
-        config.orchestrator = {
-            ...defaultSystemConfig.orchestrator,
-            lifecycle: {
-                ...defaultSystemConfig.orchestrator.lifecycle,
-                maxConcurrentAgents: parseInt(process.env.CLAUDE_FLOW_MAX_AGENTS, 10),
-            },
-        };
-    }
-    // Data directory
-    if (process.env.CLAUDE_FLOW_DATA_DIR) {
-        config.orchestrator = {
-            ...config.orchestrator,
-            ...defaultSystemConfig.orchestrator,
-            session: {
-                ...defaultSystemConfig.orchestrator.session,
-                dataDir: process.env.CLAUDE_FLOW_DATA_DIR,
-            },
-        };
-    }
-    // Memory type
-    if (process.env.CLAUDE_FLOW_MEMORY_TYPE) {
-        const memoryType = process.env.CLAUDE_FLOW_MEMORY_TYPE;
-        if (['sqlite', 'agentdb', 'hybrid', 'redis', 'memory'].includes(memoryType)) {
-            config.memory = {
-                ...(defaultSystemConfig.memory ?? { type: 'hybrid' }),
-                type: memoryType,
-            };
-        }
-    }
-    // MCP transport
-    const defaultMcp = defaultSystemConfig.mcp ?? { name: 'claude-flow', version: '3.0.0', transport: { type: 'stdio' } };
-    if (process.env.CLAUDE_FLOW_MCP_TRANSPORT) {
-        const transport = process.env.CLAUDE_FLOW_MCP_TRANSPORT;
-        if (['stdio', 'http', 'websocket'].includes(transport)) {
-            config.mcp = {
-                ...defaultMcp,
-                transport: {
-                    ...defaultMcp.transport,
-                    type: transport,
-                },
-            };
-        }
-    }
-    if (process.env.CLAUDE_FLOW_MCP_PORT) {
-        config.mcp = {
-            ...config.mcp,
-            ...defaultMcp,
-            transport: {
-                ...config.mcp?.transport,
-                ...defaultMcp.transport,
-                port: parseInt(process.env.CLAUDE_FLOW_MCP_PORT, 10),
-            },
-        };
-    }
-    // Swarm topology
-    const defaultSwarm = defaultSystemConfig.swarm ?? { topology: 'hierarchical-mesh', maxAgents: 20 };
-    if (process.env.CLAUDE_FLOW_SWARM_TOPOLOGY) {
-        const topology = process.env.CLAUDE_FLOW_SWARM_TOPOLOGY;
-        if (['hierarchical', 'mesh', 'ring', 'star', 'adaptive', 'hierarchical-mesh'].includes(topology)) {
-            config.swarm = {
-                ...defaultSwarm,
-                topology,
-            };
-        }
-    }
-    return config;
-}
-/**
- * Configuration loader class
- */
-export class ConfigLoader {
-    searchPaths = [];
-    constructor(additionalPaths) {
-        // Default search paths
-        this.searchPaths = [
-            process.cwd(),
-            resolve(process.cwd(), '..'),
-            resolve(process.env.HOME ?? '', '.claude-flow'),
-        ];
-        if (additionalPaths) {
-            this.searchPaths.push(...additionalPaths);
-        }
-    }
-    /**
-     * Load configuration from all sources
-     */
-    async load() {
-        const warnings = [];
-        // Start with defaults
-        let config = { ...defaultSystemConfig };
-        let source = 'default';
-        let path;
-        // Try to load from file
-        for (const searchPath of this.searchPaths) {
-            const configPath = await findConfigFile(searchPath);
-            if (configPath) {
-                try {
-                    const fileConfig = await loadJsonConfig(configPath);
-                    const validation = validateSystemConfig(fileConfig);
-                    if (validation.success) {
-                        config = mergeWithDefaults(validation.data, defaultSystemConfig);
-                        source = 'file';
-                        path = configPath;
-                        break;
-                    }
-                    else {
-                        // Config file exists but doesn't match the strict schema.
-                        // Merge whatever valid object fields exist with defaults and continue.
-                        // This handles partial configs, legacy configs, and simple key-value files.
-                        if (fileConfig && typeof fileConfig === 'object' && !Array.isArray(fileConfig)) {
-                            const partial = fileConfig;
-                            const merged = { ...defaultSystemConfig };
-                            for (const key of Object.keys(partial)) {
-                                if (partial[key] && typeof partial[key] === 'object' && !Array.isArray(partial[key])) {
-                                    merged[key] = { ...(merged[key] || {}), ...partial[key] };
-                                }
-                            }
-                            config = merged;
-                            source = 'file';
-                            path = configPath;
-                        }
-                        // Always break on first found config file — don't search further
-                        break;
-                    }
-                }
-                catch (error) {
-                    warnings.push(`Failed to load config from ${configPath}: ${error.message}`);
-                }
-            }
-        }
-        // Merge with environment variables
-        const envConfig = loadEnvConfig();
-        if (Object.keys(envConfig).length > 0) {
-            config = this.deepMerge(config, envConfig);
-            source = source === 'default' ? 'env' : 'merged';
-        }
-        return {
-            config,
-            source,
-            path,
-            warnings: warnings.length > 0 ? warnings : undefined,
-        };
-    }
-    /**
-     * Load configuration from specific file
-     */
-    async loadFromFile(filePath) {
-        const absolutePath = resolve(filePath);
-        const fileConfig = await loadJsonConfig(absolutePath);
-        const validation = validateSystemConfig(fileConfig);
-        if (!validation.success) {
-            throw new Error(`Invalid configuration: ${validation.errors?.map(e => e.message).join(', ')}`);
-        }
-        const config = mergeWithDefaults(validation.data, defaultSystemConfig);
-        return {
-            config,
-            source: 'file',
-            path: absolutePath,
-        };
-    }
-    /**
-     * Deep merge objects
-     */
-    deepMerge(target, source) {
-        const result = { ...target };
-        for (const key of Object.keys(source)) {
-            const sourceValue = source[key];
-            const targetValue = target[key];
-            if (sourceValue &&
-                typeof sourceValue === 'object' &&
-                !Array.isArray(sourceValue) &&
-                targetValue &&
-                typeof targetValue === 'object' &&
-                !Array.isArray(targetValue)) {
-                result[key] = this.deepMerge(targetValue, sourceValue);
-            }
-            else if (sourceValue !== undefined) {
-                result[key] = sourceValue;
-            }
-        }
-        return result;
-    }
-}
-/**
- * Load configuration (convenience function)
- */
-export async function loadConfig(options) {
-    const loader = new ConfigLoader(options?.paths);
-    if (options?.file) {
-        return loader.loadFromFile(options.file);
-    }
-    return loader.load();
-}
-//# sourceMappingURL=loader.js.map