gitforest 0.1.0

package/test/unit/utils/rate-limiter.test.ts

@@ -0,0 +1,256 @@
+/**
+ * Tests for rate limiter utilities
+ */
+import { describe, test, expect } from "bun:test";
+import { Semaphore, RateLimiter, processBatch } from "../../../src/utils/rate-limiter.ts";
+
+describe("Semaphore", () => {
+  test("should limit concurrent operations", async () => {
+    const semaphore = new Semaphore(2);
+    let concurrent = 0;
+    let maxConcurrent = 0;
+
+    const task = async () => {
+      await semaphore.acquire();
+      concurrent++;
+      maxConcurrent = Math.max(maxConcurrent, concurrent);
+      await new Promise(resolve => setTimeout(resolve, 50));
+      concurrent--;
+      semaphore.release();
+    };
+
+    await Promise.all([task(), task(), task(), task()]);
+    
+    expect(maxConcurrent).toBeLessThanOrEqual(2);
+  });
+
+  test("should run function with automatic release", async () => {
+    const semaphore = new Semaphore(1);
+    
+    const result = await semaphore.run(async () => {
+      return "success";
+    });
+    
+    expect(result).toBe("success");
+  });
+
+  test("should release on error", async () => {
+    const semaphore = new Semaphore(1);
+    
+    try {
+      await semaphore.run(async () => {
+        throw new Error("test error");
+      });
+    } catch {
+      // Expected
+    }
+    
+    // Should be able to acquire again after error
+    const result = await semaphore.run(async () => "recovered");
+    expect(result).toBe("recovered");
+  });
+});
+
+describe("RateLimiter", () => {
+  test("should enforce minimum delay between operations", async () => {
+    const limiter = new RateLimiter(100);
+    const times: number[] = [];
+    
+    for (let i = 0; i < 3; i++) {
+      await limiter.wait();
+      times.push(Date.now());
+    }
+    
+    // Check delays between operations
+    for (let i = 1; i < times.length; i++) {
+      const delay = times[i]! - times[i-1]!;
+      expect(delay).toBeGreaterThanOrEqual(95); // Allow small timing variance
+    }
+  });
+});
+
+describe("processBatch", () => {
+  test("should process all items", async () => {
+    const items = [1, 2, 3, 4, 5];
+    const results = await processBatch(
+      items,
+      async (n) => n * 2,
+      { concurrency: 2 }
+    );
+    
+    expect(results).toEqual([
+      { success: true, result: 2 },
+      { success: true, result: 4 },
+      { success: true, result: 6 },
+      { success: true, result: 8 },
+      { success: true, result: 10 }
+    ]);
+  });
+
+  test("should call progress callback", async () => {
+    const items = [1, 2, 3];
+    const progressCalls: Array<[number, number]> = [];
+    
+    const results = await processBatch(
+      items,
+      async (n) => n,
+      {
+        concurrency: 1,
+        onProgress: (completed, total) => {
+          progressCalls.push([completed, total]);
+        }
+      }
+    );
+    
+    expect(progressCalls).toEqual([[1, 3], [2, 3], [3, 3]]);
+    expect(results).toHaveLength(3);
+    expect(results.every(r => r.success)).toBe(true);
+  });
+
+  test("should handle errors with onError callback", async () => {
+    const items = [1, 2, 3];
+    const errors: Error[] = [];
+    
+    const results = await processBatch(
+      items,
+      async (n) => {
+        if (n === 2) throw new Error("test error");
+        return n;
+      },
+      {
+        concurrency: 1,
+        onError: (err, _item) => {
+          errors.push(err);
+          return true; // Continue processing
+        }
+      }
+    );
+    
+    expect(results).toEqual([
+      { success: true, result: 1 },
+      { success: false, error: new Error("test error") },
+      { success: true, result: 3 }
+    ]);
+    expect(errors).toHaveLength(1);
+  });
+
+  test("should respect concurrency limit", async () => {
+    let concurrent = 0;
+    let maxConcurrent = 0;
+    
+    const results = await processBatch(
+      [1, 2, 3, 4, 5, 6],
+      async () => {
+        concurrent++;
+        maxConcurrent = Math.max(maxConcurrent, concurrent);
+        await new Promise(resolve => setTimeout(resolve, 20));
+        concurrent--;
+      },
+      { concurrency: 3 }
+    );
+    
+    expect(maxConcurrent).toBeLessThanOrEqual(3);
+    expect(results).toHaveLength(6);
+    expect(results.every(r => r.success)).toBe(true);
+  });
+
+  test("should stop processing when onError returns false", async () => {
+    const items = [1, 2, 3, 4, 5];
+    const processed: number[] = [];
+    let errorThrown = false;
+    
+    try {
+      await processBatch(
+        items,
+        async (n) => {
+          processed.push(n);
+          if (n === 3) {
+            errorThrown = true;
+            throw new Error("stop error");
+          }
+          return n;
+        },
+        {
+          concurrency: 1,
+          onError: (err, _item) => {
+            return false; // Stop processing
+          }
+        }
+      );
+      // Should not reach here
+      throw new Error("Expected processBatch to throw");
+    } catch (error) {
+      expect((error as Error).message).toBe("stop error");
+      // With concurrency 1, items are processed sequentially
+      // So we should have processed items 1, 2, and 3 before stopping
+      expect(errorThrown).toBe(true);
+      expect(processed).toContain(1);
+      expect(processed).toContain(2);
+      expect(processed).toContain(3);
+      // Due to Promise.all creating all promises upfront, some later items
+      // might have started processing before the error was thrown
+    }
+  });
+
+  test("should capture error details in failed results", async () => {
+    const items = [1, 2, 3];
+    const customError = new Error("custom error message");
+    
+    const results = await processBatch(
+      items,
+      async (n) => {
+        if (n === 2) throw customError;
+        return n * 10;
+      },
+      {
+        concurrency: 1,
+        onError: (err, item) => {
+          expect(err).toBe(customError);
+          expect(item).toBe(2);
+          return true; // Continue processing
+        }
+      }
+    );
+    
+    expect(results).toHaveLength(3);
+    expect(results[0]).toEqual({ success: true, result: 10 });
+    expect(results[1]).toEqual({ success: false, error: customError });
+    expect(results[2]).toEqual({ success: true, result: 30 });
+  });
+
+  test("should handle multiple errors with continue", async () => {
+    const items = [1, 2, 3, 4, 5];
+    const errorItems = new Set([2, 4]);
+    
+    const results = await processBatch(
+      items,
+      async (n) => {
+        if (errorItems.has(n)) {
+          throw new Error(`Error for item ${n}`);
+        }
+        return n * 2;
+      },
+      {
+        concurrency: 2,
+        onError: (err, _item) => {
+          return true; // Continue on all errors
+        }
+      }
+    );
+    
+    expect(results).toHaveLength(5);
+    expect(results.filter(r => r.success)).toHaveLength(3);
+    expect(results.filter(r => !r.success)).toHaveLength(2);
+    
+    // Check successful results
+    expect(results[0]).toEqual({ success: true, result: 2 });
+    expect(results[2]).toEqual({ success: true, result: 6 });
+    expect(results[4]).toEqual({ success: true, result: 10 });
+    
+    // Check failed results
+    expect(results[1]?.success).toBe(false);
+    expect(results[1]?.error?.message).toBe("Error for item 2");
+    expect(results[3]?.success).toBe(false);
+    expect(results[3]?.error?.message).toBe("Error for item 4");
+  });
+});

