@posthog/agent 1.11.0 → 1.13.0

package/src/agents/execution.ts

@@ -34,11 +34,11 @@ export const EXECUTION_SYSTEM_PROMPT = `<context>
   - Verified no build artifacts or dependencies are being committed
 </checklist>
 
-<workflow>
+<approach>
 - first make a plan and create a todo list
 - execute the todo list one by one
 - test the changes
-</workflow>
+</approach>
 
 <output_format>
   Once finished respond with a summary of changes made

package/src/agents/planning.ts

@@ -11,6 +11,7 @@ You are a specialized planning agent that analyzes codebases and creates detaile
 - **Read-Only Mode**: You can only read files, search code, and analyze the codebase
 - **No Modifications**: You cannot make any changes, edits, or execute commands
 - **Research Focus**: Your goal is understanding and planning, not implementation
+- **Response Format**: Respond only with the markdown content above, no other text or formatting, no acknowledgement, no explanation, no nothing.
 
 ## Available Tools
 
@@ -49,8 +50,6 @@ When given a task, follow this systematic approach:
 
 ## Plan Output
 
-When you have completed your analysis, use the \`exit_plan_mode\` tool to present your plan. Your plan should include:
-
 - **Summary**: Brief overview of the implementation approach
 - **Files to Create/Modify**: Specific paths and purposes
 - **Implementation Steps**: Ordered list of actions to take

package/src/agents/research.ts

@@ -18,7 +18,6 @@ You are a research agent that explores codebases to understand implementation co
 - Code search and analysis
 - Repository structure analysis
 - Documentation review
-- \`create_plan\` tool for creating your research artifact
 
 ## Research Process
 
@@ -46,8 +45,6 @@ When given a task, follow this systematic approach:
 
 ## Output Format
 
-After completing your research, you MUST use the \`create_plan\` tool to create a research.md artifact with your questions.
-
 The artifact MUST follow this EXACT markdown format (this is critical for parsing):
 
 \`\`\`markdown
@@ -88,16 +85,16 @@ Based on my analysis of the codebase, here are the key questions to guide implem
 
 ## Important Requirements
 
-- Generate 2-5 questions (no more, no less)
+- DO NOT GENERATE ANY QUESTIONS IF YOU DON'T HAVE ANY (instead say "No questions required")
+- Generate up to 5 questions (no more)
 - Make options specific and reference actual code/patterns you find
 - Each question must have at least 2 concrete options plus "Something else"
 - Focus on architectural and implementation approach decisions
 - Reference specific files, components, or patterns in your options
 - Make sure the questions help guide a clear implementation path
+- Respond only with the markdown content above, no other text or formatting, no acknowledgement, no explanation, no nothing.
 
 ## Final Step
 
-Once you have completed your research and identified the questions, use the \`create_plan\` tool to create the research.md artifact with the markdown content above. Do NOT use any other tools after creating the artifact.
-
 Your research should be thorough enough that the questions help clarify the user's preferences and guide the planning phase effectively.`;
 

package/src/git-manager.ts

@@ -161,7 +161,7 @@ export class GitManager {
     await this.runGitCommand(`push ${forceFlag} -u origin ${branchName}`);
   }
 
-  // Utility methods for PostHog task workflow
+  // Utility methods for PostHog task execution
   async createTaskPlanningBranch(taskId: string, baseBranch?: string): Promise<string> {
     let branchName = `posthog/task-${taskId}-planning`;
     let counter = 1;

package/src/posthog-api.ts

@@ -1,5 +1,4 @@
 import type { Task, TaskRun, LogEntry, SupportingFile, PostHogAPIConfig, PostHogResource, ResourceType, UrlMention } from './types.js';
-import type { WorkflowDefinition, AgentDefinition } from './workflow-types.js';
 
 interface PostHogApiResponse<T> {
   results?: T[];
@@ -107,8 +106,6 @@ export class PostHogAPIClient {
     repository?: string;
     organization?: string;
     origin_product?: string;
-    workflow?: string;
-    current_stage?: string;
   }): Promise<Task[]> {
     const teamId = await this.getTeamId();
     const url = new URL(`${this.baseUrl}/api/projects/${teamId}/tasks/`);
@@ -171,26 +168,6 @@ export class PostHogAPIClient {
     });
   }
 
