get-ui-cli 0.0.0-stage → 2.0.0

package/dist/node/install.js

@@ -0,0 +1,410 @@
+// Plan and write resolved registry files into a user's project.
+import { spawn } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { mergeCss } from '../core/css.js';
+import { packageName } from '../core/resolve.js';
+import { importJsxNamespace, listImports, rewriteImports, transformIconPlaceholders } from '../core/transform.js';
+import { withKnownMajor } from '../core/versions.js';
+import { SHADCN_BASE_CSS, SHADCN_BASE_THEME, hasShadcnTheme, usesShadcnTokens } from '../core/shadcn-theme.js';
+export const UTILS_SOURCE = `import { clsx, type ClassValue } from "clsx"
+import { twMerge } from "tailwind-merge"
+
+export function cn(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs))
+}
+`;
+/** Packages a React project always has — never auto-added. */
+const IMPLICIT_PACKAGES = new Set(['react', 'react-dom', 'next', 'cn']);
+const CODE_EXT = /\.(tsx?|jsx?|mjs|cjs)$/;
+function stripExt(p) {
+    return p.replace(CODE_EXT, '');
+}
+function toPosix(p) {
+    return p.split(path.sep).join('/');
+}
+function within(dir, file) {
+    const rel = path.relative(dir, file);
+    if (!rel || rel.startsWith('..') || path.isAbsolute(rel))
+        return null;
+    return toPosix(rel);
+}
+function itemName(label) {
+    return label.split('/').pop() ?? label;
+}
+/** Map a target like `components/kokonutui/x.tsx` onto the project's directories. */
+function mapTarget(target, project) {
+    if (target.startsWith('~/'))
+        return path.join(project.cwd, target.slice(2));
+    const t = target.replace(/^\.?\/+/, '').replace(/^src\//, '');
+    const seg = (prefix) => t.startsWith(prefix) ? t.slice(prefix.length) : null;
+    let rest;
+    if ((rest = seg('components/ui/')) !== null)
+        return path.join(project.dirs.ui, rest);
+    if ((rest = seg('components/')) !== null)
+        return path.join(project.dirs.components, rest);
+    if ((rest = seg('hooks/')) !== null)
+        return path.join(project.dirs.hooks, rest);
+    if ((rest = seg('lib/')) !== null)
+        return path.join(project.dirs.lib, rest);
+    if (/^(app|pages|styles)\//.test(t))
+        return path.join(project.baseDir, t);
+    return path.join(project.cwd, target.replace(/^\.?\/+/, ''));
+}
+export function destinationFor(file, project) {
+    const base = path.posix.basename(file.path);
+    if (file.target)
+        return mapTarget(file.target, project);
+    switch (file.type) {
+        case 'registry:ui':
+            return path.join(project.dirs.ui, base);
+        case 'registry:hook':
+            return path.join(project.dirs.hooks, base);
+        case 'registry:lib':
+            return path.join(project.dirs.lib, base);
+        case 'registry:block':
+            return path.join(project.dirs.components, 'blocks', itemName(file.item), base);
+        case 'registry:theme':
+        case 'registry:style':
+        case 'registry:file':
+        case 'registry:page': {
+            // No target given: keep the path below a `registry/<style>/` prefix, if any.
+            const p = file.path.replace(/^\/+/, '').replace(/^registry\/[^/]+\//, '');
+            return path.join(project.dirs.components, p);
+        }
+        default:
+            return path.join(project.dirs.components, base);
+    }
+}
+/** Import specifier (without extension) that resolves to `abs`. */
+function specifierFor(abs, project) {
+    const noExt = stripExt(abs);
+    const order = [
+        [project.dirs.ui, project.aliases.ui],
+        [project.dirs.components, project.aliases.components],
+        [project.dirs.hooks, project.aliases.hooks],
+        [project.dirs.lib, project.aliases.lib],
+    ];
+    for (const [dir, alias] of order) {
+        const rel = within(dir, noExt);
+        if (rel)
+            return `${alias}/${rel}`;
+    }
+    const rel = within(project.baseDir, noExt) ?? within(project.cwd, noExt);
+    return `${project.aliasPrefix ?? '@/'}${rel ?? toPosix(noExt)}`;
+}
+/** When the project has no path alias, turn `@/x` specifiers into relative ones. */
+function relativize(code, fileAbs, project) {
+    if (project.aliasPrefix)
+        return code;
+    return code.replace(/(\bfrom\s*|\bimport\s*\(\s*|\bimport\s+|\brequire\s*\(\s*)(['"])@\/([^'"\n]+)\2/g, (_m, lead, q, rest) => {
+        let rel = toPosix(path.relative(path.dirname(fileAbs), path.join(project.baseDir, rest)));
+        if (!rel.startsWith('.'))
+            rel = `./${rel}`;
+        return `${lead}${q}${rel}${q}`;
+    });
+}
+/** shadcn-style primitives come in Radix and Base UI flavours that can't stand in for each other. */
+function flavour(code) {
+    if (/from\s*['"]@base-ui(?:-components)?\/react/.test(code))
+        return 'base-ui';
+    if (/from\s*['"](?:radix-ui|@radix-ui\/react-[\w-]+)['"]/.test(code))
+        return 'radix';
+    return null;
+}
+/** Share of identifiers two files have in common (0–1). A user's edits keep it near 1. */
+function similarity(a, b) {
+    const words = (code) => new Set(code.match(/[A-Za-z_$][\w$]{2,}/g) ?? []);
+    const A = words(a);
+    const B = words(b);
+    let shared = 0;
+    for (const w of A)
+        if (B.has(w))
+            shared++;
+    return shared / Math.max(1, A.size + B.size - shared);
+}
+// Measured: same-name components from different libraries score 0.3–0.4; versions
+// of the same component (another shadcn style, or the user's edits) score 0.55–1.
+const DIFFERENT_COMPONENT = 0.5;
+/** What callers can rely on: exports, component props, and cva variant options. */
+function api(code) {
+    const out = new Set();
+    for (const m of code.matchAll(/export\s+(?:default\s+)?(?:async\s+)?(?:function|const|class)\s+([A-Za-z_$][\w$]*)/g))
+        out.add(`export:${m[1]}`);
+    for (const m of code.matchAll(/export\s*\{([^}]*)\}/g))
+        for (const name of m[1].split(',')) {
+            const n = name.trim().split(/\s+as\s+/).pop();
+            if (n && n !== 'type')
+                out.add(`export:${n.replace(/^type\s+/, '')}`);
+        }
+    // Props destructured by components: function Card({ className, size = "default", ...props })
+    for (const m of code.matchAll(/(?:function\s+[A-Z][\w$]*|const\s+[A-Z][\w$]*\s*=\s*(?:React\.)?(?:forwardRef(?:<[^>]*>)?\()?)\s*\(\s*\{([^}]*)\}/g))
+        for (const part of m[1].split(',')) {
+            const p = part.trim().split(/[=:\s]/)[0];
+            if (p && !p.startsWith('...'))
+                out.add(`prop:${p}`);
+        }
+    // cva variant options: variants: { variant: { default: "…", success: "…" }, size: { sm: "…" } }
+    for (const m of code.matchAll(/\bvariants\s*:\s*\{([\s\S]*?)\n\s{0,4}\}/g))
+        for (const k of m[1].matchAll(/^\s*["']?([\w-]+)["']?\s*:/gm))
+            out.add(`variant:${k[1]}`);
+    return out;
+}
+/**
+ * An existing file at the destination that this file can't replace or reuse:
+ * - the same primitive in the other flavour (Radix vs Base UI `button.tsx`);
+ * - a different component with the same name (two libraries' `carousel.tsx`);
+ * - a version missing something the incoming one offers (a `size` prop, a badge
+ *   `success` variant) that the components being installed are likely to use.
+ * A user's styling edits keep the API, so their file is reused as before.
+ */
+export function clashes(existing, incoming) {
+    const a = flavour(existing);
+    const b = flavour(incoming);
+    if (a && b && a !== b)
+        return true;
+    if (similarity(existing, incoming) < DIFFERENT_COMPONENT)
+        return true;
+    const have = api(existing);
+    for (const x of api(incoming))
+        if (!have.has(x))
+            return true;
+    return false;
+}
+/** Folder for a clashing file: its flavour (`ui/base-ui/button.tsx`) or else its library (`ui/magicui/meteors.tsx`). */
+function clashFolder(existing, incoming, library) {
+    const a = flavour(existing);
+    const b = flavour(incoming);
+    return a && b && a !== b ? b : library;
+}
+function status(abs, content) {
+    if (!fs.existsSync(abs))
+        return 'new';
+    return fs.readFileSync(abs, 'utf8') === content ? 'identical' : 'modified';
+}
+function rel(project, abs) {
+    return toPosix(path.relative(project.cwd, abs));
+}
+/** Compute everything that would be written / installed, without touching disk. */
+export function planInstall(results, project) {
+    const warnings = [];
+    const allFiles = [];
+    const deps = new Set();
+    const devDeps = new Set();
+    const seen = new Set();
+    for (const r of results) {
+        warnings.push(...r.warnings);
+        for (const d of r.dependencies)
+            deps.add(d);
+        for (const d of r.devDependencies)
+            devDeps.add(d);
+        for (const f of r.files)
+            allFiles.push(f);
+    }
+    // Destinations + specifier map for internal imports.
+    const dest = new Map();
+    const fileMap = {};
+    const relocated = [];
+    for (const f of allFiles) {
+        let abs = destinationFor(f, project);
+        // Install a clashing file beside the existing one and point this install's
+        // imports at it; the project's own file stays as it is.
+        if (CODE_EXT.test(abs) && f.library !== 'external' && fs.existsSync(abs)) {
+            const existing = fs.readFileSync(abs, 'utf8');
+            if (clashes(existing, f.content)) {
+                const moved = path.join(path.dirname(abs), clashFolder(existing, f.content, f.library), path.basename(abs));
+                warnings.push(`${rel(project, abs)} already exists and is a different version; installed ${f.item}'s copy at ${rel(project, moved)}.`);
+                relocated.push([abs, moved]);
+                abs = moved;
+            }
+        }
+        dest.set(f, abs);
+        if (!CODE_EXT.test(abs))
+            continue;
+        const spec = specifierFor(abs, project);
+        for (const src of [f.path, f.target]) {
+            if (!src)
+                continue;
+            const clean = stripExt(src.replace(/^~?\/+/, '').replace(/^src\//, ''));
+            fileMap[`@/${clean}`] ??= spec;
+        }
+    }
+    // Components import shared files by their usual path (`@/components/ui/button`);
+    // send those imports to the relocated copies.
+    for (const [from, to] of relocated) {
+        const target = specifierFor(to, project);
+        fileMap[specifierFor(from, project)] = target;
+        const noExt = stripExt(from);
+        for (const [dir, canonical] of [[project.dirs.ui, '@/components/ui'], [project.dirs.components, '@/components'], [project.dirs.hooks, '@/hooks'], [project.dirs.lib, '@/lib']]) {
+            const r = within(dir, noExt);
+            if (r) {
+                fileMap[`${canonical}/${r}`] = target;
+                break;
+            }
+        }
+    }
+    // framer-motion was renamed to motion; if the project already uses motion, don't install both.
+    const preferMotion = project.installed.has('motion') && !project.installed.has('framer-motion');
+    let swappedMotion = false;
+    const files = [];
+    let usesUtils = false;
+    const undeclared = new Set();
+    for (const f of allFiles) {
+        const abs = dest.get(f);
+        if (seen.has(abs))
+            continue;
+        seen.add(abs);
+        let content = f.content;
+        if (CODE_EXT.test(abs)) {
+            content = transformIconPlaceholders(content);
+            if (/\.tsx?$/.test(abs))
+                content = importJsxNamespace(content);
+            content = rewriteImports(content, project.aliases, fileMap);
+            content = relativize(content, abs, project);
+            if (preferMotion) {
+                const swapped = content.replace(/(\bfrom\s*|\bimport\s*\(\s*|\bimport\s+)(['"])framer-motion\2/g, '$1$2motion/react$2');
+                if (swapped !== content)
+                    swappedMotion = true;
+                content = swapped;
+            }
+            if (!project.rsc)
+                content = content.replace(/^\s*(['"])use client\1;?\s*\n/, '');
+            if (content.includes(project.aliases.utils) || /from\s+['"][./]+[^'"]*lib\/utils['"]/.test(content))
+                usesUtils = true;
+            // Safety net: packages imported by the code but not declared by the registry item.
+            for (const spec of listImports(content)) {
+                if (/^(\.|\/|node:)/.test(spec) || spec.startsWith('@/') || (project.aliasPrefix && spec.startsWith(project.aliasPrefix)))
+                    continue;
+                const pkg = packageName(spec.startsWith('@') ? spec.split('/').slice(0, 2).join('/') : spec.split('/')[0]);
+                if (!pkg || IMPLICIT_PACKAGES.has(pkg) || project.installed.has(pkg) || /^[A-Z~#]/.test(pkg))
+                    continue;
+                if (![...deps].some((d) => packageName(d) === pkg)) {
+                    deps.add(pkg);
+                    undeclared.add(pkg);
+                }
+            }
+        }
+        files.push({ abs, rel: rel(project, abs), content, status: status(abs, content), item: f.item, kind: 'file' });
+    }
+    if (preferMotion) {
+        for (const d of [...deps])
+            if (packageName(d) === 'framer-motion')
+                deps.delete(d);
+        if (swappedMotion)
+            warnings.push('Imported from motion/react instead of framer-motion (your project already uses motion).');
+    }
+    if (undeclared.size)
+        warnings.push(`Added undeclared imports to packages: ${[...undeclared].sort().join(', ')}`);
+    // lib/utils
+    if (usesUtils && !fs.existsSync(project.utilsFile) && !seen.has(project.utilsFile)) {
+        files.unshift({ abs: project.utilsFile, rel: rel(project, project.utilsFile), content: UTILS_SOURCE, status: 'new', item: 'get-ui', kind: 'file', note: 'cn() helper' });
+        deps.add('clsx');
+        deps.add('tailwind-merge');
+    }
+    else if (usesUtils) {
+        deps.add('clsx');
+        deps.add('tailwind-merge');
+    }
+    // Global CSS
+    const cssVars = { theme: {}, light: {}, dark: {} };
+    const css = {};
+    for (const r of results) {
+        for (const k of ['theme', 'light', 'dark'])
+            Object.assign(cssVars[k], { ...r.cssVars[k], ...cssVars[k] });
+        for (const [k, v] of Object.entries(r.css))
+            if (!(k in css))
+                css[k] = v;
+    }
+    // shadcn-style components need shadcn's base tokens, which `shadcn init` normally adds.
+    // If the project never ran it, add them now (the project's own values always win).
+    if (project.tailwind.css && files.some((f) => CODE_EXT.test(f.abs) && usesShadcnTokens(f.content))) {
+        const sheet = fs.readFileSync(project.tailwind.css, 'utf8');
+        if (!hasShadcnTheme(sheet)) {
+            const v3 = project.tailwind.version === 3;
+            for (const k of ['light', 'dark'])
+                cssVars[k] = { ...SHADCN_BASE_THEME[k], ...cssVars[k] };
+            if (v3)
+                warnings.push('Tailwind v3: map the shadcn colors in tailwind.config (https://ui.shadcn.com/docs/installation/manual).');
+            else
+                cssVars.theme = { ...SHADCN_BASE_THEME.theme, ...cssVars.theme };
+            if (!v3 && !/@custom-variant\s+dark\b/.test(sheet))
+                Object.assign(css, SHADCN_BASE_CSS);
+        }
+    }
+    const hasCss = Object.values(cssVars).some((v) => Object.keys(v).length) || Object.keys(css).length;
+    if (hasCss) {
+        if (project.tailwind.css) {
+            const before = fs.readFileSync(project.tailwind.css, 'utf8');
+            const merged = mergeCss(before, { cssVars, css, tailwindVersion: project.tailwind.version });
+            warnings.push(...merged.warnings);
+            if (merged.changed)
+                files.push({
+                    abs: project.tailwind.css,
+                    rel: rel(project, project.tailwind.css),
+                    content: merged.css,
+                    status: 'modified',
+                    item: 'css',
+                    kind: 'css',
+                    note: merged.added.join('; '),
+                });
+        }
+        else {
+            warnings.push('No global CSS file found — add the component CSS variables / keyframes manually (see `get-ui view`).');
+        }
+    }
+    // Local imports that nothing provides (upstream registry bugs, e.g. a missing data file).
+    const planned = new Set(files.map((f) => f.abs));
+    const exists = (base) => ['', '.ts', '.tsx', '.js', '.jsx', '.json', '/index.ts', '/index.tsx', '/index.js'].some((e) => planned.has(base + e) || fs.existsSync(base + e));
+    for (const f of files) {
+        if (!CODE_EXT.test(f.abs))
+            continue;
+        for (const spec of listImports(f.content)) {
+            let base = null;
+            if (spec.startsWith('.'))
+                base = path.resolve(path.dirname(f.abs), spec);
+            else if (project.aliasPrefix && spec.startsWith(project.aliasPrefix))
+                base = path.join(project.baseDir, spec.slice(project.aliasPrefix.length));
+            if (base && !exists(base))
+                warnings.push(`${f.rel} imports "${spec}", which the registry doesn't provide — create it or adjust the import.`);
+        }
+    }
+    const missing = (list) => [...list].filter((d) => !project.installed.has(packageName(d))).sort();
+    const dependencies = missing(deps).map(withKnownMajor);
+    const devDependencies = missing(devDeps).filter((d) => !deps.has(d)).map(withKnownMajor);
+    return { files, dependencies, devDependencies, warnings: [...new Set(warnings)] };
+}
+export async function writePlan(plan, onConflict) {
+    const result = { written: [], skipped: [], unchanged: [] };
+    for (const f of plan.files) {
+        if (f.status === 'identical') {
+            result.unchanged.push(f);
+            continue;
+        }
+        if (f.status === 'modified' && f.kind === 'file') {
+            const decision = await onConflict(f);
+            if (decision === 'skip') {
+                result.skipped.push(f);
+                continue;
+            }
+        }
+        fs.mkdirSync(path.dirname(f.abs), { recursive: true });
+        fs.writeFileSync(f.abs, f.content);
+        result.written.push(f);
+    }
+    return result;
+}
+export function installCommand(pm, deps, dev = false) {
+    const verb = pm === 'npm' ? 'install' : 'add';
+    const devFlag = dev ? (pm === 'npm' ? '--save-dev' : '-D') : [];
+    return [pm, verb, ...[].concat(devFlag), ...deps];
+}
+export function runCommand(cmd, cwd) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(cmd[0], cmd.slice(1), { cwd, stdio: ['ignore', 'pipe', 'pipe'], shell: process.platform === 'win32' });
+        let stderr = '';
+        child.stderr?.on('data', (d) => (stderr += d));
+        child.stdout?.on('data', () => { });
+        child.on('error', reject);
+        child.on('close', (code) => (code === 0 ? resolve() : reject(new Error(`${cmd.join(' ')} exited with ${code}\n${stderr.slice(-2000)}`))));
+    });
+}

package/dist/node/project.d.ts

@@ -0,0 +1,34 @@
+import { type Aliases } from '../core/transform.js';
+export type PackageManager = 'npm' | 'pnpm' | 'yarn' | 'bun';
+export interface ProjectConfig {
+    cwd: string;
+    /** `cwd/src` when the project uses a src directory, else `cwd`. */
+    baseDir: string;
+    hasSrc: boolean;
+    /** Import specifiers used in written code. */
+    aliases: Aliases;
+    /** Absolute directories the aliases point to. */
+    dirs: {
+        components: string;
+        ui: string;
+        lib: string;
+        hooks: string;
+    };
+    utilsFile: string;
+    /** Prefix (`@/`) mapped to baseDir, or null when imports must be relative. */
+    aliasPrefix: string | null;
+    tailwind: {
+        version: 3 | 4 | null;
+        css: string | null;
+    };
+    packageManager: PackageManager;
+    rsc: boolean;
+    /** Packages already declared in package.json. */
+    installed: Set<string>;
+    hasPackageJson: boolean;
+    hasComponentsJson: boolean;
+    typescript: boolean;
+}
+/** Parse JSON with comments and trailing commas (tsconfig / jsconfig). */
+export declare function parseJsonc(text: string): any;
+export declare function detectProject(cwd: string): ProjectConfig;

package/dist/node/project.js

@@ -0,0 +1,227 @@
+// Detect the user's project layout: aliases, directories, Tailwind, package manager.
+import fs from 'node:fs';
+import path from 'node:path';
+import { DEFAULT_ALIASES } from '../core/transform.js';
+/** Parse JSON with comments and trailing commas (tsconfig / jsconfig). */
+export function parseJsonc(text) {
+    let out = '';
+    let inStr = false;
+    for (let i = 0; i < text.length; i++) {
+        const ch = text[i];
+        if (inStr) {
+            out += ch;
+            if (ch === '\\') {
+                out += text[++i] ?? '';
+            }
+            else if (ch === '"')
+                inStr = false;
+            continue;
+        }
+        if (ch === '"') {
+            inStr = true;
+            out += ch;
+        }
+        else if (ch === '/' && text[i + 1] === '/') {
+            while (i < text.length && text[i] !== '\n')
+                i++;
+            out += '\n';
+        }
+        else if (ch === '/' && text[i + 1] === '*') {
+            const end = text.indexOf('*/', i + 2);
+            i = end === -1 ? text.length : end + 1;
+        }
+        else
+            out += ch;
+    }
+    return JSON.parse(out.replace(/,(\s*[}\]])/g, '$1'));
+}
+function readJsonSafe(file, jsonc = false) {
+    try {
+        const text = fs.readFileSync(file, 'utf8');
+        return jsonc ? parseJsonc(text) : JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+}
+function readTsPaths(cwd) {
+    for (const name of ['tsconfig.json', 'jsconfig.json']) {
+        let file = path.join(cwd, name);
+        // Follow up to 3 levels of relative `extends`.
+        for (let depth = 0; depth < 4 && fs.existsSync(file); depth++) {
+            const cfg = readJsonSafe(file, true);
+            if (!cfg)
+                break;
+            const co = cfg.compilerOptions ?? {};
+            if (co.paths)
+                return { baseUrl: path.resolve(path.dirname(file), co.baseUrl ?? '.'), paths: co.paths };
+            if (typeof cfg.extends === 'string' && cfg.extends.startsWith('.')) {
+                file = path.resolve(path.dirname(file), cfg.extends);
+                if (!file.endsWith('.json'))
+                    file += '.json';
+            }
+            else
+                break;
+        }
+    }
+    return undefined;
+}
+/** Resolve an import alias like `@/components` to an absolute directory using tsconfig paths. */
+function aliasToDir(alias, ts, fallbackBase) {
+    if (ts) {
+        for (const [key, targets] of Object.entries(ts.paths)) {
+            if (!targets?.length)
+                continue;
+            if (key.endsWith('/*')) {
+                const prefix = key.slice(0, -1); // `@/`
+                if (alias.startsWith(prefix))
+                    return path.resolve(ts.baseUrl, targets[0].replace(/\*$/, ''), alias.slice(prefix.length));
+            }
+            else if (key === alias)
+                return path.resolve(ts.baseUrl, targets[0]);
+        }
+    }
+    return path.join(fallbackBase, alias.replace(/^[@~#$][^/]*\//, ''));
+}
+function detectPackageManager(cwd) {
+    let dir = cwd;
+    for (let i = 0; i < 5; i++) {
+        if (fs.existsSync(path.join(dir, 'pnpm-lock.yaml')))
+            return 'pnpm';
+        if (fs.existsSync(path.join(dir, 'bun.lockb')) || fs.existsSync(path.join(dir, 'bun.lock')))
+            return 'bun';
+        if (fs.existsSync(path.join(dir, 'yarn.lock')))
+            return 'yarn';
+        if (fs.existsSync(path.join(dir, 'package-lock.json')))
+            return 'npm';
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    const ua = process.env.npm_config_user_agent ?? '';
+    if (ua.startsWith('pnpm'))
+        return 'pnpm';
+    if (ua.startsWith('yarn'))
+        return 'yarn';
+    if (ua.startsWith('bun'))
+        return 'bun';
+    return 'npm';
+}
+const CSS_CANDIDATES = [
+    'app/globals.css',
+    'src/app/globals.css',
+    'styles/globals.css',
+    'src/styles/globals.css',
+    'app/global.css',
+    'src/app/global.css',
+    'src/index.css',
+    'src/styles.css',
+    'src/global.css',
+    'src/globals.css',
+    'app/app.css',
+    'src/app.css',
+    'app/styles/globals.css',
+    'styles/global.css',
+    'index.css',
+];
+export function detectProject(cwd) {
+    cwd = path.resolve(cwd);
+    const pkg = readJsonSafe(path.join(cwd, 'package.json')) ?? {};
+    const allDeps = { ...pkg.dependencies, ...pkg.devDependencies, ...pkg.peerDependencies };
+    const installed = new Set(Object.keys(allDeps));
+    const components = readJsonSafe(path.join(cwd, 'components.json'));
+    const ts = readTsPaths(cwd);
+    const hasSrc = fs.existsSync(path.join(cwd, 'src')) && fs.statSync(path.join(cwd, 'src')).isDirectory();
+    const baseDir = hasSrc ? path.join(cwd, 'src') : cwd;
+    // Find a wildcard alias that maps to baseDir (`@/*` -> `./src/*`).
+    let aliasPrefix = null;
+    if (ts) {
+        for (const [key, targets] of Object.entries(ts.paths)) {
+            if (!key.endsWith('/*') || !targets?.[0])
+                continue;
+            const dir = path.resolve(ts.baseUrl, targets[0].replace(/\*$/, ''));
+            if (dir === baseDir || (dir === cwd && !hasSrc)) {
+                aliasPrefix = key.slice(0, -1);
+                break;
+            }
+        }
+        if (!aliasPrefix && ts.paths['@/*'])
+            aliasPrefix = '@/';
+    }
+    let aliases;
+    if (components?.aliases) {
+        const a = components.aliases;
+        const comp = a.components ?? '@/components';
+        const prefix = comp.match(/^([^/]+\/)/)?.[1] ?? '@/';
+        aliases = {
+            components: comp,
+            ui: a.ui ?? `${comp}/ui`,
+            utils: a.utils ?? `${prefix}lib/utils`,
+            lib: a.lib ?? `${prefix}lib`,
+            hooks: a.hooks ?? `${prefix}hooks`,
+        };
+        if (!aliasPrefix)
+            aliasPrefix = prefix;
+    }
+    else {
+        const p = aliasPrefix ?? '@/';
+        aliases = {
+            components: `${p}components`,
+            ui: `${p}components/ui`,
+            utils: `${p}lib/utils`,
+            lib: `${p}lib`,
+            hooks: `${p}hooks`,
+        };
+    }
+    if (!aliasPrefix && !components)
+        aliases = { ...DEFAULT_ALIASES };
+    const dirs = {
+        components: aliasToDir(aliases.components, ts, baseDir),
+        ui: aliasToDir(aliases.ui, ts, baseDir),
+        lib: aliasToDir(aliases.lib, ts, baseDir),
+        hooks: aliasToDir(aliases.hooks, ts, baseDir),
+    };
+    const utilsBase = aliasToDir(aliases.utils, ts, baseDir);
+    const utilsFile = ['.ts', '.tsx', '.js', '.jsx'].map((e) => utilsBase + e).find((f) => fs.existsSync(f)) ?? `${utilsBase}.ts`;
+    // Tailwind
+    let cssFile = components?.tailwind?.css ? path.resolve(cwd, components.tailwind.css) : null;
+    if (cssFile && !fs.existsSync(cssFile))
+        cssFile = null;
+    if (!cssFile)
+        cssFile = CSS_CANDIDATES.map((c) => path.join(cwd, c)).find((f) => fs.existsSync(f)) ?? null;
+    let version = null;
+    const twRange = allDeps.tailwindcss;
+    if (twRange) {
+        const m = twRange.match(/(\d+)/);
+        if (m)
+            version = Number(m[1]) >= 4 ? 4 : 3;
+        if (/latest|next/.test(twRange))
+            version = 4;
+    }
+    if (cssFile) {
+        const text = fs.readFileSync(cssFile, 'utf8');
+        if (/@import\s+["']tailwindcss/.test(text))
+            version = 4;
+        else if (!version && /@tailwind\s+base/.test(text))
+            version = 3;
+    }
+    if (!version && components?.tailwind?.config)
+        version = 3;
+    return {
+        cwd,
+        baseDir,
+        hasSrc,
+        aliases,
+        dirs,
+        utilsFile,
+        aliasPrefix,
+        tailwind: { version, css: cssFile },
+        packageManager: detectPackageManager(cwd),
+        rsc: components ? !!components.rsc : installed.has('next'),
+        installed,
+        hasPackageJson: fs.existsSync(path.join(cwd, 'package.json')),
+        hasComponentsJson: !!components,
+        typescript: !!ts || fs.existsSync(path.join(cwd, 'tsconfig.json')) || installed.has('typescript'),
+    };
+}

package/dist/node/registry.d.ts

@@ -0,0 +1,10 @@
+import type { Registry } from '../registry-types.js';
+export declare const REGISTRY_URL = "https://raw.githubusercontent.com/yashjaiswal2818/getui/main/registry/index.json";
+export declare function cacheFile(): string;
+export interface LoadedRegistry {
+    registry: Registry;
+    source: 'remote' | 'cache' | 'bundled' | 'override';
+}
+export declare function loadRegistry(opts?: {
+    refresh?: boolean;
+}): Promise<LoadedRegistry>;