@posthog/agent 1.0.0

package/src/event-transformer.ts

@@ -0,0 +1,189 @@
+import type { AgentEvent } from './types.js';
+import type { SDKMessage } from '@anthropic-ai/claude-agent-sdk';
+
+export class EventTransformer {
+  transform(sdkMessage: SDKMessage): AgentEvent | null {
+    const baseEvent = { ts: Date.now() };
+
+    // Handle stream events
+    if (sdkMessage.type === 'stream_event') {
+      const event = sdkMessage.event;
+
+      switch (event.type) {
+        case 'message_start':
+          return {
+            ...baseEvent,
+            type: 'message_start',
+            messageId: event.message?.id,
+            model: event.message?.model
+          };
+
+        case 'content_block_start':
+          const contentBlock = event.content_block;
+          if (!contentBlock) return null;
+
+          return {
+            ...baseEvent,
+            type: 'content_block_start',
+            index: event.index,
+            contentType: contentBlock.type as 'text' | 'tool_use' | 'thinking',
+            toolName: contentBlock.type === 'tool_use' ? contentBlock.name : undefined,
+            toolId: contentBlock.type === 'tool_use' ? contentBlock.id : undefined
+          };
+
+        case 'content_block_delta':
+          const delta = event.delta;
+          if (!delta) return null;
+
+          if (delta.type === 'text_delta') {
+            return {
+              ...baseEvent,
+              type: 'token',
+              content: delta.text,
+              contentType: 'text'
+            };
+          } else if (delta.type === 'input_json_delta') {
+            return {
+              ...baseEvent,
+              type: 'token',
+              content: delta.partial_json,
+              contentType: 'tool_input'
+            };
+          } else if (delta.type === 'thinking_delta') {
+            return {
+              ...baseEvent,
+              type: 'token',
+              content: delta.thinking,
+              contentType: 'thinking'
+            };
+          }
+          return null;
+
+        case 'content_block_stop':
+          return {
+            ...baseEvent,
+            type: 'content_block_stop',
+            index: event.index
+          };
+
+        case 'message_delta':
+          return {
+            ...baseEvent,
+            type: 'message_delta',
+            stopReason: event.delta?.stop_reason,
+            stopSequence: event.delta?.stop_sequence,
+            usage: event.usage ? {
+              outputTokens: event.usage.output_tokens
+            } : undefined
+          };
+
+        case 'message_stop':
+          return {
+            ...baseEvent,
+            type: 'message_stop'
+          };
+
+        case 'ping':
+          // Ignore ping events
+          return null;
+
+        case 'error':
+          return {
+            ...baseEvent,
+            type: 'error',
+            message: event.error?.message || 'Unknown error',
+            error: event.error,
+            errorType: event.error?.type
+          };
+
+        default:
+          return null;
+      }
+    }
+
+    // Handle assistant messages (full message, not streaming)
+    if (sdkMessage.type === 'assistant') {
+      // Extract tool calls from assistant message
+      const message = sdkMessage.message;
+      // We could emit individual tool_call events here if needed
+      // For now, just emit a status event
+      return {
+        ...baseEvent,
+        type: 'status',
+        phase: 'assistant_message',
+        messageId: message.id,
+        model: message.model
+      };
+    }
+
+    // Handle user messages
+    if (sdkMessage.type === 'user') {
+      const content = sdkMessage.message.content;
+      const textContent = Array.isArray(content)
+        ? content.find(c => c.type === 'text')?.text
+        : typeof content === 'string' ? content : '';
+
+      return {
+        ...baseEvent,
+        type: 'user_message',
+        content: textContent || '',
+        isSynthetic: sdkMessage.isSynthetic
+      };
+    }
+
+    // Handle result messages
+    if (sdkMessage.type === 'result') {
+      if (sdkMessage.subtype === 'success') {
+        return {
+          ...baseEvent,
+          type: 'done',
+          durationMs: sdkMessage.duration_ms,
+          numTurns: sdkMessage.num_turns,
+          totalCostUsd: sdkMessage.total_cost_usd,
+          usage: sdkMessage.usage
+        };
+      } else {
+        return {
+          ...baseEvent,
+          type: 'error',
+          message: `Execution failed: ${sdkMessage.subtype}`,
+          error: { subtype: sdkMessage.subtype },
+          errorType: sdkMessage.subtype
+        };
+      }
+    }
+
+    // Handle system messages
+    if (sdkMessage.type === 'system') {
+      if (sdkMessage.subtype === 'init') {
+        return {
+          ...baseEvent,
+          type: 'init',
+          model: sdkMessage.model,
+          tools: sdkMessage.tools,
+          permissionMode: sdkMessage.permissionMode,
+          cwd: sdkMessage.cwd,
+          apiKeySource: sdkMessage.apiKeySource
+        };
+      } else if (sdkMessage.subtype === 'compact_boundary') {
+        return {
+          ...baseEvent,
+          type: 'compact_boundary',
+          trigger: sdkMessage.compact_metadata.trigger,
+          preTokens: sdkMessage.compact_metadata.pre_tokens
+        };
+      }
+    }
+
+    return null;
+  }
+  
+  createStatusEvent(phase: string, additionalData?: any): AgentEvent {
+    return {
+      type: 'status',
+      ts: Date.now(),
+      phase,
+      ...additionalData
+    };
+  }
+}

package/src/file-manager.ts

