berget 1.3.1 → 2.0.0

package/blog-post.md

@@ -0,0 +1,176 @@
+# 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._

package/dist/index.js

@@ -19,7 +19,8 @@ commander_1.program
 | |_/ /  __/ | | (_| |  __/ |_  | | | |_| |_ 
 \\____/ \\___|_|  \\__, |\\___|\\_\\_ \\_| |_/\\___/ 
                  __/ |                      
-                |___/   AI on European terms`)
+                |___/   AI on European terms
+Version: ${package_json_1.version}`)
     .version(package_json_1.version, '-v, --version')
     .option('--local', 'Use local API endpoint (hidden)', false)
     .option('--debug', 'Enable debug output', false);
@@ -34,19 +35,21 @@ if (process.argv.length <= 2) {
     console.log(chalk_1.default.blue(`  ${chalk_1.default.bold('berget auth login')}      - Log in to Berget`));
     console.log(chalk_1.default.blue(`  ${chalk_1.default.bold('berget models list')}     - List available AI models`));
     console.log(chalk_1.default.blue(`  ${chalk_1.default.bold('berget chat run')}        - Start a chat session`));
+    console.log(chalk_1.default.blue(`  ${chalk_1.default.bold('berget code init')}       - Initialize AI coding assistant`));
     console.log(chalk_1.default.blue(`  ${chalk_1.default.bold('berget api-keys list')}   - List your API keys`));
     console.log(chalk_1.default.blue(`\nRun ${chalk_1.default.bold('berget --help')} for a complete list of commands.`));
 }
 // Add helpful suggestions for common command mistakes
 const commonMistakes = {
-    'login': 'auth login',
-    'logout': 'auth logout',
-    'whoami': 'auth whoami',
+    login: 'auth login',
+    logout: 'auth logout',
+    whoami: 'auth whoami',
     'list-models': 'models list',
     'list-keys': 'api-keys list',
     'create-key': 'api-keys create',
     'list-clusters': 'clusters list',
-    'usage': 'billing usage'
+    usage: 'billing usage',
+    init: 'code init',
 };
 // Add error handler for unknown commands
 commander_1.program.on('command:*', (operands) => {
@@ -58,11 +61,11 @@ commander_1.program.on('command:*', (operands) => {
     }
     else {
         // Try to find similar commands
-        const availableCommands = commander_1.program.commands.map(cmd => cmd.name());
-        const similarCommands = availableCommands.filter(cmd => cmd.includes(unknownCommand) || unknownCommand.includes(cmd));
+        const availableCommands = commander_1.program.commands.map((cmd) => cmd.name());
+        const similarCommands = availableCommands.filter((cmd) => cmd.includes(unknownCommand) || unknownCommand.includes(cmd));
         if (similarCommands.length > 0) {
             console.log(chalk_1.default.yellow('Similar commands:'));
-            similarCommands.forEach(cmd => {
+            similarCommands.forEach((cmd) => {
                 console.log(chalk_1.default.yellow(`  ${chalk_1.default.bold(`berget ${cmd}`)}`));
             });
         }

package/dist/package.json

@@ -1,17 +1,22 @@
 {
     "name": "berget",
-    "version": "1.3.1",
+    "version": "2.0.0",
     "main": "dist/index.js",
     "bin": {
         "berget": "dist/index.js"
     },
     "private": false,
+    "publishConfig": {
+        "access": "public"
+    },
     "scripts": {
         "start": "node --import tsx ./index.ts --local",
         "login": "node --import tsx ./index.ts --local auth login",
         "logout": "node --import tsx ./index.ts --local auth logout",
         "whoami": "node --import tsx ./index.ts --local auth whoami",
         "build": "tsc",
+        "test": "vitest",
+        "test:run": "vitest run",
         "prepublishOnly": "npm run build",
         "generate-types": "openapi-typescript https://api.berget.ai/openapi.json -o src/types/api.d.ts"
     },
@@ -19,21 +24,27 @@
     "license": "MIT",
     "description": "This is a cli command for interacting with the AI infrastructure provider Berget",
     "devDependencies": {
+        "@types/dotenv": "^6.1.1",
         "@types/marked": "^5.0.2",
         "@types/marked-terminal": "^6.1.1",
         "@types/node": "^20.11.20",
         "tsx": "^4.19.3",
-        "typescript": "^5.3.3"
+        "typescript": "^5.3.3",
+        "vitest": "^1.0.0"
     },
     "dependencies": {
+        "ajv": "^8.17.1",
+        "ajv-formats": "^3.0.1",
         "chalk": "^4.1.2",
         "commander": "^12.0.0",
+        "dotenv": "^17.2.3",
         "fs-extra": "^11.3.0",
         "marked": "^9.1.6",
         "marked-terminal": "^6.2.0",
         "open": "^9.1.0",
         "openapi-fetch": "^0.9.1",
         "openapi-typescript": "^6.7.4",
-        "readline": "^1.3.0"
+        "readline": "^1.3.0",
+        "zod": "^4.1.12"
     }
 }

package/dist/src/commands/api-keys.js

@@ -46,7 +46,9 @@ function registerApiKeyCommands(program) {
                 chalk_1.default.dim('LAST USED'));
             console.log(chalk_1.default.dim('─'.repeat(85)));
             keys.forEach((key) => {
-                const lastUsed = key.lastUsed ? key.lastUsed.substring(0, 10) : 'Never';
+                const lastUsed = key.lastUsed
+                    ? key.lastUsed.substring(0, 10)
+                    : 'Never';
                 const status = key.active
                     ? chalk_1.default.green('● Active')
                     : chalk_1.default.red('● Inactive');
@@ -227,7 +229,7 @@ function registerApiKeyCommands(program) {
         try {
             const apiKeyService = api_key_service_1.ApiKeyService.getInstance();
             const keys = yield apiKeyService.list();
-            const selectedKey = keys.find(key => key.id.toString() === id);
+            const selectedKey = keys.find((key) => key.id.toString() === id);
             if (!selectedKey) {
                 console.error(chalk_1.default.red(`Error: API key with ID ${id} not found`));
                 return;

package/dist/src/commands/chat.js

@@ -8,6 +8,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -49,14 +56,16 @@ function registerChatCommands(program) {
     chat
         .command(command_structure_1.SUBCOMMANDS.CHAT.RUN)
         .description('Run a chat session with a specified model')
-        .argument('[model]', 'Model to use (default: google/gemma-3-27b-it)')
+        .argument('[model]', 'Model to use (default: openai/gpt-oss)')
+        .argument('[message]', 'Message to send directly (skips interactive mode)')
         .option('-s, --system <message>', 'System message')
         .option('-t, --temperature <temp>', 'Temperature (0-1)', parseFloat)
         .option('-m, --max-tokens <tokens>', 'Maximum tokens to generate', parseInt)
         .option('-k, --api-key <key>', 'API key to use for this chat session')
         .option('--api-key-id <id>', 'ID of the API key to use from your saved keys')
-        .option('--stream', 'Stream the response')
-        .action((options) => __awaiter(this, void 0, void 0, function* () {
+        .option('--no-stream', 'Disable streaming (streaming is enabled by default)')
+        .action((model, message, options) => __awaiter(this, void 0, void 0, function* () {
+        var _a, e_1, _b, _c;
         try {
             const chatService = chat_service_1.ChatService.getInstance();
             // Check if we have an API key or need to get one
@@ -168,11 +177,6 @@ function registerChatCommands(program) {
                     return;
                 }
             }
-            // Set up readline interface for user input
-            const rl = readline_1.default.createInterface({
-                input: process.stdin,
-                output: process.stdout,
-            });
             // Prepare messages array
             const messages = [];
             // Add system message if provided
@@ -182,12 +186,140 @@ function registerChatCommands(program) {
                     content: options.system,
                 });
             }
+            // Check if input is being piped in
+            let inputMessage = message;
+            let stdinContent = '';
+            if (!process.stdin.isTTY) {
+                // Read from stdin (piped input)
+                const chunks = [];
+                try {
+                    for (var _d = true, _e = __asyncValues(process.stdin), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
+                        _c = _f.value;
+                        _d = false;
+                        const chunk = _c;
+                        chunks.push(chunk);
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+                stdinContent = Buffer.concat(chunks).toString('utf8').trim();
+            }
+            // Combine stdin content with message if both exist
+            if (stdinContent && message) {
+                inputMessage = `${stdinContent}\n\n${message}`;
+            }
+            else if (stdinContent && !message) {
+                inputMessage = stdinContent;
+            }
+            // If a message is provided (either as argument, from stdin, or both), send it directly and exit
+            if (inputMessage) {
+                // Add user message
+                messages.push({
+                    role: 'user',
+                    content: inputMessage,
+                });
+                try {
+                    // Call the API
+                    const completionOptions = {
+                        model: model || 'openai/gpt-oss',
+                        messages: messages,
+                        temperature: options.temperature !== undefined ? options.temperature : 0.7,
+                        max_tokens: options.maxTokens || 4096,
+                        stream: options.stream !== false,
+                    };
+                    // Only add apiKey if it actually exists
+                    if (apiKey) {
+                        completionOptions.apiKey = apiKey;
+                    }
+                    // Add streaming support (now default)
+                    if (completionOptions.stream) {
+                        let assistantResponse = '';
+                        // Stream the response in real-time
+                        completionOptions.onChunk = (chunk) => {
+                            if (chunk.choices &&
+                                chunk.choices[0] &&
+                                chunk.choices[0].delta &&
+                                chunk.choices[0].delta.content) {
+                                const content = chunk.choices[0].delta.content;
+                                try {
+                                    process.stdout.write(content);
+                                }
+                                catch (error) {
+                                    // Handle EPIPE errors gracefully (when pipe is closed)
+                                    if (error.code === 'EPIPE') {
+                                        // Stop streaming if the pipe is closed
+                                        return;
+                                    }
+                                    throw error;
+                                }
+                                assistantResponse += content;
+                            }
+                        };
+                        try {
+                            yield chatService.createCompletion(completionOptions);
+                        }
+                        catch (streamError) {
+                            console.error(chalk_1.default.red('\nStreaming error:'), streamError);
+                            // Fallback to non-streaming if streaming fails
+                            console.log(chalk_1.default.yellow('Falling back to non-streaming mode...'));
+                            completionOptions.stream = false;
+                            delete completionOptions.onChunk;
+                            const response = yield chatService.createCompletion(completionOptions);
+                            if (response &&
+                                response.choices &&
+                                response.choices[0] &&
+                                response.choices[0].message) {
+                                assistantResponse = response.choices[0].message.content;
+                                console.log(assistantResponse);
+                            }
+                        }
+                        console.log(); // Add newline at the end
+                        return;
+                    }
+                    const response = yield chatService.createCompletion(completionOptions);
+                    // Check if response has the expected structure
+                    if (!response ||
+                        !response.choices ||
+                        !response.choices[0] ||
+                        !response.choices[0].message) {
+                        console.error(chalk_1.default.red('Error: Unexpected response format from API'));
+                        console.error(chalk_1.default.red('Response:', JSON.stringify(response, null, 2)));
+                        throw new Error('Unexpected response format from API');
+                    }
+                    // Get assistant's response
+                    const assistantMessage = response.choices[0].message.content;
+                    // Display the response
+                    if ((0, markdown_renderer_1.containsMarkdown)(assistantMessage)) {
+                        console.log((0, markdown_renderer_1.renderMarkdown)(assistantMessage));
+                    }
+                    else {
+                        console.log(assistantMessage);
+                    }
+                    return;
+                }
+                catch (error) {
+                    console.error(chalk_1.default.red('Error: Failed to get response'));
+                    if (error instanceof Error) {
+                        console.error(chalk_1.default.red(error.message));
+                    }
+                    process.exit(1);
+                }
+            }
+            // Set up readline interface for user input (only for interactive mode)
+            const rl = readline_1.default.createInterface({
+                input: process.stdin,
+                output: process.stdout,
+            });
             console.log(chalk_1.default.cyan('Chat with Berget AI (type "exit" to quit)'));
             console.log(chalk_1.default.cyan('----------------------------------------'));
             // Start the conversation loop
             const askQuestion = () => {
                 rl.question(chalk_1.default.green('You: '), (input) => __awaiter(this, void 0, void 0, function* () {
-                    var _a;
                     // Check if user wants to exit
                     if (input.toLowerCase() === 'exit') {
                         console.log(chalk_1.default.cyan('Goodbye!'));
@@ -202,35 +334,64 @@ function registerChatCommands(program) {
                     try {
                         // Call the API
                         const completionOptions = {
-                            model: ((_a = options.args) === null || _a === void 0 ? void 0 : _a[0]) || 'google/gemma-3-27b-it',
+                            model: model || 'openai/gpt-oss',
                             messages: messages,
                             temperature: options.temperature !== undefined ? options.temperature : 0.7,
                             max_tokens: options.maxTokens || 4096,
-                            stream: options.stream || false
+                            stream: options.stream !== false,
                         };
                         // Only add apiKey if it actually exists
                         if (apiKey) {
                             completionOptions.apiKey = apiKey;
                         }
-                        // Add streaming support
-                        if (options.stream) {
+                        // Add streaming support (now default)
+                        if (completionOptions.stream) {
                             let assistantResponse = '';
                             console.log(chalk_1.default.blue('Assistant: '));
-                            // For streaming, we'll collect the response and render it at the end
-                            // since markdown needs the complete text to render properly
+                            // Stream the response in real-time
                             completionOptions.onChunk = (chunk) => {
-                                if (chunk.choices && chunk.choices[0] && chunk.choices[0].delta && chunk.choices[0].delta.content) {
+                                if (chunk.choices &&
+                                    chunk.choices[0] &&
+                                    chunk.choices[0].delta &&
+                                    chunk.choices[0].delta.content) {
                                     const content = chunk.choices[0].delta.content;
-                                    process.stdout.write(content);
+                                    try {
+                                        process.stdout.write(content);
+                                    }
+                                    catch (error) {
+                                        // Handle EPIPE errors gracefully (when pipe is closed)
+                                        if (error.code === 'EPIPE') {
+                                            // Stop streaming if the pipe is closed
+                                            return;
+                                        }
+                                        throw error;
+                                    }
                                     assistantResponse += content;
                                 }
                             };
-                            yield chatService.createCompletion(completionOptions);
+                            try {
+                                yield chatService.createCompletion(completionOptions);
+                            }
+                            catch (streamError) {
+                                console.error(chalk_1.default.red('\nStreaming error:'), streamError);
+                                // Fallback to non-streaming if streaming fails
+                                console.log(chalk_1.default.yellow('Falling back to non-streaming mode...'));
+                                completionOptions.stream = false;
+                                delete completionOptions.onChunk;
+                                const response = yield chatService.createCompletion(completionOptions);
+                                if (response &&
+                                    response.choices &&
+                                    response.choices[0] &&
+                                    response.choices[0].message) {
+                                    assistantResponse = response.choices[0].message.content;
+                                    console.log(assistantResponse);
+                                }
+                            }
                             console.log('\n');
                             // Add assistant response to messages
                             messages.push({
                                 role: 'assistant',
-                                content: assistantResponse
+                                content: assistantResponse,
                             });
                             // Continue the conversation
                             askQuestion();
@@ -343,8 +504,7 @@ function registerChatCommands(program) {
             }
             console.log(chalk_1.default.bold('Available Chat Models:'));
             console.log(chalk_1.default.dim('─'.repeat(70)));
-            console.log(chalk_1.default.dim('MODEL ID'.padEnd(40)) +
-                chalk_1.default.dim('CAPABILITIES'));
+            console.log(chalk_1.default.dim('MODEL ID'.padEnd(40)) + chalk_1.default.dim('CAPABILITIES'));
             console.log(chalk_1.default.dim('─'.repeat(70)));
             // Filter to only show active models
             const activeModels = models.data.filter((model) => model.active === true);
@@ -358,8 +518,7 @@ function registerChatCommands(program) {
                     capabilities.push('json_mode');
                 // Format model ID in Huggingface compatible format (owner/model)
                 const modelId = `${model.owned_by.toLowerCase()}/${model.id}`.padEnd(40);
-                console.log(modelId +
-                    capabilities.join(', '));
+                console.log(modelId + capabilities.join(', '));
             });
         }
         catch (error) {