claudekit-cli 1.4.0 → 1.5.0

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

package/tests/lib/download.test.ts

@@ -1,292 +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 { join } from "node:path";
-import { DownloadManager } from "../../src/lib/download.js";
-import { DownloadError, ExtractionError } from "../../src/types.js";
-
-describe("DownloadManager", () => {
-	let manager: DownloadManager;
-	let testDir: string;
-
-	beforeEach(async () => {
-		manager = new DownloadManager();
-		testDir = join(process.cwd(), "test-temp", `test-${Date.now()}`);
-		await mkdir(testDir, { recursive: true });
-	});
-
-	afterEach(async () => {
-		if (existsSync(testDir)) {
-			await rm(testDir, { recursive: true, force: true });
-		}
-	});
-
-	describe("constructor", () => {
-		test("should create DownloadManager instance", () => {
-			expect(manager).toBeInstanceOf(DownloadManager);
-		});
-	});
-
-	describe("createTempDir", () => {
-		test("should create temporary directory", async () => {
-			const tempDir = await manager.createTempDir();
-
-			expect(tempDir).toBeDefined();
-			expect(typeof tempDir).toBe("string");
-			expect(tempDir).toContain("claudekit-");
-			expect(existsSync(tempDir)).toBe(true);
-
-			// Cleanup
-			await rm(tempDir, { recursive: true, force: true });
-		});
-
-		test("should create unique directories", async () => {
-			const tempDir1 = await manager.createTempDir();
-
-			// Wait 1ms to ensure different timestamps
-			await new Promise((resolve) => setTimeout(resolve, 1));
-
-			const tempDir2 = await manager.createTempDir();
-
-			expect(tempDir1).not.toBe(tempDir2);
-
-			// Cleanup
-			await rm(tempDir1, { recursive: true, force: true });
-			await rm(tempDir2, { recursive: true, force: true });
-		});
-	});
-
-	describe("validateExtraction", () => {
-		test("should throw error for empty directory", async () => {
-			const emptyDir = join(testDir, "empty");
-			await mkdir(emptyDir, { recursive: true });
-
-			await expect(manager.validateExtraction(emptyDir)).rejects.toThrow(ExtractionError);
-			await expect(manager.validateExtraction(emptyDir)).rejects.toThrow(
-				"Extraction resulted in no files",
-			);
-		});
-
-		test("should pass validation for directory with .claude and CLAUDE.md", async () => {
-			const validDir = join(testDir, "valid");
-			await mkdir(join(validDir, ".claude"), { recursive: true });
-			await writeFile(join(validDir, ".claude", "config.json"), "{}");
-			await writeFile(join(validDir, "CLAUDE.md"), "# Test");
-
-			// Should not throw
-			await manager.validateExtraction(validDir);
-		});
-
-		test("should warn but not fail for directory with files but missing critical paths", async () => {
-			const partialDir = join(testDir, "partial");
-			await mkdir(partialDir, { recursive: true });
-			await writeFile(join(partialDir, "README.md"), "# Test");
-
-			// Should not throw but will log warnings
-			await manager.validateExtraction(partialDir);
-		});
-
-		test("should throw error for non-existent directory", async () => {
-			const nonExistentDir = join(testDir, "does-not-exist");
-
-			await expect(manager.validateExtraction(nonExistentDir)).rejects.toThrow();
-		});
-	});
-
-	describe("wrapper directory detection", () => {
-		test("should detect version wrapper with v prefix", () => {
-			// Access private method via any type casting for testing
-			const isWrapper = (manager as any).isWrapperDirectory("project-v1.0.0");
-			expect(isWrapper).toBe(true);
-		});
-
-		test("should detect version wrapper without v prefix", () => {
-			const isWrapper = (manager as any).isWrapperDirectory("project-1.0.0");
-			expect(isWrapper).toBe(true);
-		});
-
-		test("should detect commit hash wrapper", () => {
-			const isWrapper = (manager as any).isWrapperDirectory("project-abc1234");
-			expect(isWrapper).toBe(true);
-		});
-
-		test("should detect prerelease version wrapper", () => {
-			const isWrapper = (manager as any).isWrapperDirectory("project-v1.0.0-alpha");
-			expect(isWrapper).toBe(true);
-		});
-
-		test("should detect beta version wrapper", () => {
-			const isWrapper = (manager as any).isWrapperDirectory("project-v2.0.0-beta.1");
-			expect(isWrapper).toBe(true);
-		});
-
-		test("should detect rc version wrapper", () => {
-			const isWrapper = (manager as any).isWrapperDirectory("repo-v3.0.0-rc.5");
-			expect(isWrapper).toBe(true);
-		});
-
-		test("should not detect .claude as wrapper", () => {
-			const isWrapper = (manager as any).isWrapperDirectory(".claude");
-			expect(isWrapper).toBe(false);
-		});
-
-		test("should not detect src as wrapper", () => {
-			const isWrapper = (manager as any).isWrapperDirectory("src");
-			expect(isWrapper).toBe(false);
-		});
-
-		test("should not detect docs as wrapper", () => {
-			const isWrapper = (manager as any).isWrapperDirectory("docs");
-			expect(isWrapper).toBe(false);
-		});
-
-		test("should not detect node_modules as wrapper", () => {
-			const isWrapper = (manager as any).isWrapperDirectory("node_modules");
-			expect(isWrapper).toBe(false);
-		});
-	});
-
-	describe("path safety validation", () => {
-		test("should allow safe relative paths", () => {
-			const basePath = join(testDir, "base");
-			const targetPath = join(testDir, "base", "subdir", "file.txt");
-			const isSafe = (manager as any).isPathSafe(basePath, targetPath);
-			expect(isSafe).toBe(true);
-		});
-
-		test("should block path traversal attempts with ..", () => {
-			const basePath = join(testDir, "base");
-			const targetPath = join(testDir, "outside", "file.txt");
-			const isSafe = (manager as any).isPathSafe(basePath, targetPath);
-			expect(isSafe).toBe(false);
-		});
-
-		test("should block absolute path attempts", () => {
-			const basePath = join(testDir, "base");
-			const targetPath = "/etc/passwd";
-			const isSafe = (manager as any).isPathSafe(basePath, targetPath);
-			expect(isSafe).toBe(false);
-		});
-
-		test("should allow same directory", () => {
-			const basePath = join(testDir, "base");
-			const targetPath = join(testDir, "base");
-			const isSafe = (manager as any).isPathSafe(basePath, targetPath);
-			expect(isSafe).toBe(true);
-		});
-	});
-
-	describe("archive bomb protection", () => {
-		test("should track extraction size", () => {
-			const manager = new DownloadManager();
-
-			// Add some file sizes
-			(manager as any).checkExtractionSize(100 * 1024 * 1024); // 100MB
-			expect((manager as any).totalExtractedSize).toBe(100 * 1024 * 1024);
-
-			(manager as any).checkExtractionSize(200 * 1024 * 1024); // 200MB more
-			expect((manager as any).totalExtractedSize).toBe(300 * 1024 * 1024);
-		});
-
-		test("should throw error when size exceeds limit", () => {
-			const manager = new DownloadManager();
-
-			expect(() => {
-				(manager as any).checkExtractionSize(600 * 1024 * 1024); // 600MB
-			}).toThrow(ExtractionError);
-
-			expect(() => {
-				(manager as any).checkExtractionSize(600 * 1024 * 1024); // 600MB
-			}).toThrow("Archive exceeds maximum extraction size");
-		});
-
-		test("should allow extraction within limit", () => {
-			const manager = new DownloadManager();
-
-			expect(() => {
-				(manager as any).checkExtractionSize(400 * 1024 * 1024); // 400MB
-			}).not.toThrow();
-		});
-
-		test("should reset extraction size", () => {
-			const manager = new DownloadManager();
-
-			(manager as any).checkExtractionSize(300 * 1024 * 1024); // 300MB
-			expect((manager as any).totalExtractedSize).toBe(300 * 1024 * 1024);
-
-			(manager as any).resetExtractionSize();
-			expect((manager as any).totalExtractedSize).toBe(0);
-		});
-	});
-
-	describe("file exclusion", () => {
-		test("should exclude .git directory", () => {
-			const shouldExclude = (manager as any).shouldExclude(".git");
-			expect(shouldExclude).toBe(true);
-		});
-
-		test("should exclude .git/** files", () => {
-			const shouldExclude = (manager as any).shouldExclude(".git/config");
-			expect(shouldExclude).toBe(true);
-		});
-
-		test("should exclude node_modules", () => {
-			const shouldExclude = (manager as any).shouldExclude("node_modules");
-			expect(shouldExclude).toBe(true);
-		});
-
-		test("should exclude .DS_Store", () => {
-			const shouldExclude = (manager as any).shouldExclude(".DS_Store");
-			expect(shouldExclude).toBe(true);
-		});
-
-		test("should not exclude normal files", () => {
-			const shouldExclude = (manager as any).shouldExclude("src/index.ts");
-			expect(shouldExclude).toBe(false);
-		});
-
-		test("should not exclude .claude directory", () => {
-			const shouldExclude = (manager as any).shouldExclude(".claude");
-			expect(shouldExclude).toBe(false);
-		});
-	});
-
-	describe("archive type detection", () => {
-		test("should detect .tar.gz archive", () => {
-			const type = (manager as any).detectArchiveType("project-v1.0.0.tar.gz");
-			expect(type).toBe("tar.gz");
-		});
-
-		test("should detect .tgz archive", () => {
-			const type = (manager as any).detectArchiveType("project-v1.0.0.tgz");
-			expect(type).toBe("tar.gz");
-		});
-
-		test("should detect .zip archive", () => {
-			const type = (manager as any).detectArchiveType("project-v1.0.0.zip");
-			expect(type).toBe("zip");
-		});
-
-		test("should throw error for unknown archive type", () => {
-			expect(() => {
-				(manager as any).detectArchiveType("project-v1.0.0.rar");
-			}).toThrow(ExtractionError);
-		});
-	});
-
-	describe("error classes", () => {
-		test("DownloadError should store message", () => {
-			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 store message", () => {
-			const error = new ExtractionError("Extraction failed");
-			expect(error.message).toBe("Extraction failed");
-			expect(error.code).toBe("EXTRACTION_ERROR");
-			expect(error.name).toBe("ExtractionError");
-		});
-	});
-});