yggtree 1.0.1 → 1.1.1

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

@@ -1,7 +1,7 @@
 import chalk from 'chalk';
 import inquirer from 'inquirer';
 import path from 'path';
-import { getRepoRoot, getRepoName, verifyRef, fetchAll, getCurrentBranch } from '../../lib/git.js';
+import { getRepoRoot, getRepoName, verifyRef, fetchAll, getCurrentBranch, ensureCorrectUpstream } 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';
@@ -32,7 +32,7 @@ export async function createCommandMulti(options) {
                     { name: 'Local', value: 'local' },
                 ],
                 default: 'remote',
-                when: !options.base,
+                when: !options.base && !options.source,
             },
             {
                 type: 'input',
@@ -45,15 +45,17 @@ export async function createCommandMulti(options) {
                 name: 'bootstrap',
                 message: 'Run bootstrap for all worktrees? (npm install + submodules)',
                 default: true,
-                when: options.bootstrap !== false,
-            },
+                when: options.bootstrap !== false && options.bootstrap !== true,
+            }
         ]);
-        let baseRef = options.base || answers.base;
-        if (!options.base && answers.source === 'remote' && !baseRef.startsWith('origin/')) {
+        const baseRefRaw = options.base || answers.base;
+        const source = options.source || answers.source;
+        let baseRef = baseRefRaw;
+        if (!options.base && source === 'remote' && !baseRef.startsWith('origin/')) {
             baseRef = `origin/${baseRef}`;
         }
         const branchNames = answers.branches.split(/\s+/).filter((b) => b.length > 0);
-        const shouldBootstrap = options.bootstrap === false ? false : answers.bootstrap;
+        const shouldBootstrap = options.bootstrap !== undefined ? options.bootstrap : answers.bootstrap;
         // 2. Validation of base ref
         const spinner = createSpinner('Fetching...').start();
         await fetchAll();
@@ -72,9 +74,9 @@ export async function createCommandMulti(options) {
             const wtPath = path.join(WORKTREES_ROOT, repoName, slug);
             log.header(`Processing: ${branchName}`);
             const wtSpinner = createSpinner(`Creating worktree at ${ui.path(wtPath)}...`).start();
+            // Check if target branch already exists
+            const targetBranchExists = await verifyRef(branchName);
             try {
-                // Check if target branch already exists
-                const targetBranchExists = await verifyRef(branchName);
                 await fs.ensureDir(path.dirname(wtPath));
                 if (targetBranchExists) {
                     await execa('git', ['worktree', 'add', wtPath, branchName]);
@@ -82,16 +84,39 @@ export async function createCommandMulti(options) {
                 else {
                     await execa('git', ['worktree', 'add', '-b', branchName, wtPath, baseRef]);
                 }
-                wtSpinner.succeed(`Worktree for ${chalk.cyan(branchName)} created.`);
-                createdWorktrees.push(wtPath);
-                // 4. Bootstrap
-                if (shouldBootstrap) {
-                    await runBootstrap(wtPath, repoRoot);
-                }
             }
             catch (error) {
                 wtSpinner.fail(`Failed to create worktree for ${branchName}.`);
-                log.error(error.message);
+                const cmd = targetBranchExists
+                    ? `git worktree add ${wtPath} ${branchName}`
+                    : `git worktree add -b ${branchName} ${wtPath} ${baseRef}`;
+                log.actionableError(error.message, cmd, wtPath, [
+                    'Check if the folder already exists: ls ' + wtPath,
+                    'Check if the branch is already used: git worktree list',
+                    'Try pruning stale worktrees: yggtree wt prune',
+                    `Run manually: ${cmd}`
+                ]);
+                continue;
+            }
+            try {
+                // Strong Safety Mode: Ensure upstream is origin/<branchName> and publish
+                wtSpinner.text = `Safely publishing branch ${branchName}...`;
+                await ensureCorrectUpstream(wtPath, branchName);
+                wtSpinner.succeed(`Worktree for ${chalk.cyan(branchName)} created and published.`);
+                createdWorktrees.push(wtPath);
+            }
+            catch (error) {
+                wtSpinner.fail(`Worktree for ${branchName} created, but publication failed.`);
+                log.actionableError(error.message, 'git push -u origin HEAD', wtPath, [
+                    `cd ${wtPath}`,
+                    'Attempt to push manually: git push -u origin HEAD',
+                    'Check if the remote branch already exists or if you have push permissions'
+                ]);
+                createdWorktrees.push(wtPath); // Still added to list since wt exists
+            }
+            // 4. Bootstrap
+            if (shouldBootstrap) {
+                await runBootstrap(wtPath, repoRoot);
             }
         }
         // 5. Final Output
@@ -104,7 +129,7 @@ export async function createCommandMulti(options) {
         }
     }
     catch (error) {
-        log.error(error.message);
+        log.actionableError(error.message, 'yggtree wt create-multi');
         process.exit(1);
     }
 }

package/dist/commands/wt/create.js

@@ -5,6 +5,7 @@ import { getRepoRoot, getRepoName, verifyRef, createWorktree, fetchAll, getCurre
 import { runBootstrap } from '../../lib/config.js';
 import { WORKTREES_ROOT } from '../../lib/paths.js';
 import { log, ui, createSpinner } from '../../lib/ui.js';
+import { execa } from 'execa';
 import { spawn } from 'child_process';
 import fs from 'fs-extra';
 export async function createCommand(options) {
@@ -40,33 +41,40 @@ export async function createCommand(options) {
                     { name: 'Local', value: 'local' },
                 ],
                 default: 'remote',
-                when: !options.ref,
+                when: !options.ref && !options.source,
             },
             {
                 type: 'confirm',
                 name: 'bootstrap',
                 message: 'Run bootstrap? (npm install + submodules)',
                 default: true,
-                when: options.bootstrap !== false,
+                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: 'input',
+                name: 'exec',
+                message: 'Command to run after creation (optional):',
+                default: options.exec,
+                when: options.exec === undefined,
+            }
         ]);
