agentic-flow 1.7.3 → 1.7.4

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

@@ -0,0 +1,717 @@
+#!/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 };