@posthog/agent 1.24.2 → 1.25.0

package/src/worktree-manager.ts

@@ -0,0 +1,884 @@
+import { exec, execFile } from "node:child_process";
+import * as crypto from "node:crypto";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+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 {
+  mainRepoPath: string;
+  worktreeBasePath?: string;
+  logger?: Logger;
+}
+
+const ADJECTIVES = [
+  "swift",
+  "bright",
+  "calm",
+  "bold",
+  "gentle",
+  "quick",
+  "soft",
+  "warm",
+  "cool",
+  "wise",
+  "keen",
+  "brave",
+  "clear",
+  "crisp",
+  "deep",
+  "fair",
+  "fine",
+  "free",
+  "glad",
+  "good",
+  "grand",
+  "great",
+  "happy",
+  "kind",
+  "light",
+  "lively",
+  "neat",
+  "nice",
+  "plain",
+  "proud",
+  "pure",
+  "rare",
+  "rich",
+  "safe",
+  "sharp",
+  "shy",
+  "simple",
+  "slim",
+  "smart",
+  "smooth",
+  "solid",
+  "sound",
+  "spare",
+  "stable",
+  "steady",
+  "still",
+  "strong",
+  "sure",
+  "sweet",
+  "tall",
+  "agile",
+  "ancient",
+  "autumn",
+  "azure",
+  "cosmic",
+  "daring",
+  "dawn",
+  "dusty",
+  "eager",
+  "early",
+  "endless",
+  "fading",
+  "fallen",
+  "famous",
+  "feral",
+  "fierce",
+  "fleet",
+  "foggy",
+  "forest",
+  "frozen",
+  "gleeful",
+  "golden",
+  "hazy",
+  "hidden",
+  "hollow",
+  "humble",
+  "hushed",
+  "icy",
+  "inner",
+  "late",
+  "lazy",
+  "little",
+  "lone",
+  "long",
+  "lost",
+  "lucky",
+  "lunar",
+  "magic",
+  "mellow",
+  "mighty",
+  "misty",
+  "modest",
+  "mossy",
+  "mystic",
+  "nimble",
+  "noble",
+  "ocean",
+  "outer",
+  "pale",
+  "paper",
+  "patient",
+  "peaceful",
+  "phantom",
+  "polite",
+  "primal",
+  "quiet",
+  "rapid",
+  "restless",
+  "rising",
+  "roaming",
+  "rocky",
+  "rustic",
+  "sacred",
+  "sandy",
+  "secret",
+  "serene",
+  "shadow",
+  "shining",
+  "silent",
+  "silky",
+  "silver",
+  "sleek",
+  "snowy",
+  "solar",
+  "solemn",
+  "spring",
+  "starry",
+  "stormy",
+  "summer",
+  "sunny",
+  "tender",
+  "thorny",
+  "tiny",
+  "tranquil",
+  "twilight",
+  "upward",
+  "velvet",
+  "vivid",
+  "wandering",
+  "wary",
+  "wild",
+  "windy",
+  "winter",
+  "wispy",
+  "young",
+];
+
+const COLORS = [
+  "blue",
+  "red",
+  "green",
+  "amber",
+  "coral",
+  "jade",
+  "pearl",
+  "ruby",
+  "sage",
+  "teal",
+  "gold",
+  "silver",
+  "bronze",
+  "copper",
+  "ivory",
+  "onyx",
+  "opal",
+  "rose",
+  "slate",
+  "violet",
+  "aqua",
+  "azure",
+  "beige",
+  "black",
+  "brass",
+  "brick",
+  "brown",
+  "cedar",
+  "charcoal",
+  "cherry",
+  "chestnut",
+  "chrome",
+  "cider",
+  "cinnamon",
+  "citrus",
+  "clay",
+  "cloud",
+  "cobalt",
+  "cocoa",
+  "cream",
+  "crimson",
+  "crystal",
+  "cyan",
+  "denim",
+  "dusk",
+  "ebony",
+  "ember",
+  "emerald",
+  "fern",
+  "flame",
+  "flint",
+  "forest",
+  "frost",
+  "garnet",
+  "ginger",
+  "glacier",
+  "granite",
+  "grape",
+  "gray",
+  "hazel",
+  "honey",
+  "indigo",
+  "iron",
+  "lapis",
+  "lava",
+  "lavender",
+  "lemon",
+  "lilac",
+  "lime",
+  "magenta",
+  "mahogany",
+  "maple",
+  "marble",
+  "maroon",
+  "mauve",
+  "midnight",
+  "mint",
+  "mocha",
+  "moss",
+  "mustard",
+  "navy",
+  "nickel",
+  "obsidian",
+  "ochre",
+  "olive",
+  "orange",
+  "orchid",
+  "peach",
+  "pine",
+  "pink",
+  "plum",
+  "porcelain",
+  "purple",
+  "quartz",
+  "rust",
+  "saffron",
+  "salmon",
+  "sand",
+  "sapphire",
+  "scarlet",
+  "sepia",
+  "shadow",
+  "sienna",
+  "smoke",
+  "snow",
+  "steel",
+  "stone",
+  "storm",
+  "sunset",
+  "tan",
+  "tangerine",
+  "taupe",
+  "terra",
+  "timber",
+  "topaz",
+  "turquoise",
+  "umber",
+  "vanilla",
+  "walnut",
+  "wheat",
+  "white",
+  "wine",
+  "yellow",
+];
+
+const ANIMALS = [
+  "fox",
+  "owl",
+  "bear",
+  "wolf",
+  "hawk",
+  "deer",
+  "lynx",
+  "otter",
+  "raven",
+  "falcon",
+  "badger",
+  "beaver",
+  "bison",
+  "bobcat",
+  "crane",
+  "eagle",
+  "ferret",
+  "finch",
+  "gopher",
+  "heron",
+  "jaguar",
+  "koala",
+  "lemur",
+  "marten",
+  "mink",
+  "moose",
+  "newt",
+  "ocelot",
+  "osprey",
+  "panda",
+  "parrot",
+  "pelican",
+  "puma",
+  "quail",
+  "rabbit",
+  "raccoon",
+  "salmon",
+  "seal",
+  "shark",
+  "shrew",
+  "sloth",
+  "snake",
+  "spider",
+  "squid",
+  "stork",
+  "swan",
+  "tiger",
+  "toucan",
+  "turtle",
+  "whale",
+  "albatross",
+  "ant",
+  "antelope",
+  "armadillo",
+  "baboon",
+  "bat",
+  "bee",
+  "beetle",
+  "buffalo",
+  "butterfly",
+  "camel",
+  "cardinal",
+  "caribou",
+  "catfish",
+  "cheetah",
+  "chipmunk",
+  "cicada",
+  "clam",
+  "cobra",
+  "condor",
+  "corgi",
+  "cougar",
+  "coyote",
+  "crab",
+  "cricket",
+  "crow",
+  "dolphin",
+  "donkey",
+  "dove",
+  "dragonfly",
+  "duck",
+  "eel",
+  "egret",
+  "elephant",
+  "elk",
+  "emu",
+  "firefly",
+  "flamingo",
+  "frog",
+  "gazelle",
+  "gecko",
+  "gibbon",
+  "giraffe",
+  "goat",
+  "goose",
+  "gorilla",
+  "grasshopper",
+  "grouse",
+  "gull",
+  "hamster",
+  "hare",
+  "hedgehog",
+  "hippo",
+  "hornet",
+  "horse",
+  "hound",
+  "hummingbird",
+  "hyena",
+  "ibis",
+  "iguana",
+  "impala",
+  "jackal",
+  "jay",
+  "jellyfish",
+  "kangaroo",
+  "kestrel",
+  "kingfisher",
+  "kite",
+  "kiwi",
+  "lark",
+  "leopard",
+  "lion",
+  "lizard",
+  "llama",
+  "lobster",
+  "loon",
+  "macaw",
+  "magpie",
+  "mallard",
+  "mammoth",
+  "manatee",
+  "mantis",
+  "marlin",
+  "marmot",
+  "meerkat",
+  "mockingbird",
+  "mole",
+  "mongoose",
+  "monkey",
+  "moth",
+  "mouse",
+  "mule",
+  "narwhal",
+  "nightingale",
+  "octopus",
+  "opossum",
+  "orangutan",
+  "oriole",
+  "ostrich",
+  "oyster",
+  "panther",
+  "peacock",
+  "penguin",
+  "pheasant",
+  "pig",
+  "pigeon",
+  "pike",
+  "piranha",
+  "platypus",
+  "pony",
+  "porcupine",
+  "porpoise",
+  "python",
+  "raven",
+  "ray",
+  "reindeer",
+  "rhino",
+  "robin",
+  "rooster",
+  "salamander",
+  "sandpiper",
+  "sardine",
+  "scorpion",
+  "seagull",
+  "seahorse",
+  "skunk",
+  "snail",
+  "sparrow",
+  "squirrel",
+  "starfish",
+  "starling",
+  "stingray",
+  "swallow",
+  "tapir",
+  "termite",
+  "tern",
+  "toad",
+  "trout",
+  "tuna",
+  "viper",
+  "vulture",
+  "walrus",
+  "wasp",
+  "weasel",
+  "wombat",
+  "woodpecker",
+  "wren",
+  "yak",
+  "zebra",
+];
+
+const WORKTREE_FOLDER_NAME = ".array";
+
+export class WorktreeManager {
+  private mainRepoPath: string;
+  private worktreeBasePath: string | null;
+  private repoName: string;
+  private logger: Logger;
+
+  constructor(config: WorktreeConfig) {
+    this.mainRepoPath = config.mainRepoPath;
+    this.worktreeBasePath = config.worktreeBasePath || null;
+    this.repoName = path.basename(config.mainRepoPath);
+    this.logger =
+      config.logger ||
+      new Logger({ debug: false, prefix: "[WorktreeManager]" });
+  }
+
+  private usesExternalPath(): boolean {
+    return this.worktreeBasePath !== null;
+  }
+
+  private async runGitCommand(command: string): Promise<string> {
+    try {
+      const { stdout } = await execAsync(`git ${command}`, {
+        cwd: this.mainRepoPath,
+      });
+      return stdout.trim();
+    } catch (error) {
+      throw new Error(`Git command failed: ${command}\n${error}`);
+    }
+  }
+
+  private randomElement<T>(array: T[]): T {
+    return array[crypto.randomInt(array.length)];
+  }
+
+  generateWorktreeName(): string {
+    const adjective = this.randomElement(ADJECTIVES);
+    const color = this.randomElement(COLORS);
+    const animal = this.randomElement(ANIMALS);
+    return `${adjective}-${color}-${animal}`;
+  }
+
+  private getWorktreeFolderPath(): string {
+    if (this.worktreeBasePath) {
+      return path.join(this.worktreeBasePath, this.repoName);
+    }
+    return path.join(this.mainRepoPath, WORKTREE_FOLDER_NAME);
+  }
+
+  private getWorktreePath(name: string): string {
+    return path.join(this.getWorktreeFolderPath(), name);
+  }
+
+  async worktreeExists(name: string): Promise<boolean> {
+    const worktreePath = this.getWorktreePath(name);
+    try {
+      await fs.access(worktreePath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  async ensureArrayDirIgnored(): Promise<void> {
+    // Use .git/info/exclude instead of .gitignore to avoid modifying tracked files
+    const excludePath = path.join(this.mainRepoPath, ".git", "info", "exclude");
+    const ignorePattern = `/${WORKTREE_FOLDER_NAME}/`;
+
+    let content = "";
+    try {
+      content = await fs.readFile(excludePath, "utf-8");
+    } catch {
+      // File doesn't exist or .git/info doesn't exist
+    }
+
+    // Check if pattern is already present
+    if (
+      content.includes(`/${WORKTREE_FOLDER_NAME}/`) ||
+      content.includes(`/${WORKTREE_FOLDER_NAME}`)
+    ) {
+      this.logger.debug("Exclude file already contains .array folder pattern");
+      return;
+    }
+
+    // Ensure .git/info directory exists
+    const infoDir = path.join(this.mainRepoPath, ".git", "info");
+    await fs.mkdir(infoDir, { recursive: true });
+
+    // Append the pattern
+    const newContent = `${content.trimEnd()}\n\n# Array worktrees\n${ignorePattern}\n`;
+    await fs.writeFile(excludePath, newContent);
+    this.logger.info("Added .array folder to .git/info/exclude");
+  }
+
+  private async generateUniqueWorktreeName(): Promise<string> {
+    let name = this.generateWorktreeName();
+    let attempts = 0;
+    const maxAttempts = 100;
+
+    while ((await this.worktreeExists(name)) && attempts < maxAttempts) {
+      name = this.generateWorktreeName();
+      attempts++;
+    }
+
+    if (attempts >= maxAttempts) {
+      // Fallback: append timestamp
+      name = `${this.generateWorktreeName()}-${Date.now()}`;
+    }
+
+    return name;
+  }
+
+  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.",
+          );
+        }
+      }
+    }
+  }
+
+  async createWorktree(): Promise<WorktreeInfo> {
+    // 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()) {
+      const folderPath = this.getWorktreeFolderPath();
+      await fs.mkdir(folderPath, { recursive: true });
+    }
+
+    // Generate unique worktree name
+    const worktreeName = await this.generateUniqueWorktreeName();
+    const worktreePath = this.getWorktreePath(worktreeName);
+    const branchName = `posthog/${worktreeName}`;
+    const baseBranch = await this.getDefaultBranch();
+
+    this.logger.info("Creating worktree", {
+      worktreeName,
+      worktreePath,
+      branchName,
+      baseBranch,
+      external: this.usesExternalPath(),
+    });
+
+    // Create the worktree with a new branch
+    if (this.usesExternalPath()) {
+      // Use absolute path for external worktrees
+      await this.runGitCommand(
+        `worktree add -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 createdAt = new Date().toISOString();
+
+    this.logger.info("Worktree created successfully", {
+      worktreeName,
+      worktreePath,
+      branchName,
+    });
+
+    return {
+      worktreePath,
+      worktreeName,
+      branchName,
+      baseBranch,
+      createdAt,
+    };
+  }
+
+  async deleteWorktree(worktreePath: string): Promise<void> {
+    this.logger.info("Deleting worktree", { worktreePath });
+
+    try {
+      // First, try to remove the worktree via git using execFileAsync for safety
+      await execFileAsync(
+        "git",
+        ["worktree", "remove", worktreePath, "--force"],
+        {
+          cwd: this.mainRepoPath,
+        },
+      );
+      this.logger.info("Worktree deleted successfully", { worktreePath });
+    } catch (error) {
+      this.logger.warn(
+        "Git worktree remove failed, attempting manual cleanup",
+        {
+          worktreePath,
+          error,
+        },
+      );
+
+      // Manual cleanup if git command fails
+      try {
+        await fs.rm(worktreePath, { recursive: true, force: true });
+        // Also prune the worktree list
+        await this.runGitCommand("worktree prune");
+        this.logger.info("Worktree cleaned up manually", { worktreePath });
+      } catch (cleanupError) {
+        this.logger.error("Failed to cleanup worktree", {
+          worktreePath,
+          cleanupError,
+        });
+        throw cleanupError;
+      }
+    }
+  }
+
+  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 worktrees = this.parseWorktreeList(output);
+
+      const worktree = worktrees.find((w) => w.worktreePath === worktreePath);
+      return worktree || null;
+    } catch (error) {
+      this.logger.debug("Failed to get worktree info", { worktreePath, error });
+      return null;
+    }
+  }
+
+  async listWorktrees(): Promise<WorktreeInfo[]> {
+    try {
+      const output = await this.runGitCommand("worktree list --porcelain");
+      return this.parseWorktreeList(output);
+    } catch (error) {
+      this.logger.debug("Failed to list worktrees", { error });
+      return [];
+    }
+  }
+
+  private parseWorktreeList(output: string): WorktreeInfo[] {
+    const worktrees: WorktreeInfo[] = [];
+    const entries = output.split("\n\n").filter((e) => e.trim());
+    const worktreeFolderPath = this.getWorktreeFolderPath();
+
+    for (const entry of entries) {
+      const lines = entry.split("\n");
+      let worktreePath = "";
+      let branchName = "";
+
+      for (const line of lines) {
+        if (line.startsWith("worktree ")) {
+          worktreePath = line.replace("worktree ", "");
+        } else if (line.startsWith("branch refs/heads/")) {
+          branchName = line.replace("branch refs/heads/", "");
+        }
+      }
+
+      // Include worktrees that:
+      // 1. Are in our worktree folder (external or in-repo)
+      // 2. Have a posthog/ branch prefix (our naming convention)
+      const isInWorktreeFolder = worktreePath?.startsWith(worktreeFolderPath);
+      const isPosthogBranch = branchName?.startsWith("posthog/");
+
+      if (
+        worktreePath &&
+        branchName &&
+        (isInWorktreeFolder || isPosthogBranch)
+      ) {
+        const worktreeName = path.basename(worktreePath);
+        worktrees.push({
+          worktreePath,
+          worktreeName,
+          branchName,
+          baseBranch: "",
+          createdAt: "",
+        });
+      }
+    }
+
+    return worktrees;
+  }
+
+  async isWorktree(repoPath: string): Promise<boolean> {
+    try {
+      const { stdout } = await execAsync(
+        "git rev-parse --is-inside-work-tree",
+        { cwd: repoPath },
+      );
+      if (stdout.trim() !== "true") {
+        return false;
+      }
+
+      // Check if there's a .git file (worktrees have a .git file, not a .git directory)
+      const gitPath = path.join(repoPath, ".git");
+      const stat = await fs.stat(gitPath);
+      return stat.isFile(); // Worktrees have .git as a file, main repos have .git as a directory
+    } catch {
+      return false;
+    }
+  }
+
+  async getMainRepoPathFromWorktree(
+    worktreePath: string,
+  ): Promise<string | null> {
+    try {
+      const gitFilePath = path.join(worktreePath, ".git");
+      const content = await fs.readFile(gitFilePath, "utf-8");
+
+      // The .git file in a worktree contains: gitdir: /path/to/main/.git/worktrees/name
+      const match = content.match(/gitdir:\s*(.+)/);
+      if (match) {
+        const gitDir = match[1].trim();
+        // Go up from .git/worktrees/name to get the main repo path
+        // The gitdir points to something like: /main/repo/.git/worktrees/worktree-name
+        const mainGitDir = path.resolve(gitDir, "..", "..", "..");
+        return mainGitDir;
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  }
+
+  async cleanupOrphanedWorktrees(associatedWorktreePaths: string[]): Promise<{
+    deleted: string[];
+    errors: Array<{ path: string; error: string }>;
+  }> {
+    this.logger.info("Starting cleanup of orphaned worktrees");
+
+    const allWorktrees = await this.listWorktrees();
+    const deleted: string[] = [];
+    const errors: Array<{ path: string; error: string }> = [];
+
+    const associatedPathsSet = new Set(
+      associatedWorktreePaths.map((p) => path.resolve(p)),
+    );
+
+    for (const worktree of allWorktrees) {
+      const resolvedPath = path.resolve(worktree.worktreePath);
+
+      if (!associatedPathsSet.has(resolvedPath)) {
+        this.logger.info("Found orphaned worktree", {
+          path: worktree.worktreePath,
+        });
+
+        try {
+          await this.deleteWorktree(worktree.worktreePath);
+          deleted.push(worktree.worktreePath);
+          this.logger.info("Deleted orphaned worktree", {
+            path: worktree.worktreePath,
+          });
+        } catch (error) {
+          const errorMessage =
+            error instanceof Error ? error.message : String(error);
+          errors.push({
+            path: worktree.worktreePath,
+            error: errorMessage,
+          });
+          this.logger.error("Failed to delete orphaned worktree", {
+            path: worktree.worktreePath,
+            error: errorMessage,
+          });
+        }
+      }
+    }
+
+    this.logger.info("Cleanup completed", {
+      deleted: deleted.length,
+      errors: errors.length,
+    });
+
+    return { deleted, errors };
+  }
+}