gitforest 0.1.0

package/src/utils/timeout.ts

@@ -0,0 +1,56 @@
+/**
+ * Timeout utility for wrapping promises with timeout protection
+ */
+
+export class TimeoutError extends Error {
+  constructor(public operation: string, public timeoutMs: number) {
+    super(`Operation '${operation}' timed out after ${timeoutMs}ms`);
+    this.name = "TimeoutError";
+  }
+}
+
+/**
+ * Wraps a promise with a timeout
+ * @param promise The promise to wrap
+ * @param timeoutMs Timeout in milliseconds
+ * @param operation Name of the operation for error messages
+ * @returns The result of the promise
+ * @throws TimeoutError if the operation times out
+ */
+export async function withTimeout<T>(
+  promise: Promise<T>,
+  timeoutMs: number,
+  operation: string
+): Promise<T> {
+  const timeoutPromise = new Promise<never>((_, reject) => {
+    const timer = setTimeout(() => {
+      reject(new TimeoutError(operation, timeoutMs));
+    }, timeoutMs);
+
+    // Clean up the timer when the promise settles
+    promise.finally(() => clearTimeout(timer)).catch(() => {});
+  });
+
+  return Promise.race([promise, timeoutPromise]);
+}
+
+/**
+ * Creates a timeout controller that can be used with AbortController
+ * @param timeoutMs Timeout in milliseconds
+ * @param operation Name of the operation for error messages
+ * @returns AbortController that aborts after timeout
+ */
+export function createTimeoutController(timeoutMs: number, operation: string): AbortController {
+  const controller = new AbortController();
+  
+  const timeoutId = setTimeout(() => {
+    controller.abort(new TimeoutError(operation, timeoutMs));
+  }, timeoutMs);
+
+  // Clean up if aborted manually
+  controller.signal.addEventListener('abort', () => {
+    clearTimeout(timeoutId);
+  });
+
+  return controller;
+}

package/test/integration/app.isolated.tsx

