@codeguide/core 0.0.16 → 0.0.18

package/__tests__/codeguide-repository.test.ts

@@ -0,0 +1,113 @@
+import { CodeGuide } from '../codeguide'
+import { ConnectRepositoryRequest } from '../services/projects/project-types'
+import { APIServiceConfig } from '../types'
+import axios from 'axios'
+import MockAdapter from 'axios-mock-adapter'
+
+describe('CodeGuide - Repository Connection Integration', () => {
+  let mockAxios: MockAdapter
+  let codeGuide: CodeGuide
+  let config: APIServiceConfig
+
+  beforeEach(() => {
+    mockAxios = new MockAdapter(axios)
+    config = {
+      baseUrl: 'https://api.example.com',
+      databaseApiKey: 'sk_test123',
+    }
+    codeGuide = new CodeGuide(config, { verbose: false })
+  })
+
+  afterEach(() => {
+    mockAxios.restore()
+  })
+
+  describe('projects.connectRepository', () => {
+    const projectId = 'project-123'
+    const validRequest: ConnectRepositoryRequest = {
+      repo_url: 'https://github.com/user/my-app',
+      branch: 'main',
+      github_token: 'ghp_test123',
+    }
+
+    it('should connect repository successfully using projects service', async () => {
+      const mockResponse = {
+        status: 'success',
+        data: {
+          id: 'repo-connection-123',
+          project_id: projectId,
+          repo_url: validRequest.repo_url,
+          branch: validRequest.branch,
+          connection_status: 'connected' as const,
+          created_at: '2023-01-01T00:00:00Z',
+          updated_at: '2023-01-01T00:00:00Z',
+        },
+      }
+
+      mockAxios.onPost(`/projects/${projectId}/repository`, validRequest).reply(200, mockResponse)
+
+      const result = await codeGuide.projects.connectRepository(projectId, validRequest)
+
+      expect(result).toEqual(mockResponse)
+    })
+
+    it('should work with verbose mode enabled', async () => {
+      const verboseCodeGuide = new CodeGuide(config, { verbose: true })
+
+      const mockResponse = {
+        status: 'success',
+        data: {
+          id: 'repo-connection-123',
+          project_id: projectId,
+          repo_url: validRequest.repo_url,
+          branch: validRequest.branch,
+          connection_status: 'connected' as const,
+          created_at: '2023-01-01T00:00:00Z',
+          updated_at: '2023-01-01T00:00:00Z',
+        },
+      }
+
+      mockAxios.onPost(`/projects/${projectId}/repository`, validRequest).reply(200, mockResponse)
+
+      const result = await verboseCodeGuide.projects.connectRepository(projectId, validRequest)
+
+      expect(result).toEqual(mockResponse)
+    })
+
+    it('should handle validation errors through projects service', async () => {
+      const invalidRequest = {
+        repo_url: 'https://gitlab.com/user/repo', // Invalid URL
+        branch: 'main',
+      }
+
+      await expect(codeGuide.projects.connectRepository(projectId, invalidRequest))
+        .rejects.toThrow('Repository URL must be a valid GitHub URL')
+    })
+
+    it('should connect public repository without token', async () => {
+      const publicRepoRequest = {
+        repo_url: 'https://github.com/facebook/react',
+        branch: 'main',
+      }
+
+      const mockResponse = {
+        status: 'success',
+        data: {
+          id: 'repo-connection-456',
+          project_id: projectId,
+          repo_url: publicRepoRequest.repo_url,
+          branch: publicRepoRequest.branch,
+          connection_status: 'connected' as const,
+          created_at: '2023-01-01T00:00:00Z',
+          updated_at: '2023-01-01T00:00:00Z',
+        },
+      }
+
+      mockAxios.onPost(`/projects/${projectId}/repository`, publicRepoRequest).reply(200, mockResponse)
+
+      const result = await codeGuide.projects.connectRepository(projectId, publicRepoRequest)
+
+      expect(result).toEqual(mockResponse)
+    })
+  })
+})

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/__tests__/services/projects/projects.test.ts