-        let shouldEnter = false;
-        if (!options.ref) {
-            const finalAnswer = await inquirer.prompt([{
-                    type: 'confirm',
-                    name: 'shouldEnter',
-                    message: 'Do you want to enter the new worktree now?',
-                    default: true
-                }]);
-            shouldEnter = finalAnswer.shouldEnter;
-        }
         const name = options.name || answers.name;
         let ref = options.ref || answers.ref;
+        const source = options.source || answers.source;
+        const shouldEnter = options.enter !== undefined ? options.enter : answers.shouldEnter;
+        const shouldBootstrap = options.bootstrap !== undefined ? options.bootstrap : answers.bootstrap;
+        const execCommandStr = options.exec || answers.exec;
         // Append origin/ if remote is selected and not already present
-        if (!options.ref && answers.source === 'remote' && !ref.startsWith('origin/')) {
+        if (!options.ref && source === 'remote' && !ref.startsWith('origin/')) {
             ref = `origin/${ref}`;
         }
-        const shouldBootstrap = options.bootstrap === false ? false : answers.bootstrap;
         const slug = name.replace(/\s+/g, '-');
         const repoName = await getRepoName();
         const wtPath = path.join(WORKTREES_ROOT, repoName, slug);
@@ -93,14 +101,35 @@ export async function createCommand(options) {
         }
         catch (e) {
             spinner.fail('Failed to create worktree.');
-            log.error(e.message);
+            log.actionableError(e.message, `git worktree add ${wtPath} ${ref}`, wtPath, [
+                'Check if the folder already exists: ls ' + wtPath,
+                'Check if the branch is already used: git worktree list',
+                'Try pruning stale worktrees: yggtree wt prune',
+                `Run manually: git worktree add ${wtPath} ${ref}`
+            ]);
             return;
         }
-        // 4. Bootstrap
         if (shouldBootstrap) {
             await runBootstrap(wtPath, repoRoot);
         }
-        // 5. Final Output
+        // 5. Exec Command
+        if (execCommandStr && execCommandStr.trim()) {
+            log.info(`Executing: ${execCommandStr} in ${ui.path(wtPath)}`);
+            try {
+                await execa(execCommandStr, {
+                    cwd: wtPath,
+                    stdio: 'inherit',
+                    shell: true
+                });
+            }
+            catch (error) {
+                log.actionableError(error.message, execCommandStr, wtPath, [
+                    `cd ${wtPath} && ${execCommandStr}`,
+                    'Check your command syntax and environment variables'
+                ]);
+            }
+        }
+        // 6. Final Output
         log.success('Worktree ready!');
         if (shouldEnter) {
             log.info(`Spawning sub-shell in ${ui.path(wtPath)}...`);
@@ -119,7 +148,7 @@ export async function createCommand(options) {
         }
     }
     catch (error) {
-        log.error(error.message);
+        log.actionableError(error.message, 'yggtree wt create');
         process.exit(1);
     }
 }

