@hobui/viui-cli 0.0.5 → 0.0.7

package/dist/services/lock-file-service.d.ts

@@ -0,0 +1,15 @@
+import type { LockFile } from '../types/lock-file-types.js';
+/** Get lock file path for a project */
+export declare function getLockFilePath(cwd: string): string;
+/** Compute SHA-512 integrity hash for a file */
+export declare function computeIntegrity(filePath: string): string;
+/** Read and parse .viui-lock.json */
+export declare function readLockFile(cwd: string): LockFile | null;
+/** Write .viui-lock.json with current timestamp */
+export declare function writeLockFile(cwd: string, lockFile: LockFile): void;
+/** Create a fresh lock file with default values */
+export declare function createLockFile(cliVersion: string, theme: string, styleImport: 'scss' | 'css'): LockFile;
+/** Verify integrity of installed files against lock file checksums.
+ *  v1: check file existence only. Roadmap: hash verification via computeIntegrity(). */
+export declare function verifyIntegrity(cwd: string, lockFile: LockFile): boolean;
+//# sourceMappingURL=lock-file-service.d.ts.map

package/dist/services/lock-file-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lock-file-service.d.ts","sourceRoot":"","sources":["../../src/services/lock-file-service.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,6BAA6B,CAAA;AAO3D,uCAAuC;AACvC,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAEnD;AAED,gDAAgD;AAChD,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAKzD;AAED,qCAAqC;AACrC,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,QAAQ,GAAG,IAAI,CAGzD;AAED,mDAAmD;AACnD,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,GAAG,IAAI,CAKnE;AAED,mDAAmD;AACnD,wBAAgB,cAAc,CAC5B,UAAU,EAAE,MAAM,EAClB,KAAK,EAAE,MAAM,EACb,WAAW,EAAE,MAAM,GAAG,KAAK,GAC1B,QAAQ,CAqBV;AAED;wFACwF;AACxF,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAsBxE"}

package/dist/services/lock-file-service.js

@@ -0,0 +1,74 @@
+import fs from 'node:fs';
+import crypto from 'node:crypto';
+import path from 'node:path';
+import { readJsonSafe, writeFileSafe } from '../utils/fs-safe.js';
+import { logger } from '../utils/logger.js';
+const LOCK_FILENAME = '.viui-lock.json';
+const LOCKFILE_VERSION = 1;
+/** Get lock file path for a project */
+export function getLockFilePath(cwd) {
+    return path.join(cwd, LOCK_FILENAME);
+}
+/** Compute SHA-512 integrity hash for a file */
+export function computeIntegrity(filePath) {
+    if (!fs.existsSync(filePath))
+        return '';
+    const content = fs.readFileSync(filePath);
+    const hash = crypto.createHash('sha512').update(content).digest('base64');
+    return `sha512-${hash}`;
+}
+/** Read and parse .viui-lock.json */
+export function readLockFile(cwd) {
+    const lockPath = getLockFilePath(cwd);
+    return readJsonSafe(lockPath);
+}
+/** Write .viui-lock.json with current timestamp */
+export function writeLockFile(cwd, lockFile) {
+    lockFile.metadata.generatedAt = new Date().toISOString();
+    const content = JSON.stringify(lockFile, null, 2) + '\n';
+    writeFileSafe(getLockFilePath(cwd), content);
+    logger.success(`Updated ${LOCK_FILENAME}`);
+}
+/** Create a fresh lock file with default values */
+export function createLockFile(cliVersion, theme, styleImport) {
+    return {
+        lockfileVersion: LOCKFILE_VERSION,
+        tokens: {
+            version: '0.1.0',
+            integrity: '',
+            baseVersion: '0.1.0',
+        },
+        themes: {
+            [theme]: {
+                version: '0.0.1',
+                integrity: '',
+                baseVersion: '0.0.1',
+            },
+        },
+        config: { theme, styleImport },
+        metadata: {
+            cliVersion,
+            generatedAt: new Date().toISOString(),
+        },
+    };
+}
+/** Verify integrity of installed files against lock file checksums.
+ *  v1: check file existence only. Roadmap: hash verification via computeIntegrity(). */
+export function verifyIntegrity(cwd, lockFile) {
+    logger.dim(`Lock file version: ${lockFile.lockfileVersion}`);
+    const theme = lockFile.config.theme;
+    const missing = [];
+    // Check token files exist
+    if (lockFile.tokens.integrity && !fs.existsSync(path.join(cwd, 'node_modules', '@hobui', 'tokens'))) {
+        missing.push('@hobui/tokens');
+    }
+    // Check theme entry exists in lock
+    if (theme && !lockFile.themes[theme]) {
+        missing.push(`theme "${theme}" not in lock file`);
+    }
+    if (missing.length > 0) {
+        missing.forEach((m) => logger.warn(`Missing: ${m}`));
+        return false;
+    }
+    return true;
+}

