@codeguide/core 0.0.1

package/__tests__/authentication.test.ts

@@ -0,0 +1,259 @@
+import { TestService } from './test-service'
+import { APIServiceConfig, AuthenticationMethod } from '../types'
+
+describe('Authentication Priority System', () => {
+  describe('Priority Order', () => {
+    it('should always prefer database API key over other methods', () => {
+      const testCases = [
+        {
+          config: {
+            baseUrl: 'https://api.codeguide.app',
+            databaseApiKey: 'sk_test123',
+            apiKey: 'legacy_key',
+            userId: 'user123',
+            jwtToken: 'jwt_token',
+          },
+          expectedType: 'database-api-key',
+        },
+        {
+          config: {
+            baseUrl: 'https://api.codeguide.app',
+            databaseApiKey: 'sk_test123',
+            jwtToken: 'jwt_token',
+          },
+          expectedType: 'database-api-key',
+        },
+        {
+          config: {
+            baseUrl: 'https://api.codeguide.app',
+            databaseApiKey: 'sk_test123',
+            apiKey: 'legacy_key',
+            userId: 'user123',
+          },
+          expectedType: 'database-api-key',
+        },
+      ]
+
+      testCases.forEach(({ config, expectedType }) => {
+        const service = new TestService(config)
+        const authMethod = service.getAuthenticationMethod()
+        expect(authMethod?.type).toBe(expectedType)
+      })
+    })
+
+    it('should prefer legacy API key + user ID over JWT when no database key', () => {
+      const config: APIServiceConfig = {
+        baseUrl: 'https://api.codeguide.app',
+        apiKey: 'legacy_key',
+        userId: 'user123',
+        jwtToken: 'jwt_token',
+      }
+
+      const service = new TestService(config)
+      const authMethod = service.getAuthenticationMethod()
+
+      expect(authMethod?.type).toBe('legacy-api-key')
+      expect(authMethod?.priority).toBe(2)
+    })
+
+    it('should use JWT as fallback when only method available', () => {
+      const config: APIServiceConfig = {
+        baseUrl: 'https://api.codeguide.app',
+        jwtToken: 'jwt_token',
+      }
+
+      const service = new TestService(config)
+      const authMethod = service.getAuthenticationMethod()
+
+      expect(authMethod?.type).toBe('clerk-jwt')
+      expect(authMethod?.priority).toBe(3)
+    })
+  })
+
+  describe('Header Generation', () => {
+    it('should generate correct headers for database API key', () => {
+      const config: APIServiceConfig = {
+        baseUrl: 'https://api.codeguide.app',
+        databaseApiKey: 'sk_test123',
+      }
+
+      const service = new TestService(config)
+      const authMethod = service.getAuthenticationMethod()
+
+      expect(authMethod?.headers).toEqual({
+        Authorization: 'Bearer sk_test123',
+        'Content-Type': 'application/json',
+      })
+    })
+
+    it('should generate correct headers for legacy API key', () => {
+      const config: APIServiceConfig = {
+        baseUrl: 'https://api.codeguide.app',
+        apiKey: 'legacy_key',
+        userId: 'user123',
+      }
+
+      const service = new TestService(config)
+      const authMethod = service.getAuthenticationMethod()
+
+      expect(authMethod?.headers).toEqual({
+        'X-API-Key': 'legacy_key',
+        'X-User-ID': 'user123',
+        'Content-Type': 'application/json',
+      })
+    })
+
+    it('should generate correct headers for JWT token', () => {
+      const config: APIServiceConfig = {
+        baseUrl: 'https://api.codeguide.app',
+        jwtToken: 'jwt_token',
+      }
+
+      const service = new TestService(config)
+      const authMethod = service.getAuthenticationMethod()
+
+      expect(authMethod?.headers).toEqual({
+        Authorization: 'Bearer jwt_token',
+        'Content-Type': 'application/json',
+      })
+    })
+
+    it('should generate headers for legacy API key without user ID', () => {
+      const config: APIServiceConfig = {
+        baseUrl: 'https://api.codeguide.app',
+        apiKey: 'legacy_key',
+      }
+
+      const service = new TestService(config)
+      const authMethod = service.getAuthenticationMethod()
+
+      expect(authMethod?.headers).toEqual({
+        'X-API-Key': 'legacy_key',
+        'Content-Type': 'application/json',
+      })
+    })
+  })
+
+  describe('Validation Scenarios', () => {
+    it('should reject database API key without sk_ prefix', () => {
+      const invalidConfigs = [
+        { databaseApiKey: 'test123' },
+        { databaseApiKey: 'pk_test123' },
+        { databaseApiKey: 'sktest123' },
+        { databaseApiKey: '' },
+      ]
+
+      invalidConfigs.forEach(config => {
+        const fullConfig: APIServiceConfig = {
+          baseUrl: 'https://api.codeguide.app',
+          ...config,
+        }
+
+        const service = new TestService(fullConfig)
+        const result = service.validateAuthentication()
+
+        expect(result.success).toBe(false)
+        expect(result.error).toContain('must start with "sk_"')
+      })
+    })
+
+    it('should accept valid database API key formats', () => {
+      const validConfigs = ['sk_test123', 'sk_prod_abc123', 'sk_123456789', 'sk_live_xxx']
+
+      validConfigs.forEach(apiKey => {
+        const config: APIServiceConfig = {
+          baseUrl: 'https://api.codeguide.app',
+          databaseApiKey: apiKey,
+        }
+
+        const service = new TestService(config)
+        const result = service.validateAuthentication()
+
+        expect(result.success).toBe(true)
+        expect(result.method?.type).toBe('database-api-key')
+      })
+    })
+
+    it('should handle mixed authentication configurations', () => {
+      const mixedConfigs = [
+        {
+          config: {
+            baseUrl: 'https://api.codeguide.app',
+            apiKey: 'legacy_key',
+            jwtToken: 'jwt_token',
+          },
+          expectedType: 'legacy-api-key',
+        },
+        {
+          config: {
+            baseUrl: 'https://api.codeguide.app',
+            apiKey: 'legacy_key',
+            userId: 'user123',
+            databaseApiKey: 'sk_test123',
+          },
+          expectedType: 'database-api-key',
+        },
+        {
+          config: {
+            baseUrl: 'https://api.codeguide.app',
+            jwtToken: 'jwt_token',
+            databaseApiKey: 'invalid_key',
+          },
+          expectedType: 'clerk-jwt',
+        },
+      ]
+
+      mixedConfigs.forEach(({ config, expectedType }) => {
+        const service = new TestService(config)
+        const result = service.validateAuthentication()
+
+        if (expectedType === 'database-api-key' && config.databaseApiKey === 'invalid_key') {
+          expect(result.success).toBe(false)
+        } else {
+          expect(result.success).toBe(true)
+          expect(result.method?.type).toBe(expectedType)
+        }
+      })
+    })
+  })
+
+  describe('Priority Consistency', () => {
+    it('should maintain consistent priority numbers', () => {
+      const config: APIServiceConfig = {
+        baseUrl: 'https://api.codeguide.app',
+        databaseApiKey: 'sk_test123',
+        apiKey: 'legacy_key',
+        userId: 'user123',
+        jwtToken: 'jwt_token',
+      }
+
+      const service = new TestService(config)
+      const authMethod = service.getAuthenticationMethod()
+
+      expect(authMethod?.priority).toBe(1)
+
+      // Test other methods
+      const noDbConfig: APIServiceConfig = {
+        baseUrl: 'https://api.codeguide.app',
+        apiKey: 'legacy_key',
+        userId: 'user123',
+        jwtToken: 'jwt_token',
+      }
+
+      const noDbService = new BaseService(noDbConfig)
+      const noDbAuthMethod = noDbService.getAuthenticationMethod()
+
+      expect(noDbAuthMethod?.priority).toBe(2)
+
+      const jwtOnlyConfig: APIServiceConfig = {
+        baseUrl: 'https://api.codeguide.app',
+        jwtToken: 'jwt_token',
+      }
+
+      const jwtOnlyService = new BaseService(jwtOnlyConfig)
+      const jwtOnlyAuthMethod = jwtOnlyService.getAuthenticationMethod()
+
+      expect(jwtOnlyAuthMethod?.priority).toBe(3)
+    })
+  })
+})

