@posthog/agent 1.22.0 → 1.24.0

package/src/posthog-api.ts

@@ -1,15 +1,13 @@
 import type {
-  Task,
-  TaskRun,
   LogEntry,
-  SupportingFile,
   PostHogAPIConfig,
   PostHogResource,
-  ResourceType,
-  UrlMention,
-  TaskRunArtifact,
+  Task,
   TaskArtifactUploadPayload,
-} from './types.js';
+  TaskRun,
+  TaskRunArtifact,
+  UrlMention,
+} from "./types.js";
 
 interface PostHogApiResponse<T> {
   results?: T[];
@@ -29,32 +27,31 @@ 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: {
@@ -106,7 +103,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,16 +111,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),
     });
   }
@@ -132,59 +129,86 @@ 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 [];
@@ -194,9 +218,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 ?? [];
@@ -214,13 +238,15 @@ 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 [];
       }
@@ -228,30 +254,37 @@ 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) : 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<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,
@@ -271,9 +304,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 +315,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}`);
     }
@@ -309,36 +345,40 @@ 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");
   }
 }