@posthog/agent 1.30.0 → 2.0.0

package/src/workflow/steps/plan.ts

@@ -1,167 +0,0 @@
-import { query } from "@anthropic-ai/claude-agent-sdk";
-import { POSTHOG_NOTIFICATIONS } from "../../acp-extensions.js";
-import { PLANNING_SYSTEM_PROMPT } from "../../agents/planning.js";
-import { TodoManager } from "../../todo-manager.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,
-    sessionId,
-    mcpServers,
-    sendNotification,
-  } = 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 researchData = await fileManager.readResearch(task.id);
-  if (researchData?.questions && !researchData.answered) {
-    stepLogger.info("Waiting for answered research questions", {
-      taskId: task.id,
-    });
-    await sendNotification(POSTHOG_NOTIFICATIONS.PHASE_COMPLETE, {
-      sessionId,
-      phase: "research_questions",
-    });
-    return { status: "skipped", halt: true };
-  }
-
-  stepLogger.info("Starting planning phase", { taskId: task.id });
-  await sendNotification(POSTHOG_NOTIFICATIONS.PHASE_START, {
-    sessionId,
-    phase: "planning",
-  });
-  let researchContext = "";
-  if (researchData) {
-    researchContext += `## Research Context\n\n${researchData.context}\n\n`;
-    if (researchData.keyFiles.length > 0) {
-      researchContext += `**Key Files:**\n${researchData.keyFiles.map((f) => `- ${f}`).join("\n")}\n\n`;
-    }
-    if (researchData.blockers && researchData.blockers.length > 0) {
-      researchContext += `**Considerations:**\n${researchData.blockers.map((b) => `- ${b}`).join("\n")}\n\n`;
-    }
-
-    // Add answered questions if they exist
-    if (
-      researchData.questions &&
-      researchData.answers &&
-      researchData.answered
-    ) {
-      researchContext += `## Implementation Decisions\n\n`;
-      for (const question of researchData.questions) {
-        const answer = researchData.answers.find(
-          (a) => 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, unknown> = {
-    model: step.model,
-    cwd,
-    permissionMode: "plan",
-    settingSources: ["local"],
-    mcpServers,
-    // Allow research tools: read-only operations, web search, MCP resources, and ExitPlanMode
-    allowedTools: [
-      "Read",
-      "Glob",
-      "Grep",
-      "WebFetch",
-      "WebSearch",
-      "ListMcpResources",
-      "ReadMcpResource",
-      "ExitPlanMode",
-      "TodoWrite",
-      "BashOutput",
-    ],
-  };
-
-  const response = query({
-    prompt: fullPrompt,
-    options: { ...baseOptions, ...(options.queryOverrides || {}) },
-  });
-
-  const todoManager = new TodoManager(fileManager, stepLogger);
-
-  let planContent = "";
-  try {
-    for await (const message of response) {
-      const todoList = await todoManager.checkAndPersistFromMessage(
-        message,
-        task.id,
-      );
-      if (todoList) {
-        await sendNotification(POSTHOG_NOTIFICATIONS.ARTIFACT, {
-          sessionId,
-          kind: "todos",
-          content: todoList,
-        });
-      }
-
-      // Extract text content for plan
-      if (message.type === "assistant" && message.message?.content) {
-        for (const block of message.message.content) {
-          if (block.type === "text" && block.text) {
-            planContent += `${block.text}\n`;
-          }
-        }
-      }
-    }
-  } catch (error) {
-    stepLogger.error("Error during plan step query", error);
-    throw error;
-  }
-
-  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) {
-    await sendNotification(POSTHOG_NOTIFICATIONS.PHASE_COMPLETE, {
-      sessionId,
-      phase: "planning",
-    });
-    return { status: "completed", halt: true };
-  }
-
-  await sendNotification(POSTHOG_NOTIFICATIONS.PHASE_COMPLETE, {
-    sessionId,
-    phase: "planning",
-  });
-  return { status: "completed" };
-};

package/src/workflow/steps/research.ts

@@ -1,223 +0,0 @@
-import { query } from "@anthropic-ai/claude-agent-sdk";
-import { POSTHOG_NOTIFICATIONS } from "../../acp-extensions.js";
-import { RESEARCH_SYSTEM_PROMPT } from "../../agents/research.js";
-import type { ResearchEvaluation } from "../../types.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,
-    sessionId,
-    mcpServers,
-    sendNotification,
-  } = context;
-
-  const stepLogger = logger.child("ResearchStep");
-
-  const existingResearch = await fileManager.readResearch(task.id);
-  if (existingResearch) {
-    stepLogger.info("Research already exists", {
-      taskId: task.id,
-      hasQuestions: !!existingResearch.questions,
-      answered: existingResearch.answered,
-    });
-
-    // If there are unanswered questions, re-emit them so UI can prompt user
-    if (existingResearch.questions && !existingResearch.answered) {
-      stepLogger.info("Re-emitting unanswered research questions", {
-        taskId: task.id,
-        questionCount: existingResearch.questions.length,
-      });
-
-      await sendNotification(POSTHOG_NOTIFICATIONS.ARTIFACT, {
-        sessionId,
-        kind: "research_questions",
-        content: existingResearch.questions,
-      });
-
-      // In local mode, halt to allow user to answer
-      if (!isCloudMode) {
-        await sendNotification(POSTHOG_NOTIFICATIONS.PHASE_COMPLETE, {
-          sessionId,
-          phase: "research",
-        });
-        return { status: "skipped", halt: true };
-      }
-    }
-
-    return { status: "skipped" };
-  }
-
-  stepLogger.info("Starting research phase", { taskId: task.id });
-  await sendNotification(POSTHOG_NOTIFICATIONS.PHASE_START, {
-    sessionId,
-    phase: "research",
-  });
-
-  const researchPrompt = await promptBuilder.buildResearchPrompt(task, cwd);
-  const fullPrompt = `${RESEARCH_SYSTEM_PROMPT}\n\n${researchPrompt}`;
-
-  const baseOptions: Record<string, unknown> = {
-    model: step.model,
-    cwd,
-    permissionMode: "plan",
-    settingSources: ["local"],
-    mcpServers,
-    // Allow research tools: read-only operations, web search, and MCP resources
-    allowedTools: [
-      "Read",
-      "Glob",
-      "Grep",
-      "WebFetch",
-      "WebSearch",
-      "ListMcpResources",
-      "ReadMcpResource",
-      "TodoWrite",
-      "BashOutput",
-    ],
-  };
-
-  const response = query({
-    prompt: fullPrompt,
-    options: { ...baseOptions, ...(options.queryOverrides || {}) },
-  });
-
-  let jsonContent = "";
-  try {
-    for await (const message of response) {
-      // Extract text content from assistant messages
-      if (message.type === "assistant" && message.message?.content) {
-        for (const c of message.message.content) {
-          if (c.type === "text" && c.text) {
-            jsonContent += c.text;
-          }
-        }
-      }
-    }
-  } catch (error) {
-    stepLogger.error("Error during research step query", error);
-    throw error;
-  }
-
-  if (!jsonContent.trim()) {
-    stepLogger.error("No JSON output from research agent", { taskId: task.id });
-    await sendNotification(POSTHOG_NOTIFICATIONS.ERROR, {
-      sessionId,
-      message: "Research agent returned no output",
-    });
-    return { status: "completed", halt: true };
-  }
-
-  // Parse JSON response
-  let evaluation: ResearchEvaluation;
-  try {
-    // Extract JSON from potential markdown code blocks or other wrapping
-    const jsonMatch = jsonContent.match(/\{[\s\S]*\}/);
-    if (!jsonMatch) {
-      throw new Error("No JSON object found in response");
-    }
-    evaluation = JSON.parse(jsonMatch[0]);
-    stepLogger.info("Parsed research evaluation", {
-      taskId: task.id,
-      score: evaluation.actionabilityScore,
-      hasQuestions: !!evaluation.questions,
-    });
-  } catch (error) {
-    stepLogger.error("Failed to parse research JSON", {
-      taskId: task.id,
-      error: error instanceof Error ? error.message : String(error),
-      content: jsonContent.substring(0, 500),
-    });
-    await sendNotification(POSTHOG_NOTIFICATIONS.ERROR, {
-      sessionId,
-      message: `Failed to parse research JSON: ${
-        error instanceof Error ? error.message : String(error)
-      }`,
-    });
-    return { status: "completed", halt: true };
-  }
-
-  // Add answered/answers fields to evaluation
-  if (evaluation.questions && evaluation.questions.length > 0) {
-    evaluation.answered = false;
-    evaluation.answers = undefined;
-  }
-
-  // Always write research.json
-  await fileManager.writeResearch(task.id, evaluation);
-  stepLogger.info("Research evaluation written", {
-    taskId: task.id,
-    score: evaluation.actionabilityScore,
-    hasQuestions: !!evaluation.questions,
-  });
-
-  await sendNotification(POSTHOG_NOTIFICATIONS.ARTIFACT, {
-    sessionId,
-    kind: "research_evaluation",
-    content: evaluation,
-  });
-
-  await gitManager.addAllPostHogFiles();
-  await finalizeStepGitActions(context, step, {
-    commitMessage: `Research phase for ${task.title}`,
-  });
-
-  // Log whether questions need answering
-  if (
-    evaluation.actionabilityScore < 0.7 &&
-    evaluation.questions &&
-    evaluation.questions.length > 0
-  ) {
-    stepLogger.info("Actionability score below threshold, questions needed", {
-      taskId: task.id,
-      score: evaluation.actionabilityScore,
-      questionCount: evaluation.questions.length,
-    });
-
-    await sendNotification(POSTHOG_NOTIFICATIONS.ARTIFACT, {
-      sessionId,
-      kind: "research_questions",
-      content: evaluation.questions,
-    });
-  } else {
-    stepLogger.info("Actionability score acceptable, proceeding to planning", {
-      taskId: task.id,
-      score: evaluation.actionabilityScore,
-    });
-  }
-
-  // In local mode, always halt after research for user review
-  if (!isCloudMode) {
-    await sendNotification(POSTHOG_NOTIFICATIONS.PHASE_COMPLETE, {
-      sessionId,
-      phase: "research",
-    });
-    return { status: "completed", halt: true };
-  }
-
-  // In cloud mode, check if questions need answering
-  const researchData = await fileManager.readResearch(task.id);
-  if (researchData?.questions && !researchData.answered) {
-    // Questions need answering - halt for user input in cloud mode too
-    await sendNotification(POSTHOG_NOTIFICATIONS.PHASE_COMPLETE, {
-      sessionId,
-      phase: "research",
-    });
-    return { status: "completed", halt: true };
-  }
-
-  // No questions or questions already answered - proceed to planning
-  await sendNotification(POSTHOG_NOTIFICATIONS.PHASE_COMPLETE, {
-    sessionId,
-    phase: "research",
-  });
-  return { status: "completed" };
-};

