anchi-toolkit 1.0.0 → 1.2.0

package/src/cli.js

@@ -186,8 +186,8 @@ function getAllFiles(dir, files = []) {
 async function installAntigravity(isForce = false) {
     console.log('');
     log.info('╔═══════════════════════════════════════════════════════════╗');
-    log.info('║        🌌 anchi-toolkit for Antigravity (Gemini)              ║');
-    log.info('║           Complete Installation Package                   ║');
+    log.info('║        🌌 anchi-toolkit for Antigravity (Gemini)          ║');
+    log.info('║              All-in-One Installation                      ║');
     log.info('╚═══════════════════════════════════════════════════════════╝');
     console.log('');
 
@@ -198,19 +198,16 @@ async function installAntigravity(isForce = false) {
     log.gray(`📂 Target: ${targetPath}`);
     console.log('');
 
-    // Show what will be installed
-    log.warn('📦 Components to install:');
-    console.log('  ├── .antigravity/workflows/     18 commands');
-    console.log('  ├── .antigravity/agents/        19 agents');
-    console.log('  ├── .antigravity/skills/        35 skills');
-    console.log('  ├── presets/              3 presets');
-    console.log('  ├── docs/                 Documentation');
-    console.log('  ├── GEMINI.md             AI instructions');
-    console.log('  └── ANTIGRAVITY.md        Antigravity config');
+    // 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 cho Antigravity? (Y/n): ');
+        const confirm = await ask('Tiếp tục cài đặt? (Y/n): ');
         if (confirm.toLowerCase() === 'n') {
             log.error('❌ Đã hủy.');
             rl.close();
@@ -224,77 +221,112 @@ async function installAntigravity(isForce = false) {
     log.warn('📋 Installing anchi-toolkit for Antigravity...');
     console.log('');
 
-    // 1. Copy .antigravity folder (core)
-    const agentSource = path.join(kitPath, '.antigravity');
-    const agentDest = path.join(targetPath, '.antigravity');
+    const antigravityDest = path.join(targetPath, '.antigravity');
+
+    // Ensure .antigravity folder exists
+    if (!fs.existsSync(antigravityDest)) {
+        fs.mkdirSync(antigravityDest, { recursive: true });
+    }
 
+    // 1. Copy .antigravity folder (workflows, agents, skills)
+    const agentSource = path.join(kitPath, '.antigravity');
     if (fs.existsSync(agentSource)) {
-        log.gray(`    📂 Source: ${agentSource}`);
-        await copyWithConflictHandling(agentSource, agentDest, true, isForce);
-        log.success('  ✅ .antigravity/workflows/ - 18 commands');
-        log.success('  ✅ .antigravity/agents/ - 19 agents');
-        log.success('  ✅ .antigravity/skills/ - 35 skills');
+        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
+    // 2. Copy presets INTO .antigravity/presets/
     const presetsSource = path.join(kitPath, 'presets');
-    const presetsDest = path.join(targetPath, 'presets');
+    const presetsDest = path.join(antigravityDest, 'presets');
     if (fs.existsSync(presetsSource)) {
         await copyWithConflictHandling(presetsSource, presetsDest, true, isForce);
         log.success('  ✅ presets/ - 3 architecture presets');
     }
 
-    // 3. Copy docs
+    // 3. Copy docs INTO .antigravity/docs/
     const docsSource = path.join(kitPath, 'docs');
-    const docsDest = path.join(targetPath, 'docs');
+    const docsDest = path.join(antigravityDest, 'docs');
     if (fs.existsSync(docsSource)) {
         await copyWithConflictHandling(docsSource, docsDest, true, isForce);
-        log.success('  ✅ docs/ - Documentation templates');
-    }
-
-    // 4. Copy AI instruction files
-    const geminiMdPath = path.join(kitPath, 'GEMINI.md');
-    if (fs.existsSync(geminiMdPath)) {
-        fs.copyFileSync(geminiMdPath, path.join(targetPath, 'GEMINI.md'));
-        log.success('  ✅ GEMINI.md');
+        log.success('  ✅ docs/ - Documentation');
     }
 
-    const antigravityMdPath = path.join(kitPath, 'ANTIGRAVITY.md');
-    if (fs.existsSync(antigravityMdPath)) {
-        fs.copyFileSync(antigravityMdPath, path.join(targetPath, 'ANTIGRAVITY.md'));
-        log.success('  ✅ ANTIGRAVITY.md');
-    }
-
-    // 5. Copy config files to .antigravity/
+    // 4. Copy config files from .cursor to .antigravity
     const configFiles = [
         'orchestration.yaml',
         'failure-modes.yaml',
         'agent-skill-index.yaml',
-        'team.yaml'
+        'team.yaml',
+        'anchi-toolkit.config.yaml'
     ];
 
     for (const configFile of configFiles) {
-        const configSource = path.join(kitPath, '.cursor', configFile);
-        const configDest = path.join(targetPath, '.antigravity', configFile);
-        if (fs.existsSync(configSource)) {
+        // First check if exists in .antigravity source
+        let configSource = path.join(kitPath, '.antigravity', configFile);
+        if (!fs.existsSync(configSource)) {
+            // Fallback to .cursor
+            configSource = path.join(kitPath, '.cursor', configFile);
+        }
+        const configDest = path.join(antigravityDest, configFile);
+        if (fs.existsSync(configSource) && !fs.existsSync(configDest)) {
             fs.copyFileSync(configSource, configDest);
         }
     }
-    log.success('  ✅ Config files (orchestration, failure-modes, etc.)');
+    // 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 = path.join(kitPath, '.ai-memory');
+    const memoryDest = path.join(antigravityDest, '.ai-memory'); // Inside .antigravity
+    if (fs.existsSync(memorySource)) {
+        await copyWithConflictHandling(memorySource, memoryDest, true, isForce);
+        log.success('  ✅ .ai-memory/ - Context storage');
+    }
+
+    // 7. Create scripts folder (for setup)
+    const scriptsSource = path.join(kitPath, 'scripts');
+    const scriptsDest = path.join(antigravityDest, 'scripts');
+    if (fs.existsSync(scriptsSource)) {
+        await copyWithConflictHandling(scriptsSource, scriptsDest, true, isForce);
+        log.success('  ✅ scripts/ - Setup tools');
+    }
+
+    // 8. Copy ANTIGRAVITY.md to root (entry point doc)
+    const antigravityMdPath = path.join(kitPath, 'ANTIGRAVITY.md');
+    if (fs.existsSync(antigravityMdPath)) {
+        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('');
-    log.success('══════════════════════════════════════════════════════════════');
-    log.success('  ✅ anchi-toolkit for Antigravity installed!');
-    log.success('══════════════════════════════════════════════════════════════');
+    console.log('╭───────────────────────────────────────────────────────────╮');
+    console.log('│                                                           │');
+    log.success('│   🚀 START NOW: Open Antigravity Chat and type:           │');
+    console.log('│                                                           │');
+    log.warn('│                      /start                                │');
+    console.log('│                                                           │');
+    console.log('╰───────────────────────────────────────────────────────────╯');
     console.log('');
-    console.log('📌 Next steps:');
-    log.info('  Open Antigravity Chat → Use slash commands:');
-    log.info('    /start   - Initialize project');
-    log.info('    /do      - Universal command');
-    log.info('    /commit  - Git operations');
-    log.info('    /help    - Show all commands');
+    log.gray('Other commands: /do, /commit, /test, /help');
     console.log('');
 
     rl.close();
@@ -331,17 +363,26 @@ async function install(isForce = false) {
     console.log('');
 
     // Components to install (Cursor AI specific)
+    const cursorDest = path.join(targetPath, '.cursor');
+    if (!fs.existsSync(cursorDest)) fs.mkdirSync(cursorDest, { recursive: true });
+
     const components = [
-        { source: '.cursor', isDir: true, desc: 'Cursor commands, agents, skills' },
-        { source: 'presets', isDir: true, desc: 'Architecture presets' },
-        { source: 'docs', isDir: true, desc: 'Documentation templates' },
-        { source: '.cursorrules', isDir: false, desc: 'Cursor rules' },
-        { source: 'CURSOR.md', isDir: false, desc: 'AI instructions' },
+        // 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.source);
+        const destPath = path.join(targetPath, comp.dest);
 
         if (fs.existsSync(sourcePath)) {
             log.info(`  📦 ${comp.desc}...`);
@@ -411,6 +452,16 @@ async function main() {
             await installAntigravity(isForce);
             break;
 
+        case 'clean':
+            const { clean } = require('./commands/clean');
+            await clean(process.cwd(), {
+                all: flags.includes('--all'),
+                memory: flags.includes('--memory'),
+                audit: flags.includes('--audit'),
+                force: isForce
+            });
+            break;
+
         default:
             showHelp();
             break;
@@ -429,6 +480,7 @@ function showHelp() {
     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)');

package/src/commands/clean.js

@@ -0,0 +1,87 @@
+// =============================================================================
+// anchi-toolkit Clean Command
+// Reset project context and logs
+// =============================================================================
+
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+const { getConfigDir } = require('../lib/configManager');
+
+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 };

package/src/commands/doctor.js

@@ -14,28 +14,47 @@ async function doctor(targetDir = process.cwd()) {
 
     const checks = [];
 
-    // Check .cursor folder
-    const cursorDir = path.join(targetDir, '.cursor');
+    const { getConfigDir, CONFIG_FILENAME } = require('../lib/configManager');
+    const configDir = getConfigDir(targetDir);
+    const configDirName = path.basename(configDir);
+
+    // Check config folder
     checks.push({
-        name: '.cursor folder',
-        ok: fs.existsSync(cursorDir),
+        name: `${configDirName} folder`,
+        ok: fs.existsSync(configDir),
         fix: 'Run: npx anchi-toolkit init'
     });
 
     // Check commands
-    const commandsDir = path.join(cursorDir, 'commands');
-    const commandCount = fs.existsSync(commandsDir)
-        ? fs.readdirSync(commandsDir, { recursive: true }).filter(f => f.endsWith('.md')).length
+    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',
+        name: `Commands/Workflows (${cmdFolderName})`,
         ok: commandCount > 0,
         value: `${commandCount} files`,
         fix: 'Run: npx anchi-toolkit install'
     });
 
     // Check agents
-    const agentsDir = path.join(cursorDir, 'agents');
+    const agentsDir = path.join(configDir, 'agents');
     const agentCount = fs.existsSync(agentsDir)
         ? fs.readdirSync(agentsDir).filter(f => f.endsWith('.md')).length
         : 0;
@@ -46,24 +65,46 @@ async function doctor(targetDir = process.cwd()) {
         fix: 'Run: npx anchi-toolkit install'
     });
 
-    // Check .cursorrules
-    const rulesFile = path.join(targetDir, '.cursorrules');
-    checks.push({
-        name: '.cursorrules',
-        ok: fs.existsSync(rulesFile),
-        fix: 'Run: /use-preset [name]'
-    });
+    // 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(cursorDir, 'anchi-toolkit.config.yaml');
+    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 } = require('../lib/configManager');
+                    parseYaml(content);
+                } catch (e) {
+                    configValid = false;
+                    console.log(`     ❌ Config syntax error: ${e.message}`);
+                }
+            }
+        } catch (e) {
+            configValid = false;
+        }
+    }
     checks.push({
-        name: 'Config file',
-        ok: fs.existsSync(configFile),
-        fix: 'Run: npx anchi-toolkit init'
+        name: 'Config file syntax',
+        ok: configValid,
+        fix: 'Run: npx anchi-toolkit init (or fix YAML)'
     });
 
     // Check docs
-    const docsDir = path.join(targetDir, 'docs');
+    const docsDir = path.join(configDir, 'docs');
     checks.push({
         name: 'Docs folder',
         ok: fs.existsSync(docsDir),
@@ -78,6 +119,32 @@ async function doctor(targetDir = process.cwd()) {
         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) {

package/src/commands/init.js

@@ -286,7 +286,7 @@ async function init() {
     if (finalConfig.includePresets) {
         const presetsPath = path.join(kitPath, 'presets');
         if (fs.existsSync(presetsPath)) {
-            copyDirRecursive(presetsPath, path.join(targetPath, 'presets'));
+            copyDirRecursive(presetsPath, path.join(targetPath, '.cursor/presets'));
             log.success('   ✅ Presets');
         }
     }
@@ -294,11 +294,31 @@ async function init() {
     if (finalConfig.includeDocs) {
         const docsPath = path.join(kitPath, 'docs');
         if (fs.existsSync(docsPath)) {
-            copyDirRecursive(docsPath, path.join(targetPath, '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 = path.join(kitPath, '.ai-memory');
+    if (fs.existsSync(memoryPath)) {
+        copyDirRecursive(memoryPath, path.join(targetPath, '.cursor/.ai-memory'));
+        log.success('   ✅ .ai-memory');
+    }
+
+    // Install scripts
+    const scriptsPath = path.join(kitPath, 'scripts');
+    if (fs.existsSync(scriptsPath)) {
+        copyDirRecursive(scriptsPath, path.join(targetPath, '.cursor/scripts'));
+        log.success('   ✅ scripts');
+    }
+
     // Always include
     const cursorRulesPath = path.join(kitPath, '.cursorrules');
     if (fs.existsSync(cursorRulesPath)) {

package/src/commands/uninstall.js

@@ -59,18 +59,33 @@ async function uninstall() {
 
     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' },
-        { path: 'presets', type: 'dir', desc: 'Presets' },
-        { path: 'docs', type: 'dir', desc: 'Docs (templates)' },
+
+        // 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

package/src/lib/configManager.js

@@ -128,11 +128,25 @@ function deepMerge(target, source) {
     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 configPath = path.join(targetDir, '.cursor', CONFIG_FILENAME);
+    const configDir = getConfigDir(targetDir);
+    const configPath = path.join(configDir, CONFIG_FILENAME);
 
     if (!fs.existsSync(configPath)) {
         return DEFAULT_CONFIG;
@@ -152,11 +166,11 @@ function loadConfig(targetDir) {
  * Save config to target directory
  */
 function saveConfig(targetDir, config) {
-    const cursorDir = path.join(targetDir, '.cursor');
-    const configPath = path.join(cursorDir, CONFIG_FILENAME);
+    const configDir = getConfigDir(targetDir);
+    const configPath = path.join(configDir, CONFIG_FILENAME);
 
-    if (!fs.existsSync(cursorDir)) {
-        fs.mkdirSync(cursorDir, { recursive: true });
+    if (!fs.existsSync(configDir)) {
+        fs.mkdirSync(configDir, { recursive: true });
     }
 
     const header = `# anchi-toolkit Configuration
@@ -197,4 +211,5 @@ module.exports = {
     deepMerge,
     getConfigValue,
     setConfigValue,
+    getConfigDir,
 };

package/src/lib/memoryManager.js

@@ -5,9 +5,10 @@
 
 const fs = require('fs');
 const path = require('path');
+const { getConfigDir } = require('./configManager');
 
-const MEMORY_DIR = '.cursor/context';
-const MEMORY_FILE = 'memory.json';
+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 = {
@@ -36,14 +37,16 @@ const DEFAULT_MEMORY = {
  * Get memory file path
  */
 function getMemoryPath(targetDir) {
-    return path.join(targetDir, MEMORY_DIR, MEMORY_FILE);
+    const configDir = getConfigDir(targetDir);
+    return path.join(configDir, MEMORY_DIR_NAME, MEMORY_FILE);
 }
 
 /**
  * Ensure memory directory exists
  */
 function ensureMemoryDir(targetDir) {
-    const memoryDir = path.join(targetDir, MEMORY_DIR);
+    const configDir = getConfigDir(targetDir);
+    const memoryDir = path.join(configDir, MEMORY_DIR_NAME);
     if (!fs.existsSync(memoryDir)) {
         fs.mkdirSync(memoryDir, { recursive: true });
     }