@archon-research/uikit-cli 0.3.0-rohit-improve-cli.2 → 0.3.1

package/dist/package-discovery.js

@@ -0,0 +1,168 @@
+import path from 'node:path';
+/**
+ * Package and workspace discovery for monorepos
+ */
+export class PackageDiscovery {
+    fs;
+    constructor(fs) {
+        this.fs = fs;
+    }
+    /**
+     * Find consumer workspace root by walking up looking for package.json with workspaces
+     */
+    findConsumerRoot(startDir) {
+        let current = startDir;
+        while (true) {
+            const pkgPath = path.join(current, 'package.json');
+            if (this.fs.exists(pkgPath)) {
+                try {
+                    const pkg = this.fs.readJson(pkgPath);
+                    if (pkg.workspaces) {
+                        return current;
+                    }
+                }
+                catch {
+                    // Continue searching if parse fails
+                }
+            }
+            const parent = path.dirname(current);
+            if (parent === current) {
+                throw new Error(`Could not find consumer workspace root (no package.json with workspaces field)\n` +
+                    `Searched from: ${startDir}\n` +
+                    `Suggestion: Run from inside a workspace-based monorepo`);
+            }
+            current = parent;
+        }
+    }
+    /**
+     * 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 === '@archon-research/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 pkgPath = path.join(dir, 'package.json');
+                if (!this.fs.exists(pkgPath)) {
+                    if (process.env.UIKIT_DEBUG) {
+                        console.log('[DEBUG loadWorkspaces] Skipping (no package.json):', dir);
+                    }
+                    continue;
+                }
+                try {
+                    const pkg = this.fs.readJson(pkgPath);
+                    workspaces.push({
+                        name: pkg.name ?? null,
+                        location: path.relative(rootDir, dir),
+                        path: dir,
+                        dependencies: pkg.dependencies ?? {},
+                    });
+                }
+                catch {
+                    // Skip invalid package.json
+                }
+            }
+        }
+        return workspaces.filter((ws) => Boolean(ws.name));
+    }
+    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/types.js

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

package/package.json

@@ -1,16 +1,17 @@
 {
   "name": "@archon-research/uikit-cli",
-  "version": "0.3.0-rohit-improve-cli.2",
+  "version": "0.3.1",
   "type": "module",
   "description": "CLI for managing local uikit package linking in consumer workspaces",
   "scripts": {
-    "build": "tsc -p tsconfig.json",
+    "build": "tsgo -b && npm run wrapper",
+    "wrapper": "./scripts/create-wrapper.sh",
     "clean": "rm -rf dist",
     "type:check": "tsgo -p tsconfig.json --noEmit",
     "prepare": "npm run build"
   },
   "bin": {
-    "uikit-cli": "./dist/cli.js"
+    "uikit-cli": "./dist/cli.sh"
   },
   "publishConfig": {
     "access": "public"