@posthog/agent 1.12.0 → 1.13.0

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/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' };
+};

package/src/workflow/steps/plan.ts

@@ -0,0 +1,112 @@
+import { query } from '@anthropic-ai/claude-agent-sdk';
+import { PLANNING_SYSTEM_PROMPT } from '../../agents/planning.js';
+import type { WorkflowStepRunner } from '../types.js';
+import { finalizeStepGitActions } from '../utils.js';
+
+export const planStep: WorkflowStepRunner = async ({ step, context }) => {
+    const {
+        task,
+        cwd,
+        isCloudMode,
+        options,
+        logger,
+        fileManager,
+        gitManager,
+        promptBuilder,
+        adapter,
+        mcpServers,
+        emitEvent,
+    } = context;
+
+    const stepLogger = logger.child('PlanStep');
+
+    const existingPlan = await fileManager.readPlan(task.id);
+    if (existingPlan) {
+        stepLogger.info('Plan already exists, skipping step', { taskId: task.id });
+        return { status: 'skipped' };
+    }
+
+    const questionsData = await fileManager.readQuestions(task.id);
+    if (!questionsData || !questionsData.answered) {
+        stepLogger.info('Waiting for answered research questions', { taskId: task.id });
+        emitEvent(adapter.createStatusEvent('phase_complete', { phase: 'research_questions' }));
+        return { status: 'skipped', halt: true };
+    }
+
+    stepLogger.info('Starting planning phase', { taskId: task.id });
+    emitEvent(adapter.createStatusEvent('phase_start', { phase: 'planning' }));
+
+    const researchContent = await fileManager.readResearch(task.id);
+    let researchContext = '';
+    if (researchContent) {
+        researchContext += `## Research Analysis\n\n${researchContent}\n\n`;
+    }
+
+    researchContext += `## Implementation Decisions\n\n`;
+    for (const question of questionsData.questions) {
+        const answer = questionsData.answers?.find(
+            (a: any) => a.questionId === question.id
+        );
+
+        researchContext += `### ${question.question}\n\n`;
+        if (answer) {
+            researchContext += `**Selected:** ${answer.selectedOption}\n`;
+            if (answer.customInput) {
+                researchContext += `**Details:** ${answer.customInput}\n`;
+            }
+        } else {
+            researchContext += `**Selected:** Not answered\n`;
+        }
+        researchContext += `\n`;
+    }
+
+    const planningPrompt = await promptBuilder.buildPlanningPrompt(task, cwd);
+    const fullPrompt = `${PLANNING_SYSTEM_PROMPT}\n\n${planningPrompt}\n\n${researchContext}`;
+
+    const baseOptions: Record<string, any> = {
+        model: step.model,
+        cwd,
+        permissionMode: 'plan',
+        settingSources: ['local'],
+        mcpServers,
+    };
+
+    const response = query({
+        prompt: fullPrompt,
+        options: { ...baseOptions, ...(options.queryOverrides || {}) },
+    });
+
+    let planContent = '';
+    for await (const message of response) {
+        emitEvent(adapter.createRawSDKEvent(message));
+        const transformed = adapter.transform(message);
+        if (transformed) {
+            emitEvent(transformed);
+        }
+        if (message.type === 'assistant' && message.message?.content) {
+            for (const c of message.message.content) {
+                if (c.type === 'text' && c.text) {
+                    planContent += `${c.text}\n`;
+                }
+            }
+        }
+    }
+
+    if (planContent.trim()) {
+        await fileManager.writePlan(task.id, planContent.trim());
+        stepLogger.info('Plan completed', { taskId: task.id });
+    }
+
+    await gitManager.addAllPostHogFiles();
+    await finalizeStepGitActions(context, step, {
+        commitMessage: `Planning phase for ${task.title}`,
+    });
+
+    if (!isCloudMode) {
+        emitEvent(adapter.createStatusEvent('phase_complete', { phase: 'planning' }));
+        return { status: 'completed', halt: true };
+    }
+
+    emitEvent(adapter.createStatusEvent('phase_complete', { phase: 'planning' }));
+    return { status: 'completed' };
+};

package/src/workflow/steps/research.ts

