agentic-flow 2.0.1 → 2.0.2-alpha

package/dist/utils/input-validator.d.ts

@@ -1,116 +0,0 @@
-/**
- * Input Validation Utilities
- *
- * Provides secure input validation for RuVector integration:
- * - Task description validation
- * - Configuration validation
- * - Injection attack prevention
- * - Resource exhaustion prevention
- */
-export interface ValidationOptions {
-    maxLength?: number;
-    minLength?: number;
-    allowEmpty?: boolean;
-    sanitize?: boolean;
-}
-export declare class ValidationError extends Error {
-    field?: string;
-    constructor(message: string, field?: string);
-}
-/**
- * Input Validator
- *
- * Validates all external inputs to prevent:
- * - Injection attacks (XSS, SQL injection, prompt injection)
- * - Resource exhaustion (excessive length, recursion)
- * - Malicious content (scripts, control characters)
- */
-export declare class InputValidator {
-    private static readonly SUSPICIOUS_PATTERNS;
-    private static readonly CONTROL_CHARS_REGEX;
-    /**
-     * Validate task description
-     *
-     * @param taskDescription - User-provided task description
-     * @param options - Validation options
-     * @returns Sanitized task description
-     * @throws ValidationError if invalid
-     */
-    static validateTaskDescription(taskDescription: string, options?: ValidationOptions): string;
-    /**
-     * Validate agent name
-     *
-     * @param agentName - Agent identifier
-     * @returns Sanitized agent name
-     * @throws ValidationError if invalid
-     */
-    static validateAgentName(agentName: string): string;
-    /**
-     * Validate confidence score
-     *
-     * @param confidence - Confidence score (0-1)
-     * @returns Validated confidence
-     * @throws ValidationError if invalid
-     */
-    static validateConfidence(confidence: number): number;
-    /**
-     * Validate timeout value
-     *
-     * @param timeout - Timeout in milliseconds
-     * @param min - Minimum allowed timeout (default: 100ms)
-     * @param max - Maximum allowed timeout (default: 5 minutes)
-     * @returns Validated timeout
-     * @throws ValidationError if invalid
-     */
-    static validateTimeout(timeout: number, min?: number, max?: number): number;
-    /**
-     * Validate array of strings
-     *
-     * @param array - Array to validate
-     * @param fieldName - Field name for error messages
-     * @param maxItems - Maximum number of items
-     * @param maxLength - Maximum length per item
-     * @returns Validated array
-     * @throws ValidationError if invalid
-     */
-    static validateStringArray(array: unknown, fieldName: string, maxItems?: number, maxLength?: number): string[];
-    /**
-     * Validate configuration object
-     *
-     * @param config - Configuration to validate
-     * @param schema - Validation schema
-     * @returns Validated configuration
-     * @throws ValidationError if invalid
-     */
-    static validateConfig<T extends Record<string, any>>(config: unknown, schema: {
-        [K in keyof T]: {
-            type: 'string' | 'number' | 'boolean' | 'object';
-            required?: boolean;
-            min?: number;
-            max?: number;
-            validator?: (value: any) => boolean;
-        };
-    }): T;
-    /**
-     * Sanitize HTML to prevent XSS
-     *
-     * @param html - HTML string to sanitize
-     * @returns Sanitized HTML (text only)
-     */
-    static sanitizeHtml(html: string): string;
-    /**
-     * Validate email address
-     *
-     * @param email - Email to validate
-     * @returns Normalized email
-     * @throws ValidationError if invalid
-     */
-    static validateEmail(email: string): string;
-}
-/**
- * Validation middleware factory
- *
- * Creates validation middleware for Express/Fastify routes
- */
-export declare function createValidationMiddleware(validator: (req: any) => void | Promise<void>): (req: any, res: any, next: any) => Promise<void>;
-//# sourceMappingURL=input-validator.d.ts.map

package/dist/utils/lazy-auth.js

