agentic-flow 2.0.2 → 2.0.4

package/dist/reasoningbank/core/database.js

@@ -1,250 +0,0 @@
-/**
- * SQLite Database Layer for ReasoningBank
- * Handles memory storage, retrieval, and consolidation
- */
-import Database from 'better-sqlite3';
-import { ulid } from 'ulid';
-export class ReasoningBankDB {
-    db;
-    constructor(dbPath) {
-        this.db = new Database(dbPath);
-        this.db.pragma('journal_mode = WAL'); // Enable Write-Ahead Logging for concurrency
-        this.initSchema();
-    }
-    initSchema() {
-        // Main memory table
-        this.db.exec(`
-      CREATE TABLE IF NOT EXISTS reasoning_memory (
-        id TEXT PRIMARY KEY,
-        title TEXT NOT NULL,
-        description TEXT NOT NULL,
-        content TEXT NOT NULL,
-        confidence REAL DEFAULT 0.5,
-        usage_count INTEGER DEFAULT 0,
-        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-        pattern_data JSON NOT NULL
-      );
-
-      CREATE INDEX IF NOT EXISTS idx_memory_confidence ON reasoning_memory(confidence);
-      CREATE INDEX IF NOT EXISTS idx_memory_created_at ON reasoning_memory(created_at);
-      CREATE INDEX IF NOT EXISTS idx_memory_domain ON reasoning_memory(json_extract(pattern_data, '$.domain'));
-    `);
-        // Pattern embeddings table
-        this.db.exec(`
-      CREATE TABLE IF NOT EXISTS pattern_embeddings (
-        pattern_id TEXT PRIMARY KEY,
-        embedding BLOB NOT NULL,
-        FOREIGN KEY (pattern_id) REFERENCES reasoning_memory(id) ON DELETE CASCADE
-      );
-
-      CREATE INDEX IF NOT EXISTS idx_embeddings_pattern ON pattern_embeddings(pattern_id);
-    `);
-        // Task trajectory table
-        this.db.exec(`
-      CREATE TABLE IF NOT EXISTS task_trajectory (
-        id TEXT PRIMARY KEY,
-        task_id TEXT NOT NULL,
-        trajectory TEXT NOT NULL,
-        verdict TEXT NOT NULL CHECK(verdict IN ('Success', 'Failure')),
-        confidence REAL NOT NULL,
-        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-      );
-
-      CREATE INDEX IF NOT EXISTS idx_trajectory_task ON task_trajectory(task_id);
-      CREATE INDEX IF NOT EXISTS idx_trajectory_verdict ON task_trajectory(verdict);
-    `);
-        // MaTTS runs table
-        this.db.exec(`
-      CREATE TABLE IF NOT EXISTS matts_runs (
-        id TEXT PRIMARY KEY,
-        task_id TEXT NOT NULL,
-        run_index INTEGER NOT NULL,
-        result TEXT NOT NULL,
-        verdict TEXT NOT NULL CHECK(verdict IN ('Success', 'Failure')),
-        confidence REAL NOT NULL,
-        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-      );
-
-      CREATE INDEX IF NOT EXISTS idx_matts_task ON matts_runs(task_id);
-    `);
-    }
-    // Memory operations
-    insertMemory(memory) {
-        const id = ulid();
-        const stmt = this.db.prepare(`
-      INSERT INTO reasoning_memory (id, title, description, content, confidence, usage_count, pattern_data)
-      VALUES (?, ?, ?, ?, ?, ?, json(?))
-    `);
-        stmt.run(id, memory.title, memory.description, memory.content, memory.confidence, memory.usage_count, JSON.stringify(memory.pattern_data));
-        return id;
-    }
-    getMemory(id) {
-        const stmt = this.db.prepare(`
-      SELECT id, title, description, content, confidence, usage_count,
-             datetime(created_at) as created_at, pattern_data
-      FROM reasoning_memory
-      WHERE id = ?
-    `);
-        const row = stmt.get(id);
-        if (!row)
-            return null;
-        return {
-            ...row,
-            pattern_data: JSON.parse(row.pattern_data)
-        };
-    }
-    getAllMemories() {
-        const stmt = this.db.prepare(`
-      SELECT id, title, description, content, confidence, usage_count,
-             datetime(created_at) as created_at, pattern_data
-      FROM reasoning_memory
-      ORDER BY created_at DESC
-    `);
-        const rows = stmt.all();
-        return rows.map(row => ({
-            ...row,
-            pattern_data: JSON.parse(row.pattern_data)
-        }));
-    }
-    updateMemoryUsage(id) {
-        const stmt = this.db.prepare(`
-      UPDATE reasoning_memory
-      SET usage_count = usage_count + 1
-      WHERE id = ?
-    `);
-        stmt.run(id);
-    }
-    updateMemoryConfidence(id, confidence) {
-        const stmt = this.db.prepare(`
-      UPDATE reasoning_memory
-      SET confidence = ?
-      WHERE id = ?
-    `);
-        stmt.run(confidence, id);
-    }
-    deleteMemory(id) {
-        const stmt = this.db.prepare('DELETE FROM reasoning_memory WHERE id = ?');
-        stmt.run(id);
-    }
-    // Embedding operations
-    insertEmbedding(patternId, embedding) {
-        const buffer = Buffer.from(new Float64Array(embedding).buffer);
-        const stmt = this.db.prepare(`
-      INSERT OR REPLACE INTO pattern_embeddings (pattern_id, embedding)
-      VALUES (?, ?)
-    `);
-        stmt.run(patternId, buffer);
-    }
-    getEmbedding(patternId) {
-        const stmt = this.db.prepare('SELECT embedding FROM pattern_embeddings WHERE pattern_id = ?');
-        const row = stmt.get(patternId);
-        if (!row)
-            return null;
-        const buffer = row.embedding;
-        return Array.from(new Float64Array(buffer.buffer, buffer.byteOffset, buffer.byteLength / 8));
-    }
-    getAllEmbeddings() {
-        const stmt = this.db.prepare('SELECT pattern_id, embedding FROM pattern_embeddings');
-        const rows = stmt.all();
-        const embeddings = new Map();
-        for (const row of rows) {
-            const buffer = row.embedding;
-            const embedding = Array.from(new Float64Array(buffer.buffer, buffer.byteOffset, buffer.byteLength / 8));
-            embeddings.set(row.pattern_id, embedding);
-        }
-        return embeddings;
-    }
-    // Trajectory operations
-    insertTrajectory(trajectory) {
-        const id = ulid();
-        const stmt = this.db.prepare(`
-      INSERT INTO task_trajectory (id, task_id, trajectory, verdict, confidence)
-      VALUES (?, ?, ?, ?, ?)
-    `);
-        stmt.run(id, trajectory.task_id, trajectory.trajectory, trajectory.verdict, trajectory.confidence);
-        return id;
-    }
-    getTrajectories(taskId) {
-        const stmt = this.db.prepare(`
-      SELECT id, task_id, trajectory, verdict, confidence, datetime(created_at) as created_at
-      FROM task_trajectory
-      WHERE task_id = ?
-      ORDER BY created_at DESC
-    `);
-        return stmt.all(taskId);
-    }
-    // MaTTS operations
-    insertMattsRun(run) {
-        const id = ulid();
-        const stmt = this.db.prepare(`
-      INSERT INTO matts_runs (id, task_id, run_index, result, verdict, confidence)
-      VALUES (?, ?, ?, ?, ?, ?)
-    `);
-        stmt.run(id, run.task_id, run.run_index, run.result, run.verdict, run.confidence);
-        return id;
-    }
-    getMattsRuns(taskId) {
-        const stmt = this.db.prepare(`
-      SELECT id, task_id, run_index, result, verdict, confidence, datetime(created_at) as created_at
-      FROM matts_runs
-      WHERE task_id = ?
-      ORDER BY run_index ASC
-    `);
-        return stmt.all(taskId);
-    }
-    // Statistics
-    getStats() {
-        const memoryStats = this.db.prepare(`
-      SELECT COUNT(*) as total, AVG(confidence) as avg_conf, SUM(usage_count) as total_usage
-      FROM reasoning_memory
-    `).get();
-        const trajectoryStats = this.db.prepare(`
-      SELECT
-        SUM(CASE WHEN verdict = 'Success' THEN 1 ELSE 0 END) as successes,
-        COUNT(*) as total
-      FROM task_trajectory
-    `).get();
-        return {
-            totalMemories: memoryStats.total || 0,
-            avgConfidence: memoryStats.avg_conf || 0,
-            totalUsage: memoryStats.total_usage || 0,
-            successRate: trajectoryStats.total > 0
-                ? trajectoryStats.successes / trajectoryStats.total
-                : 0
-        };
-    }
-    // Consolidation helpers
-    findDuplicates(threshold = 0.95) {
-        // Returns pairs of memory IDs that are likely duplicates
-        const memories = this.getAllMemories();
-        const embeddings = this.getAllEmbeddings();
-        const duplicates = [];
-        for (let i = 0; i < memories.length; i++) {
-            for (let j = i + 1; j < memories.length; j++) {
-                const emb1 = embeddings.get(memories[i].id);
-                const emb2 = embeddings.get(memories[j].id);
-                if (emb1 && emb2) {
-                    const similarity = this.cosineSimilarity(emb1, emb2);
-                    if (similarity >= threshold) {
-                        duplicates.push([memories[i].id, memories[j].id]);
-                    }
-                }
-            }
-        }
-        return duplicates;
-    }
-    cosineSimilarity(a, b) {
-        let dotProduct = 0;
-        let normA = 0;
-        let normB = 0;
-        for (let i = 0; i < a.length; i++) {
-            dotProduct += a[i] * b[i];
-            normA += a[i] * a[i];
-            normB += b[i] * b[i];
-        }
-        return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
-    }
-    close() {
-        this.db.close();
-    }
-}

