specweave 0.18.0 → 0.20.0

package/dist/src/core/sync/performance-optimizer.d.ts

@@ -0,0 +1,153 @@
+/**
+ * Performance Optimizer for Status Sync
+ *
+ * Implements caching, batching, and optimization strategies to ensure
+ * status sync operations complete within performance targets:
+ * - Status sync: <2 seconds
+ * - Conflict detection: <1 second
+ * - Bulk sync (10 items): <5 seconds
+ *
+ * @module performance-optimizer
+ */
+/**
+ * Performance metrics
+ */
+export interface PerformanceMetrics {
+    operationType: 'status-sync' | 'conflict-detection' | 'bulk-sync';
+    duration: number;
+    itemCount: number;
+    cacheHits: number;
+    cacheMisses: number;
+    timestamp: string;
+}
+/**
+ * Performance Optimizer
+ *
+ * Provides caching and optimization for status sync operations.
+ */
+export declare class PerformanceOptimizer {
+    private cache;
+    private readonly DEFAULT_TTL_MS;
+    private metrics;
+    /**
+     * Get cached value if available and not expired
+     *
+     * @param key - Cache key
+     * @returns Cached value or null if not found/expired
+     */
+    get<T>(key: string): T | null;
+    /**
+     * Set cache value with TTL
+     *
+     * @param key - Cache key
+     * @param value - Value to cache
+     * @param ttlMs - Time to live in milliseconds (default: 5 minutes)
+     */
+    set<T>(key: string, value: T, ttlMs?: number): void;
+    /**
+     * Clear specific cache entry
+     *
+     * @param key - Cache key
+     */
+    clear(key: string): void;
+    /**
+     * Clear all cache entries
+     */
+    clearAll(): void;
+    /**
+     * Clear expired cache entries
+     */
+    clearExpired(): void;
+    /**
+     * Get cache statistics
+     */
+    getCacheStats(): {
+        size: number;
+        keys: string[];
+        hitRate: number;
+    };
+    /**
+     * Record performance metric
+     *
+     * @param metric - Performance metric
+     */
+    recordMetric(metric: PerformanceMetrics): void;
+    /**
+     * Get performance metrics
+     *
+     * @param operationType - Filter by operation type
+     * @returns Performance metrics
+     */
+    getMetrics(operationType?: PerformanceMetrics['operationType']): PerformanceMetrics[];
+    /**
+     * Get average duration for operation type
+     *
+     * @param operationType - Operation type
+     * @returns Average duration in milliseconds
+     */
+    getAverageDuration(operationType: PerformanceMetrics['operationType']): number;
+    /**
+     * Check if performance targets are met
+     *
+     * Performance targets:
+     * - status-sync: <2000ms
+     * - conflict-detection: <1000ms
+     * - bulk-sync (10 items): <5000ms
+     *
+     * @returns Performance target status
+     */
+    checkPerformanceTargets(): {
+        statusSync: {
+            target: number;
+            actual: number;
+            met: boolean;
+        };
+        conflictDetection: {
+            target: number;
+            actual: number;
+            met: boolean;
+        };
+        bulkSync: {
+            target: number;
+            actual: number;
+            met: boolean;
+        };
+    };
+    /**
+     * Generate cache key for external status
+     *
+     * @param tool - External tool
+     * @param identifier - Issue/item identifier
+     * @returns Cache key
+     */
+    static generateStatusCacheKey(tool: string, identifier: string): string;
+    /**
+     * Generate cache key for workflow
+     *
+     * @param tool - External tool
+     * @param project - Project identifier
+     * @returns Cache key
+     */
+    static generateWorkflowCacheKey(tool: string, project: string): string;
+    /**
+     * Batch process with delay
+     *
+     * Processes items in batches with configurable delay between batches
+     * to avoid rate limiting and improve throughput.
+     *
+     * @param items - Items to process
+     * @param processor - Async function to process each item
+     * @param batchSize - Batch size (default: 5)
+     * @param delayMs - Delay between batches in milliseconds (default: 1000)
+     * @returns Array of results
+     */
+    static batchProcess<T, R>(items: T[], processor: (item: T) => Promise<R>, batchSize?: number, delayMs?: number): Promise<R[]>;
+    /**
+     * Measure execution time of an async function
+     *
+     * @param operation - Async operation to measure
+     * @returns Tuple of [result, duration in ms]
+     */
+    static measureTime<T>(operation: () => Promise<T>): Promise<[T, number]>;
+}
+//# sourceMappingURL=performance-optimizer.d.ts.map

