@posthog/agent 1.24.2 → 1.25.0

package/src/posthog-api.ts

@@ -1,15 +1,13 @@
 import type {
-  Task,
-  TaskRun,
-  LogEntry,
-  SupportingFile,
   PostHogAPIConfig,
   PostHogResource,
-  ResourceType,
-  UrlMention,
-  TaskRunArtifact,
+  StoredEntry,
+  Task,
   TaskArtifactUploadPayload,
-} from './types.js';
+  TaskRun,
+  TaskRunArtifact,
+  UrlMention,
+} from "./types.js";
 
 interface PostHogApiResponse<T> {
   results?: T[];
@@ -18,43 +16,43 @@ interface PostHogApiResponse<T> {
   previous?: string | null;
 }
 
-export interface TaskRunUpdate {
-  status?: TaskRun["status"];
-  branch?: string | null;
-  current_stage?: string | null;
-  error_message?: string | null;
-  output?: Record<string, unknown> | null;
-  state?: Record<string, unknown>;
-}
+export type TaskRunUpdate = Partial<
+  Pick<
+    TaskRun,
+    "status" | "branch" | "stage" | "error_message" | "output" | "state"
+  >
+>;
+
+export type TaskCreatePayload = Pick<Task, "description"> &
+  Partial<Pick<Task, "title" | "repository" | "origin_product">>;
 
 export class PostHogAPIClient {
   private config: PostHogAPIConfig;
-  private _teamId: number | null = null;
 
   constructor(config: PostHogAPIConfig) {
     this.config = config;
   }
 
   private get baseUrl(): string {
-    const host = this.config.apiUrl.endsWith("/") 
-      ? this.config.apiUrl.slice(0, -1) 
+    const host = this.config.apiUrl.endsWith("/")
+      ? this.config.apiUrl.slice(0, -1)
       : this.config.apiUrl;
     return host;
   }
 
   private get headers(): Record<string, string> {
     return {
-      'Authorization': `Bearer ${this.config.apiKey}`,
-      'Content-Type': 'application/json',
+      Authorization: `Bearer ${this.config.apiKey}`,
+      "Content-Type": "application/json",
     };
   }
 
   private async apiRequest<T>(
-    endpoint: string, 
-    options: RequestInit = {}
+    endpoint: string,
+    options: RequestInit = {},
   ): Promise<T> {
     const url = `${this.baseUrl}${endpoint}`;
-    
+
     const response = await fetch(url, {
       ...options,
       headers: {
@@ -106,7 +104,7 @@ export class PostHogAPIClient {
   }): Promise<Task[]> {
     const teamId = this.getTeamId();
     const url = new URL(`${this.baseUrl}/api/projects/${teamId}/tasks/`);
-    
+
     if (filters) {
       Object.entries(filters).forEach(([key, value]) => {
         if (value) url.searchParams.append(key, value);
@@ -114,77 +112,121 @@ export class PostHogAPIClient {
     }
 
     const response = await this.apiRequest<PostHogApiResponse<Task>>(
-      url.pathname + url.search
+      url.pathname + url.search,
     );
-    
+
     return response.results || [];
   }
 
   async updateTask(taskId: string, updates: Partial<Task>): Promise<Task> {
     const teamId = this.getTeamId();
     return this.apiRequest<Task>(`/api/projects/${teamId}/tasks/${taskId}/`, {
-      method: 'PATCH',
+      method: "PATCH",
       body: JSON.stringify(updates),
     });
   }
 
+  async createTask(payload: TaskCreatePayload): Promise<Task> {
+    const teamId = this.getTeamId();
+    return this.apiRequest<Task>(`/api/projects/${teamId}/tasks/`, {
+      method: "POST",
+      body: JSON.stringify({
+        origin_product: "user_created",
+        ...payload,
+      }),
+    });
+  }
+
   // TaskRun methods
   async listTaskRuns(taskId: string): Promise<TaskRun[]> {
     const teamId = this.getTeamId();
     const response = await this.apiRequest<PostHogApiResponse<TaskRun>>(
-      `/api/projects/${teamId}/tasks/${taskId}/runs/`
+      `/api/projects/${teamId}/tasks/${taskId}/runs/`,
     );
     return response.results || [];
   }
 
   async getTaskRun(taskId: string, runId: string): Promise<TaskRun> {
     const teamId = this.getTeamId();
-    return this.apiRequest<TaskRun>(`/api/projects/${teamId}/tasks/${taskId}/runs/${runId}/`);
+    return this.apiRequest<TaskRun>(
+      `/api/projects/${teamId}/tasks/${taskId}/runs/${runId}/`,
+    );
   }
 
   async createTaskRun(
     taskId: string,
-    payload?: Partial<Omit<TaskRun, 'id' | 'task' | 'team' | 'created_at' | 'updated_at' | 'completed_at'>>
+    payload?: Partial<
+      Omit<
+        TaskRun,
+        | "id"
+        | "task"
+        | "team"
+        | "created_at"
+        | "updated_at"
+        | "completed_at"
+        | "artifacts"
+      >
+    >,
   ): Promise<TaskRun> {
     const teamId = this.getTeamId();
-    return this.apiRequest<TaskRun>(`/api/projects/${teamId}/tasks/${taskId}/runs/`, {
-      method: "POST",
-      body: JSON.stringify(payload || {}),
-    });
+    return this.apiRequest<TaskRun>(
+      `/api/projects/${teamId}/tasks/${taskId}/runs/`,
+      {
+        method: "POST",
+        body: JSON.stringify(payload || {}),
+      },
+    );
   }
 
   async updateTaskRun(
     taskId: string,
     runId: string,
-    payload: TaskRunUpdate
+    payload: TaskRunUpdate,
   ): Promise<TaskRun> {
     const teamId = this.getTeamId();
-    return this.apiRequest<TaskRun>(`/api/projects/${teamId}/tasks/${taskId}/runs/${runId}/`, {
-      method: "PATCH",
-      body: JSON.stringify(payload),
-    });
+    return this.apiRequest<TaskRun>(
+      `/api/projects/${teamId}/tasks/${taskId}/runs/${runId}/`,
+      {
+        method: "PATCH",
+        body: JSON.stringify(payload),
+      },
+    );
   }
 
-  async setTaskRunOutput(taskId: string, runId: string, output: Record<string, unknown>): Promise<TaskRun> {
+  async setTaskRunOutput(
+    taskId: string,
+    runId: string,
+    output: Record<string, unknown>,
+  ): Promise<TaskRun> {
     const teamId = this.getTeamId();
-    return this.apiRequest<TaskRun>(`/api/projects/${teamId}/tasks/${taskId}/runs/${runId}/set_output/`, {
-      method: 'PATCH',
-      body: JSON.stringify({ output }),
-    });
+    return this.apiRequest<TaskRun>(
+      `/api/projects/${teamId}/tasks/${taskId}/runs/${runId}/set_output/`,
+      {
+        method: "PATCH",
+        body: JSON.stringify({ output }),
+      },
+    );
   }
 
-  async appendTaskRunLog(taskId: string, runId: string, entries: LogEntry[]): Promise<TaskRun> {
+  async appendTaskRunLog(
+    taskId: string,
+    runId: string,
+    entries: StoredEntry[],
+  ): Promise<TaskRun> {
     const teamId = this.getTeamId();
-    return this.apiRequest<TaskRun>(`/api/projects/${teamId}/tasks/${taskId}/runs/${runId}/append_log/`, {
-      method: 'POST',
-      body: JSON.stringify({ entries }),
-    });
+    return this.apiRequest<TaskRun>(
+      `/api/projects/${teamId}/tasks/${taskId}/runs/${runId}/append_log/`,
+      {
+        method: "POST",
+        body: JSON.stringify({ entries }),
+      },
+    );
   }
 
   async uploadTaskArtifacts(
     taskId: string,
     runId: string,
-    artifacts: TaskArtifactUploadPayload[]
+    artifacts: TaskArtifactUploadPayload[],
   ): Promise<TaskRunArtifact[]> {
     if (!artifacts.length) {
       return [];
@@ -194,9 +236,9 @@ export class PostHogAPIClient {
     const response = await this.apiRequest<{ artifacts: TaskRunArtifact[] }>(
       `/api/projects/${teamId}/tasks/${taskId}/runs/${runId}/artifacts/`,
       {
-        method: 'POST',
+        method: "POST",
         body: JSON.stringify({ artifacts }),
-      }
+      },
     );
 
     return response.artifacts ?? [];
@@ -205,22 +247,24 @@ export class PostHogAPIClient {
   /**
    * Fetch logs from S3 using presigned URL from TaskRun
    * @param taskRun - The task run containing the log_url
-   * @returns Array of log entries, or empty array if no logs available
+   * @returns Array of stored entries, or empty array if no logs available
    */
-  async fetchTaskRunLogs(taskRun: TaskRun): Promise<LogEntry[]> {
+  async fetchTaskRunLogs(taskRun: TaskRun): Promise<StoredEntry[]> {
     if (!taskRun.log_url) {
       return [];
     }
 
     try {
       const response = await fetch(taskRun.log_url);
-      
+
       if (!response.ok) {
-        throw new Error(`Failed to fetch logs: ${response.status} ${response.statusText}`);
+        throw new Error(
+          `Failed to fetch logs: ${response.status} ${response.statusText}`,
+        );
       }
 
       const content = await response.text();
-      
+
       if (!content.trim()) {
         return [];
       }
@@ -228,30 +272,40 @@ export class PostHogAPIClient {
       // Parse newline-delimited JSON
       return content
         .trim()
-        .split('\n')
-        .map(line => JSON.parse(line) as LogEntry);
+        .split("\n")
+        .map((line) => JSON.parse(line) as StoredEntry);
     } catch (error) {
-      throw new Error(`Failed to fetch task run logs: ${error instanceof Error ? error.message : String(error)}`);
+      throw new Error(
+        `Failed to fetch task run logs: ${error instanceof Error ? error.message : String(error)}`,
+      );
     }
   }
 
   /**
    * Fetch error details from PostHog error tracking
    */
-  async fetchErrorDetails(errorId: string, projectId?: string): Promise<PostHogResource> {
-    const teamId = projectId ? parseInt(projectId) : this.getTeamId();
-    
+  async fetchErrorDetails(
+    errorId: string,
+    projectId?: string,
+  ): Promise<PostHogResource> {
+    const teamId = projectId ? parseInt(projectId, 10) : this.getTeamId();
+
     try {
-      const errorData = await this.apiRequest<any>(`/api/projects/${teamId}/error_tracking/${errorId}/`);
-      
+      const errorData = await this.apiRequest<Record<string, unknown>>(
+        `/api/projects/${teamId}/error_tracking/${errorId}/`,
+      );
+
       // Format error details for agent consumption
       const content = this.formatErrorContent(errorData);
-      
+
       return {
-        type: 'error',
+        type: "error",
         id: errorId,
         url: `${this.baseUrl}/project/${teamId}/error_tracking/${errorId}`,
-        title: errorData.exception_type || 'Unknown Error',
+        title:
+          (typeof errorData.exception_type === "string"
+            ? errorData.exception_type
+            : undefined) || "Unknown Error",
         content,
         metadata: {
           exception_type: errorData.exception_type,
@@ -271,9 +325,9 @@ export class PostHogAPIClient {
    */
   async fetchResourceByUrl(urlMention: UrlMention): Promise<PostHogResource> {
     switch (urlMention.type) {
-      case 'error':
+      case "error": {
         if (!urlMention.id) {
-          throw new Error('Error ID is required for error resources');
+          throw new Error("Error ID is required for error resources");
         }
         // Extract project ID from URL if available, otherwise use default team
         let projectId: string | undefined;
@@ -282,23 +336,26 @@ export class PostHogAPIClient {
           projectId = projectIdMatch ? projectIdMatch[1] : undefined;
         }
         return this.fetchErrorDetails(urlMention.id, projectId);
-      
-      case 'experiment':
-      case 'insight':
-      case 'feature_flag':
-        throw new Error(`Resource type '${urlMention.type}' not yet implemented`);
-      
-      case 'generic':
+      }
+
+      case "experiment":
+      case "insight":
+      case "feature_flag":
+        throw new Error(
+          `Resource type '${urlMention.type}' not yet implemented`,
+        );
+
+      case "generic":
         // Return a minimal resource for generic URLs
         return {
-          type: 'generic',
-          id: '',
+          type: "generic",
+          id: "",
           url: urlMention.url,
-          title: 'Generic Resource',
+          title: "Generic Resource",
           content: `Generic resource: ${urlMention.url}`,
           metadata: {},
         };
-      
+
       default:
         throw new Error(`Unknown resource type: ${urlMention.type}`);
     }
@@ -307,38 +364,42 @@ export class PostHogAPIClient {
   /**
    * Format error data for agent consumption
    */
-  private formatErrorContent(errorData: any): string {
+  private formatErrorContent(errorData: Record<string, unknown>): string {
     const sections = [];
-    
+
     if (errorData.exception_type) {
       sections.push(`**Error Type**: ${errorData.exception_type}`);
     }
-    
+
     if (errorData.exception_message) {
       sections.push(`**Message**: ${errorData.exception_message}`);
     }
-    
+
     if (errorData.stack_trace) {
-      sections.push(`**Stack Trace**:\n\`\`\`\n${errorData.stack_trace}\n\`\`\``);
+      sections.push(
+        `**Stack Trace**:\n\`\`\`\n${errorData.stack_trace}\n\`\`\``,
+      );
     }
-    
+
     if (errorData.volume) {
       sections.push(`**Volume**: ${errorData.volume} occurrences`);
     }
-    
+
     if (errorData.users_affected) {
       sections.push(`**Users Affected**: ${errorData.users_affected}`);
     }
-    
+
     if (errorData.first_seen && errorData.last_seen) {
       sections.push(`**First Seen**: ${errorData.first_seen}`);
       sections.push(`**Last Seen**: ${errorData.last_seen}`);
     }
-    
+
     if (errorData.properties && Object.keys(errorData.properties).length > 0) {
-      sections.push(`**Properties**: ${JSON.stringify(errorData.properties, null, 2)}`);
+      sections.push(
+        `**Properties**: ${JSON.stringify(errorData.properties, null, 2)}`,
+      );
     }
-    
-    return sections.join('\n\n');
+
+    return sections.join("\n\n");
   }
 }