@hobui/viui-cli 0.0.2

package/dist/assets/plugins/vuetify-defaults/cards.ts

@@ -0,0 +1,12 @@
+/**
+ * iNET Design System — Vuetify defaults cho Cards (VCard, VCardText, VCardActions).
+ */
+
+import type { VuetifyOptions } from 'vuetify'
+
+export const cardDefaults: NonNullable<VuetifyOptions['defaults']> = {
+  VCard: {
+    elevation: 1,
+    rounded: 'lg',
+  },
+}

package/dist/assets/plugins/vuetify-defaults/global.ts

@@ -0,0 +1,12 @@
+/**
+ * iNET Design System — Vuetify global defaults.
+ * Áp cho mọi component; dùng design tokens qua theme (colors, border-radius-root).
+ */
+
+/** Global defaults (ripple, density) — class/style không dùng trong global. */
+export const globalDefaults: Record<string, unknown> = {
+  // Ripple: bật mặc định theo Material; tắt nếu design system yêu cầu giảm motion
+  ripple: true,
+  // Density: 'default' | 'comfortable' | 'compact'
+  density: 'default',
+}

package/dist/assets/plugins/vuetify-defaults/index.ts

@@ -0,0 +1,45 @@
+/**
+ * iNET Design System — Vuetify defaults (global + từng element).
+ * Merge tất cả và export cho createVuetify({ defaults }).
+ */
+
+import type { VuetifyOptions } from 'vuetify'
+import { globalDefaults } from './global'
+import { buttonDefaults } from './buttons'
+import { cardDefaults } from './cards'
+import { inputDefaults } from './inputs'
+import { listDefaults } from './lists'
+
+type DefaultsConfig = NonNullable<VuetifyOptions['defaults']>
+
+function mergeDefaults (...sources: DefaultsConfig[]): DefaultsConfig {
+  const result: Record<string, unknown> = { global: { ...globalDefaults } }
+  for (const src of sources) {
+    if (!src) continue
+    const srcObj = src as Record<string, unknown>
+    if (srcObj.global && typeof srcObj.global === 'object') {
+      result.global = { ...(result.global as Record<string, unknown>), ...srcObj.global }
+    }
+    for (const key of Object.keys(srcObj)) {
+      if (key === 'global') continue
+      const existing = result[key] as Record<string, unknown> | undefined
+      const incoming = srcObj[key] as Record<string, unknown> | undefined
+      result[key] = existing && incoming ? { ...existing, ...incoming } : (incoming ?? existing)
+    }
+  }
+  return result as DefaultsConfig
+}
+
+export const defaults: DefaultsConfig = mergeDefaults(
+  { global: globalDefaults },
+  buttonDefaults,
+  cardDefaults,
+  inputDefaults,
+  listDefaults,
+)
+
+export { globalDefaults } from './global'
+export { buttonDefaults } from './buttons'
+export { cardDefaults } from './cards'
+export { inputDefaults } from './inputs'
+export { listDefaults } from './lists'

package/dist/assets/plugins/vuetify-defaults/inputs.ts

@@ -0,0 +1,42 @@
+/**
+ * iNET Design System — Vuetify defaults cho form inputs:
+ * VTextField, VTextarea, VSelect, VAutocomplete, VCheckbox, VRadioGroup, VSwitch.
+ */
+
+import type { VuetifyOptions } from 'vuetify'
+
+export const inputDefaults: NonNullable<VuetifyOptions['defaults']> = {
+  VTextField: {
+    variant: 'outlined',
+    density: 'default',
+    hideDetails: 'auto',
+    rounded: 'lg',
+  },
+  VTextarea: {
+    variant: 'outlined',
+    density: 'default',
+    hideDetails: 'auto',
+    rounded: 'lg',
+  },
+  VSelect: {
+    variant: 'outlined',
+    density: 'default',
+    hideDetails: 'auto',
+    rounded: 'lg',
+  },
+  VAutocomplete: {
+    variant: 'outlined',
+    density: 'default',
+    hideDetails: 'auto',
+    rounded: 'lg',
+  },
+  VCheckbox: {
+    hideDetails: true,
+  },
+  VRadioGroup: {
+    hideDetails: 'auto',
+  },
+  VSwitch: {
+    hideDetails: true,
+  },
+}

package/dist/assets/plugins/vuetify-defaults/lists.ts

@@ -0,0 +1,17 @@
+/**
+ * iNET Design System — Vuetify defaults cho Lists (VList, VListItem, VListGroup).
+ */
+
+import type { VuetifyOptions } from 'vuetify'
+
+export const listDefaults: NonNullable<VuetifyOptions['defaults']> = {
+  VList: {
+    density: 'default',
+  },
+  VListItem: {
+    density: 'default',
+  },
+  VListGroup: {
+    density: 'default',
+  },
+}

package/dist/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":""}

package/dist/cli.js

@@ -0,0 +1,402 @@
+#!/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');
+}
+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');
+    }
+}
+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');
+        }
+    }
+}
+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;
+}
+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 def = defaultYes ? 'Y/n' : 'y/N';
+        const a = await rl.question(`${q} (${def}): `);
+        const s = a.trim().toLowerCase();
+        if (s === '')
+            return defaultYes;
+        return s === 'y' || s === 'yes';
+    };
+    console.log('\n@viui/cli — Setup i-design-system in this repo\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 cursorDir = path.join(cwd, '.cursor');
+    const hasCursor = fs.existsSync(cursorDir);
+    if (!hasCursor) {
+        console.log('Step 1: Initializing .cursor (rules, plans) and src/plugins/viui-conf...');
+        runInit(cwd, assetsDir, { yes: true, dryRun: false, noPlans: false });
+    }
+    else {
+        const doSync = opts.yes || (await ask('Step 1: .cursor exists. Sync from design system?', true));
+        if (doSync) {
+            runSync(cwd, assetsDir, { dryRun: false, backup: false });
+        }
+    }
+    const pm = detectPackageManager(cwd);
+    const doWeb = opts.yes || (await ask('Step 2: Install @viui/web for Vi* components?', true));
+    if (doWeb) {
+        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(`Running: ${addCmd}`);
+        execSync(addCmd, { cwd, stdio: 'inherit' });
+    }
+    const doPostinstall = !isPostinstall && (opts.yes || (await ask('Step 3: Add postinstall to auto-sync on install?', false)));
+    if (doPostinstall) {
+        if (addPostinstallScript(cwd, pm)) {
+            console.log('Added postinstall script to package.json.');
+        }
+        else {
+            console.log('postinstall already contains viui-cli or package.json not found.');
+        }
+    }
+    console.log('\nDone. Use: import { ViButton, ViInput, ... } from \'@viui/web\'');
+    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(`@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(`
+@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 @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 @viui/cli — then follow the setup steps. Or run: viui-cli setup
+`);
+    process.exit(0);
+}
+if (command === 'version') {
+    console.log(`@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/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@hobui/viui-cli",
+  "version": "0.0.2",
+  "description": "CLI to sync i-design-system .cursor (rules, skills, commands) into consumer repos",
+  "type": "module",
+  "files": [
+    "dist"
+  ],
+  "bin": {
+    "viui-cli": "./dist/cli.js"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "~5.9.3"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "postinstall": "node scripts/postinstall-check.cjs",
+    "build": "tsc && node scripts/copy-cursor.cjs",
+    "dev": "tsc --watch"
+  }
+}