claudekit-cli 1.0.1 → 1.2.0

package/tests/commands/version.test.ts

@@ -0,0 +1,297 @@
+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/lib/github-download-priority.test.ts

@@ -0,0 +1,301 @@
+import { describe, expect, test } from "bun:test";
+import { GitHubClient } from "../../src/lib/github.js";
+import type { GitHubRelease } from "../../src/types.js";
+
+describe("GitHubClient - Asset Download Priority", () => {
+	describe("getDownloadableAsset", () => {
+		test("should prioritize ClaudeKit Engineer Package zip file", () => {
+			const release: GitHubRelease = {
+				id: 1,
+				tag_name: "v1.0.0",
+				name: "Release 1.0.0",
+				draft: false,
+				prerelease: false,
+				tarball_url: "https://api.github.com/repos/test/repo/tarball/v1.0.0",
+				zipball_url: "https://api.github.com/repos/test/repo/zipball/v1.0.0",
+				assets: [
+					{
+						id: 1,
+						name: "other-file.tar.gz",
+						browser_download_url: "https://github.com/test/other-file.tar.gz",
+						size: 1024,
+						content_type: "application/gzip",
+					},
+					{
+						id: 2,
+						name: "ClaudeKit-Engineer-Package.zip",
+						browser_download_url: "https://github.com/test/claudekit-package.zip",
+						size: 2048,
+						content_type: "application/zip",
+					},
+				],
+			};
+
+			const result = GitHubClient.getDownloadableAsset(release);
+
+			expect(result.type).toBe("asset");
+			expect(result.name).toBe("ClaudeKit-Engineer-Package.zip");
+			expect(result.url).toBe("https://github.com/test/claudekit-package.zip");
+			expect(result.size).toBe(2048);
+		});
+
+		test("should prioritize ClaudeKit Marketing Package zip file", () => {
+			const release: GitHubRelease = {
+				id: 1,
+				tag_name: "v1.0.0",
+				name: "Release 1.0.0",
+				draft: false,
+				prerelease: false,
+				tarball_url: "https://api.github.com/repos/test/repo/tarball/v1.0.0",
+				zipball_url: "https://api.github.com/repos/test/repo/zipball/v1.0.0",
+				assets: [
+					{
+						id: 1,
+						name: "random.zip",
+						browser_download_url: "https://github.com/test/random.zip",
+						size: 512,
+						content_type: "application/zip",
+					},
+					{
+						id: 2,
+						name: "ClaudeKit-Marketing-Package.zip",
+						browser_download_url: "https://github.com/test/marketing-package.zip",
+						size: 2048,
+						content_type: "application/zip",
+					},
+				],
+			};
+
+			const result = GitHubClient.getDownloadableAsset(release);
+
+			expect(result.type).toBe("asset");
+			expect(result.name).toBe("ClaudeKit-Marketing-Package.zip");
+			expect(result.url).toBe("https://github.com/test/marketing-package.zip");
+		});
+
+		test("should match ClaudeKit package case-insensitively", () => {
+			const release: GitHubRelease = {
+				id: 1,
+				tag_name: "v1.0.0",
+				name: "Release 1.0.0",
+				draft: false,
+				prerelease: false,
+				tarball_url: "https://api.github.com/repos/test/repo/tarball/v1.0.0",
+				zipball_url: "https://api.github.com/repos/test/repo/zipball/v1.0.0",
+				assets: [
+					{
+						id: 1,
+						name: "claudekit-engineer-package.zip",
+						browser_download_url: "https://github.com/test/package.zip",
+						size: 2048,
+						content_type: "application/zip",
+					},
+				],
+			};
+
+			const result = GitHubClient.getDownloadableAsset(release);
+
+			expect(result.type).toBe("asset");
+			expect(result.name).toBe("claudekit-engineer-package.zip");
+		});
+
+		test("should fallback to other zip files if no ClaudeKit package found", () => {
+			const release: GitHubRelease = {
+				id: 1,
+				tag_name: "v1.0.0",
+				name: "Release 1.0.0",
+				draft: false,
+				prerelease: false,
+				tarball_url: "https://api.github.com/repos/test/repo/tarball/v1.0.0",
+				zipball_url: "https://api.github.com/repos/test/repo/zipball/v1.0.0",
+				assets: [
+					{
+						id: 1,
+						name: "source-code.zip",
+						browser_download_url: "https://github.com/test/source.zip",
+						size: 1024,
+						content_type: "application/zip",
+					},
+				],
+			};
+
+			const result = GitHubClient.getDownloadableAsset(release);
+
+			expect(result.type).toBe("asset");
+			expect(result.name).toBe("source-code.zip");
+		});
+
+		test("should fallback to tar.gz files if no zip found", () => {
+			const release: GitHubRelease = {
+				id: 1,
+				tag_name: "v1.0.0",
+				name: "Release 1.0.0",
+				draft: false,
+				prerelease: false,
+				tarball_url: "https://api.github.com/repos/test/repo/tarball/v1.0.0",
+				zipball_url: "https://api.github.com/repos/test/repo/zipball/v1.0.0",
+				assets: [
+					{
+						id: 1,
+						name: "release.tar.gz",
+						browser_download_url: "https://github.com/test/release.tar.gz",
+						size: 1024,
+						content_type: "application/gzip",
+					},
+				],
+			};
+
+			const result = GitHubClient.getDownloadableAsset(release);
+
+			expect(result.type).toBe("asset");
+			expect(result.name).toBe("release.tar.gz");
+		});
+
+		test("should fallback to tgz files", () => {
+			const release: GitHubRelease = {
+				id: 1,
+				tag_name: "v1.0.0",
+				name: "Release 1.0.0",
+				draft: false,
+				prerelease: false,
+				tarball_url: "https://api.github.com/repos/test/repo/tarball/v1.0.0",
+				zipball_url: "https://api.github.com/repos/test/repo/zipball/v1.0.0",
+				assets: [
+					{
+						id: 1,
+						name: "release.tgz",
+						browser_download_url: "https://github.com/test/release.tgz",
+						size: 1024,
+						content_type: "application/gzip",
+					},
+				],
+			};
+
+			const result = GitHubClient.getDownloadableAsset(release);
+
+			expect(result.type).toBe("asset");
+			expect(result.name).toBe("release.tgz");
+		});
+
+		test("should fallback to GitHub automatic tarball if no assets", () => {
+			const release: GitHubRelease = {
+				id: 1,
+				tag_name: "v1.0.0",
+				name: "Release 1.0.0",
+				draft: false,
+				prerelease: false,
+				tarball_url: "https://api.github.com/repos/test/repo/tarball/v1.0.0",
+				zipball_url: "https://api.github.com/repos/test/repo/zipball/v1.0.0",
+				assets: [],
+			};
+
+			const result = GitHubClient.getDownloadableAsset(release);
+
+			expect(result.type).toBe("tarball");
+			expect(result.url).toBe("https://api.github.com/repos/test/repo/tarball/v1.0.0");
+			expect(result.name).toBe("v1.0.0.tar.gz");
+			expect(result.size).toBeUndefined();
+		});
+
+		test("should fallback to tarball if assets have no archive files", () => {
+			const release: GitHubRelease = {
+				id: 1,
+				tag_name: "v1.0.0",
+				name: "Release 1.0.0",
+				draft: false,
+				prerelease: false,
+				tarball_url: "https://api.github.com/repos/test/repo/tarball/v1.0.0",
+				zipball_url: "https://api.github.com/repos/test/repo/zipball/v1.0.0",
+				assets: [
+					{
+						id: 1,
+						name: "README.md",
+						browser_download_url: "https://github.com/test/README.md",
+						size: 128,
+						content_type: "text/markdown",
+					},
+					{
+						id: 2,
+						name: "checksums.txt",
+						browser_download_url: "https://github.com/test/checksums.txt",
+						size: 64,
+						content_type: "text/plain",
+					},
+				],
+			};
+
+			const result = GitHubClient.getDownloadableAsset(release);
+
+			expect(result.type).toBe("tarball");
+			expect(result.url).toBe("https://api.github.com/repos/test/repo/tarball/v1.0.0");
+		});
+
+		test("should prioritize ClaudeKit package over other archives", () => {
+			const release: GitHubRelease = {
+				id: 1,
+				tag_name: "v1.0.0",
+				name: "Release 1.0.0",
+				draft: false,
+				prerelease: false,
+				tarball_url: "https://api.github.com/repos/test/repo/tarball/v1.0.0",
+				zipball_url: "https://api.github.com/repos/test/repo/zipball/v1.0.0",
+				assets: [
+					{
+						id: 1,
+						name: "source.tar.gz",
+						browser_download_url: "https://github.com/test/source.tar.gz",
+						size: 5000,
+						content_type: "application/gzip",
+					},
+					{
+						id: 2,
+						name: "docs.zip",
+						browser_download_url: "https://github.com/test/docs.zip",
+						size: 3000,
+						content_type: "application/zip",
+					},
+					{
+						id: 3,
+						name: "ClaudeKit-Engineer-Package.zip",
+						browser_download_url: "https://github.com/test/package.zip",
+						size: 2000,
+						content_type: "application/zip",
+					},
+				],
+			};
+
+			const result = GitHubClient.getDownloadableAsset(release);
+
+			// Should pick the ClaudeKit package even though it's listed last
+			expect(result.type).toBe("asset");
+			expect(result.name).toBe("ClaudeKit-Engineer-Package.zip");
+			expect(result.size).toBe(2000);
+		});
+
+		test("should handle assets with variations in naming", () => {
+			const release: GitHubRelease = {
+				id: 1,
+				tag_name: "v1.0.0",
+				name: "Release 1.0.0",
+				draft: false,
+				prerelease: false,
+				tarball_url: "https://api.github.com/repos/test/repo/tarball/v1.0.0",
+				zipball_url: "https://api.github.com/repos/test/repo/zipball/v1.0.0",
+				assets: [
+					{
+						id: 1,
+						name: "claudekit_marketing_package.zip",
+						browser_download_url: "https://github.com/test/package.zip",
+						size: 2000,
+						content_type: "application/zip",
+					},
+				],
+			};
+
+			const result = GitHubClient.getDownloadableAsset(release);
+
+			expect(result.type).toBe("asset");
+			expect(result.name).toBe("claudekit_marketing_package.zip");
+		});
+	});
+});

package/tests/lib/github.test.ts

@@ -36,13 +36,13 @@ describe("GitHubClient", () => {
 	describe("integration scenarios", () => {
 		test("should handle kit configuration correctly", () => {
 			const engineerKit = AVAILABLE_KITS.engineer;
-			expect(engineerKit.owner).toBe("mrgoonie");
+			expect(engineerKit.owner).toBe("claudekit");
 			expect(engineerKit.repo).toBe("claudekit-engineer");
 		});
 
 		test("should handle marketing kit configuration", () => {
 			const marketingKit = AVAILABLE_KITS.marketing;
-			expect(marketingKit.owner).toBe("mrgoonie");
+			expect(marketingKit.owner).toBe("claudekit");
 			expect(marketingKit.repo).toBe("claudekit-marketing");
 		});
 	});

package/tests/lib/merge.test.ts

@@ -135,4 +135,81 @@ describe("FileMerger", () => {
 			expect(existsSync(join(testDestDir, "custom-ignore.txt"))).toBe(false);
 		});
 	});
+
+	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);
+		});
+	});
 });