package/src/workflow/types.ts

@@ -1,62 +0,0 @@
-import type { AgentSideConnection } from "@agentclientprotocol/sdk";
-import type { PostHogFileManager } from "../file-manager.js";
-import type { GitManager } from "../git-manager.js";
-import type { PostHogAPIClient } from "../posthog-api.js";
-import type { PromptBuilder } from "../prompt-builder.js";
-import type { PermissionMode, Task, TaskExecutionOptions } from "../types.js";
-import type { Logger } from "../utils/logger.js";
-
-/**
- * Function type for sending custom PostHog notifications via ACP extNotification.
- * Used by workflow steps to emit artifacts, phase updates, etc.
- */
-export type SendNotification = (
-  method: string,
-  params: Record<string, unknown>,
-) => Promise<void>;
-
-export interface WorkflowRuntime {
-  task: Task;
-  taskSlug: string;
-  runId: string;
-  cwd: string;
-  isCloudMode: boolean;
-  options: TaskExecutionOptions;
-  logger: Logger;
-  fileManager: PostHogFileManager;
-  gitManager: GitManager;
-  promptBuilder: PromptBuilder;
-  connection: AgentSideConnection;
-  sessionId: string;
-  mcpServers?: Record<string, unknown>;
-  posthogAPI?: PostHogAPIClient;
-  sendNotification: SendNotification;
-  stepResults: Record<string, unknown>;
-}
-
-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[];

