@azumag/opencode-rate-limit-fallback 1.58.0 → 1.63.0

package/dist/src/errors/PatternLearner.js

@@ -1,8 +1,12 @@
 /**
- * Pattern Learning from Rate Limit Errors
+ * Pattern Learner for orchestrating error pattern learning
  */
+import { PatternExtractor } from './PatternExtractor.js';
+import { ConfidenceScorer } from './ConfidenceScorer.js';
+import { PatternStorage } from './PatternStorage.js';
 /**
- * PatternLearner - Orchestrates the learning process from errors
+ * Pattern Learner class
+ * Orchestrates the learning process
  */
 export class PatternLearner {
     extractor;
@@ -10,253 +14,178 @@ export class PatternLearner {
     storage;
     config;
     logger;
-    patternTracker = new Map();
-    learnedPatterns = new Map();
-    constructor(extractor, scorer, storage, config, logger) {
-        this.extractor = extractor;
-        this.scorer = scorer;
-        this.storage = storage;
+    // Track patterns being learned
+    patternTracking;
+    // Statistics
+    stats = {
+        totalErrorsProcessed: 0,
+        patternsLearned: 0,
+        patternsRejected: 0,
+    };
+    /**
+     * Constructor
+     */
+    constructor(config, logger) {
         this.config = config;
-        this.logger = logger;
-        // Note: Patterns will be loaded asynchronously via loadLearnedPatterns()
-    }
-    /**
-     * Learn from a rate limit error
-     */
-    learnFromError(error) {
-        if (!this.config.enabled) {
-            return;
-        }
-        try {
-            // Extract pattern candidates
-            const candidates = this.extractor.extractPatterns(error);
-            for (const candidate of candidates) {
-                this.trackPattern(candidate);
-            }
-            // Process and potentially save patterns
-            // Fire-and-forget with proper error handling
-            this.processPatterns().catch((error) => {
-                this.logger.error('[PatternLearner] Failed to process patterns', {
-                    error: error instanceof Error ? error.message : String(error),
-                });
-            });
-        }
-        catch (error) {
-            this.logger.error('[PatternLearner] Failed to learn from error', {
-                error: error instanceof Error ? error.message : String(error),
-            });
-        }
+        this.extractor = new PatternExtractor();
+        this.scorer = new ConfidenceScorer(config);
+        this.storage = new PatternStorage(config);
+        this.patternTracking = new Map();
+        this.logger = logger || {
+            debug: () => { },
+            info: () => { },
+            warn: () => { },
+            error: () => { },
+        };
     }
     /**
-     * Track a pattern candidate for learning
+     * Update configuration
      */
-    trackPattern(candidate) {
-        // Generate a key for this pattern
-        const key = this.generatePatternKey(candidate);
-        const existing = this.patternTracker.get(key);
-        if (existing) {
-            // Update existing tracker
-            existing.lastSeen = Date.now();
-            existing.count++;
-            existing.samples.push(candidate.sourceError);
-            // Keep only last 10 samples
-            if (existing.samples.length > 10) {
-                existing.samples.shift();
-            }
-        }
-        else {
-            // Create new tracker
-            this.patternTracker.set(key, {
-                pattern: candidate,
-                firstSeen: Date.now(),
-                lastSeen: Date.now(),
-                count: 1,
-                samples: [candidate.sourceError],
-            });
-        }
+    updateConfig(config) {
+        this.config = config;
+        this.scorer.updateConfig(config);
+        this.storage.updateConfig(config);
     }
     /**
-     * Process tracked patterns and save those meeting criteria
+     * Set the config file path for storage
      */
-    async processPatterns() {
-        for (const [key, tracker] of this.patternTracker.entries()) {
-            // Check if pattern meets frequency threshold
-            if (tracker.count < this.config.minErrorFrequency) {
-                continue;
-            }
-            // Check if pattern already exists in learned patterns
-            if (this.learnedPatterns.has(key)) {
-                continue;
-            }
-            // Calculate confidence score
-            const confidence = this.scorer.calculateScore(tracker.pattern, tracker.count, tracker.firstSeen);
-            // Check if pattern meets auto-approve threshold
-            if (!this.scorer.shouldAutoApprove(confidence)) {
-                this.logger.debug(`[PatternLearner] Pattern confidence ${confidence.toFixed(2)} below threshold ${this.config.autoApproveThreshold}, not auto-approving`);
-                continue;
-            }
-            // Create learned pattern
-            const learnedPattern = {
-                name: this.generatePatternName(tracker.pattern),
-                provider: tracker.pattern.provider,
-                patterns: tracker.pattern.patterns,
-                priority: this.calculatePriority(tracker.pattern, confidence),
-                confidence,
-                learnedAt: new Date(tracker.firstSeen).toISOString(),
-                sampleCount: tracker.count,
-                lastUsed: undefined,
-            };
-            // Save to storage
-            await this.storage.savePattern(learnedPattern);
-            // Add to learned patterns
-            this.learnedPatterns.set(key, learnedPattern);
-            // Remove from tracker
-            this.patternTracker.delete(key);
-            this.logger.info(`[PatternLearner] Learned new pattern: ${learnedPattern.name} (confidence: ${confidence.toFixed(2)})`);
-        }
+    setConfigFilePath(path) {
+        this.storage.setConfigFilePath(path);
     }
     /**
-     * Merge similar patterns
+     * Process an error and learn from it
      */
-    mergePatterns(patterns) {
-        if (patterns.length === 0) {
+    async processError(error) {
+        if (!this.config.enabled) {
+            this.logger.debug('Pattern learning is disabled, skipping');
             return null;
         }
-        if (patterns.length === 1) {
-            return patterns[0];
+        this.stats.totalErrorsProcessed++;
+        // Extract pattern from error
+        const candidate = this.extractor.extractPattern(error);
+        if (!candidate) {
+            return null;
         }
-        // Merge all patterns into one
-        const mergedPattern = {
-            provider: patterns[0].provider,
-            patterns: patterns.flatMap(p => p.patterns),
-            sourceError: patterns.map(p => p.sourceError).join('; '),
-            extractedAt: Math.max(...patterns.map(p => p.extractedAt)),
-        };
-        // Deduplicate patterns
-        mergedPattern.patterns = [...new Set(mergedPattern.patterns)];
-        return mergedPattern;
-    }
-    /**
-     * Load learned patterns from storage
-     */
-    async loadLearnedPatterns() {
-        try {
-            const patterns = await this.storage.loadPatterns();
-            for (const pattern of patterns) {
-                const key = this.generatePatternKeyFromLearned(pattern);
-                this.learnedPatterns.set(key, pattern);
-            }
-            this.logger.info(`[PatternLearner] Loaded ${patterns.length} learned patterns`);
+        // Check if provider is present (required for meaningful patterns)
+        if (!candidate.provider) {
+            this.logger.debug('No provider found in error, skipping pattern learning');
+            return null;
         }
-        catch (error) {
-            this.logger.error('[PatternLearner] Failed to load learned patterns', {
-                error: error instanceof Error ? error.message : String(error),
-            });
+        // Create a pattern key for tracking
+        const patternKey = this.createPatternKey(candidate);
+        // Update pattern tracking
+        const tracking = this.getOrCreateTracking(candidate, patternKey);
+        tracking.frequency++;
+        tracking.samples.push(candidate.rawText);
+        // Check if we should learn this pattern
+        if (tracking.frequency < this.config.minErrorFrequency) {
+            return null; // Not enough samples yet
         }
-    }
-    /**
-     * Get all learned patterns
-     */
-    getLearnedPatterns() {
-        return Array.from(this.learnedPatterns.values());
-    }
-    /**
-     * Get learned patterns for a specific provider
-     */
-    getLearnedPatternsForProvider(provider) {
-        return this.getLearnedPatterns().filter(p => !p.provider || p.provider === provider);
-    }
-    /**
-     * Add a learned pattern manually
-     */
-    async addLearnedPattern(pattern) {
-        const key = this.generatePatternKeyFromLearned(pattern);
-        this.learnedPatterns.set(key, pattern);
-        await this.storage.savePattern(pattern);
-    }
-    /**
-     * Remove a learned pattern
-     */
-    async removeLearnedPattern(name) {
-        const pattern = this.getLearnedPatternByName(name);
-        if (pattern) {
-            const key = this.generatePatternKeyFromLearned(pattern);
-            this.learnedPatterns.delete(key);
-            await this.storage.deletePattern(name);
-            return true;
+        // Calculate confidence
+        const confidence = this.scorer.calculateConfidence(tracking.pattern, tracking.frequency, tracking.firstSeen, []);
+        // Check if we should learn and save this pattern
+        if (!this.scorer.shouldAutoApprove(confidence)) {
+            this.stats.patternsRejected++;
+            this.logger.debug(`Pattern confidence ${confidence} below threshold ${this.config.autoApproveThreshold}`);
+            return null;
         }
-        return false;
+        // Create learned pattern
+        const learnedPattern = this.storage.createLearnedPattern(tracking.pattern, confidence, tracking.frequency);
+        // Save to storage
+        await this.saveLearnedPattern(learnedPattern);
+        // Clear tracking for this pattern
+        this.patternTracking.delete(patternKey);
+        this.stats.patternsLearned++;
+        this.logger.info(`Learned new pattern: ${learnedPattern.name} with confidence ${confidence}`);
+        return learnedPattern;
     }
     /**
-     * Get a learned pattern by name
-     */
-    getLearnedPatternByName(name) {
-        return this.getLearnedPatterns().find(p => p.name === name);
-    }
-    /**
-     * Generate a unique key for a pattern candidate
+     * Load learned patterns from storage
      */
-    generatePatternKey(pattern) {
-        const provider = pattern.provider || 'generic';
-        const patternStr = pattern.patterns.map(p => typeof p === 'string' ? p : p.source).join('|');
-        return `${provider}:${patternStr}`;
+    async loadLearnedPatterns() {
+        const patterns = await this.storage.loadLearnedPatterns();
+        this.logger.debug(`Loaded ${patterns.length} learned patterns`);
+        return patterns;
     }
     /**
-     * Generate a unique key for a learned pattern
+     * Save learned patterns
      */
-    generatePatternKeyFromLearned(pattern) {
-        const provider = pattern.provider || 'generic';
-        const patternStr = pattern.patterns.map(p => typeof p === 'string' ? p : p.source).join('|');
-        return `${provider}:${patternStr}`;
+    async saveLearnedPatterns(patterns) {
+        const merged = this.storage.mergeSimilarPatterns(patterns);
+        const cleaned = this.storage.cleanupPatterns(merged);
+        await this.storage.saveLearnedPatterns(cleaned);
+        this.logger.debug(`Saved ${cleaned.length} learned patterns`);
     }
     /**
-     * Generate a name for a pattern
+     * Get statistics
      */
-    generatePatternName(pattern) {
-        const provider = pattern.provider || 'generic';
-        const timestamp = Date.now();
-        return `learned-${provider}-${timestamp}`;
+    getStats() {
+        return { ...this.stats };
     }
     /**
-     * Calculate priority for a learned pattern
+     * Reset statistics
      */
-    calculatePriority(pattern, confidence) {
-        // Base priority on confidence
-        const basePriority = Math.floor(confidence * 50);
-        // Add bonus for provider-specific patterns
-        const providerBonus = pattern.provider ? 10 : 0;
-        // Add bonus for number of patterns
-        const patternCountBonus = Math.min(pattern.patterns.length * 2, 10);
-        return Math.max(1, Math.min(100, basePriority + providerBonus + patternCountBonus));
+    resetStats() {
+        this.stats = {
+            totalErrorsProcessed: 0,
+            patternsLearned: 0,
+            patternsRejected: 0,
+        };
     }
     /**
-     * Merge duplicate patterns in storage
+     * Clear all pattern tracking
      */
-    async mergeDuplicatePatterns() {
-        return this.storage.mergeDuplicatePatterns();
+    clearTracking() {
+        this.patternTracking.clear();
     }
     /**
-     * Cleanup old patterns
+     * Create a pattern key for tracking
      */
-    async cleanupOldPatterns() {
-        const maxPatterns = this.config.maxLearnedPatterns;
-        return this.storage.cleanupOldPatterns(maxPatterns);
+    createPatternKey(candidate) {
+        const parts = [
+            candidate.provider || 'unknown',
+            candidate.statusCode || 'no-status',
+            ...candidate.phrases.slice(0, 3), // Use first 3 phrases for key
+        ].join('|');
+        return parts;
     }
     /**
-     * Clear all tracked patterns
+     * Get or create pattern tracking
      */
-    clearTrackedPatterns() {
-        this.patternTracker.clear();
+    getOrCreateTracking(candidate, patternKey) {
+        if (this.patternTracking.has(patternKey)) {
+            return this.patternTracking.get(patternKey);
+        }
+        // Create pattern from candidate
+        const allPatterns = [
+            ...candidate.phrases,
+            ...candidate.errorCodes,
+            ...(candidate.statusCode ? [candidate.statusCode] : []),
+        ];
+        const pattern = {
+            name: `learned-${candidate.provider}-${Date.now()}`,
+            provider: candidate.provider || undefined,
+            patterns: allPatterns,
+            priority: 70, // Medium priority for learned patterns
+        };
+        const tracking = {
+            pattern,
+            frequency: 0,
+            firstSeen: Date.now(),
+            samples: [],
+        };
+        this.patternTracking.set(patternKey, tracking);
+        return tracking;
     }
     /**
-     * Get statistics about learning
+     * Save a single learned pattern
      */
-    getStats() {
-        return {
-            trackedPatterns: this.patternTracker.size,
-            learnedPatterns: this.learnedPatterns.size,
-            pendingPatterns: Array.from(this.patternTracker.values())
-                .filter(t => t.count >= this.config.minErrorFrequency).length,
-        };
+    async saveLearnedPattern(pattern) {
+        // Load existing patterns
+        const existing = await this.storage.loadLearnedPatterns();
+        // Add new pattern
+        existing.push(pattern);
+        // Merge and clean up
+        await this.saveLearnedPatterns(existing);
     }
 }

package/dist/src/errors/PatternRegistry.d.ts

@@ -1,8 +1,9 @@
 /**
  * Error Pattern Registry for rate limit error detection
  */
-import type { ErrorPattern, LearningConfig, LearnedPattern } from '../types/index.js';
+import type { ErrorPattern, LearnedPattern, PatternLearningConfig } from '../types/index.js';
 import { Logger } from '../../logger.js';
+import { PatternLearner } from './PatternLearner.js';
 /**
  * Error Pattern Registry class
  * Manages and matches error patterns for rate limit detection
@@ -10,51 +11,61 @@ import { Logger } from '../../logger.js';
 export declare class ErrorPatternRegistry {
     private patterns;
     private learnedPatterns;
-    private patternLearner?;
-    private logger;
-    private configPath?;
-    constructor(logger?: Logger, config?: {
-        learningConfig?: LearningConfig;
-        configPath?: string;
-    });
+    private patternLearner;
+    private learningConfig;
+    private _logger;
+    constructor(logger?: Logger);
+    /**
+     * Register default rate limit error patterns
+     */
+    registerDefaultPatterns(): void;
+    /**
+     * Register a new error pattern
+     */
+    register(pattern: ErrorPattern): void;
+    /**
+     * Register multiple error patterns
+     */
+    registerMany(patterns: ErrorPattern[]): void;
     /**
      * Initialize pattern learning
      */
-    private initializeLearning;
+    initializePatternLearning(config: PatternLearningConfig, configFilePath: string): void;
     /**
-     * Load learned patterns from storage (async)
+     * Check if pattern learning is enabled
      */
-    loadLearnedPatternsAsync(): Promise<void>;
+    isLearningEnabled(): boolean;
     /**
-     * Load learned patterns from storage (synchronous - kept for backward compatibility)
+     * Get the pattern learner instance
      */
-    loadLearnedPatterns(): void;
+    getPatternLearner(): PatternLearner | null;
     /**
-     * Reload learned patterns (for config hot reload)
+     * Add a learned pattern
      */
-    reloadLearnedPatterns(): Promise<void>;
+    addLearnedPattern(pattern: LearnedPattern): void;
     /**
-     * Register default rate limit error patterns
+     * Get all learned patterns
      */
-    registerDefaultPatterns(): void;
+    getLearnedPatterns(): LearnedPattern[];
     /**
-     * Register a new error pattern
+     * Clear all learned patterns
      */
-    register(pattern: ErrorPattern): void;
+    clearLearnedPatterns(): void;
     /**
-     * Register multiple error patterns
+     * Update learned patterns
      */
-    registerMany(patterns: ErrorPattern[]): void;
+    updateLearnedPatterns(patterns: LearnedPattern[]): void;
     /**
      * Check if an error matches any registered rate limit pattern
      */
     isRateLimitError(error: unknown): boolean;
     /**
      * Get the matched pattern for an error, or null if no match
+     * Checks default patterns first, then learned patterns
      */
     getMatchedPattern(error: unknown): ErrorPattern | null;
     /**
-     * Get all registered patterns
+     * Get all registered patterns (including learned patterns)
      */
     getAllPatterns(): ErrorPattern[];
     /**
@@ -77,47 +88,13 @@ export declare class ErrorPatternRegistry {
      * Reset to default patterns only
      */
     resetToDefaults(): void;
-    /**
-     * Learn a new pattern from an error
-     */
-    addLearnedPattern(error: unknown): void;
-    /**
-     * Learn a new pattern from an error (async version)
-     */
-    addLearnedPatternAsync(error: unknown): Promise<void>;
-    /**
-     * Get all learned patterns
-     */
-    getLearnedPatterns(): LearnedPattern[];
-    /**
-     * Get a learned pattern by name
-     */
-    getLearnedPatternByName(name: string): LearnedPattern | undefined;
-    /**
-     * Remove a learned pattern by name
-     */
-    removeLearnedPattern(name: string): Promise<boolean>;
-    /**
-     * Merge duplicate learned patterns
-     */
-    mergeDuplicatePatterns(): Promise<number>;
-    /**
-     * Cleanup old learned patterns
-     */
-    cleanupOldPatterns(): Promise<number>;
-    /**
-     * Get learning statistics
-     */
-    getLearningStats(): {
-        trackedPatterns: number;
-        learnedPatterns: number;
-        pendingPatterns: number;
-    } | null;
     /**
      * Get statistics about registered patterns
      */
     getStats(): {
         total: number;
+        default: number;
+        learned: number;
         byProvider: Record<string, number>;
         byPriority: Record<string, number>;
     };