package/dist/services/mcp-config-reader.d.ts

@@ -0,0 +1,11 @@
+import type { IdeInfo } from '../types/ide-types.js';
+export interface McpConfigEntry {
+    serverName: string;
+    serverUrl: string;
+    transport?: string;
+}
+/** Đọc MCP config từ project hoặc global path của IDE */
+export declare function readMcpConfig(ide: IdeInfo, useGlobal?: boolean): McpConfigEntry[];
+/** Kiểm tra IDE đã có viui MCP config chưa */
+export declare function hasViuiConfig(ide: IdeInfo, useGlobal?: boolean): boolean;
+//# sourceMappingURL=mcp-config-reader.d.ts.map

package/dist/services/mcp-config-reader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-config-reader.d.ts","sourceRoot":"","sources":["../../src/services/mcp-config-reader.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAA;AAEpD,MAAM,WAAW,cAAc;IAC7B,UAAU,EAAE,MAAM,CAAA;IAClB,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAwBD,yDAAyD;AACzD,wBAAgB,aAAa,CAAC,GAAG,EAAE,OAAO,EAAE,SAAS,UAAQ,GAAG,cAAc,EAAE,CAK/E;AAED,8CAA8C;AAC9C,wBAAgB,aAAa,CAAC,GAAG,EAAE,OAAO,EAAE,SAAS,UAAQ,GAAG,OAAO,CAGtE"}

package/dist/services/mcp-config-reader.js

@@ -0,0 +1,40 @@
+/**
+ * mcp-config-reader.ts — Đọc và parse MCP config từ IDE config files
+ */
+import fs from 'node:fs';
+/** Đọc file JSON an toàn, trả {} nếu không tồn tại hoặc parse lỗi */
+function safeReadJson(filePath) {
+    if (!fs.existsSync(filePath))
+        return {};
+    try {
+        return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    }
+    catch {
+        return {};
+    }
+}
+/** Trích xuất MCP server entries từ config object theo format IDE */
+function extractServers(data, ide) {
+    const topKey = ide.configFormat === 'vscode' ? 'servers' : 'mcpServers';
+    const servers = data[topKey];
+    if (!servers || typeof servers !== 'object')
+        return [];
+    return Object.entries(servers).map(([name, cfg]) => ({
+        serverName: name,
+        serverUrl: cfg.serverUrl || cfg.url || '',
+        transport: cfg.type,
+    }));
+}
+/** Đọc MCP config từ project hoặc global path của IDE */
+export function readMcpConfig(ide, useGlobal = false) {
+    const configPath = useGlobal ? ide.globalConfigPath : ide.configPath;
+    if (!configPath || configPath === '')
+        return [];
+    const data = safeReadJson(configPath);
+    return extractServers(data, ide);
+}
+/** Kiểm tra IDE đã có viui MCP config chưa */
+export function hasViuiConfig(ide, useGlobal = false) {
+    const entries = readMcpConfig(ide, useGlobal);
+    return entries.some(e => e.serverName === 'viui' || e.serverName === 'inet-viui');
+}

