yggtree 1.4.2 → 1.4.4

package/dist/commands/wt/create-multi.js

@@ -5,6 +5,7 @@ import { getRepoRoot, getRepoName, verifyRef, fetchAll, getCurrentBranch, ensure
 import { runBootstrap } from '../../lib/config.js';
 import { WORKTREES_ROOT } from '../../lib/paths.js';
 import { log, ui, createSpinner } from '../../lib/ui.js';
+import { findLocalEnvFiles, promptAndCopyEnvFilesToWorktrees } from '../../lib/env-files.js';
 import { execa } from 'execa';
 import fs from 'fs-extra';
 export async function createCommandMulti(options) {
@@ -117,8 +118,16 @@ export async function createCommandMulti(options) {
                 ]);
             }
             createdWorktrees.push(wtPath);
-            // 4. Bootstrap
-            if (shouldBootstrap) {
+        }
+        const envFiles = await findLocalEnvFiles(repoRoot);
+        if (envFiles.length > 0 && createdWorktrees.length > 0) {
+            await promptAndCopyEnvFilesToWorktrees(repoRoot, createdWorktrees, envFiles, {
+                promptMessage: `Copy local env file${envFiles.length === 1 ? '' : 's'} to all created worktrees? (${envFiles.join(', ')})`,
+            });
+        }
+        // 4. Bootstrap
+        if (shouldBootstrap) {
+            for (const wtPath of createdWorktrees) {
                 await runBootstrap(wtPath, repoRoot);
             }
         }

package/dist/commands/wt/create-sandbox.js

@@ -6,6 +6,7 @@ import { runBootstrap } from '../../lib/config.js';
 import { WORKTREES_ROOT } from '../../lib/paths.js';
 import { log, ui, createSpinner } from '../../lib/ui.js';
 import { generateSandboxName, normalizeSandboxName, writeSandboxMeta } from '../../lib/sandbox.js';
+import { promptAndCopyEnvFiles } from '../../lib/env-files.js';
 import { detectInstalledOpenTools, launchOpenTool, promptOpenToolSelection, } from './open.js';
 import { execa } from 'execa';
 import fs from 'fs-extra';
