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

package/dist/commands/link.js

@@ -0,0 +1,252 @@
+import path from 'node:path';
+/**
+ * Link command - links uikit packages into consumer workspaces
+ */
+export class LinkCommand {
+    discovery;
+    executor;
+    validator;
+    fs;
+    logger;
+    constructor(discovery, executor, validator, fs, logger) {
+        this.discovery = discovery;
+        this.executor = executor;
+        this.validator = validator;
+        this.fs = fs;
+        this.logger = logger;
+    }
+    execute(consumerRoot, uikitRoot, verify = false) {
+        this.logger.debug('Starting link command', { consumerRoot, uikitRoot });
+        const uikitWorkspaces = this.discovery.loadWorkspaces(uikitRoot);
+        const consumerWorkspaces = this.discovery.loadConsumerWorkspaces(consumerRoot);
+        const uikitPackages = uikitWorkspaces.filter((ws) => String(ws.name ?? '').startsWith('@r0hitsharma/'));
+        const dirByName = new Map(uikitPackages.map((pkg) => [pkg.name ?? '', pkg.path]));
+        dirByName.delete('');
+        const supportedNames = new Set(dirByName.keys());
+        const neededByWorkspace = this.collectWorkspaceRequirements(consumerWorkspaces, supportedNames);
+        if (neededByWorkspace.size === 0) {
+            this.logger.info('No local uikit packages referenced by consumer workspaces.');
+            return;
+        }
+        // Collect all packages that were actually linked
+        const linkedNames = new Set();
+        for (const names of neededByWorkspace.values()) {
+            for (const name of names) {
+                linkedNames.add(name);
+            }
+        }
+        this.linkPackages(consumerRoot, uikitRoot, neededByWorkspace, dirByName);
+        if (verify) {
+            // Only verify packages that were actually linked
+            const linkedDirByName = new Map();
+            for (const name of linkedNames) {
+                const packageDir = dirByName.get(name);
+                if (packageDir) {
+                    linkedDirByName.set(name, packageDir);
+                }
+            }
+            this.runVerification(consumerRoot, linkedDirByName);
+        }
+    }
+    collectWorkspaceRequirements(workspaces, supportedNames) {
+        const neededByWorkspace = new Map();
+        for (const ws of workspaces) {
+            const fields = [
+                ws.dependencies,
+                ws.devDependencies,
+                ws.peerDependencies,
+                ws.optionalDependencies,
+            ];
+            const needed = new Set();
+            for (const depField of fields) {
+                for (const depName of Object.keys(depField)) {
+                    if (supportedNames.has(depName)) {
+                        needed.add(depName);
+                    }
+                }
+            }
+            if (needed.size > 0) {
+                neededByWorkspace.set(ws.location, [...needed]);
+            }
+        }
+        return neededByWorkspace;
+    }
+    linkPackages(consumerRoot, uikitRoot, neededByWorkspace, dirByName) {
+        const allNames = new Set();
+        for (const names of neededByWorkspace.values()) {
+            for (const name of names) {
+                allNames.add(name);
+            }
+        }
+        // Track link steps that failed so we never report a partial link as success.
+        const failures = [];
+        // Link at root level
+        const rootPackageArgs = [...allNames].map((name) => `"${name}"`).join(' ');
+        if (rootPackageArgs) {
+            this.logger.info('Linking packages at root level...');
+            const result = this.executor.exec(`npm link ${rootPackageArgs} --package-lock=false --save=false`, {
+                cwd: consumerRoot,
+            });
+            if (!result.success) {
+                failures.push(`root: ${[...allNames].join(', ')}`);
+            }
+        }
+        // Ensure symlinks point to correct targets
+        for (const name of allNames) {
+            const target = dirByName.get(name);
+            if (target) {
+                this.ensureLinkedPath(consumerRoot, name, target);
+            }
+        }
+        // Link per workspace
+        for (const [workspace, names] of neededByWorkspace.entries()) {
+            const packageArgs = names.map((name) => `"${name}"`).join(' ');
+            if (!packageArgs)
+                continue;
+            // A single-package consumer surfaces as the root itself (location '').
+            // The root-level `npm link` above already linked it; there is no separate
+            // workspace node_modules to fix up, and `--workspace ""` is invalid.
+            if (workspace === '' || workspace === '.')
+                continue;
+            this.logger.debug(`Linking packages for workspace: ${workspace}`);
+            const result = this.executor.exec(`npm link ${packageArgs} --workspace "${workspace}" --package-lock=false --save=false`, { cwd: consumerRoot });
+            if (!result.success) {
+                failures.push(`${workspace}: ${names.join(', ')}`);
+            }
+            // Clean up shadow installs and Vite cache
+            for (const name of names) {
+                this.removeWorkspaceShadowInstall(consumerRoot, workspace, name);
+            }
+            this.clearWorkspaceViteCache(consumerRoot, workspace);
+        }
+        // Ensure linked packages can resolve external runtime deps when preserve-symlinks is enabled.
+        // Run this last because workspace linking can mutate root node_modules.
+        this.linkMissingRuntimeDependencies(consumerRoot, uikitRoot, allNames, dirByName);
+        if (failures.length > 0) {
+            this.logger.warn('Some packages did not link — the local link is PARTIAL, and those ' +
+                'names may resolve to a stale registry version instead:');
+            for (const failure of failures) {
+                this.logger.warn(`  ${failure}`);
+            }
+            this.logger.warn('A consumer .npmrc with `min-release-age` can reject a fresh prerelease ' +
+                'with ETARGET; re-run with an override (e.g. --min-release-age=0) or ' +
+                'link those packages manually.');
+            return;
+        }
+        this.logger.info('✓ Linked local uikit packages into consumer workspaces.');
+    }
+    linkMissingRuntimeDependencies(consumerRoot, uikitRoot, linkedNames, dirByName) {
+        const depsToLink = this.collectExternalDependencyClosure(uikitRoot, linkedNames, dirByName);
+        if (depsToLink.size === 0) {
+            return;
+        }
+        for (const depName of depsToLink) {
+            const sourcePath = path.join(uikitRoot, 'node_modules', depName);
+            const consumerPath = path.join(consumerRoot, 'node_modules', depName);
+            if (!this.fs.exists(sourcePath)) {
+                continue;
+            }
+            // Respect existing consumer installations to avoid overriding deliberate versions.
+            if (this.fs.exists(consumerPath)) {
+                continue;
+            }
+            this.fs.createDir(path.dirname(consumerPath));
+            this.fs.createSymlink(sourcePath, consumerPath);
+            this.logger.debug(`Linked runtime dependency ${depName}`);
+        }
+    }
+    collectExternalDependencyClosure(uikitRoot, linkedNames, dirByName) {
+        const result = new Set();
+        const queue = [];
+        for (const linkedName of linkedNames) {
+            const packageDir = dirByName.get(linkedName);
+            if (!packageDir)
+                continue;
+            const packageJsonPath = path.join(packageDir, 'package.json');
+            if (!this.fs.exists(packageJsonPath))
+                continue;
+            const packageJson = this.fs.readJson(packageJsonPath);
+            for (const depName of Object.keys(packageJson.dependencies ?? {})) {
+                if (!depName.startsWith('@r0hitsharma/')) {
+                    queue.push(depName);
+                }
+            }
+        }
+        while (queue.length > 0) {
+            const depName = queue.shift();
+            if (!depName || result.has(depName)) {
+                continue;
+            }
+            const depPackageJsonPath = path.join(uikitRoot, 'node_modules', depName, 'package.json');
+            if (!this.fs.exists(depPackageJsonPath)) {
+                continue;
+            }
+            result.add(depName);
+            const depPackageJson = this.fs.readJson(depPackageJsonPath);
+            for (const nestedDep of Object.keys(depPackageJson.dependencies ?? {})) {
+                if (!nestedDep.startsWith('@r0hitsharma/')) {
+                    queue.push(nestedDep);
+                }
+            }
+        }
+        return result;
+    }
+    ensureLinkedPath(consumerRoot, packageName, expectedTarget) {
+        const packagePath = path.join(consumerRoot, 'node_modules', packageName);
+        try {
+            if (this.fs.isSymlink(packagePath) &&
+                this.fs.realpath(packagePath) === expectedTarget) {
+                return;
+            }
+            this.fs.removeDir(packagePath);
+        }
+        catch {
+            // Path may not exist yet
+        }
+        this.fs.createDir(path.dirname(packagePath));
+        this.fs.createSymlink(expectedTarget, packagePath);
+    }
+    removeWorkspaceShadowInstall(consumerRoot, workspace, packageName) {
+        const packagePath = path.join(consumerRoot, workspace, 'node_modules', packageName);
+        if (!this.fs.exists(packagePath)) {
+            return;
+        }
+        try {
+            if (this.fs.isSymlink(packagePath)) {
+                return;
+            }
+            this.fs.removeDir(packagePath);
+            this.logger.info(`Removed shadow install at ${workspace}/node_modules/${packageName} to preserve local links.`);
+        }
+        catch {
+            // Best effort cleanup
+        }
+    }
+    clearWorkspaceViteCache(consumerRoot, workspace) {
+        const viteCachePath = path.join(consumerRoot, workspace, 'node_modules', '.vite');
+        if (!this.fs.exists(viteCachePath)) {
+            return;
+        }
+        try {
+            this.fs.removeDir(viteCachePath);
+            this.logger.debug(`Cleared Vite cache at ${workspace}/node_modules/.vite`);
+        }
+        catch {
+            // Best effort cleanup
+        }
+    }
+    runVerification(consumerRoot, dirByName) {
+        this.logger.info('\nVerifying link state...');
+        const result = this.validator.validateLinkedPackages(consumerRoot, dirByName);
+        if (result.valid) {
+            this.logger.info('✓ All links valid');
+        }
+        else {
+            this.logger.warn(`Found ${result.issues.length} issue(s):`);
+            for (const issue of result.issues) {
+                this.logger.warn(`  ${issue.type}: ${issue.package}`);
+                this.logger.warn(`    ${issue.details}`);
+            }
+        }
+    }
+}

