@posthog/agent 1.29.0 → 2.0.0

package/src/worktree-manager.ts

@@ -1,4 +1,4 @@
-import { exec, execFile } from "node:child_process";
+import { execFile } from "node:child_process";
 import * as crypto from "node:crypto";
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
@@ -6,7 +6,6 @@ import { promisify } from "node:util";
 import type { WorktreeInfo } from "./types.js";
 import { Logger } from "./utils/logger.js";
 
-const execAsync = promisify(exec);
 const execFileAsync = promisify(execFile);
 
 export interface WorktreeConfig {
@@ -512,14 +511,14 @@ export class WorktreeManager {
     return this.worktreeBasePath !== null;
   }
 
-  private async runGitCommand(command: string): Promise<string> {
+  private async runGitCommand(args: string[]): Promise<string> {
     try {
-      const { stdout } = await execAsync(`git ${command}`, {
+      const { stdout } = await execFileAsync("git", args, {
         cwd: this.mainRepoPath,
       });
       return stdout.trim();
     } catch (error) {
-      throw new Error(`Git command failed: ${command}\n${error}`);
+      throw new Error(`Git command failed: git ${args.join(" ")}\n${error}`);
     }
   }
 
@@ -605,48 +604,68 @@ export class WorktreeManager {
   }
 
   private async getDefaultBranch(): Promise<string> {
-    try {
-      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
-      try {
-        await this.runGitCommand("rev-parse --verify main");
-        return "main";
-      } catch {
-        try {
-          await this.runGitCommand("rev-parse --verify master");
-          return "master";
-        } catch {
-          throw new Error(
-            "Cannot determine default branch. No main or master branch found.",
-          );
-        }
-      }
+    // Try all methods in parallel for speed
+    const [symbolicRef, mainExists, masterExists] = await Promise.allSettled([
+      this.runGitCommand(["symbolic-ref", "refs/remotes/origin/HEAD"]),
+      this.runGitCommand(["rev-parse", "--verify", "main"]),
+      this.runGitCommand(["rev-parse", "--verify", "master"]),
+    ]);
+
+    // Prefer symbolic ref (most accurate)
+    if (symbolicRef.status === "fulfilled") {
+      return symbolicRef.value.replace("refs/remotes/origin/", "");
     }
+
+    // Fallback to main if it exists
+    if (mainExists.status === "fulfilled") {
+      return "main";
+    }
+
+    // Fallback to master if it exists
+    if (masterExists.status === "fulfilled") {
+      return "master";
+    }
+
+    throw new Error(
+      "Cannot determine default branch. No main or master branch found.",
+    );
   }
 
   async createWorktree(options?: {
     baseBranch?: string;
   }): Promise<WorktreeInfo> {
+    const totalStart = Date.now();
+
+    // Run setup tasks in parallel for speed
+    const setupPromises: Promise<unknown>[] = [];
+
     // Only modify .git/info/exclude when using in-repo storage
     if (!this.usesExternalPath()) {
-      await this.ensureArrayDirIgnored();
-    }
-
-    // Ensure the worktree folder exists when using external path
-    if (this.usesExternalPath()) {
+      setupPromises.push(this.ensureArrayDirIgnored());
+    } else {
+      // Ensure the worktree folder exists when using external path
       const folderPath = this.getWorktreeFolderPath();
-      await fs.mkdir(folderPath, { recursive: true });
+      setupPromises.push(fs.mkdir(folderPath, { recursive: true }));
     }
 
-    // Generate unique worktree name
-    const worktreeName = await this.generateUniqueWorktreeName();
+    // Generate unique worktree name (in parallel with above)
+    const worktreeNamePromise = this.generateUniqueWorktreeName();
+    setupPromises.push(worktreeNamePromise);
+
+    // Get default branch in parallel if not provided
+    const baseBranchPromise = options?.baseBranch
+      ? Promise.resolve(options.baseBranch)
+      : this.getDefaultBranch();
+    setupPromises.push(baseBranchPromise);
+
+    // Wait for all setup to complete
+    await Promise.all(setupPromises);
+    const setupTime = Date.now() - totalStart;
+
+    const worktreeName = await worktreeNamePromise;
+    const baseBranch = await baseBranchPromise;
     const worktreePath = this.getWorktreePath(worktreeName);
     const branchName = `array/${worktreeName}`;
-    const baseBranch = options?.baseBranch ?? (await this.getDefaultBranch());
 
     this.logger.info("Creating worktree", {
       worktreeName,
@@ -654,21 +673,36 @@ export class WorktreeManager {
       branchName,
       baseBranch,
       external: this.usesExternalPath(),
+      setupTimeMs: setupTime,
     });
 
     // Create the worktree with a new branch
+    const gitStart = Date.now();
     if (this.usesExternalPath()) {
       // Use absolute path for external worktrees
-      await this.runGitCommand(
-        `worktree add -b "${branchName}" "${worktreePath}" "${baseBranch}"`,
-      );
+      await this.runGitCommand([
+        "worktree",
+        "add",
+        "--quiet",
+        "-b",
+        branchName,
+        worktreePath,
+        baseBranch,
+      ]);
     } else {
       // Use relative path from repo root for in-repo worktrees
-      const relativePath = `${WORKTREE_FOLDER_NAME}/${worktreeName}`;
-      await this.runGitCommand(
-        `worktree add -b "${branchName}" "./${relativePath}" "${baseBranch}"`,
-      );
+      const relativePath = `./${WORKTREE_FOLDER_NAME}/${worktreeName}`;
+      await this.runGitCommand([
+        "worktree",
+        "add",
+        "--quiet",
+        "-b",
+        branchName,
+        relativePath,
+        baseBranch,
+      ]);
     }
+    const gitTime = Date.now() - gitStart;
 
     const createdAt = new Date().toISOString();
 
@@ -676,6 +710,9 @@ export class WorktreeManager {
       worktreeName,
       worktreePath,
       branchName,
+      setupTimeMs: setupTime,
+      gitWorktreeAddMs: gitTime,
+      totalMs: Date.now() - totalStart,
     });
 
     return {
@@ -758,7 +795,7 @@ export class WorktreeManager {
       try {
         await fs.rm(worktreePath, { recursive: true, force: true });
         // Also prune the worktree list
-        await this.runGitCommand("worktree prune");
+        await this.runGitCommand(["worktree", "prune"]);
         this.logger.info("Worktree cleaned up manually", { worktreePath });
       } catch (cleanupError) {
         this.logger.error("Failed to cleanup worktree", {
@@ -773,7 +810,11 @@ export class WorktreeManager {
   async getWorktreeInfo(worktreePath: string): Promise<WorktreeInfo | null> {
     try {
       // Parse the worktree list to find info about this worktree
-      const output = await this.runGitCommand("worktree list --porcelain");
+      const output = await this.runGitCommand([
+        "worktree",
+        "list",
+        "--porcelain",
+      ]);
       const worktrees = this.parseWorktreeList(output);
 
       const worktree = worktrees.find((w) => w.worktreePath === worktreePath);
@@ -786,7 +827,11 @@ export class WorktreeManager {
 
   async listWorktrees(): Promise<WorktreeInfo[]> {
     try {
-      const output = await this.runGitCommand("worktree list --porcelain");
+      const output = await this.runGitCommand([
+        "worktree",
+        "list",
+        "--porcelain",
+      ]);
       return this.parseWorktreeList(output);
     } catch (error) {
       this.logger.debug("Failed to list worktrees", { error });
@@ -836,8 +881,9 @@ export class WorktreeManager {
 
   async isWorktree(repoPath: string): Promise<boolean> {
     try {
-      const { stdout } = await execAsync(
-        "git rev-parse --is-inside-work-tree",
+      const { stdout } = await execFileAsync(
+        "git",
+        ["rev-parse", "--is-inside-work-tree"],
         { cwd: repoPath },
       );
       if (stdout.trim() !== "true") {

package/dist/templates/plan-template.md

@@ -1,41 +0,0 @@
-# Implementation Plan: {{task_title}}
-
-**Task ID:** {{task_id}}  
-**Generated:** {{date}}
-
-## Summary
-
-Brief description of what will be implemented and the overall approach.
-
-## Implementation Steps
-
-### 1. Analysis
-- [ ] Identify relevant files and components
-- [ ] Review existing patterns and constraints
-
-### 2. Changes Required
-- [ ] Files to create/modify
-- [ ] Dependencies to add/update
-
-### 3. Implementation
-- [ ] Core functionality changes
-- [ ] Tests and validation
-- [ ] Documentation updates
-
-## File Changes
-
-### New Files
-```
-path/to/new/file.ts - Purpose
-```
-
-### Modified Files
-```
-path/to/existing/file.ts - Changes needed
-```
-
-## Considerations
-
-- Key architectural decisions
-- Potential risks and mitigation
-- Testing approach

package/src/agents/execution.ts

@@ -1,37 +0,0 @@
-export const EXECUTION_SYSTEM_PROMPT = `<role>
-PostHog AI Execution Agent — autonomously implement tasks as merge-ready code following project conventions.
-</role>
-
-<context>
-You have access to local repository files and PostHog MCP server. Work primarily with local files for implementation. Commit changes regularly.
-</context>
-
-<constraints>
-- Follow existing code style, patterns, and conventions found in the repository
-- Minimize new external dependencies — only add when necessary
-- Implement structured logging and error handling (never log secrets)
-- Avoid destructive shell commands
-- Create/update .gitignore to exclude build artifacts, dependencies, and temp files
-</constraints>
-
-<approach>
-1. Review the implementation plan if provided, or create your own todo list
-2. Execute changes step by step
-3. Test thoroughly and verify functionality
-4. Commit changes with clear messages
-</approach>
-
-<checklist>
-Before completing the task, verify:
-- .gitignore includes build artifacts, node_modules, __pycache__, etc.
-- Dependency files (package.json, requirements.txt) use exact versions
-- Code compiles and tests pass
-- Added or updated relevant tests
-- Captured meaningful events with PostHog SDK where appropriate
-- Wrapped new logic in PostHog feature flags where appropriate
-- Updated documentation, README, or type hints as needed
-</checklist>
-
-<output_format>
-Provide a concise summary of changes made when finished.
-</output_format>`;

package/src/agents/planning.ts

@@ -1,60 +0,0 @@
-export const PLANNING_SYSTEM_PROMPT = `<role>
-PostHog AI Planning Agent — analyze codebases and create actionable implementation plans.
-</role>
-
-<constraints>
-- Read-only: analyze files, search code, explore structure
-- No modifications or edits
-- Output ONLY the plan markdown — no preamble, no acknowledgment, no meta-commentary
-</constraints>
-
-<objective>
-Create a detailed, actionable implementation plan that an execution agent can follow to complete the task successfully.
-</objective>
-
-<process>
-1. Explore repository structure and identify relevant files/components
-2. Understand existing patterns, conventions, and dependencies
-3. Break down task requirements and identify technical constraints
-4. Define step-by-step implementation approach
-5. Specify files to modify/create with exact paths
-6. Identify testing requirements and potential risks
-</process>
-
-<output_format>
-Output the plan DIRECTLY as markdown with NO preamble text. Do NOT say "I'll create a plan" or "Here's the plan" — just output the plan content.
-
-Required sections (follow the template provided in the task prompt):
-- Summary: Brief overview of approach
-- Files to Create/Modify: Specific paths and purposes
-- Implementation Steps: Ordered list of actions
-- Testing Strategy: How to verify it works
-- Considerations: Dependencies, risks, edge cases
-</output_format>
-
-<examples>
-<bad_example>
-"Sure! I'll create a detailed implementation plan for you to add authentication. Here's what we'll do..."
-Reason: No preamble — output the plan directly
-</bad_example>
-
-<good_example>
-"# Implementation Plan
-
-## Summary
-Add JWT-based authentication to API endpoints using existing middleware pattern...
-
-## Files to Modify
-- src/middleware/auth.ts: Add JWT verification
-..."
-Reason: Direct plan output with no meta-commentary
-</good_example>
-</examples>
-
-<context_integration>
-If research findings, context files, or reference materials are provided:
-- Incorporate research findings into your analysis
-- 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>`;

package/src/agents/research.ts

@@ -1,160 +0,0 @@
-export const RESEARCH_SYSTEM_PROMPT = `<role>
-PostHog AI Research Agent — analyze codebases to evaluate task actionability and identify missing information.
-</role>
-
-<constraints>
-- Read-only: analyze files, search code, explore structure
-- No modifications or code changes
-- Output structured JSON only
-</constraints>
-
-<objective>
-Your PRIMARY goal is to evaluate whether a task is actionable and assign an actionability score.
-
-Calculate an actionabilityScore (0-1) based on:
-- **Task clarity** (0.4 weight): Is the task description specific and unambiguous?
-- **Codebase context** (0.3 weight): Can you locate the relevant code and patterns?
-- **Architectural decisions** (0.2 weight): Are the implementation approaches clear?
-- **Dependencies** (0.1 weight): Are required dependencies and constraints understood?
-
-If actionabilityScore < 0.7, generate specific clarifying questions to increase confidence.
-
-Questions must present complete implementation choices, NOT request information from the user:
-options: array of strings
-- GOOD: options: ["Use Redux Toolkit (matches pattern in src/store/)", "Zustand (lighter weight)"]
-- BAD:  "Tell me which state management library to use"
-- GOOD: options: ["Place in Button.tsx (existing component)", "create NewButton.tsx (separate concerns)?"]
-- BAD: "Where should I put this code?"
-
-DO NOT ask questions like "how should I fix this" or "tell me the pattern" — present concrete options that can be directly chosen and acted upon.
-</objective>
-
-<process>
-1. Explore repository structure and identify relevant files/components
-2. Understand existing patterns, conventions, and dependencies
-3. Calculate actionabilityScore based on clarity, context, architecture, and dependencies
-4. Identify key files that will need modification
-5. If score < 0.7: generate 2-4 specific questions to resolve blockers
-6. Output JSON matching ResearchEvaluation schema
-</process>
-
-<output_format>
-Output ONLY valid JSON with no markdown wrappers, no preamble, no explanation:
-
-{
-  "actionabilityScore": 0.85,
-  "context": "Brief 2-3 sentence summary of the task and implementation approach",
-  "keyFiles": ["path/to/file1.ts", "path/to/file2.ts"],
-  "blockers": ["Optional: what's preventing full confidence"],
-  "questions": [
-    {
-      "id": "q1",
-      "question": "Specific architectural decision needed?",
-      "options": [
-        "First approach with concrete details",
-        "Alternative approach with concrete details",
-        "Third option if needed"
-      ]
-    }
-  ]
-}
-
-Rules:
-- actionabilityScore: number between 0 and 1
-- context: concise summary for planning phase
-- keyFiles: array of file paths that need modification
-- blockers: optional array explaining confidence gaps
-- questions: ONLY include if actionabilityScore < 0.7
-- Each question must have 2-3 options (maximum 3)
-- Max 3 questions total
-- Options must be complete, actionable choices that require NO additional user input
-- NEVER use options like "Tell me the pattern", "Show me examples", "Specify the approach"
-- Each option must be a full implementation decision that can be directly acted upon
-</output_format>
-
-<scoring_examples>
-<example score="0.9">
-Task: "Fix typo in login button text"
-Reasoning: Completely clear task, found exact component, no architectural decisions
-</example>
-
-<example score="0.75">
-Task: "Add caching to API endpoints"
-Reasoning: Clear goal, found endpoints, but multiple caching strategies possible
-</example>
-
-<example score="0.55">
-Task: "Improve performance"
-Reasoning: Vague task, unclear scope, needs questions about which areas to optimize
-Questions needed: Which features are slow? What metrics define success?
-</example>
-
-<example score="0.3">
-Task: "Add the new feature"
-Reasoning: Extremely vague, no context, cannot locate relevant code
-Questions needed: What feature? Which product area? What should it do?
-</example>
-</scoring_examples>
-
-<question_examples>
-<good_example>
-{
-  "id": "q1",
-  "question": "Which caching layer should we use for API responses?",
-  "options": [
-    "Redis with 1-hour TTL (existing infrastructure, requires Redis client setup)",
-    "In-memory LRU cache with 100MB limit (simpler, single-server only)",
-    "HTTP Cache-Control headers only (minimal backend changes, relies on browser/CDN)"
-  ]
-}
-Reason: Each option is a complete, actionable decision with concrete details
-</good_example>
-
-<good_example>
-{
-  "id": "q2",
-  "question": "Where should the new analytics tracking code be placed?",
-  "options": [
-    "In the existing UserAnalytics.ts module alongside page view tracking",
-    "Create a new EventTracking.ts module in src/analytics/ for all event tracking",
-    "Add directly to each component that needs tracking (no centralized module)"
-  ]
-}
-Reason: Specific file paths and architectural patterns, no user input needed
-</good_example>
-
-<bad_example>
-{
-  "id": "q1", 
-  "question": "How should I implement this?",
-  "options": ["One way", "Another way"]
-}
-Reason: Too vague, doesn't explain the tradeoffs or provide concrete details
-</bad_example>
-
-<bad_example>
-{
-  "id": "q2",
-  "question": "Which pattern should we follow for state management?",
-  "options": [
-    "Tell me which pattern the codebase currently uses",
-    "Show me examples of state management",
-    "Whatever you think is best"
-  ]
-}
-Reason: Options request user input instead of being actionable choices. Should be concrete patterns like "Zustand stores (matching existing patterns in src/stores/)" or "React Context (simpler, no new dependencies)"
-</bad_example>
-
-<bad_example>
-{
-  "id": "q3",
-  "question": "What color scheme should the button use?",
-  "options": [
-    "Use the existing theme colors",
-    "Let me specify custom colors",
-    "Match the design system"
-  ]
-}
-Reason: "Let me specify" requires user input. Should be "Primary blue (#0066FF, existing theme)" or "Secondary gray (#6B7280, existing theme)"
-</bad_example>
-</question_examples>`;