get-ui-cli 0.0.0-stage → 2.0.0

package/dist/core/resolve.js

@@ -0,0 +1,390 @@
+// Resolve a registry item (and, recursively, its registryDependencies) into a flat
+// list of files + npm dependencies + CSS. Pure — only uses `fetch`.
+import { LIBRARIES } from '../registry-types.js';
+export const SHADCN_BASE = 'https://ui.shadcn.com/r/styles/new-york-v4/';
+export const SHADCN_REGISTRIES_URL = 'https://ui.shadcn.com/r/registries.json';
+/**
+ * shadcn style used when a bare dependency is not served by the item's own library.
+ * ReUI is built on Base UI, so its blocks expect the Base UI flavour of shadcn components.
+ */
+const SHADCN_FALLBACK_STYLE = {
+    reui: 'https://ui.shadcn.com/r/styles/base-nova/',
+};
+export class FetchError extends Error {
+    status;
+    url;
+    constructor(message, status, url) {
+        super(message);
+        this.status = status;
+        this.url = url;
+    }
+}
+const SKIP_DEPS = new Set(['utils', 'cn']);
+/** `motion@^11` -> `motion`, `@scope/pkg@1` -> `@scope/pkg` */
+export function packageName(dep) {
+    if (dep.startsWith('@')) {
+        const i = dep.indexOf('@', 1);
+        return i === -1 ? dep : dep.slice(0, i);
+    }
+    const i = dep.indexOf('@');
+    return i === -1 ? dep : dep.slice(0, i);
+}
+function contextFor(lib) {
+    if (!lib || !lib.itemBase)
+        return { libraryId: lib?.id ?? 'external', itemBase: SHADCN_BASE, fallbackBase: SHADCN_BASE };
+    return { libraryId: lib.id, itemBase: lib.itemBase, fallbackBase: SHADCN_FALLBACK_STYLE[lib.id] ?? SHADCN_BASE };
+}
+function libraryForUrl(registry, url) {
+    return Object.values(registry.libraries).find((l) => l.itemBase && url.startsWith(l.itemBase));
+}
+function labelForUrl(registry, url) {
+    const lib = libraryForUrl(registry, url);
+    const name = url.split('/').pop().replace(/\.json(\?.*)?$/, '');
+    if (lib)
+        return `${lib.id}/${name}`;
+    if (url.startsWith('https://ui.shadcn.com/r/styles/'))
+        return `shadcn/${name}`;
+    return url;
+}
+function isItemJson(x) {
+    return !!x && typeof x === 'object' && !Array.isArray(x) && (Array.isArray(x.files) || 'type' in x);
+}
+/** Run async tasks with a concurrency limit. */
+async function pool(items, limit, fn) {
+    const out = new Array(items.length);
+    let next = 0;
+    const workers = Array.from({ length: Math.min(limit, items.length) }, async () => {
+        while (next < items.length) {
+            const i = next++;
+            out[i] = await fn(items[i]);
+        }
+    });
+    await Promise.all(workers);
+    return out;
+}
+export function createFetcher(opts = {}) {
+    const f = opts.fetch ?? globalThis.fetch;
+    const cache = opts.cache ?? new Map();
+    const timeoutMs = opts.timeoutMs ?? 20_000;
+    async function raw(url) {
+        for (let attempt = 0;; attempt++) {
+            const controller = typeof AbortController !== 'undefined' ? new AbortController() : undefined;
+            const timer = controller ? setTimeout(() => controller.abort(), timeoutMs) : undefined;
+            let res;
+            try {
+                res = await f(url, { headers: { accept: 'application/json, text/plain, */*', ...opts.headers?.(url) }, signal: controller?.signal });
+            }
+            catch (e) {
+                if (attempt < 2)
+                    continue;
+                throw new FetchError(`Network error fetching ${url}: ${e.message}`, 0, url);
+            }
+            finally {
+                if (timer)
+                    clearTimeout(timer);
+            }
+            // Back off on rate limits / transient server errors.
+            if ((res.status === 429 || res.status >= 502) && attempt < 3) {
+                const retryAfter = Number(res.headers.get('retry-after'));
+                const wait = Number.isFinite(retryAfter) && retryAfter > 0 ? Math.min(retryAfter, 10) * 1000 : 800 * 2 ** attempt;
+                await new Promise((r) => setTimeout(r, wait));
+                continue;
+            }
+            return res;
+        }
+    }
+    function cached(key, load) {
+        let p = cache.get(key);
+        if (!p) {
+            p = load();
+            cache.set(key, p);
+            p.catch(() => cache.delete(key));
+        }
+        return p;
+    }
+    return {
+        json(url) {
+            return cached(`json:${url}`, async () => {
+                const res = await raw(url);
+                if (!res.ok) {
+                    let detail = '';
+                    try {
+                        const body = (await res.json());
+                        const pickStr = (v) => (typeof v === 'string' ? v : v && typeof v === 'object' && typeof v.message === 'string' ? v.message : '');
+                        detail = pickStr(body.message) || pickStr(body.error);
+                    }
+                    catch {
+                        /* ignore */
+                    }
+                    throw new FetchError(`${res.status} ${res.statusText || ''} for ${url}${detail ? ` — ${detail}` : ''}`.trim(), res.status, url);
+                }
+                const text = await res.text();
+                try {
+                    return JSON.parse(text);
+                }
+                catch {
+                    throw new FetchError(`Not a JSON registry item: ${url}`, 404, url);
+                }
+            });
+        },
+        text(url) {
+            return cached(`text:${url}`, async () => {
+                const res = await raw(url);
+                if (!res.ok)
+                    throw new FetchError(`${res.status} ${res.statusText || ''} for ${url}`.trim(), res.status, url);
+                return res.text();
+            });
+        },
+    };
+}
+const LOCAL_IMPORT_RE = /(?:\bfrom\s*|\bimport\s*\(\s*|\bimport\s+)['"](\.{1,2}\/[^'"]+)['"]/g;
+const LOCAL_EXTS = ['.ts', '.tsx', '.js', '.jsx', '/index.ts', '/index.tsx'];
+const noExt = (p) => p.replace(/^\/+/, '').replace(/\.(tsx?|jsx?)$/, '');
+/** Resolve a relative import against a file's path, POSIX-style (core stays free of node:path). */
+function joinRelative(file, spec) {
+    const out = file.replace(/^\/+/, '').split('/').slice(0, -1);
+    for (const seg of spec.split('/')) {
+        if (seg === '..')
+            out.pop();
+        else if (seg !== '.' && seg)
+            out.push(seg);
+    }
+    return out.join('/');
+}
+/**
+ * Some items import local files (a hook, a helper) that their registry entry
+ * forgot to ship. For libraries with a public source repo, fetch those files
+ * from the repo and place them where the relative import expects them.
+ */
+async function fetchUnshippedLocals(fetcher, files, warnings) {
+    const have = new Set(files.flatMap((f) => [noExt(f.path), ...(f.target ? [noExt(f.target)] : [])]));
+    const tried = new Set();
+    for (let i = 0; i < files.length; i++) {
+        const f = files[i];
+        const sourceBase = f.library === 'external' ? undefined : LIBRARIES[f.library]?.sourceBase;
+        if (!sourceBase)
+            continue;
+        for (const m of f.content.matchAll(LOCAL_IMPORT_RE)) {
+            const spec = m[1];
+            const repoPath = noExt(joinRelative(f.path, spec));
+            const targetPath = f.target ? noExt(joinRelative(f.target, spec)) : undefined;
+            if (have.has(repoPath) || (targetPath && have.has(targetPath)) || tried.has(repoPath))
+                continue;
+            tried.add(repoPath);
+            let found;
+            for (const ext of LOCAL_EXTS) {
+                try {
+                    found = { ext, content: await fetcher.text(`${sourceBase}${repoPath}${ext}`) };
+                    break;
+                }
+                catch {
+                    /* try the next extension */
+                }
+            }
+            if (!found)
+                continue; // planInstall warns about imports nothing provides.
+            have.add(repoPath);
+            if (targetPath)
+                have.add(targetPath);
+            // Appended, so this loop also visits the new file's own imports.
+            files.push({
+                path: `${repoPath}${found.ext}`,
+                content: found.content,
+                type: 'registry:file',
+                target: targetPath ? `${targetPath}${found.ext}` : undefined,
+                item: f.item,
+                library: f.library,
+            });
+            warnings.push(`${f.item}: fetched ${spec} from the library's repo (its registry entry doesn't include it).`);
+        }
+    }
+}
+let registriesDirectory;
+async function lookupNamespace(fetcher, ns) {
+    registriesDirectory ??= fetcher
+        .json(SHADCN_REGISTRIES_URL)
+        .then((r) => (Array.isArray(r) ? r : []))
+        .catch(() => []);
+    const list = await registriesDirectory;
+    return list.find((r) => r.name === ns)?.url;
+}
+/**
+ * Fetch an item and all of its registryDependencies (recursively, deduped,
+ * cycle-safe, concurrently).
+ */
+export async function resolveItem(registry, item, opts = {}) {
+    const fetcher = createFetcher(opts);
+    const warnings = [];
+    const tree = [];
+    const deps = new Set();
+    const devDeps = new Set();
+    const cssVars = { theme: {}, light: {}, dark: {} };
+    const css = {};
+    const files = [];
+    const seenFiles = new Set();
+    const visited = new Set();
+    const concurrency = opts.concurrency ?? 8;
+    const rootCtx = contextFor(registry.libraries[item.library]);
+    async function fetchNode(node, root) {
+        try {
+            const data = await fetcher.json(node.url);
+            if (!isItemJson(data))
+                throw new FetchError(`Not a registry item: ${node.url}`, 404, node.url);
+            return { data, node };
+        }
+        catch (e) {
+            if (root)
+                throw e;
+            warnings.push(`Could not fetch ${node.label}: ${e.message}`);
+            return null;
+        }
+    }
+    /** Resolve a registryDependency string to a node; may probe the library before falling back to shadcn. */
+    async function resolveDep(dep, ctx) {
+        dep = dep.trim();
+        if (!dep || SKIP_DEPS.has(dep))
+            return null;
+        if (/^https?:\/\//.test(dep)) {
+            const l = libraryForUrl(registry, dep);
+            const c = l ? contextFor(l) : { libraryId: 'external', itemBase: dep.slice(0, dep.lastIndexOf('/') + 1), fallbackBase: SHADCN_BASE };
+            return { url: dep, label: labelForUrl(registry, dep), ctx: c };
+        }
+        const nsMatch = dep.match(/^(@[^/]+)\/(.+)$/);
+        if (nsMatch) {
+            const [, ns, name] = nsMatch;
+            if (ns === '@shadcn')
+                return { url: `${SHADCN_BASE}${name}.json`, label: `shadcn/${name}`, ctx: contextFor(registry.libraries.shadcn) };
+            const l = Object.values(registry.libraries).find((x) => x.namespace === ns);
+            if (l?.itemBase)
+                return { url: `${l.itemBase}${name}.json`, label: `${l.id}/${name}`, ctx: contextFor(l) };
+            const template = await lookupNamespace(fetcher, ns);
+            if (!template) {
+                warnings.push(`Unknown registry namespace ${ns} (needed for ${dep}).`);
+                return null;
+            }
+            const url = template.replace('{name}', name).replace('{style}', 'new-york-v4');
+            return { url, label: dep, ctx: { libraryId: 'external', itemBase: url.slice(0, url.lastIndexOf('/') + 1), fallbackBase: SHADCN_BASE } };
+        }
+        // Bare name: try the library first, then shadcn.
+        const own = `${ctx.itemBase}${dep}.json`;
+        if (ctx.itemBase !== ctx.fallbackBase) {
+            try {
+                const data = await fetcher.json(own);
+                if (isItemJson(data))
+                    return { url: own, label: labelForUrl(registry, own), ctx };
+            }
+            catch (e) {
+                if (e instanceof FetchError && (e.status === 401 || e.status === 403)) {
+                    warnings.push(`${labelForUrl(registry, own)} requires authentication: ${e.message}`);
+                    return null;
+                }
+            }
+        }
+        const fb = `${ctx.fallbackBase}${dep}.json`;
+        const shadcnCtx = { libraryId: 'shadcn', itemBase: ctx.fallbackBase, fallbackBase: ctx.fallbackBase };
+        return { url: fb, label: `shadcn/${dep}`, ctx: shadcnCtx };
+    }
+    function absorb(data, node) {
+        tree.push(node.label);
+        for (const d of data.dependencies ?? [])
+            if (!SKIP_DEPS.has(packageName(d)))
+                deps.add(d);
+        for (const d of data.devDependencies ?? [])
+            if (!SKIP_DEPS.has(packageName(d)))
+                devDeps.add(d);
+        for (const key of ['theme', 'light', 'dark']) {
+            for (const [k, v] of Object.entries(data.cssVars?.[key] ?? {}))
+                if (!(k in cssVars[key]))
+                    cssVars[key][k] = v;
+        }
+        for (const [k, v] of Object.entries(data.css ?? {}))
+            if (!(k in css))
+                css[k] = v;
+        for (const f of data.files ?? []) {
+            const key = (f.target ?? f.path).replace(/^\/+/, '');
+            if (seenFiles.has(key))
+                continue;
+            seenFiles.add(key);
+            if (typeof f.content !== 'string') {
+                warnings.push(`${node.label}: file ${f.path} has no content — skipped.`);
+                continue;
+            }
+            files.push({
+                path: f.path,
+                content: f.content,
+                type: f.type ?? data.type ?? 'registry:component',
+                target: f.target || undefined,
+                item: node.label,
+                library: node.ctx.libraryId,
+            });
+        }
+    }
+    // BFS by levels, fetching each level concurrently.
+    let level = [
+        { node: { url: item.source, label: item.id, ctx: rootCtx }, root: true },
+    ];
+    visited.add(item.source);
+    // Imports of sibling components that an item uses but forgot to declare.
+    const implicit = [];
+    const triedImplicit = new Set();
+    const provided = () => new Set(files.map((f) => f.path.split('/').pop().replace(/\.(tsx?|jsx?)$/, '')));
+    const IMPLICIT_RE = /from\s+["']@\/(?:components\/ui\/([\w-]+)|registry\/(?:[^"'/]+\/)*?ui\/([\w-]+)|registry\/[^"'/]+\/([\w-]+))["']/g;
+    for (;;) {
+        while (level.length) {
+            const fetched = await pool(level, concurrency, ({ node, root }) => fetchNode(node, root));
+            const pending = [];
+            for (const r of fetched) {
+                if (!r)
+                    continue;
+                absorb(r.data, r.node);
+                for (const dep of r.data.registryDependencies ?? [])
+                    pending.push({ dep, ctx: r.node.ctx });
+                for (const f of r.data.files ?? [])
+                    for (const m of (f.content ?? '').matchAll(IMPLICIT_RE))
+                        implicit.push({ dep: m[1] ?? m[2] ?? m[3], ctx: r.node.ctx });
+            }
+            // Dedupe by dep string + context before probing.
+            const uniq = new Map();
+            for (const p of pending)
+                uniq.set(`${p.ctx.itemBase}|${p.dep}`, p);
+            const nodes = await pool([...uniq.values()], concurrency, ({ dep, ctx }) => resolveDep(dep, ctx));
+            level = [];
+            for (const n of nodes) {
+                if (!n || visited.has(n.url))
+                    continue;
+                visited.add(n.url);
+                level.push({ node: n, root: false });
+            }
+        }
+        // Second pass: undeclared component imports (e.g. a dialog importing ui/button).
+        const have = provided();
+        const missing = implicit.filter(({ dep, ctx }) => {
+            const key = `${ctx.itemBase}|${dep}`;
+            if (have.has(dep) || triedImplicit.has(key))
+                return false;
+            triedImplicit.add(key);
+            return true;
+        });
+        if (!missing.length)
+            break;
+        const nodes = await pool(missing, concurrency, ({ dep, ctx }) => resolveDep(dep, ctx));
+        for (const n of nodes) {
+            if (!n || visited.has(n.url))
+                continue;
+            visited.add(n.url);
+            level.push({ node: n, root: false });
+        }
+        if (!level.length)
+            break;
+    }
+    await fetchUnshippedLocals(fetcher, files, warnings);
+    return {
+        files,
+        dependencies: [...deps].sort(),
+        devDependencies: [...devDeps].filter((d) => !deps.has(d)).sort(),
+        cssVars: Object.fromEntries(Object.entries(cssVars).filter(([, v]) => Object.keys(v).length)),
+        css,
+        warnings,
+        tree,
+    };
+}

package/dist/core/search.d.ts

@@ -0,0 +1,17 @@
+import type { ItemKind, LibraryId, RegistryItem } from '../registry-types.js';
+export interface SearchOptions {
+    library?: LibraryId | string;
+    category?: string;
+    kind?: ItemKind | string;
+    limit?: number;
+}
+export interface SearchResult {
+    item: RegistryItem;
+    score: number;
+}
+export declare function scoreItem(item: RegistryItem, query: string): number;
+export declare function searchItemsScored(items: RegistryItem[], query: string, opts?: SearchOptions): SearchResult[];
+/** Ranked fuzzy search (exact id > name prefix > word match > subsequence). */
+export declare function searchItems(items: RegistryItem[], query: string, opts?: SearchOptions): RegistryItem[];
+/** Exact lookup by id (`magicui/marquee`) or unique bare name (`marquee`). */
+export declare function findExact(items: RegistryItem[], query: string, library?: string): RegistryItem | undefined;

package/dist/core/search.js

@@ -0,0 +1,130 @@
+// Ranked fuzzy search over registry items. Pure — safe to use in the browser.
+const indexCache = new WeakMap();
+function norm(s) {
+    return (s ?? '').toLowerCase();
+}
+function index(item) {
+    let ix = indexCache.get(item);
+    if (!ix) {
+        const name = norm(item.name);
+        const title = norm(item.title);
+        ix = {
+            id: norm(item.id),
+            name,
+            title,
+            description: norm(item.description),
+            category: norm(item.category),
+            library: norm(item.library),
+            words: `${name} ${title}`.split(/[^a-z0-9]+/).filter(Boolean),
+        };
+        indexCache.set(item, ix);
+    }
+    return ix;
+}
+/** Returns a score > 0 when `needle` is a subsequence of `hay` (tighter = higher). */
+function subsequence(needle, hay) {
+    if (!needle)
+        return 0;
+    let h = 0;
+    let gaps = 0;
+    let last = -1;
+    for (const ch of needle) {
+        const found = hay.indexOf(ch, h);
+        if (found === -1)
+            return 0;
+        if (last !== -1)
+            gaps += found - last - 1;
+        last = found;
+        h = found + 1;
+    }
+    return Math.max(1, 100 - gaps * 2 - (hay.length - needle.length) * 0.2);
+}
+export function scoreItem(item, query) {
+    const q = norm(query).trim();
+    if (!q)
+        return 1;
+    const ix = index(item);
+    if (ix.id === q)
+        return 10_000;
+    if (ix.name === q)
+        return 9_000;
+    if (ix.title === q)
+        return 8_500;
+    let score = 0;
+    if (ix.name.startsWith(q))
+        score = Math.max(score, 7_000 - ix.name.length);
+    if (ix.title.startsWith(q))
+        score = Math.max(score, 6_500 - ix.title.length);
+    if (ix.id.endsWith('/' + q))
+        score = Math.max(score, 8_000);
+    // Word matching: every query token must match somewhere.
+    const tokens = q.split(/[\s/_-]+/).filter(Boolean);
+    if (tokens.length) {
+        let sum = 0;
+        let all = true;
+        for (const t of tokens) {
+            let best = 0;
+            if (ix.words.some((w) => w === t))
+                best = 80;
+            else if (ix.words.some((w) => w.startsWith(t)))
+                best = 60;
+            else if (ix.name.includes(t) || ix.title.includes(t))
+                best = 40;
+            else if (ix.category.includes(t))
+                best = 30;
+            else if (ix.library.includes(t))
+                best = 25;
+            else if (ix.description.includes(t))
+                best = 10;
+            if (!best) {
+                all = false;
+                break;
+            }
+            sum += best;
+        }
+        if (all)
+            score = Math.max(score, 1_000 + (sum / tokens.length) * 10 - ix.title.length * 0.5);
+    }
+    if (!score) {
+        const compact = q.replace(/\s+/g, '');
+        const s = Math.max(subsequence(compact, ix.name), subsequence(compact, ix.title));
+        if (s > 0)
+            score = s;
+    }
+    return score;
+}
+function matchesFilters(item, opts) {
+    if (opts.library && item.library !== opts.library)
+        return false;
+    if (opts.category && norm(item.category) !== norm(opts.category))
+        return false;
+    if (opts.kind && item.kind !== opts.kind)
+        return false;
+    return true;
+}
+export function searchItemsScored(items, query, opts = {}) {
+    const limit = opts.limit ?? 20;
+    const out = [];
+    for (const item of items) {
+        if (!matchesFilters(item, opts))
+            continue;
+        const score = scoreItem(item, query);
+        if (score > 0)
+            out.push({ item, score });
+    }
+    out.sort((a, b) => b.score - a.score || a.item.id.localeCompare(b.item.id));
+    return limit > 0 ? out.slice(0, limit) : out;
+}
+/** Ranked fuzzy search (exact id > name prefix > word match > subsequence). */
+export function searchItems(items, query, opts = {}) {
+    return searchItemsScored(items, query, opts).map((r) => r.item);
+}
+/** Exact lookup by id (`magicui/marquee`) or unique bare name (`marquee`). */
+export function findExact(items, query, library) {
+    const q = norm(query).trim();
+    const byId = items.find((i) => norm(i.id) === q);
+    if (byId)
+        return byId;
+    const byName = items.filter((i) => norm(i.name) === q && (!library || i.library === library));
+    return byName.length === 1 ? byName[0] : undefined;
+}

package/dist/core/shadcn-theme.d.ts

@@ -0,0 +1,8 @@
+import type { CssTree, CssVars } from './resolve.js';
+export declare const SHADCN_BASE_THEME: Required<CssVars>;
+/** Lets `dark:` follow a `.dark` class, as shadcn's theme expects. */
+export declare const SHADCN_BASE_CSS: CssTree;
+/** Does this code style itself with shadcn theme tokens? */
+export declare const usesShadcnTokens: (code: string) => boolean;
+/** Does this stylesheet already define the shadcn tokens (or its own `--primary`)? */
+export declare const hasShadcnTheme: (css: string) => boolean;

package/dist/core/shadcn-theme.js

@@ -0,0 +1,52 @@
+// shadcn/ui's base theme (new-york-v4, neutral). Components across the shadcn
+// ecosystem style themselves with these tokens (`bg-primary`, `border-input`, …)
+// but registry items don't ship them: `shadcn init` normally adds them once.
+// get-ui adds them on first install when a project doesn't have them. Pure.
+const LIGHT = {
+    radius: '0.625rem',
+    background: 'oklch(1 0 0)', foreground: 'oklch(0.145 0 0)',
+    card: 'oklch(1 0 0)', 'card-foreground': 'oklch(0.145 0 0)',
+    popover: 'oklch(1 0 0)', 'popover-foreground': 'oklch(0.145 0 0)',
+    primary: 'oklch(0.205 0 0)', 'primary-foreground': 'oklch(0.985 0 0)',
+    secondary: 'oklch(0.97 0 0)', 'secondary-foreground': 'oklch(0.205 0 0)',
+    muted: 'oklch(0.97 0 0)', 'muted-foreground': 'oklch(0.556 0 0)',
+    accent: 'oklch(0.97 0 0)', 'accent-foreground': 'oklch(0.205 0 0)',
+    destructive: 'oklch(0.577 0.245 27.325)',
+    border: 'oklch(0.922 0 0)', input: 'oklch(0.922 0 0)', ring: 'oklch(0.708 0 0)',
+    'chart-1': 'oklch(0.646 0.222 41.116)', 'chart-2': 'oklch(0.6 0.118 184.704)', 'chart-3': 'oklch(0.398 0.07 227.392)',
+    'chart-4': 'oklch(0.828 0.189 84.429)', 'chart-5': 'oklch(0.769 0.188 70.08)',
+    sidebar: 'oklch(0.985 0 0)', 'sidebar-foreground': 'oklch(0.145 0 0)', 'sidebar-primary': 'oklch(0.205 0 0)',
+    'sidebar-primary-foreground': 'oklch(0.985 0 0)', 'sidebar-accent': 'oklch(0.97 0 0)', 'sidebar-accent-foreground': 'oklch(0.205 0 0)',
+    'sidebar-border': 'oklch(0.922 0 0)', 'sidebar-ring': 'oklch(0.708 0 0)',
+};
+const DARK = {
+    background: 'oklch(0.145 0 0)', foreground: 'oklch(0.985 0 0)',
+    card: 'oklch(0.205 0 0)', 'card-foreground': 'oklch(0.985 0 0)',
+    popover: 'oklch(0.205 0 0)', 'popover-foreground': 'oklch(0.985 0 0)',
+    primary: 'oklch(0.922 0 0)', 'primary-foreground': 'oklch(0.205 0 0)',
+    secondary: 'oklch(0.269 0 0)', 'secondary-foreground': 'oklch(0.985 0 0)',
+    muted: 'oklch(0.269 0 0)', 'muted-foreground': 'oklch(0.708 0 0)',
+    accent: 'oklch(0.269 0 0)', 'accent-foreground': 'oklch(0.985 0 0)',
+    destructive: 'oklch(0.704 0.191 22.216)',
+    border: 'oklch(1 0 0 / 10%)', input: 'oklch(1 0 0 / 15%)', ring: 'oklch(0.556 0 0)',
+    sidebar: 'oklch(0.205 0 0)', 'sidebar-foreground': 'oklch(0.985 0 0)', 'sidebar-primary': 'oklch(0.488 0.243 264.376)',
+    'sidebar-primary-foreground': 'oklch(0.985 0 0)', 'sidebar-accent': 'oklch(0.269 0 0)', 'sidebar-accent-foreground': 'oklch(0.985 0 0)',
+    'sidebar-border': 'oklch(1 0 0 / 10%)', 'sidebar-ring': 'oklch(0.556 0 0)',
+};
+/** Tailwind v4 `@theme inline` mappings so `bg-primary` etc. resolve to the variables. */
+const THEME = {
+    'radius-sm': 'calc(var(--radius) - 4px)',
+    'radius-md': 'calc(var(--radius) - 2px)',
+    'radius-lg': 'var(--radius)',
+    'radius-xl': 'calc(var(--radius) + 4px)',
+    ...Object.fromEntries(Object.keys(LIGHT).filter((k) => k !== 'radius').map((k) => [`color-${k}`, `var(--${k})`])),
+};
+export const SHADCN_BASE_THEME = { theme: THEME, light: LIGHT, dark: DARK };
+/** Lets `dark:` follow a `.dark` class, as shadcn's theme expects. */
+export const SHADCN_BASE_CSS = { '@custom-variant dark (&:is(.dark *))': {} };
+const TOKENS = Object.keys(LIGHT).filter((k) => k !== 'radius').join('|');
+const TOKEN_CLASS = new RegExp(`(?:^|[\\s"'\`:])(?:bg|text|border|ring|outline|fill|stroke|from|to|via|divide|placeholder|caret|accent|decoration|shadow)-(?:${TOKENS})(?![\\w-])`);
+/** Does this code style itself with shadcn theme tokens? */
+export const usesShadcnTokens = (code) => TOKEN_CLASS.test(code);
+/** Does this stylesheet already define the shadcn tokens (or its own `--primary`)? */
+export const hasShadcnTheme = (css) => /--primary\s*:/.test(css) || /--color-primary\s*:/.test(css);

package/dist/core/transform.d.ts

@@ -0,0 +1,33 @@
+export interface Aliases {
+    /** e.g. `@/components` */
+    components: string;
+    /** e.g. `@/components/ui` */
+    ui: string;
+    /** e.g. `@/lib/utils` */
+    utils: string;
+    /** e.g. `@/lib` */
+    lib: string;
+    /** e.g. `@/hooks` */
+    hooks: string;
+}
+export declare const DEFAULT_ALIASES: Aliases;
+/**
+ * Map one module specifier from registry-internal form to the user's aliases.
+ * `fileMap` maps specifiers of files that are being installed (derived from their
+ * registry `path`/`target`) to where they will actually live.
+ */
+export declare function mapSpecifier(spec: string, aliases: Aliases, fileMap?: Record<string, string>): string;
+/** Rewrite all import/export/require specifiers in `code`. */
+export declare function rewriteImports(code: string, aliases: Aliases, fileMap?: Record<string, string>): string;
+/** List module specifiers imported by `code`. */
+export declare function listImports(code: string): string[];
+/**
+ * Replace `<IconPlaceholder lucide="CheckIcon" tabler="…" … />` with `<CheckIcon … />`
+ * and swap the placeholder import for a lucide-react import.
+ */
+export declare function transformIconPlaceholders(code: string): string;
+/**
+ * React 19's types dropped the global `JSX` namespace, so `JSX.Element` in older
+ * components fails to type-check. Import the namespace from react where it's used.
+ */
+export declare function importJsxNamespace(code: string): string;