package/dist/services/mcp-config-reader.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=mcp-config-reader.spec.d.ts.map

package/dist/services/mcp-config-reader.spec.d.ts.map

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

package/dist/services/mcp-config-reader.spec.js

@@ -0,0 +1,125 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { readMcpConfig, hasViuiConfig } from './mcp-config-reader.js';
+// ── Helpers ──
+const tmpDir = path.join(os.tmpdir(), '.tmp-test-reader');
+function makeIde(overrides = {}) {
+    return {
+        id: 'cursor',
+        name: 'Cursor',
+        detected: true,
+        configPath: path.join(tmpDir, 'mcp.json'),
+        globalConfigPath: null,
+        configFormat: 'standard',
+        ...overrides,
+    };
+}
+function writeJson(filePath, data) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, JSON.stringify(data), 'utf8');
+}
+// ── Tests ──
+beforeEach(() => {
+    fs.mkdirSync(tmpDir, { recursive: true });
+});
+afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+});
+describe('readMcpConfig', () => {
+    it('returns [] when file does not exist', () => {
+        const ide = makeIde({ configPath: path.join(tmpDir, 'nonexistent.json') });
+        expect(readMcpConfig(ide)).toEqual([]);
+    });
+    it('returns [] when file has invalid JSON', () => {
+        const filePath = path.join(tmpDir, 'bad.json');
+        fs.writeFileSync(filePath, '{not valid json', 'utf8');
+        const ide = makeIde({ configPath: filePath });
+        expect(readMcpConfig(ide)).toEqual([]);
+    });
+    it('returns [] when configPath is empty', () => {
+        const ide = makeIde({ configPath: '' });
+        expect(readMcpConfig(ide)).toEqual([]);
+    });
+    it('parses standard format (mcpServers key)', () => {
+        const data = {
+            mcpServers: {
+                'inet-viui': { url: 'https://viui.inet.vn/mcp', type: 'http' },
+            },
+        };
+        writeJson(path.join(tmpDir, 'mcp.json'), data);
+        const entries = readMcpConfig(makeIde());
+        expect(entries).toHaveLength(1);
+        expect(entries[0].serverName).toBe('inet-viui');
+        expect(entries[0].serverUrl).toBe('https://viui.inet.vn/mcp');
+        expect(entries[0].transport).toBe('http');
+    });
+    it('parses vscode format (servers key)', () => {
+        const filePath = path.join(tmpDir, 'vscode-mcp.json');
+        const data = {
+            servers: {
+                viui: { url: 'https://viui.inet.vn/mcp', type: 'http' },
+            },
+        };
+        writeJson(filePath, data);
+        const ide = makeIde({ configPath: filePath, configFormat: 'vscode' });
+        const entries = readMcpConfig(ide);
+        expect(entries).toHaveLength(1);
+        expect(entries[0].serverName).toBe('viui');
+        expect(entries[0].serverUrl).toBe('https://viui.inet.vn/mcp');
+    });
+    it('extracts serverUrl for gemini format', () => {
+        const filePath = path.join(tmpDir, 'gemini.json');
+        const data = {
+            mcpServers: {
+                'inet-viui': { serverUrl: 'https://viui.inet.vn/mcp' },
+            },
+        };
+        writeJson(filePath, data);
+        const ide = makeIde({ configPath: filePath, configFormat: 'gemini' });
+        const entries = readMcpConfig(ide);
+        expect(entries).toHaveLength(1);
+        expect(entries[0].serverUrl).toBe('https://viui.inet.vn/mcp');
+    });
+    it('parses multiple server entries', () => {
+        const data = {
+            mcpServers: {
+                'inet-viui': { url: 'https://viui.inet.vn/mcp' },
+                'other-server': { url: 'http://other.com/mcp' },
+            },
+        };
+        writeJson(path.join(tmpDir, 'mcp.json'), data);
+        const entries = readMcpConfig(makeIde());
+        expect(entries).toHaveLength(2);
+    });
+    it('reads global config when useGlobal=true', () => {
+        const globalPath = path.join(tmpDir, 'global-mcp.json');
+        const data = { mcpServers: { 'inet-viui': { url: 'https://viui.inet.vn/mcp' } } };
+        writeJson(globalPath, data);
+        const ide = makeIde({ globalConfigPath: globalPath });
+        const entries = readMcpConfig(ide, true);
+        expect(entries).toHaveLength(1);
+    });
+});
+describe('hasViuiConfig', () => {
+    it('returns true when "inet-viui" entry exists', () => {
+        const data = { mcpServers: { 'inet-viui': { url: 'https://viui.inet.vn/mcp' } } };
+        writeJson(path.join(tmpDir, 'mcp.json'), data);
+        expect(hasViuiConfig(makeIde())).toBe(true);
+    });
+    it('returns true when "viui" entry exists', () => {
+        const data = { mcpServers: { viui: { url: 'https://viui.inet.vn/mcp' } } };
+        writeJson(path.join(tmpDir, 'mcp.json'), data);
+        expect(hasViuiConfig(makeIde())).toBe(true);
+    });
+    it('returns false when no viui entry exists', () => {
+        const data = { mcpServers: { 'other-server': { url: 'http://other.com' } } };
+        writeJson(path.join(tmpDir, 'mcp.json'), data);
+        expect(hasViuiConfig(makeIde())).toBe(false);
+    });
+    it('returns false when file does not exist', () => {
+        const ide = makeIde({ configPath: path.join(tmpDir, 'nope.json') });
+        expect(hasViuiConfig(ide)).toBe(false);
+    });
+});

