yggtree 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Leonardo Dias
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,93 @@
+# 🌳 Yggdrasil Worktree (yggtree)
+
+**Yggdrasil Worktree** (invoked as `yggtree`) is a powerful, interactive CLI designed to streamline your Git worktree workflow. Like the mythical world tree connecting the realms, Yggdrasil connects your branches into isolated, manageable worktrees.
+
+---
+
+## 🚀 Quick Start
+
+### Installation
+
+```bash
+# Clone the repository
+git clone https://github.com/leoreisdias/yggtree.git
+cd yggtree
+
+# Install dependencies and build
+npm install
+npm run build
+
+# Link the CLI globally
+npm link
+```
+
+### Usage
+
+Simply run `yggtree` to open the interactive menu:
+
+```bash
+yggtree
+```
+
+Or use specific commands:
+
+```bash
+yggtree wt create      # Smart branch-based creation
+yggtree wt list        # View all managed worktrees
+yggtree wt prune       # Clean up stale worktree data
+```
+
+---
+
+## ✨ Key Features
+
+### 🌿 Smart Branch Creation (`wt create`)
+The primary way to start working. Instead of worrying about folder names, just tell Yggdrasil which branch you want to work on.
+- **Auto-Slug**: Converts `feat/eng-123-ui` to a clean folder name like `feat-eng-123-ui`.
+- **Auto-Branching**: If the branch doesn't exist, Yggdrasil creates it for you from a base branch.
+- **Remote Awareness**: Seamlessly base your work on `origin/main` or local refs.
+
+### 🌳 Batch Creation (`wt create-multi`)
+Need to spin up multiple features? Provide branch names separated by spaces, and Yggdrasil will provision all of them in one go.
+
+### 🚀 Custom Bootstrapping
+Configure your environment automatically using an `anvil-worktree.json` (also compatible with `.cursor/worktrees.json`) file in your project root.
+
+---
+
+## ⚙️ Configuration
+
+Yggdrasil looks for setup instructions in your project root:
+
+```json
+{
+  "setup-worktree": [
+    "npm install",
+    "git submodule sync --recursive",
+    "git submodule update --init --recursive",
+    "npm run build",
+    "echo '🌳 The realm is ready!'"
+  ]
+}
+```
+
+---
+
+## 🛠️ Commands Reference
+
+| Command | Description |
+| :--- | :--- |
+| `yggtree` | Open the interactive main menu. |
+| `yggtree wt create` | Create a worktree by branch name (Recommended). |
+| `yggtree wt create-multi` | Create multiple worktrees in a single command. |
+| `yggtree wt create-slug` | Manually specify both folder name and branch ref. |
+| `yggtree wt list` | List all managed worktrees and their status. |
+| `yggtree wt delete` | Interactively select and remove a worktree. |
+| `yggtree wt bootstrap` | Re-run the setup commands for an existing worktree. |
+| `yggtree wt prune` | Clean up Git's internal data for worktrees. |
+
+---
+
+## 📄 License
+
+MIT License.

package/bin/yggtree

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import '../dist/index.js';

package/dist/commands/wt/bootstrap.js

@@ -0,0 +1,41 @@
+import chalk from 'chalk';
+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 { runBootstrap } from '../../lib/config.js';
+export async function bootstrapCommand() {
+    try {
+        const _ = await getRepoRoot();
+        const worktrees = await listWorktrees();
+        // 1. Select Worktree
+        // Filter managed or just show all? The prompt said "managed", let's prioritize managed but maybe allow all if needed?
+        // User requirements say "managed", sticking to that for consistency.
+        const managedWts = worktrees.filter(wt => wt.path.startsWith(WORKTREES_ROOT));
+        if (managedWts.length === 0) {
+            log.info('No managed worktrees found to bootstrap.');
+            return;
+        }
+        const choices = managedWts.map(wt => ({
+            name: `${chalk.bold(path.basename(wt.path))} (${chalk.dim(wt.branch || wt.HEAD)})`,
+            value: wt.path,
+        }));
+        const { selectedPath } = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'selectedPath',
+                message: 'Select worktree to bootstrap:',
+                choices: choices,
+            },
+        ]);
+        const wtPath = selectedPath;
+        const repoRoot = await getRepoRoot();
+        await runBootstrap(wtPath, repoRoot);
+        log.success('Bootstrap completed!');
+    }
+    catch (error) {
+        log.error(error.message);
+        process.exit(1);
+    }
+}

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