package/dist/src/core/sync/performance-optimizer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"performance-optimizer.d.ts","sourceRoot":"","sources":["../../../../src/core/sync/performance-optimizer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAUH;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,aAAa,EAAE,aAAa,GAAG,oBAAoB,GAAG,WAAW,CAAC;IAClE,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;;;GAIG;AACH,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,KAAK,CAA2C;IACxD,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAiB;IAChD,OAAO,CAAC,OAAO,CAA4B;IAE3C;;;;;OAKG;IACH,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,GAAG,CAAC,GAAG,IAAI;IAgB7B;;;;;;OAMG;IACH,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,GAAE,MAA4B,GAAG,IAAI;IAOxE;;;;OAIG;IACH,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAIxB;;OAEG;IACH,QAAQ,IAAI,IAAI;IAIhB;;OAEG;IACH,YAAY,IAAI,IAAI;IASpB;;OAEG;IACH,aAAa,IAAI;QACf,IAAI,EAAE,MAAM,CAAC;QACb,IAAI,EAAE,MAAM,EAAE,CAAC;QACf,OAAO,EAAE,MAAM,CAAC;KACjB;IAcD;;;;OAIG;IACH,YAAY,CAAC,MAAM,EAAE,kBAAkB,GAAG,IAAI;IAS9C;;;;;OAKG;IACH,UAAU,CAAC,aAAa,CAAC,EAAE,kBAAkB,CAAC,eAAe,CAAC,GAAG,kBAAkB,EAAE;IAQrF;;;;;OAKG;IACH,kBAAkB,CAAC,aAAa,EAAE,kBAAkB,CAAC,eAAe,CAAC,GAAG,MAAM;IAW9E;;;;;;;;;OASG;IACH,uBAAuB,IAAI;QACzB,UAAU,EAAE;YAAE,MAAM,EAAE,MAAM,CAAC;YAAC,MAAM,EAAE,MAAM,CAAC;YAAC,GAAG,EAAE,OAAO,CAAA;SAAE,CAAC;QAC7D,iBAAiB,EAAE;YAAE,MAAM,EAAE,MAAM,CAAC;YAAC,MAAM,EAAE,MAAM,CAAC;YAAC,GAAG,EAAE,OAAO,CAAA;SAAE,CAAC;QACpE,QAAQ,EAAE;YAAE,MAAM,EAAE,MAAM,CAAC;YAAC,MAAM,EAAE,MAAM,CAAC;YAAC,GAAG,EAAE,OAAO,CAAA;SAAE,CAAC;KAC5D;IAwBD;;;;;;OAMG;IACH,MAAM,CAAC,sBAAsB,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM;IAIvE;;;;;;OAMG;IACH,MAAM,CAAC,wBAAwB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM;IAItE;;;;;;;;;;;OAWG;WACU,YAAY,CAAC,CAAC,EAAE,CAAC,EAC5B,KAAK,EAAE,CAAC,EAAE,EACV,SAAS,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,EAClC,SAAS,GAAE,MAAU,EACrB,OAAO,GAAE,MAAa,GACrB,OAAO,CAAC,CAAC,EAAE,CAAC;IAsBf;;;;;OAKG;WACU,WAAW,CAAC,CAAC,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC;CAO/E"}

package/dist/src/core/sync/performance-optimizer.js

