@posthog/agent 1.30.0 → 2.0.1

package/src/utils/tapped-stream.ts

@@ -1,60 +0,0 @@
-import type { Logger } from "./logger.js";
-
-type MessageCallback = (line: string) => void;
-
-export interface TappedStreamOptions {
-  onMessage: MessageCallback;
-  logger?: Logger;
-}
-
-/**
- * Creates a WritableStream wrapper that taps all newline-delimited messages,
- * forwarding each complete line for persistence.
- *
- * This aligns with ACP's transport model - all messages flow through
- * newline-delimited JSON-RPC streams, so we intercept at the transport layer
- * and persist everything.
- */
-export function createTappedWritableStream(
-  underlying: WritableStream<Uint8Array>,
-  options: TappedStreamOptions,
-): WritableStream<Uint8Array> {
-  const { onMessage, logger } = options;
-  const decoder = new TextDecoder();
-  let buffer = "";
-  let _messageCount = 0;
-
-  return new WritableStream({
-    async write(chunk: Uint8Array) {
-      // Decode and buffer
-      buffer += decoder.decode(chunk, { stream: true });
-
-      // Process complete lines (newline-delimited)
-      const lines = buffer.split("\n");
-      buffer = lines.pop() ?? "";
-
-      for (const line of lines) {
-        if (!line.trim()) continue;
-        _messageCount++;
-
-        onMessage(line);
-      }
-
-      // Forward to underlying stream
-      const writer = underlying.getWriter();
-      await writer.write(chunk);
-      writer.releaseLock();
-    },
-    async close() {
-      const writer = underlying.getWriter();
-      await writer.close();
-      writer.releaseLock();
-    },
-    async abort(reason: unknown) {
-      logger?.warn("Tapped stream aborted", { reason });
-      const writer = underlying.getWriter();
-      await writer.abort(reason);
-      writer.releaseLock();
-    },
-  });
-}

package/src/workflow/config.ts

@@ -1,53 +0,0 @@
-import { buildStep } from "./steps/build.js";
-import { finalizeStep } from "./steps/finalize.js";
-import { planStep } from "./steps/plan.js";
-import { researchStep } from "./steps/research.js";
-import type { WorkflowDefinition } from "./types.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,
-  },
-  {
-    id: "finalize",
-    name: "Finalize",
-    agent: "system", // not used
-    model: MODELS.HAIKU, // not used
-    permissionMode: "plan", // not used
-    commit: true,
-    push: true,
-    run: finalizeStep,
-  },
-];

package/src/workflow/steps/build.ts

@@ -1,135 +0,0 @@
-import { query } from "@anthropic-ai/claude-agent-sdk";
-import { POSTHOG_NOTIFICATIONS } from "../../acp-extensions.js";
-import { EXECUTION_SYSTEM_PROMPT } from "../../agents/execution.js";
-import { TodoManager } from "../../todo-manager.js";
-import { PermissionMode } from "../../types.js";
-import type { WorkflowStepRunner } from "../types.js";
-
-export const buildStep: WorkflowStepRunner = async ({ step, context }) => {
-  const {
-    task,
-    cwd,
-    options,
-    logger,
-    promptBuilder,
-    sessionId,
-    mcpServers,
-    gitManager,
-    sendNotification,
-  } = context;
-
-  const stepLogger = logger.child("BuildStep");
-
-  const latestRun = task.latest_run;
-  const prExists =
-    latestRun?.output && typeof latestRun.output === "object"
-      ? (latestRun.output as Record<string, unknown>).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 });
-  await sendNotification(POSTHOG_NOTIFICATIONS.PHASE_START, {
-    sessionId,
-    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, unknown> = {
-    model: step.model,
-    cwd,
-    permissionMode: configuredPermissionMode,
-    settingSources: ["local"],
-    mcpServers,
-    // Allow all tools for build phase - full read/write access needed for implementation
-    allowedTools: [
-      "Task",
-      "Bash",
-      "BashOutput",
-      "KillBash",
-      "Edit",
-      "Read",
-      "Write",
-      "Glob",
-      "Grep",
-      "NotebookEdit",
-      "WebFetch",
-      "WebSearch",
-      "ListMcpResources",
-      "ReadMcpResource",
-      "TodoWrite",
-    ],
-  };
-
-  // Add fine-grained permission hook if provided
-  if (options.canUseTool) {
-    baseOptions.canUseTool = options.canUseTool;
-  }
-
-  const response = query({
-    prompt: fullPrompt,
-    options: { ...baseOptions, ...(options.queryOverrides || {}) },
-  });
-
-  // Track commits made during Claude Code execution
-  const commitTracker = await gitManager.trackCommitsDuring();
-
-  // Track todos from TodoWrite tool calls
-  const todoManager = new TodoManager(context.fileManager, stepLogger);
-
-  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,
-        });
-      }
-    }
-  } catch (error) {
-    stepLogger.error("Error during build step query", error);
-    throw error;
-  }
-
-  // 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 changes to commit in build phase", { taskId: task.id });
-  } else {
-    stepLogger.info("Build commits finalized", {
-      taskId: task.id,
-      pushedBranch,
-    });
-  }
-
-  await sendNotification(POSTHOG_NOTIFICATIONS.PHASE_COMPLETE, {
-    sessionId,
-    phase: "build",
-  });
-  return { status: "completed" };
-};

