@uxf/scripts 11.108.0 → 11.109.1

package/README.md

@@ -63,6 +63,54 @@ notify-push:
         - uxf-push-notifier --google-chat-webhook-url=$GOOGLE_CHAT_WEBHOOK
 ```
 
+## uxf-dependencies-check
+
+All-in-one dependency health check for projects using `@uxf/*` packages. Runs two checks:
+
+1. **Version conflict detection** — parses the lock file and reports dependencies of `@uxf/*` packages that resolve to multiple versions
+2. **Peer dependency check** — verifies that all `peerDependencies` of installed `@uxf/*` packages are present and version-matched
+
+Supports **yarn**, **npm**, **pnpm**, and **bun**. The package manager is auto-detected from the lock file.
+
+```bash
+Usage:
+  uxf-dependencies-check [options]
+
+Options:
+  --fix           Auto-install missing/mismatched peer dependencies
+  --dry-run       Show what would be installed without changes
+  -e, --exclude   Packages to ignore in conflict check              [array]
+  -h, --help      Show help                                        [boolean]
+```
+
+Build-time dependencies (`yargs`, `fast-glob`) are automatically ignored in the conflict check.
+
+### Examples
+
+```bash
+# Run both checks (exits with code 1 if issues found)
+npx uxf-dependencies-check
+
+# Auto-install missing peer deps
+npx uxf-dependencies-check --fix
+
+# Preview what would be installed
+npx uxf-dependencies-check --dry-run
+
+# Ignore specific packages in conflict check
+npx uxf-dependencies-check --exclude lodash dayjs
+```
+
+### What it checks
+
+- Parses the lock file (yarn.lock / package-lock.json / pnpm-lock.yaml / bun.lock) to detect version conflicts
+- Scans all `@uxf/*` packages in your `dependencies` / `devDependencies`
+- Reads each package's `peerDependencies` from `node_modules`
+- Skips `@uxf/*`, `react`, `react-dom`, and `next` (you manage these yourself)
+- Reports missing dependencies and version mismatches
+- Distinguishes between prod and dev dependencies — peer deps required only by `devDependencies` are installed with `-D`
+- With `--fix`, auto-installs missing peer deps using the detected package manager
+
 ## uxf-lunch
 
 ```bash

package/bin/uxf-dependencies-check.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/bin/uxf-dependencies-check.js

@@ -1,8 +1,15 @@
 #!/usr/bin/env node
-require("../src/uxf-dependencies-check/cli")()
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const cli_1 = __importDefault(require("../src/uxf-dependencies-check/cli"));
+(0, cli_1.default)()
     .then((exitCode) => {
-        process.exitCode = exitCode;
-    })
-    .catch(() => {
-        process.exitCode = 1;
-    });
+    process.exitCode = exitCode;
+})
+    .catch((e) => {
+    console.error(e); // eslint-disable-line no-console
+    process.exitCode = 1;
+});

package/package.json

@@ -1,25 +1,25 @@
 {
     "name": "@uxf/scripts",
-    "version": "11.108.0",
+    "version": "11.109.1",
     "description": "",
     "main": "index.js",
     "bin": {
         "uxf-audit": "bin/uxf-audit.js",
         "uxf-claude-sync": "bin/uxf-claude-sync.js",
-        "uxf-lunch": "bin/uxf-lunch.js",
         "uxf-dependencies-check": "bin/uxf-dependencies-check.js",
+        "uxf-i18n-namespaces-gen": "bin/uxf-i18n-namespaces-gen.js",
+        "uxf-lunch": "bin/uxf-lunch.js",
         "uxf-push-notifier": "bin/uxf-push-notifier.js",
         "uxf-release": "bin/uxf-release.js",
         "uxf-sitemap-check": "bin/uxf-sitemap-check.js",
         "uxf-sitemap-meta-export": "bin/uxf-sitemap-meta-export.js",
-        "uxf-i18n-namespaces-gen": "bin/uxf-i18n-namespaces-gen.js",
         "uxf-unused": "bin/uxf-unused.js"
     },
     "scripts": {
-        "build": "",
-        "typecheck": "",
+        "build": "tsc -P tsconfig.build.json && chmod +x ./bin/*",
+        "run:mr-notifier": "GOOGLE_WEBHOOK_URL=<<TODO>> GITLAB_TOKEN=<<TODO>> CI_SERVER_URL=https://gitlab.uxf.cz node ./bin/uxf-merge-requests-notifier.js",
         "test": "./node_modules/.bin/eslint ./bin",
-        "run:mr-notifier": "GOOGLE_WEBHOOK_URL=<<TODO>> GITLAB_TOKEN=<<TODO>> CI_SERVER_URL=https://gitlab.uxf.cz node ./bin/uxf-merge-requests-notifier.js"
+        "typecheck": "tsc --noEmit -p tsconfig.json"
     },
     "publishConfig": {
         "access": "public"

package/src/uxf-dependencies-check/cli.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => Promise<number>;
+export default _default;

package/src/uxf-dependencies-check/cli.js

@@ -1,32 +1,78 @@
-const { checkUxfDependencies } = require("./index");
-const { argv } = require("process");
-
-module.exports = async () => {
-    const cli = require("yargs")()
-        .command("$0", "UXF Dependencies Check", (yargs) => {
-            yargs.demandCommand(0, 0).usage(`
-            Usage:
-  uxf-dependencies-check [options]`);
-        })
-        .option("e", {
-            alias: "exclude",
-            array: true,
-            default: [],
-            describe: "Seznam balíčků, které budou ignorovány",
-        })
-        .strict(false)
+"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 });
+const index_1 = require("./index");
+exports.default = async () => {
+    const yargs = (await Promise.resolve().then(() => __importStar(require("yargs")))).default;
+    const { hideBin } = await Promise.resolve().then(() => __importStar(require("yargs/helpers")));
+    const args = hideBin(process.argv);
+    const isHelp = args.includes("--help") || args.includes("-h");
+    const cli = yargs(args)
+        .usage("Usage: uxf-dependencies-check [options]")
+        .option("fix", {
+        type: "boolean",
+        default: false,
+        describe: "Auto-install missing/mismatched peer dependencies",
+    })
+        .option("dry-run", {
+        type: "boolean",
+        default: false,
+        describe: "Show what would be installed without changes",
+    })
+        .option("exclude", {
+        alias: "e",
+        type: "array",
+        string: true,
+        default: [],
+        describe: "Packages to ignore in conflict check",
+    })
+        .strict()
         .exitProcess(false);
-
     try {
-        const { help, exclude } = cli.parse(argv.slice(2));
-
-        if (Boolean(help)) {
+        const argv = await cli.parse();
+        if (isHelp) {
             return 0;
         }
-
-        await checkUxfDependencies(new Set(exclude));
-    } catch (e) {
-        console.error(e);
+        return await (0, index_1.checkUxfDependencies)({
+            isFix: Boolean(argv.fix),
+            isDryRun: Boolean(argv.dryRun),
+            exclude: argv.exclude,
+        });
+    }
+    catch {
+        // yargs prints its own error messages (e.g. unknown options with --strict)
         return 1;
     }
 };

package/src/uxf-dependencies-check/conflict-check.d.ts

@@ -0,0 +1,7 @@
+import type { Conflict, LockData } from "./types";
+/**
+ * Collect the set of package names that are direct dependencies of any installed @uxf/* package.
+ * Only these are relevant for version conflict detection.
+ */
+export declare function collectUxfDependencyNames(uxfPackages: string[], nodeModulesPath: string): Set<string>;
+export declare function checkMultipleVersions(lockData: LockData, relevantPackages: Set<string>, excludedPackages?: Set<string>): Conflict[];

