yggtree 1.3.0 → 1.4.1

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

package/dist/index.js

@@ -1,5 +1,6 @@
 import { Command } from 'commander';
 import inquirer from 'inquirer';
+import chalk from 'chalk';
 import { welcome, log } from './lib/ui.js';
 import { listCommand } from './commands/wt/list.js';
 import { createCommand } from './commands/wt/create.js';
@@ -12,9 +13,13 @@ 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 { unapplyCommand } from './commands/wt/unapply.js';
 import { getVersion } from './lib/version.js';
+import { findSandboxRoot } from './lib/sandbox.js';
+import { bifrostCommand } from './commands/bifrost.js';
+import { thorCommand } from './commands/thor.js';
 const program = new Command();
 program
     .name('yggtree')
@@ -23,30 +28,52 @@ program
     .action(async () => {
     // Interactive Menu if no command is provided
     await welcome();
+    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: `🧪 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: `🪓 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' },
+    ];
+    const sandboxChoices = [
+        { name: `✅ Graft Sandbox Changes ${chalk.dim('(apply sandbox changes)')}`, value: 'apply' },
+        { name: `↩️ Undo Sandbox Graft ${chalk.dim('(unapply sandbox changes)')}`, value: 'unapply' },
+    ];
+    const choices = isInSandbox
+        ? [
+            ...sandboxChoices,
+            new inquirer.Separator(),
+            ...realmChoices,
+            new inquirer.Separator(),
+            { name: `🌈 Summon the Bifrost ${chalk.dim('(easter egg)')}`, value: 'bifrost' },
+            { name: `⚡ Consult Thor ${chalk.dim('(easter egg)')}`, value: 'thor' },
+            { name: `🚪 Leave Yggdrasil ${chalk.dim('(exit)')}`, value: 'exit' },
+        ]
+        : [
+            ...realmChoices,
+            new inquirer.Separator(),
+            ...sandboxChoices,
+            new inquirer.Separator(),
+            { name: `🌈 Summon the Bifrost ${chalk.dim('(easter egg)')}`, value: 'bifrost' },
+            { name: `⚡ Consult Thor ${chalk.dim('(easter egg)')}`, value: 'thor' },
+            { name: `🚪 Leave Yggdrasil ${chalk.dim('(exit)')}`, value: 'exit' },
+        ];
     const { action } = await inquirer.prompt([
         {
             type: 'list',
             name: 'action',
             message: 'What would you like to do?',
             loop: false,
-            choices: [
-                { name: '🌿 Create new worktree (Smart Branch)', value: 'create-smart' },
-                { name: '🌳 Create multiple worktrees', value: 'create-multi' },
-                { name: '🧪 Create sandbox worktree', value: 'create-sandbox' },
-                // { name: '🌱 Create new worktree (Manual Slug)', value: 'create-slug' },
-                { name: '📋 List worktrees', value: 'list' },
-                { name: '🪓 Delete worktree', value: 'delete' },
-                { name: '🚀 Bootstrap worktree', value: 'bootstrap' },
-                { name: '🧹 Prune stale worktrees', value: 'prune' },
-                { name: '🐚 Exec command', value: 'exec' },
-                { name: '🚪 Enter worktree', value: 'enter' },
-                { name: '📍 Get worktree path', value: 'path' },
-                new inquirer.Separator(),
-                { name: '✅ Apply sandbox changes', value: 'apply' },
-                { name: '↩️  Unapply sandbox changes', value: 'unapply' },
-                new inquirer.Separator(),
-                { name: '🚪 Exit', value: 'exit' },
-            ],
+            pageSize: 12,
+            choices,
         },
     ]);
     switch (action) {
@@ -56,12 +83,15 @@ program
         case 'create-multi':
             await createCommandMulti({ bootstrap: true });
             break;
-        case 'create-slug':
+        case 'worktree-checkout':
             await createCommand({ bootstrap: true });
             break;
         case 'list':
             await listCommand();
             break;
+        case 'open':
+            await openCommand();
+            break;
         case 'delete':
             await deleteCommand();
             break;
@@ -89,6 +119,12 @@ program
         case 'create-sandbox':
             await createSandboxCommand({ bootstrap: true });
             break;
+        case 'bifrost':
+            await bifrostCommand();
+            break;
+        case 'thor':
+            await thorCommand();
+            break;
         case 'exit':
             log.info('Bye! 👋');
             process.exit(0);
@@ -97,8 +133,15 @@ program
 // --- Worktree Commands ---
 const wt = program.command('wt').description('Manage git worktrees');
 wt.command('list')
-    .description('List all worktrees')
-    .action(listCommand);
+    .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)')
@@ -122,8 +165,8 @@ wt.command('create-multi')
     .action(async (options) => {
     await createCommandMulti(options);
 });
-wt.command('create-slug [name] [ref]')
-    .description('Create a new worktree (Manual slug/ref)')
+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)')
@@ -138,8 +181,17 @@ wt.command('create-slug [name] [ref]')
     });
 });
 wt.command('delete')
