yggtree 1.4.4 → 1.4.6

package/dist/lib/global-config.js

@@ -0,0 +1,118 @@
+import os from 'os';
+import path from 'path';
+import fs from 'fs-extra';
+import { YGG_ROOT } from './paths.js';
+const CONFIG_PATH = path.join(YGG_ROOT, 'config.json');
+const DEFAULT_WORKTREE_LAYOUT = 'yggtree';
+export function expandHome(value) {
+    if (value === '~')
+        return os.homedir();
+    if (value.startsWith('~/'))
+        return path.join(os.homedir(), value.slice(2));
+    return value;
+}
+export function formatHome(value) {
+    const home = os.homedir();
+    if (value === home)
+        return '~';
+    if (value.startsWith(`${home}${path.sep}`))
+        return `~/${path.relative(home, value)}`;
+    return value;
+}
+function normalizeRoot(value, layout, repoRoot) {
+    if (value)
+        return path.resolve(expandHome(value));
+    if (layout === 'claude') {
+        return path.join(path.resolve(repoRoot || process.cwd()), '.claude', 'worktrees');
+    }
+    return path.resolve(YGG_ROOT);
+}
+export function normalizeWorktreesRootInput(value) {
+    return path.resolve(expandHome(value));
+}
+function normalizeLayout(value) {
+    return value || DEFAULT_WORKTREE_LAYOUT;
+}
+function isWorktreeLayout(value) {
+    return value === 'yggtree' || value === 'codex' || value === 'claude';
+}
+export async function readGlobalConfig() {
+    try {
+        if (await fs.pathExists(CONFIG_PATH)) {
+            const config = await fs.readJSON(CONFIG_PATH);
+            return {
+                worktreesRoot: typeof config.worktreesRoot === 'string' ? config.worktreesRoot : undefined,
+                worktreeLayout: isWorktreeLayout(config.worktreeLayout) ? config.worktreeLayout : undefined,
+            };
+        }
+    }
+    catch {
+        return {};
+    }
+    return {};
+}
+export async function writeGlobalConfig(config) {
+    await fs.ensureDir(YGG_ROOT);
+    await fs.writeJSON(CONFIG_PATH, config, { spaces: 2 });
+}
+export async function getWorktreePathConfig(repoRoot, presetOverride) {
+    const config = presetOverride === undefined
+        ? await readGlobalConfig()
+        : getPresetConfig(presetOverride);
+    if (!config) {
+        throw new Error(`Unknown config preset "${presetOverride}". Available presets: default, yggtree, codex, claude.`);
+    }
+    const layout = normalizeLayout(config.worktreeLayout);
+    return {
+        root: normalizeRoot(config.worktreesRoot, layout, repoRoot),
+        layout,
+    };
+}
+export async function getManagedWorktreesRoot(repoRoot) {
+    const config = await getWorktreePathConfig(repoRoot);
+    return config.root;
+}
+export function buildManagedWorktreePath(repoName, worktreeSlug, config) {
+    if (config.layout === 'codex') {
+        return path.join(config.root, worktreeSlug, repoName);
+    }
+    if (config.layout === 'claude') {
+        return path.join(config.root, worktreeSlug);
+    }
+    return path.join(config.root, repoName, worktreeSlug);
+}
+export function getPresetConfig(preset) {
+    const normalized = preset.trim().toLowerCase();
+    if (normalized === 'default' || normalized === 'yggtree') {
+        return {};
+    }
+    if (normalized === 'codex') {
+        return {
+            worktreesRoot: '~/.codex/worktrees',
+            worktreeLayout: 'codex',
+        };
+    }
+    if (normalized === 'claude') {
+        return {
+            worktreeLayout: 'claude',
+        };
+    }
+    return undefined;
+}
+function inferPreset(config) {
+    if (!config.worktreesRoot && !config.worktreeLayout)
+        return 'default';
+    if (!config.worktreesRoot && config.worktreeLayout === 'claude')
+        return 'claude';
+    if (config.worktreesRoot === '~/.codex/worktrees' && config.worktreeLayout === 'codex')
+        return 'codex';
+    return 'custom';
+}
+export function formatGlobalConfig(config, resolved) {
+    return [
+        `worktreesRoot: ${formatHome(resolved.root)}`,
+        `worktreeLayout: ${resolved.layout}`,
+        `configFile: ${formatHome(CONFIG_PATH)}`,
+        `preset: ${inferPreset(config)}`,
+    ];
+}

package/dist/lib/help.js

