@posthog/agent 1.22.0 → 1.24.0

package/src/template-manager.ts

@@ -1,6 +1,6 @@
-import { promises as fs, existsSync } from 'fs';
-import { join, dirname } from 'path';
-import { fileURLToPath } from 'url';
+import { existsSync, promises as fs } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
 
 export interface TemplateVariables {
   task_id: string;
@@ -21,39 +21,71 @@ export class TemplateManager {
     // Exhaustive list of possible template locations
     const candidateDirs = [
       // Standard build output (dist/src/template-manager.js -> dist/templates)
-      join(__dirname, '..', 'templates'),
+      join(__dirname, "..", "templates"),
 
       // If preserveModules creates nested structure (dist/src/template-manager.js -> dist/src/templates)
-      join(__dirname, 'templates'),
+      join(__dirname, "templates"),
 
       // Development scenarios (src/template-manager.ts -> src/templates)
-      join(__dirname, '..', '..', 'src', 'templates'),
+      join(__dirname, "..", "..", "src", "templates"),
 
       // Package root templates directory
-      join(__dirname, '..', '..', 'templates'),
+      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'),
+      join(__dirname, "..", "..", "dist", "templates"),
 
       // When consumed from node_modules deep in tree
-      join(__dirname, '..', '..', '..', 'templates'),
-      join(__dirname, '..', '..', '..', 'dist', 'templates'),
-      join(__dirname, '..', '..', '..', 'src', 'templates'),
+      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'),
+      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) {
-      console.error('[TemplateManager] Could not find templates directory.');
-      console.error('[TemplateManager] Current file:', __filename);
-      console.error('[TemplateManager] Current dir:', __dirname);
-      console.error('[TemplateManager] Tried:', candidateDirs.map(d => `\n  - ${d} (exists: ${existsSync(d)})`).join(''));
+      console.error("[TemplateManager] Could not find templates directory.");
+      console.error("[TemplateManager] Current file:", __filename);
+      console.error("[TemplateManager] Current dir:", __dirname);
+      console.error(
+        "[TemplateManager] Tried:",
+        candidateDirs
+          .map((d) => `\n  - ${d} (exists: ${existsSync(d)})`)
+          .join(""),
+      );
     }
 
     this.templatesDir = resolvedDir ?? candidateDirs[0];
@@ -62,74 +94,95 @@ export class TemplateManager {
   private async loadTemplate(templateName: string): Promise<string> {
     try {
       const templatePath = join(this.templatesDir, templateName);
-      return await fs.readFile(templatePath, 'utf8');
+      return await fs.readFile(templatePath, "utf8");
     } catch (error) {
-      throw new Error(`Failed to load template ${templateName} from ${this.templatesDir}: ${error}`);
+      throw new Error(
+        `Failed to load template ${templateName} from ${this.templatesDir}: ${error}`,
+      );
     }
   }
 
-  private substituteVariables(template: string, variables: TemplateVariables): string {
+  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');
+        const placeholder = new RegExp(`{{${key}}}`, "g");
         result = result.replace(placeholder, value);
       }
     }
-    
-    result = result.replace(/{{[^}]+}}/g, '[PLACEHOLDER]');
-    
+
+    result = result.replace(/{{[^}]+}}/g, "[PLACEHOLDER]");
+
     return result;
   }
 
   async generatePlan(variables: TemplateVariables): Promise<string> {
-    const template = await this.loadTemplate('plan-template.md');
+    const template = await this.loadTemplate("plan-template.md");
     return this.substituteVariables(template, {
       ...variables,
-      date: variables.date || new Date().toISOString().split('T')[0]
+      date: variables.date || new Date().toISOString().split("T")[0],
     });
   }
 
-  async generateCustomFile(templateName: string, variables: TemplateVariables): Promise<string> {
+  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]
+      date: variables.date || new Date().toISOString().split("T")[0],
     });
   }
 
