@posthog/agent 1.30.0 → 2.0.1

package/src/template-manager.ts

@@ -1,236 +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.
-
-## 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 for task context and planning
-- 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
-`;
-  }
-}

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/todo-manager.ts

@@ -1,180 +0,0 @@
-import type { PostHogFileManager } from "./file-manager.js";
-import { Logger } from "./utils/logger.js";
-
-export interface TodoItem {
-  content: string;
-  status: "pending" | "in_progress" | "completed";
-  activeForm: string;
-}
-
-export interface TodoList {
-  items: TodoItem[];
-  metadata: {
-    total: number;
-    pending: number;
-    in_progress: number;
-    completed: number;
-    last_updated: string;
-  };
-}
-
-export class TodoManager {
-  private fileManager: PostHogFileManager;
-  private logger: Logger;
-
-  constructor(fileManager: PostHogFileManager, logger?: Logger) {
-    this.fileManager = fileManager;
-    this.logger =
-      logger || new Logger({ debug: false, prefix: "[TodoManager]" });
-  }
-
-  async readTodos(taskId: string): Promise<TodoList | null> {
-    try {
-      const content = await this.fileManager.readTaskFile(taskId, "todos.json");
-      if (!content) {
-        return null;
-      }
-
-      const parsed = JSON.parse(content) as TodoList;
-      this.logger.debug("Loaded todos", {
-        taskId,
-        total: parsed.metadata.total,
-        pending: parsed.metadata.pending,
-        in_progress: parsed.metadata.in_progress,
-        completed: parsed.metadata.completed,
-      });
-
-      return parsed;
-    } catch (error) {
-      this.logger.debug("Failed to read todos.json", {
-        taskId,
-        error: error instanceof Error ? error.message : String(error),
-      });
-      return null;
-    }
-  }
-
-  async writeTodos(taskId: string, todos: TodoList): Promise<void> {
-    this.logger.debug("Writing todos", {
-      taskId,
-      total: todos.metadata.total,
-      pending: todos.metadata.pending,
-      in_progress: todos.metadata.in_progress,
-      completed: todos.metadata.completed,
-    });
-
-    await this.fileManager.writeTaskFile(taskId, {
-      name: "todos.json",
-      content: JSON.stringify(todos, null, 2),
-      type: "artifact",
-    });
-
-    this.logger.info("Todos saved", {
-      taskId,
-      total: todos.metadata.total,
-      completed: todos.metadata.completed,
-    });
-  }
-
-  parseTodoWriteInput(toolInput: Record<string, unknown>): TodoList {
-    const items: TodoItem[] = [];
-
-    if (toolInput.todos && Array.isArray(toolInput.todos)) {
-      for (const todo of toolInput.todos) {
-        items.push({
-          content: todo.content || "",
-          status: todo.status || "pending",
-          activeForm: todo.activeForm || todo.content || "",
-        });
-      }
-    }
-
-    const metadata = this.calculateMetadata(items);
-
-    return { items, metadata };
-  }
-
-  private calculateMetadata(items: TodoItem[]): TodoList["metadata"] {
-    const total = items.length;
-    const pending = items.filter((t) => t.status === "pending").length;
-    const in_progress = items.filter((t) => t.status === "in_progress").length;
-    const completed = items.filter((t) => t.status === "completed").length;
-
-    return {
-      total,
-      pending,
-      in_progress,
-      completed,
-      last_updated: new Date().toISOString(),
-    };
-  }
-
-  async getTodoContext(taskId: string): Promise<string> {
-    const todos = await this.readTodos(taskId);
-    if (!todos || todos.items.length === 0) {
-      return "";
-    }
-
-    const lines: string[] = ["## Previous Todo List\n"];
-    lines.push("You previously created the following todo list:\n");
-
-    for (const item of todos.items) {
-      const statusIcon =
-        item.status === "completed"
-          ? "✓"
-          : item.status === "in_progress"
-            ? "▶"
-            : "○";
-      lines.push(`${statusIcon} [${item.status}] ${item.content}`);
-    }
-
-    lines.push(
-      `\nProgress: ${todos.metadata.completed}/${todos.metadata.total} completed\n`,
-    );
-
-    return lines.join("\n");
-  }
-
-  // check for TodoWrite tool call and persist if found
-  async checkAndPersistFromMessage(
-    message: Record<string, unknown>,
-    taskId: string,
-  ): Promise<TodoList | null> {
-    if (
-      message.type !== "assistant" ||
-      typeof message.message !== "object" ||
-      !message.message ||
-      !("content" in message.message) ||
-      !Array.isArray(message.message.content)
-    ) {
-      return null;
-    }
-
-    for (const block of message.message.content) {
-      if (block.type === "tool_use" && block.name === "TodoWrite") {
-        try {
-          this.logger.info("TodoWrite detected, persisting todos", { taskId });
-
-          const todoList = this.parseTodoWriteInput(block.input);
-          await this.writeTodos(taskId, todoList);
-
-          this.logger.info("Persisted todos successfully", {
-            taskId,
-            total: todoList.metadata.total,
-            completed: todoList.metadata.completed,
-          });
-
-          return todoList;
-        } catch (error) {
-          this.logger.error("Failed to persist todos", {
-            taskId,
-            error: error instanceof Error ? error.message : String(error),
-          });
-          return null;
-        }
-      }
-    }
-
-    return null;
-  }
-}

package/src/tools/registry.ts

@@ -1,129 +0,0 @@
-import type { Tool } from "./types.js";
-
-/**
- * Registry of all known tools with their metadata.
- * Maps tool names to their definitions.
- */
-const TOOL_DEFINITIONS: Record<string, Tool> = {
-  // Filesystem tools
-  Read: {
-    name: "Read",
-    category: "filesystem",
-    description: "Read file contents from the filesystem",
-  },
-  Write: {
-    name: "Write",
-    category: "filesystem",
-    description: "Write content to a file",
-  },
-  Edit: {
-    name: "Edit",
-    category: "filesystem",
-    description: "Edit file with find and replace operations",
-  },
-  Glob: {
-    name: "Glob",
-    category: "filesystem",
-    description: "Find files matching a pattern",
-  },
-  NotebookEdit: {
-    name: "NotebookEdit",
-    category: "filesystem",
-    description: "Edit Jupyter notebook cells",
-  },
-
-  // Shell tools
-  Bash: {
-    name: "Bash",
-    category: "shell",
-    description: "Execute bash commands",
-  },
-  BashOutput: {
-    name: "BashOutput",
-    category: "shell",
-    description: "Read output from a background bash process",
-  },
-  KillShell: {
-    name: "KillShell",
-    category: "shell",
-    description: "Terminate a background bash process",
-  },
-
-  // Web tools
-  WebFetch: {
-    name: "WebFetch",
-    category: "web",
-    description: "Fetch content from a URL",
-  },
-  WebSearch: {
-    name: "WebSearch",
-    category: "web",
-    description: "Search the web",
-  },
-
-  // Search tools
-  Grep: {
-    name: "Grep",
-    category: "search",
-    description: "Search file contents using patterns",
-  },
-
-  // Assistant tools
-  Task: {
-    name: "Task",
-    category: "assistant",
-    description: "Launch a specialized agent for a sub-task",
-  },
-  TodoWrite: {
-    name: "TodoWrite",
-    category: "assistant",
-    description: "Manage task list and track progress",
-  },
-  ExitPlanMode: {
-    name: "ExitPlanMode",
-    category: "assistant",
-    description: "Exit plan mode and present plan to user",
-  },
-  SlashCommand: {
-    name: "SlashCommand",
-    category: "assistant",
-    description: "Execute a slash command",
-  },
-};
-
-/**
- * Tool registry for looking up tool definitions by name.
- * Provides metadata about tools for UI consumption.
- */
-export class ToolRegistry {
-  /**
-   * Get tool definition by name.
-   * Returns undefined if tool is not recognized.
-   */
-  get(name: string): Tool | undefined {
-    return TOOL_DEFINITIONS[name];
-  }
-
-  /**
-   * Get all registered tools.
-   */
-  getAll(): Tool[] {
-    return Object.values(TOOL_DEFINITIONS);
-  }
-
-  /**
-   * Check if a tool name is registered.
-   */
-  has(name: string): boolean {
-    return name in TOOL_DEFINITIONS;
-  }
-
-  /**
-   * Get all tools in a specific category.
-   */
-  getByCategory(category: string): Tool[] {
-    return Object.values(TOOL_DEFINITIONS).filter(
-      (tool) => tool.category === category,
-    );
-  }
-}

package/src/tools/types.ts

@@ -1,127 +0,0 @@
-/**
- * Tool category classification for grouping related tools.
- * Makes it easier for UIs to filter and display tools by function.
- */
-export type ToolCategory =
-  | "filesystem" // File operations: Read, Write, Edit, Glob, NotebookEdit
-  | "shell" // Shell operations: Bash, BashOutput, KillShell
-  | "web" // Web operations: WebFetch, WebSearch
-  | "assistant" // Assistant operations: Task, TodoWrite, ExitPlanMode
-  | "search" // Search operations: Grep
-  | "unknown"; // Unknown or unrecognized tools
-
-/**
- * Base tool interface representing a tool that can be called by the agent.
- * Each tool has a name, category, and human-readable description.
- */
-export interface Tool {
-  name: string;
-  category: ToolCategory;
-  description: string;
-}
-
-// Filesystem tools
-
-export interface ReadTool extends Tool {
-  name: "Read";
-  category: "filesystem";
-}
-
-export interface WriteTool extends Tool {
-  name: "Write";
-  category: "filesystem";
-}
-
-export interface EditTool extends Tool {
-  name: "Edit";
-  category: "filesystem";
-}
-
-export interface GlobTool extends Tool {
-  name: "Glob";
-  category: "filesystem";
-}
-
-export interface NotebookEditTool extends Tool {
-  name: "NotebookEdit";
-  category: "filesystem";
-}
-
-// Shell tools
-
-export interface BashTool extends Tool {
-  name: "Bash";
-  category: "shell";
-}
-
-export interface BashOutputTool extends Tool {
-  name: "BashOutput";
-  category: "shell";
-}
-
-export interface KillShellTool extends Tool {
-  name: "KillShell";
-  category: "shell";
-}
-
-// Web tools
-
-export interface WebFetchTool extends Tool {
-  name: "WebFetch";
-  category: "web";
-}
-
-export interface WebSearchTool extends Tool {
-  name: "WebSearch";
-  category: "web";
-}
-
-// Search tools
-
-export interface GrepTool extends Tool {
-  name: "Grep";
-  category: "search";
-}
-
-// Assistant tools
-
-export interface TaskTool extends Tool {
-  name: "Task";
-  category: "assistant";
-}
-
-export interface TodoWriteTool extends Tool {
-  name: "TodoWrite";
-  category: "assistant";
-}
-
-export interface ExitPlanModeTool extends Tool {
-  name: "ExitPlanMode";
-  category: "assistant";
-}
-
-export interface SlashCommandTool extends Tool {
-  name: "SlashCommand";
-  category: "assistant";
-}
-
-/**
- * Union type of all known tool types.
- * Useful for discriminated unions and type narrowing.
- */
-export type KnownTool =
-  | ReadTool
-  | WriteTool
-  | EditTool
-  | GlobTool
-  | NotebookEditTool
-  | BashTool
-  | BashOutputTool
-  | KillShellTool
-  | WebFetchTool
-  | WebSearchTool
-  | GrepTool
-  | TaskTool
-  | TodoWriteTool
-  | ExitPlanModeTool
-  | SlashCommandTool;