@@ -1,311 +0,0 @@
-/**
- * Lazy Authentication with Session Caching
- * Reduces auth overhead by 5-10% through session caching and lazy validation
- * Phase 3 Optimization
- */
-/**
- * Lazy Authentication Manager
- * Caches validated sessions to avoid repeated authentication overhead
- */
-export class LazyAuthManager {
-    config;
-    sessions = new Map();
-    stats;
-    cleanupTimer;
-    validationQueue = new Set();
-    constructor(config) {
-        this.config = {
-            enabled: config.enabled,
-            ttl: config.ttl || 3600000, // 1 hour default
-            maxSessions: config.maxSessions || 1000,
-            checkInterval: config.checkInterval || 60000 // 1 minute
-        };
-        this.stats = {
-            totalValidations: 0,
-            cacheHits: 0,
-            cacheMisses: 0,
-            sessionsActive: 0,
-            sessionsCleaned: 0,
-            avgValidationTime: 0
-        };
-        if (this.config.enabled) {
-            this.startCleanupTimer();
-        }
-    }
-    /**
-     * Authenticate a token (lazy validation)
-     */
-    async authenticate(token, validateFn) {
-        if (!this.config.enabled) {
-            // No caching, always validate
-            const userId = await validateFn(token);
-            return this.createSession(token, userId, true);
-        }
-        // Check cache first
-        const cached = this.sessions.get(token);
-        if (cached && !this.isExpired(cached)) {
-            this.stats.cacheHits++;
-            cached.lastAccessedAt = Date.now();
-            return cached;
-        }
-        this.stats.cacheMisses++;
-        // Lazy validation: check if already being validated
-        if (this.validationQueue.has(token)) {
-            // Wait for ongoing validation
-            return this.waitForValidation(token);
-        }
-        // Perform validation
-        return this.validateAndCache(token, validateFn);
-    }
-    /**
-     * Validate token and cache the session
-     */
-    async validateAndCache(token, validateFn) {
-        this.validationQueue.add(token);
-        try {
-            const startTime = Date.now();
-            const userId = await validateFn(token);
-            const validationTime = Date.now() - startTime;
-            // Update average validation time
-            this.updateAvgValidationTime(validationTime);
-            this.stats.totalValidations++;
-            // Create and cache session
-            const session = this.createSession(token, userId, true);
-            this.cacheSession(session);
-            return session;
-        }
-        catch (error) {
-            return null;
-        }
-        finally {
-            this.validationQueue.delete(token);
-        }
-    }
-    /**
-     * Wait for ongoing validation
-     */
-    async waitForValidation(token) {
-        // Poll for validation completion (max 5 seconds)
-        const maxAttempts = 50;
-        let attempts = 0;
-        while (this.validationQueue.has(token) && attempts < maxAttempts) {
-            await new Promise(resolve => setTimeout(resolve, 100));
-            attempts++;
-        }
-        // Check cache after validation
-        const session = this.sessions.get(token);
-        return session && !this.isExpired(session) ? session : null;
-    }
-    /**
-     * Create a session object
-     */
-    createSession(token, userId, validated) {
-        const now = Date.now();
-        return {
-            token,
-            userId,
-            validated,
-            createdAt: now,
-            lastAccessedAt: now,
-            expiresAt: now + this.config.ttl
-        };
-    }
-    /**
-     * Cache a session
-     */
-    cacheSession(session) {
-        // Check max sessions limit
-        if (this.sessions.size >= this.config.maxSessions) {
-            this.evictOldest();
-        }
-        this.sessions.set(session.token, session);
-        this.stats.sessionsActive = this.sessions.size;
-    }
-    /**
-     * Check if session is expired
-     */
-    isExpired(session) {
-        return Date.now() > session.expiresAt;
-    }
-    /**
-     * Evict oldest session (LRU)
-     */
-    evictOldest() {
-        let oldest = null;
-        let oldestToken = null;
-        for (const [token, session] of this.sessions) {
-            if (!oldest || session.lastAccessedAt < oldest.lastAccessedAt) {
-                oldest = session;
-                oldestToken = token;
-            }
-        }
-        if (oldestToken) {
-            this.sessions.delete(oldestToken);
-            this.stats.sessionsCleaned++;
-        }
-    }
-    /**
-     * Update average validation time
-     */
-    updateAvgValidationTime(newTime) {
-        const total = this.stats.totalValidations;
-        const currentAvg = this.stats.avgValidationTime;
-        this.stats.avgValidationTime = (currentAvg * total + newTime) / (total + 1);
-    }
-    /**
-     * Start cleanup timer for expired sessions
-     */
-    startCleanupTimer() {
-        this.cleanupTimer = setInterval(() => {
-            this.cleanup();
-        }, this.config.checkInterval);
-    }
-    /**
-     * Clean up expired sessions
-     */
-    cleanup() {
-        const now = Date.now();
-        let cleaned = 0;
-        for (const [token, session] of this.sessions) {
-            if (now > session.expiresAt) {
-                this.sessions.delete(token);
-                cleaned++;
-            }
-        }
-        this.stats.sessionsCleaned += cleaned;
-        this.stats.sessionsActive = this.sessions.size;
-    }
-    /**
-     * Invalidate a session
-     */
-    invalidate(token) {
-        return this.sessions.delete(token);
-    }
-    /**
-     * Invalidate all sessions for a user
-     */
-    invalidateUser(userId) {
-        let count = 0;
-        for (const [token, session] of this.sessions) {
-            if (session.userId === userId) {
-                this.sessions.delete(token);
-                count++;
-            }
-        }
-        return count;
-    }
-    /**
-     * Get session if exists and valid
-     */
-    getSession(token) {
-        const session = this.sessions.get(token);
-        if (!session || this.isExpired(session)) {
-            return null;
-        }
-        session.lastAccessedAt = Date.now();
-        return session;
-    }
-    /**
-     * Get statistics
-     */
-    getStats() {
-        return { ...this.stats };
-    }
-    /**
-     * Get cache hit rate
-     */
-    getCacheHitRate() {
-        const total = this.stats.cacheHits + this.stats.cacheMisses;
-        return total > 0 ? (this.stats.cacheHits / total) * 100 : 0;
-    }
-    /**
-     * Reset statistics
-     */
-    resetStats() {
-        this.stats = {
-            totalValidations: 0,
-            cacheHits: 0,
-            cacheMisses: 0,
-            sessionsActive: this.sessions.size,
-            sessionsCleaned: 0,
-            avgValidationTime: 0
-        };
-    }
-    /**
-     * Clear all sessions
-     */
-    clear() {
-        this.sessions.clear();
-        this.stats.sessionsActive = 0;
-    }
-    /**
-     * Destroy manager and cleanup
-     */
-    destroy() {
-        if (this.cleanupTimer) {
-            clearInterval(this.cleanupTimer);
-        }
-        this.clear();
-    }
-}
-/**
- * Token-based authentication helper
- */
-export class TokenAuth {
-    authManager;
-    validateFn;
-    constructor(authManager, validateFn) {
-        this.authManager = authManager;
-        this.validateFn = validateFn;
-    }
-    /**
-     * Authenticate a request
-     */
-    async authenticate(authHeader) {
-        // Extract token from header
-        const token = this.extractToken(authHeader);
-        if (!token) {
-            return null;
-        }
-        return this.authManager.authenticate(token, this.validateFn);
-    }
-    /**
-     * Extract token from Authorization header
-     */
-    extractToken(authHeader) {
-        if (!authHeader) {
-            return null;
-        }
-        // Support "Bearer <token>" and raw token
-        if (authHeader.startsWith('Bearer ')) {
-            return authHeader.substring(7);
-        }
-        return authHeader;
-    }
-    /**
-     * Invalidate token
-     */
-    invalidate(token) {
-        return this.authManager.invalidate(token);
-    }
-    /**
-     * Get statistics
-     */
-    getStats() {
-        return this.authManager.getStats();
-    }
-}
-/**
- * Calculate auth overhead reduction
- */
-export function calculateAuthSavings(stats) {
-    const hitRate = stats.cacheHits / (stats.cacheHits + stats.cacheMisses);
-    const savingsPercentage = hitRate * 100;
-    const avgSavedTime = stats.avgValidationTime * hitRate;
-    const totalSavedTime = stats.avgValidationTime * stats.cacheHits;
-    return {
-        savingsPercentage,
-        avgSavedTime,
-        totalSavedTime
-    };
-}

