@posthog/agent 1.24.2 → 1.26.0

package/src/agents/execution.ts

@@ -34,4 +34,4 @@ Before completing the task, verify:
 
 <output_format>
 Provide a concise summary of changes made when finished.
-</output_format>`;
+</output_format>`;

package/src/agents/planning.ts

@@ -57,4 +57,4 @@ If research findings, context files, or reference materials are provided:
 - Follow patterns and approaches identified in research
 - Build upon or refine any existing planning work
 - Reference specific files and components mentioned in context
-</context_integration>`;
+</context_integration>`;

package/src/agents/research.ts

@@ -158,4 +158,3 @@ Reason: Options request user input instead of being actionable choices. Should b
 Reason: "Let me specify" requires user input. Should be "Primary blue (#0066FF, existing theme)" or "Secondary gray (#6B7280, existing theme)"
 </bad_example>
 </question_examples>`;
-

package/src/file-manager.ts

@@ -1,18 +1,19 @@
-import { promises as fs } from 'fs';
-import { join, extname } from 'path';
-import type { SupportingFile, ResearchEvaluation } from './types.js';
-import { Logger } from './utils/logger.js';
+import { promises as fs } from "node:fs";
+import { extname, join } from "node:path";
+import z from "zod";
+import type { ResearchEvaluation, SupportingFile } from "./types.js";
+import { Logger } from "./utils/logger.js";
 
 export interface TaskFile {
   name: string;
   content: string;
-  type: 'plan' | 'context' | 'reference' | 'output' | 'artifact';
+  type: "plan" | "context" | "reference" | "output" | "artifact";
 }
 
 export interface LocalArtifact {
   name: string;
   content: string;
-  type: TaskFile['type'];
+  type: TaskFile["type"];
   contentType: string;
   size: number;
 }
@@ -23,11 +24,12 @@ export class PostHogFileManager {
 
   constructor(repositoryPath: string, logger?: Logger) {
     this.repositoryPath = repositoryPath;
-    this.logger = logger || new Logger({ debug: false, prefix: '[FileManager]' });
+    this.logger =
+      logger || new Logger({ debug: false, prefix: "[FileManager]" });
   }
 
   private getTaskDirectory(taskId: string): string {
-    return join(this.repositoryPath, '.posthog', taskId);
+    return join(this.repositoryPath, ".posthog", taskId);
   }
 
   private getTaskFilePath(taskId: string, fileName: string): string {
@@ -47,23 +49,23 @@ export class PostHogFileManager {
     await this.ensureTaskDirectory(taskId);
     const filePath = this.getTaskFilePath(taskId, file.name);
 
-    this.logger.debug('Writing task file', {
+    this.logger.debug("Writing task file", {
       filePath,
       contentLength: file.content.length,
-      contentType: typeof file.content
+      contentType: typeof file.content,
     });
 
-    await fs.writeFile(filePath, file.content, 'utf8');
+    await fs.writeFile(filePath, file.content, "utf8");
 
-    this.logger.debug('File written successfully', { filePath });
+    this.logger.debug("File written successfully", { filePath });
   }
 
   async readTaskFile(taskId: string, fileName: string): Promise<string | null> {
     try {
       const filePath = this.getTaskFilePath(taskId, fileName);
-      return await fs.readFile(filePath, 'utf8');
+      return await fs.readFile(filePath, "utf8");
     } catch (error) {
-      if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
+      if ((error as NodeJS.ErrnoException).code === "ENOENT") {
         return null;
       }
       throw error;
@@ -74,9 +76,9 @@ export class PostHogFileManager {
     try {
       const taskDir = this.getTaskDirectory(taskId);
       const files = await fs.readdir(taskDir);
-      return files.filter(file => !file.startsWith('.'));
+      return files.filter((file) => !file.startsWith("."));
     } catch (error) {
-      if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
+      if ((error as NodeJS.ErrnoException).code === "ENOENT") {
         return [];
       }
       throw error;
@@ -88,7 +90,7 @@ export class PostHogFileManager {
       const filePath = this.getTaskFilePath(taskId, fileName);
       await fs.unlink(filePath);
     } catch (error) {
-      if ((error as NodeJS.ErrnoException).code !== 'ENOENT') {
+      if ((error as NodeJS.ErrnoException).code !== "ENOENT") {
         throw error;
       }
     }
@@ -109,7 +111,7 @@ export class PostHogFileManager {
       const taskDir = this.getTaskDirectory(taskId);
       await fs.rm(taskDir, { recursive: true, force: true });
     } catch (error) {
-      if ((error as NodeJS.ErrnoException).code !== 'ENOENT') {
+      if ((error as NodeJS.ErrnoException).code !== "ENOENT") {
         throw error;
       }
     }
@@ -117,51 +119,51 @@ export class PostHogFileManager {
 
   // Convenience methods for common file types
   async writePlan(taskId: string, plan: string): Promise<void> {
-    this.logger.debug('Writing plan', {
+    this.logger.debug("Writing plan", {
       taskId,
       planLength: plan.length,
-      contentPreview: plan.substring(0, 200)
+      contentPreview: plan.substring(0, 200),
     });
 
     await this.writeTaskFile(taskId, {
-      name: 'plan.md',
+      name: "plan.md",
       content: plan,
-      type: 'plan'
+      type: "plan",
     });
 
-    this.logger.info('Plan file written', { taskId });
+    this.logger.info("Plan file written", { taskId });
   }
 
   async readPlan(taskId: string): Promise<string | null> {
-    return await this.readTaskFile(taskId, 'plan.md');
+    return await this.readTaskFile(taskId, "plan.md");
   }
 
   async writeContext(taskId: string, context: string): Promise<void> {
     await this.writeTaskFile(taskId, {
-      name: 'context.md',
+      name: "context.md",
       content: context,
-      type: 'context'
+      type: "context",
     });
   }
 
   async readContext(taskId: string): Promise<string | null> {
-    return await this.readTaskFile(taskId, 'context.md');
+    return await this.readTaskFile(taskId, "context.md");
   }
 
   async writeRequirements(taskId: string, requirements: string): Promise<void> {
     await this.writeTaskFile(taskId, {
-      name: 'requirements.md',
+      name: "requirements.md",
       content: requirements,
-      type: 'reference'
+      type: "reference",
     });
   }
 
   async readRequirements(taskId: string): Promise<string | null> {
-    return await this.readTaskFile(taskId, 'requirements.md');
+    return await this.readTaskFile(taskId, "requirements.md");
   }
 
   async writeResearch(taskId: string, data: ResearchEvaluation): Promise<void> {
-    this.logger.debug('Writing research', {
+    this.logger.debug("Writing research", {
       taskId,
       score: data.actionabilityScore,
       hasQuestions: !!data.questions,
@@ -170,13 +172,13 @@ export class PostHogFileManager {
     });
 
     await this.writeTaskFile(taskId, {
-      name: 'research.json',
+      name: "research.json",
       content: JSON.stringify(data, null, 2),
-      type: 'artifact'
+      type: "artifact",
     });
 
-    this.logger.info('Research file written', { 
-      taskId, 
+    this.logger.info("Research file written", {
+      taskId,
       score: data.actionabilityScore,
       hasQuestions: !!data.questions,
       answered: data.answered ?? false,
@@ -185,40 +187,48 @@ export class PostHogFileManager {
 
   async readResearch(taskId: string): Promise<ResearchEvaluation | null> {
     try {
-      const content = await this.readTaskFile(taskId, 'research.json');
-      return content ? JSON.parse(content) as ResearchEvaluation : null;
+      const content = await this.readTaskFile(taskId, "research.json");
+      return content ? (JSON.parse(content) as ResearchEvaluation) : null;
     } catch (error) {
-      this.logger.debug('Failed to parse research.json', { error });
+      this.logger.debug("Failed to parse research.json", { error });
       return null;
     }
   }
 
-  async writeTodos(taskId: string, data: any): Promise<void> {
-    this.logger.debug('Writing todos', {
+  async writeTodos(taskId: string, data: unknown): Promise<void> {
+    const todos = z.object({
+      metadata: z.object({
+        total: z.number(),
+        completed: z.number(),
+      }),
+    });
+
+    const validatedData = todos.parse(data);
+    this.logger.debug("Writing todos", {
       taskId,
-      total: data.metadata?.total ?? 0,
-      completed: data.metadata?.completed ?? 0,
+      total: validatedData.metadata?.total ?? 0,
+      completed: validatedData.metadata?.completed ?? 0,
     });
 
     await this.writeTaskFile(taskId, {
-      name: 'todos.json',
-      content: JSON.stringify(data, null, 2),
-      type: 'artifact'
+      name: "todos.json",
+      content: JSON.stringify(validatedData, null, 2),
+      type: "artifact",
     });
 
-    this.logger.info('Todos file written', {
+    this.logger.info("Todos file written", {
       taskId,
-      total: data.metadata?.total ?? 0,
-      completed: data.metadata?.completed ?? 0,
+      total: validatedData.metadata?.total ?? 0,
+      completed: validatedData.metadata?.completed ?? 0,
     });
   }
 
-  async readTodos(taskId: string): Promise<any | null> {
+  async readTodos(taskId: string): Promise<unknown | null> {
     try {
-      const content = await this.readTaskFile(taskId, 'todos.json');
+      const content = await this.readTaskFile(taskId, "todos.json");
       return content ? JSON.parse(content) : null;
     } catch (error) {
-      this.logger.debug('Failed to parse todos.json', { error });
+      this.logger.debug("Failed to parse todos.json", { error });
       return null;
     }
   }
@@ -226,22 +236,22 @@ export class PostHogFileManager {
   async getTaskFiles(taskId: string): Promise<SupportingFile[]> {
     const fileNames = await this.listTaskFiles(taskId);
     const files: SupportingFile[] = [];
-    
+
     for (const fileName of fileNames) {
       const content = await this.readTaskFile(taskId, fileName);
       if (content !== null) {
         // Determine type based on file name
         const type = this.resolveFileType(fileName);
-        
+
         files.push({
           name: fileName,
           content,
           type,
-          created_at: new Date().toISOString() // Could be enhanced with file stats
+          created_at: new Date().toISOString(), // Could be enhanced with file stats
         });
       }
     }
-    
+
     return files;
   }
 
@@ -257,7 +267,7 @@ export class PostHogFileManager {
 
       const type = this.resolveFileType(fileName);
       const contentType = this.inferContentType(fileName);
-      const size = Buffer.byteLength(content, 'utf8');
+      const size = Buffer.byteLength(content, "utf8");
 
       artifacts.push({
         name: fileName,
@@ -271,26 +281,26 @@ export class PostHogFileManager {
     return artifacts;
   }
 
-  private resolveFileType(fileName: string): TaskFile['type'] {
-    if (fileName === 'plan.md') return 'plan';
-    if (fileName === 'context.md') return 'context';
-    if (fileName === 'requirements.md') return 'reference';
-    if (fileName.startsWith('output_')) return 'output';
-    if (fileName.endsWith('.md')) return 'reference';
-    return 'artifact';
+  private resolveFileType(fileName: string): TaskFile["type"] {
+    if (fileName === "plan.md") return "plan";
+    if (fileName === "context.md") return "context";
+    if (fileName === "requirements.md") return "reference";
+    if (fileName.startsWith("output_")) return "output";
+    if (fileName.endsWith(".md")) return "reference";
+    return "artifact";
   }
 
   private inferContentType(fileName: string): string {
     const extension = extname(fileName).toLowerCase();
     switch (extension) {
-      case '.md':
-        return 'text/markdown';
-      case '.json':
-        return 'application/json';
-      case '.txt':
-        return 'text/plain';
+      case ".md":
+        return "text/markdown";
+      case ".json":
+        return "application/json";
+      case ".txt":
+        return "text/plain";
       default:
-        return 'text/plain';
+        return "text/plain";
     }
   }
 }