-  async createTaskStructure(taskId: string, taskTitle: string, options?: {
-    includePlan?: boolean;
-    additionalFiles?: Array<{
+  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;
-      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' }> = [];
-    
+      content: string;
+      type: "plan" | "context" | "reference" | "output";
+    }> = [];
+
     const variables: TemplateVariables = {
       task_id: taskId,
       task_title: taskTitle,
-      date: new Date().toISOString().split('T')[0]
+      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',
+        name: "plan.md",
         content: planContent,
-        type: 'plan'
+        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) {
@@ -141,7 +194,7 @@ export class TemplateManager {
         files.push({
           name: file.name,
           content,
-          type: file.name.includes('context') ? 'context' : 'reference'
+          type: file.name.includes("context") ? "context" : "reference",
         });
       }
     }

package/src/todo-manager.ts

@@ -1,9 +1,9 @@
-import type { PostHogFileManager } from './file-manager.js';
-import { Logger } from './utils/logger.js';
+import type { PostHogFileManager } from "./file-manager.js";
+import { Logger } from "./utils/logger.js";
 
 export interface TodoItem {
   content: string;
-  status: 'pending' | 'in_progress' | 'completed';
+  status: "pending" | "in_progress" | "completed";
   activeForm: string;
 }
 
@@ -24,18 +24,19 @@ export class TodoManager {
 
   constructor(fileManager: PostHogFileManager, logger?: Logger) {
     this.fileManager = fileManager;
-    this.logger = logger || new Logger({ debug: false, prefix: '[TodoManager]' });
+    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');
+      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', {
+      this.logger.debug("Loaded todos", {
         taskId,
         total: parsed.metadata.total,
         pending: parsed.metadata.pending,
@@ -45,7 +46,7 @@ export class TodoManager {
 
       return parsed;
     } catch (error) {
-      this.logger.debug('Failed to read todos.json', {
+      this.logger.debug("Failed to read todos.json", {
         taskId,
         error: error instanceof Error ? error.message : String(error),
       });
@@ -54,7 +55,7 @@ export class TodoManager {
   }
 
   async writeTodos(taskId: string, todos: TodoList): Promise<void> {
-    this.logger.debug('Writing todos', {
+    this.logger.debug("Writing todos", {
       taskId,
       total: todos.metadata.total,
       pending: todos.metadata.pending,
@@ -63,12 +64,12 @@ export class TodoManager {
     });
 
     await this.fileManager.writeTaskFile(taskId, {
-      name: 'todos.json',
+      name: "todos.json",
       content: JSON.stringify(todos, null, 2),
-      type: 'artifact',
+      type: "artifact",
     });
 
-    this.logger.info('Todos saved', {
+    this.logger.info("Todos saved", {
       taskId,
       total: todos.metadata.total,
       completed: todos.metadata.completed,
@@ -81,9 +82,9 @@ export class TodoManager {
     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 || '',
+          content: todo.content || "",
+          status: todo.status || "pending",
+          activeForm: todo.activeForm || todo.content || "",
         });
       }
     }
@@ -93,11 +94,11 @@ export class TodoManager {
     return { items, metadata };
   }
 
-  private calculateMetadata(items: TodoItem[]): TodoList['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;
+    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,
@@ -111,43 +112,47 @@ export class TodoManager {
   async getTodoContext(taskId: string): Promise<string> {
     const todos = await this.readTodos(taskId);
     if (!todos || todos.items.length === 0) {
-      return '';
+      return "";
     }
 
-    const lines: string[] = ['## Previous Todo List\n'];
-    lines.push('You previously created the following todo list:\n');
+    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' ? '▶' : '○';
+        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`
+      `\nProgress: ${todos.metadata.completed}/${todos.metadata.total} completed\n`,
     );
 
-    return lines.join('\n');
+    return lines.join("\n");
   }
 
   // check for TodoWrite tool call and persist if found
   async checkAndPersistFromMessage(
     message: any,
-    taskId: string
+    taskId: string,
   ): Promise<TodoList | null> {
-    if (message.type !== 'assistant' || !message.message?.content) {
+    if (message.type !== "assistant" || !message.message?.content) {
       return null;
     }
 
     for (const block of message.message.content) {
-      if (block.type === 'tool_use' && block.name === 'TodoWrite') {
+      if (block.type === "tool_use" && block.name === "TodoWrite") {
         try {
-          this.logger.info('TodoWrite detected, persisting todos', { taskId });
+          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', {
+          this.logger.info("Persisted todos successfully", {
             taskId,
             total: todoList.metadata.total,
             completed: todoList.metadata.completed,
@@ -155,7 +160,7 @@ export class TodoManager {
 
           return todoList;
         } catch (error) {
-          this.logger.error('Failed to persist todos', {
+          this.logger.error("Failed to persist todos", {
             taskId,
             error: error instanceof Error ? error.message : String(error),
           });

package/src/tools/registry.ts

@@ -1,4 +1,4 @@
-import type { Tool } from './types.js';
+import type { Tool } from "./types.js";
 
 /**
  * Registry of all known tools with their metadata.
@@ -6,88 +6,88 @@ import type { Tool } from './types.js';
  */
 const TOOL_DEFINITIONS: Record<string, Tool> = {
   // Filesystem tools
-  'Read': {
-    name: 'Read',
-    category: 'filesystem',
-    description: 'Read file contents from the filesystem',
+  Read: {
+    name: "Read",
+    category: "filesystem",
+    description: "Read file contents from the filesystem",
   },
-  'Write': {
-    name: 'Write',
-    category: 'filesystem',
-    description: 'Write content to a file',
+  Write: {
+    name: "Write",
+    category: "filesystem",
+    description: "Write content to a file",
   },
-  'Edit': {
-    name: 'Edit',
-    category: 'filesystem',
-    description: 'Edit file with find and replace operations',
+  Edit: {
+    name: "Edit",
+    category: "filesystem",
+    description: "Edit file with find and replace operations",
   },
-  'Glob': {
-    name: 'Glob',
-    category: 'filesystem',
-    description: 'Find files matching a pattern',
+  Glob: {
+    name: "Glob",
+    category: "filesystem",
+    description: "Find files matching a pattern",
   },
-  'NotebookEdit': {
-    name: 'NotebookEdit',
-    category: 'filesystem',
-    description: 'Edit Jupyter notebook cells',
+  NotebookEdit: {
+    name: "NotebookEdit",
+    category: "filesystem",
+    description: "Edit Jupyter notebook cells",
   },
 
   // Shell tools
-  'Bash': {
-    name: 'Bash',
-    category: 'shell',
-    description: 'Execute bash commands',
+  Bash: {
+    name: "Bash",
+    category: "shell",
+    description: "Execute bash commands",
   },
-  'BashOutput': {
-    name: 'BashOutput',
-    category: 'shell',
-    description: 'Read output from a background bash process',
+  BashOutput: {
+    name: "BashOutput",
+    category: "shell",
+    description: "Read output from a background bash process",
   },
-  'KillShell': {
-    name: 'KillShell',
-    category: 'shell',
-    description: 'Terminate 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',
+  WebFetch: {
+    name: "WebFetch",
+    category: "web",
+    description: "Fetch content from a URL",
   },
-  'WebSearch': {
-    name: 'WebSearch',
-    category: 'web',
-    description: 'Search the web',
+  WebSearch: {
+    name: "WebSearch",
+    category: "web",
+    description: "Search the web",
   },
 
   // Search tools
-  'Grep': {
-    name: 'Grep',
-    category: 'search',
-    description: 'Search file contents using patterns',
+  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',
+  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',
+  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',
+  ExitPlanMode: {
+    name: "ExitPlanMode",
+    category: "assistant",
+    description: "Exit plan mode and present plan to user",
   },
-  'SlashCommand': {
-    name: 'SlashCommand',
-    category: 'assistant',
-    description: 'Execute a slash command',
+  SlashCommand: {
+    name: "SlashCommand",
+    category: "assistant",
+    description: "Execute a slash command",
   },
 };
 
@@ -123,7 +123,7 @@ export class ToolRegistry {
    */
   getByCategory(category: string): Tool[] {
     return Object.values(TOOL_DEFINITIONS).filter(
-      (tool) => tool.category === category
+      (tool) => tool.category === category,
     );
   }
 }