@@ -0,0 +1,138 @@
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import path from 'path';
+import { getRepoRoot, verifyRef, fetchAll, getCurrentBranch } from '../../lib/git.js';
+import { runBootstrap } from '../../lib/config.js';
+import { WORKTREES_ROOT } from '../../lib/paths.js';
+import { log, ui, createSpinner } from '../../lib/ui.js';
+import { execa } from 'execa';
+import { spawn } from 'child_process';
+import fs from 'fs-extra';
+export async function createCommandNew(options) {
+    try {
+        const repoRoot = await getRepoRoot();
+        log.info(`Repo: ${chalk.dim(repoRoot)}`);
+        // 1. Gather inputs
+        const currentBranch = await getCurrentBranch();
+        const answers = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'branch',
+                message: 'Branch name (e.g. feat/new-thing):',
+                default: options.branch,
+                when: !options.branch,
+                validate: (input) => input.trim().length > 0 || 'Branch name is required',
+            },
+            {
+                type: 'input',
+                name: 'base',
+                message: 'Base branch name:',
+                default: options.base || currentBranch,
+                when: !options.base,
+                validate: (input) => input.trim().length > 0 || 'Base ref is required',
+            },
+            {
+                type: 'list',
+                name: 'source',
+                message: 'Base on:',
+                loop: false,
+                choices: [
+                    { name: 'Remote (origin)', value: 'remote' },
+                    { name: 'Local', value: 'local' },
+                ],
+                default: 'remote',
+                when: !options.base,
+            },
+            {
+                type: 'confirm',
+                name: 'bootstrap',
+                message: 'Run bootstrap? (npm install + submodules)',
+                default: true,
+                when: options.bootstrap !== false,
+            },
+        ]);
+        let shouldEnter = false;
+        if (!options.branch) {
+            const finalAnswer = await inquirer.prompt([{
+                    type: 'confirm',
+                    name: 'shouldEnter',
+                    message: 'Do you want to enter the new worktree now?',
+                    default: true
+                }]);
+            shouldEnter = finalAnswer.shouldEnter;
+        }
+        const branchName = options.branch || answers.branch;
+        let baseRef = options.base || answers.base;
+        // Append origin/ if remote is selected and not already present
+        if (!options.base && answers.source === 'remote' && !baseRef.startsWith('origin/')) {
+            baseRef = `origin/${baseRef}`;
+        }
+        const shouldBootstrap = options.bootstrap === false ? false : answers.bootstrap;
+        // Convert branch name to slug (friendly folder name)
+        // e.g. feat/eng-2222-new-button -> feat-eng-2222-new-button
+        const slug = branchName.replace(/[\/\\]/g, '-').replace(/\s+/g, '-');
+        const wtPath = path.join(WORKTREES_ROOT, slug);
+        // 2. Validation
+        if (!slug)
+            throw new Error('Invalid name');
+        if (!baseRef)
+            throw new Error('Invalid base ref');
+        // 3. Execution
+        const spinner = createSpinner('Fetching...').start();
+        await fetchAll();
+        spinner.text = 'Verifying base ref...';
+        const baseExists = await verifyRef(baseRef);
+        if (!baseExists) {
+            spinner.fail(`Base ref not found: ${baseRef}`);
+            log.warning(`Tip: try checking if the branch exists on remote.`);
+            return;
+        }
+        spinner.text = `Creating worktree at ${ui.path(wtPath)}...`;
+        // Check if target branch already exists
+        const targetBranchExists = await verifyRef(branchName);
+        // If branch doesn't exist, we create it from base
+        // If it does exist, we just check it out
+        const createBranchFlag = targetBranchExists ? '' : `-b ${branchName}`;
+        try {
+            await fs.ensureDir(path.dirname(wtPath));
+            // slightly different logic for creating new branch vs existing
+            if (targetBranchExists) {
+                await execa('git', ['worktree', 'add', wtPath, branchName]);
+            }
+            else {
+                await execa('git', ['worktree', 'add', '-b', branchName, wtPath, baseRef]);
+            }
+            spinner.succeed('Worktree created.');
+        }
+        catch (e) {
+            spinner.fail('Failed to create worktree.');
+            log.error(e.message);
+            return;
+        }
+        // 4. Bootstrap
+        if (shouldBootstrap) {
+            await runBootstrap(wtPath, repoRoot);
+        }
+        // 5. Final Output
+        log.success('Worktree ready!');
+        if (shouldEnter) {
+            log.info(`Spawning sub-shell in ${ui.path(wtPath)}...`);
+            log.dim('Type "exit" to return to the main terminal.');
+            const shell = process.env.SHELL || 'zsh';
+            const child = spawn(shell, [], {
+                cwd: wtPath,
+                stdio: 'inherit',
+            });
+            child.on('close', () => {
+                log.info('Exited sub-shell.');
+            });
+        }
+        else {
+            log.header(`cd "${wtPath}"`);
+        }
+    }
+    catch (error) {
+        log.error(error.message);
+        process.exit(1);
+    }
+}

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