package/__tests__/codeguide.test.ts

@@ -0,0 +1,293 @@
+import { CodeGuide } from '../codeguide'
+import { APIServiceConfig, CodeGuideOptions } from '../types'
+import axios from 'axios'
+import MockAdapter from 'axios-mock-adapter'
+
+// Mock the generation service
+jest.mock('../services/generation/generation-service', () => ({
+  GenerationService: jest.fn().mockImplementation(() => ({
+    refinePrompt: jest.fn(),
+  })),
+}))
+
+describe('CodeGuide', () => {
+  let mockAxios: MockAdapter
+  let codeguide: CodeGuide
+  let config: APIServiceConfig
+  let options: CodeGuideOptions
+
+  beforeEach(() => {
+    mockAxios = new MockAdapter(axios)
+    config = {
+      baseUrl: 'https://api.codeguide.app',
+      databaseApiKey: 'sk_test123',
+    }
+    options = {
+      language: 'typescript',
+      context: 'CLI testing',
+      verbose: false,
+    }
+    codeguide = new CodeGuide(config, options)
+  })
+
+  afterEach(() => {
+    mockAxios.restore()
+  })
+
+  describe('Constructor', () => {
+    it('should initialize all services', () => {
+      expect(codeguide.generation).toBeDefined()
+      expect(codeguide.projects).toBeDefined()
+      expect(codeguide.usage).toBeDefined()
+      expect(codeguide.repositoryAnalysis).toBeDefined()
+      expect(codeguide.tasks).toBeDefined()
+    })
+
+    it('should initialize with default options', () => {
+      const simpleCodeguide = new CodeGuide(config)
+      expect(simpleCodeguide).toBeDefined()
+    })
+  })
+
+  describe('getGuidance', () => {
+    it('should get guidance successfully', async () => {
+      const prompt = 'How do I create a React component?'
+      const mockResponse = {
+        refined_prompt:
+          'To create a React component, you can use either functional components with hooks or class components.',
+        original_prompt: prompt,
+      }
+
+      mockAxios.onPost('/v1/generation/refine-prompt').reply(200, mockResponse)
+
+      const result = await codeguide.getGuidance(prompt)
+
+      expect(result).toEqual({
+        id: expect.any(String),
+        response: mockResponse.refined_prompt,
+        timestamp: expect.any(String),
+        language: 'typescript',
+      })
+    })
+
+    it('should include language in request when provided', async () => {
+      const prompt = 'How do I create a React component?'
+      const mockResponse = {
+        refined_prompt: 'Here is how to create a React component in TypeScript...',
+      }
+
+      mockAxios.onPost('/v1/generation/refine-prompt').reply(200, mockResponse)
+
+      await codeguide.getGuidance(prompt)
+
+      const request = mockAxios.history.post[0]
+      const requestData = JSON.parse(request.data)
+
+      expect(requestData.language).toBe('typescript')
+    })
+
+    it('should include context in request when provided', async () => {
+      const prompt = 'How do I create a React component?'
+      const mockResponse = {
+        refined_prompt: 'Here is how to create a React component...',
+      }
+
+      mockAxios.onPost('/v1/generation/refine-prompt').reply(200, mockResponse)
+
+      await codeguide.getGuidance(prompt)
+
+      const request = mockAxios.history.post[0]
+      const requestData = JSON.parse(request.data)
+
+      expect(requestData.context).toBe('CLI testing')
+    })
+
+    it('should not include optional fields when not provided', async () => {
+      const simpleOptions: CodeGuideOptions = {}
+      const simpleCodeguide = new CodeGuide(config, simpleOptions)
+      const prompt = 'How do I create a React component?'
+      const mockResponse = {
+        refined_prompt: 'Here is how to create a React component...',
+      }
+
+      mockAxios.onPost('/v1/generation/refine-prompt').reply(200, mockResponse)
+
+      await simpleCodeguide.getGuidance(prompt)
+
+      const request = mockAxios.history.post[0]
+      const requestData = JSON.parse(request.data)
+
+      expect(requestData).not.toHaveProperty('language')
+      expect(requestData).not.toHaveProperty('context')
+    })
+
+    it('should handle API errors gracefully', async () => {
+      const prompt = 'How do I create a React component?'
+
+      mockAxios.onPost('/v1/generation/refine-prompt').reply(400, {
+        detail: 'Invalid prompt format',
+      })
+
+      await expect(codeguide.getGuidance(prompt)).rejects.toThrow(
+        'API Error: Invalid prompt format'
+      )
+    })
+
+    it('should log request and response when verbose mode is enabled', async () => {
+      const verboseOptions: CodeGuideOptions = {
+        verbose: true,
+      }
+      const verboseCodeguide = new CodeGuide(config, verboseOptions)
+      const prompt = 'How do I create a React component?'
+      const mockResponse = {
+        refined_prompt: 'Here is how to create a React component...',
+      }
+
+      // Mock console.log to verify it's called
+      const consoleSpy = jest.spyOn(console, 'log').mockImplementation()
+
+      mockAxios.onPost('/v1/generation/refine-prompt').reply(200, mockResponse)
+
+      await verboseCodeguide.getGuidance(prompt)
+
+      expect(consoleSpy).toHaveBeenCalledWith(
+        'Sending request:',
+        expect.stringContaining('user_prompt')
+      )
+      expect(consoleSpy).toHaveBeenCalledWith(
+        'Received response:',
+        expect.stringContaining('refined_prompt')
+      )
+
+      consoleSpy.mockRestore()
+    })
+  })
+
+  describe('isHealthy', () => {
+    it('should return true when API is healthy', async () => {
+      mockAxios.onGet('/v1/usage/health').reply(200, {
+        status: 'healthy',
+        timestamp: '2024-01-01T00:00:00Z',
+        version: '1.0.0',
+      })
+
+      const result = await codeguide.isHealthy()
+
+      expect(result).toBe(true)
+    })
+
+    it('should return false when API is not healthy', async () => {
+      mockAxios.onGet('/v1/usage/health').reply(200, {
+        status: 'unhealthy',
+        timestamp: '2024-01-01T00:00:00Z',
+        version: '1.0.0',
+      })
+
+      const result = await codeguide.isHealthy()
+
+      expect(result).toBe(false)
+    })
+
+    it('should return false when health check fails', async () => {
+      mockAxios.onGet('/v1/usage/health').reply(500)
+
+      const result = await codeguide.isHealthy()
+
+      expect(result).toBe(false)
+    })
+  })
+
+  describe('setOptions', () => {
+    it('should update options partially', () => {
+      const initialOptions = { ...options }
+      expect((codeguide as any).options).toEqual(initialOptions)
+
+      const newOptions: Partial<CodeGuideOptions> = {
+        language: 'javascript',
+        verbose: true,
+      }
+
+      codeguide.setOptions(newOptions)
+
+      expect((codeguide as any).options).toEqual({
+        language: 'javascript',
+        context: 'CLI testing',
+        verbose: true,
+      })
+    })
+
+    it('should add new options', () => {
+      const newOptions: Partial<CodeGuideOptions> = {
+        context: 'Updated context',
+      }
+
+      codeguide.setOptions(newOptions)
+
+      expect((codeguide as any).options.context).toBe('Updated context')
+    })
+
+    it('should handle empty options object', () => {
+      const originalOptions = { ...(codeguide as any).options }
+
+      codeguide.setOptions({})
+
+      expect((codeguide as any).options).toEqual(originalOptions)
+    })
+  })
+
+  describe('Service Access', () => {
+    it('should provide access to all services', () => {
+      expect(codeguide.generation).toBeDefined()
+      expect(codeguide.projects).toBeDefined()
+      expect(codeguide.usage).toBeDefined()
+      expect(codeguide.repositoryAnalysis).toBeDefined()
+      expect(codeguide.tasks).toBeDefined()
+
+      // Verify services are properly configured with the same auth config
+      expect((codeguide.generation as any).config).toEqual(config)
+      expect((codeguide.projects as any).config).toEqual(config)
+      expect((codeguide.usage as any).config).toEqual(config)
+      expect((codeguide.repositoryAnalysis as any).config).toEqual(config)
+      expect((codeguide.tasks as any).config).toEqual(config)
+    })
+  })
+
+  describe('Different Authentication Methods', () => {
+    it('should work with legacy API key authentication', () => {
+      const legacyConfig: APIServiceConfig = {
+        baseUrl: 'https://api.codeguide.app',
+        apiKey: 'legacy_key',
+        userId: 'user123',
+      }
+
+      const legacyCodeguide = new CodeGuide(legacyConfig, options)
+
+      expect(legacyCodeguide.generation).toBeDefined()
+      expect(legacyCodeguide.usage).toBeDefined()
+    })
+
+    it('should work with JWT authentication', () => {
+      const jwtConfig: APIServiceConfig = {
+        baseUrl: 'https://api.codeguide.app',
+        jwtToken: 'jwt_token',
+      }
+
+      const jwtCodeguide = new CodeGuide(jwtConfig, options)
+
+      expect(jwtCodeguide.generation).toBeDefined()
+      expect(jwtCodeguide.usage).toBeDefined()
+    })
+
+    it('should work with database API key authentication', () => {
+      const dbConfig: APIServiceConfig = {
+        baseUrl: 'https://api.codeguide.app',
+        databaseApiKey: 'sk_test123',
+      }
+
+      const dbCodeguide = new CodeGuide(dbConfig, options)
+
+      expect(dbCodeguide.generation).toBeDefined()
+      expect(dbCodeguide.usage).toBeDefined()
+    })
+  })
+})