yggtree 1.4.1 → 1.4.3

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

@@ -6,14 +6,17 @@ 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 { buildAgentExecCommand, detectInstalledOpenTools, isAgentTool, launchOpenTool, promptOpenToolSelection, } from './open.js';
+import { promptAndCopyEnvFiles } from '../../lib/env-files.js';
+import { detectInstalledOpenTools, launchOpenTool, promptOpenToolSelection, } from './open.js';
 import { execa } from 'execa';
-import { spawn } from 'child_process';
 import fs from 'fs-extra';
 export async function createSandboxCommand(options = {}) {
     try {
         const repoRoot = await getRepoRoot();
         log.info(`Repo: ${chalk.dim(repoRoot)}`);
+        if (options.enter !== undefined) {
+            log.warning('`--enter` / `--no-enter` is deprecated. Use `--open` / `--no-open` instead.');
+        }
         // 1. Auto-detect current branch (no prompt!)
         const currentBranch = await getCurrentBranch();
         if (!currentBranch) {
@@ -61,19 +64,12 @@ export async function createSandboxCommand(options = {}) {
                 default: true,
                 when: options.bootstrap === undefined,
             },
-            {
-                type: 'confirm',
-                name: 'shouldEnter',
-                message: 'Do you want to enter the sandbox now?',
-                default: true,
-                when: options.enter === undefined,
-            },
             {
                 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,
+                when: options.exec === undefined && options.open === undefined && options.enter === undefined,
             },
         ]);
         const requestedSandboxName = options.name !== undefined ? options.name : answers.name || '';
@@ -89,10 +85,14 @@ export async function createSandboxCommand(options = {}) {
         }
         log.info(`Sandbox name: ${chalk.yellow(sandboxName)}`);
         const shouldCarry = options.carry !== undefined ? options.carry : answers.carry;
-        const shouldEnter = options.enter !== undefined ? options.enter : answers.shouldEnter;
         const shouldBootstrap = options.bootstrap !== undefined ? options.bootstrap : answers.bootstrap;
+        const shouldOpenTool = options.open !== undefined
+            ? options.open
+            : options.enter !== undefined
+                ? options.enter
+                : Boolean(answers.shouldOpenTool);
         let selectedTool;
-        if (options.exec === undefined && answers.shouldOpenTool) {
+        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.');
@@ -101,7 +101,6 @@ export async function createSandboxCommand(options = {}) {
                 selectedTool = await promptOpenToolSelection(installedTools, 'Select tool to open:');
             }
         }
-        const execCommandStr = options.exec || (selectedTool && isAgentTool(selectedTool) ? buildAgentExecCommand(selectedTool) : undefined);
         // 4. Detect uncommitted changes before creating worktree
         let changedFiles = [];
         let submodulePaths = [];
@@ -183,27 +182,28 @@ 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);
         }
         // 9. Exec command
