yggtree 1.0.1 → 1.1.1

package/dist/index.js

@@ -8,11 +8,15 @@ 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';
+import { execCommand } from './commands/wt/exec.js';
+import { enterCommand } from './commands/wt/enter.js';
+import { pathCommand } from './commands/wt/path.js';
+import { getVersion } from './lib/version.js';
 const program = new Command();
 program
     .name('yggtree')
     .description('Interactive CLI for managing git worktrees and configs')
-    .version('1.0.0')
+    .version(getVersion())
     .action(async () => {
     // Interactive Menu if no command is provided
     await welcome();
@@ -27,9 +31,12 @@ program
                 { 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: '🗑️ 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: '🚪 Exit', value: 'exit' },
             ],
@@ -57,6 +64,15 @@ program
         case 'prune':
             await pruneCommand();
             break;
+        case 'exec':
+            await execCommand();
+            break;
+        case 'enter':
+            await enterCommand();
+            break;
+        case 'path':
+            await pathCommand();
+            break;
         case 'exit':
             log.info('Bye! 👋');
             process.exit(0);
@@ -67,28 +83,43 @@ const wt = program.command('wt').description('Manage git worktrees');
 wt.command('list')
     .description('List all worktrees')
     .action(listCommand);
-wt.command('create')
+wt.command('create [branch]')
     .description('Create a new worktree (Smart branch detection)')
     .option('-b, --branch <name>', 'Branch name (e.g. feat/new-ui)')
     .option('--base <ref>', 'Base ref (e.g. main)')
+    .option('--source <type>', 'Base source (local or remote)')
     .option('--no-bootstrap', 'Skip bootstrap (npm install + submodules)')
-    .action(async (options) => {
-    await createCommandNew(options);
+    .option('--enter', 'Enter sub-shell after creation')
+    .option('--no-enter', 'Skip entering sub-shell')
+    .option('--exec <command>', 'Command to execute after creation')
+    .action(async (branch, options) => {
+    await createCommandNew({
+        ...options,
+        branch: branch || options.branch
+    });
 });
 wt.command('create-multi')
     .description('Create multiple worktrees (Smart branch detection)')
     .option('--base <ref>', 'Base ref (e.g. main)')
+    .option('--source <type>', 'Base source (local or remote)')
     .option('--no-bootstrap', 'Skip bootstrap (npm install + submodules)')
     .action(async (options) => {
     await createCommandMulti(options);
 });
-wt.command('create-slug')
+wt.command('create-slug [name] [ref]')
     .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);
+    .option('--enter', 'Enter sub-shell after creation')
+    .option('--no-enter', 'Skip entering sub-shell')
+    .option('--exec <command>', 'Command to execute after creation')
+    .action(async (name, ref, options) => {
+    await createCommand({
+        ...options,
+        name: name || options.name,
+        ref: ref || options.ref
+    });
 });
 wt.command('delete')
     .description('Delete a managed worktree')
@@ -99,4 +130,23 @@ wt.command('bootstrap')
 wt.command('prune')
     .description('Prune stale worktree information')
     .action(pruneCommand);
+wt.command('exec')
+    .description('Execute a command in a worktree')
+    .argument('[worktree]', 'Worktree name or path')
+    .argument('[command...]', 'Command and arguments to execute')
+    .action(async (worktree, command) => {
+    await execCommand(worktree, command);
+});
+wt.command('enter')
+    .description('Enter a worktree sub-shell')
+    .argument('[worktree]', 'Worktree name or path')
+    .option('--exec <command>', 'Command to execute before entering')
+    .action(async (worktree, options) => {
+    await enterCommand(worktree, options);
+});
+wt.command('path [worktree]')
+    .description('Show the cd command for a specific worktree')
+    .action(async (worktree) => {
+    await pathCommand(worktree);
+});
 program.parse(process.argv);

package/dist/lib/config.js

@@ -2,35 +2,41 @@ 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'];
+export async function getBootstrapCommands(repoRoot, wtPath) {
+    const searchPaths = [];
+    if (wtPath)
+        searchPaths.push(wtPath);
+    searchPaths.push(repoRoot);
+    for (const searchPath of searchPaths) {
+        const configPath = path.join(searchPath, 'yggtree-worktree.json');
+        const cursorConfigPath = path.join(searchPath, '.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 ${configPath}.`);
             }
         }
-        catch (e) {
-            log.warning(`Failed to parse ${cursorConfigPath}.`);
+        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);
+    const customCommands = await getBootstrapCommands(repoRoot, wtPath);
     if (customCommands) {
         log.info('Using custom bootstrap commands from config...');
         for (const cmd of customCommands) {
@@ -42,7 +48,10 @@ export async function runBootstrap(wtPath, repoRoot) {
             }
             catch (e) {
                 spinner.fail(`Failed: ${cmd}`);
-                log.error(e.message);
+                log.actionableError(e.message, cmd, wtPath, [
+                    `Try running the command manually: cd ${wtPath} && ${cmd}`,
+                    'Check your configuration in yggtree-worktree.json'
+                ]);
             }
         }
     }
@@ -59,7 +68,10 @@ export async function runBootstrap(wtPath, repoRoot) {
             }
             catch (e) {
                 installSpinner.fail('npm install failed.');
-                log.error(e.message);
+                log.actionableError(e.message, 'npm install', wtPath, [
+                    `cd ${wtPath} && npm install`,
+                    'Check your network connection and package-lock.json'
+                ]);
             }
         }
         catch {
@@ -74,8 +86,15 @@ export async function runBootstrap(wtPath, repoRoot) {
         }
         catch (e) {
             subSpinner.fail('Submodule sync failed.');
-            log.error(e.message);
-            log.warning('Tip: If auth failed, try adding your key to the agent.');
+            const isAuthError = /permission denied|authentication|publickey/i.test(e.message);
+            const steps = [
+                'git submodule sync --recursive',
+                'git submodule update --init --recursive'
+            ];
+            if (isAuthError) {
+                steps.unshift('ssh -T git@github.com', 'ssh-add --apple-use-keychain ~/.ssh/id_ed25519');
+            }
+            log.actionableError(e.message, 'git submodule update --init --recursive', wtPath, steps);
         }
     }
 }

package/dist/lib/git.js

@@ -1,6 +1,8 @@
 import { execa } from 'execa';
 import fs from 'fs-extra';
 import path from 'path';
+import { log } from './ui.js';
+import chalk from 'chalk';
 export async function getRepoRoot() {
     try {
         const { stdout } = await execa('git', ['rev-parse', '--show-toplevel']);
@@ -74,3 +76,43 @@ export async function syncSubmodules(cwd) {
     await execa('git', ['submodule', 'sync', '--recursive'], { cwd });
     await execa('git', ['submodule', 'update', '--init', '--recursive'], { cwd });
 }
+export async function isGitClean(cwd) {
+    try {
+        const { stdout } = await execa('git', ['status', '--porcelain'], { cwd });
+        return stdout.trim().length === 0;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Ensures the branch in the given worktree path tracks origin/<branchName>.
+ * If it tracks a different base branch (e.g. origin/main), it unsets it and publishes to origin.
+ * Fails if origin/<branchName> already exists on remote and is not already the upstream.
+ */
+export async function ensureCorrectUpstream(wtPath, branchName) {
+    const desiredUpstream = `origin/${branchName}`;
+    let currentUpstream = '';
+    try {
+        const { stdout } = await execa('git', ['rev-parse', '--abbrev-ref', '--symbolic-full-name', '@{u}'], { cwd: wtPath });
+        currentUpstream = stdout.trim();
+    }
+    catch {
+        // No upstream set
+    }
+    if (currentUpstream === desiredUpstream) {
+        return; // Already correct
+    }
+    // If it's set to something else, unset it
+    if (currentUpstream) {
+        log.info(`Incorrect upstream detected: ${currentUpstream}. Unsetting...`);
+        await execa('git', ['branch', '--unset-upstream'], { cwd: wtPath });
+    }
+    // Check if remote branch already exists
+    const remoteExists = await verifyRef(desiredUpstream);
+    if (remoteExists) {
+        throw new Error(`Remote branch '${desiredUpstream}' already exists. Cannot publish safely without more info. Use 'git push -u origin HEAD' manually if you want to link them.`);
+    }
+    log.info(`Publishing branch ${chalk.cyan(branchName)} to ${chalk.cyan(desiredUpstream)}...`);
+    await execa('git', ['push', '-u', 'origin', 'HEAD'], { cwd: wtPath });
+}

package/dist/lib/ui.js

@@ -4,13 +4,15 @@ import gradient from 'gradient-string';
 import ora from 'ora';
 import path from 'path';
 import { fileURLToPath } from 'url';
+import { getVersion } from './version.js';
 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'));
+    const version = getVersion();
+    console.log(chalk.dim(`  v${version} • The World Tree Worktree Assistant`));
     console.log('');
 };
 // --- Logger ---
@@ -21,6 +23,17 @@ export const log = {
     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`)),
+    actionableError: (error, command, worktreePath, nextSteps = []) => {
+        console.log(chalk.red('\n✖ Error:'), error);
+        console.log(chalk.dim('  Command:'), chalk.white(command));
+        if (worktreePath)
+            console.log(chalk.dim('  Path:   '), chalk.cyan(worktreePath));
+        if (nextSteps.length > 0) {
+            console.log(chalk.bold('\n  Next steps:'));
+            nextSteps.forEach(step => console.log(chalk.yellow(`    - ${step}`)));
+        }
+        console.log('');
+    },
 };
 // --- Initial Spinners ---
 export const createSpinner = (text) => {

package/dist/lib/version.js

@@ -0,0 +1,17 @@
+import fs from 'fs-extra';
+import path from 'path';
+import { fileURLToPath } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+export function getVersion() {
+    try {
+        // In dist, this file is in dist/lib/version.js
+        // package.json is in the root (../../package.json)
+        const packageJsonPath = path.resolve(__dirname, '../../package.json');
+        const pkg = fs.readJsonSync(packageJsonPath);
+        return pkg.version || '1.0.0';
+    }
+    catch (error) {
+        return '1.0.0';
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yggtree",
-  "version": "1.0.1",
+  "version": "1.1.1",
   "description": "Interactive CLI for managing git worktrees and configs",
   "main": "dist/index.js",
   "type": "module",