@codeguide/core 0.0.17 → 0.0.18

package/__tests__/services/codespace/codespace-v2.test.ts

@@ -0,0 +1,260 @@
+import { CodespaceService } from '../../../services/codespace/codespace-service'
+import {
+  CreateCodespaceTaskRequestV2,
+  CreateBackgroundCodespaceTaskRequest,
+  ModelApiKey
+} from '../../../services/codespace/codespace-types'
+import { APIServiceConfig } from '../../../types'
+import axios from 'axios'
+import MockAdapter from 'axios-mock-adapter'
+
+describe('CodespaceService - V2 Task Endpoints', () => {
+  let mockAxios: MockAdapter
+  let codespaceService: CodespaceService
+  let config: APIServiceConfig
+
+  beforeEach(() => {
+    mockAxios = new MockAdapter(axios)
+    config = {
+      baseUrl: 'https://api.example.com',
+      databaseApiKey: 'sk_test123',
+    }
+    codespaceService = new CodespaceService(config)
+  })
+
+  afterEach(() => {
+    mockAxios.restore()
+  })
+
+  describe('createCodespaceTaskV2', () => {
+    const validRequest: CreateCodespaceTaskRequestV2 = {
+      project_id: 'project-123',
+      task_description: 'Create a new authentication system',
+      title: 'Auth System Implementation',
+      execution_mode: 'implementation',
+    }
+
+    it('should create a codespace task successfully', async () => {
+      const mockResponse = {
+        success: true,
+        task_id: 'task-456',
+        message: 'Task created successfully',
+        status: 'pending',
+        created_at: '2023-01-01T00:00:00Z',
+      }
+
+      mockAxios.onPost('/codespace/task', validRequest).reply(200, mockResponse)
+
+      const result = await codespaceService.createCodespaceTaskV2(validRequest)
+
+      expect(result).toEqual(mockResponse)
+    })
+
+    it('should throw error for missing project_id', async () => {
+      const invalidRequest = {
+        task_description: 'Create a new feature',
+      }
+
+      await expect(codespaceService.createCodespaceTaskV2(invalidRequest as any))
+        .rejects.toThrow('project_id is required')
+    })
+
+    it('should throw error for missing task_description', async () => {
+      const invalidRequest = {
+        project_id: 'project-123',
+      }
+
+      await expect(codespaceService.createCodespaceTaskV2(invalidRequest as any))
+        .rejects.toThrow('task_description is required')
+    })
+
+    it('should set default base_branch to main', async () => {
+      const requestWithoutBaseBranch = {
+        project_id: 'project-123',
+        task_description: 'Create a feature',
+      }
+
+      const mockResponse = {
+        success: true,
+        task_id: 'task-456',
+        message: 'Task created successfully',
+      }
+
+      mockAxios.onPost('/codespace/task', expect.objectContaining({
+        base_branch: 'main'
+      })).reply(200, mockResponse)
+
+      const result = await codespaceService.createCodespaceTaskV2(requestWithoutBaseBranch)
+
+      expect(result).toEqual(mockResponse)
+    })
+
+    it('should validate execution_mode', async () => {
+      const invalidRequest = {
+        project_id: 'project-123',
+        task_description: 'Create a feature',
+        execution_mode: 'invalid-mode' as any,
+      }
+
+      await expect(codespaceService.createCodespaceTaskV2(invalidRequest))
+        .rejects.toThrow('execution_mode must be either "implementation" or "docs-only"')
+    })
+
+    it('should accept valid execution modes', async () => {
+      const validModes = ['implementation', 'docs-only'] as const
+
+      for (const mode of validModes) {
+        const request = {
+          project_id: 'project-123',
+          task_description: 'Create a feature',
+          execution_mode: mode,
+        }
+
+        const mockResponse = {
+          success: true,
+          task_id: 'task-456',
+          message: 'Task created successfully',
+        }
+
+        mockAxios.onPost('/codespace/task', request).reply(200, mockResponse)
+
+        const result = await codespaceService.createCodespaceTaskV2(request)
+        expect(result).toEqual(mockResponse)
+      }
+    })
+
+    it('should validate model_api_keys structure', async () => {
+      const invalidRequest = {
+        project_id: 'project-123',
+        task_description: 'Create a feature',
+        model_api_keys: 'not-an-array' as any,
+      }
+
+      await expect(codespaceService.createCodespaceTaskV2(invalidRequest))
+        .rejects.toThrow('model_api_keys must be an array')
+    })
+
+    it('should validate individual model_api_key entries', async () => {
+      const invalidRequest = {
+        project_id: 'project-123',
+        task_description: 'Create a feature',
+        model_api_keys: [
+          { model_name: '', api_key: 'key1' }, // Empty model_name
+          { model_name: 'model2', api_key: '' }, // Empty api_key
+        ],
+      }
+
+      await expect(codespaceService.createCodespaceTaskV2(invalidRequest))
+        .rejects.toThrow('Each model_api_key must have a valid model_name string')
+    })
+
+    it('should accept valid model_api_keys', async () => {
+      const validModelApiKeys: ModelApiKey[] = [
+        { model_name: 'gpt-4', api_key: 'sk-key1' },
+        { model_name: 'claude-3', api_key: 'sk-key2' },
+      ]
+
+      const request = {
+        project_id: 'project-123',
+        task_description: 'Create a feature',
+        model_api_keys: validModelApiKeys,
+      }
+
+      const mockResponse = {
+        success: true,
+        task_id: 'task-456',
+        message: 'Task created successfully',
+      }
+
+      mockAxios.onPost('/codespace/task', request).reply(200, mockResponse)
+
+      const result = await codespaceService.createCodespaceTaskV2(request)
+      expect(result).toEqual(mockResponse)
+    })
+
+    it('should work with all optional fields', async () => {
+      const fullRequest: CreateCodespaceTaskRequestV2 = {
+        project_id: 'project-123',
+        project_repository_id: 'repo-456',
+        task_description: 'Create comprehensive feature',
+        title: 'Full Feature Implementation',
+        branch: 'feature-branch',
+        working_branch: 'work-branch',
+        base_branch: 'develop',
+        docs_url: 'https://docs.example.com',
+        model_api_keys: [{ model_name: 'gpt-4', api_key: 'sk-key' }],
+        github_token: 'ghp_token123',
+        codespace_task_id: 'existing-task-789',
+        execution_mode: 'implementation',
+        model_name: 'gpt-4',
+        starter_kit_repo: 'https://github.com/example/starter-kit',
+      }
+
+      const mockResponse = {
+        success: true,
+        task_id: 'task-456',
+        message: 'Task created successfully',
+        status: 'pending',
+        created_at: '2023-01-01T00:00:00Z',
+      }
+
+      mockAxios.onPost('/codespace/task', fullRequest).reply(200, mockResponse)
+
+      const result = await codespaceService.createCodespaceTaskV2(fullRequest)
+      expect(result).toEqual(mockResponse)
+    })
+  })
+
+  describe('createBackgroundCodespaceTask', () => {
+    const validRequest: CreateBackgroundCodespaceTaskRequest = {
+      project_id: 'project-123',
+      task_description: 'Create background task',
+      execution_mode: 'docs-only',
+    }
+
+    it('should create a background codespace task successfully', async () => {
+      const mockResponse = {
+        success: true,
+        task_id: 'bg-task-456',
+        message: 'Background task created successfully',
+        status: 'queued',
+        created_at: '2023-01-01T00:00:00Z',
+      }
+
+      mockAxios.onPost('/codespace/task/background', validRequest).reply(200, mockResponse)
+
+      const result = await codespaceService.createBackgroundCodespaceTask(validRequest)
+
+      expect(result).toEqual(mockResponse)
+    })
+
+    it('should apply same validation as regular task creation', async () => {
+      const invalidRequest = {
+        task_description: 'Missing project_id',
+      }
+
+      await expect(codespaceService.createBackgroundCodespaceTask(invalidRequest as any))
+        .rejects.toThrow('project_id is required')
+    })
+
+    it('should work with docs-only mode', async () => {
+      const docsOnlyRequest = {
+        project_id: 'project-123',
+        task_description: 'Generate documentation',
+        execution_mode: 'docs-only' as const,
+      }
+
+      const mockResponse = {
+        success: true,
+        task_id: 'docs-task-789',
+        message: 'Documentation task created',
+        status: 'pending',
+      }
+
+      mockAxios.onPost('/codespace/task/background', docsOnlyRequest).reply(200, mockResponse)
+
+      const result = await codespaceService.createBackgroundCodespaceTask(docsOnlyRequest)
+      expect(result).toEqual(mockResponse)
+    })
+  })
+})

