claudekit-cli 1.4.1 → 1.5.1

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

package/tests/utils/file-scanner.test.ts

@@ -1,202 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import { join } from "node:path";
-import { mkdir, remove, writeFile } from "fs-extra";
-import { FileScanner } from "../../src/utils/file-scanner.js";
-
-describe("FileScanner", () => {
-	const testDir = join(__dirname, "..", "..", "temp-test-file-scanner");
-	const destDir = join(testDir, "dest");
-	const sourceDir = join(testDir, "source");
-
-	beforeEach(async () => {
-		// Clean up and create test directories
-		await remove(testDir);
-		await mkdir(testDir, { recursive: true });
-		await mkdir(destDir, { recursive: true });
-		await mkdir(sourceDir, { recursive: true });
-	});
-
-	afterEach(async () => {
-		// Clean up test directories
-		await remove(testDir);
-	});
-
-	describe("getFiles", () => {
-		test("should return empty array for non-existent directory", async () => {
-			const files = await FileScanner.getFiles(join(testDir, "non-existent"));
-			expect(files).toEqual([]);
-		});
-
-		test("should return files from directory", async () => {
-			// Create test files
-			await writeFile(join(destDir, "file1.txt"), "content1");
-			await writeFile(join(destDir, "file2.txt"), "content2");
-
-			const files = await FileScanner.getFiles(destDir);
-
-			expect(files).toHaveLength(2);
-			expect(files).toContain("file1.txt");
-			expect(files).toContain("file2.txt");
-		});
-
-		test("should recursively scan subdirectories", async () => {
-			// Create nested structure
-			await mkdir(join(destDir, "subdir"), { recursive: true });
-			await writeFile(join(destDir, "file1.txt"), "content1");
-			await writeFile(join(destDir, "subdir", "file2.txt"), "content2");
-
-			const files = await FileScanner.getFiles(destDir);
-
-			expect(files).toHaveLength(2);
-			expect(files).toContain("file1.txt");
-			expect(files).toContain("subdir/file2.txt");
-		});
-
-		test("should handle empty directory", async () => {
-			const files = await FileScanner.getFiles(destDir);
-			expect(files).toEqual([]);
-		});
-
-		test("should handle deeply nested directories", async () => {
-			// Create deeply nested structure
-			const deepPath = join(destDir, "a", "b", "c", "d");
-			await mkdir(deepPath, { recursive: true });
-			await writeFile(join(deepPath, "deep.txt"), "deep content");
-
-			const files = await FileScanner.getFiles(destDir);
-
-			expect(files).toHaveLength(1);
-			expect(files).toContain("a/b/c/d/deep.txt");
-		});
-
-		test("should return relative paths", async () => {
-			await mkdir(join(destDir, "subdir"), { recursive: true });
-			await writeFile(join(destDir, "subdir", "file.txt"), "content");
-
-			const files = await FileScanner.getFiles(destDir);
-
-			// Should return relative path, not absolute
-			expect(files[0]).toBe("subdir/file.txt");
-			expect(files[0]).not.toContain(destDir);
-		});
-	});
-
-	describe("findCustomFiles", () => {
-		test("should identify files in dest but not in source", async () => {
-			// Create .claude directories
-			const destClaudeDir = join(destDir, ".claude");
-			const sourceClaudeDir = join(sourceDir, ".claude");
-			await mkdir(destClaudeDir, { recursive: true });
-			await mkdir(sourceClaudeDir, { recursive: true });
-
-			// Create files
-			await writeFile(join(destClaudeDir, "custom.md"), "custom content");
-			await writeFile(join(destClaudeDir, "standard.md"), "standard content");
-			await writeFile(join(sourceClaudeDir, "standard.md"), "standard content");
-
-			const customFiles = await FileScanner.findCustomFiles(destDir, sourceDir, ".claude");
-
-			expect(customFiles).toHaveLength(1);
-			expect(customFiles).toContain(".claude/custom.md");
-		});
-
-		test("should return empty array when no custom files exist", async () => {
-			// Create .claude directories
-			const destClaudeDir = join(destDir, ".claude");
-			const sourceClaudeDir = join(sourceDir, ".claude");
-			await mkdir(destClaudeDir, { recursive: true });
-			await mkdir(sourceClaudeDir, { recursive: true });
-
-			// Create same files in both
-			await writeFile(join(destClaudeDir, "file1.md"), "content1");
-			await writeFile(join(sourceClaudeDir, "file1.md"), "content1");
-
-			const customFiles = await FileScanner.findCustomFiles(destDir, sourceDir, ".claude");
-
-			expect(customFiles).toEqual([]);
-		});
-
-		test("should handle missing .claude in destination", async () => {
-			// Only create source .claude directory
-			const sourceClaudeDir = join(sourceDir, ".claude");
-			await mkdir(sourceClaudeDir, { recursive: true });
-			await writeFile(join(sourceClaudeDir, "file1.md"), "content1");
-
-			const customFiles = await FileScanner.findCustomFiles(destDir, sourceDir, ".claude");
-
-			expect(customFiles).toEqual([]);
-		});
-
-		test("should handle missing .claude in source", async () => {
-			// Only create dest .claude directory
-			const destClaudeDir = join(destDir, ".claude");
-			await mkdir(destClaudeDir, { recursive: true });
-			await writeFile(join(destClaudeDir, "custom.md"), "custom content");
-
-			const customFiles = await FileScanner.findCustomFiles(destDir, sourceDir, ".claude");
-
-			expect(customFiles).toHaveLength(1);
-			expect(customFiles).toContain(".claude/custom.md");
-		});
-
-		test("should handle nested subdirectories", async () => {
-			// Create nested structure
-			const destNestedDir = join(destDir, ".claude", "commands");
-			const sourceNestedDir = join(sourceDir, ".claude", "commands");
-			await mkdir(destNestedDir, { recursive: true });
-			await mkdir(sourceNestedDir, { recursive: true });
-
-			// Create custom file in nested dir
-			await writeFile(join(destNestedDir, "custom-cmd.md"), "custom command");
-			await writeFile(join(destNestedDir, "standard-cmd.md"), "standard command");
-			await writeFile(join(sourceNestedDir, "standard-cmd.md"), "standard command");
-
-			const customFiles = await FileScanner.findCustomFiles(destDir, sourceDir, ".claude");
-
-			expect(customFiles).toHaveLength(1);
-			expect(customFiles).toContain(".claude/commands/custom-cmd.md");
-		});
-
-		test("should handle multiple custom files", async () => {
-			// Create .claude directories
-			const destClaudeDir = join(destDir, ".claude");
-			const sourceClaudeDir = join(sourceDir, ".claude");
-			await mkdir(destClaudeDir, { recursive: true });
-			await mkdir(sourceClaudeDir, { recursive: true });
-
-			// Create multiple custom files
-			await writeFile(join(destClaudeDir, "custom1.md"), "custom1");
-			await writeFile(join(destClaudeDir, "custom2.md"), "custom2");
-			await writeFile(join(destClaudeDir, "custom3.md"), "custom3");
-			await writeFile(join(destClaudeDir, "standard.md"), "standard");
-			await writeFile(join(sourceClaudeDir, "standard.md"), "standard");
-
-			const customFiles = await FileScanner.findCustomFiles(destDir, sourceDir, ".claude");
-
-			expect(customFiles).toHaveLength(3);
-			expect(customFiles).toContain(".claude/custom1.md");
-			expect(customFiles).toContain(".claude/custom2.md");
-			expect(customFiles).toContain(".claude/custom3.md");
-		});
-
-		test("should handle files with special characters in names", async () => {
-			// Create .claude directories
-			const destClaudeDir = join(destDir, ".claude");
-			const sourceClaudeDir = join(sourceDir, ".claude");
-			await mkdir(destClaudeDir, { recursive: true });
-			await mkdir(sourceClaudeDir, { recursive: true });
-
-			// Create files with special characters
-			await writeFile(join(destClaudeDir, "file-with-dash.md"), "content");
-			await writeFile(join(destClaudeDir, "file_with_underscore.md"), "content");
-			await writeFile(join(destClaudeDir, "file.multiple.dots.md"), "content");
-
-			const customFiles = await FileScanner.findCustomFiles(destDir, sourceDir, ".claude");
-
-			expect(customFiles).toHaveLength(3);
-			expect(customFiles).toContain(".claude/file-with-dash.md");
-			expect(customFiles).toContain(".claude/file_with_underscore.md");
-			expect(customFiles).toContain(".claude/file.multiple.dots.md");
-		});
-	});
-});

