@posthog/agent 1.0.2 → 1.2.0

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,7 +2,7 @@ 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 } 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';
@@ -14,8 +14,14 @@ export class StageExecutor {
   private logger: Logger;
   private eventTransformer: EventTransformer;
   private promptBuilder: PromptBuilder;
-
-  constructor(registry: AgentRegistry, logger: Logger, promptBuilder?: PromptBuilder) {
+  private eventHandler?: (event: AgentEvent) => void;
+
+  constructor(
+    registry: AgentRegistry,
+    logger: Logger,
+    promptBuilder?: PromptBuilder,
+    eventHandler?: (event: AgentEvent) => void,
+  ) {
     this.registry = registry;
     this.logger = logger.child('StageExecutor');
     this.eventTransformer = new EventTransformer();
@@ -24,6 +30,11 @@ export class StageExecutor {
       generatePlanTemplate: async () => '',
       logger,
     });
+    this.eventHandler = eventHandler;
+  }
+
+  setEventHandler(handler?: (event: AgentEvent) => void): void {
+    this.eventHandler = handler;
   }
 
   async execute(task: Task, stage: WorkflowStage, options: WorkflowExecutionOptions): Promise<WorkflowStageExecutionResult> {
@@ -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) {
@@ -125,12 +139,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 };
   }
 }
-

package/src/task-progress-reporter.ts

