berget 1.4.0 → 2.0.0

package/src/types/json.d.ts

@@ -1,4 +1,4 @@
-declare module "*.json" {
-  const value: any;
-  export = value;
+declare module '*.json' {
+  const value: any
+  export = value
 }

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

@@ -20,7 +20,7 @@ export class DefaultApiKeyManager {
   private static instance: DefaultApiKeyManager
   private configFilePath: string
   private defaultApiKey: DefaultApiKeyData | null = null
-  
+
   private constructor() {
     // Set up config file path in user's home directory
     const bergetDir = path.join(os.homedir(), '.berget')
@@ -30,14 +30,14 @@ export class DefaultApiKeyManager {
     this.configFilePath = path.join(bergetDir, 'default-api-key.json')
     this.loadConfig()
   }
-  
+
   public static getInstance(): DefaultApiKeyManager {
     if (!DefaultApiKeyManager.instance) {
       DefaultApiKeyManager.instance = new DefaultApiKeyManager()
     }
     return DefaultApiKeyManager.instance
   }
-  
+
   /**
    * Load default API key from file
    */
@@ -52,14 +52,17 @@ export class DefaultApiKeyManager {
       this.defaultApiKey = null
     }
   }
-  
+
   /**
    * Save default API key to file
    */
   private saveConfig(): void {
     try {
       if (this.defaultApiKey) {
-        fs.writeFileSync(this.configFilePath, JSON.stringify(this.defaultApiKey, null, 2))
+        fs.writeFileSync(
+          this.configFilePath,
+          JSON.stringify(this.defaultApiKey, null, 2),
+        )
         // Set file permissions to be readable only by the owner
         fs.chmodSync(this.configFilePath, 0o600)
       } else {
@@ -72,29 +75,34 @@ export class DefaultApiKeyManager {
       logger.debug('Failed to save default API key configuration')
     }
   }
-  
+
   /**
    * Set the default API key
    */
-  public setDefaultApiKey(id: string, name: string, prefix: string, key: string): void {
+  public setDefaultApiKey(
+    id: string,
+    name: string,
+    prefix: string,
+    key: string,
+  ): void {
     this.defaultApiKey = { id, name, prefix, key }
     this.saveConfig()
   }
-  
+
   /**
    * Get the default API key string
    */
   public getDefaultApiKey(): string | null {
     return this.defaultApiKey?.key || null
   }
-  
+
   /**
    * Get the default API key data object
    */
   public getDefaultApiKeyData(): DefaultApiKeyData | null {
     return this.defaultApiKey
   }
-  
+
   /**
    * Clear the default API key
    */
@@ -110,7 +118,7 @@ export class DefaultApiKeyManager {
   public async promptForDefaultApiKey(): Promise<string | null> {
     try {
       logger.debug('promptForDefaultApiKey called')
-      
+
       // If we already have a default API key, return it
       if (this.defaultApiKey) {
         logger.debug('Using existing default API key')
@@ -118,18 +126,18 @@ export class DefaultApiKeyManager {
       }
 
       logger.debug('No default API key found, getting ApiKeyService')
-      
+
       const apiKeyService = ApiKeyService.getInstance()
-      
+
       // Get all API keys
-      let apiKeys;
+      let apiKeys
       try {
         logger.debug('Calling apiKeyService.list()')
-        
+
         apiKeys = await apiKeyService.list()
-        
+
         logger.debug(`Got ${apiKeys ? apiKeys.length : 0} API keys`)
-        
+
         if (!apiKeys || apiKeys.length === 0) {
           logger.warn('No API keys found. Create one with:')
           logger.info('  berget api-keys create --name "My Key"')
@@ -137,37 +145,41 @@ export class DefaultApiKeyManager {
         }
       } catch (error) {
         // Check if this is an authentication error
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        const isAuthError = errorMessage.includes('Unauthorized') || 
-                           errorMessage.includes('Authentication failed') ||
-                           errorMessage.includes('AUTH_FAILED');
-        
+        const errorMessage =
+          error instanceof Error ? error.message : String(error)
+        const isAuthError =
+          errorMessage.includes('Unauthorized') ||
+          errorMessage.includes('Authentication failed') ||
+          errorMessage.includes('AUTH_FAILED')
+
         if (isAuthError) {
-          logger.warn('Authentication required. Please run `berget auth login` first.');
+          logger.warn(
+            'Authentication required. Please run `berget auth login` first.',
+          )
         } else {
-          logger.error('Error fetching API keys:');
+          logger.error('Error fetching API keys:')
           if (error instanceof Error) {
-            logger.error(error.message);
-            logger.debug(`API key list error: ${error.message}`);
-            logger.debug(`Stack: ${error.stack}`);
+            logger.error(error.message)
+            logger.debug(`API key list error: ${error.message}`)
+            logger.debug(`Stack: ${error.stack}`)
           }
         }
-        return null;
+        return null
       }
-      
+
       logger.info('Select an API key to use as default:')
-      
+
       // Display available API keys
       apiKeys.forEach((key, index) => {
         logger.log(`  ${index + 1}. ${key.name} (${key.prefix}...)`)
       })
-      
+
       // Create readline interface for user input
       const rl = readline.createInterface({
         input: process.stdin,
-        output: process.stdout
+        output: process.stdout,
       })
-      
+
       // Prompt for selection
       const selection = await new Promise<number>((resolve) => {
         rl.question('Enter number (or press Enter to cancel): ', (answer) => {
@@ -180,28 +192,28 @@ export class DefaultApiKeyManager {
           }
         })
       })
-      
+
       if (selection === -1) {
         logger.warn('No API key selected')
         return null
       }
-      
+
       const selectedKey = apiKeys[selection]
-      
+
       // Create a new API key with the selected name
       const newKey = await apiKeyService.create({
         name: `CLI Default (copy of ${selectedKey.name})`,
-        description: 'Created automatically by the Berget CLI for default use'
+        description: 'Created automatically by the Berget CLI for default use',
       })
-      
+
       // Save the new key as default
       this.setDefaultApiKey(
-        newKey.id.toString(), 
-        newKey.name, 
+        newKey.id.toString(),
+        newKey.name,
         newKey.key.substring(0, 8), // Use first 8 chars as prefix
-        newKey.key
+        newKey.key,
       )
-      
+
       logger.success(`✓ Default API key set to: ${newKey.name}`)
       return newKey.key
     } catch (error) {

package/src/utils/env-manager.ts

@@ -0,0 +1,98 @@
+import fs from 'fs'
+import path from 'path'
+import { writeFile } from 'fs/promises'
+import chalk from 'chalk'
+import dotenv from 'dotenv'
+
+export interface EnvUpdateOptions {
+  envPath?: string
+  key: string
+  value: string
+  comment?: string
+  force?: boolean
+}
+
+/**
+ * Safely updates .env file without overwriting existing keys
+ * Uses dotenv for proper parsing and formatting
+ */
+export async function updateEnvFile(
+  options: EnvUpdateOptions,
+): Promise<boolean> {
+  const {
+    envPath = path.join(process.cwd(), '.env'),
+    key,
+    value,
+    comment,
+    force = false,
+  } = options
+
+  try {
+    let existingContent = ''
+    let parsed: Record<string, string> = {}
+
+    // Read existing .env file if it exists
+    if (fs.existsSync(envPath)) {
+      existingContent = fs.readFileSync(envPath, 'utf8')
+      parsed = dotenv.parse(existingContent)
+    }
+
+    // Check if key already exists and we're not forcing
+    if (parsed[key] && !force) {
+      console.log(
+        chalk.yellow(`⚠ ${key} already exists in .env - leaving unchanged`),
+      )
+      return false
+    }
+
+    // Update the parsed object
+    parsed[key] = value
+
+    // Generate new .env content
+    let newContent = ''
+
+    // Add comment at the top if this is a new file
+    if (!existingContent && comment) {
+      newContent += `# ${comment}\n`
+    }
+
+    // Convert parsed object back to .env format
+    for (const [envKey, envValue] of Object.entries(parsed)) {
+      newContent += `${envKey}=${envValue}\n`
+    }
+
+    // Write the updated content
+    await writeFile(envPath, newContent.trim() + '\n')
+
+    if (existingContent) {
+      console.log(chalk.green(`✓ Updated .env with ${key}`))
+    } else {
+      console.log(chalk.green(`✓ Created .env with ${key}`))
+    }
+
+    return true
+  } catch (error) {
+    console.error(chalk.red(`Failed to update .env file:`))
+    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,40 +1,49 @@
-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}`))
+
   // 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) {
-        console.error(chalk.dim(`Details: ${parsedError.error}`));
+        console.error(chalk.dim(`Details: ${parsedError.error}`))
         if (parsedError.code) {
-          console.error(chalk.dim(`Code: ${parsedError.code}`));
+          console.error(chalk.dim(`Code: ${parsedError.code}`))
         }
       } else {
-        console.error(chalk.dim(`Details: ${error}`));
+        console.error(chalk.dim(`Details: ${error}`))
       }
     } catch {
       // If it's not valid JSON, just print the string
-      console.error(chalk.dim(`Details: ${error}`));
+      console.error(chalk.dim(`Details: ${error}`))
     }
   } else if (error && error.message) {
     // If it's an Error object
-    console.error(chalk.dim(`Details: ${error.message}`));
+    console.error(chalk.dim(`Details: ${error.message}`))
   }
-  
+
   // Check for authentication 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'))
+    (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'))
   ) {
-    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('\nYou need to be logged in to use this command.'),
+    )
+    console.error(chalk.yellow('Run `berget auth login` to authenticate.'))
   }
 }

package/src/utils/logger.ts

@@ -8,7 +8,7 @@ export enum LogLevel {
   ERROR = 1,
   WARN = 2,
   INFO = 3,
-  DEBUG = 4
+  DEBUG = 4,
 }
 
 /**
@@ -17,7 +17,7 @@ export enum LogLevel {
 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) {
@@ -28,14 +28,14 @@ export class Logger {
       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
    */
@@ -61,21 +61,21 @@ export class Logger {
         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)
    */
@@ -88,7 +88,7 @@ export class Logger {
       }
     }
   }
-  
+
   /**
    * Log an info message (shown at INFO level and above)
    */
@@ -101,7 +101,7 @@ export class Logger {
       }
     }
   }
-  
+
   /**
    * Log a warning message (shown at WARN level and above)
    */
@@ -114,7 +114,7 @@ export class Logger {
       }
     }
   }
-  
+
   /**
    * Log an error message (shown at ERROR level and above)
    */
@@ -127,7 +127,7 @@ export class Logger {
       }
     }
   }
-  
+
   /**
    * Log a success message (shown at INFO level and above)
    */
@@ -140,7 +140,7 @@ export class Logger {
       }
     }
   }
-  
+
   /**
    * Log a plain message without color (shown at INFO level and above)
    */

package/src/utils/markdown-renderer.ts

@@ -18,8 +18,8 @@ marked.setOptions({
     // Adjust the width to fit the terminal
     width: process.stdout.columns || 80,
     // Customize code block rendering
-    codespan: chalk.cyan
-  })
+    codespan: chalk.cyan,
+  }),
 })
 
 /**
@@ -29,7 +29,7 @@ marked.setOptions({
  */
 export function renderMarkdown(markdown: string): string {
   if (!markdown) return ''
-  
+
   try {
     // Convert markdown to terminal-friendly text
     return marked(markdown)
@@ -47,22 +47,22 @@ export function renderMarkdown(markdown: string): string {
  */
 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
+    /^#+\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))
+
+  return markdownPatterns.some((pattern) => pattern.test(text))
 }

package/src/utils/opencode-validator.ts

@@ -0,0 +1,134 @@
+import Ajv from 'ajv'
+import addFormats from 'ajv-formats'
+import { readFileSync } from 'fs'
+import { join } from 'path'
+import { dirname } from 'path'
+
+// Load the official OpenCode JSON Schema
+const __dirname = dirname(__filename)
+const schemaPath = join(__dirname, '..', 'schemas', 'opencode-schema.json')
+
+let ajv: Ajv
+let openCodeSchema: any
+let validateFunction: any
+
+try {
+  const schemaContent = readFileSync(schemaPath, 'utf-8')
+  openCodeSchema = JSON.parse(schemaContent)
+
+  // Initialize AJV with formats and options
+  ajv = new Ajv({
+    allErrors: true,
+    verbose: true,
+    strict: false,
+    allowUnionTypes: true,
+    removeAdditional: false,
+  })
+
+  // Add JSON Schema formats
+  addFormats(ajv)
+
+  // Compile the schema
+  validateFunction = ajv.compile(openCodeSchema)
+} catch (error) {
+  console.error('Failed to load OpenCode schema:', error)
+  throw new Error('Could not initialize OpenCode validator')
+}
+
+export type OpenCodeConfig = any
+
+/**
+ * Validate OpenCode configuration against the official JSON Schema
+ */
+export function validateOpenCodeConfig(config: any): {
+  valid: boolean
+  errors?: string[]
+} {
+  try {
+    if (!validateFunction) {
+      return { valid: false, errors: ['Schema validator not initialized'] }
+    }
+
+    const isValid = validateFunction(config)
+
+    if (isValid) {
+      return { valid: true }
+    } else {
+      const errors = validateFunction.errors?.map((err: any) => {
+        const path = err.instancePath || err.schemaPath || 'root'
+        const message = err.message || 'Unknown error'
+        return `${path}: ${message}`
+      }) || ['Unknown validation error']
+
+      return { valid: false, errors }
+    }
+  } catch (error) {
+    console.error('Validation error:', error)
+    return { valid: false, errors: ['Validation process failed'] }
+  }
+}
+
+/**
+ * Fix common OpenCode configuration issues
+ */
+export function fixOpenCodeConfig(config: any): OpenCodeConfig {
+  const fixed = { ...config }
+
+  // Fix tools.compact - should be boolean, not object
+  if (fixed.tools && typeof fixed.tools.compact === 'object') {
+    console.warn('⚠️  Converting tools.compact from object to boolean')
+    // If it has properties, assume it should be enabled
+    fixed.tools.compact = true
+  }
+
+  // Remove invalid properties
+  const invalidProps = ['maxTokens', 'contextWindow']
+  invalidProps.forEach((prop) => {
+    if (fixed[prop] !== undefined) {
+      console.warn(`⚠️  Removing invalid property: ${prop}`)
+      delete fixed[prop]
+    }
+  })
+
+  // Fix provider models with invalid properties
+  if (fixed.provider) {
+    Object.values(fixed.provider).forEach((provider: any) => {
+      if (provider?.models) {
+        Object.values(provider.models).forEach((model: any) => {
+          if (model && typeof model === 'object') {
+            // Move maxTokens/contextWindow to proper structure if needed
+            if (model.maxTokens || model.contextWindow) {
+              if (!model.limit) model.limit = {}
+
+              // Use the larger of maxTokens/contextWindow for context
+              const contextValues = [
+                model.maxTokens,
+                model.contextWindow,
+              ].filter(Boolean)
+              if (contextValues.length > 0) {
+                const newContext = Math.max(...contextValues)
+                if (!model.limit.context || newContext > model.limit.context) {
+                  model.limit.context = newContext
+                }
+              }
+
+              // Set a reasonable default for output if not present
+              // (typically 1/4 to 1/8 of context window)
+              if (!model.limit.output && model.limit.context) {
+                model.limit.output = Math.floor(model.limit.context / 4)
+              }
+
+              delete model.maxTokens
+              delete model.contextWindow
+              console.warn(
+                '⚠️  Moved maxTokens/contextWindow to limit.context/output',
+              )
+            }
+          }
+        })
+      }
+    })
+  }
+
+  return fixed
+}