package/dist/index.d.ts

@@ -2,3 +2,4 @@ export { CodeGuide } from './codeguide';
 export * from './services';
 export * from './types';
 export type { ConnectRepositoryRequest, ConnectRepositoryResponse } from './services/projects/project-types';
+export type { CreateCodespaceTaskRequestV2 as CreateCodespaceTaskRequest, CreateCodespaceTaskResponseV2 as CreateCodespaceTaskResponse, CreateBackgroundCodespaceTaskRequest, CreateBackgroundCodespaceTaskResponse, ModelApiKey } from './services/codespace/codespace-types';

package/dist/services/codespace/codespace-service.d.ts

@@ -1,6 +1,9 @@
 import { BaseService } from '../base/base-service';
-import { GenerateTaskTitleRequest, GenerateTaskTitleResponse, CreateCodespaceTaskRequest, CreateCodespaceTaskResponse } from './codespace-types';
+import { GenerateTaskTitleRequest, GenerateTaskTitleResponse, CreateCodespaceTaskRequest, CreateCodespaceTaskResponse, CreateCodespaceTaskRequestV2, CreateCodespaceTaskResponseV2, CreateBackgroundCodespaceTaskRequest, CreateBackgroundCodespaceTaskResponse } from './codespace-types';
 export declare class CodespaceService extends BaseService {
     generateTaskTitle(request: GenerateTaskTitleRequest): Promise<GenerateTaskTitleResponse>;
     createCodespaceTask(request: CreateCodespaceTaskRequest): Promise<CreateCodespaceTaskResponse>;
+    createCodespaceTaskV2(request: CreateCodespaceTaskRequestV2): Promise<CreateCodespaceTaskResponseV2>;
+    createBackgroundCodespaceTask(request: CreateBackgroundCodespaceTaskRequest): Promise<CreateBackgroundCodespaceTaskResponse>;
+    private validateCodespaceTaskRequest;
 }

