yggtree 1.4.1 → 1.4.3

package/dist/lib/env-files.js

@@ -0,0 +1,72 @@
+import chalk from 'chalk';
+import fs from 'fs-extra';
+import inquirer from 'inquirer';
+import path from 'path';
+import { log } from './ui.js';
+const EXAMPLE_ENV_FILES = new Set([
+    '.env.example',
+    '.env.sample',
+    '.env.template',
+    '.env.defaults',
+]);
+export function canPromptForEnvFiles() {
+    return Boolean(process.stdin.isTTY && process.stdout.isTTY && !process.env.CI);
+}
+async function confirmEnvFileCopy(files, defaultMessage, options) {
+    const isInteractive = options.interactive ?? canPromptForEnvFiles();
+    if (!isInteractive) {
+        log.dim(`Skipped local env file${files.length === 1 ? '' : 's'} in non-interactive mode.`);
+        return false;
+    }
+    const { shouldCopyEnvFiles } = await inquirer.prompt([
+        {
+            type: 'confirm',
+            name: 'shouldCopyEnvFiles',
+            message: options.promptMessage || defaultMessage,
+            default: false,
+        },
+    ]);
+    if (!shouldCopyEnvFiles) {
+        log.dim('Skipped local env files.');
+    }
+    return shouldCopyEnvFiles;
+}
+export async function findLocalEnvFiles(repoRoot) {
+    const entries = await fs.readdir(repoRoot, { withFileTypes: true });
+    return entries
+        .filter(entry => entry.isFile())
+        .map(entry => entry.name)
+        .filter(name => name === '.env' || name.startsWith('.env.'))
+        .filter(name => !EXAMPLE_ENV_FILES.has(name))
+        .sort((a, b) => a.localeCompare(b));
+}
+export async function copyEnvFiles(repoRoot, wtPath, envFiles) {
+    if (envFiles.length === 0)
+        return;
+    for (const envFile of envFiles) {
+        await fs.copy(path.join(repoRoot, envFile), path.join(wtPath, envFile));
+    }
+    log.info(`Copied ${envFiles.map(file => chalk.cyan(file)).join(', ')} to the worktree.`);
+}
+export async function promptAndCopyEnvFiles(repoRoot, wtPath, envFiles, options = {}) {
+    const files = envFiles || await findLocalEnvFiles(repoRoot);
+    if (files.length === 0)
+        return;
+    const shouldCopyEnvFiles = await confirmEnvFileCopy(files, `Copy local env file${files.length === 1 ? '' : 's'} to this worktree? (${files.join(', ')})`, options);
+    if (!shouldCopyEnvFiles) {
+        return;
+    }
+    await copyEnvFiles(repoRoot, wtPath, files);
+}
+export async function promptAndCopyEnvFilesToWorktrees(repoRoot, wtPaths, envFiles, options = {}) {
+    const files = envFiles || await findLocalEnvFiles(repoRoot);
+    if (files.length === 0 || wtPaths.length === 0)
+        return;
+    const shouldCopyEnvFiles = await confirmEnvFileCopy(files, `Copy local env file${files.length === 1 ? '' : 's'} to these worktrees? (${files.join(', ')})`, options);
+    if (!shouldCopyEnvFiles) {
+        return;
+    }
+    for (const wtPath of wtPaths) {
+        await copyEnvFiles(repoRoot, wtPath, files);
+    }
+}

package/dist/lib/git.js

@@ -3,10 +3,18 @@ import fs from 'fs-extra';
 import path from 'path';
 import { log } from './ui.js';
 import chalk from 'chalk';
