agentic-flow 2.0.1 → 2.0.2-alpha

package/dist/utils/adaptive-pool-sizing.js

@@ -1,414 +0,0 @@
-/**
- * Adaptive Pool Sizing based on Traffic Patterns
- * Automatically adjusts pool sizes for 5-10% better resource utilization
- * Phase 3 Optimization
- */
-/**
- * Adaptive Pool Sizing Manager
- * Analyzes traffic patterns and automatically adjusts pool sizes
- */
-export class AdaptivePoolSizingManager {
-    config;
-    currentSize;
-    activeItems = 0;
-    stats;
-    trafficHistory = [];
-    utilizationSamples = [];
-    adjustmentTimer;
-    constructor(config) {
-        this.config = {
-            enabled: config.enabled,
-            minSize: config.minSize || 10,
-            maxSize: config.maxSize || 1000,
-            initialSize: config.initialSize || 50,
-            adjustInterval: config.adjustInterval || 30000, // 30 seconds
-            targetUtilization: config.targetUtilization || 70,
-            scaleUpThreshold: config.scaleUpThreshold || 80,
-            scaleDownThreshold: config.scaleDownThreshold || 40,
-            scaleStep: config.scaleStep || 10
-        };
-        this.currentSize = this.config.initialSize;
-        this.stats = {
-            currentSize: this.currentSize,
-            minSize: this.config.minSize,
-            maxSize: this.config.maxSize,
-            utilizationPercent: 0,
-            activeItems: 0,
-            totalAdjustments: 0,
-            scaleUps: 0,
-            scaleDowns: 0,
-            avgUtilization: 0,
-            peakUtilization: 0
-        };
-        if (this.config.enabled) {
-            this.startAdjustmentMonitoring();
-        }
-    }
-    /**
-     * Record pool usage
-     */
-    recordUsage(active, total) {
-        this.activeItems = active;
-        const poolSize = total || this.currentSize;
-        const utilization = (active / poolSize) * 100;
-        this.utilizationSamples.push(utilization);
-        // Keep last 100 samples
-        if (this.utilizationSamples.length > 100) {
-            this.utilizationSamples.shift();
-        }
-        // Update statistics
-        this.updateStats(utilization);
-    }
-    /**
-     * Record traffic pattern
-     */
-    recordTraffic(pattern) {
-        this.trafficHistory.push({
-            ...pattern,
-            timestamp: Date.now()
-        });
-        // Keep last 1000 patterns (configurable time window)
-        if (this.trafficHistory.length > 1000) {
-            this.trafficHistory.shift();
-        }
-    }
-    /**
-     * Get recommended pool size based on traffic analysis
-     */
-    getRecommendedSize() {
-        if (!this.config.enabled || this.utilizationSamples.length === 0) {
-            return this.currentSize;
-        }
-        const avgUtilization = this.calculateAverageUtilization();
-        const trend = this.analyzeTrafficTrend();
-        const predictedLoad = this.predictFutureLoad();
-        let recommendedSize = this.currentSize;
-        // Scale up if high utilization or increasing trend
-        if (avgUtilization > this.config.scaleUpThreshold || trend === 'increasing') {
-            recommendedSize = this.currentSize + this.config.scaleStep;
-        }
-        // Scale down if low utilization and stable/decreasing trend
-        else if (avgUtilization < this.config.scaleDownThreshold && (trend === 'stable' || trend === 'decreasing')) {
-            recommendedSize = this.currentSize - this.config.scaleStep;
-        }
-        // Adjust for predicted load
-        else if (predictedLoad > avgUtilization * 1.2) {
-            recommendedSize = Math.ceil(this.currentSize * (predictedLoad / avgUtilization));
-        }
-        // Ensure within bounds
-        return Math.max(this.config.minSize, Math.min(this.config.maxSize, recommendedSize));
-    }
-    /**
-     * Apply recommended pool size adjustment
-     */
-    applyAdjustment() {
-        const recommended = this.getRecommendedSize();
-        const oldSize = this.currentSize;
-        if (recommended !== oldSize) {
-            this.currentSize = recommended;
-            this.stats.currentSize = recommended;
-            this.stats.totalAdjustments++;
-            if (recommended > oldSize) {
-                this.stats.scaleUps++;
-            }
-            else {
-                this.stats.scaleDowns++;
-            }
-        }
-        return this.currentSize;
-    }
-    /**
-     * Calculate average utilization
-     */
-    calculateAverageUtilization() {
-        if (this.utilizationSamples.length === 0)
-            return 0;
-        const sum = this.utilizationSamples.reduce((a, b) => a + b, 0);
-        return sum / this.utilizationSamples.length;
-    }
-    /**
-     * Analyze traffic trend (increasing, stable, decreasing)
-     */
-    analyzeTrafficTrend() {
-        if (this.trafficHistory.length < 10)
-            return 'stable';
-        const recent = this.trafficHistory.slice(-10);
-        const older = this.trafficHistory.slice(-20, -10);
-        if (older.length === 0)
-            return 'stable';
-        const recentAvg = recent.reduce((sum, p) => sum + p.requestRate, 0) / recent.length;
-        const olderAvg = older.reduce((sum, p) => sum + p.requestRate, 0) / older.length;
-        const change = ((recentAvg - olderAvg) / olderAvg) * 100;
-        if (change > 10)
-            return 'increasing';
-        if (change < -10)
-            return 'decreasing';
-        return 'stable';
-    }
-    /**
-     * Predict future load using simple linear regression
-     */
-    predictFutureLoad() {
-        if (this.utilizationSamples.length < 10) {
-            return this.calculateAverageUtilization();
-        }
-        const samples = this.utilizationSamples.slice(-20);
-        const n = samples.length;
-        // Simple linear regression
-        let sumX = 0, sumY = 0, sumXY = 0, sumX2 = 0;
-        for (let i = 0; i < n; i++) {
-            sumX += i;
-            sumY += samples[i];
-            sumXY += i * samples[i];
-            sumX2 += i * i;
-        }
-        const slope = (n * sumXY - sumX * sumY) / (n * sumX2 - sumX * sumX);
-        const intercept = (sumY - slope * sumX) / n;
-        // Predict next value
-        const predicted = slope * n + intercept;
-        return Math.max(0, Math.min(100, predicted));
-    }
-    /**
-     * Update statistics
-     */
-    updateStats(utilization) {
-        this.stats.utilizationPercent = utilization;
-        this.stats.activeItems = this.activeItems;
-        this.stats.avgUtilization = this.calculateAverageUtilization();
-        if (utilization > this.stats.peakUtilization) {
-            this.stats.peakUtilization = utilization;
-        }
-    }
-    /**
-     * Start automatic adjustment monitoring
-     */
-    startAdjustmentMonitoring() {
-        this.adjustmentTimer = setInterval(() => {
-            this.applyAdjustment();
-        }, this.config.adjustInterval);
-    }
-    /**
-     * Get current pool size
-     */
-    getCurrentSize() {
-        return this.currentSize;
-    }
-    /**
-     * Get statistics
-     */
-    getStats() {
-        return { ...this.stats };
-    }
-    /**
-     * Get traffic analysis
-     */
-    getTrafficAnalysis() {
-        if (this.trafficHistory.length === 0) {
-            return {
-                currentRate: 0,
-                avgRate: 0,
-                peakRate: 0,
-                trend: 'stable',
-                predictedLoad: 0
-            };
-        }
-        const rates = this.trafficHistory.map(p => p.requestRate);
-        const avgRate = rates.reduce((a, b) => a + b, 0) / rates.length;
-        const peakRate = Math.max(...rates);
-        const currentRate = this.trafficHistory[this.trafficHistory.length - 1]?.requestRate || 0;
-        return {
-            currentRate,
-            avgRate,
-            peakRate,
-            trend: this.analyzeTrafficTrend(),
-            predictedLoad: this.predictFutureLoad()
-        };
-    }
-    /**
-     * Get efficiency score (0-100)
-     */
-    getEfficiencyScore() {
-        const avgUtil = this.stats.avgUtilization;
-        const target = this.config.targetUtilization;
-        // Perfect score at target utilization
-        // Score decreases as utilization deviates from target
-        const deviation = Math.abs(avgUtil - target);
-        const score = Math.max(0, 100 - (deviation * 2));
-        return score;
-    }
-    /**
-     * Reset statistics
-     */
-    resetStats() {
-        this.stats = {
-            currentSize: this.currentSize,
-            minSize: this.config.minSize,
-            maxSize: this.config.maxSize,
-            utilizationPercent: 0,
-            activeItems: 0,
-            totalAdjustments: 0,
-            scaleUps: 0,
-            scaleDowns: 0,
-            avgUtilization: 0,
-            peakUtilization: 0
-        };
-        this.utilizationSamples = [];
-        this.trafficHistory = [];
-    }
-    /**
-     * Manually set pool size
-     */
-    setSize(size) {
-        if (size < this.config.minSize || size > this.config.maxSize) {
-            return false;
-        }
-        this.currentSize = size;
-        this.stats.currentSize = size;
-        return true;
-    }
-    /**
-     * Destroy manager and cleanup
-     */
-    destroy() {
-        if (this.adjustmentTimer) {
-            clearInterval(this.adjustmentTimer);
-        }
-    }
-}
-/**
- * Connection Pool with Adaptive Sizing
- */
-export class AdaptiveConnectionPool {
-    pool = [];
-    inUse = new Set();
-    sizingManager;
-    createFn;
-    destroyFn;
-    constructor(config, createFn, destroyFn) {
-        this.sizingManager = new AdaptivePoolSizingManager(config);
-        this.createFn = createFn;
-        this.destroyFn = destroyFn;
-        // Initialize pool to initial size
-        this.adjustPoolSize();
-    }
-    /**
-     * Acquire item from pool
-     */
-    acquire() {
-        let item = this.pool.pop();
-        if (!item) {
-            item = this.createFn();
-        }
-        this.inUse.add(item);
-        this.recordUsage();
-        return item;
-    }
-    /**
-     * Release item back to pool
-     */
-    release(item) {
-        this.inUse.delete(item);
-        const targetSize = this.sizingManager.getCurrentSize();
-        if (this.pool.length + this.inUse.size > targetSize) {
-            // Pool too large, destroy item
-            this.destroyFn(item);
-        }
-        else {
-            // Return to pool
-            this.pool.push(item);
-        }
-        this.recordUsage();
-    }
-    /**
-     * Record current usage
-     */
-    recordUsage() {
-        const active = this.inUse.size;
-        const total = this.pool.length + active;
-        this.sizingManager.recordUsage(active, total);
-    }
-    /**
-     * Adjust pool size based on recommendations
-     */
-    adjustPoolSize() {
-        const targetSize = this.sizingManager.applyAdjustment();
-        const currentTotal = this.pool.length + this.inUse.size;
-        if (targetSize > currentTotal) {
-            // Scale up - create more items
-            const needed = targetSize - currentTotal;
-            for (let i = 0; i < needed; i++) {
-                this.pool.push(this.createFn());
-            }
-        }
-        else if (targetSize < currentTotal) {
-            // Scale down - remove excess items
-            const excess = currentTotal - targetSize;
-            const toRemove = Math.min(excess, this.pool.length);
-            for (let i = 0; i < toRemove; i++) {
-                const item = this.pool.pop();
-                if (item) {
-                    this.destroyFn(item);
-                }
-            }
-        }
-    }
-    /**
-     * Get statistics
-     */
-    getStats() {
-        return {
-            ...this.sizingManager.getStats(),
-            poolSize: this.pool.length,
-            inUseCount: this.inUse.size
-        };
-    }
-    /**
-     * Destroy pool
-     */
-    destroy() {
-        // Destroy all pooled items
-        while (this.pool.length > 0) {
-            const item = this.pool.pop();
-            if (item) {
-                this.destroyFn(item);
-            }
-        }
-        this.sizingManager.destroy();
-    }
-}
-/**
- * Buffer Pool with Adaptive Sizing
- */
-export class AdaptiveBufferPool {
-    pool;
-    bufferSize;
-    constructor(config, bufferSize = 64 * 1024) {
-        this.bufferSize = bufferSize;
-        this.pool = new AdaptiveConnectionPool(config, () => Buffer.allocUnsafe(this.bufferSize), (_item) => { });
-    }
-    acquire() {
-        return this.pool.acquire();
-    }
-    release(buffer) {
-        this.pool.release(buffer);
-    }
-    getStats() {
-        return this.pool.getStats();
-    }
-    destroy() {
-        this.pool.destroy();
-    }
-}
-/**
- * Calculate resource utilization improvement
- */
-export function calculatePoolSizingSavings(oldAvgSize, newAvgSize, peakSize) {
-    const resourceSavings = oldAvgSize - newAvgSize;
-    const savingsPercent = (resourceSavings / oldAvgSize) * 100;
-    const efficiencyGain = (1 - (newAvgSize / peakSize)) * 100;
-    return {
-        resourceSavings,
-        savingsPercent,
-        efficiencyGain
-    };
-}