package/dist/services/mcp-config-writer.d.ts

@@ -0,0 +1,11 @@
+import type { IdeInfo, McpConfig } from '../types/ide-types.js';
+/** Tạo đối tượng config MCP cho IDE cụ thể */
+export declare function generateMcpConfig(ide: IdeInfo, useRemote: boolean): McpConfig;
+/** Tạo nội dung JSON theo định dạng của từng IDE */
+export declare function buildConfigObject(ide: IdeInfo, mcpConfig: McpConfig): Record<string, unknown>;
+/**
+ * Ghi cấu hình MCP vào file config của IDE.
+ * Tự động backup file cũ và merge thay vì ghi đè hoàn toàn.
+ */
+export declare function writeConfig(ide: IdeInfo, mcpConfig: McpConfig, useGlobal?: boolean): void;
+//# sourceMappingURL=mcp-config-writer.d.ts.map

package/dist/services/mcp-config-writer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-config-writer.d.ts","sourceRoot":"","sources":["../../src/services/mcp-config-writer.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAA;AAK/D,8CAA8C;AAC9C,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,OAAO,EAAE,SAAS,EAAE,OAAO,GAAG,SAAS,CAM7E;AAED,oDAAoD;AACpD,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,OAAO,EAAE,SAAS,EAAE,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAgC7F;AA0BD;;;GAGG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,UAAQ,GAAG,IAAI,CA0BvF"}

package/dist/services/mcp-config-writer.js

