claudekit-cli 1.4.1 → 1.5.0

package/tests/commands/version.test.ts

@@ -1,297 +0,0 @@
-import { beforeEach, describe, expect, mock, test } from "bun:test";
-import type { GitHubRelease } from "../../src/types.js";
-import { AVAILABLE_KITS, VersionCommandOptionsSchema } from "../../src/types.js";
-
-describe("Version Command", () => {
-	beforeEach(() => {
-		// Set environment variable to avoid auth prompts during tests
-		process.env.GITHUB_TOKEN = "ghp_test_token_for_testing";
-	});
-
-	describe("VersionCommandOptionsSchema", () => {
-		test("should accept valid options with kit filter", () => {
-			const options = { kit: "engineer" as const };
-			const result = VersionCommandOptionsSchema.parse(options);
-			expect(result.kit).toBe("engineer");
-		});
-
-		test("should accept valid options with limit", () => {
-			const options = { limit: 10 };
-			const result = VersionCommandOptionsSchema.parse(options);
-			expect(result.limit).toBe(10);
-		});
-
-		test("should accept valid options with all flag", () => {
-			const options = { all: true };
-			const result = VersionCommandOptionsSchema.parse(options);
-			expect(result.all).toBe(true);
-		});
-
-		test("should accept all options combined", () => {
-			const options = { kit: "marketing" as const, limit: 20, all: true };
-			const result = VersionCommandOptionsSchema.parse(options);
-			expect(result.kit).toBe("marketing");
-			expect(result.limit).toBe(20);
-			expect(result.all).toBe(true);
-		});
-
-		test("should accept empty options", () => {
-			const options = {};
-			const result = VersionCommandOptionsSchema.parse(options);
-			expect(result.kit).toBeUndefined();
-			expect(result.limit).toBeUndefined();
-			expect(result.all).toBeUndefined();
-		});
-
-		test("should reject invalid kit type", () => {
-			const options = { kit: "invalid" };
-			expect(() => VersionCommandOptionsSchema.parse(options)).toThrow();
-		});
-	});
-
-	describe("Kit Configuration", () => {
-		test("should have engineer kit configured", () => {
-			const engineerKit = AVAILABLE_KITS.engineer;
-			expect(engineerKit.name).toBe("ClaudeKit Engineer");
-			expect(engineerKit.repo).toBe("claudekit-engineer");
-			expect(engineerKit.owner).toBe("claudekit");
-		});
-
-		test("should have marketing kit configured", () => {
-			const marketingKit = AVAILABLE_KITS.marketing;
-			expect(marketingKit.name).toBe("ClaudeKit Marketing");
-			expect(marketingKit.repo).toBe("claudekit-marketing");
-			expect(marketingKit.owner).toBe("claudekit");
-		});
-	});
-
-	describe("Release Data Handling", () => {
-		test("should handle release with all fields", () => {
-			const release: GitHubRelease = {
-				id: 1,
-				tag_name: "v1.0.0",
-				name: "Release 1.0.0",
-				draft: false,
-				prerelease: false,
-				assets: [],
-				published_at: "2024-01-01T00:00:00Z",
-			};
-
-			expect(release.tag_name).toBe("v1.0.0");
-			expect(release.name).toBe("Release 1.0.0");
-			expect(release.draft).toBe(false);
-			expect(release.prerelease).toBe(false);
-		});
-
-		test("should handle release without published_at", () => {
-			const release: GitHubRelease = {
-				id: 1,
-				tag_name: "v1.0.0",
-				name: "Release 1.0.0",
-				draft: false,
-				prerelease: false,
-				assets: [],
-			};
-
-			expect(release.published_at).toBeUndefined();
-		});
-
-		test("should handle draft release", () => {
-			const release: GitHubRelease = {
-				id: 1,
-				tag_name: "v1.0.0-draft",
-				name: "Draft Release",
-				draft: true,
-				prerelease: false,
-				assets: [],
-			};
-
-			expect(release.draft).toBe(true);
-		});
-
-		test("should handle prerelease", () => {
-			const release: GitHubRelease = {
-				id: 1,
-				tag_name: "v1.0.0-beta.1",
-				name: "Beta Release",
-				draft: false,
-				prerelease: true,
-				assets: [],
-			};
-
-			expect(release.prerelease).toBe(true);
-		});
-	});
-
-	describe("Date Formatting", () => {
-		test("should format recent dates correctly", () => {
-			const now = new Date();
-			const yesterday = new Date(now.getTime() - 24 * 60 * 60 * 1000);
-			const dateString = yesterday.toISOString();
-
-			// The actual formatting logic is in the command file
-			// We just verify the date string is valid
-			expect(dateString).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/);
-		});
-
-		test("should handle undefined date", () => {
-			const dateString = undefined;
-			expect(dateString).toBeUndefined();
-		});
-	});
-
-	describe("Release Filtering", () => {
-		const releases: GitHubRelease[] = [
-			{
-				id: 1,
-				tag_name: "v1.0.0",
-				name: "Stable Release",
-				draft: false,
-				prerelease: false,
-				assets: [],
-				published_at: "2024-01-01T00:00:00Z",
-			},
-			{
-				id: 2,
-				tag_name: "v1.1.0-beta.1",
-				name: "Beta Release",
-				draft: false,
-				prerelease: true,
-				assets: [],
-				published_at: "2024-01-02T00:00:00Z",
-			},
-			{
-				id: 3,
-				tag_name: "v1.2.0-draft",
-				name: "Draft Release",
-				draft: true,
-				prerelease: false,
-				assets: [],
-				published_at: "2024-01-03T00:00:00Z",
-			},
-		];
-
-		test("should filter out drafts by default", () => {
-			const stable = releases.filter((r) => !r.draft && !r.prerelease);
-			expect(stable).toHaveLength(1);
-			expect(stable[0].tag_name).toBe("v1.0.0");
-		});
-
-		test("should filter out prereleases by default", () => {
-			const stable = releases.filter((r) => !r.draft && !r.prerelease);
-			expect(stable.every((r) => !r.prerelease)).toBe(true);
-		});
-
-		test("should include all when --all flag is used", () => {
-			const all = releases; // No filtering when --all is true
-			expect(all).toHaveLength(3);
-		});
-
-		test("should handle empty release list", () => {
-			const empty: GitHubRelease[] = [];
-			expect(empty).toHaveLength(0);
-		});
-	});
-
-	describe("Command Options Validation", () => {
-		test("should validate limit as number", () => {
-			const validLimit = { limit: 50 };
-			const result = VersionCommandOptionsSchema.parse(validLimit);
-			expect(result.limit).toBe(50);
-		});
-
-		test("should validate all as boolean", () => {
-			const validAll = { all: false };
-			const result = VersionCommandOptionsSchema.parse(validAll);
-			expect(result.all).toBe(false);
-		});
-
-		test("should handle optional fields", () => {
-			const minimal = {};
-			const result = VersionCommandOptionsSchema.parse(minimal);
-			expect(result).toBeDefined();
-		});
-	});
-
-	describe("Error Scenarios", () => {
-		test("should handle invalid option types", () => {
-			const invalidLimit = { limit: "not-a-number" };
-			expect(() => VersionCommandOptionsSchema.parse(invalidLimit)).toThrow();
-		});
-
-		test("should handle invalid all flag type", () => {
-			const invalidAll = { all: "not-a-boolean" };
-			expect(() => VersionCommandOptionsSchema.parse(invalidAll)).toThrow();
-		});
-	});
-
-	describe("Assets Handling", () => {
-		test("should handle release with multiple assets", () => {
-			const release: GitHubRelease = {
-				id: 1,
-				tag_name: "v1.0.0",
-				name: "Release",
-				draft: false,
-				prerelease: false,
-				assets: [
-					{
-						id: 1,
-						name: "package.tar.gz",
-						browser_download_url: "https://example.com/package.tar.gz",
-						size: 1024,
-						content_type: "application/gzip",
-					},
-					{
-						id: 2,
-						name: "package.zip",
-						browser_download_url: "https://example.com/package.zip",
-						size: 2048,
-						content_type: "application/zip",
-					},
-				],
-			};
-
-			expect(release.assets).toHaveLength(2);
-		});
-
-		test("should handle release with no assets", () => {
-			const release: GitHubRelease = {
-				id: 1,
-				tag_name: "v1.0.0",
-				name: "Release",
-				draft: false,
-				prerelease: false,
-				assets: [],
-			};
-
-			expect(release.assets).toHaveLength(0);
-		});
-	});
-
-	describe("Integration Scenarios", () => {
-		test("should handle both kits in parallel", () => {
-			const kits = Object.keys(AVAILABLE_KITS);
-			expect(kits).toContain("engineer");
-			expect(kits).toContain("marketing");
-			expect(kits).toHaveLength(2);
-		});
-
-		test("should support filtering by engineer kit", () => {
-			const options = { kit: "engineer" as const };
-			const result = VersionCommandOptionsSchema.parse(options);
-			expect(result.kit).toBe("engineer");
-
-			const kitConfig = AVAILABLE_KITS[result.kit];
-			expect(kitConfig.repo).toBe("claudekit-engineer");
-		});
-
-		test("should support filtering by marketing kit", () => {
-			const options = { kit: "marketing" as const };
-			const result = VersionCommandOptionsSchema.parse(options);
-			expect(result.kit).toBe("marketing");
-
-			const kitConfig = AVAILABLE_KITS[result.kit];
-			expect(kitConfig.repo).toBe("claudekit-marketing");
-		});
-	});
-});