@@ -0,0 +1,191 @@
+import { ProjectService } from '../../../services/projects/project-service'
+import { ConnectRepositoryRequest } from '../../../services/projects/project-types'
+import { APIServiceConfig } from '../../../types'
+import axios from 'axios'
+import MockAdapter from 'axios-mock-adapter'
+
+describe('ProjectService - Repository Connection', () => {
+  let mockAxios: MockAdapter
+  let projectService: ProjectService
+  let mockConfig: APIServiceConfig
+
+  beforeEach(() => {
+    mockAxios = new MockAdapter(axios)
+    mockConfig = {
+      baseUrl: 'https://api.example.com',
+      databaseApiKey: 'sk_test123',
+    }
+    projectService = new ProjectService(mockConfig)
+  })
+
+  afterEach(() => {
+    mockAxios.restore()
+  })
+
+  describe('connectRepository', () => {
+    const projectId = 'project-123'
+    const validRequest: ConnectRepositoryRequest = {
+      repo_url: 'https://github.com/user/my-app',
+      branch: 'main',
+      github_token: 'ghp_test123',
+    }
+
+    it('should successfully connect a repository with valid data', async () => {
+      const mockResponse = {
+        status: 'success',
+        data: {
+          id: 'repo-connection-123',
+          project_id: projectId,
+          repo_url: validRequest.repo_url,
+          branch: validRequest.branch,
+          connection_status: 'connected' as const,
+          created_at: '2023-01-01T00:00:00Z',
+          updated_at: '2023-01-01T00:00:00Z',
+        },
+      }
+
+      mockAxios.onPost(`/projects/${projectId}/repository`, validRequest).reply(200, mockResponse)
+
+      const result = await projectService.connectRepository(projectId, validRequest)
+
+      expect(result).toEqual(mockResponse)
+    })
+
+    it('should throw error for missing repository URL', async () => {
+      const invalidRequest = {
+        repo_url: '',
+        branch: 'main',
+      }
+
+      await expect(projectService.connectRepository(projectId, invalidRequest))
+        .rejects.toThrow('Repository URL is required')
+    })
+
+    it('should throw error for missing branch name', async () => {
+      const invalidRequest = {
+        repo_url: 'https://github.com/user/my-app',
+        branch: '',
+      }
+
+      await expect(projectService.connectRepository(projectId, invalidRequest))
+        .rejects.toThrow('Branch name is required')
+    })
+
+    it('should throw error for invalid GitHub URL format', async () => {
+      const invalidRequest = {
+        repo_url: 'https://gitlab.com/user/my-app',
+        branch: 'main',
+      }
+
+      await expect(projectService.connectRepository(projectId, invalidRequest))
+        .rejects.toThrow('Repository URL must be a valid GitHub URL')
+    })
+
+    it('should throw error for invalid branch name characters', async () => {
+      const invalidRequest = {
+        repo_url: 'https://github.com/user/my-app',
+        branch: 'main@branch',
+      }
+
+      await expect(projectService.connectRepository(projectId, invalidRequest))
+        .rejects.toThrow('Branch name contains invalid characters')
+    })
+
+    it('should throw error for invalid GitHub token format', async () => {
+      const invalidRequest = {
+        repo_url: 'https://github.com/user/my-app',
+        branch: 'main',
+        github_token: 'invalid-token',
+      }
+
+      await expect(projectService.connectRepository(projectId, invalidRequest))
+        .rejects.toThrow('GitHub token must be a valid personal access token')
+    })
+
+    it('should accept valid GitHub token formats', async () => {
+      const validTokens = [
+        'ghp_test123',
+        'gho_test123',
+        'ghu_test123',
+        'ghs_test123',
+        'ghr_test123',
+      ]
+
+      for (const token of validTokens) {
+        const request = {
+          repo_url: 'https://github.com/user/my-app',
+          branch: 'main',
+          github_token: token,
+        }
+
+        const mockResponse = {
+          status: 'success',
+          data: {
+            id: 'repo-connection-123',
+            project_id: projectId,
+            repo_url: request.repo_url,
+            branch: request.branch,
+            connection_status: 'connected' as const,
+            created_at: '2023-01-01T00:00:00Z',
+            updated_at: '2023-01-01T00:00:00Z',
+          },
+        }
+
+        mockAxios.onPost(`/projects/${projectId}/repository`, request).reply(200, mockResponse)
+
+        const result = await projectService.connectRepository(projectId, request)
+        expect(result).toEqual(mockResponse)
+      }
+    })
+
+    it('should work without GitHub token (for public repos)', async () => {
+      const requestWithoutToken = {
+        repo_url: 'https://github.com/user/my-app',
+        branch: 'main',
+      }
+
+      const mockResponse = {
+        status: 'success',
+        data: {
+          id: 'repo-connection-123',
+          project_id: projectId,
+          repo_url: requestWithoutToken.repo_url,
+          branch: requestWithoutToken.branch,
+          connection_status: 'connected' as const,
+          created_at: '2023-01-01T00:00:00Z',
+          updated_at: '2023-01-01T00:00:00Z',
+        },
+      }
+
+      mockAxios.onPost(`/projects/${projectId}/repository`, requestWithoutToken).reply(200, mockResponse)
+
+      const result = await projectService.connectRepository(projectId, requestWithoutToken)
+      expect(result).toEqual(mockResponse)
+    })
+
+    it('should accept GitHub URLs with trailing slash', async () => {
+      const requestWithTrailingSlash = {
+        repo_url: 'https://github.com/user/my-app/',
+        branch: 'main',
+      }
+
+      const mockResponse = {
+        status: 'success',
+        data: {
+          id: 'repo-connection-123',
+          project_id: projectId,
+          repo_url: 'https://github.com/user/my-app/',
+          branch: 'main',
+          connection_status: 'connected' as const,
+          created_at: '2023-01-01T00:00:00Z',
+          updated_at: '2023-01-01T00:00:00Z',
+        },
+      }
+
+      mockAxios.onPost(`/projects/${projectId}/repository`, requestWithTrailingSlash).reply(200, mockResponse)
+
+      const result = await projectService.connectRepository(projectId, requestWithTrailingSlash)
+      expect(result).toEqual(mockResponse)
+    })
+  })
+})

