agentdb 1.2.0 → 1.3.1

package/src/controllers/SkillLibrary.ts

@@ -59,8 +59,8 @@ export class SkillLibrary {
     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 (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        avg_reward, avg_latency_ms, metadata
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
     `);
 
     const result = stmt.run(
@@ -72,7 +72,6 @@ export class SkillLibrary {
       skill.uses,
       skill.avgReward,
       skill.avgLatencyMs,
-      skill.createdFromEpisode || null,
       skill.metadata ? JSON.stringify(skill.metadata) : null
     );
 
@@ -226,15 +225,30 @@ export class SkillLibrary {
   }
 
   /**
-   * Consolidate high-reward episodes into skills
-   * This is the core learning mechanism
+   * Consolidate high-reward episodes into skills with ML pattern extraction
+   * This is the core learning mechanism enhanced with pattern analysis
    */
-  consolidateEpisodesIntoSkills(config: {
+  async consolidateEpisodesIntoSkills(config: {
     minAttempts?: number;
     minReward?: number;
     timeWindowDays?: number;
-  }): number {
-    const { minAttempts = 3, minReward = 0.7, timeWindowDays = 7 } = config;
+    extractPatterns?: boolean;
+  }): Promise<{
+    created: number;
+    updated: number;
+    patterns: Array<{
+      task: string;
+      commonPatterns: string[];
+      successIndicators: string[];
+      avgReward: number;
+    }>;
+  }> {
+    const {
+      minAttempts = 3,
+      minReward = 0.7,
+      timeWindowDays = 7,
+      extractPatterns = true
+    } = config;
 
     const stmt = this.db.prepare(`
       SELECT
@@ -254,16 +268,47 @@ export class SkillLibrary {
 
     const candidates = stmt.all(timeWindowDays * 86400, minReward, minAttempts);
     let created = 0;
+    let updated = 0;
+    const patterns: Array<{
+      task: string;
+      commonPatterns: string[];
+      successIndicators: string[];
+      avgReward: number;
+    }> = [];
 
     for (const candidate of candidates as any[]) {
+      const episodeIds = candidate.episode_ids.split(',').map(Number);
+
+      // Extract patterns from successful episodes if requested
+      let extractedPatterns: string[] = [];
+      let successIndicators: string[] = [];
+      let enhancedDescription = `Auto-generated skill from successful episodes`;
+
+      if (extractPatterns) {
+        const patternData = await this.extractPatternsFromEpisodes(episodeIds);
+        extractedPatterns = patternData.commonPatterns;
+        successIndicators = patternData.successIndicators;
+
+        if (extractedPatterns.length > 0) {
+          enhancedDescription = `Skill learned from ${episodeIds.length} successful episodes. Common patterns: ${extractedPatterns.slice(0, 3).join(', ')}`;
+        }
+
+        patterns.push({
+          task: candidate.task,
+          commonPatterns: extractedPatterns,
+          successIndicators: successIndicators,
+          avgReward: candidate.avg_reward
+        });
+      }
+
       // Check if skill already exists
       const existing = this.db.prepare('SELECT id FROM skills WHERE name = ?').get(candidate.task);
 
       if (!existing) {
-        // Create new skill
+        // Create new skill with extracted patterns
         const skill: Skill = {
           name: candidate.task,
-          description: `Auto-generated skill from successful episodes`,
+          description: enhancedDescription,
           signature: {
             inputs: { task: 'string' },
             outputs: { result: 'any' }
@@ -274,15 +319,16 @@ export class SkillLibrary {
           avgLatencyMs: candidate.avg_latency || 0,
           createdFromEpisode: candidate.latest_episode_id,
           metadata: {
-            sourceEpisodes: candidate.episode_ids.split(',').map(Number),
+            sourceEpisodes: episodeIds,
             autoGenerated: true,
-            consolidatedAt: Date.now()
+            consolidatedAt: Date.now(),
+            extractedPatterns: extractedPatterns,
+            successIndicators: successIndicators,
+            patternConfidence: this.calculatePatternConfidence(episodeIds.length, candidate.success_rate)
           }
         };
 
-        this.createSkill(skill).catch(err => {
-          console.error('Error creating skill:', err);
-        });
+        await this.createSkill(skill);
         created++;
       } else {
         // Update existing skill stats
@@ -292,10 +338,202 @@ export class SkillLibrary {
           candidate.avg_reward,
           candidate.avg_latency || 0
         );
+        updated++;
       }
     }
 
-    return created;
+    return { created, updated, patterns };
+  }
+
+  /**
+   * Extract common patterns from successful episodes using ML-inspired analysis
+   */
+  private async extractPatternsFromEpisodes(episodeIds: number[]): Promise<{
+    commonPatterns: string[];
+    successIndicators: string[];
+  }> {
+    // Retrieve episodes with their outputs and critiques
+    const episodes = this.db.prepare(`
+      SELECT id, task, input, output, critique, reward, success, metadata
+      FROM episodes
+      WHERE id IN (${episodeIds.map(() => '?').join(',')})
+      AND success = 1
+    `).all(...episodeIds) as any[];
+
+    if (episodes.length === 0) {
+      return { commonPatterns: [], successIndicators: [] };
+    }
+
+    const commonPatterns: string[] = [];
+    const successIndicators: string[] = [];
+
+    // Pattern 1: Analyze output text for common keywords and phrases
+    const outputTexts = episodes
+      .map(ep => ep.output)
+      .filter(Boolean);
+
+    if (outputTexts.length > 0) {
+      const keywordFrequency = this.extractKeywordFrequency(outputTexts);
+      const topKeywords = this.getTopKeywords(keywordFrequency, 5);
+
+      if (topKeywords.length > 0) {
+        commonPatterns.push(`Common techniques: ${topKeywords.join(', ')}`);
+      }
+    }
+
+    // Pattern 2: Analyze critique patterns for successful strategies
+    const critiques = episodes
+      .map(ep => ep.critique)
+      .filter(Boolean);
+
+    if (critiques.length > 0) {
+      const critiqueKeywords = this.extractKeywordFrequency(critiques);
+      const topCritiquePatterns = this.getTopKeywords(critiqueKeywords, 3);
+
+      if (topCritiquePatterns.length > 0) {
+        successIndicators.push(...topCritiquePatterns);
+      }
+    }
+
+    // Pattern 3: Analyze reward distribution
+    const avgReward = episodes.reduce((sum, ep) => sum + ep.reward, 0) / episodes.length;
+    const highRewardCount = episodes.filter(ep => ep.reward > avgReward).length;
+    const highRewardRatio = highRewardCount / episodes.length;
+
+    if (highRewardRatio > 0.6) {
+      successIndicators.push(`High consistency (${(highRewardRatio * 100).toFixed(0)}% above average)`);
+    }
+
+    // Pattern 4: Analyze metadata for common parameters
+    const metadataPatterns = this.extractMetadataPatterns(episodes);
+    if (metadataPatterns.length > 0) {
+      commonPatterns.push(...metadataPatterns);
+    }
+
+    // Pattern 5: Temporal analysis - learning curve
+    const learningTrend = this.analyzeLearningTrend(episodes);
+    if (learningTrend) {
+      successIndicators.push(learningTrend);
+    }
+
+    return { commonPatterns, successIndicators };
+  }
+
+  /**
+   * Extract keyword frequency from text array using NLP-inspired techniques
+   */
+  private extractKeywordFrequency(texts: string[]): Map<string, number> {
+    const frequency = new Map<string, number>();
+
+    // Common stop words to filter out
+    const stopWords = new Set([
+      'the', 'a', 'an', 'and', 'or', 'but', 'in', 'on', 'at', 'to', 'for',
+      'of', 'with', 'by', 'from', 'as', 'is', 'was', 'are', 'were', 'been',
+      'be', 'have', 'has', 'had', 'do', 'does', 'did', 'will', 'would', 'should',
+      'could', 'may', 'might', 'must', 'can', 'this', 'that', 'these', 'those'
+    ]);
+
+    for (const text of texts) {
+      // Extract words (alphanumeric sequences)
+      const words = text.toLowerCase().match(/\b[a-z0-9_-]+\b/g) || [];
+
+      for (const word of words) {
+        if (word.length > 3 && !stopWords.has(word)) {
+          frequency.set(word, (frequency.get(word) || 0) + 1);
+        }
+      }
+    }
+
+    return frequency;
+  }
+
+  /**
+   * Get top N keywords by frequency
+   */
+  private getTopKeywords(frequency: Map<string, number>, n: number): string[] {
+    return Array.from(frequency.entries())
+      .sort((a, b) => b[1] - a[1])
+      .slice(0, n)
+      .filter(([_, count]) => count >= 2) // Only keywords appearing at least twice
+      .map(([word, _]) => word);
+  }
+
+  /**
+   * Extract common patterns from episode metadata
+   */
+  private extractMetadataPatterns(episodes: any[]): string[] {
+    const patterns: string[] = [];
+    const metadataFields = new Map<string, Set<any>>();
+
+    for (const episode of episodes) {
+      if (episode.metadata) {
+        try {
+          const metadata = typeof episode.metadata === 'string'
+            ? JSON.parse(episode.metadata)
+            : episode.metadata;
+
+          for (const [key, value] of Object.entries(metadata)) {
+            if (!metadataFields.has(key)) {
+              metadataFields.set(key, new Set());
+            }
+            metadataFields.get(key)!.add(value);
+          }
+        } catch (e) {
+          // Skip invalid metadata
+        }
+      }
+    }
+
+    // Find fields with consistent values
+    metadataFields.forEach((values, field) => {
+      if (values.size === 1) {
+        // All episodes have the same value for this field
+        const value = Array.from(values)[0];
+        patterns.push(`Consistent ${field}: ${value}`);
+      }
+    });
+
+    return patterns;
+  }
+
+  /**
+   * Analyze learning trend across episodes
+   */
+  private analyzeLearningTrend(episodes: any[]): string | null {
+    if (episodes.length < 3) return null;
+
+    // Sort by episode ID (temporal order)
+    const sorted = [...episodes].sort((a, b) => a.id - b.id);
+
+    const firstHalfReward = sorted.slice(0, Math.floor(sorted.length / 2))
+      .reduce((sum, ep) => sum + ep.reward, 0) / Math.floor(sorted.length / 2);
+
+    const secondHalfReward = sorted.slice(Math.floor(sorted.length / 2))
+      .reduce((sum, ep) => sum + ep.reward, 0) / (sorted.length - Math.floor(sorted.length / 2));
+
+    const improvement = ((secondHalfReward - firstHalfReward) / firstHalfReward) * 100;
+
+    if (improvement > 10) {
+      return `Strong learning curve (+${improvement.toFixed(0)}% improvement)`;
+    } else if (improvement > 5) {
+      return `Moderate learning curve (+${improvement.toFixed(0)}% improvement)`;
+    } else if (Math.abs(improvement) < 5) {
+      return `Stable performance (±${Math.abs(improvement).toFixed(0)}%)`;
+    }
+
+    return null;
+  }
+
+  /**
+   * Calculate pattern confidence score based on sample size and success rate
+   */
+  private calculatePatternConfidence(sampleSize: number, successRate: number): number {
+    // Confidence increases with sample size and success rate
+    // Using a sigmoid-like function for smooth scaling
+    const sampleFactor = Math.min(sampleSize / 10, 1.0); // Saturates at 10 samples
+    const successFactor = successRate;
+
+    return Math.min(sampleFactor * successFactor, 0.99);
   }
 
   /**