claude-flow-novice 2.15.2 → 2.15.4

package/dist/services/edge-case-analyzer.js

@@ -0,0 +1,321 @@
+/**
+ * Edge Case Analyzer
+ * Part of Task 5.1: Edge Case Analyzer & Skill Patcher
+ *
+ * Analyzes skill execution failures to identify patterns and categorize edge cases.
+ * Supports pattern matching, confidence scoring, and failure statistics.
+ *
+ * Features:
+ * - Automatic failure categorization (syntax, logic, timeout, validation, unknown)
+ * - Pattern matching for similar failures
+ * - Confidence scoring based on failure frequency
+ * - Integration with DatabaseService
+ * - Performance optimized (<500ms for pattern matching)
+ *
+ * Usage:
+ *   const analyzer = new EdgeCaseAnalyzer({ dbPath: './edge-cases.db' });
+ *   const pattern = await analyzer.analyzeFailure(error, { skillId: 'my-skill' });
+ *   console.log(`Detected ${pattern.category} with ${pattern.confidence} confidence`);
+ */ import * as crypto from 'crypto';
+import Database from 'better-sqlite3';
+import { createLogger } from '../lib/logging.js';
+import { StandardError, ErrorCode } from '../lib/errors.js';
+const logger = createLogger('edge-case-analyzer');
+/**
+ * Failure category classification
+ */ export var FailureCategory = /*#__PURE__*/ function(FailureCategory) {
+    FailureCategory["SYNTAX_ERROR"] = "SYNTAX_ERROR";
+    FailureCategory["LOGIC_ERROR"] = "LOGIC_ERROR";
+    FailureCategory["TIMEOUT"] = "TIMEOUT";
+    FailureCategory["VALIDATION_ERROR"] = "VALIDATION_ERROR";
+    FailureCategory["UNKNOWN"] = "UNKNOWN";
+    return FailureCategory;
+}({});
+/**
+ * Edge Case Analyzer Service
+ */ export class EdgeCaseAnalyzer {
+    db;
+    constructor(config){
+        this.db = new Database(config.dbPath);
+        this.initializeDatabase();
+    }
+    /**
+   * Initialize database schema
+   */ initializeDatabase() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS edge_cases (
+        id TEXT PRIMARY KEY,
+        skill_id TEXT NOT NULL,
+        category TEXT NOT NULL,
+        error_message TEXT,
+        stack_trace TEXT,
+        context TEXT,
+        detected_at TEXT DEFAULT CURRENT_TIMESTAMP,
+        pattern_hash TEXT,
+        confidence REAL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_edge_cases_skill ON edge_cases(skill_id);
+      CREATE INDEX IF NOT EXISTS idx_edge_cases_category ON edge_cases(category);
+      CREATE INDEX IF NOT EXISTS idx_edge_cases_pattern ON edge_cases(pattern_hash);
+    `);
+    }
+    /**
+   * Categorize failure based on error type and context
+   *
+   * Performance target: <200ms
+   */ categorizeFailure(error, context) {
+        const startTime = Date.now();
+        try {
+            // Check for syntax errors
+            if (error instanceof SyntaxError) {
+                logger.debug('Categorized as SYNTAX_ERROR', {
+                    error: error.message
+                });
+                return "SYNTAX_ERROR";
+            }
+            // Check for timeout errors
+            if (error instanceof StandardError && (error.code === ErrorCode.OPERATION_TIMEOUT || error.code === ErrorCode.DB_TIMEOUT)) {
+                logger.debug('Categorized as TIMEOUT', {
+                    error: error.message
+                });
+                return "TIMEOUT";
+            }
+            if (error.message && /timeout|timed out/i.test(error.message)) {
+                logger.debug('Categorized as TIMEOUT from message', {
+                    error: error.message
+                });
+                return "TIMEOUT";
+            }
+            // Check for validation errors
+            if (error instanceof StandardError && (error.code === ErrorCode.VALIDATION_FAILED || error.code === ErrorCode.INVALID_INPUT || error.code === ErrorCode.DB_VALIDATION_FAILED)) {
+                logger.debug('Categorized as VALIDATION_ERROR', {
+                    error: error.message
+                });
+                return "VALIDATION_ERROR";
+            }
+            // Check for null/undefined errors (validation)
+            if (error instanceof TypeError && (error.message.includes('null') || error.message.includes('undefined') || error.message.includes('Cannot read property'))) {
+                logger.debug('Categorized as VALIDATION_ERROR (null/undefined)', {
+                    error: error.message
+                });
+                return "VALIDATION_ERROR";
+            }
+            // Check for logic errors (file not found, reference errors, etc.)
+            if (error instanceof ReferenceError) {
+                logger.debug('Categorized as LOGIC_ERROR (ReferenceError)', {
+                    error: error.message
+                });
+                return "LOGIC_ERROR";
+            }
+            if (error instanceof StandardError && (error.code === ErrorCode.FILE_NOT_FOUND || error.code === ErrorCode.FILE_WRITE_FAILED)) {
+                logger.debug('Categorized as LOGIC_ERROR (file operation)', {
+                    error: error.message
+                });
+                return "LOGIC_ERROR";
+            }
+            // Default to unknown
+            logger.debug('Categorized as UNKNOWN', {
+                error: error.message
+            });
+            return "UNKNOWN";
+        } finally{
+            const duration = Date.now() - startTime;
+            logger.debug('Categorization completed', {
+                durationMs: duration
+            });
+        }
+    }
+    /**
+   * Find similar failures by skill and category
+   *
+   * Performance target: <500ms
+   */ findSimilarFailures(failure) {
+        const startTime = Date.now();
+        try {
+            const stmt = this.db.prepare(`
+        SELECT * FROM edge_cases
+        WHERE skill_id = ?
+          AND category = ?
+          AND id != ?
+        ORDER BY detected_at DESC
+        LIMIT 10
+      `);
+            const rows = stmt.all(failure.skillId, failure.category, failure.id);
+            const similar = rows.map((row)=>({
+                    id: row.id,
+                    skillId: row.skill_id,
+                    category: row.category,
+                    errorMessage: row.error_message,
+                    stackTrace: row.stack_trace,
+                    context: JSON.parse(row.context || '{}'),
+                    detectedAt: new Date(row.detected_at),
+                    patternHash: row.pattern_hash,
+                    confidence: row.confidence
+                }));
+            logger.debug('Found similar failures', {
+                count: similar.length,
+                durationMs: Date.now() - startTime
+            });
+            return similar;
+        } catch (error) {
+            logger.error('Failed to find similar failures', error);
+            return [];
+        }
+    }
+    /**
+   * Calculate confidence score based on failure frequency
+   *
+   * Formula:
+   * - 0 failures: 0.0
+   * - 1 failure: 0.5
+   * - 2-3 failures: 0.6-0.7
+   * - 4-6 failures: 0.75-0.85
+   * - 7-10 failures: 0.85-0.95
+   * - 10+ failures: 0.95+
+   */ calculatePatternConfidence(failures) {
+        if (failures.length === 0) {
+            return 0;
+        }
+        if (failures.length === 1) {
+            return 0.5;
+        }
+        if (failures.length <= 3) {
+            return 0.6 + failures.length * 0.05;
+        }
+        if (failures.length <= 6) {
+            return 0.75 + (failures.length - 3) * 0.03;
+        }
+        if (failures.length <= 10) {
+            return 0.85 + (failures.length - 6) * 0.025;
+        }
+        return Math.min(0.98, 0.95 + (failures.length - 10) * 0.01);
+    }
+    /**
+   * Generate pattern hash from error message and category
+   */ generatePatternHash(category, errorMessage) {
+        // Normalize error message (remove numbers, paths, etc.)
+        const normalized = errorMessage.replace(/\d+/g, 'N') // Replace numbers
+        .replace(/\/[^\s]*/g, '/PATH') // Replace file paths
+        .replace(/at [^\n]*/g, 'at LOCATION') // Replace stack locations
+        .toLowerCase();
+        const hashInput = `${category}:${normalized}`;
+        return crypto.createHash('sha256').update(hashInput).digest('hex').substring(0, 16);
+    }
+    /**
+   * Analyze failure and detect patterns
+   *
+   * Returns failure pattern with confidence score
+   */ async analyzeFailure(error, context) {
+        const startTime = Date.now();
+        // Categorize the failure
+        const category = this.categorizeFailure(error, context);
+        // Generate pattern hash
+        const patternHash = this.generatePatternHash(category, error.message);
+        // Create failure record
+        const failure = {
+            id: crypto.randomUUID(),
+            skillId: context.skillId || 'unknown',
+            category,
+            errorMessage: error.message,
+            stackTrace: error.stack || '',
+            context,
+            detectedAt: new Date(),
+            patternHash
+        };
+        // Find similar failures
+        const similar = this.findSimilarFailures(failure);
+        // Calculate confidence
+        const allFailures = [
+            failure,
+            ...similar
+        ];
+        const confidence = this.calculatePatternConfidence(allFailures);
+        // Store failure
+        this.db.prepare(`
+      INSERT INTO edge_cases (id, skill_id, category, error_message, stack_trace, context, pattern_hash, confidence)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(failure.id, failure.skillId, failure.category, failure.errorMessage, failure.stackTrace, JSON.stringify(failure.context), failure.patternHash, confidence);
+        // Build pattern
+        const skillIds = Array.from(new Set([
+            failure.skillId,
+            ...similar.map((f)=>f.skillId)
+        ]));
+        const pattern = {
+            category,
+            patternHash,
+            failureCount: allFailures.length,
+            confidence,
+            firstSeenAt: similar.length > 0 ? similar[similar.length - 1].detectedAt : failure.detectedAt,
+            lastSeenAt: failure.detectedAt,
+            skillIds
+        };
+        logger.info('Failure analyzed', {
+            category,
+            confidence,
+            failureCount: allFailures.length,
+            durationMs: Date.now() - startTime
+        });
+        return pattern;
+    }
+    /**
+   * Get failure statistics
+   */ getFailureStats(skillId) {
+        const whereClause = skillId ? 'WHERE skill_id = ?' : '';
+        const params = skillId ? [
+            skillId
+        ] : [];
+        // Total failures
+        const totalStmt = this.db.prepare(`SELECT COUNT(*) as count FROM edge_cases ${whereClause}`);
+        const totalResult = totalStmt.get(...params);
+        const totalFailures = totalResult.count;
+        // By category
+        const categoryStmt = this.db.prepare(`
+      SELECT category, COUNT(*) as count
+      FROM edge_cases
+      ${whereClause}
+      GROUP BY category
+    `);
+        const categoryResults = categoryStmt.all(...params);
+        const byCategory = {};
+        for (const row of categoryResults){
+            byCategory[row.category] = row.count;
+        }
+        // Unique patterns
+        const patternsStmt = this.db.prepare(`
+      SELECT COUNT(DISTINCT pattern_hash) as count
+      FROM edge_cases
+      ${whereClause}
+    `);
+        const patternsResult = patternsStmt.get(...params);
+        const uniquePatterns = patternsResult.count;
+        // Top patterns
+        const topStmt = this.db.prepare(`
+      SELECT pattern_hash, category, COUNT(*) as count
+      FROM edge_cases
+      ${whereClause}
+      GROUP BY pattern_hash, category
+      ORDER BY count DESC
+      LIMIT 5
+    `);
+        const topResults = topStmt.all(...params);
+        const topPatterns = topResults.map((row)=>({
+                patternHash: row.pattern_hash,
+                count: row.count,
+                category: row.category
+            }));
+        return {
+            totalFailures,
+            byCategory,
+            uniquePatterns,
+            topPatterns
+        };
+    }
+    /**
+   * Close database connection
+   */ close() {
+        this.db.close();
+    }
+}
+
+//# sourceMappingURL=edge-case-analyzer.js.map

