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

package/dist/command-executor.js

@@ -0,0 +1,41 @@
+import { execSync } from 'node:child_process';
+/**
+ * Real npm command executor using execSync
+ */
+export class NpmCommandExecutor {
+    debugMode;
+    constructor(debugMode = false) {
+        this.debugMode = debugMode;
+    }
+    exec(command, options) {
+        const { cwd = process.cwd(), silent = false } = options || {};
+        if (this.debugMode) {
+            console.log(`[DEBUG] Executing: ${command}`);
+            console.log(`[DEBUG] CWD: ${cwd}`);
+        }
+        try {
+            const stdout = execSync(command, {
+                cwd,
+                encoding: 'utf8',
+                stdio: silent ? 'pipe' : 'inherit',
+            });
+            return {
+                stdout: typeof stdout === 'string' ? stdout : '',
+                stderr: '',
+                success: true,
+            };
+        }
+        catch (error) {
+            const err = error;
+            return {
+                stdout: err.stdout?.toString('utf8') || '',
+                stderr: err.stderr?.toString('utf8') || err.message || 'Unknown error',
+                success: false,
+            };
+        }
+    }
+    execQuiet(command, options) {
+        const result = this.exec(command, { ...options, silent: true });
+        return result.success;
+    }
+}

package/dist/commands/format.js

@@ -0,0 +1,36 @@
+import path from 'node:path';
+import { shellEscape } from '../shell-utils.js';
+/**
+ * Format command - forwards to oxfmt with config detection
+ */
+export class FormatCommand {
+    executor;
+    fs;
+    constructor(executor, fs) {
+        this.executor = executor;
+        this.fs = fs;
+    }
+    execute(args) {
+        const modifiedArgs = [...args];
+        const defaultConfig = './.oxfmtrc.ts';
+        // Add default config if not specified and file exists
+        if (!this.hasConfigFlag(modifiedArgs)) {
+            const configPath = path.join(process.cwd(), '.oxfmtrc.ts');
+            if (this.fs.exists(configPath)) {
+                modifiedArgs.unshift(defaultConfig);
+                modifiedArgs.unshift('-c');
+            }
+        }
+        const escapedArgs = modifiedArgs.map((arg) => shellEscape(arg)).join(' ');
+        this.executor.exec(`npm exec -- oxfmt ${escapedArgs}`.trim(), { cwd: process.cwd() });
+    }
+    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;
+            }
+        }
+        return false;
+    }
+}

package/dist/commands/link.js

@@ -0,0 +1,162 @@
+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.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 = 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, neededByWorkspace, dirByName);
+        if (verify) {
+            // Only verify packages that were actually linked
+            const linkedDirByName = new Map();
+            for (const name of linkedNames) {
+                const path = dirByName.get(name);
+                if (path) {
+                    linkedDirByName.set(name, path);
+                }
+            }
+            this.runVerification(consumerRoot, linkedDirByName);
+        }
+    }
+    collectWorkspaceRequirements(workspaces, supportedNames) {
+        const neededByWorkspace = new Map();
+        for (const ws of workspaces) {
+            const fields = [ws.dependencies];
+            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, neededByWorkspace, dirByName) {
+        const allNames = new Set();
+        for (const names of neededByWorkspace.values()) {
+            for (const name of names) {
+                allNames.add(name);
+            }
+        }
+        // Link at root level
+        const rootPackageArgs = [...allNames].map((name) => `"${name}"`).join(' ');
+        if (rootPackageArgs) {
+            this.logger.info('Linking packages at root level...');
+            this.executor.exec(`npm link ${rootPackageArgs} --package-lock=false --save=false`, { cwd: consumerRoot });
+        }
+        // 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;
+            this.logger.debug(`Linking packages for workspace: ${workspace}`);
+            this.executor.exec(`npm link ${packageArgs} --workspace "${workspace}" --package-lock=false --save=false`, { cwd: consumerRoot });
+            // Clean up shadow installs and Vite cache
+            for (const name of names) {
+                this.removeWorkspaceShadowInstall(consumerRoot, workspace, name);
+            }
+            this.clearWorkspaceViteCache(consumerRoot, workspace);
+        }
+        this.logger.info('✓ Linked local uikit packages into consumer workspaces.');
+    }
+    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,14 @@
+import { shellEscape } from '../shell-utils.js';
+/**
+ * Lint command - forwards to oxlint
+ */
+export class LintCommand {
+    executor;
+    constructor(executor) {
+        this.executor = executor;
+    }
+    execute(args) {
+        const escapedArgs = args.map((arg) => shellEscape(arg)).join(' ');
+        this.executor.exec(`npm exec -- oxlint ${escapedArgs}`.trim(), { cwd: process.cwd() });
+    }
+}

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('@archon-research/'));
+        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,64 @@
+/**
+ * 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.loadWorkspaces(consumerRoot);
+        const uikitPackages = uikitWorkspaces.filter((ws) => String(ws.name ?? '').startsWith('@archon-research/'));
+        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
+        for (const workspace of workspaces) {
+            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}`);
+        }
+    }
+}