package/dist/commands/wt/delete.js

@@ -21,31 +21,47 @@ export async function deleteCommand() {
                 value: wt.path,
             };
         });
-        const { selectedPath } = await inquirer.prompt([
+        const { selectedPaths } = await inquirer.prompt([
             {
-                type: 'list',
-                name: 'selectedPath',
-                message: 'Select worktree to delete:',
+                type: 'checkbox',
+                name: 'selectedPaths',
+                message: 'Select worktrees to delete:',
                 choices: choices,
             },
         ]);
-        const worktreeName = path.relative(WORKTREES_ROOT, selectedPath);
+        if (!selectedPaths || selectedPaths.length === 0) {
+            log.info('No worktrees selected.');
+            return;
+        }
+        const count = selectedPaths.length;
+        const names = selectedPaths.map((p) => path.relative(WORKTREES_ROOT, p));
         const { confirm } = await inquirer.prompt([
             {
-                type: 'input',
+                type: 'confirm',
                 name: 'confirm',
-                message: `Type "${chalk.bold(worktreeName)}" to confirm deletion:`,
-                validate: (input) => input === worktreeName || 'Incorrect name, deletion aborted.',
+                message: `Are you sure you want to delete ${count > 1 ? `${count} worktrees` : `"${names[0]}"`}?`,
+                default: false,
             },
         ]);
-        const spinner = createSpinner(`Deleting ${worktreeName}...`).start();
-        try {
-            await removeWorktree(selectedPath);
-            spinner.succeed(`Deleted worktree: ${worktreeName}`);
+        if (!confirm) {
+            log.info('Deletion aborted.');
+            return;
         }
-        catch (e) {
-            spinner.fail(`Failed to delete ${worktreeName}`);
-            log.error(e.message);
+        for (const wtPath of selectedPaths) {
+            const worktreeName = path.relative(WORKTREES_ROOT, wtPath);
+            const spinner = createSpinner(`Deleting ${worktreeName}...`).start();
+            try {
+                await removeWorktree(wtPath);
+                spinner.succeed(`Deleted worktree: ${worktreeName}`);
+            }
+            catch (e) {
+                spinner.fail(`Failed to delete ${worktreeName}`);
+                log.actionableError(e.message, `git worktree remove ${wtPath} --force`, wtPath, [
+                    `Try running manually: git worktree remove ${wtPath} --force`,
+                    'Check if any files in the worktree are open or locked',
+                    'Try running yggtree wt prune to clean up git metadata'
+                ]);
+            }
         }
     }
     catch (error) {

package/dist/commands/wt/enter.js

@@ -0,0 +1,110 @@
+import inquirer from 'inquirer';
+import { spawn } from 'child_process';
+import { execa } from 'execa';
+import path from 'path';
+import { listWorktrees, getRepoRoot } from '../../lib/git.js';
+import { WORKTREES_ROOT } from '../../lib/paths.js';
+import { log, ui } from '../../lib/ui.js';
+export async function enterCommand(wtName, options = {}) {
+    try {
+        await getRepoRoot();
+        const worktrees = await listWorktrees();
+        if (worktrees.length === 0) {
+            log.info('No worktrees found.');
+            return;
+        }
+        let targetWt;
+        if (wtName) {
+            // Find worktree by name (branch name, relative path, or slug/basename)
+            targetWt = worktrees.find(wt => {
+                const branchName = wt.branch || wt.HEAD || '';
+                const relativePath = path.relative(WORKTREES_ROOT, wt.path);
+                const basename = path.basename(wt.path);
+                return branchName === wtName ||
+                    relativePath === wtName ||
+                    wt.path === wtName ||
+                    basename === wtName;
+            });
+            if (!targetWt) {
+                log.error(`Worktree "${wtName}" not found.`);
+                return;
+            }
+        }
+        else {
+            // Interactive Selection
+            const choices = worktrees.map(wt => {
+                const branchName = wt.branch || wt.HEAD || 'detached';
+                const isManaged = wt.path.startsWith(WORKTREES_ROOT);
+                const displayPath = isManaged
+                    ? path.relative(WORKTREES_ROOT, wt.path)
+                    : wt.path.replace(process.env.HOME || '', '~');
+                return {
+                    name: `${branchName.padEnd(20)} ${displayPath}`,
+                    value: wt
+                };
+            });
+            const { selectedWt } = await inquirer.prompt([
+                {
+                    type: 'list',
+                    name: 'selectedWt',
+                    message: 'Select a worktree to enter:',
+                    choices,
+                    loop: false
+                }
+            ]);
+            targetWt = selectedWt;
+        }
+        const { execCommandStr } = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'execCommandStr',
+                message: 'Command to run before entering (optional):',
+                default: options.exec,
+                when: options.exec === undefined,
+            }
+        ]);
+        const finalExec = options.exec || execCommandStr;
+        if (finalExec && finalExec.trim()) {
+            log.info(`Executing: ${finalExec} in ${ui.path(targetWt?.path || '')}`);
+            try {
+                await execa(finalExec, {
+                    cwd: targetWt?.path,
+                    stdio: 'inherit',
+                    shell: true
+                });
+            }
+            catch (error) {
+                log.error(`Command failed: ${error.message}`);
+                // Ask if still want to enter?
+                const { stillEnter } = await inquirer.prompt([{
+                        type: 'confirm',
+                        name: 'stillEnter',
+                        message: 'Command failed. Do you still want to enter the sub-shell?',
+                        default: true
+                    }]);
+                if (!stillEnter)
+                    return;
+            }
+        }
+        log.info(`Spawning sub-shell in ${ui.path(targetWt?.path || '')}...`);
+        log.dim('Type "exit" to return to the main terminal.');
+        const shell = process.env.SHELL || 'zsh';
+        const child = spawn(shell, [], {
+            cwd: targetWt?.path,
+            stdio: 'inherit',
+            env: {
+                ...process.env,
+                YGGTREE_SHELL: 'true'
+            }
+        });
+        child.on('exit', (code) => {
+            if (code !== 0 && code !== null) {
+                // Command failed with non-zero exit code
+            }
+            log.info('Exited sub-shell.');
+        });
+    }
+    catch (error) {
+        log.error(error.message);
+    }
+}

package/dist/commands/wt/exec.js

@@ -0,0 +1,93 @@
+import inquirer from 'inquirer';
+import { execa } from 'execa';
+import path from 'path';
+import { listWorktrees, getRepoRoot } from '../../lib/git.js';
+import { WORKTREES_ROOT } from '../../lib/paths.js';
+import { log } from '../../lib/ui.js';
+export async function execCommand(wtName, commandArgs) {
+    let targetWt;
+    let command = '';
+    let args = [];
+    try {
+        await getRepoRoot();
+        const worktrees = await listWorktrees();
+        if (worktrees.length === 0) {
+            log.info('No worktrees found.');
+            return;
+        }
+        if (wtName) {
+            // Find worktree by name (branch name, relative path, or slug/basename)
+            targetWt = worktrees.find(wt => {
+                const branchName = wt.branch || wt.HEAD || '';
+                const relativePath = path.relative(WORKTREES_ROOT, wt.path);
+                const basename = path.basename(wt.path);
+                return branchName === wtName ||
+                    relativePath === wtName ||
+                    wt.path === wtName ||
+                    basename === wtName;
+            });
+            if (!targetWt) {
+                log.error(`Worktree "${wtName}" not found.`);
+                return;
+            }
+        }
+        else {
+            // Interactive Selection
+            const choices = worktrees.map(wt => {
+                const branchName = wt.branch || wt.HEAD || 'detached';
+                const isManaged = wt.path.startsWith(WORKTREES_ROOT);
+                const displayPath = isManaged
+                    ? path.relative(WORKTREES_ROOT, wt.path)
+                    : wt.path.replace(process.env.HOME || '', '~');
+                return {
+                    name: `${branchName.padEnd(20)} ${displayPath}`,
+                    value: wt
+                };
+            });
+            const { selectedWt } = await inquirer.prompt([
+                {
+                    type: 'list',
+                    name: 'selectedWt',
+                    message: 'Select a worktree:',
+                    choices,
+                    loop: false
+                }
+            ]);
+            targetWt = selectedWt;
+        }
+        if (commandArgs && commandArgs.length > 0) {
+            command = commandArgs[0];
+            args = commandArgs.slice(1);
+        }
+        else {
+            const { inputCommand } = await inquirer.prompt([
+                {
+                    type: 'input',
+                    name: 'inputCommand',
+                    message: `Enter command to run in ${targetWt?.path}:`,
+                    validate: (input) => input.trim().length > 0 || 'Command cannot be empty'
+                }
+            ]);
+            // Basic shell-like parsing for the interactive input
+            const parts = inputCommand.trim().split(/\s+/);
+            command = parts[0];
+            args = parts.slice(1);
+        }
+        log.info(`Executing: ${command} ${args.join(' ')} in ${targetWt?.path}`);
+        await execa(command, args, {
+            cwd: targetWt?.path,
+            stdio: 'inherit',
+            shell: false
+        });
+    }
+    catch (error) {
+        if (error.exitCode !== undefined) {
+            // Command failed, but it already printed its error to inherited stdio
+            return;
+        }
+        log.actionableError(error.message, `${command} ${args.join(' ')}`, targetWt?.path, [
+            `cd ${targetWt?.path} && ${command} ${args.join(' ')}`,
+            'Check if the command exists and is in your PATH'
+        ]);
+    }
+}

package/dist/commands/wt/leave.js

@@ -0,0 +1,13 @@
+import { log } from '../../lib/ui.js';
+export async function leaveCommand() {
+    if (process.env.YGGTREE_SHELL === 'true') {
+        log.info('Leaving worktree sub-shell...');
+        // SIGHUP is standard for closing shells
+        process.kill(process.ppid, 'SIGHUP');
+    }
+    else {
+        log.warning('You are not in a yggtree sub-shell.');
+        log.dim('Try using "yggtree wt enter" first.');
+        process.exit(0);
+    }
+}

package/dist/commands/wt/list.js

@@ -1,6 +1,6 @@
 import chalk from 'chalk';
 import path from 'path';
-import { listWorktrees, getRepoRoot } from '../../lib/git.js';
+import { listWorktrees, getRepoRoot, isGitClean } from '../../lib/git.js';
 import { WORKTREES_ROOT } from '../../lib/paths.js';
 import { log } from '../../lib/ui.js';
 export async function listCommand() {
@@ -13,11 +13,10 @@ export async function listCommand() {
         }
         console.log(chalk.bold('\n  Active Worktrees:\n'));
         // Header
-        console.log(`  ${chalk.dim('TYPE')}    ${chalk.dim('BRANCH')}             ${chalk.dim('PATH')}`);
-        console.log(chalk.dim('  ' + '-'.repeat(60)));
+        console.log(`  ${chalk.dim('TYPE')}    ${chalk.dim('STATE')}    ${chalk.dim('BRANCH')}             ${chalk.dim('PATH')}`);
+        console.log(chalk.dim('  ' + '-'.repeat(75)));
         for (const wt of worktrees) {
             const isManaged = wt.path.startsWith(WORKTREES_ROOT);
-            const isMain = !isManaged; // Simplification: assume main repo is not in managed dir
             const type = isManaged ? chalk.green('MANAGED') : chalk.blue('MAIN   ');
             const branchName = wt.branch || wt.HEAD || 'detached';
             let displayPath = wt.path.replace(process.env.HOME || '', '~');
@@ -25,12 +24,15 @@ export async function listCommand() {
                 displayPath = path.relative(WORKTREES_ROOT, wt.path);
             }
             const colorPath = isManaged ? chalk.cyan(displayPath) : chalk.dim(displayPath);
-            console.log(`  ${type}  ${chalk.yellow(branchName.padEnd(18))} ${colorPath}`);
+            const isClean = await isGitClean(wt.path);
+            const stateLabel = (isClean ? 'clean' : 'dirty').padEnd(8);
+            const stateText = isClean ? chalk.green(stateLabel) : chalk.yellow(stateLabel);
+            console.log(`  ${type}  ${stateText} ${chalk.yellow(branchName.padEnd(18))} ${colorPath}`);
         }
         console.log('');
     }
     catch (error) {
-        log.error(error.message);
+        log.actionableError(error.message, 'yggtree wt list');
         process.exit(1);
     }
 }

