@posthog/agent 1.24.2 → 1.25.0

package/src/git-manager.ts

@@ -1,6 +1,6 @@
-import { exec } from 'child_process';
-import { promisify } from 'util';
-import { Logger } from './utils/logger.js';
+import { exec } from "node:child_process";
+import { promisify } from "node:util";
+import { Logger } from "./utils/logger.js";
 
 const execAsync = promisify(exec);
 
@@ -27,20 +27,23 @@ export class GitManager {
     this.repositoryPath = config.repositoryPath;
     this.authorName = config.authorName;
     this.authorEmail = config.authorEmail;
-    this.logger = config.logger || new Logger({ debug: false, prefix: '[GitManager]' });
+    this.logger =
+      config.logger || new Logger({ debug: false, prefix: "[GitManager]" });
   }
 
   private escapeShellArg(str: string): string {
     return str
-      .replace(/\\/g, '\\\\')
+      .replace(/\\/g, "\\\\")
       .replace(/"/g, '\\"')
-      .replace(/`/g, '\\`')
-      .replace(/\$/g, '\\$');
+      .replace(/`/g, "\\`")
+      .replace(/\$/g, "\\$");
   }
 
   private async runGitCommand(command: string): Promise<string> {
     try {
-      const { stdout } = await execAsync(`cd "${this.repositoryPath}" && git ${command}`);
+      const { stdout } = await execAsync(
+        `cd "${this.repositoryPath}" && git ${command}`,
+      );
       return stdout.trim();
     } catch (error) {
       throw new Error(`Git command failed: ${command}\n${error}`);
@@ -49,7 +52,9 @@ export class GitManager {
 
   private async runCommand(command: string): Promise<string> {
     try {
-      const { stdout } = await execAsync(`cd "${this.repositoryPath}" && ${command}`);
+      const { stdout } = await execAsync(
+        `cd "${this.repositoryPath}" && ${command}`,
+      );
       return stdout.trim();
     } catch (error) {
       throw new Error(`Command failed: ${command}\n${error}`);
@@ -58,7 +63,7 @@ export class GitManager {
 
   async isGitRepository(): Promise<boolean> {
     try {
-      await this.runGitCommand('rev-parse --git-dir');
+      await this.runGitCommand("rev-parse --git-dir");
       return true;
     } catch {
       return false;
@@ -66,22 +71,26 @@ export class GitManager {
   }
 
   async getCurrentBranch(): Promise<string> {
-    return await this.runGitCommand('branch --show-current');
+    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/', '');
+      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';
+      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.');
+        throw new Error(
+          "Cannot determine default branch. No main or master branch found.",
+        );
       }
     }
   }
@@ -96,7 +105,7 @@ export class GitManager {
   }
 
   async createBranch(branchName: string, baseBranch?: string): Promise<void> {
-    const base = baseBranch || await this.getCurrentBranch();
+    const base = baseBranch || (await this.getCurrentBranch());
     await this.runGitCommand(`checkout -b ${branchName} ${base}`);
   }
 
@@ -109,25 +118,31 @@ export class GitManager {
     const defaultBranch = await this.getDefaultBranch();
 
     if (currentBranch === defaultBranch) {
-      this.logger.debug('Already on default branch', { branch: defaultBranch });
+      this.logger.debug("Already on default branch", { branch: defaultBranch });
       return true;
     }
 
     if (await this.hasChanges()) {
-      this.logger.warn('Skipping branch reset - uncommitted changes present', {
+      this.logger.warn("Skipping branch reset - uncommitted changes present", {
         currentBranch,
-        defaultBranch
+        defaultBranch,
       });
       return false;
     }
 
     await this.switchToBranch(defaultBranch);
-    this.logger.info('Reset to default branch', { from: currentBranch, to: defaultBranch });
+    this.logger.info("Reset to default branch", {
+      from: currentBranch,
+      to: defaultBranch,
+    });
     return true;
   }
 
-  async createOrSwitchToBranch(branchName: string, baseBranch?: string): Promise<void> {
-    await this.ensureCleanWorkingDirectory('switching branches');
+  async createOrSwitchToBranch(
+    branchName: string,
+    baseBranch?: string,
+  ): Promise<void> {
+    await this.ensureCleanWorkingDirectory("switching branches");
 
     const exists = await this.branchExists(branchName);
     if (exists) {
@@ -138,38 +153,41 @@ export class GitManager {
   }
 
   async addFiles(paths: string[]): Promise<void> {
-    const pathList = paths.map(p => `"${this.escapeShellArg(p)}"`).join(' ');
+    const pathList = paths.map((p) => `"${this.escapeShellArg(p)}"`).join(" ");
     await this.runGitCommand(`add ${pathList}`);
   }
 
   async addAllPostHogFiles(): Promise<void> {
     try {
       // Use -A flag to add all changes (including new files) and ignore errors if directory is empty
-      await this.runGitCommand('add -A .posthog/');
+      await this.runGitCommand("add -A .posthog/");
     } catch (error) {
       // If the directory doesn't exist or has no files, that's fine - just log and continue
-      this.logger.debug('No PostHog files to add', { error });
+      this.logger.debug("No PostHog files to add", { error });
     }
   }
 
-  async commitChanges(message: string, options?: {
-    authorName?: string;
-    authorEmail?: string;
-  }): Promise<string> {
+  async commitChanges(
+    message: string,
+    options?: {
+      authorName?: string;
+      authorEmail?: string;
+    },
+  ): Promise<string> {
     const command = this.buildCommitCommand(message, options);
     return await this.runGitCommand(command);
   }
 
   async hasChanges(): Promise<boolean> {
     try {
-      const status = await this.runGitCommand('status --porcelain');
+      const status = await this.runGitCommand("status --porcelain");
       if (!status || status.trim().length === 0) {
         return false;
       }
 
-      const lines = status.split('\n').filter(line => {
+      const lines = status.split("\n").filter((line) => {
         const trimmed = line.trim();
-        return trimmed.length > 0 && !trimmed.includes('.posthog/');
+        return trimmed.length > 0 && !trimmed.includes(".posthog/");
       });
 
       return lines.length > 0;
@@ -180,7 +198,7 @@ export class GitManager {
 
   async hasStagedChanges(): Promise<boolean> {
     try {
-      const status = await this.runGitCommand('diff --cached --name-only');
+      const status = await this.runGitCommand("diff --cached --name-only");
       return status.length > 0;
     } catch {
       return false;
@@ -190,12 +208,14 @@ export class GitManager {
   // Helper: Centralized safety check for uncommitted changes
   private async ensureCleanWorkingDirectory(operation: string): Promise<void> {
     if (await this.hasChanges()) {
-      throw new Error(`Uncommitted changes detected. Please commit or stash changes before ${operation}.`);
+      throw new Error(
+        `Uncommitted changes detected. Please commit or stash changes before ${operation}.`,
+      );
     }
   }
 
   private async generateUniqueBranchName(baseName: string): Promise<string> {
-    if (!await this.branchExists(baseName)) {
+    if (!(await this.branchExists(baseName))) {
       return baseName;
     }
 
@@ -213,18 +233,25 @@ export class GitManager {
     const currentBranch = await this.getCurrentBranch();
 
     if (currentBranch !== defaultBranch) {
-      await this.ensureCleanWorkingDirectory('switching to default branch');
+      await this.ensureCleanWorkingDirectory("switching to default branch");
       await this.switchToBranch(defaultBranch);
     }
 
     return defaultBranch;
   }
 
-  private buildCommitCommand(message: string, options?: { allowEmpty?: boolean; authorName?: string; authorEmail?: string }): string {
+  private buildCommitCommand(
+    message: string,
+    options?: {
+      allowEmpty?: boolean;
+      authorName?: string;
+      authorEmail?: string;
+    },
+  ): string {
     let command = `commit -m "${this.escapeShellArg(message)}"`;
 
     if (options?.allowEmpty) {
-      command += ' --allow-empty';
+      command += " --allow-empty";
     }
 
     const authorName = options?.authorName || this.authorName;
@@ -239,14 +266,14 @@ export class GitManager {
 
   async getRemoteUrl(): Promise<string | null> {
     try {
-      return await this.runGitCommand('remote get-url origin');
+      return await this.runGitCommand("remote get-url origin");
     } catch {
       return null;
     }
   }
 
   async pushBranch(branchName: string, force: boolean = false): Promise<void> {
-    const forceFlag = force ? '--force' : '';
+    const forceFlag = force ? "--force" : "";
     await this.runGitCommand(`push ${forceFlag} -u origin ${branchName}`);
   }
 
@@ -265,11 +292,11 @@ export class GitManager {
       push?: boolean;
     }) => Promise<{ commitCreated: boolean; pushedBranch: boolean }>;
   }> {
-    const initialSha = await this.getCommitSha('HEAD');
+    const initialSha = await this.getCommitSha("HEAD");
 
     return {
       finalize: async (options) => {
-        const currentSha = await this.getCommitSha('HEAD');
+        const currentSha = await this.getCommitSha("HEAD");
         const externalCommitsCreated = initialSha !== currentSha;
         const hasUncommittedChanges = await this.hasChanges();
 
@@ -282,7 +309,7 @@ export class GitManager {
 
         // Commit any remaining uncommitted changes
         if (hasUncommittedChanges) {
-          await this.runGitCommand('add .');
+          await this.runGitCommand("add .");
           const hasStagedChanges = await this.hasStagedChanges();
 
           if (hasStagedChanges) {
@@ -297,11 +324,13 @@ export class GitManager {
           const currentBranch = await this.getCurrentBranch();
           await this.pushBranch(currentBranch);
           pushedBranch = true;
-          this.logger.info('Pushed branch after operation', { branch: currentBranch });
+          this.logger.info("Pushed branch after operation", {
+            branch: currentBranch,
+          });
         }
 
         return { commitCreated, pushedBranch };
-      }
+      },
     };
   }
 
@@ -311,10 +340,10 @@ export class GitManager {
     // Ensure we're on default branch before creating task branch
     const defaultBranch = await this.ensureOnDefaultBranch();
 
-    this.logger.info('Creating task branch from default branch', {
+    this.logger.info("Creating task branch from default branch", {
       branchName,
       taskSlug,
-      baseBranch: defaultBranch
+      baseBranch: defaultBranch,
     });
 
     await this.createOrSwitchToBranch(branchName, defaultBranch);
@@ -322,26 +351,35 @@ export class GitManager {
     return branchName;
   }
 
-  async createTaskPlanningBranch(taskId: string, baseBranch?: string): Promise<string> {
+  async createTaskPlanningBranch(
+    taskId: string,
+    baseBranch?: string,
+  ): Promise<string> {
     const baseName = `posthog/task-${taskId}-planning`;
     const branchName = await this.generateUniqueBranchName(baseName);
 
-    this.logger.debug('Creating unique planning branch', { branchName, taskId });
+    this.logger.debug("Creating unique planning branch", {
+      branchName,
+      taskId,
+    });
 
-    const base = baseBranch || await this.ensureOnDefaultBranch();
+    const base = baseBranch || (await this.ensureOnDefaultBranch());
     await this.createBranch(branchName, base);
 
     return branchName;
   }
 
-  async createTaskImplementationBranch(taskId: string, planningBranchName?: string): Promise<string> {
+  async createTaskImplementationBranch(
+    taskId: string,
+    planningBranchName?: string,
+  ): Promise<string> {
     const baseName = `posthog/task-${taskId}-implementation`;
     const branchName = await this.generateUniqueBranchName(baseName);
 
-    this.logger.debug('Creating unique implementation branch', {
+    this.logger.debug("Creating unique implementation branch", {
       branchName,
       taskId,
-      currentBranch: await this.getCurrentBranch()
+      currentBranch: await this.getCurrentBranch(),
     });
 
     // Determine base branch: explicit param > current planning branch > default
@@ -349,21 +387,24 @@ export class GitManager {
 
     if (!baseBranch) {
       const currentBranch = await this.getCurrentBranch();
-      if (currentBranch.includes('-planning')) {
+      if (currentBranch.includes("-planning")) {
         baseBranch = currentBranch;
-        this.logger.debug('Using current planning branch', { baseBranch });
+        this.logger.debug("Using current planning branch", { baseBranch });
       } else {
         baseBranch = await this.ensureOnDefaultBranch();
-        this.logger.debug('Using default branch', { baseBranch });
+        this.logger.debug("Using default branch", { baseBranch });
       }
     }
 
-    this.logger.debug('Creating implementation branch from base', { baseBranch, branchName });
+    this.logger.debug("Creating implementation branch from base", {
+      baseBranch,
+      branchName,
+    });
     await this.createBranch(branchName, baseBranch);
 
-    this.logger.info('Implementation branch created', {
+    this.logger.info("Implementation branch created", {
       branchName,
-      currentBranch: await this.getCurrentBranch()
+      currentBranch: await this.getCurrentBranch(),
     });
 
     return branchName;
@@ -371,16 +412,16 @@ export class GitManager {
 
   async commitPlan(taskId: string, taskTitle: string): Promise<string> {
     const currentBranch = await this.getCurrentBranch();
-    this.logger.debug('Committing plan', { taskId, currentBranch });
+    this.logger.debug("Committing plan", { taskId, currentBranch });
 
     await this.addAllPostHogFiles();
 
     const hasChanges = await this.hasStagedChanges();
-    this.logger.debug('Checking for staged changes', { hasChanges });
+    this.logger.debug("Checking for staged changes", { hasChanges });
 
     if (!hasChanges) {
-      this.logger.info('No plan changes to commit', { taskId });
-      return 'No changes to commit';
+      this.logger.info("No plan changes to commit", { taskId });
+      return "No changes to commit";
     }
 
     const message = `📋 Add plan for task: ${taskTitle}
@@ -392,17 +433,21 @@ 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 });
+    this.logger.info("Plan committed", { taskId, taskTitle });
     return result;
   }
 
-  async commitImplementation(taskId: string, taskTitle: string, planSummary?: string): Promise<string> {
-    await this.runGitCommand('add .');
+  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';
+      this.logger.warn("No implementation changes to commit", { taskId });
+      return "No changes to commit";
     }
 
     let message = `✨ Implement task: ${taskTitle}
@@ -417,12 +462,15 @@ Generated by PostHog Agent`;
     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 });
+    this.logger.info("Implementation committed", { taskId, taskTitle });
     return result;
   }
 
-  async deleteBranch(branchName: string, force: boolean = false): Promise<void> {
-    const forceFlag = force ? '-D' : '-d';
+  async deleteBranch(
+    branchName: string,
+    force: boolean = false,
+  ): Promise<void> {
+    const forceFlag = force ? "-D" : "-d";
     await this.runGitCommand(`branch ${forceFlag} ${branchName}`);
   }
 
@@ -437,15 +485,15 @@ Generated by PostHog Agent`;
     return {
       name: branchName,
       exists,
-      isCurrentBranch: branchName === currentBranch
+      isCurrentBranch: branchName === currentBranch,
     };
   }
 
-  async getCommitSha(ref: string = 'HEAD'): Promise<string> {
+  async getCommitSha(ref: string = "HEAD"): Promise<string> {
     return await this.runGitCommand(`rev-parse ${ref}`);
   }
 
-  async getCommitMessage(ref: string = 'HEAD'): Promise<string> {
+  async getCommitMessage(ref: string = "HEAD"): Promise<string> {
     return await this.runGitCommand(`log -1 --pretty=%B ${ref}`);
   }
 
@@ -453,11 +501,11 @@ Generated by PostHog Agent`;
     branchName: string,
     title: string,
     body: string,
-    baseBranch?: string
+    baseBranch?: string,
   ): Promise<string> {
     const currentBranch = await this.getCurrentBranch();
     if (currentBranch !== branchName) {
-      await this.ensureCleanWorkingDirectory('creating PR');
+      await this.ensureCleanWorkingDirectory("creating PR");
       await this.switchToBranch(branchName);
     }
 
@@ -480,30 +528,35 @@ Generated by PostHog Agent`;
   async getTaskBranch(taskSlug: string): Promise<string | null> {
     try {
       // Get all branches matching the task slug pattern
-      const branches = await this.runGitCommand('branch --list --all');
+      const branches = await this.runGitCommand("branch --list --all");
       const branchPattern = `posthog/task-${taskSlug}`;
-      
+
       // Look for exact match or with counter suffix
-      const lines = branches.split('\n').map(l => l.trim().replace(/^\*\s+/, ''));
+      const lines = branches
+        .split("\n")
+        .map((l) => l.trim().replace(/^\*\s+/, ""));
       for (const line of lines) {
-        const cleanBranch = line.replace('remotes/origin/', '');
+        const cleanBranch = line.replace("remotes/origin/", "");
         if (cleanBranch.startsWith(branchPattern)) {
           return cleanBranch;
         }
       }
-      
+
       return null;
     } catch (error) {
-      this.logger.debug('Failed to get task branch', { taskSlug, error });
+      this.logger.debug("Failed to get task branch", { taskSlug, error });
       return null;
     }
   }
 
-  async commitAndPush(message: string, options?: { allowEmpty?: boolean }): Promise<void> {
+  async commitAndPush(
+    message: string,
+    options?: { allowEmpty?: boolean },
+  ): Promise<void> {
     const hasChanges = await this.hasStagedChanges();
 
     if (!hasChanges && !options?.allowEmpty) {
-      this.logger.debug('No changes to commit, skipping');
+      this.logger.debug("No changes to commit, skipping");
       return;
     }
 
@@ -514,6 +567,29 @@ Generated by PostHog Agent`;
     const currentBranch = await this.getCurrentBranch();
     await this.pushBranch(currentBranch);
 
-    this.logger.info('Committed and pushed changes', { branch: currentBranch, message });
+    this.logger.info("Committed and pushed changes", {
+      branch: currentBranch,
+      message,
+    });
+  }
+
+  async isWorktree(): Promise<boolean> {
+    try {
+      // In a worktree, .git is a file pointing to the main repo's .git/worktrees/{name}
+      // In a normal repo, .git is a directory
+      const result = await this.runGitCommand(
+        "rev-parse --git-common-dir --git-dir",
+      );
+      const lines = result.split("\n");
+      if (lines.length >= 2) {
+        const commonDir = lines[0].trim();
+        const gitDir = lines[1].trim();
+        // If they're different, we're in a worktree
+        return commonDir !== gitDir;
+      }
+      return false;
+    } catch {
+      return false;
+    }
   }
 }