@codeguide/core 0.0.22 → 0.0.24

package/dist/examples/project-filtering-example.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.demonstrateProjectFiltering = demonstrateProjectFiltering;
+const index_1 = require("../index");
+// Example usage of the new has_repository filtering functionality
+async function demonstrateProjectFiltering() {
+    const codeGuide = new index_1.CodeGuide({
+        baseUrl: 'https://api.example.com',
+        apiKey: 'your-api-key'
+    });
+    console.log('=== Project Filtering Examples ===\n');
+    // Example 1: Get all projects with repositories
+    console.log('1. Getting all projects with repositories:');
+    try {
+        const projectsWithRepos = await codeGuide.projects.getAllProjects({
+            has_repository: true
+        });
+        console.log(`Found ${projectsWithRepos.length} projects with repositories`);
+        projectsWithRepos.forEach((project) => {
+            console.log(`- ${project.title} (${project.project_repositories.length} repositories)`);
+        });
+    }
+    catch (error) {
+        console.log('Error:', error.message);
+    }
+    console.log('\n');
+    // Example 2: Get all projects without repositories
+    console.log('2. Getting all projects without repositories:');
+    try {
+        const projectsWithoutRepos = await codeGuide.projects.getAllProjects({
+            has_repository: false
+        });
+        console.log(`Found ${projectsWithoutRepos.length} projects without repositories`);
+        projectsWithoutRepos.forEach((project) => {
+            console.log(`- ${project.title}`);
+        });
+    }
+    catch (error) {
+        console.log('Error:', error.message);
+    }
+    console.log('\n');
+    // Example 3: Paginated projects with repository filter
+    console.log('3. Getting paginated projects with repositories:');
+    try {
+        const paginatedRequest = {
+            page: 1,
+            page_size: 10,
+            has_repository: true,
+            status: 'active'
+        };
+        const paginatedResponse = await codeGuide.projects.getPaginatedProjects(paginatedRequest);
+        console.log(`Page ${paginatedResponse.pagination.page} of ${paginatedResponse.pagination.total_pages}`);
+        console.log(`Total projects with repositories: ${paginatedResponse.pagination.total}`);
+        console.log(`Showing ${paginatedResponse.data.length} projects:`);
+        paginatedResponse.data.forEach((project) => {
+            console.log(`- ${project.title}`);
+            project.project_repositories.forEach((repo) => {
+                console.log(`  Repository: ${repo.repo_url} (${repo.branch})`);
+            });
+        });
+    }
+    catch (error) {
+        console.log('Error:', error.message);
+    }
+    console.log('\n');
+    // Example 4: Combining filters
+    console.log('4. Combining multiple filters:');
+    try {
+        const combinedFilters = {
+            page: 1,
+            page_size: 5,
+            has_repository: false,
+            search_query: 'web',
+            sort_by_date: 'desc'
+        };
+        const filteredProjects = await codeGuide.projects.getPaginatedProjects(combinedFilters);
+        console.log(`Found ${filteredProjects.pagination.total} projects matching filters:`);
+        filteredProjects.data.forEach((project) => {
+            console.log(`- ${project.title} (Updated: ${project.updated_at})`);
+        });
+    }
+    catch (error) {
+        console.log('Error:', error.message);
+    }
+}
+// Run example if this file is executed directly
+if (require.main === module) {
+    demonstrateProjectFiltering().catch(console.error);
+}

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 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, GetCodespaceTaskResponse, CodespaceTaskData, TechnicalDocument, GetProjectTasksByCodespaceResponse } from './services/codespace/codespace-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, GetProjectTasksByCodespaceResponse } from './services/codespace/codespace-types';
 export type { StoreExternalTokenRequest, StoreExternalTokenResponse, ListTokensQuery, ListTokensResponse, ValidateTokenRequest, ValidateTokenResponse, FindBestMatchRequest, FindBestMatchResponse, Platform, TokenType } from './services/external-tokens/external-tokens-types';

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

@@ -1,11 +1,15 @@
 import { BaseService } from '../base/base-service';