package/tests/utils/logger.test.ts

@@ -1,239 +0,0 @@
-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(() => {
-		// Reset logger state
-		logger.setVerbose(false);
-		logger.setLogFile(undefined);
-
-		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 Bearer tokens", () => {
-			const text = "Authorization: Bearer abc123xyz-token_value";
-			const sanitized = logger.sanitize(text);
-			expect(sanitized).toBe("Authorization: Bearer ***");
-		});
-
-		test("should sanitize query string tokens", () => {
-			const text = "https://api.example.com?token=secret123";
-			const sanitized = logger.sanitize(text);
-			expect(sanitized).toBe("https://api.example.com?token=***");
-		});
-
-		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("");
-		});
-	});
-
-	describe("verbose", () => {
-		beforeEach(() => {
-			logger.setVerbose(false);
-		});
-
-		test("should not log when verbose is disabled", () => {
-			logger.verbose("Test verbose message");
-			expect(consoleErrorSpy).not.toHaveBeenCalled();
-		});
-
-		test("should log to stderr when verbose is enabled", () => {
-			logger.setVerbose(true);
-			logger.verbose("Test verbose message");
-			expect(consoleErrorSpy).toHaveBeenCalled();
-			const call = consoleErrorSpy.mock.calls[1][0];
-			expect(call).toContain("[VERBOSE]");
-			expect(call).toContain("Test verbose message");
-		});
-
-		test("should include timestamp in verbose logs", () => {
-			logger.setVerbose(true);
-			logger.verbose("Test message");
-			const call = consoleErrorSpy.mock.calls[1][0];
-			expect(call).toMatch(/\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/);
-		});
-
-		test("should sanitize sensitive data in verbose logs", () => {
-			logger.setVerbose(true);
-			logger.verbose("Token: ghp_123456789012345678901234567890123456");
-			const call = consoleErrorSpy.mock.calls[1][0];
-			expect(call).toContain("ghp_***");
-			expect(call).not.toContain("ghp_123456789012345678901234567890123456");
-		});
-
-		test("should include context in verbose logs", () => {
-			logger.setVerbose(true);
-			logger.verbose("Test message", { key: "value", num: 123 });
-			const call = consoleErrorSpy.mock.calls[1][0];
-			expect(call).toContain('"key": "value"');
-			expect(call).toContain('"num": 123');
-		});
-
-		test("should sanitize context strings", () => {
-			logger.setVerbose(true);
-			logger.verbose("Test message", {
-				token: "ghp_123456789012345678901234567890123456",
-			});
-			const call = consoleErrorSpy.mock.calls[1][0];
-			expect(call).toContain("ghp_***");
-			expect(call).not.toContain("ghp_123456789012345678901234567890123456");
-		});
-
-		test("should handle nested objects in context", () => {
-			logger.setVerbose(true);
-			logger.verbose("Test message", {
-				nested: { key: "value" },
-			});
-			const call = consoleErrorSpy.mock.calls[1][0];
-			expect(call).toContain('"nested"');
-		});
-	});
-
-	describe("setVerbose", () => {
-		test("should enable verbose logging", () => {
-			logger.setVerbose(true);
-			expect(logger.isVerbose()).toBe(true);
-		});
-
-		test("should disable verbose logging", () => {
-			logger.setVerbose(true);
-			logger.setVerbose(false);
-			expect(logger.isVerbose()).toBe(false);
-		});
-
-		test("should log when enabling verbose", () => {
-			logger.setVerbose(true);
-			expect(consoleErrorSpy).toHaveBeenCalled();
-			const call = consoleErrorSpy.mock.calls[0][0];
-			expect(call).toContain("Verbose logging enabled");
-		});
-	});
-
-	describe("isVerbose", () => {
-		test("should return false by default", () => {
-			expect(logger.isVerbose()).toBe(false);
-		});
-
-		test("should return true when enabled", () => {
-			logger.setVerbose(true);
-			expect(logger.isVerbose()).toBe(true);
-		});
-
-		test("should return false when disabled", () => {
-			logger.setVerbose(true);
-			logger.setVerbose(false);
-			expect(logger.isVerbose()).toBe(false);
-		});
-	});
-});