@@ -0,0 +1,109 @@
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import path from 'path';
+import { getRepoRoot, verifyRef, fetchAll, getCurrentBranch } from '../../lib/git.js';
+import { runBootstrap } from '../../lib/config.js';
+import { WORKTREES_ROOT } from '../../lib/paths.js';
+import { log, ui, createSpinner } from '../../lib/ui.js';
+import { execa } from 'execa';
+import fs from 'fs-extra';
+export async function createCommandMulti(options) {
+    try {
+        const repoRoot = await getRepoRoot();
+        log.info(`Repo: ${chalk.dim(repoRoot)}`);
+        // 1. Gather inputs
+        const currentBranch = await getCurrentBranch();
+        const answers = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'base',
+                message: 'Base branch name:',
+                default: options.base || currentBranch,
+                when: !options.base,
+                validate: (input) => input.trim().length > 0 || 'Base ref is required',
+            },
+            {
+                type: 'list',
+                name: 'source',
+                message: 'Base on:',
+                loop: false,
+                choices: [
+                    { name: 'Remote (origin)', value: 'remote' },
+                    { name: 'Local', value: 'local' },
+                ],
+                default: 'remote',
+                when: !options.base,
+            },
+            {
+                type: 'input',
+                name: 'branches',
+                message: 'Enter branch names (separated by space):',
+                validate: (input) => input.trim().length > 0 || 'At least one branch name is required',
+            },
+            {
+                type: 'confirm',
+                name: 'bootstrap',
+                message: 'Run bootstrap for all worktrees? (npm install + submodules)',
+                default: true,
+                when: options.bootstrap !== false,
+            },
+        ]);
+        let baseRef = options.base || answers.base;
+        if (!options.base && answers.source === 'remote' && !baseRef.startsWith('origin/')) {
+            baseRef = `origin/${baseRef}`;
+        }
+        const branchNames = answers.branches.split(/\s+/).filter((b) => b.length > 0);
+        const shouldBootstrap = options.bootstrap === false ? false : answers.bootstrap;
+        // 2. Validation of base ref
+        const spinner = createSpinner('Fetching...').start();
+        await fetchAll();
+        spinner.text = 'Verifying base ref...';
+        const baseExists = await verifyRef(baseRef);
+        if (!baseExists) {
+            spinner.fail(`Base ref not found: ${baseRef}`);
+            return;
+        }
+        spinner.succeed(`Base ref ${chalk.cyan(baseRef)} verified.`);
+        const createdWorktrees = [];
+        // 3. Execution for each branch
+        for (const branchName of branchNames) {
+            const slug = branchName.replace(/[\/\\]/g, '-').replace(/\s+/g, '-');
+            const wtPath = path.join(WORKTREES_ROOT, slug);
+            log.header(`Processing: ${branchName}`);
+            const wtSpinner = createSpinner(`Creating worktree at ${ui.path(wtPath)}...`).start();
+            try {
+                // Check if target branch already exists
+                const targetBranchExists = await verifyRef(branchName);
+                await fs.ensureDir(path.dirname(wtPath));
+                if (targetBranchExists) {
+                    await execa('git', ['worktree', 'add', wtPath, branchName]);
+                }
+                else {
+                    await execa('git', ['worktree', 'add', '-b', branchName, wtPath, baseRef]);
+                }
+                wtSpinner.succeed(`Worktree for ${chalk.cyan(branchName)} created.`);
+                createdWorktrees.push(wtPath);
+                // 4. Bootstrap
+                if (shouldBootstrap) {
+                    await runBootstrap(wtPath, repoRoot);
+                }
+            }
+            catch (error) {
+                wtSpinner.fail(`Failed to create worktree for ${branchName}.`);
+                log.error(error.message);
+            }
+        }
+        // 5. Final Output
+        log.success(`${createdWorktrees.length} worktrees ready!`);
+        if (createdWorktrees.length > 0) {
+            log.info('You can access them with:');
+            createdWorktrees.forEach(wtPath => {
+                log.header(`cd "${wtPath}"`);
+            });
+        }
+    }
+    catch (error) {
+        log.error(error.message);
+        process.exit(1);
+    }
+}

