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

package/dist/cli.js

@@ -1,490 +1,198 @@
 #!/usr/bin/env node
-import { execSync } from 'node:child_process';
-import { existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, realpathSync, rmSync, symlinkSync, } from 'node:fs';
-import path from 'node:path';
 import { fileURLToPath } from 'node:url';
-const OXLINT_VERSION = '1.62.0';
-const OXFMT_VERSION = '0.47.0';
-function shellEscape(value) {
-    return `'${value.replace(/'/g, `'"'"'`)}'`;
-}
-function run(command, cwd) {
-    console.log(`> (${cwd}) ${command}`);
-    execSync(command, { stdio: 'inherit', cwd });
-}
-function tryRun(command, cwd, quiet = false) {
-    if (!quiet) {
-        console.log(`> (${cwd}) ${command}`);
-    }
-    try {
-        execSync(command, {
-            stdio: quiet ? 'ignore' : 'inherit',
-            cwd,
-        });
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-function removeWorkspaceShadowInstall(consumerRoot, workspace, packageName) {
-    const packagePath = path.join(consumerRoot, workspace, 'node_modules', packageName);
-    if (!existsSync(packagePath)) {
-        return;
-    }
-    try {
-        const stats = lstatSync(packagePath);
-        if (stats.isSymbolicLink()) {
-            return;
-        }
-        // Remove workspace-local regular install so Node resolves to linked root package.
-        rmSync(packagePath, { recursive: true, force: true });
-        console.log(`Removed shadow install at ${workspace}/node_modules/${packageName} to preserve local links.`);
-    }
-    catch {
-        // Best effort cleanup; linking may still succeed via root resolution.
-    }
-}
-function ensureLinkedPath(consumerRoot, packageName, expectedTarget) {
-    const packagePath = path.join(consumerRoot, 'node_modules', packageName);
-    try {
-        const stats = lstatSync(packagePath);
-        if (stats.isSymbolicLink() && realpathSync(packagePath) === expectedTarget) {
-            return;
-        }
-        rmSync(packagePath, { recursive: true, force: true });
-    }
-    catch {
-        // Path may not exist yet; continue and create symlink.
-    }
-    mkdirSync(path.dirname(packagePath), { recursive: true });
-    symlinkSync(expectedTarget, packagePath, 'dir');
-}
-function clearWorkspaceViteCache(consumerRoot, workspace) {
-    const viteCachePath = path.join(consumerRoot, workspace, 'node_modules', '.vite');
-    if (!existsSync(viteCachePath)) {
-        return;
-    }
-    try {
-        rmSync(viteCachePath, { recursive: true, force: true });
-        console.log(`Cleared Vite cache at ${workspace}/node_modules/.vite.`);
-    }
-    catch {
-        // Best-effort cache cleanup; linking still succeeds without this.
-    }
-}
-function readJson(filePath) {
-    const content = readFileSync(filePath, 'utf8');
-    return JSON.parse(content);
-}
-function getWorkspacePatterns(rootDir) {
-    const pkg = readJson(path.join(rootDir, 'package.json'));
-    const workspaces = pkg.workspaces;
-    if (Array.isArray(workspaces)) {
-        return workspaces;
-    }
-    if (workspaces && Array.isArray(workspaces.packages)) {
-        return workspaces.packages;
-    }
-    return [];
-}
-function resolveWorkspacePattern(rootDir, pattern) {
-    if (pattern.endsWith('/*')) {
-        const base = pattern.slice(0, -2);
-        const absBase = path.join(rootDir, base);
-        return readdirSync(absBase, { withFileTypes: true })
-            .filter((entry) => entry.isDirectory())
-            .map((entry) => path.join(base, entry.name));
-    }
-    return [pattern];
-}
-function loadWorkspaces(rootDir) {
-    const patterns = getWorkspacePatterns(rootDir);
-    const locations = patterns.flatMap((pattern) => resolveWorkspacePattern(rootDir, pattern));
-    return locations
-        .map((location) => {
-        const pkgPath = path.join(rootDir, location, 'package.json');
-        const pkg = readJson(pkgPath);
-        return {
-            ...pkg,
-            location,
-            path: path.join(rootDir, location),
-        };
-    })
-        .filter((ws) => Boolean(ws.name));
-}
-function findConsumerRoot(startDir) {
-    let current = startDir;
-    while (true) {
-        const pkgPath = path.join(current, 'package.json');
-        try {
-            const content = readFileSync(pkgPath, 'utf8');
-            const pkg = JSON.parse(content);
-            if (pkg.workspaces) {
-                return current;
-            }
-        }
-        catch {
-            // File not found or parse error, continue up.
-        }
-        const parent = path.dirname(current);
-        if (parent === current) {
-            throw new Error('Could not find consumer workspace root (no package.json with workspaces field)');
-        }
-        current = parent;
-    }
-}
-function findUIKitRoot(startDir) {
-    let current = startDir;
-    while (true) {
-        if (isValidUIKitRoot(current)) {
-            return current;
-        }
-        const parent = path.dirname(current);
-        if (parent === current) {
-            return null;
-        }
-        current = parent;
-    }
-}
-function isValidUIKitRoot(rootDir) {
-    try {
-        const pkgPath = path.join(rootDir, 'package.json');
-        const pkg = readJson(pkgPath);
-        if (!pkg.workspaces) {
-            return false;
-        }
-        const workspaces = loadWorkspaces(rootDir);
-        return workspaces.some((ws) => ws.name === '@archon-research/design-system');
-    }
-    catch {
-        return false;
-    }
-}
-function findUIKitRootFromConsumer(consumerRoot) {
-    const candidateNames = ['uikit'];
-    let current = consumerRoot;
-    while (true) {
-        for (const candidateName of candidateNames) {
-            const candidate = path.join(current, candidateName);
-            if (isValidUIKitRoot(candidate)) {
-                return candidate;
-            }
-        }
-        const parent = path.dirname(current);
-        if (parent === current) {
-            return null;
-        }
-        current = parent;
-    }
-}
-function resolveUIKitRoot(explicitUIKitRoot, consumerRoot) {
-    if (explicitUIKitRoot) {
-        const resolved = path.resolve(process.cwd(), explicitUIKitRoot);
-        if (!isValidUIKitRoot(resolved)) {
-            throw new Error(`Invalid uikit root: ${resolved}. Expected a workspace root containing @archon-research/design-system.`);
-        }
-        return resolved;
-    }
-    const scriptRelativeRoot = path.resolve(scriptDir, '../../..');
-    if (isValidUIKitRoot(scriptRelativeRoot)) {
-        return scriptRelativeRoot;
-    }
-    if (consumerRoot) {
-        const discovered = findUIKitRootFromConsumer(consumerRoot);
-        if (discovered) {
-            return discovered;
-        }
-    }
-    const fromCwd = findUIKitRoot(process.cwd());
-    if (fromCwd) {
-        return fromCwd;
-    }
-    throw new Error('Could not locate local uikit workspace automatically. Run from a consumer workspace near your uikit checkout, or pass --uikit-root / set UIKIT_ROOT.');
-}
+import path from 'node:path';
+import { RealFileSystem } from './fs-utils.js';
+import { NpmCommandExecutor } from './command-executor.js';
+import { ConsoleLogger } from './logger.js';
+import { PackageDiscovery } from './package-discovery.js';
+import { LinkValidator } from './link-validator.js';
+import { RegisterCommand } from './commands/register.js';
+import { LinkCommand } from './commands/link.js';
+import { UnlinkCommand } from './commands/unlink.js';
+import { LintCommand } from './commands/lint.js';
+import { FormatCommand } from './commands/format.js';
+const scriptDir = path.dirname(fileURLToPath(import.meta.url));
+/**
+ * Parse command line arguments
+ */
 function parseArgs(argv) {
     const args = argv.slice(2);
-    const command = args[0];
-    let mode;
-    if (!command || command === 'link') {
-        mode = 'link';
-    }
-    else if (command === 'unlink') {
-        mode = 'unlink';
-    }
-    else if (command === 'register') {
-        mode = 'register';
-    }
-    else if (command === 'lint') {
-        mode = 'lint';
-    }
-    else if (command === 'format') {
-        mode = 'format';
-    }
-    else {
-        throw new Error(`Unknown command: ${command}. Expected one of: link, unlink, register, lint, format.`);
-    }
-    const commandArgs = args.slice(1);
-    let consumerRoot = null;
-    let uikitRoot = process.env.UIKIT_ROOT ?? null;
-    for (let i = 1; i < args.length; i += 1) {
+    if (args.length === 0) {
+        throw new Error('Usage: uikit-cli <register|link|unlink|lint|format> [--verify] [--debug] [--uikit-root <path>] [args...]');
+    }
+    const mode = args[0];
+    const validModes = ['lint', 'format', 'register', 'link', 'unlink'];
+    if (!validModes.includes(mode)) {
+        throw new Error(`Unknown command: ${mode}`);
+    }
+    let uikitRoot;
+    let verify = false;
+    let debug = false;
+    const commandArgs = [];
+    let i = 1;
+    while (i < args.length) {
         const arg = args[i];
-        if (arg === '--consumer-root' && args[i + 1]) {
-            consumerRoot = path.resolve(process.cwd(), args[i + 1]);
+        if (arg === '--uikit-root' && i + 1 < args.length) {
+            uikitRoot = args[i + 1];
+            i += 2;
+        }
+        else if (arg === '--verify') {
+            verify = true;
             i += 1;
-            continue;
         }
-        if (arg === '--uikit-root' && args[i + 1]) {
-            uikitRoot = args[i + 1];
+        else if (arg === '--debug') {
+            debug = true;
             i += 1;
         }
-    }
-    if (mode !== 'register' &&
-        mode !== 'lint' &&
-        mode !== 'format' &&
-        !consumerRoot) {
-        consumerRoot = findConsumerRoot(process.cwd());
-    }
-    if (mode === 'lint' || mode === 'format') {
-        return {
-            mode,
-            consumerRoot: null,
-            uikitRoot: '',
-            commandArgs,
-        };
-    }
-    return {
-        mode,
-        consumerRoot,
-        uikitRoot: resolveUIKitRoot(uikitRoot, consumerRoot),
-        commandArgs,
-    };
-}
-function runLint(commandArgs) {
-    const forwarded = commandArgs.map(shellEscape).join(' ');
-    run(`npm exec --yes --package oxlint@${OXLINT_VERSION} -- oxlint ${forwarded}`.trim(), process.cwd());
-}
-function hasConfigFlag(args) {
-    for (let i = 0; i < args.length; i += 1) {
-        const arg = args[i];
-        if (arg === '-c' || arg === '--config' || arg.startsWith('--config=')) {
-            return true;
+        else {
+            commandArgs.push(arg);
+            i += 1;
         }
     }
-    return false;
-}
-function runFormat(commandArgs) {
-    const args = [...commandArgs];
-    const defaultConfig = './.oxfmtrc.ts';
-    if (!hasConfigFlag(args) && existsSync(path.join(process.cwd(), '.oxfmtrc.ts'))) {
-        args.unshift(defaultConfig);
-        args.unshift('-c');
+    // Check for UIKIT_DEBUG environment variable
+    if (process.env.UIKIT_DEBUG === '1') {
+        debug = true;
     }
-    const forwarded = args.map(shellEscape).join(' ');
-    run(`npm exec --yes --package oxfmt@${OXFMT_VERSION} -- oxfmt ${forwarded}`.trim(), process.cwd());
-}
-function registerLocalPackages(uikitRoot, supportedNames) {
-    const uikitWorkspaces = loadWorkspaces(uikitRoot);
-    const uikitPackages = uikitWorkspaces.filter((ws) => String(ws.name ?? '').startsWith('@archon-research/') &&
-        !ws.private &&
-        (!supportedNames || supportedNames.has(String(ws.name))));
-    if (uikitPackages.length === 0) {
-        console.log('No public @archon-research packages found in this uikit workspace.');
-        return;
+    // Resolve uikit root
+    const fs = new RealFileSystem();
+    const discovery = new PackageDiscovery(fs);
+    if (debug) {
+        console.log('[DEBUG parseArgs] Resolving uikit root...');
     }
-    for (const pkg of uikitPackages) {
-        if (!pkg.name) {
-            continue;
+    if (!uikitRoot) {
+        // Try relative to script location
+        const relativeRoot = path.resolve(scriptDir, '../../../..');
+        if (debug) {
+            console.log('[DEBUG parseArgs] Checking relative root:', relativeRoot);
         }
-        // Ensure CLI bin target exists before linking globally.
-        if (pkg.name === '@archon-research/uikit-cli' &&
-            !existsSync(path.join(pkg.path, 'dist', 'cli.js'))) {
-            run('npm run build', pkg.path);
-        }
-        run('npm link', pkg.path);
-    }
-    console.log('\nRegistered local uikit packages for downstream consumers.');
-}
-function linkCliIntoConsumer(consumerRoot) {
-    run('npm link "@archon-research/uikit-cli" --package-lock=false --save=false', consumerRoot);
-}
-function collectWorkspaceRequirements(workspaces, supportedNames) {
-    const neededByWorkspace = new Map();
-    for (const ws of workspaces) {
-        const fields = [
-            ws.dependencies ?? {},
-            ws.devDependencies ?? {},
-            ws.optionalDependencies ?? {},
-            ws.peerDependencies ?? {},
-        ];
-        const needed = new Set();
-        for (const depField of fields) {
-            for (const depName of Object.keys(depField)) {
-                if (supportedNames.has(depName)) {
-                    needed.add(depName);
-                }
+        if (discovery.isValidUIKitRoot(relativeRoot)) {
+            uikitRoot = relativeRoot;
+            if (debug) {
+                console.log('[DEBUG parseArgs] Found valid uikit root at relative location');
             }
         }
-        if (needed.size > 0) {
-            neededByWorkspace.set(ws.location, [...needed]);
-        }
-    }
-    return neededByWorkspace;
-}
-function linkLocalPackages(consumerRoot, neededByWorkspace, dirByName) {
-    if (neededByWorkspace.size === 0) {
-        console.log('No local uikit packages referenced by this consumer workspaces.');
-        return;
     }
-    const allNames = new Set();
-    for (const names of neededByWorkspace.values()) {
-        for (const name of names) {
-            allNames.add(name);
-        }
-    }
-    const rootPackageArgs = [...allNames].map((name) => `"${name}"`).join(' ');
-    if (rootPackageArgs) {
-        run(`npm link ${rootPackageArgs} --package-lock=false --save=false`, consumerRoot);
-    }
-    // npm can materialize regular installs in some workspace setups; enforce root links.
-    for (const name of allNames) {
-        const target = dirByName.get(name);
-        if (!target) {
-            continue;
-        }
-        ensureLinkedPath(consumerRoot, name, target);
-    }
-    for (const [workspace, names] of neededByWorkspace.entries()) {
-        const packageArgs = names.map((name) => `"${name}"`).join(' ');
-        if (!packageArgs) {
-            continue;
-        }
-        run(`npm link ${packageArgs} --workspace "${workspace}" --package-lock=false --save=false`, consumerRoot);
-        // npm --workspace link can leave a regular install in some workspace layouts.
-        // Removing workspace shadow installs keeps resolution aligned to linked root packages.
-        for (const name of names) {
-            removeWorkspaceShadowInstall(consumerRoot, workspace, name);
-        }
-        clearWorkspaceViteCache(consumerRoot, workspace);
-    }
-}
-function unlinkLocalPackages(consumerRoot, neededByWorkspace) {
-    if (neededByWorkspace.size === 0) {
-        console.log('No local uikit packages referenced by this consumer workspaces.');
-        return;
-    }
-    const allNames = new Set();
-    for (const names of neededByWorkspace.values()) {
-        for (const name of names) {
-            allNames.add(name);
-        }
-    }
-    for (const name of allNames) {
-        const ok = tryRun(`npm unlink "${name}" --package-lock=false --save=false`, consumerRoot);
-        if (!ok) {
-            console.warn(`Unable to unlink ${name} at root; continuing.`);
-        }
-    }
-    for (const [workspace, names] of neededByWorkspace.entries()) {
-        const workspaceDir = path.join(consumerRoot, workspace);
-        for (const name of names) {
-            const ok = tryRun(`npm unlink "${name}" --workspace "${workspace}" --package-lock=false --save=false`, consumerRoot);
-            if (!ok) {
-                console.warn(`Unable to unlink ${name} in ${workspace}; continuing with restore flow.`);
-            }
-            // Fallback for cases where --workspace unlink does not clear workspace-local links.
-            const fallbackOk = tryRun(`npm unlink "${name}" --package-lock=false --save=false`, workspaceDir, true);
-            if (!fallbackOk) {
-                console.warn(`Unable to unlink ${name} directly in ${workspace}; continuing with restore flow.`);
+    if (!uikitRoot && mode !== 'lint' && mode !== 'format') {
+        // Try to find from consumer
+        try {
+            const tempConsumerRoot = discovery.findConsumerRoot(process.cwd());
+            const foundRoot = discovery.findUIKitRootFromConsumer(tempConsumerRoot);
+            if (foundRoot) {
+                uikitRoot = foundRoot;
             }
         }
-        clearWorkspaceViteCache(consumerRoot, workspace);
-    }
-}
-function areRegistryPackagesReady(consumerRoot, neededByWorkspace) {
-    for (const [workspace, names] of neededByWorkspace.entries()) {
-        for (const name of names) {
-            const ok = tryRun(`npm_config_min_release_age=0 npm ls ${name} --depth=0 --workspace "${workspace}"`, consumerRoot, true);
-            if (!ok) {
-                return false;
-            }
+        catch {
+            // Will throw error below if needed
         }
     }
-    return true;
-}
-function arePackagesPublished(consumerRoot, neededByWorkspace) {
-    const uniqueNames = new Set();
-    for (const names of neededByWorkspace.values()) {
-        for (const name of names) {
-            uniqueNames.add(name);
+    if (!uikitRoot && mode !== 'lint' && mode !== 'format') {
+        // Try walking up from cwd
+        const foundRoot = discovery.findUIKitRoot(process.cwd());
+        if (foundRoot) {
+            uikitRoot = foundRoot;
         }
     }
-    for (const name of uniqueNames) {
-        const ok = tryRun(`npm view ${name} version --json`, consumerRoot, true);
-        if (!ok) {
-            return false;
-        }
+    if (!uikitRoot && mode !== 'lint' && mode !== 'format') {
+        throw new Error('Could not find uikit root directory.\n' +
+            'Tried:\n' +
+            '  - Relative to script location\n' +
+            '  - Sibling to consumer root\n' +
+            '  - Walking up from cwd\n' +
+            'Use --uikit-root to specify manually.');
+    }
+    let consumerRoot = null;
+    if (mode === 'link' || mode === 'unlink') {
+        consumerRoot = discovery.findConsumerRoot(process.cwd());
     }
-    return true;
+    return {
+        mode,
+        consumerRoot,
+        uikitRoot: uikitRoot ?? '',
+        commandArgs,
+        verify,
+        debug,
+    };
 }
-const scriptDir = path.dirname(fileURLToPath(import.meta.url));
+/**
+ * Ensure CLI binary is built before registering
+ */
+function ensureCliBinaryBuilt(uikitRoot, executor) {
+    const cliPackagePath = path.join(uikitRoot, 'packages/uikit-cli');
+    const distPath = path.join(cliPackagePath, 'dist/cli.js');
+    const fs = new RealFileSystem();
+    if (!fs.exists(distPath)) {
+        console.log('Building CLI binary...');
+        executor.exec('npm run build', { cwd: cliPackagePath });
+    }
+}
+/**
+ * Link CLI into consumer for convenience
+ */
+function linkCliIntoConsumer(consumerRoot, executor) {
+    executor.exec('npm link "@archon-research/uikit-cli" --package-lock=false --save=false --no-workspaces', { cwd: consumerRoot });
+}
+/**
+ * Main entry point
+ */
 try {
-    const { mode, consumerRoot, uikitRoot, commandArgs } = parseArgs(process.argv);
+    const parsed = parseArgs(process.argv);
+    const { mode, consumerRoot, uikitRoot, commandArgs, verify, debug } = parsed;
+    if (debug) {
+        console.log('[DEBUG] Parsed args:', { mode, consumerRoot, uikitRoot, verify });
+    }
+    // Initialize dependencies
+    const fs = new RealFileSystem();
+    const executor = new NpmCommandExecutor(debug);
+    const logger = new ConsoleLogger(debug);
+    const discovery = new PackageDiscovery(fs);
+    const validator = new LinkValidator(fs, logger);
+    // Handle lint/format commands
     if (mode === 'lint') {
-        runLint(commandArgs);
+        const lintCmd = new LintCommand(executor);
+        lintCmd.execute(commandArgs);
         process.exit(0);
     }
     if (mode === 'format') {
-        runFormat(commandArgs);
+        const formatCmd = new FormatCommand(executor, fs);
+        formatCmd.execute(commandArgs);
         process.exit(0);
     }
+    // Handle register command
     if (mode === 'register') {
-        registerLocalPackages(uikitRoot);
+        ensureCliBinaryBuilt(uikitRoot, executor);
+        const registerCmd = new RegisterCommand(discovery, executor, logger);
+        registerCmd.execute(uikitRoot);
+        if (verify) {
+            logger.info('\\nVerifying registration...');
+            // Could add verification logic here
+            logger.info('✓ Registration verified');
+        }
         process.exit(0);
     }
+    // Handle link/unlink commands (require consumerRoot)
     if (!consumerRoot) {
         throw new Error('Consumer root is required for link/unlink operations.');
     }
-    const uikitWorkspaces = loadWorkspaces(uikitRoot);
-    const consumerWorkspaces = loadWorkspaces(consumerRoot);
-    const uikitPackages = uikitWorkspaces.filter((ws) => String(ws.name ?? '').startsWith('@archon-research/'));
-    const dirByName = new Map(uikitPackages.map((pkg) => [pkg.name ?? '', pkg.path]));
-    dirByName.delete('');
-    const supportedNames = new Set(dirByName.keys());
-    const neededByWorkspace = collectWorkspaceRequirements(consumerWorkspaces, supportedNames);
-    registerLocalPackages(uikitRoot, supportedNames);
-    linkCliIntoConsumer(consumerRoot);
+    // Register packages and link CLI before link/unlink
+    ensureCliBinaryBuilt(uikitRoot, executor);
+    const registerCmd = new RegisterCommand(discovery, executor, logger);
+    registerCmd.execute(uikitRoot);
+    linkCliIntoConsumer(consumerRoot, executor);
     if (mode === 'link') {
-        linkLocalPackages(consumerRoot, neededByWorkspace, dirByName);
-        console.log('\nLinked local uikit packages into consumer workspaces.');
+        const linkCmd = new LinkCommand(discovery, executor, validator, fs, logger);
+        linkCmd.execute(consumerRoot, uikitRoot, verify);
         process.exit(0);
     }
-    if (!arePackagesPublished(consumerRoot, neededByWorkspace)) {
-        console.warn('\nRegistry packages are not published yet; keeping local uikit links in place.');
-        linkLocalPackages(consumerRoot, neededByWorkspace, dirByName);
-        console.log('\nConsumer remains on local uikit links.');
+    if (mode === 'unlink') {
+        const unlinkCmd = new UnlinkCommand(executor, logger);
+        unlinkCmd.execute(consumerRoot, uikitRoot, discovery);
         process.exit(0);
     }
-    unlinkLocalPackages(consumerRoot, neededByWorkspace);
-    let rootInstallOk = tryRun('npm_config_min_release_age=0 npm install', consumerRoot);
-    let installOk = true;
-    for (const workspace of neededByWorkspace.keys()) {
-        installOk =
-            tryRun(`npm_config_min_release_age=0 npm install --workspace "${workspace}"`, consumerRoot) &&
-                installOk;
-    }
-    if (!rootInstallOk ||
-        !installOk ||
-        !areRegistryPackagesReady(consumerRoot, neededByWorkspace)) {
-        console.warn('\nRegistry packages are not fully resolvable; falling back to local uikit linking.');
-        linkLocalPackages(consumerRoot, neededByWorkspace, dirByName);
-    }
-    // Keep consumer on the local CLI implementation so repeated link/unlink stays stable.
-    linkCliIntoConsumer(consumerRoot);
-    console.log('\nUnlinked local uikit packages and restored consumer dependencies.');
 }
 catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    console.error(`Error: ${message}`);
+    if (process.env.UIKIT_DEBUG) {
+        console.error('Full error:', error);
+    }
+    console.error(error instanceof Error ? error.message : String(error));
     process.exit(1);
 }

package/dist/cli.sh

@@ -0,0 +1,10 @@
+#!/usr/bin/env sh
+# Use --preserve-symlinks to fix ES module resolution with npm link
+# Follow symlink to find the actual script location
+if [ -L "$0" ]; then
+  SCRIPT="$(readlink -f "$0" 2>/dev/null || readlink "$0")"
+else
+  SCRIPT="$0"
+fi
+SCRIPT_DIR="$(cd "$(dirname "$SCRIPT")" && pwd)"
+exec node --preserve-symlinks "$SCRIPT_DIR/cli.js" "$@"