@getjack/jack 0.1.4 → 0.1.6

package/src/lib/local-paths.test.ts

@@ -1,902 +0,0 @@
-/**
- * Unit tests for local-paths.ts
- *
- * These tests use a temporary directory for isolation and mock the CONFIG_DIR
- * to avoid touching the real ~/.config/jack directory.
- */
-
-import { afterEach, beforeEach, describe, expect, it, mock, spyOn } from "bun:test";
-import { existsSync } from "node:fs";
-import { mkdir, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-// Test helpers
-let testDir: string;
-let testConfigDir: string;
-let testIndexPath: string;
-
-/**
- * Create a unique temp directory for each test
- */
-async function createTestDir(): Promise<string> {
-	const timestamp = Date.now();
-	const random = Math.random().toString(36).substring(7);
-	const dir = join(tmpdir(), `jack-test-${timestamp}-${random}`);
-	await mkdir(dir, { recursive: true });
-	return dir;
-}
-
-/**
- * Create a mock project with wrangler config
- */
-async function createMockProject(
-	parentDir: string,
-	name: string,
-	configType: "jsonc" | "toml" | "json" = "jsonc",
-): Promise<string> {
-	const projectDir = join(parentDir, name);
-	await mkdir(projectDir, { recursive: true });
-
-	if (configType === "jsonc") {
-		await writeFile(join(projectDir, "wrangler.jsonc"), JSON.stringify({ name }));
-	} else if (configType === "toml") {
-		await writeFile(join(projectDir, "wrangler.toml"), `name = "${name}"`);
-	} else {
-		await writeFile(join(projectDir, "wrangler.json"), JSON.stringify({ name }));
-	}
-
-	return projectDir;
-}
-
-/**
- * Write a test index file directly
- */
-async function writeTestIndex(index: object): Promise<void> {
-	await mkdir(testConfigDir, { recursive: true });
-	await writeFile(testIndexPath, JSON.stringify(index, null, 2));
-}
-
-/**
- * Read the test index file directly
- */
-async function readTestIndex(): Promise<object | null> {
-	if (!existsSync(testIndexPath)) {
-		return null;
-	}
-	const content = await Bun.file(testIndexPath).text();
-	return JSON.parse(content);
-}
-
-describe("local-paths", () => {
-	beforeEach(async () => {
-		// Create fresh temp directory for each test
-		testDir = await createTestDir();
-		testConfigDir = join(testDir, "config");
-		testIndexPath = join(testConfigDir, "local-paths.json");
-		await mkdir(testConfigDir, { recursive: true });
-	});
-
-	afterEach(async () => {
-		// Clean up temp directory
-		await rm(testDir, { recursive: true, force: true });
-	});
-
-	describe("readLocalPaths", () => {
-		it("returns empty index when file does not exist", async () => {
-			// Import fresh module for each test to avoid state pollution
-			// We'll use a mock approach for the CONFIG_DIR
-
-			// Create a mock module that uses our test paths
-			const mockConfigDir = testConfigDir;
-			const mockIndexPath = testIndexPath;
-
-			// Since we can't easily mock the constant, we test the behavior
-			// by directly testing the file I/O pattern
-
-			// The file doesn't exist yet
-			expect(existsSync(testIndexPath)).toBe(false);
-
-			// Reading a non-existent file should return empty index
-			// We simulate this behavior pattern
-			const emptyIndex = { version: 1, paths: {}, updatedAt: expect.any(String) };
-
-			// Test that our helper returns null for non-existent file
-			const result = await readTestIndex();
-			expect(result).toBe(null);
-		});
-
-		it("handles corrupted index file gracefully", async () => {
-			// Write invalid JSON to the index file
-			await writeFile(testIndexPath, "{ invalid json content");
-
-			// Reading should fail, so we verify the pattern
-			try {
-				const content = await Bun.file(testIndexPath).json();
-				// If we get here, parsing succeeded unexpectedly
-				expect(true).toBe(false);
-			} catch {
-				// Expected - corrupted file should throw
-				expect(true).toBe(true);
-			}
-		});
-
-		it("reads valid index file", async () => {
-			const testIndex = {
-				version: 1,
-				paths: {
-					"my-project": ["/path/to/my-project"],
-				},
-				updatedAt: "2024-12-28T00:00:00.000Z",
-			};
-
-			await writeTestIndex(testIndex);
-
-			const result = await readTestIndex();
-			expect(result).toEqual(testIndex);
-		});
-	});
-
-	describe("registerLocalPath", () => {
-		it("registers a new path for a new project", async () => {
-			// Create a mock project
-			const projectDir = await createMockProject(testDir, "test-project");
-
-			// Test the registration pattern
-			const index = { version: 1, paths: {} as Record<string, string[]>, updatedAt: "" };
-
-			// Simulate registerLocalPath behavior
-			const projectName = "test-project";
-			const absolutePath = projectDir;
-
-			if (!index.paths[projectName]) {
-				index.paths[projectName] = [];
-			}
-			if (!index.paths[projectName].includes(absolutePath)) {
-				index.paths[projectName].push(absolutePath);
-			}
-
-			expect(index.paths["test-project"]).toContain(projectDir);
-			expect(index.paths["test-project"]).toHaveLength(1);
-		});
-
-		it("handles duplicate paths (idempotent)", async () => {
-			const projectDir = await createMockProject(testDir, "test-project");
-
-			// Simulate registering the same path twice
-			const index = { version: 1, paths: {} as Record<string, string[]>, updatedAt: "" };
-			const projectName = "test-project";
-			const absolutePath = projectDir;
-
-			// First registration
-			if (!index.paths[projectName]) {
-				index.paths[projectName] = [];
-			}
-			if (!index.paths[projectName].includes(absolutePath)) {
-				index.paths[projectName].push(absolutePath);
-			}
-
-			// Second registration (should be idempotent)
-			if (!index.paths[projectName].includes(absolutePath)) {
-				index.paths[projectName].push(absolutePath);
-			}
-
-			expect(index.paths["test-project"]).toHaveLength(1);
-			expect(index.paths["test-project"]).toContain(projectDir);
-		});
-
-		it("allows multiple paths for the same project", async () => {
-			const projectDir1 = await createMockProject(testDir, "test-project");
-			const projectDir2 = await createMockProject(join(testDir, "fork"), "test-project");
-
-			const index = { version: 1, paths: {} as Record<string, string[]>, updatedAt: "" };
-			const projectName = "test-project";
-
-			// Register first path
-			if (!index.paths[projectName]) {
-				index.paths[projectName] = [];
-			}
-			if (!index.paths[projectName].includes(projectDir1)) {
-				index.paths[projectName].push(projectDir1);
-			}
-
-			// Register second path
-			if (!index.paths[projectName].includes(projectDir2)) {
-				index.paths[projectName].push(projectDir2);
-			}
-
-			expect(index.paths["test-project"]).toHaveLength(2);
-			expect(index.paths["test-project"]).toContain(projectDir1);
-			expect(index.paths["test-project"]).toContain(projectDir2);
-		});
-	});
-
-	describe("removeLocalPath", () => {
-		it("removes an existing path", async () => {
-			const projectDir = await createMockProject(testDir, "test-project");
-
-			const index = {
-				version: 1,
-				paths: { "test-project": [projectDir] } as Record<string, string[]>,
-				updatedAt: "",
-			};
-
-			// Simulate removeLocalPath behavior
-			const projectName = "test-project";
-			const absolutePath = projectDir;
-
-			if (index.paths[projectName]) {
-				index.paths[projectName] = index.paths[projectName].filter((p) => p !== absolutePath);
-				if (index.paths[projectName].length === 0) {
-					delete index.paths[projectName];
-				}
-			}
-
-			expect(index.paths["test-project"]).toBeUndefined();
-		});
-
-		it("handles removing non-existent path gracefully", async () => {
-			const index = {
-				version: 1,
-				paths: {} as Record<string, string[]>,
-				updatedAt: "",
-			};
-
-			// Simulate removeLocalPath for non-existent project
-			const projectName = "non-existent";
-			const absolutePath = "/some/path";
-
-			if (index.paths[projectName]) {
-				index.paths[projectName] = index.paths[projectName].filter((p) => p !== absolutePath);
-				if (index.paths[projectName].length === 0) {
-					delete index.paths[projectName];
-				}
-			}
-
-			// Should not throw and paths should remain empty
-			expect(index.paths).toEqual({});
-		});
-	});
-
-	describe("getLocalPaths", () => {
-		it("returns empty array for unknown project", async () => {
-			const index = { version: 1, paths: {}, updatedAt: "" };
-			const paths = index.paths["unknown-project"] || [];
-			expect(paths).toHaveLength(0);
-		});
-
-		it("prunes non-existent paths automatically", async () => {
-			// Create a project, add it to index, then delete the project
-			const projectDir = await createMockProject(testDir, "ghost-project");
-
-			const index = {
-				version: 1,
-				paths: {
-					"ghost-project": [projectDir, "/non/existent/path"],
-				} as Record<string, string[]>,
-				updatedAt: "",
-			};
-
-			// Simulate getLocalPaths pruning behavior
-			const projectName = "ghost-project";
-			const paths = index.paths[projectName] || [];
-			const validPaths: string[] = [];
-			const invalidPaths: string[] = [];
-
-			for (const path of paths) {
-				const hasConfig =
-					existsSync(join(path, "wrangler.jsonc")) ||
-					existsSync(join(path, "wrangler.toml")) ||
-					existsSync(join(path, "wrangler.json"));
-
-				if (hasConfig) {
-					validPaths.push(path);
-				} else {
-					invalidPaths.push(path);
-				}
-			}
-
-			expect(validPaths).toContain(projectDir);
-			expect(validPaths).not.toContain("/non/existent/path");
-			expect(invalidPaths).toContain("/non/existent/path");
-		});
-
-		it("removes project entry when all paths are invalid", async () => {
-			const index = {
-				version: 1,
-				paths: {
-					"ghost-project": ["/non/existent/path1", "/non/existent/path2"],
-				} as Record<string, string[]>,
-				updatedAt: "",
-			};
-
-			// Simulate pruning
-			const projectName = "ghost-project";
-			const paths = index.paths[projectName] || [];
-			const validPaths: string[] = [];
-
-			for (const path of paths) {
-				const hasConfig =
-					existsSync(join(path, "wrangler.jsonc")) ||
-					existsSync(join(path, "wrangler.toml")) ||
-					existsSync(join(path, "wrangler.json"));
-
-				if (hasConfig) {
-					validPaths.push(path);
-				}
-			}
-
-			// Update index
-			if (validPaths.length > 0) {
-				index.paths[projectName] = validPaths;
-			} else {
-				delete index.paths[projectName];
-			}
-
-			expect(index.paths["ghost-project"]).toBeUndefined();
-		});
-	});
-
-	describe("getAllLocalPaths", () => {
-		it("returns empty object when no projects registered", async () => {
-			const index = { version: 1, paths: {}, updatedAt: "" };
-			expect(Object.keys(index.paths)).toHaveLength(0);
-		});
-
-		it("returns all valid paths for all projects", async () => {
-			const project1 = await createMockProject(testDir, "project1");
-			const project2 = await createMockProject(testDir, "project2");
-
-			const index = {
-				version: 1,
-				paths: {
-					project1: [project1],
-					project2: [project2],
-				} as Record<string, string[]>,
-				updatedAt: "",
-			};
-
-			// Simulate getAllLocalPaths
-			const result: Record<string, string[]> = {};
-
-			for (const [projectName, paths] of Object.entries(index.paths)) {
-				const validPaths: string[] = [];
-
-				for (const path of paths) {
-					const hasConfig =
-						existsSync(join(path, "wrangler.jsonc")) ||
-						existsSync(join(path, "wrangler.toml")) ||
-						existsSync(join(path, "wrangler.json"));
-
-					if (hasConfig) {
-						validPaths.push(path);
-					}
-				}
-
-				if (validPaths.length > 0) {
-					result[projectName] = validPaths;
-				}
-			}
-
-			expect(result).toEqual({
-				project1: [project1],
-				project2: [project2],
-			});
-		});
-
-		it("prunes invalid paths across all projects", async () => {
-			const validProject = await createMockProject(testDir, "valid-project");
-
-			const index = {
-				version: 1,
-				paths: {
-					"valid-project": [validProject],
-					"invalid-project": ["/non/existent/path"],
-				} as Record<string, string[]>,
-				updatedAt: "",
-			};
-
-			// Simulate getAllLocalPaths with pruning
-			const result: Record<string, string[]> = {};
-
-			for (const [projectName, paths] of Object.entries(index.paths)) {
-				const validPaths: string[] = [];
-
-				for (const path of paths) {
-					const hasConfig =
-						existsSync(join(path, "wrangler.jsonc")) ||
-						existsSync(join(path, "wrangler.toml")) ||
-						existsSync(join(path, "wrangler.json"));
-
-					if (hasConfig) {
-						validPaths.push(path);
-					}
-				}
-
-				if (validPaths.length > 0) {
-					result[projectName] = validPaths;
-				}
-			}
-
-			expect(result).toEqual({
-				"valid-project": [validProject],
-			});
-			expect(result["invalid-project"]).toBeUndefined();
-		});
-	});
-
-	describe("scanDirectoryForProjects", () => {
-		it("finds projects in directory", async () => {
-			// Create nested structure with projects
-			const project1 = await createMockProject(join(testDir, "apps"), "project1", "jsonc");
-			const project2 = await createMockProject(join(testDir, "libs"), "project2", "toml");
-
-			// Manually scan like the function does
-			const discovered: Array<{ name: string; path: string }> = [];
-
-			// Check apps/project1
-			const project1ConfigPath = join(project1, "wrangler.jsonc");
-			if (existsSync(project1ConfigPath)) {
-				const content = await Bun.file(project1ConfigPath).text();
-				const config = JSON.parse(content);
-				discovered.push({ name: config.name, path: project1 });
-			}
-
-			// Check libs/project2
-			const project2ConfigPath = join(project2, "wrangler.toml");
-			if (existsSync(project2ConfigPath)) {
-				const content = await Bun.file(project2ConfigPath).text();
-				const match = content.match(/^name\s*=\s*["']([^"']+)["']/m);
-				if (match?.[1]) {
-					discovered.push({ name: match[1], path: project2 });
-				}
-			}
-
-			expect(discovered).toHaveLength(2);
-			expect(discovered.map((p) => p.name).sort()).toEqual(["project1", "project2"]);
-		});
-
-		it("respects maxDepth limit", async () => {
-			// Create deeply nested project
-			const deepPath = join(testDir, "a", "b", "c", "d", "e");
-			await mkdir(deepPath, { recursive: true });
-			await writeFile(join(deepPath, "wrangler.jsonc"), JSON.stringify({ name: "deep-project" }));
-
-			// At maxDepth=3, depth 0=testDir, 1=a, 2=b, 3=c - should not find d/e
-			const maxDepth = 3;
-
-			// Track depth during scan
-			function getDepth(basePath: string, fullPath: string): number {
-				const relative = fullPath.slice(basePath.length);
-				const parts = relative.split("/").filter(Boolean);
-				return parts.length;
-			}
-
-			const depth = getDepth(testDir, deepPath);
-			expect(depth).toBe(5); // a/b/c/d/e = 5 levels deep
-
-			// At maxDepth=3, we would not scan into d or e
-			expect(depth).toBeGreaterThan(maxDepth);
-		});
-
-		it("skips node_modules and .git directories", async () => {
-			// Create projects in directories that should be skipped
-			await mkdir(join(testDir, "node_modules", "some-package"), { recursive: true });
-			await writeFile(
-				join(testDir, "node_modules", "some-package", "wrangler.jsonc"),
-				JSON.stringify({ name: "should-skip" }),
-			);
-
-			await mkdir(join(testDir, ".git", "hooks"), { recursive: true });
-			await writeFile(
-				join(testDir, ".git", "hooks", "wrangler.jsonc"),
-				JSON.stringify({ name: "also-skip" }),
-			);
-
-			// Create a valid project
-			await createMockProject(testDir, "valid-project");
-
-			// Directories to skip
-			const SKIP_DIRS = new Set([
-				"node_modules",
-				".git",
-				"dist",
-				"build",
-				".next",
-				".nuxt",
-				".output",
-				"coverage",
-				".turbo",
-				".cache",
-			]);
-
-			// Simulate scanning with skip logic
-			const discovered: string[] = [];
-
-			const entries = ["node_modules", ".git", "valid-project"];
-			for (const entry of entries) {
-				if (entry.startsWith(".") || SKIP_DIRS.has(entry)) {
-					continue;
-				}
-				// Would add to discovered if it's a project
-				discovered.push(entry);
-			}
-
-			expect(discovered).toEqual(["valid-project"]);
-			expect(discovered).not.toContain("node_modules");
-			expect(discovered).not.toContain(".git");
-		});
-
-		it("does not scan subdirectories of found projects", async () => {
-			// Create a project with nested directories
-			const projectDir = await createMockProject(testDir, "parent-project");
-			await mkdir(join(projectDir, "src", "nested"), { recursive: true });
-
-			// This nested wrangler should not be found because parent is a project
-			await writeFile(
-				join(projectDir, "src", "nested", "wrangler.jsonc"),
-				JSON.stringify({ name: "nested-project" }),
-			);
-
-			// The scan should stop at parent-project
-			// Simulating the behavior: when a project is found, return early
-			let foundProjects = 0;
-
-			// Check if testDir/parent-project is a project
-			if (existsSync(join(projectDir, "wrangler.jsonc"))) {
-				foundProjects++;
-				// Return early - don't scan subdirectories
-			}
-
-			// If we continued scanning, we'd find the nested one
-			// But the algorithm stops, so we only find 1
-
-			expect(foundProjects).toBe(1);
-		});
-
-		it("returns empty array for directory with no projects", async () => {
-			// Create some regular files, no projects
-			await writeFile(join(testDir, "README.md"), "# Hello");
-			await mkdir(join(testDir, "src"));
-			await writeFile(join(testDir, "src", "index.ts"), "console.log('hi')");
-
-			// Simulate scan - no wrangler configs found
-			const discovered: Array<{ name: string; path: string }> = [];
-
-			const hasConfig =
-				existsSync(join(testDir, "wrangler.jsonc")) ||
-				existsSync(join(testDir, "wrangler.toml")) ||
-				existsSync(join(testDir, "wrangler.json"));
-
-			expect(hasConfig).toBe(false);
-			expect(discovered).toHaveLength(0);
-		});
-	});
-
-	describe("registerDiscoveredProjects", () => {
-		it("registers multiple projects at once", async () => {
-			const project1 = await createMockProject(testDir, "project1");
-			const project2 = await createMockProject(testDir, "project2");
-
-			const projects = [
-				{ name: "project1", path: project1 },
-				{ name: "project2", path: project2 },
-			];
-
-			const index = { version: 1, paths: {} as Record<string, string[]>, updatedAt: "" };
-
-			// Simulate registerDiscoveredProjects
-			for (const { name, path } of projects) {
-				if (!index.paths[name]) {
-					index.paths[name] = [];
-				}
-				if (!index.paths[name].includes(path)) {
-					index.paths[name].push(path);
-				}
-			}
-
-			expect(Object.keys(index.paths)).toHaveLength(2);
-			expect(index.paths.project1).toContain(project1);
-			expect(index.paths.project2).toContain(project2);
-		});
-
-		it("merges with existing paths", async () => {
-			const existingProject = await createMockProject(join(testDir, "existing"), "project1");
-			const newProject = await createMockProject(join(testDir, "new"), "project1");
-
-			// Start with existing path
-			const index = {
-				version: 1,
-				paths: { project1: [existingProject] } as Record<string, string[]>,
-				updatedAt: "",
-			};
-
-			// Register new discovery
-			const projects = [{ name: "project1", path: newProject }];
-
-			for (const { name, path } of projects) {
-				if (!index.paths[name]) {
-					index.paths[name] = [];
-				}
-				if (!index.paths[name].includes(path)) {
-					index.paths[name].push(path);
-				}
-			}
-
-			expect(index.paths.project1).toHaveLength(2);
-			expect(index.paths.project1).toContain(existingProject);
-			expect(index.paths.project1).toContain(newProject);
-		});
-	});
-
-	describe("hasWranglerConfig helper", () => {
-		it("detects wrangler.jsonc", async () => {
-			const projectDir = await createMockProject(testDir, "jsonc-project", "jsonc");
-			expect(existsSync(join(projectDir, "wrangler.jsonc"))).toBe(true);
-		});
-
-		it("detects wrangler.toml", async () => {
-			const projectDir = await createMockProject(testDir, "toml-project", "toml");
-			expect(existsSync(join(projectDir, "wrangler.toml"))).toBe(true);
-		});
-
-		it("detects wrangler.json", async () => {
-			const projectDir = await createMockProject(testDir, "json-project", "json");
-			expect(existsSync(join(projectDir, "wrangler.json"))).toBe(true);
-		});
-
-		it("returns false for directory without config", async () => {
-			const emptyDir = join(testDir, "empty");
-			await mkdir(emptyDir);
-
-			const hasConfig =
-				existsSync(join(emptyDir, "wrangler.jsonc")) ||
-				existsSync(join(emptyDir, "wrangler.toml")) ||
-				existsSync(join(emptyDir, "wrangler.json"));
-
-			expect(hasConfig).toBe(false);
-		});
-	});
-
-	describe("edge cases", () => {
-		it("handles empty index file gracefully", async () => {
-			await writeFile(testIndexPath, "");
-
-			try {
-				await Bun.file(testIndexPath).json();
-				expect(true).toBe(false); // Should not reach here
-			} catch {
-				// Empty file is not valid JSON
-				expect(true).toBe(true);
-			}
-		});
-
-		it("handles index with empty paths object", async () => {
-			await writeTestIndex({ version: 1, paths: {}, updatedAt: "2024-12-28T00:00:00.000Z" });
-
-			const result = await readTestIndex();
-			expect(result).toEqual({
-				version: 1,
-				paths: {},
-				updatedAt: "2024-12-28T00:00:00.000Z",
-			});
-		});
-
-		it("converts relative paths to absolute", async () => {
-			// The resolve() function converts relative to absolute
-			const { resolve } = await import("node:path");
-
-			const relativePath = "./my-project";
-			const absolutePath = resolve(relativePath);
-
-			expect(absolutePath).not.toBe(relativePath);
-			expect(absolutePath.startsWith("/")).toBe(true);
-		});
-
-		it("stores absolute paths in index", async () => {
-			const projectDir = await createMockProject(testDir, "test-project");
-
-			const index = { version: 1, paths: {} as Record<string, string[]>, updatedAt: "" };
-
-			// Use resolve to ensure absolute path
-			const { resolve } = await import("node:path");
-			const absolutePath = resolve(projectDir);
-
-			if (!index.paths["test-project"]) {
-				index.paths["test-project"] = [];
-			}
-			index.paths["test-project"].push(absolutePath);
-
-			// Verify it's an absolute path
-			expect(index.paths["test-project"][0].startsWith("/")).toBe(true);
-		});
-	});
-});
-
-/**
- * Integration tests that use the actual module functions
- * Note: scanDirectoryForProjects is safe to test as it doesn't depend on INDEX_PATH
- */
-describe("local-paths integration", () => {
-	let testDir: string;
-
-	beforeEach(async () => {
-		// Create fresh temp directory for each test
-		const timestamp = Date.now();
-		const random = Math.random().toString(36).substring(7);
-		testDir = join(tmpdir(), `jack-integration-${timestamp}-${random}`);
-		await mkdir(testDir, { recursive: true });
-	});
-
-	afterEach(async () => {
-		await rm(testDir, { recursive: true, force: true });
-	});
-
-	describe("scanDirectoryForProjects - real function", () => {
-		it("discovers projects with wrangler.jsonc", async () => {
-			// Create a real project structure
-			const projectDir = join(testDir, "my-api");
-			await mkdir(projectDir, { recursive: true });
-			await writeFile(
-				join(projectDir, "wrangler.jsonc"),
-				JSON.stringify({ name: "my-api", main: "src/index.ts" }),
-			);
-
-			// Import and call the real function
-			const { scanDirectoryForProjects } = await import("./local-paths.ts");
-			const discovered = await scanDirectoryForProjects(testDir);
-
-			expect(discovered).toHaveLength(1);
-			expect(discovered[0].name).toBe("my-api");
-			expect(discovered[0].path).toBe(projectDir);
-		});
-
-		it("discovers projects with wrangler.toml", async () => {
-			const projectDir = join(testDir, "toml-project");
-			await mkdir(projectDir, { recursive: true });
-			await writeFile(
-				join(projectDir, "wrangler.toml"),
-				'name = "toml-project"\nmain = "src/index.ts"',
-			);
-
-			const { scanDirectoryForProjects } = await import("./local-paths.ts");
-			const discovered = await scanDirectoryForProjects(testDir);
-
-			expect(discovered).toHaveLength(1);
-			expect(discovered[0].name).toBe("toml-project");
-		});
-
-		it("discovers multiple nested projects", async () => {
-			// Create multiple projects in subdirectories
-			const project1 = join(testDir, "apps", "api");
-			const project2 = join(testDir, "apps", "web");
-			const project3 = join(testDir, "services", "worker");
-
-			await mkdir(project1, { recursive: true });
-			await mkdir(project2, { recursive: true });
-			await mkdir(project3, { recursive: true });
-
-			await writeFile(join(project1, "wrangler.jsonc"), JSON.stringify({ name: "api" }));
-			await writeFile(join(project2, "wrangler.jsonc"), JSON.stringify({ name: "web" }));
-			await writeFile(join(project3, "wrangler.toml"), 'name = "worker"');
-
-			const { scanDirectoryForProjects } = await import("./local-paths.ts");
-			const discovered = await scanDirectoryForProjects(testDir);
-
-			expect(discovered).toHaveLength(3);
-			const names = discovered.map((p) => p.name).sort();
-			expect(names).toEqual(["api", "web", "worker"]);
-		});
-
-		it("respects maxDepth parameter", async () => {
-			// Create a deeply nested project
-			const deepProject = join(testDir, "level1", "level2", "level3", "level4", "deep-project");
-			await mkdir(deepProject, { recursive: true });
-			await writeFile(
-				join(deepProject, "wrangler.jsonc"),
-				JSON.stringify({ name: "deep-project" }),
-			);
-
-			// Also create a shallow project
-			const shallowProject = join(testDir, "shallow");
-			await mkdir(shallowProject, { recursive: true });
-			await writeFile(join(shallowProject, "wrangler.jsonc"), JSON.stringify({ name: "shallow" }));
-
-			const { scanDirectoryForProjects } = await import("./local-paths.ts");
-
-			// With maxDepth=2, should only find shallow project
-			const discovered = await scanDirectoryForProjects(testDir, 2);
-
-			expect(discovered).toHaveLength(1);
-			expect(discovered[0].name).toBe("shallow");
-		});
-
-		it("skips node_modules directory", async () => {
-			// Create a project in node_modules (should be skipped)
-			const nodeModulesProject = join(testDir, "node_modules", "some-package");
-			await mkdir(nodeModulesProject, { recursive: true });
-			await writeFile(
-				join(nodeModulesProject, "wrangler.jsonc"),
-				JSON.stringify({ name: "should-skip" }),
-			);
-
-			// Create a regular project
-			const realProject = join(testDir, "real-project");
-			await mkdir(realProject, { recursive: true });
-			await writeFile(
-				join(realProject, "wrangler.jsonc"),
-				JSON.stringify({ name: "real-project" }),
-			);
-
-			const { scanDirectoryForProjects } = await import("./local-paths.ts");
-			const discovered = await scanDirectoryForProjects(testDir);
-
-			expect(discovered).toHaveLength(1);
-			expect(discovered[0].name).toBe("real-project");
-		});
-
-		it("does not recurse into found projects", async () => {
-			// Create a project with a nested sub-project
-			const parentProject = join(testDir, "parent");
-			await mkdir(parentProject, { recursive: true });
-			await writeFile(join(parentProject, "wrangler.jsonc"), JSON.stringify({ name: "parent" }));
-
-			// Create a nested project inside the parent
-			const nestedProject = join(parentProject, "packages", "child");
-			await mkdir(nestedProject, { recursive: true });
-			await writeFile(join(nestedProject, "wrangler.jsonc"), JSON.stringify({ name: "child" }));
-
-			const { scanDirectoryForProjects } = await import("./local-paths.ts");
-			const discovered = await scanDirectoryForProjects(testDir);
-
-			// Should only find parent, not child
-			expect(discovered).toHaveLength(1);
-			expect(discovered[0].name).toBe("parent");
-		});
-
-		it("returns empty array for directory with no projects", async () => {
-			// Create some files but no wrangler configs
-			await writeFile(join(testDir, "README.md"), "# Hello");
-			await mkdir(join(testDir, "src"));
-			await writeFile(join(testDir, "src", "index.ts"), "export {}");
-
-			const { scanDirectoryForProjects } = await import("./local-paths.ts");
-			const discovered = await scanDirectoryForProjects(testDir);
-
-			expect(discovered).toHaveLength(0);
-		});
-
-		it("handles permission errors gracefully", async () => {
-			// Create a normal project
-			const project = join(testDir, "accessible");
-			await mkdir(project, { recursive: true });
-			await writeFile(join(project, "wrangler.jsonc"), JSON.stringify({ name: "accessible" }));
-
-			const { scanDirectoryForProjects } = await import("./local-paths.ts");
-			const discovered = await scanDirectoryForProjects(testDir);
-
-			// Should find the accessible project
-			expect(discovered.length).toBeGreaterThanOrEqual(1);
-			expect(discovered.some((p) => p.name === "accessible")).toBe(true);
-		});
-	});
-
-	describe("LocalPathsIndex structure", () => {
-		it("validates index structure", () => {
-			// Test the expected structure
-			const validIndex = {
-				version: 1 as const,
-				paths: {
-					"project-a": ["/path/to/a"],
-					"project-b": ["/path/to/b1", "/path/to/b2"],
-				},
-				updatedAt: "2024-12-28T00:00:00.000Z",
-			};
-
-			expect(validIndex.version).toBe(1);
-			expect(typeof validIndex.paths).toBe("object");
-			expect(typeof validIndex.updatedAt).toBe("string");
-			expect(Array.isArray(validIndex.paths["project-a"])).toBe(true);
-		});
-	});
-});