@r0hitsharma/uikit-cli 0.12.0-rohit-fork-ci.1

package/dist/package-discovery.js

@@ -0,0 +1,218 @@
+import path from 'node:path';
+/**
+ * Package and workspace discovery for monorepos
+ */
+export class PackageDiscovery {
+    fs;
+    constructor(fs) {
+        this.fs = fs;
+    }
+    /**
+     * Find the consumer root by walking up from `startDir`. Prefers a monorepo
+     * root (a `package.json` with a `workspaces` field); if none exists anywhere
+     * up the tree, falls back to the nearest single package that depends on an
+     * `@r0hitsharma/*` package — so link/unlink work for a plain
+     * non-workspaces consumer, not just a monorepo.
+     */
+    findConsumerRoot(startDir) {
+        let current = startDir;
+        let singlePackageRoot = null;
+        while (true) {
+            const pkgPath = path.join(current, 'package.json');
+            if (this.fs.exists(pkgPath)) {
+                try {
+                    const pkg = this.fs.readJson(pkgPath);
+                    // A workspaces root always wins (unchanged monorepo behavior).
+                    if (pkg.workspaces) {
+                        return current;
+                    }
+                    // Otherwise remember the nearest package that consumes uikit, as a
+                    // fallback if no workspaces root turns up above it.
+                    if (singlePackageRoot === null && this.dependsOnUikit(pkg)) {
+                        singlePackageRoot = current;
+                    }
+                }
+                catch {
+                    // Continue searching if parse fails
+                }
+            }
+            const parent = path.dirname(current);
+            if (parent === current) {
+                if (singlePackageRoot !== null) {
+                    return singlePackageRoot;
+                }
+                throw new Error(`Could not find a consumer root.\n` +
+                    `Searched from: ${startDir}\n` +
+                    `Found no package.json with a "workspaces" field, and none depending ` +
+                    `on an @r0hitsharma/* package.\n` +
+                    `Run from inside your consumer project (a monorepo root or a single ` +
+                    `package that installs uikit).`);
+            }
+            current = parent;
+        }
+    }
+    dependsOnUikit(pkg) {
+        const fields = [
+            pkg.dependencies,
+            pkg.devDependencies,
+            pkg.peerDependencies,
+            pkg.optionalDependencies,
+        ];
+        return fields.some((field) => field &&
+            Object.keys(field).some((name) => name.startsWith('@r0hitsharma/')));
+    }
+    /**
+     * Find uikit root by walking up looking for valid uikit monorepo structure
+     */
+    findUIKitRoot(startDir) {
+        let current = startDir;
+        while (true) {
+            if (this.isValidUIKitRoot(current)) {
+                return current;
+            }
+            const parent = path.dirname(current);
+            if (parent === current) {
+                return null;
+            }
+            current = parent;
+        }
+    }
+    /**
+     * Find uikit root from consumer by looking for sibling "uikit" directory
+     */
+    findUIKitRootFromConsumer(consumerRoot) {
+        const candidateNames = ['uikit'];
+        let current = consumerRoot;
+        while (true) {
+            for (const candidateName of candidateNames) {
+                const candidate = path.join(current, candidateName);
+                if (this.isValidUIKitRoot(candidate)) {
+                    return candidate;
+                }
+            }
+            const parent = path.dirname(current);
+            if (parent === current) {
+                return null;
+            }
+            current = parent;
+        }
+    }
+    /**
+     * Check if directory is a valid uikit root (has design-system package)
+     */
+    isValidUIKitRoot(rootDir) {
+        if (!this.fs.exists(rootDir)) {
+            return false;
+        }
+        try {
+            const workspaces = this.loadWorkspaces(rootDir);
+            return workspaces.some((ws) => ws.name === '@r0hitsharma/design-system');
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Load all workspaces from a monorepo root
+     */
+    loadWorkspaces(rootDir) {
+        const patterns = this.getWorkspacePatterns(rootDir);
+        const workspaces = [];
+        if (process.env.UIKIT_DEBUG) {
+            console.log('[DEBUG loadWorkspaces] rootDir:', rootDir, 'patterns:', patterns);
+        }
+        for (const pattern of patterns) {
+            const resolved = this.resolveWorkspacePattern(rootDir, pattern);
+            if (process.env.UIKIT_DEBUG) {
+                console.log('[DEBUG loadWorkspaces] pattern:', pattern, 'resolved to:', resolved);
+            }
+            for (const dir of resolved) {
+                const ws = this.readPackageAsWorkspace(rootDir, dir);
+                if (ws) {
+                    workspaces.push(ws);
+                }
+                else if (process.env.UIKIT_DEBUG) {
+                    console.log('[DEBUG loadWorkspaces] Skipping (no/invalid package.json):', dir);
+                }
+            }
+        }
+        return workspaces.filter((ws) => Boolean(ws.name));
+    }
+    /**
+     * Load consumer workspaces, falling back to the root package itself when the
+     * consumer is a single, non-workspaces package (`location: ''`). This is what
+     * lets link/unlink target a plain consumer, not only a monorepo.
+     */
+    loadConsumerWorkspaces(rootDir) {
+        const workspaces = this.loadWorkspaces(rootDir);
+        if (workspaces.length > 0) {
+            return workspaces;
+        }
+        const root = this.readPackageAsWorkspace(rootDir, rootDir);
+        return root && root.name ? [root] : [];
+    }
+    /** Read a directory's package.json into a WorkspaceInfo, or null if absent/invalid. */
+    readPackageAsWorkspace(rootDir, dir) {
+        const pkgPath = path.join(dir, 'package.json');
+        if (!this.fs.exists(pkgPath)) {
+            return null;
+        }
+        try {
+            const pkg = this.fs.readJson(pkgPath);
+            return {
+                name: pkg.name ?? null,
+                location: path.relative(rootDir, dir),
+                path: dir,
+                dependencies: pkg.dependencies ?? {},
+                devDependencies: pkg.devDependencies ?? {},
+                peerDependencies: pkg.peerDependencies ?? {},
+                optionalDependencies: pkg.optionalDependencies ?? {},
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    getWorkspacePatterns(rootDir) {
+        const pkgPath = path.join(rootDir, 'package.json');
+        if (!this.fs.exists(pkgPath)) {
+            return [];
+        }
+        try {
+            const pkg = this.fs.readJson(pkgPath);
+            if (Array.isArray(pkg.workspaces)) {
+                return pkg.workspaces;
+            }
+            if (pkg.workspaces && Array.isArray(pkg.workspaces.packages)) {
+                return pkg.workspaces.packages;
+            }
+        }
+        catch {
+            // Return empty if parse fails
+        }
+        return [];
+    }
+    resolveWorkspacePattern(rootDir, pattern) {
+        // Handle simple glob patterns like "packages/*"
+        if (pattern.includes('*')) {
+            // Only support "dir/*" pattern for now
+            if (pattern.endsWith('/*')) {
+                const baseDir = pattern.slice(0, -2);
+                const basePath = path.join(rootDir, baseDir);
+                if (!this.fs.exists(basePath) || !this.fs.isDirectory(basePath)) {
+                    return [];
+                }
+                const entries = this.fs.readDir(basePath);
+                return entries
+                    .filter((entry) => !entry.startsWith('.') && entry !== 'node_modules')
+                    .map((entry) => path.join(basePath, entry))
+                    .filter((p) => this.fs.isDirectory(p));
+            }
+            // Unsupported pattern
+            return [];
+        }
+        // Static pattern, return as-is if it's a directory
+        const fullPath = path.join(rootDir, pattern);
+        return this.fs.isDirectory(fullPath) ? [fullPath] : [];
+    }
+}

package/dist/shell-utils.js

@@ -0,0 +1,9 @@
+/**
+ * Shell argument escaping utility
+ */
+export function shellEscape(arg) {
+    if (/^[a-zA-Z0-9_\-./:=]+$/.test(arg)) {
+        return arg;
+    }
+    return `'${arg.replace(/'/g, "'\\''")}'`;
+}

package/dist/tool-binaries.js

@@ -0,0 +1,16 @@
+import { createRequire } from 'node:module';
+import path from 'node:path';
+const requireFromCli = createRequire(import.meta.url);
+/**
+ * Resolve a CLI binary from uikit-cli dependencies so consumers
+ * don't need tool packages installed in their own workspace.
+ */
+export function resolveCliBinary(packageName, binaryPath) {
+    try {
+        const packageJsonPath = requireFromCli.resolve(`${packageName}/package.json`);
+        return path.join(path.dirname(packageJsonPath), binaryPath);
+    }
+    catch {
+        throw new Error(`Could not resolve ${packageName} binary from @r0hitsharma/uikit-cli dependencies.`);
+    }
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@r0hitsharma/uikit-cli",
+  "type": "module",
+  "description": "CLI for managing local uikit package linking in consumer workspaces",
+  "scripts": {
+    "build": "tsc -b && npm run wrapper",
+    "wrapper": "./scripts/create-wrapper.sh",
+    "clean": "rm -rf dist",
+    "type:check": "tsc -p tsconfig.json --noEmit",
+    "lint": "oxlint -c oxlint.config.ts --max-warnings=0 src",
+    "lint:fix": "oxlint -c oxlint.config.ts --fix src",
+    "format": "oxfmt -c oxfmt.config.ts --write src",
+    "format:check": "oxfmt -c oxfmt.config.ts --check src",
+    "test": "vitest run",
+    "prepare": "npm run build"
+  },
+  "bin": {
+    "uikit-cli": "./dist/cli.sh"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "oxfmt": "0.67.0",
+    "oxlint": "1.82.0"
+  },
+  "devDependencies": {
+    "@r0hitsharma/oxfmt-config": "*",
+    "@r0hitsharma/tsconfig": "*",
+    "@types/node": "24.13.3",
+    "vitest": "^4.1.9"
+  },
+  "files": [
+    "dist"
+  ],
+  "version": "0.12.0-rohit-fork-ci.1",
+  "repository": {
+    "url": "https://github.com/r0hitsharma/uikit"
+  }
+}