package/src/workflow/utils.ts

@@ -1,53 +0,0 @@
-import type { WorkflowRuntime, WorkflowStepDefinition } from "./types.js";
-
-interface FinalizeGitOptions {
-  commitMessage: string;
-  allowEmptyCommit?: boolean;
-}
-
-/**
- * Commits (and optionally pushes) any staged changes according to the step configuration.
- * Returns true if a commit was created.
- */
-export async function finalizeStepGitActions(
-  context: WorkflowRuntime,
-  step: WorkflowStepDefinition,
-  options: FinalizeGitOptions,
-): Promise<boolean> {
-  if (!step.commit) {
-    return false;
-  }
-
-  const { gitManager, logger } = context;
-  const hasStagedChanges = await gitManager.hasStagedChanges();
-
-  if (!hasStagedChanges && !options.allowEmptyCommit) {
-    logger.debug("No staged changes to commit for step", { stepId: step.id });
-    return false;
-  }
-
-  try {
-    await gitManager.commitChanges(options.commitMessage);
-    logger.info("Committed changes for step", {
-      stepId: step.id,
-      message: options.commitMessage,
-    });
-  } catch (error) {
-    logger.error("Failed to commit changes for step", {
-      stepId: step.id,
-      error: error instanceof Error ? error.message : String(error),
-    });
-    throw error;
-  }
-
-  if (step.push) {
-    const branchName = await gitManager.getCurrentBranch();
-    await gitManager.pushBranch(branchName);
-    logger.info("Pushed branch after step", {
-      stepId: step.id,
-      branch: branchName,
-    });
-  }
-
-  return true;
-}