claude-flow-novice 2.15.3 → 2.15.4

package/dist/lib/retry.js

@@ -0,0 +1,262 @@
+/**
+ * Retry and Backoff Utilities
+ *
+ * Provides retry logic with exponential backoff for transient failures.
+ * Part of Task 0.5: Implementation Tooling & Utilities (Foundation)
+ *
+ * Usage:
+ *   const result = await withRetry(
+ *     async () => fetchData(),
+ *     { maxAttempts: 3, baseDelayMs: 1000, exponential: true }
+ *   );
+ */ import { createRetryExhaustedError, isRetryableError } from './errors.js';
+import { createLogger } from './logging.js';
+const logger = createLogger('retry-utility');
+/**
+ * Default retry options
+ */ const DEFAULT_RETRY_OPTIONS = {
+    maxAttempts: 3,
+    baseDelayMs: 1000,
+    maxDelayMs: 30000,
+    exponential: true,
+    jitter: true
+};
+/**
+ * Execute a function with retry logic
+ *
+ * @param fn - Async function to execute
+ * @param options - Retry options
+ * @returns Result of the function
+ * @throws RetryExhaustedError if all attempts fail
+ */ export async function withRetry(fn, options = {}) {
+    const opts = {
+        ...DEFAULT_RETRY_OPTIONS,
+        ...options
+    };
+    const errors = [];
+    const delays = [];
+    const startTime = Date.now();
+    let attempt = 0;
+    while(attempt < opts.maxAttempts){
+        attempt++;
+        try {
+            logger.debug('Retry attempt', {
+                attempt,
+                maxAttempts: opts.maxAttempts
+            });
+            const result = await fn();
+            // Success!
+            if (attempt > 1) {
+                logger.info('Operation succeeded after retry', {
+                    attempt,
+                    totalAttempts: attempt,
+                    totalTimeMs: Date.now() - startTime
+                });
+            }
+            return result;
+        } catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            errors.push(err);
+            // Check if we should retry
+            const shouldRetry = options.shouldRetry ? options.shouldRetry(err) : isRetryableError(err);
+            if (!shouldRetry) {
+                logger.warn('Error is not retryable', {
+                    error: err.message,
+                    attempt
+                });
+                throw err;
+            }
+            // Check if we have attempts remaining
+            if (attempt >= opts.maxAttempts) {
+                logger.error('Retry attempts exhausted', {
+                    totalAttempts: attempt,
+                    errors: errors.map((e)=>e.message),
+                    totalTimeMs: Date.now() - startTime
+                });
+                throw createRetryExhaustedError(attempt, err);
+            }
+            // Calculate delay for next attempt
+            const delayMs = calculateDelay(attempt, opts);
+            delays.push(delayMs);
+            logger.debug('Retrying after delay', {
+                attempt,
+                delayMs,
+                error: err.message
+            });
+            // Invoke retry callback if provided
+            if (options.onRetry) {
+                options.onRetry(attempt, err, delayMs);
+            }
+            // Wait before next attempt
+            await sleep(delayMs);
+        }
+    }
+    // This should never be reached due to the throw above, but TypeScript needs it
+    throw createRetryExhaustedError(attempt, errors[errors.length - 1]);
+}
+/**
+ * Calculate delay for retry attempt
+ *
+ * @param attempt - Current attempt number (1-based)
+ * @param options - Retry options
+ * @returns Delay in milliseconds
+ */ function calculateDelay(attempt, options) {
+    let delay;
+    if (options.exponential) {
+        // Exponential backoff: baseDelay * 2^(attempt - 1)
+        delay = options.baseDelayMs * Math.pow(2, attempt - 1);
+    } else {
+        // Linear backoff
+        delay = options.baseDelayMs * attempt;
+    }
+    // Cap at max delay
+    delay = Math.min(delay, options.maxDelayMs);
+    // Add jitter to prevent thundering herd
+    if (options.jitter) {
+        const jitterFactor = 0.1; // +/- 10%
+        const jitterRange = delay * jitterFactor;
+        const jitter = (Math.random() * 2 - 1) * jitterRange;
+        delay = Math.max(0, delay + jitter);
+    }
+    return Math.floor(delay);
+}
+/**
+ * Sleep for specified duration
+ *
+ * @param ms - Duration in milliseconds
+ * @returns Promise that resolves after duration
+ */ export function sleep(ms) {
+    return new Promise((resolve)=>setTimeout(resolve, ms));
+}
+/**
+ * Execute a function with retry and collect statistics
+ *
+ * @param fn - Async function to execute
+ * @param options - Retry options
+ * @returns Object with result and statistics
+ */ export async function withRetryStats(fn, options = {}) {
+    const opts = {
+        ...DEFAULT_RETRY_OPTIONS,
+        ...options
+    };
+    const errors = [];
+    const delays = [];
+    const startTime = Date.now();
+    let attempt = 0;
+    let succeeded = false;
+    let result;
+    const customOnRetry = (attemptNum, error, delayMs)=>{
+        errors.push(error);
+        delays.push(delayMs);
+        if (options.onRetry) {
+            options.onRetry(attemptNum, error, delayMs);
+        }
+    };
+    try {
+        result = await withRetry(fn, {
+            ...options,
+            onRetry: customOnRetry
+        });
+        succeeded = true;
+        attempt = errors.length + 1;
+    } catch (error) {
+        attempt = errors.length + 1;
+        throw error;
+    } finally{
+        const totalTimeMs = Date.now() - startTime;
+        if (!succeeded) {
+            logger.info('Retry statistics (failed)', {
+                totalAttempts: attempt,
+                succeeded,
+                totalTimeMs,
+                errorCount: errors.length
+            });
+        }
+    }
+    const stats = {
+        totalAttempts: attempt,
+        succeeded,
+        totalTimeMs: Date.now() - startTime,
+        delays,
+        errors
+    };
+    return {
+        result: result,
+        stats
+    };
+}
+/**
+ * Retry a function with linear backoff
+ *
+ * @param fn - Async function to execute
+ * @param maxAttempts - Maximum number of attempts
+ * @param delayMs - Delay between attempts in milliseconds
+ * @returns Result of the function
+ */ export async function withLinearRetry(fn, maxAttempts = 3, delayMs = 1000) {
+    return withRetry(fn, {
+        maxAttempts,
+        baseDelayMs: delayMs,
+        exponential: false,
+        jitter: false
+    });
+}
+/**
+ * Retry a function with exponential backoff
+ *
+ * @param fn - Async function to execute
+ * @param maxAttempts - Maximum number of attempts
+ * @param baseDelayMs - Base delay in milliseconds
+ * @returns Result of the function
+ */ export async function withExponentialRetry(fn, maxAttempts = 3, baseDelayMs = 1000) {
+    return withRetry(fn, {
+        maxAttempts,
+        baseDelayMs,
+        exponential: true,
+        jitter: true
+    });
+}
+/**
+ * Create a retryable version of an async function
+ *
+ * @param fn - Async function to make retryable
+ * @param options - Retry options
+ * @returns Retryable function
+ */ export function retryable(fn, options = {}) {
+    return async (...args)=>{
+        return withRetry(()=>fn(...args), options);
+    };
+}
+/**
+ * Retry an operation until a condition is met
+ *
+ * @param fn - Async function to execute
+ * @param condition - Condition function (returns true to stop retrying)
+ * @param options - Retry options
+ * @returns Result when condition is met
+ * @throws RetryExhaustedError if max attempts reached
+ */ export async function retryUntil(fn, condition, options = {}) {
+    const opts = {
+        ...DEFAULT_RETRY_OPTIONS,
+        ...options
+    };
+    let attempt = 0;
+    while(attempt < opts.maxAttempts){
+        attempt++;
+        const result = await fn();
+        if (condition(result)) {
+            return result;
+        }
+        if (attempt >= opts.maxAttempts) {
+            throw createRetryExhaustedError(attempt);
+        }
+        const delayMs = calculateDelay(attempt, opts);
+        logger.debug('Condition not met, retrying', {
+            attempt,
+            delayMs
+        });
+        await sleep(delayMs);
+    }
+    throw createRetryExhaustedError(attempt);
+}
+
+//# sourceMappingURL=retry.js.map

