@codeguide/core 0.0.1

package/__tests__/services/usage/usage-service.test.ts

@@ -0,0 +1,385 @@
+import { UsageService } from '../../../services/usage/usage-service'
+import { APIServiceConfig } from '../../../types'
+import axios from 'axios'
+import MockAdapter from 'axios-mock-adapter'
+import {
+  TrackUsageRequest,
+  CreditBalanceResponse,
+  CreditCheckResponse,
+  UsageSummaryResponse,
+  AuthorizationResponse,
+  CalculateUsageResponse,
+  TrackCodespaceUsageResponse,
+  CodespaceTaskUsageResponse,
+} from '../../../services/usage/usage-types'
+
+describe('UsageService', () => {
+  let mockAxios: MockAdapter
+  let usageService: UsageService
+  let config: APIServiceConfig
+
+  beforeEach(() => {
+    mockAxios = new MockAdapter(axios)
+    config = {
+      baseUrl: 'https://api.codeguide.app',
+      databaseApiKey: 'sk_test123',
+    }
+    usageService = new UsageService(config)
+  })
+
+  afterEach(() => {
+    mockAxios.restore()
+  })
+
+  describe('trackUsage', () => {
+    it('should track usage successfully', async () => {
+      const request: TrackUsageRequest = {
+        model_key: 'gpt-4',
+        input_tokens: 100,
+        output_tokens: 50,
+        call_seconds: 2,
+        cost_amount: 0.05,
+      }
+
+      const response: TrackUsageResponse = {
+        success: true,
+        credits_used: 0.05,
+        remaining_credits: 9.95,
+        message: 'Usage tracked successfully',
+      }
+
+      mockAxios.onPost('/v1/usage/track', request).reply(200, response)
+
+      const result = await usageService.trackUsage(request)
+
+      expect(result).toEqual(response)
+    })
+
+    it('should handle track usage errors', async () => {
+      const request: TrackUsageRequest = {
+        model_key: 'gpt-4',
+        input_tokens: 100,
+        output_tokens: 50,
+      }
+
+      mockAxios.onPost('/v1/usage/track', request).reply(400, {
+        detail: 'Invalid request',
+      })
+
+      await expect(usageService.trackUsage(request)).rejects.toThrow('API Error: Invalid request')
+    })
+  })
+
+  describe('getCreditBalance', () => {
+    it('should get credit balance successfully', async () => {
+      const response: CreditBalanceResponse = {
+        user_id: 'user123',
+        total_consumed: 10.5,
+        total_allotted: 100,
+        remaining_credits: 89.5,
+        utilization_percentage: 10.5,
+        billing_cycle_start: '2024-01-01',
+        billing_cycle_end: '2024-02-01',
+        subscription: {
+          plan: 'pro',
+          status: 'active',
+        },
+      }
+
+      mockAxios.onGet('/v1/usage/credit-balance').reply(200, response)
+
+      const result = await usageService.getCreditBalance()
+
+      expect(result).toEqual(response)
+    })
+  })
+
+  describe('checkCredits', () => {
+    it('should check credits with all parameters', async () => {
+      const params = {
+        model_key: 'gpt-4',
+        input_tokens: 100,
+        output_tokens: 50,
+        call_seconds: 2,
+      }
+
+      const response: CreditCheckResponse = {
+        has_sufficient_credits: true,
+        estimated_cost: 0.05,
+        remaining_credits: 89.5,
+        model_key: 'gpt-4',
+      }
+
+      mockAxios
+        .onGet(
+          '/v1/usage/credit-check?model_key=gpt-4&input_tokens=100&output_tokens=50&call_seconds=2'
+        )
+        .reply(200, response)
+
+      const result = await usageService.checkCredits(params)
+
+      expect(result).toEqual(response)
+    })
+
+    it('should check credits with partial parameters', async () => {
+      const params = {
+        model_key: 'gpt-4',
+        input_tokens: 100,
+      }
+
+      const response: CreditCheckResponse = {
+        has_sufficient_credits: true,
+        estimated_cost: 0.02,
+        remaining_credits: 89.5,
+        model_key: 'gpt-4',
+      }
+
+      mockAxios
+        .onGet('/v1/usage/credit-check?model_key=gpt-4&input_tokens=100')
+        .reply(200, response)
+
+      const result = await usageService.checkCredits(params)
+
+      expect(result).toEqual(response)
+    })
+  })
+
+  describe('getUsageSummary', () => {
+    it('should get usage summary with date range', async () => {
+      const params = {
+        start_date: '2024-01-01',
+        end_date: '2024-01-31',
+      }
+
+      const response: UsageSummaryResponse = {
+        user_id: 'user123',
+        period: {
+          start_date: '2024-01-01',
+          end_date: '2024-01-31',
+        },
+        usage_summary: {
+          total_credits_used: 15.5,
+          total_calls: 42,
+          model_breakdown: {
+            'gpt-4': { calls: 20, credits: 12.0 },
+            'gpt-3.5': { calls: 22, credits: 3.5 },
+          },
+          daily_usage: [
+            { date: '2024-01-01', credits_used: 1.5, calls: 5 },
+            { date: '2024-01-02', credits_used: 2.0, calls: 8 },
+          ],
+        },
+        subscription: {
+          plan: 'pro',
+          status: 'active',
+        },
+      }
+
+      mockAxios
+        .onGet('/v1/usage/summary?start_date=2024-01-01&end_date=2024-01-31')
+        .reply(200, response)
+
+      const result = await usageService.getUsageSummary(params)
+
+      expect(result).toEqual(response)
+    })
+
+    it('should get usage summary without date range', async () => {
+      const response: UsageSummaryResponse = {
+        user_id: 'user123',
+        period: {
+          start_date: '2024-01-01',
+          end_date: '2024-01-31',
+        },
+        usage_summary: {
+          total_credits_used: 15.5,
+          total_calls: 42,
+          model_breakdown: {},
+          daily_usage: [],
+        },
+        subscription: {
+          plan: 'pro',
+          status: 'active',
+        },
+      }
+
+      mockAxios.onGet('/v1/usage/summary').reply(200, response)
+
+      const result = await usageService.getUsageSummary()
+
+      expect(result).toEqual(response)
+    })
+  })
+
+  describe('getAuthorization', () => {
+    it('should get authorization info successfully', async () => {
+      const response: AuthorizationResponse = {
+        user_id: 'user123',
+        subscription: {
+          plan: 'pro',
+          status: 'active',
+          features: ['api-access', 'priority-queue'],
+        },
+        usage_limits: {
+          monthly_credits: 100,
+          max_calls_per_day: 1000,
+        },
+        permissions: ['read', 'write', 'delete'],
+      }
+
+      mockAxios.onGet('/v1/usage/authorization').reply(200, response)
+
+      const result = await usageService.getAuthorization()
+
+      expect(result).toEqual(response)
+    })
+  })
+
+  describe('getFreeUserStatus', () => {
+    it('should get free user status successfully', async () => {
+      const response = {
+        is_free_user: true,
+        has_available_credits: true,
+        credits_remaining: 5.0,
+        credits_expire_at: '2024-12-31',
+      }
+
+      mockAxios.onGet('/v1/usage/free-user-status').reply(200, response)
+
+      const result = await usageService.getFreeUserStatus()
+
+      expect(result).toEqual(response)
+    })
+  })
+
+  describe('calculateUsageCost', () => {
+    it('should calculate usage cost with all parameters', async () => {
+      const params = {
+        model_key: 'gpt-4',
+        input_tokens: 100,
+        output_tokens: 50,
+        call_seconds: 2,
+        cost_amount: 0.05,
+      }
+
+      const response: CalculateUsageResponse = {
+        model_key: 'gpt-4',
+        estimated_cost: 0.05,
+        calculation_breakdown: {
+          input_cost: 0.02,
+          output_cost: 0.02,
+          time_cost: 0.01,
+          total_cost: 0.05,
+        },
+      }
+
+      mockAxios
+        .onGet(
+          '/v1/usage/calculate?model_key=gpt-4&input_tokens=100&output_tokens=50&call_seconds=2&cost_amount=0.05'
+        )
+        .reply(200, response)
+
+      const result = await usageService.calculateUsageCost(params)
+
+      expect(result).toEqual(response)
+    })
+  })
+
+  describe('trackCodespaceUsage', () => {
+    it('should track codespace usage successfully', async () => {
+      const request = {
+        codespace_task_id: 'task123',
+        model_key: 'gpt-4',
+        input_tokens: 100,
+        output_tokens: 50,
+        call_seconds: 2,
+        cost_amount: 0.05,
+      }
+
+      const response: TrackCodespaceUsageResponse = {
+        id: 'usage123',
+        codespace_task_id: 'task123',
+        user_id: 'user123',
+        model_key: 'gpt-4',
+        input_tokens: 100,
+        output_tokens: 50,
+        call_seconds: 2,
+        cost_amount: 0.05,
+        created_at: '2024-01-01T00:00:00Z',
+      }
+
+      mockAxios.onPost('/v1/usage/codespace/track', request).reply(200, response)
+
+      const result = await usageService.trackCodespaceUsage(request)
+
+      expect(result).toEqual(response)
+    })
+  })
+
+  describe('getCodespaceTaskUsage', () => {
+    it('should get codespace task usage successfully', async () => {
+      const response: CodespaceTaskUsageResponse = {
+        codespace_task_id: 'task123',
+        total_usage: {
+          total_input_tokens: 200,
+          total_output_tokens: 100,
+          total_call_seconds: 4,
+          total_cost: 0.1,
+        },
+        usage_records: [
+          {
+            id: 'usage123',
+            codespace_task_id: 'task123',
+            user_id: 'user123',
+            model_key: 'gpt-4',
+            input_tokens: 100,
+            output_tokens: 50,
+            call_seconds: 2,
+            cost_amount: 0.05,
+            created_at: '2024-01-01T00:00:00Z',
+          },
+        ],
+      }
+
+      mockAxios.onGet('/v1/usage/codespace/task/task123').reply(200, response)
+
+      const result = await usageService.getCodespaceTaskUsage('task123')
+
+      expect(result).toEqual(response)
+    })
+  })
+
+  describe('healthCheck', () => {
+    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 usageService.healthCheck()
+
+      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 usageService.healthCheck()
+
+      expect(result).toBe(false)
+    })
+
+    it('should return false when health check fails', async () => {
+      mockAxios.onGet('/v1/usage/health').reply(500)
+
+      const result = await usageService.healthCheck()
+
+      expect(result).toBe(false)
+    })
+  })
+})