@@ -0,0 +1,220 @@
+/**
+ * Performance Optimizer for Status Sync
+ *
+ * Implements caching, batching, and optimization strategies to ensure
+ * status sync operations complete within performance targets:
+ * - Status sync: <2 seconds
+ * - Conflict detection: <1 second
+ * - Bulk sync (10 items): <5 seconds
+ *
+ * @module performance-optimizer
+ */
+/**
+ * Performance Optimizer
+ *
+ * Provides caching and optimization for status sync operations.
+ */
+export class PerformanceOptimizer {
+    constructor() {
+        this.cache = new Map();
+        this.DEFAULT_TTL_MS = 5 * 60 * 1000; // 5 minutes
+        this.metrics = [];
+    }
+    /**
+     * Get cached value if available and not expired
+     *
+     * @param key - Cache key
+     * @returns Cached value or null if not found/expired
+     */
+    get(key) {
+        const entry = this.cache.get(key);
+        if (!entry) {
+            return null;
+        }
+        // Check expiration
+        if (Date.now() > entry.expiresAt) {
+            this.cache.delete(key);
+            return null;
+        }
+        return entry.value;
+    }
+    /**
+     * Set cache value with TTL
+     *
+     * @param key - Cache key
+     * @param value - Value to cache
+     * @param ttlMs - Time to live in milliseconds (default: 5 minutes)
+     */
+    set(key, value, ttlMs = this.DEFAULT_TTL_MS) {
+        this.cache.set(key, {
+            value,
+            expiresAt: Date.now() + ttlMs
+        });
+    }
+    /**
+     * Clear specific cache entry
+     *
+     * @param key - Cache key
+     */
+    clear(key) {
+        this.cache.delete(key);
+    }
+    /**
+     * Clear all cache entries
+     */
+    clearAll() {
+        this.cache.clear();
+    }
+    /**
+     * Clear expired cache entries
+     */
+    clearExpired() {
+        const now = Date.now();
+        for (const [key, entry] of this.cache.entries()) {
+            if (now > entry.expiresAt) {
+                this.cache.delete(key);
+            }
+        }
+    }
+    /**
+     * Get cache statistics
+     */
+    getCacheStats() {
+        const totalRequests = this.metrics.reduce((sum, m) => sum + m.cacheHits + m.cacheMisses, 0);
+        const totalHits = this.metrics.reduce((sum, m) => sum + m.cacheHits, 0);
+        return {
+            size: this.cache.size,
+            keys: Array.from(this.cache.keys()),
+            hitRate: totalRequests > 0 ? totalHits / totalRequests : 0
+        };
+    }
+    /**
+     * Record performance metric
+     *
+     * @param metric - Performance metric
+     */
+    recordMetric(metric) {
+        this.metrics.push(metric);
+        // Keep only last 100 metrics
+        if (this.metrics.length > 100) {
+            this.metrics.shift();
+        }
+    }
+    /**
+     * Get performance metrics
+     *
+     * @param operationType - Filter by operation type
+     * @returns Performance metrics
+     */
+    getMetrics(operationType) {
+        if (!operationType) {
+            return [...this.metrics];
+        }
+        return this.metrics.filter(m => m.operationType === operationType);
+    }
+    /**
+     * Get average duration for operation type
+     *
+     * @param operationType - Operation type
+     * @returns Average duration in milliseconds
+     */
+    getAverageDuration(operationType) {
+        const metrics = this.getMetrics(operationType);
+        if (metrics.length === 0) {
+            return 0;
+        }
+        const sum = metrics.reduce((total, m) => total + m.duration, 0);
+        return sum / metrics.length;
+    }
+    /**
+     * Check if performance targets are met
+     *
+     * Performance targets:
+     * - status-sync: <2000ms
+     * - conflict-detection: <1000ms
+     * - bulk-sync (10 items): <5000ms
+     *
+     * @returns Performance target status
+     */
+    checkPerformanceTargets() {
+        const statusSyncAvg = this.getAverageDuration('status-sync');
+        const conflictAvg = this.getAverageDuration('conflict-detection');
+        const bulkSyncAvg = this.getAverageDuration('bulk-sync');
+        return {
+            statusSync: {
+                target: 2000,
+                actual: statusSyncAvg,
+                met: statusSyncAvg < 2000 || statusSyncAvg === 0
+            },
+            conflictDetection: {
+                target: 1000,
+                actual: conflictAvg,
+                met: conflictAvg < 1000 || conflictAvg === 0
+            },
+            bulkSync: {
+                target: 5000,
+                actual: bulkSyncAvg,
+                met: bulkSyncAvg < 5000 || bulkSyncAvg === 0
+            }
+        };
+    }
+    /**
+     * Generate cache key for external status
+     *
+     * @param tool - External tool
+     * @param identifier - Issue/item identifier
+     * @returns Cache key
+     */
+    static generateStatusCacheKey(tool, identifier) {
+        return `status:${tool}:${identifier}`;
+    }
+    /**
+     * Generate cache key for workflow
+     *
+     * @param tool - External tool
+     * @param project - Project identifier
+     * @returns Cache key
+     */
+    static generateWorkflowCacheKey(tool, project) {
+        return `workflow:${tool}:${project}`;
+    }
+    /**
+     * Batch process with delay
+     *
+     * Processes items in batches with configurable delay between batches
+     * to avoid rate limiting and improve throughput.
+     *
+     * @param items - Items to process
+     * @param processor - Async function to process each item
+     * @param batchSize - Batch size (default: 5)
+     * @param delayMs - Delay between batches in milliseconds (default: 1000)
+     * @returns Array of results
+     */
+    static async batchProcess(items, processor, batchSize = 5, delayMs = 1000) {
+        const results = [];
+        for (let i = 0; i < items.length; i += batchSize) {
+            const batch = items.slice(i, i + batchSize);
+            // Process batch in parallel
+            const batchResults = await Promise.all(batch.map(item => processor(item)));
+            results.push(...batchResults);
+            // Add delay between batches (except for last batch)
+            if (i + batchSize < items.length) {
+                await new Promise(resolve => setTimeout(resolve, delayMs));
+            }
+        }
+        return results;
+    }
+    /**
+     * Measure execution time of an async function
+     *
+     * @param operation - Async operation to measure
+     * @returns Tuple of [result, duration in ms]
+     */
+    static async measureTime(operation) {
+        const startTime = Date.now();
+        const result = await operation();
+        const duration = Date.now() - startTime;
+        return [result, duration];
+    }
+}
+//# sourceMappingURL=performance-optimizer.js.map