package/src/uxf-dependencies-check/conflict-check.js

@@ -0,0 +1,47 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectUxfDependencyNames = collectUxfDependencyNames;
+exports.checkMultipleVersions = checkMultipleVersions;
+const path_1 = __importDefault(require("path"));
+const types_1 = require("./types");
+/** Build-time / CLI-only dependencies that cannot cause runtime conflicts */
+const IGNORED_PACKAGES = new Set(["yargs", "fast-glob"]);
+/**
+ * Collect the set of package names that are direct dependencies of any installed @uxf/* package.
+ * Only these are relevant for version conflict detection.
+ */
+function collectUxfDependencyNames(uxfPackages, nodeModulesPath) {
+    var _a, _b;
+    const depNames = new Set();
+    for (const uxfPkg of uxfPackages) {
+        const pkgJsonPath = path_1.default.join(nodeModulesPath, uxfPkg, "package.json");
+        const pkgJson = (0, types_1.readPackageJson)(pkgJsonPath);
+        if (!pkgJson) {
+            continue;
+        }
+        for (const name of Object.keys((_a = pkgJson.dependencies) !== null && _a !== void 0 ? _a : {})) {
+            depNames.add(name);
+        }
+        for (const name of Object.keys((_b = pkgJson.peerDependencies) !== null && _b !== void 0 ? _b : {})) {
+            depNames.add(name);
+        }
+    }
+    return depNames;
+}
+function checkMultipleVersions(lockData, relevantPackages, excludedPackages = new Set()) {
+    const allExcluded = new Set([...IGNORED_PACKAGES, ...excludedPackages]);
+    const conflicts = [];
+    for (const name of relevantPackages) {
+        if (allExcluded.has(name)) {
+            continue;
+        }
+        const versions = lockData.get(name);
+        if (versions && versions.size > 1) {
+            conflicts.push({ name, versions: Array.from(versions) });
+        }
+    }
+    return conflicts;
+}

package/src/uxf-dependencies-check/detect-package-manager.d.ts

@@ -0,0 +1,6 @@
+import type { PackageManager } from "./types";
+export declare function detectPackageManager(cwd?: string): PackageManager;
+export declare function getInstallCommand(pm: PackageManager): {
+    cmd: string;
+    addArg: string;
+};

