@codeguide/core 0.0.1

package/services/tasks/task-service.ts

@@ -0,0 +1,143 @@
+import { BaseService } from '../base/base-service'
+import {
+  TaskGroup,
+  ProjectTask,
+  CreateTaskGroupRequest,
+  UpdateTaskGroupRequest,
+  CreateProjectTaskRequest,
+  UpdateProjectTaskRequest,
+  TaskGroupListResponse,
+  TaskGroupResponse,
+  ProjectTaskListResponse,
+  ProjectTaskResponse,
+  PaginatedTaskGroupsRequest,
+  PaginatedTaskGroupsResponse,
+  PaginatedProjectTasksRequest,
+  PaginatedProjectTasksResponse,
+  GenerateTasksRequest,
+  GenerateTasksResponse,
+  GetTasksByProjectRequest,
+  GetTasksByProjectResponse,
+  StartTaskRequest,
+  StartTaskResponse,
+  UpdateTaskRequest,
+  UpdateTaskResponse,
+} from './task-types'
+
+export class TaskService extends BaseService {
+  // Task Groups
+  async getAllTaskGroups(): Promise<TaskGroup[]> {
+    const response = await this.get<TaskGroupListResponse>('/task-groups')
+    return response.data
+  }
+
+  async getPaginatedTaskGroups(
+    params: PaginatedTaskGroupsRequest
+  ): Promise<PaginatedTaskGroupsResponse> {
+    const queryParams = new URLSearchParams()
+
+    if (params.page !== undefined) queryParams.append('page', params.page.toString())
+    if (params.page_size !== undefined) queryParams.append('page_size', params.page_size.toString())
+    if (params.project_id) queryParams.append('project_id', params.project_id)
+
+    const url = `/task-groups/paginated${queryParams.toString() ? `?${queryParams.toString()}` : ''}`
+    return this.get<PaginatedTaskGroupsResponse>(url)
+  }
+
+  async getTaskGroupById(taskGroupId: string): Promise<TaskGroup> {
+    const response = await this.get<TaskGroupResponse>(`/task-groups/${taskGroupId}`)
+    return response.data
+  }
+
+  async createTaskGroup(request: CreateTaskGroupRequest): Promise<TaskGroup> {
+    const response = await this.post<TaskGroupResponse>('/task-groups', request)
+    return response.data
+  }
+
+  async updateTaskGroup(taskGroupId: string, request: UpdateTaskGroupRequest): Promise<TaskGroup> {
+    const response = await this.put<TaskGroupResponse>(`/task-groups/${taskGroupId}`, request)
+    return response.data
+  }
+
+  async deleteTaskGroup(taskGroupId: string): Promise<{ status: string; message: string }> {
+    return this.delete<{ status: string; message: string }>(`/task-groups/${taskGroupId}`)
+  }
+
+  // Project Tasks
+  async getAllProjectTasks(filters?: {
+    task_group_id?: string
+    parent_task_id?: string
+    status?: string
+  }): Promise<ProjectTask[]> {
+    const queryParams = new URLSearchParams()
+
+    if (filters?.task_group_id) queryParams.append('task_group_id', filters.task_group_id)
+    if (filters?.parent_task_id) queryParams.append('parent_task_id', filters.parent_task_id)
+    if (filters?.status) queryParams.append('status', filters.status)
+
+    const url = `/project-tasks${queryParams.toString() ? `?${queryParams.toString()}` : ''}`
+    const response = await this.get<ProjectTaskListResponse>(url)
+    return response.data
+  }
+
+  async getPaginatedProjectTasks(
+    params: PaginatedProjectTasksRequest
+  ): Promise<PaginatedProjectTasksResponse> {
+    const queryParams = new URLSearchParams()
+
+    if (params.page !== undefined) queryParams.append('page', params.page.toString())
+    if (params.page_size !== undefined) queryParams.append('page_size', params.page_size.toString())
+    if (params.task_group_id) queryParams.append('task_group_id', params.task_group_id)
+    if (params.parent_task_id) queryParams.append('parent_task_id', params.parent_task_id)
+    if (params.status) queryParams.append('status', params.status)
+    if (params.search_query) queryParams.append('search_query', params.search_query)
+
+    const url = `/project-tasks/paginated${queryParams.toString() ? `?${queryParams.toString()}` : ''}`
+    return this.get<PaginatedProjectTasksResponse>(url)
+  }
+
+  async getProjectTaskById(taskId: string): Promise<ProjectTask> {
+    const response = await this.get<ProjectTaskResponse>(`/project-tasks/${taskId}`)
+    return response.data
+  }
+
+  async createProjectTask(request: CreateProjectTaskRequest): Promise<ProjectTask> {
+    const response = await this.post<ProjectTaskResponse>('/project-tasks', request)
+    return response.data
+  }
+
+  async updateProjectTask(taskId: string, request: UpdateProjectTaskRequest): Promise<ProjectTask> {
+    const response = await this.put<ProjectTaskResponse>(`/project-tasks/${taskId}`, request)
+    return response.data
+  }
+
+  async deleteProjectTask(taskId: string): Promise<{ status: string; message: string }> {
+    return this.delete<{ status: string; message: string }>(`/project-tasks/${taskId}`)
+  }
+
+  // Generate Tasks
+  async generateTasks(request: GenerateTasksRequest): Promise<GenerateTasksResponse> {
+    return this.post<GenerateTasksResponse>('/project-tasks/generate-tasks', request)
+  }
+
+  // Get Tasks by Project
+  async getTasksByProject(request: GetTasksByProjectRequest): Promise<GetTasksByProjectResponse> {
+    const queryParams = new URLSearchParams()
+
+    if (request.status) queryParams.append('status', request.status)
+    if (request.task_group_id) queryParams.append('task_group_id', request.task_group_id)
+
+    const url = `/project-tasks/by-project/${request.project_id}${queryParams.toString() ? `?${queryParams.toString()}` : ''}`
+    return this.get<GetTasksByProjectResponse>(url)
+  }
+
+  // Start Task
+  async startTask(request: StartTaskRequest): Promise<StartTaskResponse> {
+    return this.post<StartTaskResponse>(`/project-tasks/${request.task_id}/start`, request)
+  }
+
+  // Update Task
+  async updateTask(taskId: string, request: UpdateTaskRequest): Promise<UpdateTaskResponse> {
+    return this.put<UpdateTaskResponse>(`/project-tasks/${taskId}`, request)
+  }
+}

