berget 2.2.6 → 2.2.8

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

@@ -1,199 +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';
 
-const mockFs = vi.mocked(fs)
-const mockWriteFile = vi.mocked(writeFile)
-const mockPath = vi.mocked(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);
 
 describe('env-manager', () => {
-  const testEnvPath = '/test/.env'
-  const testCwd = '/test'
+  const testEnvironmentPath = '/test/.env';
+  const testCwd = '/test';
 
   beforeEach(() => {
-    vi.clearAllMocks()
-    mockPath.join.mockReturnValue(testEnvPath)
-    vi.spyOn(process, 'cwd').mockReturnValue(testCwd)
-  })
+    vi.clearAllMocks();
+    mockPath.join.mockReturnValue(testEnvironmentPath);
+    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)
+      mockFs.existsSync.mockReturnValue(false);
 
-      await updateEnvFile({
+      await updateEnvironmentFile({
+        comment: 'Test comment',
         key: 'TEST_KEY',
         value: 'test_value',
-        comment: 'Test comment',
-      })
+      });
 
-      expect(mockFs.existsSync).toHaveBeenCalledWith(testEnvPath)
+      expect(mockFs.existsSync).toHaveBeenCalledWith(testEnvironmentPath);
       expect(mockWriteFile).toHaveBeenCalledWith(
-        testEnvPath,
+        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'
-      mockFs.existsSync.mockReturnValue(true)
-      mockFs.readFileSync.mockReturnValue(existingContent)
+      const existingContent = 'EXISTING_KEY=existing_value\n';
+      mockFs.existsSync.mockReturnValue(true);
+      mockFs.readFileSync.mockReturnValue(existingContent);
 
-      await updateEnvFile({
+      await updateEnvironmentFile({
+        comment: 'Test comment',
         key: 'NEW_KEY',
         value: 'new_value',
-        comment: 'Test comment',
-      })
+      });
 
       expect(mockWriteFile).toHaveBeenCalledWith(
-        testEnvPath,
+        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'
-      mockFs.existsSync.mockReturnValue(true)
-      mockFs.readFileSync.mockReturnValue(existingContent)
+      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({
+      await updateEnvironmentFile({
         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)
+      const existingContent = 'EXISTING_KEY=existing_value\nTEST_KEY=old_value\n';
+      mockFs.existsSync.mockReturnValue(true);
+      mockFs.readFileSync.mockReturnValue(existingContent);
 
-      await updateEnvFile({
+      await updateEnvironmentFile({
+        force: true,
         key: 'TEST_KEY',
         value: 'new_value',
-        force: true,
-      })
+      });
 
       expect(mockWriteFile).toHaveBeenCalledWith(
-        testEnvPath,
+        testEnvironmentPath,
         'EXISTING_KEY=existing_value\nTEST_KEY=new_value\n',
-      )
-    })
+      );
+    });
 
     it('should handle complex values with quotes and special characters', async () => {
-      mockFs.existsSync.mockReturnValue(false)
+      mockFs.existsSync.mockReturnValue(false);
 
-      await updateEnvFile({
+      await updateEnvironmentFile({
+        comment: 'Complex test',
         key: 'COMPLEX_KEY',
         value: 'value with "quotes" and $special',
-        comment: 'Complex test',
-      })
+      });
 
       expect(mockWriteFile).toHaveBeenCalledWith(
-        testEnvPath,
+        testEnvironmentPath,
         '# 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)
+      const customPath = '/custom/.env';
+      mockFs.existsSync.mockReturnValue(false);
 
-      await updateEnvFile({
+      await updateEnvironmentFile({
         envPath: customPath,
         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'))
+      mockFs.existsSync.mockReturnValue(false);
+      mockWriteFile.mockRejectedValue(new Error('Write error'));
 
       await expect(
-        updateEnvFile({
+        updateEnvironmentFile({
           key: 'TEST_KEY',
           value: 'test_value',
         }),
-      ).rejects.toThrow('Write error')
-    })
-  })
+      ).rejects.toThrow('Write error');
+    });
+  });
 
   describe('hasEnvKey', () => {
     it('should return false when .env file does not exist', () => {
-      mockFs.existsSync.mockReturnValue(false)
+      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.readFileSync).not.toHaveBeenCalled()
-    })
+      expect(result).toBe(false);
+      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'
-      mockFs.existsSync.mockReturnValue(true)
-      mockFs.readFileSync.mockReturnValue(existingContent)
+      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)
-    })
+      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)
+      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)
-    })
+      expect(result).toBe(false);
+    });
 
     it('should return false when .env file is malformed', () => {
-      mockFs.existsSync.mockReturnValue(true)
+      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)
-    })
+      expect(result).toBe(false);
+    });
 
     it('should use default path when not provided', () => {
-      mockFs.existsSync.mockReturnValue(false)
+      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,119 +1,115 @@
-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';
+
+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',
       agent: {
         test: {
           model: 'gpt-4',
-          temperature: 0.7,
-          prompt: 'Test agent',
           permission: {
-            edit: 'allow',
             bash: 'allow',
+            edit: 'allow',
             webfetch: 'allow',
           },
+          prompt: 'Test agent',
+          temperature: 0.7,
         },
       },
-    }
+      model: 'gpt-4',
+      username: 'test-user',
+    };
 
-    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', () => {
     const invalidConfig = {
-      username: 123, // Should be string
-      model: 'gpt-4',
       agent: {
         test: {
           model: 'gpt-4',
-          temperature: 'high', // Should be number
-          prompt: 'Test agent',
           permission: {
-            edit: 'invalid', // Should be enum value
             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)
-    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', () => {
     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
               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)
+    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
+    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:');
+      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. */
@@ -91,8 +92,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',
+    globals: true,
   },
-})
+});