package/dist/src/core/sync/performance-optimizer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"performance-optimizer.js","sourceRoot":"","sources":["../../../../src/core/sync/performance-optimizer.ts"],"names":[],"mappings":"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"}

package/dist/src/core/sync/retry-handler.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Retry Handler for Status Sync
+ *
+ * Implements exponential backoff retry logic for handling transient failures
+ * in external API calls (GitHub, JIRA, Azure DevOps).
+ *
+ * Features:
+ * - Exponential backoff (1s, 2s, 4s, 8s)
+ * - Maximum retry attempts (default: 3)
+ * - Rate limit detection and handling
+ * - Clear error messages
+ *
+ * @module retry-handler
+ */
+export type RetryableError = 'network-error' | 'rate-limit' | 'server-error' | 'timeout' | 'unknown';
+export interface RetryConfig {
+    maxRetries?: number;
+    initialDelayMs?: number;
+    maxDelayMs?: number;
+    backoffMultiplier?: number;
+}
+export interface RetryContext {
+    attempt: number;
+    maxRetries: number;
+    lastError: Error;
+    errorType: RetryableError;
+}
+export interface RetryResult<T> {
+    success: boolean;
+    value?: T;
+    error?: Error;
+    attempts: number;
+    totalDelay: number;
+}
+/**
+ * Retry Handler
+ *
+ * Handles retries with exponential backoff for external API calls.
+ */
+export declare class RetryHandler {
+    private config;
+    constructor(config?: RetryConfig);
+    /**
+     * Execute operation with retry logic
+     *
+     * @param operation - Async operation to execute
+     * @param errorClassifier - Function to classify errors (determines if retryable)
+     * @returns Retry result with value or error
+     */
+    executeWithRetry<T>(operation: () => Promise<T>, errorClassifier?: (error: Error) => RetryableError): Promise<RetryResult<T>>;
+    /**
+     * Classify error type
+     *
+     * @param error - Error to classify
+     * @returns Error type
+     */
+    private classifyError;
+    /**
+     * Check if error type is retryable
+     *
+     * @param errorType - Error type
+     * @returns True if retryable
+     */
+    private isRetryable;
+    /**
+     * Calculate delay for retry attempt
+     *
+     * Uses exponential backoff: initialDelay * (multiplier ^ (attempt - 1))
+     *
+     * @param attempt - Current attempt number (1-based)
+     * @returns Delay in milliseconds
+     */
+    private calculateDelay;
+    /**
+     * Delay execution
+     *
+     * @param ms - Milliseconds to delay
+     */
+    private delay;
+    /**
+     * Create clear error message for user
+     *
+     * @param error - Original error
+     * @param context - Retry context
+     * @returns User-friendly error message
+     */
+    static createErrorMessage(error: Error, context: RetryContext): string;
+    /**
+     * Handle rate limit error
+     *
+     * Detects rate limit from error and calculates wait time.
+     *
+     * @param error - Error that may contain rate limit info
+     * @returns Wait time in seconds (null if not rate limit)
+     */
+    static detectRateLimitWait(error: Error): number | null;
+}
+//# sourceMappingURL=retry-handler.d.ts.map

