agentic-flow 2.0.2-alpha → 2.0.3

package/dist/agentdb/controllers/SkillLibrary.js

@@ -0,0 +1,276 @@
+/**
+ * SkillLibrary - Lifelong Learning Skill Management
+ *
+ * Promotes high-reward trajectories into reusable skills.
+ * Manages skill composition, relationships, and adaptive selection.
+ *
+ * Based on: "Voyager: An Open-Ended Embodied Agent with Large Language Models"
+ * https://arxiv.org/abs/2305.16291
+ */
+export class SkillLibrary {
+    db;
+    embedder;
+    constructor(db, embedder) {
+        this.db = db;
+        this.embedder = embedder;
+    }
+    /**
+     * Create a new skill manually or from an episode
+     */
+    async createSkill(skill) {
+        const stmt = this.db.prepare(`
+      INSERT INTO skills (
+        name, description, signature, code, success_rate, uses,
+        avg_reward, avg_latency_ms, created_from_episode, metadata
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+        const result = stmt.run(skill.name, skill.description || null, JSON.stringify(skill.signature), skill.code || null, skill.successRate, skill.uses, skill.avgReward, skill.avgLatencyMs, skill.createdFromEpisode || null, skill.metadata ? JSON.stringify(skill.metadata) : null);
+        const skillId = result.lastInsertRowid;
+        // Generate and store embedding
+        const text = this.buildSkillText(skill);
+        const embedding = await this.embedder.embed(text);
+        this.storeSkillEmbedding(skillId, embedding);
+        return skillId;
+    }
+    /**
+     * Update skill statistics after use
+     */
+    updateSkillStats(skillId, success, reward, latencyMs) {
+        const stmt = this.db.prepare(`
+      UPDATE skills
+      SET
+        uses = uses + 1,
+        success_rate = (success_rate * uses + ?) / (uses + 1),
+        avg_reward = (avg_reward * uses + ?) / (uses + 1),
+        avg_latency_ms = (avg_latency_ms * uses + ?) / (uses + 1)
+      WHERE id = ?
+    `);
+        stmt.run(success ? 1 : 0, reward, latencyMs, skillId);
+    }
+    /**
+     * Retrieve skills relevant to a task
+     */
+    async searchSkills(query) {
+        return this.retrieveSkills(query);
+    }
+    async retrieveSkills(query) {
+        const { task, k = 5, minSuccessRate = 0.5, preferRecent = true } = query;
+        // Generate query embedding
+        const queryEmbedding = await this.embedder.embed(task);
+        // Build filters
+        const filters = ['s.success_rate >= ?'];
+        const params = [minSuccessRate];
+        const stmt = this.db.prepare(`
+      SELECT
+        s.*,
+        se.embedding
+      FROM skills s
+      JOIN skill_embeddings se ON s.id = se.skill_id
+      WHERE ${filters.join(' AND ')}
+      ORDER BY ${preferRecent ? 's.last_used_at DESC,' : ''} s.success_rate DESC
+    `);
+        const rows = stmt.all(...params);
+        // Calculate similarities and rank
+        const skills = rows.map(row => {
+            const embedding = this.deserializeEmbedding(row.embedding);
+            const similarity = this.cosineSimilarity(queryEmbedding, embedding);
+            return {
+                id: row.id,
+                name: row.name,
+                description: row.description,
+                signature: JSON.parse(row.signature),
+                code: row.code,
+                successRate: row.success_rate,
+                uses: row.uses,
+                avgReward: row.avg_reward,
+                avgLatencyMs: row.avg_latency_ms,
+                createdFromEpisode: row.created_from_episode,
+                metadata: row.metadata ? JSON.parse(row.metadata) : undefined,
+                similarity
+            };
+        });
+        // Compute composite scores
+        skills.sort((a, b) => {
+            const scoreA = this.computeSkillScore(a);
+            const scoreB = this.computeSkillScore(b);
+            return scoreB - scoreA;
+        });
+        return skills.slice(0, k);
+    }
+    /**
+     * Link two skills with a relationship
+     */
+    linkSkills(link) {
+        const stmt = this.db.prepare(`
+      INSERT INTO skill_links (parent_skill_id, child_skill_id, relationship, weight, metadata)
+      VALUES (?, ?, ?, ?, ?)
+      ON CONFLICT(parent_skill_id, child_skill_id, relationship)
+      DO UPDATE SET weight = excluded.weight
+    `);
+        stmt.run(link.parentSkillId, link.childSkillId, link.relationship, link.weight, link.metadata ? JSON.stringify(link.metadata) : null);
+    }
+    /**
+     * Get skill composition plan (prerequisites and alternatives)
+     */
+    getSkillPlan(skillId) {
+        // Get main skill
+        const skill = this.getSkillById(skillId);
+        // Get prerequisites
+        const prereqStmt = this.db.prepare(`
+      SELECT s.* FROM skills s
+      JOIN skill_links sl ON s.id = sl.child_skill_id
+      WHERE sl.parent_skill_id = ? AND sl.relationship = 'prerequisite'
+      ORDER BY sl.weight DESC
+    `);
+        const prerequisites = prereqStmt.all(skillId).map(this.rowToSkill);
+        // Get alternatives
+        const altStmt = this.db.prepare(`
+      SELECT s.* FROM skills s
+      JOIN skill_links sl ON s.id = sl.child_skill_id
+      WHERE sl.parent_skill_id = ? AND sl.relationship = 'alternative'
+      ORDER BY sl.weight DESC, s.success_rate DESC
+    `);
+        const alternatives = altStmt.all(skillId).map(this.rowToSkill);
+        // Get refinements
+        const refStmt = this.db.prepare(`
+      SELECT s.* FROM skills s
+      JOIN skill_links sl ON s.id = sl.child_skill_id
+      WHERE sl.parent_skill_id = ? AND sl.relationship = 'refinement'
+      ORDER BY sl.weight DESC, s.created_at DESC
+    `);
+        const refinements = refStmt.all(skillId).map(this.rowToSkill);
+        return { skill, prerequisites, alternatives, refinements };
+    }
+    /**
+     * Consolidate high-reward episodes into skills
+     * This is the core learning mechanism
+     */
+    consolidateEpisodesIntoSkills(config) {
+        const { minAttempts = 3, minReward = 0.7, timeWindowDays = 7 } = config;
+        const stmt = this.db.prepare(`
+      SELECT
+        task,
+        COUNT(*) as attempt_count,
+        AVG(reward) as avg_reward,
+        AVG(success) as success_rate,
+        AVG(latency_ms) as avg_latency,
+        MAX(id) as latest_episode_id,
+        GROUP_CONCAT(id) as episode_ids
+      FROM episodes
+      WHERE ts > strftime('%s', 'now') - ?
+        AND reward >= ?
+      GROUP BY task
+      HAVING attempt_count >= ?
+    `);
+        const candidates = stmt.all(timeWindowDays * 86400, minReward, minAttempts);
+        let created = 0;
+        for (const candidate of candidates) {
+            // Check if skill already exists
+            const existing = this.db.prepare('SELECT id FROM skills WHERE name = ?').get(candidate.task);
+            if (!existing) {
+                // Create new skill
+                const skill = {
+                    name: candidate.task,
+                    description: `Auto-generated skill from successful episodes`,
+                    signature: {
+                        inputs: { task: 'string' },
+                        outputs: { result: 'any' }
+                    },
+                    successRate: candidate.success_rate,
+                    uses: candidate.attempt_count,
+                    avgReward: candidate.avg_reward,
+                    avgLatencyMs: candidate.avg_latency || 0,
+                    createdFromEpisode: candidate.latest_episode_id,
+                    metadata: {
+                        sourceEpisodes: candidate.episode_ids.split(',').map(Number),
+                        autoGenerated: true,
+                        consolidatedAt: Date.now()
+                    }
+                };
+                this.createSkill(skill).catch(err => {
+                    console.error('Error creating skill:', err);
+                });
+                created++;
+            }
+            else {
+                // Update existing skill stats
+                this.updateSkillStats(existing.id, candidate.success_rate > 0.5, candidate.avg_reward, candidate.avg_latency || 0);
+            }
+        }
+        return created;
+    }
+    /**
+     * Prune underperforming skills
+     */
+    pruneSkills(config) {
+        const { minUses = 3, minSuccessRate = 0.4, maxAgeDays = 60 } = config;
+        const stmt = this.db.prepare(`
+      DELETE FROM skills
+      WHERE uses < ?
+        AND success_rate < ?
+        AND created_at < strftime('%s', 'now') - ?
+    `);
+        const result = stmt.run(minUses, minSuccessRate, maxAgeDays * 86400);
+        return result.changes;
+    }
+    // ========================================================================
+    // Private Helper Methods
+    // ========================================================================
+    getSkillById(id) {
+        const stmt = this.db.prepare('SELECT * FROM skills WHERE id = ?');
+        const row = stmt.get(id);
+        if (!row)
+            throw new Error(`Skill ${id} not found`);
+        return this.rowToSkill(row);
+    }
+    rowToSkill(row) {
+        return {
+            id: row.id,
+            name: row.name,
+            description: row.description,
+            signature: JSON.parse(row.signature),
+            code: row.code,
+            successRate: row.success_rate,
+            uses: row.uses,
+            avgReward: row.avg_reward,
+            avgLatencyMs: row.avg_latency_ms,
+            createdFromEpisode: row.created_from_episode,
+            metadata: row.metadata ? JSON.parse(row.metadata) : undefined
+        };
+    }
+    buildSkillText(skill) {
+        const parts = [skill.name];
+        if (skill.description)
+            parts.push(skill.description);
+        parts.push(JSON.stringify(skill.signature));
+        return parts.join('\n');
+    }
+    storeSkillEmbedding(skillId, embedding) {
+        const stmt = this.db.prepare(`
+      INSERT INTO skill_embeddings (skill_id, embedding)
+      VALUES (?, ?)
+    `);
+        stmt.run(skillId, Buffer.from(embedding.buffer));
+    }
+    deserializeEmbedding(buffer) {
+        return new Float32Array(buffer.buffer, buffer.byteOffset, buffer.length / 4);
+    }
+    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));
+    }
+    computeSkillScore(skill) {
+        // Composite score: similarity * 0.4 + success_rate * 0.3 + (uses/1000) * 0.1 + avg_reward * 0.2
+        return (skill.similarity * 0.4 +
+            skill.successRate * 0.3 +
+            Math.min(skill.uses / 1000, 1.0) * 0.1 +
+            skill.avgReward * 0.2);
+    }
+}

package/dist/agentdb/controllers/frontier-index.js

@@ -0,0 +1,9 @@
+/**
+ * AgentDB Frontier Features
+ *
+ * State-of-the-art memory capabilities
+ */
+export { CausalMemoryGraph } from './CausalMemoryGraph';
+export { ExplainableRecall } from './ExplainableRecall';
+export { CausalRecall } from './CausalRecall';
+export { NightlyLearner } from './NightlyLearner';

package/dist/agentdb/controllers/index.js

@@ -0,0 +1,8 @@
+/**
+ * AgentDB Controllers - State-of-the-Art Memory Systems
+ *
+ * Export all memory controllers for agent systems
+ */
+export { ReflexionMemory } from './ReflexionMemory';
+export { SkillLibrary } from './SkillLibrary';
+export { EmbeddingService } from './EmbeddingService';

package/dist/agentdb/index.d.ts

@@ -0,0 +1,26 @@
+/**
+ * AgentDB Re-exports for Backwards Compatibility
+ *
+ * This module provides backwards-compatible exports for code that previously
+ * used embedded AgentDB controllers. Now proxies to agentdb npm package.
+ *
+ * @deprecated Import directly from specific agentdb paths for better tree-shaking
+ * @since v1.7.0 - Integrated agentdb as proper dependency
+ *
+ * Example migration:
+ * ```typescript
+ * // Old (still works)
+ * import { ReflexionMemory } from 'agentic-flow/agentdb';
+ *
+ * // New (recommended)
+ * import { ReflexionMemory } from 'agentdb/controllers/ReflexionMemory';
+ * ```
+ */
+export { ReflexionMemory } from 'agentdb';
+export { SkillLibrary } from 'agentdb';
+export { EmbeddingService } from 'agentdb';
+export { CausalMemoryGraph } from 'agentdb';
+export { CausalRecall } from 'agentdb';
+export { NightlyLearner } from 'agentdb';
+export { ExplainableRecall } from 'agentdb';
+//# sourceMappingURL=index.d.ts.map

package/dist/agentdb/optimizations/BatchOperations.js

@@ -0,0 +1,198 @@
+/**
+ * BatchOperations - Optimized Batch Processing for AgentDB
+ *
+ * Implements efficient batch operations:
+ * - Bulk inserts with transactions
+ * - Batch embedding generation
+ * - Parallel processing
+ * - Progress tracking
+ */
+export class BatchOperations {
+    db;
+    embedder;
+    config;
+    constructor(db, embedder, config) {
+        this.db = db;
+        this.embedder = embedder;
+        this.config = {
+            batchSize: 100,
+            parallelism: 4,
+            ...config
+        };
+    }
+    /**
+     * Bulk insert episodes with embeddings
+     */
+    async insertEpisodes(episodes) {
+        const totalBatches = Math.ceil(episodes.length / this.config.batchSize);
+        let completed = 0;
+        for (let i = 0; i < episodes.length; i += this.config.batchSize) {
+            const batch = episodes.slice(i, i + this.config.batchSize);
+            // Generate embeddings in parallel
+            const texts = batch.map(ep => this.buildEpisodeText(ep));
+            const embeddings = await this.embedder.embedBatch(texts);
+            // Insert with transaction
+            const transaction = this.db.transaction(() => {
+                const episodeStmt = this.db.prepare(`
+          INSERT INTO episodes (
+            session_id, task, input, output, critique, reward, success,
+            latency_ms, tokens_used, tags, metadata
+          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        `);
+                const embeddingStmt = this.db.prepare(`
+          INSERT INTO episode_embeddings (episode_id, embedding)
+          VALUES (?, ?)
+        `);
+                batch.forEach((episode, idx) => {
+                    const result = episodeStmt.run(episode.sessionId, episode.task, episode.input || null, episode.output || null, episode.critique || null, episode.reward, episode.success ? 1 : 0, episode.latencyMs || null, episode.tokensUsed || null, episode.tags ? JSON.stringify(episode.tags) : null, episode.metadata ? JSON.stringify(episode.metadata) : null);
+                    const episodeId = result.lastInsertRowid;
+                    embeddingStmt.run(episodeId, Buffer.from(embeddings[idx].buffer));
+                });
+            });
+            transaction();
+            completed += batch.length;
+            if (this.config.progressCallback) {
+                this.config.progressCallback(completed, episodes.length);
+            }
+        }
+        return completed;
+    }
+    /**
+     * Bulk update embeddings for existing episodes
+     */
+    async regenerateEmbeddings(episodeIds) {
+        let episodes;
+        if (episodeIds) {
+            const placeholders = episodeIds.map(() => '?').join(',');
+            episodes = this.db.prepare(`SELECT id, task, critique, output FROM episodes WHERE id IN (${placeholders})`).all(...episodeIds);
+        }
+        else {
+            episodes = this.db.prepare('SELECT id, task, critique, output FROM episodes').all();
+        }
+        let completed = 0;
+        const totalBatches = Math.ceil(episodes.length / this.config.batchSize);
+        for (let i = 0; i < episodes.length; i += this.config.batchSize) {
+            const batch = episodes.slice(i, i + this.config.batchSize);
+            // Generate embeddings
+            const texts = batch.map((ep) => [ep.task, ep.critique, ep.output].filter(Boolean).join('\n'));
+            const embeddings = await this.embedder.embedBatch(texts);
+            // Update with transaction
+            const transaction = this.db.transaction(() => {
+                const stmt = this.db.prepare(`
+          INSERT OR REPLACE INTO episode_embeddings (episode_id, embedding)
+          VALUES (?, ?)
+        `);
+                batch.forEach((episode, idx) => {
+                    stmt.run(episode.id, Buffer.from(embeddings[idx].buffer));
+                });
+            });
+            transaction();
+            completed += batch.length;
+            if (this.config.progressCallback) {
+                this.config.progressCallback(completed, episodes.length);
+            }
+        }
+        return completed;
+    }
+    /**
+     * Parallel batch processing with worker pool
+     */
+    async processInParallel(items, processor) {
+        const results = [];
+        const chunks = this.chunkArray(items, this.config.parallelism);
+        for (const chunk of chunks) {
+            const chunkResults = await Promise.all(chunk.map(item => processor(item)));
+            results.push(...chunkResults);
+            if (this.config.progressCallback) {
+                this.config.progressCallback(results.length, items.length);
+            }
+        }
+        return results;
+    }
+    /**
+     * Bulk delete with conditions
+     */
+    bulkDelete(table, conditions) {
+        const whereClause = Object.keys(conditions)
+            .map(key => `${key} = ?`)
+            .join(' AND ');
+        const values = Object.values(conditions);
+        const stmt = this.db.prepare(`DELETE FROM ${table} WHERE ${whereClause}`);
+        const result = stmt.run(...values);
+        return result.changes;
+    }
+    /**
+     * Bulk update with conditions
+     */
+    bulkUpdate(table, updates, conditions) {
+        const setClause = Object.keys(updates)
+            .map(key => `${key} = ?`)
+            .join(', ');
+        const whereClause = Object.keys(conditions)
+            .map(key => `${key} = ?`)
+            .join(' AND ');
+        const values = [...Object.values(updates), ...Object.values(conditions)];
+        const stmt = this.db.prepare(`UPDATE ${table} SET ${setClause} WHERE ${whereClause}`);
+        const result = stmt.run(...values);
+        return result.changes;
+    }
+    /**
+     * Vacuum and optimize database
+     */
+    optimize() {
+        console.log('🔧 Optimizing database...');
+        // Analyze tables for query planner
+        this.db.exec('ANALYZE');
+        // Rebuild indexes
+        const tables = this.db.prepare(`
+      SELECT name FROM sqlite_master
+      WHERE type='table' AND name NOT LIKE 'sqlite_%'
+    `).all();
+        for (const { name } of tables) {
+            this.db.exec(`REINDEX ${name}`);
+        }
+        // Vacuum to reclaim space
+        this.db.exec('VACUUM');
+        console.log('✅ Database optimized');
+    }
+    /**
+     * Get database statistics
+     */
+    getStats() {
+        const pageSize = this.db.pragma('page_size', { simple: true });
+        const pageCount = this.db.pragma('page_count', { simple: true });
+        const totalSize = pageSize * pageCount;
+        const tables = this.db.prepare(`
+      SELECT name FROM sqlite_master
+      WHERE type='table' AND name NOT LIKE 'sqlite_%'
+    `).all();
+        const tableStats = tables.map(({ name }) => {
+            const count = this.db.prepare(`SELECT COUNT(*) as count FROM ${name}`).get();
+            const pages = this.db.prepare(`SELECT COUNT(*) as count FROM dbstat WHERE name = ?`).get(name);
+            return {
+                name,
+                rows: count.count,
+                size: (pages?.count || 0) * pageSize
+            };
+        });
+        return { totalSize, tableStats };
+    }
+    // ========================================================================
+    // Private Methods
+    // ========================================================================
+    buildEpisodeText(episode) {
+        const parts = [episode.task];
+        if (episode.critique)
+            parts.push(episode.critique);
+        if (episode.output)
+            parts.push(episode.output);
+        return parts.join('\n');
+    }
+    chunkArray(array, size) {
+        const chunks = [];
+        for (let i = 0; i < array.length; i += size) {
+            chunks.push(array.slice(i, i + size));
+        }
+        return chunks;
+    }
+}