@@ -0,0 +1,127 @@
+export const intentRouterHelp = `
+Choose by intent:
+  New official task branch      yggtree create feat/name --base main --source remote
+  Existing branch/interruption  yggtree wc --ref branch-name
+  Continue dirty current work   yggtree handoff --name task-name
+  Disposable local experiment   yggtree create-sandbox
+  Copy sandbox files to origin  yggtree apply   # from inside sandbox, not a Git merge
+  Bulk official worktrees       yggtree create-multi
+  Agent-native path layout      yggtree config use claude   # or codex
+  Delete without prompts        yggtree delete branch-name --yes
+
+More detail: run yggtree help <command>, for example yggtree help handoff.
+`;
+const agentPathTip = `
+Agent-native paths:
+  Add --config claude for Claude Code's repo-local .claude/worktrees layout.
+  Add --config codex for Codex's ~/.codex/worktrees layout.
+`;
+export const createHelp = `
+Behavior:
+  Creates an official branch-backed worktree, publishes the branch to origin, and enters the shell by default.
+  Use for real task branches. For disposable experiments, use create-sandbox.
+
+${agentPathTip}
+
+Examples:
+  yggtree create feat/new-flow --base main --source remote
+  yggtree create feat/background-task --base main --source remote --no-open --no-enter
+  yggtree create feat/claude-layout --base main --source remote --config claude
+`;
+export const createMultiHelp = `
+Behavior:
+  Bulk-creates official branch-backed worktrees.
+  This does not share create's open/enter/exec lifecycle. Use create for one task branch.
+
+${agentPathTip}
+
+Example:
+  yggtree create-multi --base main --source remote
+  yggtree create-multi --base main --source remote --config codex
+`;
+export const checkoutHelp = `
+Behavior:
+  Creates or reuses a worktree for an existing branch or ref without disturbing current work.
+  Use for interruptions and branch review. Use create for a new official task branch.
+  Enters the worktree shell by default; add --no-enter when automation should return.
+
+${agentPathTip}
+
+Examples:
+  yggtree wc --ref hotfix/payment-timeout
+  yggtree wc --ref main --name fresh-main --no-open --no-enter
+  yggtree wc --ref main --name fresh-main --config yggtree
+`;
+export const openHelp = `
+Behavior:
+  Opens an existing worktree in an editor, desktop app, or terminal target.
+  Returns by default after opening. Add --enter only when the shell should continue inside the worktree.
+
+Examples:
+  yggtree open my-feature --tool cursor
+  yggtree open my-feature --tool codex-app
+  yggtree list --open
+`;
+export const deleteHelp = `
+Behavior:
+  Deletes selected worktrees. Main and current worktrees are always protected.
+  Without arguments, delete stays interactive. For automation, pass explicit targets and --yes.
+  Add --all only when the target is outside Yggtree's managed root and appears as LINKED in list.
+
+Examples:
+  yggtree delete my-feature --yes
+  yggtree delete my-feature other-feature --yes
+  yggtree delete --all --yes
+  yggtree delete external-feature --all --yes
+`;
+export const createSandboxHelp = `
+Behavior:
+  Creates a local-only disposable experiment from the current branch.
+  For continuing current dirty work, prefer handoff instead of teaching create-sandbox --carry.
+
+${agentPathTip}
+
+Examples:
+  yggtree create-sandbox
+  yggtree create-sandbox --name ui-option-a --no-open
+  yggtree create-sandbox --name claude-scratch --config claude
+
+Related:
+  handoff carries current dirty work into a named sandbox.
+  apply copies changed sandbox files back to origin.
+`;
+export const handoffHelp = `
+Behavior:
+  Carry staged, unstaged, and untracked work into a named sandbox so you can continue there.
+  The origin checkout is not cleaned; review or reset it separately if needed.
+
+${agentPathTip}
+
+Example:
+  yggtree handoff --name continue-auth-refactor
+  yggtree handoff --name continue-auth-refactor --config codex
+
+Related:
+  create-sandbox starts a disposable local experiment.
+  apply copies changed sandbox files back to origin.
+`;
+export const applyHelp = `
+Behavior:
+  Copies changed files from the current sandbox back to the origin checkout.
+  Stores backups in sandbox metadata before overwriting origin files.
+  Not a Git merge, rebase, patch, or cherry-pick. Review the origin diff afterward.
+
+Example:
+  yggtree apply
+
+Related:
+  unapply restores from the sandbox backup metadata while the sandbox still exists.
+`;
+export const unapplyHelp = `
+Behavior:
+  Restores origin files from sandbox metadata created by apply.
+  Only works while the sandbox still exists.
+
+Example:
+  yggtree unapply
+`;

package/dist/lib/main-menu.js

