berget 1.2.0 → 1.3.1

package/dist/src/utils/logger.js

@@ -0,0 +1,160 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = exports.Logger = exports.LogLevel = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+/**
+ * Log levels in order of increasing verbosity
+ */
+var LogLevel;
+(function (LogLevel) {
+    LogLevel[LogLevel["NONE"] = 0] = "NONE";
+    LogLevel[LogLevel["ERROR"] = 1] = "ERROR";
+    LogLevel[LogLevel["WARN"] = 2] = "WARN";
+    LogLevel[LogLevel["INFO"] = 3] = "INFO";
+    LogLevel[LogLevel["DEBUG"] = 4] = "DEBUG";
+})(LogLevel || (exports.LogLevel = LogLevel = {}));
+/**
+ * Logger class for centralized logging with configurable log levels
+ */
+class Logger {
+    constructor() {
+        this.logLevel = LogLevel.INFO; // Default log level
+        // 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;
+        }
+    }
+    static getInstance() {
+        if (!Logger.instance) {
+            Logger.instance = new Logger();
+        }
+        return Logger.instance;
+    }
+    /**
+     * Set the log level from a string
+     */
+    setLogLevelFromString(level) {
+        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
+     */
+    setLogLevel(level) {
+        this.logLevel = level;
+    }
+    /**
+     * Get the current log level
+     */
+    getLogLevel() {
+        return this.logLevel;
+    }
+    /**
+     * Log a debug message (only shown at DEBUG level)
+     */
+    debug(message, ...args) {
+        if (this.logLevel >= LogLevel.DEBUG) {
+            if (args.length > 0) {
+                console.log(chalk_1.default.yellow(`DEBUG: ${message}`), ...args);
+            }
+            else {
+                console.log(chalk_1.default.yellow(`DEBUG: ${message}`));
+            }
+        }
+    }
+    /**
+     * Log an info message (shown at INFO level and above)
+     */
+    info(message, ...args) {
+        if (this.logLevel >= LogLevel.INFO) {
+            if (args.length > 0) {
+                console.log(chalk_1.default.blue(message), ...args);
+            }
+            else {
+                console.log(chalk_1.default.blue(message));
+            }
+        }
+    }
+    /**
+     * Log a warning message (shown at WARN level and above)
+     */
+    warn(message, ...args) {
+        if (this.logLevel >= LogLevel.WARN) {
+            if (args.length > 0) {
+                console.log(chalk_1.default.yellow(message), ...args);
+            }
+            else {
+                console.log(chalk_1.default.yellow(message));
+            }
+        }
+    }
+    /**
+     * Log an error message (shown at ERROR level and above)
+     */
+    error(message, ...args) {
+        if (this.logLevel >= LogLevel.ERROR) {
+            if (args.length > 0) {
+                console.error(chalk_1.default.red(message), ...args);
+            }
+            else {
+                console.error(chalk_1.default.red(message));
+            }
+        }
+    }
+    /**
+     * Log a success message (shown at INFO level and above)
+     */
+    success(message, ...args) {
+        if (this.logLevel >= LogLevel.INFO) {
+            if (args.length > 0) {
+                console.log(chalk_1.default.green(message), ...args);
+            }
+            else {
+                console.log(chalk_1.default.green(message));
+            }
+        }
+    }
+    /**
+     * Log a plain message without color (shown at INFO level and above)
+     */
+    log(message, ...args) {
+        if (this.logLevel >= LogLevel.INFO) {
+            if (args.length > 0) {
+                console.log(message, ...args);
+            }
+            else {
+                console.log(message);
+            }
+        }
+    }
+}
+exports.Logger = Logger;
+// Export a singleton instance for easy import
+exports.logger = Logger.getInstance();

package/dist/src/utils/markdown-renderer.js

