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

package/dist/src/errors/PatternStorage.js

@@ -1,234 +1,179 @@
 /**
- * Pattern Storage for Learned Error Patterns
+ * Pattern Storage for persisting learned patterns
  */
-import { readFile, writeFile } from 'fs/promises';
 import { calculateJaccardSimilarity } from '../utils/similarity.js';
+import * as fs from 'fs/promises';
 /**
- * PatternStorage - Manages persistence of learned patterns to config file
+ * Pattern Storage class
+ * Manages persistence of learned patterns
  */
 export class PatternStorage {
-    configPath;
-    logger;
-    constructor(configPath, logger) {
-        this.configPath = configPath;
-        this.logger = logger;
-    }
+    config;
+    configFilePath = null;
     /**
-     * Save a learned pattern to config file
+     * Constructor
      */
-    async savePattern(pattern) {
-        try {
-            // Load existing config
-            const config = await this.loadConfig();
-            const errorPatterns = config.errorPatterns || {};
-            // Initialize learnedPatterns array if not exists
-            if (!errorPatterns.learnedPatterns) {
-                errorPatterns.learnedPatterns = [];
-            }
-            const learnedPatterns = errorPatterns.learnedPatterns;
-            // Check if pattern with same name already exists
-            const existingIndex = learnedPatterns.findIndex((p) => p.name === pattern.name);
-            if (existingIndex >= 0) {
-                // Update existing pattern
-                learnedPatterns[existingIndex] = pattern;
-                this.logger.debug(`[PatternStorage] Updated learned pattern: ${pattern.name}`);
-            }
-            else {
-                // Add new pattern
-                learnedPatterns.push(pattern);
-                this.logger.info(`[PatternStorage] Saved new learned pattern: ${pattern.name}`);
-            }
-            // Cleanup old patterns if exceeding limit
-            const maxPatterns = config.errorPatterns?.maxLearnedPatterns || 20;
-            if (learnedPatterns.length > maxPatterns) {
-                await this.cleanupOldPatterns(maxPatterns, learnedPatterns);
-            }
-            // Save config
-            await this.saveConfig(config);
-        }
-        catch (error) {
-            this.logger.error('[PatternStorage] Failed to save pattern', {
-                error: error instanceof Error ? error.message : String(error),
-            });
-            throw error;
-        }
+    constructor(config) {
+        this.config = config;
     }
     /**
-     * Load all learned patterns from config file
+     * Update configuration
      */
-    async loadPatterns() {
-        try {
-            const config = await this.loadConfig();
-            const learnedPatterns = config.errorPatterns?.learnedPatterns || [];
-            // Validate patterns
-            const validPatterns = learnedPatterns.filter((p) => this.isValidPattern(p));
-            if (validPatterns.length !== learnedPatterns.length) {
-                this.logger.warn(`[PatternStorage] Filtered out ${learnedPatterns.length - validPatterns.length} invalid patterns`);
-            }
-            return validPatterns;
-        }
-        catch (error) {
-            this.logger.error('[PatternStorage] Failed to load patterns', {
-                error: error instanceof Error ? error.message : String(error),
-            });
-            return [];
-        }
+    updateConfig(config) {
+        this.config = config;
     }
     /**
-     * Delete a pattern by name from config file
+     * Set the config file path
      */
-    async deletePattern(name) {
-        try {
-            const config = await this.loadConfig();
-            const errorPatterns = config.errorPatterns || {};
-            const learnedPatterns = errorPatterns.learnedPatterns || [];
-            const index = learnedPatterns.findIndex((p) => p.name === name);
-            if (index >= 0) {
-                learnedPatterns.splice(index, 1);
-                errorPatterns.learnedPatterns = learnedPatterns;
-                config.errorPatterns = errorPatterns;
-                await this.saveConfig(config);
-                this.logger.info(`[PatternStorage] Deleted learned pattern: ${name}`);
-                return true;
-            }
-            return false;
-        }
-        catch (error) {
-            this.logger.error('[PatternStorage] Failed to delete pattern', {
-                error: error instanceof Error ? error.message : String(error),
-            });
-            throw error;
-        }
+    setConfigFilePath(path) {
+        this.configFilePath = path;
     }
     /**
-     * Merge duplicate patterns with high similarity
+     * Merge similar patterns (Jaccard similarity > 0.8)
      */
-    async mergeDuplicatePatterns() {
-        try {
-            const config = await this.loadConfig();
-            const errorPatterns = config.errorPatterns || {};
-            let learnedPatterns = errorPatterns.learnedPatterns || [];
-            const mergeThreshold = 0.8;
-            let mergedCount = 0;
+    mergeSimilarPatterns(patterns) {
+        if (patterns.length === 0) {
+            return patterns;
+        }
+        const merged = [];
+        const usedIndices = new Set();
+        for (let i = 0; i < patterns.length; i++) {
+            if (usedIndices.has(i)) {
+                continue;
+            }
+            let currentPattern = patterns[i];
+            let combinedSampleCount = currentPattern.sampleCount;
+            let combinedPhrases = new Set();
+            // Collect all phrases from the current pattern
+            for (const p of currentPattern.patterns) {
+                combinedPhrases.add(String(p));
+            }
             // Find and merge similar patterns
-            const patternsToMerge = [];
-            for (let i = 0; i < learnedPatterns.length; i++) {
-                if (patternsToMerge.includes(i))
+            for (let j = i + 1; j < patterns.length; j++) {
+                if (usedIndices.has(j)) {
                     continue;
-                for (let j = i + 1; j < learnedPatterns.length; j++) {
-                    if (patternsToMerge.includes(j))
-                        continue;
-                    const pattern1 = learnedPatterns[i];
-                    const pattern2 = learnedPatterns[j];
-                    // Only merge patterns from same provider
-                    if (pattern1.provider !== pattern2.provider)
-                        continue;
-                    // Calculate similarity
-                    const similarity = this.calculatePatternSimilarity(pattern1, pattern2);
-                    if (similarity >= mergeThreshold) {
-                        // Merge pattern2 into pattern1
-                        pattern1.patterns = [...new Set([...pattern1.patterns, ...pattern2.patterns])];
-                        pattern1.sampleCount += pattern2.sampleCount;
-                        pattern1.confidence = Math.max(pattern1.confidence, pattern2.confidence);
-                        patternsToMerge.push(j);
-                        mergedCount++;
-                        this.logger.info(`[PatternStorage] Merged pattern ${pattern2.name} into ${pattern1.name}`);
+                }
+                const otherPattern = patterns[j];
+                const currentStr = currentPattern.patterns.map(p => String(p)).join(' ');
+                const otherStr = otherPattern.patterns.map(p => String(p)).join(' ');
+                const similarity = calculateJaccardSimilarity(currentStr, otherStr);
+                if (similarity > 0.8) {
+                    // Merge patterns
+                    usedIndices.add(j);
+                    combinedSampleCount += otherPattern.sampleCount;
+                    // Add phrases from the other pattern
+                    for (const p of otherPattern.patterns) {
+                        combinedPhrases.add(String(p));
                     }
+                    // Use the maximum confidence
+                    currentPattern = {
+                        ...currentPattern,
+                        confidence: Math.max(currentPattern.confidence, otherPattern.confidence),
+                    };
                 }
             }
-            // Remove merged patterns (in reverse order to preserve indices)
-            patternsToMerge.sort((a, b) => b - a);
-            for (const index of patternsToMerge) {
-                learnedPatterns.splice(index, 1);
-            }
-            if (mergedCount > 0) {
-                errorPatterns.learnedPatterns = learnedPatterns;
-                config.errorPatterns = errorPatterns;
-                await this.saveConfig(config);
-            }
-            return mergedCount;
+            // Create merged pattern
+            const mergedPattern = {
+                ...currentPattern,
+                patterns: Array.from(combinedPhrases),
+                sampleCount: combinedSampleCount,
+            };
+            merged.push(mergedPattern);
         }
-        catch (error) {
-            this.logger.error('[PatternStorage] Failed to merge patterns', {
-                error: error instanceof Error ? error.message : String(error),
-            });
-            throw error;
+        return merged;
+    }
+    /**
+     * Clean up old patterns when exceeding limit
+     */
+    cleanupPatterns(patterns) {
+        if (patterns.length <= this.config.maxLearnedPatterns) {
+            return patterns;
         }
+        // Sort by confidence and sampleCount (descending)
+        const sorted = [...patterns].sort((a, b) => {
+            if (a.confidence !== b.confidence) {
+                return b.confidence - a.confidence;
+            }
+            return b.sampleCount - a.sampleCount;
+        });
+        // Trim to max limit
+        return sorted.slice(0, this.config.maxLearnedPatterns);
     }
     /**
-     * Cleanup old patterns, keeping only the most confident ones
+     * Save learned patterns to config file
      */
-    async cleanupOldPatterns(maxCount, patterns) {
+    async saveLearnedPatterns(patterns) {
+        if (!this.configFilePath) {
+            return; // No config file set, skip saving
+        }
         try {
-            const config = await this.loadConfig();
-            const errorPatterns = config.errorPatterns || {};
-            let learnedPatterns = patterns || errorPatterns.learnedPatterns || [];
-            if (learnedPatterns.length <= maxCount) {
-                return 0;
+            // Read the existing config
+            const configData = JSON.parse(await fs.readFile(this.configFilePath, 'utf-8'));
+            // Update the learned patterns
+            if (!configData.errorPatterns) {
+                configData.errorPatterns = {};
             }
-            // Sort by confidence (descending), then by sample count (descending), then by learnedAt (descending)
-            learnedPatterns.sort((a, b) => {
-                if (b.confidence !== a.confidence) {
-                    return b.confidence - a.confidence;
-                }
-                if (b.sampleCount !== a.sampleCount) {
-                    return b.sampleCount - a.sampleCount;
-                }
-                return new Date(b.learnedAt).getTime() - new Date(a.learnedAt).getTime();
-            });
-            const removedCount = learnedPatterns.length - maxCount;
-            learnedPatterns = learnedPatterns.slice(0, maxCount);
-            errorPatterns.learnedPatterns = learnedPatterns;
-            config.errorPatterns = errorPatterns;
-            await this.saveConfig(config);
-            this.logger.info(`[PatternStorage] Cleaned up ${removedCount} old patterns`);
-            return removedCount;
+            configData.errorPatterns.learnedPatterns = patterns;
+            // Write back to file
+            await fs.writeFile(this.configFilePath, JSON.stringify(configData, null, 2), 'utf-8');
         }
         catch (error) {
-            this.logger.error('[PatternStorage] Failed to cleanup patterns', {
-                error: error instanceof Error ? error.message : String(error),
-            });
-            throw error;
+            // Silently handle save errors - pattern learning is a best-effort feature
+            // Errors will be logged by the caller if needed
         }
     }
     /**
-     * Load config file
+     * Validate and load learned patterns from config
      */
-    async loadConfig() {
+    async loadLearnedPatterns() {
+        if (!this.configFilePath) {
+            return [];
+        }
         try {
-            const content = await readFile(this.configPath, 'utf-8');
-            return JSON.parse(content);
+            const configData = JSON.parse(await fs.readFile(this.configFilePath, 'utf-8'));
+            const learnedPatterns = configData.errorPatterns?.learnedPatterns;
+            if (!Array.isArray(learnedPatterns)) {
+                return [];
+            }
+            // Validate each pattern
+            const validPatterns = [];
+            for (const pattern of learnedPatterns) {
+                if (this.isValidLearnedPattern(pattern)) {
+                    validPatterns.push(pattern);
+                }
+            }
+            return validPatterns;
         }
-        catch (error) {
-            // If file doesn't exist or is invalid, return empty config
-            return {};
+        catch {
+            // File doesn't exist or is invalid
+            return [];
         }
     }
     /**
-     * Save config file
-     */
-    async saveConfig(config) {
-        await writeFile(this.configPath, JSON.stringify(config, null, 2), 'utf-8');
-    }
-    /**
-     * Validate pattern structure
+     * Validate a learned pattern object
      */
-    isValidPattern(pattern) {
-        return (pattern &&
-            typeof pattern === 'object' &&
-            typeof pattern.name === 'string' &&
-            Array.isArray(pattern.patterns) &&
-            typeof pattern.confidence === 'number' &&
-            typeof pattern.learnedAt === 'string' &&
-            typeof pattern.sampleCount === 'number' &&
-            typeof pattern.priority === 'number');
+    isValidLearnedPattern(pattern) {
+        if (!pattern || typeof pattern !== 'object') {
+            return false;
+        }
+        const p = pattern;
+        return (typeof p.name === 'string' &&
+            typeof p.confidence === 'number' &&
+            typeof p.learnedAt === 'string' &&
+            typeof p.sampleCount === 'number' &&
+            typeof p.priority === 'number' &&
+            Array.isArray(p.patterns) &&
+            p.patterns.every((pt) => typeof pt === 'string' || pt instanceof RegExp));
     }
     /**
-     * Calculate similarity between two patterns
+     * Create a learned pattern from an error pattern
      */
-    calculatePatternSimilarity(pattern1, pattern2) {
-        const text1 = pattern1.patterns.join(' ').toLowerCase();
-        const text2 = pattern2.patterns.join(' ').toLowerCase();
-        return calculateJaccardSimilarity(text1, text2);
+    createLearnedPattern(basePattern, confidence, sampleCount) {
+        return {
+            ...basePattern,
+            confidence,
+            learnedAt: new Date().toISOString(),
+            sampleCount,
+        };
     }
 }

package/dist/src/main/ConfigReloader.d.ts

@@ -14,6 +14,12 @@ export interface ComponentRefs {
     metricsManager?: {
         updateConfig: (newConfig: PluginConfig) => void;
     };
+    errorPatternRegistry?: {
+        updateLearnedPatterns: (patterns: any[]) => void;
+        getPatternLearner: () => {
+            updateConfig: (config: any) => void;
+        } | null;
+    };
 }
 /**
  * ConfigReloader class - handles configuration reload logic

package/dist/src/main/ConfigReloader.js

@@ -125,6 +125,23 @@ export class ConfigReloader {
         if (this.components.metricsManager) {
             this.components.metricsManager.updateConfig(newConfig);
         }
+        // Reload learned patterns if errorPatterns config changed
+        if (this.components.errorPatternRegistry && newConfig.errorPatterns?.learnedPatterns) {
+            this.components.errorPatternRegistry.updateLearnedPatterns(newConfig.errorPatterns.learnedPatterns);
+            this.logger.info(`Reloaded ${newConfig.errorPatterns.learnedPatterns.length} learned patterns`);
+            // Update pattern learner config if it exists
+            const patternLearner = this.components.errorPatternRegistry.getPatternLearner();
+            if (patternLearner && newConfig.errorPatterns) {
+                const patternLearningConfig = {
+                    enabled: newConfig.errorPatterns.enableLearning ?? false,
+                    autoApproveThreshold: newConfig.errorPatterns.autoApproveThreshold ?? 0.8,
+                    maxLearnedPatterns: newConfig.errorPatterns.maxLearnedPatterns ?? 20,
+                    minErrorFrequency: newConfig.errorPatterns.minErrorFrequency ?? 3,
+                    learningWindowMs: newConfig.errorPatterns.learningWindowMs ?? 86400000,
+                };
+                patternLearner.updateConfig(patternLearningConfig);
+            }
+        }
         // Log configuration changes
         const changedSettings = this.getChangedSettings(oldConfig, newConfig);
         if (changedSettings.length > 0) {

package/dist/src/types/index.d.ts

@@ -160,27 +160,21 @@ export interface ErrorPattern {
     priority: number;
 }
 /**
- * Pattern candidate extracted from an error
- */
-export interface PatternCandidate {
-    provider?: string;
-    patterns: (string | RegExp)[];
-    sourceError: string;
-    extractedAt: number;
-}
-/**
- * Learned pattern with metadata
+ * Error pattern configuration
  */
-export interface LearnedPattern extends ErrorPattern {
-    confidence: number;
-    learnedAt: string;
-    sampleCount: number;
-    lastUsed?: number;
+export interface ErrorPatternsConfig {
+    custom?: ErrorPattern[];
+    enableLearning?: boolean;
+    learnedPatterns?: LearnedPattern[];
+    autoApproveThreshold?: number;
+    maxLearnedPatterns?: number;
+    minErrorFrequency?: number;
+    learningWindowMs?: number;
 }
 /**
- * Learning configuration
+ * Pattern learning configuration
  */
-export interface LearningConfig {
+export interface PatternLearningConfig {
     enabled: boolean;
     autoApproveThreshold: number;
     maxLearnedPatterns: number;
@@ -188,16 +182,22 @@ export interface LearningConfig {
     learningWindowMs: number;
 }
 /**
- * Error pattern configuration
+ * Learned pattern with confidence metadata
  */
-export interface ErrorPatternsConfig {
-    custom?: ErrorPattern[];
-    enableLearning?: boolean;
-    learnedPatterns?: LearnedPattern[];
-    autoApproveThreshold?: number;
-    maxLearnedPatterns?: number;
-    minErrorFrequency?: number;
-    learningWindowMs?: number;
+export interface LearnedPattern extends ErrorPattern {
+    confidence: number;
+    learnedAt: string;
+    sampleCount: number;
+}
+/**
+ * Extracted pattern from an error
+ */
+export interface PatternCandidate {
+    provider: string | null;
+    statusCode: string | null;
+    phrases: string[];
+    errorCodes: string[];
+    rawText: string;
 }
 /**
  * Configuration hot reload settings

package/dist/src/utils/config.js

@@ -4,7 +4,7 @@
 import { existsSync, readFileSync } from "fs";
 import { join, resolve, normalize, relative } from "path";
 import { DEFAULT_FALLBACK_MODELS, VALID_FALLBACK_MODES, VALID_RESET_INTERVALS, DEFAULT_RETRY_POLICY, VALID_RETRY_STRATEGIES, DEFAULT_CIRCUIT_BREAKER_CONFIG, } from '../types/index.js';
-import { DEFAULT_HEALTH_TRACKER_CONFIG, DEFAULT_COOLDOWN_MS, DEFAULT_FALLBACK_MODE, DEFAULT_LOG_CONFIG, DEFAULT_METRICS_CONFIG, DEFAULT_CONFIG_RELOAD_CONFIG, DEFAULT_DYNAMIC_PRIORITIZATION_CONFIG, DEFAULT_ERROR_PATTERN_LEARNING_CONFIG, } from '../config/defaults.js';
+import { DEFAULT_HEALTH_TRACKER_CONFIG, DEFAULT_COOLDOWN_MS, DEFAULT_FALLBACK_MODE, DEFAULT_LOG_CONFIG, DEFAULT_METRICS_CONFIG, DEFAULT_CONFIG_RELOAD_CONFIG, DEFAULT_DYNAMIC_PRIORITIZATION_CONFIG, DEFAULT_ERROR_PATTERNS_CONFIG, DEFAULT_PATTERN_LEARNING_CONFIG, } from '../config/defaults.js';
 /**
  * Default plugin configuration
  */
@@ -20,7 +20,7 @@ export const DEFAULT_CONFIG = {
     metrics: DEFAULT_METRICS_CONFIG,
     configReload: DEFAULT_CONFIG_RELOAD_CONFIG,
     dynamicPrioritization: DEFAULT_DYNAMIC_PRIORITIZATION_CONFIG,
-    errorPatterns: DEFAULT_ERROR_PATTERN_LEARNING_CONFIG,
+    errorPatterns: DEFAULT_ERROR_PATTERNS_CONFIG,
 };
 /**
  * Validate that a path does not contain directory traversal attempts
@@ -92,9 +92,14 @@ export function validateConfig(config) {
             ...config.dynamicPrioritization,
         } : DEFAULT_DYNAMIC_PRIORITIZATION_CONFIG,
         errorPatterns: config.errorPatterns ? {
-            ...DEFAULT_ERROR_PATTERN_LEARNING_CONFIG,
+            ...DEFAULT_ERROR_PATTERNS_CONFIG,
             ...config.errorPatterns,
-        } : DEFAULT_ERROR_PATTERN_LEARNING_CONFIG,
+            enableLearning: config.errorPatterns.enableLearning ?? DEFAULT_PATTERN_LEARNING_CONFIG.enabled,
+            autoApproveThreshold: config.errorPatterns.autoApproveThreshold ?? DEFAULT_PATTERN_LEARNING_CONFIG.autoApproveThreshold,
+            maxLearnedPatterns: config.errorPatterns.maxLearnedPatterns ?? DEFAULT_PATTERN_LEARNING_CONFIG.maxLearnedPatterns,
+            minErrorFrequency: config.errorPatterns.minErrorFrequency ?? DEFAULT_PATTERN_LEARNING_CONFIG.minErrorFrequency,
+            learningWindowMs: config.errorPatterns.learningWindowMs ?? DEFAULT_PATTERN_LEARNING_CONFIG.learningWindowMs,
+        } : DEFAULT_ERROR_PATTERNS_CONFIG,
     };
 }
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@azumag/opencode-rate-limit-fallback",
-  "version": "1.59.0",
+  "version": "1.63.0",
   "description": "OpenCode plugin that automatically switches to fallback models when rate limited",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",