package/dist/utils/agentBoosterPreprocessor.d.ts

@@ -1,72 +0,0 @@
-/**
- * Agent Booster Pre-Processor
- *
- * Detects code editing intents in agent tasks and attempts Agent Booster
- * pattern matching before falling back to LLM.
- */
-export interface EditIntent {
-    type: string;
-    task: string;
-    filePath?: string;
-    originalCode?: string;
-    targetCode?: string;
-    confidence: number;
-}
-export interface PreprocessorResult {
-    success: boolean;
-    method: 'agent_booster' | 'llm_required';
-    output?: string;
-    latency?: number;
-    confidence?: number;
-    strategy?: string;
-    reason?: string;
-}
-export declare class AgentBoosterPreprocessor {
-    private confidenceThreshold;
-    private enabledIntents;
-    constructor(options?: {
-        confidenceThreshold?: number;
-        enabledIntents?: string[];
-    });
-    /**
-     * Detect if a task is a code editing intent that Agent Booster can handle
-     */
-    detectIntent(task: string): EditIntent | null;
-    /**
-     * Try to apply edit using Agent Booster
-     */
-    tryApply(intent: EditIntent): Promise<PreprocessorResult>;
-    /**
-     * Extract file path from task description
-     */
-    private extractFilePath;
-    /**
-     * Detect programming language from file extension
-     */
-    private detectLanguage;
-    /**
-     * Extract var to const transformation
-     */
-    private extractVarToConst;
-    /**
-     * Extract add types transformation (TypeScript)
-     */
-    private extractAddTypes;
-    /**
-     * Extract add error handling transformation
-     */
-    private extractAddErrorHandling;
-    /**
-     * Extract async/await transformation
-     */
-    private extractAsyncAwait;
-    /**
-     * Extract add logging transformation
-     */
-    private extractAddLogging;
-    /**
-     * Extract remove console transformation
-     */
-    private extractRemoveConsole;
-}
-//# sourceMappingURL=agentBoosterPreprocessor.d.ts.map

