anchi-toolkit 1.2.2 → 1.2.3

package/dist/index.js

@@ -1 +1,2709 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
+/******/ 	var __webpack_modules__ = ({
+
+/***/ 1:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+// =============================================================================
+// anchi-toolkit Clean Command
+// Reset project context and logs
+// =============================================================================
+
+const fs = __nccwpck_require__(896);
+const path = __nccwpck_require__(928);
+const readline = __nccwpck_require__(785);
+const { getConfigDir } = __nccwpck_require__(256);
+
+const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+});
+
+function ask(question) {
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            resolve(answer);
+        });
+    });
+}
+
+async function clean(targetDir = process.cwd(), options = {}) {
+    console.log('');
+    console.log('🧹 anchi-toolkit Clean');
+    console.log('═══════════════════════════════════════════════════════════════');
+    console.log('');
+
+    const configDir = getConfigDir(targetDir);
+    const auditDir = path.join(configDir, '.ai-audit');
+    const memoryDir = path.join(configDir, '.ai-memory');
+
+    const cleanMemory = options.memory || options.all;
+    const cleanAudit = options.audit || options.all;
+    const isForce = options.force;
+
+    if (!cleanMemory && !cleanAudit) {
+        console.log('Usage:');
+        console.log('  npx anchi-toolkit clean --memory    Clear AI context');
+        console.log('  npx anchi-toolkit clean --audit     Clear logs');
+        console.log('  npx anchi-toolkit clean --all       Clear everything');
+        rl.close();
+        return;
+    }
+
+    console.log('Checking targets:');
+    if (cleanMemory) console.log(`  • Context Memory: ${memoryDir}`);
+    if (cleanAudit) console.log(`  • Audit Logs: ${auditDir}`);
+    console.log('');
+
+    if (!isForce) {
+        const confirm = await ask('⚠️  Are you sure you want to delete these files? (Y/n): ');
+        if (confirm.toLowerCase() === 'n') {
+            console.log('❌ Cancelled.');
+            rl.close();
+            return;
+        }
+    }
+
+    if (cleanMemory) {
+        if (fs.existsSync(memoryDir)) {
+            // Keep the directory, just empty it or recreate it
+            fs.rmSync(memoryDir, { recursive: true, force: true });
+            fs.mkdirSync(memoryDir, { recursive: true });
+            console.log('✅ Memory cleared.');
+        } else {
+            console.log('⚪ Memory already clean.');
+        }
+    }
+
+    if (cleanAudit) {
+        if (fs.existsSync(auditDir)) {
+            fs.rmSync(auditDir, { recursive: true, force: true });
+            fs.mkdirSync(auditDir, { recursive: true });
+            console.log('✅ Audit logs cleared.');
+        } else {
+            console.log('⚪ Audit logs already clean.');
+        }
+    }
+
+    console.log('');
+    console.log('✨ Clean complete!');
+    rl.close();
+}
+
+module.exports = { clean };
+
+
+/***/ }),
+
+/***/ 181:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+// =============================================================================
+// anchi-toolkit Doctor Command
+// Diagnose and check setup health
+// =============================================================================
+
+const fs = __nccwpck_require__(896);
+const path = __nccwpck_require__(928);
+
+async function doctor(targetDir = process.cwd()) {
+    console.log('');
+    console.log('🩺 anchi-toolkit Doctor');
+    console.log('═══════════════════════════════════════════════════════════════');
+    console.log('');
+
+    const checks = [];
+
+    const { getConfigDir, CONFIG_FILENAME } = __nccwpck_require__(256);
+    const configDir = getConfigDir(targetDir);
+    const configDirName = path.basename(configDir);
+
+    // Check config folder
+    checks.push({
+        name: `${configDirName} folder`,
+        ok: fs.existsSync(configDir),
+        fix: 'Run: npx anchi-toolkit init'
+    });
+
+    // Check commands
+    const commandsDir = path.join(configDir, (configDirName === '.antigravity' ? 'workflows' : 'commands'));
+    // Antigravity has workflows, Cursor has commands. Though user might want consistency?
+    // Wait, my ANTIGRAVITY.md says .antigravity/workflows. 
+    // cli.js installs .antigravity/workflows.
+    // So if configDir is .antigravity, check workflows.
+    // If configDir is .cursor, check commands.
+    // Actually, cli.js installs 'workflows' into .antigravity.
+    // Let's check logic:
+    // If .antigravity install: src: .cursor/commands (*.md) -> target: .antigravity/workflows (*.md)
+    // If .cursor install: src: .cursor/commands -> target: .cursor/commands.
+
+    // I need to detect which folder to check based on configDirName.
+    let cmdFolderName = 'commands';
+    if (configDirName === '.antigravity') cmdFolderName = 'workflows';
+
+    const cmdDir = path.join(configDir, cmdFolderName);
+
+    const commandCount = fs.existsSync(cmdDir)
+        ? fs.readdirSync(cmdDir, { recursive: true }).filter(f => f.endsWith('.md')).length
+        : 0;
+    checks.push({
+        name: `Commands/Workflows (${cmdFolderName})`,
+        ok: commandCount > 0,
+        value: `${commandCount} files`,
+        fix: 'Run: npx anchi-toolkit install'
+    });
+
+    // Check agents
+    const agentsDir = path.join(configDir, 'agents');
+    const agentCount = fs.existsSync(agentsDir)
+        ? fs.readdirSync(agentsDir).filter(f => f.endsWith('.md')).length
+        : 0;
+    checks.push({
+        name: 'Agents',
+        ok: agentCount > 0,
+        value: `${agentCount} files`,
+        fix: 'Run: npx anchi-toolkit install'
+    });
+
+    // Check .cursorrules (Only for Cursor?)
+    if (configDirName === '.cursor') {
+        const rulesFile = path.join(targetDir, '.cursorrules');
+        checks.push({
+            name: '.cursorrules',
+            ok: fs.existsSync(rulesFile),
+            fix: 'Run: /use-preset [name]'
+        });
+    }
+
+    // Check config
+    const configFile = path.join(configDir, CONFIG_FILENAME);
+    let configValid = false;
+    if (fs.existsSync(configFile)) {
+        try {
+            const content = fs.readFileSync(configFile, 'utf-8');
+            // Basic YAML validation check
+            if (content.trim().length > 0) {
+                configValid = true;
+                // Try parsing if possible
+                try {
+                    const { parseYaml } = __nccwpck_require__(256);
+                    parseYaml(content);
+                } catch (e) {
+                    configValid = false;
+                    console.log(`     ❌ Config syntax error: ${e.message}`);
+                }
+            }
+        } catch (e) {
+            configValid = false;
+        }
+    }
+    checks.push({
+        name: 'Config file syntax',
+        ok: configValid,
+        fix: 'Run: npx anchi-toolkit init (or fix YAML)'
+    });
+
+    // Check docs
+    const docsDir = path.join(configDir, 'docs');
+    checks.push({
+        name: 'Docs folder',
+        ok: fs.existsSync(docsDir),
+        fix: 'Run: npx anchi-toolkit install'
+    });
+
+    // Check package.json
+    const pkgFile = path.join(targetDir, 'package.json');
+    checks.push({
+        name: 'package.json',
+        ok: fs.existsSync(pkgFile),
+        fix: 'Run: npm init -y'
+    });
+
+    // Check Write Permissions (.ai-memory)
+    const memoryDir = path.join(configDir, '.ai-memory');
+    let memoryWriteable = false;
+    if (!fs.existsSync(memoryDir)) {
+        // Create checks will fail later if not exists, but we can try to create
+        // Actually, install should create it.
+        // If missing, check ok=false
+    }
+    
+    // We check if we can write to configDir (essential for logs/memory)
+    try {
+        if (!fs.existsSync(configDir)) fs.mkdirSync(configDir, {recursive: true});
+        const testFile = path.join(configDir, '.perm-test');
+        fs.writeFileSync(testFile, 'test');
+        fs.unlinkSync(testFile);
+        memoryWriteable = true;
+    } catch (e) {
+        memoryWriteable = false;
+    }
+
+    checks.push({
+        name: 'Write Permissions',
+        ok: memoryWriteable,
+        fix: 'Check folder permissions'
+    });
+
+    // Display results
+    let allOk = true;
+    for (const check of checks) {
+        const status = check.ok ? '✅' : '❌';
+        const value = check.value ? ` (${check.value})` : '';
+        console.log(`  ${status} ${check.name}${value}`);
+        if (!check.ok) {
+            console.log(`     💡 Fix: ${check.fix}`);
+            allOk = false;
+        }
+    }
+
+    console.log('');
+    console.log('═══════════════════════════════════════════════════════════════');
+
+    if (allOk) {
+        console.log('✅ All checks passed! anchi-toolkit is healthy.');
+    } else {
+        console.log('⚠️  Some issues found. See fixes above.');
+    }
+    console.log('');
+
+    return allOk;
+}
+
+module.exports = { doctor };
+
+
+/***/ }),
+
+/***/ 816:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+
+// =============================================================================
+// anchi-toolkit Enhanced Init Command
+// Usage: npx anchi-toolkit init
+// =============================================================================
+
+const fs = __nccwpck_require__(896);
+const path = __nccwpck_require__(928);
+const readline = __nccwpck_require__(785);
+
+const { PROFILES, getProfile, getProfileList, getProfileEstimate } = __nccwpck_require__(251);
+const { getSkillPackList, resolveSkillPacks } = __nccwpck_require__(548);
+const { detectTechStack, suggestSkills, formatDetectedStack } = __nccwpck_require__(835);
+const { calculateInstallSize, getComponentPaths, formatSize } = __nccwpck_require__(568);
+
+// Colors
+const colors = {
+    reset: '\x1b[0m',
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    cyan: '\x1b[36m',
+    gray: '\x1b[90m',
+    bold: '\x1b[1m',
+};
+
+const log = {
+    info: (msg) => console.log(`${colors.cyan}${msg}${colors.reset}`),
+    success: (msg) => console.log(`${colors.green}${msg}${colors.reset}`),
+    warn: (msg) => console.log(`${colors.yellow}${msg}${colors.reset}`),
+    error: (msg) => console.log(`${colors.red}${msg}${colors.reset}`),
+    gray: (msg) => console.log(`${colors.gray}${msg}${colors.reset}`),
+    bold: (msg) => console.log(`${colors.bold}${msg}${colors.reset}`),
+};
+
+const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+});
+
+function ask(question) {
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => resolve(answer.trim()));
+    });
+}
+
+async function askChoice(question, options) {
+    console.log('');
+    log.bold(question);
+    options.forEach((opt, i) => {
+        const estimate = opt.estimate ? ` ${colors.gray}(${opt.estimate})${colors.reset}` : '';
+        console.log(`  ${colors.cyan}${i + 1}${colors.reset}) ${opt.label}${estimate}`);
+        if (opt.description) {
+            log.gray(`     ${opt.description}`);
+        }
+    });
+    console.log('');
+
+    while (true) {
+        const answer = await ask(`${colors.gray}Chọn (1-${options.length}): ${colors.reset}`);
+        const num = parseInt(answer);
+        if (num >= 1 && num <= options.length) {
+            return options[num - 1].value;
+        }
+        log.warn('  Vui lòng chọn số hợp lệ');
+    }
+}
+
+async function askMultiSelect(question, options) {
+    console.log('');
+    log.bold(question);
+    log.gray('  (Nhập số cách nhau bởi dấu phẩy, VD: 1,2,3. Enter để chọn mặc định)');
+    console.log('');
+    options.forEach((opt, i) => {
+        const checked = opt.default ? `${colors.green}◉${colors.reset}` : `${colors.gray}○${colors.reset}`;
+        console.log(`  ${checked} ${colors.cyan}${i + 1}${colors.reset}) ${opt.label}`);
+    });
+    console.log('');
+
+    const answer = await ask(`${colors.gray}Chọn: ${colors.reset}`);
+
+    if (!answer) {
+        return options.filter(o => o.default).map(o => o.value);
+    }
+
+    const nums = answer.split(',').map(s => parseInt(s.trim())).filter(n => n >= 1 && n <= options.length);
+    return nums.map(n => options[n - 1].value);
+}
+
+function copyDirRecursive(src, dest) {
+    if (!fs.existsSync(dest)) {
+        fs.mkdirSync(dest, { recursive: true });
+    }
+    const entries = fs.readdirSync(src, { withFileTypes: true });
+    for (const entry of entries) {
+        const srcPath = path.join(src, entry.name);
+        const destPath = path.join(dest, entry.name);
+        if (entry.isDirectory()) {
+            copyDirRecursive(srcPath, destPath);
+        } else {
+            fs.copyFileSync(srcPath, destPath);
+        }
+    }
+}
+
+function copyFile(src, dest) {
+    const destDir = path.dirname(dest);
+    if (!fs.existsSync(destDir)) {
+        fs.mkdirSync(destDir, { recursive: true });
+    }
+    fs.copyFileSync(src, dest);
+}
+
+async function init() {
+    console.log('');
+    log.info('╔═══════════════════════════════════════════════════════════╗');
+    log.info('║           🚀 anchi-toolkit Smart Install                      ║');
+    log.info('╚═══════════════════════════════════════════════════════════╝');
+    console.log('');
+
+    const targetPath = process.cwd();
+    const kitPath = path.resolve(__dirname, '../..');
+
+    log.gray(`📂 Target: ${targetPath}`);
+
+    // Step 1: Detect tech stack
+    console.log('');
+    log.warn('🔍 Detecting tech stack...');
+    const detected = detectTechStack(targetPath);
+    const detectedStr = formatDetectedStack(detected);
+    log.info(`   ${detectedStr}`);
+
+    const suggestedSkills = suggestSkills(detected);
+    if (suggestedSkills.length > 0) {
+        log.success(`   💡 Suggested skills: ${suggestedSkills.join(', ')}`);
+    }
+
+    // Step 2: Choose profile
+    const profiles = getProfileList();
+    const profileOptions = profiles.map(p => ({
+        label: `${p.name}`,
+        description: p.description,
+        estimate: getProfileEstimate(p.key).formatted || '',
+        value: p.key,
+    }));
+
+    const selectedProfile = await askChoice('Chọn profile:', profileOptions);
+    const profile = getProfile(selectedProfile);
+
+    // Step 3: Customize (if not minimal or fullstack)
+    let finalConfig = { ...profile };
+
+    if (selectedProfile !== 'minimal' && selectedProfile !== 'fullstack') {
+        const customize = await ask(`\n${colors.yellow}Customize thêm? (y/N): ${colors.reset}`);
+
+        if (customize.toLowerCase() === 'y') {
+            // Skill packs
+            const packs = getSkillPackList();
+            const packOptions = packs.map(p => ({
+                label: `${p.name} (${p.skillCount} skills)`,
+                value: p.key,
+                default: false,
+            }));
+
+            const selectedPacks = await askMultiSelect('Thêm skill packs:', packOptions);
+            if (selectedPacks.length > 0) {
+                const extraSkills = resolveSkillPacks(selectedPacks);
+                finalConfig.skills = [...new Set([...finalConfig.skills, ...extraSkills])];
+            }
+
+            // Include presets?
+            if (!finalConfig.includePresets) {
+                const includePresets = await ask(`\n${colors.yellow}Include presets folder? (y/N): ${colors.reset}`);
+                finalConfig.includePresets = includePresets.toLowerCase() === 'y';
+            }
+
+            // Include docs?
+            if (!finalConfig.includeDocs) {
+                const includeDocs = await ask(`${colors.yellow}Include docs folder? (y/N): ${colors.reset}`);
+                finalConfig.includeDocs = includeDocs.toLowerCase() === 'y';
+            }
+        }
+    }
+
+    // Step 4: Size preview
+    console.log('');
+    log.warn('📊 Install Preview:');
+    const components = getComponentPaths(finalConfig, kitPath);
+    const sizeInfo = calculateInstallSize(kitPath, components);
+
+    console.log(`   Files: ~${sizeInfo.files}`);
+    console.log(`   Size: ~${sizeInfo.formatted}`);
+    console.log('');
+    log.info('   Components:');
+
+    if (finalConfig.commands === 'all') {
+        log.success('   ✓ All commands');
+    } else {
+        log.success(`   ✓ Commands: ${finalConfig.commands.join(', ')}`);
+    }
+
+    if (finalConfig.agents === 'all' || (Array.isArray(finalConfig.agents) && finalConfig.agents.length > 0)) {
+        log.success(`   ✓ Agents: ${finalConfig.agents === 'all' ? 'All' : finalConfig.agents.length + ' agents'}`);
+    }
+
+    if (finalConfig.skills === 'all' || (Array.isArray(finalConfig.skills) && finalConfig.skills.length > 0)) {
+        log.success(`   ✓ Skills: ${finalConfig.skills === 'all' ? 'All' : finalConfig.skills.length + ' skills'}`);
+    }
+
+    if (finalConfig.includePresets) log.success('   ✓ Presets');
+    if (finalConfig.includeDocs) log.success('   ✓ Docs');
+
+    // Step 5: Confirm
+    console.log('');
+    const confirm = await ask(`${colors.yellow}Proceed with installation? (Y/n): ${colors.reset}`);
+
+    if (confirm.toLowerCase() === 'n') {
+        log.error('❌ Cancelled.');
+        rl.close();
+        return;
+    }
+
+    // Step 6: Install
+    console.log('');
+    log.warn('📦 Installing...');
+    console.log('');
+
+    let installedFiles = 0;
+
+    // Install commands
+    const commandsPath = __nccwpck_require__.ab + "commands";
+    const destCommandsPath = __nccwpck_require__.ab + "commands";
+
+    if (finalConfig.commands === 'all') {
+        copyDirRecursive(__nccwpck_require__.ab + "commands", destCommandsPath);
+        installedFiles += fs.readdirSync(__nccwpck_require__.ab + "commands").length;
+        log.success('   ✅ Commands (all)');
+    } else {
+        for (const cmd of finalConfig.commands) {
+            const srcFile = __nccwpck_require__.ab + "commands/" + cmd + '.md';
+            if (fs.existsSync(srcFile)) {
+                copyFile(srcFile, __nccwpck_require__.ab + "commands/" + cmd + '.md');
+                installedFiles++;
+            }
+        }
+        log.success(`   ✅ Commands (${finalConfig.commands.length})`);
+    }
+
+    // Install agents
+    const agentsPath = __nccwpck_require__.ab + "agents";
+    const destAgentsPath = __nccwpck_require__.ab + "agents";
+
+    if (finalConfig.agents === 'all') {
+        copyDirRecursive(__nccwpck_require__.ab + "agents", destAgentsPath);
+        log.success('   ✅ Agents (all)');
+    } else if (Array.isArray(finalConfig.agents) && finalConfig.agents.length > 0) {
+        for (const agent of finalConfig.agents) {
+            const srcFile = __nccwpck_require__.ab + "agents/" + agent + '.md';
+            if (fs.existsSync(srcFile)) {
+                copyFile(srcFile, __nccwpck_require__.ab + "agents/" + agent + '.md');
+                installedFiles++;
+            }
+        }
+        log.success(`   ✅ Agents (${finalConfig.agents.length})`);
+    }
+
+    // Install skills
+    const skillsPath = __nccwpck_require__.ab + "skills";
+    const destSkillsPath = __nccwpck_require__.ab + "skills";
+
+    if (finalConfig.skills === 'all') {
+        copyDirRecursive(__nccwpck_require__.ab + "skills", destSkillsPath);
+        log.success('   ✅ Skills (all)');
+    } else if (Array.isArray(finalConfig.skills) && finalConfig.skills.length > 0) {
+        for (const skill of finalConfig.skills) {
+            const srcDir = __nccwpck_require__.ab + "skills/" + skill;
+            if (fs.existsSync(srcDir)) {
+                copyDirRecursive(srcDir, __nccwpck_require__.ab + "skills/" + skill);
+                installedFiles++;
+            }
+        }
+        log.success(`   ✅ Skills (${finalConfig.skills.length})`);
+    }
+
+    // Install extras
+    if (finalConfig.includePresets) {
+        const presetsPath = __nccwpck_require__.ab + "presets";
+        if (fs.existsSync(__nccwpck_require__.ab + "presets")) {
+            copyDirRecursive(presetsPath, path.join(targetPath, '.cursor/presets'));
+            log.success('   ✅ Presets');
+        }
+    }
+
+    if (finalConfig.includeDocs) {
+        const docsPath = __nccwpck_require__.ab + "docs";
+        if (fs.existsSync(__nccwpck_require__.ab + "docs")) {
+            copyDirRecursive(docsPath, path.join(targetPath, '.cursor/docs'));
+            log.success('   ✅ Docs');
+        }
+    }
+
+    // Install AI folders (Implicit)
+    const auditPath = path.join(kitPath, '.ai-audit');
+    if (fs.existsSync(auditPath)) {
+        copyDirRecursive(auditPath, path.join(targetPath, '.cursor/.ai-audit'));
+        log.success('   ✅ .ai-audit');
+    }
+
+    const memoryPath = __nccwpck_require__.ab + ".ai-memory";
+    if (fs.existsSync(__nccwpck_require__.ab + ".ai-memory")) {
+        copyDirRecursive(memoryPath, path.join(targetPath, '.cursor/.ai-memory'));
+        log.success('   ✅ .ai-memory');
+    }
+
+    // Install scripts
+    const scriptsPath = __nccwpck_require__.ab + "scripts";
+    if (fs.existsSync(__nccwpck_require__.ab + "scripts")) {
+        copyDirRecursive(scriptsPath, path.join(targetPath, '.cursor/scripts'));
+        log.success('   ✅ scripts');
+    }
+
+    // Always include
+    const cursorRulesPath = __nccwpck_require__.ab + ".cursorrules";
+    if (fs.existsSync(__nccwpck_require__.ab + ".cursorrules")) {
+        fs.copyFileSync(cursorRulesPath, path.join(targetPath, '.cursorrules'));
+        log.success('   ✅ .cursorrules');
+    }
+
+    const cursorMdPath = __nccwpck_require__.ab + "CURSOR.md";
+    if (fs.existsSync(__nccwpck_require__.ab + "CURSOR.md")) {
+        fs.copyFileSync(cursorMdPath, path.join(targetPath, 'CURSOR.md'));
+        log.success('   ✅ CURSOR.md');
+    }
+
+    // Copy MODEL_COSTS.md
+    const modelCostsPath = __nccwpck_require__.ab + "MODEL_COSTS.md";
+    if (fs.existsSync(__nccwpck_require__.ab + "MODEL_COSTS.md")) {
+        copyFile(modelCostsPath, path.join(targetPath, '.cursor/MODEL_COSTS.md'));
+        log.success('   ✅ MODEL_COSTS.md');
+    }
+
+    // Done
+    console.log('');
+    log.info('═══════════════════════════════════════════════════════════════');
+    log.success('  ✅ anchi-toolkit installed successfully!');
+    log.info('═══════════════════════════════════════════════════════════════');
+    console.log('');
+    log.warn('📌 Next steps:');
+    console.log('');
+    console.log('  1. Open Cursor and run:');
+    log.success('     /start');
+    console.log('');
+    console.log('  2. Start coding:');
+    log.success('     /plan "Feature description"');
+    console.log('');
+
+    rl.close();
+}
+
+module.exports = { init };
+
+
+/***/ }),
+
+/***/ 697:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+// =============================================================================
+// anchi-toolkit Memory CLI Command
+// =============================================================================
+
+const { loadMemory, saveMemory, clearMemory, getMemorySummary, addNote, addDecision } = __nccwpck_require__(355);
+
+async function memory(action = 'show', arg = null) {
+    const targetDir = process.cwd();
+
+    console.log('');
+    console.log('🧠 anchi-toolkit Memory');
+    console.log('═══════════════════════════════════════════════════════════════');
+    console.log('');
+
+    switch (action) {
+        case 'show':
+        case undefined:
+            showMemory(targetDir);
+            break;
+
+        case 'save':
+            saveProjectMemory(targetDir, arg);
+            break;
+
+        case 'load':
+            loadProjectMemory(targetDir);
+            break;
+
+        case 'clear':
+            clearProjectMemory(targetDir);
+            break;
+
+        case 'add':
+            addToMemory(targetDir, arg);
+            break;
+
+        default:
+            console.log('Usage:');
+            console.log('  npx anchi-toolkit memory show     Show current memory');
+            console.log('  npx anchi-toolkit memory save     Save context');
+            console.log('  npx anchi-toolkit memory load     Load context');
+            console.log('  npx anchi-toolkit memory clear    Clear memory');
+            console.log('  npx anchi-toolkit memory add "note"  Add a note');
+            break;
+    }
+
+    console.log('');
+}
+
+function showMemory(targetDir) {
+    const memory = loadMemory(targetDir);
+
+    console.log('📂 Project:');
+    if (memory.project.name) {
+        console.log(`   Name: ${memory.project.name}`);
+        if (memory.project.description) {
+            console.log(`   Description: ${memory.project.description}`);
+        }
+        if (memory.project.tech_stack.length > 0) {
+            console.log(`   Tech: ${memory.project.tech_stack.join(', ')}`);
+        }
+        if (memory.project.architecture) {
+            console.log(`   Architecture: ${memory.project.architecture}`);
+        }
+    } else {
+        console.log('   (No project info saved)');
+    }
+
+    console.log('');
+    console.log('📌 Last Session:');
+    if (memory.session.last_task) {
+        console.log(`   Task: ${memory.session.last_task}`);
+        if (memory.session.current_phase) {
+            console.log(`   Phase: ${memory.session.current_phase}`);
+        }
+        console.log(`   Last accessed: ${memory.session.last_accessed || 'Never'}`);
+    } else {
+        console.log('   (No session info)');
+    }
+
+    console.log('');
+    console.log('🧠 Decisions:');
+    if (memory.decisions.length > 0) {
+        const recent = memory.decisions.slice(-5);
+        for (const d of recent) {
+            console.log(`   • ${d.decision}`);
+        }
+        if (memory.decisions.length > 5) {
+            console.log(`   ... and ${memory.decisions.length - 5} more`);
+        }
+    } else {
+        console.log('   (No decisions recorded)');
+    }
+
+    console.log('');
+    console.log('📝 Notes:');
+    if (memory.notes.length > 0) {
+        const recent = memory.notes.slice(-5);
+        for (const n of recent) {
+            console.log(`   • ${n.note}`);
+        }
+        if (memory.notes.length > 5) {
+            console.log(`   ... and ${memory.notes.length - 5} more`);
+        }
+    } else {
+        console.log('   (No notes)');
+    }
+}
+
+function saveProjectMemory(targetDir, note) {
+    const memory = loadMemory(targetDir);
+    if (note) {
+        memory.notes.push({
+            id: Date.now(),
+            note: note,
+            category: 'session',
+            timestamp: new Date().toISOString(),
+        });
+    }
+    const path = saveMemory(targetDir, memory);
+    console.log('✅ Memory saved!');
+    console.log(`   Location: ${path}`);
+    console.log(`   Stats:`);
+    console.log(`     • Decisions: ${memory.decisions.length}`);
+    console.log(`     • Notes: ${memory.notes.length}`);
+    console.log(`     • Entities: ${Object.keys(memory.entities).length}`);
+}
+
+function loadProjectMemory(targetDir) {
+    const summary = getMemorySummary(targetDir);
+    console.log(summary);
+    console.log('');
+    console.log('✅ Context loaded! AI now remembers your project.');
+}
+
+function clearProjectMemory(targetDir) {
+    clearMemory(targetDir);
+    console.log('✅ Memory cleared!');
+    console.log('   All project context has been reset.');
+}
+
+function addToMemory(targetDir, content) {
+    if (!content) {
+        console.log('Usage: npx anchi-toolkit memory add "your note"');
+        return;
+    }
+
+    if (content.startsWith('decision:')) {
+        const parts = content.slice(9).split(' - ');
+        addDecision(targetDir, parts[0].trim(), parts[1] || '');
+        console.log('✅ Decision recorded!');
+    } else {
+        addNote(targetDir, content);
+        console.log('✅ Note added!');
+    }
+}
+
+module.exports = { memory };
+
+
+/***/ }),
+
+/***/ 66:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+
+// =============================================================================
+// anchi-toolkit Uninstall Command
+// Usage: npx anchi-toolkit uninstall
+// =============================================================================
+
+const fs = __nccwpck_require__(896);
+const path = __nccwpck_require__(928);
+const readline = __nccwpck_require__(785);
+
+const colors = {
+    reset: '\x1b[0m',
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    cyan: '\x1b[36m',
+    gray: '\x1b[90m',
+};
+
+const log = {
+    info: (msg) => console.log(`${colors.cyan}${msg}${colors.reset}`),
+    success: (msg) => console.log(`${colors.green}${msg}${colors.reset}`),
+    warn: (msg) => console.log(`${colors.yellow}${msg}${colors.reset}`),
+    error: (msg) => console.log(`${colors.red}${msg}${colors.reset}`),
+    gray: (msg) => console.log(`${colors.gray}${msg}${colors.reset}`),
+};
+
+const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+});
+
+function ask(question) {
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => resolve(answer.trim()));
+    });
+}
+
+function deleteRecursive(dir) {
+    if (fs.existsSync(dir)) {
+        fs.readdirSync(dir).forEach((file) => {
+            const curPath = path.join(dir, file);
+            if (fs.lstatSync(curPath).isDirectory()) {
+                deleteRecursive(curPath);
+            } else {
+                fs.unlinkSync(curPath);
+            }
+        });
+        fs.rmdirSync(dir);
+    }
+}
+
+async function uninstall() {
+    console.log('');
+    log.info('╔═══════════════════════════════════════════════════════════╗');
+    log.info('║           🗑️  anchi-toolkit Uninstall                          ║');
+    log.info('╚═══════════════════════════════════════════════════════════╝');
+    console.log('');
+
+    const targetPath = process.cwd();
+
+    // Items to remove
+    // Items to remove
+    const itemsToRemove = [
+        // Cursor
+        { path: '.cursor/commands', type: 'dir', desc: 'Commands' },
+        { path: '.cursor/agents', type: 'dir', desc: 'Agents' },
+        { path: '.cursor/skills', type: 'dir', desc: 'Skills' },
+        { path: '.cursor/presets', type: 'dir', desc: 'Presets' },
+        { path: '.cursor/docs', type: 'dir', desc: 'Docs' },
+        { path: '.cursor/.ai-audit', type: 'dir', desc: 'Audit Logs' },
+        { path: '.cursor/.ai-memory', type: 'dir', desc: 'Memory' },
+        { path: '.cursor/MODEL_COSTS.md', type: 'file', desc: 'Model costs guide' },
+
+        // Antigravity
+        { path: '.antigravity', type: 'dir', desc: 'Antigravity Folder' },
+
+        // Root files
+        { path: '.cursorrules', type: 'file', desc: 'Cursor rules' },
+        { path: 'CURSOR.md', type: 'file', desc: 'Cursor instructions' },
+        { path: 'GEMINI.md', type: 'file', desc: 'Gemini instructions' },
+        { path: 'ANTIGRAVITY.md', type: 'file', desc: 'Antigravity instructions' },
+
+        // Legacy (Root) - Cleanup old installs
+        { path: 'presets', type: 'dir', desc: 'Presets (Legacy)' },
+        { path: 'docs', type: 'dir', desc: 'Docs (Legacy)' },
+        { path: '.ai-audit', type: 'dir', desc: 'Audit Logs (Legacy)' },
+        { path: '.ai-memory', type: 'dir', desc: 'Memory (Legacy)' },
+    ];
+
+    // Check what exists
+    const existingItems = itemsToRemove.filter(item => {
+        const fullPath = path.join(targetPath, item.path);
+        return fs.existsSync(fullPath);
+    });
+
+    if (existingItems.length === 0) {
+        log.warn('⚠️  No anchi-toolkit files found in this directory.');
+        rl.close();
+        return;
+    }
+
+    // Show what will be removed
+    log.warn('📋 The following will be removed:');
+    console.log('');
+
+    existingItems.forEach(item => {
+        if (item.type === 'dir') {
+            log.error(`   📁 ${item.path}/`);
+        } else {
+            log.error(`   📄 ${item.path}`);
+        }
+    });
+
+    console.log('');
+    log.warn('⚠️  This action cannot be undone!');
+    console.log('');
+
+    const confirm = await ask(`${colors.red}Type 'REMOVE' to confirm: ${colors.reset}`);
+
+    if (confirm !== 'REMOVE') {
+        log.info('❌ Cancelled.');
+        rl.close();
+        return;
+    }
+
+    console.log('');
+    log.warn('🗑️  Removing...');
+    console.log('');
+
+    let removed = 0;
+
+    for (const item of existingItems) {
+        const fullPath = path.join(targetPath, item.path);
+        try {
+            if (item.type === 'dir') {
+                deleteRecursive(fullPath);
+            } else {
+                fs.unlinkSync(fullPath);
+            }
+            log.success(`   ✅ Removed: ${item.path}`);
+            removed++;
+        } catch (e) {
+            log.error(`   ❌ Failed: ${item.path} - ${e.message}`);
+        }
+    }
+
+    // Clean up empty .cursor folder
+    const cursorDir = __nccwpck_require__.ab + ".cursor";
+    if (fs.existsSync(__nccwpck_require__.ab + ".cursor")) {
+        const remaining = fs.readdirSync(cursorDir);
+        if (remaining.length === 0) {
+            fs.rmdirSync(cursorDir);
+            log.gray('   🧹 Removed empty .cursor/');
+        }
+    }
+
+    console.log('');
+    log.info('═══════════════════════════════════════════════════════════════');
+    log.success(`  ✅ Removed ${removed} items!`);
+    log.info('═══════════════════════════════════════════════════════════════');
+    console.log('');
+
+    rl.close();
+}
+
+module.exports = { uninstall };
+
+
+/***/ }),
+
+/***/ 779:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+
+// =============================================================================
+// anchi-toolkit Update Command
+// Usage: npx anchi-toolkit update
+// =============================================================================
+
+const fs = __nccwpck_require__(896);
+const path = __nccwpck_require__(928);
+const https = __nccwpck_require__(692);
+
+const colors = {
+    reset: '\x1b[0m',
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    cyan: '\x1b[36m',
+    gray: '\x1b[90m',
+};
+
+const log = {
+    info: (msg) => console.log(`${colors.cyan}${msg}${colors.reset}`),
+    success: (msg) => console.log(`${colors.green}${msg}${colors.reset}`),
+    warn: (msg) => console.log(`${colors.yellow}${msg}${colors.reset}`),
+    error: (msg) => console.log(`${colors.red}${msg}${colors.reset}`),
+    gray: (msg) => console.log(`${colors.gray}${msg}${colors.reset}`),
+};
+
+// Get current installed version
+function getCurrentVersion() {
+    try {
+        const kitPath = path.resolve(__dirname, '..');
+        const pkgPath = path.join(kitPath, 'package.json');
+        if (fs.existsSync(pkgPath)) {
+            const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+            return pkg.version || '0.0.0';
+        }
+    } catch (e) {
+        return '0.0.0';
+    }
+    return '0.0.0';
+}
+
+// Check npm registry for latest version
+function getLatestVersion() {
+    return new Promise((resolve, reject) => {
+        https.get('https://registry.npmjs.org/anchi-toolkit/latest', (res) => {
+            let data = '';
+            res.on('data', chunk => data += chunk);
+            res.on('end', () => {
+                try {
+                    const pkg = JSON.parse(data);
+                    resolve(pkg.version || '0.0.0');
+                } catch (e) {
+                    resolve('0.0.0');
+                }
+            });
+        }).on('error', () => resolve('0.0.0'));
+    });
+}
+
+// Compare versions (simple semver compare)
+function isNewer(latest, current) {
+    const l = latest.split('.').map(Number);
+    const c = current.split('.').map(Number);
+    for (let i = 0; i < 3; i++) {
+        if ((l[i] || 0) > (c[i] || 0)) return true;
+        if ((l[i] || 0) < (c[i] || 0)) return false;
+    }
+    return false;
+}
+
+// Backup and update files
+function updateFiles(targetPath, kitPath) {
+    const timestamp = new Date().toISOString().replace(/[-:]/g, '').slice(0, 15);
+    const updatableComponents = [
+        { path: '.cursor/commands', desc: 'Commands' },
+        { path: '.cursor/agents', desc: 'Agents' },
+        { path: '.cursor/skills', desc: 'Skills' },
+    ];
+
+    let updated = 0;
+
+    for (const comp of updatableComponents) {
+        const sourcePath = path.join(kitPath, comp.path);
+        const destPath = path.join(targetPath, comp.path);
+
+        if (fs.existsSync(sourcePath) && fs.existsSync(destPath)) {
+            // Backup existing
+            const backupPath = `${destPath}.backup_${timestamp}`;
+            log.gray(`  📦 Backing up ${comp.desc}...`);
+
+            // Copy source to dest (overwrite)
+            copyDirRecursive(sourcePath, destPath);
+            log.success(`  ✅ Updated: ${comp.desc}`);
+            updated++;
+        }
+    }
+
+    return updated;
+}
+
+function copyDirRecursive(src, dest) {
+    if (!fs.existsSync(dest)) {
+        fs.mkdirSync(dest, { recursive: true });
+    }
+    const entries = fs.readdirSync(src, { withFileTypes: true });
+    for (const entry of entries) {
+        const srcPath = path.join(src, entry.name);
+        const destPath = path.join(dest, entry.name);
+        if (entry.isDirectory()) {
+            copyDirRecursive(srcPath, destPath);
+        } else {
+            fs.copyFileSync(srcPath, destPath);
+        }
+    }
+}
+
+// Main update function
+async function update() {
+    console.log('');
+    log.info('╔═══════════════════════════════════════════════════════════╗');
+    log.info('║           🔄 anchi-toolkit Update                             ║');
+    log.info('╚═══════════════════════════════════════════════════════════╝');
+    console.log('');
+
+    const currentVersion = getCurrentVersion();
+    log.gray(`📦 Current version: ${currentVersion}`);
+
+    log.info('🔍 Checking for updates...');
+    const latestVersion = await getLatestVersion();
+
+    if (latestVersion === '0.0.0') {
+        log.warn('⚠️  Could not check npm registry.');
+        log.gray('   Package may not be published yet.');
+        log.info('');
+        log.info('💡 For now, you can update manually:');
+        log.success('   git pull origin main');
+        return;
+    }
+
+    log.gray(`📦 Latest version: ${latestVersion}`);
+    console.log('');
+
+    if (isNewer(latestVersion, currentVersion)) {
+        log.warn(`🆕 New version available: ${currentVersion} → ${latestVersion}`);
+        console.log('');
+        log.info('To update, run:');
+        log.success('  npm update -g anchi-toolkit');
+        log.info('');
+        log.info('Or reinstall:');
+        log.success('  npm install -g anchi-toolkit@latest');
+    } else {
+        log.success('✅ You are using the latest version!');
+    }
+
+    console.log('');
+    log.info('💡 To update project files:');
+    log.success('   npx anchi-toolkit install');
+    log.gray('   (Use Overwrite when prompted)');
+    console.log('');
+}
+
+module.exports = { update };
+
+
+/***/ }),
+
+/***/ 256:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+// =============================================================================
+// anchi-toolkit Config Manager
+// Handles loading, saving, and merging configuration
+// =============================================================================
+
+const fs = __nccwpck_require__(896);
+const path = __nccwpck_require__(928);
+
+const CONFIG_FILENAME = 'anchi-toolkit.config.yaml';
+
+// Default configuration
+const DEFAULT_CONFIG = {
+    version: '2.1',
+    profile: 'developer',
+
+    model_preference: {
+        default: 'auto',
+        complex: 'opus',
+        economy: 'haiku',
+    },
+
+    features: {
+        auto_commit: false,
+        auto_push: false,
+        progress_indicators: true,
+        summary_cards: true,
+        quick_actions: true,
+    },
+
+    team: {
+        role: null,  // frontend, backend, fullstack, lead, etc.
+        slack_webhook: null,
+        notifications: true,
+    },
+
+    hooks: {
+        enabled: false,
+        pre_commit: [],
+        post_merge: [],
+    },
+};
+
+/**
+ * Parse simple YAML (subset)
+ */
+function parseYaml(content) {
+    const result = {};
+    const lines = content.split('\n');
+    const stack = [{ obj: result, indent: -1 }];
+
+    for (const line of lines) {
+        if (line.trim() === '' || line.trim().startsWith('#')) continue;
+
+        const match = line.match(/^(\s*)([^:]+):\s*(.*)$/);
+        if (!match) continue;
+
+        const indent = match[1].length;
+        const key = match[2].trim();
+        let value = match[3].trim();
+
+        // Pop stack until we find parent
+        while (stack.length > 1 && stack[stack.length - 1].indent >= indent) {
+            stack.pop();
+        }
+
+        const parent = stack[stack.length - 1].obj;
+
+        if (value === '' || value === null) {
+            // Nested object
+            parent[key] = {};
+            stack.push({ obj: parent[key], indent: indent });
+        } else {
+            // Parse value
+            if (value === 'true') value = true;
+            else if (value === 'false') value = false;
+            else if (value === 'null') value = null;
+            else if (!isNaN(value)) value = Number(value);
+            else if (value.startsWith('"') && value.endsWith('"')) value = value.slice(1, -1);
+            else if (value.startsWith('[') && value.endsWith(']')) {
+                value = value.slice(1, -1).split(',').map(s => s.trim());
+            }
+            parent[key] = value;
+        }
+    }
+
+    return result;
+}
+
+/**
+ * Stringify to YAML
+ */
+function stringifyYaml(obj, indent = 0) {
+    let result = '';
+    const prefix = '  '.repeat(indent);
+
+    for (const [key, value] of Object.entries(obj)) {
+        if (value === null) {
+            result += `${prefix}${key}: null\n`;
+        } else if (typeof value === 'object' && !Array.isArray(value)) {
+            result += `${prefix}${key}:\n`;
+            result += stringifyYaml(value, indent + 1);
+        } else if (Array.isArray(value)) {
+            result += `${prefix}${key}: [${value.join(', ')}]\n`;
+        } else if (typeof value === 'string') {
+            result += `${prefix}${key}: "${value}"\n`;
+        } else {
+            result += `${prefix}${key}: ${value}\n`;
+        }
+    }
+
+    return result;
+}
+
+/**
+ * Deep merge objects
+ */
+function deepMerge(target, source) {
+    const result = { ...target };
+
+    for (const key of Object.keys(source)) {
+        if (source[key] && typeof source[key] === 'object' && !Array.isArray(source[key])) {
+            result[key] = deepMerge(target[key] || {}, source[key]);
+        } else {
+            result[key] = source[key];
+        }
+    }
+
+    return result;
+}
+
+/**
+ * Get config directory (.antigravity or .cursor)
+ */
+function getConfigDir(targetDir) {
+    // Check for Antigravity first
+    const antigravityDir = path.join(targetDir, '.antigravity');
+    if (fs.existsSync(antigravityDir)) {
+        return antigravityDir;
+    }
+    // Fallback to Cursor
+    return path.join(targetDir, '.cursor');
+}
+
+/**
+ * Load config from target directory
+ */
+function loadConfig(targetDir) {
+    const configDir = getConfigDir(targetDir);
+    const configPath = path.join(configDir, CONFIG_FILENAME);
+
+    if (!fs.existsSync(configPath)) {
+        return DEFAULT_CONFIG;
+    }
+
+    try {
+        const content = fs.readFileSync(configPath, 'utf-8');
+        const userConfig = parseYaml(content);
+        return deepMerge(DEFAULT_CONFIG, userConfig);
+    } catch (e) {
+        console.warn(`Warning: Could not parse config: ${e.message}`);
+        return DEFAULT_CONFIG;
+    }
+}
+
+/**
+ * Save config to target directory
+ */
+function saveConfig(targetDir, config) {
+    const configDir = getConfigDir(targetDir);
+    const configPath = path.join(configDir, CONFIG_FILENAME);
+
+    if (!fs.existsSync(configDir)) {
+        fs.mkdirSync(configDir, { recursive: true });
+    }
+
+    const header = `# anchi-toolkit Configuration
+# https://github.com/ANCHI-STE/anchi-webkit-dev
+# ═══════════════════════════════════════════════════════════════
+
+`;
+
+    fs.writeFileSync(configPath, header + stringifyYaml(config));
+    return configPath;
+}
+
+/**
+ * Get config value by path (e.g., 'features.auto_commit')
+ */
+function getConfigValue(config, keyPath) {
+    return keyPath.split('.').reduce((obj, key) => obj?.[key], config);
+}
+
+/**
+ * Set config value by path
+ */
+function setConfigValue(config, keyPath, value) {
+    const keys = keyPath.split('.');
+    const lastKey = keys.pop();
+    const target = keys.reduce((obj, key) => obj[key] = obj[key] || {}, config);
+    target[lastKey] = value;
+    return config;
+}
+
+module.exports = {
+    DEFAULT_CONFIG,
+    CONFIG_FILENAME,
+    loadConfig,
+    saveConfig,
+    parseYaml,
+    stringifyYaml,
+    deepMerge,
+    getConfigValue,
+    setConfigValue,
+    getConfigDir,
+};
+
+
+/***/ }),
+
+/***/ 835:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+// =============================================================================
+// Tech Stack Detector
+// =============================================================================
+
+const fs = __nccwpck_require__(896);
+const path = __nccwpck_require__(928);
+
+function detectTechStack(targetPath) {
+    const detected = {
+        frameworks: [],
+        languages: [],
+        databases: [],
+        styling: [],
+        auth: [],
+        testing: [],
+    };
+
+    // Check package.json
+    const pkgPath = path.join(targetPath, 'package.json');
+    if (fs.existsSync(pkgPath)) {
+        try {
+            const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+            const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+
+            // Frameworks
+            if (deps['next']) detected.frameworks.push('next');
+            if (deps['react']) detected.frameworks.push('react');
+            if (deps['vue']) detected.frameworks.push('vue');
+            if (deps['express']) detected.frameworks.push('express');
+            if (deps['fastify']) detected.frameworks.push('fastify');
+            if (deps['@nestjs/core']) detected.frameworks.push('nestjs');
+
+            // Databases
+            if (deps['prisma'] || deps['@prisma/client']) detected.databases.push('prisma');
+            if (deps['mongoose']) detected.databases.push('mongodb');
+            if (deps['pg']) detected.databases.push('postgresql');
+            if (deps['mysql2']) detected.databases.push('mysql');
+            if (deps['better-sqlite3']) detected.databases.push('sqlite');
+
+            // Styling
+            if (deps['tailwindcss']) detected.styling.push('tailwind');
+            if (deps['styled-components']) detected.styling.push('styled-components');
+            if (deps['@emotion/react']) detected.styling.push('emotion');
+            if (deps['sass']) detected.styling.push('sass');
+
+            // Auth
+            if (deps['next-auth']) detected.auth.push('next-auth');
+            if (deps['better-auth']) detected.auth.push('better-auth');
+            if (deps['passport']) detected.auth.push('passport');
+
+            // Testing
+            if (deps['jest']) detected.testing.push('jest');
+            if (deps['vitest']) detected.testing.push('vitest');
+            if (deps['playwright']) detected.testing.push('playwright');
+
+            // Languages
+            if (deps['typescript']) detected.languages.push('typescript');
+        } catch (e) {
+            // Ignore parse errors
+        }
+    }
+
+    // Check for config files
+    if (fs.existsSync(path.join(targetPath, 'tailwind.config.js')) ||
+        fs.existsSync(path.join(targetPath, 'tailwind.config.ts'))) {
+        if (!detected.styling.includes('tailwind')) detected.styling.push('tailwind');
+    }
+
+    if (fs.existsSync(path.join(targetPath, 'prisma'))) {
+        if (!detected.databases.includes('prisma')) detected.databases.push('prisma');
+    }
+
+    if (fs.existsSync(path.join(targetPath, 'tsconfig.json'))) {
+        if (!detected.languages.includes('typescript')) detected.languages.push('typescript');
+    }
+
+    return detected;
+}
+
+function suggestSkills(detected) {
+    const suggestions = new Set();
+
+    // Framework-based suggestions
+    if (detected.frameworks.includes('next') || detected.frameworks.includes('react')) {
+        suggestions.add('frontend-development');
+        suggestions.add('web-frameworks');
+    }
+    if (detected.frameworks.includes('express') || detected.frameworks.includes('fastify')) {
+        suggestions.add('backend-development');
+    }
+
+    // Database suggestions
+    if (detected.databases.length > 0) {
+        suggestions.add('databases');
+    }
+
+    // Styling suggestions
+    if (detected.styling.includes('tailwind')) {
+        suggestions.add('ui-styling');
+        suggestions.add('frontend-design');
+    }
+
+    // Auth suggestions
+    if (detected.auth.includes('better-auth')) {
+        suggestions.add('better-auth');
+    }
+
+    // Default suggestions if nothing detected
+    if (suggestions.size === 0) {
+        suggestions.add('frontend-development');
+        suggestions.add('planning');
+    }
+
+    return Array.from(suggestions);
+}
+
+function formatDetectedStack(detected) {
+    const parts = [];
+
+    if (detected.frameworks.length) {
+        parts.push(`Frameworks: ${detected.frameworks.join(', ')}`);
+    }
+    if (detected.databases.length) {
+        parts.push(`Database: ${detected.databases.join(', ')}`);
+    }
+    if (detected.styling.length) {
+        parts.push(`Styling: ${detected.styling.join(', ')}`);
+    }
+    if (detected.auth.length) {
+        parts.push(`Auth: ${detected.auth.join(', ')}`);
+    }
+
+    return parts.length > 0 ? parts.join(' | ') : 'No specific tech detected';
+}
+
+module.exports = {
+    detectTechStack,
+    suggestSkills,
+    formatDetectedStack,
+};
+
+
+/***/ }),
+
+/***/ 355:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+// =============================================================================
+// anchi-toolkit Memory Manager
+// Saves and loads project context to avoid AI "forgetting"
+// =============================================================================
+
+const fs = __nccwpck_require__(896);
+const path = __nccwpck_require__(928);
+const { getConfigDir } = __nccwpck_require__(256);
+
+const MEMORY_DIR_NAME = '.ai-memory';
+const MEMORY_FILE = 'context.json'; // Changed from memory.json to context.json based on what I saw in ls
+
+// Default memory structure
+const DEFAULT_MEMORY = {
+    version: '1.0',
+    project: {
+        name: null,
+        description: null,
+        tech_stack: [],
+        architecture: null,
+        created_at: null,
+        updated_at: null,
+    },
+    session: {
+        last_task: null,
+        current_phase: null,
+        open_files: [],
+        pending_actions: [],
+        last_accessed: null,
+    },
+    decisions: [],
+    notes: [],
+    entities: {},
+};
+
+/**
+ * Get memory file path
+ */
+function getMemoryPath(targetDir) {
+    const configDir = getConfigDir(targetDir);
+    return path.join(configDir, MEMORY_DIR_NAME, MEMORY_FILE);
+}
+
+/**
+ * Ensure memory directory exists
+ */
+function ensureMemoryDir(targetDir) {
+    const configDir = getConfigDir(targetDir);
+    const memoryDir = path.join(configDir, MEMORY_DIR_NAME);
+    if (!fs.existsSync(memoryDir)) {
+        fs.mkdirSync(memoryDir, { recursive: true });
+    }
+    return memoryDir;
+}
+
+/**
+ * Load memory from file
+ */
+function loadMemory(targetDir = process.cwd()) {
+    const memoryPath = getMemoryPath(targetDir);
+
+    if (!fs.existsSync(memoryPath)) {
+        return { ...DEFAULT_MEMORY };
+    }
+
+    try {
+        const content = fs.readFileSync(memoryPath, 'utf-8');
+        const memory = JSON.parse(content);
+        return { ...DEFAULT_MEMORY, ...memory };
+    } catch (e) {
+        console.warn(`Warning: Could not parse memory: ${e.message}`);
+        return { ...DEFAULT_MEMORY };
+    }
+}
+
+/**
+ * Save memory to file
+ */
+function saveMemory(targetDir, memory) {
+    ensureMemoryDir(targetDir);
+    const memoryPath = getMemoryPath(targetDir);
+
+    memory.session.last_accessed = new Date().toISOString();
+    memory.project.updated_at = new Date().toISOString();
+
+    fs.writeFileSync(memoryPath, JSON.stringify(memory, null, 2));
+    return memoryPath;
+}
+
+/**
+ * Update project info
+ */
+function updateProject(targetDir, projectInfo) {
+    const memory = loadMemory(targetDir);
+    memory.project = {
+        ...memory.project,
+        ...projectInfo,
+        updated_at: new Date().toISOString(),
+    };
+    if (!memory.project.created_at) {
+        memory.project.created_at = new Date().toISOString();
+    }
+    saveMemory(targetDir, memory);
+    return memory;
+}
+
+/**
+ * Update session info
+ */
+function updateSession(targetDir, sessionInfo) {
+    const memory = loadMemory(targetDir);
+    memory.session = {
+        ...memory.session,
+        ...sessionInfo,
+        last_accessed: new Date().toISOString(),
+    };
+    saveMemory(targetDir, memory);
+    return memory;
+}
+
+/**
+ * Add a decision
+ */
+function addDecision(targetDir, decision, reason, filesAffected = []) {
+    const memory = loadMemory(targetDir);
+    memory.decisions.push({
+        id: Date.now(),
+        decision,
+        reason,
+        files_affected: filesAffected,
+        timestamp: new Date().toISOString(),
+    });
+    saveMemory(targetDir, memory);
+    return memory;
+}
+
+/**
+ * Add a note
+ */
+function addNote(targetDir, note, category = 'general') {
+    const memory = loadMemory(targetDir);
+    memory.notes.push({
+        id: Date.now(),
+        note,
+        category,
+        timestamp: new Date().toISOString(),
+    });
+    saveMemory(targetDir, memory);
+    return memory;
+}
+
+/**
+ * Add/update an entity
+ */
+function upsertEntity(targetDir, entityName, entityData) {
+    const memory = loadMemory(targetDir);
+    memory.entities[entityName] = {
+        ...memory.entities[entityName],
+        ...entityData,
+        updated_at: new Date().toISOString(),
+    };
+    saveMemory(targetDir, memory);
+    return memory;
+}
+
+/**
+ * Get entity
+ */
+function getEntity(targetDir, entityName) {
+    const memory = loadMemory(targetDir);
+    return memory.entities[entityName] || null;
+}
+
+/**
+ * Clear memory
+ */
+function clearMemory(targetDir) {
+    const memory = { ...DEFAULT_MEMORY };
+    memory.project.created_at = new Date().toISOString();
+    saveMemory(targetDir, memory);
+    return memory;
+}
+
+/**
+ * Get memory summary (for AI context)
+ */
+function getMemorySummary(targetDir) {
+    const memory = loadMemory(targetDir);
+
+    let summary = '';
+
+    // Project info
+    if (memory.project.name) {
+        summary += `## Project: ${memory.project.name}\n`;
+        if (memory.project.description) {
+            summary += `${memory.project.description}\n`;
+        }
+        if (memory.project.tech_stack.length > 0) {
+            summary += `Tech Stack: ${memory.project.tech_stack.join(', ')}\n`;
+        }
+        if (memory.project.architecture) {
+            summary += `Architecture: ${memory.project.architecture}\n`;
+        }
+        summary += '\n';
+    }
+
+    // Session info
+    if (memory.session.last_task) {
+        summary += `## Last Session\n`;
+        summary += `Task: ${memory.session.last_task}\n`;
+        if (memory.session.current_phase) {
+            summary += `Phase: ${memory.session.current_phase}\n`;
+        }
+        summary += '\n';
+    }
+
+    // Recent decisions
+    if (memory.decisions.length > 0) {
+        summary += `## Recent Decisions\n`;
+        const recent = memory.decisions.slice(-5);
+        for (const d of recent) {
+            summary += `- ${d.decision}\n`;
+        }
+        summary += '\n';
+    }
+
+    // Recent notes
+    if (memory.notes.length > 0) {
+        summary += `## Notes\n`;
+        const recent = memory.notes.slice(-5);
+        for (const n of recent) {
+            summary += `- [${n.category}] ${n.note}\n`;
+        }
+    }
+
+    return summary || 'No memory saved yet.';
+}
+
+module.exports = {
+    DEFAULT_MEMORY,
+    loadMemory,
+    saveMemory,
+    updateProject,
+    updateSession,
+    addDecision,
+    addNote,
+    upsertEntity,
+    getEntity,
+    clearMemory,
+    getMemorySummary,
+    getMemoryPath,
+    ensureMemoryDir,
+};
+
+
+/***/ }),
+
+/***/ 251:
+/***/ ((module) => {
+
+// =============================================================================
+// Role-based Profiles
+// =============================================================================
+
+const PROFILES = {
+    minimal: {
+        name: 'Minimal',
+        description: 'Core commands only (fastest install)',
+        commands: ['start', 'plan', 'cook', 'fix'],
+        agents: [],
+        skills: [],
+        includePresets: false,
+        includeDocs: false,
+    },
+
+    developer: {
+        name: 'Developer',
+        description: 'Daily coding (commands + basic agents)',
+        commands: ['start', 'plan', 'cook', 'fix', 'scout', 'generate'],
+        agents: ['planner', 'scout', 'fullstack-developer', 'debugger'],
+        skills: ['frontend-development', 'backend-development', 'databases'],
+        includePresets: false,
+        includeDocs: false,
+    },
+
+    ui_ux: {
+        name: 'UI/UX Designer',
+        description: 'Frontend & Design focus',
+        commands: ['start', 'plan', 'cook', 'design-ui', 'generate'],
+        agents: ['ui-ux-designer', 'design-system-architect', 'planner'],
+        skills: ['frontend-development', 'frontend-design', 'ui-styling', 'aesthetic'],
+        includePresets: false,
+        includeDocs: false,
+    },
+
+    architect: {
+        name: 'Architect',
+        description: 'System design & DDD',
+        commands: ['start', 'plan', 'cook', 'fix', 'design-domain', 'review'],
+        agents: ['planner', 'ddd-architect', 'code-reviewer', 'researcher'],
+        skills: ['ddd-modular-monolith', 'planning', 'backend-development', 'databases'],
+        includePresets: true,
+        includeDocs: true,
+    },
+
+    lead: {
+        name: 'Team Lead',
+        description: 'Code review & management',
+        commands: ['start', 'plan', 'cook', 'fix', 'review', 'scout', 'summary'],
+        agents: ['planner', 'code-reviewer', 'project-manager', 'docs-manager', 'git-manager'],
+        skills: ['code-review', 'planning', 'debugging'],
+        includePresets: false,
+        includeDocs: true,
+    },
+
+    fullstack: {
+        name: 'Full Stack',
+        description: 'Everything included',
+        commands: 'all',
+        agents: 'all',
+        skills: 'all',
+        includePresets: true,
+        includeDocs: true,
+    },
+};
+
+function getProfile(name) {
+    return PROFILES[name] || null;
+}
+
+function getProfileList() {
+    return Object.entries(PROFILES).map(([key, profile]) => ({
+        key,
+        name: profile.name,
+        description: profile.description,
+    }));
+}
+
+function getProfileEstimate(profileKey) {
+    const profile = PROFILES[profileKey];
+    if (!profile) return null;
+
+    const estimates = {
+        minimal: { files: 5, size: '~50KB' },
+        developer: { files: 30, size: '~300KB' },
+        ui_ux: { files: 25, size: '~250KB' },
+        architect: { files: 50, size: '~500KB' },
+        lead: { files: 40, size: '~400KB' },
+        fullstack: { files: 400, size: '~5MB' },
+    };
+
+    return estimates[profileKey] || { files: '?', size: '?' };
+}
+
+module.exports = {
+    PROFILES,
+    getProfile,
+    getProfileList,
+    getProfileEstimate,
+};
+
+
+/***/ }),
+
+/***/ 568:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+// =============================================================================
+// Size Calculator
+// =============================================================================
+
+const fs = __nccwpck_require__(896);
+const path = __nccwpck_require__(928);
+
+function countFilesRecursive(dir) {
+    let count = 0;
+    let size = 0;
+
+    if (!fs.existsSync(dir)) return { count: 0, size: 0 };
+
+    try {
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                const sub = countFilesRecursive(fullPath);
+                count += sub.count;
+                size += sub.size;
+            } else {
+                count++;
+                try {
+                    const stats = fs.statSync(fullPath);
+                    size += stats.size;
+                } catch (e) {
+                    // Ignore
+                }
+            }
+        }
+    } catch (e) {
+        // Ignore
+    }
+
+    return { count, size };
+}
+
+function formatSize(bytes) {
+    if (bytes < 1024) return `${bytes}B`;
+    if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+}
+
+function calculateInstallSize(kitPath, components) {
+    let totalFiles = 0;
+    let totalSize = 0;
+
+    for (const comp of components) {
+        const compPath = path.join(kitPath, comp);
+        if (fs.existsSync(compPath)) {
+            const stats = fs.statSync(compPath);
+            if (stats.isDirectory()) {
+                const { count, size } = countFilesRecursive(compPath);
+                totalFiles += count;
+                totalSize += size;
+            } else {
+                totalFiles++;
+                totalSize += stats.size;
+            }
+        }
+    }
+
+    return {
+        files: totalFiles,
+        size: totalSize,
+        formatted: formatSize(totalSize),
+    };
+}
+
+function getComponentPaths(profile, kitPath) {
+    const components = [];
+
+    // Commands
+    if (profile.commands === 'all') {
+        components.push('.cursor/commands');
+    } else if (Array.isArray(profile.commands)) {
+        profile.commands.forEach(cmd => {
+            components.push(`.cursor/commands/${cmd}.md`);
+        });
+    }
+
+    // Agents
+    if (profile.agents === 'all') {
+        components.push('.cursor/agents');
+    } else if (Array.isArray(profile.agents)) {
+        profile.agents.forEach(agent => {
+            components.push(`.cursor/agents/${agent}.md`);
+        });
+    }
+
+    // Skills
+    if (profile.skills === 'all') {
+        components.push('.cursor/skills');
+    } else if (Array.isArray(profile.skills)) {
+        profile.skills.forEach(skill => {
+            components.push(`.cursor/skills/${skill}`);
+        });
+    }
+
+    // Extras
+    if (profile.includePresets) {
+        components.push('presets');
+    }
+    if (profile.includeDocs) {
+        components.push('docs');
+    }
+
+    // Always include
+    components.push('.cursorrules');
+    components.push('CURSOR.md');
+
+    return components;
+}
+
+module.exports = {
+    countFilesRecursive,
+    formatSize,
+    calculateInstallSize,
+    getComponentPaths,
+};
+
+
+/***/ }),
+
+/***/ 548:
+/***/ ((module) => {
+
+// =============================================================================
+// Skill Packs (Bundled Skills)
+// =============================================================================
+
+const SKILL_PACKS = {
+    frontend: {
+        name: 'Frontend Pack',
+        description: 'UI development skills',
+        skills: [
+            'frontend-development',
+            'frontend-design',
+            'ui-styling',
+            'aesthetic',
+        ],
+    },
+
+    backend: {
+        name: 'Backend Pack',
+        description: 'Server & database skills',
+        skills: [
+            'backend-development',
+            'databases',
+            'better-auth',
+        ],
+    },
+
+    fullstack: {
+        name: 'Fullstack Pack',
+        description: 'Frontend + Backend combined',
+        skills: [
+            'frontend-development',
+            'frontend-design',
+            'ui-styling',
+            'backend-development',
+            'databases',
+            'better-auth',
+            'web-frameworks',
+        ],
+    },
+
+    ddd: {
+        name: 'DDD Pack',
+        description: 'Domain-Driven Design skills',
+        skills: [
+            'ddd-modular-monolith',
+            'planning',
+            'debugging',
+        ],
+    },
+
+    devops: {
+        name: 'DevOps Pack',
+        description: 'CI/CD & infrastructure',
+        skills: [
+            'devops',
+            'debugging',
+        ],
+    },
+
+    ai: {
+        name: 'AI Tools Pack',
+        description: 'AI integration skills',
+        skills: [
+            'ai-multimodal',
+            'mcp-builder',
+            'mcp-management',
+        ],
+    },
+
+    mobile: {
+        name: 'Mobile Pack',
+        description: 'Mobile development',
+        skills: [
+            'mobile-development',
+            'frontend-development',
+        ],
+    },
+};
+
+function getSkillPack(name) {
+    return SKILL_PACKS[name] || null;
+}
+
+function getSkillPackList() {
+    return Object.entries(SKILL_PACKS).map(([key, pack]) => ({
+        key,
+        name: pack.name,
+        description: pack.description,
+        skillCount: pack.skills.length,
+    }));
+}
+
+function resolveSkillPacks(packKeys) {
+    const skills = new Set();
+    for (const key of packKeys) {
+        const pack = SKILL_PACKS[key];
+        if (pack) {
+            pack.skills.forEach(s => skills.add(s));
+        }
+    }
+    return Array.from(skills);
+}
+
+module.exports = {
+    SKILL_PACKS,
+    getSkillPack,
+    getSkillPackList,
+    resolveSkillPacks,
+};
+
+
+/***/ }),
+
+/***/ 896:
+/***/ ((module) => {
+
+"use strict";
+module.exports = require("fs");
+
+/***/ }),
+
+/***/ 692:
+/***/ ((module) => {
+
+"use strict";
+module.exports = require("https");
+
+/***/ }),
+
+/***/ 928:
+/***/ ((module) => {
+
+"use strict";
+module.exports = require("path");
+
+/***/ }),
+
+/***/ 785:
+/***/ ((module) => {
+
+"use strict";
+module.exports = require("readline");
+
+/***/ })
+
+/******/ 	});
+/************************************************************************/
+/******/ 	// The module cache
+/******/ 	var __webpack_module_cache__ = {};
+/******/ 	
+/******/ 	// The require function
+/******/ 	function __nccwpck_require__(moduleId) {
+/******/ 		// Check if module is in cache
+/******/ 		var cachedModule = __webpack_module_cache__[moduleId];
+/******/ 		if (cachedModule !== undefined) {
+/******/ 			return cachedModule.exports;
+/******/ 		}
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = __webpack_module_cache__[moduleId] = {
+/******/ 			// no module.id needed
+/******/ 			// no module.loaded needed
+/******/ 			exports: {}
+/******/ 		};
+/******/ 	
+/******/ 		// Execute the module function
+/******/ 		var threw = true;
+/******/ 		try {
+/******/ 			__webpack_modules__[moduleId](module, module.exports, __nccwpck_require__);
+/******/ 			threw = false;
+/******/ 		} finally {
+/******/ 			if(threw) delete __webpack_module_cache__[moduleId];
+/******/ 		}
+/******/ 	
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/ 	
+/************************************************************************/
+/******/ 	/* webpack/runtime/compat */
+/******/ 	
+/******/ 	if (typeof __nccwpck_require__ !== 'undefined') __nccwpck_require__.ab = __dirname + "/";
+/******/ 	
+/************************************************************************/
+var __webpack_exports__ = {};
+
+// =============================================================================
+// anchi-toolkit CLI
+// Usage: npx anchi-toolkit install
+// =============================================================================
+
+const fs = __nccwpck_require__(896);
+const path = __nccwpck_require__(928);
+const readline = __nccwpck_require__(785);
+
+// =============================================================================
+// COLORS
+// =============================================================================
+const colors = {
+    reset: '\x1b[0m',
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    cyan: '\x1b[36m',
+    gray: '\x1b[90m',
+};
+
+const log = {
+    info: (msg) => console.log(`${colors.cyan}${msg}${colors.reset}`),
+    success: (msg) => console.log(`${colors.green}${msg}${colors.reset}`),
+    warn: (msg) => console.log(`${colors.yellow}${msg}${colors.reset}`),
+    error: (msg) => console.log(`${colors.red}${msg}${colors.reset}`),
+    gray: (msg) => console.log(`${colors.gray}${msg}${colors.reset}`),
+};
+
+// =============================================================================
+// HELPERS
+// =============================================================================
+
+const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+});
+
+function ask(question) {
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            resolve(answer);
+        });
+    });
+}
+
+function writeBanner() {
+    console.log('');
+    log.info('╔═══════════════════════════════════════════════════════════╗');
+    log.info('║           🚀 anchi-toolkit for Cursor AI                      ║');
+    log.info('║     Cài đặt Cursor AI toolkit vào dự án có sẵn            ║');
+    log.info('╚═══════════════════════════════════════════════════════════╝');
+    console.log('');
+}
+
+async function askConflictResolution(filePath, isForce = false) {
+    // Force mode: auto-overwrite
+    if (isForce) {
+        log.gray(`    🔄 Force mode: auto-overwrite ${filePath}`);
+        return 'O';
+    }
+
+    console.log('');
+    log.warn(`⚠️  File đã tồn tại: ${filePath}`);
+    console.log('    [O] Overwrite - Ghi đè (backup file cũ)');
+    console.log('    [S] Skip - Bỏ qua, giữ file hiện tại');
+    console.log('    [M] Merge - Tạo file .new để merge thủ công');
+    console.log('');
+
+    while (true) {
+        const choice = (await ask('    Chọn (O/S/M): ')).toUpperCase();
+        if (['O', 'S', 'M'].includes(choice)) {
+            return choice;
+        }
+        console.log('    Vui lòng chọn O, S, hoặc M');
+    }
+}
+
+function backupFile(filePath) {
+    const timestamp = new Date().toISOString().replace(/[-:]/g, '').replace('T', '_').slice(0, 15);
+    const backupPath = `${filePath}.backup_${timestamp}`;
+    fs.copyFileSync(filePath, backupPath);
+    log.gray(`    📦 Backup: ${backupPath}`);
+    return backupPath;
+}
+
+function copyDirRecursive(src, dest) {
+    if (!fs.existsSync(dest)) {
+        fs.mkdirSync(dest, { recursive: true });
+    }
+
+    const entries = fs.readdirSync(src, { withFileTypes: true });
+
+    for (const entry of entries) {
+        const srcPath = path.join(src, entry.name);
+        const destPath = path.join(dest, entry.name);
+
+        if (entry.isDirectory()) {
+            copyDirRecursive(srcPath, destPath);
+        } else {
+            fs.copyFileSync(srcPath, destPath);
+        }
+    }
+}
+
+async function copyWithConflictHandling(source, destination, isDirectory, isForce = false) {
+    if (isDirectory) {
+        if (fs.existsSync(destination)) {
+            // Directory exists - copy contents with per-file handling
+            const files = getAllFiles(source);
+            for (const srcFile of files) {
+                const relativePath = path.relative(source, srcFile);
+                const destFile = path.join(destination, relativePath);
+                const destDir = path.dirname(destFile);
+
+                if (!fs.existsSync(destDir)) {
+                    fs.mkdirSync(destDir, { recursive: true });
+                }
+
+                if (fs.existsSync(destFile)) {
+                    const choice = await askConflictResolution(relativePath, isForce);
+                    switch (choice) {
+                        case 'O':
+                            backupFile(destFile);
+                            fs.copyFileSync(srcFile, destFile);
+                            log.success(`    ✅ Overwrote: ${relativePath}`);
+                            break;
+                        case 'S':
+                            log.gray(`    ⏭️  Skipped: ${relativePath}`);
+                            break;
+                        case 'M':
+                            fs.copyFileSync(srcFile, `${destFile}.new`);
+                            log.warn(`    📝 Merge manually: ${relativePath} vs ${relativePath}.new`);
+                            break;
+                    }
+                } else {
+                    fs.copyFileSync(srcFile, destFile);
+                }
+            }
+        } else {
+            copyDirRecursive(source, destination);
+            log.success(`    ✅ Copied: ${path.basename(source)}/`);
+        }
+    } else {
+        if (fs.existsSync(destination)) {
+            const choice = await askConflictResolution(path.basename(destination), isForce);
+            switch (choice) {
+                case 'O':
+                    backupFile(destination);
+                    fs.copyFileSync(source, destination);
+                    log.success(`    ✅ Overwrote: ${path.basename(destination)}`);
+                    break;
+                case 'S':
+                    log.gray(`    ⏭️  Skipped: ${path.basename(destination)}`);
+                    break;
+                case 'M':
+                    fs.copyFileSync(source, `${destination}.new`);
+                    log.warn(`    📝 Merge manually: ${path.basename(destination)} vs ${path.basename(destination)}.new`);
+                    break;
+            }
+        } else {
+            fs.copyFileSync(source, destination);
+            log.success(`    ✅ Copied: ${path.basename(destination)}`);
+        }
+    }
+}
+
+function getAllFiles(dir, files = []) {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            getAllFiles(fullPath, files);
+        } else {
+            files.push(fullPath);
+        }
+    }
+    return files;
+}
+
+// =============================================================================
+// ANTIGRAVITY INSTALL
+// =============================================================================
+
+async function installAntigravity(isForce = false) {
+    console.log('');
+    log.info('╔═══════════════════════════════════════════════════════════╗');
+    log.info('║        🌌 anchi-toolkit for Antigravity (Gemini)          ║');
+    log.info('║              All-in-One Installation                      ║');
+    log.info('╚═══════════════════════════════════════════════════════════╝');
+    console.log('');
+
+    const targetPath = process.cwd();
+    const kitPath = path.resolve(__dirname, '..');
+
+    log.gray(`📁 Kit source: ${kitPath}`);
+    log.gray(`📂 Target: ${targetPath}`);
+    console.log('');
+
+    // Show what will be installed - ALL into .antigravity/
+    log.warn('📦 Installing:');
+    console.log('  ├── .antigravity/     19 commands, 19 agents, 35 skills');
+    console.log('  ├── .ai-audit/        Decision logging');
+    console.log('  ├── .ai-memory/       Context storage');
+    console.log('  └── presets/docs      Architecture & docs');
+    console.log('');
+
+    if (!isForce) {
+        const confirm = await ask('Tiếp tục cài đặt? (Y/n): ');
+        if (confirm.toLowerCase() === 'n') {
+            log.error('❌ Đã hủy.');
+            rl.close();
+            process.exit(0);
+        }
+    } else {
+        log.info('🚀 Force mode: skipping confirmation...');
+    }
+
+    console.log('');
+    log.warn('📋 Installing anchi-toolkit for Antigravity...');
+    console.log('');
+
+    const antigravityDest = __nccwpck_require__.ab + ".antigravity";
+
+    // Ensure .antigravity folder exists
+    if (!fs.existsSync(__nccwpck_require__.ab + ".antigravity")) {
+        fs.mkdirSync(__nccwpck_require__.ab + ".antigravity", { recursive: true });
+    }
+
+    // 1. Copy .antigravity folder (workflows, agents, skills)
+    const agentSource = __nccwpck_require__.ab + ".antigravity";
+    if (fs.existsSync(__nccwpck_require__.ab + ".antigravity")) {
+        await copyWithConflictHandling(agentSource, antigravityDest, true, isForce);
+        log.success('  ✅ workflows/ - 18 commands');
+        log.success('  ✅ agents/ - 19 agents');
+        log.success('  ✅ skills/ - 35 skills');
+    } else {
+        log.error(`  ❌ .antigravity folder not found at: ${agentSource}`);
+    }
+
+    // 2. Copy presets INTO .antigravity/presets/
+    const presetsSource = __nccwpck_require__.ab + "presets";
+    const presetsDest = path.join(antigravityDest, 'presets');
+    if (fs.existsSync(__nccwpck_require__.ab + "presets")) {
+        await copyWithConflictHandling(presetsSource, presetsDest, true, isForce);
+        log.success('  ✅ presets/ - 3 architecture presets');
+    }
+
+    // 3. Copy docs INTO .antigravity/docs/
+    const docsSource = __nccwpck_require__.ab + "docs";
+    const docsDest = path.join(antigravityDest, 'docs');
+    if (fs.existsSync(__nccwpck_require__.ab + "docs")) {
+        await copyWithConflictHandling(docsSource, docsDest, true, isForce);
+        log.success('  ✅ docs/ - Documentation');
+    }
+
+    // 4. Copy config files from .cursor to .antigravity
+    const configFiles = [
+        'orchestration.yaml',
+        'failure-modes.yaml',
+        'agent-skill-index.yaml',
+        'team.yaml',
+        'anchi-toolkit.config.yaml'
+    ];
+
+    for (const configFile of configFiles) {
+        // First check if exists in .antigravity source
+        let configSource = __nccwpck_require__.ab + ".antigravity/" + configFile;
+        if (!fs.existsSync(configSource)) {
+            // Fallback to .cursor
+            configSource = __nccwpck_require__.ab + ".cursor/" + configFile;
+        }
+        const configDest = __nccwpck_require__.ab + ".antigravity/" + configFile;
+        if (fs.existsSync(configSource) && !fs.existsSync(configDest)) {
+            fs.copyFileSync(configSource, configDest);
+        }
+    }
+    // 5. Create .ai-audit folder (for logging)
+    const auditSource = path.join(kitPath, '.ai-audit');
+    const auditDest = path.join(antigravityDest, '.ai-audit'); // Inside .antigravity
+    if (fs.existsSync(auditSource)) {
+        await copyWithConflictHandling(auditSource, auditDest, true, isForce);
+        log.success('  ✅ .ai-audit/ - Decision logs');
+    }
+
+    // 6. Create .ai-memory folder (for context)
+    const memorySource = __nccwpck_require__.ab + ".ai-memory";
+    const memoryDest = path.join(antigravityDest, '.ai-memory'); // Inside .antigravity
+    if (fs.existsSync(__nccwpck_require__.ab + ".ai-memory")) {
+        await copyWithConflictHandling(memorySource, memoryDest, true, isForce);
+        log.success('  ✅ .ai-memory/ - Context storage');
+    }
+
+    // 7. Create scripts folder (for setup)
+    const scriptsSource = __nccwpck_require__.ab + "scripts";
+    const scriptsDest = path.join(antigravityDest, 'scripts');
+    if (fs.existsSync(__nccwpck_require__.ab + "scripts")) {
+        await copyWithConflictHandling(scriptsSource, scriptsDest, true, isForce);
+        log.success('  ✅ scripts/ - Setup tools');
+    }
+
+    // 8. Copy ANTIGRAVITY.md to root (entry point doc)
+    const antigravityMdPath = __nccwpck_require__.ab + "ANTIGRAVITY.md";
+    if (fs.existsSync(__nccwpck_require__.ab + "ANTIGRAVITY.md")) {
+        fs.copyFileSync(antigravityMdPath, path.join(targetPath, 'ANTIGRAVITY.md'));
+        log.success('  ✅ ANTIGRAVITY.md (root)');
+    }
+
+    // =====================================================================
+    // SUCCESS MESSAGE - Clear Next Steps
+    // =====================================================================
+    console.log('');
+    console.log('');
+    log.success('╔═══════════════════════════════════════════════════════════╗');
+    log.success('║              ✅ INSTALLATION COMPLETE!                    ║');
+    log.success('╚═══════════════════════════════════════════════════════════╝');
+    console.log('');
+    log.info('📂 Installed to: .antigravity/');
+    console.log('');
+    console.log('╭───────────────────────────────────────────────────────────╮');
+    console.log('│                                                           │');
+    log.success('│   🚀 START NOW: Open Antigravity Chat and type:           │');
+    console.log('│                                                           │');
+    log.warn('│                      /start                                │');
+    console.log('│                                                           │');
+    console.log('╰───────────────────────────────────────────────────────────╯');
+    console.log('');
+    log.gray('Other commands: /do, /commit, /test, /help');
+    console.log('');
+
+    rl.close();
+}
+
+
+// =============================================================================
+// MAIN
+// =============================================================================
+
+async function install(isForce = false) {
+    writeBanner();
+
+    const targetPath = process.cwd();
+    const kitPath = path.resolve(__dirname, '..');
+
+    log.gray(`📁 Kit source: ${kitPath}`);
+    log.gray(`📂 Target: ${targetPath}`);
+    console.log('');
+
+    if (!isForce) {
+        const confirm = await ask('Tiếp tục cài đặt? (Y/n): ');
+        if (confirm.toLowerCase() === 'n') {
+            log.error('❌ Đã hủy.');
+            rl.close();
+            process.exit(0);
+        }
+    } else {
+        log.info('🚀 Force mode: skipping confirmation...');
+    }
+
+    console.log('');
+    log.warn('📋 Installing anchi-toolkit components...');
+    console.log('');
+
+    // Components to install (Cursor AI specific)
+    const cursorDest = __nccwpck_require__.ab + ".cursor";
+    if (!fs.existsSync(__nccwpck_require__.ab + ".cursor")) fs.mkdirSync(__nccwpck_require__.ab + ".cursor", { recursive: true });
+
+    const components = [
+        // Folders go INSIDE .cursor/
+        { source: '.cursor', dest: '.cursor', isDir: true, desc: 'Cursor commands, agents, skills' },
+        { source: 'presets', dest: '.cursor/presets', isDir: true, desc: 'Architecture presets' },
+        { source: 'docs', dest: '.cursor/docs', isDir: true, desc: 'Documentation templates' },
+        { source: 'scripts', dest: '.cursor/scripts', isDir: true, desc: 'Setup scripts' },
+        { source: '.ai-audit', dest: '.cursor/.ai-audit', isDir: true, desc: 'AI decision logs' },
+        { source: '.ai-memory', dest: '.cursor/.ai-memory', isDir: true, desc: 'Context storage' },
+
+        // Root files (Required for IDE)
+        { source: '.cursorrules', dest: '.cursorrules', isDir: false, desc: 'Cursor rules (Root)' },
+        { source: 'CURSOR.md', dest: 'CURSOR.md', isDir: false, desc: 'AI instructions (Root)' },
+    ];
+
+    for (const comp of components) {
+        const sourcePath = path.join(kitPath, comp.source);
+        const destPath = path.join(targetPath, comp.dest);
+
+        if (fs.existsSync(sourcePath)) {
+            log.info(`  📦 ${comp.desc}...`);
+            await copyWithConflictHandling(sourcePath, destPath, comp.isDir, isForce);
+        }
+    }
+
+    console.log('');
+    log.info('═══════════════════════════════════════════════════════════════');
+    log.success('  ✅ anchi-toolkit đã được cài đặt thành công!');
+    log.info('═══════════════════════════════════════════════════════════════');
+    console.log('');
+    log.warn('📌 Bước tiếp theo:');
+    console.log('');
+    console.log('  1. Mở Cursor IDE và chạy:');
+    log.success('     /start');
+    console.log('');
+    console.log('  2. Chọn preset phù hợp:');
+    log.success('     /use-preset rapid|professional|enterprise');
+    console.log('');
+    console.log('  3. Bắt đầu code:');
+    log.success('     /plan "Feature description"');
+    console.log('');
+
+    rl.close();
+}
+
+// Command handler
+const args = process.argv.slice(2);
+const flags = args.filter(a => a.startsWith('-'));
+const commands = args.filter(a => !a.startsWith('-'));
+const command = commands[0];
+const isForce = flags.includes('-y') || flags.includes('--force');
+
+async function main() {
+    switch (command) {
+        case 'install':
+            await install(isForce);
+            break;
+
+        case 'init':
+            const { init } = __nccwpck_require__(816);
+            await init();
+            break;
+
+        case 'update':
+            const { update } = __nccwpck_require__(779);
+            await update();
+            break;
+
+        case 'uninstall':
+            const { uninstall } = __nccwpck_require__(66);
+            await uninstall();
+            break;
+
+        case 'doctor':
+            const { doctor } = __nccwpck_require__(181);
+            await doctor();
+            break;
+
+        case 'memory':
+            const { memory } = __nccwpck_require__(697);
+            await memory(args[1], args[2]);
+            break;
+
+        case 'antigravity':
+            await installAntigravity(isForce);
+            break;
+
+        case 'clean':
+            const { clean } = __nccwpck_require__(1);
+            await clean(process.cwd(), {
+                all: flags.includes('--all'),
+                memory: flags.includes('--memory'),
+                audit: flags.includes('--audit'),
+                force: isForce
+            });
+            break;
+
+        default:
+            showHelp();
+            break;
+    }
+}
+
+function showHelp() {
+    console.log('');
+    log.info('🚀 anchi-toolkit - Cursor AI & Antigravity Toolkit');
+    console.log('');
+    console.log('Commands:');
+    log.success('  npx anchi-toolkit install      Cài đặt cho Cursor AI');
+    log.success('  npx anchi-toolkit antigravity  Cài đặt cho Antigravity (Gemini)');
+    log.success('  npx anchi-toolkit init         Cài đặt thông minh (chọn profile)');
+    log.success('  npx anchi-toolkit update       Kiểm tra cập nhật');
+    log.success('  npx anchi-toolkit uninstall    Gỡ cài đặt');
+    log.success('  npx anchi-toolkit doctor       Kiểm tra setup health');
+    log.success('  npx anchi-toolkit memory       Quản lý project context');
+    log.success('  npx anchi-toolkit clean        Dọn dẹp context/logs');
+    console.log('');
+    console.log('Flags:');
+    log.success('  -y, --force                Bỏ qua tất cả prompts (auto-overwrite)');
+    console.log('');
+    console.log('Examples:');
+    log.gray('  npx anchi-toolkit install -y      # Non-interactive install');
+    log.gray('  npx anchi-toolkit antigravity -y  # Non-interactive Antigravity install');
+    console.log('');
+    console.log('Documentation:');
+    console.log('  https://github.com/ANCHI-STE/anchi-webkit-dev');
+    console.log('');
+}
+
+main().catch((err) => {
+    log.error(`❌ Error: ${err.message}`);
+    rl.close();
+    process.exit(1);
+});
+
+module.exports = __webpack_exports__;
+/******/ })()
+;