package/dist/commands/lint.js

@@ -0,0 +1,43 @@
+import { shellEscape } from '../shell-utils.js';
+import { resolveCliBinary } from '../tool-binaries.js';
+/**
+ * Lint command - forwards to oxlint
+ *
+ * Deliberately does *not* inject `-c`, unlike `format`. oxfmt only
+ * auto-discovers the `.json` form of its config, so `format` has to point at
+ * `.oxfmtrc.ts` itself; oxlint resolves `oxlint.config.ts` per target file by
+ * walking up from it, so every package in a multi-target run gets its own
+ * config with no help. Injecting `-c ./oxlint.config.ts` would *replace* that
+ * per-package resolution with whatever config happens to sit in cwd — in the
+ * git-hook shape (cwd at the repo root, targets in several packages) that
+ * silently drops the packages' own rules.
+ */
+export class LintCommand {
+    executor;
+    constructor(executor) {
+        this.executor = executor;
+    }
+    execute(args) {
+        const modifiedArgs = [...args];
+        // oxlint exits 0 on warnings. The shared presets set `correctness` and
+        // `suspicious` to `warn`, so without this every violation they describe is
+        // reported and then ignored. Callers who want warnings to stay advisory can
+        // pass their own `--max-warnings`/`--deny-warnings` and keep it.
+        if (!this.hasWarningLimitFlag(modifiedArgs)) {
+            modifiedArgs.push('--max-warnings=0');
+        }
+        const escapedArgs = modifiedArgs.map((arg) => shellEscape(arg)).join(' ');
+        const oxlintBinary = shellEscape(resolveCliBinary('oxlint', 'bin/oxlint'));
+        return this.executor.exec(`${oxlintBinary} ${escapedArgs}`.trim(), {
+            cwd: process.cwd(),
+        }).success;
+    }
+    // Only the two flags that govern the *exit code* count here. `-W`/`--warn`
+    // looks related but sets a rule's severity, and must not suppress the
+    // default.
+    hasWarningLimitFlag(args) {
+        return args.some((arg) => arg === '--max-warnings' ||
+            arg.startsWith('--max-warnings=') ||
+            arg === '--deny-warnings');
+    }
+}