package/dist/lib/retry.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/lib/retry.ts"],"sourcesContent":["/**\r\n * Retry and Backoff Utilities\r\n *\r\n * Provides retry logic with exponential backoff for transient failures.\r\n * Part of Task 0.5: Implementation Tooling & Utilities (Foundation)\r\n *\r\n * Usage:\r\n *   const result = await withRetry(\r\n *     async () => fetchData(),\r\n *     { maxAttempts: 3, baseDelayMs: 1000, exponential: true }\r\n *   );\r\n */\r\n\r\nimport { createRetryExhaustedError, isRetryableError } from './errors.js';\r\nimport { createLogger } from './logging.js';\r\n\r\nconst logger = createLogger('retry-utility');\r\n\r\n/**\r\n * Retry options\r\n */\r\nexport interface RetryOptions {\r\n  /** Maximum number of retry attempts (default: 3) */\r\n  maxAttempts?: number;\r\n  /** Base delay in milliseconds (default: 1000) */\r\n  baseDelayMs?: number;\r\n  /** Maximum delay in milliseconds (default: 30000) */\r\n  maxDelayMs?: number;\r\n  /** Use exponential backoff (default: true) */\r\n  exponential?: boolean;\r\n  /** Custom function to determine if error is retryable (optional) */\r\n  shouldRetry?: (error: Error) => boolean;\r\n  /** Callback invoked before each retry attempt (optional) */\r\n  onRetry?: (attempt: number, error: Error, delayMs: number) => void;\r\n  /** Add random jitter to delay (default: true) */\r\n  jitter?: boolean;\r\n}\r\n\r\n/**\r\n * Retry statistics\r\n */\r\nexport interface RetryStats {\r\n  /** Total attempts made */\r\n  totalAttempts: number;\r\n  /** Whether operation succeeded */\r\n  succeeded: boolean;\r\n  /** Total time spent (including delays) in milliseconds */\r\n  totalTimeMs: number;\r\n  /** Delays between attempts */\r\n  delays: number[];\r\n  /** Errors encountered */\r\n  errors: Error[];\r\n}\r\n\r\n/**\r\n * Default retry options\r\n */\r\nconst DEFAULT_RETRY_OPTIONS: Required<Omit<RetryOptions, 'shouldRetry' | 'onRetry'>> = {\r\n  maxAttempts: 3,\r\n  baseDelayMs: 1000,\r\n  maxDelayMs: 30000,\r\n  exponential: true,\r\n  jitter: true,\r\n};\r\n\r\n/**\r\n * Execute a function with retry logic\r\n *\r\n * @param fn - Async function to execute\r\n * @param options - Retry options\r\n * @returns Result of the function\r\n * @throws RetryExhaustedError if all attempts fail\r\n */\r\nexport async function withRetry<T>(\r\n  fn: () => Promise<T>,\r\n  options: RetryOptions = {}\r\n): Promise<T> {\r\n  const opts = { ...DEFAULT_RETRY_OPTIONS, ...options };\r\n  const errors: Error[] = [];\r\n  const delays: number[] = [];\r\n  const startTime = Date.now();\r\n\r\n  let attempt = 0;\r\n\r\n  while (attempt < opts.maxAttempts) {\r\n    attempt++;\r\n\r\n    try {\r\n      logger.debug('Retry attempt', { attempt, maxAttempts: opts.maxAttempts });\r\n      const result = await fn();\r\n\r\n      // Success!\r\n      if (attempt > 1) {\r\n        logger.info('Operation succeeded after retry', {\r\n          attempt,\r\n          totalAttempts: attempt,\r\n          totalTimeMs: Date.now() - startTime,\r\n        });\r\n      }\r\n\r\n      return result;\r\n    } catch (error) {\r\n      const err = error instanceof Error ? error : new Error(String(error));\r\n      errors.push(err);\r\n\r\n      // Check if we should retry\r\n      const shouldRetry = options.shouldRetry\r\n        ? options.shouldRetry(err)\r\n        : isRetryableError(err);\r\n\r\n      if (!shouldRetry) {\r\n        logger.warn('Error is not retryable', { error: err.message, attempt });\r\n        throw err;\r\n      }\r\n\r\n      // Check if we have attempts remaining\r\n      if (attempt >= opts.maxAttempts) {\r\n        logger.error('Retry attempts exhausted', {\r\n          totalAttempts: attempt,\r\n          errors: errors.map((e) => e.message),\r\n          totalTimeMs: Date.now() - startTime,\r\n        });\r\n        throw createRetryExhaustedError(attempt, err);\r\n      }\r\n\r\n      // Calculate delay for next attempt\r\n      const delayMs = calculateDelay(attempt, opts);\r\n      delays.push(delayMs);\r\n\r\n      logger.debug('Retrying after delay', {\r\n        attempt,\r\n        delayMs,\r\n        error: err.message,\r\n      });\r\n\r\n      // Invoke retry callback if provided\r\n      if (options.onRetry) {\r\n        options.onRetry(attempt, err, delayMs);\r\n      }\r\n\r\n      // Wait before next attempt\r\n      await sleep(delayMs);\r\n    }\r\n  }\r\n\r\n  // This should never be reached due to the throw above, but TypeScript needs it\r\n  throw createRetryExhaustedError(attempt, errors[errors.length - 1]);\r\n}\r\n\r\n/**\r\n * Calculate delay for retry attempt\r\n *\r\n * @param attempt - Current attempt number (1-based)\r\n * @param options - Retry options\r\n * @returns Delay in milliseconds\r\n */\r\nfunction calculateDelay(attempt: number, options: Required<Omit<RetryOptions, 'shouldRetry' | 'onRetry'>>): number {\r\n  let delay: number;\r\n\r\n  if (options.exponential) {\r\n    // Exponential backoff: baseDelay * 2^(attempt - 1)\r\n    delay = options.baseDelayMs * Math.pow(2, attempt - 1);\r\n  } else {\r\n    // Linear backoff\r\n    delay = options.baseDelayMs * attempt;\r\n  }\r\n\r\n  // Cap at max delay\r\n  delay = Math.min(delay, options.maxDelayMs);\r\n\r\n  // Add jitter to prevent thundering herd\r\n  if (options.jitter) {\r\n    const jitterFactor = 0.1; // +/- 10%\r\n    const jitterRange = delay * jitterFactor;\r\n    const jitter = (Math.random() * 2 - 1) * jitterRange;\r\n    delay = Math.max(0, delay + jitter);\r\n  }\r\n\r\n  return Math.floor(delay);\r\n}\r\n\r\n/**\r\n * Sleep for specified duration\r\n *\r\n * @param ms - Duration in milliseconds\r\n * @returns Promise that resolves after duration\r\n */\r\nexport function sleep(ms: number): Promise<void> {\r\n  return new Promise((resolve) => setTimeout(resolve, ms));\r\n}\r\n\r\n/**\r\n * Execute a function with retry and collect statistics\r\n *\r\n * @param fn - Async function to execute\r\n * @param options - Retry options\r\n * @returns Object with result and statistics\r\n */\r\nexport async function withRetryStats<T>(\r\n  fn: () => Promise<T>,\r\n  options: RetryOptions = {}\r\n): Promise<{ result: T; stats: RetryStats }> {\r\n  const opts = { ...DEFAULT_RETRY_OPTIONS, ...options };\r\n  const errors: Error[] = [];\r\n  const delays: number[] = [];\r\n  const startTime = Date.now();\r\n\r\n  let attempt = 0;\r\n  let succeeded = false;\r\n  let result: T | undefined;\r\n\r\n  const customOnRetry = (attemptNum: number, error: Error, delayMs: number) => {\r\n    errors.push(error);\r\n    delays.push(delayMs);\r\n    if (options.onRetry) {\r\n      options.onRetry(attemptNum, error, delayMs);\r\n    }\r\n  };\r\n\r\n  try {\r\n    result = await withRetry(fn, { ...options, onRetry: customOnRetry });\r\n    succeeded = true;\r\n    attempt = errors.length + 1;\r\n  } catch (error) {\r\n    attempt = errors.length + 1;\r\n    throw error;\r\n  } finally {\r\n    const totalTimeMs = Date.now() - startTime;\r\n\r\n    if (!succeeded) {\r\n      logger.info('Retry statistics (failed)', {\r\n        totalAttempts: attempt,\r\n        succeeded,\r\n        totalTimeMs,\r\n        errorCount: errors.length,\r\n      });\r\n    }\r\n  }\r\n\r\n  const stats: RetryStats = {\r\n    totalAttempts: attempt,\r\n    succeeded,\r\n    totalTimeMs: Date.now() - startTime,\r\n    delays,\r\n    errors,\r\n  };\r\n\r\n  return { result: result as T, stats };\r\n}\r\n\r\n/**\r\n * Retry a function with linear backoff\r\n *\r\n * @param fn - Async function to execute\r\n * @param maxAttempts - Maximum number of attempts\r\n * @param delayMs - Delay between attempts in milliseconds\r\n * @returns Result of the function\r\n */\r\nexport async function withLinearRetry<T>(\r\n  fn: () => Promise<T>,\r\n  maxAttempts: number = 3,\r\n  delayMs: number = 1000\r\n): Promise<T> {\r\n  return withRetry(fn, {\r\n    maxAttempts,\r\n    baseDelayMs: delayMs,\r\n    exponential: false,\r\n    jitter: false,\r\n  });\r\n}\r\n\r\n/**\r\n * Retry a function with exponential backoff\r\n *\r\n * @param fn - Async function to execute\r\n * @param maxAttempts - Maximum number of attempts\r\n * @param baseDelayMs - Base delay in milliseconds\r\n * @returns Result of the function\r\n */\r\nexport async function withExponentialRetry<T>(\r\n  fn: () => Promise<T>,\r\n  maxAttempts: number = 3,\r\n  baseDelayMs: number = 1000\r\n): Promise<T> {\r\n  return withRetry(fn, {\r\n    maxAttempts,\r\n    baseDelayMs,\r\n    exponential: true,\r\n    jitter: true,\r\n  });\r\n}\r\n\r\n/**\r\n * Create a retryable version of an async function\r\n *\r\n * @param fn - Async function to make retryable\r\n * @param options - Retry options\r\n * @returns Retryable function\r\n */\r\nexport function retryable<TArgs extends any[], TResult>(\r\n  fn: (...args: TArgs) => Promise<TResult>,\r\n  options: RetryOptions = {}\r\n): (...args: TArgs) => Promise<TResult> {\r\n  return async (...args: TArgs): Promise<TResult> => {\r\n    return withRetry(() => fn(...args), options);\r\n  };\r\n}\r\n\r\n/**\r\n * Retry an operation until a condition is met\r\n *\r\n * @param fn - Async function to execute\r\n * @param condition - Condition function (returns true to stop retrying)\r\n * @param options - Retry options\r\n * @returns Result when condition is met\r\n * @throws RetryExhaustedError if max attempts reached\r\n */\r\nexport async function retryUntil<T>(\r\n  fn: () => Promise<T>,\r\n  condition: (result: T) => boolean,\r\n  options: RetryOptions = {}\r\n): Promise<T> {\r\n  const opts = { ...DEFAULT_RETRY_OPTIONS, ...options };\r\n  let attempt = 0;\r\n\r\n  while (attempt < opts.maxAttempts) {\r\n    attempt++;\r\n\r\n    const result = await fn();\r\n\r\n    if (condition(result)) {\r\n      return result;\r\n    }\r\n\r\n    if (attempt >= opts.maxAttempts) {\r\n      throw createRetryExhaustedError(attempt);\r\n    }\r\n\r\n    const delayMs = calculateDelay(attempt, opts);\r\n    logger.debug('Condition not met, retrying', { attempt, delayMs });\r\n    await sleep(delayMs);\r\n  }\r\n\r\n  throw createRetryExhaustedError(attempt);\r\n}\r\n"],"names":["createRetryExhaustedError","isRetryableError","createLogger","logger","DEFAULT_RETRY_OPTIONS","maxAttempts","baseDelayMs","maxDelayMs","exponential","jitter","withRetry","fn","options","opts","errors","delays","startTime","Date","now","attempt","debug","result","info","totalAttempts","totalTimeMs","error","err","Error","String","push","shouldRetry","warn","message","map","e","delayMs","calculateDelay","onRetry","sleep","length","delay","Math","pow","min","jitterFactor","jitterRange","random","max","floor","ms","Promise","resolve","setTimeout","withRetryStats","succeeded","customOnRetry","attemptNum","errorCount","stats","withLinearRetry","withExponentialRetry","retryable","args","retryUntil","condition"],"mappings":"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"}