-import { GenerateTaskTitleRequest, GenerateTaskTitleResponse, CreateCodespaceTaskRequest, CreateCodespaceTaskResponse, CreateCodespaceTaskRequestV2, CreateCodespaceTaskResponseV2, CreateBackgroundCodespaceTaskRequest, CreateBackgroundCodespaceTaskResponse, GetCodespaceTaskResponse, GetProjectTasksByCodespaceResponse } from './codespace-types';
+import { GenerateTaskTitleRequest, GenerateTaskTitleResponse, CreateCodespaceTaskRequest, CreateCodespaceTaskResponse, CreateCodespaceTaskRequestV2, CreateCodespaceTaskResponseV2, CreateBackgroundCodespaceTaskRequest, CreateBackgroundCodespaceTaskResponse, GetCodespaceTaskResponse, GetProjectTasksByCodespaceResponse, GetCodespaceTasksByProjectRequest, GetCodespaceTasksByProjectResponse, CodespaceTaskDetailedResponse, CodespaceQuestionnaireRequest, CodespaceQuestionnaireResponse } from './codespace-types';
 export declare class CodespaceService extends BaseService {
     generateTaskTitle(request: GenerateTaskTitleRequest): Promise<GenerateTaskTitleResponse>;
+    generateQuestionnaire(request: CodespaceQuestionnaireRequest): Promise<CodespaceQuestionnaireResponse>;
     createCodespaceTask(request: CreateCodespaceTaskRequest): Promise<CreateCodespaceTaskResponse>;
     createCodespaceTaskV2(request: CreateCodespaceTaskRequestV2): Promise<CreateCodespaceTaskResponseV2>;
     createBackgroundCodespaceTask(request: CreateBackgroundCodespaceTaskRequest): Promise<CreateBackgroundCodespaceTaskResponse>;
     getCodespaceTask(codespaceTaskId: string): Promise<GetCodespaceTaskResponse>;
     getProjectTasksByCodespace(codespaceTaskId: string): Promise<GetProjectTasksByCodespaceResponse>;
+    getCodespaceTasksByProject(params: GetCodespaceTasksByProjectRequest): Promise<GetCodespaceTasksByProjectResponse>;
+    getCodespaceTaskDetailed(codespaceTaskId: string): Promise<CodespaceTaskDetailedResponse>;
     private validateCodespaceTaskRequest;
+    private validateQuestionnaireRequest;
 }

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

@@ -6,6 +6,10 @@ class CodespaceService extends base_service_1.BaseService {
     async generateTaskTitle(request) {
         return this.post('/codespace/generate-task-title', request);
     }
+    async generateQuestionnaire(request) {
+        this.validateQuestionnaireRequest(request);
+        return this.post('/codespace/generate-questionnaire', request);
+    }
     async createCodespaceTask(request) {
         return this.post('/codespace/create-task', request);
     }
@@ -29,6 +33,30 @@ class CodespaceService extends base_service_1.BaseService {
         }
         return this.get(`/project-tasks/by-codespace/${codespaceTaskId}`);
     }
+    async getCodespaceTasksByProject(params) {
+        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(url);
+    }
+    async getCodespaceTaskDetailed(codespaceTaskId) {
+        if (!codespaceTaskId) {
+            throw new Error('codespace_task_id is required');
+        }
+        return this.get(`/codespace/task/${codespaceTaskId}/detailed`);
+    }
     validateCodespaceTaskRequest(request) {
         if (!request.project_id) {
             throw new Error('project_id is required');
@@ -36,7 +64,8 @@ class CodespaceService extends base_service_1.BaseService {
         if (!request.task_description) {
             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"');
         }
         // Validate model_api_keys if provided
@@ -57,6 +86,51 @@ class CodespaceService extends base_service_1.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');
+                }
+            }
+        }
+    }
+    validateQuestionnaireRequest(request) {
+        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');
+                }
+            }
+        }
     }
 }
 exports.CodespaceService = CodespaceService;

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

@@ -20,6 +20,13 @@ export interface ModelApiKey {
     model_name: string;
     api_key: string;
 }