package/dist/utils/logger.d.ts

@@ -1,19 +0,0 @@
-interface LogContext {
-    agent?: string;
-    task?: string;
-    duration?: number;
-    error?: unknown;
-    [key: string]: any;
-}
-declare class Logger {
-    private context;
-    setContext(ctx: Record<string, any>): void;
-    private log;
-    debug(message: string, data?: LogContext): void;
-    info(message: string, data?: LogContext): void;
-    warn(message: string, data?: LogContext): void;
-    error(message: string, data?: LogContext): void;
-}
-export declare const logger: Logger;
-export {};
-//# sourceMappingURL=logger.d.ts.map

package/dist/utils/math.d.ts

@@ -1,12 +0,0 @@
-/**
- * Simple math utility functions
- */
-/**
- * Adds 2 and 2 together
- * @returns The sum of 2 + 2
- * @example
- * const result = addTwoPlusTwo();
- * console.log(result); // Output: 4
- */
-export declare const addTwoPlusTwo: () => number;
-//# sourceMappingURL=math.d.ts.map

package/dist/utils/mcpCommands.d.ts

@@ -1,2 +0,0 @@
-export declare function handleMCPCommand(command: string, server?: string): Promise<void>;
-//# sourceMappingURL=mcpCommands.d.ts.map

