yggtree 1.4.2 → 1.4.4

package/dist/index.js

@@ -11,39 +11,175 @@ import { deleteCommand } from './commands/wt/delete.js';
 import { bootstrapCommand } from './commands/wt/bootstrap.js';
 import { pruneCommand } from './commands/wt/prune.js';
 import { execCommand } from './commands/wt/exec.js';
-import { enterCommand } from './commands/wt/enter.js';
 import { pathCommand } from './commands/wt/path.js';
 import { openCommand } from './commands/wt/open.js';
 import { applyCommand } from './commands/wt/apply.js';
-import { closeCommand } from './commands/wt/close.js';
 import { unapplyCommand } from './commands/wt/unapply.js';
+import { handoffCommand } from './commands/wt/handoff.js';
 import { getVersion } from './lib/version.js';
+import { notifyIfUpdateAvailable } from './lib/update-check.js';
 import { findSandboxRoot } from './lib/sandbox.js';
 import { bifrostCommand } from './commands/bifrost.js';
 import { thorCommand } from './commands/thor.js';
 const program = new Command();
+const argv = process.argv.map((arg) => arg === '-v' || arg === '—version' ? '--version' : arg);
+function registerWorktreeCommands(parent) {
+    parent.command('list')
+        .description('List all repo-linked worktrees')
+        .option('--open', 'Open a worktree in an IDE/agent tool instead of listing')
+        .action(async (options) => {
+        if (options.open) {
+            await openCommand();
+            return;
+        }
+        await listCommand();
+    });
+    parent.command('create [branch]')
+        .description('Create a new worktree (Smart branch detection)')
+        .option('-b, --branch <name>', 'Branch name (e.g. feat/new-ui)')
+        .option('--base <ref>', 'Base ref (e.g. main)')
+        .option('--source <type>', 'Base source (local or remote)')
+        .option('--no-bootstrap', 'Skip bootstrap (npm install + submodules)')
+        .option('--open', 'Open an editor after creation')
+        .option('--no-open', 'Skip opening an editor after creation')
+        .option('--enter', 'Enter the worktree sub-shell after creation')
+        .option('--no-enter', 'Do not enter the worktree sub-shell after creation')
+        .option('--exec <command>', 'Command to execute after creation')
+        .action(async (branch, options) => {
+        await createCommandNew({
+            ...options,
+            branch: branch || options.branch
+        });
+    });
+    parent.command('create-multi')
+        .description('Create multiple worktrees (Smart branch detection)')
+        .option('--base <ref>', 'Base ref (e.g. main)')
+        .option('--source <type>', 'Base source (local or remote)')
+        .option('--no-bootstrap', 'Skip bootstrap (npm install + submodules)')
+        .action(async (options) => {
+        await createCommandMulti(options);
+    });
+    const registerWorktreeCheckout = (commandName, description) => {
+        parent.command(`${commandName} [name] [ref]`)
+            .description(description)
+            .option('-n, --name <slug>', 'Worktree name (slug)')
+            .option('-r, --ref <ref>', 'Existing branch or ref')
+            .option('--no-bootstrap', 'Skip bootstrap (npm install + submodules)')
+            .option('--open', 'Open editors or run a startup command before entering')
+            .option('--no-open', 'Skip opening editors or startup commands before entering')
+            .option('--tool <command>', 'Editor, app, or terminal command to open after checkout (skips open prompt)')
+            .addOption(new Option('--enter', 'Enter the worktree sub-shell after checkout/opening').hideHelp())
+            .option('--no-enter', 'Do not enter the worktree sub-shell after checkout/opening')
+            .option('--exec <command>', 'Command to execute after creation')
+            .action(async (name, ref, options) => {
+            await createCommand({
+                ...options,
+                name: name || options.name,
+                ref: ref || options.ref
+            });
+        });
+    };
+    registerWorktreeCheckout('worktree-checkout', 'Create a checkout-style worktree from an existing branch');
+    registerWorktreeCheckout('wc', 'Alias for worktree-checkout');
+    parent.command('delete')
+        .description('Delete managed worktrees')
+        .option('-a, --all', 'Include repo-linked worktrees outside ~/.yggtree (except main/current)')
+        .action(async (options) => {
+        await deleteCommand(options);
+    });
+    parent.command('open [worktree]')
+        .description('Open a worktree in an editor, supported app, or terminal target')
+        .option('--tool <command>', 'Editor, app, or terminal command to use (e.g. cursor, code, codex-app, tmux)')
+        .option('--enter', 'Enter the worktree sub-shell after opening')
+        .addOption(new Option('--no-enter', 'Do not enter the worktree sub-shell after opening').hideHelp())
+        .action(async (worktree, options) => {
+        await openCommand(worktree, options);
+    });
+    parent.command('bootstrap')
+        .description('Bootstrap dependencies in a worktree')
+        .action(bootstrapCommand);
+    parent.command('prune')
+        .description('Prune stale worktree information')
+        .action(pruneCommand);
+    parent.command('exec')
+        .description('Execute a command in a worktree')
+        .argument('[worktree]', 'Worktree name or path')
+        .argument('[command...]', 'Command and arguments to execute')
+        .action(async (worktree, command) => {
+        await execCommand(worktree, command);
+    });
+    parent.command('path [worktree]')
+        .description('Show the cd command for a specific worktree')
+        .action(async (worktree) => {
+        await pathCommand(worktree);
+    });
+    parent.command('create-sandbox')
+        .description('Create a sandbox worktree from current branch')
+        .option('-n, --name <name>', 'Optional sandbox name (auto-generated when omitted)')
+        .option('--carry', 'Carry uncommitted changes to sandbox')
+        .option('--no-carry', 'Do not carry uncommitted changes')
+        .option('--no-bootstrap', 'Skip bootstrap (npm install + submodules)')
+        .option('--open', 'Open an editor after creation')
+        .option('--no-open', 'Skip opening an editor after creation')
+        .addOption(new Option('--enter', 'Deprecated alias for --open').hideHelp())
+        .addOption(new Option('--no-enter', 'Deprecated alias for --no-open').hideHelp())
+        .option('--exec <command>', 'Command to execute after creation')
+        .action(async (options) => {
+        await createSandboxCommand(options);
+    });
+    parent.command('handoff')
+        .description('Carry uncommitted work into a sandbox worktree')
+        .option('-n, --name <name>', 'Optional handoff name (prompted when omitted)')
+        .option('--no-bootstrap', 'Skip bootstrap (npm install + submodules)')
+        .option('--open', 'Open an editor after creation')
+        .option('--no-open', 'Skip opening an editor after creation')
+        .addOption(new Option('--enter', 'Deprecated alias for --open').hideHelp())
+        .addOption(new Option('--no-enter', 'Deprecated alias for --no-open').hideHelp())
+        .option('--exec <command>', 'Command to execute after creation')
+        .action(async (options) => {
+        await handoffCommand(options);
+    });
+    parent.command('apply')
+        .description('Apply sandbox changes to origin directory')
+        .action(applyCommand);
+    parent.command('unapply')
+        .description('Undo applied sandbox changes in origin')
+        .action(unapplyCommand);
+}
+function rejectUnknownTopLevelCommand(args) {
+    const commandArg = args.slice(2).find(arg => !arg.startsWith('-'));
+    if (!commandArg)
+        return;
+    if (commandArg === 'help')
+        return;
+    const knownCommands = new Set(program.commands.flatMap(command => [command.name(), ...command.aliases()]));
+    if (!knownCommands.has(commandArg)) {
+        program.error(`error: unknown command '${commandArg}'`);
+    }
+}
 program
     .name('yggtree')
     .description('Interactive CLI for managing git worktrees and configs')
     .version(getVersion())
