@posthog/agent 1.29.0 → 2.0.0

package/src/agent.ts

@@ -9,14 +9,12 @@ import { POSTHOG_NOTIFICATIONS } from "./acp-extensions.js";
 import {
   createAcpConnection,
   type InProcessAcpConnection,
-} from "./adapters/claude/claude.js";
+} from "./adapters/connection.js";
 import { PostHogFileManager } from "./file-manager.js";
 import { GitManager } from "./git-manager.js";
 import { PostHogAPIClient } from "./posthog-api.js";
-import { PromptBuilder } from "./prompt-builder.js";
 import { SessionStore } from "./session-store.js";
 import { TaskManager } from "./task-manager.js";
-import { TemplateManager } from "./template-manager.js";
 import type {
   AgentConfig,
   CanUseTool,
@@ -25,8 +23,14 @@ import type {
   TaskExecutionOptions,
 } from "./types.js";
 import { Logger } from "./utils/logger.js";
-import { TASK_WORKFLOW } from "./workflow/config.js";
-import type { SendNotification, WorkflowRuntime } from "./workflow/types.js";
+
+/**
+ * Type for sending ACP notifications
+ */
+type SendNotification = (
+  method: string,
+  params: Record<string, unknown>,
+) => Promise<void>;
 
 export class Agent {
   private workingDirectory: string;
@@ -34,10 +38,8 @@ export class Agent {
   private posthogAPI?: PostHogAPIClient;
   private fileManager: PostHogFileManager;
   private gitManager: GitManager;
-  private templateManager: TemplateManager;
   private logger: Logger;
   private acpConnection?: InProcessAcpConnection;
-  private promptBuilder: PromptBuilder;
   private mcpServers?: Record<string, any>;
   private canUseTool?: CanUseTool;
   private currentRunId?: string;
@@ -57,8 +59,8 @@ export class Agent {
 
     // Add auth if API key provided
     const headers: Record<string, string> = {};
-    if (config.posthogApiKey) {
-      headers.Authorization = `Bearer ${config.posthogApiKey}`;
+    if (config.getPosthogApiKey) {
+      headers.Authorization = `Bearer ${config.getPosthogApiKey()}`;
     }
 
     const defaultMcpServers = {
@@ -89,16 +91,15 @@ export class Agent {
       repositoryPath: this.workingDirectory,
       logger: this.logger.child("GitManager"),
     });
-    this.templateManager = new TemplateManager();
 
     if (
       config.posthogApiUrl &&
-      config.posthogApiKey &&
+      config.getPosthogApiKey &&
       config.posthogProjectId
     ) {
       this.posthogAPI = new PostHogAPIClient({
         apiUrl: config.posthogApiUrl,
-        apiKey: config.posthogApiKey,
+        getApiKey: config.getPosthogApiKey,
         projectId: config.posthogProjectId,
       });
 
@@ -108,13 +109,6 @@ export class Agent {
         this.logger.child("SessionStore"),
       );
     }
-
-    this.promptBuilder = new PromptBuilder({
-      getTaskFiles: (taskId: string) => this.getTaskFiles(taskId),
-      generatePlanTemplate: (vars) => this.templateManager.generatePlan(vars),
-      posthogClient: this.posthogAPI,
-      logger: this.logger.child("PromptBuilder"),
-    });
   }
 
   /**
@@ -126,7 +120,7 @@ export class Agent {
   }
 
   /**
-   * Configure LLM gateway environment variables for Claude Code CLI
+   * Configure LLM gateway environment variables for Claude Code CLI.
    */
   private async _configureLlmGateway(): Promise<void> {
     if (!this.posthogAPI) {
@@ -139,113 +133,25 @@ export class Agent {
       process.env.ANTHROPIC_BASE_URL = gatewayUrl;
       process.env.ANTHROPIC_AUTH_TOKEN = apiKey;
       this.ensureOpenAIGatewayEnv(gatewayUrl, apiKey);
+      this.ensureGeminiGatewayEnv(gatewayUrl, apiKey);
     } catch (error) {
       this.logger.error("Failed to configure LLM gateway", error);
       throw error;
     }
   }
 
-  private getOrCreateConnection(): InProcessAcpConnection {
-    if (!this.acpConnection) {
-      this.acpConnection = createAcpConnection({
-        sessionStore: this.sessionStore,
-      });
-    }
-    return this.acpConnection;
-  }
-
-  // Adaptive task execution orchestrated via workflow steps
+  /**
+   * @deprecated Use runTaskV2() for local execution or runTaskCloud() for cloud execution.
+   * This method used the old workflow system which has been removed.
+   */
   async runTask(
-    taskId: string,
-    taskRunId: string,
-    options: import("./types.js").TaskExecutionOptions = {},
+    _taskId: string,
+    _taskRunId: string,
+    _options: import("./types.js").TaskExecutionOptions = {},
   ): Promise<void> {
-    // await this._configureLlmGateway();
-
-    const task = await this.fetchTask(taskId);
-    const cwd = options.repositoryPath || this.workingDirectory;
-    const isCloudMode = options.isCloudMode ?? false;
-    const taskSlug = (task as any).slug || task.id;
-
-    // Use taskRunId as sessionId - they are the same identifier
-    this.currentRunId = taskRunId;
-
-    this.logger.info("Starting adaptive task execution", {
-      taskId: task.id,
-      taskSlug,
-      taskRunId,
-      isCloudMode,
-    });
-
-    const connection = this.getOrCreateConnection();
-
-    // Create sendNotification using ACP connection's extNotification
-    const sendNotification: SendNotification = async (method, params) => {
-      this.logger.debug(`Notification: ${method}`, params);
-      await connection.agentConnection.extNotification?.(method, params);
-    };
-
-    await sendNotification(POSTHOG_NOTIFICATIONS.RUN_STARTED, {
-      sessionId: taskRunId,
-      runId: taskRunId,
-    });
-
-    await this.prepareTaskBranch(taskSlug, isCloudMode, sendNotification);
-
-    let taskError: Error | undefined;
-    try {
-      const workflowContext: WorkflowRuntime = {
-        task,
-        taskSlug,
-        runId: taskRunId,
-        cwd,
-        isCloudMode,
-        options,
-        logger: this.logger,
-        fileManager: this.fileManager,
-        gitManager: this.gitManager,
-        promptBuilder: this.promptBuilder,
-        connection: connection.agentConnection,
-        sessionId: taskRunId,
-        sendNotification,
-        mcpServers: this.mcpServers,
-        posthogAPI: this.posthogAPI,
-        stepResults: {},
-      };
-
-      for (const step of TASK_WORKFLOW) {
-        const result = await step.run({ step, context: workflowContext });
-        if (result.halt) {
-          return;
-        }
-      }
-
-      const shouldCreatePR = options.createPR ?? isCloudMode;
-      if (shouldCreatePR) {
-        await this.ensurePullRequest(
-          task,
-          workflowContext.stepResults,
-          sendNotification,
-        );
-      }
-
-      this.logger.info("Task execution complete", { taskId: task.id });
-      await sendNotification(POSTHOG_NOTIFICATIONS.TASK_COMPLETE, {
-        sessionId: taskRunId,
-        taskId: task.id,
-      });
-    } catch (error) {
-      taskError = error instanceof Error ? error : new Error(String(error));
-      this.logger.error("Task execution failed", {
-        taskId: task.id,
-        error: taskError.message,
-      });
-      await sendNotification(POSTHOG_NOTIFICATIONS.ERROR, {
-        sessionId: taskRunId,
-        message: taskError.message,
-      });
-      throw taskError;
-    }
+    throw new Error(
+      "runTask() is deprecated. Use runTaskV2() for local execution or runTaskCloud() for cloud execution.",
+    );
   }
 
   /**
@@ -262,8 +168,6 @@ export class Agent {
   ): Promise<InProcessAcpConnection> {
     await this._configureLlmGateway();
 
-    const task = await this.fetchTask(taskId);
-    const taskSlug = (task as any).slug || task.id;
     const isCloudMode = options.isCloudMode ?? false;
     const _cwd = options.repositoryPath || this.workingDirectory;
 
@@ -271,9 +175,10 @@ export class Agent {
     this.currentRunId = taskRunId;
 
     this.acpConnection = createAcpConnection({
+      framework: options.framework,
       sessionStore: this.sessionStore,
       sessionId: taskRunId,
-      taskId: task.id,
+      taskId,
     });
 
     const sendNotification: SendNotification = async (method, params) => {
@@ -284,12 +189,17 @@ export class Agent {
       );
     };
 
-    await sendNotification(POSTHOG_NOTIFICATIONS.RUN_STARTED, {
-      sessionId: taskRunId,
-      runId: taskRunId,
-    });
+    if (!options.isReconnect) {
+      await sendNotification(POSTHOG_NOTIFICATIONS.RUN_STARTED, {
+        sessionId: taskRunId,
+        runId: taskRunId,
+      });
+    }
 
+    // Only fetch task when we need the slug for git branch creation
     if (!options.skipGitBranch) {
+      const task = options.task ?? (await this.fetchTask(taskId));
+      const taskSlug = (task as any).slug || task.id;
       try {
         await this.prepareTaskBranch(taskSlug, isCloudMode, sendNotification);
       } catch (error) {
@@ -373,9 +283,7 @@ export class Agent {
 **Description**: ${taskDescription}
 
 ## Changes
-This PR implements the changes described in the task.
-
-Generated by PostHog Agent`;
+This PR implements the changes described in the task.`;
     const prBody = customBody || defaultBody;
 
     const prUrl = await this.gitManager.createPullRequest(
@@ -529,6 +437,19 @@ Generated by PostHog Agent`;
     }
   }
 
+  private ensureGeminiGatewayEnv(gatewayUrl?: string, token?: string): void {
+    const resolvedGatewayUrl = gatewayUrl || process.env.ANTHROPIC_BASE_URL;
+    const resolvedToken = token || process.env.ANTHROPIC_AUTH_TOKEN;
+
+    if (resolvedGatewayUrl) {
+      process.env.GEMINI_BASE_URL = resolvedGatewayUrl;
+    }
+
+    if (resolvedToken) {
+      process.env.GEMINI_API_KEY = resolvedToken;
+    }
+  }
+
   async runTaskCloud(
     taskId: string,
     taskRunId: string,
@@ -741,61 +662,6 @@ Generated by PostHog Agent`;
       throw error;
     }
   }
-
-  private async ensurePullRequest(
-    task: Task,
-    stepResults: Record<string, any>,
-    sendNotification: SendNotification,
-  ): Promise<void> {
-    const latestRun = task.latest_run;
-    const existingPr =
-      latestRun?.output && typeof latestRun.output === "object"
-        ? (latestRun.output as any).pr_url
-        : null;
-
-    if (existingPr) {
-      this.logger.info("PR already exists, skipping creation", {
-        taskId: task.id,
-        prUrl: existingPr,
-      });
-      return;
-    }
-
-    const buildResult = stepResults.build;
-    if (!buildResult?.commitCreated) {
-      this.logger.warn(
-        "Build step did not produce a commit; skipping PR creation",
-        { taskId: task.id },
-      );
-      return;
-    }
-
-    const branchName = await this.gitManager.getCurrentBranch();
-    const finalizeResult = stepResults.finalize;
-    const prBody = finalizeResult?.prBody;
-
-    const prUrl = await this.createPullRequest(
-      task.id,
-      branchName,
-      task.title,
-      task.description ?? "",
-      prBody,
-    );
-
-    await sendNotification(POSTHOG_NOTIFICATIONS.PR_CREATED, { prUrl });
-
-    try {
-      await this.attachPullRequestToTask(task.id, prUrl, branchName);
-      this.logger.info("PR attached to task successfully", {
-        taskId: task.id,
-        prUrl,
-      });
-    } catch (error) {
-      this.logger.warn("Could not attach PR to task", {
-        error: error instanceof Error ? error.message : String(error),
-      });
-    }
-  }
 }
 
 export type {

package/src/file-manager.ts

@@ -1,7 +1,7 @@
 import { promises as fs } from "node:fs";
 import { extname, join } from "node:path";
 import z from "zod";
-import type { ResearchEvaluation, SupportingFile } from "./types.js";
+import type { SupportingFile } from "./types.js";
 import { Logger } from "./utils/logger.js";
 
 export interface TaskFile {
@@ -162,39 +162,6 @@ export class PostHogFileManager {
     return await this.readTaskFile(taskId, "requirements.md");
   }
 
-  async writeResearch(taskId: string, data: ResearchEvaluation): Promise<void> {
-    this.logger.debug("Writing research", {
-      taskId,
-      score: data.actionabilityScore,
-      hasQuestions: !!data.questions,
-      questionCount: data.questions?.length ?? 0,
-      answered: data.answered ?? false,
-    });
-
-    await this.writeTaskFile(taskId, {
-      name: "research.json",
-      content: JSON.stringify(data, null, 2),
-      type: "artifact",
-    });
-
-    this.logger.info("Research file written", {
-      taskId,
-      score: data.actionabilityScore,
-      hasQuestions: !!data.questions,
-      answered: data.answered ?? false,
-    });
-  }
-
-  async readResearch(taskId: string): Promise<ResearchEvaluation | null> {
-    try {
-      const content = await this.readTaskFile(taskId, "research.json");
-      return content ? (JSON.parse(content) as ResearchEvaluation) : null;
-    } catch (error) {
-      this.logger.debug("Failed to parse research.json", { error });
-      return null;
-    }
-  }
-
   async writeTodos(taskId: string, data: unknown): Promise<void> {
     const todos = z.object({
       metadata: z.object({

package/src/git-manager.ts

@@ -6,8 +6,6 @@ const execAsync = promisify(exec);
 
 export interface GitConfig {
   repositoryPath: string;
-  authorName?: string;
-  authorEmail?: string;
   logger?: Logger;
 }
 
@@ -19,14 +17,10 @@ export interface BranchInfo {
 
 export class GitManager {
   private repositoryPath: string;
-  private authorName?: string;
-  private authorEmail?: string;
   private logger: Logger;
 
   constructor(config: GitConfig) {
     this.repositoryPath = config.repositoryPath;
-    this.authorName = config.authorName;
-    this.authorEmail = config.authorEmail;
     this.logger =
       config.logger || new Logger({ debug: false, prefix: "[GitManager]" });
   }
@@ -170,8 +164,7 @@ export class GitManager {
   async commitChanges(
     message: string,
     options?: {
-      authorName?: string;
-      authorEmail?: string;
+      allowEmpty?: boolean;
     },
   ): Promise<string> {
     const command = this.buildCommitCommand(message, options);
@@ -244,8 +237,6 @@ export class GitManager {
     message: string,
     options?: {
       allowEmpty?: boolean;
-      authorName?: string;
-      authorEmail?: string;
     },
   ): string {
     let command = `commit -m "${this.escapeShellArg(message)}"`;
@@ -254,13 +245,6 @@ export class GitManager {
       command += " --allow-empty";
     }
 
-    const authorName = options?.authorName || this.authorName;
-    const authorEmail = options?.authorEmail || this.authorEmail;
-
-    if (authorName && authorEmail) {
-      command += ` --author="${authorName} <${authorEmail}>"`;
-    }
-
     return command;
   }
 
@@ -427,7 +411,6 @@ export class GitManager {
     const message = `📋 Add plan for task: ${taskTitle}
 
 Task ID: ${taskId}
-Generated by PostHog Agent
 
 This commit contains the implementation plan and supporting documentation
 for the task. Review the plan before proceeding with implementation.`;
@@ -452,8 +435,7 @@ for the task. Review the plan before proceeding with implementation.`;
 
     let message = `✨ Implement task: ${taskTitle}
 
-Task ID: ${taskId}
-Generated by PostHog Agent`;
+Task ID: ${taskId}`;
 
     if (planSummary) {
       message += `\n\nPlan Summary:\n${planSummary}`;

package/src/posthog-api.ts

@@ -8,6 +8,7 @@ import type {
   TaskRunArtifact,
   UrlMention,
 } from "./types.js";
+import { getLlmGatewayUrl } from "./utils/gateway.js";
 
 interface PostHogApiResponse<T> {
   results?: T[];
@@ -42,7 +43,7 @@ export class PostHogAPIClient {
 
   private get headers(): Record<string, string> {
     return {
-      Authorization: `Bearer ${this.config.apiKey}`,
+      Authorization: `Bearer ${this.config.getApiKey()}`,
       "Content-Type": "application/json",
     };
   }
@@ -84,12 +85,11 @@ export class PostHogAPIClient {
   }
 
   getApiKey(): string {
-    return this.config.apiKey;
+    return this.config.getApiKey();
   }
 
   getLlmGatewayUrl(): string {
-    const teamId = this.getTeamId();
-    return `${this.baseUrl}/api/projects/${teamId}/llm_gateway`;
+    return getLlmGatewayUrl(this.baseUrl);
   }
 
   async fetchTask(taskId: string): Promise<Task> {

package/src/tools/registry.ts

@@ -84,6 +84,11 @@ const TOOL_DEFINITIONS: Record<string, Tool> = {
     category: "assistant",
     description: "Exit plan mode and present plan to user",
   },
+  AskUserQuestion: {
+    name: "AskUserQuestion",
+    category: "assistant",
+    description: "Ask the user a clarifying question with options",
+  },
   SlashCommand: {
     name: "SlashCommand",
     category: "assistant",

package/src/tools/types.ts

@@ -100,6 +100,11 @@ export interface ExitPlanModeTool extends Tool {
   category: "assistant";
 }
 
+export interface AskUserQuestionTool extends Tool {
+  name: "AskUserQuestion";
+  category: "assistant";
+}
+
 export interface SlashCommandTool extends Tool {
   name: "SlashCommand";
   category: "assistant";
@@ -124,4 +129,5 @@ export type KnownTool =
   | TaskTool
   | TodoWriteTool
   | ExitPlanModeTool
+  | AskUserQuestionTool
   | SlashCommandTool;

package/src/types.ts

@@ -141,6 +141,9 @@ export interface TaskExecutionOptions {
   // See: https://docs.claude.com/en/api/agent-sdk/permissions
   canUseTool?: CanUseTool;
   skipGitBranch?: boolean; // Skip creating a task-specific git branch
+  framework?: "claude"; // Agent framework to use (defaults to "claude")
+  task?: Task; // Pre-fetched task to avoid redundant API call
+  isReconnect?: boolean; // Session recreation - skip RUN_STARTED notification
 }
 
 export interface ExecutionResult {
@@ -197,7 +200,7 @@ export interface AgentConfig {
 
   // PostHog API configuration (optional - enables PostHog integration when provided)
   posthogApiUrl?: string;
-  posthogApiKey?: string;
+  getPosthogApiKey?: () => string;
   posthogProjectId?: number;
 
   // PostHog MCP configuration
@@ -219,7 +222,7 @@ export interface AgentConfig {
 
 export interface PostHogAPIConfig {
   apiUrl: string;
-  apiKey: string;
+  getApiKey: () => string;
   projectId: number;
 }
 
@@ -248,29 +251,6 @@ export interface UrlMention {
   label?: string;
 }
 
-// Research evaluation types
-export interface ResearchQuestion {
-  id: string;
-  question: string;
-  options: string[];
-}
-
-export interface ResearchAnswer {
-  questionId: string;
-  selectedOption: string;
-  customInput?: string;
-}
-
-export interface ResearchEvaluation {
-  actionabilityScore: number; // 0-1 confidence score
-  context: string; // brief summary for planning
-  keyFiles: string[]; // files needing modification
-  blockers?: string[]; // what's preventing full confidence
-  questions?: ResearchQuestion[]; // only if score < 0.7
-  answered?: boolean; // whether questions have been answered
-  answers?: ResearchAnswer[]; // user's answers to questions
-}
-
 // Worktree types for parallel task development
 export interface WorktreeInfo {
   worktreePath: string;

package/src/utils/gateway.ts

@@ -0,0 +1,15 @@
+export function getLlmGatewayUrl(posthogHost: string): string {
+  const url = new URL(posthogHost);
+  const hostname = url.hostname;
+
+  if (hostname === "localhost" || hostname === "127.0.0.1") {
+    return `${url.protocol}//localhost:3308`;
+  }
+
+  // Extract region from hostname (us.posthog.com, eu.posthog.com)
+  // app.posthog.com is legacy US
+  const regionMatch = hostname.match(/^(us|eu)\.posthog\.com$/);
+  const region = regionMatch ? regionMatch[1] : "us";
+
+  return `https://gateway.${region}.posthog.com`;
+}