package/test/unit/utils/retry.test.ts

@@ -0,0 +1,165 @@
+import { describe, test, expect } from "bun:test";
+import { withRetry, RetryError, shouldRetryGitHubError } from "../../../src/utils/retry";
+
+describe("retry utilities", () => {
+  describe("withRetry", () => {
+    test("should succeed on first attempt", async () => {
+      const fn = () => Promise.resolve("success");
+      const result = await withRetry(fn);
+      expect(result).toBe("success");
+    });
+
+    test("should retry on failure and eventually succeed", async () => {
+      let attempts = 0;
+      const fn = () => {
+        attempts++;
+        if (attempts < 3) {
+          return Promise.reject(new Error("temporary error"));
+        }
+        return Promise.resolve("success");
+      };
+
+      const result = await withRetry(fn, { maxAttempts: 3 });
+      expect(result).toBe("success");
+      expect(attempts).toBe(3);
+    });
+
+    test("should throw RetryError after max attempts", async () => {
+      const fn = () => Promise.reject(new Error("persistent error"));
+      
+      try {
+        await withRetry(fn, { maxAttempts: 3 });
+        expect(true).toBe(false); // Should not reach here
+      } catch (error) {
+        expect(error).toBeInstanceOf(RetryError);
+        expect((error as RetryError).attempts).toBe(3);
+        expect((error as RetryError).lastError.message).toBe("persistent error");
+      }
+    });
+
+    test("should use exponential backoff", async () => {
+      const delays: number[] = [];
+      let lastTime = Date.now();
+      
+      const fn = () => {
+        const currentTime = Date.now();
+        delays.push(currentTime - lastTime);
+        lastTime = currentTime;
+        return Promise.reject(new Error("error"));
+      };
+
+      try {
+        await withRetry(fn, { 
+          maxAttempts: 4, 
+          initialDelay: 100,
+          backoffFactor: 2,
+          onRetry: () => {
+            // Track delays between retries
+          }
+        });
+      } catch (error) {
+        // Expected to fail
+      }
+
+      // First attempt should be immediate (no delay)
+      expect(delays[0]).toBeLessThan(50);
+      
+      // Subsequent delays should increase exponentially
+      expect(delays[1]).toBeGreaterThan(80); // ~100ms
+      expect(delays[2]).toBeGreaterThan(180); // ~200ms
+      expect(delays[3]).toBeGreaterThan(380); // ~400ms
+    });
+
+    test("should respect maxDelay", async () => {
+      const fn = () => Promise.reject(new Error("error"));
+      const startTime = Date.now();
+
+      try {
+        await withRetry(fn, { 
+          maxAttempts: 3, 
+          initialDelay: 1000,
+          maxDelay: 1500,
+          backoffFactor: 3 // Would result in 3000ms delay without maxDelay
+        });
+      } catch (error) {
+        // Expected to fail
+      }
+
+      const totalTime = Date.now() - startTime;
+      expect(totalTime).toBeLessThan(3000); // Should be faster than 1000 + 3000ms
+    });
+
+    test("should not retry when shouldRetry returns false", async () => {
+      let attempts = 0;
+      const fn = () => {
+        attempts++;
+        return Promise.reject(new Error("do not retry"));
+      };
+
+      const shouldRetry = (error: Error) => error.message !== "do not retry";
+
+      try {
+        await withRetry(fn, { maxAttempts: 3, shouldRetry });
+      } catch (error) {
+        // Expected to fail
+      }
+
+      expect(attempts).toBe(1); // Only one attempt
+    });
+
+    test("should call onRetry callback", async () => {
+      const retryCallbacks: Array<{ error: Error; attempt: number; delay: number }> = [];
+      
+      const fn = () => Promise.reject(new Error("error"));
+      const onRetry = (error: Error, attempt: number, nextDelay: number) => {
+        retryCallbacks.push({ error, attempt, delay: nextDelay });
+      };
+
+      try {
+        await withRetry(fn, { maxAttempts: 3, onRetry });
+      } catch (error) {
+        // Expected to fail
+      }
+
+      expect(retryCallbacks).toHaveLength(2);
+      expect(retryCallbacks[0]?.attempt).toBe(1);
+      expect(retryCallbacks[1]?.attempt).toBe(2);
+      expect(retryCallbacks[0]?.delay).toBe(1000);
+      expect(retryCallbacks[1]?.delay).toBe(2000);
+    });
+  });
+
+  describe("shouldRetryGitHubError", () => {
+    test("should retry rate limit errors", () => {
+      expect(shouldRetryGitHubError(new Error("Rate limit exceeded"), 1)).toBe(true);
+      expect(shouldRetryGitHubError(new Error("API rate limit exceeded"), 1)).toBe(true);
+      expect(shouldRetryGitHubError(new Error("429 Too Many Requests"), 1)).toBe(true);
+    });
+
+    test("should retry server errors", () => {
+      expect(shouldRetryGitHubError(new Error("Internal Server Error 500"), 1)).toBe(true);
+      expect(shouldRetryGitHubError(new Error("502 Bad Gateway"), 1)).toBe(true);
+      expect(shouldRetryGitHubError(new Error("503 Service Unavailable"), 1)).toBe(true);
+      expect(shouldRetryGitHubError(new Error("504 Gateway Timeout"), 1)).toBe(true);
+    });
+
+    test("should retry network errors", () => {
+      expect(shouldRetryGitHubError(new Error("Network error"), 1)).toBe(true);
+      expect(shouldRetryGitHubError(new Error("ECONNRESET"), 1)).toBe(true);
+      expect(shouldRetryGitHubError(new Error("ETIMEDOUT"), 1)).toBe(true);
+      expect(shouldRetryGitHubError(new Error("fetch failed"), 1)).toBe(true);
+    });
+
+    test("should not retry client errors", () => {
+      expect(shouldRetryGitHubError(new Error("401 Unauthorized"), 1)).toBe(false);
+      expect(shouldRetryGitHubError(new Error("403 Forbidden"), 1)).toBe(false);
+      expect(shouldRetryGitHubError(new Error("404 Not Found"), 1)).toBe(false);
+      expect(shouldRetryGitHubError(new Error("422 Unprocessable Entity"), 1)).toBe(false);
+    });
+
+    test("should retry other errors by default", () => {
+      expect(shouldRetryGitHubError(new Error("Unknown error"), 1)).toBe(true);
+      expect(shouldRetryGitHubError(new Error("Some random error"), 1)).toBe(true);
+    });
+  });
+});