+    .allowExcessArguments(false)
     .action(async () => {
     // Interactive Menu if no command is provided
     await welcome();
+    await notifyIfUpdateAvailable();
     const isInSandbox = Boolean(await findSandboxRoot(process.cwd()));
     const realmChoices = [
         { name: `🌿 Grow New Realm ${chalk.dim('(create worktree)')}`, value: 'create-smart' },
         { name: `🔀 Traverse to Another Realm ${chalk.dim('(checkout existing branch in new worktree)')}`, value: 'worktree-checkout' },
         { name: `🌳 Grow Many Realms ${chalk.dim('(create multiple worktrees)')}`, value: 'create-multi' },
+        { name: `🤝 Hand Off Current Work ${chalk.dim('(carry dirty work into a sandbox)')}`, value: 'handoff' },
         { name: `🧪 Forge Sandbox Realm ${chalk.dim('(create sandbox worktree)')}`, value: 'create-sandbox' },
         { name: `🗺️  Survey Realms ${chalk.dim('(list worktrees)')}`, value: 'list' },
-        { name: `🧭 Open Realm in Tool ${chalk.dim('(open worktree in IDE/agent)')}`, value: 'open' },
+        { name: `🧭 Open Realm in Editor ${chalk.dim('(open worktree in editor)')}`, value: 'open' },
         { name: `🪓 Fell a Realm ${chalk.dim('(delete worktree)')}`, value: 'delete' },
         { name: `🚀 Bless Realm Setup ${chalk.dim('(bootstrap worktree)')}`, value: 'bootstrap' },
         { name: `🧹 Prune Withered Realms ${chalk.dim('(prune stale worktrees)')}`, value: 'prune' },
         { name: `🐚 Cast a Command ${chalk.dim('(exec command in worktree)')}`, value: 'exec' },
-        { name: `🚪 Enter Realm Shell ${chalk.dim('(enter worktree)')}`, value: 'enter' },
         { name: `📍 Reveal Realm Path ${chalk.dim('(show worktree path)')}`, value: 'path' },
-        { name: `🔒 Close Realm ${chalk.dim('(exit & optionally delete worktree)')}`, value: 'close' },
     ];
     const sandboxChoices = [
         { name: `✅ Graft Sandbox Changes ${chalk.dim('(apply sandbox changes)')}`, value: 'apply' },
@@ -106,9 +242,6 @@ program
         case 'exec':
             await execCommand();
             break;
-        case 'enter':
-            await enterCommand();
-            break;
         case 'path':
             await pathCommand();
             break;
@@ -121,15 +254,15 @@ program
         case 'create-sandbox':
             await createSandboxCommand({ bootstrap: true });
             break;
+        case 'handoff':
+            await handoffCommand({ bootstrap: true });
+            break;
         case 'bifrost':
             await bifrostCommand();
             break;
         case 'thor':
             await thorCommand();
             break;
-        case 'close':
-            await closeCommand();
-            break;
         case 'exit':
             log.info('Bye! 👋');
             process.exit(0);
@@ -137,124 +270,14 @@ program
 });
 // --- Worktree Commands ---
 const wt = program.command('wt').description('Manage git worktrees');
-wt.command('list')
-    .description('List all repo-linked worktrees')
-    .option('--open', 'Open a worktree in an IDE/agent tool instead of listing')
-    .action(async (options) => {
-    if (options.open) {
-        await openCommand();
-        return;
-    }
-    await listCommand();
-});
-wt.command('create [branch]')
-    .description('Create a new worktree (Smart branch detection)')
-    .option('-b, --branch <name>', 'Branch name (e.g. feat/new-ui)')
-    .option('--base <ref>', 'Base ref (e.g. main)')
-    .option('--source <type>', 'Base source (local or remote)')
-    .option('--no-bootstrap', 'Skip bootstrap (npm install + submodules)')
-    .option('--open', 'Open a tool after creation (IDE or agent CLI)')
-    .option('--no-open', 'Skip opening a tool after creation')
-    .addOption(new Option('--enter', 'Deprecated alias for --open').hideHelp())
-    .addOption(new Option('--no-enter', 'Deprecated alias for --no-open').hideHelp())
-    .option('--exec <command>', 'Command to execute after creation')
-    .action(async (branch, options) => {
-    await createCommandNew({
-        ...options,
-        branch: branch || options.branch
-    });
-});
-wt.command('create-multi')
-    .description('Create multiple worktrees (Smart branch detection)')
-    .option('--base <ref>', 'Base ref (e.g. main)')
-    .option('--source <type>', 'Base source (local or remote)')
-    .option('--no-bootstrap', 'Skip bootstrap (npm install + submodules)')
-    .action(async (options) => {
-    await createCommandMulti(options);
-});
-wt.command('worktree-checkout [name] [ref]')
-    .description('Create a checkout-style worktree from an existing branch')
-    .option('-n, --name <slug>', 'Worktree name (slug)')
-    .option('-r, --ref <ref>', 'Existing branch or ref')
-    .option('--no-bootstrap', 'Skip bootstrap (npm install + submodules)')
-    .option('--open', 'Open a tool after creation (IDE or agent CLI)')
-    .option('--no-open', 'Skip opening a tool after creation')
-    .addOption(new Option('--enter', 'Deprecated alias for --open').hideHelp())
-    .addOption(new Option('--no-enter', 'Deprecated alias for --no-open').hideHelp())
-    .option('--exec <command>', 'Command to execute after creation')
-    .action(async (name, ref, options) => {
-    await createCommand({
-        ...options,
-        name: name || options.name,
-        ref: ref || options.ref
-    });
-});
-wt.command('delete')
-    .description('Delete managed worktrees')
-    .option('-a, --all', 'Include repo-linked worktrees outside ~/.yggtree (except main/current)')
-    .action(async (options) => {
-    await deleteCommand(options);
-});
-wt.command('open [worktree]')
-    .description('Open a worktree in an IDE or agent CLI')
-    .option('--tool <command>', 'Tool command to use (e.g. cursor, code, claude, codex)')
-    .action(async (worktree, options) => {
-    await openCommand(worktree, options);
-});
-wt.command('bootstrap')
-    .description('Bootstrap dependencies in a worktree')
-    .action(bootstrapCommand);
-wt.command('prune')
-    .description('Prune stale worktree information')
-    .action(pruneCommand);
-wt.command('exec')
-    .description('Execute a command in a worktree')
-    .argument('[worktree]', 'Worktree name or path')
-    .argument('[command...]', 'Command and arguments to execute')
-    .action(async (worktree, command) => {
-    await execCommand(worktree, command);
-});
-wt.command('enter')
-    .description('Enter a worktree sub-shell')
-    .argument('[worktree]', 'Worktree name or path')
-    .option('--exec <command>', 'Command to execute before entering')
-    .action(async (worktree, options) => {
-    await enterCommand(worktree, options);
-});
-wt.command('path [worktree]')
-    .description('Show the cd command for a specific worktree')
-    .action(async (worktree) => {
-    await pathCommand(worktree);
-});
-wt.command('create-sandbox')
-    .description('Create a sandbox worktree from current branch')
-    .option('-n, --name <name>', 'Optional sandbox name (auto-generated when omitted)')
-    .option('--carry', 'Carry uncommitted changes to sandbox')
-    .option('--no-carry', 'Do not carry uncommitted changes')
-    .option('--no-bootstrap', 'Skip bootstrap (npm install + submodules)')
-    .option('--open', 'Open a tool after creation (IDE or agent CLI)')
-    .option('--no-open', 'Skip opening a tool after creation')
-    .addOption(new Option('--enter', 'Deprecated alias for --open').hideHelp())
-    .addOption(new Option('--no-enter', 'Deprecated alias for --no-open').hideHelp())
-    .option('--exec <command>', 'Command to execute after creation')
-    .action(async (options) => {
-    await createSandboxCommand(options);
-});
-wt.command('apply')
-    .description('Apply sandbox changes to origin directory')
-    .action(applyCommand);
-wt.command('close')
-    .description('Exit the sub-shell with an option to delete the worktree')
-    .action(async () => {
-    await closeCommand();
-});
-wt.command('unapply')
-    .description('Undo applied sandbox changes in origin')
-    .action(unapplyCommand);
+registerWorktreeCommands(program);
+registerWorktreeCommands(wt);
+program.addHelpCommand(true);
 program.command('bifrost')
     .description('Summon the Bifrost (Easter Egg)')
     .action(bifrostCommand);
 program.command('thor')
     .description('Consult the God of Thunder (Easter Egg)')
     .action(thorCommand);
-program.parse(process.argv);
+rejectUnknownTopLevelCommand(argv);
+program.parse(argv);

package/dist/lib/env-files.js

@@ -0,0 +1,72 @@
+import chalk from 'chalk';
+import fs from 'fs-extra';
+import inquirer from 'inquirer';
+import path from 'path';
+import { log } from './ui.js';
+const EXAMPLE_ENV_FILES = new Set([
+    '.env.example',
+    '.env.sample',
+    '.env.template',
+    '.env.defaults',
+]);
+export function canPromptForEnvFiles() {
+    return Boolean(process.stdin.isTTY && process.stdout.isTTY && !process.env.CI);
+}
+async function confirmEnvFileCopy(files, defaultMessage, options) {
+    const isInteractive = options.interactive ?? canPromptForEnvFiles();
+    if (!isInteractive) {
+        log.dim(`Skipped local env file${files.length === 1 ? '' : 's'} in non-interactive mode.`);
+        return false;
+    }
+    const { shouldCopyEnvFiles } = await inquirer.prompt([
+        {
+            type: 'confirm',
+            name: 'shouldCopyEnvFiles',
+            message: options.promptMessage || defaultMessage,
+            default: false,
+        },
+    ]);
+    if (!shouldCopyEnvFiles) {
+        log.dim('Skipped local env files.');
+    }
+    return shouldCopyEnvFiles;
+}
+export async function findLocalEnvFiles(repoRoot) {
+    const entries = await fs.readdir(repoRoot, { withFileTypes: true });
+    return entries
+        .filter(entry => entry.isFile())
+        .map(entry => entry.name)
+        .filter(name => name === '.env' || name.startsWith('.env.'))
+        .filter(name => !EXAMPLE_ENV_FILES.has(name))
+        .sort((a, b) => a.localeCompare(b));
+}
+export async function copyEnvFiles(repoRoot, wtPath, envFiles) {
+    if (envFiles.length === 0)
+        return;
+    for (const envFile of envFiles) {
+        await fs.copy(path.join(repoRoot, envFile), path.join(wtPath, envFile));
+    }
+    log.info(`Copied ${envFiles.map(file => chalk.cyan(file)).join(', ')} to the worktree.`);
+}
+export async function promptAndCopyEnvFiles(repoRoot, wtPath, envFiles, options = {}) {
+    const files = envFiles || await findLocalEnvFiles(repoRoot);
+    if (files.length === 0)
+        return;
+    const shouldCopyEnvFiles = await confirmEnvFileCopy(files, `Copy local env file${files.length === 1 ? '' : 's'} to this worktree? (${files.join(', ')})`, options);
+    if (!shouldCopyEnvFiles) {
+        return;
+    }
+    await copyEnvFiles(repoRoot, wtPath, files);
+}
+export async function promptAndCopyEnvFilesToWorktrees(repoRoot, wtPaths, envFiles, options = {}) {
+    const files = envFiles || await findLocalEnvFiles(repoRoot);
+    if (files.length === 0 || wtPaths.length === 0)
+        return;
+    const shouldCopyEnvFiles = await confirmEnvFileCopy(files, `Copy local env file${files.length === 1 ? '' : 's'} to these worktrees? (${files.join(', ')})`, options);
+    if (!shouldCopyEnvFiles) {
+        return;
+    }
+    for (const wtPath of wtPaths) {
+        await copyEnvFiles(repoRoot, wtPath, files);
+    }
+}

package/dist/lib/git.js

@@ -54,6 +54,9 @@ export async function removeWorktree(wtPath) {
 }
 export async function listWorktrees() {
     const { stdout } = await execa('git', ['worktree', 'list', '--porcelain']);
+    return parseWorktreeList(stdout);
+}
+export function parseWorktreeList(stdout) {
     const worktrees = [];
     let currentWt = {};
     for (const line of stdout.split('\n')) {
@@ -71,6 +74,8 @@ export async function listWorktrees() {
             currentWt.HEAD = value;
         if (key === 'branch')
             currentWt.branch = value.replace('refs/heads/', '');
+        if (key === 'prunable')
+            currentWt.prunable = value;
     }
     // Push the last one if active
     if (currentWt.path)

package/dist/lib/repo-context.js

@@ -0,0 +1,46 @@
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { getRepoRoot } from './git.js';
+import { getValidRegisteredRepos } from './registry.js';
+import { log } from './ui.js';
+import { formatWorktreeDisplayPath } from './worktree.js';
+export async function ensureRepoContext() {
+    try {
+        return await getRepoRoot();
+    }
+    catch {
+        const validRepos = await getValidRegisteredRepos();
+        const repoEntries = Object.entries(validRepos);
+        if (repoEntries.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);
+        }
+        if (repoEntries.length === 1 && (process.env.CI === 'true' || !process.stdin.isTTY)) {
+            const [, selectedRepoPath] = repoEntries[0];
+            process.chdir(selectedRepoPath);
+            return await getRepoRoot();
+        }
+        if (!process.stdin.isTTY) {
+            log.error('Not inside a git repository and multiple registered realms are available.');
+            log.dim('Run yggtree from the repo you want to use, or run interactive mode from a real terminal to choose one.');
+            log.dim(`Available realms: ${repoEntries.map(([name]) => name).join(', ')}`);
+            process.exit(1);
+        }
+        console.log(chalk.bold('\n  Not inside a realm. Pick a known one:'));
+        const { selectedRepoPath } = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'selectedRepoPath',
+                message: 'Select a realm:',
+                choices: repoEntries.map(([name, repoPath]) => ({
+                    name: `${chalk.bold.yellow(name)} ${chalk.dim(formatWorktreeDisplayPath(repoPath))}`,
+                    value: repoPath,
+                })),
+                pageSize: 10,
+            },
+        ]);
+        process.chdir(selectedRepoPath);
+        return await getRepoRoot();
+    }
+}

