@codeguide/core 0.0.16 → 0.0.17

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/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,4 @@
 export { CodeGuide } from './codeguide';
 export * from './services';
 export * from './types';
+export type { ConnectRepositoryRequest, ConnectRepositoryResponse } from './services/projects/project-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,6 @@ 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'

package/package.json

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

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
+  }
+}