-    .description('Delete a managed worktree')
-    .action(deleteCommand);
+    .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);
@@ -167,6 +219,7 @@ wt.command('path [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)')
@@ -182,4 +235,10 @@ wt.command('apply')
 wt.command('unapply')
     .description('Undo applied sandbox changes in origin')
     .action(unapplyCommand);
+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);

package/dist/lib/prompt.js

@@ -0,0 +1,9 @@
+import inquirer from 'inquirer';
+import autocompletePrompt from 'inquirer-autocomplete-prompt';
+let autocompleteRegistered = false;
+export function ensureAutocompletePrompt() {
+    if (!autocompleteRegistered) {
+        inquirer.registerPrompt('autocomplete', autocompletePrompt);
+        autocompleteRegistered = true;
+    }
+}

package/dist/lib/sandbox.js

@@ -11,6 +11,20 @@ export function generateSandboxName(branch) {
     const safeBranch = branch.replace(/[\\/]/g, '-');
     return `sandbox-${hash}_${safeBranch}`;
 }
+/**
+ * Normalize a custom sandbox name into a branch-safe slug.
+ * Keeps current sandbox prefix conventions for easier filtering.
+ */
+export function normalizeSandboxName(input) {
+    const cleaned = input
+        .trim()
+        .replace(/[\\/]/g, '-')
+        .replace(/\s+/g, '-')
+        .replace(/^-+|-+$/g, '');
+    if (!cleaned)
+        return '';
+    return cleaned.startsWith('sandbox-') ? cleaned : `sandbox-${cleaned}`;
+}
 /**
  * Get the path to the sandbox metadata file
  */

package/dist/lib/worktree.js

@@ -0,0 +1,52 @@
+import chalk from 'chalk';
+import fs from 'fs-extra';
+import path from 'path';
+import { WORKTREES_ROOT } from './paths.js';
+import { getSandboxMetaPath } from './sandbox.js';
+export const WORKTREE_TYPE_ORDER = {
+    MAIN: 0,
+    MANAGED: 1,
+    SANDBOX: 2,
+    LINKED: 3,
+};
+export function getWorktreeBranchName(worktree) {
+    return worktree.branch || worktree.HEAD || 'detached';
+}
+export function isManagedWorktreePath(worktreePath) {
+    return worktreePath.startsWith(WORKTREES_ROOT);
+}
+export function formatWorktreeDisplayPath(worktreePath) {
+    if (isManagedWorktreePath(worktreePath)) {
+        return path.relative(WORKTREES_ROOT, worktreePath);
+    }
+    return worktreePath.replace(process.env.HOME || '', '~');
+}
+export function findWorktreeByName(worktrees, worktreeName) {
+    return worktrees.find(worktree => {
+        const branchName = getWorktreeBranchName(worktree);
+        const relativePath = path.relative(WORKTREES_ROOT, worktree.path);
+        const basename = path.basename(worktree.path);
+        return branchName === worktreeName ||
+            relativePath === worktreeName ||
+            worktree.path === worktreeName ||
+            basename === worktreeName;
+    });
+}
+export async function detectWorktreeType(worktree, mainWorktreePath) {
+    const isManaged = isManagedWorktreePath(worktree.path);
+    if (!isManaged) {
+        return worktree.path === mainWorktreePath ? 'MAIN' : 'LINKED';
+    }
+    const hasSandboxMeta = await fs.pathExists(getSandboxMetaPath(worktree.path));
+    const isSandboxBranch = (worktree.branch || '').startsWith('sandbox-');
+    return hasSandboxMeta || isSandboxBranch ? 'SANDBOX' : 'MANAGED';
+}
+export function formatWorktreeType(type) {
+    if (type === 'SANDBOX')
+        return chalk.magenta('SANDBOX');
+    if (type === 'MANAGED')
+        return chalk.green('MANAGED');
+    if (type === 'MAIN')
+        return chalk.blue('MAIN   ');
+    return chalk.cyan('LINKED ');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yggtree",
-  "version": "1.3.0",
+  "version": "1.4.1",
   "description": "Interactive CLI for managing git worktrees and configs",
   "main": "dist/index.js",
   "type": "module",
@@ -34,6 +34,7 @@
     "fs-extra": "^11.2.0",
     "gradient-string": "^2.0.2",
     "inquirer": "^9.2.14",
+    "inquirer-autocomplete-prompt": "^3.0.1",
     "ora": "^8.0.1",
     "zod": "^3.22.4"
   },