@posthog/agent 1.24.0 → 1.24.2

package/src/git-manager.ts

@@ -1,6 +1,6 @@
-import { exec } from "node:child_process";
-import { promisify } from "node:util";
-import { Logger } from "./utils/logger.js";
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { Logger } from './utils/logger.js';
 
 const execAsync = promisify(exec);
 
@@ -27,23 +27,20 @@ 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}`);
@@ -52,9 +49,7 @@ 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}`);
@@ -63,7 +58,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;
@@ -71,26 +66,22 @@ 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.');
       }
     }
   }
@@ -105,7 +96,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}`);
   }
 
@@ -118,31 +109,25 @@ 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) {
@@ -153,41 +138,38 @@ 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;
@@ -198,7 +180,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;
@@ -208,14 +190,12 @@ 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;
     }
 
@@ -233,25 +213,18 @@ 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;
@@ -266,14 +239,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}`);
   }
 
@@ -292,11 +265,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();
 
@@ -309,7 +282,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) {
@@ -324,13 +297,11 @@ 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 };
-      },
+      }
     };
   }
 
@@ -340,10 +311,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);
@@ -351,35 +322,26 @@ 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
@@ -387,24 +349,21 @@ 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;
@@ -412,16 +371,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}
@@ -433,21 +392,17 @@ 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}
@@ -462,15 +417,12 @@ 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}`);
   }
 
@@ -485,15 +437,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}`);
   }
 
@@ -501,11 +453,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);
     }
 
@@ -528,35 +480,30 @@ 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;
     }
 
@@ -567,9 +514,6 @@ 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 });
   }
 }