@@ -0,0 +1,71 @@
+export function buildMainMenuEntries(context) {
+    const dailyChoices = actions([
+        'create-smart',
+        'worktree-checkout',
+        'handoff',
+        'open',
+        'list',
+    ]);
+    const growthChoices = actions([
+        'create-multi',
+        'create-sandbox',
+    ]);
+    const tendingChoices = actions([
+        'bootstrap',
+        'exec',
+        'path',
+        'delete',
+        'prune',
+    ]);
+    const sandboxChoices = actions([
+        'apply',
+        'unapply',
+    ]);
+    const loreChoices = actions([
+        'bifrost',
+        'thor',
+        'docs',
+        'exit',
+    ]);
+    if (context === 'sandbox') {
+        return [
+            ...sandboxChoices,
+            separator('Daily routes'),
+            ...dailyChoices,
+            separator('Growth and experiments'),
+            ...growthChoices,
+            separator('Tend realms'),
+            ...tendingChoices,
+            separator('Lore'),
+            ...loreChoices,
+        ];
+    }
+    if (context === 'worktree') {
+        return [
+            ...actions(['copy-env', 'path', 'exec', 'bootstrap']),
+            separator('Daily routes'),
+            ...dailyChoices,
+            separator('Growth and experiments'),
+            ...growthChoices,
+            separator('Tend realms'),
+            ...actions(['delete', 'prune']),
+            separator('Lore'),
+            ...loreChoices,
+        ];
+    }
+    return [
+        ...dailyChoices,
+        separator('Growth and experiments'),
+        ...growthChoices,
+        separator('Tend realms'),
+        ...tendingChoices,
+        separator('Lore'),
+        ...loreChoices,
+    ];
+}
+function actions(values) {
+    return values.map(value => ({ type: 'action', value }));
+}
+function separator(label) {
+    return { type: 'separator', label };
+}

package/dist/lib/paths.js

@@ -1,4 +1,3 @@
 import os from 'os';
 import path from 'path';
 export const YGG_ROOT = path.join(os.homedir(), '.yggtree');
-export const WORKTREES_ROOT = YGG_ROOT;

package/dist/lib/repo-context.js

@@ -1,6 +1,7 @@
 import chalk from 'chalk';
 import inquirer from 'inquirer';
 import { getRepoRoot } from './git.js';
+import { getManagedWorktreesRoot } from './global-config.js';
 import { getValidRegisteredRepos } from './registry.js';
 import { log } from './ui.js';
 import { formatWorktreeDisplayPath } from './worktree.js';