@@ -0,0 +1,240 @@
+/**
+ * Integration tests for the main App component
+ */
+
+import { describe, test, expect, beforeEach, mock } from "bun:test";
+import { render } from "ink-testing-library";
+import { App } from "../../src/app.tsx";
+import { createMockConfig } from "../unit/mocks/config.ts";
+import { createMockUnifiedRepo } from "../unit/mocks/unified.ts";
+// Import the real utility functions to use in mocks - these don't need mocking
+import { sortProjects as realSortProjects, filterProjects as realFilterProjects } from "../../src/utils/project-utils.ts";
+
+// Mock all external dependencies
+const mockLoadUnifiedRepos = mock(() => {});
+const mockRefreshGitHub = mock(() => {});
+const mockCloneRepo = mock(() => {});
+const mockBatchClone = mock(() => {});
+const mockBackgroundRefresh = mock(() => {});
+const mockUseKeyBindings = mock(() => {});
+const mockUseBackgroundFetch = mock(() => {});
+const mockScanWithCache = mock(() => Promise.resolve([]));
+const mockFetchGitHubReposWithCache = mock(() => Promise.resolve({ repos: [], error: null }));
+const mockLoadGitHubReposFromCache = mock(() => Promise.resolve([]));
+const mockCreateUnifiedView = mock(() => []);
+const mockCloneGitHubRepo = mock(() => Promise.resolve({ success: true }));
+
+mock.module("../../src/hooks/useUnifiedRepos.ts", () => ({
+  useUnifiedRepos: mock(() => ({
+    loadUnifiedRepos: mockLoadUnifiedRepos,
+    refreshGitHub: mockRefreshGitHub,
+    cloneRepo: mockCloneRepo,
+    batchClone: mockBatchClone,
+    backgroundRefresh: mockBackgroundRefresh,
+  })),
+}));
+
+mock.module("../../src/hooks/useKeyBindings.ts", () => ({
+  useKeyBindings: mockUseKeyBindings,
+}));
+
+mock.module("../../src/hooks/useBackgroundFetch.ts", () => ({
+  useBackgroundFetch: mockUseBackgroundFetch,
+}));
+
+mock.module("../../src/scanner/index.ts", () => ({
+  scanWithCache: mockScanWithCache,
+  // Use real implementations for utility functions to avoid polluting other tests
+  sortProjects: realSortProjects,
+  filterProjects: realFilterProjects,
+}));
+
+mock.module("../../src/github/cache.ts", () => ({
+  fetchGitHubReposWithCache: mockFetchGitHubReposWithCache,
+  loadGitHubReposFromCache: mockLoadGitHubReposFromCache,
+}));
+
+mock.module("../../src/github/unified.ts", () => ({
+  createUnifiedView: mockCreateUnifiedView,
+  cloneGitHubRepo: mockCloneGitHubRepo,
+}));
+
+describe("App Integration", () => {
+  let mockConfig: any;
+
+  beforeEach(() => {
+    // Reset all mocks
+    mockLoadUnifiedRepos.mockReset();
+    mockUseKeyBindings.mockReset();
+    mockUseBackgroundFetch.mockReset();
+
+    // Create mock config
+    mockConfig = createMockConfig({
+      directories: [{ path: "/test/projects", maxDepth: 3 }],
+    });
+  });
+
+  describe("App rendering", () => {
+    test("renders without crashing", () => {
+      const { unmount } = render(<App config={mockConfig} />);
+      
+      // Should render without throwing
+      expect(() => unmount()).not.toThrow();
+    });
+
+    test("StoreProvider wraps content correctly", () => {
+      const { lastFrame } = render(<App config={mockConfig} />);
+      
+      // Should contain the app structure
+      const frame = lastFrame();
+      expect(frame).toBeTruthy();
+      expect(frame).toContain("gitforest");
+    });
+
+    test("Layout component receives correct props", () => {
+      render(<App config={mockConfig} />);
+      
+      // The Layout component should be rendered with the correct props
+      // We can verify this by checking the hooks were called with expected parameters
+      expect(mockUseKeyBindings).toHaveBeenCalledWith({
+        config: mockConfig,
+        onRefresh: mockLoadUnifiedRepos,
+      });
+    });
+
+    test("initial loading state is shown", () => {
+      const { lastFrame } = render(<App config={mockConfig} />);
+      
+      // Should show loading state initially
+      const frame = lastFrame();
+      expect(frame).toContain("Scanning projects");
+    });
+  });
+
+  describe("App initialization", () => {
+    test("projects are loaded on mount", () => {
+      render(<App config={mockConfig} />);
+      
+      // The App should render and initialize hooks
+      // We verify this by checking the Layout is rendered
+      expect(mockUseKeyBindings).toHaveBeenCalled();
+      expect(mockUseBackgroundFetch).toHaveBeenCalled();
+    });
+
+    test("keyboard bindings are set up", () => {
+      render(<App config={mockConfig} />);
+      
+      // Should set up key bindings
+      expect(mockUseKeyBindings).toHaveBeenCalledWith({
+        config: mockConfig,
+        onRefresh: mockLoadUnifiedRepos,
+      });
+    });
+
+    test("background fetch is initialized", () => {
+      render(<App config={mockConfig} />);
+      
+      // Should initialize background fetch
+      expect(mockUseBackgroundFetch).toHaveBeenCalledWith(mockConfig, mockLoadUnifiedRepos);
+    });
+  });
+
+  describe("Error handling", () => {
+    test("error state is handled gracefully", () => {
+      // Mock an error during loading
+      const errorMessage = "Failed to load projects";
+      mockLoadUnifiedRepos.mockImplementation(() => {
+        throw new Error(errorMessage);
+      });
+
+      const { lastFrame } = render(<App config={mockConfig} />);
+      
+      // Should handle error without crashing
+      const frame = lastFrame();
+      expect(frame).toBeTruthy();
+    });
+
+    test("handles missing config gracefully", () => {
+      // Test with minimal config (must have at least one directory)
+      const minimalConfig = createMockConfig({
+        directories: [{ path: "/test", maxDepth: 2 }],
+      });
+
+      const { lastFrame } = render(<App config={minimalConfig} />);
+      
+      const frame = lastFrame();
+      expect(frame).toBeTruthy();
+      expect(frame).toContain("gitforest");
+    });
+  });
+
+  describe("Clone functionality", () => {
+    test("batchClone handler is properly configured", () => {
+      const mockBatchCloneResult = mock(() => Promise.resolve({ successful: 2, failed: 0 }));
+      const useUnifiedRepos = require("../../src/hooks/useUnifiedRepos.ts").useUnifiedRepos;
+      useUnifiedRepos.mockReturnValue({
+        loadUnifiedRepos: mockLoadUnifiedRepos,
+        refreshGitHub: mock(() => {}),
+        cloneRepo: mock(() => {}),
+        batchClone: mockBatchCloneResult,
+        backgroundRefresh: mock(() => {}),
+      });
+
+      render(<App config={mockConfig} />);
+
+      // Verify the App renders without issues with the batchClone handler
+      expect(mockBatchCloneResult).toBeDefined();
+    });
+
+    test("handles clone errors gracefully", () => {
+      const mockBatchCloneError = mock(() => Promise.reject(new Error("Clone failed")));
+      const useUnifiedRepos = require("../../src/hooks/useUnifiedRepos.ts").useUnifiedRepos;
+      useUnifiedRepos.mockReturnValue({
+        loadUnifiedRepos: mockLoadUnifiedRepos,
+        refreshGitHub: mock(() => {}),
+        cloneRepo: mock(() => {}),
+        batchClone: mockBatchCloneError,
+        backgroundRefresh: mock(() => {}),
+      });
+
+      const { unmount } = render(<App config={mockConfig} />);
+      
+      // Should not crash even if clone fails
+      expect(() => unmount()).not.toThrow();
+    });
+  });
+
+  describe("State management", () => {
+    test("maintains consistent state during operations", () => {
+      // Mock loading repos
+      mockLoadUnifiedRepos.mockImplementation(() => {
+        // Simulate loading state
+        return Promise.resolve();
+      });
+
+      const { lastFrame } = render(<App config={mockConfig} />);
+      
+      // Should maintain UI consistency
+      const frame = lastFrame();
+      expect(frame).toBeTruthy();
+      expect(frame).toContain("gitforest");
+    });
+  });
+
+  describe("Performance", () => {
+    test("handles large number of repos efficiently", () => {
+      const { lastFrame } = render(<App config={mockConfig} />);
+      
+      // Should render without performance issues
+      const frame = lastFrame();
+      expect(frame).toBeTruthy();
+    });
+
+    test("properly cleans up on unmount", () => {
+      const { unmount } = render(<App config={mockConfig} />);
+      
+      // Should clean up without errors
+      expect(() => unmount()).not.toThrow();
+    });
+  });
+});

