@posthog/agent 1.26.0 → 1.28.0

package/dist/src/worktree-manager.js

@@ -1,808 +0,0 @@
-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