@posthog/agent 1.24.0 → 1.24.2

package/src/posthog-api.ts

@@ -1,13 +1,15 @@
 import type {
+  Task,
+  TaskRun,
   LogEntry,
+  SupportingFile,
   PostHogAPIConfig,
   PostHogResource,
-  Task,
-  TaskArtifactUploadPayload,
-  TaskRun,
-  TaskRunArtifact,
+  ResourceType,
   UrlMention,
-} from "./types.js";
+  TaskRunArtifact,
+  TaskArtifactUploadPayload,
+} from './types.js';
 
 interface PostHogApiResponse<T> {
   results?: T[];
@@ -27,31 +29,32 @@ export interface TaskRunUpdate {
 
 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: {
@@ -103,7 +106,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);
@@ -111,16 +114,16 @@ 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),
     });
   }
@@ -129,86 +132,59 @@ export class PostHogAPIClient {
   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'>>
   ): 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: LogEntry[]): 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 [];
@@ -218,9 +194,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 ?? [];
@@ -238,15 +214,13 @@ export class PostHogAPIClient {
 
     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 [];
       }
@@ -254,37 +228,30 @@ 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 LogEntry);
     } 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, 10) : this.getTeamId();
-
+  async fetchErrorDetails(errorId: string, projectId?: string): Promise<PostHogResource> {
+    const teamId = projectId ? parseInt(projectId) : this.getTeamId();
+    
     try {
-      const errorData = await this.apiRequest<any>(
-        `/api/projects/${teamId}/error_tracking/${errorId}/`,
-      );
-
+      const errorData = await this.apiRequest<any>(`/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: errorData.exception_type || 'Unknown Error',
         content,
         metadata: {
           exception_type: errorData.exception_type,
@@ -304,9 +271,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;
@@ -315,26 +282,23 @@ 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}`);
     }
@@ -345,40 +309,36 @@ export class PostHogAPIClient {
    */
   private formatErrorContent(errorData: any): 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');
   }
 }