berget 2.0.3 → 2.0.5

package/src/utils/config-loader.ts

@@ -0,0 +1,261 @@
+import * as fs from 'fs'
+import * as path from 'path'
+import { logger } from './logger'
+
+/**
+ * Centralized agent configuration loader
+ * Loads all agent configurations from opencode.json as the single source of truth
+ */
+
+export interface AgentConfig {
+  model: string
+  temperature: number
+  top_p: number
+  mode: 'primary' | 'subagent'
+  permission: {
+    edit: 'allow' | 'deny'
+    bash: 'allow' | 'deny'
+    webfetch: 'allow' | 'deny'
+  }
+  description?: string
+  prompt?: string
+  note?: string
+}
+
+export interface ModelConfig {
+  primary: string
+  small: string
+}
+
+export interface ProviderModelConfig {
+  name: string
+  limit: {
+    output: number
+    context: number
+  }
+}
+
+export interface OpenCodeConfig {
+  $schema?: string
+  username?: string
+  theme?: string
+  share?: string
+  autoupdate?: boolean
+  model?: string
+  small_model?: string
+  agent?: Record<string, AgentConfig>
+  command?: Record<string, any>
+  watcher?: Record<string, any>
+  provider?: Record<string, any>
+}
+
+export class ConfigLoader {
+  private static instance: ConfigLoader
+  private config: OpenCodeConfig | null = null
+  private configPath: string
+
+  private constructor(configPath?: string) {
+    // Default to opencode.json in current working directory
+    this.configPath = configPath || path.join(process.cwd(), 'opencode.json')
+  }
+
+  public static getInstance(configPath?: string): ConfigLoader {
+    if (!ConfigLoader.instance) {
+      ConfigLoader.instance = new ConfigLoader(configPath)
+    }
+    return ConfigLoader.instance
+  }
+
+  /**
+   * Load configuration from opencode.json
+   */
+  public loadConfig(): OpenCodeConfig {
+    if (this.config) {
+      return this.config
+    }
+
+    try {
+      if (!fs.existsSync(this.configPath)) {
+        throw new Error(`Configuration file not found: ${this.configPath}`)
+      }
+
+      const configContent = fs.readFileSync(this.configPath, 'utf8')
+      this.config = JSON.parse(configContent) as OpenCodeConfig
+      
+      logger.debug(`Loaded configuration from ${this.configPath}`)
+      return this.config
+    } catch (error) {
+      logger.error(`Failed to load configuration from ${this.configPath}:`, error)
+      throw new Error(`Failed to load configuration: ${error instanceof Error ? error.message : String(error)}`)
+    }
+  }
+
+  /**
+   * Get agent configuration by name
+   */
+  public getAgentConfig(agentName: string): AgentConfig | null {
+    const config = this.loadConfig()
+    return config.agent?.[agentName] || null
+  }
+
+  /**
+   * Get all agent configurations
+   */
+  public getAllAgentConfigs(): Record<string, AgentConfig> {
+    const config = this.loadConfig()
+    return config.agent || {}
+  }
+
+  /**
+   * Get model configuration
+   */
+  public getModelConfig(): ModelConfig {
+    const config = this.loadConfig()
+    
+    // Extract from config or fall back to defaults
+    const primary = config.model || 'berget/deepseek-r1'
+    const small = config.small_model || 'berget/gpt-oss'
+    
+    return { primary, small }
+  }
+
+  /**
+   * Get provider model configuration
+   */
+  public getProviderModels(): Record<string, ProviderModelConfig> {
+    const config = this.loadConfig()
+    
+    // Extract from provider configuration
+    if (config.provider?.berget?.models) {
+      return config.provider.berget.models as Record<string, ProviderModelConfig>
+    }
+    
+    // Fallback to defaults
+    return {
+      'deepseek-r1': {
+        name: 'GLM-4.6',
+        limit: { output: 4000, context: 90000 }
+      },
+      'gpt-oss': {
+        name: 'GPT-OSS',
+        limit: { output: 4000, context: 128000 }
+      },
+      'llama-8b': {
+        name: 'llama-3.1-8b',
+        limit: { output: 4000, context: 128000 }
+      }
+    }
+  }
+
+  /**
+   * Get command configurations
+   */
+  public getCommandConfigs(): Record<string, any> {
+    const config = this.loadConfig()
+    return config.command || {}
+  }
+
+  /**
+   * Get watcher configuration
+   */
+  public getWatcherConfig(): Record<string, any> {
+    const config = this.loadConfig()
+    return config.watcher || { ignore: ['node_modules', 'dist', '.git', 'coverage'] }
+  }
+
+  /**
+   * Get provider configuration
+   */
+  public getProviderConfig(): Record<string, any> {
+    const config = this.loadConfig()
+    return config.provider || {}
+  }
+
+  /**
+   * Check if an agent exists
+   */
+  public hasAgent(agentName: string): boolean {
+    return agentName in this.getAllAgentConfigs()
+  }
+
+  /**
+   * Get list of all available agent names
+   */
+  public getAgentNames(): string[] {
+    return Object.keys(this.getAllAgentConfigs())
+  }
+
+  /**
+   * Get list of primary agents (mode: 'primary')
+   */
+  public getPrimaryAgentNames(): string[] {
+    const agents = this.getAllAgentConfigs()
+    return Object.keys(agents).filter(name => agents[name].mode === 'primary')
+  }
+
+  /**
+   * Get list of subagents (mode: 'subagent')
+   */
+  public getSubagentNames(): string[] {
+    const agents = this.getAllAgentConfigs()
+    return Object.keys(agents).filter(name => agents[name].mode === 'subagent')
+  }
+
+  /**
+   * Reload configuration from file
+   */
+  public reloadConfig(): OpenCodeConfig {
+    this.config = null
+    return this.loadConfig()
+  }
+
+  /**
+   * Set custom configuration path (for testing or different environments)
+   */
+  public setConfigPath(configPath: string): void {
+    this.configPath = configPath
+    this.config = null // Force reload
+  }
+
+  /**
+   * Get the current configuration path
+   */
+  public getConfigPath(): string {
+    return this.configPath
+  }
+}
+
+/**
+ * Convenience function to get the config loader instance
+ */
+export function getConfigLoader(configPath?: string): ConfigLoader {
+  return ConfigLoader.getInstance(configPath)
+}
+
+/**
+ * Convenience function to get agent configuration
+ */
+export function getAgentConfig(agentName: string, configPath?: string): AgentConfig | null {
+  return getConfigLoader(configPath).getAgentConfig(agentName)
+}
+
+/**
+ * Convenience function to get all agent configurations
+ */
+export function getAllAgentConfigs(configPath?: string): Record<string, AgentConfig> {
+  return getConfigLoader(configPath).getAllAgentConfigs()
+}
+
+/**
+ * Convenience function to get model configuration
+ */
+export function getModelConfig(configPath?: string): ModelConfig {
+  return getConfigLoader(configPath).getModelConfig()
+}
+
+/**
+ * Convenience function to get provider models
+ */
+export function getProviderModels(configPath?: string): Record<string, ProviderModelConfig> {
+  return getConfigLoader(configPath).getProviderModels()
+}

