@posthog/agent 1.1.0 → 1.3.0

package/src/agent.ts

@@ -14,6 +14,7 @@ import { AgentRegistry } from './agent-registry.js';
 import { WorkflowRegistry } from './workflow-registry.js';
 import { StageExecutor } from './stage-executor.js';
 import { PromptBuilder } from './prompt-builder.js';
+import { TaskProgressReporter } from './task-progress-reporter.js';
 
 export class Agent {
     private workingDirectory: string;
@@ -28,12 +29,39 @@ export class Agent {
     private agentRegistry: AgentRegistry;
     private workflowRegistry: WorkflowRegistry;
     private stageExecutor: StageExecutor;
+    private progressReporter: TaskProgressReporter;
+    private mcpServers?: Record<string, any>;
     public debug: boolean;
 
     constructor(config: AgentConfig = {}) {
         this.workingDirectory = config.workingDirectory || process.cwd();
         this.onEvent = config.onEvent;
         this.debug = config.debug || false;
+
+        // Build default PostHog MCP server configuration
+        const posthogMcpUrl = config.posthogMcpUrl
+            || process.env.POSTHOG_MCP_URL
+            || 'https://mcp.posthog.com/mcp';
+
+        // Add auth if API key provided
+        const headers: Record<string, string> = {};
+        if (config.posthogApiKey) {
+            headers['Authorization'] = `Bearer ${config.posthogApiKey}`;
+        }
+
+        const defaultMcpServers = {
+            posthog: {
+                type: 'http' as const,
+                url: posthogMcpUrl,
+                ...(Object.keys(headers).length > 0 ? { headers } : {}),
+            }
+        };
+
+        // Merge default PostHog MCP with user-provided servers (user config takes precedence)
+        this.mcpServers = {
+            ...defaultMcpServers,
+            ...config.mcpServers
+        };
         this.logger = new Logger({ debug: this.debug, prefix: '[PostHog Agent]' });
         this.taskManager = new TaskManager();
         this.eventTransformer = new EventTransformer();
@@ -63,7 +91,15 @@ export class Agent {
             generatePlanTemplate: (vars) => this.templateManager.generatePlan(vars),
             logger: this.logger.child('PromptBuilder')
         });
-        this.stageExecutor = new StageExecutor(this.agentRegistry, this.logger, promptBuilder);
+        this.stageExecutor = new StageExecutor(
+            this.agentRegistry,
+            this.logger,
+            promptBuilder,
+            undefined, // eventHandler set via setEventHandler below
+            this.mcpServers
+        );
+        this.stageExecutor.setEventHandler((event) => this.emitEvent(event));
+        this.progressReporter = new TaskProgressReporter(this.posthogAPI, this.logger);
     }
 
     /**
@@ -82,6 +118,7 @@ export class Agent {
         if (!workflow) {
             throw new Error(`Workflow ${workflowId} not found`);
         }
+        const orderedStages = [...workflow.stages].sort((a, b) => a.position - b.position);
 
         // Ensure task is assigned to workflow and positioned at first stage
         if (this.posthogAPI) {
@@ -103,9 +140,13 @@ export class Agent {
         const executionId = this.taskManager.generateExecutionId();
         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,
+        });
 
         try {
-            const orderedStages = [...workflow.stages].sort((a, b) => a.position - b.position);
             let startIndex = 0;
             const currentStageId = (task as any).current_stage as string | undefined;
 
@@ -114,7 +155,10 @@ export class Agent {
                 const currIdx = orderedStages.findIndex(s => s.id === currentStageId);
                 const atLastStage = currIdx >= 0 && currIdx === orderedStages.length - 1;
                 if (atLastStage) {
-                    this.emitEvent(this.eventTransformer.createStatusEvent('no_next_stage', { stage: orderedStages[currIdx].key }));
+                    const finalStageKey = orderedStages[currIdx]?.key;
+                    this.emitEvent(this.eventTransformer.createStatusEvent('no_next_stage', { stage: finalStageKey }));
+                    await this.progressReporter.noNextStage(finalStageKey);
+                    await this.progressReporter.complete();
                     this.taskManager.completeExecution(executionId, { task, workflow });
                     return { task, workflow };
                 }
@@ -135,7 +179,9 @@ export class Agent {
 
             for (let i = startIndex; i < orderedStages.length; i++) {
                 const stage = orderedStages[i];
+                await this.progressReporter.stageStarted(stage.key, i);
                 await this.executeStage(task, stage, options);
+                await this.progressReporter.stageCompleted(stage.key, i + 1);
                 if (options.autoProgress) {
                     const hasNext = i < orderedStages.length - 1;
                     if (hasNext) {
@@ -143,9 +189,11 @@ export class Agent {
                     }
                 }
             }
+            await this.progressReporter.complete();
             this.taskManager.completeExecution(executionId, { task, workflow });
             return { task, workflow };
         } catch (error) {
+            await this.progressReporter.fail(error as Error);
             this.taskManager.failExecution(executionId, error as Error);
             throw error;
         }
@@ -167,10 +215,12 @@ export class Agent {
             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 }));
+            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 }));
+            await this.progressReporter.branchCreated(stage.key, implBranch);
         }
 
         const result = await this.stageExecutor.execute(task, stage, options);
@@ -179,6 +229,7 @@ export class Agent {
             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' }));
+            await this.progressReporter.commitMade(stage.key, 'plan');
         }
 
         if (isManual) {
@@ -193,12 +244,14 @@ export class Agent {
                     await this.updateTaskBranch(task.id, implBranch);
                     branchName = implBranch;
                     this.emitEvent(this.eventTransformer.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);
+                    await this.attachPullRequestToTask(task.id, prUrl, branchName);
                     this.emitEvent(this.eventTransformer.createStatusEvent('pr_created', { stage: stage.key, prUrl }));
+                    await this.progressReporter.pullRequestCreated(stage.key, prUrl);
                 } catch {}
             }
             // Do not auto-progress on manual stages
@@ -211,6 +264,7 @@ export class Agent {
             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' }));
+            await this.progressReporter.commitMade(stage.key, 'implementation');
         }
 
         // PR creation on complete stage (or if explicitly requested), regardless of whether edits occurred
@@ -222,8 +276,9 @@ export class Agent {
                 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);
+                    await this.attachPullRequestToTask(task.id, prUrl, branchName);
                     this.emitEvent(this.eventTransformer.createStatusEvent('pr_created', { stage: stage.key, prUrl }));
+                    await this.progressReporter.pullRequestCreated(stage.key, prUrl);
                 } catch {}
             }
         }
@@ -239,10 +294,11 @@ export class Agent {
     // Direct prompt execution - still supported for low-level usage
     async run(prompt: string, options: { repositoryPath?: string; permissionMode?: import('./types.js').PermissionMode; queryOverrides?: Record<string, any> } = {}): Promise<ExecutionResult> {
         const baseOptions: Record<string, any> = {
-            model: "claude-4-5-sonnet",
+            model: "claude-sonnet-4-5-20250929",
             cwd: options.repositoryPath || this.workingDirectory,
             permissionMode: (options.permissionMode as any) || "default",
             settingSources: ["local"],
+            mcpServers: this.mcpServers,
         };
 
         const response = query({
@@ -252,7 +308,7 @@ export class Agent {
 
         const results = [];
         for await (const message of response) {
-            this.logger.debug('Received message in direct run', { type: message.type });
+            this.logger.debug('Received message in direct run', message);
             const transformedEvent = this.eventTransformer.transform(message);
             this.onEvent?.(transformedEvent);
             results.push(message);
@@ -271,6 +327,10 @@ export class Agent {
         }
         return this.posthogAPI.fetchTask(taskId);
     }
+
+    getPostHogClient(): PostHogAPIClient | undefined {
+        return this.posthogAPI;
+    }
     
     async listTasks(filters?: {
         repository?: string;
@@ -367,8 +427,8 @@ Generated by PostHog Agent`;
         return prUrl;
     }
 
-    async attachPullRequestToTask(taskId: string, prUrl: string): Promise<void> {
-        this.logger.info('Attaching PR to task', { taskId, prUrl });
+    async attachPullRequestToTask(taskId: string, prUrl: string, branchName?: string): Promise<void> {
+        this.logger.info('Attaching PR to task', { taskId, prUrl, branchName });
 
         if (!this.posthogAPI) {
             const error = new Error('PostHog API not configured. Cannot attach PR to task.');
@@ -376,7 +436,7 @@ Generated by PostHog Agent`;
             throw error;
         }
 
-        await this.posthogAPI.updateTask(taskId, { github_pr_url: prUrl });
+        await this.posthogAPI.attachTaskPullRequest(taskId, prUrl, branchName);
         this.logger.debug('PR attached to task', { taskId, prUrl });
     }
 
@@ -389,7 +449,7 @@ Generated by PostHog Agent`;
             throw error;
         }
 
-        await this.posthogAPI.updateTask(taskId, { github_branch: branchName });
+        await this.posthogAPI.setTaskBranch(taskId, branchName);
         this.logger.debug('Task branch updated', { taskId, branchName });
     }
 
@@ -419,6 +479,12 @@ Generated by PostHog Agent`;
             // Log all events except tokens (too verbose)
             this.logger.debug('Emitting event', { type: event.type, ts: event.ts });
         }
+        const persistPromise = this.progressReporter.recordEvent(event);
+        if (persistPromise && typeof persistPromise.then === 'function') {
+            persistPromise.catch((error: Error) =>
+                this.logger.debug('Failed to persist agent event', { message: error.message })
+            );
+        }
         this.onEvent?.(event);
     }
 }

package/src/event-transformer.ts

@@ -118,15 +118,14 @@ export class EventTransformer {
 
     // Handle user messages
     if (sdkMessage.type === 'user') {
-      const content = sdkMessage.message.content;
-      const textContent = Array.isArray(content)
-        ? content.find(c => c.type === 'text')?.text
-        : typeof content === 'string' ? content : '';
-
+      const textContent = this.extractUserContent(sdkMessage.message?.content);
+      if (!textContent) {
+        return null;
+      }
       return {
         ...baseEvent,
         type: 'user_message',
-        content: textContent || '',
+        content: textContent,
         isSynthetic: sdkMessage.isSynthetic
       };
     }
@@ -186,4 +185,59 @@ export class EventTransformer {
       ...additionalData
     };
   }
-}
+
+  private extractUserContent(content: unknown): string | null {
+    if (!content) {
+      return null;
+    }
+
+    if (typeof content === 'string') {
+      const trimmed = content.trim();
+      return trimmed.length > 0 ? trimmed : null;
+    }
+
+    if (Array.isArray(content)) {
+      const parts: string[] = [];
+      for (const block of content) {
+        const extracted = this.extractUserContent(block);
+        if (extracted) {
+          parts.push(extracted);
+        } else if (block && typeof block === 'object') {
+          const candidate = this.extractFromObject(block as Record<string, unknown>);
+          if (candidate) {
+            parts.push(candidate);
+          }
+        }
+      }
+      const text = parts.join('\n').trim();
+      return text.length > 0 ? text : null;
+    }
+
+    if (typeof content === 'object') {
+      return this.extractFromObject(content as Record<string, unknown>);
+    }
+
+    return null;
+  }
+
+  private extractFromObject(value: Record<string, unknown>): string | null {
+    const preferredKeys = ['text', 'input_text', 'input', 'markdown', 'content', 'message'];
+    for (const key of preferredKeys) {
+      if (typeof value[key] === 'string') {
+        const trimmed = (value[key] as string).trim();
+        if (trimmed.length > 0) {
+          return trimmed;
+        }
+      }
+    }
+
+    for (const entry of Object.values(value)) {
+      const extracted = this.extractUserContent(entry);
+      if (extracted) {
+        return extracted;
+      }
+    }
+
+    return null;
+  }
+}

package/src/posthog-api.ts

@@ -26,6 +26,36 @@ interface TaskProgressResponse {
   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;
+  error_message?: string | null;
+  workflow_id?: string | null;
+  workflow_run_id?: string | null;
+  activity_id?: string | null;
+}
+
 export class PostHogAPIClient {
   private config: PostHogAPIConfig;
   private _teamId: number | null = null;
@@ -137,11 +167,60 @@ export class PostHogAPIClient {
     });
   }
 
+  async setTaskBranch(taskId: string, branch: string): Promise<Task> {
+    const teamId = await this.getTeamId();
+    return this.apiRequest<Task>(`/api/projects/${teamId}/tasks/${taskId}/set_branch/`, {
+      method: "POST",
+      body: JSON.stringify({ branch }),
+    });
+  }
+
+  async attachTaskPullRequest(taskId: string, prUrl: string, branch?: string): Promise<Task> {
+    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",
+      body: JSON.stringify(payload),
+    });
+  }
+
   async getTaskProgress(taskId: string): Promise<TaskProgressResponse> {
     const teamId = await this.getTeamId();
     return this.apiRequest<TaskProgressResponse>(`/api/projects/${teamId}/tasks/${taskId}/progress/`);
   }
 
+  async createTaskProgress(
+    taskId: string,
+    payload: TaskProgressUpdate & { status: TaskProgressRecord["status"] }
+  ): Promise<TaskProgressRecord> {
+    const teamId = await this.getTeamId();
+    return this.apiRequest<TaskProgressRecord>(`/api/projects/${teamId}/task_progress/`, {
+      method: "POST",
+      body: JSON.stringify({
+        ...payload,
+        task: taskId,
+      }),
+    });
+  }
+
+  async updateTaskProgress(
+    taskId: string,
+    progressId: string,
+    payload: TaskProgressUpdate
+  ): Promise<TaskProgressRecord> {
+    const teamId = await this.getTeamId();
+    return this.apiRequest<TaskProgressRecord>(`/api/projects/${teamId}/task_progress/${progressId}/`, {
+      method: "PATCH",
+      body: JSON.stringify({
+        ...payload,
+        task: taskId,
+      }),
+    });
+  }
+
   // Workflow endpoints
   async fetchWorkflow(workflowId: string): Promise<WorkflowDefinition> {
     const teamId = await this.getTeamId();

package/src/stage-executor.ts

@@ -2,20 +2,27 @@ import { query } from '@anthropic-ai/claude-agent-sdk';
 import { Logger } from './utils/logger.js';
 import { EventTransformer } from './event-transformer.js';
 import { AgentRegistry } from './agent-registry.js';
-import type { Task } from './types.js';
+import type { AgentEvent, Task, McpServerConfig } from './types.js';
 import type { WorkflowStage, WorkflowStageExecutionResult, WorkflowExecutionOptions } from './workflow-types.js';
 import { PLANNING_SYSTEM_PROMPT } from './agents/planning.js';
 import { EXECUTION_SYSTEM_PROMPT } from './agents/execution.js';
 import { PromptBuilder } from './prompt-builder.js';
-import { POSTHOG_MCP } from './utils/mcp.js';
 
 export class StageExecutor {
   private registry: AgentRegistry;
   private logger: Logger;
   private eventTransformer: EventTransformer;
   private promptBuilder: PromptBuilder;
-
-  constructor(registry: AgentRegistry, logger: Logger, promptBuilder?: PromptBuilder) {
+  private eventHandler?: (event: AgentEvent) => void;
+  private mcpServers?: Record<string, McpServerConfig>;
+
+  constructor(
+    registry: AgentRegistry,
+    logger: Logger,
+    promptBuilder?: PromptBuilder,
+    eventHandler?: (event: AgentEvent) => void,
+    mcpServers?: Record<string, McpServerConfig>,
+  ) {
     this.registry = registry;
     this.logger = logger.child('StageExecutor');
     this.eventTransformer = new EventTransformer();
@@ -24,6 +31,12 @@ export class StageExecutor {
       generatePlanTemplate: async () => '',
       logger,
     });
+    this.eventHandler = eventHandler;
+    this.mcpServers = mcpServers;
+  }
+
+  setEventHandler(handler?: (event: AgentEvent) => void): void {
+    this.eventHandler = handler;
   }
 
   async execute(task: Task, stage: WorkflowStage, options: WorkflowExecutionOptions): Promise<WorkflowStageExecutionResult> {
@@ -72,9 +85,7 @@ export class StageExecutor {
       cwd,
       permissionMode: 'plan',
       settingSources: ['local'],
-      mcpServers: {
-        ...POSTHOG_MCP
-      }
+      mcpServers: this.mcpServers
     };
 
     const response = query({
@@ -85,8 +96,11 @@ export class StageExecutor {
     let plan = '';
     for await (const message of response) {
       const transformed = this.eventTransformer.transform(message);
-      if (transformed && transformed.type !== 'token') {
-        this.logger.debug('Planning event', { type: transformed.type });
+      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) {
@@ -113,9 +127,7 @@ export class StageExecutor {
       cwd,
       permissionMode,
       settingSources: ['local'],
-      mcpServers: {
-        ...POSTHOG_MCP
-      }
+      mcpServers: this.mcpServers
     };
 
     const response = query({
@@ -125,12 +137,14 @@ export class StageExecutor {
     const results: any[] = [];
     for await (const message of response) {
       const transformed = this.eventTransformer.transform(message);
-      if (transformed && transformed.type !== 'token') {
-        this.logger.debug('Execution event', { type: transformed.type });
+      if (transformed) {
+        if (transformed.type !== 'token') {
+          this.logger.debug('Execution event', { type: transformed.type });
+        }
+        this.eventHandler?.(transformed);
       }
       results.push(message);
     }
     return { results };
   }
 }
-