@codeguide/core 0.0.33 → 0.0.36

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

@@ -0,0 +1,101 @@
+/**
+ * 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/services/streaming/index.ts

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

package/services/streaming/streaming-service.ts

@@ -0,0 +1,123 @@
+import { BaseService } from '../base/base-service'
+import { StreamTechSpecRequest, StreamChunk } from './streaming-types'
+
+export 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
+   *   }
+   * );
+   * ```
+   */
+  async streamTechSpec(
+    request: StreamTechSpecRequest,
+    onChunk: (content: string) => void,
+    onError?: (error: Error) => void
+  ): Promise<string> {
+    return new Promise<string>(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'
+              ) as [string, 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: StreamChunk = 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)
+      }
+    })
+  }
+}

package/services/streaming/streaming-types.ts

@@ -0,0 +1,15 @@
+/**
+ * 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/services/tasks/task-service.ts

@@ -20,6 +20,10 @@ import {
   GetTasksByProjectResponse,
   UpdateTaskRequest,
   UpdateTaskResponse,
+  GenerateTasksCustomBackgroundRequest,
+  GenerateTasksCustomBackgroundResponse,
+  GeneratePromptRequest,
+  GeneratePromptResponse,
 } from './task-types'
 
 export class TaskService extends BaseService {
@@ -84,7 +88,10 @@ export class TaskService extends BaseService {
         })
         taskGroup = updateResponse
       } catch (error) {
-        console.warn('Failed to create codespace task, but task group was created successfully:', error)
+        console.warn(
+          'Failed to create codespace task, but task group was created successfully:',
+          error
+        )
         // Continue without codespace task if it fails
       }
     }
@@ -93,7 +100,10 @@ export class TaskService extends BaseService {
   }
 
   async updateTaskGroup(taskGroupId: string, request: UpdateTaskGroupRequest): Promise<TaskGroup> {
-    const response = await this.put<TaskGroupResponse>(`/project-tasks/task-groups/${taskGroupId}`, request)
+    const response = await this.put<TaskGroupResponse>(
+      `/project-tasks/task-groups/${taskGroupId}`,
+      request
+    )
     return response.data
   }
 
@@ -158,6 +168,16 @@ export class TaskService extends BaseService {
     return this.post<GenerateTasksResponse>('/project-tasks/generate-tasks', request)
   }
 
+  // Generate Tasks Custom (Background)
+  async generateTasksCustomBackground(
+    request: GenerateTasksCustomBackgroundRequest
+  ): Promise<GenerateTasksCustomBackgroundResponse> {
+    return this.post<GenerateTasksCustomBackgroundResponse>(
+      '/project-tasks/generate-tasks-custom/background',
+      request
+    )
+  }
+
   // Get Tasks by Project
   async getTasksByProject(request: GetTasksByProjectRequest): Promise<GetTasksByProjectResponse> {
     const queryParams = new URLSearchParams()
@@ -183,4 +203,12 @@ export class TaskService extends BaseService {
     const url = `/project-tasks/by-codespace/${codespaceTaskId}`
     return this.get<ProjectTaskListResponse>(url)
   }
+
+  // Generate Prompt for a Project Task
+  async generatePrompt(
+    taskId: string,
+    request: GeneratePromptRequest = {}
+  ): Promise<GeneratePromptResponse> {
+    return this.post<GeneratePromptResponse>(`/project-tasks/${taskId}/generate-prompt`, request)
+  }
 }

package/services/tasks/task-types.ts

@@ -179,7 +179,6 @@ export interface GetTasksByProjectResponse {
   }
 }
 
-
 export interface UpdateTaskRequest {
   status?: string
   ai_result?: string
@@ -194,3 +193,22 @@ 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/services/usage/usage-service.ts

@@ -21,6 +21,14 @@ import {
   UsageDetailsResponse,
   ServiceBreakdownRequest,
   ServiceBreakdownResponse,
+  // Activity Heatmap types
+  ActivityHeatmapRequest,
+  ActivityHeatmapResponse,
+  // Repository Analysis types
+  RepositoryAnalysisSummaryRequest,
+  RepositoryAnalysisSummaryResponse,
+  RepositoryAnalysisTimelineRequest,
+  RepositoryAnalysisTimelineResponse,
 } from './usage-types'
 
 export class UsageService extends BaseService {
@@ -142,4 +150,77 @@ export class UsageService extends BaseService {
     const url = `/usage/dashboard/services${queryParams.toString() ? `?${queryParams.toString()}` : ''}`
     return this.get<ServiceBreakdownResponse>(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?: ActivityHeatmapRequest): Promise<ActivityHeatmapResponse> {
+    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<ActivityHeatmapResponse>(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?: RepositoryAnalysisSummaryRequest
+  ): Promise<RepositoryAnalysisSummaryResponse> {
+    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<RepositoryAnalysisSummaryResponse>(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?: RepositoryAnalysisTimelineRequest
+  ): Promise<RepositoryAnalysisTimelineResponse> {
+    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<RepositoryAnalysisTimelineResponse>(url)
+  }
 }

package/services/usage/usage-types.ts

@@ -51,8 +51,8 @@ export interface CreditBalance {
   remaining_credits: number
   is_over_limit: boolean
   utilization_percentage: number
-  billing_cycle_start: string
-  billing_cycle_end: string
+  billing_cycle_start?: string
+  billing_cycle_end?: string
 }
 
 export interface LimitInfo {
@@ -77,18 +77,19 @@ export interface PlanLimits {
     storage_gb: LimitInfo
     projects: LimitInfo
     collaborators: LimitInfo
+    softwarev2_access?: LimitInfo
   }
 }
 
 export interface AuthorizationSubscription {
-  id: string
-  status: string
-  interval: string
-  current_period_start: string
-  current_period_end: string
-  price_id: string
-  product_name: string | null
-  plan_name: string
+  id?: string
+  status?: string
+  interval?: string
+  current_period_start?: string
+  current_period_end?: string
+  price_id?: string
+  product_name?: string | null
+  plan_name?: string
 }
 
 export interface AuthorizationData {
@@ -103,7 +104,7 @@ export interface AuthorizationData {
   can_create_tasks: boolean
   can_analyze_repos: boolean
   can_access_previous_projects: boolean
-  plan_limits: PlanLimits
+  plan_limits?: PlanLimits | null
   codespace_task_limit: LimitInfo | null
 }
 
@@ -291,34 +292,13 @@ export interface UsageSummaryRequest {
   end_date?: string
 }
 
-export interface CurrentPeriodUsage {
-  credits_consumed: number
-  cost_usd: number
-  requests_count: number
-}
-
-export interface PreviousPeriodUsage {
-  credits_consumed: number
-  cost_usd: number
-  requests_count: number
-}
-
-export interface BillingCycleInfo {
-  total_allotted: number
-  total_consumed: number
-  remaining_credits: number
-}
-
 export interface UsageSummaryResponse {
   status: string
   data: {
-    current_period: CurrentPeriodUsage
-    previous_period: PreviousPeriodUsage
-    billing_cycle: BillingCycleInfo
-    utilization_percentage: number
-    remaining_credits: number
-    daily_average: number
-    projected_monthly: number
+    period: { start?: string; end?: string }
+    usage: { [key: string]: number }
+    breakdown: { [key: string]: number }
+    service_breakdown: Array<{ service_type: string; [key: string]: any }>
   }
 }
 
@@ -349,3 +329,104 @@ export interface ServiceBreakdownResponse {
   status: string
   data: ServiceBreakdownData
 }
+
+// Activity Heatmap Types (GitHub-style contribution graph)
+export type HeatmapPeriodType = '3m' | '6m' | '1y'
+export type ActivityLevel = 0 | 1 | 2 | 3 | 4
+
+export interface ActivityHeatmapRequest {
+  period?: HeatmapPeriodType
+  start_date?: string
+  end_date?: string
+}
+
+export interface HeatmapDayData {
+  date: string
+  count: number
+  level: ActivityLevel
+}
+
+export interface ActivityHeatmapData {
+  period: PeriodInfo
+  days: HeatmapDayData[]
+  total_tasks: number
+  most_active_day: string | null
+  max_daily_count: number
+  average_daily: number
+  active_days: number
+}
+
+export interface ActivityHeatmapResponse {
+  status: string
+  data: ActivityHeatmapData
+}
+
+// Repository Analysis Summary Types
+export type RepoAnalysisPeriodType = '7d' | '1w' | '1m' | '3m' | '6m' | '1y'
+
+export interface RepositoryAnalysisSummaryRequest {
+  period?: RepoAnalysisPeriodType
+  start_date?: string
+  end_date?: string
+}
+
+export interface RepositoryAnalysisSummaryData {
+  total_repositories: number
+  total_lines: number
+  total_files_processed: number
+  total_files_found: number
+  total_directories: number
+  total_characters: number
+  estimated_tokens_total: number
+  total_size_bytes: number
+  binary_files_skipped: number
+  large_files_skipped: number
+  encoding_errors: number
+  average_lines_per_repo: number
+  average_files_per_repo: number
+  period: PeriodInfo | null
+}
+
+export interface RepositoryAnalysisSummaryResponse {
+  status: string
+  data: RepositoryAnalysisSummaryData
+}
+
+// Repository Analysis Timeline Types
+export type TimelineGranularity = 'daily' | 'weekly' | 'monthly'
+
+export interface RepositoryAnalysisTimelineRequest {
+  period?: RepoAnalysisPeriodType
+  start_date?: string
+  end_date?: string
+  granularity?: TimelineGranularity
+}
+
+export interface RepositoryAnalysisTimelineItem {
+  date: string
+  repos_analyzed: number
+  total_lines: number
+  total_files: number
+  total_characters: number
+  estimated_tokens: number
+}
+
+export interface RepositoryAnalysisTimelineTotals {
+  repos_analyzed: number
+  total_lines: number
+  total_files: number
+  total_characters: number
+  estimated_tokens: number
+}
+
+export interface RepositoryAnalysisTimelineData {
+  period: PeriodInfo
+  granularity: TimelineGranularity
+  timeline: RepositoryAnalysisTimelineItem[]
+  totals: RepositoryAnalysisTimelineTotals
+}
+
+export interface RepositoryAnalysisTimelineResponse {
+  status: string
+  data: RepositoryAnalysisTimelineData
+}

package/services/users/user-service.ts

@@ -1,5 +1,8 @@
 import { BaseService } from '../base/base-service'
-import { GetCurrentClerkUserResponse } from './user-types'
+import {
+  GetCurrentClerkUserResponse,
+  CheckAdminStatusResponse,
+} from './user-types'
 
 export class UserService extends BaseService {
   /**
@@ -12,4 +15,15 @@ export class UserService extends BaseService {
   async getCurrentClerkUser(): Promise<GetCurrentClerkUserResponse> {
     return this.get<GetCurrentClerkUserResponse>('/users/me/clerk')
   }
+
+  /**
+   * Check if the current authenticated user has admin role
+   *
+   * GET /users/me/admin
+   *
+   * @returns Promise resolving to admin status data
+   */
+  async checkAdminStatus(): Promise<CheckAdminStatusResponse> {
+    return this.get<CheckAdminStatusResponse>('/users/me/admin')
+  }
 }

package/services/users/user-types.ts

@@ -57,3 +57,19 @@ export interface GetCurrentClerkUserResponse {
   status: 'success' | 'error'
   data: ClerkUserData
 }
+
+/**
+ * Admin status check data
+ */
+export interface AdminStatusData {
+  is_admin: boolean
+  user_id: string
+}
+
+/**
+ * Response for checking if current user is admin
+ */
+export interface CheckAdminStatusResponse {
+  status: 'success' | 'error'
+  data: AdminStatusData
+}