package/codeguide.ts

@@ -87,6 +87,7 @@ export class CodeGuide {
     return this.tasks.createTaskGroupWithCodespace(request, this.codespace)
   }
 
+  
   setOptions(options: Partial<CodeGuideOptions>): void {
     this.options = { ...this.options, ...options }
   }

package/dist/index.d.ts

@@ -1,3 +1,5 @@
 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/dist/services/projects/project-service.d.ts

@@ -1,5 +1,5 @@
 import { BaseService } from '../base/base-service';
-import { Project, CreateProjectRequest, UpdateProjectRequest, PaginatedProjectsRequest, PaginatedProjectsResponse, GetProjectDocumentsRequest, GetProjectDocumentsResponse } from './project-types';
+import { Project, CreateProjectRequest, UpdateProjectRequest, PaginatedProjectsRequest, PaginatedProjectsResponse, GetProjectDocumentsRequest, GetProjectDocumentsResponse, ConnectRepositoryRequest, ConnectRepositoryResponse } from './project-types';
 export declare class ProjectService extends BaseService {
     getAllProjects(): Promise<Project[]>;
     getPaginatedProjects(params: PaginatedProjectsRequest): Promise<PaginatedProjectsResponse>;
@@ -11,4 +11,6 @@ export declare class ProjectService extends BaseService {
         message: string;
     }>;
     getProjectDocuments(projectId: string, params?: GetProjectDocumentsRequest): Promise<GetProjectDocumentsResponse>;
+    connectRepository(projectId: string, request: ConnectRepositoryRequest): Promise<ConnectRepositoryResponse>;
+    private validateConnectRepositoryRequest;
 }

package/dist/services/projects/project-service.js

@@ -49,5 +49,31 @@ class ProjectService extends base_service_1.BaseService {
         const url = `/projects/${projectId}/documents${queryParams.toString() ? `?${queryParams.toString()}` : ''}`;
         return this.get(url);
     }
