@posthog/agent 1.7.1 → 1.10.0

package/src/agent.ts

@@ -6,7 +6,8 @@ import { PostHogAPIClient } from './posthog-api.js';
 import { PostHogFileManager } from './file-manager.js';
 import { GitManager } from './git-manager.js';
 import { TemplateManager } from './template-manager.js';
-import { EventTransformer } from './event-transformer.js';
+import { ClaudeAdapter } from './adapters/claude/claude-adapter.js';
+import type { ProviderAdapter } from './adapters/types.js';
 import { PLANNING_SYSTEM_PROMPT } from './agents/planning.js';
 import { EXECUTION_SYSTEM_PROMPT } from './agents/execution.js';
 import { Logger } from './utils/logger.js';
@@ -24,7 +25,7 @@ export class Agent {
     private fileManager: PostHogFileManager;
     private gitManager: GitManager;
     private templateManager: TemplateManager;
-    private eventTransformer: EventTransformer;
+    private adapter: ProviderAdapter;
     private logger: Logger;
     private agentRegistry: AgentRegistry;
     private workflowRegistry: WorkflowRegistry;
@@ -64,7 +65,8 @@ export class Agent {
         };
         this.logger = new Logger({ debug: this.debug, prefix: '[PostHog Agent]' });
         this.taskManager = new TaskManager();
-        this.eventTransformer = new EventTransformer();
+        // Hardcode Claude adapter for now - extensible for other providers later
+        this.adapter = new ClaudeAdapter();
 
         this.fileManager = new PostHogFileManager(
             this.workingDirectory,
@@ -156,13 +158,8 @@ export class Agent {
                     await this.posthogAPI.updateTask(task.id, { workflow: workflowId } as any);
                     (task as any).workflow = workflowId;
                 }
-                if (!(task as any).current_stage && workflow.stages.length > 0) {
-                    const firstStage = [...workflow.stages].sort((a, b) => a.position - b.position)[0];
-                    await this.posthogAPI.updateTaskStage(task.id, firstStage.id);
-                    (task as any).current_stage = firstStage.id;
-                }
             } catch (e) {
-                this.logger.warn('Failed to sync task workflow/stage before execution', { error: (e as Error).message });
+                this.logger.warn('Failed to sync task workflow before execution', { error: (e as Error).message });
             }
         }
 