package/dist/commands/register.js

@@ -0,0 +1,35 @@
+/**
+ * Register command - globally links uikit packages via npm link
+ */
+export class RegisterCommand {
+    discovery;
+    executor;
+    logger;
+    constructor(discovery, executor, logger) {
+        this.discovery = discovery;
+        this.executor = executor;
+        this.logger = logger;
+    }
+    execute(uikitRoot, supportedNames) {
+        this.logger.debug('Starting register command', { uikitRoot });
+        const uikitWorkspaces = this.discovery.loadWorkspaces(uikitRoot);
+        const uikitPackages = uikitWorkspaces.filter((ws) => String(ws.name ?? '').startsWith('@r0hitsharma/'));
+        const packagesToRegister = supportedNames
+            ? uikitPackages.filter((pkg) => supportedNames.has(pkg.name ?? ''))
+            : uikitPackages;
+        this.logger.info(`Registering ${packagesToRegister.length} local uikit packages...`);
+        for (const pkg of packagesToRegister) {
+            if (!pkg.name)
+                continue;
+            this.logger.debug(`Registering ${pkg.name}`, { path: pkg.path });
+            const result = this.executor.exec(`npm link`, { cwd: pkg.path });
+            if (!result.success) {
+                this.logger.error(`Failed to register ${pkg.name}`, {
+                    error: result.stderr,
+                });
+                throw new Error(`Failed to register ${pkg.name}`);
+            }
+        }
+        this.logger.info('✓ All packages registered successfully');
+    }
+}

