@codeguide/core 0.0.33 → 0.0.36

package/dist/services/prompt-generations/prompt-generations-service.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PromptGenerationsService = void 0;
+const base_service_1 = require("../base/base-service");
+class PromptGenerationsService extends base_service_1.BaseService {
+    /**
+     * Create a new AI system prompt generation
+     *
+     * Generates a new AI system prompt based on user input using GPT-5.1.
+     *
+     * POST /prompt-generations/
+     *
+     * @param request - The prompt generation request parameters
+     * @returns Promise resolving to the created prompt generation data
+     */
+    async createPromptGeneration(request) {
+        return this.post('/prompt-generations/', request);
+    }
+    /**
+     * List all prompt generations for the authenticated user
+     *
+     * Retrieves all prompt generations that belong to the current user.
+     *
+     * GET /prompt-generations/
+     *
+     * @returns Promise resolving to an array of prompt generations
+     */
+    async listPromptGenerations() {
+        return this.get('/prompt-generations/');
+    }
+    /**
+     * Get a specific prompt generation by ID
+     *
+     * Retrieves detailed information about a single prompt generation.
+     *
+     * GET /prompt-generations/{generation_id}
+     *
+     * @param generationId - The UUID of the prompt generation to retrieve
+     * @returns Promise resolving to the prompt generation data
+     */
+    async getPromptGeneration(generationId) {
+        return this.get(`/prompt-generations/${generationId}`);
+    }
+    /**
+     * Delete a specific prompt generation by ID
+     *
+     * Permanently removes a prompt generation from the database.
+     *
+     * DELETE /prompt-generations/{generation_id}
+     *
+     * @param generationId - The UUID of the prompt generation to delete
+     * @returns Promise resolving to the deleted prompt generation data
+     */
+    async deletePromptGeneration(generationId) {
+        return this.delete(`/prompt-generations/${generationId}`);
+    }
+}
+exports.PromptGenerationsService = PromptGenerationsService;

package/dist/services/prompt-generations/prompt-generations-types.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Persona types for prompt generation
+ */
+export type PersonaType = 'expert' | 'assistant' | 'teacher' | 'analyst' | 'creative';
+/**
+ * Output format types for generated prompts
+ */
+export type OutputFormatType = 'markdown' | 'json' | 'xml' | 'plain' | 'code';
+/**
+ * Request body for creating a new prompt generation
+ */
+export interface CreatePromptGenerationRequest {
+    /** User's description of their AI assistant */
+    input: string;
+    /** Persona type: expert, assistant, teacher, analyst, creative */
+    persona?: PersonaType;
+    /** Format: markdown, json, xml, plain, code */
+    output_format?: OutputFormatType;
+    /** Creativity level (0-2) */
+    temperature?: number;
+    /** Response length (256-8192) */
+    max_tokens?: number;
+    /** Include examples in prompt */
+    include_examples?: boolean;
+    /** Add constraints to prompt */
+    include_constraints?: boolean;
+    /** Include error handling guidance */
+    include_error_handling?: boolean;
+    /** Enable chain of thought */
+    chain_of_thought?: boolean;
+    /** Use JSON output schema */
+    structured_output?: boolean;
+}
+/**
+ * Prompt generation data model
+ */
+export interface PromptGeneration {
+    /** Unique identifier (UUID v4) */
+    id: string;
+    /** User ID who owns this generation */
+    user_id: string;
+    /** User's original input */
+    input: string;
+    /** Persona type used */
+    persona: PersonaType;
+    /** Output format */
+    output_format: OutputFormatType;
+    /** Temperature value */
+    temperature: number;
+    /** Max tokens setting */
+    max_tokens: number;
+    /** Include examples flag */
+    include_examples: boolean;
+    /** Include constraints flag */
+    include_constraints: boolean;
+    /** Include error handling flag */
+    include_error_handling: boolean;
+    /** Chain of thought flag */
+    chain_of_thought: boolean;
+    /** Structured output flag */
+    structured_output: boolean;
+    /** The generated AI system prompt */
+    generated_prompt: string;
+    /** Creation timestamp (ISO 8601 UTC) */
+    created_at: string;
+}
+/**
+ * Response for creating a prompt generation
+ */
+export interface CreatePromptGenerationResponse {
+    /** The created prompt generation */
+    data: PromptGeneration;
+}
+/**
+ * Response for listing prompt generations
+ */
+export interface ListPromptGenerationsResponse {
+    /** Array of prompt generations */
+    data: PromptGeneration[];
+}
+/**
+ * Response for getting a single prompt generation
+ */
+export interface GetPromptGenerationResponse {
+    /** The requested prompt generation */
+    data: PromptGeneration;
+}
+/**
+ * Response for deleting a prompt generation
+ */
+export interface DeletePromptGenerationResponse {
+    /** The deleted prompt generation */
+    data: PromptGeneration;
+}