package/dist/commands/wt/create.js

@@ -0,0 +1,124 @@
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import path from 'path';
+import { getRepoRoot, verifyRef, createWorktree, fetchAll, getCurrentBranch } from '../../lib/git.js';
+import { runBootstrap } from '../../lib/config.js';
+import { WORKTREES_ROOT } from '../../lib/paths.js';
+import { log, ui, createSpinner } from '../../lib/ui.js';
+import { spawn } from 'child_process';
+import fs from 'fs-extra';
+export async function createCommand(options) {
+    try {
+        const repoRoot = await getRepoRoot();
+        log.info(`Repo: ${chalk.dim(repoRoot)}`);
+        // 1. Gather inputs
+        const currentBranch = await getCurrentBranch();
+        const answers = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'name',
+                message: 'Worktree name (slug):',
+                default: options.name,
+                when: !options.name,
+                validate: (input) => input.trim().length > 0 || 'Name is required',
+            },
+            {
+                type: 'input',
+                name: 'ref',
+                message: 'Base branch name:',
+                default: options.ref || currentBranch,
+                when: !options.ref,
+                validate: (input) => input.trim().length > 0 || 'Ref is required',
+            },
+            {
+                type: 'list',
+                name: 'source',
+                message: 'Base on:',
+                loop: false,
+                choices: [
+                    { name: 'Remote (origin)', value: 'remote' },
+                    { name: 'Local', value: 'local' },
+                ],
+                default: 'remote',
+                when: !options.ref,
+            },
+            {
+                type: 'confirm',
+                name: 'bootstrap',
+                message: 'Run bootstrap? (npm install + submodules)',
+                default: true,
+                when: options.bootstrap !== false,
+            },
+        ]);
+        let shouldEnter = false;
+        if (!options.ref) {
+            const finalAnswer = await inquirer.prompt([{
+                    type: 'confirm',
+                    name: 'shouldEnter',
+                    message: 'Do you want to enter the new worktree now?',
+                    default: true
+                }]);
+            shouldEnter = finalAnswer.shouldEnter;
+        }
+        const name = options.name || answers.name;
+        let ref = options.ref || answers.ref;
+        // Append origin/ if remote is selected and not already present
+        if (!options.ref && answers.source === 'remote' && !ref.startsWith('origin/')) {
+            ref = `origin/${ref}`;
+        }
+        const shouldBootstrap = options.bootstrap === false ? false : answers.bootstrap;
+        const slug = name.replace(/\s+/g, '-');
+        const wtPath = path.join(WORKTREES_ROOT, slug);
+        // 2. Validation
+        if (!slug)
+            throw new Error('Invalid name');
+        if (!ref)
+            throw new Error('Invalid ref');
+        // 3. Execution
+        const spinner = createSpinner('Fetching...').start();
+        await fetchAll();
+        spinner.text = 'Verifying ref...';
+        const exists = await verifyRef(ref);
+        if (!exists) {
+            spinner.fail(`Ref not found: ${ref}`);
+            log.warning(`Tip: try 'origin/${ref}' or check if the branch exists.`);
+            return;
+        }
+        spinner.text = `Creating worktree at ${ui.path(wtPath)}...`;
+        try {
+            await fs.ensureDir(path.dirname(wtPath));
+            await createWorktree(wtPath, ref);
+            spinner.succeed('Worktree created.');
+        }
+        catch (e) {
+            spinner.fail('Failed to create worktree.');
+            log.error(e.message);
+            return;
+        }
+        // 4. Bootstrap
+        if (shouldBootstrap) {
+            await runBootstrap(wtPath, repoRoot);
+        }
+        // 5. Final Output
+        log.success('Worktree ready!');
+        if (shouldEnter) {
+            log.info(`Spawning sub-shell in ${ui.path(wtPath)}...`);
+            log.dim('Type "exit" to return to the main terminal.');
+            const shell = process.env.SHELL || 'zsh';
+            const child = spawn(shell, [], {
+                cwd: wtPath,
+                stdio: 'inherit',
+            });
+            child.on('close', () => {
+                log.info('Exited sub-shell.');
+            });
+        }
+        else {
+            log.header(`cd "${wtPath}"`);
+        }
+    }
+    catch (error) {
+        log.error(error.message);
+        process.exit(1);
+    }
+}

