@uxf/scripts 11.109.0 → 11.109.1

package/README.md

@@ -72,8 +72,6 @@ All-in-one dependency health check for projects using `@uxf/*` packages. Runs tw
 
 Supports **yarn**, **npm**, **pnpm**, and **bun**. The package manager is auto-detected from the lock file.
 
-Requires `tsx` or another tool to execute typescript (typically already available in your project's `devDependencies`).
-
 ```bash
 Usage:
   uxf-dependencies-check [options]
@@ -91,16 +89,16 @@ Build-time dependencies (`yargs`, `fast-glob`) are automatically ignored in the
 
 ```bash
 # Run both checks (exits with code 1 if issues found)
-npx tsx -dependencies-check
+npx uxf-dependencies-check
 
 # Auto-install missing peer deps
-npx tsx uxf-dependencies-check --fix
+npx uxf-dependencies-check --fix
 
 # Preview what would be installed
-npx tsx uxf-dependencies-check --dry-run
+npx uxf-dependencies-check --dry-run
 
 # Ignore specific packages in conflict check
-npx tsx uxf-dependencies-check --exclude lodash dayjs
+npx uxf-dependencies-check --exclude lodash dayjs
 ```
 
 ### What it checks

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

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

package/bin/uxf-dependencies-check.js

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+"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((e) => {
+    console.error(e); // eslint-disable-line no-console
+    process.exitCode = 1;
+});

package/package.json

@@ -1,12 +1,12 @@
 {
     "name": "@uxf/scripts",
-    "version": "11.109.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-dependencies-check": "bin/uxf-dependencies-check.ts",
+        "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",
@@ -16,7 +16,7 @@
         "uxf-unused": "bin/uxf-unused.js"
     },
     "scripts": {
-        "build": "",
+        "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",
         "typecheck": "tsc --noEmit -p tsconfig.json"

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

@@ -0,0 +1,78 @@
+"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 argv = await cli.parse();
+        if (isHelp) {
+            return 0;
+        }
+        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

@@ -0,0 +1,79 @@
+"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;
+    }
+}
+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;
+        }
+        else {
+            console.log("No dependency version conflicts found.\n"); // eslint-disable-line no-console
+        }
+    }
+    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;
+}

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/bin/uxf-dependencies-check.ts

@@ -1,11 +0,0 @@
-#!/usr/bin/env tsx
-import cli from "../src/uxf-dependencies-check/cli";
-
-cli()
-    .then((exitCode) => {
-        process.exitCode = exitCode;
-    })
-    .catch((e) => {
-        console.error(e); // eslint-disable-line no-console
-        process.exitCode = 1;
-    });