package/test/unit/utils/strip-ansi.ts

@@ -0,0 +1,13 @@
+/**
+ * Strip ANSI escape codes from a string
+ * Used for comparing ink component output in tests
+ *
+ * This is a fallback utility if NO_COLOR environment variable doesn't work.
+ * The preload.ts script sets NO_COLOR=1, but some libraries may ignore it.
+ */
+export function stripAnsi(str: string | undefined): string {
+  if (!str) return "";
+  // Match ANSI escape sequences: ESC[ followed by params and command
+  const ansiPattern = /\u001b\[[0-9;]*[a-zA-Z]/g;
+  return str.replace(ansiPattern, "");
+}

package/test/unit/utils/timeout.test.ts

@@ -0,0 +1,93 @@
+/**
+ * Tests for timeout utility
+ */
+
+import { describe, test, expect } from "bun:test";
+import { withTimeout, createTimeoutController, TimeoutError } from "../../../src/utils/timeout.ts";
+
+describe("withTimeout", () => {
+  test("should resolve when promise completes before timeout", async () => {
+    const promise = Promise.resolve("success");
+    const result = await withTimeout(promise, 1000, "test operation");
+    expect(result).toBe("success");
+  });
+
+  test("should reject with TimeoutError when promise takes too long", async () => {
+    const promise = new Promise((resolve) => setTimeout(() => resolve("too late"), 2000));
+    
+    await expect(
+      withTimeout(promise, 100, "slow operation")
+    ).rejects.toThrow(TimeoutError);
+  });
+
+  test("should include operation name in timeout error", async () => {
+    const promise = new Promise((resolve) => setTimeout(() => resolve("too late"), 2000));
+    
+    try {
+      await withTimeout(promise, 100, "git clone");
+    } catch (error) {
+      expect(error).toBeInstanceOf(TimeoutError);
+      expect((error as TimeoutError).operation).toBe("git clone");
+      expect((error as Error).message).toContain("git clone");
+      expect((error as Error).message).toContain("100ms");
+    }
+  });
+
+  test("should handle already resolved promises", async () => {
+    const result = await withTimeout(Promise.resolve("immediate"), 1000, "test");
+    expect(result).toBe("immediate");
+  });
+
+  test("should handle already rejected promises", async () => {
+    const error = new Error("test error");
+    await expect(
+      withTimeout(Promise.reject(error), 1000, "test")
+    ).rejects.toThrow("test error");
+  });
+});
+
+describe("createTimeoutController", () => {
+  test("should abort after timeout", async () => {
+    const controller = createTimeoutController(100, "test operation");
+    
+    expect(controller.signal.aborted).toBe(false);
+    
+    await new Promise(resolve => setTimeout(resolve, 150));
+    
+    expect(controller.signal.aborted).toBe(true);
+  });
+
+  test("should not abort before timeout", async () => {
+    const controller = createTimeoutController(1000, "test operation");
+    
+    expect(controller.signal.aborted).toBe(false);
+    
+    await new Promise(resolve => setTimeout(resolve, 100));
+    
+    expect(controller.signal.aborted).toBe(false);
+  });
+
+  test("should include timeout error in abort reason", async () => {
+    const controller = createTimeoutController(100, "test operation");
+    
+    await new Promise(resolve => setTimeout(resolve, 150));
+    
+    expect(controller.signal.reason).toBeInstanceOf(TimeoutError);
+    expect((controller.signal.reason as TimeoutError).operation).toBe("test operation");
+  });
+
+  test("should clean up timer when manually aborted", async () => {
+    const controller = createTimeoutController(1000, "test operation");
+    
+    // Manually abort
+    controller.abort();
+    
+    expect(controller.signal.aborted).toBe(true);
+    
+    // Wait past the original timeout
+    await new Promise(resolve => setTimeout(resolve, 1100));
+    
+    // Should still be aborted (no double abort)
+    expect(controller.signal.aborted).toBe(true);
+  });
+});

package/tsconfig.json

@@ -0,0 +1,29 @@
+{
+  "compilerOptions": {
+    // Environment setup & latest features
+    "lib": ["ESNext"],
+    "target": "ESNext",
+    "module": "Preserve",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+    "allowJs": true,
+
+    // Bundler mode
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+
+    // Best practices
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+
+    // Some stricter flags (disabled by default)
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noPropertyAccessFromIndexSignature": false
+  }
+}