claudekit-cli 1.0.0

package/tests/lib/merge.test.ts

@@ -0,0 +1,138 @@
+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", async () => {
+			// Create test files including protected ones
+			await writeFile(join(testSourceDir, "normal.txt"), "normal");
+			await writeFile(join(testSourceDir, ".env"), "SECRET=value");
+
+			await merger.merge(testSourceDir, testDestDir, true);
+
+			// Verify normal file was copied but .env was not
+			expect(existsSync(join(testDestDir, "normal.txt"))).toBe(true);
+			expect(existsSync(join(testDestDir, ".env"))).toBe(false);
+		});
+
+		test("should skip protected patterns like *.key", 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(false);
+		});
+
+		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", 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(false);
+		});
+	});
+});

package/tests/lib/prompts.test.ts

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

@@ -0,0 +1,255 @@
+import { describe, expect, test } from "bun:test";
+import {
+	AVAILABLE_KITS,
+	AuthenticationError,
+	ClaudeKitError,
+	ConfigSchema,
+	DownloadError,
+	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("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();
+		});
+
+		test("should accept optional fields", () => {
+			const result = NewCommandOptionsSchema.parse({ dir: "./custom" });
+			expect(result.dir).toBe("./custom");
+			expect(result.kit).toBeUndefined();
+		});
+	});
+
+	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(".");
+		});
+	});
+
+	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",
+				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",
+				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",
+						browser_download_url: "https://github.com/test/release.tar.gz",
+						size: 1024,
+						content_type: "application/gzip",
+					},
+				],
+				published_at: "2024-01-01T00:00:00Z",
+			};
+			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: [],
+			};
+			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");
+		});
+	});
+});