package/dist/commands/wt/delete.js

@@ -0,0 +1,52 @@
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import path from 'path';
+import { listWorktrees, removeWorktree, getRepoRoot } from '../../lib/git.js';
+import { WORKTREES_ROOT } from '../../lib/paths.js';
+import { log, createSpinner } from '../../lib/ui.js';
+export async function deleteCommand() {
+    try {
+        const _ = 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.');
+            return;
+        }
+        const choices = managedWts.map(wt => ({
+            name: `${chalk.bold(path.basename(wt.path))} (${chalk.dim(wt.branch || wt.HEAD)})`,
+            value: wt.path,
+        }));
+        const { selectedPath } = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'selectedPath',
+                message: 'Select worktree to delete:',
+                choices: choices,
+            },
+        ]);
+        const worktreeName = path.basename(selectedPath);
+        const { confirm } = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'confirm',
+                message: `Type "${chalk.bold(worktreeName)}" to confirm deletion:`,
+                validate: (input) => input === worktreeName || 'Incorrect name, deletion aborted.',
+            },
+        ]);
+        const spinner = createSpinner(`Deleting ${worktreeName}...`).start();
+        try {
+            await removeWorktree(selectedPath);
+            spinner.succeed(`Deleted worktree: ${worktreeName}`);
+        }
+        catch (e) {
+            spinner.fail(`Failed to delete ${worktreeName}`);
+            log.error(e.message);
+        }
+    }
+    catch (error) {
+        log.error(error.message);
+        process.exit(1);
+    }
+}

package/dist/commands/wt/list.js

@@ -0,0 +1,32 @@
+import chalk from 'chalk';
+import { listWorktrees, getRepoRoot } from '../../lib/git.js';
+import { WORKTREES_ROOT } from '../../lib/paths.js';
+import { log } from '../../lib/ui.js';
+export async function listCommand() {
+    try {
+        const _ = await getRepoRoot(); // Verify we are in a git repo
+        const worktrees = await listWorktrees();
+        if (worktrees.length === 0) {
+            log.info('No worktrees found.');
+            return;
+        }
+        console.log(chalk.bold('\n  Active Worktrees:\n'));
+        // Header
+        console.log(`  ${chalk.dim('TYPE')}    ${chalk.dim('BRANCH')}             ${chalk.dim('PATH')}`);
+        console.log(chalk.dim('  ' + '-'.repeat(60)));
+        for (const wt of worktrees) {
+            const isManaged = wt.path.startsWith(WORKTREES_ROOT);
+            const isMain = !isManaged; // Simplification: assume main repo is not in managed dir
+            const type = isManaged ? chalk.green('MANAGED') : chalk.blue('MAIN   ');
+            const branchName = wt.branch || wt.HEAD || 'detached';
+            const displayPath = wt.path.replace(process.env.HOME || '', '~');
+            const colorPath = isManaged ? chalk.cyan(displayPath) : chalk.dim(displayPath);
+            console.log(`  ${type}  ${chalk.yellow(branchName.padEnd(18))} ${colorPath}`);
+        }
+        console.log('');
+    }
+    catch (error) {
+        log.error(error.message);
+        process.exit(1);
+    }
+}

