claudekit-cli 1.4.1 → 1.5.0

package/tests/lib/merge.test.ts

@@ -1,267 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } 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";
-import { FileMerger } from "../../src/lib/merge.js";
-
-describe("FileMerger", () => {
-	let merger: FileMerger;
-	let testSourceDir: string;
-	let testDestDir: string;
-
-	beforeEach(async () => {
-		merger = new FileMerger();
-
-		// Create temporary test directories
-		const timestamp = Date.now();
-		testSourceDir = join(tmpdir(), `test-source-${timestamp}`);
-		testDestDir = join(tmpdir(), `test-dest-${timestamp}`);
-
-		await mkdir(testSourceDir, { recursive: true });
-		await mkdir(testDestDir, { recursive: true });
-	});
-
-	afterEach(async () => {
-		// Cleanup test directories
-		if (existsSync(testSourceDir)) {
-			await rm(testSourceDir, { recursive: true, force: true });
-		}
-		if (existsSync(testDestDir)) {
-			await rm(testDestDir, { recursive: true, force: true });
-		}
-	});
-
-	describe("constructor", () => {
-		test("should create FileMerger instance", () => {
-			expect(merger).toBeInstanceOf(FileMerger);
-		});
-	});
-
-	describe("addIgnorePatterns", () => {
-		test("should add custom ignore patterns", () => {
-			const patterns = ["*.log", "temp/**"];
-			expect(() => merger.addIgnorePatterns(patterns)).not.toThrow();
-		});
-
-		test("should accept empty array", () => {
-			expect(() => merger.addIgnorePatterns([])).not.toThrow();
-		});
-	});
-
-	describe("merge with skipConfirmation", () => {
-		test("should copy files from source to destination", async () => {
-			// Create test files
-			await writeFile(join(testSourceDir, "test.txt"), "test content");
-			await writeFile(join(testSourceDir, "readme.md"), "# README");
-
-			await merger.merge(testSourceDir, testDestDir, true);
-
-			// Verify files were copied
-			expect(existsSync(join(testDestDir, "test.txt"))).toBe(true);
-			expect(existsSync(join(testDestDir, "readme.md"))).toBe(true);
-		});
-
-		test("should skip protected files like .env if they exist in destination", async () => {
-			// Create test files in source
-			await writeFile(join(testSourceDir, "normal.txt"), "normal");
-			await writeFile(join(testSourceDir, ".env"), "NEW_SECRET=new_value");
-
-			// Create existing .env in destination
-			await writeFile(join(testDestDir, ".env"), "OLD_SECRET=old_value");
-
-			await merger.merge(testSourceDir, testDestDir, true);
-
-			// Verify normal file was copied
-			expect(existsSync(join(testDestDir, "normal.txt"))).toBe(true);
-
-			// Verify .env was NOT overwritten (still has old value)
-			const envContent = await Bun.file(join(testDestDir, ".env")).text();
-			expect(envContent).toBe("OLD_SECRET=old_value");
-		});
-
-		test("should copy protected files like .env if they don't exist in destination", async () => {
-			// Create test files in source
-			await writeFile(join(testSourceDir, "normal.txt"), "normal");
-			await writeFile(join(testSourceDir, ".env"), "SECRET=value");
-
-			await merger.merge(testSourceDir, testDestDir, true);
-
-			// Verify both files were copied (no existing .env to protect)
-			expect(existsSync(join(testDestDir, "normal.txt"))).toBe(true);
-			expect(existsSync(join(testDestDir, ".env"))).toBe(true);
-		});
-
-		test("should skip protected patterns like *.key if they exist in destination", async () => {
-			await writeFile(join(testSourceDir, "normal.txt"), "normal");
-			await writeFile(join(testSourceDir, "private.key"), "new key data");
-
-			// Create existing key file in destination
-			await writeFile(join(testDestDir, "private.key"), "old key data");
-
-			await merger.merge(testSourceDir, testDestDir, true);
-
-			expect(existsSync(join(testDestDir, "normal.txt"))).toBe(true);
-
-			// Verify key file was NOT overwritten
-			const keyContent = await Bun.file(join(testDestDir, "private.key")).text();
-			expect(keyContent).toBe("old key data");
-		});
-
-		test("should copy protected patterns like *.key if they don't exist in destination", async () => {
-			await writeFile(join(testSourceDir, "normal.txt"), "normal");
-			await writeFile(join(testSourceDir, "private.key"), "key data");
-
-			await merger.merge(testSourceDir, testDestDir, true);
-
-			expect(existsSync(join(testDestDir, "normal.txt"))).toBe(true);
-			expect(existsSync(join(testDestDir, "private.key"))).toBe(true);
-		});
-
-		test("should handle nested directories", async () => {
-			const nestedDir = join(testSourceDir, "nested", "deep");
-			await mkdir(nestedDir, { recursive: true });
-			await writeFile(join(nestedDir, "file.txt"), "nested content");
-
-			await merger.merge(testSourceDir, testDestDir, true);
-
-			expect(existsSync(join(testDestDir, "nested", "deep", "file.txt"))).toBe(true);
-		});
-
-		test("should overwrite existing files", async () => {
-			// Create files in both directories
-			await writeFile(join(testSourceDir, "file.txt"), "new content");
-			await writeFile(join(testDestDir, "file.txt"), "old content");
-
-			await merger.merge(testSourceDir, testDestDir, true);
-
-			const content = await Bun.file(join(testDestDir, "file.txt")).text();
-			expect(content).toBe("new content");
-		});
-
-		test("should handle empty source directory", async () => {
-			// Empty directory should complete without errors
-			await merger.merge(testSourceDir, testDestDir, true);
-			// If we get here, the test passed
-			expect(true).toBe(true);
-		});
-	});
-
-	describe("edge cases", () => {
-		test("should handle files with special characters in names", async () => {
-			const specialFileName = "file with spaces.txt";
-			await writeFile(join(testSourceDir, specialFileName), "content");
-
-			await merger.merge(testSourceDir, testDestDir, true);
-
-			expect(existsSync(join(testDestDir, specialFileName))).toBe(true);
-		});
-
-		test("should skip custom ignore patterns if they exist in destination", async () => {
-			merger.addIgnorePatterns(["custom-*"]);
-
-			await writeFile(join(testSourceDir, "normal.txt"), "normal");
-			await writeFile(join(testSourceDir, "custom-ignore.txt"), "new content");
-
-			// Create existing file in destination
-			await writeFile(join(testDestDir, "custom-ignore.txt"), "old content");
-
-			await merger.merge(testSourceDir, testDestDir, true);
-
-			expect(existsSync(join(testDestDir, "normal.txt"))).toBe(true);
-
-			// Verify custom file was NOT overwritten
-			const customContent = await Bun.file(join(testDestDir, "custom-ignore.txt")).text();
-			expect(customContent).toBe("old content");
-		});
-
-		test("should copy custom ignore patterns if they don't exist in destination", async () => {
-			merger.addIgnorePatterns(["custom-*"]);
-
-			await writeFile(join(testSourceDir, "normal.txt"), "normal");
-			await writeFile(join(testSourceDir, "custom-ignore.txt"), "ignore me");
-
-			await merger.merge(testSourceDir, testDestDir, true);
-
-			expect(existsSync(join(testDestDir, "normal.txt"))).toBe(true);
-			expect(existsSync(join(testDestDir, "custom-ignore.txt"))).toBe(true);
-		});
-	});
-
-	describe("custom .claude file preservation", () => {
-		test("should preserve custom .claude files when patterns are added", async () => {
-			// Create .claude directories
-			const sourceClaudeDir = join(testSourceDir, ".claude");
-			const destClaudeDir = join(testDestDir, ".claude");
-			await mkdir(sourceClaudeDir, { recursive: true });
-			await mkdir(destClaudeDir, { recursive: true });
-
-			// Create files in source (from release package)
-			await writeFile(join(sourceClaudeDir, "standard.md"), "standard content");
-
-			// Create files in destination (existing + custom)
-			await writeFile(join(destClaudeDir, "standard.md"), "old standard content");
-			await writeFile(join(destClaudeDir, "custom.md"), "custom content");
-
-			// Add custom file to ignore patterns (this would be done by update.ts)
-			merger.addIgnorePatterns([".claude/custom.md"]);
-
-			await merger.merge(testSourceDir, testDestDir, true);
-
-			// Standard file should be overwritten
-			const standardContent = await Bun.file(join(destClaudeDir, "standard.md")).text();
-			expect(standardContent).toBe("standard content");
-
-			// Custom file should be preserved
-			expect(existsSync(join(destClaudeDir, "custom.md"))).toBe(true);
-			const customContent = await Bun.file(join(destClaudeDir, "custom.md")).text();
-			expect(customContent).toBe("custom content");
-		});
-
-		test("should preserve nested custom .claude files", async () => {
-			// Create nested .claude structure
-			const sourceCommandsDir = join(testSourceDir, ".claude", "commands");
-			const destCommandsDir = join(testDestDir, ".claude", "commands");
-			await mkdir(sourceCommandsDir, { recursive: true });
-			await mkdir(destCommandsDir, { recursive: true });
-
-			// Create standard file in source
-			await writeFile(join(sourceCommandsDir, "standard-cmd.md"), "standard command");
-
-			// Create custom file in destination
-			await writeFile(join(destCommandsDir, "custom-cmd.md"), "custom command");
-
-			// Add custom file to ignore patterns
-			merger.addIgnorePatterns([".claude/commands/custom-cmd.md"]);
-
-			await merger.merge(testSourceDir, testDestDir, true);
-
-			// Custom file should be preserved
-			expect(existsSync(join(destCommandsDir, "custom-cmd.md"))).toBe(true);
-			const customContent = await Bun.file(join(destCommandsDir, "custom-cmd.md")).text();
-			expect(customContent).toBe("custom command");
-		});
-
-		test("should preserve multiple custom .claude files", async () => {
-			const sourceClaudeDir = join(testSourceDir, ".claude");
-			const destClaudeDir = join(testDestDir, ".claude");
-			await mkdir(sourceClaudeDir, { recursive: true });
-			await mkdir(destClaudeDir, { recursive: true });
-
-			// Create multiple custom files in destination
-			await writeFile(join(destClaudeDir, "custom1.md"), "custom1");
-			await writeFile(join(destClaudeDir, "custom2.md"), "custom2");
-			await writeFile(join(destClaudeDir, "custom3.md"), "custom3");
-
-			// Add all custom files to ignore patterns
-			merger.addIgnorePatterns([".claude/custom1.md", ".claude/custom2.md", ".claude/custom3.md"]);
-
-			await merger.merge(testSourceDir, testDestDir, true);
-
-			// All custom files should be preserved
-			expect(existsSync(join(destClaudeDir, "custom1.md"))).toBe(true);
-			expect(existsSync(join(destClaudeDir, "custom2.md"))).toBe(true);
-			expect(existsSync(join(destClaudeDir, "custom3.md"))).toBe(true);
-		});
-	});
-});

