berget 2.2.7 → 2.2.8

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

@@ -3,28 +3,28 @@ 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;
+exports.validateOpenCodeConfig = exports.fixOpenCodeConfig = 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");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const node_path_2 = require("node: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");
+const __dirname = (0, node_path_2.dirname)(__filename);
+const schemaPath = (0, node_path_1.join)(__dirname, '..', 'schemas', 'opencode-schema.json');
 let ajv;
 let openCodeSchema;
 let validateFunction;
 try {
-    const schemaContent = (0, fs_1.readFileSync)(schemaPath, "utf-8");
+    const schemaContent = (0, node_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,
+        strict: false,
+        verbose: true,
     });
     // Add JSON Schema formats
     (0, ajv_formats_1.default)(ajv);
@@ -32,83 +32,54 @@ try {
     validateFunction = ajv.compile(openCodeSchema);
 }
 catch (error) {
-    console.error("Failed to load OpenCode schema:", error);
-    throw new Error("Could not initialize OpenCode validator");
+    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);
+    const fixed = { ...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 (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];
+    const invalidProperties = ['maxTokens', 'contextWindow'];
+    for (const property of invalidProperties) {
+        if (fixed[property] !== undefined) {
+            console.warn(`⚠️  Removing invalid property: ${property}`);
+            delete fixed[property];
         }
-    });
+    }
     // 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) {
+            if (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);
+                    if (model &&
+                        typeof model === 'object' && // Move maxTokens/contextWindow to proper structure if needed
+                        (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;
                             }
-                            delete model.maxTokens;
-                            delete model.contextWindow;
-                            console.warn("⚠️  Moved maxTokens/contextWindow to limit.context/output");
                         }
+                        // 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');
                     }
                 });
             }
@@ -117,3 +88,30 @@ function fixOpenCodeConfig(config) {
     return fixed;
 }
 exports.fixOpenCodeConfig = fixOpenCodeConfig;
+/**
+ * Validate OpenCode configuration against the official JSON Schema
+ */
+function validateOpenCodeConfig(config) {
+    try {
+        if (!validateFunction) {
+            return { errors: ['Schema validator not initialized'], valid: false };
+        }
+        const isValid = validateFunction(config);
+        if (isValid) {
+            return { valid: true };
+        }
+        else {
+            const errors = validateFunction.errors?.map((error) => {
+                const path = error.instancePath || error.schemaPath || 'root';
+                const message = error.message || 'Unknown error';
+                return `${path}: ${message}`;
+            }) || ['Unknown validation error'];
+            return { errors, valid: false };
+        }
+    }
+    catch (error) {
+        console.error('Validation error:', error);
+        return { errors: ['Validation process failed'], valid: false };
+    }
+}
+exports.validateOpenCodeConfig = validateOpenCodeConfig;

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

@@ -24,43 +24,24 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TokenManager = void 0;
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-const os = __importStar(require("os"));
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
 const logger_1 = require("./logger");