+    async connectRepository(projectId, request) {
+        this.validateConnectRepositoryRequest(request);
+        const response = await this.post(`/projects/${projectId}/repository`, request);
+        return response;
+    }
+    validateConnectRepositoryRequest(request) {
+        if (!request.repo_url) {
+            throw new Error('Repository URL is required');
+        }
+        if (!request.branch) {
+            throw new Error('Branch name is required');
+        }
+        // Validate GitHub URL format
+        const githubUrlPattern = /^https:\/\/github\.com\/[^\/]+\/[^\/]+\/?$/;
+        if (!githubUrlPattern.test(request.repo_url)) {
+            throw new Error('Repository URL must be a valid GitHub URL (e.g., https://github.com/user/repo)');
+        }
+        // Validate branch name format (basic validation)
+        if (!/^[a-zA-Z0-9._-]+$/.test(request.branch)) {
+            throw new Error('Branch name contains invalid characters');
+        }
+        // Validate GitHub token format if provided
+        if (request.github_token && !request.github_token.startsWith('ghp_') && !request.github_token.startsWith('gho_') && !request.github_token.startsWith('ghu_') && !request.github_token.startsWith('ghs_') && !request.github_token.startsWith('ghr_')) {
+            throw new Error('GitHub token must be a valid personal access token');
+        }
+    }
 }
 exports.ProjectService = ProjectService;

package/dist/services/projects/project-types.d.ts

@@ -95,3 +95,20 @@ export interface PaginatedProjectsResponse {
         total_pages: number;
     };
 }
+export interface ConnectRepositoryRequest {
+    repo_url: string;
+    branch: string;
+    github_token?: string;
+}
+export interface ConnectRepositoryResponse {
+    status: string;
+    data: {
+        id: string;
+        project_id: string;
+        repo_url: string;
+        branch: string;
+        connection_status: 'pending' | 'connected' | 'failed';
+        created_at: string;
+        updated_at: string;
+    };
+}

package/index.ts

@@ -10,3 +10,13 @@ dotenv.config({
 export { CodeGuide } from './codeguide'
 export * from './services'
 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.16",
+  "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'

package/services/projects/project-service.ts

@@ -9,6 +9,8 @@ import {
   PaginatedProjectsResponse,
   GetProjectDocumentsRequest,
   GetProjectDocumentsResponse,
+  ConnectRepositoryRequest,
+  ConnectRepositoryResponse,
 } from './project-types'
 
 export class ProjectService extends BaseService {
@@ -64,4 +66,39 @@ export class ProjectService extends BaseService {
     const url = `/projects/${projectId}/documents${queryParams.toString() ? `?${queryParams.toString()}` : ''}`
     return this.get<GetProjectDocumentsResponse>(url)
   }
+
+  async connectRepository(
+    projectId: string,
+    request: ConnectRepositoryRequest
+  ): Promise<ConnectRepositoryResponse> {
+    this.validateConnectRepositoryRequest(request)
+    const response = await this.post<ConnectRepositoryResponse>(`/projects/${projectId}/repository`, request)
+    return response
+  }
+
+  private validateConnectRepositoryRequest(request: ConnectRepositoryRequest): void {
+    if (!request.repo_url) {
+      throw new Error('Repository URL is required')
+    }
+
+    if (!request.branch) {
+      throw new Error('Branch name is required')
+    }
+
+    // Validate GitHub URL format
+    const githubUrlPattern = /^https:\/\/github\.com\/[^\/]+\/[^\/]+\/?$/
+    if (!githubUrlPattern.test(request.repo_url)) {
+      throw new Error('Repository URL must be a valid GitHub URL (e.g., https://github.com/user/repo)')
+    }
+
+    // Validate branch name format (basic validation)
+    if (!/^[a-zA-Z0-9._-]+$/.test(request.branch)) {
+      throw new Error('Branch name contains invalid characters')
+    }
+
+    // Validate GitHub token format if provided
+    if (request.github_token && !request.github_token.startsWith('ghp_') && !request.github_token.startsWith('gho_') && !request.github_token.startsWith('ghu_') && !request.github_token.startsWith('ghs_') && !request.github_token.startsWith('ghr_')) {
+      throw new Error('GitHub token must be a valid personal access token')
+    }
+  }
 }

package/services/projects/project-types.ts

@@ -106,3 +106,22 @@ export interface PaginatedProjectsResponse {
     total_pages: number
   }
 }
+
+export interface ConnectRepositoryRequest {
+  repo_url: string
+  branch: string
+  github_token?: string
+}
+
+export interface ConnectRepositoryResponse {
+  status: string
+  data: {
+    id: string
+    project_id: string
+    repo_url: string
+    branch: string
+    connection_status: 'pending' | 'connected' | 'failed'
+    created_at: string
+    updated_at: string
+  }
+}