@archon-research/uikit-cli 0.2.2 → 0.3.1

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}`);
+        }
+    }
+}

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 {};