package/dist/lib/update-check.js

@@ -0,0 +1,55 @@
+import chalk from 'chalk';
+import { execa } from 'execa';
+import { getVersion } from './version.js';
+import { log } from './ui.js';
+function parseVersion(version) {
+    const [core] = version.trim().replace(/^v/, '').split('-');
+    return core.split('.').map(part => {
+        const parsed = Number.parseInt(part, 10);
+        return Number.isNaN(parsed) ? 0 : parsed;
+    });
+}
+export function isNewerVersion(latestVersion, currentVersion) {
+    const latestParts = parseVersion(latestVersion);
+    const currentParts = parseVersion(currentVersion);
+    const maxLength = Math.max(latestParts.length, currentParts.length);
+    for (let index = 0; index < maxLength; index += 1) {
+        const latestPart = latestParts[index] ?? 0;
+        const currentPart = currentParts[index] ?? 0;
+        if (latestPart > currentPart)
+            return true;
+        if (latestPart < currentPart)
+            return false;
+    }
+    return false;
+}
+export async function fetchLatestPackageVersion() {
+    const { stdout } = await execa('npm', ['view', 'yggtree', 'version', '--silent'], {
+        timeout: 3_000,
+    });
+    return stdout.trim();
+}
+export async function checkForUpdate(options = {}) {
+    const currentVersion = getVersion();
+    const fetchLatestVersion = options.fetchLatestVersion ?? fetchLatestPackageVersion;
+    try {
+        const latestVersion = await fetchLatestVersion();
+        if (!latestVersion)
+            return null;
+        return {
+            currentVersion,
+            latestVersion,
+            updateAvailable: isNewerVersion(latestVersion, currentVersion),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export async function notifyIfUpdateAvailable() {
+    const result = await checkForUpdate();
+    if (!result?.updateAvailable)
+        return;
+    log.warning(`A newer yggtree is available: ${chalk.dim(`v${result.currentVersion}`)} -> ${chalk.green(`v${result.latestVersion}`)}`);
+    log.dim('Update with: npm install -g yggtree');
+}

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "yggtree",
-  "version": "1.4.2",
+  "version": "1.4.4",
+  "packageManager": "pnpm@11.0.9",
   "description": "Interactive CLI for managing git worktrees and configs",
   "main": "dist/index.js",
   "type": "module",
   "repository": {
-    "url": "github.com/leoreisdias/yggdrasil-worktree",
+    "url": "git+https://github.com/logbookfordevs/yggdrasil-worktree.git",
     "type": "git"
   },
   "homepage": "yggtree.logbookfordevs.com",
@@ -21,7 +22,9 @@
     "build": "tsc",
     "start": "node dist/index.js",
     "dev": "tsc --watch",
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "site:dev": "pnpm --dir apps/site dev",
+    "test": "pnpm build && pnpm test:typecheck && vitest run",
+    "test:typecheck": "tsc --noEmit -p tsconfig.test.json"
   },
   "keywords": [
     "cli",
@@ -49,6 +52,7 @@
     "@types/gradient-string": "^1.1.6",
     "@types/inquirer": "^9.0.7",
     "@types/node": "^20.11.19",
-    "typescript": "^5.3.3"
+    "typescript": "^5.3.3",
+    "vitest": "^4.1.7"
   }
 }

package/dist/commands/wt/close.js

@@ -1,96 +0,0 @@
-import inquirer from 'inquirer';
-import chalk from 'chalk';
-import { listWorktrees, removeWorktree, getRepoRoot } from '../../lib/git.js';
-import { log, createSpinner } from '../../lib/ui.js';
-import { detectWorktreeType, formatWorktreeDisplayPath, getWorktreeBranchName, isManagedWorktreePath, } from '../../lib/worktree.js';
-/**
- * Terminate the parent sub-shell and exit.
- * Sends SIGHUP to the parent process (the spawned shell from `wt enter`)
- * so the user doesn't get stranded in a dead directory.
- */
-function exitSubShell() {
-    try {
-        process.kill(process.ppid, 'SIGHUP');
-    }
-    catch {
-        log.dim('Type "exit" to leave the sub-shell.');
-    }
-    process.exit(0);
-}
-/**
- * Close command — gracefully exit a worktree sub-shell.
- *
- * When inside an yggtree sub-shell (YGGTREE_SHELL=true), this command:
- * 1. Asks whether you want to delete the worktree you're leaving.
- * 2. If yes, removes the worktree via `git worktree remove`.
- * 3. Terminates the parent sub-shell so the user returns to their original terminal.
- *
- * Outside a sub-shell it simply informs the user.
- */
-export async function closeCommand() {
-    const isSubShell = process.env.YGGTREE_SHELL === 'true';
-    if (!isSubShell) {
-        log.info('Not inside an Yggdrasil sub-shell. Use `exit` to leave your terminal.');
-        return;
-    }
-    try {
-        const currentPath = await getRepoRoot();
-        const worktrees = await listWorktrees();
-        const mainWorktreePath = worktrees[0]?.path || '';
-        const currentWt = worktrees.find(wt => wt.path === currentPath);
-        if (!currentWt) {
-            log.info('Bye! \ud83d\udc4b');
-            exitSubShell();
-        }
-        const branchName = getWorktreeBranchName(currentWt);
-        const type = await detectWorktreeType(currentWt, mainWorktreePath);
-        const displayPath = formatWorktreeDisplayPath(currentWt.path);
-        const isMain = type === 'MAIN';
-        const isManaged = isManagedWorktreePath(currentWt.path);
-        // Main worktree can't be deleted — just exit
-        if (isMain) {
-            log.info('Bye! \ud83d\udc4b');
-            exitSubShell();
-        }
-        console.log('');
-        log.info(`Leaving worktree: ${chalk.yellow(branchName)} ${chalk.dim(`(${displayPath})`)}`);
-        const { shouldDelete } = await inquirer.prompt([{
-                type: 'confirm',
-                name: 'shouldDelete',
-                message: `Delete this worktree before leaving?${isManaged ? '' : chalk.dim(' (external worktree \u2014 will use --force)')}`,
-                default: false,
-            }]);
-        if (shouldDelete) {
-            const { confirmDelete } = await inquirer.prompt([{
-                    type: 'confirm',
-                    name: 'confirmDelete',
-                    message: `Are you sure? This will remove ${chalk.bold.yellow(branchName)} at ${chalk.cyan(displayPath)}.`,
-                    default: false,
-                }]);
-            if (confirmDelete) {
-                const spinner = createSpinner(`Deleting ${displayPath}...`).start();
-                try {
-                    await removeWorktree(currentWt.path);
-                    spinner.succeed(`Deleted worktree: ${displayPath}`);
-                }
-                catch (e) {
-                    spinner.fail(`Failed to delete ${displayPath}`);
-                    log.actionableError(e.message, `git worktree remove ${currentWt.path} --force`, currentWt.path, [
-                        `Try running manually: git worktree remove ${currentWt.path} --force`,
-                        'Check if any files in the worktree are open or locked',
-                        'Try running yggtree wt prune to clean up git metadata',
-                    ]);
-                }
-            }
-            else {
-                log.info('Deletion cancelled.');
-            }
-        }
-        log.info('Bye! \ud83d\udc4b');
-        exitSubShell();
-    }
-    catch (error) {
-        log.error(error.message);
-        process.exit(1);
-    }
-}