lattice-ui 0.4.3

package/dist/core/logger.d.ts

@@ -0,0 +1,27 @@
+export interface Spinner {
+    succeed(message?: string): void;
+    fail(message?: string): void;
+    stop(message?: string): void;
+}
+export interface Logger {
+    readonly verbose: boolean;
+    info(message: string): void;
+    success(message: string): void;
+    warn(message: string): void;
+    error(message: string): void;
+    debug(message: string): void;
+    section(title: string): void;
+    kv(label: string, value: string): void;
+    step(message: string): void;
+    list(items: string[]): void;
+    confirm(message: string): Promise<boolean>;
+    spinner(message: string): Spinner;
+}
+export interface LoggerOptions {
+    verbose: boolean;
+    yes: boolean;
+    stdin?: NodeJS.ReadStream;
+    stdout?: NodeJS.WriteStream;
+    stderr?: NodeJS.WriteStream;
+}
+export declare function createLogger(options: LoggerOptions): Logger;

package/dist/core/logger.js

@@ -0,0 +1,166 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLogger = createLogger;
+const promises_1 = require("node:readline/promises");
+const FRAMES = ["-", "\\", "|", "/"];
+const ICONS = {
+    tty: {
+        info: "?",
+        success: "✔",
+        warn: "⚠",
+        error: "✖",
+        step: "›",
+        debug: "·",
+    },
+    plain: {
+        info: "[?]",
+        success: "[+]",
+        warn: "[!]",
+        error: "[x]",
+        step: "[>]",
+        debug: "[d]",
+    },
+};
+const ANSI = {
+    reset: "\u001b[0m",
+    cyan: "\u001b[36m",
+    green: "\u001b[32m",
+    yellow: "\u001b[33m",
+    red: "\u001b[31m",
+    magenta: "\u001b[35m",
+    gray: "\u001b[90m",
+    bold: "\u001b[1m",
+};
+function isTTY(stdout, stderr) {
+    return Boolean(stdout.isTTY || stderr.isTTY);
+}
+function colorize(enabled, color, text) {
+    if (!enabled) {
+        return text;
+    }
+    return `${color}${text}${ANSI.reset}`;
+}
+function createLogger(options) {
+    const stdin = options.stdin ?? process.stdin;
+    const stdout = options.stdout ?? process.stdout;
+    const stderr = options.stderr ?? process.stderr;
+    const useColor = isTTY(stdout, stderr);
+    const useUnicodeIcons = isTTY(stdout, stderr);
+    function icon(kind) {
+        return useUnicodeIcons ? ICONS.tty[kind] : ICONS.plain[kind];
+    }
+    function write(stream, iconKey, message, color, tokenOnlyColor = true, leadingNewline = false) {
+        const token = icon(iconKey);
+        const decoratedToken = tokenOnlyColor ? colorize(useColor, color, token) : token;
+        const decoratedMessage = tokenOnlyColor ? message : colorize(useColor, color, message);
+        const prefix = token.length > 0 ? `${decoratedToken} ` : "";
+        stream.write(`${leadingNewline ? "\n" : ""}${prefix}${decoratedMessage}\n`);
+    }
+    return {
+        verbose: options.verbose,
+        info(message) {
+            write(stdout, "info", message, ANSI.cyan);
+        },
+        success(message) {
+            write(stdout, "success", message, ANSI.green);
+        },
+        warn(message) {
+            write(stderr, "warn", message, ANSI.yellow);
+        },
+        error(message) {
+            write(stderr, "error", message, ANSI.red);
+        },
+        debug(message) {
+            if (options.verbose) {
+                write(stdout, "debug", message, ANSI.gray);
+            }
+        },
+        section(title) {
+            const text = useColor ? `${ANSI.bold}${title}${ANSI.reset}` : title;
+            write(stdout, "step", text, ANSI.magenta, true, true);
+        },
+        kv(label, value) {
+            const labelText = useColor ? `${ANSI.bold}${label}${ANSI.reset}` : label;
+            write(stdout, "info", `${labelText}: ${value}`, ANSI.cyan);
+        },
+        step(message) {
+            write(stdout, "step", message, ANSI.cyan);
+        },
+        list(items) {
+            for (const item of items) {
+                const bullet = colorize(useColor, ANSI.gray, "-");
+                stdout.write(`    ${bullet} ${item}\n`);
+            }
+        },
+        async confirm(message) {
+            if (options.yes) {
+                return true;
+            }
+            if (!stdin.isTTY || !stdout.isTTY) {
+                write(stderr, "warn", `${message} (confirmation required; pass --yes in non-interactive mode)`, ANSI.yellow);
+                return false;
+            }
+            const rl = (0, promises_1.createInterface)({ input: stdin, output: stdout });
+            try {
+                const answer = await rl.question(`${colorize(useColor, ANSI.cyan, icon("step"))} ${message} [y/N] `);
+                const normalized = answer.trim().toLowerCase();
+                return normalized === "y" || normalized === "yes";
+            }
+            finally {
+                rl.close();
+            }
+        },
+        spinner(message) {
+            if (!stdout.isTTY || options.verbose) {
+                write(stdout, "step", message, ANSI.cyan);
+                return {
+                    succeed(nextMessage) {
+                        if (nextMessage) {
+                            write(stdout, "success", nextMessage, ANSI.green);
+                        }
+                    },
+                    fail(nextMessage) {
+                        if (nextMessage) {
+                            write(stderr, "error", nextMessage, ANSI.red);
+                        }
+                    },
+                    stop(nextMessage) {
+                        if (nextMessage) {
+                            write(stdout, "info", nextMessage, ANSI.cyan);
+                        }
+                    },
+                };
+            }
+            let frameIndex = 0;
+            const renderFrame = (frame) => `${colorize(useColor, ANSI.cyan, frame)} ${message}`;
+            stdout.write(renderFrame(FRAMES[frameIndex]));
+            const timer = setInterval(() => {
+                frameIndex = (frameIndex + 1) % FRAMES.length;
+                stdout.write(`\r${renderFrame(FRAMES[frameIndex])}`);
+            }, 80);
+            let finished = false;
+            const stop = (token, color, nextMessage, stream) => {
+                if (finished) {
+                    return;
+                }
+                finished = true;
+                clearInterval(timer);
+                const output = stream ?? stdout;
+                const finalToken = colorize(useColor, color, token);
+                const finalMessage = nextMessage ?? message;
+                output.write(`\r${finalToken} ${finalMessage}\n`);
+            };
+            return {
+                succeed(nextMessage) {
+                    stop(icon("success"), ANSI.green, nextMessage, stdout);
+                },
+                fail(nextMessage) {
+                    stop(icon("error"), ANSI.red, nextMessage, stderr);
+                },
+                stop(nextMessage) {
+                    stop(icon("info"), ANSI.cyan, nextMessage, stdout);
+                },
+            };
+        },
+    };
+}

