claudekit-cli 1.0.0

package/tests/utils/config.test.ts

@@ -0,0 +1,263 @@
+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 });
+			}
+		});
+	});
+});

package/tests/utils/logger.test.ts

@@ -0,0 +1,124 @@
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+import { logger } from "../../src/utils/logger.js";
+
+describe("Logger Utilities", () => {
+	let consoleLogSpy: any;
+	let consoleErrorSpy: any;
+	const originalDebug = process.env.DEBUG;
+
+	beforeEach(() => {
+		consoleLogSpy = mock(() => {});
+		consoleErrorSpy = mock(() => {});
+		console.log = consoleLogSpy;
+		console.error = consoleErrorSpy;
+	});
+
+	afterEach(() => {
+		process.env.DEBUG = originalDebug;
+		consoleLogSpy.mockRestore?.();
+		consoleErrorSpy.mockRestore?.();
+	});
+
+	describe("info", () => {
+		test("should log info messages", () => {
+			logger.info("Test info message");
+			expect(consoleLogSpy).toHaveBeenCalled();
+		});
+	});
+
+	describe("success", () => {
+		test("should log success messages", () => {
+			logger.success("Test success message");
+			expect(consoleLogSpy).toHaveBeenCalled();
+		});
+	});
+
+	describe("warning", () => {
+		test("should log warning messages", () => {
+			logger.warning("Test warning message");
+			expect(consoleLogSpy).toHaveBeenCalled();
+		});
+	});
+
+	describe("error", () => {
+		test("should log error messages", () => {
+			logger.error("Test error message");
+			expect(consoleErrorSpy).toHaveBeenCalled();
+		});
+	});
+
+	describe("debug", () => {
+		test("should log debug messages when DEBUG is set", () => {
+			process.env.DEBUG = "true";
+			logger.debug("Test debug message");
+			expect(consoleLogSpy).toHaveBeenCalled();
+		});
+
+		test("should not log debug messages when DEBUG is not set", () => {
+			process.env.DEBUG = undefined;
+			logger.debug("Test debug message");
+			expect(consoleLogSpy).not.toHaveBeenCalled();
+		});
+	});
+
+	describe("sanitize", () => {
+		test("should sanitize ghp_ tokens (36 chars)", () => {
+			const text = "Token: ghp_123456789012345678901234567890123456";
+			const sanitized = logger.sanitize(text);
+			expect(sanitized).toBe("Token: ghp_***");
+		});
+
+		test("should sanitize github_pat_ tokens (82 chars)", () => {
+			// github_pat_ prefix + 82 alphanumeric/underscore characters (exact length)
+			const token =
+				"1234567890123456789012345678901234567890123456789012345678901234567890123456789012";
+			const text = `Token: github_pat_${token}`;
+			const sanitized = logger.sanitize(text);
+			expect(sanitized).toBe("Token: github_pat_***");
+		});
+
+		test("should sanitize gho_ tokens (36 chars)", () => {
+			const text = "Token: gho_123456789012345678901234567890123456";
+			const sanitized = logger.sanitize(text);
+			expect(sanitized).toBe("Token: gho_***");
+		});
+
+		test("should sanitize ghu_ tokens (36 chars)", () => {
+			const text = "Token: ghu_123456789012345678901234567890123456";
+			const sanitized = logger.sanitize(text);
+			expect(sanitized).toBe("Token: ghu_***");
+		});
+
+		test("should sanitize ghs_ tokens (36 chars)", () => {
+			const text = "Token: ghs_123456789012345678901234567890123456";
+			const sanitized = logger.sanitize(text);
+			expect(sanitized).toBe("Token: ghs_***");
+		});
+
+		test("should sanitize ghr_ tokens (36 chars)", () => {
+			const text = "Token: ghr_123456789012345678901234567890123456";
+			const sanitized = logger.sanitize(text);
+			expect(sanitized).toBe("Token: ghr_***");
+		});
+
+		test("should sanitize multiple tokens", () => {
+			const ghpToken = "123456789012345678901234567890123456";
+			const patToken =
+				"1234567890123456789012345678901234567890123456789012345678901234567890123456789012";
+			const text = `Tokens: ghp_${ghpToken} and github_pat_${patToken}`;
+			const sanitized = logger.sanitize(text);
+			expect(sanitized).toBe("Tokens: ghp_*** and github_pat_***");
+		});
+
+		test("should not modify text without tokens", () => {
+			const text = "No tokens here, just regular text";
+			const sanitized = logger.sanitize(text);
+			expect(sanitized).toBe(text);
+		});
+
+		test("should handle empty string", () => {
+			const sanitized = logger.sanitize("");
+			expect(sanitized).toBe("");
+		});
+	});
+});

package/tsconfig.json

@@ -0,0 +1,30 @@
+{
+	"compilerOptions": {
+		"target": "ES2022",
+		"module": "ESNext",
+		"lib": ["ES2022"],
+		"moduleResolution": "bundler",
+		"types": ["bun-types"],
+
+		"strict": true,
+		"esModuleInterop": true,
+		"skipLibCheck": true,
+		"forceConsistentCasingInFileNames": true,
+		"resolveJsonModule": true,
+		"allowSyntheticDefaultImports": true,
+
+		"declaration": true,
+		"declarationMap": true,
+		"sourceMap": true,
+
+		"outDir": "./dist",
+		"rootDir": "./src",
+
+		"noUnusedLocals": true,
+		"noUnusedParameters": true,
+		"noImplicitReturns": true,
+		"noFallthroughCasesInSwitch": true
+	},
+	"include": ["src/**/*"],
+	"exclude": ["node_modules", "dist", "bin"]
+}