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

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

@@ -113,6 +113,26 @@ export interface HealthTrackerConfig {
  * Use this for backward compatibility.
  */
 export type HealthPersistenceConfig = HealthTrackerConfig;
+/**
+ * Dynamic prioritization configuration
+ */
+export interface DynamicPrioritizationConfig {
+    enabled: boolean;
+    updateInterval: number;
+    successRateWeight: number;
+    responseTimeWeight: number;
+    recentUsageWeight: number;
+    minSamples: number;
+    maxHistorySize: number;
+}
+/**
+ * Dynamic prioritization metrics
+ */
+export interface DynamicPrioritizationMetrics {
+    enabled: boolean;
+    reorders: number;
+    modelsWithDynamicScores: number;
+}
 /**
  * Health metrics for a model
  */
@@ -139,12 +159,45 @@ export interface ErrorPattern {
     patterns: (string | RegExp)[];
     priority: number;
 }
+/**
+ * Pattern candidate extracted from an error
+ */
+export interface PatternCandidate {
+    provider?: string;
+    patterns: (string | RegExp)[];
+    sourceError: string;
+    extractedAt: number;
+}
+/**
+ * Learned pattern with metadata
+ */
+export interface LearnedPattern extends ErrorPattern {
+    confidence: number;
+    learnedAt: string;
+    sampleCount: number;
+    lastUsed?: number;
+}
+/**
+ * Learning configuration
+ */
+export interface LearningConfig {
+    enabled: boolean;
+    autoApproveThreshold: number;
+    maxLearnedPatterns: number;
+    minErrorFrequency: number;
+    learningWindowMs: number;
+}
 /**
  * Error pattern configuration
  */
 export interface ErrorPatternsConfig {
     custom?: ErrorPattern[];
     enableLearning?: boolean;
+    learnedPatterns?: LearnedPattern[];
+    autoApproveThreshold?: number;
+    maxLearnedPatterns?: number;
+    minErrorFrequency?: number;
+    learningWindowMs?: number;
 }
 /**
  * Configuration hot reload settings
@@ -193,6 +246,7 @@ export interface PluginConfig {
     verbose?: boolean;
     errorPatterns?: ErrorPatternsConfig;
     configReload?: ConfigReloadConfig;
+    dynamicPrioritization?: DynamicPrioritizationConfig;
 }
 /**
  * Fallback state for tracking progress
@@ -357,6 +411,7 @@ export interface MetricsData {
         total: CircuitBreakerMetrics;
         byModel: Map<string, CircuitBreakerMetrics>;
     };
+    dynamicPrioritization: DynamicPrioritizationMetrics;
     startedAt: number;
     generatedAt: number;
 }

package/dist/src/utils/config.js

@@ -2,9 +2,9 @@
  * Configuration loading and validation
  */
 import { existsSync, readFileSync } from "fs";
-import { join } from "path";
+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, } 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_PATTERN_LEARNING_CONFIG, } from '../config/defaults.js';
 /**
  * Default plugin configuration
  */
@@ -19,7 +19,35 @@ export const DEFAULT_CONFIG = {
     log: DEFAULT_LOG_CONFIG,
     metrics: DEFAULT_METRICS_CONFIG,
     configReload: DEFAULT_CONFIG_RELOAD_CONFIG,
+    dynamicPrioritization: DEFAULT_DYNAMIC_PRIORITIZATION_CONFIG,
+    errorPatterns: DEFAULT_ERROR_PATTERN_LEARNING_CONFIG,
 };
+/**
+ * Validate that a path does not contain directory traversal attempts
+ */
+function validatePathSafety(path, allowedDirs) {
+    try {
+        const resolvedPath = resolve(path);
+        const normalizedPath = normalize(path);
+        // Check for obvious path traversal patterns
+        if (normalizedPath.includes('..')) {
+            return false;
+        }
+        // Check that resolved path is within allowed directories
+        for (const allowedDir of allowedDirs) {
+            const resolvedAllowedDir = resolve(allowedDir);
+            const relativePath = relative(resolvedAllowedDir, resolvedPath);
+            // If relative path does not start with '..', the path is within the allowed directory
+            if (!relativePath.startsWith('..')) {
+                return true;
+            }
+        }
+        return false;
+    }
+    catch {
+        return false;
+    }
+}
 /**
  * Validate configuration values
  */
