Implement Phase 5: Rate limiting and retry logic

- Add token bucket rate limiter with configurable refill
- Implement multi-endpoint rate limiting
- Create retry utility with exponential backoff
- Add retryable error detection (rate limit, network, server errors)
- All tests passing

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <[e-mail]>

src/utils/rate-limit.ts

···
+import { logger } from "../logger/index.js";
+
+export interface RateLimiterConfig {
+  maxTokens: number;
+  refillRate: number;
+  refillInterval: number;
+}
+
+export class RateLimiter {
+  private tokens: number;
+  private lastRefill: number;
+  private config: RateLimiterConfig;
+
+  constructor(config: RateLimiterConfig) {
+    this.config = config;
+    this.tokens = config.maxTokens;
+    this.lastRefill = Date.now();
+  }
+
+  private refill(): void {
+    const now = Date.now();
+    const elapsed = now - this.lastRefill;
+    const intervals = Math.floor(elapsed / this.config.refillInterval);
+
+    if (intervals > 0) {
+      this.tokens = Math.min(
+        this.config.maxTokens,
+        this.tokens + intervals * this.config.refillRate
+      );
+      this.lastRefill = now;
+    }
+  }
+
+  async acquire(tokens: number = 1): Promise<void> {
+    while (true) {
+      this.refill();
+
+      if (this.tokens >= tokens) {
+        this.tokens -= tokens;
+        return;
+      }
+
+      const waitTime = this.config.refillInterval;
+      logger.debug(
+        { tokens, available: this.tokens, waitTime },
+        "Rate limit reached, waiting"
+      );
+
+      await new Promise((resolve) => setTimeout(resolve, waitTime));
+    }
+  }
+
+  getAvailableTokens(): number {
+    this.refill();
+    return this.tokens;
+  }
+
+  reset(): void {
+    this.tokens = this.config.maxTokens;
+    this.lastRefill = Date.now();
+  }
+}
+
+export class MultiRateLimiter {
+  private limiters: Map<string, RateLimiter> = new Map();
+
+  constructor(
+    private defaultConfig: RateLimiterConfig
+  ) {}
+
+  setLimiter(key: string, config: RateLimiterConfig): void {
+    this.limiters.set(key, new RateLimiter(config));
+  }
+
+  async acquire(key: string, tokens: number = 1): Promise<void> {
+    let limiter = this.limiters.get(key);
+    if (!limiter) {
+      limiter = new RateLimiter(this.defaultConfig);
+      this.limiters.set(key, limiter);
+    }
+    await limiter.acquire(tokens);
+  }
+
+  reset(key?: string): void {
+    if (key) {
+      this.limiters.get(key)?.reset();
+    } else {
+      for (const limiter of this.limiters.values()) {
+        limiter.reset();
+      }
+    }
+  }
+}

src/utils/retry.ts

···
+import { logger } from "../logger/index.js";
+
+export interface RetryConfig {
+  maxAttempts: number;
+  initialDelay: number;
+  maxDelay: number;
+  backoffMultiplier: number;
+  retryableErrors?: ((error: any) => boolean)[];
+}
+
+export class RetryError extends Error {
+  constructor(
+    message: string,
+    public attempts: number,
+    public lastError: Error
+  ) {
+    super(message);
+    this.name = "RetryError";
+  }
+}
+
+export async function withRetry<T>(
+  fn: () => Promise<T>,
+  config: Partial<RetryConfig> = {}
+): Promise<T> {
+  const {
+    maxAttempts = 3,
+    initialDelay = 1000,
+    maxDelay = 30000,
+    backoffMultiplier = 2,
+    retryableErrors = [(error) => true],
+  } = config;
+
+  let lastError: Error;
+  let delay = initialDelay;
+
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+
+      const isRetryable = retryableErrors.some((check) => check(lastError));
+
+      if (!isRetryable || attempt >= maxAttempts) {
+        throw new RetryError(
+          `Operation failed after ${attempt} attempts`,
+          attempt,
+          lastError
+        );
+      }
+
+      logger.warn(
+        {
+          attempt,
+          maxAttempts,
+          delay,
+          error: lastError.message,
+        },
+        "Retrying after error"
+      );
+
+      await new Promise((resolve) => setTimeout(resolve, delay));
+      delay = Math.min(delay * backoffMultiplier, maxDelay);
+    }
+  }
+
+  throw new RetryError(
+    `Operation failed after ${maxAttempts} attempts`,
+    maxAttempts,
+    lastError!
+  );
+}
+
+export function isRateLimitError(error: any): boolean {
+  return (
+    error?.status === 429 ||
+    error?.message?.toLowerCase().includes("rate limit") ||
+    error?.message?.toLowerCase().includes("too many requests")
+  );
+}
+
+export function isNetworkError(error: any): boolean {
+  return (
+    error?.code === "ECONNRESET" ||
+    error?.code === "ENOTFOUND" ||
+    error?.code === "ETIMEDOUT" ||
+    error?.message?.toLowerCase().includes("network") ||
+    error?.message?.toLowerCase().includes("timeout")
+  );
+}
+
+export function isServerError(error: any): boolean {
+  return error?.status >= 500 && error?.status < 600;
+}