berget 1.3.1 → 2.0.0

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

@@ -256,26 +256,26 @@ class ChatService {
      */
     handleStreamingResponse(options, headers) {
         return __awaiter(this, void 0, void 0, function* () {
-            logger_1.logger.debug('Handling streaming response');
-            // Create URL with query parameters
-            const url = new URL(`${client_1.API_BASE_URL}/v1/chat/completions`);
-            // Debug the headers and options
-            logger_1.logger.debug('Streaming headers:');
-            logger_1.logger.debug(JSON.stringify(headers, null, 2));
-            logger_1.logger.debug('Streaming options:');
-            logger_1.logger.debug(JSON.stringify(Object.assign(Object.assign({}, options), { onChunk: options.onChunk ? 'function present' : 'no function' }), null, 2));
+            // Use the same base URL as the client
+            const baseUrl = process.env.API_BASE_URL || 'https://api.berget.ai';
+            const url = new URL(`${baseUrl}/v1/chat/completions`);
             try {
+                logger_1.logger.debug(`Making streaming request to: ${url.toString()}`);
+                logger_1.logger.debug(`Headers:`, JSON.stringify(headers, null, 2));
+                logger_1.logger.debug(`Body:`, JSON.stringify(options, null, 2));
                 // Make fetch request directly to handle streaming
                 const response = yield fetch(url.toString(), {
                     method: 'POST',
                     headers: Object.assign({ 'Content-Type': 'application/json', Accept: 'text/event-stream' }, headers),
                     body: JSON.stringify(options),
                 });
+                logger_1.logger.debug(`Response status: ${response.status}`);
+                logger_1.logger.debug(`Response headers:`, JSON.stringify(Object.fromEntries(response.headers.entries()), null, 2));
                 if (!response.ok) {
                     const errorText = yield response.text();
                     logger_1.logger.error(`Stream request failed: ${response.status} ${response.statusText}`);
-                    logger_1.logger.debug(`Error response: ${errorText}`);
-                    throw new Error(`Stream request failed: ${response.status} ${response.statusText}`);
+                    logger_1.logger.error(`Error response: ${errorText}`);
+                    throw new Error(`Stream request failed: ${response.status} ${response.statusText} - ${errorText}`);
                 }
                 if (!response.body) {
                     throw new Error('No response body received');

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

@@ -74,7 +74,7 @@ class ClusterService {
                 // This is a placeholder since the API doesn't have a specific endpoint
                 // In a real implementation, this would call a specific endpoint
                 const clusters = yield this.list();
-                return clusters.find(cluster => cluster.id === clusterId) || null;
+                return clusters.find((cluster) => cluster.id === clusterId) || null;
             }
             catch (error) {
                 console.error('Failed to describe cluster:', error);

package/dist/src/utils/default-api-key.js

@@ -179,7 +179,7 @@ class DefaultApiKeyManager {
                 // Create readline interface for user input
                 const rl = readline_1.default.createInterface({
                     input: process.stdin,
-                    output: process.stdout
+                    output: process.stdout,
                 });
                 // Prompt for selection
                 const selection = yield new Promise((resolve) => {
@@ -202,7 +202,7 @@ class DefaultApiKeyManager {
                 // Create a new API key with the selected name
                 const newKey = yield apiKeyService.create({
                     name: `CLI Default (copy of ${selectedKey.name})`,
-                    description: 'Created automatically by the Berget CLI for default use'
+                    description: 'Created automatically by the Berget CLI for default use',
                 });
                 // Save the new key as default
                 this.setDefaultApiKey(newKey.id.toString(), newKey.name, newKey.key.substring(0, 8), // Use first 8 chars as prefix

package/dist/src/utils/env-manager.js

@@ -0,0 +1,86 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasEnvKey = exports.updateEnvFile = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const promises_1 = require("fs/promises");
+const chalk_1 = __importDefault(require("chalk"));
+const dotenv_1 = __importDefault(require("dotenv"));
+/**
+ * Safely updates .env file without overwriting existing keys
+ * Uses dotenv for proper parsing and formatting
+ */
+function updateEnvFile(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { envPath = path_1.default.join(process.cwd(), '.env'), key, value, comment, force = false, } = options;
+        try {
+            let existingContent = '';
+            let parsed = {};
+            // Read existing .env file if it exists
+            if (fs_1.default.existsSync(envPath)) {
+                existingContent = fs_1.default.readFileSync(envPath, 'utf8');
+                parsed = dotenv_1.default.parse(existingContent);
+            }
+            // Check if key already exists and we're not forcing
+            if (parsed[key] && !force) {
+                console.log(chalk_1.default.yellow(`⚠ ${key} already exists in .env - leaving unchanged`));
+                return false;
+            }
+            // Update the parsed object
+            parsed[key] = value;
+            // Generate new .env content
+            let newContent = '';
+            // Add comment at the top if this is a new file
+            if (!existingContent && comment) {
+                newContent += `# ${comment}\n`;
+            }
+            // Convert parsed object back to .env format
+            for (const [envKey, envValue] of Object.entries(parsed)) {
+                newContent += `${envKey}=${envValue}\n`;
+            }
+            // Write the updated content
+            yield (0, promises_1.writeFile)(envPath, newContent.trim() + '\n');
+            if (existingContent) {
+                console.log(chalk_1.default.green(`✓ Updated .env with ${key}`));
+            }
+            else {
+                console.log(chalk_1.default.green(`✓ Created .env with ${key}`));
+            }
+            return true;
+        }
+        catch (error) {
+            console.error(chalk_1.default.red(`Failed to update .env file:`));
+            throw error;
+        }
+    });
+}
+exports.updateEnvFile = updateEnvFile;
+/**
+ * Checks if a .env file exists and contains a specific key
+ */
+function hasEnvKey(envPath = path_1.default.join(process.cwd(), '.env'), key) {
+    if (!fs_1.default.existsSync(envPath)) {
+        return false;
+    }
+    try {
+        const content = fs_1.default.readFileSync(envPath, 'utf8');
+        const parsed = dotenv_1.default.parse(content);
+        return key in parsed;
+    }
+    catch (_a) {
+        return false;
+    }
+}
+exports.hasEnvKey = hasEnvKey;

package/dist/src/utils/error-handler.js

@@ -35,9 +35,16 @@ function handleError(message, error) {
         console.error(chalk_1.default.dim(`Details: ${error.message}`));
     }
     // Check for authentication errors
-    if ((typeof error === 'string' && (error.includes('Unauthorized') || error.includes('Authentication failed'))) ||
-        (error && error.message && (error.message.includes('Unauthorized') || error.message.includes('Authentication failed'))) ||
-        (error && error.code && (error.code === 401 || error.code === 'AUTH_FAILED'))) {
+    if ((typeof error === 'string' &&
+        (error.includes('Unauthorized') ||
+            error.includes('Authentication failed'))) ||
+        (error &&
+            error.message &&
+            (error.message.includes('Unauthorized') ||
+                error.message.includes('Authentication failed'))) ||
+        (error &&
+            error.code &&
+            (error.code === 401 || error.code === 'AUTH_FAILED'))) {
         console.error(chalk_1.default.yellow('\nYou need to be logged in to use this command.'));
         console.error(chalk_1.default.yellow('Run `berget auth login` to authenticate.'));
     }

package/dist/src/utils/markdown-renderer.js

@@ -23,8 +23,8 @@ marked_1.marked.setOptions({
         // Adjust the width to fit the terminal
         width: process.stdout.columns || 80,
         // Customize code block rendering
-        codespan: chalk_1.default.cyan
-    })
+        codespan: chalk_1.default.cyan,
+    }),
 });
 /**
  * Render markdown text to terminal-friendly formatted text
@@ -66,8 +66,8 @@ function containsMarkdown(text) {
         /^\s*>\s+/m, // Blockquotes
         /\|.*\|.*\|/, // Tables
         /^---+$/m, // Horizontal rules
-        /^===+$/m // Alternative headers
+        /^===+$/m, // Alternative headers
     ];
-    return markdownPatterns.some(pattern => pattern.test(text));
+    return markdownPatterns.some((pattern) => pattern.test(text));
 }
 exports.containsMarkdown = containsMarkdown;

package/dist/src/utils/opencode-validator.js

@@ -0,0 +1,122 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fixOpenCodeConfig = exports.validateOpenCodeConfig = void 0;
+const ajv_1 = __importDefault(require("ajv"));
+const ajv_formats_1 = __importDefault(require("ajv-formats"));
+const fs_1 = require("fs");
+const path_1 = require("path");
+const path_2 = require("path");
+// Load the official OpenCode JSON Schema
+const __dirname = (0, path_2.dirname)(__filename);
+const schemaPath = (0, path_1.join)(__dirname, '..', 'schemas', 'opencode-schema.json');
+let ajv;
+let openCodeSchema;
+let validateFunction;
+try {
+    const schemaContent = (0, fs_1.readFileSync)(schemaPath, 'utf-8');
+    openCodeSchema = JSON.parse(schemaContent);
+    // Initialize AJV with formats and options
+    ajv = new ajv_1.default({
+        allErrors: true,
+        verbose: true,
+        strict: false,
+        allowUnionTypes: true,
+        removeAdditional: false,
+    });
+    // Add JSON Schema formats
+    (0, ajv_formats_1.default)(ajv);
+    // Compile the schema
+    validateFunction = ajv.compile(openCodeSchema);
+}
+catch (error) {
+    console.error('Failed to load OpenCode schema:', error);
+    throw new Error('Could not initialize OpenCode validator');
+}
+/**
+ * Validate OpenCode configuration against the official JSON Schema
+ */
+function validateOpenCodeConfig(config) {
+    var _a;
+    try {
+        if (!validateFunction) {
+            return { valid: false, errors: ['Schema validator not initialized'] };
+        }
+        const isValid = validateFunction(config);
+        if (isValid) {
+            return { valid: true };
+        }
+        else {
+            const errors = ((_a = validateFunction.errors) === null || _a === void 0 ? void 0 : _a.map((err) => {
+                const path = err.instancePath || err.schemaPath || 'root';
+                const message = err.message || 'Unknown error';
+                return `${path}: ${message}`;
+            })) || ['Unknown validation error'];
+            return { valid: false, errors };
+        }
+    }
+    catch (error) {
+        console.error('Validation error:', error);
+        return { valid: false, errors: ['Validation process failed'] };
+    }
+}
+exports.validateOpenCodeConfig = validateOpenCodeConfig;
+/**
+ * Fix common OpenCode configuration issues
+ */
+function fixOpenCodeConfig(config) {
+    const fixed = Object.assign({}, config);
+    // Fix tools.compact - should be boolean, not object
+    if (fixed.tools && typeof fixed.tools.compact === 'object') {
+        console.warn('⚠️  Converting tools.compact from object to boolean');
+        // If it has properties, assume it should be enabled
+        fixed.tools.compact = true;
+    }
+    // Remove invalid properties
+    const invalidProps = ['maxTokens', 'contextWindow'];
+    invalidProps.forEach((prop) => {
+        if (fixed[prop] !== undefined) {
+            console.warn(`⚠️  Removing invalid property: ${prop}`);
+            delete fixed[prop];
+        }
+    });
+    // Fix provider models with invalid properties
+    if (fixed.provider) {
+        Object.values(fixed.provider).forEach((provider) => {
+            if (provider === null || provider === void 0 ? void 0 : provider.models) {
+                Object.values(provider.models).forEach((model) => {
+                    if (model && typeof model === 'object') {
+                        // Move maxTokens/contextWindow to proper structure if needed
+                        if (model.maxTokens || model.contextWindow) {
+                            if (!model.limit)
+                                model.limit = {};
+                            // Use the larger of maxTokens/contextWindow for context
+                            const contextValues = [
+                                model.maxTokens,
+                                model.contextWindow,
+                            ].filter(Boolean);
+                            if (contextValues.length > 0) {
+                                const newContext = Math.max(...contextValues);
+                                if (!model.limit.context || newContext > model.limit.context) {
+                                    model.limit.context = newContext;
+                                }
+                            }
+                            // Set a reasonable default for output if not present
+                            // (typically 1/4 to 1/8 of context window)
+                            if (!model.limit.output && model.limit.context) {
+                                model.limit.output = Math.floor(model.limit.context / 4);
+                            }
+                            delete model.maxTokens;
+                            delete model.contextWindow;
+                            console.warn('⚠️  Moved maxTokens/contextWindow to limit.context/output');
+                        }
+                    }
+                });
+            }
+        });
+    }
+    return fixed;
+}
+exports.fixOpenCodeConfig = fixOpenCodeConfig;

package/dist/src/utils/token-manager.js

@@ -135,7 +135,7 @@ class TokenManager {
         this.tokenData = {
             access_token: accessToken,
             refresh_token: refreshToken,
-            expires_at: Date.now() + (expiresIn * 1000)
+            expires_at: Date.now() + expiresIn * 1000,
         };
         this.saveToken();
     }
@@ -148,7 +148,7 @@ class TokenManager {
         if (!this.tokenData)
             return;
         this.tokenData.access_token = accessToken;
-        this.tokenData.expires_at = Date.now() + (expiresIn * 1000);
+        this.tokenData.expires_at = Date.now() + expiresIn * 1000;
         this.saveToken();
     }
     /**

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

@@ -0,0 +1,109 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const commander_1 = require("commander");
+const chat_1 = require("../../src/commands/chat");
+const chat_service_1 = require("../../src/services/chat-service");
+const default_api_key_1 = require("../../src/utils/default-api-key");
+// Mock dependencies
+vitest_1.vi.mock('../../src/services/chat-service');
+vitest_1.vi.mock('../../src/utils/default-api-key');
+vitest_1.vi.mock('readline', () => ({
+    createInterface: vitest_1.vi.fn(() => ({
+        question: vitest_1.vi.fn(),
+        close: vitest_1.vi.fn(),
+    })),
+}));
+(0, vitest_1.describe)('Chat Commands', () => {
+    let program;
+    let mockChatService;
+    let mockDefaultApiKeyManager;
+    (0, vitest_1.beforeEach)(() => {
+        program = new commander_1.Command();
+        // Mock ChatService
+        mockChatService = {
+            createCompletion: vitest_1.vi.fn(),
+            listModels: vitest_1.vi.fn(),
+        };
+        vitest_1.vi.mocked(chat_service_1.ChatService.getInstance).mockReturnValue(mockChatService);
+        // Mock DefaultApiKeyManager
+        mockDefaultApiKeyManager = {
+            getDefaultApiKeyData: vitest_1.vi.fn(),
+            promptForDefaultApiKey: vitest_1.vi.fn(),
+        };
+        vitest_1.vi.mocked(default_api_key_1.DefaultApiKeyManager.getInstance).mockReturnValue(mockDefaultApiKeyManager);
+        (0, chat_1.registerChatCommands)(program);
+    });
+    (0, vitest_1.afterEach)(() => {
+        vitest_1.vi.clearAllMocks();
+    });
+    (0, vitest_1.describe)('chat run command', () => {
+        (0, vitest_1.it)('should use openai/gpt-oss 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.it)('should have streaming enabled by default', () => {
+            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 that the option is --no-stream (meaning streaming is default)
+            const streamOption = runCommand === null || runCommand === void 0 ? void 0 : runCommand.options.find((opt) => opt.long === '--no-stream');
+            (0, vitest_1.expect)(streamOption).toBeDefined();
+            (0, vitest_1.expect)(streamOption === null || streamOption === void 0 ? void 0 : streamOption.description).toContain('Disable streaming');
+        });
+        (0, vitest_1.it)('should create completion with correct default options', () => __awaiter(void 0, void 0, void 0, function* () {
+            // Mock API key
+            process.env.BERGET_API_KEY = 'test-key';
+            // Mock successful completion
+            mockChatService.createCompletion.mockResolvedValue({
+                choices: [
+                    {
+                        message: { content: 'Test response' },
+                    },
+                ],
+            });
+            // This would normally test the actual command execution
+            // but since it involves readline interaction, we just verify
+            // that the service would be called with correct defaults
+            (0, vitest_1.expect)(mockChatService.createCompletion).not.toHaveBeenCalled();
+            // Clean up
+            delete process.env.BERGET_API_KEY;
+        }));
+    });
+    (0, vitest_1.describe)('chat list command', () => {
+        (0, vitest_1.it)('should list available models', () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockModels = {
+                data: [
+                    {
+                        id: 'gpt-oss',
+                        owned_by: 'openai',
+                        active: true,
+                        capabilities: {
+                            vision: false,
+                            function_calling: true,
+                            json_mode: true,
+                        },
+                    },
+                ],
+            };
+            mockChatService.listModels.mockResolvedValue(mockModels);
+            const chatCommand = program.commands.find((cmd) => cmd.name() === 'chat');
+            const listCommand = chatCommand === null || chatCommand === void 0 ? void 0 : chatCommand.commands.find((cmd) => cmd.name() === 'list');
+            (0, vitest_1.expect)(listCommand).toBeDefined();
+            (0, vitest_1.expect)(listCommand === null || listCommand === void 0 ? void 0 : listCommand.description()).toBe('List available chat models');
+        }));
+    });
+});