package/dist/src/core/sync/retry-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retry-handler.d.ts","sourceRoot":"","sources":["../../../../src/core/sync/retry-handler.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,MAAM,MAAM,cAAc,GACtB,eAAe,GACf,YAAY,GACZ,cAAc,GACd,SAAS,GACT,SAAS,CAAC;AAEd,MAAM,WAAW,WAAW;IAC1B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,KAAK,CAAC;IACjB,SAAS,EAAE,cAAc,CAAC;CAC3B;AAED,MAAM,WAAW,WAAW,CAAC,CAAC;IAC5B,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,CAAC,CAAC;IACV,KAAK,CAAC,EAAE,KAAK,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED;;;;GAIG;AACH,qBAAa,YAAY;IACvB,OAAO,CAAC,MAAM,CAAwB;gBAE1B,MAAM,GAAE,WAAgB;IASpC;;;;;;OAMG;IACG,gBAAgB,CAAC,CAAC,EACtB,SAAS,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EAC3B,eAAe,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,cAAc,GACjD,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;IAoD1B;;;;;OAKG;IACH,OAAO,CAAC,aAAa;IA0CrB;;;;;OAKG;IACH,OAAO,CAAC,WAAW;IAInB;;;;;;;OAOG;IACH,OAAO,CAAC,cAAc;IAStB;;;;OAIG;IACH,OAAO,CAAC,KAAK;IAIb;;;;;;OAMG;IACH,MAAM,CAAC,kBAAkB,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,YAAY,GAAG,MAAM;IAkBtE;;;;;;;OAOG;IACH,MAAM,CAAC,mBAAmB,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM,GAAG,IAAI;CAsBxD"}

package/dist/src/core/sync/retry-handler.js