@@ -0,0 +1,287 @@
+import type { Logger } from './utils/logger.js';
+import type { PostHogAPIClient, TaskProgressRecord, TaskProgressUpdate } from './posthog-api.js';
+import type { AgentEvent } from './types.js';
+
+interface ProgressMetadata {
+  workflowId?: string;
+  workflowRunId?: string;
+  activityId?: string;
+  totalSteps?: number;
+}
+
+/**
+ * Persists task execution progress to PostHog so clients can poll for updates.
+ *
+ * The reporter is intentionally best-effort – failures are logged but never
+ * allowed to break the agent execution flow.
+ */
+export class TaskProgressReporter {
+  private posthogAPI?: PostHogAPIClient;
+  private logger: Logger;
+  private progressRecord?: TaskProgressRecord;
+  private taskId?: string;
+  private outputLog: string[] = [];
+  private totalSteps?: number;
+  private lastLogEntry?: string;
+
+  constructor(posthogAPI: PostHogAPIClient | undefined, logger: Logger) {
+    this.posthogAPI = posthogAPI;
+    this.logger = logger.child('TaskProgressReporter');
+  }
+
+  get progressId(): string | undefined {
+    return this.progressRecord?.id;
+  }
+
+  async start(taskId: string, metadata: ProgressMetadata = {}): Promise<void> {
+    if (!this.posthogAPI) {
+      return;
+    }
+
+    this.taskId = taskId;
+    this.totalSteps = metadata.totalSteps;
+
+    try {
+      const record = await this.posthogAPI.createTaskProgress(taskId, {
+        status: 'started',
+        current_step: 'initializing',
+        total_steps: metadata.totalSteps ?? 0,
+        completed_steps: 0,
+        workflow_id: metadata.workflowId,
+        workflow_run_id: metadata.workflowRunId,
+        activity_id: metadata.activityId,
+        output_log: '',
+      });
+      this.progressRecord = record;
+      this.outputLog = record.output_log ? record.output_log.split('\n') : [];
+      this.logger.debug('Created task progress record', { taskId, progressId: record.id });
+    } catch (error) {
+      this.logger.warn('Failed to create task progress record', { taskId, error: (error as Error).message });
+    }
+  }
+
+  async stageStarted(stageKey: string, stageIndex: number): Promise<void> {
+    await this.update({
+      status: 'in_progress',
+      current_step: stageKey,
+      completed_steps: Math.min(stageIndex, this.totalSteps ?? stageIndex),
+    }, `Stage started: ${stageKey}`);
+  }
+
+  async stageCompleted(stageKey: string, completedStages: number): Promise<void> {
+    await this.update({
+      status: 'in_progress',
+      current_step: stageKey,
+      completed_steps: Math.min(completedStages, this.totalSteps ?? completedStages),
+    }, `Stage completed: ${stageKey}`);
+  }
+
+  async branchCreated(stageKey: string, branchName: string): Promise<void> {
+    await this.appendLog(`Branch created (${stageKey}): ${branchName}`);
+  }
+
+  async commitMade(stageKey: string, kind: 'plan' | 'implementation'): Promise<void> {
+    await this.appendLog(`Commit made (${stageKey}, ${kind})`);
+  }
+
+  async pullRequestCreated(stageKey: string, prUrl: string): Promise<void> {
+    await this.appendLog(`Pull request created (${stageKey}): ${prUrl}`);
+  }
+
+  async noNextStage(stageKey?: string): Promise<void> {
+    await this.appendLog(
+      stageKey
+        ? `No next stage available after '${stageKey}'. Execution halted.`
+        : 'No next stage available. Execution halted.'
+    );
+  }
+
+  async complete(): Promise<void> {
+    await this.update({ status: 'completed', completed_steps: this.totalSteps }, 'Workflow execution completed');
+  }
+
+  async fail(error: Error | string): Promise<void> {
+    const message = typeof error === 'string' ? error : error.message;
+    await this.update({ status: 'failed', error_message: message }, `Workflow execution failed: ${message}`);
+  }
+
+  async appendLog(line: string): Promise<void> {
+    await this.update({}, line);
+  }
+
+  async recordEvent(event: AgentEvent): Promise<void> {
+    if (!this.posthogAPI || !this.progressId || !this.taskId) {
+      return;
+    }
+
+    switch (event.type) {
+      case 'token':
+      case 'message_delta':
+      case 'content_block_start':
+      case 'content_block_stop':
+      case 'compact_boundary':
+      case 'tool_call':
+      case 'tool_result':
+      case 'message_start':
+      case 'message_stop':
+      case 'metric':
+      case 'artifact':
+        // Skip verbose streaming artifacts from persistence
+        return;
+
+      case 'file_write':
+        await this.appendLog(this.formatFileWriteEvent(event));
+        return;
+
+      case 'diff':
+        await this.appendLog(this.formatDiffEvent(event));
+        return;
+
+      case 'status':
+        // Status events are covered by dedicated progress updates
+        return;
+
+      case 'error':
+        await this.appendLog(`[error] ${event.message}`);
+        return;
+
+      case 'done': {
+        const cost = event.totalCostUsd !== undefined ? ` cost=$${event.totalCostUsd.toFixed(2)}` : '';
+        await this.appendLog(
+          `[done] duration=${event.durationMs ?? 'unknown'}ms turns=${event.numTurns ?? 'unknown'}${cost}`
+        );
+        return;
+      }
+
+      case 'init':
+        // Omit verbose init messages from persisted log
+        return;
+
+      case 'user_message': {
+        const summary = this.summarizeUserMessage(event.content);
+        if (summary) {
+          await this.appendLog(summary);
+        }
+        return;
+      }
+
+      default:
+        // For any unfamiliar event types, avoid spamming the log.
+        return;
+    }
+  }
+
+  private async update(update: TaskProgressUpdate, logLine?: string): Promise<void> {
+    if (!this.posthogAPI || !this.progressId || !this.taskId) {
+      return;
+    }
+
+    if (logLine) {
+      if (logLine !== this.lastLogEntry) {
+        this.outputLog.push(logLine);
+        this.lastLogEntry = logLine;
+      }
+      update.output_log = this.outputLog.join('\n');
+    }
+
+    try {
+      const record = await this.posthogAPI.updateTaskProgress(this.taskId, this.progressId, update);
+      // Sync local cache with server response to avoid drift if server modifies values
+      this.progressRecord = record;
+      if (record.output_log !== undefined && record.output_log !== null) {
+        this.outputLog = record.output_log ? record.output_log.split('\n') : [];
+      }
+    } catch (error) {
+      this.logger.warn('Failed to update task progress record', {
+        taskId: this.taskId,
+        progressId: this.progressId,
+        error: (error as Error).message,
+      });
+    }
+  }
+
+  private summarizeUserMessage(content?: string): string | null {
+    if (!content) {
+      return null;
+    }
+    const trimmed = content.trim();
+    if (!trimmed) {
+      return null;
+    }
+
+    const fileUpdateMatch = trimmed.match(/The file\s+([^\s]+)\s+has been updated/i);
+    if (fileUpdateMatch) {
+      return `[user] file updated: ${fileUpdateMatch[1]}`;
+    }
+
+    if (/Todos have been modified/i.test(trimmed)) {
+      return '[todo] list updated';
+    }
+
+    const diffMatch = trimmed.match(/diff --git a\/([^\s]+) b\/([^\s]+)/);
+    if (diffMatch) {
+      return `[diff] ${diffMatch[2] ?? diffMatch[1]}`;
+    }
+
+    const gitStatusMatch = trimmed.match(/^On branch ([^\n]+)/);
+    if (gitStatusMatch) {
+      return `[git] status ${gitStatusMatch[1]}`;
+    }
+
+    if (/This Bash command contains multiple operations/i.test(trimmed)) {
+      return '[approval] multi-step command pending';
+    }
+
+    if (/This command requires approval/i.test(trimmed)) {
+      return '[approval] command awaiting approval';
+    }
+
+    if (/^Exit plan mode\?/i.test(trimmed)) {
+      return null;
+    }
+
+    if (trimmed.includes('node_modules')) {
+      return null;
+    }
+
+    if (trimmed.includes('total ') && trimmed.includes('drwx')) {
+      return null;
+    }
+
+    if (trimmed.includes('→')) {
+      return null;
+    }
+
+    if (trimmed.split('\n').length > 2) {
+      return null;
+    }
+
+    const normalized = trimmed.replace(/\s+/g, ' ');
+    const maxLen = 120;
+    if (!normalized) {
+      return null;
+    }
+    const preview = normalized.length > maxLen ? `${normalized.slice(0, maxLen)}…` : normalized;
+    return `[user] ${preview}`;
+  }
+
+  private formatFileWriteEvent(event: Extract<AgentEvent, { type: 'file_write' }>): string {
+    const size = event.bytes !== undefined ? ` (${event.bytes} bytes)` : '';
+    return `[file] wrote ${event.path}${size}`;
+  }
+
+  private formatDiffEvent(event: Extract<AgentEvent, { type: 'diff' }>): string {
+    const summary = event.summary
+      ? event.summary.trim()
+      : this.truncateMultiline(event.patch ?? '', 160);
+    return `[diff] ${event.file}${summary ? ` | ${summary}` : ''}`;
+  }
+
+  private truncateMultiline(text: string, max = 160): string {
+    if (!text) {
+      return '';
+    }
+    const compact = text.replace(/\s+/g, ' ').trim();
+    return compact.length > max ? `${compact.slice(0, max)}…` : compact;
+  }
+}

