berget 2.2.7 → 2.2.8

package/dist/tests/commands/code.test.js

@@ -22,46 +22,37 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-const vitest_1 = require("vitest");
 const commander_1 = require("commander");
+const fs = __importStar(require("node:fs"));
+const promises_1 = require("node:fs/promises");
+const vitest_1 = require("vitest");
 const code_1 = require("../../src/commands/code");
 const api_key_service_1 = require("../../src/services/api-key-service");
-const fs = __importStar(require("fs"));
-const promises_1 = require("fs/promises");
 const env_manager_1 = require("../../src/utils/env-manager");
 // Mock dependencies
-vitest_1.vi.mock("../../src/services/api-key-service");
-vitest_1.vi.mock("fs", () => ({
+vitest_1.vi.mock('../../src/services/api-key-service');
+vitest_1.vi.mock('fs', () => ({
     default: {
         existsSync: vitest_1.vi.fn(),
         readFileSync: vitest_1.vi.fn(),
     },
 }));
-vitest_1.vi.mock("fs/promises", () => ({
+vitest_1.vi.mock('fs/promises', () => ({
     readFile: vitest_1.vi.fn(),
     writeFile: vitest_1.vi.fn(),
 }));
-vitest_1.vi.mock("../../src/utils/env-manager");
-vitest_1.vi.mock("child_process", () => ({
+vitest_1.vi.mock('../../src/utils/env-manager');
+vitest_1.vi.mock('child_process', () => ({
     spawn: vitest_1.vi.fn(),
 }));
-vitest_1.vi.mock("readline", () => ({
+vitest_1.vi.mock('readline', () => ({
     createInterface: vitest_1.vi.fn(() => ({
-        question: vitest_1.vi.fn(),
         close: vitest_1.vi.fn(),
+        question: vitest_1.vi.fn(),
     })),
 }));
-(0, vitest_1.describe)("Code Commands", () => {
+(0, vitest_1.describe)('Code Commands', () => {
     let program;
     let mockApiKeyService;
     let mockFs;
@@ -86,47 +77,47 @@ vitest_1.vi.mock("readline", () => ({
         mockFsPromises.writeFile = vitest_1.vi.fn();
         // Mock spawn
         mockSpawn = vitest_1.vi.fn();
-        vitest_1.vi.doMock("child_process", () => ({ spawn: mockSpawn }));
+        vitest_1.vi.doMock('child_process', () => ({ spawn: mockSpawn }));
         (0, code_1.registerCodeCommands)(program);
     });
     (0, vitest_1.afterEach)(() => {
         vitest_1.vi.clearAllMocks();
     });
-    (0, vitest_1.describe)("code init command", () => {
-        (0, vitest_1.it)("should register init command with correct description", () => {
-            const codeCommand = program.commands.find(cmd => cmd.name() === "code");
-            const initCommand = codeCommand === null || codeCommand === void 0 ? void 0 : codeCommand.commands.find(cmd => cmd.name() === "init");
+    (0, vitest_1.describe)('code init command', () => {
+        (0, vitest_1.it)('should register init command with correct description', () => {
+            const codeCommand = program.commands.find((cmd) => cmd.name() === 'code');
+            const initCommand = codeCommand?.commands.find((cmd) => cmd.name() === 'init');
             (0, vitest_1.expect)(initCommand).toBeDefined();
-            (0, vitest_1.expect)(initCommand === null || initCommand === void 0 ? void 0 : initCommand.description()).toBe("Initialize project for AI coding assistant");
+            (0, vitest_1.expect)(initCommand?.description()).toBe('Initialize project for AI coding assistant');
         });
-        (0, vitest_1.it)("should have name, force, and yes options", () => {
-            const codeCommand = program.commands.find(cmd => cmd.name() === "code");
-            const initCommand = codeCommand === null || codeCommand === void 0 ? void 0 : codeCommand.commands.find(cmd => cmd.name() === "init");
+        (0, vitest_1.it)('should have name, force, and yes options', () => {
+            const codeCommand = program.commands.find((cmd) => cmd.name() === 'code');
+            const initCommand = codeCommand?.commands.find((cmd) => cmd.name() === 'init');
             (0, vitest_1.expect)(initCommand).toBeDefined();
-            const nameOption = initCommand === null || initCommand === void 0 ? void 0 : initCommand.options.find(opt => opt.long === "--name");
-            const forceOption = initCommand === null || initCommand === void 0 ? void 0 : initCommand.options.find(opt => opt.long === "--force");
-            const yesOption = initCommand === null || initCommand === void 0 ? void 0 : initCommand.options.find(opt => opt.long === "--yes");
+            const nameOption = initCommand?.options.find((opt) => opt.long === '--name');
+            const forceOption = initCommand?.options.find((opt) => opt.long === '--force');
+            const yesOption = initCommand?.options.find((opt) => opt.long === '--yes');
             (0, vitest_1.expect)(nameOption).toBeDefined();
-            (0, vitest_1.expect)(nameOption === null || nameOption === void 0 ? void 0 : nameOption.description).toContain("Project name");
+            (0, vitest_1.expect)(nameOption?.description).toContain('Project name');
             (0, vitest_1.expect)(forceOption).toBeDefined();
-            (0, vitest_1.expect)(forceOption === null || forceOption === void 0 ? void 0 : forceOption.description).toContain("Overwrite existing configuration");
+            (0, vitest_1.expect)(forceOption?.description).toContain('Overwrite existing configuration');
             (0, vitest_1.expect)(yesOption).toBeDefined();
-            (0, vitest_1.expect)(yesOption === null || yesOption === void 0 ? void 0 : yesOption.description).toContain("Automatically answer yes");
+            (0, vitest_1.expect)(yesOption?.description).toContain('Automatically answer yes');
         });
-        (0, vitest_1.it)("should check if opencode is installed", () => {
-            const codeCommand = program.commands.find(cmd => cmd.name() === "code");
-            const initCommand = codeCommand === null || codeCommand === void 0 ? void 0 : codeCommand.commands.find(cmd => cmd.name() === "init");
+        (0, vitest_1.it)('should check if opencode is installed', () => {
+            const codeCommand = program.commands.find((cmd) => cmd.name() === 'code');
+            const initCommand = codeCommand?.commands.find((cmd) => cmd.name() === 'init');
             (0, vitest_1.expect)(initCommand).toBeDefined();
             // The command should attempt to spawn opencode --version
             // This is tested implicitly through the spawn mock
         });
-        (0, vitest_1.it)("should list existing API keys and allow selection", () => __awaiter(void 0, void 0, void 0, function* () {
+        (0, vitest_1.it)('should list existing API keys and allow selection', async () => {
             // Mock successful opencode installation check
-            mockSpawn.mockImplementation((command, args) => {
-                if (command === "opencode" && args[0] === "--version") {
+            mockSpawn.mockImplementation((command, arguments_) => {
+                if (command === 'opencode' && arguments_[0] === '--version') {
                     return {
                         on: vitest_1.vi.fn().mockImplementation((event, callback) => {
-                            if (event === "close")
+                            if (event === 'close')
                                 callback(0);
                         }),
                     };
@@ -136,34 +127,34 @@ vitest_1.vi.mock("readline", () => ({
             // Mock existing API keys
             const mockExistingKeys = [
                 {
+                    created: '2023-01-01T00:00:00.000Z',
                     id: 1,
-                    name: "existing-key-1",
-                    prefix: "sk_ber",
-                    created: "2023-01-01T00:00:00.000Z",
                     lastUsed: null,
+                    name: 'existing-key-1',
+                    prefix: 'sk_ber',
                 },
                 {
+                    created: '2023-01-02T00:00:00.000Z',
                     id: 2,
-                    name: "existing-key-2",
-                    prefix: "sk_ber",
-                    created: "2023-01-02T00:00:00.000Z",
-                    lastUsed: "2023-01-03T00:00:00.000Z",
+                    lastUsed: '2023-01-03T00:00:00.000Z',
+                    name: 'existing-key-2',
+                    prefix: 'sk_ber',
                 },
             ];
             mockApiKeyService.list.mockResolvedValue(mockExistingKeys);
             // Mock file operations
             mockFs.existsSync.mockReturnValue(false);
-            mockFsPromises.writeFile.mockResolvedValue(undefined);
+            mockFsPromises.writeFile.mockResolvedValue();
             // Verify that the list method is called
             (0, vitest_1.expect)(mockApiKeyService.list).toBeDefined();
-        }));
-        (0, vitest_1.it)("should create new API key with project-based naming", () => __awaiter(void 0, void 0, void 0, function* () {
+        });
+        (0, vitest_1.it)('should create new API key with project-based naming', async () => {
             // Mock successful opencode installation check
-            mockSpawn.mockImplementation((command, args) => {
-                if (command === "opencode" && args[0] === "--version") {
+            mockSpawn.mockImplementation((command, arguments_) => {
+                if (command === 'opencode' && arguments_[0] === '--version') {
                     return {
                         on: vitest_1.vi.fn().mockImplementation((event, callback) => {
-                            if (event === "close")
+                            if (event === 'close')
                                 callback(0);
                         }),
                     };
@@ -175,77 +166,77 @@ vitest_1.vi.mock("readline", () => ({
             // Mock successful API key creation
             const mockApiKeyData = {
                 id: 123,
-                name: "opencode-testproject-1234567890",
-                key: "test-api-key-12345",
+                key: 'test-api-key-12345',
+                name: 'opencode-testproject-1234567890',
             };
             mockApiKeyService.create.mockResolvedValue(mockApiKeyData);
             // Mock file operations
             mockFs.existsSync.mockReturnValue(false);
-            mockFsPromises.writeFile.mockResolvedValue(undefined);
+            mockFsPromises.writeFile.mockResolvedValue();
             // Verify that the create method is available
             (0, vitest_1.expect)(mockApiKeyService.create).toBeDefined();
-        }));
-        (0, vitest_1.it)("should create opencode.json with correct structure", () => __awaiter(void 0, void 0, void 0, function* () {
+        });
+        (0, vitest_1.it)('should create opencode.json with correct structure', async () => {
             // This tests the expected config structure
             const expectedConfig = {
-                model: "berget/glm-4-6",
-                apiKey: "test-api-key",
-                projectName: "testproject",
-                provider: "berget",
+                apiKey: 'test-api-key',
                 created: vitest_1.expect.any(String),
-                version: "1.0.0",
+                model: 'berget/glm-4-6',
+                projectName: 'testproject',
+                provider: 'berget',
+                version: '1.0.0',
             };
-            (0, vitest_1.expect)(expectedConfig.model).toBe("berget/glm-4-6");
-            (0, vitest_1.expect)(expectedConfig.provider).toBe("berget");
-            (0, vitest_1.expect)(expectedConfig.version).toBe("1.0.0");
-        }));
-        (0, vitest_1.it)("should handle existing config file", () => {
-            const codeCommand = program.commands.find(cmd => cmd.name() === "code");
-            const initCommand = codeCommand === null || codeCommand === void 0 ? void 0 : codeCommand.commands.find(cmd => cmd.name() === "init");
+            (0, vitest_1.expect)(expectedConfig.model).toBe('berget/glm-4-6');
+            (0, vitest_1.expect)(expectedConfig.provider).toBe('berget');
+            (0, vitest_1.expect)(expectedConfig.version).toBe('1.0.0');
+        });
+        (0, vitest_1.it)('should handle existing config file', () => {
+            const codeCommand = program.commands.find((cmd) => cmd.name() === 'code');
+            const initCommand = codeCommand?.commands.find((cmd) => cmd.name() === 'init');
             (0, vitest_1.expect)(initCommand).toBeDefined();
             // Should check if opencode.json exists before proceeding
             (0, vitest_1.expect)(mockFs.existsSync).toBeDefined();
         });
     });
-    (0, vitest_1.describe)("code run command", () => {
-        (0, vitest_1.it)("should register run command with correct description", () => {
-            const codeCommand = program.commands.find(cmd => cmd.name() === "code");
-            const runCommand = codeCommand === null || codeCommand === void 0 ? void 0 : codeCommand.commands.find(cmd => cmd.name() === "run");
+    (0, vitest_1.describe)('code run command', () => {
+        (0, vitest_1.it)('should register run command with correct description', () => {
+            const codeCommand = program.commands.find((cmd) => cmd.name() === 'code');
+            const runCommand = codeCommand?.commands.find((cmd) => cmd.name() === 'run');
             (0, vitest_1.expect)(runCommand).toBeDefined();
-            (0, vitest_1.expect)(runCommand === null || runCommand === void 0 ? void 0 : runCommand.description()).toBe("Run AI coding assistant");
+            (0, vitest_1.expect)(runCommand?.description()).toBe('Run AI coding assistant');
         });
-        (0, vitest_1.it)("should accept prompt argument and model, no-config, and yes options", () => {
-            const codeCommand = program.commands.find(cmd => cmd.name() === "code");
-            const runCommand = codeCommand === null || codeCommand === void 0 ? void 0 : codeCommand.commands.find(cmd => cmd.name() === "run");
+        (0, vitest_1.it)('should accept prompt argument and model, no-config, and yes options', () => {
+            const codeCommand = program.commands.find((cmd) => cmd.name() === 'code');
+            const runCommand = codeCommand?.commands.find((cmd) => cmd.name() === 'run');
             (0, vitest_1.expect)(runCommand).toBeDefined();
-            const modelOption = runCommand === null || runCommand === void 0 ? void 0 : runCommand.options.find(opt => opt.long === "--model");
-            const noConfigOption = runCommand === null || runCommand === void 0 ? void 0 : runCommand.options.find(opt => opt.long === "--no-config");
-            const yesOption = runCommand === null || runCommand === void 0 ? void 0 : runCommand.options.find(opt => opt.long === "--yes");
+            const modelOption = runCommand?.options.find((opt) => opt.long === '--model');
+            const noConfigOption = runCommand?.options.find((opt) => opt.long === '--no-config');
+            const yesOption = runCommand?.options.find((opt) => opt.long === '--yes');
             (0, vitest_1.expect)(modelOption).toBeDefined();
-            (0, vitest_1.expect)(modelOption === null || modelOption === void 0 ? void 0 : modelOption.description).toContain("Model to use");
+            (0, vitest_1.expect)(modelOption?.description).toContain('Model to use');
             (0, vitest_1.expect)(noConfigOption).toBeDefined();
-            (0, vitest_1.expect)(noConfigOption === null || noConfigOption === void 0 ? void 0 : noConfigOption.description).toContain("Run without loading project config");
+            (0, vitest_1.expect)(noConfigOption?.description).toContain('Run without loading project config');
             (0, vitest_1.expect)(yesOption).toBeDefined();
-            (0, vitest_1.expect)(yesOption === null || yesOption === void 0 ? void 0 : yesOption.description).toContain("Automatically answer yes");
+            (0, vitest_1.expect)(yesOption?.description).toContain('Automatically answer yes');
         });
-        (0, vitest_1.it)("should load configuration from opencode.json", () => __awaiter(void 0, void 0, void 0, function* () {
+        (0, vitest_1.it)('should load configuration from opencode.json', async () => {
             const mockConfig = {
-                model: "berget/glm-4-6",
-                apiKey: "test-api-key",
-                projectName: "testproject",
-                provider: "berget",
-                created: "2023-01-01T00:00:00.000Z",
-                version: "1.0.0",
+                apiKey: 'test-api-key',
+                created: '2023-01-01T00:00:00.000Z',
+                model: 'berget/glm-4-6',
+                projectName: 'testproject',
+                provider: 'berget',
+                version: '1.0.0',
             };
             // Mock file exists and contains config
             mockFs.existsSync.mockReturnValue(true);
             mockFsPromises.readFile.mockResolvedValue(JSON.stringify(mockConfig));
             // Mock successful opencode check
-            mockSpawn.mockImplementation((command, args) => {
-                if (command === "opencode" && args[0] === "--version") {
+            mockSpawn.mockImplementation((command, arguments_) => {
+                if (command === 'opencode' && arguments_[0] === '--version') {
                     return {
                         on: vitest_1.vi.fn().mockImplementation((event, callback) => {
-                            if (event === "close")
+                            if (event === 'close')
                                 callback(0);
                         }),
                     };
@@ -253,37 +244,37 @@ vitest_1.vi.mock("readline", () => ({
                 return { on: vitest_1.vi.fn() };
             });
             // Verify config structure expectations
-            (0, vitest_1.expect)(mockConfig.model).toBe("berget/glm-4-6");
-            (0, vitest_1.expect)(mockConfig.apiKey).toBe("test-api-key");
-            (0, vitest_1.expect)(mockConfig.projectName).toBe("testproject");
-        }));
-        (0, vitest_1.it)("should spawn opencode with correct arguments", () => {
-            const codeCommand = program.commands.find(cmd => cmd.name() === "code");
-            const runCommand = codeCommand === null || codeCommand === void 0 ? void 0 : codeCommand.commands.find(cmd => cmd.name() === "run");
+            (0, vitest_1.expect)(mockConfig.model).toBe('berget/glm-4-6');
+            (0, vitest_1.expect)(mockConfig.apiKey).toBe('test-api-key');
+            (0, vitest_1.expect)(mockConfig.projectName).toBe('testproject');
+        });
+        (0, vitest_1.it)('should spawn opencode with correct arguments', () => {
+            const codeCommand = program.commands.find((cmd) => cmd.name() === 'code');
+            const runCommand = codeCommand?.commands.find((cmd) => cmd.name() === 'run');
             (0, vitest_1.expect)(runCommand).toBeDefined();
             // Should spawn opencode with appropriate arguments
             (0, vitest_1.expect)(mockSpawn).toBeDefined();
         });
-        (0, vitest_1.it)("should handle missing configuration file", () => {
-            const codeCommand = program.commands.find(cmd => cmd.name() === "code");
-            const runCommand = codeCommand === null || codeCommand === void 0 ? void 0 : codeCommand.commands.find(cmd => cmd.name() === "run");
+        (0, vitest_1.it)('should handle missing configuration file', () => {
+            const codeCommand = program.commands.find((cmd) => cmd.name() === 'code');
+            const runCommand = codeCommand?.commands.find((cmd) => cmd.name() === 'run');
             (0, vitest_1.expect)(runCommand).toBeDefined();
             // Should check if opencode.json exists
             (0, vitest_1.expect)(mockFs.existsSync).toBeDefined();
         });
     });
-    (0, vitest_1.describe)("opencode installation", () => {
-        (0, vitest_1.it)("should check if opencode is installed", () => {
+    (0, vitest_1.describe)('opencode installation', () => {
+        (0, vitest_1.it)('should check if opencode is installed', () => {
             // The spawn function should be called with opencode --version
             (0, vitest_1.expect)(mockSpawn).toBeDefined();
         });
-        (0, vitest_1.it)("should offer to install opencode if not found", () => {
+        (0, vitest_1.it)('should offer to install opencode if not found', () => {
             // Mock opencode not installed
-            mockSpawn.mockImplementation((command, args) => {
-                if (command === "opencode" && args[0] === "--version") {
+            mockSpawn.mockImplementation((command, arguments_) => {
+                if (command === 'opencode' && arguments_[0] === '--version') {
                     return {
                         on: vitest_1.vi.fn().mockImplementation((event, callback) => {
-                            if (event === "close")
+                            if (event === 'close')
                                 callback(1); // Non-zero exit code
                         }),
                     };
@@ -293,153 +284,153 @@ vitest_1.vi.mock("readline", () => ({
             // Should handle the case where opencode is not installed
             (0, vitest_1.expect)(mockSpawn).toBeDefined();
         });
-        (0, vitest_1.it)("should install opencode via npm if user agrees", () => {
+        (0, vitest_1.it)('should install opencode via npm if user agrees', () => {
             // Should spawn npm install -g opencode-ai
             (0, vitest_1.expect)(mockSpawn).toBeDefined();
         });
     });
-    (0, vitest_1.describe)("automation support", () => {
-        (0, vitest_1.it)("should support -y flag for automated initialization", () => {
-            const codeCommand = program.commands.find(cmd => cmd.name() === "code");
-            const initCommand = codeCommand === null || codeCommand === void 0 ? void 0 : codeCommand.commands.find(cmd => cmd.name() === "init");
+    (0, vitest_1.describe)('automation support', () => {
+        (0, vitest_1.it)('should support -y flag for automated initialization', () => {
+            const codeCommand = program.commands.find((cmd) => cmd.name() === 'code');
+            const initCommand = codeCommand?.commands.find((cmd) => cmd.name() === 'init');
             (0, vitest_1.expect)(initCommand).toBeDefined();
-            const yesOption = initCommand === null || initCommand === void 0 ? void 0 : initCommand.options.find(opt => opt.long === "--yes");
+            const yesOption = initCommand?.options.find((opt) => opt.long === '--yes');
             (0, vitest_1.expect)(yesOption).toBeDefined();
-            (0, vitest_1.expect)(yesOption === null || yesOption === void 0 ? void 0 : yesOption.description).toContain("automation");
+            (0, vitest_1.expect)(yesOption?.description).toContain('automation');
         });
-        (0, vitest_1.it)("should support -y flag for automated run", () => {
-            const codeCommand = program.commands.find(cmd => cmd.name() === "code");
-            const runCommand = codeCommand === null || codeCommand === void 0 ? void 0 : codeCommand.commands.find(cmd => cmd.name() === "run");
+        (0, vitest_1.it)('should support -y flag for automated run', () => {
+            const codeCommand = program.commands.find((cmd) => cmd.name() === 'code');
+            const runCommand = codeCommand?.commands.find((cmd) => cmd.name() === 'run');
             (0, vitest_1.expect)(runCommand).toBeDefined();
-            const yesOption = runCommand === null || runCommand === void 0 ? void 0 : runCommand.options.find(opt => opt.long === "--yes");
+            const yesOption = runCommand?.options.find((opt) => opt.long === '--yes');
             (0, vitest_1.expect)(yesOption).toBeDefined();
-            (0, vitest_1.expect)(yesOption === null || yesOption === void 0 ? void 0 : yesOption.description).toContain("automation");
+            (0, vitest_1.expect)(yesOption?.description).toContain('automation');
         });
-        (0, vitest_1.it)("should use BERGET_API_KEY environment variable in automation mode", () => {
+        (0, vitest_1.it)('should use BERGET_API_KEY environment variable in automation mode', () => {
             // Test that environment variable is used when -y flag is set
-            process.env.BERGET_API_KEY = "test-env-key";
-            (0, vitest_1.expect)(process.env.BERGET_API_KEY).toBe("test-env-key");
+            process.env.BERGET_API_KEY = 'test-env-key';
+            (0, vitest_1.expect)(process.env.BERGET_API_KEY).toBe('test-env-key');
             // Clean up
             delete process.env.BERGET_API_KEY;
         });
     });
-    (0, vitest_1.describe)(".env file handling", () => {
-        let mockUpdateEnvFile;
+    (0, vitest_1.describe)('.env file handling', () => {
+        let mockUpdateEnvironmentFile;
         (0, vitest_1.beforeEach)(() => {
-            mockUpdateEnvFile = vitest_1.vi.mocked(env_manager_1.updateEnvFile);
+            mockUpdateEnvironmentFile = vitest_1.vi.mocked(env_manager_1.updateEnvFile);
         });
-        (0, vitest_1.it)("should call updateEnvFile when creating new project", () => __awaiter(void 0, void 0, void 0, function* () {
-            mockUpdateEnvFile.mockResolvedValue(true);
+        (0, vitest_1.it)('should call updateEnvFile when creating new project', async () => {
+            mockUpdateEnvironmentFile.mockResolvedValue(true);
             mockFs.existsSync.mockReturnValue(false); // .env doesn't exist
-            mockFsPromises.writeFile.mockResolvedValue(undefined);
+            mockFsPromises.writeFile.mockResolvedValue();
             // This would be tested by actually calling the init command
             // For now we verify the mock is properly set up
-            (0, vitest_1.expect)(mockUpdateEnvFile).toBeDefined();
-        }));
-        (0, vitest_1.it)("should not overwrite existing BERGET_API_KEY in .env", () => __awaiter(void 0, void 0, void 0, function* () {
-            const consoleSpy = vitest_1.vi.spyOn(console, "log").mockImplementation(() => { });
+            (0, vitest_1.expect)(mockUpdateEnvironmentFile).toBeDefined();
+        });
+        (0, vitest_1.it)('should not overwrite existing BERGET_API_KEY in .env', async () => {
+            const consoleSpy = vitest_1.vi.spyOn(console, 'log').mockImplementation(() => { });
             // Mock existing .env with BERGET_API_KEY
             mockFs.existsSync.mockReturnValue(true);
-            mockFs.readFileSync.mockReturnValue("BERGET_API_KEY=existing_key\nOTHER_KEY=value\n");
+            mockFs.readFileSync.mockReturnValue('BERGET_API_KEY=existing_key\nOTHER_KEY=value\n');
             // Mock updateEnvFile to simulate the check
-            mockUpdateEnvFile.mockImplementation((options) => __awaiter(void 0, void 0, void 0, function* () {
-                if (options.key === "BERGET_API_KEY" && !options.force) {
+            mockUpdateEnvironmentFile.mockImplementation(async (options) => {
+                if (options.key === 'BERGET_API_KEY' && !options.force) {
                     console.log(`⚠ ${options.key} already exists in .env - leaving unchanged`);
                     return false;
                 }
                 return true;
-            }));
-            yield (0, env_manager_1.updateEnvFile)({
-                key: "BERGET_API_KEY",
-                value: "new_key",
             });
-            (0, vitest_1.expect)(consoleSpy).toHaveBeenCalledWith(vitest_1.expect.stringContaining("BERGET_API_KEY already exists in .env - leaving unchanged"));
+            await (0, env_manager_1.updateEnvFile)({
+                key: 'BERGET_API_KEY',
+                value: 'new_key',
+            });
+            (0, vitest_1.expect)(consoleSpy).toHaveBeenCalledWith(vitest_1.expect.stringContaining('BERGET_API_KEY already exists in .env - leaving unchanged'));
             consoleSpy.mockRestore();
-        }));
-        (0, vitest_1.it)("should add new key to existing .env file", () => __awaiter(void 0, void 0, void 0, function* () {
+        });
+        (0, vitest_1.it)('should add new key to existing .env file', async () => {
             mockFs.existsSync.mockReturnValue(true);
-            mockFs.readFileSync.mockReturnValue("EXISTING_KEY=value\n");
-            mockUpdateEnvFile.mockResolvedValue(true);
-            yield (0, env_manager_1.updateEnvFile)({
-                key: "BERGET_API_KEY",
-                value: "new_api_key",
-                comment: "Berget AI Configuration",
+            mockFs.readFileSync.mockReturnValue('EXISTING_KEY=value\n');
+            mockUpdateEnvironmentFile.mockResolvedValue(true);
+            await (0, env_manager_1.updateEnvFile)({
+                comment: 'Berget AI Configuration',
+                key: 'BERGET_API_KEY',
+                value: 'new_api_key',
             });
-            (0, vitest_1.expect)(mockUpdateEnvFile).toHaveBeenCalledWith({
-                key: "BERGET_API_KEY",
-                value: "new_api_key",
-                comment: "Berget AI Configuration",
+            (0, vitest_1.expect)(mockUpdateEnvironmentFile).toHaveBeenCalledWith({
+                comment: 'Berget AI Configuration',
+                key: 'BERGET_API_KEY',
+                value: 'new_api_key',
             });
-        }));
-        (0, vitest_1.it)("should create new .env file when none exists", () => __awaiter(void 0, void 0, void 0, function* () {
+        });
+        (0, vitest_1.it)('should create new .env file when none exists', async () => {
             mockFs.existsSync.mockReturnValue(false);
-            mockUpdateEnvFile.mockResolvedValue(true);
-            yield (0, env_manager_1.updateEnvFile)({
-                key: "BERGET_API_KEY",
-                value: "new_api_key",
+            mockUpdateEnvironmentFile.mockResolvedValue(true);
+            await (0, env_manager_1.updateEnvFile)({
+                key: 'BERGET_API_KEY',
+                value: 'new_api_key',
             });
-            (0, vitest_1.expect)(mockUpdateEnvFile).toHaveBeenCalledWith({
-                key: "BERGET_API_KEY",
-                value: "new_api_key",
+            (0, vitest_1.expect)(mockUpdateEnvironmentFile).toHaveBeenCalledWith({
+                key: 'BERGET_API_KEY',
+                value: 'new_api_key',
             });
-        }));
+        });
     });
-    (0, vitest_1.describe)("error handling", () => {
-        (0, vitest_1.it)("should handle API key creation failures", () => {
+    (0, vitest_1.describe)('error handling', () => {
+        (0, vitest_1.it)('should handle API key creation failures', () => {
             // Mock API key service to throw error
-            mockApiKeyService.create.mockRejectedValue(new Error("API Error"));
+            mockApiKeyService.create.mockRejectedValue(new Error('API Error'));
             (0, vitest_1.expect)(mockApiKeyService.create).toBeDefined();
         });
-        (0, vitest_1.it)("should handle file system errors", () => {
+        (0, vitest_1.it)('should handle file system errors', () => {
             // Mock file operations to throw errors
-            mockFsPromises.writeFile.mockRejectedValue(new Error("File write error"));
+            mockFsPromises.writeFile.mockRejectedValue(new Error('File write error'));
             (0, vitest_1.expect)(mockFsPromises.writeFile).toBeDefined();
         });
-        (0, vitest_1.it)("should handle spawn errors", () => {
+        (0, vitest_1.it)('should handle spawn errors', () => {
             // Mock spawn to throw error
             mockSpawn.mockImplementation(() => {
-                throw new Error("Command not found");
+                throw new Error('Command not found');
             });
             (0, vitest_1.expect)(mockSpawn).toBeDefined();
         });
-        (0, vitest_1.it)("should handle .env update failures", () => __awaiter(void 0, void 0, void 0, function* () {
-            const mockUpdateEnvFile = vitest_1.vi.mocked(env_manager_1.updateEnvFile);
-            mockUpdateEnvFile.mockRejectedValue(new Error("Env update failed"));
-            yield (0, vitest_1.expect)((0, env_manager_1.updateEnvFile)({
-                key: "TEST_KEY",
-                value: "test_value",
-            })).rejects.toThrow("Env update failed");
-        }));
+        (0, vitest_1.it)('should handle .env update failures', async () => {
+            const mockUpdateEnvironmentFile = vitest_1.vi.mocked(env_manager_1.updateEnvFile);
+            mockUpdateEnvironmentFile.mockRejectedValue(new Error('Env update failed'));
+            await (0, vitest_1.expect)((0, env_manager_1.updateEnvFile)({
+                key: 'TEST_KEY',
+                value: 'test_value',
+            })).rejects.toThrow('Env update failed');
+        });
     });
-    (0, vitest_1.describe)("experimental features", () => {
-        let originalEnv;
+    (0, vitest_1.describe)('experimental features', () => {
+        let originalEnvironment;
         (0, vitest_1.beforeEach)(() => {
-            originalEnv = process.env.BERGET_EXPERIMENTAL;
+            originalEnvironment = process.env.BERGET_EXPERIMENTAL;
         });
         (0, vitest_1.afterEach)(() => {
-            if (originalEnv === undefined) {
+            if (originalEnvironment === undefined) {
                 delete process.env.BERGET_EXPERIMENTAL;
             }
             else {
-                process.env.BERGET_EXPERIMENTAL = originalEnv;
+                process.env.BERGET_EXPERIMENTAL = originalEnvironment;
             }
         });
-        (0, vitest_1.it)("should NOT show setup command when BERGET_EXPERIMENTAL is not set", () => {
+        (0, vitest_1.it)('should NOT show setup command when BERGET_EXPERIMENTAL is not set', () => {
             delete process.env.BERGET_EXPERIMENTAL;
             const freshProgram = new commander_1.Command();
             (0, code_1.registerCodeCommands)(freshProgram);
-            const codeCommand = freshProgram.commands.find(cmd => cmd.name() === "code");
-            const setupCommand = codeCommand === null || codeCommand === void 0 ? void 0 : codeCommand.commands.find(cmd => cmd.name() === "setup");
+            const codeCommand = freshProgram.commands.find((cmd) => cmd.name() === 'code');
+            const setupCommand = codeCommand?.commands.find((cmd) => cmd.name() === 'setup');
             (0, vitest_1.expect)(setupCommand).toBeUndefined();
         });
-        (0, vitest_1.it)("should show setup command when BERGET_EXPERIMENTAL is set", () => {
-            process.env.BERGET_EXPERIMENTAL = "1";
+        (0, vitest_1.it)('should show setup command when BERGET_EXPERIMENTAL is set', () => {
+            process.env.BERGET_EXPERIMENTAL = '1';
             const freshProgram = new commander_1.Command();
             (0, code_1.registerCodeCommands)(freshProgram);
-            const codeCommand = freshProgram.commands.find(cmd => cmd.name() === "code");
-            const setupCommand = codeCommand === null || codeCommand === void 0 ? void 0 : codeCommand.commands.find(cmd => cmd.name() === "setup");
+            const codeCommand = freshProgram.commands.find((cmd) => cmd.name() === 'code');
+            const setupCommand = codeCommand?.commands.find((cmd) => cmd.name() === 'setup');
             (0, vitest_1.expect)(setupCommand).toBeDefined();
-            (0, vitest_1.expect)(setupCommand === null || setupCommand === void 0 ? void 0 : setupCommand.description()).toBe("Interactive setup for Berget AI coding tools");
+            (0, vitest_1.expect)(setupCommand?.description()).toBe('Interactive setup for Berget AI coding tools');
         });
     });
 });