package/dist/utils/model-cache.d.ts

@@ -1,61 +0,0 @@
-/**
- * Global Model Cache
- *
- * Caches loaded models in memory to avoid repeated initialization overhead.
- * Supports ONNX embeddings, transformers.js pipelines, and other heavy models.
- */
-interface CacheStats {
-    models: number;
-    totalSize: number;
-    size?: number;
-    totalHits: number;
-    totalMisses: number;
-    hits: number;
-    misses: number;
-    hitRate: number;
-}
-declare class ModelCache {
-    private cache;
-    private maxSize;
-    private totalHits;
-    private totalMisses;
-    constructor(maxSizeMB?: number);
-    /**
-     * Get a cached model or load it
-     */
-    getOrLoad<T>(key: string, loader: () => Promise<T>, sizeEstimate?: number): Promise<T>;
-    /**
-     * Check if model is cached
-     */
-    has(key: string): boolean;
-    /**
-     * Get cached model without loading
-     */
-    get<T>(key: string): T | undefined;
-    /**
-     * Manually cache a model
-     */
-    set(key: string, model: any, sizeEstimate?: number): void;
-    /**
-     * Remove a model from cache
-     */
-    delete(key: string): boolean;
-    /**
-     * Clear all cached models
-     */
-    clear(): void;
-    /**
-     * Get cache statistics
-     */
-    getStats(): CacheStats;
-    /**
-     * Evict least recently used models if cache is full
-     */
-    private evictIfNeeded;
-}
-export declare const modelCache: ModelCache;
-export declare function getCachedOnnxEmbedder(): Promise<any>;
-export declare function getCachedTransformersPipeline(task?: string, model?: string): Promise<any>;
-export declare function getCachedRuvectorCore(): Promise<any>;
-export {};
-//# sourceMappingURL=model-cache.d.ts.map

package/dist/utils/model-cache.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"model-cache.d.ts","sourceRoot":"","sources":["../../src/utils/model-cache.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAUH,UAAU,UAAU;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,cAAM,UAAU;IACd,OAAO,CAAC,KAAK,CAAkC;IAC/C,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,SAAS,CAAK;IACtB,OAAO,CAAC,WAAW,CAAK;gBAEZ,SAAS,GAAE,MAAY;IAInC;;OAEG;IACG,SAAS,CAAC,CAAC,EACf,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EACxB,YAAY,GAAE,MAAyB,GACtC,OAAO,CAAC,CAAC,CAAC;IA4Bb;;OAEG;IACH,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAIzB;;OAEG;IACH,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,GAAG,CAAC,GAAG,SAAS;IAUlC;;OAEG;IACH,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,EAAE,YAAY,GAAE,MAAyB,GAAG,IAAI;IAW3E;;OAEG;IACH,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAI5B;;OAEG;IACH,KAAK,IAAI,IAAI;IAIb;;OAEG;IACH,QAAQ,IAAI,UAAU;IAoBtB;;OAEG;IACH,OAAO,CAAC,aAAa;CAuBtB;AAGD,eAAO,MAAM,UAAU,YAAmB,CAAC;AAG3C,wBAAsB,qBAAqB,IAAI,OAAO,CAAC,GAAG,CAAC,CAgC1D;AAED,wBAAsB,6BAA6B,CACjD,IAAI,GAAE,MAA6B,EACnC,KAAK,GAAE,MAAkC,GACxC,OAAO,CAAC,GAAG,CAAC,CASd;AAED,wBAAsB,qBAAqB,IAAI,OAAO,CAAC,GAAG,CAAC,CAS1D"}

package/dist/utils/model-cache.js

