gitforest 0.1.0 → 1.0.0

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

@@ -1,256 +0,0 @@
-/**
- * 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

@@ -1,165 +0,0 @@
-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

@@ -1,13 +0,0 @@
-/**
- * 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

@@ -1,93 +0,0 @@
-/**
- * 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

@@ -1,29 +0,0 @@
-{
-  "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
-  }
-}