package/__tests__/simple.test.ts

@@ -0,0 +1,10 @@
+describe('Simple Test', () => {
+  it('should pass a simple test', () => {
+    expect(1 + 1).toBe(2)
+  })
+
+  it('should handle async operations', async () => {
+    const promise = Promise.resolve('test')
+    await expect(promise).resolves.toBe('test')
+  })
+})

package/__tests__/test-service.ts

@@ -0,0 +1,37 @@
+import { BaseService } from '../services/base/base-service'
+import { APIServiceConfig } from '../types'
+
+export class TestService extends BaseService {
+  constructor(config: APIServiceConfig) {
+    super(config)
+  }
+
+  // Public methods to test protected methods
+  public async testGet(url: string, config?: any): Promise<any> {
+    return this.get(url, config)
+  }
+
+  public async testPost(url: string, data?: any, config?: any): Promise<any> {
+    return this.post(url, data, config)
+  }
+
+  public async testPut(url: string, data?: any, config?: any): Promise<any> {
+    return this.put(url, data, config)
+  }
+
+  public async testDelete(url: string, config?: any): Promise<any> {
+    return this.delete(url, config)
+  }
+
+  public testBuildUrl(endpoint: string): string {
+    return this.buildUrl(endpoint)
+  }
+
+  public testGetAuthenticationMethod() {
+    return this.getAuthenticationMethod()
+  }
+
+  public testValidateAuthentication() {
+    return this.validateAuthentication()
+  }
+}

