@posthog/agent 1.24.0 → 1.24.2

package/src/template-manager.ts

@@ -1,6 +1,6 @@
-import { existsSync, promises as fs } from "node:fs";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
+import { promises as fs, existsSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
 
 export interface TemplateVariables {
   task_id: string;
@@ -21,71 +21,39 @@ 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];
@@ -94,95 +62,74 @@ 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<{
-        name: string;
-        template?: string;
-        content?: string;
-      }>;
-    },
-  ): Promise<
-    Array<{
-      name: string;
-      content: string;
-      type: "plan" | "context" | "reference" | "output";
-    }>
-  > {
-    const files: Array<{
+  async createTaskStructure(taskId: string, taskTitle: string, options?: {
+    includePlan?: boolean;
+    additionalFiles?: Array<{
       name: string;
-      content: string;
-      type: "plan" | "context" | "reference" | "output";
-    }> = [];
-
+      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],
+      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) {
@@ -194,7 +141,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,19 +24,18 @@ 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,
@@ -46,7 +45,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),
       });
@@ -55,7 +54,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,
@@ -64,12 +63,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,
@@ -82,9 +81,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 || '',
         });
       }
     }
@@ -94,11 +93,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,
@@ -112,47 +111,43 @@ 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,
@@ -160,7 +155,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
     );
   }
 }