berget 2.2.6 → 2.2.8

package/src/utils/error-handler.ts

@@ -1,55 +1,59 @@
-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') {
     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 (
@@ -58,10 +62,10 @@ function provideTroubleshootingTips(errorType: string, errorCode: string, errorD
     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
@@ -71,11 +75,11 @@ function provideTroubleshootingTips(errorType: string, errorCode: string, errorD
     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
@@ -84,11 +88,13 @@ function provideTroubleshootingTips(errorType: string, errorCode: string, errorD
     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
@@ -97,34 +103,31 @@ function provideTroubleshootingTips(errorType: string, errorCode: string, errorD
     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 && parseInt(errorCode) >= 500)
+    (errorCode && Number.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
@@ -136,11 +139,13 @@ function provideTroubleshootingTips(errorType: string, errorCode: string, errorD
     !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,145 +15,151 @@ 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)
+      this.setLogLevelFromString(process.env.LOG_LEVEL);
     } else if (process.argv.includes('--debug')) {
-      this.logLevel = LogLevel.DEBUG
+      this.logLevel = LogLevel.DEBUG;
     } else if (process.argv.includes('--quiet')) {
-      this.logLevel = LogLevel.ERROR
+      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;
   }
 
   /**
-   * Set the log level from a string
+   * Log a debug message (only shown at DEBUG level)
    */
-  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
-      default:
-        // Invalid log level, keep default
-        console.warn(`Invalid log level: ${level}. Using default (INFO).`)
+  public debug(message: string, ...arguments_: any[]): void {
+    if (this.logLevel >= LogLevel.DEBUG) {
+      if (arguments_.length > 0) {
+        console.log(chalk.yellow(`DEBUG: ${message}`), ...arguments_);
+      } else {
+        console.log(chalk.yellow(`DEBUG: ${message}`));
+      }
     }
   }
 
   /**
-   * Set the log level
+   * Log an error message (shown at ERROR level and above)
    */
-  public setLogLevel(level: LogLevel): void {
-    this.logLevel = level
+  public error(message: string, ...arguments_: any[]): void {
+    if (this.logLevel >= LogLevel.ERROR) {
+      if (arguments_.length > 0) {
+        console.error(chalk.red(message), ...arguments_);
+      } else {
+        console.error(chalk.red(message));
+      }
+    }
   }
 
   /**
    * Get the current log level
    */
   public getLogLevel(): LogLevel {
-    return this.logLevel
+    return this.logLevel;
   }
 
   /**
-   * Log a debug message (only shown at DEBUG level)
+   * Log an info message (shown at INFO level and above)
    */
-  public debug(message: string, ...args: any[]): void {
-    if (this.logLevel >= LogLevel.DEBUG) {
-      if (args.length > 0) {
-        console.log(chalk.yellow(`DEBUG: ${message}`), ...args)
+  public info(message: string, ...arguments_: any[]): void {
+    if (this.logLevel >= LogLevel.INFO) {
+      if (arguments_.length > 0) {
+        console.log(chalk.blue(message), ...arguments_);
       } else {
-        console.log(chalk.yellow(`DEBUG: ${message}`))
+        console.log(chalk.blue(message));
       }
     }
   }
 
   /**
-   * Log an info message (shown at INFO level and above)
+   * Log a plain message without color (shown at INFO level and above)
    */
-  public info(message: string, ...args: any[]): void {
+  public log(message: string, ...arguments_: any[]): void {
     if (this.logLevel >= LogLevel.INFO) {
-      if (args.length > 0) {
-        console.log(chalk.blue(message), ...args)
+      if (arguments_.length > 0) {
+        console.log(message, ...arguments_);
       } else {
-        console.log(chalk.blue(message))
+        console.log(message);
       }
     }
   }
 
   /**
-   * Log a warning message (shown at WARN level and above)
+   * Set the log level
    */
-  public warn(message: string, ...args: any[]): void {
-    if (this.logLevel >= LogLevel.WARN) {
-      if (args.length > 0) {
-        console.log(chalk.yellow(message), ...args)
-      } else {
-        console.log(chalk.yellow(message))
-      }
-    }
+  public setLogLevel(level: LogLevel): void {
+    this.logLevel = level;
   }
 
   /**
-   * Log an error message (shown at ERROR level and above)
+   * Log a success message (shown at INFO level and above)
    */
-  public error(message: string, ...args: any[]): void {
-    if (this.logLevel >= LogLevel.ERROR) {
-      if (args.length > 0) {
-        console.error(chalk.red(message), ...args)
+  public success(message: string, ...arguments_: any[]): void {
+    if (this.logLevel >= LogLevel.INFO) {
+      if (arguments_.length > 0) {
+        console.log(chalk.green(message), ...arguments_);
       } else {
-        console.error(chalk.red(message))
+        console.log(chalk.green(message));
       }
     }
   }
 
   /**
-   * Log a success message (shown at INFO level and above)
+   * Log a warning message (shown at WARN level and above)
    */
-  public success(message: string, ...args: any[]): void {
-    if (this.logLevel >= LogLevel.INFO) {
-      if (args.length > 0) {
-        console.log(chalk.green(message), ...args)
+  public warn(message: string, ...arguments_: any[]): void {
+    if (this.logLevel >= LogLevel.WARN) {
+      if (arguments_.length > 0) {
+        console.log(chalk.yellow(message), ...arguments_);
       } else {
-        console.log(chalk.green(message))
+        console.log(chalk.yellow(message));
       }
     }
   }
 
   /**
-   * Log a plain message without color (shown at INFO level and above)
+   * Set the log level from a string
    */
-  public log(message: string, ...args: any[]): void {
-    if (this.logLevel >= LogLevel.INFO) {
-      if (args.length > 0) {
-        console.log(message, ...args)
-      } else {
-        console.log(message)
+  private setLogLevelFromString(level: string): void {
+    switch (level.toLowerCase()) {
+      case 'debug': {
+        this.logLevel = LogLevel.DEBUG;
+        break;
+      }
+      case 'error': {
+        this.logLevel = LogLevel.ERROR;
+        break;
+      }
+      case 'info': {
+        this.logLevel = LogLevel.INFO;
+        break;
+      }
+      case 'none': {
+        this.logLevel = LogLevel.NONE;
+        break;
+      }
+      case 'warn': {
+        this.logLevel = LogLevel.WARN;
+        break;
+      }
+      default: {
+        // Invalid log level, keep default
+        console.warn(`Invalid log level: ${level}. Using default (INFO).`);
       }
     }
   }
 }
 
 // Export a singleton instance for easy import
-export const logger = Logger.getInstance()
+export const logger = Logger.getInstance();

package/src/utils/markdown-renderer.ts

@@ -1,44 +1,26 @@
-import { marked } from 'marked'
-import TerminalRenderer from 'marked-terminal'
-import chalk from 'chalk'
+import chalk from 'chalk';
+import { marked } from 'marked';
+import TerminalRenderer from 'marked-terminal';
 
 // Configure marked to use the terminal renderer
 marked.setOptions({
   renderer: new TerminalRenderer({
+    blockquote: chalk.gray.italic,
     // Customize the rendering options
     code: chalk.cyan,
-    blockquote: chalk.gray.italic,
-    table: chalk.white,
-    listitem: chalk.yellow,
-    strong: chalk.bold,
+    // Customize code block rendering
+    codespan: chalk.cyan,
     em: chalk.italic,
     heading: chalk.bold.blueBright,
     hr: chalk.gray,
     link: chalk.blue.underline,
+    listitem: chalk.yellow,
+    strong: chalk.bold,
+    table: chalk.white,
     // Adjust the width to fit the terminal
     width: process.stdout.columns || 80,
-    // Customize code block rendering
-    codespan: chalk.cyan,
   }),
-})
-
-/**
- * Render markdown text to terminal-friendly formatted text
- * @param markdown The markdown text to render
- * @returns Formatted text for terminal display
- */
-export function renderMarkdown(markdown: string): string {
-  if (!markdown) return ''
-
-  try {
-    // Convert markdown to terminal-friendly text
-    return marked(markdown)
-  } catch (error) {
-    // If rendering fails, return the original text
-    console.error(`Error rendering markdown: ${error}`)
-    return markdown
-  }
-}
+});
 
 /**
  * Check if a string contains markdown formatting
@@ -46,7 +28,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 +44,25 @@ export function containsMarkdown(text: string): boolean {
     /\|.*\|.*\|/, // Tables
     /^---+$/m, // Horizontal rules
     /^===+$/m, // Alternative headers
-  ]
+  ];
+
+  return markdownPatterns.some((pattern) => pattern.test(text));
+}
+
+/**
+ * Render markdown text to terminal-friendly formatted text
+ * @param markdown The markdown text to render
+ * @returns Formatted text for terminal display
+ */
+export function renderMarkdown(markdown: string): string {
+  if (!markdown) return '';
 
-  return markdownPatterns.some((pattern) => pattern.test(text))
+  try {
+    // Convert markdown to terminal-friendly text
+    return marked(markdown);
+  } catch (error) {
+    // If rendering fails, return the original text
+    console.error(`Error rendering markdown: ${error}`);
+    return markdown;
+  }
 }