package/dist/commands/wt/prune.js

@@ -0,0 +1,20 @@
+import { pruneWorktrees, getRepoRoot } from '../../lib/git.js';
+import { log, createSpinner } from '../../lib/ui.js';
+export async function pruneCommand() {
+    try {
+        const _ = await getRepoRoot();
+        const spinner = createSpinner('Pruning stale worktrees...').start();
+        try {
+            await pruneWorktrees();
+            spinner.succeed('Worktrees pruned.');
+        }
+        catch (e) {
+            spinner.fail('Failed to prune worktrees.');
+            log.error(e.message);
+        }
+    }
+    catch (error) {
+        log.error(error.message);
+        process.exit(1);
+    }
+}

package/dist/index.js

@@ -0,0 +1,102 @@
+import { Command } from 'commander';
+import inquirer from 'inquirer';
+import { welcome, log } from './lib/ui.js';
+import { listCommand } from './commands/wt/list.js';
+import { createCommand } from './commands/wt/create.js';
+import { createCommandNew } from './commands/wt/create-branch.js';
+import { createCommandMulti } from './commands/wt/create-multi.js';
+import { deleteCommand } from './commands/wt/delete.js';
+import { bootstrapCommand } from './commands/wt/bootstrap.js';
+import { pruneCommand } from './commands/wt/prune.js';
+const program = new Command();
+program
+    .name('yggtree')
+    .description('Interactive CLI for managing git worktrees and configs')
+    .version('1.0.0')
+    .action(async () => {
+    // Interactive Menu if no command is provided
+    await welcome();
+    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 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' },
+                new inquirer.Separator(),
+                { name: '🚪 Exit', value: 'exit' },
+            ],
+        },
+    ]);
+    switch (action) {
+        case 'create-smart':
+            await createCommandNew({ bootstrap: true });
+            break;
+        case 'create-multi':
+            await createCommandMulti({ bootstrap: true });
+            break;
+        case 'create-slug':
+            await createCommand({ bootstrap: true });
+            break;
+        case 'list':
+            await listCommand();
+            break;
+        case 'delete':
+            await deleteCommand();
+            break;
+        case 'bootstrap':
+            await bootstrapCommand();
+            break;
+        case 'prune':
+            await pruneCommand();
+            break;
+        case 'exit':
+            log.info('Bye! 👋');
+            process.exit(0);
+    }
+});
+// --- Worktree Commands ---
+const wt = program.command('wt').description('Manage git worktrees');
+wt.command('list')
+    .description('List all worktrees')
+    .action(listCommand);
+wt.command('create')
+    .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('--no-bootstrap', 'Skip bootstrap (npm install + submodules)')
+    .action(async (options) => {
+    await createCommandNew(options);
+});
+wt.command('create-multi')
+    .description('Create multiple worktrees (Smart branch detection)')
+    .option('--base <ref>', 'Base ref (e.g. main)')
+    .option('--no-bootstrap', 'Skip bootstrap (npm install + submodules)')
+    .action(async (options) => {
+    await createCommandMulti(options);
+});
+wt.command('create-slug')
+    .description('Create a new worktree (Manual slug/ref)')
+    .option('-n, --name <slug>', 'Worktree name (slug)')
+    .option('-r, --ref <ref>', 'Existing branch or ref')
+    .option('--no-bootstrap', 'Skip bootstrap (npm install + submodules)')
+    .action(async (options) => {
+    await createCommand(options);
+});
+wt.command('delete')
+    .description('Delete a managed worktree')
+    .action(deleteCommand);
+wt.command('bootstrap')
+    .description('Bootstrap dependencies in a worktree')
+    .action(bootstrapCommand);
+wt.command('prune')
+    .description('Prune stale worktree information')
+    .action(pruneCommand);
+program.parse(process.argv);

package/dist/lib/config.js

