berget 2.2.6 → 2.2.7

package/src/utils/error-handler.ts

@@ -1,146 +1,151 @@
-import chalk from 'chalk'
+import chalk from "chalk";
 
 /**
  * Formats and prints error messages in a consistent way
  */
 export function handleError(message: string, error: any): void {
-  console.error(chalk.red(`❌ Error: ${message}`))
+  console.error(chalk.red(`❌ Error: ${message}`));
 
-  let errorDetails = ''
-  let errorCode = ''
-  let errorType = ''
+  let errorDetails = "";
+  let errorCode = "";
+  let errorType = "";
 
   // If the error is a string (like JSON.stringify(error))
-  if (typeof error === 'string') {
+  if (typeof error === "string") {
     try {
       // Try to parse it as JSON
-      const parsedError = JSON.parse(error)
+      const parsedError = JSON.parse(error);
       if (parsedError.error) {
-        errorDetails = parsedError.error.message || parsedError.error
-        errorCode = parsedError.error.code || parsedError.code
-        errorType = parsedError.error.type || ''
+        errorDetails = parsedError.error.message || parsedError.error;
+        errorCode = parsedError.error.code || parsedError.code;
+        errorType = parsedError.error.type || "";
       } else {
-        errorDetails = error
+        errorDetails = error;
       }
     } catch {
       // If it's not valid JSON, just print the string
-      errorDetails = error
+      errorDetails = error;
     }
   } else if (error && error.message) {
     // If it's an Error object
-    errorDetails = error.message
-    errorCode = error.code
-    errorType = error.type
+    errorDetails = error.message;
+    errorCode = error.code;
+    errorType = error.type;
   }
 
   // Print error details
   if (errorDetails) {
-    console.error(chalk.dim(`📝 Details: ${errorDetails}`))
+    console.error(chalk.dim(`📝 Details: ${errorDetails}`));
   }
   if (errorCode) {
-    console.error(chalk.dim(`🔢 Code: ${errorCode}`))
+    console.error(chalk.dim(`🔢 Code: ${errorCode}`));
   }
 
   // Provide helpful troubleshooting based on error type
-  provideTroubleshootingTips(errorType, errorCode, errorDetails)
+  provideTroubleshootingTips(errorType, errorCode, errorDetails);
 }
 
 /**
  * Provides helpful troubleshooting tips based on error type
  */
-function provideTroubleshootingTips(errorType: string, errorCode: string, errorDetails: string): void {
-  console.error(chalk.blue('\n💡 Troubleshooting tips:'))
+function provideTroubleshootingTips(
+  errorType: string,
+  errorCode: string,
+  errorDetails: string
+): void {
+  console.error(chalk.blue("\n💡 Troubleshooting tips:"));
 
   // Authentication errors
   if (
-    errorType === 'authentication_error' ||
-    errorCode === 'AUTH_FAILED' ||
-    errorDetails?.includes('Unauthorized') ||
-    errorDetails?.includes('Authentication failed')
+    errorType === "authentication_error" ||
+    errorCode === "AUTH_FAILED" ||
+    errorDetails?.includes("Unauthorized") ||
+    errorDetails?.includes("Authentication failed")
   ) {
-    console.error(chalk.yellow('   🔐 Authentication issue detected:'))
-    console.error(chalk.white('   • Run `berget auth login` to log in'))
-    console.error(chalk.white('   • Check if your session has expired'))
-    console.error(chalk.white('   • Verify you have the correct permissions'))
+    console.error(chalk.yellow("   🔐 Authentication issue detected:"));
+    console.error(chalk.white("   • Run `berget auth login` to log in"));
+    console.error(chalk.white("   • Check if your session has expired"));
+    console.error(chalk.white("   • Verify you have the correct permissions"));
   }
 
   // Network/connection errors
   if (
-    errorDetails?.includes('fetch failed') ||
-    errorDetails?.includes('ECONNREFUSED') ||
-    errorDetails?.includes('ENOTFOUND') ||
-    errorDetails?.includes('network')
+    errorDetails?.includes("fetch failed") ||
+    errorDetails?.includes("ECONNREFUSED") ||
+    errorDetails?.includes("ENOTFOUND") ||
+    errorDetails?.includes("network")
   ) {
-    console.error(chalk.yellow('   🌐 Network issue detected:'))
-    console.error(chalk.white('   • Check your internet connection'))
-    console.error(chalk.white('   • Verify you can reach api.berget.ai'))
-    console.error(chalk.white('   • Try again in a few minutes'))
-    console.error(chalk.white('   • Check if any firewall is blocking the request'))
+    console.error(chalk.yellow("   🌐 Network issue detected:"));
+    console.error(chalk.white("   • Check your internet connection"));
+    console.error(chalk.white("   • Verify you can reach api.berget.ai"));
+    console.error(chalk.white("   • Try again in a few minutes"));
+    console.error(chalk.white("   • Check if any firewall is blocking the request"));
   }
 
   // API key errors
   if (
-    errorCode?.includes('API_KEY') ||
-    errorDetails?.includes('API key') ||
-    errorType === 'invalid_request_error'
+    errorCode?.includes("API_KEY") ||
+    errorDetails?.includes("API key") ||
+    errorType === "invalid_request_error"
   ) {
-    console.error(chalk.yellow('   🔑 API key issue detected:'))
-    console.error(chalk.white('   • Run `berget api-keys list` to check your keys'))
-    console.error(chalk.white('   • Create a new key with `berget api-keys create --name "My Key"`'))
-    console.error(chalk.white('   • Set a default key with `berget api-keys set-default <id>`'))
-    console.error(chalk.white('   • Check if your API key has expired'))
+    console.error(chalk.yellow("   🔑 API key issue detected:"));
+    console.error(chalk.white("   • Run `berget api-keys list` to check your keys"));
+    console.error(
+      chalk.white('   • Create a new key with `berget api-keys create --name "My Key"`')
+    );
+    console.error(chalk.white("   • Set a default key with `berget api-keys set-default <id>`"));
+    console.error(chalk.white("   • Check if your API key has expired"));
   }
 
   // Rate limiting
   if (
-    errorCode === 'RATE_LIMIT_EXCEEDED' ||
-    errorDetails?.includes('rate limit') ||
-    errorDetails?.includes('too many requests')
+    errorCode === "RATE_LIMIT_EXCEEDED" ||
+    errorDetails?.includes("rate limit") ||
+    errorDetails?.includes("too many requests")
   ) {
-    console.error(chalk.yellow('   ⏱️  Rate limit exceeded:'))
-    console.error(chalk.white('   • Wait a few minutes before trying again'))
-    console.error(chalk.white('   • Consider upgrading your plan for higher limits'))
-    console.error(chalk.white('   • Use `berget billing get-usage` to check your usage'))
+    console.error(chalk.yellow("   ⏱️  Rate limit exceeded:"));
+    console.error(chalk.white("   • Wait a few minutes before trying again"));
+    console.error(chalk.white("   • Consider upgrading your plan for higher limits"));
+    console.error(chalk.white("   • Use `berget billing get-usage` to check your usage"));
   }
 
   // Server errors
   if (
-    errorCode?.includes('SERVER_ERROR') ||
-    errorType === 'server_error' ||
+    errorCode?.includes("SERVER_ERROR") ||
+    errorType === "server_error" ||
     (errorCode && parseInt(errorCode) >= 500)
   ) {
-    console.error(chalk.yellow('   🖥️  Server issue detected:'))
-    console.error(chalk.white('   • This is a temporary problem on our end'))
-    console.error(chalk.white('   • Try again in a few minutes'))
-    console.error(chalk.white('   • Check status.berget.ai for service status'))
-    console.error(chalk.white('   • Contact support if the problem persists'))
+    console.error(chalk.yellow("   🖥️  Server issue detected:"));
+    console.error(chalk.white("   • This is a temporary problem on our end"));
+    console.error(chalk.white("   • Try again in a few minutes"));
+    console.error(chalk.white("   • Check status.berget.ai for service status"));
+    console.error(chalk.white("   • Contact support if the problem persists"));
   }
 
   // Cluster errors
-  if (
-    errorCode?.includes('CLUSTERS') ||
-    errorDetails?.includes('cluster')
-  ) {
-    console.error(chalk.yellow('   🏗️  Cluster issue detected:'))
-    console.error(chalk.white('   • Clusters may be temporarily unavailable'))
-    console.error(chalk.white('   • Try again later or contact support'))
-    console.error(chalk.white('   • Check your cluster permissions'))
+  if (errorCode?.includes("CLUSTERS") || errorDetails?.includes("cluster")) {
+    console.error(chalk.yellow("   🏗️  Cluster issue detected:"));
+    console.error(chalk.white("   • Clusters may be temporarily unavailable"));
+    console.error(chalk.white("   • Try again later or contact support"));
+    console.error(chalk.white("   • Check your cluster permissions"));
   }
 
   // Generic fallback
   if (
-    !errorType?.includes('authentication') &&
-    !errorDetails?.includes('fetch failed') &&
-    !errorCode?.includes('API_KEY') &&
-    !errorCode?.includes('RATE_LIMIT') &&
-    !errorCode?.includes('SERVER_ERROR') &&
-    !errorCode?.includes('CLUSTERS')
+    !errorType?.includes("authentication") &&
+    !errorDetails?.includes("fetch failed") &&
+    !errorCode?.includes("API_KEY") &&
+    !errorCode?.includes("RATE_LIMIT") &&
+    !errorCode?.includes("SERVER_ERROR") &&
+    !errorCode?.includes("CLUSTERS")
   ) {
-    console.error(chalk.yellow('   ❓ General issue:'))
-    console.error(chalk.white('   • Try running the command with --debug for more info'))
-    console.error(chalk.white('   • Check your configuration with `berget auth whoami`'))
-    console.error(chalk.white('   • Contact support if the problem persists'))
+    console.error(chalk.yellow("   ❓ General issue:"));
+    console.error(chalk.white("   • Try running the command with --debug for more info"));
+    console.error(chalk.white("   • Check your configuration with `berget auth whoami`"));
+    console.error(chalk.white("   • Contact support if the problem persists"));
   }
 
-  console.error(chalk.dim('\nNeed more help? Visit https://docs.berget.ai or contact support@berget.ai'))
+  console.error(
+    chalk.dim("\nNeed more help? Visit https://docs.berget.ai or contact support@berget.ai")
+  );
 }

package/src/utils/logger.ts

@@ -1,4 +1,4 @@
-import chalk from 'chalk'
+import chalk from "chalk";
 
 /**
  * Log levels in order of increasing verbosity
@@ -15,25 +15,25 @@ export enum LogLevel {
  * Logger class for centralized logging with configurable log levels
  */
 export class Logger {
-  private static instance: Logger
-  private logLevel: LogLevel = LogLevel.INFO // Default log level
+  private static instance: Logger;
+  private logLevel: LogLevel = LogLevel.INFO; // Default log level
 
   private constructor() {
     // Set log level from environment variable or command line argument
     if (process.env.LOG_LEVEL) {
-      this.setLogLevelFromString(process.env.LOG_LEVEL)
-    } else if (process.argv.includes('--debug')) {
-      this.logLevel = LogLevel.DEBUG
-    } else if (process.argv.includes('--quiet')) {
-      this.logLevel = LogLevel.ERROR
+      this.setLogLevelFromString(process.env.LOG_LEVEL);
+    } else if (process.argv.includes("--debug")) {
+      this.logLevel = LogLevel.DEBUG;
+    } else if (process.argv.includes("--quiet")) {
+      this.logLevel = LogLevel.ERROR;
     }
   }
 
   public static getInstance(): Logger {
     if (!Logger.instance) {
-      Logger.instance = new Logger()
+      Logger.instance = new Logger();
     }
-    return Logger.instance
+    return Logger.instance;
   }
 
   /**
@@ -41,24 +41,24 @@ export class Logger {
    */
   private setLogLevelFromString(level: string): void {
     switch (level.toLowerCase()) {
-      case 'none':
-        this.logLevel = LogLevel.NONE
-        break
-      case 'error':
-        this.logLevel = LogLevel.ERROR
-        break
-      case 'warn':
-        this.logLevel = LogLevel.WARN
-        break
-      case 'info':
-        this.logLevel = LogLevel.INFO
-        break
-      case 'debug':
-        this.logLevel = LogLevel.DEBUG
-        break
+      case "none":
+        this.logLevel = LogLevel.NONE;
+        break;
+      case "error":
+        this.logLevel = LogLevel.ERROR;
+        break;
+      case "warn":
+        this.logLevel = LogLevel.WARN;
+        break;
+      case "info":
+        this.logLevel = LogLevel.INFO;
+        break;
+      case "debug":
+        this.logLevel = LogLevel.DEBUG;
+        break;
       default:
         // Invalid log level, keep default
-        console.warn(`Invalid log level: ${level}. Using default (INFO).`)
+        console.warn(`Invalid log level: ${level}. Using default (INFO).`);
     }
   }
 
@@ -66,14 +66,14 @@ export class Logger {
    * Set the log level
    */
   public setLogLevel(level: LogLevel): void {
-    this.logLevel = level
+    this.logLevel = level;
   }
 
   /**
    * Get the current log level
    */
   public getLogLevel(): LogLevel {
-    return this.logLevel
+    return this.logLevel;
   }
 
   /**
@@ -82,9 +82,9 @@ export class Logger {
   public debug(message: string, ...args: any[]): void {
     if (this.logLevel >= LogLevel.DEBUG) {
       if (args.length > 0) {
-        console.log(chalk.yellow(`DEBUG: ${message}`), ...args)
+        console.log(chalk.yellow(`DEBUG: ${message}`), ...args);
       } else {
-        console.log(chalk.yellow(`DEBUG: ${message}`))
+        console.log(chalk.yellow(`DEBUG: ${message}`));
       }
     }
   }
@@ -95,9 +95,9 @@ export class Logger {
   public info(message: string, ...args: any[]): void {
     if (this.logLevel >= LogLevel.INFO) {
       if (args.length > 0) {
-        console.log(chalk.blue(message), ...args)
+        console.log(chalk.blue(message), ...args);
       } else {
-        console.log(chalk.blue(message))
+        console.log(chalk.blue(message));
       }
     }
   }
@@ -108,9 +108,9 @@ export class Logger {
   public warn(message: string, ...args: any[]): void {
     if (this.logLevel >= LogLevel.WARN) {
       if (args.length > 0) {
-        console.log(chalk.yellow(message), ...args)
+        console.log(chalk.yellow(message), ...args);
       } else {
-        console.log(chalk.yellow(message))
+        console.log(chalk.yellow(message));
       }
     }
   }
@@ -121,9 +121,9 @@ export class Logger {
   public error(message: string, ...args: any[]): void {
     if (this.logLevel >= LogLevel.ERROR) {
       if (args.length > 0) {
-        console.error(chalk.red(message), ...args)
+        console.error(chalk.red(message), ...args);
       } else {
-        console.error(chalk.red(message))
+        console.error(chalk.red(message));
       }
     }
   }
@@ -134,9 +134,9 @@ export class Logger {
   public success(message: string, ...args: any[]): void {
     if (this.logLevel >= LogLevel.INFO) {
       if (args.length > 0) {
-        console.log(chalk.green(message), ...args)
+        console.log(chalk.green(message), ...args);
       } else {
-        console.log(chalk.green(message))
+        console.log(chalk.green(message));
       }
     }
   }
@@ -147,13 +147,13 @@ export class Logger {
   public log(message: string, ...args: any[]): void {
     if (this.logLevel >= LogLevel.INFO) {
       if (args.length > 0) {
-        console.log(message, ...args)
+        console.log(message, ...args);
       } else {
-        console.log(message)
+        console.log(message);
       }
     }
   }
 }
 
 // Export a singleton instance for easy import
-export const logger = Logger.getInstance()
+export const logger = Logger.getInstance();

package/src/utils/markdown-renderer.ts

@@ -1,6 +1,6 @@
-import { marked } from 'marked'
-import TerminalRenderer from 'marked-terminal'
-import chalk from 'chalk'
+import { marked } from "marked";
+import TerminalRenderer from "marked-terminal";
+import chalk from "chalk";
 
 // Configure marked to use the terminal renderer
 marked.setOptions({
@@ -20,7 +20,7 @@ marked.setOptions({
     // Customize code block rendering
     codespan: chalk.cyan,
   }),
-})
+});
 
 /**
  * Render markdown text to terminal-friendly formatted text
@@ -28,15 +28,15 @@ marked.setOptions({
  * @returns Formatted text for terminal display
  */
 export function renderMarkdown(markdown: string): string {
-  if (!markdown) return ''
+  if (!markdown) return "";
 
   try {
     // Convert markdown to terminal-friendly text
-    return marked(markdown)
+    return marked(markdown);
   } catch (error) {
     // If rendering fails, return the original text
-    console.error(`Error rendering markdown: ${error}`)
-    return markdown
+    console.error(`Error rendering markdown: ${error}`);
+    return markdown;
   }
 }
 
@@ -46,7 +46,7 @@ export function renderMarkdown(markdown: string): string {
  * @returns True if the text contains markdown formatting
  */
 export function containsMarkdown(text: string): boolean {
-  if (!text) return false
+  if (!text) return false;
 
   // Check for common markdown patterns
   const markdownPatterns = [
@@ -62,7 +62,7 @@ export function containsMarkdown(text: string): boolean {
     /\|.*\|.*\|/, // Tables
     /^---+$/m, // Horizontal rules
     /^===+$/m, // Alternative headers
-  ]
+  ];
 
-  return markdownPatterns.some((pattern) => pattern.test(text))
+  return markdownPatterns.some(pattern => pattern.test(text));
 }

package/src/utils/opencode-validator.ts

@@ -1,20 +1,20 @@
-import Ajv from 'ajv'
-import addFormats from 'ajv-formats'
-import { readFileSync } from 'fs'
-import { join } from 'path'
-import { dirname } from 'path'
+import Ajv from "ajv";
+import addFormats from "ajv-formats";
+import { readFileSync } from "fs";
+import { join } from "path";
+import { dirname } from "path";
 
 // Load the official OpenCode JSON Schema
-const __dirname = dirname(__filename)
-const schemaPath = join(__dirname, '..', 'schemas', 'opencode-schema.json')
+const __dirname = dirname(__filename);
+const schemaPath = join(__dirname, "..", "schemas", "opencode-schema.json");
 
-let ajv: Ajv
-let openCodeSchema: any
-let validateFunction: any
+let ajv: Ajv;
+let openCodeSchema: any;
+let validateFunction: any;
 
 try {
-  const schemaContent = readFileSync(schemaPath, 'utf-8')
-  openCodeSchema = JSON.parse(schemaContent)
+  const schemaContent = readFileSync(schemaPath, "utf-8");
+  openCodeSchema = JSON.parse(schemaContent);
 
   // Initialize AJV with formats and options
   ajv = new Ajv({
@@ -23,48 +23,48 @@ try {
     strict: false,
     allowUnionTypes: true,
     removeAdditional: false,
-  })
+  });
 
   // Add JSON Schema formats
-  addFormats(ajv)
+  addFormats(ajv);
 
   // Compile the schema
-  validateFunction = ajv.compile(openCodeSchema)
+  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");
 }
 
-export type OpenCodeConfig = any
+export type OpenCodeConfig = any;
 
 /**
  * Validate OpenCode configuration against the official JSON Schema
  */
 export function validateOpenCodeConfig(config: any): {
-  valid: boolean
-  errors?: string[]
+  valid: boolean;
+  errors?: string[];
 } {
   try {
     if (!validateFunction) {
-      return { valid: false, errors: ['Schema validator not initialized'] }
+      return { valid: false, errors: ["Schema validator not initialized"] };
     }
 
-    const isValid = validateFunction(config)
+    const isValid = validateFunction(config);
 
     if (isValid) {
-      return { valid: true }
+      return { valid: true };
     } else {
       const errors = validateFunction.errors?.map((err: any) => {
-        const path = err.instancePath || err.schemaPath || 'root'
-        const message = err.message || 'Unknown error'
-        return `${path}: ${message}`
-      }) || ['Unknown validation error']
+        const path = err.instancePath || err.schemaPath || "root";
+        const message = err.message || "Unknown error";
+        return `${path}: ${message}`;
+      }) || ["Unknown validation error"];
 
-      return { valid: false, errors }
+      return { valid: false, errors };
     }
   } catch (error) {
-    console.error('Validation error:', error)
-    return { valid: false, errors: ['Validation process failed'] }
+    console.error("Validation error:", error);
+    return { valid: false, errors: ["Validation process failed"] };
   }
 }
 
@@ -72,63 +72,58 @@ export function validateOpenCodeConfig(config: any): {
  * Fix common OpenCode configuration issues
  */
 export function fixOpenCodeConfig(config: any): OpenCodeConfig {
-  const fixed = { ...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
+    fixed.tools.compact = true;
   }
 
   // Remove invalid properties
-  const invalidProps = ['maxTokens', 'contextWindow']
-  invalidProps.forEach((prop) => {
+  const invalidProps = ["maxTokens", "contextWindow"];
+  invalidProps.forEach(prop => {
     if (fixed[prop] !== undefined) {
-      console.warn(`⚠️  Removing invalid property: ${prop}`)
-      delete fixed[prop]
+      console.warn(`⚠️  Removing invalid property: ${prop}`);
+      delete fixed[prop];
     }
-  })
+  });
 
   // Fix provider models with invalid properties
   if (fixed.provider) {
     Object.values(fixed.provider).forEach((provider: any) => {
       if (provider?.models) {
         Object.values(provider.models).forEach((model: any) => {
-          if (model && typeof model === 'object') {
+          if (model && typeof model === "object") {
             // Move maxTokens/contextWindow to proper structure if needed
             if (model.maxTokens || model.contextWindow) {
-              if (!model.limit) model.limit = {}
+              if (!model.limit) model.limit = {};
 
               // Use the larger of maxTokens/contextWindow for context
-              const contextValues = [
-                model.maxTokens,
-                model.contextWindow,
-              ].filter(Boolean)
+              const contextValues = [model.maxTokens, model.contextWindow].filter(Boolean);
               if (contextValues.length > 0) {
-                const newContext = Math.max(...contextValues)
+                const newContext = Math.max(...contextValues);
                 if (!model.limit.context || newContext > model.limit.context) {
-                  model.limit.context = newContext
+                  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)
+                model.limit.output = Math.floor(model.limit.context / 4);
               }
 
-              delete model.maxTokens
-              delete model.contextWindow
-              console.warn(
-                '⚠️  Moved maxTokens/contextWindow to limit.context/output',
-              )
+              delete model.maxTokens;
+              delete model.contextWindow;
+              console.warn("⚠️  Moved maxTokens/contextWindow to limit.context/output");
             }
           }
-        })
+        });
       }
-    })
+    });
   }
 
-  return fixed
+  return fixed;
 }