package/dist/utils/agentLoader.d.ts

@@ -1,22 +0,0 @@
-export interface AgentDefinition {
-    name: string;
-    description: string;
-    systemPrompt: string;
-    color?: string;
-    tools?: string[];
-    filePath: string;
-}
-/**
- * Load all agents from .claude/agents directory with deduplication
- * Local agents (.claude/agents in CWD) override package agents
- */
-export declare function loadAgents(agentsDir?: string): Map<string, AgentDefinition>;
-/**
- * Get a specific agent by name
- */
-export declare function getAgent(name: string, agentsDir?: string): AgentDefinition | undefined;
-/**
- * List all available agents
- */
-export declare function listAgents(agentsDir?: string): AgentDefinition[];
-//# sourceMappingURL=agentLoader.d.ts.map

package/dist/utils/agentdb-runtime-patch.d.ts

@@ -1,28 +0,0 @@
-/**
- * AgentDB Runtime Patch
- *
- * Automatically fixes AgentDB v1.3.9 import resolution issues at runtime.
- * This patch works in all contexts: npm install, npm install -g, and npx.
- *
- * Issue: agentdb v1.3.9 missing .js extensions in ESM exports
- * Solution: Patch the controller index.js file at runtime before first import
- */
-/**
- * Apply AgentDB import fix at runtime
- * Safe to call multiple times - only patches once
- */
-export declare function applyAgentDBPatch(): boolean;
-/**
- * Check if AgentDB patch is needed
- */
-export declare function isAgentDBPatchNeeded(): boolean;
-/**
- * Get patch status information
- */
-export declare function getAgentDBPatchStatus(): {
-    needed: boolean;
-    applied: boolean;
-    attempted: boolean;
-    location: string | null;
-};
-//# sourceMappingURL=agentdb-runtime-patch.d.ts.map