@@ -0,0 +1,196 @@
+/**
+ * Retry Handler for Status Sync
+ *
+ * Implements exponential backoff retry logic for handling transient failures
+ * in external API calls (GitHub, JIRA, Azure DevOps).
+ *
+ * Features:
+ * - Exponential backoff (1s, 2s, 4s, 8s)
+ * - Maximum retry attempts (default: 3)
+ * - Rate limit detection and handling
+ * - Clear error messages
+ *
+ * @module retry-handler
+ */
+/**
+ * Retry Handler
+ *
+ * Handles retries with exponential backoff for external API calls.
+ */
+export class RetryHandler {
+    constructor(config = {}) {
+        this.config = {
+            maxRetries: config.maxRetries ?? 3,
+            initialDelayMs: config.initialDelayMs ?? 1000,
+            maxDelayMs: config.maxDelayMs ?? 8000,
+            backoffMultiplier: config.backoffMultiplier ?? 2
+        };
+    }
+    /**
+     * Execute operation with retry logic
+     *
+     * @param operation - Async operation to execute
+     * @param errorClassifier - Function to classify errors (determines if retryable)
+     * @returns Retry result with value or error
+     */
+    async executeWithRetry(operation, errorClassifier) {
+        let attempt = 0;
+        let totalDelay = 0;
+        let lastError;
+        while (attempt <= this.config.maxRetries) {
+            try {
+                const value = await operation();
+                return {
+                    success: true,
+                    value,
+                    attempts: attempt + 1,
+                    totalDelay
+                };
+            }
+            catch (error) {
+                lastError = error;
+                attempt++;
+                // Classify error
+                const errorType = errorClassifier
+                    ? errorClassifier(lastError)
+                    : this.classifyError(lastError);
+                // Check if we should retry
+                if (!this.isRetryable(errorType) || attempt > this.config.maxRetries) {
+                    return {
+                        success: false,
+                        error: lastError,
+                        attempts: attempt,
+                        totalDelay
+                    };
+                }
+                // Calculate delay for next retry
+                const delay = this.calculateDelay(attempt);
+                totalDelay += delay;
+                // Wait before retrying
+                await this.delay(delay);
+            }
+        }
+        // Should not reach here, but TypeScript needs this
+        return {
+            success: false,
+            error: lastError ?? new Error('Unknown error'),
+            attempts: attempt,
+            totalDelay
+        };
+    }
+    /**
+     * Classify error type
+     *
+     * @param error - Error to classify
+     * @returns Error type
+     */
+    classifyError(error) {
+        const message = error.message.toLowerCase();
+        // Network errors (retry)
+        if (message.includes('network') ||
+            message.includes('econnrefused') ||
+            message.includes('enotfound') ||
+            message.includes('etimedout')) {
+            return 'network-error';
+        }
+        // Rate limit errors (retry with longer delay)
+        if (message.includes('rate limit') ||
+            message.includes('429') ||
+            message.includes('too many requests')) {
+            return 'rate-limit';
+        }
+        // Server errors (retry)
+        if (message.includes('500') ||
+            message.includes('502') ||
+            message.includes('503') ||
+            message.includes('504') ||
+            message.includes('internal server error')) {
+            return 'server-error';
+        }
+        // Timeout errors (retry)
+        if (message.includes('timeout')) {
+            return 'timeout';
+        }
+        // Unknown errors (don't retry by default)
+        return 'unknown';
+    }
+    /**
+     * Check if error type is retryable
+     *
+     * @param errorType - Error type
+     * @returns True if retryable
+     */
+    isRetryable(errorType) {
+        return errorType !== 'unknown';
+    }
+    /**
+     * Calculate delay for retry attempt
+     *
+     * Uses exponential backoff: initialDelay * (multiplier ^ (attempt - 1))
+     *
+     * @param attempt - Current attempt number (1-based)
+     * @returns Delay in milliseconds
+     */
+    calculateDelay(attempt) {
+        const delay = this.config.initialDelayMs *
+            Math.pow(this.config.backoffMultiplier, attempt - 1);
+        // Cap at max delay
+        return Math.min(delay, this.config.maxDelayMs);
+    }
+    /**
+     * Delay execution
+     *
+     * @param ms - Milliseconds to delay
+     */
+    delay(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+    /**
+     * Create clear error message for user
+     *
+     * @param error - Original error
+     * @param context - Retry context
+     * @returns User-friendly error message
+     */
+    static createErrorMessage(error, context) {
+        const messages = {
+            'network-error': `Network error occurred. Please check your internet connection and try again.`,
+            'rate-limit': `Rate limit exceeded for external API. Please wait a few minutes and try again.`,
+            'server-error': `External service is experiencing issues. Please try again later.`,
+            'timeout': `Request timed out. Please check your connection and try again.`,
+            'unknown': `An unexpected error occurred: ${error.message}`
+        };
+        const baseMessage = messages[context.errorType];
+        if (context.attempt >= context.maxRetries) {
+            return `${baseMessage}\n\nFailed after ${context.attempt} attempts.`;
+        }
+        return baseMessage;
+    }
+    /**
+     * Handle rate limit error
+     *
+     * Detects rate limit from error and calculates wait time.
+     *
+     * @param error - Error that may contain rate limit info
+     * @returns Wait time in seconds (null if not rate limit)
+     */
+    static detectRateLimitWait(error) {
+        const message = error.message;
+        // GitHub rate limit format: "API rate limit exceeded. Retry after 60 seconds"
+        const githubMatch = message.match(/retry after (\d+) seconds/i);
+        if (githubMatch) {
+            return parseInt(githubMatch[1], 10);
+        }
+        // JIRA rate limit (typically in headers, but may be in error message)
+        const jiraMatch = message.match(/retry after (\d+)/i);
+        if (jiraMatch) {
+            return parseInt(jiraMatch[1], 10);
+        }
+        // Generic 429 error - default to 60 seconds
+        if (message.includes('429') || message.toLowerCase().includes('rate limit')) {
+            return 60;
+        }
+        return null;
+    }
+}
+//# sourceMappingURL=retry-handler.js.map