@@ -0,0 +1,156 @@
+import { query } from '@anthropic-ai/claude-agent-sdk';
+import { RESEARCH_SYSTEM_PROMPT } from '../../agents/research.js';
+import type { ExtractedQuestionWithAnswer } from '../../structured-extraction.js';
+import type { WorkflowStepRunner } from '../types.js';
+import { finalizeStepGitActions } from '../utils.js';
+
+export const researchStep: WorkflowStepRunner = async ({ step, context }) => {
+    const {
+        task,
+        cwd,
+        isCloudMode,
+        options,
+        logger,
+        fileManager,
+        gitManager,
+        promptBuilder,
+        adapter,
+        mcpServers,
+        extractor,
+        emitEvent,
+    } = context;
+
+    const stepLogger = logger.child('ResearchStep');
+
+    const existingResearch = await fileManager.readResearch(task.id);
+    if (existingResearch) {
+        stepLogger.info('Research already exists, skipping step', { taskId: task.id });
+        return { status: 'skipped' };
+    }
+
+    stepLogger.info('Starting research phase', { taskId: task.id });
+    emitEvent(adapter.createStatusEvent('phase_start', { phase: 'research' }));
+
+    const researchPrompt = await promptBuilder.buildResearchPrompt(task, cwd);
+    const fullPrompt = `${RESEARCH_SYSTEM_PROMPT}\n\n${researchPrompt}`;
+
+    const baseOptions: Record<string, any> = {
+        model: step.model,
+        cwd,
+        permissionMode: 'plan',
+        settingSources: ['local'],
+        mcpServers,
+    };
+
+    const response = query({
+        prompt: fullPrompt,
+        options: { ...baseOptions, ...(options.queryOverrides || {}) },
+    });
+
+    let researchContent = '';
+    for await (const message of response) {
+        emitEvent(adapter.createRawSDKEvent(message));
+        const transformed = adapter.transform(message);
+        if (transformed) {
+            emitEvent(transformed);
+        }
+        if (message.type === 'assistant' && message.message?.content) {
+            for (const c of message.message.content) {
+                if (c.type === 'text' && c.text) {
+                    researchContent += `${c.text}\n`;
+                }
+            }
+        }
+    }
+
+    if (researchContent.trim()) {
+        await fileManager.writeResearch(task.id, researchContent.trim());
+        stepLogger.info('Research completed', { taskId: task.id });
+    }
+
+    await gitManager.addAllPostHogFiles();
+    await finalizeStepGitActions(context, step, {
+        commitMessage: `Research phase for ${task.title}`,
+    });
+
+    if (extractor && researchContent.trim()) {
+        try {
+            stepLogger.info('Extracting questions from research.md', { taskId: task.id });
+            const parsedQuestions = await extractor.extractQuestions(researchContent);
+
+            await fileManager.writeQuestions(task.id, {
+                questions: parsedQuestions,
+                answered: false,
+                answers: null,
+            });
+
+            emitEvent({
+                type: 'artifact',
+                ts: Date.now(),
+                kind: 'research_questions',
+                content: parsedQuestions,
+            });
+
+            stepLogger.info('Questions extracted successfully', {
+                taskId: task.id,
+                count: parsedQuestions.length,
+            });
+        } catch (error) {
+            stepLogger.error('Failed to extract questions', {
+                taskId: task.id,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            emitEvent({
+                type: 'error',
+                ts: Date.now(),
+                message: `Failed to extract questions: ${
+                    error instanceof Error ? error.message : String(error)
+                }`,
+            });
+        }
+    } else if (!extractor) {
+        stepLogger.warn(
+            'Question extractor not available, skipping question extraction. Ensure LLM gateway is configured.'
+        );
+        emitEvent({
+            type: 'status',
+            ts: Date.now(),
+            phase: 'extraction_skipped',
+            message: 'Question extraction skipped - extractor not configured',
+        });
+    }
+
+    if (!isCloudMode) {
+        emitEvent(adapter.createStatusEvent('phase_complete', { phase: 'research' }));
+        return { status: 'completed', halt: true };
+    }
+
+    const questionsData = await fileManager.readQuestions(task.id);
+    if (questionsData && !questionsData.answered && extractor && researchContent.trim()) {
+        const researchQuestions = await extractor.extractQuestionsWithAnswers(researchContent);
+        const answers = (researchQuestions as ExtractedQuestionWithAnswer[]).map((qa) => ({
+            questionId: qa.id,
+            selectedOption: qa.recommendedAnswer,
+            customInput: qa.justification,
+        }));
+
+        await fileManager.writeQuestions(task.id, {
+            questions: researchQuestions.map((qa) => ({
+                id: qa.id,
+                question: qa.question,
+                options: qa.options,
+            })),
+            answered: true,
+            answers,
+        });
+
+        await gitManager.addAllPostHogFiles();
+        await finalizeStepGitActions(context, step, {
+            commitMessage: `Answer research questions for ${task.title}`,
+        });
+        stepLogger.info('Auto-answered research questions', { taskId: task.id });
+    }
+
+    emitEvent(adapter.createStatusEvent('phase_complete', { phase: 'research' }));
+    return { status: 'completed' };
+};

package/src/workflow/types.ts

@@ -0,0 +1,53 @@
+import type { Task, TaskExecutionOptions, PermissionMode } from '../types.js';
+import type { Logger } from '../utils/logger.js';
+import type { PostHogFileManager } from '../file-manager.js';
+import type { GitManager } from '../git-manager.js';
+import type { PromptBuilder } from '../prompt-builder.js';
+import type { TaskProgressReporter } from '../task-progress-reporter.js';
+import type { ProviderAdapter } from '../adapters/types.js';
+import type { PostHogAPIClient } from '../posthog-api.js';
+import type { StructuredExtractor } from '../structured-extraction.js';
+
+export interface WorkflowRuntime {
+    task: Task;
+    taskSlug: string;
+    cwd: string;
+    isCloudMode: boolean;
+    options: TaskExecutionOptions;
+    logger: Logger;
+    fileManager: PostHogFileManager;
+    gitManager: GitManager;
+    promptBuilder: PromptBuilder;
+    progressReporter: TaskProgressReporter;
+    adapter: ProviderAdapter;
+    mcpServers?: Record<string, any>;
+    posthogAPI?: PostHogAPIClient;
+    extractor?: StructuredExtractor;
+    emitEvent: (event: any) => void;
+    stepResults: Record<string, any>;
+}
+
+export interface WorkflowStepDefinition {
+    id: string;
+    name: string;
+    agent: string;
+    model: string;
+    permissionMode?: PermissionMode | string;
+    commit?: boolean;
+    push?: boolean;
+    run: WorkflowStepRunner;
+}
+
+export interface WorkflowStepRuntime {
+    step: WorkflowStepDefinition;
+    context: WorkflowRuntime;
+}
+
+export interface WorkflowStepResult {
+    status: 'completed' | 'skipped';
+    halt?: boolean;
+}
+
+export type WorkflowStepRunner = (runtime: WorkflowStepRuntime) => Promise<WorkflowStepResult>;
+
+export type WorkflowDefinition = WorkflowStepDefinition[];