package/test/integration/cli-commands.test.ts

@@ -0,0 +1,287 @@
+import { describe, test, expect, beforeAll, afterAll } from "bun:test";
+import { $ } from "bun";
+import { join, resolve } from "path";
+import { tmpdir } from "os";
+import { mkdirSync, writeFileSync, unlinkSync, existsSync } from "fs";
+
+describe("CLI Commands Integration", () => {
+  // Use absolute path for mainPath
+  const mainPath = resolve(import.meta.dir, "../../src/index.tsx");
+  const timeout = 15000; // 15 second timeout for CLI commands
+  let testConfigPath: string;
+
+  beforeAll(async () => {
+    // Create a temporary test config directory
+    const testDir = join(tmpdir(), `gitforest-cli-test-${Date.now()}`);
+    mkdirSync(testDir, { recursive: true });
+
+    // Create gitforest subdirectory for XDG config
+    const gitforestConfigDir = join(testDir, "gitforest");
+    mkdirSync(gitforestConfigDir, { recursive: true });
+
+    // Create a test config file in XDG config location
+    testConfigPath = join(gitforestConfigDir, "config.yaml");
+    writeFileSync(testConfigPath, `
+directories:
+  - path: ${testDir}
+    maxDepth: 1
+display:
+  sortBy: name
+  sortDirection: asc
+`);
+
+    // Set environment variables for testing
+    process.env.TEST_TIMEOUT = String(timeout);
+    process.env.GITTY_IGNORE_GH = "true";
+    // Set config to our test config
+    process.env.XDG_CONFIG_HOME = testDir;
+  });
+
+  afterAll(() => {
+    // Cleanup
+    delete process.env.TEST_TIMEOUT;
+    delete process.env.GITTY_IGNORE_GH;
+    delete process.env.XDG_CONFIG_HOME;
+
+    // Clean up test config file
+    if (testConfigPath && existsSync(testConfigPath)) {
+      unlinkSync(testConfigPath);
+    }
+  });
+
+  describe("help command", () => {
+    test("shows help with --help flag", async () => {
+      const result = await $`timeout 10 bun ${mainPath} --help`.quiet().nothrow();
+      const stdout = result.stdout.toString();
+
+      expect(result.exitCode).toBe(0);
+      expect(stdout).toContain("gitforest");
+      expect(stdout).toContain("Usage");
+      expect(stdout).toContain("Commands");
+    }, { timeout });
+
+    test("shows help with -h flag", async () => {
+      const result = await $`timeout 10 bun ${mainPath} -h`.quiet().nothrow();
+      const stdout = result.stdout.toString();
+
+      expect(result.exitCode).toBe(0);
+      expect(stdout).toContain("gitforest");
+    }, { timeout });
+
+    test("lists available commands in help", async () => {
+      const result = await $`timeout 10 bun ${mainPath} --help`.quiet().nothrow();
+      const stdout = result.stdout.toString();
+
+      expect(stdout).toContain("list");
+      expect(stdout).toContain("status");
+      expect(stdout).toContain("dirty");
+      expect(stdout).toContain("pull");
+      expect(stdout).toContain("push");
+      expect(stdout).toContain("fetch");
+    }, { timeout });
+
+    test("shows GitHub commands in help", async () => {
+      const result = await $`timeout 10 bun ${mainPath} --help`.quiet().nothrow();
+      const stdout = result.stdout.toString();
+
+      expect(stdout).toContain("github");
+      expect(stdout).toContain("GITHUB_TOKEN");
+    }, { timeout });
+
+    test("shows options in help", async () => {
+      const result = await $`timeout 10 bun ${mainPath} --help`.quiet().nothrow();
+      const stdout = result.stdout.toString();
+
+      expect(stdout).toContain("--json");
+      expect(stdout).toContain("--verbose");
+      expect(stdout).toContain("--init");
+    }, { timeout });
+  });
+
+  describe("version flag", () => {
+    test("handles --version flag", async () => {
+      const result = await $`timeout 10 bun ${mainPath} --version`.quiet().nothrow();
+      // Version flag may not be implemented - just verify it doesn't hang
+      // Exit code may be 0 (success) or 1 (not implemented)
+      expect([0, 1]).toContain(result.exitCode);
+    }, { timeout });
+  });
+
+  describe("unknown command handling", () => {
+    test("shows help for unknown commands", async () => {
+      const result = await $`timeout 10 bun ${mainPath} unknowncommand`.quiet().nothrow();
+      const stdout = result.stdout.toString();
+      const stderr = result.stderr.toString();
+      const output = stdout + stderr;
+
+      // Should mention help or show an error message
+      expect(output.length).toBeGreaterThan(0);
+    }, { timeout });
+  });
+
+  describe("command output formats", () => {
+    test("list command accepts --json flag", async () => {
+      const result = await $`timeout 10 bun ${mainPath} list --json`.quiet().nothrow();
+
+      // Should not fail due to flag validation
+      expect(result.exitCode).toBe(0);
+      const stdout = result.stdout.toString();
+      // Should output JSON array
+      expect(stdout).toMatch(/\[[\s\S]*\]/);
+    }, { timeout });
+
+    test("status command accepts --json flag", async () => {
+      const result = await $`timeout 10 bun ${mainPath} status --json`.quiet().nothrow();
+
+      // Should not fail due to flag validation
+      expect(result.exitCode).toBe(0);
+      const stdout = result.stdout.toString();
+      // Should output JSON object
+      expect(stdout).toMatch(/\{[\s\S]*\}/);
+    }, { timeout });
+
+    test("dirty command accepts --json flag", async () => {
+      const result = await $`timeout 10 bun ${mainPath} dirty --json`.quiet().nothrow();
+
+      // Should not fail due to flag validation
+      expect(result.exitCode).toBe(0);
+      const stdout = result.stdout.toString();
+      // Should output JSON array
+      expect(stdout).toMatch(/\[[\s\S]*\]/);
+    }, { timeout });
+  });
+
+  describe("GitHub commands", () => {
+    test("auth command shows token status", async () => {
+      const result = await $`timeout 10 bash -c 'GITHUB_TOKEN= bun ${mainPath} auth'`.quiet().nothrow();
+
+      expect(result.exitCode).toBe(0);
+      const stdout = result.stdout.toString();
+      expect(stdout).toContain("GITHUB_TOKEN not set");
+    }, { timeout });
+
+    test("github command works without GITHUB_TOKEN but shows warning", async () => {
+      const result = await $`timeout 10 bash -c 'GITHUB_TOKEN= bun ${mainPath} github'`.quiet().nothrow();
+
+      expect(result.exitCode).toBe(1);
+      const output = result.stdout.toString() + result.stderr.toString();
+      expect(output).toContain("GitHub authentication required");
+    }, { timeout });
+
+    test("clone command works without GITHUB_TOKEN but shows warning", async () => {
+      const result = await $`timeout 10 bash -c 'GITHUB_TOKEN= bun ${mainPath} clone'`.quiet().nothrow();
+
+      // Clone command succeeds but shows warning when no repos to clone
+      expect(result.exitCode).toBe(1);
+      const output = result.stdout.toString() + result.stderr.toString();
+      expect(output).toContain("GitHub authentication required");
+    }, { timeout });
+  });
+
+  describe("filter functionality", () => {
+    test("commands accept --filter flag", async () => {
+      const commands = ["list", "status", "dirty"];
+
+      for (const cmd of commands) {
+        const result = await $`timeout 10 bun ${mainPath} ${cmd} --filter test`.quiet().nothrow();
+
+        // Should not fail due to flag validation
+        expect(result.exitCode).toBe(0);
+      }
+    }, { timeout });
+
+    test("commands accept -f short flag", async () => {
+      const commands = ["list", "status", "dirty"];
+
+      for (const cmd of commands) {
+        const result = await $`timeout 10 bun ${mainPath} ${cmd} -f test`.quiet().nothrow();
+
+        // Should not fail due to flag validation
+        expect(result.exitCode).toBe(0);
+      }
+    }, { timeout });
+  });
+
+  describe("clone command", () => {
+    test("clone accepts --target flag", async () => {
+      const result = await $`timeout 10 bash -c 'GITHUB_TOKEN= bun ${mainPath} clone --target /tmp'`.quiet().nothrow();
+
+      // Clone command succeeds but shows warning
+      expect(result.exitCode).toBe(1);
+      const output = result.stdout.toString() + result.stderr.toString();
+      expect(output).toContain("GitHub authentication required");
+    }, { timeout });
+
+    test("clone accepts -t short flag", async () => {
+      const result = await $`timeout 10 bash -c 'GITHUB_TOKEN= bun ${mainPath} clone -t /tmp'`.quiet().nothrow();
+
+      // Clone command succeeds but shows warning
+      expect(result.exitCode).toBe(1);
+      const output = result.stdout.toString() + result.stderr.toString();
+      expect(output).toContain("GitHub authentication required");
+    }, { timeout });
+
+    test("clone accepts --https flag", async () => {
+      const result = await $`timeout 10 bash -c 'GITHUB_TOKEN= bun ${mainPath} clone --https'`.quiet().nothrow();
+
+      // Clone command succeeds but shows warning
+      expect(result.exitCode).toBe(1);
+      const output = result.stdout.toString() + result.stderr.toString();
+      expect(output).toContain("GitHub authentication required");
+    }, { timeout });
+  });
+
+  describe("create-repos command", () => {
+    test("create-repos works without GITHUB_TOKEN but shows errors", async () => {
+      const result = await $`timeout 10 bash -c 'GITHUB_TOKEN= bun ${mainPath} create-repos'`.quiet().nothrow();
+
+      expect(result.exitCode).toBe(1);
+      const output = result.stdout.toString() + result.stderr.toString();
+      expect(output).toContain("GitHub authentication required");
+    }, { timeout });
+
+    test("create-repos accepts --public flag", async () => {
+      const result = await $`timeout 10 bash -c 'GITHUB_TOKEN= bun ${mainPath} create-repos --public'`.quiet().nothrow();
+
+      expect(result.exitCode).toBe(1);
+      const output = result.stdout.toString() + result.stderr.toString();
+      expect(output).toContain("GitHub authentication required");
+    }, { timeout });
+  });
+
+  describe("setup command", () => {
+    test("setup works without GITHUB_TOKEN but shows errors", async () => {
+      const result = await $`timeout 10 bash -c 'GITHUB_TOKEN= bun ${mainPath} setup'`.quiet().nothrow();
+
+      expect(result.exitCode).toBe(1);
+      const output = result.stdout.toString() + result.stderr.toString();
+      expect(output).toContain("GitHub authentication required");
+    }, { timeout });
+
+    test("setup accepts --public flag", async () => {
+      const result = await $`timeout 10 bash -c 'GITHUB_TOKEN= bun ${mainPath} setup --public'`.quiet().nothrow();
+
+      expect(result.exitCode).toBe(1);
+      const output = result.stdout.toString() + result.stderr.toString();
+      expect(output).toContain("GitHub authentication required");
+    }, { timeout });
+  });
+
+  describe("archive command", () => {
+    test("archive requires repositories argument", async () => {
+      const result = await $`timeout 10 bash -c 'GITHUB_TOKEN= bun ${mainPath} archive'`.quiet().nothrow();
+
+      expect(result.exitCode).toBe(1);
+      const stderr = result.stderr.toString();
+      expect(stderr).toContain("Please specify repositories to archive");
+    }, { timeout });
+
+    test("archive works without GITHUB_TOKEN but shows errors", async () => {
+      const result = await $`timeout 10 bash -c 'GITHUB_TOKEN= bun ${mainPath} archive repo1 repo2'`.quiet().nothrow();
+
+      expect(result.exitCode).toBe(1);
+      const output = result.stdout.toString() + result.stderr.toString();
+      expect(output).toContain("GitHub authentication required");
+    }, { timeout });
+  });
+});