package/tests/integration/cli.test.ts

@@ -1,252 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import { execSync } from "node:child_process";
-import { existsSync } from "node:fs";
-import { mkdir, rm, writeFile } from "node:fs/promises";
-import { join } from "node:path";
-import { fileURLToPath } from "node:url";
-
-/**
- * Integration tests for CLI commands
- * These tests actually run the CLI and verify the results
- */
-describe("CLI Integration Tests", () => {
-	let testDir: string;
-	const __dirname = join(fileURLToPath(import.meta.url), "..", "..", "..");
-	const cliPath = join(__dirname, "dist", "index.js");
-
-	// Skip integration tests in CI environments for now due to execution issues
-	const isCI = process.env.CI === "true" || process.env.GITHUB_ACTIONS === "true";
-
-	beforeEach(async () => {
-		// Skip in CI
-		if (isCI) {
-			return;
-		}
-
-		// Create test directory
-		testDir = join(process.cwd(), "test-integration", `cli-test-${Date.now()}`);
-		await mkdir(testDir, { recursive: true });
-
-		// Build the CLI first if not exists
-		if (!existsSync(cliPath)) {
-			execSync("bun run build", { cwd: process.cwd() });
-		}
-	});
-
-	afterEach(async () => {
-		// Skip in CI
-		if (isCI) {
-			return;
-		}
-
-		// Cleanup test directory
-		if (existsSync(testDir)) {
-			await rm(testDir, { recursive: true, force: true });
-		}
-	});
-
-	describe("ck new command", () => {
-		test("should create new project in specified directory", async () => {
-			if (isCI) {
-				return;
-			}
-
-			const projectDir = join(testDir, "test-ck-new");
-
-			try {
-				// Run ck new command with --kit and --force flags for non-interactive mode
-				execSync(`node ${cliPath} new --dir ${projectDir} --kit engineer --force`, {
-					cwd: testDir,
-					stdio: "pipe",
-					timeout: 60000, // 60 second timeout
-				});
-
-				// Verify project structure
-				expect(existsSync(projectDir)).toBe(true);
-				expect(existsSync(join(projectDir, ".claude"))).toBe(true);
-				expect(existsSync(join(projectDir, "CLAUDE.md"))).toBe(true);
-			} catch (error) {
-				// Log error for debugging
-				console.error("Command failed:", error);
-				throw error;
-			}
-		}, 120000); // 2 minute timeout for the test
-
-		test("should create project with correct file contents", async () => {
-			if (isCI) {
-				return;
-			}
-
-			const projectDir = join(testDir, "test-content");
-
-			try {
-				execSync(`node ${cliPath} new --dir ${projectDir} --kit engineer --force`, {
-					cwd: testDir,
-					stdio: "pipe",
-					timeout: 60000,
-				});
-
-				// Verify file contents (basic check)
-				const claudeMd = await Bun.file(join(projectDir, "CLAUDE.md")).text();
-				expect(claudeMd).toContain("CLAUDE.md");
-			} catch (error) {
-				console.error("Command failed:", error);
-				throw error;
-			}
-		}, 120000);
-
-		test("should not overwrite existing project without confirmation", async () => {
-			if (isCI) {
-				return;
-			}
-
-			const projectDir = join(testDir, "test-no-overwrite");
-
-			// Create existing directory with a file
-			await mkdir(projectDir, { recursive: true });
-			await writeFile(join(projectDir, "existing.txt"), "existing content");
-
-			try {
-				// This should fail because --force is not provided
-				execSync(`node ${cliPath} new --dir ${projectDir} --kit engineer`, {
-					cwd: testDir,
-					stdio: "pipe",
-					timeout: 5000,
-				});
-				// Should not reach here
-				expect(true).toBe(false);
-			} catch (error: any) {
-				// Expected to fail without --force flag
-				expect(error).toBeDefined();
-				expect(error.message).toContain("not empty");
-			}
-
-			// Verify existing file is still there
-			expect(existsSync(join(projectDir, "existing.txt"))).toBe(true);
-		});
-	});
-
-	describe("ck update command", () => {
-		test("should update existing project", async () => {
-			if (isCI) {
-				return;
-			}
-
-			const projectDir = join(testDir, "test-ck-update");
-
-			// First create a project with --kit and --force flags
-			execSync(`node ${cliPath} new --dir ${projectDir} --kit engineer --force`, {
-				cwd: testDir,
-				stdio: "pipe",
-				timeout: 60000,
-			});
-
-			// Add a custom file to .claude directory
-			await writeFile(join(projectDir, ".claude", "custom.md"), "# Custom file");
-
-			// Update the project (will ask for confirmation, so it may timeout/fail)
-			try {
-				execSync(`node ${cliPath} update`, {
-					cwd: projectDir,
-					stdio: "pipe",
-					timeout: 60000,
-				});
-
-				// Note: Update requires confirmation, so this test may need adjustment
-				// based on how confirmation is handled in tests
-			} catch (error) {
-				// May fail due to confirmation prompt
-				console.log("Update command requires confirmation, which is expected");
-			}
-
-			// Verify custom file is preserved
-			expect(existsSync(join(projectDir, ".claude", "custom.md"))).toBe(true);
-		}, 120000);
-
-		test("should fail when not in a project directory", async () => {
-			if (isCI) {
-				return;
-			}
-
-			const emptyDir = join(testDir, "empty");
-			await mkdir(emptyDir, { recursive: true });
-
-			try {
-				execSync(`node ${cliPath} update`, {
-					cwd: emptyDir,
-					stdio: "pipe",
-					timeout: 5000,
-				});
-
-				// Should not reach here
-				expect(true).toBe(false);
-			} catch (error: any) {
-				// Expected to fail
-				expect(error).toBeDefined();
-			}
-		});
-	});
-
-	describe("project structure validation", () => {
-		test("new project should have all required directories", async () => {
-			if (isCI) {
-				return;
-			}
-
-			const projectDir = join(testDir, "test-structure");
-
-			execSync(`node ${cliPath} new --dir ${projectDir} --kit engineer --force`, {
-				cwd: testDir,
-				stdio: "pipe",
-				timeout: 60000,
-			});
-
-			// Check for required directories
-			const requiredDirs = [".claude"];
-
-			for (const dir of requiredDirs) {
-				expect(existsSync(join(projectDir, dir))).toBe(true);
-			}
-		}, 120000);
-
-		test("new project should have all required files", async () => {
-			if (isCI) {
-				return;
-			}
-
-			const projectDir = join(testDir, "test-files");
-
-			execSync(`node ${cliPath} new --dir ${projectDir} --kit engineer --force`, {
-				cwd: testDir,
-				stdio: "pipe",
-				timeout: 60000,
-			});
-
-			// Check for required files
-			const requiredFiles = ["CLAUDE.md"];
-
-			for (const file of requiredFiles) {
-				expect(existsSync(join(projectDir, file))).toBe(true);
-			}
-		}, 120000);
-
-		test("project should not contain excluded files", async () => {
-			if (isCI) {
-				return;
-			}
-
-			const projectDir = join(testDir, "test-exclusions");
-
-			execSync(`node ${cliPath} new --dir ${projectDir} --kit engineer --force`, {
-				cwd: testDir,
-				stdio: "pipe",
-				timeout: 60000,
-			});
-
-			// Verify excluded patterns are not present
-			expect(existsSync(join(projectDir, ".git"))).toBe(false);
-			expect(existsSync(join(projectDir, "node_modules"))).toBe(false);
-			expect(existsSync(join(projectDir, ".DS_Store"))).toBe(false);
-		}, 120000);
-	});
-});

