@posthog/agent 1.29.0 → 2.0.0

package/src/template-manager.ts

@@ -1,240 +0,0 @@
-import { existsSync, promises as fs } from "node:fs";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-import { Logger } from "./utils/logger";
-
-const logger = new Logger({ prefix: "[TemplateManager]" });
-
-export interface TemplateVariables {
-  task_id: string;
-  task_title: string;
-  task_description?: string;
-  date: string;
-  repository?: string;
-  [key: string]: string | undefined;
-}
-
-export class TemplateManager {
-  private templatesDir: string;
-
-  constructor() {
-    const __filename = fileURLToPath(import.meta.url);
-    const __dirname = dirname(__filename);
-
-    // Exhaustive list of possible template locations
-    const candidateDirs = [
-      // Standard build output (dist/src/template-manager.js -> dist/templates)
-      join(__dirname, "..", "templates"),
-
-      // If preserveModules creates nested structure (dist/src/template-manager.js -> dist/src/templates)
-      join(__dirname, "templates"),
-
-      // Development scenarios (src/template-manager.ts -> src/templates)
-      join(__dirname, "..", "..", "src", "templates"),
-
-      // Package root templates directory
-      join(__dirname, "..", "..", "templates"),
-
-      // When node_modules symlink or installed (node_modules/@posthog/agent/dist/src/... -> node_modules/@posthog/agent/dist/templates)
-      join(__dirname, "..", "..", "dist", "templates"),
-
-      // When consumed from node_modules deep in tree
-      join(__dirname, "..", "..", "..", "templates"),
-      join(__dirname, "..", "..", "..", "dist", "templates"),
-      join(__dirname, "..", "..", "..", "src", "templates"),
-
-      // When bundled by Vite/Webpack (e.g., .vite/build/index.js -> node_modules/@posthog/agent/dist/templates)
-      // Try to find node_modules from current location
-      join(
-        __dirname,
-        "..",
-        "node_modules",
-        "@posthog",
-        "agent",
-        "dist",
-        "templates",
-      ),
-      join(
-        __dirname,
-        "..",
-        "..",
-        "node_modules",
-        "@posthog",
-        "agent",
-        "dist",
-        "templates",
-      ),
-      join(
-        __dirname,
-        "..",
-        "..",
-        "..",
-        "node_modules",
-        "@posthog",
-        "agent",
-        "dist",
-        "templates",
-      ),
-    ];
-
-    const resolvedDir = candidateDirs.find((dir) => existsSync(dir));
-
-    if (!resolvedDir) {
-      logger.error("Could not find templates directory.");
-      logger.error(`Current file: ${__filename}`);
-      logger.error(`Current dir: ${__dirname}`);
-      logger.error(
-        `Tried: ${candidateDirs.map((d) => `\n  - ${d} (exists: ${existsSync(d)})`).join("")}`,
-      );
-    }
-
-    this.templatesDir = resolvedDir ?? candidateDirs[0];
-  }
-
-  private async loadTemplate(templateName: string): Promise<string> {
-    try {
-      const templatePath = join(this.templatesDir, templateName);
-      return await fs.readFile(templatePath, "utf8");
-    } catch (error) {
-      throw new Error(
-        `Failed to load template ${templateName} from ${this.templatesDir}: ${error}`,
-      );
-    }
-  }
-
-  private substituteVariables(
-    template: string,
-    variables: TemplateVariables,
-  ): string {
-    let result = template;
-
-    for (const [key, value] of Object.entries(variables)) {
-      if (value !== undefined) {
-        const placeholder = new RegExp(`{{${key}}}`, "g");
-        result = result.replace(placeholder, value);
-      }
-    }
-
-    result = result.replace(/{{[^}]+}}/g, "[PLACEHOLDER]");
-
-    return result;
-  }
-
-  async generatePlan(variables: TemplateVariables): Promise<string> {
-    const template = await this.loadTemplate("plan-template.md");
-    return this.substituteVariables(template, {
-      ...variables,
-      date: variables.date || new Date().toISOString().split("T")[0],
-    });
-  }
-
-  async generateCustomFile(
-    templateName: string,
-    variables: TemplateVariables,
-  ): Promise<string> {
-    const template = await this.loadTemplate(templateName);
-    return this.substituteVariables(template, {
-      ...variables,
-      date: variables.date || new Date().toISOString().split("T")[0],
-    });
-  }
-
-  async createTaskStructure(
-    taskId: string,
-    taskTitle: string,
-    options?: {
-      includePlan?: boolean;
-      additionalFiles?: Array<{
-        name: string;
-        template?: string;
-        content?: string;
-      }>;
-    },
-  ): Promise<
-    Array<{
-      name: string;
-      content: string;
-      type: "plan" | "context" | "reference" | "output";
-    }>
-  > {
-    const files: Array<{
-      name: string;
-      content: string;
-      type: "plan" | "context" | "reference" | "output";
-    }> = [];
-
-    const variables: TemplateVariables = {
-      task_id: taskId,
-      task_title: taskTitle,
-      date: new Date().toISOString().split("T")[0],
-    };
-
-    // Generate plan file if requested
-    if (options?.includePlan !== false) {
-      const planContent = await this.generatePlan(variables);
-      files.push({
-        name: "plan.md",
-        content: planContent,
-        type: "plan",
-      });
-    }
-
-    if (options?.additionalFiles) {
-      for (const file of options.additionalFiles) {
-        let content: string;
-
-        if (file.template) {
-          content = await this.generateCustomFile(file.template, variables);
-        } else if (file.content) {
-          content = this.substituteVariables(file.content, variables);
-        } else {
-          content = `# ${file.name}\n\nPlaceholder content for ${file.name}`;
-        }
-
-        files.push({
-          name: file.name,
-          content,
-          type: file.name.includes("context") ? "context" : "reference",
-        });
-      }
-    }
-
-    return files;
-  }
-
-  generatePostHogReadme(): string {
-    return `# PostHog Task Files
-
-This directory contains task-related files generated by the PostHog Agent.
-
-## Structure
-
-Each task has its own subdirectory: \`.posthog/{task-id}/\`
-
-### Common Files
-
-- **plan.md** - Implementation plan generated during planning phase
-- **Supporting files** - Any additional files added for task context
-- **artifacts/** - Generated files, outputs, and temporary artifacts
-
-### Usage
-
-These files are:
-- Version controlled alongside your code
-- Used by the PostHog Agent for context
-- Available for review in pull requests
-- Organized by task ID for easy reference
-
-### Gitignore
-
-Customize \`.posthog/.gitignore\` to control which files are committed:
-- Include plans and documentation by default
-- Exclude temporary files and sensitive data
-- Customize based on your team's needs
-
----
-
-*Generated by PostHog Agent*
-`;
-  }
-}

package/src/templates/plan-template.md

@@ -1,41 +0,0 @@
-# Implementation Plan: {{task_title}}
-
-**Task ID:** {{task_id}}  
-**Generated:** {{date}}
-
-## Summary
-
-Brief description of what will be implemented and the overall approach.
-
-## Implementation Steps
-
-### 1. Analysis
-- [ ] Identify relevant files and components
-- [ ] Review existing patterns and constraints
-
-### 2. Changes Required
-- [ ] Files to create/modify
-- [ ] Dependencies to add/update
-
-### 3. Implementation
-- [ ] Core functionality changes
-- [ ] Tests and validation
-- [ ] Documentation updates
-
-## File Changes
-
-### New Files
-```
-path/to/new/file.ts - Purpose
-```
-
-### Modified Files
-```
-path/to/existing/file.ts - Changes needed
-```
-
-## Considerations
-
-- Key architectural decisions
-- Potential risks and mitigation
-- Testing approach

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