@@ -170,11 +167,21 @@ export class Agent {
         this.logger.info('Starting workflow execution', { taskId: task.id, workflowId, executionId });
         this.taskManager.startExecution(task.id, 'plan_and_build', executionId);
         await this.progressReporter.start(task.id, {
-            workflowId,
-            workflowRunId: executionId,
             totalSteps: orderedStages.length,
         });
 
+        // Set initial stage on the newly created run
+        const firstStage = orderedStages[0];
+        if (this.posthogAPI && this.progressReporter.runId && firstStage) {
+            try {
+                await this.posthogAPI.updateTaskRun(task.id, this.progressReporter.runId, {
+                    current_stage: firstStage.id
+                });
+            } catch (e) {
+                this.logger.warn('Failed to set initial stage on run', { error: (e as Error).message });
+            }
+        }
+
         try {
             let startIndex = 0;
             const currentStageId = (task as any).current_stage as string | undefined;
@@ -185,7 +192,7 @@ export class Agent {
                 const atLastStage = currIdx >= 0 && currIdx === orderedStages.length - 1;
                 if (atLastStage) {
                     const finalStageKey = orderedStages[currIdx]?.key;
-                    this.emitEvent(this.eventTransformer.createStatusEvent('no_next_stage', { stage: finalStageKey }));
+                    this.emitEvent(this.adapter.createStatusEvent('no_next_stage', { stage: finalStageKey }));
                     await this.progressReporter.noNextStage(finalStageKey);
                     await this.progressReporter.complete();
                     this.taskManager.completeExecution(executionId, { task, workflow });
@@ -198,11 +205,17 @@ export class Agent {
                 if (idx >= 0) startIndex = idx;
             }
 
-            // Align server-side stage when restarting from the beginning
-            if (this.posthogAPI) {
+            // Align server-side stage when restarting from a different stage
+            if (this.posthogAPI && this.progressReporter.runId) {
                 const targetStage = orderedStages[startIndex];
                 if (targetStage && targetStage.id !== currentStageId) {
-                    try { await this.posthogAPI.updateTaskStage(task.id, targetStage.id); (task as any).current_stage = targetStage.id; } catch {}
+                    try {
+                        await this.posthogAPI.updateTaskRun(task.id, this.progressReporter.runId, {
+                            current_stage: targetStage.id
+                        });
+                    } catch (e) {
+                        this.logger.warn('Failed to update run stage', { error: (e as Error).message });
+                    }
                 }
             }
 
@@ -229,7 +242,7 @@ export class Agent {
     }
 
     async executeStage(task: Task, stage: WorkflowStage, options: WorkflowExecutionOptions = {}): Promise<void> {
-        this.emitEvent(this.eventTransformer.createStatusEvent('stage_start', { stage: stage.key }));
+        this.emitEvent(this.adapter.createStatusEvent('stage_start', { stage: stage.key }));
         const overrides = options.stageOverrides?.[stage.key];
         const agentName = stage.agent_name || 'code_generation';
         const agentDef = this.agentRegistry.getAgent(agentName);
@@ -243,12 +256,12 @@ export class Agent {
         if (isPlanning && shouldCreatePlanningBranch) {
             const planningBranch = await this.createPlanningBranch(task.id);
             await this.updateTaskBranch(task.id, planningBranch);
-            this.emitEvent(this.eventTransformer.createStatusEvent('branch_created', { stage: stage.key, branch: planningBranch }));
+            this.emitEvent(this.adapter.createStatusEvent('branch_created', { stage: stage.key, branch: planningBranch }));
             await this.progressReporter.branchCreated(stage.key, planningBranch);
         } else if (!isPlanning && !isManual && shouldCreateImplBranch) {
             const implBranch = await this.createImplementationBranch(task.id);
             await this.updateTaskBranch(task.id, implBranch);
-            this.emitEvent(this.eventTransformer.createStatusEvent('branch_created', { stage: stage.key, branch: implBranch }));
+            this.emitEvent(this.adapter.createStatusEvent('branch_created', { stage: stage.key, branch: implBranch }));
             await this.progressReporter.branchCreated(stage.key, implBranch);
         }
 
@@ -257,7 +270,7 @@ export class Agent {
         if (result.plan) {
             await this.writePlan(task.id, result.plan);
             await this.commitPlan(task.id, task.title);
-            this.emitEvent(this.eventTransformer.createStatusEvent('commit_made', { stage: stage.key, kind: 'plan' }));
+            this.emitEvent(this.adapter.createStatusEvent('commit_made', { stage: stage.key, kind: 'plan' }));
             await this.progressReporter.commitMade(stage.key, 'plan');
         }
 
@@ -272,19 +285,19 @@ export class Agent {
                     const implBranch = await this.createImplementationBranch(task.id);
                     await this.updateTaskBranch(task.id, implBranch);
                     branchName = implBranch;
-                    this.emitEvent(this.eventTransformer.createStatusEvent('branch_created', { stage: stage.key, branch: implBranch }));
+                    this.emitEvent(this.adapter.createStatusEvent('branch_created', { stage: stage.key, branch: implBranch }));
                     await this.progressReporter.branchCreated(stage.key, implBranch);
                 }
                 try {
                     const prUrl = await this.createPullRequest(task.id, branchName, task.title, task.description);
                     await this.updateTaskBranch(task.id, branchName);
                     await this.attachPullRequestToTask(task.id, prUrl, branchName);
-                    this.emitEvent(this.eventTransformer.createStatusEvent('pr_created', { stage: stage.key, prUrl }));
+                    this.emitEvent(this.adapter.createStatusEvent('pr_created', { stage: stage.key, prUrl }));
                     await this.progressReporter.pullRequestCreated(stage.key, prUrl);
                 } catch {}
             }
             // Do not auto-progress on manual stages
-            this.emitEvent(this.eventTransformer.createStatusEvent('stage_complete', { stage: stage.key }));
+            this.emitEvent(this.adapter.createStatusEvent('stage_complete', { stage: stage.key }));
             return;
         }
 
@@ -292,7 +305,7 @@ export class Agent {
             const existingPlan = await this.readPlan(task.id);
             const planSummary = existingPlan ? existingPlan.split('\n')[0] : undefined;
             await this.commitImplementation(task.id, task.title, planSummary);
-            this.emitEvent(this.eventTransformer.createStatusEvent('commit_made', { stage: stage.key, kind: 'implementation' }));
+            this.emitEvent(this.adapter.createStatusEvent('commit_made', { stage: stage.key, kind: 'implementation' }));
             await this.progressReporter.commitMade(stage.key, 'implementation');
         }
 
@@ -306,27 +319,30 @@ export class Agent {
                     const prUrl = await this.createPullRequest(task.id, branchName, task.title, task.description);
                     await this.updateTaskBranch(task.id, branchName);
                     await this.attachPullRequestToTask(task.id, prUrl, branchName);
-                    this.emitEvent(this.eventTransformer.createStatusEvent('pr_created', { stage: stage.key, prUrl }));
+                    this.emitEvent(this.adapter.createStatusEvent('pr_created', { stage: stage.key, prUrl }));
                     await this.progressReporter.pullRequestCreated(stage.key, prUrl);
                 } catch {}
             }
         }
 
-        this.emitEvent(this.eventTransformer.createStatusEvent('stage_complete', { stage: stage.key }));
+        this.emitEvent(this.adapter.createStatusEvent('stage_complete', { stage: stage.key }));
     }
 
     async progressToNextStage(taskId: string, currentStageKey?: string): Promise<void> {
-        if (!this.posthogAPI) throw new Error('PostHog API not configured. Cannot progress stage.');
+        if (!this.posthogAPI || !this.progressReporter.runId) {
+            throw new Error('PostHog API not configured or no active run. Cannot progress stage.');
+        }
         try {
-            await this.posthogAPI.progressTask(taskId, { auto: true });
+            await this.posthogAPI.progressTaskRun(taskId, this.progressReporter.runId);
         } catch (error) {
             if (error instanceof Error && error.message.includes('No next stage available')) {
-                this.logger.warn('No next stage available when attempting to progress task', {
+                this.logger.warn('No next stage available when attempting to progress run', {
                     taskId,
+                    runId: this.progressReporter.runId,
                     stage: currentStageKey,
                     error: error.message,
                 });
-                this.emitEvent(this.eventTransformer.createStatusEvent('no_next_stage', { stage: currentStageKey }));
+                this.emitEvent(this.adapter.createStatusEvent('no_next_stage', { stage: currentStageKey }));
                 await this.progressReporter.noNextStage(currentStageKey);
                 return;
             }
@@ -354,9 +370,9 @@ export class Agent {
         for await (const message of response) {
             this.logger.debug('Received message in direct run', message);
             // Emit raw SDK event
-            this.emitEvent(this.eventTransformer.createRawSDKEvent(message));
+            this.emitEvent(this.adapter.createRawSDKEvent(message));
             // Emit transformed event
-            const transformedEvent = this.eventTransformer.transform(message);
+            const transformedEvent = this.adapter.transform(message);
             if (transformedEvent) {
                 this.emitEvent(transformedEvent);
             }
@@ -477,29 +493,36 @@ Generated by PostHog Agent`;
     }
 
     async attachPullRequestToTask(taskId: string, prUrl: string, branchName?: string): Promise<void> {
-        this.logger.info('Attaching PR to task', { taskId, prUrl, branchName });
+        this.logger.info('Attaching PR to task run', { taskId, prUrl, branchName });
 
-        if (!this.posthogAPI) {
-            const error = new Error('PostHog API not configured. Cannot attach PR to task.');
+        if (!this.posthogAPI || !this.progressReporter.runId) {
+            const error = new Error('PostHog API not configured or no active run. Cannot attach PR to task.');
             this.logger.error('PostHog API not configured', error);
             throw error;
         }
 
-        await this.posthogAPI.attachTaskPullRequest(taskId, prUrl, branchName);
-        this.logger.debug('PR attached to task', { taskId, prUrl });
+        const updates: any = {
+            output: { pr_url: prUrl }
+        };
+        if (branchName) {
+            updates.branch = branchName;
+        }
+
+        await this.posthogAPI.updateTaskRun(taskId, this.progressReporter.runId, updates);
+        this.logger.debug('PR attached to task run', { taskId, runId: this.progressReporter.runId, prUrl });
     }
 
     async updateTaskBranch(taskId: string, branchName: string): Promise<void> {
-        this.logger.info('Updating task branch', { taskId, branchName });
+        this.logger.info('Updating task run branch', { taskId, branchName });
 
-        if (!this.posthogAPI) {
-            const error = new Error('PostHog API not configured. Cannot update task branch.');
+        if (!this.posthogAPI || !this.progressReporter.runId) {
+            const error = new Error('PostHog API not configured or no active run. Cannot update branch.');
             this.logger.error('PostHog API not configured', error);
             throw error;
         }
 
-        await this.posthogAPI.setTaskBranch(taskId, branchName);
-        this.logger.debug('Task branch updated', { taskId, branchName });
+        await this.posthogAPI.updateTaskRun(taskId, this.progressReporter.runId, { branch: branchName });
+        this.logger.debug('Task run branch updated', { taskId, runId: this.progressReporter.runId, branchName });
     }
 
     // Execution management

package/src/posthog-api.ts

@@ -1,4 +1,4 @@
-import type { Task, SupportingFile, PostHogAPIConfig, PostHogResource, ResourceType, UrlMention } from './types.js';
+import type { Task, TaskRun, LogEntry, SupportingFile, PostHogAPIConfig, PostHogResource, ResourceType, UrlMention } from './types.js';
 import type { WorkflowDefinition, AgentDefinition } from './workflow-types.js';
 
 interface PostHogApiResponse<T> {
@@ -8,52 +8,14 @@ interface PostHogApiResponse<T> {
   previous?: string | null;
 }
 
-interface TaskProgressResponse {
-  has_progress: boolean;
-  id?: string;
-  status?: "started" | "in_progress" | "completed" | "failed";
-  current_step?: string;
-  completed_steps?: number;
-  total_steps?: number;
-  progress_percentage?: number;
-  output_log?: string;
-  error_message?: string;
-  created_at?: string;
-  updated_at?: string;
-  completed_at?: string;
-  workflow_id?: string;
-  workflow_run_id?: string;
-  message?: string;
-}
-
-export interface TaskProgressRecord {
-  id: string;
-  task: string;
-  status: "started" | "in_progress" | "completed" | "failed";
-  current_step?: string | null;
-  completed_steps?: number | null;
-  total_steps?: number | null;
-  progress_percentage?: number | null;
-  output_log?: string | null;
-  error_message?: string | null;
-  workflow_id?: string | null;
-  workflow_run_id?: string | null;
-  activity_id?: string | null;
-  created_at: string;
-  updated_at: string;
-  completed_at?: string | null;
-}
-
-export interface TaskProgressUpdate {
-  status?: TaskProgressRecord["status"];
-  current_step?: string | null;
-  completed_steps?: number | null;
-  total_steps?: number | null;
-  output_log?: string | null;
+export interface TaskRunUpdate {
+  status?: TaskRun["status"];
+  branch?: string | null;
+  current_stage?: string | null;
+  log?: LogEntry[];
   error_message?: string | null;
-  workflow_id?: string | null;
-  workflow_run_id?: string | null;
-  activity_id?: string | null;
+  output?: Record<string, unknown> | null;
+  state?: Record<string, unknown>;
 }
 
 export class PostHogAPIClient {
@@ -172,65 +134,76 @@ export class PostHogAPIClient {
     });
   }
 
-  async updateTaskStage(taskId: string, stageId: string): Promise<Task> {
+  // TaskRun methods
+  async listTaskRuns(taskId: string): Promise<TaskRun[]> {
     const teamId = await this.getTeamId();
-    return this.apiRequest<Task>(`/api/projects/${teamId}/tasks/${taskId}/update_stage/`, {
-      method: 'PATCH',
-      body: JSON.stringify({ current_stage: stageId }),
-    });
+    const response = await this.apiRequest<PostHogApiResponse<TaskRun>>(
+      `/api/projects/${teamId}/tasks/${taskId}/runs/`
+    );
+    return response.results || [];
   }
 
-  async setTaskBranch(taskId: string, branch: string): Promise<Task> {
+  async getTaskRun(taskId: string, runId: string): Promise<TaskRun> {
     const teamId = await this.getTeamId();
-    return this.apiRequest<Task>(`/api/projects/${teamId}/tasks/${taskId}/set_branch/`, {
+    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'>>
+  ): Promise<TaskRun> {
+    const teamId = await this.getTeamId();
+    return this.apiRequest<TaskRun>(`/api/projects/${teamId}/tasks/${taskId}/runs/`, {
       method: "POST",
-      body: JSON.stringify({ branch }),
+      body: JSON.stringify(payload || {}),
     });
   }
 
-  async attachTaskPullRequest(taskId: string, prUrl: string, branch?: string): Promise<Task> {
+  async updateTaskRun(
+    taskId: string,
+    runId: string,
+    payload: TaskRunUpdate
+  ): Promise<TaskRun> {
     const teamId = await this.getTeamId();
-    const payload: Record<string, string> = { pr_url: prUrl };
-    if (branch) {
-      payload.branch = branch;
-    }
-    return this.apiRequest<Task>(`/api/projects/${teamId}/tasks/${taskId}/attach_pr/`, {
-      method: "POST",
+    return this.apiRequest<TaskRun>(`/api/projects/${teamId}/tasks/${taskId}/runs/${runId}/`, {
+      method: "PATCH",
       body: JSON.stringify(payload),
     });
   }
 
-  async getTaskProgress(taskId: string): Promise<TaskProgressResponse> {
+  async updateTaskRunStage(taskId: string, runId: string, stageId: string): Promise<TaskRun> {
     const teamId = await this.getTeamId();
-    return this.apiRequest<TaskProgressResponse>(`/api/projects/${teamId}/tasks/${taskId}/progress/`);
+    return this.apiRequest<TaskRun>(`/api/projects/${teamId}/tasks/${taskId}/runs/${runId}/update_stage/`, {
+      method: 'PATCH',
+      body: JSON.stringify({ current_stage: stageId }),
+    });
   }
 
-  async createTaskProgress(
-    taskId: string,
-    payload: TaskProgressUpdate & { status: TaskProgressRecord["status"] }
-  ): Promise<TaskProgressRecord> {
+  async progressTaskRun(taskId: string, runId: string, nextStageId?: string): Promise<TaskRun> {
     const teamId = await this.getTeamId();
-    return this.apiRequest<TaskProgressRecord>(`/api/projects/${teamId}/task_progress/`, {
-      method: "POST",
-      body: JSON.stringify({
-        ...payload,
-        task: taskId,
-      }),
+    const payload: Record<string, string> = {};
+    if (nextStageId) {
+      payload.next_stage_id = nextStageId;
+    }
+    return this.apiRequest<TaskRun>(`/api/projects/${teamId}/tasks/${taskId}/runs/${runId}/progress_run/`, {
+      method: 'POST',
+      body: JSON.stringify(payload),
     });
   }
 
-  async updateTaskProgress(
-    taskId: string,
-    progressId: string,
-    payload: TaskProgressUpdate
-  ): Promise<TaskProgressRecord> {
+  async setTaskRunOutput(taskId: string, runId: string, output: Record<string, unknown>): Promise<TaskRun> {
     const teamId = await this.getTeamId();
-    return this.apiRequest<TaskProgressRecord>(`/api/projects/${teamId}/task_progress/${progressId}/`, {
-      method: "PATCH",
-      body: JSON.stringify({
-        ...payload,
-        task: taskId,
-      }),
+    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> {
+    const teamId = await this.getTeamId();
+    return this.apiRequest<TaskRun>(`/api/projects/${teamId}/tasks/${taskId}/runs/${runId}/append_log/`, {
+      method: 'POST',
+      body: JSON.stringify({ entries }),
     });
   }
 
@@ -251,14 +224,6 @@ export class PostHogAPIClient {
     return this.apiRequest<AgentDefinition[]>(`/api/agents/`);
   }
 
-  async progressTask(taskId: string, options?: { next_stage_id?: string; auto?: boolean }): Promise<Task> {
-    const teamId = await this.getTeamId();
-    return this.apiRequest<Task>(`/api/projects/${teamId}/tasks/${taskId}/progress_task/`, {
-      method: 'POST',
-      body: JSON.stringify(options || {}),
-    });
-  }
-
   /**
    * Fetch error details from PostHog error tracking
    */

package/src/stage-executor.ts

@@ -1,6 +1,6 @@
 import { query } from '@anthropic-ai/claude-agent-sdk';
 import { Logger } from './utils/logger.js';
-import { EventTransformer } from './event-transformer.js';
+import { ClaudeAdapter } from './adapters/claude/claude-adapter.js';
 import { AgentRegistry } from './agent-registry.js';
 import type { AgentEvent, Task, McpServerConfig } from './types.js';
 import type { WorkflowStage, WorkflowStageExecutionResult, WorkflowExecutionOptions } from './workflow-types.js';
@@ -11,7 +11,7 @@ import { PromptBuilder } from './prompt-builder.js';
 export class StageExecutor {
   private registry: AgentRegistry;
   private logger: Logger;
-  private eventTransformer: EventTransformer;
+  private adapter: ClaudeAdapter;
   private promptBuilder: PromptBuilder;
   private eventHandler?: (event: AgentEvent) => void;
   private mcpServers?: Record<string, McpServerConfig>;
@@ -25,7 +25,7 @@ export class StageExecutor {
   ) {
     this.registry = registry;
     this.logger = logger.child('StageExecutor');
-    this.eventTransformer = new EventTransformer();
+    this.adapter = new ClaudeAdapter();
     this.promptBuilder = promptBuilder || new PromptBuilder({
       getTaskFiles: async () => [],
       generatePlanTemplate: async () => '',
@@ -96,17 +96,17 @@ export class StageExecutor {
     let plan = '';
     for await (const message of response) {
       // Emit raw SDK event first
-      this.eventHandler?.(this.eventTransformer.createRawSDKEvent(message));
-      
+      this.eventHandler?.(this.adapter.createRawSDKEvent(message));
+
       // Then emit transformed event
-      const transformed = this.eventTransformer.transform(message);
+      const transformed = this.adapter.transform(message);
       if (transformed) {
         if (transformed.type !== 'token') {
           this.logger.debug('Planning event', { type: transformed.type });
         }
         this.eventHandler?.(transformed);
       }
-      
+
       if (message.type === 'assistant' && message.message?.content) {
         for (const c of message.message.content) {
           if (c.type === 'text' && c.text) plan += c.text + '\n';
@@ -142,17 +142,17 @@ export class StageExecutor {
     const results: any[] = [];
     for await (const message of response) {
       // Emit raw SDK event first
-      this.eventHandler?.(this.eventTransformer.createRawSDKEvent(message));
-      
+      this.eventHandler?.(this.adapter.createRawSDKEvent(message));
+
       // Then emit transformed event
-      const transformed = this.eventTransformer.transform(message);
+      const transformed = this.adapter.transform(message);
       if (transformed) {
         if (transformed.type !== 'token') {
           this.logger.debug('Execution event', { type: transformed.type });
         }
         this.eventHandler?.(transformed);
       }
-      
+
       results.push(message);
     }
     return { results };