gitforest 0.1.0 → 1.1.0

package/test/unit/scanner/index.test.ts

@@ -1,1011 +0,0 @@
-import { describe, test, expect, beforeEach, afterEach } from "bun:test";
-import {
-  scanAllDirectories,
-  scanWithCache,
-  clearCache,
-  getCacheStats,
-  sortProjects,
-  filterProjects,
-} from "../../../src/scanner/index.ts";
-import { closeDb, initDb, getDbPath } from "../../../src/db/index.ts";
-import type { Project, GitforestConfig } from "../../../src/types/index.ts";
-import {
-  createTempDir,
-  cleanupTempDir,
-  createMockGitRepo,
-  createMockProject,
-  createMockRepoWithSubmodule,
-} from "../fixtures/setup.ts";
-import { createMockConfig } from "../mocks/config.ts";
-import { mkdir } from "fs/promises";
-import { join } from "path";
-
-function createTestConfig(tempDir: string, overrides?: Partial<GitforestConfig>): GitforestConfig {
-  return createMockConfig({
-    directories: [{ path: tempDir, maxDepth: 2 }],
-    ...overrides,
-  });
-}
-
-describe("scanAllDirectories", () => {
-  let tempDir: string;
-
-  beforeEach(() => {
-    tempDir = createTempDir("scanner-test");
-  });
-
-  afterEach(() => {
-    cleanupTempDir(tempDir);
-  });
-
-  test("finds git repositories", async () => {
-    await createMockGitRepo(tempDir, "repo1");
-    await createMockGitRepo(tempDir, "repo2");
-
-    const config = createTestConfig(tempDir);
-    const projects = await scanAllDirectories(config);
-
-    expect(projects.length).toBeGreaterThanOrEqual(2);
-    const gitProjects = projects.filter((p) => p.type === "git");
-    expect(gitProjects.length).toBeGreaterThanOrEqual(2);
-  });
-
-  test("finds non-git projects with markers", async () => {
-    createMockProject(tempDir, "node-project", "package.json");
-    createMockProject(tempDir, "rust-project", "Cargo.toml");
-
-    const config = createTestConfig(tempDir);
-    const projects = await scanAllDirectories(config);
-
-    const nonGitProjects = projects.filter((p) => p.type === "non-git");
-    expect(nonGitProjects.length).toBeGreaterThanOrEqual(2);
-  });
-
-  test("finds mixed projects", async () => {
-    await createMockGitRepo(tempDir, "git-repo");
-    createMockProject(tempDir, "node-project", "package.json");
-
-    const config = createTestConfig(tempDir);
-    const projects = await scanAllDirectories(config);
-
-    expect(projects.some((p) => p.type === "git")).toBe(true);
-    expect(projects.some((p) => p.type === "non-git")).toBe(true);
-  });
-
-  test("respects maxDepth", async () => {
-    const { mkdirSync } = await import("fs");
-    const { join } = await import("path");
-
-    // Create nested structure
-    const level1 = join(tempDir, "level1");
-    const level2 = join(level1, "level2");
-    const level3 = join(level2, "level3");
-    mkdirSync(level3, { recursive: true });
-
-    await createMockGitRepo(level3, "deep-repo");
-
-    // With maxDepth 2, shouldn't find level3 repo
-    const config = createTestConfig(tempDir, {
-      directories: [{ path: tempDir, maxDepth: 2 }],
-    });
-    const projects = await scanAllDirectories(config);
-
-    const deepRepo = projects.find((p) => p.name === "deep-repo");
-    expect(deepRepo).toBeUndefined();
-  });
-
-  test("respects ignore patterns", async () => {
-    const { mkdirSync } = await import("fs");
-    const { join } = await import("path");
-
-    const nodeModulesDir = join(tempDir, "node_modules");
-    mkdirSync(nodeModulesDir);
-    await createMockGitRepo(nodeModulesDir, "ignored-repo");
-
-    const config = createTestConfig(tempDir);
-    const projects = await scanAllDirectories(config);
-
-    const ignoredProject = projects.find((p) => p.name === "ignored-repo");
-    expect(ignoredProject).toBeUndefined();
-  });
-
-  test("includes git status for git repos", async () => {
-    await createMockGitRepo(tempDir, "repo-with-status", {
-      withChanges: true,
-    });
-
-    const config = createTestConfig(tempDir);
-    const projects = await scanAllDirectories(config);
-
-    const repo = projects.find((p) => p.name === "repo-with-status");
-    expect(repo).toBeDefined();
-    expect(repo?.status).not.toBeNull();
-    expect(repo?.status?.isDirty).toBe(true);
-  });
-
-  test("sets correct project marker for non-git projects", async () => {
-    createMockProject(tempDir, "node-project", "package.json");
-
-    const config = createTestConfig(tempDir);
-    const projects = await scanAllDirectories(config);
-
-    const nodeProject = projects.find((p) => p.name === "node-project");
-    expect(nodeProject?.projectMarker).toBe("package.json");
-  });
-
-  test("generates unique IDs for each project", async () => {
-    await createMockGitRepo(tempDir, "repo1");
-    await createMockGitRepo(tempDir, "repo2");
-
-    const config = createTestConfig(tempDir);
-    const projects = await scanAllDirectories(config);
-
-    const ids = projects.map((p) => p.id);
-    const uniqueIds = new Set(ids);
-    expect(uniqueIds.size).toBe(ids.length);
-  });
-
-  test("sets lastScanned date", async () => {
-    await createMockGitRepo(tempDir, "dated-repo");
-
-    const config = createTestConfig(tempDir);
-    const projects = await scanAllDirectories(config);
-
-    const repo = projects.find((p) => p.name === "dated-repo");
-    expect(repo?.lastScanned).toBeInstanceOf(Date);
-  });
-
-  test("respects showNonGitProjects config when true", async () => {
-    createMockProject(tempDir, "node-project", "package.json");
-    createMockProject(tempDir, "rust-project", "Cargo.toml");
-
-    const config = createTestConfig(tempDir, {
-      display: { showSubmodules: true, showNonGitProjects: true, sortBy: "status", sortDirection: "desc" }
-    });
-    const projects = await scanAllDirectories(config);
-
-    const nonGitProjects = projects.filter((p) => p.type === "non-git");
-    expect(nonGitProjects.length).toBe(2);
-  });
-
-  test("respects showNonGitProjects config when false", async () => {
-    createMockProject(tempDir, "node-project", "package.json");
-    createMockProject(tempDir, "rust-project", "Cargo.toml");
-
-    const config = createTestConfig(tempDir, {
-      display: { showSubmodules: true, showNonGitProjects: false, sortBy: "status", sortDirection: "desc" }
-    });
-    const projects = await scanAllDirectories(config);
-
-    const nonGitProjects = projects.filter((p) => p.type === "non-git");
-    expect(nonGitProjects.length).toBe(0);
-  });
-});
-
-describe("sortProjects", () => {
-  const createMockProjects = (): Project[] => [
-    {
-      id: "1",
-      name: "zebra",
-      path: "/zebra",
-      type: "git",
-      projectMarker: null,
-      status: {
-        isDirty: false,
-        hasUnstagedChanges: false,
-        hasStagedChanges: false,
-        hasUntrackedFiles: false,
-        modifiedCount: 0,
-        stagedCount: 0,
-        untrackedCount: 0,
-        currentBranch: "main",
-        trackingBranch: null,
-        unpushedCommits: 0,
-        unpulledCommits: 0,
-        hasRemote: true,
-        remoteUrl: "https://github.com/test/zebra",
-        lastLocalCommit: new Date("2024-01-01"),
-        lastRemoteActivity: null,
-        hasCommits: true,
-        isAhead: false,
-        isBehind: false,
-        isOutOfSync: false,
-      },
-      submodule: null,
-      lastScanned: new Date(),
-      lastModified: null,
-    },
-    {
-      id: "2",
-      name: "alpha",
-      path: "/alpha",
-      type: "git",
-      projectMarker: null,
-      status: {
-        isDirty: true,
-        hasUnstagedChanges: true,
-        hasStagedChanges: false,
-        hasUntrackedFiles: false,
-        modifiedCount: 2,
-        stagedCount: 0,
-        untrackedCount: 0,
-        currentBranch: "main",
-        trackingBranch: null,
-        unpushedCommits: 3,
-        unpulledCommits: 0,
-        hasRemote: true,
-        remoteUrl: "https://github.com/test/alpha",
-        lastLocalCommit: new Date("2024-06-15"),
-        lastRemoteActivity: null,
-        hasCommits: true,
-        isAhead: true,
-        isBehind: false,
-        isOutOfSync: true,
-      },
-      submodule: null,
-      lastScanned: new Date(),
-      lastModified: null,
-    },
-    {
-      id: "3",
-      name: "middle",
-      path: "/middle",
-      type: "non-git",
-      projectMarker: "package.json",
-      status: null,
-      submodule: null,
-      lastScanned: new Date(),
-      lastModified: null,
-    },
-  ];
-
-  test("sorts by name ascending", () => {
-    const projects = createMockProjects();
-    const sorted = sortProjects(projects, "name", "asc");
-
-    expect(sorted[0]?.name).toBe("alpha");
-    expect(sorted[1]?.name).toBe("middle");
-    expect(sorted[2]?.name).toBe("zebra");
-  });
-
-  test("sorts by name descending", () => {
-    const projects = createMockProjects();
-    const sorted = sortProjects(projects, "name", "desc");
-
-    expect(sorted[0]?.name).toBe("zebra");
-    expect(sorted[1]?.name).toBe("middle");
-    expect(sorted[2]?.name).toBe("alpha");
-  });
-
-  test("sorts by status (dirty first)", () => {
-    const projects = createMockProjects();
-    const sorted = sortProjects(projects, "status", "desc");
-
-    // Dirty projects should come first (higher priority)
-    const dirtyIndex = sorted.findIndex((p) => p.name === "alpha");
-    const cleanIndex = sorted.findIndex((p) => p.name === "zebra");
-    expect(dirtyIndex).toBeLessThan(cleanIndex);
-  });
-
-  test("sorts by lastActivity descending (most recent first)", () => {
-    const projects = createMockProjects();
-    const sorted = sortProjects(projects, "lastActivity", "desc");
-
-    // alpha (2024-06-15) should come before zebra (2024-01-01)
-    const alphaIndex = sorted.findIndex((p) => p.name === "alpha");
-    const zebraIndex = sorted.findIndex((p) => p.name === "zebra");
-    expect(alphaIndex).toBeLessThan(zebraIndex);
-  });
-
-  test("sorts by lastActivity ascending (oldest first)", () => {
-    const projects = createMockProjects();
-    const sorted = sortProjects(projects, "lastActivity", "asc");
-
-    // zebra (2024-01-01) should come before alpha (2024-06-15)
-    const alphaIndex = sorted.findIndex((p) => p.name === "alpha");
-    const zebraIndex = sorted.findIndex((p) => p.name === "zebra");
-    expect(zebraIndex).toBeLessThan(alphaIndex);
-  });
-
-  test("does not mutate original array", () => {
-    const projects = createMockProjects();
-    const originalFirst = projects[0]?.name;
-    sortProjects(projects, "name", "asc");
-    expect(projects[0]?.name).toBe(originalFirst);
-  });
-});
-
-describe("filterProjects", () => {
-  const createMockProjects = (): Project[] => [
-    {
-      id: "1",
-      name: "my-awesome-project",
-      path: "/projects/my-awesome-project",
-      type: "git",
-      projectMarker: null,
-      status: null,
-      submodule: null,
-      lastScanned: new Date(),
-      lastModified: null,
-    },
-    {
-      id: "2",
-      name: "node-api",
-      path: "/work/node-api",
-      type: "git",
-      projectMarker: "package.json",
-      status: null,
-      submodule: null,
-      lastScanned: new Date(),
-      lastModified: null,
-    },
-    {
-      id: "3",
-      name: "rust-lib",
-      path: "/home/rust-lib",
-      type: "non-git",
-      projectMarker: "Cargo.toml",
-      status: null,
-      submodule: null,
-      lastScanned: new Date(),
-      lastModified: null,
-    },
-  ];
-
-  test("returns all projects when filter is empty", () => {
-    const projects = createMockProjects();
-    const filtered = filterProjects(projects, "");
-    expect(filtered).toHaveLength(3);
-  });
-
-  test("returns all projects when filter is whitespace", () => {
-    const projects = createMockProjects();
-    const filtered = filterProjects(projects, "   ");
-    expect(filtered).toHaveLength(3);
-  });
-
-  test("filters by project name", () => {
-    const projects = createMockProjects();
-    const filtered = filterProjects(projects, "awesome");
-    expect(filtered).toHaveLength(1);
-    expect(filtered[0]?.name).toBe("my-awesome-project");
-  });
-
-  test("filters by path", () => {
-    const projects = createMockProjects();
-    const filtered = filterProjects(projects, "work");
-    expect(filtered).toHaveLength(1);
-    expect(filtered[0]?.name).toBe("node-api");
-  });
-
-  test("filters by project marker", () => {
-    const projects = createMockProjects();
-    const filtered = filterProjects(projects, "Cargo");
-    expect(filtered).toHaveLength(1);
-    expect(filtered[0]?.name).toBe("rust-lib");
-  });
-
-  test("filters by type", () => {
-    const projects = createMockProjects();
-    const filtered = filterProjects(projects, "non-git");
-    expect(filtered).toHaveLength(1);
-    expect(filtered[0]?.type).toBe("non-git");
-  });
-
-  test("filter is case-insensitive", () => {
-    const projects = createMockProjects();
-    const filtered = filterProjects(projects, "AWESOME");
-    expect(filtered).toHaveLength(1);
-    expect(filtered[0]?.name).toBe("my-awesome-project");
-  });
-
-  test("returns empty array when no matches", () => {
-    const projects = createMockProjects();
-    const filtered = filterProjects(projects, "nonexistent");
-    expect(filtered).toHaveLength(0);
-  });
-
-  test("does not mutate original array", () => {
-    const projects = createMockProjects();
-    filterProjects(projects, "awesome");
-    expect(projects).toHaveLength(3);
-  });
-});
-
-describe("scanAllDirectories - Additional Tests", () => {
-  let tempDir: string;
-
-  beforeEach(() => {
-    tempDir = createTempDir("scanner-test-additional");
-  });
-
-  afterEach(() => {
-    cleanupTempDir(tempDir);
-  });
-
-  test("handles hidden directories when includeHidden is true", async () => {
-    const hiddenDir = join(tempDir, ".hidden-repo");
-    await mkdir(hiddenDir);
-    await createMockGitRepo(hiddenDir, "git-repo");
-
-    const config = createTestConfig(tempDir, {
-      scan: { 
-        includeHidden: true,
-        ignore: ["node_modules", ".git", "vendor"],
-        concurrency: 5
-      },
-    });
-    const projects = await scanAllDirectories(config);
-
-    expect(projects.some(p => p.name === "git-repo")).toBe(true);
-  });
-
-  test("ignores hidden directories when includeHidden is false", async () => {
-    const hiddenDir = join(tempDir, ".hidden-repo");
-    await mkdir(hiddenDir);
-    await createMockGitRepo(hiddenDir, "git-repo");
-
-    const config = createTestConfig(tempDir, {
-      scan: { 
-        includeHidden: false,
-        ignore: ["node_modules", ".git", "vendor"],
-        concurrency: 5
-      },
-    });
-    const projects = await scanAllDirectories(config);
-
-    expect(projects.some(p => p.name === "git-repo")).toBe(false);
-  });
-
-  test("finds submodules when showSubmodules is true", async () => {
-    const { parentPath } = await createMockRepoWithSubmodule(tempDir, "parent", "submodule");
-
-    const config = createTestConfig(parentPath, {
-      display: { 
-        showSubmodules: true,
-        showNonGitProjects: true,
-        sortBy: "status",
-        sortDirection: "desc"
-      },
-    });
-    const projects = await scanAllDirectories(config);
-
-    expect(projects.some(p => p.name === "parent")).toBe(true);
-    expect(projects.some(p => p.name === "submodule" && p.type === "git-submodule")).toBe(true);
-  });
-
-  test("ignores submodules when showSubmodules is false", async () => {
-    const { parentPath } = await createMockRepoWithSubmodule(tempDir, "parent", "submodule");
-
-    const config = createTestConfig(parentPath, {
-      display: { 
-        showSubmodules: false,
-        showNonGitProjects: true,
-        sortBy: "status",
-        sortDirection: "desc"
-      },
-    });
-    const projects = await scanAllDirectories(config);
-
-    expect(projects.some(p => p.name === "parent")).toBe(true);
-    expect(projects.some(p => p.name === "submodule" && p.type === "git-submodule")).toBe(false);
-  });
-
-  test("calls onProgress callback", async () => {
-    await createMockGitRepo(tempDir, "repo1");
-    await createMockGitRepo(tempDir, "repo2");
-    createMockProject(tempDir, "node-project", "package.json");
-
-    const progressCalls: Array<{ scanned: number; found: number }> = [];
-    const config = createTestConfig(tempDir);
-    
-    await scanAllDirectories(config, { 
-      onProgress: (scanned, found) => {
-        progressCalls.push({ scanned, found });
-      }
-    });
-
-    expect(progressCalls.length).toBeGreaterThan(0);
-    expect(progressCalls[progressCalls.length - 1]?.found).toBe(3);
-  });
-
-  test("handles non-existent directories gracefully", async () => {
-    const config = createMockConfig({
-      directories: [{ path: "/non/existent/path", maxDepth: 2 }],
-    });
-    
-    const projects = await scanAllDirectories(config);
-    expect(projects).toEqual([]);
-  });
-
-  test("generates unique project IDs consistently", async () => {
-    await createMockGitRepo(tempDir, "repo1");
-    
-    const config = createTestConfig(tempDir);
-    const projects1 = await scanAllDirectories(config);
-    const projects2 = await scanAllDirectories(config);
-
-    expect(projects1.length).toBeGreaterThan(0);
-    expect(projects2.length).toBeGreaterThan(0);
-    expect(projects1[0]?.id).toBe(projects2[0]?.id);
-    expect(projects1[0]?.id).toHaveLength(12); // MD5 hash first 12 chars
-  });
-
-  test("handles directories with read permissions issues", async () => {
-    // Create a nested structure
-    const subDir = join(tempDir, "subdir");
-    await mkdir(subDir);
-    await createMockGitRepo(subDir, "accessible-repo");
-
-    // Create a directory that we can't read (simulate permission denied)
-    const protectedDir = join(tempDir, "protected");
-    await mkdir(protectedDir);
-    
-    const config = createTestConfig(tempDir);
-    const projects = await scanAllDirectories(config);
-
-    // Should still find the accessible repo
-    expect(projects.some(p => p.name === "accessible-repo")).toBe(true);
-  });
-
-  test("respects custom ignore patterns", async () => {
-    const customDir = join(tempDir, "custom-ignore");
-    await mkdir(customDir);
-    await createMockGitRepo(customDir, "ignored-repo");
-
-    const config = createTestConfig(tempDir, {
-      scan: { 
-        ignore: ["custom-ignore", "node_modules", ".git"],
-        includeHidden: false,
-        concurrency: 5
-      },
-    });
-    const projects = await scanAllDirectories(config);
-
-    expect(projects.some(p => p.name === "ignored-repo")).toBe(false);
-  });
-
-  test("finds projects at exact maxDepth", async () => {
-    const level1 = join(tempDir, "level1");
-    const level2 = join(level1, "level2");
-    await mkdir(level2, { recursive: true });
-
-    await createMockGitRepo(level2, "exact-depth-repo");
-
-    // maxDepth of 2 should find the repo at level 2 (root is level 0, level1 is level 1, level2 is level 2)
-    const config = createTestConfig(tempDir, {
-      directories: [{ path: tempDir, maxDepth: 3 }], // Need maxDepth 3 to reach level 2
-    });
-    const projects = await scanAllDirectories(config);
-
-    expect(projects.some(p => p.name === "exact-depth-repo")).toBe(true);
-  });
-
-  test("finds multiple project types with different markers", async () => {
-    createMockProject(tempDir, "node-project", "package.json");
-    createMockProject(tempDir, "rust-project", "Cargo.toml");
-    createMockProject(tempDir, "python-project", "pyproject.toml");
-    createMockProject(tempDir, "go-project", "go.mod");
-
-    const config = createTestConfig(tempDir);
-    const projects = await scanAllDirectories(config);
-
-    expect(projects.find(p => p.name === "node-project")?.projectMarker).toBe("package.json");
-    expect(projects.find(p => p.name === "rust-project")?.projectMarker).toBe("Cargo.toml");
-    expect(projects.find(p => p.name === "python-project")?.projectMarker).toBe("pyproject.toml");
-    expect(projects.find(p => p.name === "go-project")?.projectMarker).toBe("go.mod");
-  });
-});
-
-describe("scanWithCache", () => {
-  let tempDir: string;
-  let originalDbPath: string | undefined;
-
-  beforeEach(() => {
-    tempDir = createTempDir("scanner-cache-test");
-    // Use a temporary database for each test
-    originalDbPath = process.env.XDG_DATA_HOME;
-    process.env.XDG_DATA_HOME = join(tempDir, ".local", "share");
-  });
-
-  afterEach(async () => {
-    cleanupTempDir(tempDir);
-    // Restore original database path (close DB after restoring path to avoid conflicts)
-    if (originalDbPath !== undefined) {
-      process.env.XDG_DATA_HOME = originalDbPath;
-    } else {
-      delete process.env.XDG_DATA_HOME;
-    }
-    // Close database connection after restoring path
-    closeDb();
-  });
-
-  test("returns cached data when fresh", async () => {
-    // Ensure cache is clear before test
-    await clearCache();
-    
-    // Create a dedicated subdirectory for this test
-    const testDir = join(tempDir, "cache-test");
-    await mkdir(testDir);
-    
-    await createMockGitRepo(testDir, "repo1");
-    
-    const config = createMockConfig({
-      directories: [{ path: testDir, maxDepth: 2 }],
-      cache: { 
-        ttlSeconds: 300,
-        githubTtlSeconds: 600,
-        enableBackgroundRefresh: true,
-        backgroundRefreshIntervalSeconds: 300
-      },
-    });
-
-    // First scan - should hit the filesystem
-    const projects1 = await scanWithCache(config);
-    expect(projects1).toHaveLength(1);
-
-    // Add another repo
-    await createMockGitRepo(testDir, "repo2");
-
-    // Second scan - should return cached data (only repo1)
-    const projects2 = await scanWithCache(config);
-    expect(projects2).toHaveLength(1);
-    expect(projects2[0]?.name).toBe("repo1");
-  });
-
-  test("performs fresh scan when cache is stale", async () => {
-    await createMockGitRepo(tempDir, "repo1");
-    
-    const config = createTestConfig(tempDir, {
-      cache: { 
-        ttlSeconds: 1, // Very short TTL to force fresh scan
-        githubTtlSeconds: 600,
-        enableBackgroundRefresh: true,
-        backgroundRefreshIntervalSeconds: 300
-      },
-    });
-
-    // First scan
-    const projects1 = await scanWithCache(config);
-    expect(projects1).toHaveLength(1);
-
-    // Add another repo
-    await createMockGitRepo(tempDir, "repo2");
-
-    // Wait for cache to become stale (TTL is 1 second)
-    await new Promise(resolve => setTimeout(resolve, 1100));
-
-    // Second scan - should find both repos (fresh scan)
-    const projects2 = await scanWithCache(config);
-    expect(projects2).toHaveLength(2);
-  });
-
-  test("performs fresh scan when forceRefresh is true", async () => {
-    await createMockGitRepo(tempDir, "repo1");
-    
-    const config = createTestConfig(tempDir, {
-      cache: { 
-        ttlSeconds: 300,
-        githubTtlSeconds: 600,
-        enableBackgroundRefresh: true,
-        backgroundRefreshIntervalSeconds: 300
-      },
-    });
-
-    // First scan
-    const projects1 = await scanWithCache(config);
-    expect(projects1).toHaveLength(1);
-
-    // Add another repo
-    await createMockGitRepo(tempDir, "repo2");
-
-    // Force refresh - should find both repos
-    const projects2 = await scanWithCache(config, { forceRefresh: true });
-    expect(projects2).toHaveLength(2);
-  });
-
-  test("saves results to cache after scan", async () => {
-    await createMockGitRepo(tempDir, "repo1");
-    
-    const config = createTestConfig(tempDir);
-
-    // Clear any existing cache
-    await clearCache();
-
-    // Verify cache is empty
-    const initialStats = await getCacheStats();
-    expect(initialStats.projectCount).toBe(0);
-
-    // Scan
-    await scanWithCache(config);
-
-    // Verify cache now has the project
-    const finalStats = await getCacheStats();
-    expect(finalStats.projectCount).toBe(1);
-  });
-
-  test("handles cache read failures gracefully", async () => {
-    await createMockGitRepo(tempDir, "repo1");
-    
-    const config = createTestConfig(tempDir);
-
-    // Mock a cache read failure by corrupting the database
-    // This is a bit hacky but tests the error handling
-    const projects = await scanWithCache(config);
-    expect(projects).toHaveLength(1);
-  });
-
-  test("handles cache write failures gracefully", async () => {
-    // Create read-only directory to simulate write failure
-    const readOnlyDir = join(tempDir, "readonly");
-    await mkdir(readOnlyDir);
-    await createMockGitRepo(readOnlyDir, "repo1");
-
-    const config = createTestConfig(readOnlyDir);
-
-    // Should still return projects even if cache write fails
-    const projects = await scanWithCache(config);
-    expect(projects).toHaveLength(1);
-  });
-
-  test("calls onProgress callback during fresh scan", async () => {
-    await createMockGitRepo(tempDir, "repo1");
-    await createMockGitRepo(tempDir, "repo2");
-
-    const progressCalls: Array<{ scanned: number; found: number }> = [];
-    const config = createTestConfig(tempDir, {
-      cache: { 
-        ttlSeconds: 1, // Very short TTL to force fresh scan
-        githubTtlSeconds: 600,
-        enableBackgroundRefresh: true,
-        backgroundRefreshIntervalSeconds: 300
-      },
-    });
-
-    await scanWithCache(config, { 
-      onProgress: (scanned, found) => {
-        progressCalls.push({ scanned, found });
-      }
-    });
-
-    expect(progressCalls.length).toBeGreaterThan(0);
-    const lastCall = progressCalls[progressCalls.length - 1];
-    if (lastCall) {
-      expect(lastCall.found).toBe(2);
-    }
-  });
-
-  test("does not call onProgress when returning cached data", async () => {
-    await createMockGitRepo(tempDir, "repo1");
-    
-    const config = createTestConfig(tempDir, {
-      cache: { 
-        ttlSeconds: 1, // Very short TTL to force fresh scan
-        githubTtlSeconds: 600,
-        enableBackgroundRefresh: true,
-        backgroundRefreshIntervalSeconds: 300
-      },
-    });
-
-    // First scan to populate cache
-    await scanWithCache(config);
-
-    // Second scan should use cache
-    let progressCalled = false;
-    await scanWithCache(config, {
-      onProgress: () => {
-        progressCalled = true;
-      }
-    });
-
-    expect(progressCalled).toBe(false);
-  });
-});
-
-describe("getCacheStats", () => {
-  let originalDbPath: string | undefined;
-
-  beforeEach(async () => {
-    // Use a temporary database for each test
-    originalDbPath = process.env.XDG_DATA_HOME;
-    process.env.XDG_DATA_HOME = join(createTempDir("cache-stats-db"), ".local", "share");
-  });
-
-  afterEach(async () => {
-    // Close database connection to prevent disk I/O errors
-    closeDb();
-    
-    // Restore original database path
-    if (originalDbPath !== undefined) {
-      process.env.XDG_DATA_HOME = originalDbPath;
-    } else {
-      delete process.env.XDG_DATA_HOME;
-    }
-  });
-
-  test("returns correct project count", async () => {
-    const tempDir = createTempDir("cache-stats-test");
-    
-    try {
-      // Create multiple projects
-      await createMockGitRepo(tempDir, "repo1");
-      await createMockGitRepo(tempDir, "repo2");
-      createMockProject(tempDir, "node-project", "package.json");
-
-      const config = createMockConfig({
-        directories: [{ path: tempDir, maxDepth: 2 }],
-      });
-
-      // Scan to populate cache
-      await scanWithCache(config);
-
-      // Check stats
-      const stats = await getCacheStats();
-      expect(stats.projectCount).toBe(3);
-    } finally {
-      cleanupTempDir(tempDir);
-    }
-  });
-
-  test("returns oldest and newest scan dates", async () => {
-    const tempDir = createTempDir("cache-dates-test");
-    
-    try {
-      // Create and scan first project
-      await createMockGitRepo(tempDir, "repo1");
-      const config = createMockConfig({
-        directories: [{ path: tempDir, maxDepth: 2 }],
-        cache: { 
-          ttlSeconds: 1, // Short TTL so cache expires quickly
-          githubTtlSeconds: 600,
-          enableBackgroundRefresh: true,
-          backgroundRefreshIntervalSeconds: 300
-        },
-      });
-      await scanWithCache(config);
-
-      const stats1 = await getCacheStats();
-      const firstScanDate = stats1.newestScan!;
-      expect(stats1.projectCount).toBe(1);
-
-      // Wait for cache to become stale, then add another project and scan
-      await new Promise(resolve => setTimeout(resolve, 1100));
-      await createMockGitRepo(tempDir, "repo2");
-      
-      // Second scan without forceRefresh - repo1 is stale so will be rescanned,
-      // repo2 is new so will be scanned fresh
-      await scanWithCache(config);
-
-      const stats2 = await getCacheStats();
-      expect(stats2.projectCount).toBe(2);
-      
-      // Both projects now have recent scan times
-      // Just verify we have valid dates (the exact timing is unreliable in tests)
-      expect(stats2.oldestScan).not.toBeNull();
-      expect(stats2.newestScan).not.toBeNull();
-      expect(stats2.newestScan!.getTime()).toBeGreaterThanOrEqual(firstScanDate.getTime());
-    } finally {
-      cleanupTempDir(tempDir);
-    }
-  });
-
-  test("handles empty cache", async () => {
-    const stats = await getCacheStats();
-    
-    expect(stats.projectCount).toBe(0);
-    expect(stats.oldestScan).toBeNull();
-    expect(stats.newestScan).toBeNull();
-  });
-
-  test("returns consistent dates for single project", async () => {
-    const tempDir = createTempDir("cache-single-test");
-    
-    try {
-      await createMockGitRepo(tempDir, "repo1");
-      const config = createMockConfig({
-        directories: [{ path: tempDir, maxDepth: 2 }],
-      });
-      await scanWithCache(config);
-
-      const stats = await getCacheStats();
-      
-      expect(stats.projectCount).toBe(1);
-      expect(stats.oldestScan).toBeInstanceOf(Date);
-      expect(stats.newestScan).toBeInstanceOf(Date);
-      expect(stats.oldestScan!.getTime()).toBe(stats.newestScan!.getTime());
-    } finally {
-      cleanupTempDir(tempDir);
-    }
-  });
-});
-
-describe("clearCache", () => {
-  let originalDbPath: string | undefined;
-
-  beforeEach(async () => {
-    // Use a temporary database for each test
-    originalDbPath = process.env.XDG_DATA_HOME;
-    process.env.XDG_DATA_HOME = join(createTempDir("clear-cache-db"), ".local", "share");
-  });
-
-  afterEach(async () => {
-    // Close database connection to prevent disk I/O errors
-    closeDb();
-    
-    // Restore original database path
-    if (originalDbPath !== undefined) {
-      process.env.XDG_DATA_HOME = originalDbPath;
-    } else {
-      delete process.env.XDG_DATA_HOME;
-    }
-  });
-
-  test("clears all cached projects", async () => {
-    const tempDir = createTempDir("clear-cache-test");
-    
-    try {
-      // Populate cache
-      await createMockGitRepo(tempDir, "repo1");
-      await createMockGitRepo(tempDir, "repo2");
-      const config = createMockConfig({
-        directories: [{ path: tempDir, maxDepth: 2 }],
-      });
-      await scanWithCache(config);
-
-      // Verify cache has projects
-      const statsBefore = await getCacheStats();
-      expect(statsBefore.projectCount).toBe(2);
-
-      // Clear cache
-      await clearCache();
-
-      // Verify cache is empty
-      const statsAfter = await getCacheStats();
-      expect(statsAfter.projectCount).toBe(0);
-      expect(statsAfter.oldestScan).toBeNull();
-      expect(statsAfter.newestScan).toBeNull();
-    } finally {
-      cleanupTempDir(tempDir);
-    }
-  });
-
-  test("handles clearing empty cache", async () => {
-    // Clear any existing cache
-    await clearCache();
-    
-    // Clear again - should not throw
-    await clearCache();
-    
-    // Verify still empty
-    const stats = await getCacheStats();
-    expect(stats.projectCount).toBe(0);
-  });
-
-  test("cache is empty after clearing even with stale data", async () => {
-    const tempDir = createTempDir("clear-stale-cache-test");
-    
-    try {
-      // Add old data to cache with expired TTL
-      await createMockGitRepo(tempDir, "old-repo");
-      const config = createMockConfig({
-        directories: [{ path: tempDir, maxDepth: 2 }],
-        cache: { 
-          ttlSeconds: 1, // Very short TTL
-          githubTtlSeconds: 600,
-          enableBackgroundRefresh: true,
-          backgroundRefreshIntervalSeconds: 300
-        },
-      });
-      await scanWithCache(config);
-
-      // Clear cache
-      await clearCache();
-
-      // Verify completely empty
-      const stats = await getCacheStats();
-      expect(stats.projectCount).toBe(0);
-    } finally {
-      cleanupTempDir(tempDir);
-    }
-  });
-});