package/dist/commands/unlink.js

@@ -0,0 +1,68 @@
+/**
+ * Unlink command - simplified version without registry checks
+ */
+export class UnlinkCommand {
+    executor;
+    logger;
+    constructor(executor, logger) {
+        this.executor = executor;
+        this.logger = logger;
+    }
+    execute(consumerRoot, uikitRoot, discovery) {
+        // Load workspaces and determine requirements
+        const uikitWorkspaces = discovery.loadWorkspaces(uikitRoot);
+        const consumerWorkspaces = discovery.loadConsumerWorkspaces(consumerRoot);
+        const uikitPackages = uikitWorkspaces.filter((ws) => String(ws.name ?? '').startsWith('@r0hitsharma/'));
+        const supportedNames = new Set(uikitPackages.map((pkg) => pkg.name ?? '').filter((name) => name !== ''));
+        // Collect workspace requirements
+        const neededByWorkspace = new Map();
+        const allPackages = new Set();
+        for (const ws of consumerWorkspaces) {
+            const needed = new Set();
+            for (const depName of Object.keys(ws.dependencies)) {
+                if (supportedNames.has(depName)) {
+                    needed.add(depName);
+                    allPackages.add(depName);
+                }
+            }
+            if (needed.size > 0) {
+                neededByWorkspace.set(ws.location, [...needed]);
+            }
+        }
+        const packages = [...allPackages];
+        const workspaces = [...neededByWorkspace.keys()];
+        this.logger.debug('Starting unlink command', {
+            consumerRoot,
+            packageCount: packages.length,
+        });
+        // Unlink at root level
+        this.logger.info('Unlinking packages at root level...');
+        const packageArgs = packages.map((name) => `"${name}"`).join(' ');
+        if (packageArgs) {
+            const result = this.executor.execQuiet(`npm unlink ${packageArgs} --package-lock=false --save=false`, { cwd: consumerRoot });
+            if (!result) {
+                this.logger.warn('Root unlink had issues, continuing...');
+            }
+        }
+        // Unlink per workspace. The single-package consumer surfaces as the root
+        // (location ''); the root-level unlink above already covered it and
+        // `--workspace ""` is invalid.
+        for (const workspace of workspaces) {
+            if (workspace === '' || workspace === '.')
+                continue;
+            this.logger.debug(`Unlinking packages for workspace: ${workspace}`);
+            this.executor.execQuiet(`npm unlink ${packageArgs} --workspace "${workspace}" --package-lock=false --save=false`, { cwd: consumerRoot });
+        }
+        // Restore from registry
+        this.logger.info('Restoring packages from registry...');
+        const installResult = this.executor.exec('npm_config_min_release_age=0 npm install', {
+            cwd: consumerRoot,
+        });
+        if (!installResult.success) {
+            this.logger.error('Failed to restore packages from registry');
+            this.logger.warn('You may need to run `uikit-cli link` again to restore local links');
+            throw new Error('Unlink failed: could not restore registry packages');
+        }
+        this.logger.info('✓ Packages unlinked and restored from registry');
+    }
+}

package/dist/fs-utils.js