@@ -0,0 +1,98 @@
+/**
+ * mcp-config-writer.ts — Tạo và ghi cấu hình MCP server vào từng IDE
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+const REMOTE_URL = 'https://viui.inet.vn/mcp';
+const LOCAL_URL = 'http://localhost:3200/mcp';
+/** Tạo đối tượng config MCP cho IDE cụ thể */
+export function generateMcpConfig(ide, useRemote) {
+    return {
+        serverName: ide.id === 'vscode' ? 'viui' : 'inet-viui',
+        serverUrl: useRemote ? REMOTE_URL : LOCAL_URL,
+        transport: 'http',
+    };
+}
+/** Tạo nội dung JSON theo định dạng của từng IDE */
+export function buildConfigObject(ide, mcpConfig) {
+    switch (ide.configFormat) {
+        case 'vscode':
+            // .vscode/mcp.json: { servers: { name: { url, type } } }
+            return {
+                servers: {
+                    [mcpConfig.serverName]: {
+                        url: mcpConfig.serverUrl,
+                        type: mcpConfig.transport,
+                    },
+                },
+            };
+        case 'gemini':
+            // Gemini: { mcpServers: { name: { serverUrl } } }
+            return {
+                mcpServers: {
+                    [mcpConfig.serverName]: {
+                        serverUrl: mcpConfig.serverUrl,
+                    },
+                },
+            };
+        default:
+            // Standard: Cursor, Claude, Windsurf, Trae
+            return {
+                mcpServers: {
+                    [mcpConfig.serverName]: {
+                        url: mcpConfig.serverUrl,
+                        type: mcpConfig.transport,
+                    },
+                },
+            };
+    }
+}
+/** Deep merge hai object */
+function deepMerge(base, override) {
+    const result = { ...base };
+    for (const key of Object.keys(override)) {
+        const baseVal = result[key];
+        const overVal = override[key];
+        if (baseVal !== null && typeof baseVal === 'object' && !Array.isArray(baseVal) &&
+            overVal !== null && typeof overVal === 'object' && !Array.isArray(overVal)) {
+            result[key] = deepMerge(baseVal, overVal);
+        }
+        else {
+            result[key] = overVal;
+        }
+    }
+    return result;
+}
+/** Backup file hiện có nếu tồn tại */
+function backupExisting(filePath) {
+    if (!fs.existsSync(filePath))
+        return;
+    fs.copyFileSync(filePath, `${filePath}.bak`);
+}
+/**
+ * Ghi cấu hình MCP vào file config của IDE.
+ * Tự động backup file cũ và merge thay vì ghi đè hoàn toàn.
+ */
+export function writeConfig(ide, mcpConfig, useGlobal = false) {
+    const configPath = useGlobal ? ide.globalConfigPath : ide.configPath;
+    if (!configPath) {
+        throw new Error(`${ide.name} không hỗ trợ ${useGlobal ? 'global' : 'project'} config`);
+    }
+    const configDir = path.dirname(configPath);
+    if (!fs.existsSync(configDir)) {
+        fs.mkdirSync(configDir, { recursive: true });
+    }
+    backupExisting(configPath);
+    let existing = {};
+    if (fs.existsSync(configPath)) {
+        try {
+            existing = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+        }
+        catch {
+            // File hỏng — bắt đầu mới, backup đã được tạo
+        }
+    }
+    const newConfig = buildConfigObject(ide, mcpConfig);
+    const merged = deepMerge(existing, newConfig);
+    fs.writeFileSync(configPath, JSON.stringify(merged, null, 2) + '\n', 'utf8');
+}

package/dist/services/mcp-config-writer.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=mcp-config-writer.spec.d.ts.map

package/dist/services/mcp-config-writer.spec.d.ts.map

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

package/dist/services/mcp-config-writer.spec.js