@@ -0,0 +1,73 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.containsMarkdown = exports.renderMarkdown = void 0;
+const marked_1 = require("marked");
+const marked_terminal_1 = __importDefault(require("marked-terminal"));
+const chalk_1 = __importDefault(require("chalk"));
+// Configure marked to use the terminal renderer
+marked_1.marked.setOptions({
+    renderer: new marked_terminal_1.default({
+        // Customize the rendering options
+        code: chalk_1.default.cyan,
+        blockquote: chalk_1.default.gray.italic,
+        table: chalk_1.default.white,
+        listitem: chalk_1.default.yellow,
+        strong: chalk_1.default.bold,
+        em: chalk_1.default.italic,
+        heading: chalk_1.default.bold.blueBright,
+        hr: chalk_1.default.gray,
+        link: chalk_1.default.blue.underline,
+        // Adjust the width to fit the terminal
+        width: process.stdout.columns || 80,
+        // Customize code block rendering
+        codespan: chalk_1.default.cyan
+    })
+});
+/**
+ * Render markdown text to terminal-friendly formatted text
+ * @param markdown The markdown text to render
+ * @returns Formatted text for terminal display
+ */
+function renderMarkdown(markdown) {
+    if (!markdown)
+        return '';
+    try {
+        // Convert markdown to terminal-friendly text
+        return (0, marked_1.marked)(markdown);
+    }
+    catch (error) {
+        // If rendering fails, return the original text
+        console.error(`Error rendering markdown: ${error}`);
+        return markdown;
+    }
+}
+exports.renderMarkdown = renderMarkdown;
+/**
+ * Check if a string contains markdown formatting
+ * @param text The text to check
+ * @returns True if the text contains markdown formatting
+ */
+function containsMarkdown(text) {
+    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));
+}
+exports.containsMarkdown = containsMarkdown;

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

@@ -22,15 +22,12 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": 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 chalk_1 = __importDefault(require("chalk"));
+const logger_1 = require("./logger");
 /**
  * Manages authentication tokens including refresh functionality
  */
@@ -62,7 +59,7 @@ class TokenManager {
             }
         }
         catch (error) {
-            console.error(chalk_1.default.dim('Failed to load authentication token'));
+            logger_1.logger.error('Failed to load authentication token');
             this.tokenData = null;
         }
     }