-  async updateTaskRunStage(taskId: string, runId: string, stageId: string): Promise<TaskRun> {
-    const teamId = await this.getTeamId();
-    return this.apiRequest<TaskRun>(`/api/projects/${teamId}/tasks/${taskId}/runs/${runId}/update_stage/`, {
-      method: 'PATCH',
-      body: JSON.stringify({ current_stage: stageId }),
-    });
-  }
-
-  async progressTaskRun(taskId: string, runId: string, nextStageId?: string): Promise<TaskRun> {
-    const teamId = await this.getTeamId();
-    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 setTaskRunOutput(taskId: string, runId: string, output: Record<string, unknown>): Promise<TaskRun> {
     const teamId = await this.getTeamId();
     return this.apiRequest<TaskRun>(`/api/projects/${teamId}/tasks/${taskId}/runs/${runId}/set_output/`, {
@@ -207,23 +184,6 @@ export class PostHogAPIClient {
     });
   }
 
-  // Workflow endpoints
-  async fetchWorkflow(workflowId: string): Promise<WorkflowDefinition> {
-    const teamId = await this.getTeamId();
-    return this.apiRequest<WorkflowDefinition>(`/api/projects/${teamId}/workflows/${workflowId}/`);
-  }
-
-  async listWorkflows(): Promise<WorkflowDefinition[]> {
-    const teamId = await this.getTeamId();
-    const response = await this.apiRequest<PostHogApiResponse<WorkflowDefinition>>(`/api/projects/${teamId}/workflows/`);
-    return response.results || [];
-  }
-
-  // Agent catalog exposure
-  async listAgents(): Promise<AgentDefinition[]> {
-    return this.apiRequest<AgentDefinition[]>(`/api/agents/`);
-  }
-
   /**
    * Fetch error details from PostHog error tracking
    */

package/src/prompt-builder.ts

@@ -254,8 +254,6 @@ export class PromptBuilder {
       this.logger.debug('No existing task files found for research', { taskId: task.id });
     }
 
-    prompt += `\n\nPlease explore the codebase thoroughly and generate 3-5 clarifying questions that will help guide the implementation of this task. Use the \`create_plan\` tool to create a research.md artifact with your questions in the markdown format specified in your system prompt.`;
-
     return prompt;
   }
 

package/src/structured-extraction.ts

@@ -1,4 +1,6 @@
-import OpenAI from 'openai';
+import { generateObject } from 'ai';
+import { anthropic } from '@ai-sdk/anthropic';
+import { z } from 'zod';
 import { Logger } from './utils/logger.js';
 
 export interface ExtractedQuestion {
@@ -12,73 +14,54 @@ export interface ExtractedQuestionWithAnswer extends ExtractedQuestion {
   justification: string;
 }
 
-const questionsOnlySchema = {
-  type: 'object',
-  properties: {
-    questions: {
-      type: 'array',
-      items: {
-        type: 'object',
-        properties: {
-          id: { type: 'string' },
-          question: { type: 'string' },
-          options: {
-            type: 'array',
-            items: { type: 'string' }
-          }
-        },
-        required: ['id', 'question', 'options'],
-        additionalProperties: false
-      }
-    }
-  },
-  required: ['questions'],
-  additionalProperties: false
-};
-
-const questionsWithAnswersSchema = {
-  type: 'object',
-  properties: {
-    questions: {
-      type: 'array',
-      items: {
-        type: 'object',
-        properties: {
-          id: { type: 'string' },
-          question: { type: 'string' },
-          options: {
-            type: 'array',
-            items: { type: 'string' }
-          },
-          recommendedAnswer: { type: 'string' },
-          justification: { type: 'string' }
-        },
-        required: ['id', 'question', 'options', 'recommendedAnswer', 'justification'],
-        additionalProperties: false
-      }
-    }
-  },
-  required: ['questions'],
-  additionalProperties: false
-};
+const questionsOnlySchema = z.object({
+  questions: z.array(
+    z.object({
+      id: z.string(),
+      question: z.string(),
+      options: z.array(z.string()),
+    })
+  ),
+});
+
+const questionsWithAnswersSchema = z.object({
+  questions: z.array(
+    z.object({
+      id: z.string(),
+      question: z.string(),
+      options: z.array(z.string()),
+      recommendedAnswer: z.string().describe('The letter of the recommended option (e.g., "a", "b", "c")'),
+      justification: z.string().describe('Brief explanation for the recommended answer'),
+    })
+  ),
+});
 
 export interface StructuredExtractor {
   extractQuestions(researchContent: string): Promise<ExtractedQuestion[]>;
   extractQuestionsWithAnswers(researchContent: string): Promise<ExtractedQuestionWithAnswer[]>;
 }
 
-export class OpenAIExtractor implements StructuredExtractor {
-  private client: OpenAI;
+export class AISDKExtractor implements StructuredExtractor {
   private logger: Logger;
+  private model: any;
 
   constructor(logger?: Logger) {
-    const apiKey = process.env.OPENAI_API_KEY;
+    this.logger = logger || new Logger({ debug: false, prefix: '[AISDKExtractor]' });
+
+    // Determine which provider to use based on environment variables
+    // Priority: Anthropic (if ANTHROPIC_BASE_URL is set) > OpenAI
+    const apiKey = process.env.ANTHROPIC_AUTH_TOKEN
+      || process.env.ANTHROPIC_API_KEY
+      || process.env.OPENAI_API_KEY;
+
     if (!apiKey) {
-      throw new Error('OPENAI_API_KEY environment variable is required for structured extraction');
+      throw new Error('Missing API key for structured extraction. Ensure the LLM gateway is configured.');
     }
-    
-    this.client = new OpenAI({ apiKey });
-    this.logger = logger || new Logger({ debug: false, prefix: '[OpenAIExtractor]' });
+
+    const baseURL = process.env.ANTHROPIC_BASE_URL || process.env.OPENAI_BASE_URL;
+    const modelName = 'claude-haiku-4-5';
+    this.model = anthropic(modelName);
+    this.logger.debug('Using Anthropic provider for structured extraction', { modelName, baseURL });
   }
 
   async extractQuestions(researchContent: string): Promise<ExtractedQuestion[]> {
@@ -86,40 +69,20 @@ export class OpenAIExtractor implements StructuredExtractor {
       contentLength: researchContent.length,
     });
 
-    const completion = await this.client.chat.completions.create({
-      model: 'gpt-4o-mini',
-      messages: [
-        {
-          role: 'system',
-          content: 'Extract the research questions from the provided markdown. Return a JSON object matching the schema.',
-        },
-        {
-          role: 'user',
-          content: researchContent,
-        },
-      ],
-      response_format: {
-        type: 'json_schema',
-        json_schema: {
-          name: 'questions',
-          strict: true,
-          schema: questionsOnlySchema,
-        },
-      },
+    const { object } = await generateObject({
+      model: this.model,
+      schema: questionsOnlySchema,
+      schemaName: 'ResearchQuestions',
+      schemaDescription: 'Research questions extracted from markdown content',
+      system: 'Extract the research questions from the provided markdown. Return a JSON object matching the schema.',
+      prompt: researchContent,
     });
 
-    const content = completion.choices[0].message.content;
-    if (!content) {
-      throw new Error('No content in OpenAI response');
-    }
-
-    const parsed = JSON.parse(content) as { questions: ExtractedQuestion[] };
-    
     this.logger.info('Successfully extracted questions', {
-      questionCount: parsed.questions.length,
+      questionCount: object.questions.length,
     });
 
-    return parsed.questions;
+    return object.questions;
   }
 
   async extractQuestionsWithAnswers(
@@ -129,39 +92,19 @@ export class OpenAIExtractor implements StructuredExtractor {
       contentLength: researchContent.length,
     });
 
-    const completion = await this.client.chat.completions.create({
-      model: 'gpt-4o-mini',
-      messages: [
-        {
-          role: 'system',
-          content: 'Extract the research questions from the markdown and provide recommended answers based on the analysis. For each question, include a recommendedAnswer (the letter: a, b, c, etc.) and a brief justification. Return a JSON object matching the schema.',
-        },
-        {
-          role: 'user',
-          content: researchContent,
-        },
-      ],
-      response_format: {
-        type: 'json_schema',
-        json_schema: {
-          name: 'questions_with_answers',
-          strict: true,
-          schema: questionsWithAnswersSchema,
-        },
-      },
+    const { object } = await generateObject({
+      model: this.model,
+      schema: questionsWithAnswersSchema,
+      schemaName: 'ResearchQuestionsWithAnswers',
+      schemaDescription: 'Research questions with recommended answers extracted from markdown',
+      system: 'Extract the research questions from the markdown and provide recommended answers based on the analysis. For each question, include a recommendedAnswer (the letter: a, b, c, etc.) and a brief justification. Return a JSON object matching the schema.',
+      prompt: researchContent,
     });
 
-    const content = completion.choices[0].message.content;
-    if (!content) {
-      throw new Error('No content in OpenAI response');
-    }
-
-    const parsed = JSON.parse(content) as { questions: ExtractedQuestionWithAnswer[] };
-    
     this.logger.info('Successfully extracted questions with answers', {
-      questionCount: parsed.questions.length,
+      questionCount: object.questions.length,
     });
 
-    return parsed.questions;
+    return object.questions;
   }
 }

package/src/task-progress-reporter.ts

@@ -51,45 +51,13 @@ export class TaskProgressReporter {
     }
   }
 
-  async stageStarted(stageKey: string, stageIndex: number): Promise<void> {
-    await this.update({
-      status: 'in_progress',
-    }, `Stage started: ${stageKey}`);
-  }
-
-  async stageCompleted(stageKey: string, completedStages: number): Promise<void> {
-    await this.update({
-      status: 'in_progress',
-    }, `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' }, 'Workflow execution completed');
+    await this.update({ status: 'completed' }, 'Task 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}`);
+    await this.update({ status: 'failed', error_message: message }, `Task execution failed: ${message}`);
   }
 
   async appendLog(line: string): Promise<void> {

package/src/template-manager.ts

@@ -17,14 +17,45 @@ export class TemplateManager {
   constructor() {
     const __filename = fileURLToPath(import.meta.url);
     const __dirname = dirname(__filename);
+
+    // Exhaustive list of possible template locations
     const candidateDirs = [
-      join(__dirname, 'templates'),
+      // Standard build output (dist/src/template-manager.js -> dist/templates)
       join(__dirname, '..', 'templates'),
+
+      // If preserveModules creates nested structure (dist/src/template-manager.js -> dist/src/templates)
+      join(__dirname, 'templates'),
+
+      // Development scenarios (src/template-manager.ts -> src/templates)
+      join(__dirname, '..', '..', 'src', 'templates'),
+
+      // Package root templates directory
       join(__dirname, '..', '..', 'templates'),
-      join(__dirname, '..', '..', 'src', 'templates')
+
+      // When node_modules symlink or installed (node_modules/@posthog/agent/dist/src/... -> node_modules/@posthog/agent/dist/templates)
+      join(__dirname, '..', '..', 'dist', 'templates'),
+
+      // When consumed from node_modules deep in tree
+      join(__dirname, '..', '..', '..', 'templates'),
+      join(__dirname, '..', '..', '..', 'dist', 'templates'),
+      join(__dirname, '..', '..', '..', 'src', 'templates'),
+
+      // When bundled by Vite/Webpack (e.g., .vite/build/index.js -> node_modules/@posthog/agent/dist/templates)
+      // Try to find node_modules from current location
+      join(__dirname, '..', 'node_modules', '@posthog', 'agent', 'dist', 'templates'),
+      join(__dirname, '..', '..', 'node_modules', '@posthog', 'agent', 'dist', 'templates'),
+      join(__dirname, '..', '..', '..', 'node_modules', '@posthog', 'agent', 'dist', 'templates'),
     ];
 
     const resolvedDir = candidateDirs.find((dir) => existsSync(dir));
+
+    if (!resolvedDir) {
+      console.error('[TemplateManager] Could not find templates directory.');
+      console.error('[TemplateManager] Current file:', __filename);
+      console.error('[TemplateManager] Current dir:', __dirname);
+      console.error('[TemplateManager] Tried:', candidateDirs.map(d => `\n  - ${d} (exists: ${existsSync(d)})`).join(''));
+    }
+
     this.templatesDir = resolvedDir ?? candidateDirs[0];
   }
 
@@ -33,7 +64,7 @@ export class TemplateManager {
       const templatePath = join(this.templatesDir, templateName);
       return await fs.readFile(templatePath, 'utf8');
     } catch (error) {
-      throw new Error(`Failed to load template ${templateName}: ${error}`);
+      throw new Error(`Failed to load template ${templateName} from ${this.templatesDir}: ${error}`);
     }
   }
 
@@ -60,7 +91,6 @@ export class TemplateManager {
     });
   }
 
-
   async generateCustomFile(templateName: string, variables: TemplateVariables): Promise<string> {
     const template = await this.loadTemplate(templateName);
     return this.substituteVariables(template, {
@@ -147,7 +177,7 @@ These files are:
 Customize \`.posthog/.gitignore\` to control which files are committed:
 - Include plans and documentation by default
 - Exclude temporary files and sensitive data
-- Customize based on your team's workflow
+- Customize based on your team's needs
 
 ---
 

package/src/types.ts

@@ -5,7 +5,6 @@ export interface Task {
   description: string;
   origin_product: 'error_tracking' | 'eval_clusters' | 'user_created' | 'support_queue' | 'session_summaries';
   position?: number;
-  workflow?: string | null;
   github_integration?: number | null;
   repository_config?: unknown; // JSONField
   repository_list: string;
@@ -34,7 +33,6 @@ export interface TaskRun {
   task: string; // Task ID
   team: number;
   branch: string | null;
-  current_stage: string | null; // WorkflowStage ID
   status: 'started' | 'in_progress' | 'completed' | 'failed';
   log: LogEntry[]; // Array of log entry objects
   error_message: string | null;
@@ -52,8 +50,6 @@ export interface SupportingFile {
   created_at: string;
 }
 
-// Removed legacy ExecutionMode in favor of configurable workflows
-
 export enum PermissionMode {
   PLAN = "plan",
   DEFAULT = "default",
@@ -155,11 +151,9 @@ export interface StatusEvent extends BaseEvent {
   type: 'status';
   phase: string;
   // Common optional fields (varies by phase):
-  stage?: string;           // Workflow stage (plan, code, complete)
   kind?: string;            // Kind of status (plan, implementation)
   branch?: string;          // Git branch name
   prUrl?: string;           // Pull request URL
-  workflowId?: string;      // Workflow identifier
   taskId?: string;          // Task identifier
   messageId?: string;       // Claude message ID
   model?: string;           // Model name
@@ -271,7 +265,6 @@ export interface TaskExecutionResult {
   task: Task;
   plan?: string;
   executionResult?: ExecutionResult;
-  // Deprecated: mode removed in workflow-based execution
 }
 
 // MCP Server configuration types (re-exported from Claude SDK for convenience)

package/src/workflow/config.ts

@@ -0,0 +1,42 @@
+import type { WorkflowDefinition } from './types.js';
+import { researchStep } from './steps/research.js';
+import { planStep } from './steps/plan.js';
+import { buildStep } from './steps/build.js';
+
+const MODELS = {
+    SONNET: "claude-sonnet-4-5",
+    HAIKU: "claude-haiku-4-5",
+}
+
+export const TASK_WORKFLOW: WorkflowDefinition = [
+    {
+        id: 'research',
+        name: 'Research',
+        agent: 'research',
+        model: MODELS.HAIKU,
+        permissionMode: 'plan',
+        commit: true,
+        push: true,
+        run: researchStep,
+    },
+    {
+        id: 'plan',
+        name: 'Plan',
+        agent: 'planning',
+        model: MODELS.SONNET,
+        permissionMode: 'plan',
+        commit: true,
+        push: true,
+        run: planStep,
+    },
+    {
+        id: 'build',
+        name: 'Build',
+        agent: 'execution',
+        model: MODELS.SONNET,
+        permissionMode: 'acceptEdits',
+        commit: true,
+        push: true,
+        run: buildStep,
+    },
+];

package/src/workflow/steps/build.ts

@@ -0,0 +1,87 @@
+import { query } from '@anthropic-ai/claude-agent-sdk';
+import { EXECUTION_SYSTEM_PROMPT } from '../../agents/execution.js';
+import { PermissionMode } from '../../types.js';
+import type { WorkflowStepRunner } from '../types.js';
+import { finalizeStepGitActions } from '../utils.js';
+
+export const buildStep: WorkflowStepRunner = async ({ step, context }) => {
+    const {
+        task,
+        cwd,
+        options,
+        logger,
+        promptBuilder,
+        adapter,
+        mcpServers,
+        gitManager,
+        emitEvent,
+    } = context;
+
+    const stepLogger = logger.child('BuildStep');
+
+    const latestRun = task.latest_run;
+    const prExists =
+        latestRun?.output && typeof latestRun.output === 'object'
+            ? (latestRun.output as any).pr_url
+            : null;
+
+    if (prExists) {
+        stepLogger.info('PR already exists, skipping build phase', { taskId: task.id });
+        return { status: 'skipped' };
+    }
+
+    stepLogger.info('Starting build phase', { taskId: task.id });
+    emitEvent(adapter.createStatusEvent('phase_start', { phase: 'build' }));
+
+    const executionPrompt = await promptBuilder.buildExecutionPrompt(task, cwd);
+    const fullPrompt = `${EXECUTION_SYSTEM_PROMPT}\n\n${executionPrompt}`;
+
+    const configuredPermissionMode =
+        options.permissionMode ??
+        (typeof step.permissionMode === 'string'
+            ? (step.permissionMode as PermissionMode)
+            : step.permissionMode) ??
+        PermissionMode.ACCEPT_EDITS;
+
+    const baseOptions: Record<string, any> = {
+        model: step.model,
+        cwd,
+        permissionMode: configuredPermissionMode,
+        settingSources: ['local'],
+        mcpServers,
+    };
+
+    const response = query({
+        prompt: fullPrompt,
+        options: { ...baseOptions, ...(options.queryOverrides || {}) },
+    });
+
+    for await (const message of response) {
+        emitEvent(adapter.createRawSDKEvent(message));
+        const transformed = adapter.transform(message);
+        if (transformed) {
+            emitEvent(transformed);
+        }
+    }
+
+    const hasChanges = await gitManager.hasChanges();
+    context.stepResults[step.id] = { commitCreated: false };
+    if (!hasChanges) {
+        stepLogger.warn('No changes to commit in build phase', { taskId: task.id });
+        emitEvent(adapter.createStatusEvent('phase_complete', { phase: 'build' }));
+        return { status: 'completed' };
+    }
+
+    await gitManager.addFiles(['.']);
+    const commitCreated = await finalizeStepGitActions(context, step, {
+        commitMessage: `Implementation for ${task.title}`,
+    });
+    context.stepResults[step.id] = { commitCreated };
+
+    if (!commitCreated) {
+        stepLogger.warn('No commit created during build step', { taskId: task.id });
+    }
+
+    emitEvent(adapter.createStatusEvent('phase_complete', { phase: 'build' }));
+    return { status: 'completed' };
+};