advui 0.1.0

package/LICENSE

@@ -0,0 +1,49 @@
+MIT License
+
+Copyright (c) 2026 Universal UI contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+---------------------------------------------------------------------------
+
+Third-party notices
+
+Icons in packages/icons are generated from Lucide (https://lucide.dev),
+licensed under the ISC License:
+
+  ISC License
+  Copyright (c) for portions of Lucide are held by Cole Bemis 2013-2022 as part
+  of Feather (MIT). All other copyright (c) for Lucide are held by Lucide
+  Contributors 2022.
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+  SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
+  OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+  CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+Color scales in packages/theme are based on Radix Colors
+(https://github.com/radix-ui/colors), licensed under the MIT License,
+Copyright (c) 2022 WorkOS.

package/README.md

@@ -0,0 +1,21 @@
+# advui (CLI)
+
+Copy Adv UI component source into your project, shadcn-style.
+
+```bash
+npx advui init                      # detect framework, write config, install base packages
+npx advui add button dialog         # add components (dependencies resolved)
+npx advui add --all
+npx advui list
+```
+
+| Option                                       | Description                                                                        |
+| -------------------------------------------- | ---------------------------------------------------------------------------------- |
+| `--registry <url or path>`                   | Registry to read (default: `advui.json`, then https://zinmin232.github.io/advui/r) |
+| `--cwd <path>`                               | Project directory                                                                  |
+| `--framework next\|expo\|react-native\|vite` | Skip detection in `init`                                                           |
+| `--no-install`                               | Print the install command instead of running it                                    |
+| `--overwrite`                                | Replace existing files                                                             |
+
+The registry is generated from component metadata by `pnpm registry:build` in
+the monorepo. License: MIT.

package/dist/commands.js

@@ -0,0 +1,126 @@
+import { execSync } from 'node:child_process';
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { dirname, join, relative } from 'node:path';
+import { defaultConfig, readConfig, writeConfig } from './config.js';
+import { BASE_DEPENDENCIES, CLI_NAME, CONFIG_FILE, DEFAULT_REGISTRY, PACKAGE_SCOPE, PRODUCT_NAME, } from './constants.js';
+import { detectProject, installCommand } from './project.js';
+import { collectDependencies, fetchRegistryJson, resolveItems, } from './registry.js';
+const frameworkPeers = {
+    next: ['react-native-web', 'react-native'],
+    expo: ['react-native-svg'],
+    'react-native': ['react-native-svg'],
+    vite: ['react-native-web', 'react-native'],
+    unknown: [],
+};
+const setupNotes = {
+    next: `Next.js: add to next.config.ts
+  transpilePackages: ['${PACKAGE_SCOPE}/theme', '${PACKAGE_SCOPE}/icons', '${PACKAGE_SCOPE}/utils', 'react-native-web'],
+  turbopack: { resolveAlias: { 'react-native': 'react-native-web' },
+    resolveExtensions: ['.web.tsx', '.web.ts', '.tsx', '.ts', '.jsx', '.js', '.mjs', '.json'] }
+and wrap your root layout in a 'use client' provider that renders <UniversalProvider config={config}>.`,
+    expo: `Expo: no Metro changes needed (SDK 52+). Wrap app/_layout.tsx in <UniversalProvider config={config}>.`,
+    'react-native': `React Native: wrap your root component in <UniversalProvider config={config}>.`,
+    vite: `Vite: alias 'react-native' to 'react-native-web' and prefer '.web.tsx' extensions in vite.config.ts.`,
+    unknown: `Wrap your app root in <UniversalProvider config={config}>.`,
+};
+function run(command, cwd, log) {
+    log(`$ ${command}`);
+    execSync(command, { cwd, stdio: 'inherit' });
+}
+export async function initCommand(options) {
+    const project = detectProject(options.cwd);
+    const framework = options.framework ?? project.framework;
+    const existing = readConfig(options.cwd);
+    const config = existing ?? defaultConfig(framework, project.srcDir);
+    if (options.registry)
+        config.registry = options.registry;
+    writeConfig(options.cwd, config);
+    options.log(`${existing ? 'Updated' : 'Created'} ${CONFIG_FILE} (framework: ${framework})`);
+    const configFile = join(options.cwd, config.tamaguiConfig);
+    if (!existsSync(configFile) || options.overwrite) {
+        mkdirSync(dirname(configFile), { recursive: true });
+        writeFileSync(configFile, `import { createUniversalConfig } from '${PACKAGE_SCOPE}/theme'
+
+// Change the preset, colors, radius or font scale — every component follows.
+export const config = createUniversalConfig({ preset: 'indigo', radius: 'md' })
+
+export default config
+`);
+        options.log(`Created ${config.tamaguiConfig}`);
+    }
+    const packages = [
+        ...BASE_DEPENDENCIES,
+        `${PACKAGE_SCOPE}/core`,
+        ...frameworkPeers[framework],
+    ].filter((pkg) => !project.dependencies[pkg]);
+    if (packages.length) {
+        const command = installCommand(project.packageManager, packages);
+        if (options.install)
+            run(command, options.cwd, options.log);
+        else
+            options.log(`Install dependencies:\n  ${command}`);
+    }
+    options.log(`\n${setupNotes[framework]}\n\n${PRODUCT_NAME} is ready. Add components with: npx ${CLI_NAME} add button`);
+}
+export async function addCommand(names, options) {
+    const project = detectProject(options.cwd);
+    const config = readConfig(options.cwd) ?? defaultConfig(project.framework, project.srcDir);
+    const registry = options.registry ?? config.registry;
+    const load = (name) => fetchRegistryJson(registry, name, options.cwd);
+    let requested = names;
+    if (options.all) {
+        const index = await fetchRegistryJson(registry, 'index', options.cwd);
+        requested = index.items
+            .filter((item) => item.type === 'registry:component')
+            .map((item) => item.name);
+    }
+    if (!requested.length)
+        throw new Error(`Specify components, e.g. \`${CLI_NAME} add button dialog\``);
+    const items = await resolveItems(requested, load);
+    const written = [];
+    const skipped = [];
+    for (const item of items) {
+        for (const file of item.files) {
+            const target = join(options.cwd, config.uiDir, file.path);
+            if (existsSync(target) && !options.overwrite) {
+                skipped.push(relative(options.cwd, target));
+                continue;
+            }
+            mkdirSync(dirname(target), { recursive: true });
+            writeFileSync(target, file.content);
+            written.push(relative(options.cwd, target));
+        }
+    }
+    options.log(`Added ${items.map((i) => i.name).join(', ')}`);
+    for (const file of written)
+        options.log(`  + ${file}`);
+    if (skipped.length)
+        options.log(`Skipped ${skipped.length} existing file(s) (use --overwrite).`);
+    const missing = collectDependencies(items).filter((pkg) => !project.dependencies[pkg]);
+    if (missing.length) {
+        const command = installCommand(project.packageManager, missing);
+        if (options.install)
+            run(command, options.cwd, options.log);
+        else
+            options.log(`Install dependencies:\n  ${command}`);
+    }
+    return { items, written, skipped };
+}
+export async function listCommand(options) {
+    const project = (() => {
+        try {
+            return detectProject(options.cwd);
+        }
+        catch {
+            return null;
+        }
+    })();
+    const config = project ? readConfig(options.cwd) : null;
+    // Listing needs no project, so fall back to the published registry.
+    const registry = options.registry ?? config?.registry ?? DEFAULT_REGISTRY;
+    const index = await fetchRegistryJson(registry, 'index', options.cwd);
+    for (const item of index.items) {
+        options.log(`${item.name.padEnd(16)} ${(item.status ?? '').padEnd(8)} ${item.description}`);
+    }
+    return index;
+}

package/dist/config.js

@@ -0,0 +1,21 @@
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { CONFIG_FILE, DEFAULT_REGISTRY } from './constants.js';
+export function defaultConfig(framework, srcDir) {
+    return {
+        $schema: 'https://zinmin232.github.io/advui/schema/config.json',
+        framework,
+        uiDir: srcDir ? 'src/ui' : 'ui',
+        registry: DEFAULT_REGISTRY,
+        tamaguiConfig: srcDir ? 'src/tamagui.config.ts' : 'tamagui.config.ts',
+    };
+}
+export function readConfig(root) {
+    const file = join(root, CONFIG_FILE);
+    if (!existsSync(file))
+        return null;
+    return JSON.parse(readFileSync(file, 'utf8'));
+}
+export function writeConfig(root, config) {
+    writeFileSync(join(root, CONFIG_FILE), `${JSON.stringify(config, null, 2)}\n`);
+}

package/dist/constants.js

@@ -0,0 +1,14 @@
+// Branding lives here so the project can be renamed in one place (see scripts/rename.mjs).
+export const PRODUCT_NAME = 'Adv UI';
+export const CLI_NAME = 'advui';
+export const PACKAGE_SCOPE = '@advui';
+export const CONFIG_FILE = 'advui.json';
+/** Default remote registry. Override with `--registry` or the config file. */
+export const DEFAULT_REGISTRY = 'https://zinmin232.github.io/advui/r';
+/** Packages every project needs, regardless of which components are added. */
+export const BASE_DEPENDENCIES = [
+    `${PACKAGE_SCOPE}/theme`,
+    `${PACKAGE_SCOPE}/icons`,
+    `${PACKAGE_SCOPE}/utils`,
+    'tamagui',
+];

package/dist/index.js

@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+import { parseArgs } from 'node:util';
+import { addCommand, initCommand, listCommand } from './commands.js';
+import { CLI_NAME, DEFAULT_REGISTRY, PRODUCT_NAME } from './constants.js';
+const help = `${PRODUCT_NAME} CLI
+
+Usage
+  npx ${CLI_NAME} init [--framework next|expo|react-native|vite]
+  npx ${CLI_NAME} add <component...> [--all] [--overwrite]
+  npx ${CLI_NAME} list
+
+Options
+  --registry <url|path>  Registry to read from (default: from advui.json, else ${DEFAULT_REGISTRY})
+  --cwd <path>           Project directory (default: current directory)
+  --no-install           Print the install command instead of running it
+  --overwrite            Replace existing files
+  -h, --help             Show this help`;
+async function main(argv) {
+    const { values, positionals } = parseArgs({
+        args: argv,
+        allowPositionals: true,
+        options: {
+            registry: { type: 'string' },
+            cwd: { type: 'string' },
+            framework: { type: 'string' },
+            'no-install': { type: 'boolean', default: false },
+            overwrite: { type: 'boolean', default: false },
+            all: { type: 'boolean', default: false },
+            help: { type: 'boolean', short: 'h', default: false },
+        },
+    });
+    const [command, ...rest] = positionals;
+    if (values.help || !command) {
+        console.log(help);
+        return;
+    }
+    const common = {
+        cwd: values.cwd ?? process.cwd(),
+        registry: values.registry,
+        install: !values['no-install'],
+        overwrite: values.overwrite ?? false,
+        log: (message) => console.log(message),
+    };
+    switch (command) {
+        case 'init':
+            return initCommand({ ...common, framework: values.framework });
+        case 'add':
+            return addCommand(rest, { ...common, all: values.all });
+        case 'list':
+            return listCommand(common);
+        default:
+            throw new Error(`Unknown command "${command}".\n\n${help}`);
+    }
+}
+main(process.argv.slice(2)).catch((error) => {
+    console.error(error instanceof Error ? error.message : error);
+    process.exitCode = 1;
+});

package/dist/project.js

@@ -0,0 +1,50 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+export function readPackageJson(root) {
+    const file = join(root, 'package.json');
+    if (!existsSync(file))
+        return null;
+    return JSON.parse(readFileSync(file, 'utf8'));
+}
+export function detectFramework(deps) {
+    if (deps.next)
+        return 'next';
+    if (deps.expo)
+        return 'expo';
+    if (deps['react-native'])
+        return 'react-native';
+    if (deps.vite)
+        return 'vite';
+    return 'unknown';
+}
+export function detectPackageManager(root) {
+    if (existsSync(join(root, 'pnpm-lock.yaml')) || existsSync(join(root, 'pnpm-workspace.yaml')))
+        return 'pnpm';
+    if (existsSync(join(root, 'yarn.lock')))
+        return 'yarn';
+    if (existsSync(join(root, 'bun.lockb')) || existsSync(join(root, 'bun.lock')))
+        return 'bun';
+    return 'npm';
+}
+export function detectProject(root) {
+    const pkg = readPackageJson(root);
+    if (!pkg)
+        throw new Error(`No package.json found in ${root}. Run this inside your app.`);
+    const dependencies = {
+        ...(pkg.dependencies ?? {}),
+        ...(pkg.devDependencies ?? {}),
+    };
+    return {
+        root,
+        framework: detectFramework(dependencies),
+        packageManager: detectPackageManager(root),
+        typescript: existsSync(join(root, 'tsconfig.json')),
+        srcDir: existsSync(join(root, 'src')),
+        dependencies,
+    };
+}
+export function installCommand(pm, packages, dev = false) {
+    const flag = dev ? (pm === 'npm' ? ' --save-dev' : ' -D') : '';
+    const verb = pm === 'npm' ? 'install' : 'add';
+    return `${pm} ${verb}${flag} ${packages.join(' ')}`;
+}

package/dist/registry.js

@@ -0,0 +1,50 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { isAbsolute, join, resolve } from 'node:path';
+const isUrl = (source) => /^https?:\/\//.test(source);
+/** Loads `<name>.json` from a registry URL or local directory. */
+export async function fetchRegistryJson(source, name, cwd) {
+    if (isUrl(source)) {
+        const url = `${source.replace(/\/$/, '')}/${name}.json`;
+        const response = await fetch(url);
+        if (!response.ok)
+            throw new Error(`Registry request failed: ${response.status} ${url}`);
+        return (await response.json());
+    }
+    const dir = isAbsolute(source) ? source : resolve(cwd, source);
+    const file = join(dir, `${name}.json`);
+    if (!existsSync(file))
+        throw new Error(`"${name}" not found in registry ${dir}`);
+    return JSON.parse(readFileSync(file, 'utf8'));
+}
+/**
+ * Resolves the requested items plus their registry dependencies (depth-first,
+ * dependencies before dependents, each item once).
+ */
+export async function resolveItems(names, load) {
+    const ordered = [];
+    const seen = new Set();
+    const visiting = new Set();
+    async function visit(name) {
+        if (seen.has(name))
+            return;
+        if (visiting.has(name))
+            throw new Error(`Circular registry dependency at "${name}"`);
+        visiting.add(name);
+        const item = await load(name);
+        for (const dependency of item.registryDependencies)
+            await visit(dependency);
+        visiting.delete(name);
+        seen.add(name);
+        ordered.push(item);
+    }
+    for (const name of names)
+        await visit(name);
+    return ordered;
+}
+export function collectDependencies(items) {
+    const all = new Set();
+    for (const item of items)
+        for (const dep of item.dependencies)
+            all.add(dep);
+    return [...all].sort();
+}

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "advui",
+  "version": "0.1.0",
+  "description": "CLI to add Adv UI components to your project (shadcn-style source installation).",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/zinmin232/advui.git",
+    "directory": "packages/cli"
+  },
+  "homepage": "https://github.com/zinmin232/advui/tree/main/packages/cli#readme",
+  "bugs": {
+    "url": "https://github.com/zinmin232/advui/issues"
+  },
+  "type": "module",
+  "bin": {
+    "advui": "./dist/index.js"
+  },
+  "main": "./dist/index.js",
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "devDependencies": {
+    "@types/node": "^22.15.0",
+    "@advui/eslint-config": "0.1.0",
+    "@advui/tsconfig": "0.1.0",
+    "vitest": "^5.0.2"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint .",
+    "test": "vitest run",
+    "clean": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\""
+  }
+}