@@ -0,0 +1,81 @@
+import path from 'path';
+import fs from 'fs-extra';
+import { execa } from 'execa';
+import { log, createSpinner } from './ui.js';
+export async function getBootstrapCommands(repoRoot) {
+    const configPath = path.join(repoRoot, 'anvil-worktree.json');
+    const cursorConfigPath = path.join(repoRoot, '.cursor', 'worktrees.json');
+    if (await fs.pathExists(configPath)) {
+        try {
+            const config = await fs.readJSON(configPath);
+            if (config['setup-worktree'] && Array.isArray(config['setup-worktree'])) {
+                return config['setup-worktree'];
+            }
+        }
+        catch (e) {
+            log.warning(`Failed to parse ${configPath}.`);
+        }
+    }
+    if (await fs.pathExists(cursorConfigPath)) {
+        try {
+            const config = await fs.readJSON(cursorConfigPath);
+            if (config['setup-worktree'] && Array.isArray(config['setup-worktree'])) {
+                return config['setup-worktree'];
+            }
+        }
+        catch (e) {
+            log.warning(`Failed to parse ${cursorConfigPath}.`);
+        }
+    }
+    return null;
+}
+export async function runBootstrap(wtPath, repoRoot) {
+    const customCommands = await getBootstrapCommands(repoRoot);
+    if (customCommands) {
+        log.info('Using custom bootstrap commands from config...');
+        for (const cmd of customCommands) {
+            const spinner = createSpinner(`Running: ${cmd}`).start();
+            try {
+                // Split command and arguments properly if needed, or run via shell
+                await execa(cmd, { cwd: wtPath, shell: true });
+                spinner.succeed(`Finished: ${cmd}`);
+            }
+            catch (e) {
+                spinner.fail(`Failed: ${cmd}`);
+                log.error(e.message);
+            }
+        }
+    }
+    else {
+        // Fallback to default behavior
+        log.info('Running default bootstrap (npm install + submodules)...');
+        // npm install
+        try {
+            await execa('npm', ['--version']);
+            const installSpinner = createSpinner('Running npm install...').start();
+            try {
+                await execa('npm', ['install'], { cwd: wtPath });
+                installSpinner.succeed('Dependencies installed.');
+            }
+            catch (e) {
+                installSpinner.fail('npm install failed.');
+                log.error(e.message);
+            }
+        }
+        catch {
+            log.warning('npm not found, skipping install.');
+        }
+        // Submodules
+        const subSpinner = createSpinner('Syncing submodules...').start();
+        try {
+            await execa('git', ['submodule', 'sync', '--recursive'], { cwd: wtPath });
+            await execa('git', ['submodule', 'update', '--init', '--recursive'], { cwd: wtPath });
+            subSpinner.succeed('Submodules synced.');
+        }
+        catch (e) {
+            subSpinner.fail('Submodule sync failed.');
+            log.error(e.message);
+            log.warning('Tip: If auth failed, try adding your key to the agent.');
+        }
+    }
+}

package/dist/lib/git.js

