berget 1.2.0 → 1.3.1

package/src/utils/default-api-key.ts

@@ -4,6 +4,7 @@ import * as os from 'os'
 import chalk from 'chalk'
 import { ApiKeyService } from '../services/api-key-service'
 import readline from 'readline'
+import { logger } from './logger'
 
 interface DefaultApiKeyData {
   id: string
@@ -47,9 +48,7 @@ export class DefaultApiKeyManager {
         this.defaultApiKey = JSON.parse(data)
       }
     } catch (error) {
-      if (process.argv.includes('--debug')) {
-        console.error(chalk.dim('Failed to load default API key configuration'))
-      }
+      logger.debug('Failed to load default API key configuration')
       this.defaultApiKey = null
     }
   }
@@ -70,9 +69,7 @@ export class DefaultApiKeyManager {
         }
       }
     } catch (error) {
-      if (process.argv.includes('--debug')) {
-        console.error(chalk.dim('Failed to save default API key configuration'))
-      }
+      logger.debug('Failed to save default API key configuration')
     }
   }
   
@@ -112,42 +109,30 @@ export class DefaultApiKeyManager {
    */
   public async promptForDefaultApiKey(): Promise<string | null> {
     try {
-      const isDebug = process.argv.includes('--debug')
-      
-      if (isDebug) {
-        console.log(chalk.yellow('DEBUG: promptForDefaultApiKey called'))
-      }
+      logger.debug('promptForDefaultApiKey called')
       
       // If we already have a default API key, return it
       if (this.defaultApiKey) {
-        if (isDebug) {
-          console.log(chalk.yellow('DEBUG: Using existing default API key'))
-        }
+        logger.debug('Using existing default API key')
         return this.defaultApiKey.key
       }
 
-      if (isDebug) {
-        console.log(chalk.yellow('DEBUG: No default API key found, getting ApiKeyService'))
-      }
+      logger.debug('No default API key found, getting ApiKeyService')
       
       const apiKeyService = ApiKeyService.getInstance()
       
       // Get all API keys
       let apiKeys;
       try {
-        if (isDebug) {
-          console.log(chalk.yellow('DEBUG: Calling apiKeyService.list()'))
-        }
+        logger.debug('Calling apiKeyService.list()')
         
         apiKeys = await apiKeyService.list()
         
-        if (isDebug) {
-          console.log(chalk.yellow(`DEBUG: Got ${apiKeys ? apiKeys.length : 0} API keys`))
-        }
+        logger.debug(`Got ${apiKeys ? apiKeys.length : 0} API keys`)
         
         if (!apiKeys || apiKeys.length === 0) {
-          console.log(chalk.yellow('No API keys found. Create one with:'))
-          console.log(chalk.blue('  berget api-keys create --name "My Key"'))
+          logger.warn('No API keys found. Create one with:')
+          logger.info('  berget api-keys create --name "My Key"')
           return null
         }
       } catch (error) {
@@ -158,25 +143,23 @@ export class DefaultApiKeyManager {
                            errorMessage.includes('AUTH_FAILED');
         
         if (isAuthError) {
-          console.log(chalk.yellow('Authentication required. Please run `berget auth login` first.'));
+          logger.warn('Authentication required. Please run `berget auth login` first.');
         } else {
-          console.log(chalk.red('Error fetching API keys:'));
+          logger.error('Error fetching API keys:');
           if (error instanceof Error) {
-            console.log(chalk.red(error.message));
-            if (isDebug) {
-              console.log(chalk.yellow(`DEBUG: API key list error: ${error.message}`));
-              console.log(chalk.yellow(`DEBUG: Stack: ${error.stack}`));
-            }
+            logger.error(error.message);
+            logger.debug(`API key list error: ${error.message}`);
+            logger.debug(`Stack: ${error.stack}`);
           }
         }
         return null;
       }
       
-      console.log(chalk.blue('Select an API key to use as default:'))
+      logger.info('Select an API key to use as default:')
       
       // Display available API keys
       apiKeys.forEach((key, index) => {
-        console.log(`  ${index + 1}. ${key.name} (${key.prefix}...)`)
+        logger.log(`  ${index + 1}. ${key.name} (${key.prefix}...)`)
       })
       
       // Create readline interface for user input
@@ -199,7 +182,7 @@ export class DefaultApiKeyManager {
       })
       
       if (selection === -1) {
-        console.log(chalk.yellow('No API key selected'))
+        logger.warn('No API key selected')
         return null
       }
       
@@ -219,10 +202,10 @@ export class DefaultApiKeyManager {
         newKey.key
       )
       
-      console.log(chalk.green(`✓ Default API key set to: ${newKey.name}`))
+      logger.success(`✓ Default API key set to: ${newKey.name}`)
       return newKey.key
     } catch (error) {
-      console.error(chalk.red('Failed to set default API key:'), error)
+      logger.error('Failed to set default API key:', error)
       return null
     }
   }

package/src/utils/logger.ts

@@ -0,0 +1,159 @@
+import chalk from 'chalk'
+
+/**
+ * Log levels in order of increasing verbosity
+ */
+export enum LogLevel {
+  NONE = 0,
+  ERROR = 1,
+  WARN = 2,
+  INFO = 3,
+  DEBUG = 4
+}
+
+/**
+ * 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 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
+    }
+  }
+  
+  public static getInstance(): Logger {
+    if (!Logger.instance) {
+      Logger.instance = new Logger()
+    }
+    return Logger.instance
+  }
+  
+  /**
+   * Set the log level from a string
+   */
+  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).`)
+    }
+  }
+  
+  /**
+   * Set the log level
+   */
+  public setLogLevel(level: LogLevel): void {
+    this.logLevel = level
+  }
+  
+  /**
+   * Get the current log level
+   */
+  public getLogLevel(): LogLevel {
+    return this.logLevel
+  }
+  
+  /**
+   * Log a debug message (only shown at DEBUG level)
+   */
+  public debug(message: string, ...args: any[]): void {
+    if (this.logLevel >= LogLevel.DEBUG) {
+      if (args.length > 0) {
+        console.log(chalk.yellow(`DEBUG: ${message}`), ...args)
+      } else {
+        console.log(chalk.yellow(`DEBUG: ${message}`))
+      }
+    }
+  }
+  
+  /**
+   * Log an info message (shown at INFO level and above)
+   */
+  public info(message: string, ...args: any[]): void {
+    if (this.logLevel >= LogLevel.INFO) {
+      if (args.length > 0) {
+        console.log(chalk.blue(message), ...args)
+      } else {
+        console.log(chalk.blue(message))
+      }
+    }
+  }
+  
+  /**
+   * Log a warning message (shown at WARN level and above)
+   */
+  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))
+      }
+    }
+  }
+  
+  /**
+   * Log an error message (shown at ERROR 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)
+      } else {
+        console.error(chalk.red(message))
+      }
+    }
+  }
+  
+  /**
+   * Log a success message (shown at INFO 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)
+      } else {
+        console.log(chalk.green(message))
+      }
+    }
+  }
+  
+  /**
+   * Log a plain message without color (shown at INFO level and above)
+   */
+  public log(message: string, ...args: any[]): void {
+    if (this.logLevel >= LogLevel.INFO) {
+      if (args.length > 0) {
+        console.log(message, ...args)
+      } else {
+        console.log(message)
+      }
+    }
+  }
+}
+
+// Export a singleton instance for easy import
+export const logger = Logger.getInstance()

package/src/utils/markdown-renderer.ts

@@ -0,0 +1,68 @@
+import { marked } from 'marked'
+import TerminalRenderer from 'marked-terminal'
+import chalk from 'chalk'
+
+// Configure marked to use the terminal renderer
+marked.setOptions({
+  renderer: new TerminalRenderer({
+    // Customize the rendering options
+    code: chalk.cyan,
+    blockquote: chalk.gray.italic,
+    table: chalk.white,
+    listitem: chalk.yellow,
+    strong: chalk.bold,
+    em: chalk.italic,
+    heading: chalk.bold.blueBright,
+    hr: chalk.gray,
+    link: chalk.blue.underline,
+    // 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
+ * @param text The text to check
+ * @returns True if the text contains markdown formatting
+ */
+export function containsMarkdown(text: string): boolean {
+  if (!text) return false
+  
+  // Check for common markdown patterns
+  const markdownPatterns = [
+    /^#+\s+/m,                // Headers
+    /\*\*.*?\*\*/,            // Bold
+    /\*.*?\*/,                // Italic
+    /`.*?`/,                  // Inline code
+    /```[\s\S]*?```/,         // Code blocks
+    /\[.*?\]\(.*?\)/,         // Links
+    /^\s*[-*+]\s+/m,          // Lists
+    /^\s*\d+\.\s+/m,          // Numbered lists
+    /^\s*>\s+/m,              // Blockquotes
+    /\|.*\|.*\|/,             // Tables
+    /^---+$/m,                // Horizontal rules
+    /^===+$/m                 // Alternative headers
+  ]
+  
+  return markdownPatterns.some(pattern => pattern.test(text))
+}

package/src/utils/token-manager.ts

@@ -2,6 +2,7 @@ import * as fs from 'fs'
 import * as path from 'path'
 import * as os from 'os'
 import chalk from 'chalk'
+import { logger } from './logger'
 
 interface TokenData {
   access_token: string
@@ -44,7 +45,7 @@ export class TokenManager {
         this.tokenData = JSON.parse(data)
       }
     } catch (error) {
-      console.error(chalk.dim('Failed to load authentication token'))
+      logger.error('Failed to load authentication token')
       this.tokenData = null
     }
   }
@@ -65,7 +66,7 @@ export class TokenManager {
         }
       }
     } catch (error) {
-      console.error(chalk.dim('Failed to save authentication token'))
+      logger.error('Failed to save authentication token')
     }
   }
   
@@ -100,14 +101,14 @@ export class TokenManager {
       const expirationBuffer = 10 * 60 * 1000 // 10 minutes in milliseconds
       const isExpired = Date.now() + expirationBuffer >= this.tokenData.expires_at;
       
-      if (isExpired && process.argv.includes('--debug')) {
-        console.log(chalk.yellow(`DEBUG: Token expired or expiring soon. Current time: ${new Date().toISOString()}, Expiry: ${new Date(this.tokenData.expires_at).toISOString()}`));
+      if (isExpired) {
+        logger.debug(`Token expired or expiring soon. Current time: ${new Date().toISOString()}, Expiry: ${new Date(this.tokenData.expires_at).toISOString()}`);
       }
       
       return isExpired;
     } catch (error) {
       // If there's any error checking expiration, assume token is expired
-      console.error(chalk.dim(`Error checking token expiration: ${error instanceof Error ? error.message : String(error)}`));
+      logger.error(`Error checking token expiration: ${error instanceof Error ? error.message : String(error)}`);
       return true;
     }
   }