package/api-service.ts

@@ -0,0 +1,67 @@
+import dotenv from 'dotenv'
+import path from 'path'
+
+// Load environment variables from project root
+dotenv.config({
+  path: path.resolve(__dirname, '../../../.env'),
+  quiet: true,
+})
+import axios, { AxiosInstance } from 'axios'
+import { CodeGuideRequest, CodeGuideResponse, APIServiceConfig } from './types'
+
+export class APIService {
+  private client: AxiosInstance
+  private config: APIServiceConfig
+
+  constructor(config: APIServiceConfig) {
+    this.config = config
+
+    // Ensure baseUrl includes the API version
+    const baseUrl = config.baseUrl.endsWith('/v1')
+      ? config.baseUrl
+      : `${config.baseUrl}${config.baseUrl.endsWith('/') ? '' : '/'}v1`
+
+    this.client = axios.create({
+      baseURL: baseUrl,
+      timeout: config.timeout || 3600000, // 1 hour timeout for document generation
+      headers: {
+        'Content-Type': 'application/json',
+        ...(config.apiKey && { 'X-API-Key': config.apiKey }),
+        ...(config.userId && { 'X-User-ID': config.userId }),
+      },
+    })
+  }
+
+  async getCodeGuide(request: CodeGuideRequest): Promise<CodeGuideResponse> {
+    try {
+      // Use the appropriate endpoint based on the API documentation
+      const response = await this.client.post<CodeGuideResponse>('/generate/refine-prompt', {
+        user_prompt: request.prompt,
+        ...request,
+      })
+      return {
+        id: response.data.id || Date.now().toString(),
+        response: response.data.refined_prompt || response.data.content || 'No response available',
+        timestamp: new Date().toISOString(),
+        language: request.language,
+      }
+    } catch (error) {
+      if (axios.isAxiosError(error)) {
+        throw new Error(
+          `API Error: ${error.response?.data?.detail || error.response?.data?.message || error.message}`
+        )
+      }
+      throw new Error(`Unknown error: ${error instanceof Error ? error.message : 'Unknown error'}`)
+    }
+  }
+
+  async healthCheck(): Promise<boolean> {
+    try {
+      // Use usage health endpoint from API documentation
+      await this.client.get('/usage/health')
+      return true
+    } catch {
+      return false
+    }
+  }
+}

