berget 2.2.6 → 2.2.7

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

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

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

@@ -1,63 +1,60 @@
-import { describe, it, expect } from 'vitest'
-import {
-  validateOpenCodeConfig,
-  fixOpenCodeConfig,
-} from '../../src/utils/opencode-validator'
-import { readFileSync } from 'fs'
+import { describe, it, expect } from "vitest";
+import { validateOpenCodeConfig, fixOpenCodeConfig } from "../../src/utils/opencode-validator";
+import { readFileSync } from "fs";
 
-describe('OpenCode Validator', () => {
-  it('should validate a correct OpenCode configuration', () => {
+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",
+      username: "test-user",
+      model: "gpt-4",
       agent: {
         test: {
-          model: 'gpt-4',
+          model: "gpt-4",
           temperature: 0.7,
-          prompt: 'Test agent',
+          prompt: "Test agent",
           permission: {
-            edit: 'allow',
-            bash: 'allow',
-            webfetch: 'allow',
+            edit: "allow",
+            bash: "allow",
+            webfetch: "allow",
           },
         },
       },
-    }
+    };
 
-    const result = validateOpenCodeConfig(validConfig)
-    expect(result.valid).toBe(true)
-    expect(result.errors).toBeUndefined()
-  })
+    const result = validateOpenCodeConfig(validConfig);
+    expect(result.valid).toBe(true);
+    expect(result.errors).toBeUndefined();
+  });
 
-  it('should reject invalid configuration', () => {
+  it("should reject invalid configuration", () => {
     const invalidConfig = {
       username: 123, // Should be string
-      model: 'gpt-4',
+      model: "gpt-4",
       agent: {
         test: {
-          model: 'gpt-4',
-          temperature: 'high', // Should be number
-          prompt: 'Test agent',
+          model: "gpt-4",
+          temperature: "high", // Should be number
+          prompt: "Test agent",
           permission: {
-            edit: 'invalid', // Should be enum value
-            bash: 'allow',
-            webfetch: 'allow',
+            edit: "invalid", // Should be enum value
+            bash: "allow",
+            webfetch: "allow",
           },
         },
       },
-    }
+    };
 
-    const result = validateOpenCodeConfig(invalidConfig)
-    expect(result.valid).toBe(false)
-    expect(result.errors).toBeDefined()
-    expect(result.errors!.length).toBeGreaterThan(0)
-  })
+    const result = validateOpenCodeConfig(invalidConfig);
+    expect(result.valid).toBe(false);
+    expect(result.errors).toBeDefined();
+    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',
+      username: "test-user",
+      model: "gpt-4",
       tools: {
         compact: { threshold: 80000 }, // Should be boolean
       },
@@ -65,55 +62,53 @@ describe('OpenCode Validator', () => {
       provider: {
         berget: {
           models: {
-            'test-model': {
-              name: 'Test Model',
+            "test-model": {
+              name: "Test Model",
               maxTokens: 4000, // Should be moved to limit.context
               contextWindow: 8000, // Should be moved to limit.context
             },
           },
         },
       },
-    }
+    };
 
-    const fixed = fixOpenCodeConfig(configWithIssues)
+    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()
+    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', () => {
-    let currentConfig
+  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)
-      return
+      console.log("Skipping: opencode.json not found:", error);
+      return;
     }
 
     // Apply fixes to handle common issues
-    const fixedConfig = fixOpenCodeConfig(currentConfig)
+    const fixedConfig = fixOpenCodeConfig(currentConfig);
 
     // Validate the fixed config
-    const result = validateOpenCodeConfig(fixedConfig)
+    const result = validateOpenCodeConfig(fixedConfig);
 
     // The fixed config should be valid according to the JSON Schema
-    expect(result.valid).toBe(true)
+    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:");
+      result.errors?.forEach(err => console.log(`  - ${err}`));
     }
-  })
-})
+  });
+});

package/tsconfig.json

@@ -91,8 +91,8 @@
     // "noImplicitThis": true,                           /* Enable error reporting when 'this' is given the type 'any'. */
     // "useUnknownInCatchVariables": true,               /* Default catch clause variables as 'unknown' instead of 'any'. */
     // "alwaysStrict": true,                             /* Ensure 'use strict' is always emitted. */
-    // "noUnusedLocals": true,                           /* Enable error reporting when local variables aren't read. */
-    // "noUnusedParameters": true,                       /* Raise an error when a function parameter isn't read. */
+    "noUnusedLocals": true /* Enable error reporting when local variables aren't read. */,
+    "noUnusedParameters": true /* Raise an error when a function parameter isn't read. */,
     // "exactOptionalPropertyTypes": true,               /* Interpret optional property types as written, rather than adding 'undefined'. */
     // "noImplicitReturns": true,                        /* Enable error reporting for codepaths that do not explicitly return in a function. */
     // "noFallthroughCasesInSwitch": true,               /* Enable error reporting for fallthrough cases in switch statements. */

package/vitest.config.ts

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