@@ -59,6 +87,14 @@ export function validateConfig(config) {
             ...DEFAULT_CONFIG.configReload,
             ...config.configReload,
         } : DEFAULT_CONFIG.configReload,
+        dynamicPrioritization: config.dynamicPrioritization ? {
+            ...DEFAULT_DYNAMIC_PRIORITIZATION_CONFIG,
+            ...config.dynamicPrioritization,
+        } : DEFAULT_DYNAMIC_PRIORITIZATION_CONFIG,
+        errorPatterns: config.errorPatterns ? {
+            ...DEFAULT_ERROR_PATTERN_LEARNING_CONFIG,
+            ...config.errorPatterns,
+        } : DEFAULT_ERROR_PATTERN_LEARNING_CONFIG,
     };
 }
 /**
@@ -70,18 +106,18 @@ export function loadConfig(directory, worktree, logger) {
     // Build search paths: worktree first, then directory, then home locations
     const searchDirs = [];
     if (worktree) {
-        searchDirs.push(worktree);
+        searchDirs.push(resolve(worktree));
     }
     if (!worktree || worktree !== directory) {
-        searchDirs.push(directory);
+        searchDirs.push(resolve(directory));
     }
+    searchDirs.push(resolve(homedir));
+    searchDirs.push(resolve(xdgConfigHome));
     const configPaths = [];
     for (const dir of searchDirs) {
         configPaths.push(join(dir, ".opencode", "rate-limit-fallback.json"));
         configPaths.push(join(dir, "rate-limit-fallback.json"));
     }
-    configPaths.push(join(homedir, ".opencode", "rate-limit-fallback.json"));
-    configPaths.push(join(xdgConfigHome, "opencode", "rate-limit-fallback.json"));
     // Log search paths for debugging
     if (logger) {
         logger.debug(`Searching for config file in ${configPaths.length} locations`);
@@ -92,6 +128,13 @@ export function loadConfig(directory, worktree, logger) {
     }
     for (const configPath of configPaths) {
         if (existsSync(configPath)) {
+            // Validate path safety before reading
+            if (!validatePathSafety(configPath, searchDirs)) {
+                if (logger) {
+                    logger.warn(`Config file rejected due to path validation: ${configPath}`);
+                }
+                continue;
+            }
             try {
                 const content = readFileSync(configPath, "utf-8");
                 const userConfig = JSON.parse(content);

package/dist/src/utils/similarity.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Similarity utility functions
+ */
+/**
+ * Calculate Jaccard similarity between two strings
+ * @param str1 - First string
+ * @param str2 - Second string
+ * @returns Similarity score between 0 and 1
+ */
+export declare function calculateJaccardSimilarity(str1: string, str2: string): number;

package/dist/src/utils/similarity.js

@@ -0,0 +1,24 @@
+/**
+ * Similarity utility functions
+ */
+/**
+ * Calculate Jaccard similarity between two strings
+ * @param str1 - First string
+ * @param str2 - Second string
+ * @returns Similarity score between 0 and 1
+ */
+export function calculateJaccardSimilarity(str1, str2) {
+    // Tokenize strings
+    const tokens1 = new Set(str1.split(/\s+/).filter(t => t.length > 0));
+    const tokens2 = new Set(str2.split(/\s+/).filter(t => t.length > 0));
+    if (tokens1.size === 0 && tokens2.size === 0) {
+        return 1;
+    }
+    if (tokens1.size === 0 || tokens2.size === 0) {
+        return 0;
+    }
+    // Calculate intersection and union
+    const intersection = new Set([...tokens1].filter(x => tokens2.has(x)));
+    const union = new Set([...tokens1, ...tokens2]);
+    return intersection.size / union.size;
+}

package/package.json

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