package/tests/lib/prompts.test.ts

@@ -1,66 +0,0 @@
-import { beforeEach, describe, expect, test } from "bun:test";
-import { PromptsManager } from "../../src/lib/prompts.js";
-import { AVAILABLE_KITS } from "../../src/types.js";
-
-describe("PromptsManager", () => {
-	let manager: PromptsManager;
-
-	beforeEach(() => {
-		manager = new PromptsManager();
-	});
-
-	describe("constructor", () => {
-		test("should create PromptsManager instance", () => {
-			expect(manager).toBeInstanceOf(PromptsManager);
-		});
-	});
-
-	describe("utility methods", () => {
-		test("intro should not throw", () => {
-			expect(() => manager.intro("Test intro")).not.toThrow();
-		});
-
-		test("outro should not throw", () => {
-			expect(() => manager.outro("Test outro")).not.toThrow();
-		});
-
-		test("note should not throw", () => {
-			expect(() => manager.note("Test note", "Title")).not.toThrow();
-		});
-
-		test("note should work without title", () => {
-			expect(() => manager.note("Test note")).not.toThrow();
-		});
-	});
-
-	// Note: Interactive prompt tests (selectKit, selectVersion, getDirectory, confirm)
-	// would require mocking the @clack/prompts library or using integration tests
-	// with simulated user input. These are better suited for e2e testing.
-
-	describe("validation logic", () => {
-		test("selectVersion should handle empty versions array", async () => {
-			await expect(manager.selectVersion([], undefined)).rejects.toThrow("No versions available");
-		});
-
-		test("selectVersion should return first version when only one exists", async () => {
-			const versions = ["v1.0.0"];
-			const result = await manager.selectVersion(versions);
-			expect(result).toBe("v1.0.0");
-		});
-
-		test("selectVersion should return first version when no default is provided", async () => {
-			const versions = ["v1.0.0", "v2.0.0"];
-			const result = await manager.selectVersion(versions);
-			expect(result).toBe("v1.0.0");
-		});
-	});
-
-	describe("kit configuration", () => {
-		test("AVAILABLE_KITS should be properly structured", () => {
-			expect(AVAILABLE_KITS.engineer).toBeDefined();
-			expect(AVAILABLE_KITS.marketing).toBeDefined();
-			expect(AVAILABLE_KITS.engineer.name).toBe("ClaudeKit Engineer");
-			expect(AVAILABLE_KITS.marketing.name).toBe("ClaudeKit Marketing");
-		});
-	});
-});