package/dist/services/codespace/codespace-service.js

@@ -9,5 +9,42 @@ class CodespaceService extends base_service_1.BaseService {
     async createCodespaceTask(request) {
         return this.post('/codespace/create-task', request);
     }
+    async createCodespaceTaskV2(request) {
+        this.validateCodespaceTaskRequest(request);
+        return this.post('/codespace/task', request);
+    }
+    async createBackgroundCodespaceTask(request) {
+        this.validateCodespaceTaskRequest(request);
+        return this.post('/codespace/task/background', request);
+    }
+    validateCodespaceTaskRequest(request) {
+        if (!request.project_id) {
+            throw new Error('project_id is required');
+        }
+        if (!request.task_description) {
+            throw new Error('task_description is required');
+        }
+        if (request.execution_mode && !['implementation', 'docs-only'].includes(request.execution_mode)) {
+            throw new Error('execution_mode must be either "implementation" or "docs-only"');
+        }
+        // Validate model_api_keys if provided
+        if (request.model_api_keys) {
+            if (!Array.isArray(request.model_api_keys)) {
+                throw new Error('model_api_keys must be an array');
+            }
+            for (const key of request.model_api_keys) {
+                if (!key.model_name || typeof key.model_name !== 'string') {
+                    throw new Error('Each model_api_key must have a valid model_name string');
+                }
+                if (!key.api_key || typeof key.api_key !== 'string') {
+                    throw new Error('Each model_api_key must have a valid api_key string');
+                }
+            }
+        }
+        // Validate base_branch default
+        if (request.base_branch === undefined) {
+            request.base_branch = 'main';
+        }
+    }
 }
 exports.CodespaceService = CodespaceService;

package/dist/services/codespace/codespace-types.d.ts

@@ -16,3 +16,34 @@ export interface CreateCodespaceTaskResponse {
     task_id: string;
     message: string;
 }
+export interface ModelApiKey {
+    model_name: string;
+    api_key: string;
+}
+export interface CreateCodespaceTaskRequestV2 {
+    project_id: string;
+    project_repository_id?: string;
+    task_description: string;
+    title?: string;
+    branch?: string;
+    working_branch?: string;
+    base_branch?: string;
+    docs_url?: string;
+    model_api_keys?: ModelApiKey[];
+    github_token?: string;
+    codespace_task_id?: string;
+    execution_mode?: 'implementation' | 'docs-only';
+    model_name?: string;
+    starter_kit_repo?: string;
+}
+export interface CreateCodespaceTaskResponseV2 {
+    success: boolean;
+    task_id: string;
+    message: string;
+    status?: string;
+    created_at?: string;
+}
+export interface CreateBackgroundCodespaceTaskRequest extends CreateCodespaceTaskRequestV2 {
+}
+export interface CreateBackgroundCodespaceTaskResponse extends CreateCodespaceTaskResponseV2 {
+}

package/dist/services/codespace/index.d.ts

@@ -1,2 +1,3 @@
 export { CodespaceService } from './codespace-service';
 export * from './codespace-types';
+export type { CreateCodespaceTaskRequestV2 as CreateCodespaceTaskRequest, CreateCodespaceTaskResponseV2 as CreateCodespaceTaskResponse, CreateBackgroundCodespaceTaskRequest, CreateBackgroundCodespaceTaskResponse, ModelApiKey } from './codespace-types';

package/index.ts

@@ -13,3 +13,10 @@ export * from './types'
 
 // Export commonly used types for convenience
 export type { ConnectRepositoryRequest, ConnectRepositoryResponse } from './services/projects/project-types'
