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

package/dist/src/errors/PatternRegistry.js

@@ -1,9 +1,6 @@
 /**
  * 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
@@ -11,101 +8,21 @@ import { PatternLearner } from './PatternLearner.js';
  */
 export class ErrorPatternRegistry {
     patterns = [];
-    learnedPatterns = new Map();
-    patternLearner;
-    logger;
-    configPath;
-    constructor(logger, config) {
+    learnedPatterns = [];
+    patternLearner = null;
+    learningConfig = null;
+    // Logger is available for future use
+    // @ts-ignore - Unused but kept for potential future use
+    _logger;
+    constructor(logger) {
         // Initialize logger
-        this.logger = logger || {
+        this._logger = logger || {
             debug: () => { },
             info: () => { },
             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
@@ -193,20 +110,66 @@ export class ErrorPatternRegistry {
             this.register(pattern);
         }
     }
+    /**
+     * Initialize pattern learning
+     */
+    initializePatternLearning(config, configFilePath) {
+        this.learningConfig = config;
+        this.patternLearner = new PatternLearner(config, this._logger);
+        this.patternLearner.setConfigFilePath(configFilePath);
+    }
+    /**
+     * Check if pattern learning is enabled
+     */
+    isLearningEnabled() {
+        return this.learningConfig?.enabled === true && this.patternLearner !== null;
+    }
+    /**
+     * Get the pattern learner instance
+     */
+    getPatternLearner() {
+        return this.patternLearner;
+    }
+    /**
+     * Add a learned pattern
+     */
+    addLearnedPattern(pattern) {
+        // Check for duplicates by name
+        const existingIndex = this.learnedPatterns.findIndex(p => p.name === pattern.name);
+        if (existingIndex >= 0) {
+            this.learnedPatterns[existingIndex] = pattern;
+        }
+        else {
+            this.learnedPatterns.push(pattern);
+        }
+    }
+    /**
+     * Get all learned patterns
+     */
+    getLearnedPatterns() {
+        return [...this.learnedPatterns];
+    }
+    /**
+     * Clear all learned patterns
+     */
+    clearLearnedPatterns() {
+        this.learnedPatterns = [];
+    }
+    /**
+     * Update learned patterns
+     */
+    updateLearnedPatterns(patterns) {
+        this.learnedPatterns = [...patterns];
+    }
     /**
      * Check if an error matches any registered rate limit pattern
      */
     isRateLimitError(error) {
-        // 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;
+        return this.getMatchedPattern(error) !== null;
     }
     /**
      * Get the matched pattern for an error, or null if no match
+     * Checks default patterns first, then learned patterns
      */
     getMatchedPattern(error) {
         if (!error || typeof error !== 'object') {
@@ -220,7 +183,7 @@ export class ErrorPatternRegistry {
         const statusCode = err.data?.statusCode?.toString() || '';
         // Combine all text sources for matching
         const allText = [responseBody, message, name, statusCode].join(' ').toLowerCase();
-        // Check each pattern
+        // Check each pattern in default patterns first
         for (const pattern of this.patterns) {
             for (const patternStr of pattern.patterns) {
                 let match = false;
@@ -241,13 +204,34 @@ export class ErrorPatternRegistry {
                 }
             }
         }
+        // Check learned patterns
+        for (const pattern of this.learnedPatterns) {
+            for (const patternStr of pattern.patterns) {
+                let match = false;
+                if (typeof patternStr === 'string') {
+                    // String matching (case-insensitive)
+                    if (allText.includes(patternStr.toLowerCase())) {
+                        match = true;
+                    }
+                }
+                else if (patternStr instanceof RegExp) {
+                    // RegExp matching
+                    if (patternStr.test(allText)) {
+                        match = true;
+                    }
+                }
+                if (match) {
+                    return pattern;
+                }
+            }
+        }
         return null;
     }
     /**
-     * Get all registered patterns
+     * Get all registered patterns (including learned patterns)
      */
     getAllPatterns() {
-        return [...this.patterns];
+        return [...this.patterns, ...this.learnedPatterns];
     }
     /**
      * Get patterns for a specific provider
@@ -285,101 +269,13 @@ export class ErrorPatternRegistry {
         this.clearAllPatterns();
         this.registerDefaultPatterns();
     }
-    /**
-     * 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.');
-        }
-    }
-    /**
-     * Learn a new pattern from an error (async version)
-     */
-    async addLearnedPatternAsync(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
-     */
-    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
      */
     getStats() {
         const byProvider = {};
         const byPriority = {};
-        for (const pattern of this.patterns) {
+        for (const pattern of [...this.patterns, ...this.learnedPatterns]) {
             // Count by provider
             const provider = pattern.provider || 'generic';
             byProvider[provider] = (byProvider[provider] || 0) + 1;
@@ -388,7 +284,9 @@ export class ErrorPatternRegistry {
             byPriority[priorityRange] = (byPriority[priorityRange] || 0) + 1;
         }
         return {
-            total: this.patterns.length,
+            total: this.patterns.length + this.learnedPatterns.length,
+            default: this.patterns.length,
+            learned: this.learnedPatterns.length,
             byProvider,
             byPriority,
         };

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

@@ -1,49 +1,48 @@
 /**
- * Pattern Storage for Learned Error Patterns
+ * Pattern Storage for persisting learned patterns
  */
-import type { LearnedPattern } from '../types/index.js';
-import type { Logger } from '../../logger.js';
+import type { LearnedPattern, PatternLearningConfig, ErrorPattern } from '../types/index.js';
 /**
- * PatternStorage - Manages persistence of learned patterns to config file
+ * Pattern Storage class
+ * Manages persistence of learned patterns
  */
 export declare class PatternStorage {
-    private configPath;
-    private logger;
-    constructor(configPath: string, logger: Logger);
+    private config;
+    private configFilePath;
     /**
-     * Save a learned pattern to config file
+     * Constructor
      */
-    savePattern(pattern: LearnedPattern): Promise<void>;
+    constructor(config: PatternLearningConfig);
     /**
-     * Load all learned patterns from config file
+     * Update configuration
      */
-    loadPatterns(): Promise<LearnedPattern[]>;
+    updateConfig(config: PatternLearningConfig): void;
     /**
-     * Delete a pattern by name from config file
+     * Set the config file path
      */
-    deletePattern(name: string): Promise<boolean>;
+    setConfigFilePath(path: string): void;
     /**
-     * Merge duplicate patterns with high similarity
+     * Merge similar patterns (Jaccard similarity > 0.8)
      */
-    mergeDuplicatePatterns(): Promise<number>;
+    mergeSimilarPatterns(patterns: LearnedPattern[]): LearnedPattern[];
     /**
-     * Cleanup old patterns, keeping only the most confident ones
+     * Clean up old patterns when exceeding limit
      */
-    cleanupOldPatterns(maxCount: number, patterns?: LearnedPattern[]): Promise<number>;
+    cleanupPatterns(patterns: LearnedPattern[]): LearnedPattern[];
     /**
-     * Load config file
+     * Save learned patterns to config file
      */
-    private loadConfig;
+    saveLearnedPatterns(patterns: LearnedPattern[]): Promise<void>;
     /**
-     * Save config file
+     * Validate and load learned patterns from config
      */
-    private saveConfig;
+    loadLearnedPatterns(): Promise<LearnedPattern[]>;
     /**
-     * Validate pattern structure
+     * Validate a learned pattern object
      */
-    private isValidPattern;
+    private isValidLearnedPattern;
     /**
-     * Calculate similarity between two patterns
+     * Create a learned pattern from an error pattern
      */
-    private calculatePatternSimilarity;
+    createLearnedPattern(basePattern: ErrorPattern, confidence: number, sampleCount: number): LearnedPattern;
 }