berget 2.0.6 → 2.1.1

package/dist/src/services/chat-service.js

@@ -269,6 +269,7 @@ class ChatService {
      * @returns A promise that resolves when the stream is complete
      */
     handleStreamingResponse(options, headers) {
+        var _a, _b, _c, _d;
         return __awaiter(this, void 0, void 0, function* () {
             // Use the same base URL as the client
             const baseUrl = process.env.API_BASE_URL || 'https://api.berget.ai';
@@ -299,22 +300,74 @@ class ChatService {
                 const decoder = new TextDecoder();
                 let fullContent = '';
                 let fullResponse = null;
+                let buffer = ''; // Buffer to accumulate partial JSON data
                 while (true) {
                     const { done, value } = yield reader.read();
                     if (done)
                         break;
                     const chunk = decoder.decode(value, { stream: true });
                     logger_1.logger.debug(`Received chunk: ${chunk.length} bytes`);
-                    // Process the chunk - it may contain multiple SSE events
-                    const lines = chunk.split('\n');
-                    for (const line of lines) {
+                    // Add chunk to buffer
+                    buffer += chunk;
+                    logger_1.logger.debug(`Added chunk to buffer. Buffer length: ${buffer.length}`);
+                    // Process the buffer - it may contain multiple SSE events
+                    const lines = buffer.split('\n');
+                    logger_1.logger.debug(`Processing ${lines.length} lines from buffer`);
+                    // Keep track of processed lines to update buffer
+                    let processedLines = 0;
+                    for (let i = 0; i < lines.length; i++) {
+                        const line = lines[i];
+                        logger_1.logger.debug(`Line ${i}: "${line}"`);
                         if (line.startsWith('data:')) {
                             const jsonData = line.slice(5).trim();
+                            logger_1.logger.debug(`Extracted JSON data: "${jsonData}"`);
                             // Skip empty data or [DONE] marker
-                            if (jsonData === '' || jsonData === '[DONE]')
+                            if (jsonData === '' || jsonData === '[DONE]') {
+                                logger_1.logger.debug(`Skipping empty data or [DONE] marker`);
+                                processedLines = i + 1;
                                 continue;
+                            }
+                            // Check if JSON looks complete (basic validation)
+                            if (!jsonData.startsWith('{')) {
+                                logger_1.logger.warn(`JSON data doesn't start with '{', might be partial: "${jsonData.substring(0, 50)}..."`);
+                                // Don't process this line yet, keep it in buffer
+                                break;
+                            }
+                            // Count braces to check if JSON is complete
+                            let braceCount = 0;
+                            let inString = false;
+                            let escaped = false;
+                            for (let j = 0; j < jsonData.length; j++) {
+                                const char = jsonData[j];
+                                if (escaped) {
+                                    escaped = false;
+                                    continue;
+                                }
+                                if (char === '\\') {
+                                    escaped = true;
+                                    continue;
+                                }
+                                if (char === '"') {
+                                    inString = !inString;
+                                    continue;
+                                }
+                                if (!inString && char === '{') {
+                                    braceCount++;
+                                }
+                                else if (!inString && char === '}') {
+                                    braceCount--;
+                                }
+                            }
+                            if (braceCount !== 0) {
+                                logger_1.logger.warn(`JSON braces don't balance (${braceCount}), treating as partial: "${jsonData.substring(0, 50)}..."`);
+                                // Don't process this line yet, keep it in buffer
+                                break;
+                            }
                             try {
+                                logger_1.logger.debug(`Attempting to parse JSON of length: ${jsonData.length}`);
                                 const parsedData = JSON.parse(jsonData);
+                                logger_1.logger.debug(`Successfully parsed JSON: ${JSON.stringify(parsedData, null, 2)}`);
+                                processedLines = i + 1; // Mark this line as processed
                                 // Call the onChunk callback with the parsed data
                                 if (options.onChunk) {
                                     options.onChunk(parsedData);
@@ -334,10 +387,29 @@ class ChatService {
                             }
                             catch (e) {
                                 logger_1.logger.error(`Error parsing chunk: ${e}`);
-                                logger_1.logger.debug(`Problematic chunk: ${jsonData}`);
+                                logger_1.logger.error(`JSON parse error at position ${((_b = (_a = e.message) === null || _a === void 0 ? void 0 : _a.match(/position (\d+)/)) === null || _b === void 0 ? void 0 : _b[1]) || 'unknown'}`);
+                                logger_1.logger.error(`Problematic chunk length: ${jsonData.length}`);
+                                logger_1.logger.error(`Problematic chunk content: "${jsonData}"`);
+                                logger_1.logger.error(`Chunk starts with: "${jsonData.substring(0, 50)}..."`);
+                                logger_1.logger.error(`Chunk ends with: "...${jsonData.substring(jsonData.length - 50)}"`);
+                                // Show character codes around the error position
+                                const errorPos = parseInt(((_d = (_c = e.message) === null || _c === void 0 ? void 0 : _c.match(/position (\d+)/)) === null || _d === void 0 ? void 0 : _d[1]) || '0');
+                                if (errorPos > 0) {
+                                    const start = Math.max(0, errorPos - 20);
+                                    const end = Math.min(jsonData.length, errorPos + 20);
+                                    logger_1.logger.error(`Context around error position ${errorPos}:`);
+                                    logger_1.logger.error(`"${jsonData.substring(start, end)}"`);
+                                    logger_1.logger.error(`Character codes: ${Array.from(jsonData.substring(start, end)).map(c => c.charCodeAt(0)).join(' ')}`);
+                                }
                             }
                         }
                     }
+                    // Update buffer to only contain unprocessed lines
+                    if (processedLines > 0) {
+                        const remainingLines = lines.slice(processedLines);
+                        buffer = remainingLines.join('\n');
+                        logger_1.logger.debug(`Updated buffer. Remaining lines: ${remainingLines.length}, Buffer length: ${buffer.length}`);
+                    }
                 }
                 // Construct the final response object similar to non-streaming response
                 if (fullResponse) {

package/dist/src/utils/config-loader.js

@@ -39,6 +39,12 @@ class ConfigLoader {
         }
         return ConfigLoader.instance;
     }
+    /**
+     * Clear the singleton instance (for testing purposes)
+     */
+    static clearInstance() {
+        ConfigLoader.instance = null;
+    }
     /**
      * Load configuration from opencode.json
      */
@@ -65,72 +71,122 @@ class ConfigLoader {
      */
     getAgentConfig(agentName) {
         var _a;
-        const config = this.loadConfig();
-        return ((_a = config.agent) === null || _a === void 0 ? void 0 : _a[agentName]) || null;
+        try {
+            const config = this.loadConfig();
+            return ((_a = config.agent) === null || _a === void 0 ? void 0 : _a[agentName]) || null;
+        }
+        catch (error) {
+            // Config file doesn't exist, return null
+            return null;
+        }
     }
     /**
      * Get all agent configurations
      */
     getAllAgentConfigs() {
-        const config = this.loadConfig();
-        return config.agent || {};
+        try {
+            const config = this.loadConfig();
+            return config.agent || {};
+        }
+        catch (error) {
+            // Config file doesn't exist, return empty object
+            return {};
+        }
     }
     /**
      * Get model configuration
      */
     getModelConfig() {
-        const config = this.loadConfig();
-        // Extract from config or fall back to defaults
-        const primary = config.model || 'berget/deepseek-r1';
-        const small = config.small_model || 'berget/gpt-oss';
-        return { primary, small };
+        try {
+            const config = this.loadConfig();
+            // Extract from config or fall back to defaults
+            const primary = config.model || 'berget/glm-4.7';
+            const small = config.small_model || 'berget/gpt-oss';
+            return { primary, small };
+        }
+        catch (error) {
+            // Fallback to defaults when no config exists (init scenario)
+            return {
+                primary: 'berget/glm-4.7',
+                small: 'berget/gpt-oss',
+            };
+        }
     }
     /**
      * Get provider model configuration
      */
     getProviderModels() {
         var _a, _b;
-        const config = this.loadConfig();
-        // Extract from provider configuration
-        if ((_b = (_a = config.provider) === null || _a === void 0 ? void 0 : _a.berget) === null || _b === void 0 ? void 0 : _b.models) {
-            return config.provider.berget.models;
+        try {
+            const config = this.loadConfig();
+            // Extract from provider configuration
+            if ((_b = (_a = config.provider) === null || _a === void 0 ? void 0 : _a.berget) === null || _b === void 0 ? void 0 : _b.models) {
+                return config.provider.berget.models;
+            }
+        }
+        catch (error) {
+            // Config file doesn't exist, use fallback defaults
         }
         // Fallback to defaults
         return {
-            'deepseek-r1': {
-                name: 'GLM-4.6',
-                limit: { output: 4000, context: 90000 }
+            'glm-4.7': {
+                name: 'GLM-4.7',
+                limit: { output: 4000, context: 90000 },
             },
             'gpt-oss': {
                 name: 'GPT-OSS',
-                limit: { output: 4000, context: 128000 }
+                limit: { output: 4000, context: 128000 },
+                modalities: {
+                    input: ['text', 'image'],
+                    output: ['text'],
+                },
             },
             'llama-8b': {
                 name: 'llama-3.1-8b',
-                limit: { output: 4000, context: 128000 }
-            }
+                limit: { output: 4000, context: 128000 },
+            },
         };
     }
     /**
      * Get command configurations
      */
     getCommandConfigs() {
-        const config = this.loadConfig();
-        return config.command || {};
+        try {
+            const config = this.loadConfig();
+            return config.command || {};
+        }
+        catch (error) {
+            // Config file doesn't exist, return empty object
+            return {};
+        }
     }
     /**
      * Get watcher configuration
      */
     getWatcherConfig() {
-        const config = this.loadConfig();
-        return config.watcher || { ignore: ['node_modules', 'dist', '.git', 'coverage'] };
+        try {
+            const config = this.loadConfig();
+            return (config.watcher || {
+                ignore: ['node_modules', 'dist', '.git', 'coverage'],
+            });
+        }
+        catch (error) {
+            // Config file doesn't exist, return default watcher config
+            return { ignore: ['node_modules', 'dist', '.git', 'coverage'] };
+        }
     }
     /**
      * Get provider configuration
      */
     getProviderConfig() {
-        const config = this.loadConfig();
-        return config.provider || {};
+        try {
+            const config = this.loadConfig();
+            return config.provider || {};
+        }
+        catch (error) {
+            // Config file doesn't exist, return empty object
+            return {};
+        }
     }
     /**
      * Check if an agent exists
@@ -149,14 +205,14 @@ class ConfigLoader {
      */
     getPrimaryAgentNames() {
         const agents = this.getAllAgentConfigs();
-        return Object.keys(agents).filter(name => agents[name].mode === 'primary');
+        return Object.keys(agents).filter((name) => agents[name].mode === 'primary');
     }
     /**
      * Get list of subagents (mode: 'subagent')
      */
     getSubagentNames() {
         const agents = this.getAllAgentConfigs();
-        return Object.keys(agents).filter(name => agents[name].mode === 'subagent');
+        return Object.keys(agents).filter((name) => agents[name].mode === 'subagent');
     }
     /**
      * Reload configuration from file

package/dist/tests/commands/chat.test.js

@@ -47,13 +47,13 @@ vitest_1.vi.mock('readline', () => ({
         vitest_1.vi.clearAllMocks();
     });
     (0, vitest_1.describe)('chat run command', () => {
-        (0, vitest_1.it)('should use openai/gpt-oss as default model', () => {
+        (0, vitest_1.it)('should use berget/glm-4.7 as default model', () => {
             const chatCommand = program.commands.find((cmd) => cmd.name() === 'chat');
             const runCommand = chatCommand === null || chatCommand === void 0 ? void 0 : chatCommand.commands.find((cmd) => cmd.name() === 'run');
             (0, vitest_1.expect)(runCommand).toBeDefined();
             // Check the help text which contains the default model
             const helpText = runCommand === null || runCommand === void 0 ? void 0 : runCommand.helpInformation();
-            (0, vitest_1.expect)(helpText).toContain('openai/gpt-oss');
+            (0, vitest_1.expect)(helpText).toContain('glm-4.7');
         });
         (0, vitest_1.it)('should have streaming enabled by default', () => {
             const chatCommand = program.commands.find((cmd) => cmd.name() === 'chat');

package/dist/tests/commands/code.test.js

@@ -188,14 +188,14 @@ vitest_1.vi.mock('readline', () => ({
         (0, vitest_1.it)('should create opencode.json with correct structure', () => __awaiter(void 0, void 0, void 0, function* () {
             // This tests the expected config structure
             const expectedConfig = {
-                model: 'berget/deepseek-r1',
+                model: 'berget/glm-4-6',
                 apiKey: 'test-api-key',
                 projectName: 'testproject',
                 provider: 'berget',
                 created: vitest_1.expect.any(String),
                 version: '1.0.0',
             };
-            (0, vitest_1.expect)(expectedConfig.model).toBe('berget/deepseek-r1');
+            (0, vitest_1.expect)(expectedConfig.model).toBe('berget/glm-4-6');
             (0, vitest_1.expect)(expectedConfig.provider).toBe('berget');
             (0, vitest_1.expect)(expectedConfig.version).toBe('1.0.0');
         }));
@@ -230,7 +230,7 @@ vitest_1.vi.mock('readline', () => ({
         });
         (0, vitest_1.it)('should load configuration from opencode.json', () => __awaiter(void 0, void 0, void 0, function* () {
             const mockConfig = {
-                model: 'berget/deepseek-r1',
+                model: 'berget/glm-4-6',
                 apiKey: 'test-api-key',
                 projectName: 'testproject',
                 provider: 'berget',
@@ -253,7 +253,7 @@ vitest_1.vi.mock('readline', () => ({
                 return { on: vitest_1.vi.fn() };
             });
             // Verify config structure expectations
-            (0, vitest_1.expect)(mockConfig.model).toBe('berget/deepseek-r1');
+            (0, vitest_1.expect)(mockConfig.model).toBe('berget/glm-4-6');
             (0, vitest_1.expect)(mockConfig.apiKey).toBe('test-api-key');
             (0, vitest_1.expect)(mockConfig.projectName).toBe('testproject');
         }));