package/dist/core/npm/latest.d.ts

@@ -0,0 +1 @@
+export declare function resolveLatestVersions(packages: string[]): Promise<Record<string, string>>;

package/dist/core/npm/latest.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveLatestVersions = resolveLatestVersions;
+const errors_1 = require("../errors");
+const LATEST_TIMEOUT_MS = 10_000;
+async function fetchLatestVersion(packageName) {
+    const encodedName = encodeURIComponent(packageName);
+    const url = `https://registry.npmjs.org/${encodedName}/latest`;
+    let response;
+    try {
+        response = await fetch(url, {
+            headers: {
+                Accept: "application/json",
+            },
+            signal: AbortSignal.timeout(LATEST_TIMEOUT_MS),
+        });
+    }
+    catch (error) {
+        throw (0, errors_1.packageManagerFailedError)(`Failed to fetch latest version for ${packageName}.`, error);
+    }
+    if (!response.ok) {
+        throw (0, errors_1.packageManagerFailedError)(`Failed to fetch latest version for ${packageName}: npm registry responded with ${response.status}.`);
+    }
+    let payload;
+    try {
+        payload = (await response.json());
+    }
+    catch (error) {
+        throw (0, errors_1.packageManagerFailedError)(`Failed to parse npm registry response for ${packageName}.`, error);
+    }
+    if (typeof payload.version !== "string" || payload.version.length === 0) {
+        throw (0, errors_1.packageManagerFailedError)(`npm registry did not return a valid latest version for ${packageName}.`);
+    }
+    return payload.version;
+}
+async function resolveLatestVersions(packages) {
+    const uniquePackages = [...new Set(packages)];
+    const entries = await Promise.all(uniquePackages.map(async (packageName) => [packageName, await fetchLatestVersion(packageName)]));
+    return Object.fromEntries(entries);
+}

package/dist/core/output.d.ts