package/tests/types.test.ts

@@ -1,337 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import {
-	AVAILABLE_KITS,
-	AuthenticationError,
-	ClaudeKitError,
-	ConfigSchema,
-	DownloadError,
-	ExcludePatternSchema,
-	ExtractionError,
-	GitHubError,
-	GitHubReleaseAssetSchema,
-	GitHubReleaseSchema,
-	KitConfigSchema,
-	KitType,
-	NewCommandOptionsSchema,
-	UpdateCommandOptionsSchema,
-} from "../src/types.js";
-
-describe("Types and Schemas", () => {
-	describe("KitType", () => {
-		test("should validate correct kit types", () => {
-			expect(KitType.parse("engineer")).toBe("engineer");
-			expect(KitType.parse("marketing")).toBe("marketing");
-		});
-
-		test("should reject invalid kit types", () => {
-			expect(() => KitType.parse("invalid")).toThrow();
-			expect(() => KitType.parse("")).toThrow();
-			expect(() => KitType.parse(123)).toThrow();
-		});
-	});
-
-	describe("ExcludePatternSchema", () => {
-		test("should accept valid glob patterns", () => {
-			const validPatterns = ["*.log", "**/*.tmp", "temp/**", "logs/*.txt", "cache/**/*"];
-			validPatterns.forEach((pattern) => {
-				expect(() => ExcludePatternSchema.parse(pattern)).not.toThrow();
-			});
-		});
-
-		test("should reject absolute paths", () => {
-			expect(() => ExcludePatternSchema.parse("/etc/passwd")).toThrow("Absolute paths not allowed");
-			expect(() => ExcludePatternSchema.parse("/var/log/**")).toThrow("Absolute paths not allowed");
-		});
-
-		test("should reject path traversal", () => {
-			expect(() => ExcludePatternSchema.parse("../../etc/passwd")).toThrow(
-				"Path traversal not allowed",
-			);
-			expect(() => ExcludePatternSchema.parse("../../../secret")).toThrow(
-				"Path traversal not allowed",
-			);
-		});
-
-		test("should reject empty patterns", () => {
-			expect(() => ExcludePatternSchema.parse("")).toThrow("Exclude pattern cannot be empty");
-			expect(() => ExcludePatternSchema.parse("   ")).toThrow("Exclude pattern cannot be empty");
-		});
-
-		test("should reject overly long patterns", () => {
-			const longPattern = "a".repeat(501);
-			expect(() => ExcludePatternSchema.parse(longPattern)).toThrow("Exclude pattern too long");
-		});
-
-		test("should trim whitespace", () => {
-			const result = ExcludePatternSchema.parse("  *.log  ");
-			expect(result).toBe("*.log");
-		});
-	});
-
-	describe("NewCommandOptionsSchema", () => {
-		test("should validate correct options", () => {
-			const result = NewCommandOptionsSchema.parse({
-				dir: "./test",
-				kit: "engineer",
-				version: "v1.0.0",
-			});
-			expect(result.dir).toBe("./test");
-			expect(result.kit).toBe("engineer");
-			expect(result.version).toBe("v1.0.0");
-		});
-
-		test("should use default values", () => {
-			const result = NewCommandOptionsSchema.parse({});
-			expect(result.dir).toBe(".");
-			expect(result.kit).toBeUndefined();
-			expect(result.version).toBeUndefined();
-			expect(result.exclude).toEqual([]);
-		});
-
-		test("should accept optional fields", () => {
-			const result = NewCommandOptionsSchema.parse({ dir: "./custom" });
-			expect(result.dir).toBe("./custom");
-			expect(result.kit).toBeUndefined();
-		});
-
-		test("should validate exclude patterns", () => {
-			const result = NewCommandOptionsSchema.parse({
-				dir: "./test",
-				exclude: ["*.log", "temp/**"],
-			});
-			expect(result.exclude).toEqual(["*.log", "temp/**"]);
-		});
-
-		test("should reject invalid exclude patterns", () => {
-			expect(() =>
-				NewCommandOptionsSchema.parse({
-					dir: "./test",
-					exclude: ["/etc/passwd"],
-				}),
-			).toThrow();
-		});
-	});
-
-	describe("UpdateCommandOptionsSchema", () => {
-		test("should validate correct options", () => {
-			const result = UpdateCommandOptionsSchema.parse({
-				dir: "./test",
-				kit: "engineer",
-				version: "v2.0.0",
-			});
-			expect(result.dir).toBe("./test");
-			expect(result.kit).toBe("engineer");
-			expect(result.version).toBe("v2.0.0");
-		});
-
-		test("should use default values", () => {
-			const result = UpdateCommandOptionsSchema.parse({});
-			expect(result.dir).toBe(".");
-			expect(result.exclude).toEqual([]);
-		});
-
-		test("should validate exclude patterns", () => {
-			const result = UpdateCommandOptionsSchema.parse({
-				dir: "./test",
-				exclude: ["*.log", "**/*.tmp"],
-			});
-			expect(result.exclude).toEqual(["*.log", "**/*.tmp"]);
-		});
-
-		test("should reject invalid exclude patterns", () => {
-			expect(() =>
-				UpdateCommandOptionsSchema.parse({
-					dir: "./test",
-					exclude: ["../../../etc"],
-				}),
-			).toThrow();
-		});
-	});
-
-	describe("ConfigSchema", () => {
-		test("should validate complete config", () => {
-			const config = {
-				github: {
-					token: "ghp_test123456789",
-				},
-				defaults: {
-					kit: "engineer",
-					dir: "./projects",
-				},
-			};
-			const result = ConfigSchema.parse(config);
-			expect(result.github?.token).toBe("ghp_test123456789");
-			expect(result.defaults?.kit).toBe("engineer");
-			expect(result.defaults?.dir).toBe("./projects");
-		});
-
-		test("should validate empty config", () => {
-			const result = ConfigSchema.parse({});
-			expect(result.github).toBeUndefined();
-			expect(result.defaults).toBeUndefined();
-		});
-
-		test("should validate partial config", () => {
-			const result = ConfigSchema.parse({ github: {} });
-			expect(result.github).toEqual({});
-			expect(result.defaults).toBeUndefined();
-		});
-	});
-
-	describe("GitHubReleaseAssetSchema", () => {
-		test("should validate correct asset", () => {
-			const asset = {
-				id: 123,
-				name: "release.tar.gz",
-				url: "https://api.github.com/repos/test/repo/releases/assets/123",
-				browser_download_url: "https://github.com/test/release.tar.gz",
-				size: 1024,
-				content_type: "application/gzip",
-			};
-			const result = GitHubReleaseAssetSchema.parse(asset);
-			expect(result.id).toBe(123);
-			expect(result.name).toBe("release.tar.gz");
-			expect(result.size).toBe(1024);
-		});
-
-		test("should reject invalid URL", () => {
-			const asset = {
-				id: 123,
-				name: "release.tar.gz",
-				url: "not-a-url",
-				browser_download_url: "not-a-url",
-				size: 1024,
-				content_type: "application/gzip",
-			};
-			expect(() => GitHubReleaseAssetSchema.parse(asset)).toThrow();
-		});
-
-		test("should reject missing required fields", () => {
-			const asset = {
-				id: 123,
-				name: "release.tar.gz",
-			};
-			expect(() => GitHubReleaseAssetSchema.parse(asset)).toThrow();
-		});
-	});
-
-	describe("GitHubReleaseSchema", () => {
-		test("should validate complete release", () => {
-			const release = {
-				id: 1,
-				tag_name: "v1.0.0",
-				name: "Version 1.0.0",
-				draft: false,
-				prerelease: false,
-				assets: [
-					{
-						id: 123,
-						name: "release.tar.gz",
-						url: "https://api.github.com/repos/test/repo/releases/assets/123",
-						browser_download_url: "https://github.com/test/release.tar.gz",
-						size: 1024,
-						content_type: "application/gzip",
-					},
-				],
-				published_at: "2024-01-01T00:00:00Z",
-				tarball_url: "https://api.github.com/repos/test/test-repo/tarball/v1.0.0",
-				zipball_url: "https://api.github.com/repos/test/test-repo/zipball/v1.0.0",
-			};
-			const result = GitHubReleaseSchema.parse(release);
-			expect(result.id).toBe(1);
-			expect(result.tag_name).toBe("v1.0.0");
-			expect(result.assets).toHaveLength(1);
-		});
-
-		test("should validate release without published_at", () => {
-			const release = {
-				id: 1,
-				tag_name: "v1.0.0",
-				name: "Version 1.0.0",
-				draft: false,
-				prerelease: false,
-				assets: [],
-				tarball_url: "https://api.github.com/repos/test/test-repo/tarball/v1.0.0",
-				zipball_url: "https://api.github.com/repos/test/test-repo/zipball/v1.0.0",
-			};
-			const result = GitHubReleaseSchema.parse(release);
-			expect(result.published_at).toBeUndefined();
-		});
-	});
-
-	describe("KitConfigSchema", () => {
-		test("should validate correct kit config", () => {
-			const config = {
-				name: "Test Kit",
-				repo: "test-repo",
-				owner: "test-owner",
-				description: "Test description",
-			};
-			const result = KitConfigSchema.parse(config);
-			expect(result.name).toBe("Test Kit");
-			expect(result.repo).toBe("test-repo");
-		});
-
-		test("should reject missing fields", () => {
-			const config = {
-				name: "Test Kit",
-				repo: "test-repo",
-			};
-			expect(() => KitConfigSchema.parse(config)).toThrow();
-		});
-	});
-
-	describe("AVAILABLE_KITS", () => {
-		test("should have engineer kit", () => {
-			expect(AVAILABLE_KITS.engineer).toBeDefined();
-			expect(AVAILABLE_KITS.engineer.name).toBe("ClaudeKit Engineer");
-			expect(AVAILABLE_KITS.engineer.repo).toBe("claudekit-engineer");
-		});
-
-		test("should have marketing kit", () => {
-			expect(AVAILABLE_KITS.marketing).toBeDefined();
-			expect(AVAILABLE_KITS.marketing.name).toBe("ClaudeKit Marketing");
-			expect(AVAILABLE_KITS.marketing.repo).toBe("claudekit-marketing");
-		});
-	});
-
-	describe("Custom Error Classes", () => {
-		test("ClaudeKitError should store code and statusCode", () => {
-			const error = new ClaudeKitError("Test error", "TEST_CODE", 500);
-			expect(error.message).toBe("Test error");
-			expect(error.code).toBe("TEST_CODE");
-			expect(error.statusCode).toBe(500);
-			expect(error.name).toBe("ClaudeKitError");
-		});
-
-		test("AuthenticationError should set correct defaults", () => {
-			const error = new AuthenticationError("Auth failed");
-			expect(error.message).toBe("Auth failed");
-			expect(error.code).toBe("AUTH_ERROR");
-			expect(error.statusCode).toBe(401);
-			expect(error.name).toBe("AuthenticationError");
-		});
-
-		test("GitHubError should store statusCode", () => {
-			const error = new GitHubError("GitHub failed", 404);
-			expect(error.message).toBe("GitHub failed");
-			expect(error.code).toBe("GITHUB_ERROR");
-			expect(error.statusCode).toBe(404);
-			expect(error.name).toBe("GitHubError");
-		});
-
-		test("DownloadError should have correct code", () => {
-			const error = new DownloadError("Download failed");
-			expect(error.message).toBe("Download failed");
-			expect(error.code).toBe("DOWNLOAD_ERROR");
-			expect(error.name).toBe("DownloadError");
-		});
-
-		test("ExtractionError should have correct code", () => {
-			const error = new ExtractionError("Extract failed");
-			expect(error.message).toBe("Extract failed");
-			expect(error.code).toBe("EXTRACTION_ERROR");
-			expect(error.name).toBe("ExtractionError");
-		});
-	});
-});