berget 2.2.7 → 2.2.9

package/src/utils/env-manager.ts

@@ -1,15 +1,35 @@
-import fs from "fs";
-import path from "path";
-import { writeFile } from "fs/promises";
-import chalk from "chalk";
-import dotenv from "dotenv";
+import chalk from 'chalk';
+import dotenv from 'dotenv';
+import fs from 'node:fs';
+import { writeFile } from 'node:fs/promises';
+import path from 'node:path';
 
 export interface EnvUpdateOptions {
+  comment?: string;
   envPath?: string;
+  force?: boolean;
   key: string;
   value: string;
-  comment?: string;
-  force?: boolean;
+}
+
+/**
+ * Checks if a .env file exists and contains a specific key
+ */
+export function hasEnvKey(
+  environmentPath: string = path.join(process.cwd(), '.env'),
+  key: string,
+): boolean {
+  if (!fs.existsSync(environmentPath)) {
+    return false;
+  }
+
+  try {
+    const content = fs.readFileSync(environmentPath, 'utf8');
+    const parsed = dotenv.parse(content);
+    return key in parsed;
+  } catch {
+    return false;
+  }
 }
 
 /**
@@ -18,20 +38,20 @@ export interface EnvUpdateOptions {
  */
 export async function updateEnvFile(options: EnvUpdateOptions): Promise<boolean> {
   const {
-    envPath = path.join(process.cwd(), ".env"),
-    key,
-    value,
     comment,
+    envPath: environmentPath = path.join(process.cwd(), '.env'),
     force = false,
+    key,
+    value,
   } = options;
 
   try {
-    let existingContent = "";
+    let existingContent = '';
     let parsed: Record<string, string> = {};
 
     // Read existing .env file if it exists
-    if (fs.existsSync(envPath)) {
-      existingContent = fs.readFileSync(envPath, "utf8");
+    if (fs.existsSync(environmentPath)) {
+      existingContent = fs.readFileSync(environmentPath, 'utf8');
       parsed = dotenv.parse(existingContent);
     }
 
@@ -45,7 +65,7 @@ export async function updateEnvFile(options: EnvUpdateOptions): Promise<boolean>
     parsed[key] = value;
 
     // Generate new .env content
-    let newContent = "";
+    let newContent = '';
 
     // Add comment at the top if this is a new file
     if (!existingContent && comment) {
@@ -53,12 +73,12 @@ export async function updateEnvFile(options: EnvUpdateOptions): Promise<boolean>
     }
 
     // Convert parsed object back to .env format
-    for (const [envKey, envValue] of Object.entries(parsed)) {
-      newContent += `${envKey}=${envValue}\n`;
+    for (const [environmentKey, environmentValue] of Object.entries(parsed)) {
+      newContent += `${environmentKey}=${environmentValue}\n`;
     }
 
     // Write the updated content
-    await writeFile(envPath, newContent.trim() + "\n");
+    await writeFile(environmentPath, newContent.trim() + '\n');
 
     if (existingContent) {
       console.log(chalk.green(`✓ Updated .env with ${key}`));
@@ -72,23 +92,3 @@ export async function updateEnvFile(options: EnvUpdateOptions): Promise<boolean>
     throw error;
   }
 }
-
-/**
- * Checks if a .env file exists and contains a specific key
- */
-export function hasEnvKey(
-  envPath: string = path.join(process.cwd(), ".env"),
-  key: string
-): boolean {
-  if (!fs.existsSync(envPath)) {
-    return false;
-  }
-
-  try {
-    const content = fs.readFileSync(envPath, "utf8");
-    const parsed = dotenv.parse(content);
-    return key in parsed;
-  } catch {
-    return false;
-  }
-}

package/src/utils/error-handler.ts

@@ -1,4 +1,4 @@
-import chalk from "chalk";
+import chalk from 'chalk';
 
 /**
  * Formats and prints error messages in a consistent way
@@ -6,19 +6,19 @@ import chalk from "chalk";
 export function handleError(message: string, error: any): void {
   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);
       if (parsedError.error) {
         errorDetails = parsedError.error.message || parsedError.error;
         errorCode = parsedError.error.code || parsedError.code;
-        errorType = parsedError.error.type || "";
+        errorType = parsedError.error.type || '';
       } else {
         errorDetails = error;
       }
@@ -51,101 +51,101 @@ export function handleError(message: string, error: any): void {
 function provideTroubleshootingTips(
   errorType: string,
   errorCode: string,
-  errorDetails: string
+  errorDetails: string,
 ): void {
-  console.error(chalk.blue("\n💡 Troubleshooting tips:"));
+  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.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"`')
+      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.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 && parseInt(errorCode) >= 500)
+    errorCode?.includes('SERVER_ERROR') ||
+    errorType === 'server_error' ||
+    (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
   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")
+    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
@@ -22,9 +22,9 @@ export class Logger {
     // 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")) {
+    } else if (process.argv.includes('--debug')) {
       this.logLevel = LogLevel.DEBUG;
-    } else if (process.argv.includes("--quiet")) {
+    } else if (process.argv.includes('--quiet')) {
       this.logLevel = LogLevel.ERROR;
     }
   }
@@ -37,36 +37,29 @@ export class Logger {
   }
 
   /**
-   * 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));
+      }
+    }
   }
 
   /**
@@ -77,79 +70,92 @@ export class Logger {
   }
 
   /**
-   * 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).`);
       }
     }
   }

package/src/utils/markdown-renderer.ts

@@ -1,45 +1,27 @@
-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
  * @param text The text to check
@@ -64,5 +46,23 @@ export function containsMarkdown(text: string): boolean {
     /^===+$/m, // Alternative headers
   ];
 
-  return markdownPatterns.some(pattern => pattern.test(text));
+  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 '';
+
+  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;
+  }
 }