@@ -11,6 +12,7 @@ export async function ensureRepoContext() {
     catch {
         const validRepos = await getValidRegisteredRepos();
         const repoEntries = Object.entries(validRepos);
+        const managedRoot = await getManagedWorktreesRoot();
         if (repoEntries.length === 0) {
             log.error('Not inside a git repository and no registered realms found.');
             log.dim('Run `yggtree` inside an existing git project first to register it.');
@@ -34,7 +36,7 @@ export async function ensureRepoContext() {
                 name: 'selectedRepoPath',
                 message: 'Select a realm:',
                 choices: repoEntries.map(([name, repoPath]) => ({
-                    name: `${chalk.bold.yellow(name)} ${chalk.dim(formatWorktreeDisplayPath(repoPath))}`,
+                    name: `${chalk.bold.yellow(name)} ${chalk.dim(formatWorktreeDisplayPath(repoPath, managedRoot))}`,
                     value: repoPath,
                 })),
                 pageSize: 10,

package/dist/lib/ui.js

@@ -6,15 +6,86 @@ 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 yggAccent = chalk.hex('#DEADED');
+const yggLeaf = chalk.hex('#9AD68B');
+const yggSky = chalk.hex('#7AC7D8');
+const yggBark = chalk.hex('#C99A5B');
+const yggRoot = chalk.hex('#B48AE8');
+const yggWarn = chalk.hex('#E4B85E');
+const yggDanger = chalk.hex('#E06C75');
+const yggMuted = chalk.hex('#8D8D8D');
+export function renderWelcome(options = {}) {
+    const rule = yggAccent('─'.repeat(54));
     const title = figlet.textSync('Yggdrasil', { font: 'Standard' });
-    console.log(gradient.mind.multiline(title));
     const version = getVersion();
-    console.log(chalk.dim(`  v${version} • The World Tree Worktree Assistant`));
-    console.log('');
+    const updateLines = renderUpdateNotice(options.update);
+    return [
+        '',
+        rule,
+        gradient.mind.multiline(title),
+        chalk.bold(yggAccent('  Yggdrasil')),
+        chalk.dim(`  v${version} • The World Tree Worktree Assistant`),
+        ...updateLines,
+        rule,
+        '',
+    ].join('\n');
+}
+export const welcome = async (options = {}) => {
+    console.log(renderWelcome(options));
 };
+export function renderMainMenuIntro(options) {
+    const detail = (() => {
+        if (options.context === 'sandbox') {
+            return 'Sandbox tools appear first because this realm can apply or undo grafted changes.';
+        }
+        if (options.context === 'worktree') {
+            return 'Current-realm tools appear first for this worktree.';
+        }
+        return 'Create, enter, inspect, or tend your worktrees.';
+    })();
+    return [
+        'Choose the next realm action.',
+        yggMuted('Daily routes first. Maintenance and lore wait below.'),
+        '',
+        `${yggBark('┌')}   ${badge('route 01')} ${chalk.bold('Realm')}`,
+        `${yggBark('│')}   ${yggMuted(detail)}`,
+    ].join('\n');
+}
+export function formatMainMenuChoice(options) {
+    const tone = menuTone(options.tone);
+    const label = options.label.padEnd(24);
+    return `${tone(options.glyph)}  ${chalk.bold(label)} ${yggMuted(options.detail)}`;
+}
+function renderUpdateNotice(update) {
+    if (!update?.updateAvailable)
+        return [];
+    return [
+        '',
+        `${yggWarn('Update available')} ${yggMuted(`yggtree ${update.currentVersion} -> ${update.latestVersion}`)}`,
+        yggMuted('Run: npm install -g yggtree'),
+    ];
+}
+function badge(value) {
+    return yggRoot(` ${value} `);
+}
+function menuTone(tone) {
+    switch (tone) {
+        case 'growth':
+            return yggLeaf;
+        case 'travel':
+            return yggSky;
+        case 'sandbox':
+            return yggRoot;
+        case 'tending':
+            return yggBark;
+        case 'danger':
+            return yggDanger;
+        case 'lore':
+            return yggAccent;
+        case 'exit':
+            return yggMuted;
+    }
+}
 // --- Logger ---
 export const log = {
     info: (msg) => console.log(chalk.blue('ℹ'), msg),

package/dist/lib/worktree.js

@@ -1,7 +1,7 @@
 import chalk from 'chalk';
 import fs from 'fs-extra';
 import path from 'path';
-import { WORKTREES_ROOT } from './paths.js';
+import { YGG_ROOT } from './paths.js';
 import { getSandboxMetaPath } from './sandbox.js';
 export const WORKTREE_TYPE_ORDER = {
     MAIN: 0,
@@ -12,19 +12,23 @@ export const WORKTREE_TYPE_ORDER = {
 export function getWorktreeBranchName(worktree) {
     return worktree.branch || worktree.HEAD || 'detached';
 }
-export function isManagedWorktreePath(worktreePath) {
-    return worktreePath.startsWith(WORKTREES_ROOT);
+function isPathInsideRoot(worktreePath, managedRoot) {
+    const relative = path.relative(managedRoot, worktreePath);
+    return relative === '' || Boolean(relative && !relative.startsWith('..') && !path.isAbsolute(relative));
 }
-export function formatWorktreeDisplayPath(worktreePath) {
-    if (isManagedWorktreePath(worktreePath)) {
-        return path.relative(WORKTREES_ROOT, worktreePath);
+export function isManagedWorktreePath(worktreePath, managedRoot = YGG_ROOT) {
+    return isPathInsideRoot(path.resolve(worktreePath), path.resolve(managedRoot));
+}
+export function formatWorktreeDisplayPath(worktreePath, managedRoot = YGG_ROOT) {
+    if (isManagedWorktreePath(worktreePath, managedRoot)) {
+        return path.relative(managedRoot, worktreePath);
     }
     return worktreePath.replace(process.env.HOME || '', '~');
 }
-export function findWorktreeByName(worktrees, worktreeName) {
+export function findWorktreeByName(worktrees, worktreeName, managedRoot = YGG_ROOT) {
     return worktrees.find(worktree => {
         const branchName = getWorktreeBranchName(worktree);
-        const relativePath = path.relative(WORKTREES_ROOT, worktree.path);
+        const relativePath = path.relative(managedRoot, worktree.path);
         const basename = path.basename(worktree.path);
         return branchName === worktreeName ||
             relativePath === worktreeName ||
@@ -32,8 +36,8 @@ export function findWorktreeByName(worktrees, worktreeName) {
             basename === worktreeName;
     });
 }
-export async function detectWorktreeType(worktree, mainWorktreePath) {
-    const isManaged = isManagedWorktreePath(worktree.path);
+export async function detectWorktreeType(worktree, mainWorktreePath, managedRoot = YGG_ROOT) {
+    const isManaged = isManagedWorktreePath(worktree.path, managedRoot);
     if (!isManaged) {
         return worktree.path === mainWorktreePath ? 'MAIN' : 'LINKED';
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yggtree",
-  "version": "1.4.4",
+  "version": "1.4.6",
   "packageManager": "pnpm@11.0.9",
   "description": "Interactive CLI for managing git worktrees and configs",
   "main": "dist/index.js",