@posthog/agent 1.0.0

package/src/git-manager.ts

@@ -0,0 +1,344 @@
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { Logger } from './utils/logger';
+
+const execAsync = promisify(exec);
+
+export interface GitConfig {
+  repositoryPath: string;
+  authorName?: string;
+  authorEmail?: string;
+  logger?: Logger;
+}
+
+export interface BranchInfo {
+  name: string;
+  exists: boolean;
+  isCurrentBranch: boolean;
+}
+
+export class GitManager {
+  private repositoryPath: string;
+  private authorName?: string;
+  private authorEmail?: string;
+  private logger: Logger;
+
+  constructor(config: GitConfig) {
+    this.repositoryPath = config.repositoryPath;
+    this.authorName = config.authorName;
+    this.authorEmail = config.authorEmail;
+    this.logger = config.logger || new Logger({ debug: false, prefix: '[GitManager]' });
+  }
+
+  private async runGitCommand(command: string): Promise<string> {
+    try {
+      const { stdout } = await execAsync(`cd "${this.repositoryPath}" && git ${command}`);
+      return stdout.trim();
+    } catch (error) {
+      throw new Error(`Git command failed: ${command}\n${error}`);
+    }
+  }
+
+  private async runCommand(command: string): Promise<string> {
+    try {
+      const { stdout } = await execAsync(`cd "${this.repositoryPath}" && ${command}`);
+      return stdout.trim();
+    } catch (error) {
+      throw new Error(`Command failed: ${command}\n${error}`);
+    }
+  }
+
+  async isGitRepository(): Promise<boolean> {
+    try {
+      await this.runGitCommand('rev-parse --git-dir');
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  async getCurrentBranch(): Promise<string> {
+    return await this.runGitCommand('branch --show-current');
+  }
+
+  async getDefaultBranch(): Promise<string> {
+    try {
+      // Try to get the default branch from remote
+      const remoteBranch = await this.runGitCommand('symbolic-ref refs/remotes/origin/HEAD');
+      return remoteBranch.replace('refs/remotes/origin/', '');
+    } catch {
+      // Fallback: check if main exists, otherwise use master
+      if (await this.branchExists('main')) {
+        return 'main';
+      } else if (await this.branchExists('master')) {
+        return 'master';
+      } else {
+        throw new Error('Cannot determine default branch. No main or master branch found.');
+      }
+    }
+  }
+
+  async branchExists(branchName: string): Promise<boolean> {
+    try {
+      await this.runGitCommand(`rev-parse --verify ${branchName}`);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  async createBranch(branchName: string, baseBranch?: string): Promise<void> {
+    const base = baseBranch || await this.getCurrentBranch();
+    await this.runGitCommand(`checkout -b ${branchName} ${base}`);
+  }
+
+  async switchToBranch(branchName: string): Promise<void> {
+    await this.runGitCommand(`checkout ${branchName}`);
+  }
+
+  async createOrSwitchToBranch(branchName: string, baseBranch?: string): Promise<void> {
+    const exists = await this.branchExists(branchName);
+    if (exists) {
+      await this.switchToBranch(branchName);
+    } else {
+      await this.createBranch(branchName, baseBranch);
+    }
+  }
+
+  async addFiles(paths: string[]): Promise<void> {
+    const pathList = paths.map(p => `"${p}"`).join(' ');
+    await this.runGitCommand(`add ${pathList}`);
+  }
+
+  async addAllPostHogFiles(): Promise<void> {
+    await this.runGitCommand('add .posthog/');
+  }
+
+  async commitChanges(message: string, options?: {
+    authorName?: string;
+    authorEmail?: string;
+  }): Promise<string> {
+    let command = 'commit -m "' + message.replace(/"/g, '\\"') + '"';
+
+    const authorName = options?.authorName || this.authorName;
+    const authorEmail = options?.authorEmail || this.authorEmail;
+
+    if (authorName && authorEmail) {
+      command += ` --author="${authorName} <${authorEmail}>"`;
+    }
+
+    return await this.runGitCommand(command);
+  }
+
+  async hasChanges(): Promise<boolean> {
+    try {
+      const status = await this.runGitCommand('status --porcelain');
+      return status.length > 0;
+    } catch {
+      return false;
+    }
+  }
+
+  async hasStagedChanges(): Promise<boolean> {
+    try {
+      const status = await this.runGitCommand('diff --cached --name-only');
+      return status.length > 0;
+    } catch {
+      return false;
+    }
+  }
+
+  async getRemoteUrl(): Promise<string | null> {
+    try {
+      return await this.runGitCommand('remote get-url origin');
+    } catch {
+      return null;
+    }
+  }
+
+  async pushBranch(branchName: string, force: boolean = false): Promise<void> {
+    const forceFlag = force ? '--force' : '';
+    await this.runGitCommand(`push ${forceFlag} -u origin ${branchName}`);
+  }
+
+  // Utility methods for PostHog task workflow
+  async createTaskPlanningBranch(taskId: string, baseBranch?: string): Promise<string> {
+    let branchName = `posthog/task-${taskId}-planning`;
+    let counter = 1;
+
+    // Find a unique branch name if the base name already exists
+    while (await this.branchExists(branchName)) {
+      branchName = `posthog/task-${taskId}-planning-${counter}`;
+      counter++;
+    }
+
+    this.logger.debug('Creating unique planning branch', { branchName, taskId });
+
+    // If no base branch specified, ensure we're on main/master
+    if (!baseBranch) {
+      baseBranch = await this.getDefaultBranch();
+      await this.switchToBranch(baseBranch);
+
+      // Check for uncommitted changes
+      if (await this.hasChanges()) {
+        throw new Error(`Uncommitted changes detected. Please commit or stash changes before running tasks.`);
+      }
+    }
+
+    await this.createBranch(branchName, baseBranch); // Use createBranch instead of createOrSwitchToBranch for new branches
+    return branchName;
+  }
+
+  async createTaskImplementationBranch(taskId: string, planningBranchName?: string): Promise<string> {
+    let branchName = `posthog/task-${taskId}-implementation`;
+    let counter = 1;
+
+    // Find a unique branch name if the base name already exists
+    while (await this.branchExists(branchName)) {
+      branchName = `posthog/task-${taskId}-implementation-${counter}`;
+      counter++;
+    }
+
+    const currentBranchBefore = await this.getCurrentBranch();
+    this.logger.debug('Creating unique implementation branch', {
+      branchName,
+      taskId,
+      currentBranch: currentBranchBefore
+    });
+
+    // Implementation branch should branch from the specific planning branch
+    let baseBranch = planningBranchName;
+
+    if (!baseBranch) {
+      // Try to find the corresponding planning branch
+      const currentBranch = await this.getCurrentBranch();
+      if (currentBranch.includes('-planning')) {
+        baseBranch = currentBranch; // Use current planning branch
+        this.logger.debug('Using current planning branch', { baseBranch });
+      } else {
+        // Fallback to default branch
+        baseBranch = await this.getDefaultBranch();
+        this.logger.debug('No planning branch found, using default', { baseBranch });
+        await this.switchToBranch(baseBranch);
+      }
+    }
+
+    this.logger.debug('Creating implementation branch from base', { baseBranch, branchName });
+    await this.createBranch(branchName, baseBranch); // Create fresh branch from base
+
+    const currentBranchAfter = await this.getCurrentBranch();
+    this.logger.info('Implementation branch created', {
+      branchName,
+      currentBranch: currentBranchAfter
+    });
+
+    return branchName;
+  }
+
+  async commitPlan(taskId: string, taskTitle: string): Promise<string> {
+    const currentBranch = await this.getCurrentBranch();
+    this.logger.debug('Committing plan', { taskId, currentBranch });
+
+    await this.addAllPostHogFiles();
+
+    const hasChanges = await this.hasStagedChanges();
+    this.logger.debug('Checking for staged changes', { hasChanges });
+
+    if (!hasChanges) {
+      this.logger.info('No plan changes to commit', { taskId });
+      return 'No changes to commit';
+    }
+
+    const message = `📋 Add plan for task: ${taskTitle}
+
+Task ID: ${taskId}
+Generated by PostHog Agent
+
+This commit contains the implementation plan and supporting documentation
+for the task. Review the plan before proceeding with implementation.`;
+
+    const result = await this.commitChanges(message);
+    this.logger.info('Plan committed', { taskId, taskTitle });
+    return result;
+  }
+
+  async commitImplementation(taskId: string, taskTitle: string, planSummary?: string): Promise<string> {
+    await this.runGitCommand('add .');
+
+    const hasChanges = await this.hasStagedChanges();
+    if (!hasChanges) {
+      this.logger.warn('No implementation changes to commit', { taskId });
+      return 'No changes to commit';
+    }
+
+    let message = `✨ Implement task: ${taskTitle}
+
+Task ID: ${taskId}
+Generated by PostHog Agent`;
+
+    if (planSummary) {
+      message += `\n\nPlan Summary:\n${planSummary}`;
+    }
+
+    message += `\n\nThis commit implements the changes described in the task plan.`;
+
+    const result = await this.commitChanges(message);
+    this.logger.info('Implementation committed', { taskId, taskTitle });
+    return result;
+  }
+
+  async deleteBranch(branchName: string, force: boolean = false): Promise<void> {
+    const forceFlag = force ? '-D' : '-d';
+    await this.runGitCommand(`branch ${forceFlag} ${branchName}`);
+  }
+
+  async deleteRemoteBranch(branchName: string): Promise<void> {
+    await this.runGitCommand(`push origin --delete ${branchName}`);
+  }
+
+  async getBranchInfo(branchName: string): Promise<BranchInfo> {
+    const exists = await this.branchExists(branchName);
+    const currentBranch = await this.getCurrentBranch();
+
+    return {
+      name: branchName,
+      exists,
+      isCurrentBranch: branchName === currentBranch
+    };
+  }
+
+  async getCommitSha(ref: string = 'HEAD'): Promise<string> {
+    return await this.runGitCommand(`rev-parse ${ref}`);
+  }
+
+  async getCommitMessage(ref: string = 'HEAD'): Promise<string> {
+    return await this.runGitCommand(`log -1 --pretty=%B ${ref}`);
+  }
+
+  async createPullRequest(
+    branchName: string,
+    title: string,
+    body: string,
+    baseBranch?: string
+  ): Promise<string> {
+    const currentBranch = await this.getCurrentBranch();
+    if (currentBranch !== branchName) {
+      await this.switchToBranch(branchName);
+    }
+
+    await this.pushBranch(branchName);
+
+    let command = `gh pr create --title "${title.replace(/"/g, '\\"')}" --body "${body.replace(/"/g, '\\"')}"`;
+
+    if (baseBranch) {
+      command += ` --base ${baseBranch}`;
+    }
+
+    try {
+      const prUrl = await this.runCommand(command);
+      return prUrl.trim();
+    } catch (error) {
+      throw new Error(`Failed to create PR: ${error}`);
+    }
+  }
+}

package/src/posthog-api.ts

@@ -0,0 +1,169 @@
+import type { Task, SupportingFile, PostHogAPIConfig } from './types';
+import type { WorkflowDefinition, AgentDefinition } from './workflow-types';
+
+interface PostHogApiResponse<T> {
+  results?: T[];
+  count?: number;
+  next?: string | null;
+  previous?: string | null;
+}
+
+interface TaskProgressResponse {
+  has_progress: boolean;
+  id?: string;
+  status?: "started" | "in_progress" | "completed" | "failed";
+  current_step?: string;
+  completed_steps?: number;
+  total_steps?: number;
+  progress_percentage?: number;
+  output_log?: string;
+  error_message?: string;
+  created_at?: string;
+  updated_at?: string;
+  completed_at?: string;
+  workflow_id?: string;
+  workflow_run_id?: string;
+  message?: string;
+}
+
+export class PostHogAPIClient {
+  private config: PostHogAPIConfig;
+  private _teamId: number | null = null;
+
+  constructor(config: PostHogAPIConfig) {
+    this.config = config;
+  }
+
+  private get baseUrl(): string {
+    const host = this.config.apiUrl.endsWith("/") 
+      ? this.config.apiUrl.slice(0, -1) 
+      : this.config.apiUrl;
+    return host;
+  }
+
+  private get headers(): Record<string, string> {
+    return {
+      'Authorization': `Bearer ${this.config.apiKey}`,
+      'Content-Type': 'application/json',
+    };
+  }
+
+  private async apiRequest<T>(
+    endpoint: string, 
+    options: RequestInit = {}
+  ): Promise<T> {
+    const url = `${this.baseUrl}${endpoint}`;
+    
+    const response = await fetch(url, {
+      ...options,
+      headers: {
+        ...this.headers,
+        ...options.headers,
+      },
+    });
+
+    if (!response.ok) {
+      let errorMessage: string;
+      try {
+        const errorResponse = await response.json();
+        errorMessage = `Failed request: [${response.status}] ${JSON.stringify(errorResponse)}`;
+      } catch {
+        errorMessage = `Failed request: [${response.status}] ${response.statusText}`;
+      }
+      throw new Error(errorMessage);
+    }
+
+    return response.json();
+  }
+
+  private async getTeamId(): Promise<number> {
+    if (this._teamId !== null) {
+      return this._teamId;
+    }
+
+    // Fetch user info to get team ID (following Array's pattern)
+    const userResponse = await this.apiRequest<any>('/api/users/@me/');
+    
+    if (!userResponse.team?.id) {
+      throw new Error('No team found for user');
+    }
+
+    const teamId = Number(userResponse.team.id);
+    this._teamId = teamId;
+    return teamId;
+  }
+
+  async fetchTask(taskId: string): Promise<Task> {
+    const teamId = await this.getTeamId();
+    return this.apiRequest<Task>(`/api/projects/${teamId}/tasks/${taskId}/`);
+  }
+
+  async listTasks(filters?: {
+    repository?: string;
+    organization?: string;
+    origin_product?: string;
+    workflow?: string;
+    current_stage?: string;
+  }): Promise<Task[]> {
+    const teamId = await this.getTeamId();
+    const url = new URL(`${this.baseUrl}/api/projects/${teamId}/tasks/`);
+    
+    if (filters) {
+      Object.entries(filters).forEach(([key, value]) => {
+        if (value) url.searchParams.append(key, value);
+      });
+    }
+
+    const response = await this.apiRequest<PostHogApiResponse<Task>>(
+      url.pathname + url.search
+    );
+    
+    return response.results || [];
+  }
+
+  async updateTask(taskId: string, updates: Partial<Task>): Promise<Task> {
+    const teamId = await this.getTeamId();
+    return this.apiRequest<Task>(`/api/projects/${teamId}/tasks/${taskId}/`, {
+      method: 'PATCH',
+      body: JSON.stringify(updates),
+    });
+  }
+
+  async updateTaskStage(taskId: string, stageId: string): Promise<Task> {
+    const teamId = await this.getTeamId();
+    return this.apiRequest<Task>(`/api/projects/${teamId}/tasks/${taskId}/update_stage/`, {
+      method: 'PATCH',
+      body: JSON.stringify({ current_stage: stageId }),
+    });
+  }
+
+  async getTaskProgress(taskId: string): Promise<TaskProgressResponse> {
+    const teamId = await this.getTeamId();
+    return this.apiRequest<TaskProgressResponse>(`/api/projects/${teamId}/tasks/${taskId}/progress/`);
+  }
+
+  // Workflow endpoints
+  async fetchWorkflow(workflowId: string): Promise<WorkflowDefinition> {
+    const teamId = await this.getTeamId();
+    return this.apiRequest<WorkflowDefinition>(`/api/projects/${teamId}/task_workflows/${workflowId}/`);
+  }
+
+  async listWorkflows(): Promise<WorkflowDefinition[]> {
+    const teamId = await this.getTeamId();
+    const response = await this.apiRequest<PostHogApiResponse<WorkflowDefinition>>(`/api/projects/${teamId}/task_workflows/`);
+    return response.results || [];
+  }
+
+  // Agent catalog exposure
+  async listAgents(): Promise<AgentDefinition[]> {
+    return this.apiRequest<AgentDefinition[]>(`/api/agents/`);
+  }
+
+  async progressTask(taskId: string, options?: { next_stage_id?: string; auto?: boolean }): Promise<Task> {
+    const teamId = await this.getTeamId();
+    return this.apiRequest<Task>(`/api/projects/${teamId}/tasks/${taskId}/progress_task/`, {
+      method: 'POST',
+      body: JSON.stringify(options || {}),
+    });
+  }
+}

package/src/prompt-builder.ts

@@ -0,0 +1,93 @@
+import type { Task } from './types';
+import type { TemplateVariables } from './template-manager';
+import { Logger } from './utils/logger';
+
+export interface PromptBuilderDeps {
+  getTaskFiles: (taskId: string) => Promise<any[]>;
+  generatePlanTemplate: (vars: TemplateVariables) => Promise<string>;
+  logger?: Logger;
+}
+
+export class PromptBuilder {
+  private getTaskFiles: PromptBuilderDeps['getTaskFiles'];
+  private generatePlanTemplate: PromptBuilderDeps['generatePlanTemplate'];
+  private logger: Logger;
+
+  constructor(deps: PromptBuilderDeps) {
+    this.getTaskFiles = deps.getTaskFiles;
+    this.generatePlanTemplate = deps.generatePlanTemplate;
+    this.logger = deps.logger || new Logger({ debug: false, prefix: '[PromptBuilder]' });
+  }
+
+  async buildPlanningPrompt(task: Task): Promise<string> {
+    let prompt = '';
+    prompt += `## Current Task\n\n**Task**: ${task.title}\n**Description**: ${task.description}`;
+
+    if ((task as any).primary_repository) {
+      prompt += `\n**Repository**: ${(task as any).primary_repository}`;
+    }
+
+    try {
+      const taskFiles = await this.getTaskFiles(task.id);
+      const contextFiles = taskFiles.filter((f: any) => f.type === 'context' || f.type === 'reference');
+      if (contextFiles.length > 0) {
+        prompt += `\n\n## Supporting Files`;
+        for (const file of contextFiles) {
+          prompt += `\n\n### ${file.name} (${file.type})\n${file.content}`;
+        }
+      }
+    } catch (error) {
+      this.logger.debug('No existing task files found for planning', { taskId: task.id });
+    }
+
+    const templateVariables = {
+      task_id: task.id,
+      task_title: task.title,
+      task_description: task.description,
+      date: new Date().toISOString().split('T')[0],
+      repository: ((task as any).primary_repository || '') as string,
+    };
+
+    const planTemplate = await this.generatePlanTemplate(templateVariables);
+
+    prompt += `\n\nPlease analyze the codebase and create a detailed implementation plan for this task. Use the following template structure for your plan:\n\n${planTemplate}\n\nFill in each section with specific, actionable information based on your analysis. Replace all placeholder content with actual details about this task.`;
+
+    return prompt;
+  }
+
+  async buildExecutionPrompt(task: Task): Promise<string> {
+    let prompt = '';
+    prompt += `## Current Task\n\n**Task**: ${task.title}\n**Description**: ${task.description}`;
+
+    if ((task as any).primary_repository) {
+      prompt += `\n**Repository**: ${(task as any).primary_repository}`;
+    }
+
+    try {
+      const taskFiles = await this.getTaskFiles(task.id);
+      const hasPlan = taskFiles.some((f: any) => f.type === 'plan');
+      if (taskFiles.length > 0) {
+        prompt += `\n\n## Context and Supporting Information`;
+        for (const file of taskFiles) {
+          if (file.type === 'plan') {
+            prompt += `\n\n### Execution Plan\n${file.content}`;
+          } else {
+            prompt += `\n\n### ${file.name} (${file.type})\n${file.content}`;
+          }
+        }
+      }
+      if (hasPlan) {
+        prompt += `\n\nPlease implement the changes described in the execution plan above. Follow the plan step-by-step and make the necessary file modifications. You must actually edit files and make changes - do not just analyze or review.`;
+      } else {
+        prompt += `\n\nPlease implement the changes described in the task above. You must actually edit files and make changes - do not just analyze or review.`;
+      }
+    } catch (error) {
+      this.logger.debug('No supporting files found for execution', { taskId: task.id });
+      prompt += `\n\nPlease implement the changes described in the task above.`;
+    }
+    return prompt;
+  }
+}
+
+
+