package/services/tasks/task-types.ts

@@ -0,0 +1,165 @@
+export interface TaskGroup {
+  id: string
+  name: string
+  description?: string
+  user_id: string
+  project_id: string
+  created_at: string
+  updated_at: string
+  project_tasks: ProjectTask[]
+}
+
+export interface ProjectTask {
+  id: string
+  title: string
+  description?: string
+  status: string
+  user_id: string
+  task_group_id: string
+  parent_task_id?: string
+  ordinal: number
+  created_at: string
+  updated_at: string
+  subtasks?: ProjectTask[]
+}
+
+export interface CreateTaskGroupRequest {
+  name: string
+  description?: string
+  project_id: string
+}
+
+export interface UpdateTaskGroupRequest {
+  name?: string
+  description?: string
+  project_id?: string
+}
+
+export interface CreateProjectTaskRequest {
+  title: string
+  description?: string
+  task_group_id: string
+  parent_task_id?: string
+  ordinal?: number
+}
+
+export interface UpdateProjectTaskRequest {
+  title?: string
+  description?: string
+  status?: string
+  task_group_id?: string
+  parent_task_id?: string
+  ordinal?: number
+}
+
+export interface TaskGroupListResponse {
+  status: string
+  data: TaskGroup[]
+}
+
+export interface TaskGroupResponse {
+  status: string
+  data: TaskGroup
+}
+
+export interface ProjectTaskListResponse {
+  status: string
+  data: ProjectTask[]
+}
+
+export interface ProjectTaskResponse {
+  status: string
+  data: ProjectTask
+}
+
+export interface PaginatedTaskGroupsRequest {
+  page?: number
+  page_size?: number
+  project_id?: string
+}
+
+export interface PaginatedTaskGroupsResponse {
+  status: string
+  data: TaskGroup[]
+  pagination: {
+    total: number
+    page: number
+    page_size: number
+    total_pages: number
+  }
+}
+
+export interface PaginatedProjectTasksRequest {
+  page?: number
+  page_size?: number
+  task_group_id?: string
+  parent_task_id?: string
+  status?: string
+  search_query?: string
+}
+
+export interface PaginatedProjectTasksResponse {
+  status: string
+  data: ProjectTask[]
+  pagination: {
+    total: number
+    page: number
+    page_size: number
+    total_pages: number
+  }
+}
+
+export interface GenerateTasksRequest {
+  project_id: string
+}
+
+export interface GenerateTasksResponse {
+  status: string
+  message: string
+  data?: {
+    task_groups_created: number
+    tasks_created: number
+  }
+}
+
+export interface GetTasksByProjectRequest {
+  project_id: string
+  status?: string
+  task_group_id?: string
+}
+
+export interface GetTasksByProjectResponse {
+  status: string
+  data: {
+    task_groups: TaskGroup[]
+    tasks: ProjectTask[]
+  }
+}
+
+export interface StartTaskRequest {
+  task_id: string
+}
+
+export interface StartTaskResponse {
+  status: string
+  message: string
+  data: {
+    task: ProjectTask
+  }
+}
+
+export interface UpdateTaskRequest {
+  task_id: string
+  status?: string
+  ai_result?: string
+  title?: string
+  description?: string
+}
+
+export interface UpdateTaskResponse {
+  status: string
+  message: string
+  data: {
+    task: ProjectTask
+  }
+}