@@ -0,0 +1,56 @@
+import { existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, realpathSync, rmSync, statSync, symlinkSync, } from 'node:fs';
+/**
+ * Real file system implementation
+ */
+export class RealFileSystem {
+    exists(path) {
+        return existsSync(path);
+    }
+    readFile(path) {
+        return readFileSync(path, 'utf8');
+    }
+    readJson(path) {
+        try {
+            if (process.env.UIKIT_DEBUG) {
+                console.log('[DEBUG readJson]', path);
+            }
+            const content = this.readFile(path);
+            return JSON.parse(content);
+        }
+        catch (error) {
+            console.error('[readJson ERROR] Failed to read:', path);
+            throw error;
+        }
+    }
+    realpath(path) {
+        return realpathSync(path);
+    }
+    isSymlink(path) {
+        try {
+            return lstatSync(path).isSymbolicLink();
+        }
+        catch {
+            return false;
+        }
+    }
+    removeDir(path, options) {
+        rmSync(path, { recursive: true, force: true, ...options });
+    }
+    createSymlink(target, path) {
+        symlinkSync(target, path, 'dir');
+    }
+    createDir(path, options) {
+        mkdirSync(path, { recursive: true, ...options });
+    }
+    readDir(path) {
+        return readdirSync(path);
+    }
+    isDirectory(path) {
+        try {
+            return statSync(path).isDirectory();
+        }
+        catch {
+            return false;
+        }
+    }
+}

package/dist/link-validator.js

@@ -0,0 +1,80 @@
+import path from 'node:path';
+/**
+ * Validates link state without npm registry checks
+ */
+export class LinkValidator {
+    fs;
+    logger;
+    constructor(fs, logger) {
+        this.fs = fs;
+        this.logger = logger;
+    }
+    /**
+     * Validate all expected links in consumer
+     */
+    validateLinkedPackages(consumerRoot, expectedLinks) {
+        const issues = [];
+        this.logger.debug('Validating linked packages', {
+            consumerRoot,
+            packageCount: expectedLinks.size,
+        });
+        for (const [packageName, expectedTarget] of expectedLinks) {
+            const linkPath = path.join(consumerRoot, 'node_modules', packageName);
+            const status = this.validateSymlink(linkPath, expectedTarget);
+            if (status !== 'valid') {
+                issues.push({
+                    type: status,
+                    package: packageName,
+                    details: this.getStatusDetails(linkPath, expectedTarget, status),
+                });
+            }
+        }
+        return {
+            valid: issues.length === 0,
+            issues,
+        };
+    }
+    /**
+     * Validate a single symlink
+     */
+    validateSymlink(linkPath, expectedTarget) {
+        if (!this.fs.exists(linkPath)) {
+            return 'missing';
+        }
+        if (!this.fs.isSymlink(linkPath)) {
+            // Not a symlink, might be a regular install
+            return 'missing';
+        }
+        try {
+            const actualTarget = this.fs.realpath(linkPath);
+            const normalizedExpected = path.resolve(expectedTarget);
+            const normalizedActual = path.resolve(actualTarget);
+            if (normalizedActual === normalizedExpected) {
+                return 'valid';
+            }
+            return 'wrong-target';
+        }
+        catch {
+            return 'broken';
+        }
+    }
+    getStatusDetails(linkPath, expectedTarget, status) {
+        switch (status) {
+            case 'missing':
+                return `Link does not exist at ${linkPath}`;
+            case 'broken':
+                return `Symlink exists but points to non-existent location`;
+            case 'wrong-target': {
+                try {
+                    const actualTarget = this.fs.realpath(linkPath);
+                    return `Expected: ${expectedTarget}\nActual: ${actualTarget}`;
+                }
+                catch {
+                    return `Could not read symlink target`;
+                }
+            }
+            default:
+                return '';
+        }
+    }
+}

package/dist/logger.js

@@ -0,0 +1,43 @@
+/**
+ * Console logger with optional debug mode
+ */
+export class ConsoleLogger {
+    debugMode;
+    constructor(debugMode = false) {
+        this.debugMode = debugMode;
+    }
+    info(message, context) {
+        if (context) {
+            console.log(message, context);
+        }
+        else {
+            console.log(message);
+        }
+    }
+    warn(message, context) {
+        if (context) {
+            console.warn(`⚠️  ${message}`, context);
+        }
+        else {
+            console.warn(`⚠️  ${message}`);
+        }
+    }
+    error(message, context) {
+        if (context) {
+            console.error(`❌ ${message}`, context);
+        }
+        else {
+            console.error(`❌ ${message}`);
+        }
+    }
+    debug(message, context) {
+        if (!this.debugMode)
+            return;
+        if (context) {
+            console.log(`[DEBUG] ${message}`, context);
+        }
+        else {
+            console.log(`[DEBUG] ${message}`);
+        }
+    }
+}