yggtree 1.4.2 → 1.4.4

package/dist/commands/wt/open.js

@@ -9,20 +9,30 @@ 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'] },
+export const OPEN_TOOL_CANDIDATES = [
+    { id: 'cursor', name: 'Cursor', command: 'cursor', kind: 'editor', aliases: ['cursor'] },
+    { id: 'code', name: 'VS Code', command: 'code', kind: 'editor', aliases: ['vscode', 'code'] },
+    { id: 'windsurf', name: 'Windsurf', command: 'windsurf', kind: 'editor', aliases: ['windsurf'] },
+    { id: 'zed', name: 'Zed', command: 'zed', kind: 'editor', aliases: ['zed'] },
+    { id: 'idea', name: 'IntelliJ IDEA', command: 'idea', kind: 'editor', aliases: ['idea', 'intellij'] },
+    { id: 'webstorm', name: 'WebStorm', command: 'webstorm', kind: 'editor', aliases: ['webstorm'] },
+    { id: 'subl', name: 'Sublime Text', command: 'subl', kind: 'editor', aliases: ['subl', 'sublime'] },
+    {
+        id: 'codex-app',
+        name: 'Codex App',
+        command: 'codex-app',
+        kind: 'app',
+        aliases: ['codex', 'codex-app'],
+        bundleId: 'com.openai.codex',
+    },
+    { id: 'cmux', name: 'Cmux Panel', command: 'cmux', kind: 'terminal', aliases: ['cmux', 'cmux-panel'] },
+    { id: 'tmux', name: 'Tmux Session', command: 'tmux', kind: 'terminal', aliases: ['tmux', 'tmux-session'] },
 ];
