@getpaseo/server 0.1.37 → 0.1.38

package/dist/src/utils/worktree.js

@@ -1,744 +0,0 @@
-import { exec, spawn } from "child_process";
-import { promisify } from "util";
-import { existsSync, mkdirSync, readFileSync, realpathSync, rmSync, statSync } from "fs";
-import { join, basename, dirname, resolve, sep } from "path";
-import net from "node:net";
-import { createHash } from "node:crypto";
-import { createNameId } from "mnemonic-id";
-import { normalizeBaseRefName, readPaseoWorktreeMetadata, readPaseoWorktreeRuntimePort, writePaseoWorktreeMetadata, writePaseoWorktreeRuntimeMetadata, } from "./worktree-metadata.js";
-import { resolvePaseoHome } from "../server/paseo-home.js";
-const execAsync = promisify(exec);
-const READ_ONLY_GIT_ENV = {
-    ...process.env,
-    GIT_OPTIONAL_LOCKS: "0",
-};
-export class WorktreeSetupError extends Error {
-    constructor(message, results) {
-        super(message);
-        this.name = "WorktreeSetupError";
-        this.results = results;
-    }
-}
-export class WorktreeDestroyError extends Error {
-    constructor(message, results) {
-        super(message);
-        this.name = "WorktreeDestroyError";
-        this.results = results;
-    }
-}
-function readPaseoConfig(repoRoot) {
-    const paseoConfigPath = join(repoRoot, "paseo.json");
-    if (!existsSync(paseoConfigPath)) {
-        return null;
-    }
-    try {
-        return JSON.parse(readFileSync(paseoConfigPath, "utf8"));
-    }
-    catch {
-        throw new Error(`Failed to parse paseo.json`);
-    }
-}
-export function getWorktreeSetupCommands(repoRoot) {
-    const config = readPaseoConfig(repoRoot);
-    const setupCommands = config?.worktree?.setup;
-    if (!setupCommands || setupCommands.length === 0) {
-        return [];
-    }
-    return setupCommands.filter((cmd) => typeof cmd === "string" && cmd.trim().length > 0);
-}
-export function getWorktreeDestroyCommands(repoRoot) {
-    const config = readPaseoConfig(repoRoot);
-    const destroyCommands = config?.worktree?.destroy;
-    if (!destroyCommands || destroyCommands.length === 0) {
-        return [];
-    }
-    return destroyCommands.filter((cmd) => typeof cmd === "string" && cmd.trim().length > 0);
-}
-export function getWorktreeTerminalSpecs(repoRoot) {
-    const config = readPaseoConfig(repoRoot);
-    const terminals = config?.worktree?.terminals;
-    if (!Array.isArray(terminals) || terminals.length === 0) {
-        return [];
-    }
-    const specs = [];
-    for (const terminal of terminals) {
-        if (!terminal || typeof terminal !== "object") {
-            continue;
-        }
-        const rawCommand = terminal.command;
-        if (typeof rawCommand !== "string") {
-            continue;
-        }
-        const command = rawCommand.trim();
-        if (!command) {
-            continue;
-        }
-        const rawName = terminal.name;
-        const name = typeof rawName === "string" && rawName.trim().length > 0 ? rawName.trim() : undefined;
-        specs.push({
-            ...(name ? { name } : {}),
-            command,
-        });
-    }
-    return specs;
-}
-async function execSetupCommand(command, options) {
-    const startedAt = Date.now();
-    try {
-        const { stdout, stderr } = await execAsync(command, {
-            cwd: options.cwd,
-            env: options.env,
-            shell: "/bin/bash",
-        });
-        return {
-            command,
-            cwd: options.cwd,
-            stdout: stdout ?? "",
-            stderr: stderr ?? "",
-            exitCode: 0,
-            durationMs: Date.now() - startedAt,
-        };
-    }
-    catch (error) {
-        return {
-            command,
-            cwd: options.cwd,
-            stdout: error?.stdout ?? "",
-            stderr: error?.stderr ?? (error instanceof Error ? error.message : String(error)),
-            exitCode: typeof error?.code === "number" ? error.code : null,
-            durationMs: Date.now() - startedAt,
-        };
-    }
-}
-async function execSetupCommandStreamed(options) {
-    return new Promise((resolve) => {
-        const startedAt = Date.now();
-        const stdoutChunks = [];
-        const stderrChunks = [];
-        let settled = false;
-        const finish = (exitCode) => {
-            if (settled) {
-                return;
-            }
-            settled = true;
-            const result = {
-                command: options.command,
-                cwd: options.cwd,
-                stdout: stdoutChunks.join(""),
-                stderr: stderrChunks.join(""),
-                exitCode,
-                durationMs: Date.now() - startedAt,
-            };
-            options.onEvent?.({
-                type: "command_completed",
-                index: options.index,
-                total: options.total,
-                command: options.command,
-                cwd: options.cwd,
-                exitCode: result.exitCode,
-                durationMs: result.durationMs,
-                stdout: result.stdout,
-                stderr: result.stderr,
-            });
-            resolve(result);
-        };
-        options.onEvent?.({
-            type: "command_started",
-            index: options.index,
-            total: options.total,
-            command: options.command,
-            cwd: options.cwd,
-        });
-        const child = spawn("/bin/bash", ["-lc", options.command], {
-            cwd: options.cwd,
-            env: options.env,
-            stdio: ["ignore", "pipe", "pipe"],
-        });
-        child.stdout?.on("data", (chunk) => {
-            const text = chunk.toString();
-            stdoutChunks.push(text);
-            options.onEvent?.({
-                type: "output",
-                index: options.index,
-                total: options.total,
-                command: options.command,
-                cwd: options.cwd,
-                stream: "stdout",
-                chunk: text,
-            });
-        });
-        child.stderr?.on("data", (chunk) => {
-            const text = chunk.toString();
-            stderrChunks.push(text);
-            options.onEvent?.({
-                type: "output",
-                index: options.index,
-                total: options.total,
-                command: options.command,
-                cwd: options.cwd,
-                stream: "stderr",
-                chunk: text,
-            });
-        });
-        child.on("error", (error) => {
-            stderrChunks.push(error instanceof Error ? error.message : String(error));
-            finish(null);
-        });
-        child.on("close", (code) => {
-            finish(typeof code === "number" ? code : null);
-        });
-    });
-}
-async function getAvailablePort() {
-    return new Promise((resolve, reject) => {
-        const server = net.createServer();
-        server.once("error", reject);
-        server.listen(0, () => {
-            const address = server.address();
-            if (!address || typeof address === "string") {
-                server.close(() => reject(new Error("Failed to acquire available port")));
-                return;
-            }
-            server.close((error) => {
-                if (error) {
-                    reject(error);
-                    return;
-                }
-                resolve(address.port);
-            });
-        });
-    });
-}
-async function assertPortAvailable(port) {
-    await new Promise((resolve, reject) => {
-        const server = net.createServer();
-        server.once("error", (error) => {
-            const message = error?.code === "EADDRINUSE"
-                ? `Persisted worktree port ${port} is already in use`
-                : error instanceof Error
-                    ? error.message
-                    : String(error);
-            reject(new Error(message));
-        });
-        server.listen(port, () => {
-            server.close((error) => {
-                if (error) {
-                    reject(error);
-                    return;
-                }
-                resolve();
-            });
-        });
-    });
-}
-async function inferRepoRootPathFromWorktreePath(worktreePath) {
-    try {
-        const commonDir = await getGitCommonDir(worktreePath);
-        const normalizedCommonDir = normalizePathForOwnership(commonDir);
-        // Normal repo/worktree: common dir is <repoRoot>/.git
-        if (basename(normalizedCommonDir) === ".git") {
-            return dirname(normalizedCommonDir);
-        }
-        // Bare repo: common dir is the repo dir itself
-        return normalizedCommonDir;
-    }
-    catch {
-        // Fallback: best-effort resolve toplevel (will be the worktree root in typical cases)
-        try {
-            const { stdout } = await execAsync("git rev-parse --path-format=absolute --show-toplevel", {
-                cwd: worktreePath,
-                env: READ_ONLY_GIT_ENV,
-            });
-            const topLevel = stdout.trim();
-            if (topLevel) {
-                return normalizePathForOwnership(topLevel);
-            }
-        }
-        catch {
-            // ignore
-        }
-        return normalizePathForOwnership(worktreePath);
-    }
-}
-export async function runWorktreeSetupCommands(options) {
-    // Read paseo.json from the worktree (it will have the same content as the source repo)
-    const setupCommands = getWorktreeSetupCommands(options.worktreePath);
-    if (setupCommands.length === 0) {
-        return [];
-    }
-    const runtimeEnv = options.runtimeEnv ??
-        (await resolveWorktreeRuntimeEnv({
-            worktreePath: options.worktreePath,
-            branchName: options.branchName,
-            ...(options.repoRootPath ? { repoRootPath: options.repoRootPath } : {}),
-        }));
-    const setupEnv = {
-        ...process.env,
-        ...runtimeEnv,
-    };
-    const results = [];
-    for (const [index, cmd] of setupCommands.entries()) {
-        const result = options.onEvent
-            ? await execSetupCommandStreamed({
-                command: cmd,
-                cwd: options.worktreePath,
-                env: setupEnv,
-                index: index + 1,
-                total: setupCommands.length,
-                onEvent: options.onEvent,
-            })
-            : await execSetupCommand(cmd, {
-                cwd: options.worktreePath,
-                env: setupEnv,
-            });
-        results.push(result);
-        if (result.exitCode !== 0) {
-            if (options.cleanupOnFailure) {
-                try {
-                    await execAsync(`git worktree remove "${options.worktreePath}" --force`, {
-                        cwd: options.worktreePath,
-                    });
-                }
-                catch {
-                    rmSync(options.worktreePath, { recursive: true, force: true });
-                }
-            }
-            throw new WorktreeSetupError(`Worktree setup command failed: ${cmd}\n${result.stderr}`.trim(), results);
-        }
-    }
-    return results;
-}
-async function resolveBranchNameForWorktreePath(worktreePath) {
-    try {
-        const { stdout } = await execAsync("git branch --show-current", {
-            cwd: worktreePath,
-            env: READ_ONLY_GIT_ENV,
-        });
-        const branchName = stdout.trim();
-        if (branchName.length > 0) {
-            return branchName;
-        }
-    }
-    catch {
-        // ignore
-    }
-    return basename(worktreePath);
-}
-export async function resolveWorktreeRuntimeEnv(options) {
-    const repoRootPath = options.repoRootPath ?? (await inferRepoRootPathFromWorktreePath(options.worktreePath));
-    const branchName = options.branchName ?? (await resolveBranchNameForWorktreePath(options.worktreePath));
-    let worktreePort = readPaseoWorktreeRuntimePort(options.worktreePath);
-    if (worktreePort === null) {
-        worktreePort = await getAvailablePort();
-        const metadata = readPaseoWorktreeMetadata(options.worktreePath);
-        if (metadata) {
-            writePaseoWorktreeRuntimeMetadata(options.worktreePath, { worktreePort });
-        }
-    }
-    else {
-        await assertPortAvailable(worktreePort);
-    }
-    return {
-        // Source checkout path is the original git repo root (shared across worktrees), not the
-        // worktree itself. This allows setup scripts to copy local files (e.g. .env) from the
-        // source checkout.
-        PASEO_SOURCE_CHECKOUT_PATH: repoRootPath,
-        // Backward-compatible alias.
-        PASEO_ROOT_PATH: repoRootPath,
-        PASEO_WORKTREE_PATH: options.worktreePath,
-        PASEO_BRANCH_NAME: branchName,
-        PASEO_WORKTREE_PORT: String(worktreePort),
-    };
-}
-export async function runWorktreeDestroyCommands(options) {
-    // Read paseo.json from the worktree (it will have the same content as the source repo)
-    const destroyCommands = getWorktreeDestroyCommands(options.worktreePath);
-    if (destroyCommands.length === 0) {
-        return [];
-    }
-    const repoRootPath = options.repoRootPath ?? (await inferRepoRootPathFromWorktreePath(options.worktreePath));
-    const branchName = options.branchName ?? (await resolveBranchNameForWorktreePath(options.worktreePath));
-    const destroyEnv = {
-        ...process.env,
-        // Source checkout path is the original git repo root (shared across worktrees), not the
-        // worktree itself. This allows destroy scripts to clean resources using paths from the
-        // source checkout.
-        PASEO_SOURCE_CHECKOUT_PATH: repoRootPath,
-        // Backward-compatible alias.
-        PASEO_ROOT_PATH: repoRootPath,
-        PASEO_WORKTREE_PATH: options.worktreePath,
-        PASEO_BRANCH_NAME: branchName,
-    };
-    const results = [];
-    for (const cmd of destroyCommands) {
-        const result = await execSetupCommand(cmd, {
-            cwd: options.worktreePath,
-            env: destroyEnv,
-        });
-        results.push(result);
-        if (result.exitCode !== 0) {
-            throw new WorktreeDestroyError(`Worktree destroy command failed: ${cmd}\n${result.stderr}`.trim(), results);
-        }
-    }
-    return results;
-}
-/**
- * Get the git common directory (shared across worktrees) for a given cwd.
- * This is where refs, objects, etc. are stored.
- */
-export async function getGitCommonDir(cwd) {
-    const { stdout } = await execAsync("git rev-parse --path-format=absolute --git-common-dir", {
-        cwd,
-        env: READ_ONLY_GIT_ENV,
-    });
-    const commonDir = stdout.trim();
-    if (!commonDir) {
-        throw new Error("Not in a git repository");
-    }
-    return commonDir;
-}
-/**
- * Validate that a string is a valid git branch name slug
- * Must be lowercase, alphanumeric, hyphens only
- */
-export function validateBranchSlug(slug) {
-    if (!slug || slug.length === 0) {
-        return { valid: false, error: "Branch name cannot be empty" };
-    }
-    if (slug.length > 100) {
-        return { valid: false, error: "Branch name too long (max 100 characters)" };
-    }
-    // Check for valid characters: lowercase letters, numbers, hyphens, forward slashes
-    const validPattern = /^[a-z0-9-/]+$/;
-    if (!validPattern.test(slug)) {
-        return {
-            valid: false,
-            error: "Branch name must contain only lowercase letters, numbers, hyphens, and forward slashes",
-        };
-    }
-    // Cannot start or end with hyphen
-    if (slug.startsWith("-") || slug.endsWith("-")) {
-        return {
-            valid: false,
-            error: "Branch name cannot start or end with a hyphen",
-        };
-    }
-    // Cannot have consecutive hyphens
-    if (slug.includes("--")) {
-        return { valid: false, error: "Branch name cannot have consecutive hyphens" };
-    }
-    return { valid: true };
-}
-const MAX_SLUG_LENGTH = 50;
-/**
- * Convert string to kebab-case for branch names
- */
-export function slugify(input) {
-    const slug = input
-        .toLowerCase()
-        .replace(/[^a-z0-9]+/g, "-")
-        .replace(/^-+|-+$/g, "");
-    if (slug.length <= MAX_SLUG_LENGTH) {
-        return slug;
-    }
-    // Truncate at word boundary (hyphen) if possible
-    const truncated = slug.slice(0, MAX_SLUG_LENGTH);
-    const lastHyphen = truncated.lastIndexOf("-");
-    if (lastHyphen > MAX_SLUG_LENGTH / 2) {
-        return truncated.slice(0, lastHyphen);
-    }
-    return truncated.replace(/-+$/, "");
-}
-function generateWorktreeSlug() {
-    return createNameId();
-}
-const WORKTREE_PROJECT_HASH_LENGTH = 8;
-function deriveShortAlphanumericHash(value) {
-    const digest = createHash("sha256").update(value).digest();
-    let hashValue = 0n;
-    for (let index = 0; index < 8; index += 1) {
-        hashValue = (hashValue << 8n) | BigInt(digest[index] ?? 0);
-    }
-    return hashValue.toString(36).padStart(13, "0").slice(0, WORKTREE_PROJECT_HASH_LENGTH);
-}
-export async function deriveWorktreeProjectHash(cwd) {
-    try {
-        const commonDir = await getGitCommonDir(cwd);
-        const normalizedCommonDir = normalizePathForOwnership(commonDir);
-        const repoRoot = basename(normalizedCommonDir) === ".git" ? dirname(normalizedCommonDir) : normalizedCommonDir;
-        return deriveShortAlphanumericHash(repoRoot);
-    }
-    catch {
-        return deriveShortAlphanumericHash(normalizePathForOwnership(cwd));
-    }
-}
-export async function getPaseoWorktreesRoot(cwd, paseoHome) {
-    const home = paseoHome ? resolve(paseoHome) : resolvePaseoHome();
-    const projectHash = await deriveWorktreeProjectHash(cwd);
-    return join(home, "worktrees", projectHash);
-}
-export async function computeWorktreePath(cwd, slug, paseoHome) {
-    const worktreesRoot = await getPaseoWorktreesRoot(cwd, paseoHome);
-    return join(worktreesRoot, slug);
-}
-function normalizePathForOwnership(input) {
-    try {
-        return realpathSync(input);
-    }
-    catch {
-        return resolve(input);
-    }
-}
-function resolveRepoRootFromGitCommonDir(commonDir) {
-    const normalizedCommonDir = normalizePathForOwnership(commonDir);
-    return basename(normalizedCommonDir) === ".git"
-        ? dirname(normalizedCommonDir)
-        : normalizedCommonDir;
-}
-export async function isPaseoOwnedWorktreeCwd(cwd, options) {
-    let gitCommonDir;
-    try {
-        gitCommonDir = await getGitCommonDir(cwd);
-    }
-    catch {
-        return {
-            allowed: false,
-            worktreePath: normalizePathForOwnership(cwd),
-        };
-    }
-    const repoRoot = resolveRepoRootFromGitCommonDir(gitCommonDir);
-    const worktreesRoot = await getPaseoWorktreesRoot(cwd, options?.paseoHome);
-    const resolvedRoot = normalizePathForOwnership(worktreesRoot) + sep;
-    const resolvedCwd = normalizePathForOwnership(cwd);
-    if (!resolvedCwd.startsWith(resolvedRoot)) {
-        return {
-            allowed: false,
-            repoRoot,
-            worktreeRoot: worktreesRoot,
-            worktreePath: resolvedCwd,
-        };
-    }
-    const worktrees = await listPaseoWorktrees({ cwd, paseoHome: options?.paseoHome });
-    const allowed = worktrees.some((entry) => {
-        const worktreePath = resolve(entry.path);
-        return resolvedCwd === worktreePath || resolvedCwd.startsWith(worktreePath + sep);
-    });
-    return {
-        allowed,
-        repoRoot,
-        worktreeRoot: worktreesRoot,
-        worktreePath: resolvedCwd,
-    };
-}
-function parseWorktreeList(output) {
-    const entries = [];
-    let current = null;
-    for (const line of output.split("\n")) {
-        if (line.startsWith("worktree ")) {
-            if (current?.path) {
-                entries.push(current);
-            }
-            current = { path: line.slice("worktree ".length).trim() };
-            continue;
-        }
-        if (!current) {
-            continue;
-        }
-        if (line.startsWith("branch ")) {
-            const ref = line.slice("branch ".length).trim();
-            current.branchName = ref.startsWith("refs/heads/") ? ref.slice("refs/heads/".length) : ref;
-        }
-        else if (line.startsWith("HEAD ")) {
-            current.head = line.slice("HEAD ".length).trim();
-        }
-        else if (line.trim().length === 0) {
-            if (current.path) {
-                entries.push(current);
-            }
-            current = null;
-        }
-    }
-    if (current?.path) {
-        entries.push(current);
-    }
-    return entries;
-}
-function resolveWorktreeCreatedAtIso(worktreePath) {
-    try {
-        const stats = statSync(worktreePath);
-        const birthtimeMs = stats.birthtimeMs;
-        const createdAtMs = Number.isFinite(birthtimeMs) && birthtimeMs > 0 ? birthtimeMs : stats.ctimeMs;
-        return new Date(createdAtMs).toISOString();
-    }
-    catch {
-        return new Date(0).toISOString();
-    }
-}
-export async function listPaseoWorktrees({ cwd, paseoHome, }) {
-    const worktreesRoot = await getPaseoWorktreesRoot(cwd, paseoHome);
-    const { stdout } = await execAsync("git worktree list --porcelain", {
-        cwd,
-        env: READ_ONLY_GIT_ENV,
-    });
-    const rootPrefix = normalizePathForOwnership(worktreesRoot) + sep;
-    return parseWorktreeList(stdout)
-        .map((entry) => ({ ...entry, path: normalizePathForOwnership(entry.path) }))
-        .filter((entry) => entry.path.startsWith(rootPrefix))
-        .map((entry) => ({
-        ...entry,
-        createdAt: resolveWorktreeCreatedAtIso(entry.path),
-    }));
-}
-export async function resolvePaseoWorktreeRootForCwd(cwd, options) {
-    let gitCommonDir;
-    try {
-        gitCommonDir = await getGitCommonDir(cwd);
-    }
-    catch {
-        return null;
-    }
-    const worktreesRoot = await getPaseoWorktreesRoot(cwd, options?.paseoHome);
-    const resolvedRoot = normalizePathForOwnership(worktreesRoot) + sep;
-    let worktreeRoot = null;
-    try {
-        const { stdout } = await execAsync("git rev-parse --path-format=absolute --show-toplevel", {
-            cwd,
-            env: READ_ONLY_GIT_ENV,
-        });
-        const trimmed = stdout.trim();
-        worktreeRoot = trimmed.length > 0 ? trimmed : null;
-    }
-    catch {
-        worktreeRoot = null;
-    }
-    if (!worktreeRoot) {
-        return null;
-    }
-    const resolvedWorktreeRoot = normalizePathForOwnership(worktreeRoot);
-    if (!resolvedWorktreeRoot.startsWith(resolvedRoot)) {
-        return null;
-    }
-    const knownWorktrees = await listPaseoWorktrees({
-        cwd,
-        paseoHome: options?.paseoHome,
-    });
-    const match = knownWorktrees.find((entry) => entry.path === resolvedWorktreeRoot);
-    if (!match) {
-        return null;
-    }
-    return {
-        repoRoot: gitCommonDir,
-        worktreeRoot: worktreesRoot,
-        worktreePath: match.path,
-    };
-}
-export async function deletePaseoWorktree({ cwd, worktreePath, worktreeSlug, paseoHome, }) {
-    if (!worktreePath && !worktreeSlug) {
-        throw new Error("worktreePath or worktreeSlug is required");
-    }
-    const worktreesRoot = await getPaseoWorktreesRoot(cwd, paseoHome);
-    const resolvedRoot = normalizePathForOwnership(worktreesRoot) + sep;
-    const requestedPath = worktreePath ?? join(worktreesRoot, worktreeSlug);
-    const resolvedRequested = normalizePathForOwnership(requestedPath);
-    const resolvedWorktree = (await resolvePaseoWorktreeRootForCwd(requestedPath, { paseoHome }))?.worktreePath ??
-        resolvedRequested;
-    if (!resolvedWorktree.startsWith(resolvedRoot)) {
-        throw new Error("Refusing to delete non-Paseo worktree");
-    }
-    await runWorktreeDestroyCommands({
-        worktreePath: resolvedWorktree,
-    });
-    await execAsync(`git worktree remove "${resolvedWorktree}" --force`, {
-        cwd,
-    });
-    if (existsSync(resolvedWorktree)) {
-        rmSync(resolvedWorktree, { recursive: true, force: true });
-    }
-}
-/**
- * Create a git worktree with proper naming conventions
- */
-export async function createWorktree({ branchName, cwd, baseBranch, worktreeSlug, runSetup = true, paseoHome, }) {
-    // Validate branch name
-    const validation = validateBranchSlug(branchName);
-    if (!validation.valid) {
-        throw new Error(`Invalid branch name: ${validation.error}`);
-    }
-    const normalizedBaseBranch = baseBranch ? normalizeBaseRefName(baseBranch) : "";
-    if (!normalizedBaseBranch) {
-        throw new Error("Base branch is required when creating a Paseo worktree");
-    }
-    if (normalizedBaseBranch === "HEAD") {
-        throw new Error("Base branch cannot be HEAD when creating a Paseo worktree");
-    }
-    // Resolve the base branch - try local first, then remote
-    let resolvedBaseBranch = normalizedBaseBranch;
-    try {
-        await execAsync(`git rev-parse --verify ${normalizedBaseBranch}`, { cwd });
-    }
-    catch {
-        // Local branch doesn't exist, try remote (origin/{branch})
-        try {
-            await execAsync(`git rev-parse --verify origin/${normalizedBaseBranch}`, { cwd });
-            resolvedBaseBranch = `origin/${normalizedBaseBranch}`;
-        }
-        catch {
-            throw new Error(`Base branch not found: ${normalizedBaseBranch}`);
-        }
-    }
-    let worktreePath;
-    const desiredSlug = worktreeSlug || generateWorktreeSlug();
-    worktreePath = join(await getPaseoWorktreesRoot(cwd, paseoHome), desiredSlug);
-    mkdirSync(dirname(worktreePath), { recursive: true });
-    // Check if branch already exists
-    let branchExists = false;
-    try {
-        await execAsync(`git show-ref --verify --quiet refs/heads/${branchName}`, { cwd });
-        branchExists = true;
-    }
-    catch {
-        branchExists = false;
-    }
-    // Always create a new branch for the worktree
-    // If branchName already exists, use it as base and create worktree-slug as branch name
-    // If branchName doesn't exist, create it from baseBranch (resolved to remote if needed)
-    const base = branchExists ? branchName : resolvedBaseBranch;
-    const candidateBranch = branchExists ? desiredSlug : branchName;
-    // Find unique branch name if collision
-    let newBranchName = candidateBranch;
-    let suffix = 1;
-    while (true) {
-        try {
-            await execAsync(`git show-ref --verify --quiet refs/heads/${newBranchName}`, { cwd });
-            // Branch exists, try with suffix
-            newBranchName = `${candidateBranch}-${suffix}`;
-            suffix++;
-        }
-        catch {
-            break;
-        }
-    }
-    // Also handle worktree path collision
-    let finalWorktreePath = worktreePath;
-    let pathSuffix = 1;
-    while (existsSync(finalWorktreePath)) {
-        finalWorktreePath = `${worktreePath}-${pathSuffix}`;
-        pathSuffix++;
-    }
-    const command = `git worktree add "${finalWorktreePath}" -b "${newBranchName}" "${base}"`;
-    await execAsync(command, { cwd });
-    worktreePath = normalizePathForOwnership(finalWorktreePath);
-    writePaseoWorktreeMetadata(worktreePath, { baseRefName: normalizedBaseBranch });
-    if (runSetup) {
-        await runWorktreeSetupCommands({
-            worktreePath,
-            branchName: newBranchName,
-            cleanupOnFailure: true,
-        });
-    }
-    return {
-        branchName: newBranchName,
-        worktreePath,
-    };
-}
-//# sourceMappingURL=worktree.js.map