@agentic-qe/v3 3.0.0-alpha.6 → 3.0.0-alpha.8

package/src/domains/defect-intelligence/services/pattern-learner.ts

@@ -1,738 +0,0 @@
-/**
- * Agentic QE v3 - Defect Pattern Learner Service
- * Learns and recognizes defect patterns from historical data
- * Uses NomicEmbedder for semantic embeddings
- */
-
-import { v4 as uuidv4 } from 'uuid';
-import { Result, ok, err } from '../../../shared/types';
-import { MemoryBackend, VectorSearchResult } from '../../../kernel/interfaces';
-import {
-  LearnRequest,
-  LearnedDefectPatterns,
-  DefectPattern,
-  DefectInfo,
-  ClusterRequest,
-  DefectClusters,
-  DefectCluster,
-} from '../interfaces';
-import { NomicEmbedder, IEmbeddingProvider, EMBEDDING_CONFIG } from '../../../shared/embeddings';
-
-/**
- * Interface for the pattern learner service
- */
-export interface IPatternLearnerService {
-  learnPatterns(request: LearnRequest): Promise<Result<LearnedDefectPatterns, Error>>;
-  clusterDefects(request: ClusterRequest): Promise<Result<DefectClusters, Error>>;
-  findSimilarDefects(defect: DefectInfo, limit?: number): Promise<Result<DefectInfo[], Error>>;
-  getPatternById(patternId: string): Promise<DefectPattern | undefined>;
-  listPatterns(limit?: number): Promise<DefectPattern[]>;
-}
-
-/**
- * Configuration for the pattern learner
- */
-export interface PatternLearnerConfig {
-  minPatternFrequency: number;
-  maxPatterns: number;
-  clusterThreshold: number;
-  embeddingDimension: number;
-  patternNamespace: string;
-  enableSemanticClustering: boolean;
-  /** Optional embedder instance (defaults to NomicEmbedder with fallback) */
-  embedder?: IEmbeddingProvider;
-}
-
-const DEFAULT_CONFIG: PatternLearnerConfig = {
-  minPatternFrequency: 2,
-  maxPatterns: 50,
-  clusterThreshold: 0.7,
-  embeddingDimension: EMBEDDING_CONFIG.DIMENSIONS,
-  patternNamespace: 'defect-intelligence:patterns',
-  enableSemanticClustering: true,
-};
-
-/**
- * Known defect pattern indicators
- */
-const KNOWN_PATTERNS: Record<string, { indicators: string[]; prevention: string }> = {
-  'null-pointer': {
-    indicators: ['null', 'undefined', 'NullPointerException', 'TypeError: Cannot read'],
-    prevention: 'Use null-safe operators and defensive programming',
-  },
-  'race-condition': {
-    indicators: ['concurrent', 'async', 'race', 'timing', 'intermittent'],
-    prevention: 'Implement proper synchronization and use atomic operations',
-  },
-  'memory-leak': {
-    indicators: ['memory', 'leak', 'OutOfMemory', 'heap', 'gc'],
-    prevention: 'Ensure proper resource cleanup and avoid circular references',
-  },
-  'off-by-one': {
-    indicators: ['index', 'boundary', 'array', 'loop', 'range'],
-    prevention: 'Validate array bounds and use inclusive/exclusive ranges consistently',
-  },
-  'input-validation': {
-    indicators: ['validation', 'sanitize', 'input', 'injection', 'XSS'],
-    prevention: 'Implement strict input validation and sanitization',
-  },
-  'resource-exhaustion': {
-    indicators: ['timeout', 'resource', 'exhausted', 'limit', 'quota'],
-    prevention: 'Implement rate limiting and resource pooling',
-  },
-  'state-corruption': {
-    indicators: ['state', 'inconsistent', 'corrupt', 'invalid state'],
-    prevention: 'Use immutable state patterns and proper state machines',
-  },
-  'encoding-issue': {
-    indicators: ['encoding', 'charset', 'UTF', 'unicode', 'character'],
-    prevention: 'Use consistent encoding throughout the application',
-  },
-};
-
-/**
- * Pattern Learner Service Implementation
- * Learns and recognizes defect patterns using ML and heuristics
- */
-export class PatternLearnerService implements IPatternLearnerService {
-  private readonly config: PatternLearnerConfig;
-  private readonly patternCache: Map<string, DefectPattern> = new Map();
-  private readonly embedder: IEmbeddingProvider;
-
-  constructor(
-    private readonly memory: MemoryBackend,
-    config: Partial<PatternLearnerConfig> = {}
-  ) {
-    this.config = { ...DEFAULT_CONFIG, ...config };
-    // Use provided embedder or create NomicEmbedder with fallback enabled
-    this.embedder = config.embedder ?? new NomicEmbedder({ enableFallback: true });
-  }
-
-  /**
-   * Learn patterns from a collection of defects
-   */
-  async learnPatterns(request: LearnRequest): Promise<Result<LearnedDefectPatterns, Error>> {
-    try {
-      const { defects, includeResolutions = false } = request;
-
-      if (defects.length === 0) {
-        return err(new Error('No defects provided for learning'));
-      }
-
-      const patterns: DefectPattern[] = [];
-      let modelUpdated = false;
-
-      // Extract patterns using multiple strategies
-      const extractedPatterns = await this.extractPatterns(defects);
-
-      // Merge with known patterns
-      const mergedPatterns = this.mergeWithKnownPatterns(extractedPatterns);
-
-      // Filter by frequency threshold
-      for (const pattern of mergedPatterns) {
-        if (pattern.frequency >= this.config.minPatternFrequency) {
-          patterns.push(pattern);
-
-          // Store learned pattern
-          await this.storePattern(pattern);
-          modelUpdated = true;
-        }
-      }
-
-      // Calculate improvement estimate based on pattern coverage
-      const improvementEstimate = this.calculateImprovementEstimate(
-        defects.length,
-        patterns
-      );
-
-      // Store resolution mappings if requested
-      if (includeResolutions) {
-        await this.learnResolutions(defects, patterns);
-      }
-
-      return ok({
-        patterns: patterns.slice(0, this.config.maxPatterns),
-        modelUpdated,
-        improvementEstimate,
-      });
-    } catch (error) {
-      return err(error instanceof Error ? error : new Error(String(error)));
-    }
-  }
-
-  /**
-   * Cluster defects by similarity
-   */
-  async clusterDefects(request: ClusterRequest): Promise<Result<DefectClusters, Error>> {
-    try {
-      const { defects, method, minClusterSize = 2 } = request;
-
-      if (defects.length === 0) {
-        return err(new Error('No defects provided for clustering'));
-      }
-
-      let clusters: DefectCluster[];
-
-      switch (method) {
-        case 'semantic':
-          clusters = await this.clusterBySemantic(defects, minClusterSize);
-          break;
-        case 'behavioral':
-          clusters = await this.clusterByBehavior(defects, minClusterSize);
-          break;
-        case 'temporal':
-          clusters = await this.clusterByTemporal(defects, minClusterSize);
-          break;
-        default:
-          return err(new Error(`Unknown clustering method: ${method}`));
-      }
-
-      // Identify outliers (defects not in any cluster)
-      const clusteredDefects = new Set(clusters.flatMap((c) => c.defects));
-      const outliers = defects
-        .filter((d) => !clusteredDefects.has(d.id))
-        .map((d) => d.id);
-
-      // Calculate clustering metrics
-      const clusteringMetrics = this.calculateClusteringMetrics(
-        clusters,
-        defects.length
-      );
-
-      return ok({
-        clusters,
-        outliers,
-        clusteringMetrics,
-      });
-    } catch (error) {
-      return err(error instanceof Error ? error : new Error(String(error)));
-    }
-  }
-
-  /**
-   * Find defects similar to a given defect
-   */
-  async findSimilarDefects(
-    defect: DefectInfo,
-    limit: number = 5
-  ): Promise<Result<DefectInfo[], Error>> {
-    try {
-      // Generate embedding for the defect
-      const embedding = await this.generateDefectEmbedding(defect);
-
-      // Search for similar vectors
-      const results: VectorSearchResult[] = await this.memory.vectorSearch(
-        embedding,
-        limit + 1 // +1 to exclude self
-      );
-
-      const similarDefects: DefectInfo[] = [];
-      for (const result of results) {
-        if (result.score >= this.config.clusterThreshold) {
-          const storedDefect = await this.memory.get<DefectInfo>(result.key);
-          if (storedDefect && storedDefect.id !== defect.id) {
-            similarDefects.push(storedDefect);
-          }
-        }
-      }
-
-      return ok(similarDefects.slice(0, limit));
-    } catch (error) {
-      return err(error instanceof Error ? error : new Error(String(error)));
-    }
-  }
-
-  /**
-   * Get a pattern by ID
-   */
-  async getPatternById(patternId: string): Promise<DefectPattern | undefined> {
-    // Check cache first
-    if (this.patternCache.has(patternId)) {
-      return this.patternCache.get(patternId);
-    }
-
-    // Load from memory
-    const patternKey = `${this.config.patternNamespace}:${patternId}`;
-    const stored = await this.memory.get<DefectPattern>(patternKey);
-
-    if (stored) {
-      this.patternCache.set(patternId, stored);
-      return stored;
-    }
-
-    return undefined;
-  }
-
-  /**
-   * List all learned patterns
-   */
-  async listPatterns(limit: number = this.config.maxPatterns): Promise<DefectPattern[]> {
-    const patterns: DefectPattern[] = [];
-    const keys = await this.memory.search(`${this.config.patternNamespace}:*`, limit * 2);
-
-    for (const key of keys) {
-      const pattern = await this.memory.get<DefectPattern>(key);
-      if (pattern) {
-        patterns.push(pattern);
-        if (patterns.length >= limit) break;
-      }
-    }
-
-    return patterns.sort((a, b) => b.frequency - a.frequency);
-  }
-
-  // ============================================================================
-  // Private Helper Methods
-  // ============================================================================
-
-  private async extractPatterns(defects: DefectInfo[]): Promise<DefectPattern[]> {
-    const patternCounts: Map<string, { indicators: string[]; defects: string[] }> =
-      new Map();
-
-    for (const defect of defects) {
-      const text = `${defect.title} ${defect.description}`.toLowerCase();
-
-      // Match against known patterns
-      for (const [patternName, patternData] of Object.entries(KNOWN_PATTERNS)) {
-        const matchingIndicators = patternData.indicators.filter((indicator) =>
-          text.includes(indicator.toLowerCase())
-        );
-
-        if (matchingIndicators.length > 0) {
-          const existing = patternCounts.get(patternName);
-          if (existing) {
-            existing.defects.push(defect.id);
-            existing.indicators.push(
-              ...matchingIndicators.filter((i) => !existing.indicators.includes(i))
-            );
-          } else {
-            patternCounts.set(patternName, {
-              indicators: matchingIndicators,
-              defects: [defect.id],
-            });
-          }
-        }
-      }
-
-      // Also look for custom patterns based on tags
-      if (defect.tags) {
-        for (const tag of defect.tags) {
-          const tagPattern = `tag-${tag}`;
-          const existing = patternCounts.get(tagPattern);
-          if (existing) {
-            existing.defects.push(defect.id);
-          } else {
-            patternCounts.set(tagPattern, {
-              indicators: [tag],
-              defects: [defect.id],
-            });
-          }
-        }
-      }
-    }
-
-    // Convert to DefectPattern array
-    const patterns: DefectPattern[] = [];
-    for (const [name, data] of patternCounts) {
-      const knownPattern = KNOWN_PATTERNS[name];
-      patterns.push({
-        id: uuidv4(),
-        name: this.formatPatternName(name),
-        indicators: [...new Set(data.indicators)],
-        frequency: data.defects.length,
-        prevention: knownPattern?.prevention || `Address ${name} issues proactively`,
-      });
-    }
-
-    return patterns;
-  }
-
-  private mergeWithKnownPatterns(extracted: DefectPattern[]): DefectPattern[] {
-    const merged = [...extracted];
-
-    // Add known patterns that weren't detected but are commonly relevant
-    for (const [name, data] of Object.entries(KNOWN_PATTERNS)) {
-      const exists = merged.some(
-        (p) => p.name.toLowerCase().includes(name.replace('-', ' '))
-      );
-
-      if (!exists) {
-        merged.push({
-          id: uuidv4(),
-          name: this.formatPatternName(name),
-          indicators: data.indicators,
-          frequency: 0, // Not yet observed
-          prevention: data.prevention,
-        });
-      }
-    }
-
-    return merged;
-  }
-
-  private formatPatternName(name: string): string {
-    return name
-      .split('-')
-      .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
-      .join(' ');
-  }
-
-  private async storePattern(pattern: DefectPattern): Promise<void> {
-    const patternKey = `${this.config.patternNamespace}:${pattern.id}`;
-    await this.memory.set(patternKey, pattern, {
-      namespace: 'defect-intelligence',
-      persist: true,
-    });
-
-    // Store vector for semantic search
-    if (this.config.enableSemanticClustering) {
-      const embedding = await this.generatePatternEmbedding(pattern);
-      await this.memory.storeVector(patternKey, embedding, {
-        patternId: pattern.id,
-        name: pattern.name,
-      });
-    }
-
-    this.patternCache.set(pattern.id, pattern);
-  }
-
-  private async learnResolutions(
-    defects: DefectInfo[],
-    patterns: DefectPattern[]
-  ): Promise<void> {
-    // Group defects by pattern
-    for (const pattern of patterns) {
-      const relatedDefects = defects.filter((d) => {
-        const text = `${d.title} ${d.description}`.toLowerCase();
-        return pattern.indicators.some((i) => text.includes(i.toLowerCase()));
-      });
-
-      if (relatedDefects.length > 0) {
-        await this.memory.set(
-          `${this.config.patternNamespace}:resolutions:${pattern.id}`,
-          {
-            patternId: pattern.id,
-            defectIds: relatedDefects.map((d) => d.id),
-            learnedAt: new Date().toISOString(),
-          },
-          { namespace: 'defect-intelligence', persist: true }
-        );
-      }
-    }
-  }
-
-  private calculateImprovementEstimate(
-    totalDefects: number,
-    patterns: DefectPattern[]
-  ): number {
-    if (totalDefects === 0) return 0;
-
-    // Calculate what percentage of defects are covered by patterns
-    const coveredDefects = patterns.reduce((sum, p) => sum + p.frequency, 0);
-    const coverage = Math.min(1, coveredDefects / totalDefects);
-
-    // Estimate improvement based on coverage and pattern quality
-    const patternQuality = patterns.length > 0
-      ? patterns.reduce((sum, p) => sum + (p.prevention ? 0.1 : 0), 0) /
-        patterns.length
-      : 0;
-
-    return coverage * 0.7 + patternQuality * 0.3;
-  }
-
-  private async clusterBySemantic(
-    defects: DefectInfo[],
-    minSize: number
-  ): Promise<DefectCluster[]> {
-    const clusters: Map<string, DefectCluster> = new Map();
-
-    // Generate embeddings for all defects
-    const embeddings: { defect: DefectInfo; embedding: number[] }[] = [];
-    for (const defect of defects) {
-      const embedding = await this.generateDefectEmbedding(defect);
-      embeddings.push({ defect, embedding });
-
-      // Store for future similarity searches
-      await this.memory.storeVector(
-        `${this.config.patternNamespace}:defect:${defect.id}`,
-        embedding,
-        { defectId: defect.id }
-      );
-    }
-
-    // Simple clustering by finding nearest neighbors
-    const assigned = new Set<string>();
-
-    for (const { defect, embedding } of embeddings) {
-      if (assigned.has(defect.id)) continue;
-
-      const clusterMembers: string[] = [defect.id];
-      assigned.add(defect.id);
-
-      // Find similar defects
-      for (const other of embeddings) {
-        if (other.defect.id === defect.id || assigned.has(other.defect.id)) continue;
-
-        const similarity = this.cosineSimilarity(embedding, other.embedding);
-        if (similarity >= this.config.clusterThreshold) {
-          clusterMembers.push(other.defect.id);
-          assigned.add(other.defect.id);
-        }
-      }
-
-      if (clusterMembers.length >= minSize) {
-        const clusterId = uuidv4();
-        const commonFactors = this.findCommonFactors(
-          defects.filter((d) => clusterMembers.includes(d.id))
-        );
-
-        clusters.set(clusterId, {
-          id: clusterId,
-          label: this.generateClusterLabel(
-            defects.filter((d) => clusterMembers.includes(d.id))
-          ),
-          defects: clusterMembers,
-          commonFactors,
-          suggestedFix: this.suggestFix(commonFactors),
-        });
-      }
-    }
-
-    return Array.from(clusters.values());
-  }
-
-  private async clusterByBehavior(
-    defects: DefectInfo[],
-    minSize: number
-  ): Promise<DefectCluster[]> {
-    const clusters: Map<string, DefectCluster> = new Map();
-
-    // Group by tags and file
-    const groups: Map<string, DefectInfo[]> = new Map();
-
-    for (const defect of defects) {
-      const groupKey = defect.tags?.sort().join('|') || defect.file || 'unknown';
-      const group = groups.get(groupKey) || [];
-      group.push(defect);
-      groups.set(groupKey, group);
-    }
-
-    for (const [key, groupDefects] of groups) {
-      if (groupDefects.length >= minSize) {
-        const clusterId = uuidv4();
-        const commonFactors = this.findCommonFactors(groupDefects);
-
-        clusters.set(clusterId, {
-          id: clusterId,
-          label: `Behavioral: ${key.replace('|', ', ')}`,
-          defects: groupDefects.map((d) => d.id),
-          commonFactors,
-          suggestedFix: this.suggestFix(commonFactors),
-        });
-      }
-    }
-
-    return Array.from(clusters.values());
-  }
-
-  private async clusterByTemporal(
-    defects: DefectInfo[],
-    _minSize: number
-  ): Promise<DefectCluster[]> {
-    // Temporal clustering would require timestamps
-    // Stub implementation - group by same title words
-    const clusters: Map<string, DefectCluster> = new Map();
-    const titleWords: Map<string, DefectInfo[]> = new Map();
-
-    for (const defect of defects) {
-      const words = defect.title.toLowerCase().split(/\s+/).slice(0, 2).join(' ');
-      const group = titleWords.get(words) || [];
-      group.push(defect);
-      titleWords.set(words, group);
-    }
-
-    for (const [words, groupDefects] of titleWords) {
-      if (groupDefects.length >= 2) {
-        const clusterId = uuidv4();
-        const commonFactors = this.findCommonFactors(groupDefects);
-
-        clusters.set(clusterId, {
-          id: clusterId,
-          label: `Temporal: ${words}`,
-          defects: groupDefects.map((d) => d.id),
-          commonFactors,
-          suggestedFix: this.suggestFix(commonFactors),
-        });
-      }
-    }
-
-    return Array.from(clusters.values());
-  }
-
-  private findCommonFactors(defects: DefectInfo[]): string[] {
-    const factors: string[] = [];
-
-    // Find common tags
-    if (defects.every((d) => d.tags)) {
-      const allTags = defects.map((d) => new Set(d.tags));
-      const commonTags = [...allTags[0]].filter((tag) =>
-        allTags.every((tags) => tags.has(tag))
-      );
-      factors.push(...commonTags);
-    }
-
-    // Find common file patterns
-    if (defects.every((d) => d.file)) {
-      const filePaths = defects.map((d) => d.file!.split('/'));
-      const minLen = Math.min(...filePaths.map((p) => p.length));
-      for (let i = 0; i < minLen; i++) {
-        if (filePaths.every((p) => p[i] === filePaths[0][i])) {
-          factors.push(`Path: ${filePaths[0][i]}`);
-        }
-      }
-    }
-
-    // Find common words in titles
-    const titleWords = defects.map(
-      (d) => new Set(d.title.toLowerCase().split(/\s+/))
-    );
-    const commonWords = [...titleWords[0]].filter(
-      (word) => word.length > 3 && titleWords.every((words) => words.has(word))
-    );
-    factors.push(...commonWords.map((w) => `Keyword: ${w}`));
-
-    return [...new Set(factors)];
-  }
-
-  private generateClusterLabel(defects: DefectInfo[]): string {
-    // Generate a label based on common patterns
-    const titles = defects.map((d) => d.title.toLowerCase());
-    const words = titles.flatMap((t) => t.split(/\s+/));
-    const wordCounts = new Map<string, number>();
-
-    for (const word of words) {
-      if (word.length > 3) {
-        wordCounts.set(word, (wordCounts.get(word) || 0) + 1);
-      }
-    }
-
-    const sortedWords = [...wordCounts.entries()]
-      .sort((a, b) => b[1] - a[1])
-      .slice(0, 2)
-      .map(([word]) => word);
-
-    return sortedWords.join(' ') || 'Unnamed Cluster';
-  }
-
-  private suggestFix(commonFactors: string[]): string {
-    // Generate fix suggestion based on common factors
-    for (const factor of commonFactors) {
-      for (const [pattern, data] of Object.entries(KNOWN_PATTERNS)) {
-        if (
-          factor.toLowerCase().includes(pattern) ||
-          data.indicators.some((i) =>
-            factor.toLowerCase().includes(i.toLowerCase())
-          )
-        ) {
-          return data.prevention;
-        }
-      }
-    }
-
-    return 'Review common factors and implement targeted fixes';
-  }
-
-  private calculateClusteringMetrics(
-    clusters: DefectCluster[],
-    totalDefects: number
-  ): { silhouette: number; cohesion: number } {
-    if (clusters.length === 0 || totalDefects === 0) {
-      return { silhouette: 0, cohesion: 0 };
-    }
-
-    // Simplified metrics
-    const clusteredDefects = clusters.reduce(
-      (sum, c) => sum + c.defects.length,
-      0
-    );
-    const avgClusterSize = clusteredDefects / clusters.length;
-
-    // Cohesion: how many defects are clustered
-    const cohesion = clusteredDefects / totalDefects;
-
-    // Silhouette approximation: based on cluster size uniformity
-    const sizes = clusters.map((c) => c.defects.length);
-    const sizeVariance =
-      sizes.reduce((sum, s) => sum + Math.pow(s - avgClusterSize, 2), 0) /
-      sizes.length;
-    const silhouette = Math.max(0, 1 - sizeVariance / (avgClusterSize * avgClusterSize || 1));
-
-    return {
-      silhouette: Math.round(silhouette * 100) / 100,
-      cohesion: Math.round(cohesion * 100) / 100,
-    };
-  }
-
-  /**
-   * Generate embedding for a defect
-   * Uses NomicEmbedder for semantic embeddings
-   */
-  private async generateDefectEmbedding(defect: DefectInfo): Promise<number[]> {
-    const text = this.formatDefectForEmbedding(defect);
-    return this.embedder.embed(text);
-  }
-
-  /**
-   * Generate embedding for a pattern
-   * Uses the same embedder as defects for consistent similarity matching
-   */
-  private async generatePatternEmbedding(pattern: DefectPattern): Promise<number[]> {
-    const text = this.formatPatternForEmbedding(pattern);
-    return this.embedder.embed(text);
-  }
-
-  /**
-   * Format a defect for embedding generation
-   */
-  private formatDefectForEmbedding(defect: DefectInfo): string {
-    const parts = [
-      `Title: ${defect.title}`,
-      defect.description ? `Description: ${defect.description}` : '',
-      defect.tags?.length ? `Tags: ${defect.tags.join(', ')}` : '',
-      defect.file ? `File: ${defect.file}` : '',
-    ].filter(Boolean);
-
-    return parts.join('\n');
-  }
-
-  /**
-   * Format a pattern for embedding generation
-   */
-  private formatPatternForEmbedding(pattern: DefectPattern): string {
-    const parts = [
-      `Pattern: ${pattern.name}`,
-      `Indicators: ${pattern.indicators.join(', ')}`,
-      `Prevention: ${pattern.prevention}`,
-      `Frequency: ${pattern.frequency}`,
-    ].filter(Boolean);
-
-    return parts.join('\n');
-  }
-
-  private cosineSimilarity(a: number[], b: number[]): number {
-    if (a.length !== b.length) return 0;
-
-    let dotProduct = 0;
-    let normA = 0;
-    let normB = 0;
-
-    for (let i = 0; i < a.length; i++) {
-      dotProduct += a[i] * b[i];
-      normA += a[i] * a[i];
-      normB += b[i] * b[i];
-    }
-
-    const denominator = Math.sqrt(normA) * Math.sqrt(normB);
-    return denominator === 0 ? 0 : dotProduct / denominator;
-  }
-}