agentdb 1.2.0 → 1.3.1

package/src/cli/agentdb-cli.ts

@@ -14,7 +14,7 @@ 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, Episode, ReflexionQuery, ReflexionCritiqueSummary, ReflexionPruneConfig } from '../controllers/ReflexionMemory.js';
+import { ReflexionMemory, Episode, ReflexionQuery } from '../controllers/ReflexionMemory.js';
 import { SkillLibrary, Skill, SkillQuery } from '../controllers/SkillLibrary.js';
 import { EmbeddingService } from '../controllers/EmbeddingService.js';
 import * as fs from 'fs';
@@ -76,8 +76,13 @@ class AgentDBCLI {
     // 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.causalRecall = new CausalRecall(this.db, this.embedder, {
+      alpha: 0.7,
+      beta: 0.2,
+      gamma: 0.1,
+      minConfidence: 0.6
+    });
+    this.nightlyLearner = new NightlyLearner(this.db, this.embedder);
     this.reflexion = new ReflexionMemory(this.db, this.embedder);
     this.skills = new SkillLibrary(this.db, this.embedder);
   }
@@ -100,12 +105,16 @@ class AgentDBCLI {
     log.info(`Effect: ${params.effect}`);
     log.info(`Uplift: ${params.uplift}`);
 
-    const edgeId = this.causalGraph.addEdge({
-      cause: params.cause,
-      effect: params.effect,
+    const edgeId = this.causalGraph.addCausalEdge({
+      fromMemoryId: 1,
+      fromMemoryType: 'episode',
+      toMemoryId: 2,
+      toMemoryType: 'episode',
+      similarity: 0.9,
       uplift: params.uplift,
       confidence: params.confidence || 0.95,
       sampleSize: params.sampleSize || 0,
+      mechanism: `${params.cause} → ${params.effect}`,
       evidenceIds: []
     });
 
@@ -126,8 +135,14 @@ class AgentDBCLI {
 
     const expId = this.causalGraph.createExperiment({
       name: params.name,
-      cause: params.cause,
-      effect: params.effect
+      hypothesis: `Does ${params.cause} causally affect ${params.effect}?`,
+      treatmentId: 0,
+      treatmentType: params.cause,
+      controlId: undefined,
+      startTime: Math.floor(Date.now() / 1000),
+      sampleSize: 0,
+      status: 'running',
+      metadata: { effect: params.effect }
     });
 
     log.success(`Created experiment #${expId}`);
@@ -142,11 +157,20 @@ class AgentDBCLI {
   }): Promise<void> {
     if (!this.causalGraph) throw new Error('Not initialized');
 
+    // Create a dummy episode to get an episode ID
+    const insertResult = this.db!.prepare('INSERT INTO episodes (session_id, task, reward, success, created_at) VALUES (?, ?, ?, ?, ?)').run('cli-session', 'experiment', params.outcome, 1, Math.floor(Date.now() / 1000));
+    if (!insertResult || !insertResult.lastInsertRowid) {
+      throw new Error('Failed to create episode');
+    }
+    const episodeId = Number(insertResult.lastInsertRowid);
+
     this.causalGraph.recordObservation({
       experimentId: params.experimentId,
+      episodeId: episodeId,
       isTreatment: params.isTreatment,
-      outcome: params.outcome,
-      context: params.context || '{}'
+      outcomeValue: params.outcome,
+      outcomeType: 'reward',
+      context: params.context ? JSON.parse(params.context) : undefined
     });
 
     log.success(`Recorded ${params.isTreatment ? 'treatment' : 'control'} observation: ${params.outcome}`);
@@ -159,14 +183,31 @@ class AgentDBCLI {
 
     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`);
+    // Fetch experiment details (now includes calculated means)
+    const experiment = this.db!.prepare('SELECT * FROM causal_experiments WHERE id = ?').get(experimentId) as any;
+    if (!experiment) {
+      throw new Error(`Experiment ${experimentId} not found`);
+    }
+
+    log.info(`Experiment: ${experiment.hypothesis || 'Unknown'}`);
+    log.info(`Treatment Mean: ${experiment.treatment_mean?.toFixed(3) || 'N/A'}`);
+    log.info(`Control Mean: ${experiment.control_mean?.toFixed(3) || 'N/A'}`);
+    log.success(`Uplift: ${result?.uplift?.toFixed(3) || 'N/A'}`);
+    if (result?.confidenceInterval && result.confidenceInterval.length === 2) {
+      log.info(`95% CI: [${result.confidenceInterval[0]?.toFixed(3) || 'N/A'}, ${result.confidenceInterval[1]?.toFixed(3) || 'N/A'}]`);
+    }
+    if (result?.pValue !== undefined) {
+      log.info(`p-value: ${result.pValue.toFixed(4)}`);
+    }
 
-    if (result.pValue < 0.05) {
+    // Get sample sizes from observations
+    const counts = this.db!.prepare('SELECT COUNT(*) as total, SUM(is_treatment) as treatment FROM causal_observations WHERE experiment_id = ?').get(experimentId) as any;
+    if (!counts) {
+      throw new Error(`Failed to get observation counts for experiment ${experimentId}`);
+    }
+    log.info(`Sample Sizes: ${counts.treatment || 0} treatment, ${(counts.total || 0) - (counts.treatment || 0)} control`);
+
+    if (result && result.pValue !== undefined && result.pValue < 0.05) {
       log.success('Result is statistically significant (p < 0.05)');
     } else {
       log.warning('Result is not statistically significant');
@@ -184,9 +225,10 @@ class AgentDBCLI {
 
     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
     });
@@ -198,8 +240,8 @@ 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(`  Uplift: ${colors.green}${edge.uplift.toFixed(3)}${colors.reset}`);
+      console.log(`${colors.bright}#${i + 1}: ${edge.fromMemoryType} → ${edge.toMemoryType}${colors.reset}`);
+      console.log(`  Uplift: ${colors.green}${(edge.uplift || 0).toFixed(3)}${colors.reset}`);
       console.log(`  Confidence: ${edge.confidence.toFixed(2)} (n=${edge.sampleSize})`);
       console.log('─'.repeat(80));
     });
@@ -226,30 +268,26 @@ class AgentDBCLI {
 
     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) => {
-      console.log(`\n${colors.bright}#${i + 1}: Episode ${r.episode.id}${colors.reset}`);
-      console.log(`  Task: ${r.episode.task}`);
+    result.candidates.slice(0, 5).forEach((r, i) => {
+      console.log(`\n${colors.bright}#${i + 1}: ${r.type} ${r.id}${colors.reset}`);
+      console.log(`  Content: ${r.content.substring(0, 50)}...`);
       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(`  Utility: ${colors.yellow}${r.utilityScore.toFixed(3)}${colors.reset}`);
     });
 
     console.log('\n' + '═'.repeat(80));
@@ -309,9 +347,16 @@ class AgentDBCLI {
 
     log.header('\n🧹 Pruning Low-Quality Edges');
 
-    const pruned = await this.nightlyLearner.pruneEdges(params);
+    // Update config and run pruning
+    this.nightlyLearner.updateConfig({
+      confidenceThreshold: params.minConfidence || 0.6,
+      upliftThreshold: params.minUplift || 0.05,
+      edgeMaxAgeDays: params.maxAgeDays || 90
+    });
 
-    log.success(`Pruned ${pruned} edges`);
+    const report = await this.nightlyLearner.run();
+
+    log.success(`Pruned ${report.edgesPruned} edges`);
   }
 
   // ============================================================================
@@ -399,7 +444,7 @@ class AgentDBCLI {
 
     const summary = await this.reflexion.getCritiqueSummary({
       task: params.task,
-      k: params.k || 5
+      k: params.k
     });
 
     console.log('\n' + '═'.repeat(80));
@@ -417,7 +462,7 @@ class AgentDBCLI {
 
     log.header('\n🧹 Pruning Episodes');
 
-    const pruned = await this.reflexion.pruneEpisodes({
+    const pruned = this.reflexion.pruneEpisodes({
       minReward: params.minReward || 0.3,
       maxAgeDays: params.maxAgeDays || 30,
       keepMinPerTask: params.keepMinPerTask || 5
@@ -498,21 +543,57 @@ class AgentDBCLI {
     minAttempts?: number;
     minReward?: number;
     timeWindowDays?: number;
+    extractPatterns?: boolean;
   }): Promise<void> {
     if (!this.skills) throw new Error('Not initialized');
 
-    log.header('\n🔄 Consolidating Episodes into Skills');
+    log.header('\n🔄 Consolidating Episodes into Skills with Pattern Extraction');
     log.info(`Min Attempts: ${params.minAttempts || 3}`);
     log.info(`Min Reward: ${params.minReward || 0.7}`);
     log.info(`Time Window: ${params.timeWindowDays || 7} days`);
+    log.info(`Pattern Extraction: ${params.extractPatterns !== false ? 'Enabled' : 'Disabled'}`);
+
+    const startTime = Date.now();
 
-    const created = this.skills.consolidateEpisodesIntoSkills({
+    const result = await this.skills.consolidateEpisodesIntoSkills({
       minAttempts: params.minAttempts || 3,
       minReward: params.minReward || 0.7,
-      timeWindowDays: params.timeWindowDays || 7
+      timeWindowDays: params.timeWindowDays || 7,
+      extractPatterns: params.extractPatterns !== false
     });
 
-    log.success(`Created ${created} new skills from successful episodes`);
+    const duration = Date.now() - startTime;
+
+    log.success(`Created ${result.created} new skills, updated ${result.updated} existing skills in ${duration}ms`);
+
+    // Display extracted patterns if available
+    if (result.patterns.length > 0) {
+      console.log('\n' + '═'.repeat(80));
+      console.log(`${colors.bright}${colors.cyan}Extracted Patterns:${colors.reset}`);
+      console.log('═'.repeat(80));
+
+      result.patterns.forEach((pattern, i) => {
+        console.log(`\n${colors.bright}#${i + 1}: ${pattern.task}${colors.reset}`);
+        console.log(`  Avg Reward: ${colors.green}${pattern.avgReward.toFixed(2)}${colors.reset}`);
+
+        if (pattern.commonPatterns.length > 0) {
+          console.log(`  ${colors.cyan}Common Patterns:${colors.reset}`);
+          pattern.commonPatterns.forEach(p => console.log(`    • ${p}`));
+        }
+
+        if (pattern.successIndicators.length > 0) {
+          console.log(`  ${colors.yellow}Success Indicators:${colors.reset}`);
+          pattern.successIndicators.forEach(s => console.log(`    • ${s}`));
+        }
+
+        console.log('─'.repeat(80));
+      });
+    }
+
+    if (result.created === 0 && result.updated === 0) {
+      log.warning('No episodes met the criteria for skill consolidation');
+      log.info('Try lowering minReward or increasing timeWindowDays');
+    }
   }
 
   async skillPrune(params: {
@@ -700,7 +781,7 @@ async function handleReflexionCommands(cli: AgentDBCLI, subcommand: string, args
   } else if (subcommand === 'critique-summary') {
     await cli.reflexionGetCritiqueSummary({
       task: args[0],
-      onlyFailures: args[1] === 'true'
+      k: args[1] ? parseInt(args[1]) : undefined
     });
   } else if (subcommand === 'prune') {
     await cli.reflexionPrune({
@@ -729,7 +810,8 @@ async function handleSkillCommands(cli: AgentDBCLI, subcommand: string, args: st
     await cli.skillConsolidate({
       minAttempts: args[0] ? parseInt(args[0]) : undefined,
       minReward: args[1] ? parseFloat(args[1]) : undefined,
-      timeWindowDays: args[2] ? parseInt(args[2]) : undefined
+      timeWindowDays: args[2] ? parseInt(args[2]) : undefined,
+      extractPatterns: args[3] !== 'false' // Default true, set to false if explicitly passed
     });
   } else if (subcommand === 'prune') {
     await cli.skillPrune({
@@ -812,8 +894,10 @@ ${colors.bright}SKILL COMMANDS:${colors.reset}
   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 consolidate [min-attempts] [min-reward] [time-window-days] [extract-patterns]
+    Auto-create skills from successful episodes with ML pattern extraction
+    Defaults: min-attempts=3, min-reward=0.7, time-window-days=7, extract-patterns=true
+    Analyzes: keyword frequency, critique patterns, reward distribution, metadata, learning curves
 
   agentdb skill prune [min-uses] [min-success-rate] [max-age-days]
     Remove underperforming skills (defaults: 3, 0.4, 60)
@@ -834,7 +918,8 @@ ${colors.bright}EXAMPLES:${colors.reset}
   # 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
+  agentdb skill consolidate 3 0.7 7 true  # With pattern extraction
+  agentdb skill consolidate 5 0.8 14      # Higher thresholds, longer window
 
   # Causal: Add edges and run experiments
   agentdb causal add-edge "add_tests" "code_quality" 0.25 0.95 100

package/src/controllers/CausalMemoryGraph.ts

@@ -92,9 +92,9 @@ export class CausalMemoryGraph {
       INSERT INTO causal_edges (
         from_memory_id, from_memory_type, to_memory_id, to_memory_type,
         similarity, uplift, confidence, sample_size,
-        evidence_ids, experiment_ids, confounder_score,
+        evidence_ids, confounder_score,
         mechanism, metadata
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
     `);
 
     const result = stmt.run(
@@ -107,7 +107,6 @@ export class CausalMemoryGraph {
       edge.confidence,
       edge.sampleSize || null,
       edge.evidenceIds ? JSON.stringify(edge.evidenceIds) : null,
-      edge.experimentIds ? JSON.stringify(edge.experimentIds) : null,
       edge.confounderScore || null,
       edge.mechanism || null,
       edge.metadata ? JSON.stringify(edge.metadata) : null

package/src/controllers/CausalRecall.ts

@@ -161,7 +161,8 @@ export class CausalRecall {
 
     for (const ep of episodes) {
       const episodeRow = ep as any;
-      const embedding = new Float32Array(JSON.parse(episodeRow.embedding));
+      // Embeddings are stored as Buffer, not JSON
+      const embedding = this.deserializeEmbedding(episodeRow.embedding);
       const similarity = this.cosineSimilarity(queryEmbedding, embedding);
       results.push({
         id: episodeRow.id.toString(),
@@ -313,6 +314,13 @@ export class CausalRecall {
     return [...new Set(words)];
   }
 
+  /**
+   * Deserialize embedding from Buffer
+   */
+  private deserializeEmbedding(buffer: Buffer): Float32Array {
+    return new Float32Array(buffer.buffer, buffer.byteOffset, buffer.length / 4);
+  }
+
   /**
    * Cosine similarity between two vectors
    */
@@ -392,4 +400,68 @@ export class CausalRecall {
   updateConfig(config: Partial<RerankConfig>): void {
     this.config = { ...this.config, ...config };
   }
+
+  /**
+   * Search for memories with semantic similarity and causal utility ranking
+   *
+   * @param params Search parameters
+   * @returns Array of ranked search results with similarity and causal uplift scores
+   */
+  async search(params: {
+    query: string;
+    k?: number;
+    includeEvidence?: boolean;
+    alpha?: number;
+    beta?: number;
+    gamma?: number;
+  }): Promise<Array<{
+    id: number;
+    type: string;
+    content: string;
+    similarity: number;
+    causalUplift: number;
+    utilityScore: number;
+  }>> {
+    const {
+      query,
+      k = 12,
+      includeEvidence = false,
+      alpha = this.config.alpha,
+      beta = this.config.beta,
+      gamma = this.config.gamma
+    } = params;
+
+    // Temporarily override config for this search
+    const originalConfig = { ...this.config };
+    this.config = { ...this.config, alpha, beta, gamma };
+
+    try {
+      // Step 1: Generate query embedding
+      const queryEmbedding = await this.embedder.embed(query);
+
+      // Step 2: Vector similarity search
+      const candidates = await this.vectorSearch(queryEmbedding, k * 2);
+
+      // Step 3: Load causal edges for uplift scoring
+      const causalEdges = await this.loadCausalEdges(candidates.map(c => c.id));
+
+      // Step 4: Rerank by utility
+      const reranked = this.rerankByUtility(candidates, causalEdges);
+
+      // Step 5: Format results for search interface
+      const results = reranked.slice(0, k).map(candidate => ({
+        id: parseInt(candidate.id),
+        type: candidate.type,
+        content: candidate.content,
+        similarity: candidate.similarity,
+        causalUplift: candidate.uplift || 0,
+        utilityScore: candidate.utilityScore
+      }));
+
+      return results;
+    } finally {
+      // Restore original config
+      this.config = originalConfig;
+    }
+  }
 }

package/src/controllers/EmbeddingService.ts

@@ -104,7 +104,7 @@ export class EmbeddingService {
       })
     });
 
-    const data = await response.json();
+    const data: any = await response.json();
     return new Float32Array(data.data[0].embedding);
   }
 
@@ -112,6 +112,11 @@ export class EmbeddingService {
     // Simple deterministic mock embedding for testing
     const embedding = new Float32Array(this.config.dimension);
 
+    // Handle null/undefined/empty text
+    if (!text || text.length === 0) {
+      return new Array(this.config.dimension).fill(0) as any as Float32Array;
+    }
+
     // Use simple hash-based generation
     let hash = 0;
     for (let i = 0; i < text.length; i++) {

package/src/controllers/ExplainableRecall.ts

@@ -428,7 +428,7 @@ export class ExplainableRecall {
     const contentHash = this.getContentHash(sourceType, sourceId);
 
     this.db.prepare(`
-      INSERT INTO provenance_sources (source_type, source_id, content_hash, creator)
+      INSERT OR IGNORE INTO provenance_sources (source_type, source_id, content_hash, creator)
       VALUES (?, ?, ?, ?)
     `).run(sourceType, sourceId, contentHash, 'system');