berget 2.2.7 → 2.2.8

package/dist/tests/utils/config-loader.test.js

@@ -5,13 +5,13 @@ const config_loader_1 = require("../../src/utils/config-loader");
 // Mock fs module
 const mockFs = vitest_1.vi.hoisted(() => ({
     existsSync: vitest_1.vi.fn(),
+    mkdirSync: vitest_1.vi.fn(),
     readFileSync: vitest_1.vi.fn(),
     writeFileSync: vitest_1.vi.fn(),
-    mkdirSync: vitest_1.vi.fn(),
 }));
-vitest_1.vi.mock("fs", () => mockFs);
-(0, vitest_1.describe)("ConfigLoader", () => {
-    const testConfigPath = "/tmp/test-opencode.json";
+vitest_1.vi.mock('fs', () => mockFs);
+(0, vitest_1.describe)('ConfigLoader', () => {
+    const testConfigPath = '/tmp/test-opencode.json';
     let configLoader;
     (0, vitest_1.beforeEach)(() => {
         // Reset mocks and clear singleton
@@ -24,242 +24,242 @@ vitest_1.vi.mock("fs", () => mockFs);
         vitest_1.vi.clearAllMocks();
         config_loader_1.ConfigLoader.clearInstance();
     });
-    (0, vitest_1.describe)("when config file does not exist", () => {
+    (0, vitest_1.describe)('when config file does not exist', () => {
         (0, vitest_1.beforeEach)(() => {
             mockFs.existsSync.mockReturnValue(false);
         });
-        (0, vitest_1.describe)("getModelConfig", () => {
-            (0, vitest_1.it)("should return default values when config file does not exist", () => {
+        (0, vitest_1.describe)('getModelConfig', () => {
+            (0, vitest_1.it)('should return default values when config file does not exist', () => {
                 const modelConfig = configLoader.getModelConfig();
                 (0, vitest_1.expect)(modelConfig).toEqual({
-                    primary: "berget/glm-4.7",
-                    small: "berget/gpt-oss",
+                    primary: 'berget/glm-4.7',
+                    small: 'berget/gpt-oss',
                 });
             });
-            (0, vitest_1.it)("should return default values when using convenience function", () => {
+            (0, vitest_1.it)('should return default values when using convenience function', () => {
                 const modelConfig = (0, config_loader_1.getModelConfig)(testConfigPath);
                 (0, vitest_1.expect)(modelConfig).toEqual({
-                    primary: "berget/glm-4.7",
-                    small: "berget/gpt-oss",
+                    primary: 'berget/glm-4.7',
+                    small: 'berget/gpt-oss',
                 });
             });
         });
-        (0, vitest_1.describe)("getProviderModels", () => {
-            (0, vitest_1.it)("should return default provider models when config file does not exist", () => {
+        (0, vitest_1.describe)('getProviderModels', () => {
+            (0, vitest_1.it)('should return default provider models when config file does not exist', () => {
                 const models = configLoader.getProviderModels();
                 (0, vitest_1.expect)(models).toEqual({
-                    "glm-4.7": {
-                        name: "GLM-4.7",
-                        limit: { output: 4000, context: 90000 },
+                    'glm-4.7': {
+                        limit: { context: 90000, output: 4000 },
+                        name: 'GLM-4.7',
                     },
-                    "gpt-oss": {
-                        name: "GPT-OSS",
-                        limit: { output: 4000, context: 128000 },
+                    'gpt-oss': {
+                        limit: { context: 128000, output: 4000 },
                         modalities: {
-                            input: ["text", "image"],
-                            output: ["text"],
+                            input: ['text', 'image'],
+                            output: ['text'],
                         },
+                        name: 'GPT-OSS',
                     },
-                    "llama-8b": {
-                        name: "llama-3.1-8b",
-                        limit: { output: 4000, context: 128000 },
+                    'llama-8b': {
+                        limit: { context: 128000, output: 4000 },
+                        name: 'llama-3.1-8b',
                     },
                 });
             });
-            (0, vitest_1.it)("should return default provider models when using convenience function", () => {
+            (0, vitest_1.it)('should return default provider models when using convenience function', () => {
                 const models = (0, config_loader_1.getProviderModels)(testConfigPath);
                 (0, vitest_1.expect)(models).toEqual({
-                    "glm-4.7": {
-                        name: "GLM-4.7",
-                        limit: { output: 4000, context: 90000 },
+                    'glm-4.7': {
+                        limit: { context: 90000, output: 4000 },
+                        name: 'GLM-4.7',
                     },
-                    "gpt-oss": {
-                        name: "GPT-OSS",
-                        limit: { output: 4000, context: 128000 },
+                    'gpt-oss': {
+                        limit: { context: 128000, output: 4000 },
                         modalities: {
-                            input: ["text", "image"],
-                            output: ["text"],
+                            input: ['text', 'image'],
+                            output: ['text'],
                         },
+                        name: 'GPT-OSS',
                     },
-                    "llama-8b": {
-                        name: "llama-3.1-8b",
-                        limit: { output: 4000, context: 128000 },
+                    'llama-8b': {
+                        limit: { context: 128000, output: 4000 },
+                        name: 'llama-3.1-8b',
                     },
                 });
             });
         });
-        (0, vitest_1.describe)("getAllAgentConfigs", () => {
-            (0, vitest_1.it)("should return empty object when config file does not exist", () => {
+        (0, vitest_1.describe)('getAllAgentConfigs', () => {
+            (0, vitest_1.it)('should return empty object when config file does not exist', () => {
                 const agents = configLoader.getAllAgentConfigs();
                 (0, vitest_1.expect)(agents).toEqual({});
             });
-            (0, vitest_1.it)("should return empty object when using convenience function", () => {
+            (0, vitest_1.it)('should return empty object when using convenience function', () => {
                 const agents = (0, config_loader_1.getAllAgentConfigs)(testConfigPath);
                 (0, vitest_1.expect)(agents).toEqual({});
             });
         });
-        (0, vitest_1.describe)("getAgentConfig", () => {
-            (0, vitest_1.it)("should return null when config file does not exist", () => {
-                const agent = configLoader.getAgentConfig("fullstack");
+        (0, vitest_1.describe)('getAgentConfig', () => {
+            (0, vitest_1.it)('should return null when config file does not exist', () => {
+                const agent = configLoader.getAgentConfig('fullstack');
                 (0, vitest_1.expect)(agent).toBeNull();
             });
         });
     });
-    (0, vitest_1.describe)("when config file exists", () => {
+    (0, vitest_1.describe)('when config file exists', () => {
         const mockConfig = {
-            model: "custom-model",
-            small_model: "custom-small-model",
             agent: {
                 fullstack: {
-                    model: "custom-agent-model",
-                    temperature: 0.5,
-                    mode: "primary",
+                    mode: 'primary',
+                    model: 'custom-agent-model',
                     permission: {
-                        edit: "allow",
-                        bash: "allow",
-                        webfetch: "allow",
+                        bash: 'allow',
+                        edit: 'allow',
+                        webfetch: 'allow',
                     },
+                    temperature: 0.5,
                 },
             },
             command: {
                 test: {
-                    description: "Test command",
+                    description: 'Test command',
                 },
             },
-            watcher: {
-                ignore: ["custom-ignore"],
-            },
+            model: 'custom-model',
             provider: {
                 berget: {
                     models: {
-                        "custom-model": {
-                            name: "Custom Model",
-                            limit: { output: 8000, context: 160000 },
+                        'custom-model': {
+                            limit: { context: 160000, output: 8000 },
+                            name: 'Custom Model',
                         },
                     },
                 },
             },
+            small_model: 'custom-small-model',
+            watcher: {
+                ignore: ['custom-ignore'],
+            },
         };
         (0, vitest_1.beforeEach)(() => {
             mockFs.existsSync.mockReturnValue(true);
             mockFs.readFileSync.mockReturnValue(JSON.stringify(mockConfig));
         });
-        (0, vitest_1.describe)("getModelConfig", () => {
-            (0, vitest_1.it)("should return values from config file", () => {
+        (0, vitest_1.describe)('getModelConfig', () => {
+            (0, vitest_1.it)('should return values from config file', () => {
                 const modelConfig = configLoader.getModelConfig();
                 (0, vitest_1.expect)(modelConfig).toEqual({
-                    primary: "custom-model",
-                    small: "custom-small-model",
+                    primary: 'custom-model',
+                    small: 'custom-small-model',
                 });
             });
         });
-        (0, vitest_1.describe)("getProviderModels", () => {
-            (0, vitest_1.it)("should return models from config file", () => {
+        (0, vitest_1.describe)('getProviderModels', () => {
+            (0, vitest_1.it)('should return models from config file', () => {
                 const models = configLoader.getProviderModels();
                 (0, vitest_1.expect)(models).toEqual({
-                    "custom-model": {
-                        name: "Custom Model",
-                        limit: { output: 8000, context: 160000 },
+                    'custom-model': {
+                        limit: { context: 160000, output: 8000 },
+                        name: 'Custom Model',
                     },
                 });
             });
         });
-        (0, vitest_1.describe)("getAllAgentConfigs", () => {
-            (0, vitest_1.it)("should return agents from config file", () => {
+        (0, vitest_1.describe)('getAllAgentConfigs', () => {
+            (0, vitest_1.it)('should return agents from config file', () => {
                 const agents = configLoader.getAllAgentConfigs();
                 (0, vitest_1.expect)(agents).toEqual(mockConfig.agent);
             });
         });
-        (0, vitest_1.describe)("getAgentConfig", () => {
-            (0, vitest_1.it)("should return specific agent from config file", () => {
-                const agent = configLoader.getAgentConfig("fullstack");
+        (0, vitest_1.describe)('getAgentConfig', () => {
+            (0, vitest_1.it)('should return specific agent from config file', () => {
+                const agent = configLoader.getAgentConfig('fullstack');
                 (0, vitest_1.expect)(agent).toEqual(mockConfig.agent.fullstack);
             });
-            (0, vitest_1.it)("should return null for non-existent agent", () => {
-                const agent = configLoader.getAgentConfig("nonexistent");
+            (0, vitest_1.it)('should return null for non-existent agent', () => {
+                const agent = configLoader.getAgentConfig('nonexistent');
                 (0, vitest_1.expect)(agent).toBeNull();
             });
         });
     });
-    (0, vitest_1.describe)("when config file is invalid JSON", () => {
+    (0, vitest_1.describe)('when config file is invalid JSON', () => {
         (0, vitest_1.beforeEach)(() => {
             mockFs.existsSync.mockReturnValue(true);
-            mockFs.readFileSync.mockReturnValue("invalid json {");
+            mockFs.readFileSync.mockReturnValue('invalid json {');
         });
-        (0, vitest_1.it)("should fall back to defaults for getModelConfig", () => {
+        (0, vitest_1.it)('should fall back to defaults for getModelConfig', () => {
             const modelConfig = configLoader.getModelConfig();
             (0, vitest_1.expect)(modelConfig).toEqual({
-                primary: "berget/glm-4.7",
-                small: "berget/gpt-oss",
+                primary: 'berget/glm-4.7',
+                small: 'berget/gpt-oss',
             });
         });
-        (0, vitest_1.it)("should fall back to defaults for getProviderModels", () => {
+        (0, vitest_1.it)('should fall back to defaults for getProviderModels', () => {
             const models = configLoader.getProviderModels();
             (0, vitest_1.expect)(models).toEqual({
-                "glm-4.7": {
-                    name: "GLM-4.7",
-                    limit: { output: 4000, context: 90000 },
+                'glm-4.7': {
+                    limit: { context: 90000, output: 4000 },
+                    name: 'GLM-4.7',
                 },
-                "gpt-oss": {
-                    name: "GPT-OSS",
-                    limit: { output: 4000, context: 128000 },
+                'gpt-oss': {
+                    limit: { context: 128000, output: 4000 },
                     modalities: {
-                        input: ["text", "image"],
-                        output: ["text"],
+                        input: ['text', 'image'],
+                        output: ['text'],
                     },
+                    name: 'GPT-OSS',
                 },
-                "llama-8b": {
-                    name: "llama-3.1-8b",
-                    limit: { output: 4000, context: 128000 },
+                'llama-8b': {
+                    limit: { context: 128000, output: 4000 },
+                    name: 'llama-3.1-8b',
                 },
             });
         });
-        (0, vitest_1.it)("should fall back to defaults for getAllAgentConfigs", () => {
+        (0, vitest_1.it)('should fall back to defaults for getAllAgentConfigs', () => {
             const agents = configLoader.getAllAgentConfigs();
             (0, vitest_1.expect)(agents).toEqual({});
         });
     });
-    (0, vitest_1.describe)("singleton pattern", () => {
-        (0, vitest_1.it)("should return the same instance for same path", () => {
+    (0, vitest_1.describe)('singleton pattern', () => {
+        (0, vitest_1.it)('should return the same instance for same path', () => {
             config_loader_1.ConfigLoader.clearInstance();
             const loader1 = config_loader_1.ConfigLoader.getInstance(testConfigPath);
             const loader2 = config_loader_1.ConfigLoader.getInstance(testConfigPath);
             (0, vitest_1.expect)(loader1).toBe(loader2);
         });
-        (0, vitest_1.it)("should return the same instance even for different paths (true singleton)", () => {
+        (0, vitest_1.it)('should return the same instance even for different paths (true singleton)', () => {
             config_loader_1.ConfigLoader.clearInstance();
-            const loader1 = config_loader_1.ConfigLoader.getInstance("/path1/config.json");
-            const loader2 = config_loader_1.ConfigLoader.getInstance("/path2/config.json");
+            const loader1 = config_loader_1.ConfigLoader.getInstance('/path1/config.json');
+            const loader2 = config_loader_1.ConfigLoader.getInstance('/path2/config.json');
             // ConfigLoader is a true singleton - it returns the same instance regardless of path
             (0, vitest_1.expect)(loader1).toBe(loader2);
         });
     });
-    (0, vitest_1.describe)("init scenario regression tests", () => {
-        (0, vitest_1.it)("should handle missing config file during init scenario", () => {
+    (0, vitest_1.describe)('init scenario regression tests', () => {
+        (0, vitest_1.it)('should handle missing config file during init scenario', () => {
             // This test specifically verifies the fix for the init issue
             mockFs.existsSync.mockReturnValue(false);
             // All these methods should work without throwing errors
             (0, vitest_1.expect)(() => configLoader.getModelConfig()).not.toThrow();
             (0, vitest_1.expect)(() => configLoader.getProviderModels()).not.toThrow();
             (0, vitest_1.expect)(() => configLoader.getAllAgentConfigs()).not.toThrow();
-            (0, vitest_1.expect)(() => configLoader.getAgentConfig("fullstack")).not.toThrow();
+            (0, vitest_1.expect)(() => configLoader.getAgentConfig('fullstack')).not.toThrow();
             // And return sensible defaults
             (0, vitest_1.expect)(configLoader.getModelConfig()).toEqual({
-                primary: "berget/glm-4.7",
-                small: "berget/gpt-oss",
+                primary: 'berget/glm-4.7',
+                small: 'berget/gpt-oss',
             });
             (0, vitest_1.expect)(configLoader.getAllAgentConfigs()).toEqual({});
-            (0, vitest_1.expect)(configLoader.getAgentConfig("fullstack")).toBeNull();
+            (0, vitest_1.expect)(configLoader.getAgentConfig('fullstack')).toBeNull();
         });
-        (0, vitest_1.it)("should work with convenience functions during init scenario", () => {
+        (0, vitest_1.it)('should work with convenience functions during init scenario', () => {
             // This test verifies that convenience functions also work during init
             mockFs.existsSync.mockReturnValue(false);
             (0, vitest_1.expect)(() => (0, config_loader_1.getModelConfig)(testConfigPath)).not.toThrow();
             (0, vitest_1.expect)(() => (0, config_loader_1.getProviderModels)(testConfigPath)).not.toThrow();
             (0, vitest_1.expect)(() => (0, config_loader_1.getAllAgentConfigs)(testConfigPath)).not.toThrow();
             (0, vitest_1.expect)((0, config_loader_1.getModelConfig)(testConfigPath)).toEqual({
-                primary: "berget/glm-4.7",
-                small: "berget/gpt-oss",
+                primary: 'berget/glm-4.7',
+                small: 'berget/gpt-oss',
             });
             (0, vitest_1.expect)((0, config_loader_1.getAllAgentConfigs)(testConfigPath)).toEqual({});
         });

package/dist/tests/utils/env-manager.test.js

@@ -1,148 +1,139 @@
 "use strict";
-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());
-    });
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+const node_fs_1 = __importDefault(require("node:fs"));
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
 const vitest_1 = require("vitest");
-const fs_1 = __importDefault(require("fs"));
-const promises_1 = require("fs/promises");
-const path_1 = __importDefault(require("path"));
 const env_manager_1 = require("../../src/utils/env-manager");
-vitest_1.vi.mock("fs");
-vitest_1.vi.mock("fs/promises");
-vitest_1.vi.mock("path");
-const mockFs = vitest_1.vi.mocked(fs_1.default);
+vitest_1.vi.mock('fs');
+vitest_1.vi.mock('fs/promises');
+vitest_1.vi.mock('path');
+const mockFs = vitest_1.vi.mocked(node_fs_1.default);
 const mockWriteFile = vitest_1.vi.mocked(promises_1.writeFile);
-const mockPath = vitest_1.vi.mocked(path_1.default);
-(0, vitest_1.describe)("env-manager", () => {
-    const testEnvPath = "/test/.env";
-    const testCwd = "/test";
+const mockPath = vitest_1.vi.mocked(node_path_1.default);
+(0, vitest_1.describe)('env-manager', () => {
+    const testEnvironmentPath = '/test/.env';
+    const testCwd = '/test';
     (0, vitest_1.beforeEach)(() => {
         vitest_1.vi.clearAllMocks();
-        mockPath.join.mockReturnValue(testEnvPath);
-        vitest_1.vi.spyOn(process, "cwd").mockReturnValue(testCwd);
+        mockPath.join.mockReturnValue(testEnvironmentPath);
+        vitest_1.vi.spyOn(process, 'cwd').mockReturnValue(testCwd);
     });
     (0, vitest_1.afterEach)(() => {
         vitest_1.vi.restoreAllMocks();
     });
-    (0, vitest_1.describe)("updateEnvFile", () => {
-        (0, vitest_1.it)("should create a new .env file with the key when file does not exist", () => __awaiter(void 0, void 0, void 0, function* () {
+    (0, vitest_1.describe)('updateEnvFile', () => {
+        (0, vitest_1.it)('should create a new .env file with the key when file does not exist', async () => {
             mockFs.existsSync.mockReturnValue(false);
-            yield (0, env_manager_1.updateEnvFile)({
-                key: "TEST_KEY",
-                value: "test_value",
-                comment: "Test comment",
+            await (0, env_manager_1.updateEnvFile)({
+                comment: 'Test comment',
+                key: 'TEST_KEY',
+                value: 'test_value',
             });
-            (0, vitest_1.expect)(mockFs.existsSync).toHaveBeenCalledWith(testEnvPath);
-            (0, vitest_1.expect)(mockWriteFile).toHaveBeenCalledWith(testEnvPath, "# Test comment\nTEST_KEY=test_value\n");
-        }));
-        (0, vitest_1.it)("should append to existing .env file when key does not exist", () => __awaiter(void 0, void 0, void 0, function* () {
-            const existingContent = "EXISTING_KEY=existing_value\n";
+            (0, vitest_1.expect)(mockFs.existsSync).toHaveBeenCalledWith(testEnvironmentPath);
+            (0, vitest_1.expect)(mockWriteFile).toHaveBeenCalledWith(testEnvironmentPath, '# Test comment\nTEST_KEY=test_value\n');
+        });
+        (0, vitest_1.it)('should append to existing .env file when key does not exist', async () => {
+            const existingContent = 'EXISTING_KEY=existing_value\n';
             mockFs.existsSync.mockReturnValue(true);
             mockFs.readFileSync.mockReturnValue(existingContent);
-            yield (0, env_manager_1.updateEnvFile)({
-                key: "NEW_KEY",
-                value: "new_value",
-                comment: "Test comment",
+            await (0, env_manager_1.updateEnvFile)({
+                comment: 'Test comment',
+                key: 'NEW_KEY',
+                value: 'new_value',
             });
-            (0, vitest_1.expect)(mockWriteFile).toHaveBeenCalledWith(testEnvPath, "EXISTING_KEY=existing_value\nNEW_KEY=new_value\n");
-        }));
-        (0, vitest_1.it)("should not update when key already exists and force is false", () => __awaiter(void 0, void 0, void 0, function* () {
-            const existingContent = "EXISTING_KEY=existing_value\nTEST_KEY=old_value\n";
+            (0, vitest_1.expect)(mockWriteFile).toHaveBeenCalledWith(testEnvironmentPath, 'EXISTING_KEY=existing_value\nNEW_KEY=new_value\n');
+        });
+        (0, vitest_1.it)('should not update when key already exists and force is false', async () => {
+            const existingContent = 'EXISTING_KEY=existing_value\nTEST_KEY=old_value\n';
             mockFs.existsSync.mockReturnValue(true);
             mockFs.readFileSync.mockReturnValue(existingContent);
-            const consoleSpy = vitest_1.vi.spyOn(console, "log").mockImplementation(() => { });
-            yield (0, env_manager_1.updateEnvFile)({
-                key: "TEST_KEY",
-                value: "new_value",
+            const consoleSpy = vitest_1.vi.spyOn(console, 'log').mockImplementation(() => { });
+            await (0, env_manager_1.updateEnvFile)({
+                key: 'TEST_KEY',
+                value: 'new_value',
             });
-            (0, vitest_1.expect)(consoleSpy).toHaveBeenCalledWith(vitest_1.expect.stringContaining("TEST_KEY already exists in .env - leaving unchanged"));
+            (0, vitest_1.expect)(consoleSpy).toHaveBeenCalledWith(vitest_1.expect.stringContaining('TEST_KEY already exists in .env - leaving unchanged'));
             (0, vitest_1.expect)(mockWriteFile).not.toHaveBeenCalled();
             consoleSpy.mockRestore();
-        }));
-        (0, vitest_1.it)("should update existing key when force is true", () => __awaiter(void 0, void 0, void 0, function* () {
-            const existingContent = "EXISTING_KEY=existing_value\nTEST_KEY=old_value\n";
+        });
+        (0, vitest_1.it)('should update existing key when force is true', async () => {
+            const existingContent = 'EXISTING_KEY=existing_value\nTEST_KEY=old_value\n';
             mockFs.existsSync.mockReturnValue(true);
             mockFs.readFileSync.mockReturnValue(existingContent);
-            yield (0, env_manager_1.updateEnvFile)({
-                key: "TEST_KEY",
-                value: "new_value",
+            await (0, env_manager_1.updateEnvFile)({
                 force: true,
+                key: 'TEST_KEY',
+                value: 'new_value',
             });
-            (0, vitest_1.expect)(mockWriteFile).toHaveBeenCalledWith(testEnvPath, "EXISTING_KEY=existing_value\nTEST_KEY=new_value\n");
-        }));
-        (0, vitest_1.it)("should handle complex values with quotes and special characters", () => __awaiter(void 0, void 0, void 0, function* () {
+            (0, vitest_1.expect)(mockWriteFile).toHaveBeenCalledWith(testEnvironmentPath, 'EXISTING_KEY=existing_value\nTEST_KEY=new_value\n');
+        });
+        (0, vitest_1.it)('should handle complex values with quotes and special characters', async () => {
             mockFs.existsSync.mockReturnValue(false);
-            yield (0, env_manager_1.updateEnvFile)({
-                key: "COMPLEX_KEY",
+            await (0, env_manager_1.updateEnvFile)({
+                comment: 'Complex test',
+                key: 'COMPLEX_KEY',
                 value: 'value with "quotes" and $special',
-                comment: "Complex test",
             });
-            (0, vitest_1.expect)(mockWriteFile).toHaveBeenCalledWith(testEnvPath, '# Complex test\nCOMPLEX_KEY=value with "quotes" and $special\n');
-        }));
-        (0, vitest_1.it)("should use custom env path when provided", () => __awaiter(void 0, void 0, void 0, function* () {
-            const customPath = "/custom/.env";
+            (0, vitest_1.expect)(mockWriteFile).toHaveBeenCalledWith(testEnvironmentPath, '# Complex test\nCOMPLEX_KEY=value with "quotes" and $special\n');
+        });
+        (0, vitest_1.it)('should use custom env path when provided', async () => {
+            const customPath = '/custom/.env';
             mockFs.existsSync.mockReturnValue(false);
-            yield (0, env_manager_1.updateEnvFile)({
+            await (0, env_manager_1.updateEnvFile)({
                 envPath: customPath,
-                key: "TEST_KEY",
-                value: "test_value",
+                key: 'TEST_KEY',
+                value: 'test_value',
             });
             (0, vitest_1.expect)(mockFs.existsSync).toHaveBeenCalledWith(customPath);
-            (0, vitest_1.expect)(mockWriteFile).toHaveBeenCalledWith(customPath, "TEST_KEY=test_value\n");
-        }));
-        (0, vitest_1.it)("should throw error when write fails", () => __awaiter(void 0, void 0, void 0, function* () {
+            (0, vitest_1.expect)(mockWriteFile).toHaveBeenCalledWith(customPath, 'TEST_KEY=test_value\n');
+        });
+        (0, vitest_1.it)('should throw error when write fails', async () => {
             mockFs.existsSync.mockReturnValue(false);
-            mockWriteFile.mockRejectedValue(new Error("Write error"));
-            yield (0, vitest_1.expect)((0, env_manager_1.updateEnvFile)({
-                key: "TEST_KEY",
-                value: "test_value",
-            })).rejects.toThrow("Write error");
-        }));
+            mockWriteFile.mockRejectedValue(new Error('Write error'));
+            await (0, vitest_1.expect)((0, env_manager_1.updateEnvFile)({
+                key: 'TEST_KEY',
+                value: 'test_value',
+            })).rejects.toThrow('Write error');
+        });
     });
-    (0, vitest_1.describe)("hasEnvKey", () => {
-        (0, vitest_1.it)("should return false when .env file does not exist", () => {
+    (0, vitest_1.describe)('hasEnvKey', () => {
+        (0, vitest_1.it)('should return false when .env file does not exist', () => {
             mockFs.existsSync.mockReturnValue(false);
-            const result = (0, env_manager_1.hasEnvKey)(testEnvPath, "TEST_KEY");
+            const result = (0, env_manager_1.hasEnvKey)(testEnvironmentPath, 'TEST_KEY');
             (0, vitest_1.expect)(result).toBe(false);
-            (0, vitest_1.expect)(mockFs.existsSync).toHaveBeenCalledWith(testEnvPath);
+            (0, vitest_1.expect)(mockFs.existsSync).toHaveBeenCalledWith(testEnvironmentPath);
             (0, vitest_1.expect)(mockFs.readFileSync).not.toHaveBeenCalled();
         });
-        (0, vitest_1.it)("should return true when key exists in .env file", () => {
-            const existingContent = "KEY1=value1\nTEST_KEY=test_value\nKEY2=value2\n";
+        (0, vitest_1.it)('should return true when key exists in .env file', () => {
+            const existingContent = 'KEY1=value1\nTEST_KEY=test_value\nKEY2=value2\n';
             mockFs.existsSync.mockReturnValue(true);
             mockFs.readFileSync.mockReturnValue(existingContent);
-            const result = (0, env_manager_1.hasEnvKey)(testEnvPath, "TEST_KEY");
+            const result = (0, env_manager_1.hasEnvKey)(testEnvironmentPath, 'TEST_KEY');
             (0, vitest_1.expect)(result).toBe(true);
         });
-        (0, vitest_1.it)("should return false when key does not exist in .env file", () => {
-            const existingContent = "KEY1=value1\nKEY2=value2\n";
+        (0, vitest_1.it)('should return false when key does not exist in .env file', () => {
+            const existingContent = 'KEY1=value1\nKEY2=value2\n';
             mockFs.existsSync.mockReturnValue(true);
             mockFs.readFileSync.mockReturnValue(existingContent);
-            const result = (0, env_manager_1.hasEnvKey)(testEnvPath, "TEST_KEY");
+            const result = (0, env_manager_1.hasEnvKey)(testEnvironmentPath, 'TEST_KEY');
             (0, vitest_1.expect)(result).toBe(false);
         });
-        (0, vitest_1.it)("should return false when .env file is malformed", () => {
+        (0, vitest_1.it)('should return false when .env file is malformed', () => {
             mockFs.existsSync.mockReturnValue(true);
             mockFs.readFileSync.mockImplementation(() => {
-                throw new Error("Read error");
+                throw new Error('Read error');
             });
-            const result = (0, env_manager_1.hasEnvKey)(testEnvPath, "TEST_KEY");
+            const result = (0, env_manager_1.hasEnvKey)(testEnvironmentPath, 'TEST_KEY');
             (0, vitest_1.expect)(result).toBe(false);
         });
-        (0, vitest_1.it)("should use default path when not provided", () => {
+        (0, vitest_1.it)('should use default path when not provided', () => {
             mockFs.existsSync.mockReturnValue(false);
-            (0, env_manager_1.hasEnvKey)(undefined, "TEST_KEY");
-            (0, vitest_1.expect)(mockFs.existsSync).toHaveBeenCalledWith(testEnvPath);
+            (0, env_manager_1.hasEnvKey)(undefined, 'TEST_KEY');
+            (0, vitest_1.expect)(mockFs.existsSync).toHaveBeenCalledWith(testEnvironmentPath);
         });
     });
 });