package/dist/commands/wt/path.js

@@ -0,0 +1,62 @@
+import inquirer from 'inquirer';
+import path from 'path';
+import { listWorktrees, getRepoRoot } from '../../lib/git.js';
+import { WORKTREES_ROOT } from '../../lib/paths.js';
+import { log } from '../../lib/ui.js';
+export async function pathCommand(wtName) {
+    try {
+        await getRepoRoot();
+        const worktrees = await listWorktrees();
+        if (worktrees.length === 0) {
+            log.info('No worktrees found.');
+            return;
+        }
+        let targetWt;
+        if (wtName) {
+            // Find worktree by name (branch name, relative path, or slug/basename)
+            targetWt = worktrees.find(wt => {
+                const branchName = wt.branch || wt.HEAD || '';
+                const relativePath = path.relative(WORKTREES_ROOT, wt.path);
+                const basename = path.basename(wt.path);
+                return branchName === wtName ||
+                    relativePath === wtName ||
+                    wt.path === wtName ||
+                    basename === wtName;
+            });
+            if (!targetWt) {
+                log.error(`Worktree "${wtName}" not found.`);
+                return;
+            }
+        }
+        else {
+            // Interactive Selection
+            const choices = worktrees.map(wt => {
+                const branchName = wt.branch || wt.HEAD || 'detached';
+                const isManaged = wt.path.startsWith(WORKTREES_ROOT);
+                const displayPath = isManaged
+                    ? path.relative(WORKTREES_ROOT, wt.path)
+                    : wt.path.replace(process.env.HOME || '', '~');
+                return {
+                    name: `${branchName.padEnd(20)} ${displayPath}`,
+                    value: wt
+                };
+            });
+            const { selectedWt } = await inquirer.prompt([
+                {
+                    type: 'list',
+                    name: 'selectedWt',
+                    message: 'Select a worktree to get path:',
+                    choices,
+                    loop: false
+                }
+            ]);
+            targetWt = selectedWt;
+        }
+        if (targetWt) {
+            console.log(`cd "${targetWt.path}"`);
+        }
+    }
+    catch (error) {
+        log.error(error.message);
+    }
+}

package/dist/commands/wt/prune.js

@@ -10,7 +10,10 @@ export async function pruneCommand() {
         }
         catch (e) {
             spinner.fail('Failed to prune worktrees.');
-            log.error(e.message);
+            log.actionableError(e.message, 'git worktree prune', undefined, [
+                'Try running manually: git worktree prune',
+                'Check if any worktree folders were deleted manually without using git'
+            ]);
         }
     }
     catch (error) {