@hobui/viui-cli 0.0.6 → 0.0.7

package/dist/cli.legacy.js

@@ -0,0 +1,597 @@
+#!/usr/bin/env node
+/**
+ * @viui/cli — Sync .cursor (rules, skills, commands) from i-design-system into consumer repo.
+ * Commands: init, sync, setup, version.
+ * After `pnpm add @viui/cli`, postinstall runs `setup --postinstall` for step-by-step UX.
+ */
+import { parseArgs } from 'node:util';
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import fs from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import readline from 'node:readline/promises';
+const require = createRequire(import.meta.url);
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const pkg = require(path.join(__dirname, '..', 'package.json'));
+function getAssetsCursorDir() {
+    return path.join(__dirname, 'assets', 'cursor');
+}
+/** viui-conf bundle path (synced to consumer src/plugins/viui-conf). */
+function getAssetsPluginsDir() {
+    return path.join(__dirname, 'assets', 'plugins');
+}
+/** viui-themes SCSS bundle path (synced to consumer src/assets/styles/viui-themes). */
+function getAssetsViuiThemesDir() {
+    return path.join(__dirname, 'assets', 'viui-themes');
+}
+function loadManifest(assetsDir) {
+    const p = path.join(assetsDir, 'sync-manifest.json');
+    if (!fs.existsSync(p))
+        return {};
+    return JSON.parse(fs.readFileSync(p, 'utf8'));
+}
+function getDesignSystemVersion(assetsDir) {
+    const p = path.join(assetsDir, '.design-system-version');
+    if (!fs.existsSync(p))
+        return '0.0.0';
+    return fs.readFileSync(p, 'utf8').trim();
+}
+function copyRecursive(src, dest, opts) {
+    if (!fs.existsSync(src))
+        return;
+    if (!opts.dryRun)
+        fs.mkdirSync(dest, { recursive: true });
+    const entries = fs.readdirSync(src, { withFileTypes: true });
+    for (const e of entries) {
+        const srcPath = path.join(src, e.name);
+        const destPath = path.join(dest, e.name);
+        if (e.isDirectory()) {
+            copyRecursive(srcPath, destPath, opts);
+        }
+        else {
+            if (opts.dryRun) {
+                console.log(`Would copy: ${path.relative(process.cwd(), destPath) || destPath}`);
+            }
+            else {
+                if (opts.backup && fs.existsSync(destPath)) {
+                    const backupPath = destPath + '.backup.' + Date.now();
+                    fs.copyFileSync(destPath, backupPath);
+                }
+                fs.copyFileSync(srcPath, destPath);
+            }
+        }
+    }
+}
+/**
+ * List all relative paths under dir (files and dirs), with forward slashes.
+ */
+function listRelativePaths(dir, prefix = '') {
+    if (!fs.existsSync(dir))
+        return [];
+    const out = [];
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const e of entries) {
+        const rel = prefix ? `${prefix}/${e.name}` : e.name;
+        out.push(rel);
+        if (e.isDirectory()) {
+            out.push(...listRelativePaths(path.join(dir, e.name), rel));
+        }
+    }
+    return out;
+}
+/**
+ * Remove from destDir any path that does not exist in sourceSet (mirror bundle).
+ * Deletes deeper paths first so dirs can be removed after their contents.
+ */
+function removePathsNotInSource(destDir, sourceSet, opts) {
+    if (!fs.existsSync(destDir))
+        return;
+    const destPaths = listRelativePaths(destDir);
+    const sorted = destPaths.sort((a, b) => b.split('/').length - a.split('/').length);
+    for (const rel of sorted) {
+        const relNorm = rel.replace(/\\/g, '/');
+        if (sourceSet.has(relNorm))
+            continue;
+        const destPath = path.join(destDir, relNorm);
+        if (!fs.existsSync(destPath))
+            continue;
+        if (opts.dryRun) {
+            console.log(`Would remove: ${path.relative(process.cwd(), destPath) || destPath}`);
+        }
+        else {
+            fs.rmSync(destPath, { recursive: true });
+            console.log('Removed:', path.relative(process.cwd(), destPath) || destPath);
+        }
+    }
+}
+function runInit(cwd, assetsDir, opts) {
+    const manifest = loadManifest(assetsDir);
+    const version = getDesignSystemVersion(assetsDir);
+    const cursorDir = path.join(cwd, '.cursor');
+    const dirs = ['rules', 'skills', 'commands'];
+    if (!opts.noPlans)
+        dirs.push('plans');
+    if (opts.dryRun) {
+        console.log('Dry run: would create .cursor and copy:');
+        for (const key of Object.keys(manifest)) {
+            if (key === 'plans' && opts.noPlans)
+                continue;
+            const src = path.join(assetsDir, manifest[key].dir);
+            if (fs.existsSync(src)) {
+                const entries = fs.readdirSync(src, { withFileTypes: true });
+                entries.forEach(e => console.log(`  .cursor/${manifest[key].dir}/${e.name}`));
+            }
+        }
+        console.log(`  .cursor/.design-system-version (${version})`);
+        return;
+    }
+    if (!fs.existsSync(cursorDir))
+        fs.mkdirSync(cursorDir, { recursive: true });
+    for (const d of dirs) {
+        const sub = path.join(cursorDir, d);
+        if (!fs.existsSync(sub))
+            fs.mkdirSync(sub, { recursive: true });
+    }
+    for (const key of Object.keys(manifest)) {
+        if (key === 'plans' && opts.noPlans)
+            continue;
+        const src = path.join(assetsDir, manifest[key].dir);
+        const dest = path.join(cursorDir, manifest[key].dir);
+        if (fs.existsSync(src))
+            copyRecursive(src, dest, { dryRun: false });
+    }
+    fs.writeFileSync(path.join(cursorDir, '.design-system-version'), version, 'utf8');
+    console.log('Initialized .cursor with design system version', version);
+    // Sync viui-conf (theme + defaults) — trừ vuetify.ts
+    const viuiConfSrc = path.join(getAssetsPluginsDir(), 'viui-conf');
+    const viuiConfDest = path.join(cwd, 'src', 'plugins', 'viui-conf');
+    if (fs.existsSync(viuiConfSrc)) {
+        if (opts.dryRun) {
+            console.log('Would sync viui-conf to src/plugins/viui-conf');
+        }
+        else {
+            if (!fs.existsSync(path.join(cwd, 'src', 'plugins')))
+                fs.mkdirSync(path.join(cwd, 'src', 'plugins'), { recursive: true });
+            copyRecursive(viuiConfSrc, viuiConfDest, { dryRun: false });
+        }
+        if (!opts.dryRun)
+            console.log('Synced viui-conf to src/plugins/viui-conf');
+    }
+    syncViuiThemesAndEntry(cwd, opts.dryRun ?? false);
+}
+/**
+ * Sync viui-themes SCSS to consumer and ensure theme SCSS is loaded.
+ * - Copies dist/assets/viui-themes → src/assets/styles/viui-themes
+ * - Writes viui-themes-entry.scss that @use's viui-themes/index.scss
+ * - Injects import into main.scss if present and not already there
+ */
+function syncViuiThemesAndEntry(cwd, dryRun) {
+    const themesSrc = getAssetsViuiThemesDir();
+    const stylesDir = path.join(cwd, 'src', 'assets', 'styles');
+    const themesDest = path.join(stylesDir, 'viui-themes');
+    const entryPath = path.join(stylesDir, 'viui-themes-entry.scss');
+    const mainScssPath = path.join(stylesDir, 'main.scss');
+    const entryImport = "@use './viui-themes-entry' as *;";
+    if (!fs.existsSync(themesSrc))
+        return;
+    if (dryRun) {
+        console.log('Would sync viui-themes to src/assets/styles/viui-themes');
+        console.log('Would write src/assets/styles/viui-themes-entry.scss');
+        console.log('Would ensure main.scss imports viui-themes-entry');
+        return;
+    }
+    if (!fs.existsSync(path.join(cwd, 'src', 'assets')))
+        fs.mkdirSync(path.join(cwd, 'src', 'assets'), { recursive: true });
+    if (!fs.existsSync(stylesDir))
+        fs.mkdirSync(stylesDir, { recursive: true });
+    copyRecursive(themesSrc, themesDest, { dryRun: false });
+    console.log('Synced viui-themes to src/assets/styles/viui-themes');
+    const entryContent = `/**
+ * ViUi design style themes — auto-loaded when using viui-conf (VITE_VIUI_THEME).
+ * Do not edit: generated by viui-cli sync. Styles apply when body has .design-style-<id> or wrapper has .design-style-<id>.
+ */
+@use './viui-themes/index.scss' as *;
+`;
+    fs.writeFileSync(entryPath, entryContent, 'utf8');
+    console.log('Wrote viui-themes-entry.scss');
+    if (fs.existsSync(mainScssPath)) {
+        const mainContent = fs.readFileSync(mainScssPath, 'utf8');
+        const hasEntry = /viui-themes-entry/.test(mainContent);
+        if (!hasEntry) {
+            const appended = mainContent.trimEnd() + '\n' + entryImport + '\n';
+            fs.writeFileSync(mainScssPath, appended, 'utf8');
+            console.log('Added viui-themes-entry import to main.scss');
+        }
+    }
+    else {
+        console.log('Note: src/assets/styles/main.scss not found. To load theme styles: create it with "' +
+            entryImport +
+            '" and import main.scss in your app entry (e.g. main.ts).');
+    }
+}
+function runSync(cwd, assetsDir, opts) {
+    const manifest = loadManifest(assetsDir);
+    const version = getDesignSystemVersion(assetsDir);
+    const cursorDir = path.join(cwd, '.cursor');
+    console.log('Syncing .cursor at:', path.resolve(cursorDir));
+    let keys = Object.keys(manifest);
+    if (opts.rulesOnly)
+        keys = keys.filter(k => k === 'rules');
+    if (opts.skillsOnly)
+        keys = keys.filter(k => k === 'skills');
+    if (opts.commandsOnly)
+        keys = keys.filter(k => k === 'commands');
+    if (opts.dryRun) {
+        console.log('Dry run: would overwrite:');
+        for (const key of keys) {
+            const src = path.join(assetsDir, manifest[key].dir);
+            if (fs.existsSync(src)) {
+                const entries = fs.readdirSync(src, { withFileTypes: true });
+                entries.forEach(e => console.log(`  .cursor/${manifest[key].dir}/${e.name}`));
+            }
+        }
+        console.log(`  .cursor/.design-system-version (${version})`);
+        return;
+    }
+    if (!fs.existsSync(cursorDir))
+        fs.mkdirSync(cursorDir, { recursive: true });
+    for (const key of keys) {
+        const src = path.join(assetsDir, manifest[key].dir);
+        const dest = path.join(cursorDir, manifest[key].dir);
+        if (fs.existsSync(src)) {
+            if (!fs.existsSync(dest))
+                fs.mkdirSync(dest, { recursive: true });
+            copyRecursive(src, dest, { dryRun: opts.dryRun, backup: opts.backup });
+            const sourceRelPaths = listRelativePaths(src).map(p => p.replace(/\\/g, '/'));
+            const sourceSet = new Set(sourceRelPaths);
+            removePathsNotInSource(dest, sourceSet, { dryRun: opts.dryRun });
+        }
+    }
+    fs.writeFileSync(path.join(cursorDir, '.design-system-version'), version, 'utf8');
+    console.log('Synced .cursor with design system version', version);
+    // Sync viui-conf (theme + defaults) — trừ vuetify.ts
+    const viuiConfSrc = path.join(getAssetsPluginsDir(), 'viui-conf');
+    const viuiConfDest = path.join(cwd, 'src', 'plugins', 'viui-conf');
+    if (fs.existsSync(viuiConfSrc)) {
+        if (opts.dryRun) {
+            console.log('Would sync viui-conf to src/plugins/viui-conf');
+        }
+        else {
+            if (!fs.existsSync(path.join(cwd, 'src', 'plugins')))
+                fs.mkdirSync(path.join(cwd, 'src', 'plugins'), { recursive: true });
+            copyRecursive(viuiConfSrc, viuiConfDest, { dryRun: false, backup: opts.backup });
+            console.log('Synced viui-conf to src/plugins/viui-conf');
+        }
+    }
+    syncViuiThemesAndEntry(cwd, opts.dryRun ?? false);
+}
+function detectPackageManager(cwd) {
+    if (fs.existsSync(path.join(cwd, 'pnpm-lock.yaml')))
+        return 'pnpm';
+    if (fs.existsSync(path.join(cwd, 'yarn.lock')))
+        return 'yarn';
+    return 'npm';
+}
+function addPostinstallScript(cwd, pm) {
+    const pkgPath = path.join(cwd, 'package.json');
+    if (!fs.existsSync(pkgPath))
+        return false;
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+    const scripts = pkg.scripts ?? {};
+    const cmd = pm === 'pnpm' ? 'pnpm exec viui-cli sync' : pm === 'yarn' ? 'yarn viui-cli sync' : 'npx viui-cli sync';
+    if (scripts.postinstall?.includes('viui-cli'))
+        return false;
+    scripts.postinstall = scripts.postinstall ? `${scripts.postinstall} && ${cmd}` : cmd;
+    pkg.scripts = scripts;
+    fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n', 'utf8');
+    return true;
+}
+const VIUI_THEME_IDS = ['minimalist-2', 'neo-brutalism', 'material'];
+function setEnvTheme(cwd, themeId) {
+    const envPath = path.join(cwd, '.env');
+    const examplePath = path.join(cwd, '.env.example');
+    const line = `VITE_VIUI_THEME=${themeId}`;
+    const targets = [envPath, examplePath].filter((p) => fs.existsSync(p));
+    if (targets.length === 0) {
+        fs.writeFileSync(envPath, line + '\n', 'utf8');
+        console.log('Created .env with', line);
+        return;
+    }
+    for (const p of targets) {
+        let content = fs.readFileSync(p, 'utf8');
+        const re = /^\s*VITE_VIUI_THEME=.*/m;
+        if (re.test(content)) {
+            content = content.replace(re, line);
+        }
+        else {
+            content = content.trimEnd() + '\n' + line + '\n';
+        }
+        fs.writeFileSync(p, content, 'utf8');
+        console.log('Set', line, 'in', path.basename(p));
+    }
+}
+function ensureApplyThemeBodyInVuetify(cwd) {
+    const vuetifyPath = path.join(cwd, 'src', 'plugins', 'vuetify.ts');
+    if (!fs.existsSync(vuetifyPath))
+        return false;
+    const content = fs.readFileSync(vuetifyPath, 'utf8');
+    if (/apply-theme-body|applyThemeBody/.test(content))
+        return false;
+    const importLine = "import './viui-conf/apply-theme-body'";
+    const defaultsImportMatch = content.match(/import\s+.+\s+from\s+['"]\.\/viui-conf\/defaults[^'"]*['"]/);
+    const insert = defaultsImportMatch
+        ? content.replace(defaultsImportMatch[0], defaultsImportMatch[0] + '\n' + importLine)
+        : content.trimStart().replace(/^(\s*)/, `$1${importLine}\n$1`);
+    fs.writeFileSync(vuetifyPath, insert, 'utf8');
+    console.log('Added apply-theme-body import to src/plugins/vuetify.ts');
+    return true;
+}
+function showHelpDocs(cwd) {
+    console.log('\n--- Design system setup ---');
+    console.log('Design themes (viui-themes) are in: src/assets/styles/viui-themes/');
+    console.log('Available theme ids: minimalist-2 (default), neo-brutalism, material');
+    console.log('To use a theme: set VITE_VIUI_THEME in .env and add in vuetify.ts:');
+    console.log("  import './viui-conf/apply-theme-body'");
+    console.log('Details: src/plugins/viui-conf/defaults/README.md');
+    console.log('CLI docs: pnpm exec viui-cli --help');
+    console.log('---\n');
+}
+async function runConfigureTheme(cwd, rl, opts) {
+    console.log('\n  Design theme (viui-themes)');
+    console.log('  Available: minimalist-2 (default), neo-brutalism, material\n');
+    console.log('  a) Use minimalist-2 (default) — thin borders, flat');
+    console.log('  b) Use neo-brutalism        — thick borders, hard shadow');
+    console.log('  c) Use material             — elevated, standard Material');
+    console.log('  d) Skip / configure manually — set .env yourself\n');
+    const a = await rl.question('  Choose (a-d, or Enter for a): ');
+    const choice = (a.trim().toLowerCase() || 'a')[0];
+    const map = {
+        a: 'minimalist-2',
+        b: 'neo-brutalism',
+        c: 'material',
+        d: 'skip',
+    };
+    const themeId = map[choice] ?? map.a;
+    if (themeId === 'skip') {
+        console.log('  Skipped. Set VITE_VIUI_THEME in .env and add import in vuetify.ts. See src/plugins/viui-conf/defaults/README.md');
+        return;
+    }
+    setEnvTheme(cwd, themeId);
+    const vuetifyPath = path.join(cwd, 'src', 'plugins', 'vuetify.ts');
+    const hasImport = fs.existsSync(vuetifyPath) && /apply-theme-body|applyThemeBody/.test(fs.readFileSync(vuetifyPath, 'utf8'));
+    if (!hasImport && fs.existsSync(vuetifyPath)) {
+        const ans = await rl.question('  Add apply-theme-body import to vuetify.ts? (Y/n): ');
+        const add = opts.yes || (ans.trim().toLowerCase() === '' || ans.trim().toLowerCase() === 'y' || ans.trim().toLowerCase() === 'yes');
+        if (add)
+            ensureApplyThemeBodyInVuetify(cwd);
+    }
+    console.log('  Theme configured:', themeId);
+}
+async function runSetup(cwd, assetsDir, opts) {
+    const isPostinstall = opts.postinstall === true;
+    if (isPostinstall && !process.stdin.isTTY) {
+        return;
+    }
+    if (!fs.existsSync(assetsDir)) {
+        if (isPostinstall)
+            return;
+        console.error('Assets not found. Run "pnpm build" in packages/cli first.');
+        throw new Error('Assets not found');
+    }
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const ask = async (q, defaultYes) => {
+        const a = await rl.question(`${q} (${defaultYes ? 'Y/n' : 'y/N'}): `);
+        const s = a.trim().toLowerCase();
+        if (s === '')
+            return defaultYes;
+        return s === 'y' || s === 'yes';
+    };
+    console.log(`\n${pkg.name ?? '@viui/cli'} — Setup i-design-system in this repo\n`);
+    console.log('  This will: sync .cursor, viui-conf, viui-themes; optional @viui/web, theme config, postinstall.\n');
+    const runNow = opts.yes || (await ask('Run setup now?', true));
+    if (!runNow) {
+        console.log('Skipped. Run later: pnpm exec viui-cli setup');
+        rl.close();
+        return;
+    }
+    const pm = detectPackageManager(cwd);
+    const cursorDir = path.join(cwd, '.cursor');
+    for (;;) {
+        console.log('\n  What do you want to do?\n');
+        console.log('  1) Full setup (recommended) — init/sync .cursor + viui-conf + viui-themes, install @viui/web, configure theme, add postinstall');
+        console.log('  2) Sync only                — update .cursor, viui-conf, viui-themes (no npm install)');
+        console.log('  3) Install @viui/web only   — add Vi* components dependency');
+        console.log('  4) Configure design theme   — set VITE_VIUI_THEME in .env and ensure body class is applied');
+        console.log('  5) Add postinstall script   — auto-sync on every pnpm install');
+        console.log('  6) Show help / docs         — print links and next steps\n');
+        const choiceInput = await rl.question('  Choose (1-6, or Enter for 1): ');
+        const choice = (choiceInput.trim() || '1').replace(/[^1-6]/, '1');
+        const n = parseInt(choice, 10);
+        if (n < 1 || n > 6)
+            continue;
+        if (n === 1) {
+            if (!fs.existsSync(cursorDir)) {
+                console.log('\nStep: Initializing .cursor, viui-conf, viui-themes...');
+                runInit(cwd, assetsDir, { yes: true, dryRun: false, noPlans: false });
+            }
+            else {
+                console.log('\nStep: Syncing .cursor, viui-conf, viui-themes...');
+                runSync(cwd, assetsDir, { dryRun: false, backup: false });
+            }
+            console.log('\nStep: Installing @viui/web...');
+            const { execSync } = await import('node:child_process');
+            const addCmd = pm === 'pnpm' ? 'pnpm add @viui/web' : pm === 'yarn' ? 'yarn add @viui/web' : 'npm install @viui/web';
+            try {
+                execSync(addCmd, { cwd, stdio: 'inherit' });
+            }
+            catch {
+                console.warn('\nCould not install @viui/web (e.g. not published or no permission). Add it manually: pnpm add @viui/web or use a file: link. Continuing with theme config and postinstall.');
+            }
+            await runConfigureTheme(cwd, rl, { yes: opts.yes });
+            if (!isPostinstall && (opts.yes || (await ask('\nAdd postinstall to auto-sync on install?', false)))) {
+                if (addPostinstallScript(cwd, pm))
+                    console.log('Added postinstall script to package.json.');
+            }
+            console.log('\nDone. Use: import { ViButton, ViInput, ... } from \'@viui/web\'');
+            console.log('Design themes: src/assets/styles/viui-themes/ — set VITE_VIUI_THEME in .env; see src/plugins/viui-conf/defaults/README.md');
+            break;
+        }
+        if (n === 2) {
+            if (!fs.existsSync(cursorDir)) {
+                console.log('\nInitializing .cursor, viui-conf, viui-themes...');
+                runInit(cwd, assetsDir, { yes: true, dryRun: false, noPlans: false });
+            }
+            else {
+                console.log('\nSyncing .cursor, viui-conf, viui-themes...');
+                runSync(cwd, assetsDir, { dryRun: false, backup: false });
+            }
+            console.log('Sync done.');
+            break;
+        }
+        if (n === 3) {
+            const { execSync } = await import('node:child_process');
+            const addCmd = pm === 'pnpm' ? 'pnpm add @viui/web' : pm === 'yarn' ? 'yarn add @viui/web' : 'npm install @viui/web';
+            console.log('\nRunning:', addCmd);
+            try {
+                execSync(addCmd, { cwd, stdio: 'inherit' });
+            }
+            catch {
+                console.warn('\nCould not install @viui/web (e.g. not published or no permission). Add manually: pnpm add @viui/web or use file: link.');
+                break;
+            }
+            console.log('Done. Use: import { ViButton, ViInput, ... } from \'@viui/web\'');
+            break;
+        }
+        if (n === 4) {
+            await runConfigureTheme(cwd, rl, { yes: opts.yes });
+            break;
+        }
+        if (n === 5) {
+            if (addPostinstallScript(cwd, pm)) {
+                console.log('\nAdded postinstall script to package.json.');
+            }
+            else {
+                console.log('\npostinstall already contains viui-cli or package.json not found.');
+            }
+            break;
+        }
+        if (n === 6) {
+            showHelpDocs(cwd);
+            const again = opts.yes || (await ask('Show menu again?', true));
+            if (!again)
+                break;
+        }
+    }
+    rl.close();
+}
+const result = parseArgs({
+    options: {
+        help: { type: 'boolean', short: 'h', default: false },
+        version: { type: 'boolean', short: 'v', default: false },
+        yes: { type: 'boolean', short: 'y', default: false },
+        postinstall: { type: 'boolean', default: false },
+        'dry-run': { type: 'boolean', default: false },
+        'no-plans': { type: 'boolean', default: false },
+        backup: { type: 'boolean', default: false },
+        'rules-only': { type: 'boolean', default: false },
+        'skills-only': { type: 'boolean', default: false },
+        'commands-only': { type: 'boolean', default: false },
+    },
+    allowPositionals: true,
+});
+const { values } = result;
+const positionals = result.positionals ?? [];
+const [command] = positionals;
+if (values.version && !command) {
+    console.log(`${pkg.name ?? '@viui/cli'} ${pkg.version}`);
+    const cwd = process.cwd();
+    const versionFile = path.join(cwd, '.cursor', '.design-system-version');
+    if (fs.existsSync(versionFile)) {
+        console.log('Design system (synced):', fs.readFileSync(versionFile, 'utf8').trim());
+    }
+    process.exit(0);
+}
+if (values.help || !command || command === 'help') {
+    console.log(`
+${pkg.name ?? '@viui/cli'} — Sync design system .cursor into your repo
+
+Usage: viui-cli <command> [options]
+
+Commands:
+  init     Create .cursor and copy rules, skills, commands (run once at repo root)
+  sync     Update .cursor from design system (overwrite)
+  setup    Interactive setup: init/sync .cursor, install @viui/web, optional postinstall (runs after pnpm add ${pkg.name ?? '@viui/cli'})
+  version  Print CLI and design system version
+
+Setup options:
+  -y, --yes         Non-interactive: run all steps (init/sync, add @viui/web, skip postinstall prompt)
+  --postinstall      Used by postinstall hook; skips wizard when not TTY (e.g. CI)
+
+Init options:
+  -y, --yes       Skip confirmation
+  --dry-run       Print what would be copied
+  --no-plans      Do not sync plans
+
+Sync options:
+  --dry-run       Print what would be overwritten
+  --backup        Backup existing files before overwrite
+  --rules-only    Sync only rules
+  --skills-only   Sync only skills
+  --commands-only Sync only commands
+
+Global:
+  -h, --help      Show this help
+  -v, --version   Print version
+
+One-command UX: pnpm add ${pkg.name ?? '@viui/cli'} — then follow the setup steps. Or run: viui-cli setup
+`);
+    process.exit(0);
+}
+if (command === 'version') {
+    console.log(`${pkg.name ?? '@viui/cli'} ${pkg.version}`);
+    const cwd = process.cwd();
+    const versionFile = path.join(cwd, '.cursor', '.design-system-version');
+    if (fs.existsSync(versionFile)) {
+        console.log('Design system (synced):', fs.readFileSync(versionFile, 'utf8').trim());
+    }
+    process.exit(0);
+}
+const assetsDir = getAssetsCursorDir();
+const cwd = process.cwd();
+if (!fs.existsSync(assetsDir) && command !== 'setup') {
+    console.error('Assets not found. Run "pnpm build" in packages/cli first.');
+    process.exit(1);
+}
+if (command === 'init') {
+    runInit(cwd, assetsDir, {
+        yes: values.yes,
+        dryRun: values['dry-run'],
+        noPlans: values['no-plans'],
+    });
+    process.exit(0);
+}
+if (command === 'sync') {
+    runSync(cwd, assetsDir, {
+        dryRun: values['dry-run'],
+        backup: values.backup,
+        rulesOnly: values['rules-only'],
+        skillsOnly: values['skills-only'],
+        commandsOnly: values['commands-only'],
+    });
+    process.exit(0);
+}
+if (command === 'setup') {
+    runSetup(cwd, assetsDir, {
+        postinstall: values.postinstall,
+        yes: values.yes,
+    })
+        .then(() => process.exit(0))
+        .catch((err) => {
+        console.error(err);
+        process.exit(1);
+    });
+}
+else {
+    console.error(`Unknown command: ${command}. Use --help for usage.`);
+    process.exit(1);
+}

package/dist/commands/audit.d.ts

@@ -0,0 +1,3 @@
+import type { Command } from 'commander';
+export declare function registerAuditCommand(program: Command): void;
+//# sourceMappingURL=audit.d.ts.map

package/dist/commands/audit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"audit.d.ts","sourceRoot":"","sources":["../../src/commands/audit.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AAoHxC,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CA4C3D"}