@codeguide/core 0.0.22 → 0.0.24

package/index.ts

@@ -12,13 +12,21 @@ export * from './services'
 export * from './types'
 
 // Export commonly used types for convenience
-export type { ConnectRepositoryRequest, ConnectRepositoryResponse } from './services/projects/project-types'
+export type {
+  ConnectRepositoryRequest,
+  ConnectRepositoryResponse,
+  ProjectRepository,
+  GetProjectsRequest,
+  PaginatedProjectsRequest,
+  PaginatedProjectsResponse
+} from './services/projects/project-types'
 export type {
   CreateCodespaceTaskRequestV2 as CreateCodespaceTaskRequest,
   CreateCodespaceTaskResponseV2 as CreateCodespaceTaskResponse,
   CreateBackgroundCodespaceTaskRequest,
   CreateBackgroundCodespaceTaskResponse,
   ModelApiKey,
+  Attachment,
   GetCodespaceTaskResponse,
   CodespaceTaskData,
   TechnicalDocument,

package/package.json

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

package/services/codespace/codespace-service.ts

@@ -10,6 +10,11 @@ import {
   CreateBackgroundCodespaceTaskResponse,
   GetCodespaceTaskResponse,
   GetProjectTasksByCodespaceResponse,
+  GetCodespaceTasksByProjectRequest,
+  GetCodespaceTasksByProjectResponse,
+  CodespaceTaskDetailedResponse,
+  CodespaceQuestionnaireRequest,
+  CodespaceQuestionnaireResponse,
 } from './codespace-types'
 
 export class CodespaceService extends BaseService {
@@ -17,16 +22,27 @@ export class CodespaceService extends BaseService {
     return this.post<GenerateTaskTitleResponse>('/codespace/generate-task-title', request)
   }
 
-  async createCodespaceTask(request: CreateCodespaceTaskRequest): Promise<CreateCodespaceTaskResponse> {
+  async generateQuestionnaire(request: CodespaceQuestionnaireRequest): Promise<CodespaceQuestionnaireResponse> {
+    this.validateQuestionnaireRequest(request)
+    return this.post<CodespaceQuestionnaireResponse>('/codespace/generate-questionnaire', request)
+  }
+
+  async createCodespaceTask(
+    request: CreateCodespaceTaskRequest
+  ): Promise<CreateCodespaceTaskResponse> {
     return this.post<CreateCodespaceTaskResponse>('/codespace/create-task', request)
   }
 
-  async createCodespaceTaskV2(request: CreateCodespaceTaskRequestV2): Promise<CreateCodespaceTaskResponseV2> {
+  async createCodespaceTaskV2(
+    request: CreateCodespaceTaskRequestV2
+  ): Promise<CreateCodespaceTaskResponseV2> {
     this.validateCodespaceTaskRequest(request)
     return this.post<CreateCodespaceTaskResponseV2>('/codespace/task', request)
   }
 
-  async createBackgroundCodespaceTask(request: CreateBackgroundCodespaceTaskRequest): Promise<CreateBackgroundCodespaceTaskResponse> {
+  async createBackgroundCodespaceTask(
+    request: CreateBackgroundCodespaceTaskRequest
+  ): Promise<CreateBackgroundCodespaceTaskResponse> {
     this.validateCodespaceTaskRequest(request)
     return this.post<CreateBackgroundCodespaceTaskResponse>('/codespace/task/background', request)
   }
@@ -38,11 +54,41 @@ export class CodespaceService extends BaseService {
     return this.get<GetCodespaceTaskResponse>(`/codespace/task/${codespaceTaskId}`)
   }
 
-  async getProjectTasksByCodespace(codespaceTaskId: string): Promise<GetProjectTasksByCodespaceResponse> {
+  async getProjectTasksByCodespace(
+    codespaceTaskId: string
+  ): Promise<GetProjectTasksByCodespaceResponse> {
+    if (!codespaceTaskId) {
+      throw new Error('codespace_task_id is required')
+    }
+    return this.get<GetProjectTasksByCodespaceResponse>(
+      `/project-tasks/by-codespace/${codespaceTaskId}`
+    )
+  }
+
+  async getCodespaceTasksByProject(
+    params: GetCodespaceTasksByProjectRequest
+  ): Promise<GetCodespaceTasksByProjectResponse> {
+    if (!params.project_id) {
+      throw new Error('project_id is required')
+    }
+
+    const queryParams = new URLSearchParams()
+
+    if (params.status) queryParams.append('status', params.status)
+    if (params.limit !== undefined) queryParams.append('limit', params.limit.toString())
+    if (params.offset !== undefined) queryParams.append('offset', params.offset.toString())
+    if (params.sort_by) queryParams.append('sort_by', params.sort_by)
+    if (params.sort_order) queryParams.append('sort_order', params.sort_order)
+
+    const url = `/codespace/tasks/project/${params.project_id}${queryParams.toString() ? `?${queryParams.toString()}` : ''}`
+    return this.get<GetCodespaceTasksByProjectResponse>(url)
+  }
+
+  async getCodespaceTaskDetailed(codespaceTaskId: string): Promise<CodespaceTaskDetailedResponse> {
     if (!codespaceTaskId) {
       throw new Error('codespace_task_id is required')
     }
-    return this.get<GetProjectTasksByCodespaceResponse>(`/project-tasks/by-codespace/${codespaceTaskId}`)
+    return this.get<CodespaceTaskDetailedResponse>(`/codespace/task/${codespaceTaskId}/detailed`)
   }
 
   private validateCodespaceTaskRequest(request: CreateCodespaceTaskRequestV2): void {
@@ -54,7 +100,10 @@ export class CodespaceService extends BaseService {
       throw new Error('task_description is required')
     }
 
-    if (request.execution_mode && !['implementation', 'docs-only'].includes(request.execution_mode)) {
+    if (
+      request.execution_mode &&
+      !['implementation', 'docs-only'].includes(request.execution_mode)
+    ) {
       throw new Error('execution_mode must be either "implementation" or "docs-only"')
     }
 
@@ -78,5 +127,56 @@ export class CodespaceService extends BaseService {
     if (request.base_branch === undefined) {
       request.base_branch = 'main'
     }
+
+    // Validate ai_questionnaire if provided
+    if (request.ai_questionnaire) {
+      if (typeof request.ai_questionnaire !== 'object' || request.ai_questionnaire === null) {
+        throw new Error('ai_questionnaire must be an object')
+      }
+      
+      // Check if it's a plain object with string keys and string values
+      for (const [key, value] of Object.entries(request.ai_questionnaire)) {
+        if (typeof key !== 'string') {
+          throw new Error('All ai_questionnaire keys must be strings')
+        }
+        if (typeof value !== 'string') {
+          throw new Error('All ai_questionnaire values must be strings')
+        }
+      }
+    }
+  }
+
+  private validateQuestionnaireRequest(request: CodespaceQuestionnaireRequest): void {
+    if (!request.task_description) {
+      throw new Error('task_description is required')
+    }
+
+    // Validate attachments if provided
+    if (request.attachments) {
+      if (!Array.isArray(request.attachments)) {
+        throw new Error('attachments must be an array')
+      }
+
+      for (const attachment of request.attachments) {
+        // Check required fields
+        if (!attachment.filename || typeof attachment.filename !== 'string') {
+          throw new Error('Each attachment must have a valid filename string')
+        }
+        if (!attachment.file_data || typeof attachment.file_data !== 'string') {
+          throw new Error('Each attachment must have valid file_data string')
+        }
+        if (!attachment.mime_type || typeof attachment.mime_type !== 'string') {
+          throw new Error('Each attachment must have a valid mime_type string')
+        }
+        if (typeof attachment.file_size !== 'number' || attachment.file_size < 0) {
+          throw new Error('Each attachment must have a valid file_size number (>= 0)')
+        }
+
+        // Validate optional description field
+        if (attachment.description && typeof attachment.description !== 'string') {
+          throw new Error('Attachment description must be a string if provided')
+        }
+      }
+    }
   }
-}
+}

package/services/codespace/codespace-types.ts

@@ -25,6 +25,14 @@ export interface ModelApiKey {
   api_key: string
 }
 
+export interface Attachment {
+  filename: string
+  file_data: string // bytes (base64)
+  mime_type: string
+  file_size: number
+  description?: string
+}
+
 export interface CreateCodespaceTaskRequestV2 {
   project_id: string
   project_repository_id?: string
@@ -40,6 +48,9 @@ export interface CreateCodespaceTaskRequestV2 {
   execution_mode?: 'implementation' | 'docs-only'
   model_name?: string
   starter_kit_repo?: string
+  use_enhanced_summary?: boolean
+  attachments?: Attachment[]
+  ai_questionnaire?: Record<string, string>
 }
 
 export interface CreateCodespaceTaskResponseV2 {
@@ -124,4 +135,50 @@ export interface GetProjectTasksByCodespaceResponse {
 
 export interface CreateBackgroundCodespaceTaskRequest extends CreateCodespaceTaskRequestV2 {}
 
-export interface CreateBackgroundCodespaceTaskResponse extends CreateCodespaceTaskResponseV2 {}
+export interface CreateBackgroundCodespaceTaskResponse extends CreateCodespaceTaskResponseV2 {}
+
+// Request parameters for getting codespace tasks by project
+export interface GetCodespaceTasksByProjectRequest {
+  project_id: string
+  status?: 'completed' | 'failed' | 'in_progress' | 'created' | 'cancelled'
+  limit?: number
+  offset?: number
+  sort_by?: string
+  sort_order?: 'asc' | 'desc'
+}
+
+// Response for getting codespace tasks by project
+export interface GetCodespaceTasksByProjectResponse {
+  status: string
+  data: CodespaceTaskData[]
+  total_count: number
+  message: string
+}
+
+// Response for getting detailed codespace task with relations
+export interface CodespaceTaskDetailedResponse {
+  status: string
+  data: {
+    task: CodespaceTaskData
+    project: any // Project data structure
+    repository: any // Repository data structure
+    usage_summary: any // Usage statistics
+  }
+  message: string
+}
+
+export interface CodespaceQuestionnaireRequest {
+  task_description: string
+  project_context?: string
+  repository_info?: {
+    name?: string
+    description?: string
+  }
+  attachments?: Attachment[]
+}
+
+export interface CodespaceQuestionnaireResponse {
+  success: boolean
+  questions: string[]
+  message: string
+}

package/services/codespace/index.ts

@@ -8,8 +8,11 @@ export type {
   CreateBackgroundCodespaceTaskRequest,
   CreateBackgroundCodespaceTaskResponse,
   ModelApiKey,
+  Attachment,
   GetCodespaceTaskResponse,
   CodespaceTaskData,
   TechnicalDocument,
-  GetProjectTasksByCodespaceResponse
+  GetProjectTasksByCodespaceResponse,
+  CodespaceQuestionnaireRequest,
+  CodespaceQuestionnaireResponse
 } from './codespace-types'

package/services/projects/README.md

@@ -0,0 +1,226 @@
+# Projects Service
+
+The Projects Service provides functionality for managing projects and their associated repositories. This service includes filtering capabilities to retrieve projects based on whether they have connected repositories.
+
+## Features
+
+### Project Filtering by Repository Status
+
+The service supports filtering projects based on whether they have connected repositories using the `has_repository` parameter.
+
+#### API Methods
+
+##### `getAllProjects(params?: GetProjectsRequest): Promise<Project[]>`
+
+Retrieves a list of all projects with optional filtering.
+
+```typescript
+// Get all projects with repositories
+const projectsWithRepos = await codeGuide.project.getAllProjects({
+  has_repository: true
+})
+
+// Get all projects without repositories
+const projectsWithoutRepos = await codeGuide.project.getAllProjects({
+  has_repository: false
+})
+```
+
+##### `getPaginatedProjects(params: PaginatedProjectsRequest): Promise<PaginatedProjectsResponse>`
+
+Retrieves paginated projects with advanced filtering options.
+
+```typescript
+// Combine repository filter with other filters
+const paginatedProjects = await codeGuide.project.getPaginatedProjects({
+  page: 1,
+  page_size: 10,
+  has_repository: true,
+  status: 'active',
+  search_query: 'web',
+  sort_by_date: 'desc'
+})
+```
+
+### Types
+
+#### `GetProjectsRequest`
+
+```typescript
+interface GetProjectsRequest {
+  has_repository?: boolean // Filter by repository status
+}
+```
+
+#### `PaginatedProjectsRequest`
+
+```typescript
+interface PaginatedProjectsRequest {
+  page?: number
+  page_size?: number
+  search_query?: string
+  status?: string
+  start_date?: string
+  end_date?: string
+  sort_by_date?: 'asc' | 'desc'
+  has_repository?: boolean // Filter by repository status
+}
+```
+
+#### `ProjectRepository`
+
+```typescript
+interface ProjectRepository {
+  id: string
+  project_id: string
+  repo_url: string
+  branch: string
+  author: string
+  name: string
+  connection_status: 'pending' | 'connected' | 'failed'
+  created_at: string
+  updated_at: string
+}
+```
+
+#### `Project`
+
+```typescript
+interface Project {
+  id: string
+  title: string
+  description: string
+  user_id: string
+  created_at: string
+  updated_at: string
+  project_documents: ProjectDocument[]
+  project_repositories: ProjectRepository[] // Added for repository information
+  category?: Category
+  codie_tool?: CodieTool
+  github_url?: string
+  status?: string
+  tools_selected?: string[]
+  ai_questionaire?: Record<string, any>
+  project_outline?: Record<string, any>
+}
+```
+
+## Usage Examples
+
+### Basic Filtering
+
+```typescript
+import { CodeGuide } from '@codeguide/core'
+
+const codeGuide = new CodeGuide({
+  baseURL: 'https://api.example.com',
+  apiKey: 'your-api-key'
+})
+
+// Get projects that have repositories connected
+const projectsWithRepos = await codeGuide.project.getAllProjects({
+  has_repository: true
+})
+
+console.log('Projects with repositories:', projectsWithRepos.length)
+projectsWithRepos.forEach(project => {
+  console.log(`${project.title} - ${project.project_repositories.length} repositories`)
+})
+```
+
+### Advanced Filtering
+
+```typescript
+// Get paginated projects without repositories, filtered by status and search
+const filteredProjects = await codeGuide.project.getPaginatedProjects({
+  page: 1,
+  page_size: 20,
+  has_repository: false,
+  status: 'in_progress',
+  search_query: 'mobile'
+})
+
+console.log(`Found ${filteredProjects.pagination.total} projects`)
+filteredProjects.data.forEach(project => {
+  console.log(`${project.title} - No repositories connected`)
+})
+```
+
+### Combining with Other Features
+
+```typescript
+// Connect a repository to a project
+const connectionResult = await codeGuide.project.connectRepository(
+  projectId,
+  {
+    repo_url: 'https://github.com/user/repo',
+    branch: 'main',
+    github_token: 'optional-token'
+  }
+)
+
+// After connecting, verify the project appears in filtered results
+const updatedProjects = await codeGuide.project.getAllProjects({
+  has_repository: true
+})
+
+const isProjectInFilteredResults = updatedProjects.some(
+  project => project.id === projectId
+)
+```
+
+## Response Format
+
+The API response includes project data with repository information:
+
+```json
+{
+  "status": "success",
+  "data": [
+    {
+      "id": "project-uuid",
+      "title": "My Project",
+      "description": "Project description",
+      "project_repositories": [
+        {
+          "id": "repo-uuid",
+          "project_id": "project-uuid",
+          "repo_url": "https://github.com/user/repo",
+          "branch": "main",
+          "author": "user",
+          "name": "repo",
+          "connection_status": "connected",
+          "created_at": "2023-01-01T00:00:00Z",
+          "updated_at": "2023-01-01T00:00:00Z"
+        }
+      ],
+      "created_at": "2023-01-01T00:00:00Z",
+      "updated_at": "2023-01-01T00:00:00Z"
+    }
+  ]
+}
+```
+
+## Error Handling
+
+The service includes validation for repository connections:
+
+```typescript
+try {
+  await codeGuide.project.connectRepository(projectId, {
+    repo_url: 'invalid-url',
+    branch: 'main'
+  })
+} catch (error) {
+  console.error('Connection failed:', error.message)
+  // Example: "Repository URL must be a valid GitHub URL (e.g., https://github.com/user/repo)"
+}
+```
+
+## Notes
+
+- The `has_repository` parameter is optional
+- When `has_repository=true`, only projects with at least one connected repository are returned
+- When `has_repository=false`, only projects with no connected repositories are returned
+- Repository information is included in the `project_repositories` field of each project
+- The filtering works with both basic project listing and paginated queries

package/services/projects/project-service.ts

@@ -7,6 +7,7 @@ import {
   ProjectResponse,
   PaginatedProjectsRequest,
   PaginatedProjectsResponse,
+  GetProjectsRequest,
   GetProjectDocumentsRequest,
   GetProjectDocumentsResponse,
   ConnectRepositoryRequest,
@@ -14,8 +15,15 @@ import {
 } from './project-types'
 
 export class ProjectService extends BaseService {
-  async getAllProjects(): Promise<Project[]> {
-    const response = await this.get<ProjectListResponse>('/projects')
+  async getAllProjects(params?: GetProjectsRequest): Promise<Project[]> {
+    const queryParams = new URLSearchParams()
+
+    if (params?.has_repository !== undefined) {
+      queryParams.append('has_repository', params.has_repository.toString())
+    }
+
+    const url = `/projects${queryParams.toString() ? `?${queryParams.toString()}` : ''}`
+    const response = await this.get<ProjectListResponse>(url)
     return response.data
   }
 
@@ -29,6 +37,7 @@ export class ProjectService extends BaseService {
     if (params.start_date) queryParams.append('start_date', params.start_date)
     if (params.end_date) queryParams.append('end_date', params.end_date)
     if (params.sort_by_date) queryParams.append('sort_by_date', params.sort_by_date)
+    if (params.has_repository !== undefined) queryParams.append('has_repository', params.has_repository.toString())
 
     const url = `/projects/paginated${queryParams.toString() ? `?${queryParams.toString()}` : ''}`
     return this.get<PaginatedProjectsResponse>(url)

package/services/projects/project-types.ts

@@ -1,3 +1,15 @@
+export interface ProjectRepository {
+  id: string
+  project_id: string
+  repo_url: string
+  branch: string
+  author: string
+  name: string
+  connection_status: 'pending' | 'connected' | 'failed'
+  created_at: string
+  updated_at: string
+}
+
 export interface Project {
   id: string
   title: string
@@ -6,6 +18,7 @@ export interface Project {
   created_at: string
   updated_at: string
   project_documents: ProjectDocument[]
+  project_repositories: ProjectRepository[]
   category?: Category
   codie_tool?: CodieTool
   github_url?: string
@@ -86,6 +99,10 @@ export interface ProjectResponse {
   data: Project
 }
 
+export interface GetProjectsRequest {
+  has_repository?: boolean
+}
+
 export interface PaginatedProjectsRequest {
   page?: number
   page_size?: number
@@ -94,6 +111,7 @@ export interface PaginatedProjectsRequest {
   start_date?: string
   end_date?: string
   sort_by_date?: 'asc' | 'desc'
+  has_repository?: boolean
 }
 
 export interface PaginatedProjectsResponse {

package/services/repository-analysis/repository-types.ts

@@ -1,8 +1,22 @@
+import { Attachment } from '../codespace/codespace-types'
+
 export interface AnalyzeRepositoryRequest {
-  repository_url: string
+  github_url: string
+  github_token?: string
   generate_documents?: boolean
   create_codespace_task?: boolean
   project_id?: string
+  codespace_task_description?: string
+  codespace_branch?: string
+  codespace_base_branch?: string
+  model_api_keys?: {
+    model_name: string
+    api_key: string
+  }[]
+  model_name?: string
+  starter_kit_repo?: string
+  use_enhanced_summary?: boolean
+  attachments?: Attachment[]
 }
 
 export interface AnalyzeRepositoryResponse {