@@ -1,176 +0,0 @@
-/**
- * Global Model Cache
- *
- * Caches loaded models in memory to avoid repeated initialization overhead.
- * Supports ONNX embeddings, transformers.js pipelines, and other heavy models.
- */
-class ModelCache {
-    cache = new Map();
-    maxSize; // Max cache size in bytes
-    totalHits = 0;
-    totalMisses = 0;
-    constructor(maxSizeMB = 512) {
-        this.maxSize = maxSizeMB * 1024 * 1024;
-    }
-    /**
-     * Get a cached model or load it
-     */
-    async getOrLoad(key, loader, sizeEstimate = 50 * 1024 * 1024 // Default 50MB estimate
-    ) {
-        const cached = this.cache.get(key);
-        if (cached) {
-            cached.lastUsed = Date.now();
-            cached.useCount++;
-            this.totalHits++;
-            return cached.model;
-        }
-        this.totalMisses++;
-        // Evict if needed
-        this.evictIfNeeded(sizeEstimate);
-        // Load model
-        const model = await loader();
-        this.cache.set(key, {
-            model,
-            loadedAt: Date.now(),
-            lastUsed: Date.now(),
-            useCount: 1,
-            sizeEstimate
-        });
-        return model;
-    }
-    /**
-     * Check if model is cached
-     */
-    has(key) {
-        return this.cache.has(key);
-    }
-    /**
-     * Get cached model without loading
-     */
-    get(key) {
-        const cached = this.cache.get(key);
-        if (cached) {
-            cached.lastUsed = Date.now();
-            cached.useCount++;
-            return cached.model;
-        }
-        return undefined;
-    }
-    /**
-     * Manually cache a model
-     */
-    set(key, model, sizeEstimate = 50 * 1024 * 1024) {
-        this.evictIfNeeded(sizeEstimate);
-        this.cache.set(key, {
-            model,
-            loadedAt: Date.now(),
-            lastUsed: Date.now(),
-            useCount: 1,
-            sizeEstimate
-        });
-    }
-    /**
-     * Remove a model from cache
-     */
-    delete(key) {
-        return this.cache.delete(key);
-    }
-    /**
-     * Clear all cached models
-     */
-    clear() {
-        this.cache.clear();
-    }
-    /**
-     * Get cache statistics
-     */
-    getStats() {
-        let totalSize = 0;
-        for (const cached of this.cache.values()) {
-            totalSize += cached.sizeEstimate;
-        }
-        const hits = this.totalHits;
-        const misses = this.totalMisses;
-        const total = hits + misses;
-        return {
-            models: this.cache.size,
-            totalSize,
-            size: this.cache.size,
-            totalHits: hits,
-            totalMisses: misses,
-            hits,
-            misses,
-            hitRate: total > 0 ? hits / total : 0
-        };
-    }
-    /**
-     * Evict least recently used models if cache is full
-     */
-    evictIfNeeded(newSize) {
-        let currentSize = 0;
-        for (const cached of this.cache.values()) {
-            currentSize += cached.sizeEstimate;
-        }
-        if (currentSize + newSize <= this.maxSize) {
-            return;
-        }
-        // Sort by last used time (LRU)
-        const entries = Array.from(this.cache.entries())
-            .sort((a, b) => a[1].lastUsed - b[1].lastUsed);
-        // Evict until we have space
-        for (const [key, cached] of entries) {
-            if (currentSize + newSize <= this.maxSize) {
-                break;
-            }
-            this.cache.delete(key);
-            currentSize -= cached.sizeEstimate;
-        }
-    }
-}
-// Global singleton
-export const modelCache = new ModelCache();
-// Convenience functions
-export async function getCachedOnnxEmbedder() {
-    return modelCache.getOrLoad('onnx-embeddings', async () => {
-        // Suppress experimental warning for WASM
-        const originalEmit = process.emit;
-        // @ts-ignore
-        process.emit = function (name, data, ...args) {
-            if (name === 'warning' && typeof data === 'object' &&
-                data.name === 'ExperimentalWarning' &&
-                data.message?.includes('Import')) {
-                return false;
-            }
-            // @ts-ignore
-            return originalEmit.apply(process, [name, data, ...args]);
-        };
-        try {
-            const onnxModule = await import('ruvector-onnx-embeddings-wasm');
-            const EmbedderClass = onnxModule.OnnxEmbeddings || onnxModule.default;
-            if (EmbedderClass) {
-                const embedder = new EmbedderClass();
-                await embedder.initialize?.();
-                return embedder;
-            }
-        }
-        finally {
-            process.emit = originalEmit;
-        }
-        return null;
-    }, 100 * 1024 * 1024 // 100MB estimate for ONNX model
-    );
-}
-export async function getCachedTransformersPipeline(task = 'feature-extraction', model = 'Xenova/all-MiniLM-L6-v2') {
-    return modelCache.getOrLoad(`transformers:${task}:${model}`, async () => {
-        const { pipeline } = await import('@xenova/transformers');
-        return pipeline(task, model);
-    }, 200 * 1024 * 1024 // 200MB estimate for transformers model
-    );
-}
-export async function getCachedRuvectorCore() {
-    return modelCache.getOrLoad('ruvector-core', async () => {
-        const ruvector = await import('ruvector');
-        return ruvector;
-    }, 50 * 1024 * 1024);
-}
-//# sourceMappingURL=model-cache.js.map