yggtree 1.3.0 → 1.4.0

package/dist/commands/wt/delete.js

@@ -1,35 +1,60 @@
 import chalk from 'chalk';
 import inquirer from 'inquirer';
-import path from 'path';
 import { listWorktrees, removeWorktree, getRepoRoot, getLastActivity } from '../../lib/git.js';
-import { WORKTREES_ROOT } from '../../lib/paths.js';
 import { log, createSpinner, timeAgo } from '../../lib/ui.js';
-export async function deleteCommand() {
+import { detectWorktreeType, formatWorktreeDisplayPath, formatWorktreeType, getWorktreeBranchName, isManagedWorktreePath, } from '../../lib/worktree.js';
+export async function deleteCommand(options = {}) {
     try {
-        const _ = await getRepoRoot();
+        const currentWorktreePath = await getRepoRoot();
         const worktrees = await listWorktrees();
-        // Filter only managed worktrees
-        const managedWts = worktrees.filter(wt => wt.path.startsWith(WORKTREES_ROOT));
-        if (managedWts.length === 0) {
-            log.info('No managed worktrees found to delete.');
+        let showAll = options.all;
+        if (showAll === undefined) {
+            const { includeExternal } = await inquirer.prompt([
+                {
+                    type: 'confirm',
+                    name: 'includeExternal',
+                    message: 'Include external linked worktrees (outside ~/.yggtree)?',
+                    default: false,
+                },
+            ]);
+            showAll = includeExternal;
+        }
+        const includeAll = Boolean(showAll);
+        const mainWorktreePath = worktrees[0]?.path;
+        const deletableWts = worktrees.filter(wt => {
+            if (includeAll) {
+                const isMainWorktree = wt.path === mainWorktreePath;
+                const isCurrentWorktree = wt.path === currentWorktreePath;
+                return !isMainWorktree && !isCurrentWorktree;
+            }
+            return isManagedWorktreePath(wt.path);
+        });
+        if (deletableWts.length === 0) {
+            log.info(includeAll
+                ? 'No deletable linked worktrees found.'
+                : 'No managed worktrees found to delete. Use "yggtree wt delete --all" to include external linked worktrees.');
             return;
         }
-        // Pre-fetch activity for all managed worktrees in parallel
-        const activities = await Promise.all(managedWts.map(wt => getLastActivity(wt.path)));
-        const choices = managedWts.map((wt, i) => {
-            const branchName = wt.branch || wt.HEAD || 'detached';
-            const active = activities[i] ? chalk.magenta(timeAgo(activities[i])) : chalk.dim('—');
+        const choices = await Promise.all(deletableWts.map(async (wt) => {
+            const [activity, type] = await Promise.all([
+                getLastActivity(wt.path),
+                detectWorktreeType(wt, mainWorktreePath || ''),
+            ]);
+            const branchName = getWorktreeBranchName(wt);
+            const active = activity ? chalk.magenta(timeAgo(activity)) : chalk.dim('—');
+            const displayPath = formatWorktreeDisplayPath(wt.path);
             return {
-                name: `${chalk.bold.yellow(branchName)} ${chalk.dim('·')} ${active}`,
+                name: `${formatWorktreeType(type)} ${chalk.bold.yellow(branchName)} ${chalk.dim('·')} ${active} ${chalk.dim('·')} ${chalk.dim(displayPath)}`,
                 value: wt.path,
             };
-        });
+        }));
         const { selectedPaths } = await inquirer.prompt([
             {
                 type: 'checkbox',
                 name: 'selectedPaths',
-                message: 'Select worktrees to delete:',
+                message: includeAll ? 'Select worktrees to delete:' : 'Select managed worktrees to delete:',
                 choices: choices,
+                pageSize: 10,
             },
         ]);
         if (!selectedPaths || selectedPaths.length === 0) {
@@ -37,7 +62,7 @@ export async function deleteCommand() {
             return;
         }
         const count = selectedPaths.length;
-        const names = selectedPaths.map((p) => path.relative(WORKTREES_ROOT, p));
+        const names = selectedPaths.map((p) => formatWorktreeDisplayPath(p));
         const { confirm } = await inquirer.prompt([
             {
                 type: 'confirm',
@@ -51,7 +76,7 @@ export async function deleteCommand() {
             return;
         }
         for (const wtPath of selectedPaths) {
-            const worktreeName = path.relative(WORKTREES_ROOT, wtPath);
+            const worktreeName = formatWorktreeDisplayPath(wtPath);
             const spinner = createSpinner(`Deleting ${worktreeName}...`).start();
             try {
                 await removeWorktree(wtPath);

package/dist/commands/wt/enter.js

@@ -1,30 +1,51 @@
 import inquirer from 'inquirer';
 import { spawn } from 'child_process';
 import { execa } from 'execa';
-import path from 'path';
+import chalk from 'chalk';
 import { listWorktrees, getRepoRoot } from '../../lib/git.js';
-import { WORKTREES_ROOT } from '../../lib/paths.js';
 import { log, ui } from '../../lib/ui.js';
+import { detectWorktreeType, findWorktreeByName, formatWorktreeDisplayPath, formatWorktreeType, getWorktreeBranchName, } from '../../lib/worktree.js';
+function truncateEnd(value, maxLen) {
+    if (maxLen <= 0)
+        return '';
+    if (value.length <= maxLen)
+        return value;
+    if (maxLen <= 1)
+        return '…';
+    return `${value.slice(0, maxLen - 1)}…`;
+}
+function truncateStart(value, maxLen) {
+    if (maxLen <= 0)
+        return '';
+    if (value.length <= maxLen)
+        return value;
+    if (maxLen <= 1)
+        return '…';
+    return `…${value.slice(-(maxLen - 1))}`;
+}
+function formatChoiceLabel(type, branchName, displayPath, terminalColumns) {
+    const maxRowWidth = Math.max(40, terminalColumns - 10);
+    const typeWidth = 8;
+    const availableWidth = Math.max(22, maxRowWidth - typeWidth);
+    const branchWidth = Math.min(44, Math.max(12, Math.floor(availableWidth * 0.55)));
+    const pathWidth = Math.max(10, availableWidth - branchWidth - 1);
+    const branchText = truncateEnd(branchName, branchWidth).padEnd(branchWidth);
+    const pathText = truncateStart(displayPath, pathWidth);
+    const typeText = formatWorktreeType(type);
+    return `${typeText} ${chalk.yellow(branchText)} ${chalk.cyan(pathText)}`;
+}
 export async function enterCommand(wtName, options = {}) {
     try {
         await getRepoRoot();
         const worktrees = await listWorktrees();
+        const mainWorktreePath = worktrees[0]?.path || '';
         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;
-            });
+            targetWt = findWorktreeByName(worktrees, wtName);
             if (!targetWt) {
                 log.error(`Worktree "${wtName}" not found.`);
                 return;
@@ -32,38 +53,29 @@ export async function enterCommand(wtName, options = {}) {
         }
         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 || '', '~');
+            const terminalColumns = process.stdout.columns || 100;
+            const choices = await Promise.all(worktrees.map(async (wt) => {
+                const type = await detectWorktreeType(wt, mainWorktreePath);
+                const branchName = getWorktreeBranchName(wt);
+                const displayPath = formatWorktreeDisplayPath(wt.path);
                 return {
-                    name: `${branchName.padEnd(20)} ${displayPath}`,
+                    name: formatChoiceLabel(type, branchName, displayPath, terminalColumns),
                     value: wt
                 };
-            });
+            }));
             const { selectedWt } = await inquirer.prompt([
                 {
                     type: 'list',
                     name: 'selectedWt',
                     message: 'Select a worktree to enter:',
                     choices,
-                    loop: false
+                    loop: false,
+                    pageSize: 10,
                 }
             ]);
             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;
+        const finalExec = options.exec;
         if (finalExec && finalExec.trim()) {
             log.info(`Executing: ${finalExec} in ${ui.path(targetWt?.path || '')}`);
             try {

package/dist/commands/wt/exec.js

@@ -1,9 +1,8 @@
 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';
+import { findWorktreeByName, formatWorktreeDisplayPath, getWorktreeBranchName } from '../../lib/worktree.js';
 export async function execCommand(wtName, commandArgs) {
     let targetWt;
     let command = '';
@@ -16,16 +15,7 @@ export async function execCommand(wtName, commandArgs) {
             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;
-            });
+            targetWt = findWorktreeByName(worktrees, wtName);
             if (!targetWt) {
                 log.error(`Worktree "${wtName}" not found.`);
                 return;
@@ -34,11 +24,8 @@ export async function execCommand(wtName, commandArgs) {
         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 || '', '~');
+                const branchName = getWorktreeBranchName(wt);
+                const displayPath = formatWorktreeDisplayPath(wt.path);
                 return {
                     name: `${branchName.padEnd(20)} ${displayPath}`,
                     value: wt

package/dist/commands/wt/list.js

@@ -1,11 +1,12 @@
 import chalk from 'chalk';
 import { listWorktrees, getRepoRoot, isGitClean, getLastActivity } from '../../lib/git.js';
-import { WORKTREES_ROOT } from '../../lib/paths.js';
 import { log, timeAgo } from '../../lib/ui.js';
+import { detectWorktreeType, formatWorktreeType, getWorktreeBranchName, WORKTREE_TYPE_ORDER, } from '../../lib/worktree.js';
 export async function listCommand() {
     try {
-        const _ = await getRepoRoot(); // Verify we are in a git repo
+        await getRepoRoot(); // Verify we are in a git repo
         const worktrees = await listWorktrees();
+        const mainWorktreePath = worktrees[0]?.path || '';
         if (worktrees.length === 0) {
             log.info('No worktrees found.');
             return;
@@ -14,21 +15,30 @@ export async function listCommand() {
         // Header
         console.log(`  ${chalk.dim('TYPE')}    ${chalk.dim('STATE')}    ${chalk.dim('LAST ACTIVE')}    ${chalk.dim('BRANCH')}`);
         console.log(chalk.dim('  ' + '-'.repeat(70)));
-        for (const wt of worktrees) {
-            const isManaged = wt.path.startsWith(WORKTREES_ROOT);
-            const type = isManaged ? chalk.green('MANAGED') : chalk.blue('MAIN   ');
-            const branchName = wt.branch || wt.HEAD || 'detached';
-            // Fetch state and activity in parallel
-            const [isClean, lastActive] = await Promise.all([
+        const rows = await Promise.all(worktrees.map(async (wt, index) => {
+            const [typeKey, isClean, lastActive] = await Promise.all([
+                detectWorktreeType(wt, mainWorktreePath),
                 isGitClean(wt.path),
                 getLastActivity(wt.path),
             ]);
+            const type = formatWorktreeType(typeKey);
+            const branchName = getWorktreeBranchName(wt);
             const stateLabel = (isClean ? 'clean' : 'dirty').padEnd(8);
             const stateText = isClean ? chalk.green(stateLabel) : chalk.yellow(stateLabel);
             const activeLabel = lastActive ? timeAgo(lastActive) : '—';
             const activeText = chalk.magenta(activeLabel.padEnd(14));
-            console.log(`  ${type}  ${stateText} ${activeText} ${chalk.yellow(branchName)}`);
-        }
+            return {
+                text: `  ${type}  ${stateText} ${activeText} ${chalk.yellow(branchName)}`,
+                sortType: WORKTREE_TYPE_ORDER[typeKey],
+                sortBranch: branchName.toLowerCase(),
+                sortIndex: index,
+            };
+        }));
+        rows
+            .sort((a, b) => a.sortType - b.sortType ||
+            a.sortBranch.localeCompare(b.sortBranch) ||
+            a.sortIndex - b.sortIndex)
+            .forEach(row => console.log(row.text));
         console.log('');
     }
     catch (error) {

package/dist/commands/wt/open.js

@@ -0,0 +1,245 @@
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import path from 'path';
+import fs from 'fs-extra';
+import { constants as fsConstants } from 'fs';
+import { execa } from 'execa';
+import { listWorktrees, getRepoRoot } from '../../lib/git.js';
+import { log, ui } from '../../lib/ui.js';
+import { ensureAutocompletePrompt } from '../../lib/prompt.js';
+import { detectWorktreeType, findWorktreeByName, formatWorktreeDisplayPath, formatWorktreeType, getWorktreeBranchName, } from '../../lib/worktree.js';
+import { enterCommand } from './enter.js';
+const OPEN_TOOL_CANDIDATES = [
+    { id: 'cursor', name: 'Cursor', command: 'cursor', kind: 'ide', aliases: ['cursor'] },
+    { id: 'code', name: 'VS Code', command: 'code', kind: 'ide', aliases: ['vscode', 'code'] },
+    { id: 'windsurf', name: 'Windsurf', command: 'windsurf', kind: 'ide', aliases: ['windsurf'] },
+    { id: 'zed', name: 'Zed', command: 'zed', kind: 'ide', aliases: ['zed'] },
+    { id: 'agy', name: 'Agy', command: 'agy', kind: 'ide', aliases: ['agy'] },
+    { id: 'idea', name: 'IntelliJ IDEA', command: 'idea', kind: 'ide', aliases: ['idea', 'intellij'] },
+    { id: 'webstorm', name: 'WebStorm', command: 'webstorm', kind: 'ide', aliases: ['webstorm'] },
+    { id: 'subl', name: 'Sublime Text', command: 'subl', kind: 'ide', aliases: ['subl', 'sublime'] },
+    { id: 'claude', name: 'Claude Code', command: 'claude', kind: 'agent', aliases: ['claude', 'claude-code'] },
+    { id: 'codex', name: 'Codex', command: 'codex', kind: 'agent', aliases: ['codex'] },
+    { id: 'gemini', name: 'Gemini CLI', command: 'gemini', kind: 'agent', aliases: ['gemini'] },
+    { id: 'opencode', name: 'OpenCode', command: 'opencode', kind: 'agent', aliases: ['opencode'] },
+];
+function truncateEnd(value, maxLen) {
+    if (maxLen <= 0)
+        return '';
+    if (value.length <= maxLen)
+        return value;
+    if (maxLen <= 1)
+        return '…';
+    return `${value.slice(0, maxLen - 1)}…`;
+}
+function truncateStart(value, maxLen) {
+    if (maxLen <= 0)
+        return '';
+    if (value.length <= maxLen)
+        return value;
+    if (maxLen <= 1)
+        return '…';
+    return `…${value.slice(-(maxLen - 1))}`;
+}
+function formatWorktreeChoiceLabel(type, branchName, displayPath, terminalColumns) {
+    const maxRowWidth = Math.max(40, terminalColumns - 10);
+    const typeWidth = 8;
+    const availableWidth = Math.max(22, maxRowWidth - typeWidth);
+    const branchWidth = Math.min(44, Math.max(12, Math.floor(availableWidth * 0.55)));
+    const pathWidth = Math.max(10, availableWidth - branchWidth - 1);
+    const branchText = truncateEnd(branchName, branchWidth).padEnd(branchWidth);
+    const pathText = truncateStart(displayPath, pathWidth);
+    const typeText = formatWorktreeType(type);
+    return `${typeText} ${chalk.yellow(branchText)} ${chalk.cyan(pathText)}`;
+}
+export async function commandExists(command) {
+    if (!command)
+        return false;
+    const isWindows = process.platform === 'win32';
+    const pathEntries = (process.env.PATH || '')
+        .split(path.delimiter)
+        .filter(Boolean);
+    const extensions = isWindows
+        ? (process.env.PATHEXT || '.EXE;.CMD;.BAT')
+            .split(';')
+            .map(ext => ext.toLowerCase())
+        : [''];
+    const hasPathSeparator = command.includes('/') || command.includes('\\');
+    const candidates = hasPathSeparator
+        ? [command]
+        : pathEntries.flatMap(dir => extensions.map(ext => path.join(dir, `${command}${ext}`)));
+    const mode = isWindows ? fsConstants.F_OK : fsConstants.X_OK;
+    for (const candidate of candidates) {
+        try {
+            await fs.access(candidate, mode);
+            return true;
+        }
+        catch {
+            // Continue scanning
+        }
+    }
+    return false;
+}
+export async function detectInstalledOpenTools() {
+    const checks = await Promise.all(OPEN_TOOL_CANDIDATES.map(async (tool) => ({
+        tool,
+        exists: await commandExists(tool.command),
+    })));
+    return checks
+        .filter(check => check.exists)
+        .map(check => check.tool);
+}
+function resolveWorktreeByName(worktrees, wtName) {
+    return findWorktreeByName(worktrees, wtName);
+}
+export function resolveOpenToolOption(input, installed) {
+    const normalized = input.trim().toLowerCase();
+    return installed.find(tool => tool.id === normalized ||
+        tool.command.toLowerCase() === normalized ||
+        tool.aliases?.some(alias => alias.toLowerCase() === normalized));
+}
+export function isAgentTool(tool) {
+    return tool.kind === 'agent';
+}
+export function buildAgentExecCommand(tool) {
+    return tool.command;
+}
+export async function promptOpenToolSelection(installedTools, message = 'Select tool to open:') {
+    const ideChoices = installedTools
+        .filter(tool => tool.kind === 'ide')
+        .map(tool => ({
+        name: `${tool.name} ${chalk.dim(`(${tool.command})`)}`,
+        value: tool,
+    }));
+    const agentChoices = installedTools
+        .filter(tool => tool.kind === 'agent')
+        .map(tool => ({
+        name: `${tool.name} ${chalk.dim(`(${tool.command})`)}`,
+        value: tool,
+    }));
+    const choices = [];
+    if (ideChoices.length > 0) {
+        choices.push(new inquirer.Separator(chalk.dim('── IDEs ──')));
+        choices.push(...ideChoices);
+    }
+    if (agentChoices.length > 0) {
+        if (choices.length > 0)
+            choices.push(new inquirer.Separator(" "));
+        choices.push(new inquirer.Separator(chalk.dim('── Agent CLIs ──')));
+        choices.push(...agentChoices);
+    }
+    const { selectedTool } = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'selectedTool',
+            message,
+            choices,
+            loop: false,
+            pageSize: 10,
+        },
+    ]);
+    return selectedTool;
+}
+export async function launchOpenTool(tool, wtPath) {
+    if (isAgentTool(tool)) {
+        await enterCommand(wtPath, { exec: buildAgentExecCommand(tool) });
+        return;
+    }
+    await execa(tool.command, [wtPath], {
+        cwd: wtPath,
+        stdio: 'ignore',
+    });
+}
+export async function openCommand(wtName, options = {}) {
+    try {
+        await getRepoRoot();
+        const worktrees = await listWorktrees();
+        const mainWorktreePath = worktrees[0]?.path || '';
+        if (worktrees.length === 0) {
+            log.info('No worktrees found.');
+            return;
+        }
+        let targetWt;
+        if (wtName) {
+            targetWt = resolveWorktreeByName(worktrees, wtName);
+            if (!targetWt) {
+                log.error(`Worktree "${wtName}" not found.`);
+                return;
+            }
+        }
+        else {
+            ensureAutocompletePrompt();
+            const terminalColumns = process.stdout.columns || 100;
+            const candidates = await Promise.all(worktrees.map(async (wt) => {
+                const type = await detectWorktreeType(wt, mainWorktreePath);
+                const branchName = getWorktreeBranchName(wt);
+                const displayPath = formatWorktreeDisplayPath(wt.path);
+                const rawType = type.toLowerCase();
+                const rawDisplayPath = displayPath.toLowerCase();
+                const rawBranchName = branchName.toLowerCase();
+                return {
+                    worktree: wt,
+                    label: formatWorktreeChoiceLabel(type, branchName, displayPath, terminalColumns),
+                    searchText: `${rawType} ${rawBranchName} ${rawDisplayPath}`,
+                };
+            }));
+            const { selectedWt } = await inquirer.prompt([
+                {
+                    type: 'autocomplete',
+                    name: 'selectedWt',
+                    message: 'Select a worktree to open (type to filter):',
+                    source: async (_answers, input = '') => {
+                        const term = input.trim().toLowerCase();
+                        const filtered = term
+                            ? candidates.filter(candidate => candidate.searchText.includes(term))
+                            : candidates;
+                        return filtered.map(candidate => ({
+                            name: candidate.label,
+                            value: candidate.worktree,
+                        }));
+                    },
+                    pageSize: 10,
+                },
+            ]);
+            targetWt = selectedWt;
+        }
+        if (!targetWt) {
+            log.error('No worktree selected.');
+            return;
+        }
+        const installedTools = await detectInstalledOpenTools();
+        let chosenTool;
+        const requestedTool = options.tool;
+        if (requestedTool) {
+            chosenTool = resolveOpenToolOption(requestedTool, installedTools);
+            if (!chosenTool && await commandExists(requestedTool)) {
+                chosenTool = {
+                    id: 'custom',
+                    name: requestedTool,
+                    command: requestedTool,
+                    kind: 'ide',
+                };
+            }
+            if (!chosenTool) {
+                const available = installedTools.map(tool => tool.command).join(', ') || 'none detected';
+                log.error(`Tool "${requestedTool}" not found.`);
+                log.dim(`Detected tool commands: ${available}`);
+                return;
+            }
+        }
+        else {
+            if (installedTools.length === 0) {
+                log.error('No supported open tool command was detected in PATH.');
+                log.dim('Try: yggtree wt open --tool <command> (e.g. --tool cursor, --tool claude)');
+                return;
+            }
+            chosenTool = await promptOpenToolSelection(installedTools);
+        }
+        log.info(`Opening ${ui.path(targetWt.path)} in ${chalk.cyan(chosenTool.name)}...`);
+        await launchOpenTool(chosenTool, targetWt.path);
+        log.success(isAgentTool(chosenTool) ? 'Agent launched.' : 'IDE launched.');
+    }
+    catch (error) {
+        log.error(error.message);
+    }
+}

package/dist/commands/wt/path.js

@@ -1,8 +1,7 @@
 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';
+import { findWorktreeByName, formatWorktreeDisplayPath, getWorktreeBranchName } from '../../lib/worktree.js';
 export async function pathCommand(wtName) {
     try {
         await getRepoRoot();
@@ -13,16 +12,7 @@ export async function pathCommand(wtName) {
         }
         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;
-            });
+            targetWt = findWorktreeByName(worktrees, wtName);
             if (!targetWt) {
                 log.error(`Worktree "${wtName}" not found.`);
                 return;
@@ -31,11 +21,8 @@ export async function pathCommand(wtName) {
         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 || '', '~');
+                const branchName = getWorktreeBranchName(wt);
+                const displayPath = formatWorktreeDisplayPath(wt.path);
                 return {
                     name: `${branchName.padEnd(20)} ${displayPath}`,
                     value: wt