@@ -84,7 +81,7 @@ class TokenManager {
             }
         }
         catch (error) {
-            console.error(chalk_1.default.dim('Failed to save authentication token'));
+            logger_1.logger.error('Failed to save authentication token');
         }
     }
     /**
@@ -117,14 +114,14 @@ class TokenManager {
             // Using a larger buffer to be more proactive about refreshing
             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_1.default.yellow(`DEBUG: Token expired or expiring soon. Current time: ${new Date().toISOString()}, Expiry: ${new Date(this.tokenData.expires_at).toISOString()}`));
+            if (isExpired) {
+                logger_1.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_1.default.dim(`Error checking token expiration: ${error instanceof Error ? error.message : String(error)}`));
+            logger_1.logger.error(`Error checking token expiration: ${error instanceof Error ? error.message : String(error)}`);
             return true;
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "berget",
-  "version": "1.2.0",
+  "version": "1.3.1",
   "main": "dist/index.js",
   "bin": {
     "berget": "dist/index.js"
@@ -19,6 +19,8 @@
   "license": "MIT",
   "description": "This is a cli command for interacting with the AI infrastructure provider Berget",
   "devDependencies": {
+    "@types/marked": "^5.0.2",
+    "@types/marked-terminal": "^6.1.1",
     "@types/node": "^20.11.20",
     "tsx": "^4.19.3",
     "typescript": "^5.3.3"
@@ -27,6 +29,8 @@
     "chalk": "^4.1.2",
     "commander": "^12.0.0",
     "fs-extra": "^11.3.0",
+    "marked": "^9.1.6",
+    "marked-terminal": "^6.2.0",
     "open": "^9.1.0",
     "openapi-fetch": "^0.9.1",
     "openapi-typescript": "^6.7.4",

package/src/client.ts

@@ -5,16 +5,17 @@ import * as path from 'path'
 import * as os from 'os'
 import chalk from 'chalk'
 import { TokenManager } from './utils/token-manager'
+import { logger } from './utils/logger'
 
 // API Base URL
 // Use --local flag to test against local API
 const isLocalMode = process.argv.includes('--local')
-const API_BASE_URL =
+export const API_BASE_URL =
   process.env.BERGET_API_URL ||
   (isLocalMode ? 'http://localhost:3000' : 'https://api.berget.ai')
 
-if (isLocalMode && !process.env.BERGET_API_URL && process.argv.includes('--debug')) {
-  console.log(chalk.yellow('Using local API endpoint: http://localhost:3000'))
+if (isLocalMode && !process.env.BERGET_API_URL) {
+  logger.debug('Using local API endpoint: http://localhost:3000')
 }
 
 // Create a typed client for the Berget API
@@ -50,11 +51,9 @@ export const clearAuthToken = (): void => {
 export const createAuthenticatedClient = () => {
   const tokenManager = TokenManager.getInstance()
 
-  if (!tokenManager.getAccessToken() && process.argv.includes('--debug')) {
-    console.warn(
-      chalk.yellow(
-        'No authentication token found. Please run `berget auth login` first.'
-      )
+  if (!tokenManager.getAccessToken()) {
+    logger.debug(
+      'No authentication token found. Please run `berget auth login` first.'
     )
   }
 
@@ -88,7 +87,10 @@ export const createAuthenticatedClient = () => {
           }
 
           // Update the Authorization header with the current token
-          if (tokenManager.getAccessToken()) {
+          if (
+            !args[1]?.headers?.Authorization &&
+            tokenManager.getAccessToken()
+          ) {
             if (!args[1]) args[1] = {}
             if (!args[1].headers) args[1].headers = {}
             args[1].headers.Authorization = `Bearer ${tokenManager.getAccessToken()}`
@@ -101,17 +103,13 @@ export const createAuthenticatedClient = () => {
               ...args
             )
           } catch (requestError) {
-            if (process.argv.includes('--debug')) {
-              console.log(
-                chalk.red(
-                  `DEBUG: Request error: ${
-                    requestError instanceof Error
-                      ? requestError.message
-                      : String(requestError)
-                  }`
-                )
-              )
-            }
+            logger.debug(
+              `Request error: ${
+                requestError instanceof Error
+                  ? requestError.message
+                  : String(requestError)
+              }`
+            )
             return {
               error: {
                 message: `Request failed: ${
@@ -126,66 +124,59 @@ export const createAuthenticatedClient = () => {
           // If we get an auth error, try to refresh the token and retry
           if (result.error) {
             // Detect various forms of authentication errors
-            let isAuthError = false;
-            
+            let isAuthError = false
+
             try {
               // Standard 401 Unauthorized
-              if (typeof result.error === 'object' && result.error.status === 401) {
-                isAuthError = true;
+              if (
+                typeof result.error === 'object' &&
+                result.error.status === 401
+              ) {
+                isAuthError = true
               }
               // OAuth specific errors
-              else if (result.error.error &&
+              else if (
+                result.error.error &&
                 (result.error.error.code === 'invalid_token' ||
-                 result.error.error.code === 'token_expired' ||
-                 result.error.error.message === 'Invalid API key' ||
-                 result.error.error.message?.toLowerCase().includes('token') ||
-                 result.error.error.message?.toLowerCase().includes('unauthorized'))) {
-                isAuthError = true;
+                  result.error.error.code === 'token_expired' ||
+                  result.error.error.message === 'Invalid API key' ||
+                  result.error.error.message?.toLowerCase().includes('token') ||
+                  result.error.error.message
+                    ?.toLowerCase()
+                    .includes('unauthorized'))
+              ) {
+                isAuthError = true
               }
               // Message-based detection as fallback
-              else if (typeof result.error === 'string' && 
+              else if (
+                typeof result.error === 'string' &&
                 (result.error.toLowerCase().includes('unauthorized') ||
-                 result.error.toLowerCase().includes('token') ||
-                 result.error.toLowerCase().includes('auth'))) {
-                isAuthError = true;
+                  result.error.toLowerCase().includes('token') ||
+                  result.error.toLowerCase().includes('auth'))
+              ) {
+                isAuthError = true
               }
             } catch (parseError) {
               // If we can't parse the error structure, do a simple string check
-              const errorStr = String(result.error);
-              if (errorStr.toLowerCase().includes('unauthorized') ||
-                  errorStr.toLowerCase().includes('token') ||
-                  errorStr.toLowerCase().includes('auth')) {
-                isAuthError = true;
+              const errorStr = String(result.error)
+              if (
+                errorStr.toLowerCase().includes('unauthorized') ||
+                errorStr.toLowerCase().includes('token') ||
+                errorStr.toLowerCase().includes('auth')
+              ) {
+                isAuthError = true
               }
             }
 
             if (isAuthError && tokenManager.getRefreshToken()) {
-              if (process.argv.includes('--debug')) {
-                console.log(
-                  chalk.yellow(
-                    'DEBUG: Auth error detected, attempting token refresh'
-                  )
-                )
-                console.log(
-                  chalk.yellow(
-                    `DEBUG: Error details: ${JSON.stringify(
-                      result.error,
-                      null,
-                      2
-                    )}`
-                  )
-                )
-              }
+              logger.debug('Auth error detected, attempting token refresh')
+              logger.debug(
+                `Error details: ${JSON.stringify(result.error, null, 2)}`
+              )
 
               const refreshed = await refreshAccessToken(tokenManager)
               if (refreshed) {
-                if (process.argv.includes('--debug')) {
-                  console.log(
-                    chalk.green(
-                      'DEBUG: Token refreshed successfully, retrying request'
-                    )
-                  )
-                }
+                logger.debug('Token refreshed successfully, retrying request')
 
                 // Update the Authorization header with the new token
                 if (!args[1]) args[1] = {}
@@ -197,13 +188,12 @@ export const createAuthenticatedClient = () => {
                   ...args
                 )
               } else {
-                if (process.argv.includes('--debug')) {
-                  console.log(chalk.red('DEBUG: Token refresh failed'))
-                }
-                
+                logger.debug('Token refresh failed')
+
                 // Add a more helpful error message for users
                 if (typeof result.error === 'object') {
-                  result.error.userMessage = 'Your session has expired. Please run `berget auth login` to log in again.'
+                  result.error.userMessage =
+                    'Your session has expired. Please run `berget auth login` to log in again.'
                 }
               }
             }
@@ -227,9 +217,7 @@ async function refreshAccessToken(
     const refreshToken = tokenManager.getRefreshToken()
     if (!refreshToken) return false
 
-    if (process.argv.includes('--debug')) {
-      console.log(chalk.yellow('DEBUG: Attempting to refresh access token'))
-    }
+    logger.debug('Attempting to refresh access token')
 
     // Use fetch directly since this endpoint might not be in the OpenAPI spec
     try {
@@ -240,15 +228,13 @@ async function refreshAccessToken(
           Accept: 'application/json',
         },
         body: JSON.stringify({ refresh_token: refreshToken }),
-      });
+      })
 
       // Handle HTTP errors
       if (!response.ok) {
-        if (process.argv.includes('--debug')) {
-          console.log(
-            chalk.yellow(`DEBUG: Token refresh error: HTTP ${response.status} ${response.statusText}`)
-          )
-        }
+        logger.debug(
+          `Token refresh error: HTTP ${response.status} ${response.statusText}`
+        )
 
         // Check if the refresh token itself is expired or invalid
         if (response.status === 401 || response.status === 403) {
@@ -290,34 +276,33 @@ async function refreshAccessToken(
         return false
       }
 
-      if (process.argv.includes('--debug')) {
-        console.log(chalk.green('DEBUG: Token refreshed successfully'))
-      }
+      logger.debug('Token refreshed successfully')
 
       // Update the token
-      tokenManager.updateAccessToken(
-        data.token,
-        data.expires_in || 3600
-      )
-      
+      tokenManager.updateAccessToken(data.token, data.expires_in || 3600)
+
       // If a new refresh token was provided, update that too
       if (data.refresh_token) {
-        tokenManager.setTokens(data.token, data.refresh_token, data.expires_in || 3600)
-        if (process.argv.includes('--debug')) {
-          console.log(chalk.green('DEBUG: Refresh token also updated'))
-        }
+        tokenManager.setTokens(
+          data.token,
+          data.refresh_token,
+          data.expires_in || 3600
+        )
+        logger.debug('Refresh token also updated')
       }
     } catch (fetchError) {
       console.warn(
         chalk.yellow(
           `Failed to refresh token: ${
-            fetchError instanceof Error ? fetchError.message : String(fetchError)
+            fetchError instanceof Error
+              ? fetchError.message
+              : String(fetchError)
           }`
         )
       )
       return false
     }
-    
+
     return true
   } catch (error) {
     console.warn(