package/src/uxf-dependencies-check/detect-package-manager.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectPackageManager = detectPackageManager;
+exports.getInstallCommand = getInstallCommand;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const LOCK_FILES = [
+    { file: "bun.lock", pm: "bun" },
+    { file: "pnpm-lock.yaml", pm: "pnpm" },
+    { file: "yarn.lock", pm: "yarn" },
+    { file: "package-lock.json", pm: "npm" },
+];
+function detectPackageManager(cwd = process.cwd()) {
+    for (const { file, pm } of LOCK_FILES) {
+        if (fs_1.default.existsSync(path_1.default.resolve(cwd, file))) {
+            return pm;
+        }
+    }
+    throw new Error("Could not detect package manager. Please run this command from a project root.");
+}
+function getInstallCommand(pm) {
+    switch (pm) {
+        case "yarn":
+            return { cmd: "yarn", addArg: "add" };
+        case "pnpm":
+            return { cmd: "pnpm", addArg: "add" };
+        case "bun":
+            return { cmd: "bun", addArg: "add" };
+        case "npm":
+            return { cmd: "npm", addArg: "install" };
+        default:
+            throw new Error(`Unsupported package manager: ${pm}`);
+    }
+}

package/src/uxf-dependencies-check/index.d.ts

@@ -0,0 +1,7 @@
+interface CheckOptions {
+    isFix: boolean;
+    isDryRun: boolean;
+    exclude: string[];
+}
+export declare function checkUxfDependencies(options: CheckOptions): Promise<number>;
+export {};

package/src/uxf-dependencies-check/index.js