-        if (execCommandStr && execCommandStr.trim()) {
-            log.info(`Executing: ${execCommandStr} in ${ui.path(wtPath)}`);
+        if (options.exec && options.exec.trim()) {
+            log.info(`Executing: ${options.exec} in ${ui.path(wtPath)}`);
             try {
-                await execa(execCommandStr, {
+                await execa(options.exec, {
                     cwd: wtPath,
                     stdio: 'inherit',
                     shell: true
                 });
             }
             catch (error) {
-                log.actionableError(error.message, execCommandStr, wtPath, [
-                    `cd ${wtPath} && ${execCommandStr}`,
+                log.actionableError(error.message, options.exec, wtPath, [
+                    `cd ${wtPath} && ${options.exec}`,
                     'Check your command syntax and environment variables'
                 ]);
             }
         }
-        if (selectedTool && !isAgentTool(selectedTool)) {
+        else if (selectedTool) {
             try {
                 log.info(`Opening ${ui.path(wtPath)} in ${chalk.cyan(selectedTool.name)}...`);
                 await launchOpenTool(selectedTool, wtPath);
@@ -216,21 +216,7 @@ export async function createSandboxCommand(options = {}) {
         log.success('Sandbox ready!');
         log.info(`Use ${chalk.cyan('yggtree wt apply')} to apply changes to origin.`);
         log.info(`Use ${chalk.cyan('yggtree wt unapply')} to undo applied changes.`);
-        if (shouldEnter) {
-            log.info(`Spawning sub-shell in ${ui.path(wtPath)}...`);
-            log.dim('Type "exit" to return to the main terminal.');
-            const shell = process.env.SHELL || 'zsh';
-            const child = spawn(shell, [], {
-                cwd: wtPath,
-                stdio: 'inherit',
-            });
-            child.on('close', () => {
-                log.info('Exited sub-shell.');
-            });
-        }
-        else {
-            log.header(`cd "${wtPath}"`);
-        }
+        log.header(`cd "${wtPath}"`);
     }
     catch (error) {
         log.actionableError(error.message, 'yggtree wt create-sandbox');

package/dist/commands/wt/create.js

@@ -1,15 +1,16 @@
 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 { buildAgentExecCommand, detectInstalledOpenTools, isAgentTool, launchOpenTool, promptOpenToolSelection, } from './open.js';
+import { detectInstalledOpenTools, promptOpenActions, resolveOpenToolAction, runOpenActions, } from './open.js';
 import { execa } from 'execa';
-import { spawn } from 'child_process';
 import fs from 'fs-extra';
 function toSlug(value) {
     return value
@@ -17,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']),
@@ -33,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();
@@ -55,14 +61,22 @@ 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));
+}
 export async function createCommand(options) {
     try {
-        const repoRoot = await getRepoRoot();
+        const repoRoot = await ensureRepoContext();
         log.info(`Repo: ${chalk.dim(repoRoot)}`);
         // 1. Load branches
         const loadingSpinner = createSpinner('Fetching branches...').start();
@@ -94,10 +108,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,
                         }));
                     },
@@ -111,15 +126,55 @@ 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)}.`);
-            if (options.enter === false) {
-                log.header(`cd "${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(existingBranchWorktree.path, { exec: options.exec });
                 return;
             }
+            const shouldOpenExisting = options.tool
+                ? true
+                : options.open !== undefined
+                    ? options.open
+                    : (await inquirer.prompt([
+                        {
+                            type: 'confirm',
+                            name: 'shouldOpenTool',
+                            message: shouldEnterShell
+                                ? 'Open anything before entering the existing worktree shell?'
+                                : 'Open anything in the existing worktree?',
+                            default: true,
+                        },
+                    ])).shouldOpenTool;
+            if (!shouldOpenExisting) {
+                if (shouldEnterShell) {
+                    await enterCommand(existingBranchWorktree.path);
+                    return;
+                }
+                log.header(`cd "${existingBranchWorktree.path}"`);
+                return;
+            }
+            const installedTools = await detectInstalledOpenTools();
             log.info('Opening existing worktree instead of creating a duplicate...');
-            await enterCommand(existingManagedWorktree.path, { exec: options.exec ?? '' });
+            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;
+            }
+            await runOpenActions(actions, existingBranchWorktree.path, { enter: shouldEnterShell });
+            log.success('Existing worktree opened.');
             return;
         }
         // 3. Gather remaining inputs
@@ -140,35 +195,45 @@ export async function createCommand(options) {
                 default: true,
                 when: options.bootstrap !== false && options.bootstrap !== true,
             },
-            {
-                type: 'confirm',
-                name: 'shouldEnter',
-                message: 'Do you want to enter the new worktree now?',
-                default: true,
-                when: options.enter === undefined,
-            },
             {
                 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,
+                when: options.exec === undefined && options.open === undefined && options.tool === undefined,
             },
         ]);
         const name = options.name || answers.name;
-        const shouldEnter = options.enter !== undefined ? options.enter : answers.shouldEnter;
         const shouldBootstrap = options.bootstrap !== undefined ? options.bootstrap : answers.bootstrap;
-        let selectedTool;
-        if (options.exec === undefined && answers.shouldOpenTool) {
+        const shouldOpenTool = options.tool
+            ? true
+            : options.open !== undefined
+                ? options.open
+                : Boolean(answers.shouldOpenTool);
+        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 execCommandStr = options.exec || (selectedTool && isAgentTool(selectedTool) ? buildAgentExecCommand(selectedTool) : undefined);
         const slug = toSlug(name);
         const repoName = await getRepoName();
         const wtPath = path.join(WORKTREES_ROOT, repoName, slug);
@@ -200,52 +265,38 @@ export async function createCommand(options) {
             ]);
             return;
         }
+        await promptAndCopyEnvFiles(repoRoot, wtPath);
         if (shouldBootstrap) {
             await runBootstrap(wtPath, repoRoot);
         }
         // 6. Exec Command