@@ -0,0 +1,8 @@
+import type { PackageManagerName } from "./pm/types";
+export interface SummarizedItems {
+    total: number;
+    visible: string[];
+    hidden: number;
+}
+export declare function resolveLocalLatticeCommand(pmName: PackageManagerName): string;
+export declare function summarizeItems(items: string[], limit?: number): SummarizedItems;

package/dist/core/output.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveLocalLatticeCommand = resolveLocalLatticeCommand;
+exports.summarizeItems = summarizeItems;
+function resolveLocalLatticeCommand(pmName) {
+    if (pmName === "npm") {
+        return "npx lattice";
+    }
+    return `${pmName} lattice`;
+}
+function summarizeItems(items, limit = 8) {
+    const normalizedLimit = Math.max(0, Math.floor(limit));
+    const uniqueItems = [...new Set(items)];
+    const visible = uniqueItems.slice(0, normalizedLimit);
+    return {
+        total: uniqueItems.length,
+        visible,
+        hidden: Math.max(0, uniqueItems.length - visible.length),
+    };
+}

package/dist/core/pm/detect.d.ts

@@ -0,0 +1,18 @@
+import type { PromptRuntime } from "../prompt";
+import { promptSelect } from "../prompt";
+import type { PackageManager, PackageManagerName } from "./types";
+export type PackageManagerResolutionSource = "override" | "lockfile" | "installed" | "prompt";
+export interface DetectPackageManagerResult {
+    name: PackageManagerName;
+    manager: PackageManager;
+    lockfiles: PackageManagerName[];
+    installed: PackageManagerName[];
+    source: PackageManagerResolutionSource;
+}
+export interface DetectPackageManagerOptions {
+    runtime?: PromptRuntime;
+    promptSelectFn?: typeof promptSelect;
+    detectInstalledPackageManagersFn?: () => Promise<PackageManagerName[]>;
+}
+export declare function detectInstalledPackageManagers(): Promise<PackageManagerName[]>;
+export declare function detectPackageManager(cwd: string, override?: string, options?: DetectPackageManagerOptions): Promise<DetectPackageManagerResult>;

package/dist/core/pm/detect.js

