claudekit-cli 1.4.0 → 1.5.0

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");
-		});
-	});
-});

package/tests/utils/config.test.ts

@@ -1,263 +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 { homedir } from "node:os";
-import { join } from "node:path";
-import type { Config } from "../../src/types.js";
-import { ConfigManager } from "../../src/utils/config.js";
-
-const TEST_CONFIG_DIR = join(homedir(), ".claudekit-test");
-const TEST_CONFIG_FILE = join(TEST_CONFIG_DIR, "config.json");
-
-describe("ConfigManager", () => {
-	beforeEach(async () => {
-		// Create test config directory
-		if (!existsSync(TEST_CONFIG_DIR)) {
-			await mkdir(TEST_CONFIG_DIR, { recursive: true });
-		}
-
-		// Override config paths for testing
-		// Note: This is a simplified test - in production we'd need to mock the paths
-	});
-
-	afterEach(async () => {
-		// Clean up test config directory
-		if (existsSync(TEST_CONFIG_DIR)) {
-			await rm(TEST_CONFIG_DIR, { recursive: true, force: true });
-		}
-
-		// Reset ConfigManager state
-		(ConfigManager as any).config = null;
-	});
-
-	describe("load", () => {
-		test("should return default config when no config file exists", async () => {
-			const config = await ConfigManager.load();
-			expect(config).toEqual({ github: {}, defaults: {} });
-		});
-
-		test("should load config from file when it exists", async () => {
-			const testConfig: Config = {
-				github: { token: "test-token" },
-				defaults: { kit: "engineer", dir: "./test" },
-			};
-
-			// Write test config file (to actual location for this test)
-			const actualConfigDir = join(homedir(), ".claudekit");
-			const actualConfigFile = join(actualConfigDir, "config.json");
-
-			if (!existsSync(actualConfigDir)) {
-				await mkdir(actualConfigDir, { recursive: true });
-			}
-			await writeFile(actualConfigFile, JSON.stringify(testConfig));
-
-			try {
-				const config = await ConfigManager.load();
-				expect(config.github?.token).toBe("test-token");
-				expect(config.defaults?.kit).toBe("engineer");
-			} finally {
-				// Cleanup
-				if (existsSync(actualConfigFile)) {
-					await rm(actualConfigFile);
-				}
-			}
-		});
-
-		test("should return default config on invalid JSON", async () => {
-			const actualConfigDir = join(homedir(), ".claudekit");
-			const actualConfigFile = join(actualConfigDir, "config.json");
-
-			if (!existsSync(actualConfigDir)) {
-				await mkdir(actualConfigDir, { recursive: true });
-			}
-			await writeFile(actualConfigFile, "invalid json");
-
-			try {
-				const config = await ConfigManager.load();
-				expect(config).toEqual({ github: {}, defaults: {} });
-			} finally {
-				// Cleanup
-				if (existsSync(actualConfigFile)) {
-					await rm(actualConfigFile);
-				}
-			}
-		});
-
-		test("should cache config after first load", async () => {
-			const config1 = await ConfigManager.load();
-			const config2 = await ConfigManager.load();
-			expect(config1).toBe(config2); // Same reference
-		});
-	});
-
-	describe("save", () => {
-		test("should save valid config to file", async () => {
-			const testConfig: Config = {
-				github: { token: "test-token" },
-				defaults: { kit: "marketing", dir: "./projects" },
-			};
-
-			await ConfigManager.save(testConfig);
-
-			// Verify file was created
-			const actualConfigFile = join(homedir(), ".claudekit", "config.json");
-			expect(existsSync(actualConfigFile)).toBe(true);
-
-			// Cleanup
-			if (existsSync(actualConfigFile)) {
-				await rm(actualConfigFile);
-			}
-			const actualConfigDir = join(homedir(), ".claudekit");
-			if (existsSync(actualConfigDir)) {
-				await rm(actualConfigDir, { recursive: true });
-			}
-		});
-
-		test("should create config directory if it does not exist", async () => {
-			const actualConfigDir = join(homedir(), ".claudekit");
-			if (existsSync(actualConfigDir)) {
-				await rm(actualConfigDir, { recursive: true });
-			}
-
-			const testConfig: Config = { github: {}, defaults: {} };
-			await ConfigManager.save(testConfig);
-
-			expect(existsSync(actualConfigDir)).toBe(true);
-
-			// Cleanup
-			if (existsSync(actualConfigDir)) {
-				await rm(actualConfigDir, { recursive: true });
-			}
-		});
-
-		test("should throw error on invalid config", async () => {
-			const invalidConfig = {
-				github: { token: 123 }, // Invalid: should be string
-			};
-
-			await expect(ConfigManager.save(invalidConfig as any)).rejects.toThrow();
-		});
-
-		test("should update cached config", async () => {
-			const testConfig: Config = {
-				github: { token: "new-token" },
-				defaults: {},
-			};
-
-			await ConfigManager.save(testConfig);
-			const loaded = await ConfigManager.get();
-			expect(loaded.github?.token).toBe("new-token");
-
-			// Cleanup
-			const actualConfigFile = join(homedir(), ".claudekit", "config.json");
-			const actualConfigDir = join(homedir(), ".claudekit");
-			if (existsSync(actualConfigFile)) {
-				await rm(actualConfigFile);
-			}
-			if (existsSync(actualConfigDir)) {
-				await rm(actualConfigDir, { recursive: true });
-			}
-		});
-	});
-
-	describe("get", () => {
-		test("should return current config", async () => {
-			const config = await ConfigManager.get();
-			expect(config).toBeDefined();
-			expect(config).toHaveProperty("github");
-			expect(config).toHaveProperty("defaults");
-		});
-	});
-
-	describe("set", () => {
-		test("should set nested config value", async () => {
-			await ConfigManager.set("github.token", "test-token-123");
-			const config = await ConfigManager.get();
-			expect(config.github?.token).toBe("test-token-123");
-
-			// Cleanup
-			const actualConfigFile = join(homedir(), ".claudekit", "config.json");
-			const actualConfigDir = join(homedir(), ".claudekit");
-			if (existsSync(actualConfigFile)) {
-				await rm(actualConfigFile);
-			}
-			if (existsSync(actualConfigDir)) {
-				await rm(actualConfigDir, { recursive: true });
-			}
-		});
-
-		test("should create nested objects if they do not exist", async () => {
-			await ConfigManager.set("defaults.kit", "engineer");
-			const config = await ConfigManager.get();
-			expect(config.defaults?.kit).toBe("engineer");
-
-			// Cleanup
-			const actualConfigFile = join(homedir(), ".claudekit", "config.json");
-			const actualConfigDir = join(homedir(), ".claudekit");
-			if (existsSync(actualConfigFile)) {
-				await rm(actualConfigFile);
-			}
-			if (existsSync(actualConfigDir)) {
-				await rm(actualConfigDir, { recursive: true });
-			}
-		});
-
-		test("should handle multiple nested levels", async () => {
-			await ConfigManager.set("defaults.dir", "/test/path");
-			const config = await ConfigManager.get();
-			expect(config.defaults?.dir).toBe("/test/path");
-
-			// Cleanup
-			const actualConfigFile = join(homedir(), ".claudekit", "config.json");
-			const actualConfigDir = join(homedir(), ".claudekit");
-			if (existsSync(actualConfigFile)) {
-				await rm(actualConfigFile);
-			}
-			if (existsSync(actualConfigDir)) {
-				await rm(actualConfigDir, { recursive: true });
-			}
-		});
-	});
-
-	describe("getToken", () => {
-		test("should return token from config", async () => {
-			await ConfigManager.setToken("test-token-456");
-			const token = await ConfigManager.getToken();
-			expect(token).toBe("test-token-456");
-
-			// Cleanup
-			const actualConfigFile = join(homedir(), ".claudekit", "config.json");
-			const actualConfigDir = join(homedir(), ".claudekit");
-			if (existsSync(actualConfigFile)) {
-				await rm(actualConfigFile);
-			}
-			if (existsSync(actualConfigDir)) {
-				await rm(actualConfigDir, { recursive: true });
-			}
-		});
-
-		test("should return undefined if no token is set", async () => {
-			(ConfigManager as any).config = null;
-			const token = await ConfigManager.getToken();
-			expect(token).toBeUndefined();
-		});
-	});
-
-	describe("setToken", () => {
-		test("should set token in config", async () => {
-			await ConfigManager.setToken("new-test-token");
-			const config = await ConfigManager.get();
-			expect(config.github?.token).toBe("new-test-token");
-
-			// Cleanup
-			const actualConfigFile = join(homedir(), ".claudekit", "config.json");
-			const actualConfigDir = join(homedir(), ".claudekit");
-			if (existsSync(actualConfigFile)) {
-				await rm(actualConfigFile);
-			}
-			if (existsSync(actualConfigDir)) {
-				await rm(actualConfigDir, { recursive: true });
-			}
-		});
-	});
-});