berget 2.0.6 → 2.1.1

package/tests/utils/config-loader.test.ts

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

package/blog-post.md

@@ -1,176 +0,0 @@
-# OpenCode + Berget AI: Den ultimata AI-kodassistensen för svenska företag
-
-I en värld där AI-drivna kodassistenter blir standard, står svenska företag inför ett kritiskt val: hur man balanserar produktivitetsvinster med data-suveränitet och efterlevnad. Med integrationen mellan OpenCode och Berget AI får du nu det bästa av två världar – en kraftfull, open source AI-kodassistent med svensk datainfrastruktur.
-
-## Vad är OpenCode?
-
-OpenCode är en open source AI-kodassistent byggd för terminalen. Till skillnad från många kommersiella alternativ ger OpenCode dig full kontroll över din kod och dina data. Med över 26 000 GitHub-stjärnor och 200 000+ aktiva utvecklare varje månad har det blivit ett av de mest populära verktygen för AI-assisterad programmering.
-
-**Nödvändiga funktioner i OpenCode:**
-
-- 🎯 **Native TUI** – Responsivt terminalgränssnitt som fungerar i din befintliga workflow
-- 🔄 **Multi-session** – Köra flera agenter parallellt på samma projekt
-- 🔗 **Share links** – Dela sessioner för kodgranskning och felsökning
-- 🤖 **Any model** – Stöd för 75+ LLM-providers via Models.dev
-- 🛠️ **LSP enabled** – Automatisk laddning av rätt Language Servers för LLM:en
-
-## Berget AI: Svensk datainfrastruktur
-
-Berget AI är en svensk AI-infrastrukturleverantör som säkerställer att din data aldrig lämnar Sverige. Detta är särskilt viktigt för företag som hanterar känslig information, personuppgifter eller skyddad kod.
-
-**Fördelar med Berget AI:**
-
-- 🇸🇪 **Data-suveränitet** – All data bearbetas inom Sverige
-- ⚖️ **GDPR-kompatibilitet** – Full efterlevnad med EU:s dataskyddslagar
-- 🔒 **Säkerhet** – Industriell säkerhet med kryptering och isolering
-- 🏛️ **Reglering** – Enklare efterlevnad av svenska och EU-regleringar
-- 🚀 **Prestanda** – Låg latens med svensk infrastruktur
-
-## Varför kombinationen är oslagbar
-
-### 1. Data som aldrig lämnar Sverige
-
-När du använder OpenCode med Berget AI förblir all din kod – inklusive API-nycklar, konfigurationer och känslig affärslogik – inom Sveriges gränser. Detta eliminerar risken för dataexponering som kan uppstå med internationella molntjänster.
-
-```bash
-# Initiera ditt projekt med AI-assistent
-berget code init
-
-# Din kod och data förblir alltid i Sverige ✅
-```
-
-### 2. Förenklad reglering och efterlevnad
-
-För svenska företag, särskilt inom finans, vård och offentlig sektor, är efterlevnad avgörande. Med Berget AI får du:
-
-- **GDPR-säker hantering** av personuppgifter i koden
-- **Klassificerad information** hanteras säkert
-- **Revisionsbara spår** av all AI-interaktion
-- **Lokal lagring** av konfigurationer och API-nycklar
-
-### 3. Säker hantering av känslig kod
-
-Många företag arbetar med kod som innehåller:
-
-- API-nycklar och hemligheter
-- Affärskritisk algoritmlogik
-- Känslig kunddata
-- Proprietära systemintegrationer
-
-Med OpenCode + Berget AI kan du använda AI-assistens för:
-
-```bash
-# Refaktorera känslig kod utan att lämna Sverige
-berget code run "Refaktorera denna autentiseringsmodul"
-
-# Få hjälp med API-integrationer säkert
-berget code run "Optimera denna databasanslutning"
-```
-
-### 4. Projektspecifika API-nycklar
-
-Varje projekt får sin egen unika API-nyckel som skapas automatiskt:
-
-```json
-{
-  "model": "berget/deepseek-r1",
-  "apiKey": "projekt-specifik-nyckel",
-  "projectName": "mitt-svenska-projekt",
-  "provider": "berget",
-  "created": "2025-01-01T00:00:00.000Z",
-  "version": "1.0.0"
-}
-```
-
-Detta ger:
-
-- 🔐 **Isolering** mellan projekt
-- 📊 **Spårbarhet** av användning
-- 🔄 **Enkel rotation** av nycklar
-- 🎯 **Granulär kontroll** av åtkomst
-
-## Kom igång på 2 minuter
-
-### Steg 1: Installera OpenCode
-
-```bash
-curl -fsSL https://opencode.ai/install | bash
-```
-
-### Steg 2: Initiera ditt projekt
-
-```bash
-cd ditt-projekt
-berget code init
-```
-
-### Steg 3: Starta AI-assistenen
-
-```bash
-berget code run
-```
-
-Det var allt! Du har nu en fullfjädrad AI-kodassistent med svensk datainfrastruktur.
-
-## Användningsfall för svenska företag
-
-### Finans & Försäkring
-
-- Refaktorera transaktionslogik med full säkerhet
-- Hjälp med compliance-kod (KYC, AML)
-- Optimera riskberäkningsalgoritmer
-
-### Vård & Hälsa
-
-- Utveckla patientdata-system med GDPR-säkerhet
-- Hjälp med medicinsk kod och integrationer
-- Säker hantering av journalsystem
-
-### Offentlig Sektor
-
-- Utveckla e-tjänster med svensk data
-- Hjälp med myndighetsintegrationer
-- Säker hantering av medborgardata
-
-### Industri & Tillverkning
-
-- Optimera PLC-kod och styrsystem
-- Hjälp med IoT-integrationer
-- Säker utveckling av produktionssystem
-
-## Teknisk integration
-
-OpenCode + Berget AI använder den kraftfulla **GLM-4.6** modellen (för närvarande deepseek-r1) som är optimerad för kodning:
-
-```bash
-# Se vilka modeller som finns tillgängliga
-berget models list
-
-# Använd specifik modell
-berget code run --model berget/glm-4-6 "Hjälp mig optimera denna funktion"
-```
-
-## Framtiden för svensk AI-utveckling
-
-Kombinationen av OpenCode och Berget AI representerar nästa generations AI-utveckling för svenska företag:
-
-1. **Produktivitet** – AI-assisterad kodning utan kompromisser
-2. **Säkerhet** – Full kontroll över din data och kod
-3. **Efterlevnad** – Inbyggt stöd för svenska och EU-regleringar
-4. **Flexibilitet** – Open source med frihet att välja modeller och verktyg
-5. **Skalbarhet** – Från små projekt till enterprise-nivå
-
-## Sammanfattning
-
-OpenCode + Berget AI är inte bara ett verktyg – det är en strategisk lösning för svenska företag som vill leda inom AI-driven utveckling utan att kompromissa med säkerhet och efterlevnad.
-
-Med svensk datainfrastruktur, projektspecifika API-nycklar och en open source AI-assistent får du det bästa av två världar: global AI-kompetens med lokal dataskydd.
-
-**Redo att transformera din kodning med svensk AI?**
-
-```bash
-# Börja idag
-berget code init
-```
-
-_Din kod, din data, ditt land – nu med AI-superkrafter._