@@ -1,110 +1,79 @@
-const fs = require("fs");
-const path = require("path");
-
-const yarnLockPath = path.resolve(process.cwd(), "yarn.lock");
-const packageJsonPath = path.resolve(process.cwd(), "package.json");
-
-// Build-time / CLI-only dependencies that cannot cause runtime conflicts
-const IGNORED_PACKAGES = new Set(["yargs", "fast-glob"]);
-
-async function parseLockFile() {
-    const YAML = await import("yaml");
-
-    const content = fs.readFileSync(yarnLockPath, "utf8");
-    return YAML.parse(content);
-}
-
-function parsePackageJson() {
-    const content = fs.readFileSync(packageJsonPath, "utf8");
-    return JSON.parse(content);
-}
-
-function extractPackageName(key) {
-    const match = key.match(/^(@[^/]+\/[^@]+|[^@]+)@/);
-    return match ? match[1] : null;
-}
-
-function findUxfPackagesInDependencies(lockData, packageJson) {
-    const declaredDependencies = new Set(Object.keys(packageJson.dependencies || {}));
-
-    const uxfPackages = [];
-
-    for (const key of Object.keys(lockData)) {
-        const name = extractPackageName(key);
-        if (name?.startsWith("@uxf/") && declaredDependencies.has(name)) {
-            uxfPackages.push(key);
-        }
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkUxfDependencies = checkUxfDependencies;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const conflict_check_1 = require("./conflict-check");
+const detect_package_manager_1 = require("./detect-package-manager");
+const lock_parsers_1 = require("./lock-parsers");
+const peer_deps_1 = require("./peer-deps");
+function readProjectPackageJson(cwd) {
+    try {
+        return JSON.parse(fs_1.default.readFileSync(path_1.default.resolve(cwd, "package.json"), "utf8"));
+    }
+    catch {
+        return null;
     }
-
-    return uxfPackages;
 }
-
-function collectDirectDependencies(packageKeys, lockData) {
-    const found = {};
-
-    for (const key of packageKeys) {
-        const entry = lockData[key];
-        if (!entry) continue;
-
-        const dependencies = entry.dependencies || {};
-
-        for (const depName in dependencies) {
-            const matchingKeys = Object.keys(lockData).filter((lockKey) => extractPackageName(lockKey) === depName);
-
-            for (const matchKey of matchingKeys) {
-                const depEntry = lockData[matchKey];
-                if (!depEntry || !depEntry.version) continue;
-
-                if (!found[depName]) {
-                    found[depName] = new Set();
-                }
-
-                found[depName].add(depEntry.version);
+async function checkUxfDependencies(options) {
+    const cwd = process.cwd();
+    const pm = (0, detect_package_manager_1.detectPackageManager)(cwd);
+    const projectPkg = readProjectPackageJson(cwd);
+    if (!projectPkg) {
+        console.error("Could not read package.json in current directory."); // eslint-disable-line no-console
+        return 1;
+    }
+    const nodeModulesPath = path_1.default.resolve(cwd, "node_modules");
+    if (!fs_1.default.existsSync(nodeModulesPath)) {
+        console.error("node_modules not found. Run install first."); // eslint-disable-line no-console
+        return 1;
+    }
+    const uxfPackages = (0, peer_deps_1.findInstalledUxfPackages)(projectPkg);
+    if (uxfPackages.length === 0) {
+        console.log("No @uxf/* packages found in dependencies."); // eslint-disable-line no-console
+        return 0;
+    }
+    console.log(`Detected package manager: ${pm}`); // eslint-disable-line no-console
+    console.log(`Found ${uxfPackages.length} @uxf/* packages: ${uxfPackages.join(", ")}\n`); // eslint-disable-line no-console
+    let hasIssues = false;
+    // --- Conflict check (lock file) ---
+    // Only check dependencies of @uxf/* packages, not the entire lock file
+    try {
+        const lockData = await (0, lock_parsers_1.parseLockFile)(pm, cwd);
+        const relevantDeps = (0, conflict_check_1.collectUxfDependencyNames)(uxfPackages, nodeModulesPath);
+        const conflicts = (0, conflict_check_1.checkMultipleVersions)(lockData, relevantDeps, new Set(options.exclude));
+        if (conflicts.length > 0) {
+            console.log("Dependency version conflicts in @uxf/* packages:"); // eslint-disable-line no-console
+            for (const { name, versions } of conflicts) {
+                console.log(`  ${name}: ${versions.join(", ")}`); // eslint-disable-line no-console
             }
+            console.log(); // eslint-disable-line no-console
+            hasIssues = true;
         }
-    }
-
-    return found;
-}
-
-function checkMultipleVersions(dependencyMap, excludedPackages = new Set()) {
-    const conflicts = [];
-
-    for (const [name, versions] of Object.entries(dependencyMap)) {
-        if (excludedPackages.has(name)) continue;
-        if (versions.size > 1) {
-            conflicts.push({ name, versions: Array.from(versions) });
+        else {
+            console.log("No dependency version conflicts found.\n"); // eslint-disable-line no-console
         }
     }
-
-    return conflicts;
-}
-
-async function checkUxfDependencies(excludedPackages = new Set()) {
-    const lockData = await parseLockFile();
-    const packageJson = parsePackageJson();
-
-    const uxfPackages = findUxfPackagesInDependencies(lockData, packageJson);
-    const dependencies = collectDirectDependencies(uxfPackages, lockData);
-
-    const allExcluded = new Set([...IGNORED_PACKAGES, ...excludedPackages]);
-    const conflicts = checkMultipleVersions(dependencies, allExcluded);
-
-    if (conflicts.length > 0) {
-        console.log("Následující balíčky mají více verzí v závislostech UXF balíčků:");
-        for (const { name, versions } of conflicts) {
-            console.log(`- ${name}: ${versions.join(", ")}`);
-        }
-        process.exit(1);
-    } else {
-        console.log("Všechny závislosti UXF balíčků mají jednotnou verzi.");
-        process.exit(0);
+    catch {
+        console.log("Could not parse lock file — skipping conflict check.\n"); // eslint-disable-line no-console
+    }
+    // --- Peer dependency check ---
+    const requiredPeerDeps = (0, peer_deps_1.collectRequiredPeerDeps)(uxfPackages, nodeModulesPath, projectPkg);
+    const { missing, mismatched } = (0, peer_deps_1.findMissingOrMismatchedDeps)(requiredPeerDeps, projectPkg);
+    if (missing.size === 0 && mismatched.size === 0) {
+        console.log("All peer dependencies are correctly installed."); // eslint-disable-line no-console
+        return hasIssues ? 1 : 0;
     }
+    (0, peer_deps_1.printPeerDepsReport)(missing, mismatched);
+    hasIssues = true;
+    if (options.isDryRun || !options.isFix) {
+        (0, peer_deps_1.printSuggestedCommands)(missing, mismatched, pm);
+        return 1;
+    }
+    (0, peer_deps_1.installDeps)(missing, mismatched, pm);
+    console.log("\nAll peer dependencies are now installed."); // eslint-disable-line no-console
+    return 0;
 }
-
-module.exports = {
-    findUxfPackagesInDependencies,
-    collectDirectDependencies,
-    checkMultipleVersions,
-    checkUxfDependencies,
-};

package/src/uxf-dependencies-check/lock-parsers.d.ts

@@ -0,0 +1,2 @@
+import type { LockData, PackageManager } from "./types";
+export declare function parseLockFile(pm: PackageManager, cwd?: string): Promise<LockData>;

package/src/uxf-dependencies-check/lock-parsers.js

@@ -0,0 +1,204 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseLockFile = parseLockFile;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+/**
+ * Extract package name from a yarn.lock key like "@uxf/button@^1.0.0"
+ * Works for both Classic (v1) and Berry (v2+) key formats.
+ */
+function extractPackageNameFromYarnKey(key) {
+    var _a;
+    const match = key.match(/^(@[^/]+\/[^@]+|[^@]+)@/);
+    return match ? ((_a = match.at(1)) !== null && _a !== void 0 ? _a : null) : null;
+}
+/**
+ * Extract package name from a node_modules path like "node_modules/@uxf/button"
+ */
+function extractPackageNameFromPath(modulePath) {
+    var _a;
+    const match = modulePath.match(/node_modules\/(@[^/]+\/[^/]+|[^/]+)$/);
+    return match ? ((_a = match.at(1)) !== null && _a !== void 0 ? _a : null) : null;
+}
+function addToResult(result, name, version) {
+    const existing = result.get(name);
+    if (existing) {
+        existing.add(version);
+    }
+    else {
+        result.set(name, new Set([version]));
+    }
+}
+async function parseYarnLock(cwd) {
+    const YAML = await Promise.resolve().then(() => __importStar(require("yaml")));
+    const content = fs_1.default.readFileSync(path_1.default.resolve(cwd, "yarn.lock"), "utf8");
+    const parsed = YAML.parse(content);
+    const result = new Map();
+    for (const [key, entry] of Object.entries(parsed)) {
+        if (key === "__metadata") {
+            continue;
+        }
+        const entryObj = entry;
+        const name = extractPackageNameFromYarnKey(key);
+        const version = entryObj.version;
+        // Berry also has "resolution" field like "@uxf/core@npm:1.0.0" — extract version from it as fallback
+        const resolution = typeof entryObj.resolution === "string" ? entryObj.resolution : null;
+        if (!name) {
+            continue;
+        }
+        if (typeof version === "string") {
+            addToResult(result, name, version);
+        }
+        else if (resolution) {
+            // Berry resolution format: "package@npm:version" or "package@version"
+            const atIdx = resolution.lastIndexOf("@");
+            if (atIdx > 0) {
+                const resVersion = resolution.slice(atIdx + 1).replace(/^npm:/, "");
+                if (resVersion) {
+                    addToResult(result, name, resVersion);
+                }
+            }
+        }
+    }
+    return result;
+}
+async function parsePackageLockJson(cwd) {
+    var _a;
+    const content = fs_1.default.readFileSync(path_1.default.resolve(cwd, "package-lock.json"), "utf8");
+    const parsed = JSON.parse(content);
+    const result = new Map();
+    // package-lock.json v3 uses "packages" with node_modules paths as keys
+    const packages = (_a = parsed.packages) !== null && _a !== void 0 ? _a : {};
+    for (const [pkgPath, entry] of Object.entries(packages)) {
+        if (!pkgPath || pkgPath === "") {
+            continue;
+        }
+        const name = extractPackageNameFromPath(pkgPath);
+        const version = entry.version;
+        if (!name || typeof version !== "string") {
+            continue;
+        }
+        addToResult(result, name, version);
+    }
+    return result;
+}
+async function parsePnpmLock(cwd) {
+    var _a, _b, _c;
+    const YAML = await Promise.resolve().then(() => __importStar(require("yaml")));
+    const content = fs_1.default.readFileSync(path_1.default.resolve(cwd, "pnpm-lock.yaml"), "utf8");
+    const parsed = YAML.parse(content);
+    const result = new Map();
+    // pnpm v9+ uses "snapshots" for resolved versions, older versions use "packages"
+    const lockfileVersion = String((_a = parsed.lockfileVersion) !== null && _a !== void 0 ? _a : "");
+    const isV9Plus = parseFloat(lockfileVersion) >= 9;
+    const packages = isV9Plus ? ((_b = parsed.snapshots) !== null && _b !== void 0 ? _b : {}) : ((_c = parsed.packages) !== null && _c !== void 0 ? _c : {});
+    for (const key of Object.keys(packages)) {
+        // Handle formats: "/@scope/name@version", "/name@version", "@scope/name@version", "name@version"
+        const cleaned = key.startsWith("/") ? key.slice(1) : key;
+        const atIdx = cleaned.startsWith("@") ? cleaned.indexOf("@", 1) : cleaned.indexOf("@");
+        if (atIdx === -1) {
+            continue;
+        }
+        const name = cleaned.slice(0, atIdx);
+        const version = cleaned
+            .slice(atIdx + 1)
+            .split("(")
+            .at(0); // strip peerDep suffixes like "(react@18.0.0)"
+        if (!name || !version) {
+            continue;
+        }
+        addToResult(result, name, version);
+    }
+    return result;
+}
+/**
+ * Strip JSONC comments (// line comments) from bun.lock content.
+ * bun.lock is a JSONC-like text format, not valid JSON.
+ */
+function stripJsoncComments(content) {
+    return content.replace(/^\s*\/\/.*$/gm, "");
+}
+async function parseBunLock(cwd) {
+    var _a;
+    const content = fs_1.default.readFileSync(path_1.default.resolve(cwd, "bun.lock"), "utf8");
+    const parsed = JSON.parse(stripJsoncComments(content));
+    const result = new Map();
+    // bun.lock "packages" is a flat object: key is an ident like "@uxf/button",
+    // value is a tuple where the first element is "name@version" or just "version"
+    const packages = (_a = parsed.packages) !== null && _a !== void 0 ? _a : {};
+    for (const [key, value] of Object.entries(packages)) {
+        if (!key || key === "") {
+            continue;
+        }
+        const tuple = value;
+        if (!Array.isArray(tuple) || tuple.length === 0) {
+            continue;
+        }
+        const raw = String(tuple.at(0));
+        // The first element is typically "name@version" or just "version"
+        // The key itself is the package identifier
+        let name;
+        let version;
+        // If the raw value contains @, extract version after last @
+        const lastAt = raw.lastIndexOf("@");
+        if (lastAt > 0) {
+            name = raw.slice(0, lastAt);
+            version = raw.slice(lastAt + 1);
+        }
+        else {
+            // raw is just a version, key is the name
+            name = key;
+            version = raw;
+        }
+        if (!name || !version) {
+            continue;
+        }
+        addToResult(result, name, version);
+    }
+    return result;
+}
+const PARSERS = {
+    yarn: parseYarnLock,
+    npm: parsePackageLockJson,
+    pnpm: parsePnpmLock,
+    bun: parseBunLock,
+};
+async function parseLockFile(pm, cwd = process.cwd()) {
+    return PARSERS[pm](cwd);
+}

package/src/uxf-dependencies-check/peer-deps.d.ts

@@ -0,0 +1,10 @@
+import type { DepInfo, MismatchInfo, PackageJson, PackageManager } from "./types";
+export declare function findInstalledUxfPackages(projectPkg: PackageJson): string[];
+export declare function collectRequiredPeerDeps(uxfPackages: string[], nodeModulesPath: string, projectPkg: PackageJson): Map<string, DepInfo>;
+export declare function findMissingOrMismatchedDeps(requiredPeerDeps: Map<string, DepInfo>, projectPkg: PackageJson): {
+    missing: Map<string, DepInfo>;
+    mismatched: Map<string, MismatchInfo>;
+};
+export declare function printPeerDepsReport(missing: Map<string, DepInfo>, mismatched: Map<string, MismatchInfo>): void;
+export declare function printSuggestedCommands(missing: Map<string, DepInfo>, mismatched: Map<string, MismatchInfo>, pm: PackageManager): void;
+export declare function installDeps(missing: Map<string, DepInfo>, mismatched: Map<string, MismatchInfo>, pm: PackageManager): void;

package/src/uxf-dependencies-check/peer-deps.js

@@ -0,0 +1,168 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findInstalledUxfPackages = findInstalledUxfPackages;
+exports.collectRequiredPeerDeps = collectRequiredPeerDeps;
+exports.findMissingOrMismatchedDeps = findMissingOrMismatchedDeps;
+exports.printPeerDepsReport = printPeerDepsReport;
+exports.printSuggestedCommands = printSuggestedCommands;
+exports.installDeps = installDeps;
+const child_process_1 = require("child_process");
+const path_1 = __importDefault(require("path"));
+const detect_package_manager_1 = require("./detect-package-manager");
+const types_1 = require("./types");
+/** Packages that consumers always install themselves — skip these in suggestions */
+const CONSUMER_PROVIDED = new Set(["react", "react-dom", "next"]);
+function findInstalledUxfPackages(projectPkg) {
+    const deps = { ...projectPkg.dependencies, ...projectPkg.devDependencies };
+    return Object.keys(deps).filter((name) => name.startsWith("@uxf/"));
+}
+function collectRequiredPeerDeps(uxfPackages, nodeModulesPath, projectPkg) {
+    var _a;
+    const prodDeps = new Set(Object.keys((_a = projectPkg.dependencies) !== null && _a !== void 0 ? _a : {}));
+    const peerDeps = new Map();
+    for (const uxfPkg of uxfPackages) {
+        const pkgJsonPath = path_1.default.join(nodeModulesPath, uxfPkg, "package.json");
+        const pkgJson = (0, types_1.readPackageJson)(pkgJsonPath);
+        if (!(pkgJson === null || pkgJson === void 0 ? void 0 : pkgJson.peerDependencies)) {
+            continue;
+        }
+        const isRequirerDev = !prodDeps.has(uxfPkg);
+        for (const [depName, depVersion] of Object.entries(pkgJson.peerDependencies)) {
+            if (!depVersion || depName.startsWith("@uxf/") || CONSUMER_PROVIDED.has(depName)) {
+                continue;
+            }
+            const existing = peerDeps.get(depName);
+            if (existing) {
+                existing.requiredBy.push(uxfPkg);
+                // If any requirer is a prod dependency, the peer dep should be prod too
+                if (!isRequirerDev) {
+                    existing.isDev = false;
+                }
+            }
+            else {
+                peerDeps.set(depName, { version: depVersion, requiredBy: [uxfPkg], isDev: isRequirerDev });
+            }
+        }
+    }
+    return peerDeps;
+}
+function findMissingOrMismatchedDeps(requiredPeerDeps, projectPkg) {
+    const allProjectDeps = { ...projectPkg.dependencies, ...projectPkg.devDependencies };
+    const missing = new Map();
+    const mismatched = new Map();
+    for (const [depName, { version, requiredBy, isDev }] of requiredPeerDeps) {
+        const installedVersion = allProjectDeps[depName];
+        if (!installedVersion) {
+            missing.set(depName, { version, requiredBy, isDev });
+        }
+        else if (installedVersion !== version) {
+            mismatched.set(depName, { expected: version, actual: installedVersion, requiredBy, isDev });
+        }
+    }
+    return { missing, mismatched };
+}
+function printPeerDepsReport(missing, mismatched) {
+    if (missing.size > 0) {
+        console.log("Missing peer dependencies:"); // eslint-disable-line no-console
+        for (const [name, { version, requiredBy, isDev }] of missing) {
+            const devTag = isDev ? " [dev]" : "";
+            console.log(`  ${name}@${version}${devTag} (required by ${requiredBy.join(", ")})`); // eslint-disable-line no-console
+        }
+        console.log(); // eslint-disable-line no-console
+    }
+    if (mismatched.size > 0) {
+        console.log("Version mismatches:"); // eslint-disable-line no-console
+        for (const [name, { expected, actual, requiredBy, isDev }] of mismatched) {
+            const devTag = isDev ? " [dev]" : "";
+            // eslint-disable-next-line no-console
+            console.log(`  ${name}: installed ${actual}, expected ${expected}${devTag} (required by ${requiredBy.join(", ")})`);
+        }
+        console.log(); // eslint-disable-line no-console
+    }
+}
+function formatInstallArgs(packages) {
+    return Array.from(packages.entries()).map(([name, version]) => `${name}@${version}`);
+}
+function splitDepsByDevFlag(deps) {
+    const prod = new Map();
+    const dev = new Map();
+    for (const [name, info] of deps) {
+        if (info.isDev) {
+            dev.set(name, info.version);
+        }
+        else {
+            prod.set(name, info.version);
+        }
+    }
+    return { prod, dev };
+}
+function splitMismatchesByDevFlag(deps) {
+    const prod = new Map();
+    const dev = new Map();
+    for (const [name, info] of deps) {
+        if (info.isDev) {
+            dev.set(name, info.expected);
+        }
+        else {
+            prod.set(name, info.expected);
+        }
+    }
+    return { prod, dev };
+}
+function printSuggestedCommands(missing, mismatched, pm) {
+    const { cmd, addArg } = (0, detect_package_manager_1.getInstallCommand)(pm);
+    if (missing.size > 0) {
+        const { prod, dev } = splitDepsByDevFlag(missing);
+        if (prod.size > 0) {
+            const pkgs = formatInstallArgs(prod).join(" ");
+            console.log(`To install missing dependencies, run:\n  ${cmd} ${addArg} ${pkgs}\n`); // eslint-disable-line no-console
+        }
+        if (dev.size > 0) {
+            const pkgs = formatInstallArgs(dev).join(" ");
+            console.log(`To install missing dev dependencies, run:\n  ${cmd} ${addArg} -D ${pkgs}\n`); // eslint-disable-line no-console
+        }
+    }
+    if (mismatched.size > 0) {
+        const { prod, dev } = splitMismatchesByDevFlag(mismatched);
+        if (prod.size > 0) {
+            const pkgs = formatInstallArgs(prod).join(" ");
+            console.log(`To fix version mismatches, run:\n  ${cmd} ${addArg} ${pkgs}\n`); // eslint-disable-line no-console
+        }
+        if (dev.size > 0) {
+            const pkgs = formatInstallArgs(dev).join(" ");
+            console.log(`To fix dev version mismatches, run:\n  ${cmd} ${addArg} -D ${pkgs}\n`); // eslint-disable-line no-console
+        }
+    }
+}
+function installDeps(missing, mismatched, pm) {
+    const { cmd, addArg } = (0, detect_package_manager_1.getInstallCommand)(pm);
+    if (missing.size > 0) {
+        const { prod, dev } = splitDepsByDevFlag(missing);
+        if (prod.size > 0) {
+            const pkgs = formatInstallArgs(prod);
+            console.log("Installing missing dependencies..."); // eslint-disable-line no-console
+            (0, child_process_1.execFileSync)(cmd, [addArg, ...pkgs], { stdio: "inherit", cwd: process.cwd() });
+        }
+        if (dev.size > 0) {
+            const pkgs = formatInstallArgs(dev);
+            console.log("Installing missing dev dependencies..."); // eslint-disable-line no-console
+            (0, child_process_1.execFileSync)(cmd, [addArg, "-D", ...pkgs], { stdio: "inherit", cwd: process.cwd() });
+        }
+    }
+    if (mismatched.size > 0) {
+        const { prod, dev } = splitMismatchesByDevFlag(mismatched);
+        if (prod.size > 0) {
+            const pkgs = formatInstallArgs(prod);
+            console.log("Fixing version mismatches..."); // eslint-disable-line no-console
+            (0, child_process_1.execFileSync)(cmd, [addArg, ...pkgs], { stdio: "inherit", cwd: process.cwd() });
+        }
+        if (dev.size > 0) {
+            const pkgs = formatInstallArgs(dev);
+            console.log("Fixing dev version mismatches..."); // eslint-disable-line no-console
+            (0, child_process_1.execFileSync)(cmd, [addArg, "-D", ...pkgs], { stdio: "inherit", cwd: process.cwd() });
+        }
+    }
+}

package/src/uxf-dependencies-check/types.d.ts

@@ -0,0 +1,27 @@
+export type PackageManager = "yarn" | "npm" | "pnpm" | "bun";
+export interface PackageJson {
+    dependencies?: Partial<Record<string, string>>;
+    devDependencies?: Partial<Record<string, string>>;
+    peerDependencies?: Partial<Record<string, string>>;
+}
+export interface DepInfo {
+    isDev: boolean;
+    requiredBy: string[];
+    version: string;
+}
+export interface MismatchInfo {
+    actual: string;
+    expected: string;
+    isDev: boolean;
+    requiredBy: string[];
+}
+export interface Conflict {
+    name: string;
+    versions: string[];
+}
+/**
+ * Normalized lock data: maps package name → set of resolved versions.
+ * Every lock file parser must return this shape.
+ */
+export type LockData = Map<string, Set<string>>;
+export declare function readPackageJson(filePath: string): PackageJson | null;

package/src/uxf-dependencies-check/types.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readPackageJson = readPackageJson;
+const fs_1 = __importDefault(require("fs"));
+function readPackageJson(filePath) {
+    try {
+        return JSON.parse(fs_1.default.readFileSync(filePath, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}

package/src/uxf-dependencies-check/uxf-dependencies-check.test.js

@@ -1,111 +0,0 @@
-const { findUxfPackagesInDependencies, collectDirectDependencies, checkMultipleVersions } = require("./index"); // Adjust the path if needed
-
-describe("findUxfPackagesInDependencies", () => {
-    const lockData = {
-        "@uxf/button@^1.0.0": {},
-        "@uxf/form@^2.1.0": {},
-        "react@^17.0.0": {},
-        "lodash@^4.17.0": {},
-        "classnames@^2.3.1": {},
-    };
-
-    const packageJson = {
-        dependencies: {
-            "@uxf/button": "^1.0.0",
-            "@uxf/form": "^2.1.0",
-            react: "^17.0.0",
-        },
-    };
-
-    it("returns @uxf/* packages that are in package.json dependencies", () => {
-        const result = findUxfPackagesInDependencies(lockData, packageJson);
-        expect(result).toEqual(["@uxf/button@^1.0.0", "@uxf/form@^2.1.0"]);
-    });
-});
-
-describe("collectDirectDependencies", () => {
-    const lockData = {
-        "@uxf/button@^1.0.0": {
-            dependencies: {
-                react: "^17.0.0",
-                lodash: "^4.17.0",
-            },
-        },
-        "@uxf/form@^2.1.0": {
-            dependencies: {
-                react: "^17.0.1", // different version range
-                classnames: "^2.3.1",
-            },
-        },
-        "react@^17.0.0": {
-            version: "17.0.2",
-        },
-        "react@^17.0.1": {
-            version: "17.0.1",
-        },
-        "lodash@^4.17.0": {
-            version: "4.17.21",
-        },
-        "classnames@^2.3.1": {
-            version: "2.3.1",
-        },
-    };
-
-    const packageKeys = ["@uxf/button@^1.0.0", "@uxf/form@^2.1.0"];
-
-    it("collects direct dependencies of multiple UXF packages with shared and unique deps", () => {
-        const result = collectDirectDependencies(packageKeys, lockData);
-
-        expect(result).toEqual({
-            react: new Set(["17.0.2", "17.0.1"]),
-            lodash: new Set(["4.17.21"]),
-            classnames: new Set(["2.3.1"]),
-        });
-    });
-
-    it("handles empty dependencies gracefully", () => {
-        const lockData = {
-            "@uxf/empty@1.0.0": {},
-        };
-
-        const result = collectDirectDependencies(["@uxf/empty@1.0.0"], lockData);
-        expect(result).toEqual({});
-    });
-});
-
-describe("checkMultipleVersions", () => {
-    it("returns empty array when all packages have a single version", () => {
-        const deps = {
-            react: new Set(["17.0.2"]),
-            lodash: new Set(["4.17.21"]),
-        };
-        expect(checkMultipleVersions(deps)).toEqual([]);
-    });
-
-    it("returns conflicts when a package has multiple versions", () => {
-        const deps = {
-            react: new Set(["17.0.2", "18.0.0"]),
-            lodash: new Set(["4.17.21"]),
-        };
-        const conflicts = checkMultipleVersions(deps);
-        expect(conflicts).toHaveLength(1);
-        expect(conflicts[0].name).toBe("react");
-        expect(conflicts[0].versions).toEqual(expect.arrayContaining(["17.0.2", "18.0.0"]));
-    });
-
-    it("excludes packages that are in the excludedPackages set", () => {
-        const deps = {
-            react: new Set(["17.0.2", "18.0.0"]),
-        };
-        const result = checkMultipleVersions(deps, new Set(["react"]));
-        expect(result).toEqual([]);
-    });
-
-    it("returns multiple conflicts when several packages have version mismatches", () => {
-        const deps = {
-            react: new Set(["17.0.2", "18.0.0"]),
-            lodash: new Set(["4.17.0", "4.17.21"]),
-        };
-        expect(checkMultipleVersions(deps)).toHaveLength(2);
-    });
-});