-        if (execCommandStr && execCommandStr.trim()) {
-            log.info(`Executing: ${execCommandStr} in ${ui.path(wtPath)}`);
+        if (options.exec && options.exec.trim()) {
+            log.info(`Executing: ${options.exec} in ${ui.path(wtPath)}`);
             try {
-                await execa(execCommandStr, {
+                await execa(options.exec, {
                     cwd: wtPath,
                     stdio: 'inherit',
                     shell: true
                 });
             }
             catch (error) {
-                log.actionableError(error.message, execCommandStr, wtPath, [
-                    `cd ${wtPath} && ${execCommandStr}`,
+                log.actionableError(error.message, options.exec, wtPath, [
+                    `cd ${wtPath} && ${options.exec}`,
                     'Check your command syntax and environment variables'
                 ]);
             }
         }
-        if (selectedTool && !isAgentTool(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
         log.success('Worktree ready!');
-        if (shouldEnter) {
-            log.info(`Spawning sub-shell in ${ui.path(wtPath)}...`);
-            log.dim('Type "exit" to return to the main terminal.');
-            const shell = process.env.SHELL || 'zsh';
-            const child = spawn(shell, [], {
-                cwd: wtPath,
-                stdio: 'inherit',
-            });
-            child.on('close', () => {
-                log.info('Exited sub-shell.');
-            });
-        }
-        else {
-            log.header(`cd "${wtPath}"`);
-        }
+        log.header(`cd "${wtPath}"`);
     }
     catch (error) {
         log.actionableError(error.message, 'yggtree wt worktree-checkout');

package/dist/commands/wt/enter.js

@@ -2,8 +2,9 @@ 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';
 function truncateEnd(value, maxLen) {
     if (maxLen <= 0)
@@ -36,7 +37,7 @@ function formatChoiceLabel(type, branchName, displayPath, terminalColumns) {
 }
 export async function enterCommand(wtName, options = {}) {
     try {
-        await getRepoRoot();
+        await ensureRepoContext();
         const worktrees = await listWorktrees();
         const mainWorktreePath = worktrees[0]?.path || '';
         if (worktrees.length === 0) {

package/dist/commands/wt/list.js

@@ -1,7 +1,7 @@
 import chalk from 'chalk';
-import { listWorktrees, getRepoRoot, isGitClean, getLastActivity } from '../../lib/git.js';
+import { listWorktrees, getRepoRoot, isGitClean, getLastActivity, isGhAvailable, getPrStatusBatch } from '../../lib/git.js';
 import { log, timeAgo } from '../../lib/ui.js';
-import { detectWorktreeType, formatWorktreeType, getWorktreeBranchName, WORKTREE_TYPE_ORDER, } from '../../lib/worktree.js';
+import { detectWorktreeType, formatWorktreeType, formatPrStatus, getWorktreeBranchName, WORKTREE_TYPE_ORDER, } from '../../lib/worktree.js';
 export async function listCommand() {
     try {
         await getRepoRoot(); // Verify we are in a git repo
@@ -11,10 +11,17 @@ export async function listCommand() {
             log.info('No worktrees found.');
             return;
         }
+        // Determine if PR status column should be shown
+        const ghReady = await isGhAvailable();
+        // Collect branch names for batch PR lookup
+        const branches = worktrees.map(wt => getWorktreeBranchName(wt));
+        const prStatusMap = ghReady ? await getPrStatusBatch(branches) : new Map();
+        const showPr = prStatusMap.size > 0;
         console.log(chalk.bold('\n  Active Worktrees:\n'));
-        // Header
-        console.log(`  ${chalk.dim('TYPE')}    ${chalk.dim('STATE')}    ${chalk.dim('LAST ACTIVE')}    ${chalk.dim('BRANCH')}`);
-        console.log(chalk.dim('  ' + '-'.repeat(70)));
+        // Header — PR column only appears when there's data
+        const headerPr = showPr ? `${chalk.dim('PR')}            ` : '';
+        console.log(`  ${chalk.dim('TYPE')}    ${chalk.dim('STATE')}    ${chalk.dim('LAST ACTIVE')}     ${headerPr}${chalk.dim('BRANCH')}`);
+        console.log(chalk.dim('  ' + '-'.repeat(showPr ? 90 : 70)));
         const rows = await Promise.all(worktrees.map(async (wt, index) => {
             const [typeKey, isClean, lastActive] = await Promise.all([
                 detectWorktreeType(wt, mainWorktreePath),
@@ -27,8 +34,12 @@ export async function listCommand() {
             const stateText = isClean ? chalk.green(stateLabel) : chalk.yellow(stateLabel);
             const activeLabel = lastActive ? timeAgo(lastActive) : '—';
             const activeText = chalk.magenta(activeLabel.padEnd(14));
+            const prStatus = prStatusMap.get(branchName);
+            const prText = showPr
+                ? (prStatus ? formatPrStatus(prStatus).padEnd(24) : chalk.dim('—'.padEnd(14)))
+                : '';
             return {
-                text: `  ${type}  ${stateText} ${activeText} ${chalk.yellow(branchName)}`,
+                text: `  ${type}  ${stateText} ${activeText} ${prText}${chalk.yellow(branchName)}`,
                 sortType: WORKTREE_TYPE_ORDER[typeKey],
                 sortBranch: branchName.toLowerCase(),
                 sortIndex: index,
@@ -39,6 +50,12 @@ export async function listCommand() {
             a.sortBranch.localeCompare(b.sortBranch) ||
             a.sortIndex - b.sortIndex)
             .forEach(row => console.log(row.text));
+        if (ghReady && !showPr) {
+            console.log(chalk.dim('\n  ℹ No open PRs found for any worktree branch.'));
+        }
+        else if (!ghReady) {
+            console.log(chalk.dim('\n  ℹ PR status omitted (gh CLI not found). Install GitHub CLI for PR tracking.'));
+        }
         console.log('');
     }
     catch (error) {