package/codeguide.ts

@@ -0,0 +1,70 @@
+import dotenv from 'dotenv'
+import path from 'path'
+
+// Load environment variables from project root
+dotenv.config({
+  path: path.resolve(__dirname, '../../../.env'),
+  quiet: true,
+})
+import {
+  GenerationService,
+  ProjectService,
+  UsageService,
+  RepositoryAnalysisService,
+  TaskService,
+} from './services'
+import { APIServiceConfig, CodeGuideOptions } from './types'
+
+export class CodeGuide {
+  public generation: GenerationService
+  public projects: ProjectService
+  public usage: UsageService
+  public repositoryAnalysis: RepositoryAnalysisService
+  public tasks: TaskService
+  private options: CodeGuideOptions
+
+  constructor(config: APIServiceConfig, options: CodeGuideOptions = {}) {
+    this.options = options
+
+    // Initialize all services with the same config
+    this.generation = new GenerationService(config)
+    this.projects = new ProjectService(config)
+    this.usage = new UsageService(config)
+    this.repositoryAnalysis = new RepositoryAnalysisService(config)
+    this.tasks = new TaskService(config)
+  }
+
+  // Convenience method for backward compatibility
+  async getGuidance(prompt: string): Promise<any> {
+    const request = {
+      user_prompt: prompt,
+      ...(this.options.language && { language: this.options.language }),
+      ...(this.options.context && { context: this.options.context }),
+    }
+
+    if (this.options.verbose) {
+      console.log('Sending request:', JSON.stringify(request, null, 2))
+    }
+
+    const response = await this.generation.refinePrompt(request)
+
+    if (this.options.verbose) {
+      console.log('Received response:', JSON.stringify(response, null, 2))
+    }
+
+    return {
+      id: Date.now().toString(),
+      response: response.refined_prompt,
+      timestamp: new Date().toISOString(),
+      language: this.options.language,
+    }
+  }
+
+  async isHealthy(): Promise<boolean> {
+    return this.usage.healthCheck()
+  }
+
+  setOptions(options: Partial<CodeGuideOptions>): void {
+    this.options = { ...this.options, ...options }
+  }
+}