+import { registerRepo } from './registry.js';
+let cachedRepoRoot = null;
 export async function getRepoRoot() {
+    if (cachedRepoRoot)
+        return cachedRepoRoot;
     try {
         const { stdout } = await execa('git', ['rev-parse', '--show-toplevel']);
-        return stdout.trim();
+        cachedRepoRoot = stdout.trim();
+        // Silently register the repo in the background
+        const name = path.basename(cachedRepoRoot);
+        registerRepo(name, cachedRepoRoot).catch(() => { });
+        return cachedRepoRoot;
     }
     catch (error) {
         throw new Error('Not a git repository');
@@ -46,6 +54,9 @@ export async function removeWorktree(wtPath) {
 }
 export async function listWorktrees() {
     const { stdout } = await execa('git', ['worktree', 'list', '--porcelain']);
+    return parseWorktreeList(stdout);
+}
+export function parseWorktreeList(stdout) {
     const worktrees = [];
     let currentWt = {};
     for (const line of stdout.split('\n')) {
@@ -63,6 +74,8 @@ export async function listWorktrees() {
             currentWt.HEAD = value;
         if (key === 'branch')
             currentWt.branch = value.replace('refs/heads/', '');
+        if (key === 'prunable')
+            currentWt.prunable = value;
     }
     // Push the last one if active
     if (currentWt.path)
@@ -130,13 +143,83 @@ export async function publishBranch(wtPath, branchName) {
     log.info(`Publishing ${chalk.cyan(branchName)} → ${chalk.cyan(desiredUpstream)}...`);
     await execa('git', ['push', '-u', 'origin', 'HEAD'], { cwd: wtPath });
 }
+let ghAvailableCache = null;
 /**
- * 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.
+ * Check whether `gh` CLI is installed and authenticated.
+ * Result is cached for the process lifetime.
+ */
+export async function isGhAvailable() {
+    if (ghAvailableCache !== null)
+        return ghAvailableCache;
+    try {
+        await execa('gh', ['auth', 'status'], { stdio: 'ignore' });
+        ghAvailableCache = true;
+    }
+    catch {
+        ghAvailableCache = false;
+    }
+    return ghAvailableCache;
+}
+function derivePrLabel(state, reviewDecision) {
+    if (state === 'merged')
+        return 'MERGED';
+    if (state === 'closed')
+        return 'CLOSED';
+    if (state === 'draft')
+        return 'DRAFT';
+    // state === 'open'
+    if (reviewDecision === 'approved')
+        return 'APPROVED';
+    if (reviewDecision === 'changes_requested')
+        return 'CHANGES';
+    if (reviewDecision === 'review_required')
+        return 'IN REVIEW';
+    return 'OPEN';
+}
+/**
+ * Fetch PR status for a branch using `gh pr view`.
+ * Returns null when `gh` is unavailable or the branch has no PR.
  */
+export async function getPrStatusForBranch(branch, cwd) {
+    if (!branch || branch === 'detached')
+        return null;
+    try {
+        const { stdout } = await execa('gh', ['pr', 'view', branch, '--json', 'state,reviewDecision,isDraft,number'], { cwd, timeout: 10_000 });
+        const data = JSON.parse(stdout);
+        const isDraft = data.isDraft === true;
+        const rawState = (data.state || '').toLowerCase();
+        const state = isDraft && rawState === 'open' ? 'draft' : rawState;
+        const reviewDecision = (data.reviewDecision || '').toLowerCase().replace(/ /g, '_') || null;
+        return {
+            state,
+            reviewDecision,
+            label: derivePrLabel(state, reviewDecision),
+            number: data.number,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Batch-fetch PR statuses for all provided branches (parallelized).
+ * Returns a Map<branchName, PrStatus>.
+ * If `gh` is unavailable, returns an empty map immediately.
+ */
+export async function getPrStatusBatch(branches, cwd) {
+    const map = new Map();
+    if (!(await isGhAvailable()))
+        return map;
+    const results = await Promise.all(branches.map(async (branch) => {
+        const status = await getPrStatusForBranch(branch, cwd);
+        return { branch, status };
+    }));
+    for (const { branch, status } of results) {
+        if (status)
+            map.set(branch, status);
+    }
+    return map;
+}
 export async function getLastActivity(wtPath) {
     const dates = [];
     // Signal 1 — last commit epoch

package/dist/lib/registry.js

@@ -0,0 +1,81 @@
+import fs from 'fs-extra';
+import path from 'path';
+import { YGG_ROOT } from './paths.js';
+const REGISTRY_PATH = path.join(YGG_ROOT, 'registry.json');
+/**
+ * Read the registry, initializing if missing.
+ */
+export async function readRegistry() {
+    try {
+        if (await fs.pathExists(REGISTRY_PATH)) {
+            return await fs.readJson(REGISTRY_PATH);
+        }
+    }
+    catch {
+        // Ignore JSON read errors, just return empty
+    }
+    return { repos: {} };
+}
+/**
+ * Write the registry back to disk.
+ */
+async function writeRegistry(registry) {
+    await fs.ensureDir(YGG_ROOT);
+    await fs.writeJson(REGISTRY_PATH, registry, { spaces: 2 });
+}
+/**
+ * Silently register a repository path.
+ * This is meant to be called in the background (fire-and-forget).
+ */
+export async function registerRepo(repoName, repoRoot) {
+    try {
+        const registry = await readRegistry();
+        // Only write if it actually changed
+        if (registry.repos[repoName] !== repoRoot) {
+            registry.repos[repoName] = repoRoot;
+            await writeRegistry(registry);
+        }
+    }
+    catch {
+        // Fail silently — registry is a nice-to-have, shouldn't crash commands
+    }
+}
+/**
+ * Get a specific repo path from the registry.
+ * Also verifies the path still exists on disk, removing it if not.
+ */
+export async function getRegisteredRepoPath(repoName) {
+    const registry = await readRegistry();
+    const repoPath = registry.repos[repoName];
+    if (!repoPath)
+        return null;
+    // Prune dead links
+    if (!(await fs.pathExists(repoPath))) {
+        delete registry.repos[repoName];
+        await writeRegistry(registry).catch(() => { });
+        return null;
+    }
+    return repoPath;
+}
+/**
+ * Get all registered repos that still exist on disk.
+ */
+export async function getValidRegisteredRepos() {
+    const registry = await readRegistry();
+    const valid = {};
+    let changed = false;
+    // Validate in parallel
+    await Promise.all(Object.entries(registry.repos).map(async ([name, rPath]) => {
+        if (await fs.pathExists(rPath)) {
+            valid[name] = rPath;
+        }
+        else {
+            delete registry.repos[name];
+            changed = true;
+        }
+    }));
+    if (changed) {
+        await writeRegistry(registry).catch(() => { });
+    }
+    return valid;
+}

package/dist/lib/repo-context.js

@@ -0,0 +1,46 @@
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { getRepoRoot } from './git.js';
+import { getValidRegisteredRepos } from './registry.js';
+import { log } from './ui.js';
+import { formatWorktreeDisplayPath } from './worktree.js';
+export async function ensureRepoContext() {
+    try {
+        return await getRepoRoot();
+    }
+    catch {
+        const validRepos = await getValidRegisteredRepos();
+        const repoEntries = Object.entries(validRepos);
+        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.');
+            process.exit(1);
+        }
+        if (repoEntries.length === 1 && (process.env.CI === 'true' || !process.stdin.isTTY)) {
+            const [, selectedRepoPath] = repoEntries[0];
+            process.chdir(selectedRepoPath);
+            return await getRepoRoot();
+        }
+        if (!process.stdin.isTTY) {
+            log.error('Not inside a git repository and multiple registered realms are available.');
+            log.dim('Run yggtree from the repo you want to use, or run interactive mode from a real terminal to choose one.');
+            log.dim(`Available realms: ${repoEntries.map(([name]) => name).join(', ')}`);
+            process.exit(1);
+        }
+        console.log(chalk.bold('\n  Not inside a realm. Pick a known one:'));
+        const { selectedRepoPath } = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'selectedRepoPath',
+                message: 'Select a realm:',
+                choices: repoEntries.map(([name, repoPath]) => ({
+                    name: `${chalk.bold.yellow(name)} ${chalk.dim(formatWorktreeDisplayPath(repoPath))}`,
+                    value: repoPath,
+                })),
+                pageSize: 10,
+            },
+        ]);
+        process.chdir(selectedRepoPath);
+        return await getRepoRoot();
+    }
+}

package/dist/lib/update-check.js

@@ -0,0 +1,55 @@
+import chalk from 'chalk';
+import { execa } from 'execa';
+import { getVersion } from './version.js';
+import { log } from './ui.js';
+function parseVersion(version) {
+    const [core] = version.trim().replace(/^v/, '').split('-');
+    return core.split('.').map(part => {
+        const parsed = Number.parseInt(part, 10);
+        return Number.isNaN(parsed) ? 0 : parsed;
+    });
+}
+export function isNewerVersion(latestVersion, currentVersion) {
+    const latestParts = parseVersion(latestVersion);
+    const currentParts = parseVersion(currentVersion);
+    const maxLength = Math.max(latestParts.length, currentParts.length);
+    for (let index = 0; index < maxLength; index += 1) {
+        const latestPart = latestParts[index] ?? 0;
+        const currentPart = currentParts[index] ?? 0;
+        if (latestPart > currentPart)
+            return true;
+        if (latestPart < currentPart)
+            return false;
+    }
+    return false;
+}
+export async function fetchLatestPackageVersion() {
+    const { stdout } = await execa('npm', ['view', 'yggtree', 'version', '--silent'], {
+        timeout: 3_000,
+    });
+    return stdout.trim();
+}
+export async function checkForUpdate(options = {}) {
+    const currentVersion = getVersion();
+    const fetchLatestVersion = options.fetchLatestVersion ?? fetchLatestPackageVersion;
+    try {
+        const latestVersion = await fetchLatestVersion();
+        if (!latestVersion)
+            return null;
+        return {
+            currentVersion,
+            latestVersion,
+            updateAvailable: isNewerVersion(latestVersion, currentVersion),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export async function notifyIfUpdateAvailable() {
+    const result = await checkForUpdate();
+    if (!result?.updateAvailable)
+        return;
+    log.warning(`A newer yggtree is available: ${chalk.dim(`v${result.currentVersion}`)} -> ${chalk.green(`v${result.latestVersion}`)}`);
+    log.dim('Update with: npm install -g yggtree');
+}

package/dist/lib/worktree.js

@@ -50,3 +50,15 @@ export function formatWorktreeType(type) {
         return chalk.blue('MAIN   ');
     return chalk.cyan('LINKED ');
 }
+export function formatPrStatus(pr) {
+    switch (pr.label) {
+        case 'MERGED': return chalk.magenta(`#${pr.number} MERGED`);
+        case 'APPROVED': return chalk.green(`#${pr.number} APPROVED`);
+        case 'CHANGES': return chalk.red(`#${pr.number} CHANGES`);
+        case 'IN REVIEW': return chalk.yellow(`#${pr.number} IN REVIEW`);
+        case 'DRAFT': return chalk.dim(`#${pr.number} DRAFT`);
+        case 'OPEN': return chalk.cyan(`#${pr.number} OPEN`);
+        case 'CLOSED': return chalk.dim(`#${pr.number} CLOSED`);
+        default: return chalk.dim(`#${pr.number} ${pr.label}`);
+    }
+}

package/package.json

@@ -1,9 +1,15 @@
 {
   "name": "yggtree",
-  "version": "1.4.1",
+  "version": "1.4.3",
+  "packageManager": "pnpm@11.0.9",
   "description": "Interactive CLI for managing git worktrees and configs",
   "main": "dist/index.js",
   "type": "module",
+  "repository": {
+    "url": "git+https://github.com/logbookfordevs/yggdrasil-worktree.git",
+    "type": "git"
+  },
+  "homepage": "yggtree.logbookfordevs.com",
   "bin": {
     "yggtree": "./bin/yggtree"
   },
@@ -16,7 +22,9 @@
     "build": "tsc",
     "start": "node dist/index.js",
     "dev": "tsc --watch",
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "site:dev": "pnpm --dir apps/site dev",
+    "test": "pnpm build && pnpm test:typecheck && vitest run",
+    "test:typecheck": "tsc --noEmit -p tsconfig.test.json"
   },
   "keywords": [
     "cli",
@@ -44,6 +52,7 @@
     "@types/gradient-string": "^1.1.6",
     "@types/inquirer": "^9.0.7",
     "@types/node": "^20.11.19",
-    "typescript": "^5.3.3"
+    "typescript": "^5.3.3",
+    "vitest": "^4.1.7"
   }
 }