package/services/usage/index.ts

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

package/services/usage/usage-service.ts

@@ -0,0 +1,96 @@
+import { BaseService } from '../base/base-service'
+import {
+  TrackUsageRequest,
+  TrackUsageResponse,
+  CreditBalanceResponse,
+  CreditCheckRequest,
+  CreditCheckResponse,
+  UsageSummaryRequest,
+  UsageSummaryResponse,
+  AuthorizationResponse,
+  FreeUserStatusResponse,
+  CalculateUsageRequest,
+  CalculateUsageResponse,
+  TrackCodespaceUsageRequest,
+  TrackCodespaceUsageResponse,
+  CodespaceTaskUsageResponse,
+  HealthResponse,
+} from './usage-types'
+
+export class UsageService extends BaseService {
+  async trackUsage(request: TrackUsageRequest): Promise<TrackUsageResponse> {
+    return this.post<TrackUsageResponse>('/usage/track', request)
+  }
+
+  async getCreditBalance(): Promise<CreditBalanceResponse> {
+    return this.get<CreditBalanceResponse>('/usage/credit-balance')
+  }
+
+  async checkCredits(params: CreditCheckRequest): Promise<CreditCheckResponse> {
+    const queryParams = new URLSearchParams()
+
+    if (params.input_tokens !== undefined)
+      queryParams.append('input_tokens', params.input_tokens.toString())
+    if (params.output_tokens !== undefined)
+      queryParams.append('output_tokens', params.output_tokens.toString())
+    if (params.call_seconds !== undefined)
+      queryParams.append('call_seconds', params.call_seconds.toString())
+
+    const url = `/usage/credit-check?${queryParams.toString()}`
+    return this.get<CreditCheckResponse>(url)
+  }
+
+  async getUsageSummary(params?: UsageSummaryRequest): Promise<UsageSummaryResponse> {
+    const queryParams = new URLSearchParams()
+
+    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/summary${queryParams.toString() ? `?${queryParams.toString()}` : ''}`
+    return this.get<UsageSummaryResponse>(url)
+  }
+
+  async getAuthorization(): Promise<AuthorizationResponse> {
+    return this.get<AuthorizationResponse>('/usage/authorization')
+  }
+
+  async getFreeUserStatus(): Promise<FreeUserStatusResponse> {
+    return this.get<FreeUserStatusResponse>('/usage/free-user-status')
+  }
+
+  async calculateUsageCost(params: CalculateUsageRequest): Promise<CalculateUsageResponse> {
+    const queryParams = new URLSearchParams()
+
+    queryParams.append('model_key', params.model_key)
+    if (params.input_tokens !== undefined)
+      queryParams.append('input_tokens', params.input_tokens.toString())
+    if (params.output_tokens !== undefined)
+      queryParams.append('output_tokens', params.output_tokens.toString())
+    if (params.call_seconds !== undefined)
+      queryParams.append('call_seconds', params.call_seconds.toString())
+    if (params.cost_amount !== undefined)
+      queryParams.append('cost_amount', params.cost_amount.toString())
+
+    const url = `/usage/calculate?${queryParams.toString()}`
+    return this.get<CalculateUsageResponse>(url)
+  }
+
+  async trackCodespaceUsage(
+    request: TrackCodespaceUsageRequest
+  ): Promise<TrackCodespaceUsageResponse> {
+    return this.post<TrackCodespaceUsageResponse>('/usage/codespace/track', request)
+  }
+
+  async getCodespaceTaskUsage(codespaceTaskId: string): Promise<CodespaceTaskUsageResponse> {
+    return this.get<CodespaceTaskUsageResponse>(`/usage/codespace/task/${codespaceTaskId}`)
+  }
+
+  async healthCheck(): Promise<boolean> {
+    try {
+      const response = await this.get<HealthResponse>('/usage/health')
+      return response.status === 'healthy'
+    } catch {
+      return false
+    }
+  }
+}

package/services/usage/usage-types.ts

@@ -0,0 +1,147 @@
+export interface TrackUsageRequest {
+  model_key: string
+  input_tokens: number
+  output_tokens: number
+  call_seconds?: number
+  cost_amount?: number
+}
+
+export interface TrackUsageResponse {
+  success: boolean
+  credits_used: number
+  remaining_credits: number
+  message: string
+}
+
+export interface CreditBalanceResponse {
+  user_id: string
+  total_consumed: number
+  total_allotted: number
+  remaining_credits: number
+  utilization_percentage: number
+  billing_cycle_start: string
+  billing_cycle_end: string
+  subscription: {
+    plan: string
+    status: string
+  }
+}
+
+export interface CreditCheckRequest {
+  model_key: string
+  input_tokens?: number
+  output_tokens?: number
+  call_seconds?: number
+}
+
+export interface CreditCheckResponse {
+  has_sufficient_credits: boolean
+  estimated_cost: number
+  remaining_credits: number
+  model_key: string
+}
+
+export interface UsageSummaryRequest {
+  start_date?: string
+  end_date?: string
+}
+
+export interface UsageSummaryResponse {
+  user_id: string
+  period: {
+    start_date: string
+    end_date: string
+  }
+  usage_summary: {
+    total_credits_used: number
+    total_calls: number
+    model_breakdown: Record<string, any>
+    daily_usage: Array<{
+      date: string
+      credits_used: number
+      calls: number
+    }>
+  }
+  subscription: {
+    plan: string
+    status: string
+  }
+}
+
+export interface AuthorizationResponse {
+  user_id: string
+  subscription: {
+    plan: string
+    status: string
+    features: string[]
+  }
+  usage_limits: {
+    monthly_credits: number
+    max_calls_per_day: number
+  }
+  permissions: string[]
+}
+
+export interface FreeUserStatusResponse {
+  is_free_user: boolean
+  has_available_credits: boolean
+  credits_remaining: number
+  credits_expire_at?: string
+}
+
+export interface CalculateUsageRequest {
+  model_key: string
+  input_tokens?: number
+  output_tokens?: number
+  call_seconds?: number
+  cost_amount?: number
+}
+
+export interface CalculateUsageResponse {
+  model_key: string
+  estimated_cost: number
+  calculation_breakdown: {
+    input_cost: number
+    output_cost: number
+    time_cost: number
+    total_cost: number
+  }
+}
+
+export interface TrackCodespaceUsageRequest {
+  codespace_task_id: string
+  model_key: string
+  input_tokens: number
+  output_tokens: number
+  call_seconds?: number
+  cost_amount?: number
+}
+
+export interface TrackCodespaceUsageResponse {
+  id: string
+  codespace_task_id: string
+  user_id: string
+  model_key: string
+  input_tokens: number
+  output_tokens: number
+  call_seconds: number
+  cost_amount: number
+  created_at: string
+}
+
+export interface CodespaceTaskUsageResponse {
+  codespace_task_id: string
+  total_usage: {
+    total_input_tokens: number
+    total_output_tokens: number
+    total_call_seconds: number
+    total_cost: number
+  }
+  usage_records: TrackCodespaceUsageResponse[]
+}
+
+export interface HealthResponse {
+  status: string
+  timestamp: string
+  version: string
+}

package/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./",
+    "composite": true
+  },
+  "include": ["**/*"],
+  "exclude": ["node_modules", "dist", "**/*.test.ts"]
+}

package/types.ts

@@ -0,0 +1,51 @@
+export interface CodeGuideRequest {
+  prompt: string
+  language?: string
+  context?: string
+}
+
+export interface CodeGuideResponse {
+  id?: string
+  response?: string
+  refined_prompt?: string
+  content?: string
+  timestamp: string
+  language?: string
+}
+
+export interface APIServiceConfig {
+  baseUrl: string
+  // Database API Key (highest priority) - format: sk_...
+  databaseApiKey?: string
+  // Legacy API Key (medium priority)
+  apiKey?: string
+  // Legacy User ID (for legacy auth)
+  userId?: string
+  // Clerk JWT Token (lowest priority)
+  jwtToken?: string
+  timeout?: number
+}
+
+export interface AuthenticationMethod {
+  type: 'database-api-key' | 'legacy-api-key' | 'clerk-jwt'
+  priority: number
+  headers: Record<string, string>
+}
+
+export interface AuthenticationResult {
+  success: boolean
+  method?: AuthenticationMethod
+  user?: {
+    id: string
+    email?: string
+    subscriptionStatus?: string
+    creditsRemaining?: number
+  }
+  error?: string
+}
+
+export interface CodeGuideOptions {
+  language?: string
+  context?: string
+  verbose?: boolean
+}