+const OTHER_COMMAND_ACTION = '__other_command__';
+const NO_OPEN_ACTION = '__no_open__';
+const OPEN_ACTION_PAGE_SIZE = 16;
+const CMUX_TERMINAL_STARTUP_DELAY_MS = 350;
+const yggtreeAccent = chalk.hex('#DEADED');
 function truncateEnd(value, maxLen) {
     if (maxLen <= 0)
         return '';
@@ -52,6 +62,71 @@ function formatWorktreeChoiceLabel(type, branchName, displayPath, terminalColumn
     const typeText = formatWorktreeType(type);
     return `${typeText} ${chalk.yellow(branchText)} ${chalk.cyan(pathText)}`;
 }
+function openRail() {
+    return yggtreeAccent('│');
+}
+function formatOpenColumns(name, command, detail) {
+    const paddedName = name.padEnd(16);
+    const paddedCommand = command.padEnd(13);
+    const row = `${openRail()}  ${chalk.bold(paddedName)} ${chalk.cyan(paddedCommand)}`;
+    return detail ? `${row} ${chalk.dim(detail)}` : row;
+}
+export function formatOpenToolChoice(tool) {
+    return formatOpenColumns(tool.name, tool.command, '');
+}
+function shellQuote(value) {
+    return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function formatTerminalSessionName(wtPath) {
+    const basename = path.basename(wtPath) || 'worktree';
+    const slug = basename.toLowerCase().replace(/[^a-z0-9_.-]+/g, '-').replace(/^-+|-+$/g, '');
+    return `yggtree-${slug || 'worktree'}`.slice(0, 80);
+}
+export function buildTmuxLaunchCommand(wtPath, env = process.env) {
+    const sessionName = formatTerminalSessionName(wtPath);
+    if (env.TMUX) {
+        return {
+            executable: 'tmux',
+            args: ['new-window', '-c', wtPath, '-n', sessionName],
+        };
+    }
+    return {
+        executable: 'tmux',
+        args: ['new-session', '-A', '-s', sessionName, '-c', wtPath],
+    };
+}
+export function buildCmuxNewPaneCommand() {
+    return {
+        executable: 'cmux',
+        args: ['new-pane', '--type', 'terminal', '--direction', 'right', '--focus', 'true'],
+    };
+}
+export function parseCmuxSurfaceRef(output) {
+    return output.match(/\bsurface:\S+/)?.[0];
+}
+function delay(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+export function buildCmuxSendCommand(surfaceRef, wtPath) {
+    return {
+        executable: 'cmux',
+        args: ['send', '--surface', surfaceRef, `cd ${shellQuote(wtPath)}`],
+    };
+}
+export function buildCmuxEnterCommand(surfaceRef) {
+    return {
+        executable: 'cmux',
+        args: ['send-key', '--surface', surfaceRef, 'Enter'],
+    };
+}
+export function formatOpenSpecialChoice(value, allowShellAction) {
+    if (value === OTHER_COMMAND_ACTION) {
+        return formatOpenColumns('Other command', 'custom', 'run first, then stay in shell');
+    }
+    return allowShellAction
+        ? formatOpenColumns('Nothing', 'skip', 'just enter the shell')
+        : formatOpenColumns('Do not open', 'skip', 'return after selection');
+}
 export async function commandExists(command) {
     if (!command)
         return false;
@@ -80,10 +155,29 @@ export async function commandExists(command) {
     }
     return false;
 }
+export async function macOSAppBundleExists(bundleId) {
+    if (process.platform !== 'darwin')
+        return false;
+    try {
+        const result = await execa('/usr/bin/mdfind', [`kMDItemCFBundleIdentifier == '${bundleId}'`]);
+        if (result.stdout.trim().length > 0)
+            return true;
+    }
+    catch {
+        // Fall back to common application roots when Spotlight is unavailable.
+    }
+    const commonAppPaths = [
+        '/Applications/Codex.app',
+        path.join(process.env.HOME || '', 'Applications', 'Codex.app'),
+    ];
+    return commonAppPaths.some(appPath => fs.existsSync(appPath));
+}
 export async function detectInstalledOpenTools() {
     const checks = await Promise.all(OPEN_TOOL_CANDIDATES.map(async (tool) => ({
         tool,
-        exists: await commandExists(tool.command),
+        exists: tool.bundleId
+            ? await macOSAppBundleExists(tool.bundleId)
+            : await commandExists(tool.command),
     })));
     return checks
         .filter(check => check.exists)
@@ -98,36 +192,39 @@ export function resolveOpenToolOption(input, installed) {
         tool.command.toLowerCase() === normalized ||
         tool.aliases?.some(alias => alias.toLowerCase() === normalized));
 }
-export function isAgentTool(tool) {
-    return tool.kind === 'agent';
+export function resolveOpenToolCandidate(input) {
+    const normalized = input.trim().toLowerCase();
+    return OPEN_TOOL_CANDIDATES.find(tool => tool.id === normalized ||
+        tool.command.toLowerCase() === normalized ||
+        tool.aliases?.some(alias => alias.toLowerCase() === normalized));
 }
-export function buildAgentExecCommand(tool) {
-    return tool.command;
+async function resolveKnownOpenToolOption(input) {
+    const candidate = resolveOpenToolCandidate(input);
+    if (!candidate)
+        return undefined;
+    const exists = candidate.bundleId
+        ? await macOSAppBundleExists(candidate.bundleId)
+        : await commandExists(candidate.command);
+    return exists ? candidate : undefined;
+}
+export async function resolveOpenToolAction(input, installed) {
+    let chosenTool = resolveOpenToolOption(input, installed) || await resolveKnownOpenToolOption(input);
+    if (!chosenTool && await commandExists(input)) {
+        chosenTool = {
+            id: 'custom',
+            name: input,
+            command: input,
+            kind: 'editor',
+        };
+    }
+    return chosenTool ? { type: 'tool', tool: chosenTool } : undefined;
 }
 export async function promptOpenToolSelection(installedTools, message = 'Select tool to open:') {
-    const ideChoices = installedTools
-        .filter(tool => tool.kind === 'ide')
+    const choices = installedTools
         .map(tool => ({
-        name: `${tool.name} ${chalk.dim(`(${tool.command})`)}`,
+        name: formatOpenToolChoice(tool),
         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',
@@ -135,21 +232,136 @@ export async function promptOpenToolSelection(installedTools, message = 'Select
             message,
             choices,
             loop: false,
-            pageSize: 10,
+            pageSize: OPEN_ACTION_PAGE_SIZE,
         },
     ]);
     return selectedTool;
 }
+export function buildOpenActionsFromSelection(selectedValue, installedTools, otherCommand) {
+    if (selectedValue === NO_OPEN_ACTION)
+        return [];
+    if (selectedValue.startsWith('tool:')) {
+        const tool = installedTools.find(candidate => `tool:${candidate.id}` === selectedValue);
+        return tool ? [{ type: 'tool', tool }] : [];
+    }
+    if (selectedValue === OTHER_COMMAND_ACTION && otherCommand?.trim()) {
+        return [{ type: 'other-command', command: otherCommand.trim() }];
+    }
+    return [];
+}
+export function buildOpenActionChoices(installedTools, allowShellAction) {
+    const choices = installedTools.map(tool => ({
+        name: formatOpenToolChoice(tool),
+        value: `tool:${tool.id}`,
+    }));
+    if (allowShellAction) {
+        choices.push({
+            name: formatOpenSpecialChoice(OTHER_COMMAND_ACTION, allowShellAction),
+            value: OTHER_COMMAND_ACTION,
+        });
+    }
+    choices.push({
+        name: formatOpenSpecialChoice(NO_OPEN_ACTION, allowShellAction),
+        value: NO_OPEN_ACTION,
+    });
+    return choices;
+}
+export async function promptOpenActions(installedTools, options = {}) {
+    const allowShellAction = options.allowShellAction ?? true;
+    const choices = buildOpenActionChoices(installedTools, allowShellAction);
+    const { selectedValue } = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'selectedValue',
+            message: options.message || 'Open anything before entering the shell?',
+            choices,
+            loop: false,
+            pageSize: OPEN_ACTION_PAGE_SIZE,
+        },
+    ]);
+    let otherCommand;
+    if (selectedValue === OTHER_COMMAND_ACTION) {
+        const answer = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'otherCommand',
+                message: 'Command to run in the worktree shell:',
+                validate: (input) => input.trim().length > 0 || 'Command is required',
+            },
+        ]);
+        otherCommand = answer.otherCommand;
+    }
+    return buildOpenActionsFromSelection(selectedValue, installedTools, otherCommand);
+}
 export async function launchOpenTool(tool, wtPath) {
-    if (isAgentTool(tool)) {
-        await enterCommand(wtPath, { exec: buildAgentExecCommand(tool) });
+    if (tool.id === 'cmux') {
+        const newPaneCommand = buildCmuxNewPaneCommand();
+        const newPaneResult = await execa(newPaneCommand.executable, newPaneCommand.args, {
+            cwd: wtPath,
+        });
+        const surfaceRef = parseCmuxSurfaceRef(newPaneResult.stdout);
+        if (!surfaceRef) {
+            throw new Error(`Cmux did not return a terminal surface handle: ${newPaneResult.stdout || '<empty output>'}`);
+        }
+        await delay(CMUX_TERMINAL_STARTUP_DELAY_MS);
+        const sendCommand = buildCmuxSendCommand(surfaceRef, wtPath);
+        await execa(sendCommand.executable, sendCommand.args, {
+            cwd: wtPath,
+            stdio: 'ignore',
+        });
+        const enterCommand = buildCmuxEnterCommand(surfaceRef);
+        await execa(enterCommand.executable, enterCommand.args, {
+            cwd: wtPath,
+            stdio: 'ignore',
+        });
+        return;
+    }
+    if (tool.id === 'tmux') {
+        const { executable, args } = buildTmuxLaunchCommand(wtPath);
+        await execa(executable, args, {
+            cwd: wtPath,
+            stdio: 'inherit',
+        });
         return;
     }
-    await execa(tool.command, [wtPath], {
+    const { executable, args } = buildOpenToolLaunchCommand(tool, wtPath);
+    await execa(executable, args, {
         cwd: wtPath,
         stdio: 'ignore',
     });
 }
+export function buildOpenToolLaunchCommand(tool, wtPath) {
+    if (tool.bundleId) {
+        return {
+            executable: '/usr/bin/open',
+            args: ['-b', tool.bundleId, wtPath],
+        };
+    }
+    return {
+        executable: tool.command,
+        args: [wtPath],
+    };
+}
+export async function runOpenActions(actions, wtPath, options = {}) {
+    let openedTerminal = false;
+    for (const action of actions) {
+        if (action.type === 'tool' && action.tool) {
+            log.info(`Opening ${ui.path(wtPath)} in ${chalk.cyan(action.tool.name)}...`);
+            await launchOpenTool(action.tool, wtPath);
+            if (action.tool.kind === 'terminal') {
+                openedTerminal = true;
+            }
+        }
+    }
+    const shellAction = actions.find(action => action.type === 'other-command');
+    if (shellAction?.command) {
+        await enterCommand(wtPath, { exec: shellAction.command });
+        return;
+    }
+    if (options.enter !== false && !openedTerminal) {
+        await enterCommand(wtPath);
+    }
+}
 export async function openCommand(wtName, options = {}) {
     try {
         await getRepoRoot();
@@ -208,36 +420,33 @@ export async function openCommand(wtName, options = {}) {
             return;
         }
         const installedTools = await detectInstalledOpenTools();
-        let chosenTool;
         const requestedTool = options.tool;
+        const shouldEnter = options.enter === true;
         if (requestedTool) {
-            chosenTool = resolveOpenToolOption(requestedTool, installedTools);
-            if (!chosenTool && await commandExists(requestedTool)) {
-                chosenTool = {
-                    id: 'custom',
-                    name: requestedTool,
-                    command: requestedTool,
-                    kind: 'ide',
-                };
-            }
-            if (!chosenTool) {
+            const toolAction = await resolveOpenToolAction(requestedTool, installedTools);
+            if (!toolAction) {
                 const available = installedTools.map(tool => tool.command).join(', ') || 'none detected';
                 log.error(`Tool "${requestedTool}" not found.`);
                 log.dim(`Detected tool commands: ${available}`);
                 return;
             }
+            await runOpenActions([toolAction], targetWt.path, { enter: shouldEnter });
+            log.success('Worktree opened.');
+            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)');
+            if (installedTools.length === 0 && !shouldEnter) {
+                log.error('No supported editor command or app was detected.');
+                log.dim('Try: yggtree open --tool <command> (e.g. --tool cursor or --tool codex-app), or yggtree open --enter');
                 return;
             }
-            chosenTool = await promptOpenToolSelection(installedTools);
+            const actions = await promptOpenActions(installedTools, {
+                allowShellAction: shouldEnter,
+                message: shouldEnter ? 'Open anything before entering the shell?' : 'Open anything?',
+            });
+            await runOpenActions(actions, targetWt.path, { enter: shouldEnter });
         }
-        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.');
+        log.success('Worktree opened.');
     }
     catch (error) {
         log.error(error.message);