@@ -0,0 +1,72 @@
+import { execa } from 'execa';
+import fs from 'fs-extra';
+import path from 'path';
+export async function getRepoRoot() {
+    try {
+        const { stdout } = await execa('git', ['rev-parse', '--show-toplevel']);
+        return stdout.trim();
+    }
+    catch (error) {
+        throw new Error('Not a git repository');
+    }
+}
+export async function getCurrentBranch() {
+    try {
+        const { stdout } = await execa('git', ['rev-parse', '--abbrev-ref', 'HEAD']);
+        return stdout.trim();
+    }
+    catch {
+        return '';
+    }
+}
+export async function verifyRef(ref) {
+    try {
+        await execa('git', ['rev-parse', '--verify', ref]);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function fetchAll() {
+    await execa('git', ['fetch', '--all', '--prune']);
+}
+export async function createWorktree(wtPath, ref) {
+    await fs.ensureDir(path.dirname(wtPath));
+    await execa('git', ['worktree', 'add', wtPath, ref]);
+}
+export async function removeWorktree(wtPath) {
+    await execa('git', ['worktree', 'remove', wtPath, '--force']);
+}
+export async function listWorktrees() {
+    const { stdout } = await execa('git', ['worktree', 'list', '--porcelain']);
+    const worktrees = [];
+    let currentWt = {};
+    for (const line of stdout.split('\n')) {
+        if (!line) {
+            if (currentWt.path)
+                worktrees.push(currentWt);
+            currentWt = {};
+            continue;
+        }
+        const [key, ...rest] = line.split(' ');
+        const value = rest.join(' ');
+        if (key === 'worktree')
+            currentWt.path = value;
+        if (key === 'HEAD')
+            currentWt.HEAD = value;
+        if (key === 'branch')
+            currentWt.branch = value.replace('refs/heads/', '');
+    }
+    // Push the last one if active
+    if (currentWt.path)
+        worktrees.push(currentWt);
+    return worktrees;
+}
+export async function pruneWorktrees() {
+    await execa('git', ['worktree', 'prune']);
+}
+export async function syncSubmodules(cwd) {
+    await execa('git', ['submodule', 'sync', '--recursive'], { cwd });
+    await execa('git', ['submodule', 'update', '--init', '--recursive'], { cwd });
+}

package/dist/lib/paths.js

@@ -0,0 +1,4 @@
+import os from 'os';
+import path from 'path';
+export const ANVIL_ROOT = path.join(os.homedir(), '.yggdrasil');
+export const WORKTREES_ROOT = path.join(ANVIL_ROOT, 'worktrees');

package/dist/lib/ui.js

@@ -0,0 +1,39 @@
+import chalk from 'chalk';
+import figlet from 'figlet';
+import gradient from 'gradient-string';
+import ora from 'ora';
+import path from 'path';
+import { fileURLToPath } from 'url';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+// --- Personality & Branding ---
+export const welcome = async () => {
+    console.log('');
+    const title = figlet.textSync('Yggdrasil', { font: 'Standard' });
+    console.log(gradient.mind.multiline(title));
+    console.log(chalk.dim('  v1.0.0 • The World Tree Worktree Assistant'));
+    console.log('');
+};
+// --- Logger ---
+export const log = {
+    info: (msg) => console.log(chalk.blue('ℹ'), msg),
+    success: (msg) => console.log(chalk.green('✔'), msg),
+    warning: (msg) => console.log(chalk.yellow('⚠'), msg),
+    error: (msg) => console.log(chalk.red('✖'), msg),
+    dim: (msg) => console.log(chalk.dim(msg)),
+    header: (msg) => console.log(chalk.bold.hex('#DEADED')(`\n${msg}\n`)),
+};
+// --- Initial Spinners ---
+export const createSpinner = (text) => {
+    return ora({
+        text,
+        color: 'cyan',
+        spinner: 'dots',
+    });
+};
+// --- Prompts helpers ---
+// Ensure consistency in UI
+export const ui = {
+    docLink: (url) => chalk.underline.cyan(url),
+    code: (cmd) => chalk.bgBlack.white(` ${cmd} `),
+    path: (p) => chalk.cyan(p),
+};

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "yggtree",
+  "version": "1.0.0",
+  "description": "Interactive CLI for managing git worktrees and configs",
+  "main": "dist/index.js",
+  "type": "module",
+  "bin": {
+    "yggtree": "./bin/yggtree"
+  },
+  "files": [
+    "dist",
+    "bin",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "tsc --watch",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "cli",
+    "git",
+    "worktree",
+    "productivity"
+  ],
+  "author": "Leonardo Dias",
+  "license": "MIT",
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "commander": "^12.0.0",
+    "execa": "^8.0.1",
+    "figlet": "^1.7.0",
+    "fs-extra": "^11.2.0",
+    "gradient-string": "^2.0.2",
+    "inquirer": "^9.2.14",
+    "ora": "^8.0.1",
+    "zod": "^3.22.4"
+  },
+  "devDependencies": {
+    "@types/figlet": "^1.5.8",
+    "@types/fs-extra": "^11.0.4",
+    "@types/gradient-string": "^1.1.6",
+    "@types/inquirer": "^9.0.7",
+    "@types/node": "^20.11.19",
+    "typescript": "^5.3.3"
+  }
+}