-/**
- * Extract the expiration time from a JWT token
- * @param accessToken The JWT access token
- * @returns The expiration timestamp in milliseconds, or 0 if invalid
- */
-function extractJwtExpiresAt(accessToken) {
-    try {
-        const parts = accessToken.split(".");
-        if (parts.length !== 3)
-            return 0;
-        const payload = Buffer.from(parts[1], "base64url").toString("utf8");
-        const decoded = JSON.parse(payload);
-        if (typeof decoded.exp === "number") {
-            return decoded.exp * 1000; // JWT exp is in seconds, convert to milliseconds
-        }
-    }
-    catch (_a) {
-        // If decoding fails, return 0 (treated as expired)
-    }
-    return 0;
-}
 /**
  * Manages authentication tokens including refresh functionality
  */
 class TokenManager {
+    static instance;
+    tokenData = null;
+    tokenFilePath;
     constructor() {
-        this.tokenData = null;
         // Set up token file path in user's home directory
-        const bergetDir = path.join(os.homedir(), ".berget");
+        const bergetDir = path.join(os.homedir(), '.berget');
         if (!fs.existsSync(bergetDir)) {
             fs.mkdirSync(bergetDir, { recursive: true });
         }
-        this.tokenFilePath = path.join(bergetDir, "auth.json");
+        this.tokenFilePath = path.join(bergetDir, 'auth.json');
         this.loadToken();
     }
     static getInstance() {
@@ -70,40 +51,11 @@ class TokenManager {
         return TokenManager.instance;
     }
     /**
-     * Load token data from file
-     */
-    loadToken() {
-        try {
-            if (fs.existsSync(this.tokenFilePath)) {
-                const data = fs.readFileSync(this.tokenFilePath, "utf8");
-                this.tokenData = JSON.parse(data);
-            }
-        }
-        catch (_a) {
-            logger_1.logger.error("Failed to load authentication token");
-            this.tokenData = null;
-        }
-    }
-    /**
-     * Save token data to file
+     * Clear all token data
      */
-    saveToken() {
-        try {
-            if (this.tokenData) {
-                fs.writeFileSync(this.tokenFilePath, JSON.stringify(this.tokenData, null, 2));
-                // Set file permissions to be readable only by the owner
-                fs.chmodSync(this.tokenFilePath, 0o600);
-            }
-            else {
-                // If token data is null, remove the file
-                if (fs.existsSync(this.tokenFilePath)) {
-                    fs.unlinkSync(this.tokenFilePath);
-                }
-            }
-        }
-        catch (_a) {
-            logger_1.logger.error("Failed to save authentication token");
-        }
+    clearTokens() {
+        this.tokenData = null;
+        this.saveToken();
     }
     /**
      * Get the current access token
@@ -163,8 +115,8 @@ class TokenManager {
         const expiresAt = jwtExpiresAt > 0 ? jwtExpiresAt : Date.now() + expiresIn * 1000;
         this.tokenData = {
             access_token: accessToken,
-            refresh_token: refreshToken,
             expires_at: expiresAt,
+            refresh_token: refreshToken,
         };
         this.saveToken();
     }
@@ -184,11 +136,61 @@ class TokenManager {
         this.saveToken();
     }
     /**
-     * Clear all token data
+     * Load token data from file
      */
-    clearTokens() {
-        this.tokenData = null;
-        this.saveToken();
+    loadToken() {
+        try {
+            if (fs.existsSync(this.tokenFilePath)) {
+                const data = fs.readFileSync(this.tokenFilePath, 'utf8');
+                this.tokenData = JSON.parse(data);
+            }
+        }
+        catch {
+            logger_1.logger.error('Failed to load authentication token');
+            this.tokenData = null;
+        }
+    }
+    /**
+     * Save token data to file
+     */
+    saveToken() {
+        try {
+            if (this.tokenData) {
+                fs.writeFileSync(this.tokenFilePath, JSON.stringify(this.tokenData, null, 2));
+                // Set file permissions to be readable only by the owner
+                fs.chmodSync(this.tokenFilePath, 0o600);
+            }
+            else {
+                // If token data is null, remove the file
+                if (fs.existsSync(this.tokenFilePath)) {
+                    fs.unlinkSync(this.tokenFilePath);
+                }
+            }
+        }
+        catch {
+            logger_1.logger.error('Failed to save authentication token');
+        }
     }
 }
 exports.TokenManager = TokenManager;
+/**
+ * Extract the expiration time from a JWT token
+ * @param accessToken The JWT access token
+ * @returns The expiration timestamp in milliseconds, or 0 if invalid
+ */
+function extractJwtExpiresAt(accessToken) {
+    try {
+        const parts = accessToken.split('.');
+        if (parts.length !== 3)
+            return 0;
+        const payload = Buffer.from(parts[1], 'base64url').toString('utf8');
+        const decoded = JSON.parse(payload);
+        if (typeof decoded.exp === 'number') {
+            return decoded.exp * 1000; // JWT exp is in seconds, convert to milliseconds
+        }
+    }
+    catch {
+        // If decoding fails, return 0 (treated as expired)
+    }
+    return 0;
+}

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

@@ -1,29 +1,20 @@
 "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 vitest_1 = require("vitest");
 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", () => ({
+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(),
+        question: vitest_1.vi.fn(),
     })),
 }));
-(0, vitest_1.describe)("Chat Commands", () => {
+(0, vitest_1.describe)('Chat Commands', () => {
     let program;
     let mockChatService;
     let mockDefaultApiKeyManager;
@@ -46,32 +37,32 @@ vitest_1.vi.mock("readline", () => ({
     (0, vitest_1.afterEach)(() => {
         vitest_1.vi.clearAllMocks();
     });
-    (0, vitest_1.describe)("chat run command", () => {
-        (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.describe)('chat run command', () => {
+        (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?.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("glm-4.7");
+            const helpText = runCommand?.helpInformation();
+            (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");
-            const runCommand = chatCommand === null || chatCommand === void 0 ? void 0 : chatCommand.commands.find(cmd => cmd.name() === "run");
+        (0, vitest_1.it)('should have streaming enabled by default', () => {
+            const chatCommand = program.commands.find((cmd) => cmd.name() === 'chat');
+            const runCommand = 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");
+            const streamOption = 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.expect)(streamOption?.description).toContain('Disable streaming');
         });
-        (0, vitest_1.it)("should create completion with correct default options", () => __awaiter(void 0, void 0, void 0, function* () {
+        (0, vitest_1.it)('should create completion with correct default options', async () => {
             // Mock API key
-            process.env.BERGET_API_KEY = "test-key";
+            process.env.BERGET_API_KEY = 'test-key';
             // Mock successful completion
             mockChatService.createCompletion.mockResolvedValue({
                 choices: [
                     {
-                        message: { content: "Test response" },
+                        message: { content: 'Test response' },
                     },
                 ],
             });
@@ -81,29 +72,29 @@ vitest_1.vi.mock("readline", () => ({
             (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* () {
+    (0, vitest_1.describe)('chat list command', () => {
+        (0, vitest_1.it)('should list available models', async () => {
             const mockModels = {
                 data: [
                     {
-                        id: "gpt-oss",
-                        owned_by: "openai",
                         active: true,
                         capabilities: {
-                            vision: false,
                             function_calling: true,
                             json_mode: true,
+                            vision: false,
                         },
+                        id: 'gpt-oss',
+                        owned_by: 'openai',
                     },
                 ],
             };
             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");
+            const chatCommand = program.commands.find((cmd) => cmd.name() === 'chat');
+            const listCommand = 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");
-        }));
+            (0, vitest_1.expect)(listCommand?.description()).toBe('List available chat models');
+        });
     });
 });