package/dist/__tests__/test-service.d.ts

@@ -0,0 +1,12 @@
+import { BaseService } from '../services/base/base-service';
+import { APIServiceConfig } from '../types';
+export declare class TestService extends BaseService {
+    constructor(config: APIServiceConfig);
+    testGet(url: string, config?: any): Promise<any>;
+    testPost(url: string, data?: any, config?: any): Promise<any>;
+    testPut(url: string, data?: any, config?: any): Promise<any>;
+    testDelete(url: string, config?: any): Promise<any>;
+    testBuildUrl(endpoint: string): string;
+    testGetAuthenticationMethod(): import("../types").AuthenticationMethod | null;
+    testValidateAuthentication(): import("../types").AuthenticationResult;
+}

package/dist/__tests__/test-service.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestService = void 0;
+const base_service_1 = require("../services/base/base-service");
+class TestService extends base_service_1.BaseService {
+    constructor(config) {
+        super(config);
+    }
+    // Public methods to test protected methods
+    async testGet(url, config) {
+        return this.get(url, config);
+    }
+    async testPost(url, data, config) {
+        return this.post(url, data, config);
+    }
+    async testPut(url, data, config) {
+        return this.put(url, data, config);
+    }
+    async testDelete(url, config) {
+        return this.delete(url, config);
+    }
+    testBuildUrl(endpoint) {
+        return this.buildUrl(endpoint);
+    }
+    testGetAuthenticationMethod() {
+        return this.getAuthenticationMethod();
+    }
+    testValidateAuthentication() {
+        return this.validateAuthentication();
+    }
+}
+exports.TestService = TestService;

package/dist/api-service.d.ts

@@ -0,0 +1,8 @@
+import { CodeGuideRequest, CodeGuideResponse, APIServiceConfig } from './types';
+export declare class APIService {
+    private client;
+    private config;
+    constructor(config: APIServiceConfig);
+    getCodeGuide(request: CodeGuideRequest): Promise<CodeGuideResponse>;
+    healthCheck(): Promise<boolean>;
+}

package/dist/api-service.js

@@ -0,0 +1,64 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.APIService = void 0;
+const dotenv_1 = __importDefault(require("dotenv"));
+const path_1 = __importDefault(require("path"));
+// Load environment variables from project root
+dotenv_1.default.config({
+    path: path_1.default.resolve(__dirname, '../../../.env'),
+    quiet: true,
+});
+const axios_1 = __importDefault(require("axios"));
+class APIService {
+    constructor(config) {
+        this.config = config;
+        // Ensure baseUrl includes the API version
+        const baseUrl = config.baseUrl.endsWith('/v1')
+            ? config.baseUrl
+            : `${config.baseUrl}${config.baseUrl.endsWith('/') ? '' : '/'}v1`;
+        this.client = axios_1.default.create({
+            baseURL: baseUrl,
+            timeout: config.timeout || 3600000, // 1 hour timeout for document generation
+            headers: {
+                'Content-Type': 'application/json',
+                ...(config.apiKey && { 'X-API-Key': config.apiKey }),
+                ...(config.userId && { 'X-User-ID': config.userId }),
+            },
+        });
+    }
+    async getCodeGuide(request) {
+        try {
+            // Use the appropriate endpoint based on the API documentation
+            const response = await this.client.post('/generate/refine-prompt', {
+                user_prompt: request.prompt,
+                ...request,
+            });
+            return {
+                id: response.data.id || Date.now().toString(),
+                response: response.data.refined_prompt || response.data.content || 'No response available',
+                timestamp: new Date().toISOString(),
+                language: request.language,
+            };
+        }
+        catch (error) {
+            if (axios_1.default.isAxiosError(error)) {
+                throw new Error(`API Error: ${error.response?.data?.detail || error.response?.data?.message || error.message}`);
+            }
+            throw new Error(`Unknown error: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    async healthCheck() {
+        try {
+            // Use usage health endpoint from API documentation
+            await this.client.get('/usage/health');
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+exports.APIService = APIService;