@posthog/agent 1.24.2 → 1.26.0

package/dist/src/worktree-manager.js

@@ -0,0 +1,808 @@
+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 { Logger } from './utils/logger.js';
+
+const execAsync = promisify(exec);
+const execFileAsync = promisify(execFile);
+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";
+class WorktreeManager {
+    mainRepoPath;
+    worktreeBasePath;
+    repoName;
+    logger;
+    constructor(config) {
+        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]" });
+    }
+    usesExternalPath() {
+        return this.worktreeBasePath !== null;
+    }
+    async runGitCommand(command) {
+        try {
+            const { stdout } = await execAsync(`git ${command}`, {
+                cwd: this.mainRepoPath,
+            });
+            return stdout.trim();
+        }
+        catch (error) {
+            throw new Error(`Git command failed: ${command}\n${error}`);
+        }
+    }
+    randomElement(array) {
+        return array[crypto.randomInt(array.length)];
+    }
+    generateWorktreeName() {
+        const adjective = this.randomElement(ADJECTIVES);
+        const color = this.randomElement(COLORS);
+        const animal = this.randomElement(ANIMALS);
+        return `${adjective}-${color}-${animal}`;
+    }
+    getWorktreeFolderPath() {
+        if (this.worktreeBasePath) {
+            return path.join(this.worktreeBasePath, this.repoName);
+        }
+        return path.join(this.mainRepoPath, WORKTREE_FOLDER_NAME);
+    }
+    getWorktreePath(name) {
+        return path.join(this.getWorktreeFolderPath(), name);
+    }
+    async worktreeExists(name) {
+        const worktreePath = this.getWorktreePath(name);
+        try {
+            await fs.access(worktreePath);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async ensureArrayDirIgnored() {
+        // 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");
+    }
+    async generateUniqueWorktreeName() {
+        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;
+    }
+    async getDefaultBranch() {
+        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() {
+        // 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 = `array/${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) {
+        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) {
+        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() {
+        try {
+            const output = await this.runGitCommand("worktree list --porcelain");
+            return this.parseWorktreeList(output);
+        }
+        catch (error) {
+            this.logger.debug("Failed to list worktrees", { error });
+            return [];
+        }
+    }
+    parseWorktreeList(output) {
+        const worktrees = [];
+        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 isArrayBranch = branchName?.startsWith("array/") || branchName?.startsWith("posthog/");
+            if (worktreePath && branchName && (isInWorktreeFolder || isArrayBranch)) {
+                const worktreeName = path.basename(worktreePath);
+                worktrees.push({
+                    worktreePath,
+                    worktreeName,
+                    branchName,
+                    baseBranch: "",
+                    createdAt: "",
+                });
+            }
+        }
+        return worktrees;
+    }
+    async isWorktree(repoPath) {
+        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) {
+        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) {
+        this.logger.info("Starting cleanup of orphaned worktrees");
+        const allWorktrees = await this.listWorktrees();
+        const deleted = [];
+        const errors = [];
+        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 };
+    }
+}
+
+export { WorktreeManager };
+//# sourceMappingURL=worktree-manager.js.map