package/src/utils/error-handler.ts

@@ -4,7 +4,11 @@ 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 = ''
 
   // If the error is a string (like JSON.stringify(error))
   if (typeof error === 'string') {
@@ -12,38 +16,131 @@ export function handleError(message: string, error: any): void {
       // Try to parse it as JSON
       const parsedError = JSON.parse(error)
       if (parsedError.error) {
-        console.error(chalk.dim(`Details: ${parsedError.error}`))
-        if (parsedError.code) {
-          console.error(chalk.dim(`Code: ${parsedError.code}`))
-        }
+        errorDetails = parsedError.error.message || parsedError.error
+        errorCode = parsedError.error.code || parsedError.code
+        errorType = parsedError.error.type || ''
       } else {
-        console.error(chalk.dim(`Details: ${error}`))
+        errorDetails = error
       }
     } catch {
       // If it's not valid JSON, just print the string
-      console.error(chalk.dim(`Details: ${error}`))
+      errorDetails = error
     }
   } else if (error && error.message) {
     // If it's an Error object
-    console.error(chalk.dim(`Details: ${error.message}`))
+    errorDetails = error.message
+    errorCode = error.code
+    errorType = error.type
+  }
+
+  // Print error details
+  if (errorDetails) {
+    console.error(chalk.dim(`📝 Details: ${errorDetails}`))
+  }
+  if (errorCode) {
+    console.error(chalk.dim(`🔢 Code: ${errorCode}`))
+  }
+
+  // Provide helpful troubleshooting based on error type
+  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:'))
+
+  // Authentication errors
+  if (
+    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'))
+  }
+
+  // Network/connection errors
+  if (
+    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'))
   }
 
-  // Check for authentication errors
+  // API key errors
   if (
-    (typeof error === 'string' &&
-      (error.includes('Unauthorized') ||
-        error.includes('Authentication failed'))) ||
-    (error &&
-      error.message &&
-      (error.message.includes('Unauthorized') ||
-        error.message.includes('Authentication failed'))) ||
-    (error &&
-      error.code &&
-      (error.code === 401 || error.code === 'AUTH_FAILED'))
+    errorCode?.includes('API_KEY') ||
+    errorDetails?.includes('API key') ||
+    errorType === 'invalid_request_error'
   ) {
-    console.error(
-      chalk.yellow('\nYou need to be logged in to use this command.'),
-    )
-    console.error(chalk.yellow('Run `berget auth login` to authenticate.'))
+    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')
+  ) {
+    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)
+  ) {
+    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'))
+  }
+
+  // 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')
+  ) {
+    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'))
 }