package/dist/services/prompt-generations/prompt-generations-types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,2 @@
+export { StreamingService } from './streaming-service';
+export * from './streaming-types';

package/dist/services/streaming/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamingService = void 0;
+var streaming_service_1 = require("./streaming-service");
+Object.defineProperty(exports, "StreamingService", { enumerable: true, get: function () { return streaming_service_1.StreamingService; } });
+__exportStar(require("./streaming-types"), exports);

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

@@ -0,0 +1,30 @@
+import { BaseService } from '../base/base-service';
+import { StreamTechSpecRequest } from './streaming-types';
+export declare class StreamingService extends BaseService {
+    /**
+     * Stream a tech-spec document for the given project.
+     *
+     * This method connects to the `/chat/tech-spec` endpoint and streams the response
+     * using Server-Sent Events (SSE) format. Each chunk is passed to the `onChunk`
+     * callback as it arrives, allowing for incremental UI updates.
+     *
+     * @param request - The request containing the project_id
+     * @param onChunk - Callback function invoked with each content chunk as it arrives
+     * @param onError - Optional callback function for handling errors
+     * @returns Promise that resolves to the full accumulated content when streaming completes
+     *
+     * @example
+     * ```typescript
+     * const streamingService = new StreamingService(config);
+     * let fullContent = '';
+     *
+     * fullContent = await streamingService.streamTechSpec(
+     *   { project_id: 'project-123' },
+     *   (chunk) => {
+     *     setContent(prev => prev + chunk); // Update UI incrementally
+     *   }
+     * );
+     * ```
+     */
+    streamTechSpec(request: StreamTechSpecRequest, onChunk: (content: string) => void, onError?: (error: Error) => void): Promise<string>;
+}

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

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamingService = void 0;
+const base_service_1 = require("../base/base-service");
+class StreamingService extends base_service_1.BaseService {
+    /**
+     * Stream a tech-spec document for the given project.
+     *
+     * This method connects to the `/chat/tech-spec` endpoint and streams the response
+     * using Server-Sent Events (SSE) format. Each chunk is passed to the `onChunk`
+     * callback as it arrives, allowing for incremental UI updates.
+     *
+     * @param request - The request containing the project_id
+     * @param onChunk - Callback function invoked with each content chunk as it arrives
+     * @param onError - Optional callback function for handling errors
+     * @returns Promise that resolves to the full accumulated content when streaming completes
+     *
+     * @example
+     * ```typescript
+     * const streamingService = new StreamingService(config);
+     * let fullContent = '';
+     *
+     * fullContent = await streamingService.streamTechSpec(
+     *   { project_id: 'project-123' },
+     *   (chunk) => {
+     *     setContent(prev => prev + chunk); // Update UI incrementally
+     *   }
+     * );
+     * ```
+     */
+    async streamTechSpec(request, onChunk, onError) {
+        return new Promise(async (resolve, reject) => {
+            let fullContent = '';
+            const fullUrl = `${this.client.defaults.baseURL}/chat/tech-spec`;
+            try {
+                const response = await fetch(fullUrl, {
+                    method: 'POST',
+                    headers: {
+                        ...Object.fromEntries(Object.entries(this.client.defaults.headers).filter(([_, v]) => typeof v === 'string')),
+                        Accept: 'text/event-stream',
+                        'Cache-Control': 'no-cache',
+                    },
+                    body: JSON.stringify(request),
+                });
+                if (!response.ok) {
+                    const errorText = await response.text();
+                    const error = new Error(`HTTP ${response.status}: ${errorText || response.statusText}`);
+                    onError?.(error);
+                    reject(error);
+                    return;
+                }
+                const reader = response.body?.getReader();
+                if (!reader) {
+                    const error = new Error('Response body is not readable');
+                    onError?.(error);
+                    reject(error);
+                    return;
+                }
+                const decoder = new TextDecoder();
+                let buffer = '';
+                while (true) {
+                    const { done, value } = await reader.read();
+                    if (done) {
+                        resolve(fullContent);
+                        break;
+                    }
+                    buffer += decoder.decode(value, { stream: true });
+                    const lines = buffer.split('\n');
+                    buffer = lines.pop() || ''; // Keep incomplete line in buffer
+                    for (const line of lines) {
+                        if (line.startsWith('data: ')) {
+                            const jsonStr = line.slice(6); // Remove 'data: ' prefix
+                            if (jsonStr.trim()) {
+                                try {
+                                    const chunk = JSON.parse(jsonStr);
+                                    if (chunk.error) {
+                                        const error = new Error(chunk.error);
+                                        onError?.(error);
+                                        reject(error);
+                                        return;
+                                    }
+                                    if (chunk.done) {
+                                        resolve(fullContent);
+                                        return;
+                                    }
+                                    if (chunk.content) {
+                                        fullContent += chunk.content;
+                                        onChunk(chunk.content);
+                                    }
+                                }
+                                catch (parseError) {
+                                    console.warn('Failed to parse SSE data:', jsonStr, parseError);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            catch (error) {
+                const err = error instanceof Error ? error : new Error(String(error));
+                onError?.(err);
+                reject(err);
+            }
+        });
+    }
+}
+exports.StreamingService = StreamingService;

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

@@ -0,0 +1,14 @@
+/**
+ * Request type for streaming a tech-spec
+ */
+export interface StreamTechSpecRequest {
+    project_id: string;
+}
+/**
+ * A single chunk from the SSE stream
+ */
+export interface StreamChunk {
+    content: string;
+    done: boolean;
+    error?: string;
+}

package/dist/services/streaming/streaming-types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/services/tasks/task-service.d.ts

@@ -1,5 +1,5 @@
 import { BaseService } from '../base/base-service';
-import { TaskGroup, ProjectTask, CreateTaskGroupRequest, UpdateTaskGroupRequest, CreateProjectTaskRequest, UpdateProjectTaskRequest, ProjectTaskListResponse, PaginatedTaskGroupsRequest, PaginatedTaskGroupsResponse, PaginatedProjectTasksRequest, PaginatedProjectTasksResponse, GenerateTasksRequest, GenerateTasksResponse, GetTasksByProjectRequest, GetTasksByProjectResponse, UpdateTaskRequest, UpdateTaskResponse } from './task-types';
+import { TaskGroup, ProjectTask, CreateTaskGroupRequest, UpdateTaskGroupRequest, CreateProjectTaskRequest, UpdateProjectTaskRequest, ProjectTaskListResponse, PaginatedTaskGroupsRequest, PaginatedTaskGroupsResponse, PaginatedProjectTasksRequest, PaginatedProjectTasksResponse, GenerateTasksRequest, GenerateTasksResponse, GetTasksByProjectRequest, GetTasksByProjectResponse, UpdateTaskRequest, UpdateTaskResponse, GenerateTasksCustomBackgroundRequest, GenerateTasksCustomBackgroundResponse, GeneratePromptRequest, GeneratePromptResponse } from './task-types';
 export declare class TaskService extends BaseService {
     getAllTaskGroups(): Promise<TaskGroup[]>;
     getPaginatedTaskGroups(params: PaginatedTaskGroupsRequest): Promise<PaginatedTaskGroupsResponse>;
@@ -25,7 +25,9 @@ export declare class TaskService extends BaseService {
         message: string;
     }>;
     generateTasks(request: GenerateTasksRequest): Promise<GenerateTasksResponse>;
+    generateTasksCustomBackground(request: GenerateTasksCustomBackgroundRequest): Promise<GenerateTasksCustomBackgroundResponse>;
     getTasksByProject(request: GetTasksByProjectRequest): Promise<GetTasksByProjectResponse>;
     updateTask(taskId: string, request: UpdateTaskRequest): Promise<UpdateTaskResponse>;
     getProjectTasksbyCodespace(codespaceTaskId: string): Promise<ProjectTaskListResponse>;
+    generatePrompt(taskId: string, request?: GeneratePromptRequest): Promise<GeneratePromptResponse>;
 }

package/dist/services/tasks/task-service.js

@@ -116,6 +116,10 @@ class TaskService extends base_service_1.BaseService {
     async generateTasks(request) {
         return this.post('/project-tasks/generate-tasks', request);
     }
+    // Generate Tasks Custom (Background)
+    async generateTasksCustomBackground(request) {
+        return this.post('/project-tasks/generate-tasks-custom/background', request);
+    }
     // Get Tasks by Project
     async getTasksByProject(request) {
         const queryParams = new URLSearchParams();
@@ -138,5 +142,9 @@ class TaskService extends base_service_1.BaseService {
         const url = `/project-tasks/by-codespace/${codespaceTaskId}`;
         return this.get(url);
     }
+    // Generate Prompt for a Project Task
+    async generatePrompt(taskId, request = {}) {
+        return this.post(`/project-tasks/${taskId}/generate-prompt`, request);
+    }
 }
 exports.TaskService = TaskService;

package/dist/services/tasks/task-types.d.ts

@@ -170,3 +170,18 @@ export interface UpdateTaskResponse {
         task: ProjectTask;
     };
 }
+export interface GenerateTasksCustomBackgroundRequest {
+    project_id: string;
+}
+export interface GenerateTasksCustomBackgroundResponse {
+    status: string;
+    job_id: string;
+    message: string;
+}
+export interface GeneratePromptRequest {
+    additional_context?: string;
+}
+export interface GeneratePromptResponse {
+    status: string;
+    prompt: string;
+}

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

@@ -1,5 +1,5 @@
 import { BaseService } from '../base/base-service';
-import { TrackUsageRequest, TrackUsageResponse, CreditBalanceResponse, CreditCheckRequest, CreditCheckResponse, UsageSummaryRequest, UsageSummaryResponse, AuthorizationResponse, FreeUserStatusResponse, CalculateUsageRequest, CalculateUsageResponse, TrackCodespaceUsageRequest, TrackCodespaceUsageResponse, CodespaceTaskUsageResponse, DashboardAnalyticsRequest, DashboardAnalyticsResponse, UsageDetailsRequest, UsageDetailsResponse, ServiceBreakdownRequest, ServiceBreakdownResponse } from './usage-types';
+import { TrackUsageRequest, TrackUsageResponse, CreditBalanceResponse, CreditCheckRequest, CreditCheckResponse, UsageSummaryRequest, UsageSummaryResponse, AuthorizationResponse, FreeUserStatusResponse, CalculateUsageRequest, CalculateUsageResponse, TrackCodespaceUsageRequest, TrackCodespaceUsageResponse, CodespaceTaskUsageResponse, DashboardAnalyticsRequest, DashboardAnalyticsResponse, UsageDetailsRequest, UsageDetailsResponse, ServiceBreakdownRequest, ServiceBreakdownResponse, ActivityHeatmapRequest, ActivityHeatmapResponse, RepositoryAnalysisSummaryRequest, RepositoryAnalysisSummaryResponse, RepositoryAnalysisTimelineRequest, RepositoryAnalysisTimelineResponse } from './usage-types';
 export declare class UsageService extends BaseService {
     trackUsage(request: TrackUsageRequest): Promise<TrackUsageResponse>;
     getCreditBalance(): Promise<CreditBalanceResponse>;
@@ -14,4 +14,38 @@ export declare class UsageService extends BaseService {
     getUsageDetails(params?: UsageDetailsRequest): Promise<UsageDetailsResponse>;
     getUsageSummary(params?: UsageSummaryRequest): Promise<UsageSummaryResponse>;
     getServiceBreakdown(params?: ServiceBreakdownRequest): Promise<ServiceBreakdownResponse>;
+    /**
+     * Get activity heatmap data based on codespace tasks created.
+     * Similar to GitHub's contribution graph.
+     *
+     * @param params - Optional request parameters
+     * @param params.period - Time period: '3m', '6m', '1y' (default: '3m')
+     * @param params.start_date - Custom start date in YYYY-MM-DD format
+     * @param params.end_date - Custom end date in YYYY-MM-DD format
+     * @returns Activity heatmap data with daily counts and levels
+     */
+    getActivityHeatmap(params?: ActivityHeatmapRequest): Promise<ActivityHeatmapResponse>;
+    /**
+     * Get summary statistics for repository analysis.
+     * Provides aggregated metrics across all analyzed repositories.
+     *
+     * @param params - Optional request parameters
+     * @param params.period - Time period: '7d', '1w', '1m', '3m', '6m', '1y' (optional - defaults to all-time)
+     * @param params.start_date - Custom start date in YYYY-MM-DD format
+     * @param params.end_date - Custom end date in YYYY-MM-DD format
+     * @returns Summary statistics including total repos, lines, files, etc.
+     */
+    getRepositoryAnalysisSummary(params?: RepositoryAnalysisSummaryRequest): Promise<RepositoryAnalysisSummaryResponse>;
+    /**
+     * Get timeline data for repository analysis suitable for line graphs.
+     * Provides time-series data for visualization.
+     *
+     * @param params - Optional request parameters
+     * @param params.period - Time period: '7d', '1w', '1m', '3m', '6m', '1y' (default: '1m')
+     * @param params.start_date - Custom start date in YYYY-MM-DD format
+     * @param params.end_date - Custom end date in YYYY-MM-DD format
+     * @param params.granularity - Data granularity: 'daily', 'weekly', 'monthly' (default: 'daily')
+     * @returns Timeline data with repos analyzed, lines, files per period
+     */
+    getRepositoryAnalysisTimeline(params?: RepositoryAnalysisTimelineRequest): Promise<RepositoryAnalysisTimelineResponse>;
 }

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

@@ -113,5 +113,73 @@ class UsageService extends base_service_1.BaseService {
         const url = `/usage/dashboard/services${queryParams.toString() ? `?${queryParams.toString()}` : ''}`;
         return this.get(url);
     }
+    // Activity Heatmap Methods
+    /**
+     * Get activity heatmap data based on codespace tasks created.
+     * Similar to GitHub's contribution graph.
+     *
+     * @param params - Optional request parameters
+     * @param params.period - Time period: '3m', '6m', '1y' (default: '3m')
+     * @param params.start_date - Custom start date in YYYY-MM-DD format
+     * @param params.end_date - Custom end date in YYYY-MM-DD format
+     * @returns Activity heatmap data with daily counts and levels
+     */
+    async getActivityHeatmap(params) {
+        const queryParams = new URLSearchParams();
+        if (params?.period)
+            queryParams.append('period', params.period);
+        if (params?.start_date)
+            queryParams.append('start_date', params.start_date);
+        if (params?.end_date)
+            queryParams.append('end_date', params.end_date);
+        const url = `/usage/dashboard/activity-heatmap${queryParams.toString() ? `?${queryParams.toString()}` : ''}`;
+        return this.get(url);
+    }
+    // Repository Analysis Stats Methods
+    /**
+     * Get summary statistics for repository analysis.
+     * Provides aggregated metrics across all analyzed repositories.
+     *
+     * @param params - Optional request parameters
+     * @param params.period - Time period: '7d', '1w', '1m', '3m', '6m', '1y' (optional - defaults to all-time)
+     * @param params.start_date - Custom start date in YYYY-MM-DD format
+     * @param params.end_date - Custom end date in YYYY-MM-DD format
+     * @returns Summary statistics including total repos, lines, files, etc.
+     */
+    async getRepositoryAnalysisSummary(params) {
+        const queryParams = new URLSearchParams();
+        if (params?.period)
+            queryParams.append('period', params.period);
+        if (params?.start_date)
+            queryParams.append('start_date', params.start_date);
+        if (params?.end_date)
+            queryParams.append('end_date', params.end_date);
+        const url = `/usage/dashboard/repo-analysis/summary${queryParams.toString() ? `?${queryParams.toString()}` : ''}`;
+        return this.get(url);
+    }
+    /**
+     * Get timeline data for repository analysis suitable for line graphs.
+     * Provides time-series data for visualization.
+     *
+     * @param params - Optional request parameters
+     * @param params.period - Time period: '7d', '1w', '1m', '3m', '6m', '1y' (default: '1m')
+     * @param params.start_date - Custom start date in YYYY-MM-DD format
+     * @param params.end_date - Custom end date in YYYY-MM-DD format
+     * @param params.granularity - Data granularity: 'daily', 'weekly', 'monthly' (default: 'daily')
+     * @returns Timeline data with repos analyzed, lines, files per period
+     */
+    async getRepositoryAnalysisTimeline(params) {
+        const queryParams = new URLSearchParams();
+        if (params?.period)
+            queryParams.append('period', params.period);
+        if (params?.start_date)
+            queryParams.append('start_date', params.start_date);
+        if (params?.end_date)
+            queryParams.append('end_date', params.end_date);
+        if (params?.granularity)
+            queryParams.append('granularity', params.granularity);
+        const url = `/usage/dashboard/repo-analysis/timeline${queryParams.toString() ? `?${queryParams.toString()}` : ''}`;
+        return this.get(url);
+    }
 }
 exports.UsageService = UsageService;