package/src/template-manager.ts

@@ -1,4 +1,4 @@
-import { promises as fs } from 'fs';
+import { promises as fs, existsSync } from 'fs';
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
 
@@ -17,7 +17,15 @@ export class TemplateManager {
   constructor() {
     const __filename = fileURLToPath(import.meta.url);
     const __dirname = dirname(__filename);
-    this.templatesDir = join(__dirname, 'templates');
+    const candidateDirs = [
+      join(__dirname, 'templates'),
+      join(__dirname, '..', 'templates'),
+      join(__dirname, '..', '..', 'templates'),
+      join(__dirname, '..', '..', 'src', 'templates')
+    ];
+
+    const resolvedDir = candidateDirs.find((dir) => existsSync(dir));
+    this.templatesDir = resolvedDir ?? candidateDirs[0];
   }
 
   private async loadTemplate(templateName: string): Promise<string> {
@@ -146,4 +154,4 @@ Customize \`.posthog/.gitignore\` to control which files are committed:
 *Generated by PostHog Agent*
 `;
   }
-}
+}

package/dist/example.js

@@ -1,49 +0,0 @@
-#!/usr/bin/env bun
-import { config } from "dotenv";
-config();
-import { Agent, PermissionMode } from './src/agent.js';
-async function testAgent() {
-    const REPO_PATH = process.argv[2] || process.cwd();
-    const TASK_ID = process.argv[3];
-    if (!process.env.POSTHOG_API_KEY) {
-        console.error("❌ POSTHOG_API_KEY required");
-        process.exit(1);
-    }
-    console.log(`📁 Working in: ${REPO_PATH}`);
-    const agent = new Agent({
-        workingDirectory: REPO_PATH,
-        posthogApiUrl: process.env.POSTHOG_API_URL || "http://localhost:8010",
-        posthogApiKey: process.env.POSTHOG_API_KEY,
-        onEvent: (event) => {
-            console.log(`[${event.type}]`, event);
-        },
-        debug: true,
-    });
-    if (TASK_ID) {
-        console.log(`🎯 Running task: ${TASK_ID}`);
-        try {
-            // Example: list and run a workflow
-            await agent['workflowRegistry'].loadWorkflows();
-            const workflows = agent['workflowRegistry'].listWorkflows();
-            if (workflows.length === 0) {
-                throw new Error('No workflows available');
-            }
-            const selectedWorkflow = workflows[0];
-            const options = {
-                repositoryPath: REPO_PATH,
-                permissionMode: PermissionMode.ACCEPT_EDITS,
-                autoProgress: true,
-            };
-            const result = await agent.runWorkflow(TASK_ID, selectedWorkflow.id, options);
-            console.log("✅ Done!");
-            console.log(`📁 Plan stored in: .posthog/${TASK_ID}/plan.md`);
-        }
-        finally {
-        }
-    }
-    else {
-        console.log("❌ Please provide a task ID");
-    }
-}
-testAgent().catch(console.error);
-//# sourceMappingURL=example.js.map