package/src/workflow/steps/finalize.ts

@@ -1,241 +0,0 @@
-import type { LocalArtifact } from "../../file-manager.js";
-import type { Task, TaskRunArtifact } from "../../types.js";
-import type { WorkflowStepRunner } from "../types.js";
-import { finalizeStepGitActions } from "../utils.js";
-
-const MAX_SNIPPET_LENGTH = 1200;
-
-export const finalizeStep: WorkflowStepRunner = async ({ step, context }) => {
-  const { task, logger, fileManager, gitManager, posthogAPI, runId } = context;
-
-  const stepLogger = logger.child("FinalizeStep");
-  const artifacts = await fileManager.collectTaskArtifacts(task.id);
-  let uploadedArtifacts: TaskRunArtifact[] | undefined;
-
-  if (artifacts.length && posthogAPI && runId) {
-    try {
-      const payload = artifacts.map((artifact) => ({
-        name: artifact.name,
-        type: artifact.type,
-        content: artifact.content,
-        content_type: artifact.contentType,
-      }));
-      uploadedArtifacts = await posthogAPI.uploadTaskArtifacts(
-        task.id,
-        runId,
-        payload,
-      );
-      stepLogger.info("Uploaded task artifacts to PostHog", {
-        taskId: task.id,
-        uploadedCount: uploadedArtifacts.length,
-      });
-    } catch (error) {
-      stepLogger.warn("Failed to upload task artifacts", {
-        taskId: task.id,
-        error: error instanceof Error ? error.message : String(error),
-      });
-    }
-  } else {
-    stepLogger.debug("Skipping artifact upload", {
-      hasArtifacts: artifacts.length > 0,
-      hasPostHogApi: Boolean(posthogAPI),
-      runId,
-    });
-  }
-
-  const prBody = buildPullRequestBody(task, artifacts, uploadedArtifacts);
-  await fileManager.cleanupTaskDirectory(task.id);
-  await gitManager.addAllPostHogFiles();
-
-  // Commit the deletion of artifacts
-  await finalizeStepGitActions(context, step, {
-    commitMessage: `Cleanup task artifacts for ${task.title}`,
-    allowEmptyCommit: true,
-  });
-
-  context.stepResults[step.id] = {
-    prBody,
-    uploadedArtifacts,
-    artifactCount: artifacts.length,
-  };
-
-  return { status: "completed" };
-};
-
-function buildPullRequestBody(
-  task: Task,
-  artifacts: LocalArtifact[],
-  uploaded?: TaskRunArtifact[],
-): string {
-  const lines: string[] = [];
-  const taskSlug = (task as unknown as Record<string, unknown>).slug || task.id;
-
-  lines.push("## Task context");
-  lines.push(`- **Task**: ${taskSlug}`);
-  lines.push(`- **Title**: ${task.title}`);
-  lines.push(`- **Origin**: ${task.origin_product}`);
-
-  if (task.description) {
-    lines.push("");
-    lines.push(`> ${task.description.trim().split("\n").join("\n> ")}`);
-  }
-
-  const usedFiles = new Set<string>();
-
-  const contextArtifact = artifacts.find(
-    (artifact) => artifact.name === "context.md",
-  );
-  if (contextArtifact) {
-    lines.push("");
-    lines.push("### Task prompt");
-    lines.push(contextArtifact.content);
-    usedFiles.add(contextArtifact.name);
-  }
-
-  const researchArtifact = artifacts.find(
-    (artifact) => artifact.name === "research.json",
-  );
-  if (researchArtifact) {
-    usedFiles.add(researchArtifact.name);
-    const researchSection = formatResearchSection(researchArtifact.content);
-    if (researchSection) {
-      lines.push("");
-      lines.push(researchSection);
-    }
-  }
-
-  const planArtifact = artifacts.find(
-    (artifact) => artifact.name === "plan.md",
-  );
-  if (planArtifact) {
-    lines.push("");
-    lines.push("### Implementation plan");
-    lines.push(planArtifact.content);
-    usedFiles.add(planArtifact.name);
-  }
-
-  const todoArtifact = artifacts.find(
-    (artifact) => artifact.name === "todos.json",
-  );
-  if (todoArtifact) {
-    const summary = summarizeTodos(todoArtifact.content);
-    if (summary) {
-      lines.push("");
-      lines.push("### Todo list");
-      lines.push(summary);
-    }
-    usedFiles.add(todoArtifact.name);
-  }
-
-  const remainingArtifacts = artifacts.filter(
-    (artifact) => !usedFiles.has(artifact.name),
-  );
-  if (remainingArtifacts.length) {
-    lines.push("");
-    lines.push("### Additional artifacts");
-    for (const artifact of remainingArtifacts) {
-      lines.push(`#### ${artifact.name}`);
-      lines.push(renderCodeFence(artifact.content));
-    }
-  }
-
-  const artifactList =
-    uploaded ??
-    artifacts.map((artifact) => ({
-      name: artifact.name,
-      type: artifact.type,
-    }));
-
-  if (artifactList.length) {
-    lines.push("");
-    lines.push("### Uploaded artifacts");
-    for (const artifact of artifactList) {
-      const rawStoragePath =
-        "storage_path" in artifact
-          ? (artifact as Record<string, unknown>).storage_path
-          : undefined;
-      const storagePath =
-        typeof rawStoragePath === "string" ? rawStoragePath : undefined;
-      const storage =
-        storagePath && storagePath.trim().length > 0
-          ? ` – \`${storagePath.trim()}\``
-          : "";
-      lines.push(`- ${artifact.name} (${artifact.type})${storage}`);
-    }
-  }
-
-  return lines.join("\n\n");
-}
-
-function renderCodeFence(content: string): string {
-  const snippet = truncate(content, MAX_SNIPPET_LENGTH);
-  return ["```", snippet, "```"].join("\n");
-}
-
-function truncate(value: string, maxLength: number): string {
-  if (value.length <= maxLength) {
-    return value;
-  }
-  return `${value.slice(0, maxLength)}\n…`;
-}
-
-function formatResearchSection(content: string): string | null {
-  try {
-    const parsed = JSON.parse(content);
-    const sections: string[] = [];
-
-    if (parsed.context) {
-      sections.push("### Research summary");
-      sections.push(parsed.context);
-    }
-
-    if (parsed.questions?.length) {
-      sections.push("");
-      sections.push("### Questions needing answers");
-      for (const question of parsed.questions) {
-        sections.push(`- ${question.question ?? question}`);
-      }
-    }
-
-    if (parsed.answers?.length) {
-      sections.push("");
-      sections.push("### Answers provided");
-      for (const answer of parsed.answers) {
-        const questionId = answer.questionId
-          ? ` (Q: ${answer.questionId})`
-          : "";
-        sections.push(
-          `- ${answer.selectedOption || answer.customInput || "answer"}${questionId}`,
-        );
-      }
-    }
-
-    return sections.length ? sections.join("\n") : null;
-  } catch {
-    return null;
-  }
-}
-
-function summarizeTodos(content: string): string | null {
-  try {
-    const data = JSON.parse(content);
-    const total = data?.metadata?.total ?? data?.items?.length;
-    const completed =
-      data?.metadata?.completed ??
-      data?.items?.filter(
-        (item: { status?: string }) => item.status === "completed",
-      ).length;
-
-    const lines = [`Progress: ${completed}/${total} completed`];
-
-    if (data?.items?.length) {
-      for (const item of data.items) {
-        lines.push(`- [${item.status}] ${item.content}`);
-      }
-    }
-
-    return lines.join("\n");
-  } catch {
-    return null;
-  }
-}

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" };
-};