@@ -0,0 +1,204 @@
+import { promises as fs } from 'fs';
+import { join, dirname } from 'path';
+import type { SupportingFile } from './types';
+import { Logger } from './utils/logger';
+
+export interface TaskFile {
+  name: string;
+  content: string;
+  type: 'plan' | 'context' | 'reference' | 'output' | 'artifact';
+}
+
+export class PostHogFileManager {
+  private repositoryPath: string;
+  private logger: Logger;
+
+  constructor(repositoryPath: string, logger?: Logger) {
+    this.repositoryPath = repositoryPath;
+    this.logger = logger || new Logger({ debug: false, prefix: '[FileManager]' });
+  }
+
+  private getTaskDirectory(taskId: string): string {
+    return join(this.repositoryPath, '.posthog', taskId);
+  }
+
+  private getTaskFilePath(taskId: string, fileName: string): string {
+    return join(this.getTaskDirectory(taskId), fileName);
+  }
+
+  async ensureTaskDirectory(taskId: string): Promise<void> {
+    const taskDir = this.getTaskDirectory(taskId);
+    try {
+      await fs.access(taskDir);
+    } catch {
+      await fs.mkdir(taskDir, { recursive: true });
+    }
+  }
+
+  async writeTaskFile(taskId: string, file: TaskFile): Promise<void> {
+    await this.ensureTaskDirectory(taskId);
+    const filePath = this.getTaskFilePath(taskId, file.name);
+
+    this.logger.debug('Writing task file', {
+      filePath,
+      contentLength: file.content.length,
+      contentType: typeof file.content
+    });
+
+    await fs.writeFile(filePath, file.content, 'utf8');
+
+    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');
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
+        return null;
+      }
+      throw error;
+    }
+  }
+
+  async listTaskFiles(taskId: string): Promise<string[]> {
+    try {
+      const taskDir = this.getTaskDirectory(taskId);
+      const files = await fs.readdir(taskDir);
+      return files.filter(file => !file.startsWith('.'));
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
+        return [];
+      }
+      throw error;
+    }
+  }
+
+  async deleteTaskFile(taskId: string, fileName: string): Promise<void> {
+    try {
+      const filePath = this.getTaskFilePath(taskId, fileName);
+      await fs.unlink(filePath);
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== 'ENOENT') {
+        throw error;
+      }
+    }
+  }
+
+  async taskDirectoryExists(taskId: string): Promise<boolean> {
+    try {
+      const taskDir = this.getTaskDirectory(taskId);
+      await fs.access(taskDir);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  async cleanupTaskDirectory(taskId: string): Promise<void> {
+    try {
+      const taskDir = this.getTaskDirectory(taskId);
+      await fs.rm(taskDir, { recursive: true, force: true });
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== 'ENOENT') {
+        throw error;
+      }
+    }
+  }
+
+  // Convenience methods for common file types
+  async writePlan(taskId: string, plan: string): Promise<void> {
+    this.logger.debug('Writing plan', {
+      taskId,
+      planLength: plan.length,
+      contentPreview: plan.substring(0, 200)
+    });
+
+    await this.writeTaskFile(taskId, {
+      name: 'plan.md',
+      content: plan,
+      type: 'plan'
+    });
+
+    this.logger.info('Plan file written', { taskId });
+  }
+
+  async readPlan(taskId: string): Promise<string | null> {
+    return await this.readTaskFile(taskId, 'plan.md');
+  }
+
+  async writeContext(taskId: string, context: string): Promise<void> {
+    await this.writeTaskFile(taskId, {
+      name: 'context.md',
+      content: context,
+      type: 'context'
+    });
+  }
+
+  async readContext(taskId: string): Promise<string | null> {
+    return await this.readTaskFile(taskId, 'context.md');
+  }
+
+  async writeRequirements(taskId: string, requirements: string): Promise<void> {
+    await this.writeTaskFile(taskId, {
+      name: 'requirements.md',
+      content: requirements,
+      type: 'reference'
+    });
+  }
+
+  async readRequirements(taskId: string): Promise<string | null> {
+    return await this.readTaskFile(taskId, 'requirements.md');
+  }
+
+  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
+        let type: SupportingFile['type'] = 'reference';
+        if (fileName === 'plan.md') type = 'plan';
+        else if (fileName === 'context.md') type = 'context';
+        else if (fileName === 'requirements.md') type = 'reference';
+        else if (fileName.startsWith('output_')) type = 'output';
+        
+        files.push({
+          name: fileName,
+          content,
+          type,
+          created_at: new Date().toISOString() // Could be enhanced with file stats
+        });
+      }
+    }
+    
+    return files;
+  }
+
+  async ensureGitignore(): Promise<void> {
+    const gitignorePath = join(this.repositoryPath, '.posthog', '.gitignore');
+    const gitignoreContent = `# PostHog task artifacts - customize as needed
+# Exclude temporary files
+*/temp/
+*/cache/
+*/.env
+*/.secrets
+
+# Include plans and documentation by default
+!*/plan.md
+!*/context.md
+!*/requirements.md
+!*/README.md
+`;
+
+    try {
+      await fs.access(gitignorePath);
+    } catch {
+      await fs.mkdir(dirname(gitignorePath), { recursive: true });
+      await fs.writeFile(gitignorePath, gitignoreContent, 'utf8');
+    }
+  }
+}