package/dist/utils/agentdbCommands.js

@@ -1,175 +0,0 @@
-/**
- * AgentDB CLI Command Handlers
- *
- * Handles all AgentDB vector database commands for the CLI
- */
-/**
- * Handle AgentDB command
- */
-export async function handleAgentDBCommand(args) {
-    const command = args[0];
-    if (!command || command === 'help') {
-        printAgentDBHelp();
-        return;
-    }
-    // Import AgentDB CLI
-    const { createAgentDBCLI } = await import('agentdb/reasoningbank/cli/commands');
-    // Create AgentDB CLI instance
-    const program = createAgentDBCLI();
-    // Run command with proper args
-    const cliArgs = ['node', 'agentdb', ...args];
-    await program.parseAsync(cliArgs);
-}
-/**
- * Print AgentDB help
- */
-function printAgentDBHelp() {
-    console.log(`
-🗄️  AgentDB - Ultra-Fast Vector Database for ReasoningBank
-
-USAGE:
-  npx agentic-flow agentdb <command> [options]
-
-COMMANDS:
-  init                    Initialize AgentDB database
-  insert                  Insert pattern with embedding
-  search                  Search for similar patterns
-  train                   Train learning model on experiences
-  stats                   Display database statistics
-  optimize                Optimize database (consolidation, pruning)
-  update <id>             Update pattern statistics
-  delete <id>             Delete pattern
-  migrate                 Migrate from legacy ReasoningBank
-  export                  Export patterns to JSON
-  import <file>           Import patterns from JSON
-
-INIT:
-  npx agentic-flow agentdb init [options]
-
-  Options:
-    -p, --path <path>       Database path (default: .agentdb/reasoningbank.db)
-    --dimension <dim>       Embedding dimension (default: 768)
-
-INSERT:
-  npx agentic-flow agentdb insert [options]
-
-  Options:
-    -e, --embedding <json>  Embedding vector (JSON array)
-    -d, --domain <domain>   Domain name
-    -p, --pattern <json>    Pattern data (JSON)
-    -c, --confidence <val>  Confidence (0-1, default: 0.5)
-
-SEARCH:
-  npx agentic-flow agentdb search [options]
-
-  Options:
-    -q, --query <json>      Query embedding (JSON array)
-    -l, --limit <n>         Result limit (default: 10)
-    -d, --domain <domain>   Filter by domain
-    --min-confidence <val>  Minimum confidence
-
-TRAIN:
-  npx agentic-flow agentdb train [options]
-
-  Options:
-    -e, --epochs <n>        Number of epochs (default: 50)
-    -b, --batch-size <n>    Batch size (default: 32)
-
-STATS:
-  npx agentic-flow agentdb stats
-
-  Displays:
-    • Total patterns
-    • Total trajectories
-    • Average confidence
-    • Domains
-    • Database size
-
-OPTIMIZE:
-  npx agentic-flow agentdb optimize
-
-  Performs:
-    • Pattern consolidation (95%+ similarity)
-    • Low-quality pattern pruning
-    • Database reindexing
-    • Space optimization
-
-UPDATE:
-  npx agentic-flow agentdb update <id> [options]
-
-  Options:
-    -c, --confidence <val>  New confidence value
-    -u, --usage <n>         Usage count
-    -s, --success <n>       Success count
-
-DELETE:
-  npx agentic-flow agentdb delete <id>
-
-MIGRATE:
-  npx agentic-flow agentdb migrate [options]
-
-  Options:
-    -s, --source <path>     Source database path (legacy)
-    -d, --destination <p>   Destination path (default: .agentdb/reasoningbank.db)
-
-  Automatically:
-    • Creates backup of source database
-    • Migrates all patterns and trajectories
-    • Validates migration
-    • Zero data loss guarantee
-
-EXPORT:
-  npx agentic-flow agentdb export [options]
-
-  Options:
-    -o, --output <file>     Output file (default: patterns.json)
-    -d, --domain <domain>   Filter by domain
-
-IMPORT:
-  npx agentic-flow agentdb import <file>
-
-EXAMPLES:
-  # Initialize database
-  npx agentic-flow agentdb init --path .agentdb/reasoningbank.db
-
-  # Search similar patterns
-  npx agentic-flow agentdb search --query '[0.1, 0.2, ...]' --limit 10
-
-  # Train learning model
-  npx agentic-flow agentdb train --epochs 50 --batch-size 32
-
-  # Get statistics
-  npx agentic-flow agentdb stats
-
-  # Optimize database
-  npx agentic-flow agentdb optimize
-
-  # Migrate from legacy
-  npx agentic-flow agentdb migrate --source .swarm/memory.db
-
-  # Export patterns
-  npx agentic-flow agentdb export --output patterns.json --domain code-generation
-
-  # Import patterns
-  npx agentic-flow agentdb import patterns.json
-
-PERFORMANCE:
-  • Pattern Search: 150x faster (100µs vs 15ms)
-  • Batch Insert: 500x faster (2ms vs 1s)
-  • Large-scale: 12,500x faster (8ms vs 100s at 1M patterns)
-  • Memory: 4-32x reduction with quantization
-
-FEATURES:
-  ✅ HNSW Vector Indexing - O(log n) search complexity
-  ✅ 9 Learning Algorithms - Decision Transformer, Q-Learning, etc.
-  ✅ 4 Reasoning Agents - Pattern Matching, Context Synthesis, etc.
-  ✅ QUIC Synchronization - Multi-agent memory sync
-  ✅ Quantization - Binary (32x), Scalar (4x), Product (8-16x)
-  ✅ 100% Backward Compatible - Drop-in replacement
-
-DOCUMENTATION:
-  Integration Guide: docs/AGENTDB_INTEGRATION.md
-  API Reference: packages/agentdb/docs/integration/IMPLEMENTATION_SUMMARY.md
-  GitHub: https://github.com/ruvnet/agentic-flow/tree/main/packages/agentdb
-`);
-}