package/tests/lib/auth.test.ts

@@ -1,116 +0,0 @@
-import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
-import { AuthManager } from "../../src/lib/auth.js";
-import { AuthenticationError } from "../../src/types.js";
-
-describe("AuthManager", () => {
-	beforeEach(() => {
-		// Reset AuthManager state
-		(AuthManager as any).token = null;
-		(AuthManager as any).authMethod = null;
-	});
-
-	afterEach(() => {
-		// Clean up environment variables
-		process.env.GITHUB_TOKEN = undefined;
-		process.env.GH_TOKEN = undefined;
-	});
-
-	describe("isValidTokenFormat", () => {
-		test("should accept ghp_ tokens", () => {
-			expect(AuthManager.isValidTokenFormat("ghp_1234567890")).toBe(true);
-		});
-
-		test("should accept github_pat_ tokens", () => {
-			expect(AuthManager.isValidTokenFormat("github_pat_1234567890")).toBe(true);
-		});
-
-		test("should reject invalid token formats", () => {
-			expect(AuthManager.isValidTokenFormat("invalid_token")).toBe(false);
-			expect(AuthManager.isValidTokenFormat("gho_1234567890")).toBe(false);
-			expect(AuthManager.isValidTokenFormat("")).toBe(false);
-			expect(AuthManager.isValidTokenFormat("token123")).toBe(false);
-		});
-
-		test("should handle empty and malformed tokens", () => {
-			expect(AuthManager.isValidTokenFormat("")).toBe(false);
-			expect(AuthManager.isValidTokenFormat("ghp")).toBe(false);
-			expect(AuthManager.isValidTokenFormat("github_pat")).toBe(false);
-		});
-	});
-
-	describe("getToken - environment variables", () => {
-		test("should get token from environment (gh-cli, env-var, or cached)", async () => {
-			// Set environment variable to avoid prompting in CI
-			process.env.GITHUB_TOKEN = "ghp_test_token_ci_123";
-
-			// This test acknowledges that the token can come from multiple sources
-			// in the fallback chain: gh-cli > env-var > config > keychain > prompt
-			const result = await AuthManager.getToken();
-
-			expect(result.token).toBeDefined();
-			expect(result.token.length).toBeGreaterThan(0);
-			expect(result.method).toBeDefined();
-			// Method could be 'gh-cli', 'env-var', 'keychain', or 'prompt'
-			expect(["gh-cli", "env-var", "keychain", "prompt"]).toContain(result.method);
-		});
-
-		test("should cache token after first retrieval", async () => {
-			// Set environment variable to avoid prompting in CI
-			process.env.GITHUB_TOKEN = "ghp_test_token_cache_456";
-
-			// Clear cache first
-			(AuthManager as any).token = null;
-			(AuthManager as any).authMethod = null;
-
-			const result1 = await AuthManager.getToken();
-			const result2 = await AuthManager.getToken();
-
-			expect(result1.token).toBe(result2.token);
-			expect(result1.method).toBe(result2.method);
-		});
-
-		test("should handle GITHUB_TOKEN env var when gh-cli is not available", async () => {
-			// Note: If gh CLI is installed and authenticated, it will take precedence
-			// This test documents the expected behavior but may not enforce it
-			process.env.GITHUB_TOKEN = "ghp_test_token_123";
-
-			// Clear cache
-			(AuthManager as any).token = null;
-			(AuthManager as any).authMethod = null;
-
-			const result = await AuthManager.getToken();
-
-			// Token should either be from gh-cli or env-var
-			expect(result.token).toBeDefined();
-			expect(["gh-cli", "env-var"]).toContain(result.method);
-		});
-
-		test("should handle GH_TOKEN env var when GITHUB_TOKEN is not set", async () => {
-			process.env.GITHUB_TOKEN = undefined;
-			process.env.GH_TOKEN = "ghp_test_token_456";
-
-			// Clear cache
-			(AuthManager as any).token = null;
-			(AuthManager as any).authMethod = null;
-
-			const result = await AuthManager.getToken();
-
-			// Token should either be from gh-cli or env-var
-			expect(result.token).toBeDefined();
-			expect(["gh-cli", "env-var"]).toContain(result.method);
-		});
-	});
-
-	describe("clearToken", () => {
-		test("should clear cached token", async () => {
-			// Set a cached token
-			(AuthManager as any).token = "test-token";
-			(AuthManager as any).authMethod = "env-var";
-
-			await AuthManager.clearToken();
-
-			expect((AuthManager as any).token).toBeNull();
-			expect((AuthManager as any).authMethod).toBeNull();
-		});
-	});
-});