package/dist/reasoningbank/core/memory-engine.js

@@ -1,335 +0,0 @@
-/**
- * ReasoningBank Memory Engine
- * Implements the 4-phase learning loop: RETRIEVE → JUDGE → DISTILL → CONSOLIDATE
- */
-import { ReasoningBankDB } from './database.js';
-import { createEmbeddingProvider, cosineSimilarity } from '../utils/embeddings.js';
-import { piiScrubber } from '../utils/pii-scrubber.js';
-export class ReasoningBankEngine {
-    db;
-    embeddings;
-    piiEnabled;
-    weights;
-    defaultK;
-    minConfidence;
-    consolidationThreshold;
-    memoriesSinceConsolidation = 0;
-    constructor(config) {
-        this.db = new ReasoningBankDB(config.dbPath);
-        this.embeddings = createEmbeddingProvider(config.embeddings?.provider || 'hash', {
-            apiKey: process.env.OPENAI_API_KEY || process.env.ANTHROPIC_API_KEY,
-            model: config.embeddings?.model
-        });
-        this.piiEnabled = config.piiScrub?.enabled !== false;
-        this.weights = {
-            alpha: config.retrieval?.weights?.alpha || 0.65, // Similarity
-            beta: config.retrieval?.weights?.beta || 0.15, // Recency
-            gamma: config.retrieval?.weights?.gamma || 0.20, // Reliability
-            delta: config.retrieval?.weights?.delta || 0.10 // Diversity penalty
-        };
-        this.defaultK = config.retrieval?.k || 3;
-        this.minConfidence = config.retrieval?.minConfidence || 0.3;
-        this.consolidationThreshold = config.consolidation?.scheduleEvery || 20;
-    }
-    /**
-     * Phase 1: RETRIEVE - Get relevant memories using 4-factor scoring
-     */
-    async retrieve(options) {
-        const k = options.k || this.defaultK;
-        const lambda = options.lambda || 0.9;
-        // Generate query embedding
-        const queryEmbedding = await this.embeddings.generate(options.query);
-        // Get all memories
-        const allMemories = this.db.getAllMemories();
-        const embeddings = this.db.getAllEmbeddings();
-        // Filter by domain if specified
-        let candidates = allMemories;
-        if (options.domain) {
-            candidates = candidates.filter(m => m.pattern_data.domain === options.domain ||
-                m.pattern_data.domain?.startsWith(options.domain + '.'));
-        }
-        // Calculate scores for each candidate
-        const scoredCandidates = [];
-        for (const memory of candidates) {
-            const embedding = embeddings.get(memory.id);
-            if (!embedding)
-                continue;
-            // 1. Similarity score (cosine similarity)
-            const similarity = cosineSimilarity(queryEmbedding, embedding);
-            // 2. Recency score (exponential decay, 30-day half-life)
-            const ageDays = (Date.now() - new Date(memory.created_at).getTime()) / (1000 * 60 * 60 * 24);
-            const recency = Math.exp(-ageDays / 30);
-            // 3. Reliability score (confidence × sqrt(usage/10))
-            const reliability = Math.min(memory.confidence * Math.sqrt(memory.usage_count / 10), 1.0);
-            // Combined score (before diversity penalty)
-            const score = this.weights.alpha * similarity +
-                this.weights.beta * recency +
-                this.weights.gamma * reliability;
-            scoredCandidates.push({
-                ...memory,
-                score,
-                similarity,
-                recency,
-                reliability,
-                diversityPenalty: 0 // Will be calculated in MMR
-            });
-        }
-        // Sort by score
-        scoredCandidates.sort((a, b) => b.score - a.score);
-        // Apply MMR for diversity
-        const selected = this.selectWithMMR(scoredCandidates, queryEmbedding, k, lambda);
-        // Update usage counts
-        for (const memory of selected) {
-            this.db.updateMemoryUsage(memory.id);
-        }
-        // Filter by minimum confidence
-        return selected.filter(m => m.confidence >= this.minConfidence);
-    }
-    /**
-     * MMR (Maximal Marginal Relevance) Selection
-     * Balances relevance and diversity
-     */
-    selectWithMMR(candidates, queryEmbedding, k, lambda) {
-        const selected = [];
-        const remaining = [...candidates];
-        const embeddings = this.db.getAllEmbeddings();
-        while (selected.length < k && remaining.length > 0) {
-            let bestScore = -Infinity;
-            let bestIndex = -1;
-            for (let i = 0; i < remaining.length; i++) {
-                const candidate = remaining[i];
-                const candidateEmbedding = embeddings.get(candidate.id);
-                if (!candidateEmbedding)
-                    continue;
-                // Relevance to query
-                const relevance = candidate.score;
-                // Maximum similarity to already selected
-                let maxSimilarity = 0;
-                if (selected.length > 0) {
-                    for (const selectedMemory of selected) {
-                        const selectedEmbedding = embeddings.get(selectedMemory.id);
-                        if (selectedEmbedding) {
-                            const sim = cosineSimilarity(candidateEmbedding, selectedEmbedding);
-                            maxSimilarity = Math.max(maxSimilarity, sim);
-                        }
-                    }
-                }
-                // MMR score
-                const mmrScore = lambda * relevance - (1 - lambda) * maxSimilarity;
-                if (mmrScore > bestScore) {
-                    bestScore = mmrScore;
-                    bestIndex = i;
-                }
-            }
-            if (bestIndex >= 0) {
-                selected.push(remaining[bestIndex]);
-                remaining.splice(bestIndex, 1);
-            }
-            else {
-                break;
-            }
-        }
-        return selected;
-    }
-    /**
-     * Phase 2: JUDGE - Evaluate task outcome
-     */
-    async judge(trajectory) {
-        // Simple heuristic judge (can be upgraded to LLM)
-        const scrubbed = this.piiEnabled ? piiScrubber.scrub(trajectory) : trajectory;
-        // Heuristics for success/failure
-        const errorKeywords = ['error', 'failed', 'exception', 'timeout', 'unauthorized', 'forbidden'];
-        const successKeywords = ['success', 'completed', 'ok', '200', 'done'];
-        const lowerTrajectory = scrubbed.toLowerCase();
-        const hasError = errorKeywords.some(kw => lowerTrajectory.includes(kw));
-        const hasSuccess = successKeywords.some(kw => lowerTrajectory.includes(kw));
-        if (hasSuccess && !hasError) {
-            return { label: 'Success', confidence: 0.8, rationale: 'Success keywords found' };
-        }
-        else if (hasError && !hasSuccess) {
-            return { label: 'Failure', confidence: 0.8, rationale: 'Error keywords found' };
-        }
-        else if (hasSuccess && hasError) {
-            return { label: 'Success', confidence: 0.5, rationale: 'Mixed signals' };
-        }
-        else {
-            return { label: 'Failure', confidence: 0.5, rationale: 'No clear indicators' };
-        }
-    }
-    /**
-     * Phase 3: DISTILL - Extract patterns from trajectory
-     */
-    async distill(taskId, trajectory, verdict, domain) {
-        const scrubbed = this.piiEnabled ? piiScrubber.scrub(trajectory) : trajectory;
-        // Store trajectory
-        this.db.insertTrajectory({
-            task_id: taskId,
-            trajectory: scrubbed,
-            verdict: verdict.label,
-            confidence: verdict.confidence
-        });
-        // Extract pattern based on verdict
-        const pattern = verdict.label === 'Success'
-            ? this.extractSuccessPattern(scrubbed, domain)
-            : this.extractFailureGuardrail(scrubbed, domain);
-        // Store as memory
-        const memoryId = this.db.insertMemory({
-            title: pattern.title,
-            description: pattern.description,
-            content: pattern.content,
-            confidence: verdict.confidence,
-            usage_count: 0,
-            pattern_data: {
-                domain,
-                success_pattern: verdict.label === 'Success',
-                failure_guardrail: verdict.label === 'Failure'
-            }
-        });
-        // Generate and store embedding
-        const embedding = await this.embeddings.generate(pattern.content);
-        this.db.insertEmbedding(memoryId, embedding);
-        this.memoriesSinceConsolidation++;
-        return memoryId;
-    }
-    extractSuccessPattern(trajectory, domain) {
-        // Extract key steps from successful execution
-        const lines = trajectory.split('\n').filter(l => l.trim());
-        const keySteps = lines.slice(0, 5).join('\n');
-        return {
-            title: `Success pattern for ${domain}`,
-            description: `Successful execution strategy`,
-            content: `Successful approach:\n${keySteps}`
-        };
-    }
-    extractFailureGuardrail(trajectory, domain) {
-        // Extract error information
-        const lines = trajectory.split('\n').filter(l => l.trim());
-        const errorInfo = lines.find(l => l.toLowerCase().includes('error') ||
-            l.toLowerCase().includes('failed')) || 'Unknown error';
-        return {
-            title: `Failure guardrail for ${domain}`,
-            description: `Prevention strategy for common failures`,
-            content: `Avoid: ${errorInfo}\nRecommend: Check prerequisites and retry with backoff`
-        };
-    }
-    /**
-     * Phase 4: CONSOLIDATE - Deduplicate and prune
-     */
-    async consolidate(options) {
-        const startTime = Date.now();
-        const dedupeThreshold = options?.dedupeThreshold || 0.95;
-        const maxAgeDays = options?.prune?.maxAgeDays || 90;
-        const minConfidence = options?.prune?.minConfidence || 0.3;
-        const unusedDays = options?.prune?.unusedDays || 30;
-        // Find and merge duplicates
-        const duplicates = this.db.findDuplicates(dedupeThreshold);
-        for (const [id1, id2] of duplicates) {
-            const mem1 = this.db.getMemory(id1);
-            const mem2 = this.db.getMemory(id2);
-            if (mem1 && mem2) {
-                // Keep the one with higher confidence and usage
-                const keepId = mem1.confidence > mem2.confidence ||
-                    (mem1.confidence === mem2.confidence && mem1.usage_count > mem2.usage_count)
-                    ? id1 : id2;
-                const deleteId = keepId === id1 ? id2 : id1;
-                this.db.deleteMemory(deleteId);
-            }
-        }
-        // Prune old or low-quality memories
-        const allMemories = this.db.getAllMemories();
-        let pruned = 0;
-        for (const memory of allMemories) {
-            const ageDays = (Date.now() - new Date(memory.created_at).getTime()) / (1000 * 60 * 60 * 24);
-            const lastUsedDays = ageDays; // Simplified: assume last used = created
-            const shouldPrune = ageDays > maxAgeDays ||
-                memory.confidence < minConfidence ||
-                (memory.usage_count === 0 && lastUsedDays > unusedDays);
-            if (shouldPrune) {
-                this.db.deleteMemory(memory.id);
-                pruned++;
-            }
-        }
-        // Detect contradictions (simplified)
-        const contradictions = 0; // TODO: Implement semantic contradiction detection
-        this.memoriesSinceConsolidation = 0;
-        return {
-            processed: allMemories.length,
-            duplicates: duplicates.length,
-            contradictions,
-            pruned,
-            durationMs: Date.now() - startTime
-        };
-    }
-    /**
-     * High-level task execution with full learning loop
-     */
-    async runTask(options) {
-        // Phase 1: RETRIEVE
-        const memories = await this.retrieve({
-            query: options.query,
-            domain: options.domain
-        });
-        // EXECUTE
-        const result = await options.executeFn(memories);
-        // Phase 2: JUDGE
-        const verdict = await this.judge(result.log);
-        // Phase 3: DISTILL
-        await this.distill(options.taskId, result.log, verdict, options.domain);
-        // Phase 4: CONSOLIDATE (if threshold reached)
-        if (this.memoriesSinceConsolidation >= this.consolidationThreshold) {
-            await this.consolidate();
-        }
-        return {
-            success: result.success,
-            summary: `Task ${options.taskId}: ${verdict.label} (confidence: ${verdict.confidence})`,
-            memories,
-            verdict
-        };
-    }
-    /**
-     * MaTTS: Memory-aware Test-Time Scaling (Parallel)
-     */
-    async mattsParallel(options) {
-        const runs = await Promise.all(Array.from({ length: options.k }, async (_, i) => {
-            const memories = await this.retrieve({
-                query: options.query,
-                domain: options.domain
-            });
-            const result = await options.executeFn(memories);
-            const verdict = await this.judge(result.log);
-            this.db.insertMattsRun({
-                task_id: options.taskId,
-                run_index: i,
-                result: result.log,
-                verdict: verdict.label,
-                confidence: verdict.confidence
-            });
-            return { result, verdict };
-        }));
-        // Calculate consensus
-        const successes = runs.filter(r => r.verdict.label === 'Success').length;
-        const avgConfidence = runs.reduce((sum, r) => sum + r.verdict.confidence, 0) / runs.length;
-        const consensusVerdict = {
-            label: successes > runs.length / 2 ? 'Success' : 'Failure',
-            confidence: avgConfidence
-        };
-        return {
-            success: consensusVerdict.label === 'Success',
-            summary: `MaTTS Parallel: ${successes}/${runs.length} successes, consensus: ${consensusVerdict.label}`,
-            memories: [],
-            verdict: consensusVerdict
-        };
-    }
-    /**
-     * Get statistics
-     */
-    getStats() {
-        return this.db.getStats();
-    }
-    /**
-     * Close database connection
-     */
-    close() {
-        this.db.close();
-    }
-}