berget 1.3.1 → 2.0.0

package/src/utils/token-manager.ts

@@ -17,7 +17,7 @@ export class TokenManager {
   private static instance: TokenManager
   private tokenFilePath: string
   private tokenData: TokenData | null = null
-  
+
   private constructor() {
     // Set up token file path in user's home directory
     const bergetDir = path.join(os.homedir(), '.berget')
@@ -27,14 +27,14 @@ export class TokenManager {
     this.tokenFilePath = path.join(bergetDir, 'auth.json')
     this.loadToken()
   }
-  
+
   public static getInstance(): TokenManager {
     if (!TokenManager.instance) {
       TokenManager.instance = new TokenManager()
     }
     return TokenManager.instance
   }
-  
+
   /**
    * Load token data from file
    */
@@ -49,14 +49,17 @@ export class TokenManager {
       this.tokenData = null
     }
   }
-  
+
   /**
    * Save token data to file
    */
   private saveToken(): void {
     try {
       if (this.tokenData) {
-        fs.writeFileSync(this.tokenFilePath, JSON.stringify(this.tokenData, null, 2))
+        fs.writeFileSync(
+          this.tokenFilePath,
+          JSON.stringify(this.tokenData, null, 2),
+        )
         // Set file permissions to be readable only by the owner
         fs.chmodSync(this.tokenFilePath, 0o600)
       } else {
@@ -69,7 +72,7 @@ export class TokenManager {
       logger.error('Failed to save authentication token')
     }
   }
-  
+
   /**
    * Get the current access token
    * @returns The access token or null if not available
@@ -78,7 +81,7 @@ export class TokenManager {
     if (!this.tokenData) return null
     return this.tokenData.access_token
   }
-  
+
   /**
    * Get the refresh token
    * @returns The refresh token or null if not available
@@ -87,47 +90,56 @@ export class TokenManager {
     if (!this.tokenData) return null
     return this.tokenData.refresh_token
   }
-  
+
   /**
    * Check if the access token is expired
    * @returns true if expired or about to expire (within 5 minutes), false otherwise
    */
   public isTokenExpired(): boolean {
     if (!this.tokenData || !this.tokenData.expires_at) return true
-    
+
     try {
       // Consider token expired if it's within 10 minutes of expiration
       // 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;
-      
+      const isExpired =
+        Date.now() + expirationBuffer >= this.tokenData.expires_at
+
       if (isExpired) {
-        logger.debug(`Token expired or expiring soon. Current time: ${new Date().toISOString()}, Expiry: ${new Date(this.tokenData.expires_at).toISOString()}`);
+        logger.debug(
+          `Token expired or expiring soon. Current time: ${new Date().toISOString()}, Expiry: ${new Date(this.tokenData.expires_at).toISOString()}`,
+        )
       }
-      
-      return isExpired;
+
+      return isExpired
     } catch (error) {
       // If there's any error checking expiration, assume token is expired
-      logger.error(`Error checking token expiration: ${error instanceof Error ? error.message : String(error)}`);
-      return true;
+      logger.error(
+        `Error checking token expiration: ${error instanceof Error ? error.message : String(error)}`,
+      )
+      return true
     }
   }
-  
+
   /**
    * Set new token data
    * @param accessToken The new access token
    * @param refreshToken The new refresh token
    * @param expiresIn Expiration time in seconds
    */
-  public setTokens(accessToken: string, refreshToken: string, expiresIn: number): void {
+  public setTokens(
+    accessToken: string,
+    refreshToken: string,
+    expiresIn: number,
+  ): void {
     this.tokenData = {
       access_token: accessToken,
       refresh_token: refreshToken,
-      expires_at: Date.now() + (expiresIn * 1000)
+      expires_at: Date.now() + expiresIn * 1000,
     }
     this.saveToken()
   }
-  
+
   /**
    * Update just the access token and its expiration
    * @param accessToken The new access token
@@ -135,12 +147,12 @@ export class TokenManager {
    */
   public updateAccessToken(accessToken: string, expiresIn: number): void {
     if (!this.tokenData) return
-    
+
     this.tokenData.access_token = accessToken
-    this.tokenData.expires_at = Date.now() + (expiresIn * 1000)
+    this.tokenData.expires_at = Date.now() + expiresIn * 1000
     this.saveToken()
   }
-  
+
   /**
    * Clear all token data
    */

package/tests/commands/chat.test.ts

@@ -0,0 +1,129 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import { Command } from 'commander'
+import { registerChatCommands } from '../../src/commands/chat'
+import { ChatService } from '../../src/services/chat-service'
+import { DefaultApiKeyManager } from '../../src/utils/default-api-key'
+
+// Mock dependencies
+vi.mock('../../src/services/chat-service')
+vi.mock('../../src/utils/default-api-key')
+vi.mock('readline', () => ({
+  createInterface: vi.fn(() => ({
+    question: vi.fn(),
+    close: vi.fn(),
+  })),
+}))
+
+describe('Chat Commands', () => {
+  let program: Command
+  let mockChatService: any
+  let mockDefaultApiKeyManager: any
+
+  beforeEach(() => {
+    program = new Command()
+
+    // Mock ChatService
+    mockChatService = {
+      createCompletion: vi.fn(),
+      listModels: vi.fn(),
+    }
+    vi.mocked(ChatService.getInstance).mockReturnValue(mockChatService)
+
+    // Mock DefaultApiKeyManager
+    mockDefaultApiKeyManager = {
+      getDefaultApiKeyData: vi.fn(),
+      promptForDefaultApiKey: vi.fn(),
+    }
+    vi.mocked(DefaultApiKeyManager.getInstance).mockReturnValue(
+      mockDefaultApiKeyManager,
+    )
+
+    registerChatCommands(program)
+  })
+
+  afterEach(() => {
+    vi.clearAllMocks()
+  })
+
+  describe('chat run command', () => {
+    it('should use openai/gpt-oss as default model', () => {
+      const chatCommand = program.commands.find((cmd) => cmd.name() === 'chat')
+      const runCommand = chatCommand?.commands.find(
+        (cmd) => cmd.name() === 'run',
+      )
+
+      expect(runCommand).toBeDefined()
+
+      // Check the help text which contains the default model
+      const helpText = runCommand?.helpInformation()
+      expect(helpText).toContain('openai/gpt-oss')
+    })
+
+    it('should have streaming enabled by default', () => {
+      const chatCommand = program.commands.find((cmd) => cmd.name() === 'chat')
+      const runCommand = chatCommand?.commands.find(
+        (cmd) => cmd.name() === 'run',
+      )
+
+      expect(runCommand).toBeDefined()
+
+      // Check that the option is --no-stream (meaning streaming is default)
+      const streamOption = runCommand?.options.find(
+        (opt) => opt.long === '--no-stream',
+      )
+      expect(streamOption).toBeDefined()
+      expect(streamOption?.description).toContain('Disable streaming')
+    })
+
+    it('should create completion with correct default options', async () => {
+      // Mock API key
+      process.env.BERGET_API_KEY = 'test-key'
+
+      // Mock successful completion
+      mockChatService.createCompletion.mockResolvedValue({
+        choices: [
+          {
+            message: { content: 'Test response' },
+          },
+        ],
+      })
+
+      // This would normally test the actual command execution
+      // but since it involves readline interaction, we just verify
+      // that the service would be called with correct defaults
+      expect(mockChatService.createCompletion).not.toHaveBeenCalled()
+
+      // Clean up
+      delete process.env.BERGET_API_KEY
+    })
+  })
+
+  describe('chat list command', () => {
+    it('should list available models', async () => {
+      const mockModels = {
+        data: [
+          {
+            id: 'gpt-oss',
+            owned_by: 'openai',
+            active: true,
+            capabilities: {
+              vision: false,
+              function_calling: true,
+              json_mode: true,
+            },
+          },
+        ],
+      }
+
+      mockChatService.listModels.mockResolvedValue(mockModels)
+
+      const chatCommand = program.commands.find((cmd) => cmd.name() === 'chat')
+      const listCommand = chatCommand?.commands.find(
+        (cmd) => cmd.name() === 'list',
+      )
+
+      expect(listCommand).toBeDefined()
+      expect(listCommand?.description()).toBe('List available chat models')
+    })
+  })
+})