package/dist/services/edge-case-analyzer.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/services/edge-case-analyzer.ts"],"sourcesContent":["/**\r\n * Edge Case Analyzer\r\n * Part of Task 5.1: Edge Case Analyzer & Skill Patcher\r\n *\r\n * Analyzes skill execution failures to identify patterns and categorize edge cases.\r\n * Supports pattern matching, confidence scoring, and failure statistics.\r\n *\r\n * Features:\r\n * - Automatic failure categorization (syntax, logic, timeout, validation, unknown)\r\n * - Pattern matching for similar failures\r\n * - Confidence scoring based on failure frequency\r\n * - Integration with DatabaseService\r\n * - Performance optimized (<500ms for pattern matching)\r\n *\r\n * Usage:\r\n *   const analyzer = new EdgeCaseAnalyzer({ dbPath: './edge-cases.db' });\r\n *   const pattern = await analyzer.analyzeFailure(error, { skillId: 'my-skill' });\r\n *   console.log(`Detected ${pattern.category} with ${pattern.confidence} confidence`);\r\n */\r\n\r\nimport * as crypto from 'crypto';\r\nimport Database from 'better-sqlite3';\r\nimport { createLogger } from '../lib/logging.js';\r\nimport { StandardError, ErrorCode, createError } from '../lib/errors.js';\r\n\r\nconst logger = createLogger('edge-case-analyzer');\r\n\r\n/**\r\n * Failure category classification\r\n */\r\nexport enum FailureCategory {\r\n  SYNTAX_ERROR = 'SYNTAX_ERROR',\r\n  LOGIC_ERROR = 'LOGIC_ERROR',\r\n  TIMEOUT = 'TIMEOUT',\r\n  VALIDATION_ERROR = 'VALIDATION_ERROR',\r\n  UNKNOWN = 'UNKNOWN',\r\n}\r\n\r\n/**\r\n * Failure record\r\n */\r\nexport interface Failure {\r\n  id: string;\r\n  skillId: string;\r\n  category: FailureCategory;\r\n  errorMessage: string;\r\n  stackTrace: string;\r\n  context: Record<string, any>;\r\n  detectedAt: Date;\r\n  patternHash: string;\r\n  confidence?: number;\r\n}\r\n\r\n/**\r\n * Failure pattern with statistics\r\n */\r\nexport interface FailurePattern {\r\n  category: FailureCategory;\r\n  patternHash: string;\r\n  failureCount: number;\r\n  confidence: number;\r\n  firstSeenAt: Date;\r\n  lastSeenAt: Date;\r\n  skillIds: string[];\r\n}\r\n\r\n/**\r\n * Failure statistics\r\n */\r\nexport interface FailureStats {\r\n  totalFailures: number;\r\n  byCategory: Record<string, number>;\r\n  uniquePatterns: number;\r\n  topPatterns: Array<{\r\n    patternHash: string;\r\n    count: number;\r\n    category: FailureCategory;\r\n  }>;\r\n}\r\n\r\n/**\r\n * Analyzer configuration\r\n */\r\nexport interface EdgeCaseAnalyzerConfig {\r\n  dbPath: string;\r\n}\r\n\r\n/**\r\n * Edge Case Analyzer Service\r\n */\r\nexport class EdgeCaseAnalyzer {\r\n  private db: Database.Database;\r\n\r\n  constructor(config: EdgeCaseAnalyzerConfig) {\r\n    this.db = new Database(config.dbPath);\r\n    this.initializeDatabase();\r\n  }\r\n\r\n  /**\r\n   * Initialize database schema\r\n   */\r\n  private initializeDatabase(): void {\r\n    this.db.exec(`\r\n      CREATE TABLE IF NOT EXISTS edge_cases (\r\n        id TEXT PRIMARY KEY,\r\n        skill_id TEXT NOT NULL,\r\n        category TEXT NOT NULL,\r\n        error_message TEXT,\r\n        stack_trace TEXT,\r\n        context TEXT,\r\n        detected_at TEXT DEFAULT CURRENT_TIMESTAMP,\r\n        pattern_hash TEXT,\r\n        confidence REAL\r\n      );\r\n\r\n      CREATE INDEX IF NOT EXISTS idx_edge_cases_skill ON edge_cases(skill_id);\r\n      CREATE INDEX IF NOT EXISTS idx_edge_cases_category ON edge_cases(category);\r\n      CREATE INDEX IF NOT EXISTS idx_edge_cases_pattern ON edge_cases(pattern_hash);\r\n    `);\r\n  }\r\n\r\n  /**\r\n   * Categorize failure based on error type and context\r\n   *\r\n   * Performance target: <200ms\r\n   */\r\n  categorizeFailure(error: Error, context: any): FailureCategory {\r\n    const startTime = Date.now();\r\n\r\n    try {\r\n      // Check for syntax errors\r\n      if (error instanceof SyntaxError) {\r\n        logger.debug('Categorized as SYNTAX_ERROR', { error: error.message });\r\n        return FailureCategory.SYNTAX_ERROR;\r\n      }\r\n\r\n      // Check for timeout errors\r\n      if (\r\n        error instanceof StandardError &&\r\n        (error.code === ErrorCode.OPERATION_TIMEOUT || error.code === ErrorCode.DB_TIMEOUT)\r\n      ) {\r\n        logger.debug('Categorized as TIMEOUT', { error: error.message });\r\n        return FailureCategory.TIMEOUT;\r\n      }\r\n\r\n      if (error.message && /timeout|timed out/i.test(error.message)) {\r\n        logger.debug('Categorized as TIMEOUT from message', { error: error.message });\r\n        return FailureCategory.TIMEOUT;\r\n      }\r\n\r\n      // Check for validation errors\r\n      if (\r\n        error instanceof StandardError &&\r\n        (error.code === ErrorCode.VALIDATION_FAILED ||\r\n          error.code === ErrorCode.INVALID_INPUT ||\r\n          error.code === ErrorCode.DB_VALIDATION_FAILED)\r\n      ) {\r\n        logger.debug('Categorized as VALIDATION_ERROR', { error: error.message });\r\n        return FailureCategory.VALIDATION_ERROR;\r\n      }\r\n\r\n      // Check for null/undefined errors (validation)\r\n      if (\r\n        error instanceof TypeError &&\r\n        (error.message.includes('null') ||\r\n          error.message.includes('undefined') ||\r\n          error.message.includes('Cannot read property'))\r\n      ) {\r\n        logger.debug('Categorized as VALIDATION_ERROR (null/undefined)', {\r\n          error: error.message,\r\n        });\r\n        return FailureCategory.VALIDATION_ERROR;\r\n      }\r\n\r\n      // Check for logic errors (file not found, reference errors, etc.)\r\n      if (error instanceof ReferenceError) {\r\n        logger.debug('Categorized as LOGIC_ERROR (ReferenceError)', { error: error.message });\r\n        return FailureCategory.LOGIC_ERROR;\r\n      }\r\n\r\n      if (\r\n        error instanceof StandardError &&\r\n        (error.code === ErrorCode.FILE_NOT_FOUND || error.code === ErrorCode.FILE_WRITE_FAILED)\r\n      ) {\r\n        logger.debug('Categorized as LOGIC_ERROR (file operation)', { error: error.message });\r\n        return FailureCategory.LOGIC_ERROR;\r\n      }\r\n\r\n      // Default to unknown\r\n      logger.debug('Categorized as UNKNOWN', { error: error.message });\r\n      return FailureCategory.UNKNOWN;\r\n    } finally {\r\n      const duration = Date.now() - startTime;\r\n      logger.debug('Categorization completed', { durationMs: duration });\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Find similar failures by skill and category\r\n   *\r\n   * Performance target: <500ms\r\n   */\r\n  findSimilarFailures(failure: Failure): Failure[] {\r\n    const startTime = Date.now();\r\n\r\n    try {\r\n      const stmt = this.db.prepare(`\r\n        SELECT * FROM edge_cases\r\n        WHERE skill_id = ?\r\n          AND category = ?\r\n          AND id != ?\r\n        ORDER BY detected_at DESC\r\n        LIMIT 10\r\n      `);\r\n\r\n      const rows = stmt.all(failure.skillId, failure.category, failure.id) as any[];\r\n\r\n      const similar = rows.map(row => ({\r\n        id: row.id,\r\n        skillId: row.skill_id,\r\n        category: row.category as FailureCategory,\r\n        errorMessage: row.error_message,\r\n        stackTrace: row.stack_trace,\r\n        context: JSON.parse(row.context || '{}'),\r\n        detectedAt: new Date(row.detected_at),\r\n        patternHash: row.pattern_hash,\r\n        confidence: row.confidence,\r\n      }));\r\n\r\n      logger.debug('Found similar failures', {\r\n        count: similar.length,\r\n        durationMs: Date.now() - startTime,\r\n      });\r\n\r\n      return similar;\r\n    } catch (error) {\r\n      logger.error('Failed to find similar failures', error as Error);\r\n      return [];\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Calculate confidence score based on failure frequency\r\n   *\r\n   * Formula:\r\n   * - 0 failures: 0.0\r\n   * - 1 failure: 0.5\r\n   * - 2-3 failures: 0.6-0.7\r\n   * - 4-6 failures: 0.75-0.85\r\n   * - 7-10 failures: 0.85-0.95\r\n   * - 10+ failures: 0.95+\r\n   */\r\n  calculatePatternConfidence(failures: Failure[]): number {\r\n    if (failures.length === 0) {\r\n      return 0;\r\n    }\r\n\r\n    if (failures.length === 1) {\r\n      return 0.5;\r\n    }\r\n\r\n    if (failures.length <= 3) {\r\n      return 0.6 + failures.length * 0.05;\r\n    }\r\n\r\n    if (failures.length <= 6) {\r\n      return 0.75 + (failures.length - 3) * 0.03;\r\n    }\r\n\r\n    if (failures.length <= 10) {\r\n      return 0.85 + (failures.length - 6) * 0.025;\r\n    }\r\n\r\n    return Math.min(0.98, 0.95 + (failures.length - 10) * 0.01);\r\n  }\r\n\r\n  /**\r\n   * Generate pattern hash from error message and category\r\n   */\r\n  private generatePatternHash(category: FailureCategory, errorMessage: string): string {\r\n    // Normalize error message (remove numbers, paths, etc.)\r\n    const normalized = errorMessage\r\n      .replace(/\\d+/g, 'N') // Replace numbers\r\n      .replace(/\\/[^\\s]*/g, '/PATH') // Replace file paths\r\n      .replace(/at [^\\n]*/g, 'at LOCATION') // Replace stack locations\r\n      .toLowerCase();\r\n\r\n    const hashInput = `${category}:${normalized}`;\r\n    return crypto.createHash('sha256').update(hashInput).digest('hex').substring(0, 16);\r\n  }\r\n\r\n  /**\r\n   * Analyze failure and detect patterns\r\n   *\r\n   * Returns failure pattern with confidence score\r\n   */\r\n  async analyzeFailure(error: Error, context: any): Promise<FailurePattern> {\r\n    const startTime = Date.now();\r\n\r\n    // Categorize the failure\r\n    const category = this.categorizeFailure(error, context);\r\n\r\n    // Generate pattern hash\r\n    const patternHash = this.generatePatternHash(category, error.message);\r\n\r\n    // Create failure record\r\n    const failure: Failure = {\r\n      id: crypto.randomUUID(),\r\n      skillId: context.skillId || 'unknown',\r\n      category,\r\n      errorMessage: error.message,\r\n      stackTrace: error.stack || '',\r\n      context,\r\n      detectedAt: new Date(),\r\n      patternHash,\r\n    };\r\n\r\n    // Find similar failures\r\n    const similar = this.findSimilarFailures(failure);\r\n\r\n    // Calculate confidence\r\n    const allFailures = [failure, ...similar];\r\n    const confidence = this.calculatePatternConfidence(allFailures);\r\n\r\n    // Store failure\r\n    this.db\r\n      .prepare(\r\n        `\r\n      INSERT INTO edge_cases (id, skill_id, category, error_message, stack_trace, context, pattern_hash, confidence)\r\n      VALUES (?, ?, ?, ?, ?, ?, ?, ?)\r\n    `\r\n      )\r\n      .run(\r\n        failure.id,\r\n        failure.skillId,\r\n        failure.category,\r\n        failure.errorMessage,\r\n        failure.stackTrace,\r\n        JSON.stringify(failure.context),\r\n        failure.patternHash,\r\n        confidence\r\n      );\r\n\r\n    // Build pattern\r\n    const skillIds = Array.from(new Set([failure.skillId, ...similar.map(f => f.skillId)]));\r\n\r\n    const pattern: FailurePattern = {\r\n      category,\r\n      patternHash,\r\n      failureCount: allFailures.length,\r\n      confidence,\r\n      firstSeenAt: similar.length > 0 ? similar[similar.length - 1].detectedAt : failure.detectedAt,\r\n      lastSeenAt: failure.detectedAt,\r\n      skillIds,\r\n    };\r\n\r\n    logger.info('Failure analyzed', {\r\n      category,\r\n      confidence,\r\n      failureCount: allFailures.length,\r\n      durationMs: Date.now() - startTime,\r\n    });\r\n\r\n    return pattern;\r\n  }\r\n\r\n  /**\r\n   * Get failure statistics\r\n   */\r\n  getFailureStats(skillId?: string): FailureStats {\r\n    const whereClause = skillId ? 'WHERE skill_id = ?' : '';\r\n    const params = skillId ? [skillId] : [];\r\n\r\n    // Total failures\r\n    const totalStmt = this.db.prepare(`SELECT COUNT(*) as count FROM edge_cases ${whereClause}`);\r\n    const totalResult = totalStmt.get(...params) as any;\r\n    const totalFailures = totalResult.count;\r\n\r\n    // By category\r\n    const categoryStmt = this.db.prepare(`\r\n      SELECT category, COUNT(*) as count\r\n      FROM edge_cases\r\n      ${whereClause}\r\n      GROUP BY category\r\n    `);\r\n    const categoryResults = categoryStmt.all(...params) as any[];\r\n\r\n    const byCategory: Record<string, number> = {};\r\n    for (const row of categoryResults) {\r\n      byCategory[row.category] = row.count;\r\n    }\r\n\r\n    // Unique patterns\r\n    const patternsStmt = this.db.prepare(`\r\n      SELECT COUNT(DISTINCT pattern_hash) as count\r\n      FROM edge_cases\r\n      ${whereClause}\r\n    `);\r\n    const patternsResult = patternsStmt.get(...params) as any;\r\n    const uniquePatterns = patternsResult.count;\r\n\r\n    // Top patterns\r\n    const topStmt = this.db.prepare(`\r\n      SELECT pattern_hash, category, COUNT(*) as count\r\n      FROM edge_cases\r\n      ${whereClause}\r\n      GROUP BY pattern_hash, category\r\n      ORDER BY count DESC\r\n      LIMIT 5\r\n    `);\r\n    const topResults = topStmt.all(...params) as any[];\r\n\r\n    const topPatterns = topResults.map(row => ({\r\n      patternHash: row.pattern_hash,\r\n      count: row.count,\r\n      category: row.category as FailureCategory,\r\n    }));\r\n\r\n    return {\r\n      totalFailures,\r\n      byCategory,\r\n      uniquePatterns,\r\n      topPatterns,\r\n    };\r\n  }\r\n\r\n  /**\r\n   * Close database connection\r\n   */\r\n  close(): void {\r\n    this.db.close();\r\n  }\r\n}\r\n"],"names":["crypto","Database","createLogger","StandardError","ErrorCode","logger","FailureCategory","EdgeCaseAnalyzer","db","config","dbPath","initializeDatabase","exec","categorizeFailure","error","context","startTime","Date","now","SyntaxError","debug","message","code","OPERATION_TIMEOUT","DB_TIMEOUT","test","VALIDATION_FAILED","INVALID_INPUT","DB_VALIDATION_FAILED","TypeError","includes","ReferenceError","FILE_NOT_FOUND","FILE_WRITE_FAILED","duration","durationMs","findSimilarFailures","failure","stmt","prepare","rows","all","skillId","category","id","similar","map","row","skill_id","errorMessage","error_message","stackTrace","stack_trace","JSON","parse","detectedAt","detected_at","patternHash","pattern_hash","confidence","count","length","calculatePatternConfidence","failures","Math","min","generatePatternHash","normalized","replace","toLowerCase","hashInput","createHash","update","digest","substring","analyzeFailure","randomUUID","stack","allFailures","run","stringify","skillIds","Array","from","Set","f","pattern","failureCount","firstSeenAt","lastSeenAt","info","getFailureStats","whereClause","params","totalStmt","totalResult","get","totalFailures","categoryStmt","categoryResults","byCategory","patternsStmt","patternsResult","uniquePatterns","topStmt","topResults","topPatterns","close"],"mappings":"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"}

package/dist/services/edge-case-deduplicator.js

@@ -0,0 +1,266 @@
+/**
+ * Edge Case Deduplicator Service
+ *
+ * Deduplicates edge cases to prevent redundant tracking.
+ * Part of Task 1.5: MVP Edge Case Feedback Loop
+ *
+ * Features:
+ * - Similarity detection using Levenshtein distance
+ * - Pattern matching for error messages and stack traces
+ * - Configurable similarity threshold (default: 90%)
+ * - Occurrence count tracking
+ * - Smart deduplication based on skill + error type + message similarity
+ *
+ * Usage:
+ *   const deduplicator = new EdgeCaseDeduplicator(dbService, logger);
+ *   const isDuplicate = await deduplicator.deduplicateEdgeCase(edgeCase);
+ */ import { createLogger } from '../lib/logging.js';
+/**
+ * Edge case deduplicator service
+ */ export class EdgeCaseDeduplicator {
+    dbService;
+    logger;
+    config;
+    constructor(dbService, logger, config){
+        this.dbService = dbService;
+        this.logger = logger || createLogger('edge-case-deduplicator');
+        // Set default config
+        this.config = {
+            similarityThreshold: config?.similarityThreshold ?? 0.90,
+            maxAgedays: config?.maxAgedays ?? 30,
+            maxCandidates: config?.maxCandidates ?? 50
+        };
+    }
+    /**
+   * Deduplicate edge case against existing records
+   *
+   * @param edgeCase - Edge case to deduplicate
+   * @returns True if duplicate found and handled, false otherwise
+   */ async deduplicateEdgeCase(edgeCase) {
+        try {
+            // 1. Find similar failures
+            const similar = await this.findSimilarFailures(edgeCase);
+            if (similar.length === 0) {
+                this.logger.debug('No similar edge cases found', {
+                    skill_id: edgeCase.skill_id,
+                    error_type: edgeCase.error_type
+                });
+                return false;
+            }
+            this.logger.debug(`Found ${similar.length} similar edge cases`, {
+                skill_id: edgeCase.skill_id,
+                error_type: edgeCase.error_type
+            });
+            // 2. Calculate similarity scores
+            for (const candidate of similar){
+                const score = this.calculateSimilarity(edgeCase, candidate);
+                this.logger.debug('Similarity score calculated', {
+                    candidate_id: candidate.id,
+                    total_score: score.total,
+                    threshold: this.config.similarityThreshold
+                });
+                // 3. If >threshold% similar, it's a duplicate
+                if (score.total >= this.config.similarityThreshold) {
+                    this.logger.info('Duplicate edge case found', {
+                        edge_case_id: edgeCase.id,
+                        duplicate_of: candidate.id,
+                        similarity_score: score.total
+                    });
+                    // Update existing edge case
+                    await this.incrementOccurrenceCount(candidate.id);
+                    return true;
+                }
+            }
+            // No duplicates found
+            return false;
+        } catch (error) {
+            this.logger.error('Failed to deduplicate edge case', error, {
+                edge_case_id: edgeCase.id
+            });
+            // Don't throw - allow edge case to be stored even if deduplication fails
+            return false;
+        }
+    }
+    /**
+   * Find similar failures based on skill and error type
+   *
+   * @param edgeCase - Edge case to find similar failures for
+   * @returns Array of similar edge cases
+   */ async findSimilarFailures(edgeCase) {
+        const sqlite = this.dbService.getAdapter('sqlite');
+        // Calculate cutoff date
+        const cutoffDate = new Date();
+        cutoffDate.setDate(cutoffDate.getDate() - this.config.maxAgedays);
+        // Query for similar edge cases
+        const query = `
+      SELECT *
+      FROM edge_cases
+      WHERE skill_id = ?
+        AND error_type = ?
+        AND status = 'new'
+        AND last_seen >= ?
+      ORDER BY occurrence_count DESC, last_seen DESC
+      LIMIT ?
+    `;
+        const rows = await sqlite.raw(query, [
+            edgeCase.skill_id,
+            edgeCase.error_type,
+            cutoffDate.toISOString(),
+            this.config.maxCandidates
+        ]);
+        if (!Array.isArray(rows)) {
+            return [];
+        }
+        return rows.map((row)=>this.mapRowToEdgeCase(row));
+    }
+    /**
+   * Calculate similarity between two edge cases
+   *
+   * Similarity breakdown:
+   * - Same skill + error type: 40%
+   * - Error message similarity: 30%
+   * - Stack trace similarity: 30%
+   *
+   * @param a - First edge case
+   * @param b - Second edge case
+   * @returns Similarity score (0.0 - 1.0)
+   */ calculateSimilarity(a, b) {
+        let score = 0;
+        const breakdown = {
+            total: 0,
+            skillAndType: 0,
+            messageMatch: 0,
+            stackMatch: 0
+        };
+        // Same skill + error type = 40%
+        if (a.skill_id === b.skill_id && a.error_type === b.error_type) {
+            score += 0.40;
+            breakdown.skillAndType = 0.40;
+        }
+        // Similar error message = 30%
+        const messageSimilarity = this.computeLevenshteinSimilarity(a.error_message, b.error_message);
+        const messageScore = messageSimilarity * 0.30;
+        score += messageScore;
+        breakdown.messageMatch = messageScore;
+        // Similar stack trace = 30%
+        const stackA = a.stack_trace || '';
+        const stackB = b.stack_trace || '';
+        const stackSimilarity = this.computeLevenshteinSimilarity(stackA, stackB);
+        const stackScore = stackSimilarity * 0.30;
+        score += stackScore;
+        breakdown.stackMatch = stackScore;
+        breakdown.total = score;
+        return breakdown;
+    }
+    /**
+   * Compute Levenshtein similarity (normalized)
+   *
+   * @param a - First string
+   * @param b - Second string
+   * @returns Similarity score (0.0 - 1.0)
+   */ computeLevenshteinSimilarity(a, b) {
+        if (a === b) return 1.0;
+        if (!a || !b) return 0.0;
+        const distance = this.levenshteinDistance(a, b);
+        const maxLength = Math.max(a.length, b.length);
+        if (maxLength === 0) return 1.0;
+        return 1.0 - distance / maxLength;
+    }
+    /**
+   * Calculate Levenshtein distance between two strings
+   *
+   * @param a - First string
+   * @param b - Second string
+   * @returns Edit distance
+   */ levenshteinDistance(a, b) {
+        const matrix = [];
+        // Initialize matrix
+        for(let i = 0; i <= b.length; i++){
+            matrix[i] = [
+                i
+            ];
+        }
+        for(let j = 0; j <= a.length; j++){
+            matrix[0][j] = j;
+        }
+        // Fill matrix
+        for(let i = 1; i <= b.length; i++){
+            for(let j = 1; j <= a.length; j++){
+                if (b.charAt(i - 1) === a.charAt(j - 1)) {
+                    matrix[i][j] = matrix[i - 1][j - 1];
+                } else {
+                    matrix[i][j] = Math.min(matrix[i - 1][j - 1] + 1, matrix[i][j - 1] + 1, matrix[i - 1][j] + 1 // deletion
+                    );
+                }
+            }
+        }
+        return matrix[b.length][a.length];
+    }
+    /**
+   * Increment occurrence count for existing edge case
+   *
+   * @param edgeCaseId - Edge case ID
+   */ async incrementOccurrenceCount(edgeCaseId) {
+        const sqlite = this.dbService.getAdapter('sqlite');
+        const query = `
+      UPDATE edge_cases
+      SET occurrence_count = occurrence_count + 1,
+          last_seen = CURRENT_TIMESTAMP
+      WHERE id = ?
+    `;
+        const result = await sqlite.raw(query, [
+            edgeCaseId
+        ]);
+        this.logger.info('Incremented occurrence count', {
+            edge_case_id: edgeCaseId
+        });
+    }
+    /**
+   * Get deduplication statistics
+   */ async getStats() {
+        const sqlite = this.dbService.getAdapter('sqlite');
+        // Total edge cases
+        const totalResult = await sqlite.raw('SELECT COUNT(*) as count FROM edge_cases WHERE status = "new"');
+        const totalEdgeCases = Array.isArray(totalResult) && totalResult[0] ? totalResult[0].count : 0;
+        // Unique skills
+        const uniqueResult = await sqlite.raw('SELECT COUNT(DISTINCT skill_id) as count FROM edge_cases WHERE status = "new"');
+        const uniqueSkills = Array.isArray(uniqueResult) && uniqueResult[0] ? uniqueResult[0].count : 0;
+        // Average occurrence count
+        const avgResult = await sqlite.raw('SELECT AVG(occurrence_count) as avg FROM edge_cases WHERE status = "new"');
+        const avgOccurrenceCount = Array.isArray(avgResult) && avgResult[0] ? avgResult[0].avg || 0 : 0;
+        // Most frequent failure
+        const frequentResult = await sqlite.raw(`SELECT id, skill_id, error_type, occurrence_count
+       FROM edge_cases
+       WHERE status = 'new'
+       ORDER BY occurrence_count DESC
+       LIMIT 1`);
+        const mostFrequentFailure = Array.isArray(frequentResult) && frequentResult[0] ? frequentResult[0] : null;
+        return {
+            totalEdgeCases,
+            uniqueSkills,
+            avgOccurrenceCount,
+            mostFrequentFailure
+        };
+    }
+    /**
+   * Map database row to EdgeCase object
+   */ mapRowToEdgeCase(row) {
+        return {
+            id: row.id,
+            skill_id: row.skill_id,
+            error_type: row.error_type,
+            severity: row.severity,
+            error_message: row.error_message,
+            stack_trace: row.stack_trace,
+            input_context: row.input_context,
+            output_context: row.output_context,
+            first_seen: new Date(row.first_seen),
+            last_seen: new Date(row.last_seen),
+            occurrence_count: row.occurrence_count,
+            status: row.status,
+            metadata: row.metadata ? JSON.parse(row.metadata) : {}
+        };
+    }
+}
+
+//# sourceMappingURL=edge-case-deduplicator.js.map