yggtree 1.2.0 → 1.3.0

package/README.md

@@ -118,8 +118,8 @@ Use the interactive UI or drive everything through commands and flags.
 ## 🧠 Parallel Development, Done Right
 
 ```bash
-yggtree wt create feat/eng-2581-state-selection
-yggtree wt create fix/eng-2610-validation
+yggtree wt create feat/city-selection
+yggtree wt create fix/validation
 yggtree wt create chore/cleanup-api
 ```
 
@@ -373,11 +373,12 @@ yggtree wt create feat/login-flow
 
 **What happens:**
 
-* Creates a new branch if it doesn’t exist
+* Creates a new branch if it doesn’t exist (without inheriting base tracking), then publishes it to `origin` when possible
 * Creates a dedicated worktree
 * Runs bootstrap if enabled
 * Drops you into a sub-shell inside the worktree
 
+
 </details>
 ---
 

package/dist/commands/wt/apply.js

@@ -4,7 +4,7 @@ import path from 'path';
 import fs from 'fs-extra';
 import { execa } from 'execa';
 import { log, ui, createSpinner } from '../../lib/ui.js';
-import { findSandboxRoot, readSandboxMeta, writeSandboxMeta } from '../../lib/sandbox.js';
+import { findSandboxRoot, readSandboxMeta, writeSandboxMeta, YGGTREE_DIR } from '../../lib/sandbox.js';
 export async function applyCommand() {
     try {
         const cwd = process.cwd();
@@ -35,6 +35,12 @@ export async function applyCommand() {
                 ...stagedFiles.split('\n').filter(Boolean),
                 ...untrackedFiles.split('\n').filter(Boolean)
             ]);
+            // Exclude internal .yggtree/ directory (config, sandbox metadata, etc.)
+            for (const file of allChanges) {
+                if (file.startsWith(`${YGGTREE_DIR}/`)) {
+                    allChanges.delete(file);
+                }
+            }
             changedFiles = [...allChanges];
         }
         catch (e) {

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

@@ -1,7 +1,7 @@
 import chalk from 'chalk';
 import inquirer from 'inquirer';
 import path from 'path';
-import { getRepoRoot, getRepoName, verifyRef, fetchAll, getCurrentBranch, ensureCorrectUpstream } from '../../lib/git.js';
+import { getRepoRoot, getRepoName, verifyRef, fetchAll, getCurrentBranch, ensureCorrectUpstream, publishBranch } 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';
@@ -76,7 +76,7 @@ export async function createCommandNew(options) {
             baseRef = `origin/${baseRef}`;
         }
         // Convert branch name to slug (friendly folder name)
-        // e.g. feat/eng-2222-new-button -> feat-eng-2222-new-button
+        // e.g. feat/new-button -> feat-new-button
         const slug = branchName.replace(/[\/\\]/g, '-').replace(/\s+/g, '-');
         const repoName = await getRepoName();
         const wtPath = path.join(WORKTREES_ROOT, repoName, slug);
@@ -98,24 +98,23 @@ export async function createCommandNew(options) {
         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) {
+                // Branch exists — just attach the worktree
                 await execa('git', ['worktree', 'add', wtPath, branchName]);
             }
             else {
-                await execa('git', ['worktree', 'add', '-b', branchName, wtPath, baseRef]);
+                // Create branch WITHOUT tracking the base, then attach worktree
+                await execa('git', ['branch', '--no-track', branchName, baseRef]);
+                await execa('git', ['worktree', 'add', wtPath, branchName]);
             }
         }
         catch (e) {
             spinner.fail('Failed to create worktree.');
             const cmd = targetBranchExists
                 ? `git worktree add ${wtPath} ${branchName}`
-                : `git worktree add -b ${branchName} ${wtPath} ${baseRef}`;
+                : `git branch --no-track ${branchName} ${baseRef} && git worktree add ${wtPath} ${branchName}`;
             log.actionableError(e.message, cmd, wtPath, [
                 'Check if the folder already exists: ls ' + wtPath,
                 'Check if the branch is already used: git worktree list',
@@ -124,20 +123,21 @@ export async function createCommandNew(options) {
             ]);
             return;
         }
+        // Safety net: ensure no incorrect upstream was inherited
+        spinner.text = 'Verifying upstream safety...';
+        await ensureCorrectUpstream(wtPath, branchName);
+        // Auto-publish: push to origin and set correct tracking
         try {
-            // Strong Safety Mode: Ensure upstream is origin/<branchName> and publish
-            spinner.text = 'Safely publishing branch...';
-            await ensureCorrectUpstream(wtPath, branchName);
+            spinner.text = 'Publishing branch...';
+            await publishBranch(wtPath, branchName);
             spinner.succeed('Worktree created and branch published.');
         }
         catch (e) {
-            spinner.fail('Worktree created, but branch publication failed.');
+            spinner.succeed('Worktree created (publish failed — push manually later).');
             log.actionableError(e.message, 'git push -u origin HEAD', wtPath, [
                 `cd ${wtPath}`,
                 'Attempt to push manually: git push -u origin HEAD',
-                'Check if the remote branch already exists or if you have push permissions'
             ]);
-            // We don't return here because the worktree IS created, we just failed to publish
         }
         if (shouldBootstrap) {
             await runBootstrap(wtPath, repoRoot);

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

@@ -1,7 +1,7 @@
 import chalk from 'chalk';
 import inquirer from 'inquirer';
 import path from 'path';
-import { getRepoRoot, getRepoName, verifyRef, fetchAll, getCurrentBranch, ensureCorrectUpstream } from '../../lib/git.js';
+import { getRepoRoot, getRepoName, verifyRef, fetchAll, getCurrentBranch, ensureCorrectUpstream, publishBranch } 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';
@@ -82,14 +82,16 @@ export async function createCommandMulti(options) {
                     await execa('git', ['worktree', 'add', wtPath, branchName]);
                 }
                 else {
-                    await execa('git', ['worktree', 'add', '-b', branchName, wtPath, baseRef]);
+                    // Create branch WITHOUT tracking the base, then attach worktree
+                    await execa('git', ['branch', '--no-track', branchName, baseRef]);
+                    await execa('git', ['worktree', 'add', wtPath, branchName]);
                 }
             }
             catch (error) {
                 wtSpinner.fail(`Failed to create worktree for ${branchName}.`);
                 const cmd = targetBranchExists
                     ? `git worktree add ${wtPath} ${branchName}`
-                    : `git worktree add -b ${branchName} ${wtPath} ${baseRef}`;
+                    : `git branch --no-track ${branchName} ${baseRef} && git worktree add ${wtPath} ${branchName}`;
                 log.actionableError(error.message, cmd, wtPath, [
                     'Check if the folder already exists: ls ' + wtPath,
                     'Check if the branch is already used: git worktree list',
@@ -98,22 +100,23 @@ export async function createCommandMulti(options) {
                 ]);
                 continue;
             }
+            // Safety net: ensure no incorrect upstream was inherited
+            wtSpinner.text = `Verifying upstream safety for ${branchName}...`;
+            await ensureCorrectUpstream(wtPath, branchName);
+            // Auto-publish: push to origin and set correct tracking
             try {
-                // Strong Safety Mode: Ensure upstream is origin/<branchName> and publish
-                wtSpinner.text = `Safely publishing branch ${branchName}...`;
-                await ensureCorrectUpstream(wtPath, branchName);
+                wtSpinner.text = `Publishing branch ${branchName}...`;
+                await publishBranch(wtPath, branchName);
                 wtSpinner.succeed(`Worktree for ${chalk.cyan(branchName)} created and published.`);
-                createdWorktrees.push(wtPath);
             }
             catch (error) {
-                wtSpinner.fail(`Worktree for ${branchName} created, but publication failed.`);
+                wtSpinner.succeed(`Worktree for ${chalk.cyan(branchName)} created (publish failed — push manually later).`);
                 log.actionableError(error.message, 'git push -u origin HEAD', wtPath, [
                     `cd ${wtPath}`,
                     'Attempt to push manually: git push -u origin HEAD',
-                    'Check if the remote branch already exists or if you have push permissions'
                 ]);
-                createdWorktrees.push(wtPath); // Still added to list since wt exists
             }
+            createdWorktrees.push(wtPath);
             // 4. Bootstrap
             if (shouldBootstrap) {
                 await runBootstrap(wtPath, repoRoot);

package/dist/commands/wt/delete.js

@@ -1,9 +1,9 @@
 import chalk from 'chalk';
 import inquirer from 'inquirer';
 import path from 'path';
-import { listWorktrees, removeWorktree, getRepoRoot } from '../../lib/git.js';
+import { listWorktrees, removeWorktree, getRepoRoot, getLastActivity } from '../../lib/git.js';
 import { WORKTREES_ROOT } from '../../lib/paths.js';
-import { log, createSpinner } from '../../lib/ui.js';
+import { log, createSpinner, timeAgo } from '../../lib/ui.js';
 export async function deleteCommand() {
     try {
         const _ = await getRepoRoot();
@@ -14,10 +14,13 @@ export async function deleteCommand() {
             log.info('No managed worktrees found to delete.');
             return;
         }
-        const choices = managedWts.map(wt => {
-            const relative = path.relative(WORKTREES_ROOT, wt.path);
+        // Pre-fetch activity for all managed worktrees in parallel
+        const activities = await Promise.all(managedWts.map(wt => getLastActivity(wt.path)));
+        const choices = managedWts.map((wt, i) => {
+            const branchName = wt.branch || wt.HEAD || 'detached';
+            const active = activities[i] ? chalk.magenta(timeAgo(activities[i])) : chalk.dim('—');
             return {
-                name: `${chalk.bold(relative)} (${chalk.dim(wt.branch || wt.HEAD)})`,
+                name: `${chalk.bold.yellow(branchName)} ${chalk.dim('·')} ${active}`,
                 value: wt.path,
             };
         });

package/dist/commands/wt/list.js

@@ -1,8 +1,7 @@
 import chalk from 'chalk';
-import path from 'path';
-import { listWorktrees, getRepoRoot, isGitClean } from '../../lib/git.js';
+import { listWorktrees, getRepoRoot, isGitClean, getLastActivity } from '../../lib/git.js';
 import { WORKTREES_ROOT } from '../../lib/paths.js';
-import { log } from '../../lib/ui.js';
+import { log, timeAgo } from '../../lib/ui.js';
 export async function listCommand() {
     try {
         const _ = await getRepoRoot(); // Verify we are in a git repo
@@ -13,21 +12,22 @@ export async function listCommand() {
         }
         console.log(chalk.bold('\n  Active Worktrees:\n'));
         // Header
-        console.log(`  ${chalk.dim('TYPE')}    ${chalk.dim('STATE')}    ${chalk.dim('BRANCH')}             ${chalk.dim('PATH')}`);
-        console.log(chalk.dim('  ' + '-'.repeat(75)));
+        console.log(`  ${chalk.dim('TYPE')}    ${chalk.dim('STATE')}    ${chalk.dim('LAST ACTIVE')}    ${chalk.dim('BRANCH')}`);
+        console.log(chalk.dim('  ' + '-'.repeat(70)));
         for (const wt of worktrees) {
             const isManaged = wt.path.startsWith(WORKTREES_ROOT);
             const type = isManaged ? chalk.green('MANAGED') : chalk.blue('MAIN   ');
             const branchName = wt.branch || wt.HEAD || 'detached';
-            let displayPath = wt.path.replace(process.env.HOME || '', '~');
-            if (isManaged) {
-                displayPath = path.relative(WORKTREES_ROOT, wt.path);
-            }
-            const colorPath = isManaged ? chalk.cyan(displayPath) : chalk.dim(displayPath);
-            const isClean = await isGitClean(wt.path);
+            // Fetch state and activity in parallel
+            const [isClean, lastActive] = await Promise.all([
+                isGitClean(wt.path),
+                getLastActivity(wt.path),
+            ]);
             const stateLabel = (isClean ? 'clean' : 'dirty').padEnd(8);
             const stateText = isClean ? chalk.green(stateLabel) : chalk.yellow(stateLabel);
-            console.log(`  ${type}  ${stateText} ${chalk.yellow(branchName.padEnd(18))} ${colorPath}`);
+            const activeLabel = lastActive ? timeAgo(lastActive) : '—';
+            const activeText = chalk.magenta(activeLabel.padEnd(14));
+            console.log(`  ${type}  ${stateText} ${activeText} ${chalk.yellow(branchName)}`);
         }
         console.log('');
     }

package/dist/lib/config.js

@@ -3,13 +3,26 @@ import fs from 'fs-extra';
 import { execa } from 'execa';
 import { log, createSpinner } from './ui.js';
 export async function getBootstrapCommands(repoRoot, wtPath) {
-    const searchPaths = [];
-    if (wtPath)
+    // repoRoot first (source of truth — where yggtree is run from)
+    // wtPath second (per-worktree override if needed)
+    const searchPaths = [repoRoot];
+    if (wtPath && wtPath !== repoRoot)
         searchPaths.push(wtPath);
-    searchPaths.push(repoRoot);
     for (const searchPath of searchPaths) {
+        const yggtreeConfigPath = path.join(searchPath, '.yggtree', 'worktree-setup.json');
         const configPath = path.join(searchPath, 'yggtree-worktree.json');
         const cursorConfigPath = path.join(searchPath, '.cursor', 'worktrees.json');
+        if (await fs.pathExists(yggtreeConfigPath)) {
+            try {
+                const config = await fs.readJSON(yggtreeConfigPath);
+                if (config['setup-worktree'] && Array.isArray(config['setup-worktree'])) {
+                    return config['setup-worktree'];
+                }
+            }
+            catch (e) {
+                log.warning(`Failed to parse ${yggtreeConfigPath}.`);
+            }
+        }
         if (await fs.pathExists(configPath)) {
             try {
                 const config = await fs.readJSON(configPath);
@@ -50,7 +63,7 @@ export async function runBootstrap(wtPath, repoRoot) {
                 spinner.fail(`Failed: ${cmd}`);
                 log.actionableError(e.message, cmd, wtPath, [
                     `Try running the command manually: cd ${wtPath} && ${cmd}`,
-                    'Check your configuration in yggtree-worktree.json'
+                    'Check your configuration in .yggtree/worktree-setup.json or yggtree-worktree.json'
                 ]);
             }
         }

package/dist/lib/git.js

@@ -86,9 +86,12 @@ export async function isGitClean(cwd) {
     }
 }
 /**
- * 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.
+ * Safety net: ensures the branch does NOT track an incorrect upstream
+ * (e.g. origin/main when the branch is feat/new-thing).
+ *
+ * - Correct tracking (origin/<branchName>) → no-op
+ * - No tracking at all → no-op
+ * - Wrong tracking → unsets it
  */
 export async function ensureCorrectUpstream(wtPath, branchName) {
     const desiredUpstream = `origin/${branchName}`;
@@ -98,21 +101,68 @@ export async function ensureCorrectUpstream(wtPath, branchName) {
         currentUpstream = stdout.trim();
     }
     catch {
-        // No upstream set
+        // No upstream set — safe
+        return;
     }
     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 });
+    // Wrong tracking — kill it
+    log.warning(`Incorrect upstream detected: ${chalk.red(currentUpstream)} (expected ${chalk.cyan(desiredUpstream)}). Unsetting...`);
+    await execa('git', ['branch', '--unset-upstream'], { cwd: wtPath });
+}
+/**
+ * Publishes a local branch to origin and sets upstream tracking.
+ * Skips if the branch is already published (origin/<branchName> exists and is tracked).
+ */
+export async function publishBranch(wtPath, branchName) {
+    const desiredUpstream = `origin/${branchName}`;
+    // Check if already tracking the correct remote
+    try {
+        const { stdout } = await execa('git', ['rev-parse', '--abbrev-ref', '--symbolic-full-name', '@{u}'], { cwd: wtPath });
+        if (stdout.trim() === desiredUpstream) {
+            return; // Already published and tracked
+        }
     }
-    // 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.`);
+    catch {
+        // No upstream — expected for new branches
     }
-    log.info(`Publishing branch ${chalk.cyan(branchName)} to ${chalk.cyan(desiredUpstream)}...`);
+    log.info(`Publishing ${chalk.cyan(branchName)} → ${chalk.cyan(desiredUpstream)}...`);
     await execa('git', ['push', '-u', 'origin', 'HEAD'], { cwd: wtPath });
 }
+/**
+ * Returns the most recent activity date for a worktree by checking two signals:
+ * 1. Last commit time (captures committed work)
+ * 2. Git index mtime (captures staging, checkouts, uncommitted work)
+ *
+ * The most recent of the two wins. Returns null if both fail.
+ */
+export async function getLastActivity(wtPath) {
+    const dates = [];
+    // Signal 1 — last commit epoch
+    try {
+        const { stdout } = await execa('git', ['log', '-1', '--format=%ct'], { cwd: wtPath });
+        const epoch = parseInt(stdout.trim(), 10);
+        if (!isNaN(epoch)) {
+            dates.push(new Date(epoch * 1000));
+        }
+    }
+    catch {
+        // no commits reachable — skip
+    }
+    // Signal 2 — git index file mtime
+    try {
+        const { stdout: gitDir } = await execa('git', ['rev-parse', '--git-dir'], { cwd: wtPath });
+        const gitDirPath = gitDir.trim();
+        const resolvedGitDir = path.isAbsolute(gitDirPath) ? gitDirPath : path.join(wtPath, gitDirPath);
+        const indexPath = path.join(resolvedGitDir, 'index');
+        const stat = await fs.stat(indexPath);
+        dates.push(stat.mtime);
+    }
+    catch {
+        // index not found — skip
+    }
+    if (dates.length === 0)
+        return null;
+    return new Date(Math.max(...dates.map(d => d.getTime())));
+}

package/dist/lib/sandbox.js

@@ -1,26 +1,28 @@
 import crypto from 'crypto';
 import path from 'path';
 import fs from 'fs-extra';
-const SANDBOX_META_FILE = '.sandbox-meta.json';
+export const YGGTREE_DIR = '.yggtree';
+export const SANDBOX_META_FILE = 'sandbox-meta.json';
 /**
  * Generate a sandbox worktree name: <branch>_<4-char-hash>
  */
 export function generateSandboxName(branch) {
     const hash = crypto.randomBytes(2).toString('hex'); // 4 hex chars
     const safeBranch = branch.replace(/[\\/]/g, '-');
-    return `${safeBranch}_${hash}`;
+    return `sandbox-${hash}_${safeBranch}`;
 }
 /**
  * Get the path to the sandbox metadata file
  */
 export function getSandboxMetaPath(wtPath) {
-    return path.join(wtPath, SANDBOX_META_FILE);
+    return path.join(wtPath, YGGTREE_DIR, SANDBOX_META_FILE);
 }
 /**
  * Write sandbox metadata to the worktree
  */
 export async function writeSandboxMeta(wtPath, meta) {
     const metaPath = getSandboxMetaPath(wtPath);
+    await fs.ensureDir(path.dirname(metaPath));
     await fs.writeJSON(metaPath, meta, { spaces: 2 });
 }
 /**

package/dist/lib/ui.js

@@ -50,3 +50,23 @@ export const ui = {
     code: (cmd) => chalk.bgBlack.white(` ${cmd} `),
     path: (p) => chalk.cyan(p),
 };
+// --- Time helpers ---
+/**
+ * Returns a human-friendly relative time string like "just now", "5 min ago", "3 days ago".
+ */
+export function timeAgo(date) {
+    const seconds = Math.floor((Date.now() - date.getTime()) / 1000);
+    if (seconds < 60)
+        return 'just now';
+    if (seconds < 3600)
+        return `${Math.floor(seconds / 60)} min ago`;
+    if (seconds < 86400)
+        return `${Math.floor(seconds / 3600)}h ago`;
+    if (seconds < 604800)
+        return `${Math.floor(seconds / 86400)}d ago`;
+    if (seconds < 2592000)
+        return `${Math.floor(seconds / 604800)}w ago`;
+    if (seconds < 31536000)
+        return `${Math.floor(seconds / 2592000)}mo ago`;
+    return `${Math.floor(seconds / 31536000)}y ago`;
+}

package/package.json

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

package/dist/commands/wt/leave.js

@@ -1,13 +0,0 @@
-import { log } from '../../lib/ui.js';
-export async function leaveCommand() {
-    if (process.env.YGGTREE_SHELL === 'true') {
-        log.info('Leaving worktree sub-shell...');
-        // SIGHUP is standard for closing shells
-        process.kill(process.ppid, 'SIGHUP');
-    }
-    else {
-        log.warning('You are not in a yggtree sub-shell.');
-        log.dim('Try using "yggtree wt enter" first.');
-        process.exit(0);
-    }
-}