+export interface Attachment {
+    filename: string;
+    file_data: string;
+    mime_type: string;
+    file_size: number;
+    description?: string;
+}
 export interface CreateCodespaceTaskRequestV2 {
     project_id: string;
     project_repository_id?: string;
@@ -35,6 +42,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 {
     success: boolean;
@@ -115,3 +125,41 @@ export interface CreateBackgroundCodespaceTaskRequest extends CreateCodespaceTas
 }
 export interface CreateBackgroundCodespaceTaskResponse extends CreateCodespaceTaskResponseV2 {
 }
+export interface GetCodespaceTasksByProjectRequest {
+    project_id: string;
+    status?: 'completed' | 'failed' | 'in_progress' | 'created' | 'cancelled';
+    limit?: number;
+    offset?: number;
+    sort_by?: string;
+    sort_order?: 'asc' | 'desc';
+}
+export interface GetCodespaceTasksByProjectResponse {
+    status: string;
+    data: CodespaceTaskData[];
+    total_count: number;
+    message: string;
+}
+export interface CodespaceTaskDetailedResponse {
+    status: string;
+    data: {
+        task: CodespaceTaskData;
+        project: any;
+        repository: any;
+        usage_summary: any;
+    };
+    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/dist/services/codespace/index.d.ts

@@ -1,3 +1,3 @@
 export { CodespaceService } from './codespace-service';
 export * from './codespace-types';
-export type { CreateCodespaceTaskRequestV2 as CreateCodespaceTaskRequest, CreateCodespaceTaskResponseV2 as CreateCodespaceTaskResponse, CreateBackgroundCodespaceTaskRequest, CreateBackgroundCodespaceTaskResponse, ModelApiKey, GetCodespaceTaskResponse, CodespaceTaskData, TechnicalDocument, GetProjectTasksByCodespaceResponse } from './codespace-types';
+export type { CreateCodespaceTaskRequestV2 as CreateCodespaceTaskRequest, CreateCodespaceTaskResponseV2 as CreateCodespaceTaskResponse, CreateBackgroundCodespaceTaskRequest, CreateBackgroundCodespaceTaskResponse, ModelApiKey, Attachment, GetCodespaceTaskResponse, CodespaceTaskData, TechnicalDocument, GetProjectTasksByCodespaceResponse, CodespaceQuestionnaireRequest, CodespaceQuestionnaireResponse } from './codespace-types';

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

@@ -1,7 +1,7 @@
 import { BaseService } from '../base/base-service';
-import { Project, CreateProjectRequest, UpdateProjectRequest, PaginatedProjectsRequest, PaginatedProjectsResponse, GetProjectDocumentsRequest, GetProjectDocumentsResponse, ConnectRepositoryRequest, ConnectRepositoryResponse } from './project-types';
+import { Project, CreateProjectRequest, UpdateProjectRequest, PaginatedProjectsRequest, PaginatedProjectsResponse, GetProjectsRequest, GetProjectDocumentsRequest, GetProjectDocumentsResponse, ConnectRepositoryRequest, ConnectRepositoryResponse } from './project-types';
 export declare class ProjectService extends BaseService {
-    getAllProjects(): Promise<Project[]>;
+    getAllProjects(params?: GetProjectsRequest): Promise<Project[]>;
     getPaginatedProjects(params: PaginatedProjectsRequest): Promise<PaginatedProjectsResponse>;
     getProjectById(projectId: string): Promise<Project>;
     createProject(request: CreateProjectRequest): Promise<Project>;

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

@@ -3,8 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ProjectService = void 0;
 const base_service_1 = require("../base/base-service");
 class ProjectService extends base_service_1.BaseService {
-    async getAllProjects() {
-        const response = await this.get('/projects');
+    async getAllProjects(params) {
+        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(url);
         return response.data;
     }
     async getPaginatedProjects(params) {
@@ -23,6 +28,8 @@ class ProjectService extends base_service_1.BaseService {
             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(url);
     }

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

@@ -1,3 +1,14 @@
+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 +17,7 @@ export interface Project {
     created_at: string;
     updated_at: string;
     project_documents: ProjectDocument[];
+    project_repositories: ProjectRepository[];
     category?: Category;
     codie_tool?: CodieTool;
     github_url?: string;
@@ -76,6 +88,9 @@ export interface ProjectResponse {
     status: string;
     data: Project;
 }
+export interface GetProjectsRequest {
+    has_repository?: boolean;
+}
 export interface PaginatedProjectsRequest {
     page?: number;
     page_size?: number;
@@ -84,6 +99,7 @@ export interface PaginatedProjectsRequest {
     start_date?: string;
     end_date?: string;
     sort_by_date?: 'asc' | 'desc';
+    has_repository?: boolean;
 }
 export interface PaginatedProjectsResponse {
     status: string;

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

@@ -1,8 +1,21 @@
+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 {
     task_id: string;