berget 1.1.0 → 1.3.0

package/src/commands/chat.ts

@@ -2,7 +2,7 @@ import { Command } from 'commander'
 import chalk from 'chalk'
 import readline from 'readline'
 import { COMMAND_GROUPS, SUBCOMMANDS } from '../constants/command-structure'
-import { ChatService, ChatMessage } from '../services/chat-service'
+import { ChatService, ChatMessage, ChatCompletionOptions } from '../services/chat-service'
 import { ApiKeyService } from '../services/api-key-service'
 import { AuthService } from '../services/auth-service'
 import { handleError } from '../utils/error-handler'
@@ -36,7 +36,7 @@ export function registerChatCommands(program: Command): void {
   chat
     .command(SUBCOMMANDS.CHAT.RUN)
     .description('Run a chat session with a specified model')
-    .argument('[model]', 'Model to use (default: berget-70b-instruct)')
+    .argument('[model]', 'Model to use (default: google/gemma-3-27b-it)')
     .option('-s, --system <message>', 'System message')
     .option('-t, --temperature <temp>', 'Temperature (0-1)', parseFloat)
     .option('-m, --max-tokens <tokens>', 'Maximum tokens to generate', parseInt)
@@ -45,6 +45,7 @@ export function registerChatCommands(program: Command): void {
       '--api-key-id <id>',
       'ID of the API key to use from your saved keys'
     )
+    .option('--stream', 'Stream the response')
     .action(async (options) => {
       try {
         const chatService = ChatService.getInstance()
@@ -52,19 +53,92 @@ export function registerChatCommands(program: Command): void {
         // Check if we have an API key or need to get one
         let apiKey = options.apiKey
         let apiKeyId = options.apiKeyId
-
-        // If no API key or API key ID provided, check for default API key
-        if (!apiKey && !apiKeyId) {
-          const defaultApiKeyManager = DefaultApiKeyManager.getInstance()
-          const defaultApiKey = defaultApiKeyManager.getDefaultApiKey()
-
-          if (defaultApiKey) {
-            apiKeyId = defaultApiKey.id
+        
+        // Check for environment variable first
+        const envApiKey = process.env.BERGET_API_KEY;
+        if (envApiKey) {
+          console.log(
+            chalk.dim(`Using API key from BERGET_API_KEY environment variable`)
+          )
+          apiKey = envApiKey;
+          
+          // Debug the API key (first few characters only)
+          if (process.argv.includes('--debug')) {
             console.log(
-              chalk.dim(`Using default API key: ${defaultApiKey.name}`)
+              chalk.yellow(`DEBUG: API key from env starts with: ${envApiKey.substring(0, 4)}...`)
             )
           }
         }
+        // If API key is already provided via command line, use it
+        else if (options.apiKey) {
+          console.log(
+            chalk.dim(`Using API key from command line argument`)
+          )
+          apiKey = options.apiKey;
+        }
+        // If no API key or API key ID provided and no env var, check for default API key
+        else if (!apiKey && !apiKeyId) {
+          try {
+            const defaultApiKeyManager = DefaultApiKeyManager.getInstance()
+            const defaultApiKeyData = defaultApiKeyManager.getDefaultApiKeyData()
+
+            if (defaultApiKeyData) {
+              apiKeyId = defaultApiKeyData.id
+              apiKey = defaultApiKeyData.key
+              
+              if (apiKey) {
+                console.log(
+                  chalk.dim(`Using default API key: ${defaultApiKeyData.name}`)
+                )
+              } else {
+                console.log(
+                  chalk.yellow(`Default API key "${defaultApiKeyData.name}" exists but the key value is missing.`)
+                )
+                console.log(
+                  chalk.yellow(`Try rotating the key with: berget api-keys rotate ${defaultApiKeyData.id}`)
+                )
+              }
+            } else {
+              // No default API key, prompt the user to create one
+              console.log(chalk.yellow('No default API key set.'))
+
+              // Try to prompt for a default API key
+              apiKey = await defaultApiKeyManager.promptForDefaultApiKey()
+
+              if (!apiKey) {
+                console.log(
+                  chalk.red(
+                    'Error: An API key is required to use the chat command.'
+                  )
+                )
+                console.log(chalk.yellow('You can:'))
+                console.log(
+                  chalk.yellow(
+                    '1. Create an API key with: berget api-keys create --name "My Key"'
+                  )
+                )
+                console.log(
+                  chalk.yellow(
+                    '2. Set a default API key with: berget api-keys set-default <id>'
+                  )
+                )
+                console.log(
+                  chalk.yellow(
+                    '3. Provide an API key with the --api-key option'
+                  )
+                )
+                return
+              }
+            }
+          } catch (error) {
+            if (process.argv.includes('--debug')) {
+              console.log(
+                chalk.yellow('DEBUG: Error checking default API key:')
+              )
+              console.log(chalk.yellow(String(error)))
+            }
+          }
+        }
 
         // If no direct API key, try to get one from API key ID
         if (!apiKey && apiKeyId) {
@@ -106,9 +180,19 @@ export function registerChatCommands(program: Command): void {
               }
             }
           } catch (error) {
-            console.error(chalk.red('Error fetching API key:'))
-            console.error(error)
-            console.log(chalk.yellow('Using default authentication instead.'))
+            // 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');
+            
+            if (isAuthError) {
+              console.log(chalk.yellow('Authentication required. Please run `berget auth login` first.'));
+            } else {
+              console.error(chalk.red('Error fetching API key:'));
+              console.error(error);
+            }
+            console.log(chalk.yellow('Using default authentication instead.'));
           }
         }
 
@@ -171,14 +255,50 @@ export function registerChatCommands(program: Command): void {
 
             try {
               // Call the API
-              const response = await chatService.createCompletion({
-                model: options.args?.[0] || 'berget-70b-instruct',
+              const completionOptions: ChatCompletionOptions = {
+                model: options.args?.[0] || 'google/gemma-3-27b-it',
                 messages: messages,
                 temperature:
                   options.temperature !== undefined ? options.temperature : 0.7,
                 max_tokens: options.maxTokens || 4096,
-                apiKey: apiKey,
-              })
+                stream: options.stream || false
+              }
+
+              // Only add apiKey if it actually exists
+              if (apiKey) {
+                completionOptions.apiKey = apiKey
+              }
+              
+              // Add streaming support
+              if (options.stream) {
+                let assistantResponse = ''
+                process.stdout.write(chalk.blue('Assistant: '))
+                
+                completionOptions.onChunk = (chunk: any) => {
+                  if (chunk.choices && chunk.choices[0] && chunk.choices[0].delta && chunk.choices[0].delta.content) {
+                    const content = chunk.choices[0].delta.content
+                    process.stdout.write(content)
+                    assistantResponse += content
+                  }
+                }
+                
+                await chatService.createCompletion(completionOptions)
+                console.log('\n')
+                
+                // Add assistant response to messages
+                messages.push({
+                  role: 'assistant',
+                  content: assistantResponse
+                })
+                
+                // Continue the conversation
+                askQuestion()
+                return
+              }
+              
+              const response = await chatService.createCompletion(
+                completionOptions
+              )
 
               // Debug output
               if (program.opts().debug) {
@@ -252,12 +372,12 @@ export function registerChatCommands(program: Command): void {
         // If no API key or API key ID provided, check for default API key
         if (!apiKey && !apiKeyId) {
           const defaultApiKeyManager = DefaultApiKeyManager.getInstance()
-          const defaultApiKey = defaultApiKeyManager.getDefaultApiKey()
+          const defaultApiKeyData = defaultApiKeyManager.getDefaultApiKeyData()
 
-          if (defaultApiKey) {
-            apiKeyId = defaultApiKey.id
+          if (defaultApiKeyData) {
+            apiKeyId = defaultApiKeyData.id
             console.log(
-              chalk.dim(`Using default API key: ${defaultApiKey.name}`)
+              chalk.dim(`Using default API key: ${defaultApiKeyData.name}`)
             )
           }
         }

package/src/services/api-key-service.ts

@@ -33,10 +33,10 @@ export interface ApiKeyResponse {
 export class ApiKeyService {
   private static instance: ApiKeyService
   private client = createAuthenticatedClient()
-  
+
   // Command group name for this service
   public static readonly COMMAND_GROUP = COMMAND_GROUPS.API_KEYS
-  
+
   // Subcommands for this service
   public static readonly COMMANDS = SUBCOMMANDS.API_KEYS
 
@@ -56,18 +56,7 @@ export class ApiKeyService {
   public async list(): Promise<ApiKey[]> {
     try {
       const { data, error } = await this.client.GET('/v1/api-keys')
-      if (error) {
-        // Check if this is an authentication error
-        const errorObj = typeof error === 'string' ? JSON.parse(error) : error;
-        if (errorObj.status === 401) {
-          throw new Error(JSON.stringify({
-            error: "Authentication failed. Your session may have expired.",
-            code: "AUTH_FAILED",
-            details: "Please run 'berget login' to authenticate again."
-          }))
-        }
-        throw new Error(JSON.stringify(error))
-      }
+      if (error) throw error
       return data || []
     } catch (error) {
       handleError('Failed to list API keys', error)
@@ -82,7 +71,7 @@ export class ApiKeyService {
   public async create(options: CreateApiKeyOptions): Promise<ApiKeyResponse> {
     try {
       const { data, error } = await this.client.POST('/v1/api-keys', {
-        body: options
+        body: options,
       })
       if (error) throw new Error(JSON.stringify(error))
       return data!
@@ -99,7 +88,7 @@ export class ApiKeyService {
   public async delete(id: string): Promise<boolean> {
     try {
       const { error } = await this.client.DELETE('/v1/api-keys/{id}', {
-        params: { path: { id } }
+        params: { path: { id } },
       })
       if (error) throw new Error(JSON.stringify(error))
       return true
@@ -115,9 +104,12 @@ export class ApiKeyService {
    */
   public async rotate(id: string): Promise<ApiKeyResponse> {
     try {
-      const { data, error } = await this.client.PUT('/v1/api-keys/{id}/rotate', {
-        params: { path: { id } }
-      })
+      const { data, error } = await this.client.PUT(
+        '/v1/api-keys/{id}/rotate',
+        {
+          params: { path: { id } },
+        }
+      )
       if (error) throw new Error(JSON.stringify(error))
       return data!
     } catch (error) {
@@ -133,7 +125,7 @@ export class ApiKeyService {
   public async describe(id: string): Promise<any> {
     try {
       const { data, error } = await this.client.GET('/v1/api-keys/{id}/usage', {
-        params: { path: { id } }
+        params: { path: { id } },
       })
       if (error) throw new Error(JSON.stringify(error))
       return data