@posthog/agent 1.16.0 → 1.16.2

package/src/git-manager.ts

@@ -97,6 +97,8 @@ export class GitManager {
   }
 
   async createOrSwitchToBranch(branchName: string, baseBranch?: string): Promise<void> {
+    await this.ensureCleanWorkingDirectory('switching branches');
+
     const exists = await this.branchExists(branchName);
     if (exists) {
       await this.switchToBranch(branchName);
@@ -118,15 +120,7 @@ export class GitManager {
     authorName?: string;
     authorEmail?: string;
   }): Promise<string> {
-    let command = 'commit -m "' + message.replace(/"/g, '\\"') + '"';
-
-    const authorName = options?.authorName || this.authorName;
-    const authorEmail = options?.authorEmail || this.authorEmail;
-
-    if (authorName && authorEmail) {
-      command += ` --author="${authorName} <${authorEmail}>"`;
-    }
-
+    const command = this.buildCommitCommand(message, options);
     return await this.runGitCommand(command);
   }
 
@@ -148,6 +142,56 @@ export class GitManager {
     }
   }
 
+  // Helper: Centralized safety check for uncommitted changes
+  private async ensureCleanWorkingDirectory(operation: string): Promise<void> {
+    if (await this.hasChanges()) {
+      throw new Error(`Uncommitted changes detected. Please commit or stash changes before ${operation}.`);
+    }
+  }
+
+  private async generateUniqueBranchName(baseName: string): Promise<string> {
+    if (!await this.branchExists(baseName)) {
+      return baseName;
+    }
+
+    let counter = 1;
+    let uniqueName = `${baseName}-${counter}`;
+    while (await this.branchExists(uniqueName)) {
+      counter++;
+      uniqueName = `${baseName}-${counter}`;
+    }
+    return uniqueName;
+  }
+
+  private async ensureOnDefaultBranch(): Promise<string> {
+    const defaultBranch = await this.getDefaultBranch();
+    const currentBranch = await this.getCurrentBranch();
+
+    if (currentBranch !== defaultBranch) {
+      await this.ensureCleanWorkingDirectory('switching to default branch');
+      await this.switchToBranch(defaultBranch);
+    }
+
+    return defaultBranch;
+  }
+
+  private buildCommitCommand(message: string, options?: { allowEmpty?: boolean; authorName?: string; authorEmail?: string }): string {
+    let command = `commit -m "${message.replace(/"/g, '\\"')}"`;
+
+    if (options?.allowEmpty) {
+      command += ' --allow-empty';
+    }
+
+    const authorName = options?.authorName || this.authorName;
+    const authorEmail = options?.authorEmail || this.authorEmail;
+
+    if (authorName && authorEmail) {
+      command += ` --author="${authorName} <${authorEmail}>"`;
+    }
+
+    return command;
+  }
+
   async getRemoteUrl(): Promise<string | null> {
     try {
       return await this.runGitCommand('remote get-url origin');
@@ -161,75 +205,120 @@ export class GitManager {
     await this.runGitCommand(`push ${forceFlag} -u origin ${branchName}`);
   }
 
-  // Utility methods for PostHog task execution
-  async createTaskPlanningBranch(taskId: string, baseBranch?: string): Promise<string> {
-    let branchName = `posthog/task-${taskId}-planning`;
-    let counter = 1;
+  /**
+   * Tracks whether commits were made during an operation by comparing HEAD SHA
+   * before and after. Returns an object with methods to finalize the operation.
+   *
+   * Usage:
+   * const tracker = await gitManager.trackCommitsDuring();
+   * // ... do work that might create commits ...
+   * const result = await tracker.finalize({ commitMessage: 'fallback message', push: true });
+   */
+  async trackCommitsDuring(): Promise<{
+    finalize: (options: {
+      commitMessage: string;
+      push?: boolean;
+    }) => Promise<{ commitCreated: boolean; pushedBranch: boolean }>;
+  }> {
+    const initialSha = await this.getCommitSha('HEAD');
 
-    // Find a unique branch name if the base name already exists
-    while (await this.branchExists(branchName)) {
-      branchName = `posthog/task-${taskId}-planning-${counter}`;
-      counter++;
-    }
+    return {
+      finalize: async (options) => {
+        const currentSha = await this.getCommitSha('HEAD');
+        const externalCommitsCreated = initialSha !== currentSha;
+        const hasUncommittedChanges = await this.hasChanges();
+
+        // If no commits and no changes, nothing to do
+        if (!externalCommitsCreated && !hasUncommittedChanges) {
+          return { commitCreated: false, pushedBranch: false };
+        }
 
-    this.logger.debug('Creating unique planning branch', { branchName, taskId });
+        let commitCreated = externalCommitsCreated;
 
-    // If no base branch specified, ensure we're on main/master
-    if (!baseBranch) {
-      baseBranch = await this.getDefaultBranch();
-      await this.switchToBranch(baseBranch);
+        // Commit any remaining uncommitted changes
+        if (hasUncommittedChanges) {
+          await this.runGitCommand('add .');
+          const hasStagedChanges = await this.hasStagedChanges();
 
-      // Check for uncommitted changes
-      if (await this.hasChanges()) {
-        throw new Error(`Uncommitted changes detected. Please commit or stash changes before running tasks.`);
+          if (hasStagedChanges) {
+            await this.commitChanges(options.commitMessage);
+            commitCreated = true;
+          }
+        }
+
+        // Push if requested and commits were made
+        let pushedBranch = false;
+        if (options.push && commitCreated) {
+          const currentBranch = await this.getCurrentBranch();
+          await this.pushBranch(currentBranch);
+          pushedBranch = true;
+          this.logger.info('Pushed branch after operation', { branch: currentBranch });
+        }
+
+        return { commitCreated, pushedBranch };
       }
-    }
+    };
+  }
+
+  async createTaskBranch(taskSlug: string): Promise<string> {
+    const branchName = `posthog/task-${taskSlug}`;
+
+    // Ensure we're on default branch before creating task branch
+    const defaultBranch = await this.ensureOnDefaultBranch();
+
+    this.logger.info('Creating task branch from default branch', {
+      branchName,
+      taskSlug,
+      baseBranch: defaultBranch
+    });
+
+    await this.createOrSwitchToBranch(branchName, defaultBranch);
 
-    await this.createBranch(branchName, baseBranch); // Use createBranch instead of createOrSwitchToBranch for new branches
     return branchName;
   }
 
-  async createTaskImplementationBranch(taskId: string, planningBranchName?: string): Promise<string> {
-    let branchName = `posthog/task-${taskId}-implementation`;
-    let counter = 1;
+  async createTaskPlanningBranch(taskId: string, baseBranch?: string): Promise<string> {
+    const baseName = `posthog/task-${taskId}-planning`;
+    const branchName = await this.generateUniqueBranchName(baseName);
 
-    // Find a unique branch name if the base name already exists
-    while (await this.branchExists(branchName)) {
-      branchName = `posthog/task-${taskId}-implementation-${counter}`;
-      counter++;
-    }
+    this.logger.debug('Creating unique planning branch', { branchName, taskId });
+
+    const base = baseBranch || await this.ensureOnDefaultBranch();
+    await this.createBranch(branchName, base);
+
+    return branchName;
+  }
+
+  async createTaskImplementationBranch(taskId: string, planningBranchName?: string): Promise<string> {
+    const baseName = `posthog/task-${taskId}-implementation`;
+    const branchName = await this.generateUniqueBranchName(baseName);
 
-    const currentBranchBefore = await this.getCurrentBranch();
     this.logger.debug('Creating unique implementation branch', {
       branchName,
       taskId,
-      currentBranch: currentBranchBefore
+      currentBranch: await this.getCurrentBranch()
     });
 
-    // Implementation branch should branch from the specific planning branch
+    // Determine base branch: explicit param > current planning branch > default
     let baseBranch = planningBranchName;
 
     if (!baseBranch) {
-      // Try to find the corresponding planning branch
       const currentBranch = await this.getCurrentBranch();
       if (currentBranch.includes('-planning')) {
-        baseBranch = currentBranch; // Use current planning branch
+        baseBranch = currentBranch;
         this.logger.debug('Using current planning branch', { baseBranch });
       } else {
-        // Fallback to default branch
-        baseBranch = await this.getDefaultBranch();
-        this.logger.debug('No planning branch found, using default', { baseBranch });
-        await this.switchToBranch(baseBranch);
+        baseBranch = await this.ensureOnDefaultBranch();
+        this.logger.debug('Using default branch', { baseBranch });
       }
     }
 
     this.logger.debug('Creating implementation branch from base', { baseBranch, branchName });
-    await this.createBranch(branchName, baseBranch); // Create fresh branch from base
+    await this.createBranch(branchName, baseBranch);
 
-    const currentBranchAfter = await this.getCurrentBranch();
     this.logger.info('Implementation branch created', {
       branchName,
-      currentBranch: currentBranchAfter
+      currentBranch: await this.getCurrentBranch()
     });
 
     return branchName;
@@ -323,6 +412,7 @@ Generated by PostHog Agent`;
   ): Promise<string> {
     const currentBranch = await this.getCurrentBranch();
     if (currentBranch !== branchName) {
+      await this.ensureCleanWorkingDirectory('creating PR');
       await this.switchToBranch(branchName);
     }
 
@@ -366,31 +456,19 @@ Generated by PostHog Agent`;
 
   async commitAndPush(message: string, options?: { allowEmpty?: boolean }): Promise<void> {
     const hasChanges = await this.hasStagedChanges();
-    
+
     if (!hasChanges && !options?.allowEmpty) {
       this.logger.debug('No changes to commit, skipping');
       return;
     }
 
-    let command = `commit -m "${message.replace(/"/g, '\\"')}"`;
-    
-    if (options?.allowEmpty) {
-      command += ' --allow-empty';
-    }
-
-    const authorName = this.authorName;
-    const authorEmail = this.authorEmail;
-
-    if (authorName && authorEmail) {
-      command += ` --author="${authorName} <${authorEmail}>"`;
-    }
-
+    const command = this.buildCommitCommand(message, options);
     await this.runGitCommand(command);
-    
+
     // Push to origin
     const currentBranch = await this.getCurrentBranch();
     await this.pushBranch(currentBranch);
-    
+
     this.logger.info('Committed and pushed changes', { branch: currentBranch, message });
   }
 }

package/src/structured-extraction.ts

@@ -1,7 +1,7 @@
 import { generateObject } from 'ai';
-import { anthropic } from '@ai-sdk/anthropic';
 import { z } from 'zod';
 import { Logger } from './utils/logger.js';
+import { getAnthropicModel } from './utils/ai-sdk.js';
 
 export interface ExtractedQuestion {
   id: string;
@@ -41,27 +41,34 @@ export interface StructuredExtractor {
   extractQuestionsWithAnswers(researchContent: string): Promise<ExtractedQuestionWithAnswer[]>;
 }
 
+export type StructuredExtractorConfig = {
+  apiKey: string;
+  baseURL: string;
+  modelName?: string;
+  logger?: Logger;
+}
+
 export class AISDKExtractor implements StructuredExtractor {
   private logger: Logger;
   private model: any;
 
-  constructor(logger?: Logger) {
-    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;
+  constructor(config: StructuredExtractorConfig) {
+    this.logger = config.logger || new Logger({ debug: false, prefix: '[AISDKExtractor]' });
 
-    if (!apiKey) {
+    if (!config.apiKey) {
       throw new Error('Missing API key for structured extraction. Ensure the LLM gateway is configured.');
     }
 
-    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 });
+    this.model = getAnthropicModel({
+      apiKey: config.apiKey,
+      baseURL: config.baseURL,
+      modelName: config.modelName || 'claude-haiku-4-5',
+    });
+
+    this.logger.debug('Using PostHog LLM gateway for structured extraction', {
+      modelName: config.modelName || 'claude-haiku-4-5',
+      baseURL: config.baseURL
+    });
   }
 
   async extractQuestions(researchContent: string): Promise<ExtractedQuestion[]> {

package/src/types.ts

@@ -301,8 +301,8 @@ export interface AgentConfig {
   onEvent?: (event: AgentEvent) => void;
 
   // PostHog API configuration
-  posthogApiUrl?: string;
-  posthogApiKey?: string;
+  posthogApiUrl: string;
+  posthogApiKey: string;
 
   // PostHog MCP configuration
   posthogMcpUrl?: string;

package/src/utils/ai-sdk.ts

@@ -0,0 +1,47 @@
+import { createAnthropic } from '@ai-sdk/anthropic';
+
+export interface PostHogGatewayConfig {
+  apiKey: string;
+  baseURL: string;
+  modelName?: string;
+}
+
+/**
+ * Creates an Anthropic model configured for PostHog LLM gateway.
+ * 
+ * Handles two key differences between AI SDK and PostHog gateway:
+ * 1. Appends /v1 to baseURL (gateway expects /v1/messages, SDK appends /messages)
+ * 2. Converts x-api-key header to Authorization Bearer token
+ */
+export function getAnthropicModel(config: PostHogGatewayConfig) {
+  const modelName = config.modelName || 'claude-haiku-4-5';
+  
+  // PostHog gateway expects /v1/messages, but AI SDK appends /messages
+  // So we need to append /v1 to the baseURL
+  const baseURL = config.baseURL ? `${config.baseURL}/v1` : undefined;
+
+  // Custom fetch to convert x-api-key header to Authorization Bearer
+  // PostHog gateway expects Bearer token, but Anthropic SDK sends x-api-key
+  const customFetch = async (url: RequestInfo, init?: RequestInit): Promise<Response> => {
+    const headers = new Headers(init?.headers);
+
+    if (headers.has('x-api-key')) {
+      headers.delete('x-api-key');
+      headers.set('Authorization', `Bearer ${config.apiKey}`);
+    }
+
+    return fetch(url, {
+      ...init,
+      headers,
+    });
+  };
+
+  const anthropic = createAnthropic({
+    apiKey: config.apiKey,
+    baseURL,
+    //@ts-ignore
+    fetch: customFetch,
+  });
+
+  return anthropic(modelName);
+}

package/src/workflow/steps/build.ts

@@ -79,6 +79,9 @@ export const buildStep: WorkflowStepRunner = async ({ step, context }) => {
         options: { ...baseOptions, ...(options.queryOverrides || {}) },
     });
 
+    // Track commits made during Claude Code execution
+    const commitTracker = await gitManager.trackCommitsDuring();
+
     for await (const message of response) {
         emitEvent(adapter.createRawSDKEvent(message));
         const transformed = adapter.transform(message);
@@ -87,29 +90,21 @@ export const buildStep: WorkflowStepRunner = async ({ step, context }) => {
         }
     }
 
-    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, {
+    // Finalize: commit any remaining changes and optionally push
+    const { commitCreated, pushedBranch } = await commitTracker.finalize({
         commitMessage: `Implementation for ${task.title}`,
+        push: step.push,
     });
+
     context.stepResults[step.id] = { commitCreated };
 
     if (!commitCreated) {
-        stepLogger.warn('No commit created during build step', { taskId: task.id });
-    }
-
-    // Always push after build if configured, even if agent created the commits
-    if (step.push && !commitCreated) {
-        const branchName = await gitManager.getCurrentBranch();
-        await gitManager.pushBranch(branchName);
-        stepLogger.info('Pushed branch after build', { branch: branchName });
+        stepLogger.warn('No changes to commit in build phase', { taskId: task.id });
+    } else {
+        stepLogger.info('Build commits finalized', {
+            taskId: task.id,
+            pushedBranch
+        });
     }
 
     emitEvent(adapter.createStatusEvent('phase_complete', { phase: 'build' }));