@azumag/opencode-rate-limit-fallback 1.50.0 → 1.57.0

package/dist/src/errors/PatternLearner.js

@@ -0,0 +1,257 @@
+/**
+ * Pattern Learning from Rate Limit Errors
+ */
+/**
+ * PatternLearner - Orchestrates the learning process from errors
+ */
+export class PatternLearner {
+    extractor;
+    scorer;
+    storage;
+    config;
+    logger;
+    patternTracker = new Map();
+    learnedPatterns = new Map();
+    constructor(extractor, scorer, storage, config, logger) {
+        this.extractor = extractor;
+        this.scorer = scorer;
+        this.storage = storage;
+        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
+            this.processPatterns();
+        }
+        catch (error) {
+            this.logger.error('[PatternLearner] Failed to learn from error', {
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    /**
+     * Track a pattern candidate for learning
+     */
+    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],
+            });
+        }
+    }
+    /**
+     * Process tracked patterns and save those meeting criteria
+     */
+    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)})`);
+        }
+    }
+    /**
+     * Merge similar patterns
+     */
+    mergePatterns(patterns) {
+        if (patterns.length === 0) {
+            return null;
+        }
+        if (patterns.length === 1) {
+            return patterns[0];
+        }
+        // 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`);
+        }
+        catch (error) {
+            this.logger.error('[PatternLearner] Failed to load learned patterns', {
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    /**
+     * 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;
+        }
+        return false;
+    }
+    /**
+     * Get a learned pattern by name
+     */
+    getLearnedPatternByName(name) {
+        return this.getLearnedPatterns().find(p => p.name === name);
+    }
+    /**
+     * Generate a unique key for a pattern candidate
+     */
+    generatePatternKey(pattern) {
+        const provider = pattern.provider || 'generic';
+        const patternStr = pattern.patterns.map(p => typeof p === 'string' ? p : p.source).join('|');
+        return `${provider}:${patternStr}`;
+    }
+    /**
+     * Generate a unique key for a learned pattern
+     */
+    generatePatternKeyFromLearned(pattern) {
+        const provider = pattern.provider || 'generic';
+        const patternStr = pattern.patterns.map(p => typeof p === 'string' ? p : p.source).join('|');
+        return `${provider}:${patternStr}`;
+    }
+    /**
+     * Generate a name for a pattern
+     */
+    generatePatternName(pattern) {
+        const provider = pattern.provider || 'generic';
+        const timestamp = Date.now();
+        return `learned-${provider}-${timestamp}`;
+    }
+    /**
+     * Calculate priority for a learned pattern
+     */
+    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));
+    }
+    /**
+     * Merge duplicate patterns in storage
+     */
+    async mergeDuplicatePatterns() {
+        return this.storage.mergeDuplicatePatterns();
+    }
+    /**
+     * Cleanup old patterns
+     */
+    async cleanupOldPatterns() {
+        const maxPatterns = this.config.maxLearnedPatterns;
+        return this.storage.cleanupOldPatterns(maxPatterns);
+    }
+    /**
+     * Clear all tracked patterns
+     */
+    clearTrackedPatterns() {
+        this.patternTracker.clear();
+    }
+    /**
+     * Get statistics about learning
+     */
+    getStats() {
+        return {
+            trackedPatterns: this.patternTracker.size,
+            learnedPatterns: this.learnedPatterns.size,
+            pendingPatterns: Array.from(this.patternTracker.values())
+                .filter(t => t.count >= this.config.minErrorFrequency).length,
+        };
+    }
+}

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

@@ -1,7 +1,7 @@
 /**
  * Error Pattern Registry for rate limit error detection
  */