package/dist/example.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"example.js","sourceRoot":"","sources":["../example.ts"],"names":[],"mappings":";AAEA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAChC,MAAM,EAAE,CAAC;AAET,OAAO,EAAE,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAGvD,KAAK,UAAU,SAAS;IACpB,MAAM,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,OAAO,CAAC,GAAG,EAAE,CAAC;IACnD,MAAM,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAEhC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,eAAe,EAAE,CAAC;QAC/B,OAAO,CAAC,KAAK,CAAC,4BAA4B,CAAC,CAAC;QAC5C,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IACpB,CAAC;IAED,OAAO,CAAC,GAAG,CAAC,kBAAkB,SAAS,EAAE,CAAC,CAAC;IAE3C,MAAM,KAAK,GAAG,IAAI,KAAK,CAAC;QACpB,gBAAgB,EAAE,SAAS;QAC3B,aAAa,EAAE,OAAO,CAAC,GAAG,CAAC,eAAe,IAAI,uBAAuB;QACrE,aAAa,EAAE,OAAO,CAAC,GAAG,CAAC,eAAe;QAC1C,OAAO,EAAE,CAAC,KAAK,EAAE,EAAE;YACf,OAAO,CAAC,GAAG,CAAC,IAAI,KAAK,CAAC,IAAI,GAAG,EAAE,KAAK,CAAC,CAAC;QAC1C,CAAC;QACD,KAAK,EAAE,IAAI;KACd,CAAC,CAAC;IAEH,IAAI,OAAO,EAAE,CAAC;QACV,OAAO,CAAC,GAAG,CAAC,oBAAoB,OAAO,EAAE,CAAC,CAAC;QAC3C,IAAI,CAAC;YACD,mCAAmC;YACnC,MAAM,KAAK,CAAC,kBAAkB,CAAC,CAAC,aAAa,EAAE,CAAC;YAChD,MAAM,SAAS,GAAG,KAAK,CAAC,kBAAkB,CAAC,CAAC,aAAa,EAAE,CAAC;YAC5D,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;gBACzB,MAAM,IAAI,KAAK,CAAC,wBAAwB,CAAC,CAAC;YAC9C,CAAC;YACD,MAAM,gBAAgB,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC;YACtC,MAAM,OAAO,GAA6B;gBACtC,cAAc,EAAE,SAAS;gBACzB,cAAc,EAAE,cAAc,CAAC,YAAY;gBAC3C,YAAY,EAAE,IAAI;aACrB,CAAC;YACF,MAAM,MAAM,GAAG,MAAM,KAAK,CAAC,WAAW,CAAC,OAAO,EAAE,gBAAgB,CAAC,EAAE,EAAE,OAAO,CAAC,CAAC;YAC9E,OAAO,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;YACvB,OAAO,CAAC,GAAG,CAAC,+BAA+B,OAAO,UAAU,CAAC,CAAC;QAClE,CAAC;gBAAS,CAAC;QACX,CAAC;IACL,CAAC;SAAM,CAAC;QACJ,OAAO,CAAC,GAAG,CAAC,4BAA4B,CAAC,CAAC;IAC9C,CAAC;AACL,CAAC;AAED,SAAS,EAAE,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC"}

package/dist/src/workflow-types.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=workflow-types.js.map

package/dist/src/workflow-types.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"workflow-types.js","sourceRoot":"","sources":["../../src/workflow-types.ts"],"names":[],"mappings":""}