@@ -0,0 +1,162 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { generateMcpConfig, buildConfigObject, writeConfig } from './mcp-config-writer.js';
+// ── Helpers ──
+function makeIde(overrides = {}) {
+    return {
+        id: 'cursor',
+        name: 'Cursor',
+        detected: true,
+        configPath: '/project/.cursor/mcp.json',
+        globalConfigPath: null,
+        configFormat: 'standard',
+        ...overrides,
+    };
+}
+function makeMcpConfig(overrides = {}) {
+    return {
+        serverName: 'inet-viui',
+        serverUrl: 'https://viui.inet.vn/mcp',
+        transport: 'http',
+        ...overrides,
+    };
+}
+// ── Tests ──
+describe('generateMcpConfig', () => {
+    it('returns "viui" serverName for vscode', () => {
+        const ide = makeIde({ id: 'vscode', configFormat: 'vscode' });
+        const config = generateMcpConfig(ide, true);
+        expect(config.serverName).toBe('viui');
+    });
+    it('returns "inet-viui" serverName for non-vscode IDEs', () => {
+        for (const id of ['cursor', 'claude', 'windsurf', 'trae', 'gemini']) {
+            const ide = makeIde({ id });
+            const config = generateMcpConfig(ide, true);
+            expect(config.serverName).toBe('inet-viui');
+        }
+    });
+    it('uses remote URL when useRemote=true', () => {
+        const config = generateMcpConfig(makeIde(), true);
+        expect(config.serverUrl).toBe('https://viui.inet.vn/mcp');
+    });
+    it('uses local URL when useRemote=false', () => {
+        const config = generateMcpConfig(makeIde(), false);
+        expect(config.serverUrl).toBe('http://localhost:3200/mcp');
+    });
+    it('always sets transport to "http"', () => {
+        const config = generateMcpConfig(makeIde(), true);
+        expect(config.transport).toBe('http');
+    });
+});
+describe('buildConfigObject', () => {
+    it('builds vscode format with "servers" key', () => {
+        const ide = makeIde({ configFormat: 'vscode' });
+        const mcpConfig = makeMcpConfig({ serverName: 'viui' });
+        const result = buildConfigObject(ide, mcpConfig);
+        expect(result).toEqual({
+            servers: {
+                viui: {
+                    url: 'https://viui.inet.vn/mcp',
+                    type: 'http',
+                },
+            },
+        });
+    });
+    it('builds gemini format with "serverUrl" field', () => {
+        const ide = makeIde({ id: 'gemini', configFormat: 'gemini' });
+        const mcpConfig = makeMcpConfig();
+        const result = buildConfigObject(ide, mcpConfig);
+        expect(result).toEqual({
+            mcpServers: {
+                'inet-viui': {
+                    serverUrl: 'https://viui.inet.vn/mcp',
+                },
+            },
+        });
+    });
+    it('builds standard format for cursor/claude/windsurf/trae', () => {
+        const ide = makeIde({ configFormat: 'standard' });
+        const mcpConfig = makeMcpConfig();
+        const result = buildConfigObject(ide, mcpConfig);
+        expect(result).toEqual({
+            mcpServers: {
+                'inet-viui': {
+                    url: 'https://viui.inet.vn/mcp',
+                    type: 'http',
+                },
+            },
+        });
+    });
+    it('gemini format does NOT include type field', () => {
+        const ide = makeIde({ configFormat: 'gemini' });
+        const result = buildConfigObject(ide, makeMcpConfig());
+        const server = result.mcpServers['inet-viui'];
+        expect(server.type).toBeUndefined();
+    });
+});
+describe('writeConfig', () => {
+    const tmpDir = path.join(os.tmpdir(), '.tmp-test-writeconfig');
+    const configPath = path.join(tmpDir, '.cursor', 'mcp.json');
+    beforeEach(() => {
+        fs.mkdirSync(path.dirname(configPath), { recursive: true });
+    });
+    afterEach(() => {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+    it('creates directory and writes config when file does not exist', () => {
+        const newConfigPath = path.join(tmpDir, 'new-dir', 'mcp.json');
+        const ide = makeIde({ configPath: newConfigPath });
+        const mcpConfig = makeMcpConfig();
+        writeConfig(ide, mcpConfig);
+        expect(fs.existsSync(newConfigPath)).toBe(true);
+        const written = JSON.parse(fs.readFileSync(newConfigPath, 'utf8'));
+        expect(written.mcpServers['inet-viui'].url).toBe('https://viui.inet.vn/mcp');
+    });
+    it('backs up existing file before writing', () => {
+        fs.writeFileSync(configPath, '{"existing": true}', 'utf8');
+        const ide = makeIde({ configPath });
+        writeConfig(ide, makeMcpConfig());
+        expect(fs.existsSync(`${configPath}.bak`)).toBe(true);
+        const backup = JSON.parse(fs.readFileSync(`${configPath}.bak`, 'utf8'));
+        expect(backup.existing).toBe(true);
+    });
+    it('merges with existing config without losing data', () => {
+        const existing = { mcpServers: { 'other-server': { url: 'http://other' } }, custom: 'keep' };
+        fs.writeFileSync(configPath, JSON.stringify(existing), 'utf8');
+        const ide = makeIde({ configPath });
+        writeConfig(ide, makeMcpConfig());
+        const result = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+        expect(result.custom).toBe('keep');
+        expect(result.mcpServers['other-server']).toBeDefined();
+        expect(result.mcpServers['inet-viui']).toBeDefined();
+    });
+    it('writes JSON with 2-space indent and trailing newline', () => {
+        const ide = makeIde({ configPath });
+        writeConfig(ide, makeMcpConfig());
+        const raw = fs.readFileSync(configPath, 'utf8');
+        expect(raw).toContain('  ');
+        expect(raw.endsWith('\n')).toBe(true);
+    });
+    it('throws when configPath is not available', () => {
+        const ide = makeIde({ configPath: '' });
+        expect(() => writeConfig(ide, makeMcpConfig())).toThrow();
+    });
+    it('uses globalConfigPath when useGlobal=true', () => {
+        const globalPath = path.join(tmpDir, 'global', 'mcp.json');
+        const ide = makeIde({ globalConfigPath: globalPath });
+        writeConfig(ide, makeMcpConfig(), true);
+        expect(fs.existsSync(globalPath)).toBe(true);
+    });
+    it('handles corrupted existing JSON gracefully', () => {
+        fs.writeFileSync(configPath, '{broken json!!!', 'utf8');
+        const ide = makeIde({ configPath });
+        writeConfig(ide, makeMcpConfig());
+        // Backup should still be created
+        expect(fs.existsSync(`${configPath}.bak`)).toBe(true);
+        // New config written successfully (corrupted data discarded)
+        const result = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+        expect(result.mcpServers['inet-viui']).toBeDefined();
+    });
+});

package/dist/services/merge-engine.d.ts

@@ -0,0 +1,12 @@
+import readline from 'node:readline/promises';
+export type MergeChoice = 'ours' | 'theirs' | 'skip';
+/** v1 merge: diff + accept/reject per file (ours/theirs/skip) */
+export declare function mergeFile(filePath: string, sourceContent: string, rl: readline.Interface): Promise<MergeChoice>;
+/** Apply merge choice to a file. baseDir constrains writes to prevent traversal. */
+export declare function applyMergeChoice(filePath: string, sourceContent: string, choice: MergeChoice, baseDir?: string): void;
+/** Non-interactive merge: apply all source files (used with --apply flag) */
+export declare function mergeApplyAll(files: Array<{
+    filePath: string;
+    sourceContent: string;
+}>): void;
+//# sourceMappingURL=merge-engine.d.ts.map

package/dist/services/merge-engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge-engine.d.ts","sourceRoot":"","sources":["../../src/services/merge-engine.ts"],"names":[],"mappings":"AAEA,OAAO,QAAQ,MAAM,wBAAwB,CAAA;AAK7C,MAAM,MAAM,WAAW,GAAG,MAAM,GAAG,QAAQ,GAAG,MAAM,CAAA;AAEpD,iEAAiE;AACjE,wBAAsB,SAAS,CAC7B,QAAQ,EAAE,MAAM,EAChB,aAAa,EAAE,MAAM,EACrB,EAAE,EAAE,QAAQ,CAAC,SAAS,GACrB,OAAO,CAAC,WAAW,CAAC,CAoBtB;AAED,oFAAoF;AACpF,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,MAAM,EAChB,aAAa,EAAE,MAAM,EACrB,MAAM,EAAE,WAAW,EACnB,OAAO,CAAC,EAAE,MAAM,GACf,IAAI,CAwBN;AAED,6EAA6E;AAC7E,wBAAgB,aAAa,CAC3B,KAAK,EAAE,KAAK,CAAC;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAA;CAAE,CAAC,GACxD,IAAI,CAIN"}

package/dist/services/merge-engine.js

@@ -0,0 +1,54 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import chalk from 'chalk';
+import { readFileOrEmpty } from './diff-engine.js';
+import { logger } from '../utils/logger.js';
+/** v1 merge: diff + accept/reject per file (ours/theirs/skip) */
+export async function mergeFile(filePath, sourceContent, rl) {
+    const localContent = readFileOrEmpty(filePath);
+    if (localContent === sourceContent) {
+        return 'skip'; // No changes needed
+    }
+    logger.br();
+    logger.header(`Conflict: ${path.basename(filePath)}`);
+    console.log(chalk.dim('  Local (ours) differs from source (theirs)'));
+    logger.br();
+    const answer = await rl.question(`  Choose: ${chalk.cyan('(o)urs')} keep local / ${chalk.green('(t)heirs')} use source / ${chalk.yellow('(s)kip')} ignore: `);
+    const choice = answer.trim().toLowerCase();
+    if (choice === 't' || choice === 'theirs')
+        return 'theirs';
+    if (choice === 'o' || choice === 'ours')
+        return 'ours';
+    return 'skip';
+}
+/** Apply merge choice to a file. baseDir constrains writes to prevent traversal. */
+export function applyMergeChoice(filePath, sourceContent, choice, baseDir) {
+    const resolved = path.resolve(filePath);
+    // Validate path stays within base directory to prevent path traversal
+    if (baseDir) {
+        const resolvedBase = path.resolve(baseDir);
+        if (!resolved.startsWith(resolvedBase + path.sep) && resolved !== resolvedBase) {
+            logger.error(`Path traversal rejected: ${filePath} is outside ${baseDir}`);
+            return;
+        }
+    }
+    switch (choice) {
+        case 'theirs':
+            fs.mkdirSync(path.dirname(resolved), { recursive: true });
+            fs.writeFileSync(resolved, sourceContent, 'utf8');
+            logger.success(`Applied source version: ${path.basename(filePath)}`);
+            break;
+        case 'ours':
+            logger.dim(`Kept local version: ${path.basename(filePath)}`);
+            break;
+        case 'skip':
+            logger.dim(`Skipped: ${path.basename(filePath)}`);
+            break;
+    }
+}
+/** Non-interactive merge: apply all source files (used with --apply flag) */
+export function mergeApplyAll(files) {
+    for (const { filePath, sourceContent } of files) {
+        applyMergeChoice(filePath, sourceContent, 'theirs');
+    }
+}

package/dist/services/vuetify-scaffold-service.d.ts

@@ -0,0 +1,5 @@
+/** Scaffold src/plugins/vuetify.ts from template (wired to viui-conf) */
+export declare function scaffoldVuetifyPlugin(cwd: string, assetsDir: string): void;
+/** Patch main.ts to import and use the scaffolded vuetify plugin */
+export declare function patchMainEntry(cwd: string): void;
+//# sourceMappingURL=vuetify-scaffold-service.d.ts.map

package/dist/services/vuetify-scaffold-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vuetify-scaffold-service.d.ts","sourceRoot":"","sources":["../../src/services/vuetify-scaffold-service.ts"],"names":[],"mappings":"AAKA,yEAAyE;AACzE,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI,CAgB1E;AAED,oEAAoE;AACpE,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAkDhD"}