-import type { ErrorPattern } from '../types/index.js';
+import type { ErrorPattern, LearningConfig, LearnedPattern } from '../types/index.js';
 import { Logger } from '../../logger.js';
 /**
  * Error Pattern Registry class
@@ -9,8 +9,30 @@ import { Logger } from '../../logger.js';
  */
 export declare class ErrorPatternRegistry {
     private patterns;
+    private learnedPatterns;
+    private patternLearner?;
     private logger;
-    constructor(logger?: Logger);
+    private configPath?;
+    constructor(logger?: Logger, config?: {
+        learningConfig?: LearningConfig;
+        configPath?: string;
+    });
+    /**
+     * Initialize pattern learning
+     */
+    private initializeLearning;
+    /**
+     * Load learned patterns from storage (async)
+     */
+    loadLearnedPatternsAsync(): Promise<void>;
+    /**
+     * Load learned patterns from storage (synchronous - kept for backward compatibility)
+     */
+    loadLearnedPatterns(): void;
+    /**
+     * Reload learned patterns (for config hot reload)
+     */
+    reloadLearnedPatterns(): Promise<void>;
     /**
      * Register default rate limit error patterns
      */
@@ -56,10 +78,37 @@ export declare class ErrorPatternRegistry {
      */
     resetToDefaults(): void;
     /**
-     * Learn a new pattern from an error (for future ML-based learning)
-     * Currently disabled - patterns must be manually registered
+     * Learn a new pattern from an error
+     */
+    addLearnedPattern(error: unknown): 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
      */
-    addLearnedPattern(_error: unknown): void;
+    getLearningStats(): {
+        trackedPatterns: number;
+        learnedPatterns: number;
+        pendingPatterns: number;
+    } | null;
     /**
      * Get statistics about registered patterns
      */

package/dist/src/errors/PatternRegistry.js

@@ -1,14 +1,21 @@
 /**
  * Error Pattern Registry for rate limit error detection
  */
+import { PatternExtractor } from './PatternExtractor.js';
+import { ConfidenceScorer } from './ConfidenceScorer.js';
+import { PatternStorage } from './PatternStorage.js';
+import { PatternLearner } from './PatternLearner.js';
 /**
  * Error Pattern Registry class
  * Manages and matches error patterns for rate limit detection
  */
 export class ErrorPatternRegistry {
     patterns = [];
+    learnedPatterns = new Map();
+    patternLearner;
     logger;
-    constructor(logger) {
+    configPath;
+    constructor(logger, config) {
         // Initialize logger
         this.logger = logger || {
             debug: () => { },
@@ -16,7 +23,89 @@ export class ErrorPatternRegistry {
             warn: () => { },
             error: () => { },
         };
+        this.configPath = config?.configPath;
         this.registerDefaultPatterns();
+        // Initialize pattern learning if enabled
+        if (config?.learningConfig && config.learningConfig.enabled) {
+            this.initializeLearning(config.learningConfig);
+        }
+    }
+    /**
+     * Initialize pattern learning
+     */
+    initializeLearning(learningConfig) {
+        if (!this.configPath) {
+            this.logger.warn('[ErrorPatternRegistry] Config path not provided, pattern learning disabled');
+            return;
+        }
+        try {
+            const extractor = new PatternExtractor();
+            const scorer = new ConfidenceScorer(learningConfig, this.patterns);
+            const storage = new PatternStorage(this.configPath, this.logger);
+            this.patternLearner = new PatternLearner(extractor, scorer, storage, learningConfig, this.logger);
+            // Note: Patterns will be loaded asynchronously via loadLearnedPatternsAsync()
+            this.logger.info('[ErrorPatternRegistry] Pattern learning enabled');
+        }
+        catch (error) {
+            this.logger.error('[ErrorPatternRegistry] Failed to initialize pattern learning', {
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    /**
+     * Load learned patterns from storage (async)
+     */
+    async loadLearnedPatternsAsync() {
+        if (!this.patternLearner) {
+            return;
+        }
+        try {
+            await this.patternLearner.loadLearnedPatterns();
+            const learnedPatterns = this.patternLearner.getLearnedPatterns();
+            for (const pattern of learnedPatterns) {
+                this.learnedPatterns.set(pattern.name, pattern);
+                this.register(pattern);
+            }
+            this.logger.info(`[ErrorPatternRegistry] Loaded ${learnedPatterns.length} learned patterns`);
+        }
+        catch (error) {
+            this.logger.error('[ErrorPatternRegistry] Failed to load learned patterns', {
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    /**
+     * Load learned patterns from storage (synchronous - kept for backward compatibility)
+     */
+    loadLearnedPatterns() {
+        if (!this.patternLearner) {
+            return;
+        }
+        try {
+            // Load patterns without awaiting (sync fallback)
+            this.patternLearner.loadLearnedPatterns().catch((error) => {
+                this.logger.error('[ErrorPatternRegistry] Failed to load learned patterns asynchronously', {
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            });
+            const learnedPatterns = this.patternLearner.getLearnedPatterns();
+            for (const pattern of learnedPatterns) {
+                this.learnedPatterns.set(pattern.name, pattern);
+                this.register(pattern);
+            }
+        }
+        catch (error) {
+            this.logger.error('[ErrorPatternRegistry] Failed to load learned patterns', {
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    /**
+     * Reload learned patterns (for config hot reload)
+     */
+    async reloadLearnedPatterns() {
+        this.learnedPatterns.clear();
+        await this.loadLearnedPatternsAsync();
     }
     /**
      * Register default rate limit error patterns
@@ -108,7 +197,13 @@ export class ErrorPatternRegistry {
      * Check if an error matches any registered rate limit pattern
      */
     isRateLimitError(error) {
-        return this.getMatchedPattern(error) !== null;
+        // Check if this is a rate limit error
+        const isRateLimit = this.getMatchedPattern(error) !== null;
+        // If enabled, learn from this error
+        if (isRateLimit && this.patternLearner) {
+            this.patternLearner.learnFromError(error);
+        }
+        return isRateLimit;
     }
     /**
      * Get the matched pattern for an error, or null if no match
@@ -191,13 +286,81 @@ export class ErrorPatternRegistry {
         this.registerDefaultPatterns();
     }
     /**
-     * Learn a new pattern from an error (for future ML-based learning)
-     * Currently disabled - patterns must be manually registered
+     * Learn a new pattern from an error
+     */
+    addLearnedPattern(error) {
+        if (this.patternLearner) {
+            this.patternLearner.learnFromError(error);
+        }
+        else {
+            this.logger.warn('[ErrorPatternRegistry] Pattern learning is not enabled. Patterns must be manually registered via configuration.');
+        }
+    }
+    /**
+     * Get all learned patterns
+     */
+    getLearnedPatterns() {
+        if (!this.patternLearner) {
+            return [];
+        }
+        return this.patternLearner.getLearnedPatterns();
+    }
+    /**
+     * Get a learned pattern by name
+     */
+    getLearnedPatternByName(name) {
+        if (!this.patternLearner) {
+            return undefined;
+        }
+        return this.patternLearner.getLearnedPatternByName(name);
+    }
+    /**
+     * Remove a learned pattern by name
+     */
+    async removeLearnedPattern(name) {
+        if (!this.patternLearner) {
+            return false;
+        }
+        const removed = await this.patternLearner.removeLearnedPattern(name);
+        if (removed) {
+            this.removePattern(name);
+        }
+        return removed;
+    }
+    /**
+     * Merge duplicate learned patterns
+     */
+    async mergeDuplicatePatterns() {
+        if (!this.patternLearner) {
+            return 0;
+        }
+        const mergedCount = await this.patternLearner.mergeDuplicatePatterns();
+        if (mergedCount > 0) {
+            this.reloadLearnedPatterns();
+        }
+        return mergedCount;
+    }
+    /**
+     * Cleanup old learned patterns
      */
-    addLearnedPattern(_error) {
-        // Placeholder for future ML-based pattern learning
-        // For now, patterns must be manually registered via config
-        this.logger.warn('[ErrorPatternRegistry] Automatic pattern learning is not enabled. Patterns must be manually registered via configuration.');
+    async cleanupOldPatterns() {
+        if (!this.patternLearner) {
+            return 0;
+        }
+        const removedCount = await this.patternLearner.cleanupOldPatterns();
+        if (removedCount > 0) {
+            this.reloadLearnedPatterns();
+        }
+        return removedCount;
+    }
+    /**
+     * Get learning statistics
+     */
+    getLearningStats() {
+        if (!this.patternLearner) {
+            return null;
+        }
+        return this.patternLearner.getStats();
     }
     /**
      * Get statistics about registered patterns

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

@@ -0,0 +1,49 @@
+/**
+ * Pattern Storage for Learned Error Patterns
+ */
+import type { LearnedPattern } from '../types/index.js';
+import type { Logger } from '../../logger.js';
+/**
+ * PatternStorage - Manages persistence of learned patterns to config file
+ */
+export declare class PatternStorage {
+    private configPath;
+    private logger;
+    constructor(configPath: string, logger: Logger);
+    /**
+     * Save a learned pattern to config file
+     */
+    savePattern(pattern: LearnedPattern): Promise<void>;
+    /**
+     * Load all learned patterns from config file
+     */
+    loadPatterns(): Promise<LearnedPattern[]>;
+    /**
+     * Delete a pattern by name from config file
+     */
+    deletePattern(name: string): Promise<boolean>;
+    /**
+     * Merge duplicate patterns with high similarity
+     */
+    mergeDuplicatePatterns(): Promise<number>;
+    /**
+     * Cleanup old patterns, keeping only the most confident ones
+     */
+    cleanupOldPatterns(maxCount: number, patterns?: LearnedPattern[]): Promise<number>;
+    /**
+     * Load config file
+     */
+    private loadConfig;
+    /**
+     * Save config file
+     */
+    private saveConfig;
+    /**
+     * Validate pattern structure
+     */
+    private isValidPattern;
+    /**
+     * Calculate similarity between two patterns
+     */
+    private calculatePatternSimilarity;
+}