+export type {
+  CreateCodespaceTaskRequestV2 as CreateCodespaceTaskRequest,
+  CreateCodespaceTaskResponseV2 as CreateCodespaceTaskResponse,
+  CreateBackgroundCodespaceTaskRequest,
+  CreateBackgroundCodespaceTaskResponse,
+  ModelApiKey
+} from './services/codespace/codespace-types'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codeguide/core",
-  "version": "0.0.17",
+  "version": "0.0.18",
   "description": "Core package for code guidance with programmatic API",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/services/codespace/codespace-service.ts

@@ -4,6 +4,10 @@ import {
   GenerateTaskTitleResponse,
   CreateCodespaceTaskRequest,
   CreateCodespaceTaskResponse,
+  CreateCodespaceTaskRequestV2,
+  CreateCodespaceTaskResponseV2,
+  CreateBackgroundCodespaceTaskRequest,
+  CreateBackgroundCodespaceTaskResponse,
 } from './codespace-types'
 
 export class CodespaceService extends BaseService {
@@ -14,4 +18,49 @@ export class CodespaceService extends BaseService {
   async createCodespaceTask(request: CreateCodespaceTaskRequest): Promise<CreateCodespaceTaskResponse> {
     return this.post<CreateCodespaceTaskResponse>('/codespace/create-task', request)
   }
+
+  async createCodespaceTaskV2(request: CreateCodespaceTaskRequestV2): Promise<CreateCodespaceTaskResponseV2> {
+    this.validateCodespaceTaskRequest(request)
+    return this.post<CreateCodespaceTaskResponseV2>('/codespace/task', request)
+  }
+
+  async createBackgroundCodespaceTask(request: CreateBackgroundCodespaceTaskRequest): Promise<CreateBackgroundCodespaceTaskResponse> {
+    this.validateCodespaceTaskRequest(request)
+    return this.post<CreateBackgroundCodespaceTaskResponse>('/codespace/task/background', request)
+  }
+
+  private validateCodespaceTaskRequest(request: CreateCodespaceTaskRequestV2): void {
+    if (!request.project_id) {
+      throw new Error('project_id is required')
+    }
+
+    if (!request.task_description) {
+      throw new Error('task_description is required')
+    }
+
+    if (request.execution_mode && !['implementation', 'docs-only'].includes(request.execution_mode)) {
+      throw new Error('execution_mode must be either "implementation" or "docs-only"')
+    }
+
+    // Validate model_api_keys if provided
+    if (request.model_api_keys) {
+      if (!Array.isArray(request.model_api_keys)) {
+        throw new Error('model_api_keys must be an array')
+      }
+
+      for (const key of request.model_api_keys) {
+        if (!key.model_name || typeof key.model_name !== 'string') {
+          throw new Error('Each model_api_key must have a valid model_name string')
+        }
+        if (!key.api_key || typeof key.api_key !== 'string') {
+          throw new Error('Each model_api_key must have a valid api_key string')
+        }
+      }
+    }
+
+    // Validate base_branch default
+    if (request.base_branch === undefined) {
+      request.base_branch = 'main'
+    }
+  }
 }

package/services/codespace/codespace-types.ts

@@ -18,4 +18,38 @@ export interface CreateCodespaceTaskResponse {
   success: boolean
   task_id: string
   message: string
-}
+}
+
+export interface ModelApiKey {
+  model_name: string
+  api_key: string
+}
+
+export interface CreateCodespaceTaskRequestV2 {
+  project_id: string
+  project_repository_id?: string
+  task_description: string
+  title?: string
+  branch?: string
+  working_branch?: string
+  base_branch?: string
+  docs_url?: string
+  model_api_keys?: ModelApiKey[]
+  github_token?: string
+  codespace_task_id?: string
+  execution_mode?: 'implementation' | 'docs-only'
+  model_name?: string
+  starter_kit_repo?: string
+}
+
+export interface CreateCodespaceTaskResponseV2 {
+  success: boolean
+  task_id: string
+  message: string
+  status?: string
+  created_at?: string
+}
+
+export interface CreateBackgroundCodespaceTaskRequest extends CreateCodespaceTaskRequestV2 {}
+
+export interface CreateBackgroundCodespaceTaskResponse extends CreateCodespaceTaskResponseV2 {}

package/services/codespace/index.ts

@@ -1,2 +1,11 @@
 export { CodespaceService } from './codespace-service'
-export * from './codespace-types'
+export * from './codespace-types'
+
+// Re-export commonly used V2 types for convenience
+export type {
+  CreateCodespaceTaskRequestV2 as CreateCodespaceTaskRequest,
+  CreateCodespaceTaskResponseV2 as CreateCodespaceTaskResponse,
+  CreateBackgroundCodespaceTaskRequest,
+  CreateBackgroundCodespaceTaskResponse,
+  ModelApiKey
+} from './codespace-types'