@@ -66,7 +67,7 @@ export async function createSandboxCommand(options = {}) {
             {
                 type: 'confirm',
                 name: 'shouldOpenTool',
-                message: 'Open a tool after creation? (IDE or agent CLI)',
+                message: 'Open an editor after creation?',
                 default: false,
                 when: options.exec === undefined && options.open === undefined && options.enter === undefined,
             },
@@ -181,6 +182,7 @@ export async function createSandboxCommand(options = {}) {
         spinner.succeed(`Sandbox created: ${chalk.cyan(sandboxName)}`);
         log.dim('This is a local sandbox - no remote branch will be pushed.');
         // 8. Bootstrap
+        await promptAndCopyEnvFiles(repoRoot, wtPath);
         if (shouldBootstrap) {
             await runBootstrap(wtPath, repoRoot);
         }

package/dist/commands/wt/create.js

@@ -1,13 +1,15 @@
 import chalk from 'chalk';
 import inquirer from 'inquirer';
 import path from 'path';
-import { getRepoRoot, getRepoName, createWorktree, fetchAll, listWorktrees } from '../../lib/git.js';
+import { getRepoName, createWorktree, fetchAll, listWorktrees } from '../../lib/git.js';
 import { runBootstrap } from '../../lib/config.js';
 import { WORKTREES_ROOT } from '../../lib/paths.js';
 import { log, ui, createSpinner } from '../../lib/ui.js';
 import { ensureAutocompletePrompt } from '../../lib/prompt.js';
+import { promptAndCopyEnvFiles } from '../../lib/env-files.js';
+import { ensureRepoContext } from '../../lib/repo-context.js';
 import { enterCommand } from './enter.js';
-import { detectInstalledOpenTools, launchOpenTool, promptOpenToolSelection, } from './open.js';
+import { detectInstalledOpenTools, promptOpenActions, resolveOpenToolAction, runOpenActions, } from './open.js';
 import { execa } from 'execa';
 import fs from 'fs-extra';
 function toSlug(value) {
@@ -16,7 +18,7 @@ function toSlug(value) {
         .replace(/[\/\\]/g, '-')
         .replace(/\s+/g, '-');
 }
-async function listBranchCandidates() {
+export async function listBranchCandidates() {
     const [localRefs, remoteRefs] = await Promise.all([
         execa('git', ['for-each-ref', '--format=%(refname:short)', 'refs/heads']),
         execa('git', ['for-each-ref', '--format=%(refname:short)', 'refs/remotes/origin']),
@@ -32,21 +34,26 @@ async function listBranchCandidates() {
         .filter(ref => ref !== 'origin/HEAD' && !ref.endsWith('/HEAD'))
         .map(ref => ref.replace(/^origin\//, ''));
     const localSet = new Set(localBranches);
-    const remoteOnly = [...new Set(remoteBranches)].filter(branch => !localSet.has(branch));
+    const uniqueRemoteBranches = [...new Set(remoteBranches)];
     const localCandidates = localBranches.map(branchName => ({
         branchName,
         checkoutRef: branchName,
         createLocalBranch: false,
         source: 'local',
+        attachedBranchName: branchName,
+        sourceLabel: 'local',
     }));
-    const remoteCandidates = remoteOnly.map(branchName => ({
+    const remoteCandidates = uniqueRemoteBranches.map(branchName => ({
         branchName,
         checkoutRef: `origin/${branchName}`,
-        createLocalBranch: true,
+        createLocalBranch: !localSet.has(branchName),
         source: 'remote',
+        attachedBranchName: localSet.has(branchName) ? undefined : branchName,
+        sourceLabel: localSet.has(branchName) ? 'remote tip, detached' : 'remote, creates local branch',
     }));
     return [...localCandidates, ...remoteCandidates]
-        .sort((a, b) => a.branchName.localeCompare(b.branchName));
+        .sort((a, b) => a.branchName.localeCompare(b.branchName) ||
+        a.checkoutRef.localeCompare(b.checkoutRef));
 }
 function resolveCandidateFromRef(ref, candidates) {
     const trimmedRef = ref.trim();
@@ -54,18 +61,47 @@ function resolveCandidateFromRef(ref, candidates) {
         return undefined;
     if (trimmedRef.startsWith('origin/')) {
         const branchName = trimmedRef.replace(/^origin\//, '');
-        return candidates.find(candidate => candidate.branchName === branchName);
+        return candidates.find(candidate => candidate.branchName === branchName &&
+            candidate.checkoutRef === trimmedRef);
     }
     return candidates.find(candidate => candidate.branchName === trimmedRef ||
         candidate.checkoutRef === trimmedRef);
 }
+export function findExistingBranchWorktree(worktrees, branchName) {
+    if (!branchName)
+        return undefined;
+    return worktrees.find(wt => wt.branch === branchName &&
+        !wt.prunable &&
+        fs.pathExistsSync(wt.path));
+}
+function normalizeExistingPath(value) {
+    try {
+        return fs.realpathSync(value);
+    }
+    catch {
+        return path.resolve(value);
+    }
+}
+function findWorktreeByPath(worktrees, wtPath) {
+    const normalizedPath = normalizeExistingPath(wtPath);
+    return worktrees.find(wt => normalizeExistingPath(wt.path) === normalizedPath);
+}
+export function getWorktreePathCollisionMessage(worktreeName, wtPath, worktrees) {
+    if (!fs.pathExistsSync(wtPath))
+        return undefined;
+    const occupyingWorktree = findWorktreeByPath(worktrees, wtPath);
+    if (occupyingWorktree?.branch) {
+        return `Worktree name "${worktreeName}" is already used by branch "${occupyingWorktree.branch}".`;
+    }
+    if (occupyingWorktree?.prunable) {
+        return `Worktree path exists but Git marks its metadata as prunable: ${occupyingWorktree.prunable}.`;
+    }
+    return 'Worktree path already exists.';
+}
 export async function createCommand(options) {
     try {
-        const repoRoot = await getRepoRoot();
+        const repoRoot = await ensureRepoContext();
         log.info(`Repo: ${chalk.dim(repoRoot)}`);
-        if (options.enter !== undefined) {
-            log.warning('`--enter` / `--no-enter` is deprecated. Use `--open` / `--no-open` instead.');
-        }
         // 1. Load branches
         const loadingSpinner = createSpinner('Fetching branches...').start();
         await fetchAll();
@@ -96,10 +132,11 @@ export async function createCommand(options) {
                     source: async (_answers, input = '') => {
                         const term = input.trim().toLowerCase();
                         const filtered = term
-                            ? candidates.filter(candidate => candidate.branchName.toLowerCase().includes(term))
+                            ? candidates.filter(candidate => candidate.branchName.toLowerCase().includes(term) ||
+                                candidate.checkoutRef.toLowerCase().includes(term))
                             : candidates;
                         return filtered.map(candidate => ({
-                            name: `${chalk.yellow(candidate.branchName)} ${chalk.dim(`(${candidate.source})`)}`,
+                            name: `${chalk.yellow(candidate.checkoutRef)} ${chalk.dim(`(${candidate.sourceLabel})`)}`,
                             value: candidate,
                         }));
                     },
@@ -113,44 +150,61 @@ export async function createCommand(options) {
             return;
         }
         const existingWorktrees = await listWorktrees();
-        const existingManagedWorktree = existingWorktrees.find(wt => wt.branch === selectedBranch.branchName && wt.path.startsWith(WORKTREES_ROOT));
-        if (existingManagedWorktree) {
-            log.info(`Branch ${chalk.cyan(selectedBranch.branchName)} is already active in ${ui.path(existingManagedWorktree.path)}.`);
+        const existingBranchWorktree = findExistingBranchWorktree(existingWorktrees, selectedBranch.attachedBranchName);
+        const shouldEnterShell = options.enter !== false;
+        if (existingBranchWorktree) {
+            log.info(`Branch ${chalk.cyan(selectedBranch.branchName)} is already active in ${ui.path(existingBranchWorktree.path)}.`);
             if (options.exec && options.exec.trim()) {
                 log.info('Reusing the existing worktree and running the requested command...');
-                await enterCommand(existingManagedWorktree.path, { exec: options.exec });
+                await enterCommand(existingBranchWorktree.path, { exec: options.exec });
                 return;
             }
-            const shouldOpenExisting = options.open !== undefined
-                ? options.open
-                : options.enter !== undefined
-                    ? options.enter
+            const shouldOpenExisting = options.tool
+                ? true
+                : options.open !== undefined
+                    ? options.open
                     : (await inquirer.prompt([
                         {
                             type: 'confirm',
                             name: 'shouldOpenTool',
-                            message: 'Open a tool in the existing worktree now? (IDE or agent CLI)',
+                            message: shouldEnterShell
+                                ? 'Open anything before entering the existing worktree shell?'
+                                : 'Open anything in the existing worktree?',
                             default: true,
                         },
                     ])).shouldOpenTool;
             if (!shouldOpenExisting) {
-                log.header(`cd "${existingManagedWorktree.path}"`);
+                if (shouldEnterShell) {
+                    await enterCommand(existingBranchWorktree.path);
+                    return;
+                }
+                log.header(`cd "${existingBranchWorktree.path}"`);
                 return;
             }
             const installedTools = await detectInstalledOpenTools();
-            if (installedTools.length === 0) {
-                log.warning('No IDE/agent tool detected in PATH. Skipping open step.');
-                log.header(`cd "${existingManagedWorktree.path}"`);
+            log.info('Opening existing worktree instead of creating a duplicate...');
+            const actions = options.tool
+                ? [await resolveOpenToolAction(options.tool, installedTools)].filter((action) => Boolean(action))
+                : await promptOpenActions(installedTools, {
+                    allowShellAction: shouldEnterShell,
+                    message: shouldEnterShell
+                        ? 'Open anything before entering the existing worktree shell?'
+                        : 'Open anything in the existing worktree?',
+                });
+            if (options.tool && actions.length === 0) {
+                const available = installedTools.map(tool => tool.command).join(', ') || 'none detected';
+                log.error(`Tool "${options.tool}" not found.`);
+                log.dim(`Detected tool commands: ${available}`);
                 return;
             }
-            const selectedTool = await promptOpenToolSelection(installedTools, 'Select tool to open in the existing worktree:');
-            log.info('Opening existing worktree instead of creating a duplicate...');
-            await launchOpenTool(selectedTool, existingManagedWorktree.path);
+            await runOpenActions(actions, existingBranchWorktree.path, { enter: shouldEnterShell });
             log.success('Existing worktree opened.');
             return;
         }
         // 3. Gather remaining inputs
         const defaultSlug = toSlug(selectedBranch.branchName);
+        const repoName = await getRepoName();
+        const resolveWorktreePath = (name) => path.join(WORKTREES_ROOT, repoName, toSlug(name));
         const answers = await inquirer.prompt([
             {
                 type: 'input',
@@ -158,7 +212,12 @@ export async function createCommand(options) {
                 message: 'Worktree name (slug):',
                 default: options.name || defaultSlug,
                 when: !options.name,
-                validate: (input) => input.trim().length > 0 || 'Name is required',
+                validate: (input) => {
+                    const slug = toSlug(input);
+                    if (!slug)
+                        return 'Name is required';
+                    return getWorktreePathCollisionMessage(slug, resolveWorktreePath(input), existingWorktrees) || true;
+                },
             },
             {
                 type: 'confirm',
@@ -170,34 +229,56 @@ export async function createCommand(options) {
             {
                 type: 'confirm',
                 name: 'shouldOpenTool',
-                message: 'Open a tool after creation? (IDE or agent CLI)',
+                message: shouldEnterShell
+                    ? 'Open anything before entering the worktree shell?'
+                    : 'Open anything after creation?',
                 default: false,
-                when: options.exec === undefined && options.open === undefined && options.enter === undefined,
+                when: options.exec === undefined && options.open === undefined && options.tool === undefined,
             },
         ]);
         const name = options.name || answers.name;
+        const slug = toSlug(name);
+        const wtPath = resolveWorktreePath(name);
+        // 4. Validation
+        if (!slug)
+            throw new Error('Invalid name');
+        const pathCollisionMessage = getWorktreePathCollisionMessage(slug, wtPath, existingWorktrees);
+        if (pathCollisionMessage) {
+            log.actionableError(pathCollisionMessage, `yggtree wc --name ${slug}`, wtPath, [
+                'Choose a different worktree name with --name',
+                `Inspect the occupying path: ls ${wtPath}`,
+                'Use yggtree wt prune only if Git reports stale worktree metadata',
+            ]);
+            return;
+        }
         const shouldBootstrap = options.bootstrap !== undefined ? options.bootstrap : answers.bootstrap;
-        const shouldOpenTool = options.open !== undefined
-            ? options.open
-            : options.enter !== undefined
-                ? options.enter
+        const shouldOpenTool = options.tool
+            ? true
+            : options.open !== undefined
+                ? options.open
                 : Boolean(answers.shouldOpenTool);
-        let selectedTool;
+        let openActions = [];
         if (options.exec === undefined && shouldOpenTool) {
             const installedTools = await detectInstalledOpenTools();
-            if (installedTools.length === 0) {
-                log.warning('No IDE/agent tool detected in PATH. Skipping open step.');
+            if (options.tool) {
+                const toolAction = await resolveOpenToolAction(options.tool, installedTools);
+                if (!toolAction) {
+                    const available = installedTools.map(tool => tool.command).join(', ') || 'none detected';
+                    log.error(`Tool "${options.tool}" not found.`);
+                    log.dim(`Detected tool commands: ${available}`);
+                    return;
+                }
+                openActions = [toolAction];
             }
             else {
-                selectedTool = await promptOpenToolSelection(installedTools, 'Select tool to open:');
+                openActions = await promptOpenActions(installedTools, {
+                    allowShellAction: shouldEnterShell,
+                    message: shouldEnterShell
+                        ? 'Open anything before entering the worktree shell?'
+                        : 'Open anything after creation?',
+                });
             }
         }
-        const slug = toSlug(name);
-        const repoName = await getRepoName();
-        const wtPath = path.join(WORKTREES_ROOT, repoName, slug);
-        // 4. Validation
-        if (!slug)
-            throw new Error('Invalid name');
         // 5. Execution (checkout-style: attach to selected branch)
         const spinner = createSpinner(`Creating worktree at ${ui.path(wtPath)}...`).start();
         try {
@@ -223,6 +304,7 @@ export async function createCommand(options) {
             ]);
             return;
         }
+        await promptAndCopyEnvFiles(repoRoot, wtPath);
         if (shouldBootstrap) {
             await runBootstrap(wtPath, repoRoot);
         }
@@ -243,13 +325,12 @@ export async function createCommand(options) {
                 ]);
             }
         }
-        else if (selectedTool) {
+        else {
             try {
-                log.info(`Opening ${ui.path(wtPath)} in ${chalk.cyan(selectedTool.name)}...`);
-                await launchOpenTool(selectedTool, wtPath);
+                await runOpenActions(openActions, wtPath, { enter: shouldEnterShell });
             }
             catch (error) {
-                log.warning(`Could not open ${selectedTool.name}: ${error.message}`);
+                log.warning(`Could not complete post-checkout action: ${error.message}`);
             }
         }
         // 7. Final Output

package/dist/commands/wt/enter.js

@@ -2,10 +2,10 @@ import inquirer from 'inquirer';
 import { spawn } from 'child_process';
 import { execa } from 'execa';
 import chalk from 'chalk';
-import { listWorktrees, getRepoRoot } from '../../lib/git.js';
+import { listWorktrees } from '../../lib/git.js';
 import { log, ui } from '../../lib/ui.js';
+import { ensureRepoContext } from '../../lib/repo-context.js';
 import { detectWorktreeType, findWorktreeByName, formatWorktreeDisplayPath, formatWorktreeType, getWorktreeBranchName, } from '../../lib/worktree.js';
-import { getValidRegisteredRepos } from '../../lib/registry.js';
 function truncateEnd(value, maxLen) {
     if (maxLen <= 0)
         return '';
@@ -37,31 +37,7 @@ function formatChoiceLabel(type, branchName, displayPath, terminalColumns) {
 }
 export async function enterCommand(wtName, options = {}) {
     try {
-        try {
-            await getRepoRoot();
-        }
-        catch {
-            const validRepos = await getValidRegisteredRepos();
-            const repoNames = Object.keys(validRepos);
-            if (repoNames.length === 0) {
-                log.error('Not inside a git repository and no registered realms found.');
-                log.dim('Run `yggtree` inside an existing git project first to register it.');
-                process.exit(1);
-            }
-            console.log(chalk.bold('\n  Not inside a realm. Pick a known one:'));
-            const { selectedRepoName } = await inquirer.prompt([{
-                    type: 'list',
-                    name: 'selectedRepoName',
-                    message: 'Select a realm:',
-                    choices: Object.entries(validRepos).map(([name, rPath]) => ({
-                        name: `${chalk.bold.yellow(name)} ${chalk.dim(formatWorktreeDisplayPath(rPath))}`,
-                        value: name,
-                    })),
-                    pageSize: 10,
-                }]);
-            const repoPath = validRepos[selectedRepoName];
-            process.chdir(repoPath);
-        }
+        await ensureRepoContext();
         const worktrees = await listWorktrees();
         const mainWorktreePath = worktrees[0]?.path || '';
         if (worktrees.length === 0) {

package/dist/commands/wt/handoff.js

@@ -0,0 +1,7 @@
+import { createSandboxCommand } from './create-sandbox.js';
+export async function handoffCommand(options = {}) {
+    await createSandboxCommand({
+        ...options,
+        carry: true,
+    });
+}