agentdb 1.1.6 → 1.1.8

package/dist/cli/agentdb-cli.js

@@ -56,7 +56,8 @@ class AgentDBCLI {
         this.db.pragma('journal_mode = WAL');
         this.db.pragma('synchronous = NORMAL');
         this.db.pragma('cache_size = -64000');
-        // Load schemas (base + frontier)
+        // Load schema if needed
+        // Load both base schema and frontier schema
         const baseSchemaPath = path.join(__dirname, '../schemas/schema.sql');
         const frontierSchemaPath = path.join(__dirname, '../schemas/frontier-schema.sql');
 
@@ -115,9 +116,14 @@ class AgentDBCLI {
         log.info(`Cause: ${params.cause}`);
         log.info(`Effect: ${params.effect}`);
         const expId = this.causalGraph.createExperiment({
-            name: params.name,
-            cause: params.cause,
-            effect: params.effect
+            hypothesis: params.name,
+            treatmentId: 0,
+            treatmentType: params.cause,
+            controlId: null,
+            startTime: Date.now(),
+            sampleSize: 0,
+            status: 'running',
+            metadata: { effect: params.effect }
         });
         log.success(`Created experiment #${expId}`);
         log.info('Use `agentdb causal experiment add-observation` to record data');
@@ -125,10 +131,14 @@ class AgentDBCLI {
     async causalExperimentAddObservation(params) {
         if (!this.causalGraph)
             throw new Error('Not initialized');
+        // Create a dummy episode to get an episode ID
+        const episodeId = this.db.prepare('INSERT INTO episodes (session_id, task, reward, success, created_at) VALUES (?, ?, ?, ?, ?)').run('cli-session', 'experiment', params.outcome, true, Date.now()).lastInsertRowid;
         this.causalGraph.recordObservation({
             experimentId: params.experimentId,
+            episodeId: episodeId,
             isTreatment: params.isTreatment,
-            outcome: params.outcome,
+            outcomeValue: params.outcome,
+            outcomeType: 'reward',
             context: params.context || '{}'
         });
         log.success(`Recorded ${params.isTreatment ? 'treatment' : 'control'} observation: ${params.outcome}`);
@@ -138,10 +148,13 @@ class AgentDBCLI {
             throw new Error('Not initialized');
         log.header('\n📈 Calculating Uplift');
         const result = this.causalGraph.calculateUplift(experimentId);
+        // Fetch experiment details
+        const experiment = this.db.prepare('SELECT * FROM causal_experiments WHERE id = ?').get(experimentId);
+        log.info(`Experiment: ${experiment?.hypothesis || 'Unknown'}`);
         log.info(`Treatment Mean: ${result.treatmentMean.toFixed(3)}`);
         log.info(`Control Mean: ${result.controlMean.toFixed(3)}`);
         log.success(`Uplift: ${result.uplift.toFixed(3)}`);
-        log.info(`95% CI: [${result.confidenceLower.toFixed(3)}, ${result.confidenceUpper.toFixed(3)}]`);
+        log.info(`95% CI: [${result.confidenceInterval[0].toFixed(3)}, ${result.confidenceInterval[1].toFixed(3)}]`);
         log.info(`p-value: ${result.pValue.toFixed(4)}`);
         log.info(`Sample Sizes: ${result.treatmentN} treatment, ${result.controlN} control`);
         if (result.pValue < 0.05) {
@@ -155,9 +168,10 @@ class AgentDBCLI {
         if (!this.causalGraph)
             throw new Error('Not initialized');
         log.header('\n🔍 Querying Causal Edges');
-        const edges = this.causalGraph.getCausalEffects({
-            cause: params.cause,
-            effect: params.effect,
+        const edges = this.causalGraph.queryCausalEffects({
+            interventionMemoryId: 0,
+            interventionMemoryType: params.cause,
+            outcomeMemoryId: params.effect ? 0 : undefined,
             minConfidence: params.minConfidence || 0.7,
             minUplift: params.minUplift || 0.1
         });
@@ -167,9 +181,9 @@ class AgentDBCLI {
         }
         console.log('\n' + '═'.repeat(80));
         edges.slice(0, params.limit || 10).forEach((edge, i) => {
-            console.log(`${colors.bright}#${i + 1}: ${edge.cause} → ${edge.effect}${colors.reset}`);
+            console.log(`${colors.bright}#${i + 1}: ${edge.from_memory_type} → ${edge.to_memory_type}${colors.reset}`);
             console.log(`  Uplift: ${colors.green}${edge.uplift.toFixed(3)}${colors.reset}`);
-            console.log(`  Confidence: ${edge.confidence.toFixed(2)} (n=${edge.sampleSize})`);
+            console.log(`  Confidence: ${edge.confidence.toFixed(2)} (n=${edge.sample_size})`);
             console.log('─'.repeat(80));
         });
         log.success(`Found ${edges.length} causal edges`);
@@ -184,21 +198,12 @@ class AgentDBCLI {
         log.info(`Query: "${params.query}"`);
         log.info(`k: ${params.k || 12}`);
         const startTime = Date.now();
-        const result = await this.causalRecall.recall({
-            qid: 'cli-' + Date.now(),
-            query: params.query,
-            k: params.k || 12,
-            weights: {
-                alpha: params.alpha || 0.7,
-                beta: params.beta || 0.2,
-                gamma: params.gamma || 0.1
-            }
-        });
+        const result = await this.causalRecall.recall('cli-' + Date.now(), params.query, params.k || 12, undefined, 'internal');
         const duration = Date.now() - startTime;
         console.log('\n' + '═'.repeat(80));
-        console.log(`${colors.bright}Results (${result.results.length})${colors.reset}`);
+        console.log(`${colors.bright}Results (${result.candidates.length})${colors.reset}`);
         console.log('═'.repeat(80));
-        result.results.slice(0, 5).forEach((r, i) => {
+        result.candidates.slice(0, 5).forEach((r, i) => {
             console.log(`\n${colors.bright}#${i + 1}: Episode ${r.episode.id}${colors.reset}`);
             console.log(`  Task: ${r.episode.task}`);
             console.log(`  Similarity: ${colors.cyan}${r.similarity.toFixed(3)}${colors.reset}`);
@@ -725,12 +730,10 @@ ${colors.bright}EXAMPLES:${colors.reset}
   agentdb db stats
 `);
 }
-// ESM entry point - run when executed directly
+// ESM entry point check
 if (import.meta.url.startsWith('file:')) {
-    const modulePath = import.meta.url.slice(7); // Remove 'file://'
+    const modulePath = import.meta.url.slice(7);
     const scriptPath = process.argv[1];
-
-    // Run if this file is being executed (handles both direct execution and npx/global bin)
     if (modulePath.includes('agentdb-cli.js') || scriptPath?.includes('agentdb')) {
         main().catch(console.error);
     }

package/dist/cli/agentdb-cli.js.backup

@@ -0,0 +1,718 @@
+#!/usr/bin/env node
+/**
+ * AgentDB CLI - Command-line interface for frontier memory features
+ *
+ * Provides commands for:
+ * - Causal memory graph operations
+ * - Explainable recall with certificates
+ * - Nightly learner automation
+ * - Database management
+ */
+import Database from 'better-sqlite3';
+import { CausalMemoryGraph } from '../controllers/CausalMemoryGraph.js';
+import { CausalRecall } from '../controllers/CausalRecall.js';
+import { ExplainableRecall } from '../controllers/ExplainableRecall.js';
+import { NightlyLearner } from '../controllers/NightlyLearner.js';
+import { ReflexionMemory } from '../controllers/ReflexionMemory.js';
+import { SkillLibrary } from '../controllers/SkillLibrary.js';
+import { EmbeddingService } from '../controllers/EmbeddingService.js';
+import * as fs from 'fs';
+import * as path from 'path';
+// Color codes for terminal output
+const colors = {
+    reset: '\x1b[0m',
+    bright: '\x1b[1m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    blue: '\x1b[34m',
+    red: '\x1b[31m',
+    cyan: '\x1b[36m'
+};
+const log = {
+    success: (msg) => console.log(`${colors.green}✅ ${msg}${colors.reset}`),
+    error: (msg) => console.error(`${colors.red}❌ ${msg}${colors.reset}`),
+    info: (msg) => console.log(`${colors.blue}ℹ ${msg}${colors.reset}`),
+    warning: (msg) => console.log(`${colors.yellow}⚠ ${msg}${colors.reset}`),
+    header: (msg) => console.log(`${colors.bright}${colors.cyan}${msg}${colors.reset}`)
+};
+class AgentDBCLI {
+    db;
+    causalGraph;
+    causalRecall;
+    explainableRecall;
+    nightlyLearner;
+    reflexion;
+    skills;
+    embedder;
+    async initialize(dbPath = './agentdb.db') {
+        // Initialize database
+        this.db = new Database(dbPath);
+        // Configure for performance
+        this.db.pragma('journal_mode = WAL');
+        this.db.pragma('synchronous = NORMAL');
+        this.db.pragma('cache_size = -64000');
+        // Load schema if needed
+        const schemaPath = path.join(__dirname, '../schemas/frontier-schema.sql');
+        if (fs.existsSync(schemaPath)) {
+            const schema = fs.readFileSync(schemaPath, 'utf-8');
+            this.db.exec(schema);
+        }
+        // Initialize embedding service
+        this.embedder = new EmbeddingService({
+            model: 'all-MiniLM-L6-v2',
+            dimension: 384,
+            provider: 'transformers'
+        });
+        await this.embedder.initialize();
+        // Initialize controllers
+        this.causalGraph = new CausalMemoryGraph(this.db);
+        this.explainableRecall = new ExplainableRecall(this.db);
+        this.causalRecall = new CausalRecall(this.db, this.embedder, this.causalGraph, this.explainableRecall);
+        this.nightlyLearner = new NightlyLearner(this.db, this.embedder, this.causalGraph);
+        this.reflexion = new ReflexionMemory(this.db, this.embedder);
+        this.skills = new SkillLibrary(this.db, this.embedder);
+    }
+    // ============================================================================
+    // Causal Commands
+    // ============================================================================
+    async causalAddEdge(params) {
+        if (!this.causalGraph)
+            throw new Error('Not initialized');
+        log.header('\n📊 Adding Causal Edge');
+        log.info(`Cause: ${params.cause}`);
+        log.info(`Effect: ${params.effect}`);
+        log.info(`Uplift: ${params.uplift}`);
+        const edgeId = this.causalGraph.addEdge({
+            cause: params.cause,
+            effect: params.effect,
+            uplift: params.uplift,
+            confidence: params.confidence || 0.95,
+            sampleSize: params.sampleSize || 0,
+            evidenceIds: []
+        });
+        log.success(`Added causal edge #${edgeId}`);
+    }
+    async causalExperimentCreate(params) {
+        if (!this.causalGraph)
+            throw new Error('Not initialized');
+        log.header('\n🧪 Creating A/B Experiment');
+        log.info(`Name: ${params.name}`);
+        log.info(`Cause: ${params.cause}`);
+        log.info(`Effect: ${params.effect}`);
+        const expId = this.causalGraph.createExperiment({
+            name: params.name,
+            cause: params.cause,
+            effect: params.effect
+        });
+        log.success(`Created experiment #${expId}`);
+        log.info('Use `agentdb causal experiment add-observation` to record data');
+    }
+    async causalExperimentAddObservation(params) {
+        if (!this.causalGraph)
+            throw new Error('Not initialized');
+        this.causalGraph.recordObservation({
+            experimentId: params.experimentId,
+            isTreatment: params.isTreatment,
+            outcome: params.outcome,
+            context: params.context || '{}'
+        });
+        log.success(`Recorded ${params.isTreatment ? 'treatment' : 'control'} observation: ${params.outcome}`);
+    }
+    async causalExperimentCalculate(experimentId) {
+        if (!this.causalGraph)
+            throw new Error('Not initialized');
+        log.header('\n📈 Calculating Uplift');
+        const result = this.causalGraph.calculateUplift(experimentId);
+        log.info(`Treatment Mean: ${result.treatmentMean.toFixed(3)}`);
+        log.info(`Control Mean: ${result.controlMean.toFixed(3)}`);
+        log.success(`Uplift: ${result.uplift.toFixed(3)}`);
+        log.info(`95% CI: [${result.confidenceLower.toFixed(3)}, ${result.confidenceUpper.toFixed(3)}]`);
+        log.info(`p-value: ${result.pValue.toFixed(4)}`);
+        log.info(`Sample Sizes: ${result.treatmentN} treatment, ${result.controlN} control`);
+        if (result.pValue < 0.05) {
+            log.success('Result is statistically significant (p < 0.05)');
+        }
+        else {
+            log.warning('Result is not statistically significant');
+        }
+    }
+    async causalQuery(params) {
+        if (!this.causalGraph)
+            throw new Error('Not initialized');
+        log.header('\n🔍 Querying Causal Edges');
+        const edges = this.causalGraph.getCausalEffects({
+            cause: params.cause,
+            effect: params.effect,
+            minConfidence: params.minConfidence || 0.7,
+            minUplift: params.minUplift || 0.1
+        });
+        if (edges.length === 0) {
+            log.warning('No causal edges found');
+            return;
+        }
+        console.log('\n' + '═'.repeat(80));
+        edges.slice(0, params.limit || 10).forEach((edge, i) => {
+            console.log(`${colors.bright}#${i + 1}: ${edge.cause} → ${edge.effect}${colors.reset}`);
+            console.log(`  Uplift: ${colors.green}${edge.uplift.toFixed(3)}${colors.reset}`);
+            console.log(`  Confidence: ${edge.confidence.toFixed(2)} (n=${edge.sampleSize})`);
+            console.log('─'.repeat(80));
+        });
+        log.success(`Found ${edges.length} causal edges`);
+    }
+    // ============================================================================
+    // Recall Commands
+    // ============================================================================
+    async recallWithCertificate(params) {
+        if (!this.causalRecall)
+            throw new Error('Not initialized');
+        log.header('\n🔍 Causal Recall with Certificate');
+        log.info(`Query: "${params.query}"`);
+        log.info(`k: ${params.k || 12}`);
+        const startTime = Date.now();
+        const result = await this.causalRecall.recall({
+            qid: 'cli-' + Date.now(),
+            query: params.query,
+            k: params.k || 12,
+            weights: {
+                alpha: params.alpha || 0.7,
+                beta: params.beta || 0.2,
+                gamma: params.gamma || 0.1
+            }
+        });
+        const duration = Date.now() - startTime;
+        console.log('\n' + '═'.repeat(80));
+        console.log(`${colors.bright}Results (${result.results.length})${colors.reset}`);
+        console.log('═'.repeat(80));
+        result.results.slice(0, 5).forEach((r, i) => {
+            console.log(`\n${colors.bright}#${i + 1}: Episode ${r.episode.id}${colors.reset}`);
+            console.log(`  Task: ${r.episode.task}`);
+            console.log(`  Similarity: ${colors.cyan}${r.similarity.toFixed(3)}${colors.reset}`);
+            console.log(`  Uplift: ${colors.green}${r.uplift?.toFixed(3) || 'N/A'}${colors.reset}`);
+            console.log(`  Utility: ${colors.yellow}${r.utility.toFixed(3)}${colors.reset}`);
+            console.log(`  Reward: ${r.episode.reward.toFixed(2)}`);
+        });
+        console.log('\n' + '═'.repeat(80));
+        log.info(`Certificate ID: ${result.certificate.id}`);
+        log.info(`Query: ${result.certificate.queryText}`);
+        log.info(`Completeness: ${result.certificate.completenessScore.toFixed(2)}`);
+        log.success(`Completed in ${duration}ms`);
+    }
+    // ============================================================================
+    // Learner Commands
+    // ============================================================================
+    async learnerRun(params) {
+        if (!this.nightlyLearner)
+            throw new Error('Not initialized');
+        log.header('\n🌙 Running Nightly Learner');
+        log.info(`Min Attempts: ${params.minAttempts || 3}`);
+        log.info(`Min Success Rate: ${params.minSuccessRate || 0.6}`);
+        log.info(`Min Confidence: ${params.minConfidence || 0.7}`);
+        const startTime = Date.now();
+        const discovered = await this.nightlyLearner.discover({
+            minAttempts: params.minAttempts || 3,
+            minSuccessRate: params.minSuccessRate || 0.6,
+            minConfidence: params.minConfidence || 0.7,
+            dryRun: params.dryRun || false
+        });
+        const duration = Date.now() - startTime;
+        log.success(`Discovered ${discovered.length} causal edges in ${(duration / 1000).toFixed(1)}s`);
+        if (discovered.length > 0) {
+            console.log('\n' + '═'.repeat(80));
+            discovered.slice(0, 10).forEach((edge, i) => {
+                console.log(`${colors.bright}#${i + 1}: ${edge.cause} → ${edge.effect}${colors.reset}`);
+                console.log(`  Uplift: ${colors.green}${edge.uplift.toFixed(3)}${colors.reset} (CI: ${edge.confidence.toFixed(2)})`);
+                console.log(`  Sample size: ${edge.sampleSize}`);
+                console.log('─'.repeat(80));
+            });
+        }
+    }
+    async learnerPrune(params) {
+        if (!this.nightlyLearner)
+            throw new Error('Not initialized');
+        log.header('\n🧹 Pruning Low-Quality Edges');
+        const pruned = await this.nightlyLearner.pruneEdges(params);
+        log.success(`Pruned ${pruned} edges`);
+    }
+    // ============================================================================
+    // Reflexion Commands
+    // ============================================================================
+    async reflexionStoreEpisode(params) {
+        if (!this.reflexion)
+            throw new Error('Not initialized');
+        log.header('\n💭 Storing Episode');
+        log.info(`Task: ${params.task}`);
+        log.info(`Success: ${params.success ? 'Yes' : 'No'}`);
+        log.info(`Reward: ${params.reward.toFixed(2)}`);
+        const episodeId = await this.reflexion.storeEpisode(params);
+        log.success(`Stored episode #${episodeId}`);
+        if (params.critique) {
+            log.info(`Critique: "${params.critique}"`);
+        }
+    }
+    async reflexionRetrieve(params) {
+        if (!this.reflexion)
+            throw new Error('Not initialized');
+        log.header('\n🔍 Retrieving Past Episodes');
+        log.info(`Task: "${params.task}"`);
+        log.info(`k: ${params.k || 5}`);
+        if (params.onlyFailures)
+            log.info('Filter: Failures only');
+        if (params.onlySuccesses)
+            log.info('Filter: Successes only');
+        const episodes = await this.reflexion.retrieveRelevant({
+            task: params.task,
+            k: params.k || 5,
+            onlyFailures: params.onlyFailures,
+            onlySuccesses: params.onlySuccesses,
+            minReward: params.minReward
+        });
+        if (episodes.length === 0) {
+            log.warning('No episodes found');
+            return;
+        }
+        console.log('\n' + '═'.repeat(80));
+        episodes.forEach((ep, i) => {
+            console.log(`${colors.bright}#${i + 1}: Episode ${ep.id}${colors.reset}`);
+            console.log(`  Task: ${ep.task}`);
+            console.log(`  Reward: ${colors.green}${ep.reward.toFixed(2)}${colors.reset}`);
+            console.log(`  Success: ${ep.success ? colors.green + 'Yes' : colors.red + 'No'}${colors.reset}`);
+            console.log(`  Similarity: ${colors.cyan}${ep.similarity?.toFixed(3) || 'N/A'}${colors.reset}`);
+            if (ep.critique) {
+                console.log(`  Critique: "${ep.critique}"`);
+            }
+            console.log('─'.repeat(80));
+        });
+        log.success(`Retrieved ${episodes.length} relevant episodes`);
+    }
+    async reflexionGetCritiqueSummary(params) {
+        if (!this.reflexion)
+            throw new Error('Not initialized');
+        log.header('\n📋 Critique Summary');
+        log.info(`Task: "${params.task}"`);
+        const summary = await this.reflexion.getCritiqueSummary({
+            task: params.task,
+            k: params.k || 5
+        });
+        console.log('\n' + '═'.repeat(80));
+        console.log(colors.bright + 'Past Lessons:' + colors.reset);
+        console.log(summary);
+        console.log('═'.repeat(80));
+    }
+    async reflexionPrune(params) {
+        if (!this.reflexion)
+            throw new Error('Not initialized');
+        log.header('\n🧹 Pruning Episodes');
+        const pruned = await this.reflexion.pruneEpisodes({
+            minReward: params.minReward || 0.3,
+            maxAgeDays: params.maxAgeDays || 30,
+            keepMinPerTask: params.keepMinPerTask || 5
+        });
+        log.success(`Pruned ${pruned} low-quality episodes`);
+    }
+    // ============================================================================
+    // Skill Library Commands
+    // ============================================================================
+    async skillCreate(params) {
+        if (!this.skills)
+            throw new Error('Not initialized');
+        log.header('\n🎯 Creating Skill');
+        log.info(`Name: ${params.name}`);
+        log.info(`Description: ${params.description}`);
+        const skillId = await this.skills.createSkill({
+            name: params.name,
+            description: params.description,
+            signature: { inputs: {}, outputs: {} },
+            code: params.code,
+            successRate: params.successRate || 0.0,
+            uses: 0,
+            avgReward: 0.0,
+            avgLatencyMs: 0.0,
+            createdFromEpisode: params.episodeId
+        });
+        log.success(`Created skill #${skillId}`);
+    }
+    async skillSearch(params) {
+        if (!this.skills)
+            throw new Error('Not initialized');
+        log.header('\n🔍 Searching Skills');
+        log.info(`Task: "${params.task}"`);
+        log.info(`Min Success Rate: ${params.minSuccessRate || 0.0}`);
+        const skills = await this.skills.searchSkills({
+            task: params.task,
+            k: params.k || 10,
+            minSuccessRate: params.minSuccessRate || 0.0
+        });
+        if (skills.length === 0) {
+            log.warning('No skills found');
+            return;
+        }
+        console.log('\n' + '═'.repeat(80));
+        skills.forEach((skill, i) => {
+            console.log(`${colors.bright}#${i + 1}: ${skill.name}${colors.reset}`);
+            console.log(`  Description: ${skill.description}`);
+            console.log(`  Success Rate: ${colors.green}${(skill.successRate * 100).toFixed(1)}%${colors.reset}`);
+            console.log(`  Uses: ${skill.uses}`);
+            console.log(`  Avg Reward: ${skill.avgReward.toFixed(2)}`);
+            console.log(`  Avg Latency: ${skill.avgLatencyMs.toFixed(0)}ms`);
+            console.log('─'.repeat(80));
+        });
+        log.success(`Found ${skills.length} matching skills`);
+    }
+    async skillConsolidate(params) {
+        if (!this.skills)
+            throw new Error('Not initialized');
+        log.header('\n🔄 Consolidating Episodes into Skills');
+        log.info(`Min Attempts: ${params.minAttempts || 3}`);
+        log.info(`Min Reward: ${params.minReward || 0.7}`);
+        log.info(`Time Window: ${params.timeWindowDays || 7} days`);
+        const created = this.skills.consolidateEpisodesIntoSkills({
+            minAttempts: params.minAttempts || 3,
+            minReward: params.minReward || 0.7,
+            timeWindowDays: params.timeWindowDays || 7
+        });
+        log.success(`Created ${created} new skills from successful episodes`);
+    }
+    async skillPrune(params) {
+        if (!this.skills)
+            throw new Error('Not initialized');
+        log.header('\n🧹 Pruning Skills');
+        const pruned = this.skills.pruneSkills({
+            minUses: params.minUses || 3,
+            minSuccessRate: params.minSuccessRate || 0.4,
+            maxAgeDays: params.maxAgeDays || 60
+        });
+        log.success(`Pruned ${pruned} underperforming skills`);
+    }
+    // ============================================================================
+    // Database Commands
+    // ============================================================================
+    async dbStats() {
+        if (!this.db)
+            throw new Error('Not initialized');
+        log.header('\n📊 Database Statistics');
+        const tables = ['causal_edges', 'causal_experiments', 'causal_observations',
+            'certificates', 'provenance_lineage', 'episodes'];
+        console.log('\n' + '═'.repeat(80));
+        tables.forEach(table => {
+            try {
+                const count = this.db.prepare(`SELECT COUNT(*) as count FROM ${table}`).get();
+                console.log(`${colors.bright}${table}:${colors.reset} ${colors.cyan}${count.count}${colors.reset} records`);
+            }
+            catch (e) {
+                console.log(`${colors.bright}${table}:${colors.reset} ${colors.yellow}N/A${colors.reset}`);
+            }
+        });
+        console.log('═'.repeat(80));
+    }
+}
+// ============================================================================
+// CLI Entry Point
+// ============================================================================
+async function main() {
+    const args = process.argv.slice(2);
+    if (args.length === 0 || args[0] === 'help' || args[0] === '--help' || args[0] === '-h') {
+        printHelp();
+        process.exit(0);
+    }
+    const cli = new AgentDBCLI();
+    const dbPath = process.env.AGENTDB_PATH || './agentdb.db';
+    try {
+        await cli.initialize(dbPath);
+        const command = args[0];
+        const subcommand = args[1];
+        if (command === 'causal') {
+            await handleCausalCommands(cli, subcommand, args.slice(2));
+        }
+        else if (command === 'recall') {
+            await handleRecallCommands(cli, subcommand, args.slice(2));
+        }
+        else if (command === 'learner') {
+            await handleLearnerCommands(cli, subcommand, args.slice(2));
+        }
+        else if (command === 'reflexion') {
+            await handleReflexionCommands(cli, subcommand, args.slice(2));
+        }
+        else if (command === 'skill') {
+            await handleSkillCommands(cli, subcommand, args.slice(2));
+        }
+        else if (command === 'db') {
+            await handleDbCommands(cli, subcommand, args.slice(2));
+        }
+        else {
+            log.error(`Unknown command: ${command}`);
+            printHelp();
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        log.error(error.message);
+        process.exit(1);
+    }
+}
+// Command handlers
+async function handleCausalCommands(cli, subcommand, args) {
+    if (subcommand === 'add-edge') {
+        await cli.causalAddEdge({
+            cause: args[0],
+            effect: args[1],
+            uplift: parseFloat(args[2]),
+            confidence: args[3] ? parseFloat(args[3]) : undefined,
+            sampleSize: args[4] ? parseInt(args[4]) : undefined
+        });
+    }
+    else if (subcommand === 'experiment' && args[0] === 'create') {
+        await cli.causalExperimentCreate({
+            name: args[1],
+            cause: args[2],
+            effect: args[3]
+        });
+    }
+    else if (subcommand === 'experiment' && args[0] === 'add-observation') {
+        await cli.causalExperimentAddObservation({
+            experimentId: parseInt(args[1]),
+            isTreatment: args[2] === 'true',
+            outcome: parseFloat(args[3]),
+            context: args[4]
+        });
+    }
+    else if (subcommand === 'experiment' && args[0] === 'calculate') {
+        await cli.causalExperimentCalculate(parseInt(args[1]));
+    }
+    else if (subcommand === 'query') {
+        await cli.causalQuery({
+            cause: args[0],
+            effect: args[1],
+            minConfidence: args[2] ? parseFloat(args[2]) : undefined,
+            minUplift: args[3] ? parseFloat(args[3]) : undefined,
+            limit: args[4] ? parseInt(args[4]) : undefined
+        });
+    }
+    else {
+        log.error(`Unknown causal subcommand: ${subcommand}`);
+        printHelp();
+    }
+}
+async function handleRecallCommands(cli, subcommand, args) {
+    if (subcommand === 'with-certificate') {
+        await cli.recallWithCertificate({
+            query: args[0],
+            k: args[1] ? parseInt(args[1]) : undefined,
+            alpha: args[2] ? parseFloat(args[2]) : undefined,
+            beta: args[3] ? parseFloat(args[3]) : undefined,
+            gamma: args[4] ? parseFloat(args[4]) : undefined
+        });
+    }
+    else {
+        log.error(`Unknown recall subcommand: ${subcommand}`);
+        printHelp();
+    }
+}
+async function handleLearnerCommands(cli, subcommand, args) {
+    if (subcommand === 'run') {
+        await cli.learnerRun({
+            minAttempts: args[0] ? parseInt(args[0]) : undefined,
+            minSuccessRate: args[1] ? parseFloat(args[1]) : undefined,
+            minConfidence: args[2] ? parseFloat(args[2]) : undefined,
+            dryRun: args[3] === 'true'
+        });
+    }
+    else if (subcommand === 'prune') {
+        await cli.learnerPrune({
+            minConfidence: args[0] ? parseFloat(args[0]) : undefined,
+            minUplift: args[1] ? parseFloat(args[1]) : undefined,
+            maxAgeDays: args[2] ? parseInt(args[2]) : undefined
+        });
+    }
+    else {
+        log.error(`Unknown learner subcommand: ${subcommand}`);
+        printHelp();
+    }
+}
+async function handleReflexionCommands(cli, subcommand, args) {
+    if (subcommand === 'store') {
+        await cli.reflexionStoreEpisode({
+            sessionId: args[0],
+            task: args[1],
+            reward: parseFloat(args[2]),
+            success: args[3] === 'true',
+            critique: args[4],
+            input: args[5],
+            output: args[6],
+            latencyMs: args[7] ? parseInt(args[7]) : undefined,
+            tokensUsed: args[8] ? parseInt(args[8]) : undefined
+        });
+    }
+    else if (subcommand === 'retrieve') {
+        await cli.reflexionRetrieve({
+            task: args[0],
+            k: args[1] ? parseInt(args[1]) : undefined,
+            minReward: args[2] ? parseFloat(args[2]) : undefined,
+            onlyFailures: args[3] === 'true' ? true : undefined,
+            onlySuccesses: args[4] === 'true' ? true : undefined
+        });
+    }
+    else if (subcommand === 'critique-summary') {
+        await cli.reflexionGetCritiqueSummary({
+            task: args[0],
+            onlyFailures: args[1] === 'true'
+        });
+    }
+    else if (subcommand === 'prune') {
+        await cli.reflexionPrune({
+            maxAgeDays: args[0] ? parseInt(args[0]) : undefined,
+            minReward: args[1] ? parseFloat(args[1]) : undefined
+        });
+    }
+    else {
+        log.error(`Unknown reflexion subcommand: ${subcommand}`);
+        printHelp();
+    }
+}
+async function handleSkillCommands(cli, subcommand, args) {
+    if (subcommand === 'create') {
+        await cli.skillCreate({
+            name: args[0],
+            description: args[1],
+            code: args[2]
+        });
+    }
+    else if (subcommand === 'search') {
+        await cli.skillSearch({
+            task: args[0],
+            k: args[1] ? parseInt(args[1]) : undefined
+        });
+    }
+    else if (subcommand === 'consolidate') {
+        await cli.skillConsolidate({
+            minAttempts: args[0] ? parseInt(args[0]) : undefined,
+            minReward: args[1] ? parseFloat(args[1]) : undefined,
+            timeWindowDays: args[2] ? parseInt(args[2]) : undefined
+        });
+    }
+    else if (subcommand === 'prune') {
+        await cli.skillPrune({
+            minUses: args[0] ? parseInt(args[0]) : undefined,
+            minSuccessRate: args[1] ? parseFloat(args[1]) : undefined,
+            maxAgeDays: args[2] ? parseInt(args[2]) : undefined
+        });
+    }
+    else {
+        log.error(`Unknown skill subcommand: ${subcommand}`);
+        printHelp();
+    }
+}
+async function handleDbCommands(cli, subcommand, args) {
+    if (subcommand === 'stats') {
+        await cli.dbStats();
+    }
+    else {
+        log.error(`Unknown db subcommand: ${subcommand}`);
+        printHelp();
+    }
+}
+function printHelp() {
+    console.log(`
+${colors.bright}${colors.cyan}█▀█ █▀▀ █▀▀ █▄░█ ▀█▀ █▀▄ █▄▄
+█▀█ █▄█ ██▄ █░▀█ ░█░ █▄▀ █▄█${colors.reset}
+
+${colors.bright}${colors.cyan}AgentDB CLI - Frontier Memory Features${colors.reset}
+
+${colors.bright}USAGE:${colors.reset}
+  agentdb <command> <subcommand> [options]
+
+${colors.bright}CAUSAL COMMANDS:${colors.reset}
+  agentdb causal add-edge <cause> <effect> <uplift> [confidence] [sample-size]
+    Add a causal edge manually
+
+  agentdb causal experiment create <name> <cause> <effect>
+    Create a new A/B experiment
+
+  agentdb causal experiment add-observation <experiment-id> <is-treatment> <outcome> [context]
+    Record an observation (is-treatment: true/false)
+
+  agentdb causal experiment calculate <experiment-id>
+    Calculate uplift and statistical significance
+
+  agentdb causal query [cause] [effect] [min-confidence] [min-uplift] [limit]
+    Query causal edges with filters
+
+${colors.bright}RECALL COMMANDS:${colors.reset}
+  agentdb recall with-certificate <query> [k] [alpha] [beta] [gamma]
+    Retrieve episodes with causal utility and provenance certificate
+    Defaults: k=12, alpha=0.7, beta=0.2, gamma=0.1
+
+${colors.bright}LEARNER COMMANDS:${colors.reset}
+  agentdb learner run [min-attempts] [min-success-rate] [min-confidence] [dry-run]
+    Discover causal edges from episode patterns
+    Defaults: min-attempts=3, min-success-rate=0.6, min-confidence=0.7
+
+  agentdb learner prune [min-confidence] [min-uplift] [max-age-days]
+    Remove low-quality or old causal edges
+    Defaults: min-confidence=0.5, min-uplift=0.05, max-age-days=90
+
+${colors.bright}REFLEXION COMMANDS:${colors.reset}
+  agentdb reflexion store <session-id> <task> <reward> <success> [critique] [input] [output] [latency-ms] [tokens]
+    Store episode with self-critique
+
+  agentdb reflexion retrieve <task> [k] [min-reward] [only-failures] [only-successes]
+    Retrieve relevant past episodes
+
+  agentdb reflexion critique-summary <task> [only-failures]
+    Get aggregated critique lessons
+
+  agentdb reflexion prune [max-age-days] [max-reward]
+    Clean up old or low-value episodes
+
+${colors.bright}SKILL COMMANDS:${colors.reset}
+  agentdb skill create <name> <description> [code]
+    Create a reusable skill
+
+  agentdb skill search <query> [k]
+    Find applicable skills by similarity
+
+  agentdb skill consolidate [min-attempts] [min-reward] [time-window-days]
+    Auto-create skills from successful episodes (defaults: 3, 0.7, 7)
+
+  agentdb skill prune [min-uses] [min-success-rate] [max-age-days]
+    Remove underperforming skills (defaults: 3, 0.4, 60)
+
+${colors.bright}DATABASE COMMANDS:${colors.reset}
+  agentdb db stats
+    Show database statistics
+
+${colors.bright}ENVIRONMENT:${colors.reset}
+  AGENTDB_PATH    Database file path (default: ./agentdb.db)
+
+${colors.bright}EXAMPLES:${colors.reset}
+  # Reflexion: Store and retrieve episodes
+  agentdb reflexion store "session-1" "implement_auth" 0.95 true "Used OAuth2"
+  agentdb reflexion retrieve "authentication" 10 0.8
+  agentdb reflexion critique-summary "bug_fix" true
+
+  # Skills: Create and search
+  agentdb skill create "jwt_auth" "Generate JWT tokens" "code here..."
+  agentdb skill search "authentication" 5
+  agentdb skill consolidate 3 0.7 7
+
+  # Causal: Add edges and run experiments
+  agentdb causal add-edge "add_tests" "code_quality" 0.25 0.95 100
+  agentdb causal experiment create "test-coverage-quality" "test_coverage" "bug_rate"
+  agentdb causal experiment add-observation 1 true 0.15
+  agentdb causal experiment calculate 1
+
+  # Retrieve with causal utility
+  agentdb recall with-certificate "implement authentication" 10
+
+  # Discover patterns automatically
+  agentdb learner run 3 0.6 0.7
+
+  # Get database stats
+  agentdb db stats
+`);
+}
+// ESM entry point check
+if (import.meta.url === `file://${process.argv[1]}`) {
+    main().catch(console.error);
+}
+export { AgentDBCLI };
+//# sourceMappingURL=agentdb-cli.js.map

package/dist/controllers/EmbeddingService.js

@@ -23,7 +23,7 @@ export class EmbeddingService {
                 this.pipeline = await pipeline('feature-extraction', this.config.model);
             }
             catch (error) {
-                // Silently fall back to mock embeddings (transformers.js is optional for basic CLI commands)
+                console.warn('Transformers.js not available, falling back to mock embeddings');
                 this.pipeline = null;
             }
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentdb",
-  "version": "1.1.6",
+  "version": "1.1.8",
   "description": "AgentDB - Frontier Memory Features: Causal reasoning, reflexion memory, skill library, explainable recall, and automated learning for AI agents. 150x faster vector search with HNSW indexing.",
   "type": "module",
   "main": "dist/index.js",
@@ -55,16 +55,16 @@
   },
   "homepage": "https://agentdb.ruv.io",
   "dependencies": {
+    "@xenova/transformers": "^2.17.2",
     "better-sqlite3": "^11.7.0",
-    "commander": "^12.1.0",
     "chalk": "^5.3.0",
-    "@xenova/transformers": "^2.17.2"
+    "commander": "^12.1.0"
   },
   "devDependencies": {
     "@types/better-sqlite3": "^7.6.11",
     "@types/node": "^22.10.2",
-    "typescript": "^5.7.2",
     "tsx": "^4.19.2",
+    "typescript": "^5.7.2",
     "vitest": "^2.1.8"
   },
   "engines": {