berget 2.2.7 → 2.2.9

package/tests/utils/env-manager.test.ts

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

package/tests/utils/opencode-validator.test.ts

@@ -1,25 +1,26 @@
-import { describe, it, expect } from "vitest";
-import { validateOpenCodeConfig, fixOpenCodeConfig } from "../../src/utils/opencode-validator";
-import { readFileSync } from "fs";
+import { readFileSync } from 'node:fs';
+import { describe, expect, it } from 'vitest';
 
-describe("OpenCode Validator", () => {
-  it("should validate a correct OpenCode configuration", () => {
+import { fixOpenCodeConfig, validateOpenCodeConfig } from '../../src/utils/opencode-validator';
+
+describe('OpenCode Validator', () => {
+  it('should validate a correct OpenCode configuration', () => {
     const validConfig = {
-      $schema: "https://opencode.ai/config.json",
-      username: "test-user",
-      model: "gpt-4",
+      $schema: 'https://opencode.ai/config.json',
       agent: {
         test: {
-          model: "gpt-4",
-          temperature: 0.7,
-          prompt: "Test agent",
+          model: 'gpt-4',
           permission: {
-            edit: "allow",
-            bash: "allow",
-            webfetch: "allow",
+            bash: 'allow',
+            edit: 'allow',
+            webfetch: 'allow',
           },
+          prompt: 'Test agent',
+          temperature: 0.7,
         },
       },
+      model: 'gpt-4',
+      username: 'test-user',
     };
 
     const result = validateOpenCodeConfig(validConfig);
@@ -27,22 +28,22 @@ describe("OpenCode Validator", () => {
     expect(result.errors).toBeUndefined();
   });
 
-  it("should reject invalid configuration", () => {
+  it('should reject invalid configuration', () => {
     const invalidConfig = {
-      username: 123, // Should be string
-      model: "gpt-4",
       agent: {
         test: {
-          model: "gpt-4",
-          temperature: "high", // Should be number
-          prompt: "Test agent",
+          model: 'gpt-4',
           permission: {
-            edit: "invalid", // Should be enum value
-            bash: "allow",
-            webfetch: "allow",
+            bash: 'allow',
+            edit: 'invalid', // Should be enum value
+            webfetch: 'allow',
           },
+          prompt: 'Test agent',
+          temperature: 'high', // Should be number
         },
       },
+      model: 'gpt-4',
+      username: 123, // Should be string
     };
 
     const result = validateOpenCodeConfig(invalidConfig);
@@ -51,49 +52,49 @@ describe("OpenCode Validator", () => {
     expect(result.errors!.length).toBeGreaterThan(0);
   });
 
-  it("should fix common configuration issues", () => {
+  it('should fix common configuration issues', () => {
     const configWithIssues = {
-      username: "test-user",
-      model: "gpt-4",
-      tools: {
-        compact: { threshold: 80000 }, // Should be boolean
-      },
       maxTokens: 4000, // Invalid property
+      model: 'gpt-4',
       provider: {
         berget: {
           models: {
-            "test-model": {
-              name: "Test Model",
-              maxTokens: 4000, // Should be moved to limit.context
+            'test-model': {
               contextWindow: 8000, // Should be moved to limit.context
+              maxTokens: 4000, // Should be moved to limit.context
+              name: 'Test Model',
             },
           },
         },
       },
+      tools: {
+        compact: { threshold: 80_000 }, // Should be boolean
+      },
+      username: 'test-user',
     };
 
     const fixed = fixOpenCodeConfig(configWithIssues);
 
     // tools.compact should be boolean
-    expect(typeof fixed.tools.compact).toBe("boolean");
+    expect(typeof fixed.tools.compact).toBe('boolean');
 
     // maxTokens should be removed
     expect(fixed.maxTokens).toBeUndefined();
 
     // maxTokens and contextWindow should be moved to limit.context
-    expect(fixed.provider.berget.models["test-model"].limit).toBeDefined();
-    expect(fixed.provider.berget.models["test-model"].limit.context).toBe(8000);
-    expect(fixed.provider.berget.models["test-model"].maxTokens).toBeUndefined();
-    expect(fixed.provider.berget.models["test-model"].contextWindow).toBeUndefined();
+    expect(fixed.provider.berget.models['test-model'].limit).toBeDefined();
+    expect(fixed.provider.berget.models['test-model'].limit.context).toBe(8000);
+    expect(fixed.provider.berget.models['test-model'].maxTokens).toBeUndefined();
+    expect(fixed.provider.berget.models['test-model'].contextWindow).toBeUndefined();
   });
 
-  it("should validate the current opencode.json file", () => {
+  it('should validate the current opencode.json file', () => {
     let currentConfig;
     try {
-      currentConfig = JSON.parse(readFileSync("opencode.json", "utf8"));
+      currentConfig = JSON.parse(readFileSync('opencode.json', 'utf8'));
     } catch (error) {
       // Skip when opencode.json is not present (e.g. in CI or clean checkouts)
-      console.log("Skipping: opencode.json not found:", error);
+      console.log('Skipping: opencode.json not found:', error);
       return;
     }
 
@@ -107,8 +108,8 @@ describe("OpenCode Validator", () => {
     expect(result.valid).toBe(true);
 
     if (!result.valid) {
-      console.log("Fixed opencode.json validation errors:");
-      result.errors?.forEach(err => console.log(`  - ${err}`));
+      console.log('Fixed opencode.json validation errors:');
+      if (result.errors) for (const error of result.errors) console.log(`  - ${error}`);
     }
   });
 });

package/tsconfig.json

@@ -11,7 +11,8 @@
     // "disableReferencedProjectLoad": true,             /* Reduce the number of projects loaded automatically by TypeScript. */
 
     /* Language and Environment */
-    "target": "es2016" /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */,
+    "target": "ES2022",
+    "lib": ["ES2022"],
     // "lib": [],                                        /* Specify a set of bundled library declaration files that describe the target runtime environment. */
     // "jsx": "preserve",                                /* Specify what JSX code is generated. */
     // "experimentalDecorators": true,                   /* Enable experimental support for legacy experimental decorators. */

package/vitest.config.ts

@@ -1,8 +1,8 @@
-import { defineConfig } from "vitest/config";
+import { defineConfig } from 'vitest/config';
 
 export default defineConfig({
   test: {
+    environment: 'node',
     globals: true,
-    environment: "node",
   },
 });