@@ -0,0 +1,147 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectInstalledPackageManagers = detectInstalledPackageManagers;
+exports.detectPackageManager = detectPackageManager;
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = require("node:fs");
+const path = __importStar(require("node:path"));
+const errors_1 = require("../errors");
+const prompt_1 = require("../prompt");
+const npm_1 = require("./npm");
+const pnpm_1 = require("./pnpm");
+const yarn_1 = require("./yarn");
+const promptPackageManagerOrder = ["npm", "pnpm", "yarn"];
+const lockfileDetectionOrder = ["pnpm", "yarn", "npm"];
+const PACKAGE_MANAGER_HINT = "--pm <pnpm|npm|yarn>";
+const lockfileByManager = {
+    pnpm: "pnpm-lock.yaml",
+    yarn: "yarn.lock",
+    npm: "package-lock.json",
+};
+const managerFactory = {
+    pnpm: pnpm_1.createPnpmPackageManager,
+    yarn: yarn_1.createYarnPackageManager,
+    npm: npm_1.createNpmPackageManager,
+};
+async function exists(filePath) {
+    try {
+        await node_fs_1.promises.access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function normalizePackageManagers(values) {
+    const unique = new Set(values);
+    return promptPackageManagerOrder.filter((managerName) => unique.has(managerName));
+}
+async function isPackageManagerInstalled(managerName) {
+    return new Promise((resolve) => {
+        const child = (0, node_child_process_1.spawn)(managerName, ["--version"], {
+            stdio: "ignore",
+            shell: process.platform === "win32",
+        });
+        child.on("error", () => {
+            resolve(false);
+        });
+        child.on("close", (code) => {
+            resolve(code === 0);
+        });
+    });
+}
+async function detectInstalledPackageManagers() {
+    const checks = await Promise.all(promptPackageManagerOrder.map(async (managerName) => (await isPackageManagerInstalled(managerName)) ? managerName : null));
+    return checks.filter((managerName) => managerName !== null);
+}
+function createResult(name, lockfiles, installed, source) {
+    return {
+        name,
+        manager: managerFactory[name](),
+        lockfiles,
+        installed,
+        source,
+    };
+}
+function ensureInstalled(selected, installed, reason) {
+    if (installed.includes(selected)) {
+        return;
+    }
+    if (reason === "override") {
+        throw (0, errors_1.usageError)(`Requested package manager "${selected}" is not installed. Install ${selected} or choose a different ${PACKAGE_MANAGER_HINT}.`);
+    }
+    throw (0, errors_1.usageError)(`Detected ${selected} from ${lockfileByManager[selected]} but ${selected} is not installed. Install ${selected} or re-run with ${PACKAGE_MANAGER_HINT}.`);
+}
+async function detectPackageManager(cwd, override, options) {
+    const requested = override?.trim();
+    if (requested && requested !== "pnpm" && requested !== "npm" && requested !== "yarn") {
+        throw (0, errors_1.usageError)(`Invalid --pm value "${override}". Use pnpm, npm, or yarn.`);
+    }
+    const lockfiles = [];
+    for (const managerName of lockfileDetectionOrder) {
+        if (await exists(path.join(cwd, lockfileByManager[managerName]))) {
+            lockfiles.push(managerName);
+        }
+    }
+    const installed = normalizePackageManagers(await (options?.detectInstalledPackageManagersFn ?? detectInstalledPackageManagers)());
+    if (requested) {
+        const selected = requested;
+        ensureInstalled(selected, installed, "override");
+        return createResult(selected, lockfiles, installed, "override");
+    }
+    if (lockfiles.length > 0) {
+        const selected = lockfiles[0];
+        ensureInstalled(selected, installed, "lockfile");
+        return createResult(selected, lockfiles, installed, "lockfile");
+    }
+    if (installed.length === 0) {
+        throw (0, errors_1.usageError)("No supported package manager is installed. Install npm, pnpm, or yarn and re-run the command.");
+    }
+    if (installed.length === 1) {
+        return createResult(installed[0], lockfiles, installed, "installed");
+    }
+    const runtime = options?.runtime ?? { yes: false, stdin: process.stdin, stdout: process.stdout };
+    const stdin = runtime.stdin ?? process.stdin;
+    const stdout = runtime.stdout ?? process.stdout;
+    if (runtime.yes || !stdin.isTTY || !stdout.isTTY) {
+        throw (0, errors_1.usageError)(`Multiple package managers are installed (${installed.join(", ")}). Re-run with ${PACKAGE_MANAGER_HINT}.`);
+    }
+    const selected = await (options?.promptSelectFn ?? prompt_1.promptSelect)(runtime, "Select a package manager", installed.map((managerName) => ({
+        label: managerName,
+        value: managerName,
+    })), { defaultIndex: 0 });
+    return createResult(selected, lockfiles, installed, "prompt");
+}

package/dist/core/pm/npm.d.ts

@@ -0,0 +1,2 @@
+import type { PackageManager } from "./types";
+export declare function createNpmPackageManager(): PackageManager;

package/dist/core/pm/npm.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNpmPackageManager = createNpmPackageManager;
+const node_child_process_1 = require("node:child_process");
+const errors_1 = require("../errors");
+function run(command, args, cwd) {
+    return new Promise((resolve, reject) => {
+        const child = (0, node_child_process_1.spawn)(command, args, {
+            cwd,
+            stdio: "inherit",
+            shell: process.platform === "win32",
+        });
+        child.on("error", (error) => {
+            reject((0, errors_1.packageManagerFailedError)(`Failed to run ${command}: ${error.message}`, error));
+        });
+        child.on("close", (code) => {
+            if (code === 0) {
+                resolve();
+                return;
+            }
+            reject((0, errors_1.packageManagerFailedError)(`${command} ${args.join(" ")} exited with code ${code ?? "unknown"}.`));
+        });
+    });
+}
+function createNpmPackageManager() {
+    return {
+        name: "npm",
+        async add(dev, specs, cwd) {
+            if (specs.length === 0) {
+                return;
+            }
+            const args = ["install", ...(dev ? ["--save-dev"] : []), ...specs];
+            await run("npm", args, cwd);
+        },
+        async remove(specs, cwd) {
+            if (specs.length === 0) {
+                return;
+            }
+            await run("npm", ["uninstall", ...specs], cwd);
+        },
+        async install(cwd) {
+            await run("npm", ["install"], cwd);
+        },
+        async exec(bin, args, cwd) {
+            await run("npm", ["exec", "--", bin, ...args], cwd);
+        },
+    };
+}

package/dist/core/pm/pnpm.d.ts

@@ -0,0 +1,2 @@
+import type { PackageManager } from "./types";
+export declare function createPnpmPackageManager(): PackageManager;

package/dist/core/pm/pnpm.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPnpmPackageManager = createPnpmPackageManager;
+const node_child_process_1 = require("node:child_process");
+const errors_1 = require("../errors");
+function run(command, args, cwd) {
+    return new Promise((resolve, reject) => {
+        const child = (0, node_child_process_1.spawn)(command, args, {
+            cwd,
+            stdio: "inherit",
+            shell: process.platform === "win32",
+        });
+        child.on("error", (error) => {
+            reject((0, errors_1.packageManagerFailedError)(`Failed to run ${command}: ${error.message}`, error));
+        });
+        child.on("close", (code) => {
+            if (code === 0) {
+                resolve();
+                return;
+            }
+            reject((0, errors_1.packageManagerFailedError)(`${command} ${args.join(" ")} exited with code ${code ?? "unknown"}.`));
+        });
+    });
+}
+function createPnpmPackageManager() {
+    return {
+        name: "pnpm",
+        async add(dev, specs, cwd) {
+            if (specs.length === 0) {
+                return;
+            }
+            const args = ["add", ...(dev ? ["-D"] : []), ...specs];
+            await run("pnpm", args, cwd);
+        },
+        async remove(specs, cwd) {
+            if (specs.length === 0) {
+                return;
+            }
+            await run("pnpm", ["remove", ...specs], cwd);
+        },
+        async install(cwd) {
+            await run("pnpm", ["install"], cwd);
+        },
+        async exec(bin, args, cwd) {
+            await run("pnpm", ["exec", bin, ...args], cwd);
+        },
+    };
+}

package/dist/core/pm/types.d.ts

@@ -0,0 +1,8 @@
+export type PackageManagerName = "pnpm" | "npm" | "yarn";
+export interface PackageManager {
+    name: "pnpm" | "npm" | "yarn";
+    add(dev: boolean, specs: string[], cwd: string): Promise<void>;
+    remove(specs: string[], cwd: string): Promise<void>;
+    install(cwd: string): Promise<void>;
+    exec(bin: string, args: string[], cwd: string): Promise<void>;
+}

package/dist/core/pm/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/pm/yarn.d.ts

@@ -0,0 +1,2 @@
+import type { PackageManager } from "./types";
+export declare function createYarnPackageManager(): PackageManager;

package/dist/core/pm/yarn.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createYarnPackageManager = createYarnPackageManager;
+const node_child_process_1 = require("node:child_process");
+const errors_1 = require("../errors");
+function run(command, args, cwd) {
+    return new Promise((resolve, reject) => {
+        const child = (0, node_child_process_1.spawn)(command, args, {
+            cwd,
+            stdio: "inherit",
+            shell: process.platform === "win32",
+        });
+        child.on("error", (error) => {
+            reject((0, errors_1.packageManagerFailedError)(`Failed to run ${command}: ${error.message}`, error));
+        });
+        child.on("close", (code) => {
+            if (code === 0) {
+                resolve();
+                return;
+            }
+            reject((0, errors_1.packageManagerFailedError)(`${command} ${args.join(" ")} exited with code ${code ?? "unknown"}.`));
+        });
+    });
+}
+function createYarnPackageManager() {
+    return {
+        name: "yarn",
+        async add(dev, specs, cwd) {
+            if (specs.length === 0) {
+                return;
+            }
+            const args = ["add", ...(dev ? ["--dev"] : []), ...specs];
+            await run("yarn", args, cwd);
+        },
+        async remove(specs, cwd) {
+            if (specs.length === 0) {
+                return;
+            }
+            await run("yarn", ["remove", ...specs], cwd);
+        },
+        async install(cwd) {
+            await run("yarn", ["install"], cwd);
+        },
+        async exec(bin, args, cwd) {
+            await run("yarn", ["run", bin, ...args], cwd);
+        },
+    };
+}

package/dist/core/project/findRoot.d.ts

@@ -0,0 +1 @@
+export declare function findRoot(startDir: string): Promise<string | undefined>;

package/dist/core/project/findRoot.js

@@ -0,0 +1,60 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findRoot = findRoot;
+const node_fs_1 = require("node:fs");
+const path = __importStar(require("node:path"));
+async function hasPackageJson(dirPath) {
+    try {
+        await node_fs_1.promises.access(path.join(dirPath, "package.json"));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function findRoot(startDir) {
+    let currentDir = path.resolve(startDir);
+    while (true) {
+        if (await hasPackageJson(currentDir)) {
+            return currentDir;
+        }
+        const parentDir = path.dirname(currentDir);
+        if (parentDir === currentDir) {
+            return undefined;
+        }
+        currentDir = parentDir;
+    }
+}