claude-mem 3.3.7 → 3.3.9

package/dist/commands/install.js

@@ -0,0 +1,836 @@
+import { readFileSync, writeFileSync, existsSync, chmodSync, mkdirSync, copyFileSync, statSync, readdirSync } from 'fs';
+import { join, dirname } from 'path';
+import { homedir } from 'os';
+import { execSync } from 'child_process';
+import { fileURLToPath } from 'url';
+import * as p from '@clack/prompts';
+import figlet from 'figlet';
+import gradient from 'gradient-string';
+import chalk from 'chalk';
+import boxen from 'boxen';
+import { PACKAGE_NAME } from '../shared/config.js';
+// Enhanced animation utilities
+function createLoadingAnimation(message) {
+    let interval;
+    let frame = 0;
+    const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+    return {
+        start() {
+            interval = setInterval(() => {
+                process.stdout.write(`\r${chalk.cyan(frames[frame % frames.length])} ${message}`);
+                frame++;
+            }, 50); // Faster spinner animation (was 80ms)
+        },
+        stop(result, success = true) {
+            clearInterval(interval);
+            const icon = success ? chalk.green('✓') : chalk.red('✗');
+            process.stdout.write(`\r${icon} ${result}\n`);
+        }
+    };
+}
+// Create animated rainbow text with adjustable speed
+function animatedRainbow(text, speed = 100) {
+    return new Promise((resolve) => {
+        let offset = 0;
+        const maxFrames = 10;
+        const interval = setInterval(() => {
+            // Create a shifted gradient by rotating through different presets
+            const gradients = [fastRainbow, vibrantRainbow, gradient.rainbow, gradient.pastel];
+            const shifted = gradients[offset % gradients.length](text);
+            process.stdout.write('\r' + shifted);
+            offset++;
+            if (offset >= maxFrames) {
+                clearInterval(interval);
+                resolve();
+            }
+        }, speed);
+    });
+}
+// Sleep utility for smooth animations
+const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+// Fast rainbow gradient preset with tighter color transitions
+const fastRainbow = gradient(['#ff0000', '#ff4500', '#ffa500', '#ffff00', '#00ff00', '#00ffff', '#0000ff', '#8b00ff']);
+const vibrantRainbow = gradient(['#ff006e', '#fb5607', '#ffbe0b', '#8338ec', '#3a86ff']);
+// <Block> Silent Prerequisites validation - no visual output unless error
+async function validatePrerequisites() {
+    // No announcement, just run checks silently
+    const checks = [
+        {
+            name: 'Node.js version',
+            check: async () => {
+                const nodeVersion = process.versions.node;
+                const [major] = nodeVersion.split('.').map(Number);
+                return {
+                    success: major >= 18,
+                    message: major >= 18 ? '' : `Node.js ${nodeVersion} is below required version 18.0.0`
+                };
+            }
+        },
+        {
+            name: 'Claude Code CLI',
+            check: async () => {
+                try {
+                    execSync('which claude', { stdio: 'ignore' });
+                    return { success: true, message: '' };
+                }
+                catch {
+                    return { success: false, message: 'Claude Code CLI not found. Please install: https://docs.anthropic.com/claude/docs/claude-code' };
+                }
+            }
+        },
+        {
+            name: 'Write permissions',
+            check: async () => {
+                const testDir = join(homedir(), '.claude-mem-test');
+                try {
+                    mkdirSync(testDir, { recursive: true });
+                    writeFileSync(join(testDir, 'test'), 'test');
+                    execSync(`rm -rf ${testDir}`, { stdio: 'ignore' });
+                    return { success: true, message: '' };
+                }
+                catch {
+                    return { success: false, message: 'No write permissions to home directory' };
+                }
+            }
+        }
+    ];
+    // Run all checks silently
+    for (const { name, check } of checks) {
+        const result = await check();
+        if (!result.success) {
+            // Only show output if there's an error
+            console.log(boxen(chalk.red(`❌ ${name} check failed!\n\n${result.message}`), {
+                padding: 1,
+                margin: 1,
+                borderStyle: 'double',
+                borderColor: 'red'
+            }));
+            return false;
+        }
+    }
+    // Success - no output, just return true
+    return true;
+}
+// </Block>
+// <Block> Claude binary path detection
+function detectClaudePath() {
+    try {
+        const path = execSync('which claude', {
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'ignore']
+        }).trim();
+        return path || null;
+    }
+    catch {
+        return null;
+    }
+}
+// </Block>
+// <Block> Installation status detection
+function detectExistingInstallation() {
+    const result = {
+        hasHooks: false,
+        hasChromaMcp: false,
+        hasSettings: false,
+        scope: undefined
+    };
+    // Check for hooks
+    const hooksDir = join(homedir(), '.claude-mem', 'hooks');
+    result.hasHooks = existsSync(hooksDir) &&
+        existsSync(join(hooksDir, 'pre-compact.js')) &&
+        existsSync(join(hooksDir, 'session-start.js'));
+    // Check for Chroma MCP server configuration
+    const userMcpPath = join(homedir(), '.claude.json');
+    const projectMcpPath = join(process.cwd(), '.mcp.json');
+    if (existsSync(userMcpPath)) {
+        try {
+            const config = JSON.parse(readFileSync(userMcpPath, 'utf8'));
+            if (config.mcpServers?.['claude-mem']) {
+                result.hasChromaMcp = true;
+                result.scope = 'user';
+            }
+        }
+        catch { }
+    }
+    if (existsSync(projectMcpPath)) {
+        try {
+            const config = JSON.parse(readFileSync(projectMcpPath, 'utf8'));
+            if (config.mcpServers?.['claude-mem']) {
+                result.hasChromaMcp = true;
+                result.scope = 'project';
+            }
+        }
+        catch { }
+    }
+    // Check for settings
+    const userSettingsPath = join(homedir(), '.claude-mem', 'settings.json');
+    result.hasSettings = existsSync(userSettingsPath);
+    return result;
+}
+// </Block>
+// <Block> Interactive installation wizard
+async function runInstallationWizard(existingInstall) {
+    const config = {};
+    // If existing installation found, ask about reinstallation
+    if (existingInstall.hasHooks || existingInstall.hasChromaMcp) {
+        const shouldReinstall = await p.confirm({
+            message: '🧠 Existing claude-mem installation detected. Your memories and data are safe!\n\nReinstall to update hooks and configuration?',
+            initialValue: true
+        });
+        if (p.isCancel(shouldReinstall)) {
+            p.cancel('Installation cancelled');
+            return null;
+        }
+        if (!shouldReinstall) {
+            p.cancel('Installation cancelled');
+            return null;
+        }
+        config.forceReinstall = true;
+    }
+    else {
+        config.forceReinstall = false;
+    }
+    // Select installation scope
+    const scope = await p.select({
+        message: 'Select installation scope',
+        options: [
+            {
+                value: 'user',
+                label: 'User (Recommended)',
+                hint: 'Install for current user (~/.claude)'
+            },
+            {
+                value: 'project',
+                label: 'Project',
+                hint: 'Install for current project only (./.mcp.json)'
+            },
+            {
+                value: 'local',
+                label: 'Local',
+                hint: 'Custom local installation'
+            }
+        ],
+        initialValue: existingInstall.scope || 'user'
+    });
+    if (p.isCancel(scope)) {
+        p.cancel('Installation cancelled');
+        return null;
+    }
+    config.scope = scope;
+    // If local scope, ask for custom path
+    if (scope === 'local') {
+        const customPath = await p.text({
+            message: 'Enter custom installation directory',
+            placeholder: join(process.cwd(), '.claude-mem'),
+            validate: (value) => {
+                if (!value)
+                    return 'Path is required';
+                if (!value.startsWith('/') && !value.startsWith('~')) {
+                    return 'Please provide an absolute path';
+                }
+            }
+        });
+        if (p.isCancel(customPath)) {
+            p.cancel('Installation cancelled');
+            return null;
+        }
+        config.customPath = customPath;
+    }
+    // Use default hook timeout (3 minutes)
+    config.hookTimeout = 180000;
+    // Always install/reinstall Chroma MCP - it's required for claude-mem to work
+    // Ask about smart trash alias
+    const enableSmartTrash = await p.confirm({
+        message: 'Enable Smart Trash? This creates an alias for "rm" that moves files to ~/.claude-mem/trash instead of permanently deleting them. You can restore files anytime by typing "claude-mem restore".',
+        initialValue: true
+    });
+    if (p.isCancel(enableSmartTrash)) {
+        p.cancel('Installation cancelled');
+        return null;
+    }
+    config.enableSmartTrash = enableSmartTrash;
+    // Ask about save-on-clear
+    const saveMemoriesOnClear = await p.confirm({
+        message: 'claude-mem is designed to save "memories" when you type /compact. The official compact summary + claude-mem produces the best ongoing results, but sometimes you may want to completely clear the context and still retain the "memories" from your last conversation.\n\nWould you like to save memories when you type "/clear" in Claude Code? When running /clear with this on, it takes about a minute to save memories before your new session starts.',
+        initialValue: false
+    });
+    if (p.isCancel(saveMemoriesOnClear)) {
+        p.cancel('Installation cancelled');
+        return null;
+    }
+    config.saveMemoriesOnClear = saveMemoriesOnClear;
+    return config;
+}
+// </Block>
+// <Block> Backup existing configuration
+async function backupExistingConfig() {
+    const backupDir = join(homedir(), '.claude-mem', 'backups', new Date().toISOString().replace(/[:.]/g, '-'));
+    try {
+        mkdirSync(backupDir, { recursive: true });
+        // Backup hooks if they exist
+        const hooksDir = join(homedir(), '.claude-mem', 'hooks');
+        if (existsSync(hooksDir)) {
+            copyFileRecursively(hooksDir, join(backupDir, 'hooks'));
+        }
+        // Backup settings
+        const settingsPath = join(homedir(), '.claude-mem', 'settings.json');
+        if (existsSync(settingsPath)) {
+            copyFileSync(settingsPath, join(backupDir, 'settings.json'));
+        }
+        // Backup Claude settings
+        const claudeSettingsPath = join(homedir(), '.claude', 'settings.json');
+        if (existsSync(claudeSettingsPath)) {
+            copyFileSync(claudeSettingsPath, join(backupDir, 'claude-settings.json'));
+        }
+        return backupDir;
+    }
+    catch (error) {
+        return null;
+    }
+}
+// </Block>
+// <Block> Directory structure creation - natural setup flow
+function ensureDirectoryStructure() {
+    const claudeMemDir = join(homedir(), '.claude-mem');
+    const hooksDir = join(claudeMemDir, 'hooks');
+    const indexDir = join(claudeMemDir, 'index');
+    const archivesDir = join(claudeMemDir, 'archives');
+    const logsDir = join(claudeMemDir, 'logs');
+    const backupsDir = join(claudeMemDir, 'backups');
+    [claudeMemDir, hooksDir, indexDir, archivesDir, logsDir, backupsDir].forEach(dir => {
+        if (!existsSync(dir)) {
+            mkdirSync(dir, { recursive: true });
+        }
+    });
+}
+// </Block>
+function copyFileRecursively(src, dest) {
+    const stat = statSync(src);
+    if (stat.isDirectory()) {
+        if (!existsSync(dest)) {
+            mkdirSync(dest, { recursive: true });
+        }
+        const files = readdirSync(src);
+        files.forEach((file) => {
+            copyFileRecursively(join(src, file), join(dest, file));
+        });
+    }
+    else {
+        copyFileSync(src, dest);
+    }
+}
+function writeHookFiles(timeout = 180000) {
+    const hooksDir = join(homedir(), '.claude-mem', 'hooks');
+    // Find the installed package hooks directory
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = dirname(__filename);
+    const packageHooksDir = join(__dirname, '..', '..', 'hooks');
+    // Copy hook files from the package instead of creating wrappers
+    const hooks = ['pre-compact.js', 'session-start.js', 'session-end.js'];
+    for (const hookName of hooks) {
+        const sourcePath = join(packageHooksDir, hookName);
+        const destPath = join(hooksDir, hookName);
+        if (existsSync(sourcePath)) {
+            copyFileSync(sourcePath, destPath);
+            chmodSync(destPath, 0o755);
+        }
+    }
+    // Copy shared directory if it exists
+    const sourceSharedDir = join(packageHooksDir, 'shared');
+    const destSharedDir = join(hooksDir, 'shared');
+    if (existsSync(sourceSharedDir)) {
+        copyFileRecursively(sourceSharedDir, destSharedDir);
+    }
+    // Write configuration with custom timeout
+    const hookConfigPath = join(hooksDir, 'config.json');
+    const hookConfig = {
+        packageName: PACKAGE_NAME,
+        cliCommand: PACKAGE_NAME,
+        backend: 'chroma',
+        timeout
+    };
+    writeFileSync(hookConfigPath, JSON.stringify(hookConfig, null, 2));
+}
+function ensureClaudeMdInstructions() {
+    const claudeMdPath = join(homedir(), '.claude', 'CLAUDE.md');
+    const claudeMdDir = dirname(claudeMdPath);
+    // Ensure .claude directory exists
+    if (!existsSync(claudeMdDir)) {
+        mkdirSync(claudeMdDir, { recursive: true });
+    }
+    const instructions = `
+<!-- CLAUDE-MEM INSTRUCTIONS -->
+- You have access to a persistent memory system via the Chroma MCP server (installed as "claude-mem")
+- The memory system automatically compresses and stores context from your sessions
+- Available MCP tools:
+  - \`mcp__claude-mem__chroma_add_documents\`: Store new knowledge as documents in the "claude_memories" collection
+  - \`mcp__claude-mem__chroma_query_documents\`: Search for relevant memories using semantic search in the "claude_memories" collection
+  - \`mcp__claude-mem__chroma_get_documents\`: Retrieve specific documents by IDs from the "claude_memories" collection
+- **Document Structure:**
+  - Documents are stored as natural language descriptions of knowledge
+  - Each document has metadata including: timestamp, session_id, keywords, entity_type
+  - Use descriptive content that captures the essence of what was learned or accomplished
+- **Search Tips:**
+  - Use semantic queries: \`chroma_query_documents\` with natural language queries
+  - Search by metadata: Use \`where\` parameter to filter by entity_type, timestamp, etc.
+  - Use keywords in metadata for precise filtering
+- **Storage Format:**
+  - Store knowledge as readable documents rather than structured entities
+  - Include context, rationale, and outcomes in document content
+  - Use metadata to categorize and filter memories
+- **Smart Retrieval Commands:**
+  - **Find similar concepts**: \`chroma_query_documents(["your search terms"])\`
+    - Example: \`chroma_query_documents(["websocket", "connection"])\` - finds all websocket-related memories
+  - **Load specific memory**: \`chroma_get_documents(["document_id"])\`
+    - Example: \`chroma_get_documents(["project_session_1"])\` - loads exact memory by ID
+  - **Search by metadata**: Use keywords from memories to find related items
+    - The system uses semantic search, so "auth" will find "authentication", "login", etc.
+  - **Find connected memories**: Look for memories with related_to fields linking them together
+- Collection name: "claude_memories"
+- Compressed session archives are stored in ~/.claude-mem/archives/
+- **Optimal Search Strategies:**
+  - **Most Effective Patterns:**
+    - Session continuity: \`where: {session_id: "xxx"}\` - precise retrieval of all session work
+    - Find specific fixes: \`where: {type: "fix"}\` - filters to only bug fixes
+    - Natural language queries: "fixing overview display in templates" beats "fix AND overview AND template"
+    - Include file/function names: "extractOverview ContextTemplates" for precise code location
+  - **Search by Intent:**
+    - Debug: Use exact error messages or symptom descriptions
+    - Find code: Include function names + file names when known
+    - Architecture: Search "migration from X to Y" or "refactored X"
+    - Agent work: Search agent names directly (e.g., "steve-krug-ux")
+  - **What Doesn't Work:**
+    - Boolean operators (AND/OR) - treated as literal text
+    - Timestamp filtering with strings - needs numeric values
+    - Generic tech terms alone - too broad, add context
+    - Complex where clauses - only basic operators supported ($eq, $ne, $in)
+  - **Best Practice:** Semantic search for discovery, metadata filtering for precision. Combine both when possible.
+<!-- /CLAUDE-MEM INSTRUCTIONS -->`;
+    // Check if file exists and read content
+    let content = '';
+    if (existsSync(claudeMdPath)) {
+        content = readFileSync(claudeMdPath, 'utf8');
+        // Check if instructions already exist
+        if (content.includes('<!-- CLAUDE-MEM INSTRUCTIONS -->')) {
+            // Replace existing instructions
+            const startMarker = '<!-- CLAUDE-MEM INSTRUCTIONS -->';
+            const endMarker = '<!-- /CLAUDE-MEM INSTRUCTIONS -->';
+            const startIndex = content.indexOf(startMarker);
+            const endIndex = content.indexOf(endMarker) + endMarker.length;
+            if (startIndex !== -1 && endIndex !== -1) {
+                content = content.substring(0, startIndex) + instructions.trim() + content.substring(endIndex);
+            }
+        }
+        else {
+            // Append instructions to the end
+            content = content.trim() + '\n' + instructions;
+        }
+    }
+    else {
+        // Create new file with instructions
+        content = instructions.trim();
+    }
+    // Write the updated content
+    writeFileSync(claudeMdPath, content);
+}
+async function installChromaMcp() {
+    const loader = createLoadingAnimation('Installing Chroma MCP server...');
+    loader.start();
+    try {
+        await sleep(400); // Realistic timing
+        // Remove existing claude-mem MCP server if it exists (silently ignore errors)
+        try {
+            execSync('claude mcp remove claude-mem', { stdio: 'pipe' });
+            await sleep(200);
+        }
+        catch {
+            // Ignore errors - server may not exist
+        }
+        // Install fresh Chroma MCP server
+        const chromaMcpCommand = `claude mcp add claude-mem -- uvx chroma-mcp --client-type persistent --data-dir ${homedir()}/.claude-mem/chroma`;
+        execSync(chromaMcpCommand, { stdio: 'pipe' });
+        await sleep(300);
+        loader.stop(vibrantRainbow('Chroma MCP server installed successfully! 🚀'), true);
+        return true;
+    }
+    catch (error) {
+        loader.stop('Chroma MCP server installation failed', false);
+        console.log(boxen(chalk.yellow(`⚠️  Manual installation required:\n\n${chalk.cyan(`claude mcp add claude-mem -- uvx chroma-mcp --client-type persistent --data-dir ${homedir()}/.claude-mem/chroma`)}`), {
+            padding: 1,
+            margin: 1,
+            borderStyle: 'round',
+            borderColor: 'yellow'
+        }));
+        return false;
+    }
+}
+async function configureHooks(settingsPath, config) {
+    const claudeMemHooksDir = join(homedir(), '.claude-mem', 'hooks');
+    const preCompactScript = join(claudeMemHooksDir, 'pre-compact.js');
+    const sessionStartScript = join(claudeMemHooksDir, 'session-start.js');
+    const sessionEndScript = join(claudeMemHooksDir, 'session-end.js');
+    let settings = {};
+    if (existsSync(settingsPath)) {
+        const content = readFileSync(settingsPath, 'utf8');
+        settings = JSON.parse(content);
+    }
+    // Ensure settings directory exists
+    const settingsDir = dirname(settingsPath);
+    if (!existsSync(settingsDir)) {
+        mkdirSync(settingsDir, { recursive: true });
+    }
+    // Initialize hooks structure if it doesn't exist
+    if (!settings.hooks) {
+        settings.hooks = {};
+    }
+    // Remove existing claude-mem hooks to ensure clean installation/update
+    // Non-tool hooks: filter out configs where hooks contain our commands
+    if (settings.hooks.PreCompact) {
+        settings.hooks.PreCompact = settings.hooks.PreCompact.filter((cfg) => !cfg.hooks?.some((hook) => hook.command?.includes(PACKAGE_NAME) || hook.command?.includes('pre-compact.js')));
+        if (!settings.hooks.PreCompact.length)
+            delete settings.hooks.PreCompact;
+    }
+    if (settings.hooks.SessionStart) {
+        settings.hooks.SessionStart = settings.hooks.SessionStart.filter((cfg) => !cfg.hooks?.some((hook) => hook.command?.includes(PACKAGE_NAME) || hook.command?.includes('session-start.js')));
+        if (!settings.hooks.SessionStart.length)
+            delete settings.hooks.SessionStart;
+    }
+    if (settings.hooks.SessionEnd) {
+        settings.hooks.SessionEnd = settings.hooks.SessionEnd.filter((cfg) => !cfg.hooks?.some((hook) => hook.command?.includes(PACKAGE_NAME) || hook.command?.includes('session-end.js')));
+        if (!settings.hooks.SessionEnd.length)
+            delete settings.hooks.SessionEnd;
+    }
+    /**
+     * 🔒 LOCKED by @docs-agent | Change to 🔑 to allow @docs-agent edits
+     *
+     * OFFICIAL DOCS: Claude Code Hooks Configuration v2025
+     * Last Verified: 2025-08-31
+     *
+     * Hook Configuration Structure Requirements:
+     * - Tool-related hooks (PreToolUse, PostToolUse): Use 'matcher' field for tool patterns
+     * - Non-tool hooks (PreCompact, SessionStart, SessionEnd, etc.): NO matcher/pattern field
+     *
+     * Correct Non-Tool Hook Structure:
+     * {
+     *   hooks: [{
+     *     type: "command",
+     *     command: "/path/to/script.js"
+     *   }]
+     * }
+     *
+     * @see https://docs.anthropic.com/en/docs/claude-code/hooks
+     * @see docs/claude-code/hook-configuration.md for full documentation
+     */
+    // Add PreCompact hook - Non-tool hook (no matcher field)
+    if (!settings.hooks.PreCompact) {
+        settings.hooks.PreCompact = [];
+    }
+    // ✅ CORRECT: Non-tool hooks have no 'pattern' or 'matcher' field
+    settings.hooks.PreCompact.push({
+        hooks: [
+            {
+                type: "command",
+                command: preCompactScript,
+                timeout: config.hookTimeout
+            }
+        ]
+    });
+    // Add SessionStart hook - Non-tool hook (no matcher field)
+    if (!settings.hooks.SessionStart) {
+        settings.hooks.SessionStart = [];
+    }
+    // ✅ CORRECT: Non-tool hooks have no 'pattern' or 'matcher' field
+    settings.hooks.SessionStart.push({
+        hooks: [
+            {
+                type: "command",
+                command: sessionStartScript
+            }
+        ]
+    });
+    // Add SessionEnd hook (only if the file exists)
+    if (existsSync(sessionEndScript)) {
+        if (!settings.hooks.SessionEnd) {
+            settings.hooks.SessionEnd = [];
+        }
+        // ✅ CORRECT: Non-tool hooks have no 'pattern' or 'matcher' field
+        settings.hooks.SessionEnd.push({
+            hooks: [{
+                    type: "command",
+                    command: sessionEndScript,
+                    timeout: config.hookTimeout
+                }]
+        });
+    }
+    // Write updated settings
+    writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+}
+async function configureSmartTrashAlias() {
+    const homeDir = homedir();
+    const shellConfigs = [
+        join(homeDir, '.bashrc'),
+        join(homeDir, '.zshrc'),
+        join(homeDir, '.bash_profile')
+    ];
+    const aliasLine = 'alias rm="claude-mem trash"';
+    const commentLine = '# claude-mem smart trash alias';
+    for (const configPath of shellConfigs) {
+        if (!existsSync(configPath))
+            continue;
+        try {
+            let content = readFileSync(configPath, 'utf8');
+            // Check if alias already exists
+            if (content.includes(aliasLine)) {
+                continue; // Already configured
+            }
+            // Add the alias
+            const aliasBlock = `\n${commentLine}\n${aliasLine}\n`;
+            content += aliasBlock;
+            writeFileSync(configPath, content);
+        }
+        catch (error) {
+            // Silent fail - not critical
+        }
+    }
+}
+async function verifyInstallation() {
+    const s = p.spinner();
+    s.start('Verifying installation');
+    const issues = [];
+    // Check hooks
+    const hooksDir = join(homedir(), '.claude-mem', 'hooks');
+    if (!existsSync(join(hooksDir, 'pre-compact.js'))) {
+        issues.push('Pre-compact hook not found');
+    }
+    if (!existsSync(join(hooksDir, 'session-start.js'))) {
+        issues.push('Session-start hook not found');
+    }
+    if (issues.length > 0) {
+        s.stop('Installation verification completed with issues');
+        p.log.warn('The following issues were detected:');
+        issues.forEach(issue => p.log.error(`  - ${issue}`));
+        p.log.info('The installation may not work correctly. Consider reinstalling with --force flag.');
+    }
+    else {
+        s.stop('Installation verified successfully');
+    }
+}
+export async function install(options = {}) {
+    // Create stunning ASCII banner
+    try {
+        const banner = await new Promise((resolve, reject) => {
+            figlet('claude-mem', (err, data) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve(data || 'claude-mem');
+            });
+        });
+        console.log(fastRainbow(banner));
+    }
+    catch {
+        // Fallback banner if figlet fails
+        console.log(fastRainbow('\n██████╗ ██╗      ██████╗ ██╗   ██╗██████╗ ███████╗      ███████╗ ███████╗███╗   ███╗'));
+        console.log(fastRainbow('██╔═════╝██║     ██╔══██╗██║   ██║██╔══██╗██╔════╝      ██╔════╝ ██╔════╝████╗ ████║'));
+        console.log(fastRainbow('██║     ██║     ███████║██║   ██║██║  ██║█████╗        █████╗   █████╗  ██╔████╔██║'));
+        console.log(fastRainbow('██║     ██║     ██╔══██║██║   ██║██║  ██║██╔══╝        ██╔══╝   ██╔══╝  ██║╚██╔╝██║'));
+        console.log(fastRainbow('╚██████╗███████╗██║  ██║╚██████╔╝██████╔╝███████╗      ███████╗███████╗██║ ╚═╝ ██║'));
+        console.log(fastRainbow(' ╚═════╝╚══════╝╚═╝  ╚═╝ ╚═════╝ ╚═════╝ ╚══════╝      ╚══════╝╚══════╝╚═╝     ╚═╝'));
+    }
+    console.log(boxen(vibrantRainbow('🧠 Persistent Memory System for Claude Code\n\n✨ Transform your Claude experience with seamless context preservation\n🚀 Never lose your conversation history again'), {
+        padding: 2,
+        margin: 1,
+        borderStyle: 'double',
+        borderColor: 'magenta',
+        textAlignment: 'center'
+    }));
+    await sleep(500); // Let the banner shine
+    // Check if running with flags (non-interactive mode)
+    const isNonInteractive = options.user || options.project || options.local || options.force;
+    let config;
+    if (isNonInteractive) {
+        // Non-interactive mode - use flags
+        config = {
+            scope: options.local ? 'local' : options.project ? 'project' : 'user',
+            customPath: options.path,
+            hookTimeout: options.timeout || 180000,
+            forceReinstall: !!options.force,
+        };
+    }
+    else {
+        // Interactive mode
+        // Validate prerequisites
+        const prereqValid = await validatePrerequisites();
+        if (!prereqValid) {
+            p.outro('Please fix the prerequisites issues and try again');
+            process.exit(1);
+        }
+        // Detect existing installation
+        const existingInstall = detectExistingInstallation();
+        // Run installation wizard
+        const wizardConfig = await runInstallationWizard(existingInstall);
+        if (!wizardConfig) {
+            process.exit(0);
+        }
+        config = wizardConfig;
+    }
+    // Backup existing configuration if force reinstall
+    if (config.forceReinstall) {
+        const backupPath = await backupExistingConfig();
+        if (backupPath) {
+            p.log.info(`Backup created at: ${backupPath}`);
+        }
+    }
+    // Enhanced installation steps with beautiful progress
+    console.log(vibrantRainbow('\n🚀 Beginning Installation Process\n'));
+    const installationSteps = [
+        {
+            name: 'Creating directory structure',
+            action: async () => {
+                await sleep(200);
+                ensureDirectoryStructure();
+                await sleep(100);
+            }
+        },
+        {
+            name: 'Installing Chroma MCP server',
+            action: async () => {
+                const success = await installChromaMcp();
+                if (!success)
+                    throw new Error('MCP installation failed');
+            }
+        },
+        {
+            name: 'Adding CLAUDE.md instructions',
+            action: async () => {
+                await sleep(300);
+                ensureClaudeMdInstructions();
+                await sleep(200);
+            }
+        },
+        {
+            name: 'Installing memory hooks',
+            action: async () => {
+                await sleep(400);
+                writeHookFiles(config.hookTimeout);
+                await sleep(200);
+            }
+        },
+        {
+            name: 'Configuring Claude settings',
+            action: async () => {
+                await sleep(300);
+                // Determine settings path
+                let settingsPath;
+                if (config.scope === 'local' && config.customPath) {
+                    settingsPath = join(config.customPath, 'settings.local.json');
+                }
+                else if (config.scope === 'project') {
+                    settingsPath = join(process.cwd(), '.claude', 'settings.json');
+                }
+                else {
+                    settingsPath = join(homedir(), '.claude', 'settings.json');
+                }
+                await configureHooks(settingsPath, config);
+                // Store backend setting in user settings
+                const userSettingsDir = join(homedir(), '.claude-mem');
+                const userSettingsPath = join(userSettingsDir, 'settings.json');
+                let userSettings = {};
+                if (existsSync(userSettingsPath)) {
+                    try {
+                        userSettings = JSON.parse(readFileSync(userSettingsPath, 'utf8'));
+                    }
+                    catch { }
+                }
+                userSettings.backend = 'chroma';
+                userSettings.installed = true;
+                userSettings.embedded = true;
+                userSettings.saveMemoriesOnClear = config.saveMemoriesOnClear || false;
+                // Detect and store Claude binary path
+                const claudePath = detectClaudePath();
+                if (claudePath) {
+                    userSettings.claudePath = claudePath;
+                }
+                else {
+                    delete userSettings.claudePath;
+                }
+                writeFileSync(userSettingsPath, JSON.stringify(userSettings, null, 2));
+                await sleep(200);
+            }
+        }
+    ];
+    // Add Smart Trash step if enabled
+    if (config.enableSmartTrash) {
+        installationSteps.push({
+            name: 'Configuring Smart Trash alias',
+            action: async () => {
+                await sleep(200);
+                await configureSmartTrashAlias();
+                await sleep(100);
+            }
+        });
+    }
+    // Execute all steps with enhanced progress display
+    for (let i = 0; i < installationSteps.length; i++) {
+        const step = installationSteps[i];
+        const progress = `[${i + 1}/${installationSteps.length}]`;
+        const loader = createLoadingAnimation(`${chalk.gray(progress)} ${step.name}...`);
+        loader.start();
+        try {
+            await step.action();
+            loader.stop(`${chalk.gray(progress)} ${step.name} ${vibrantRainbow('completed! ✨')}`);
+        }
+        catch (error) {
+            loader.stop(`${chalk.gray(progress)} ${step.name} ${chalk.red('failed')}`, false);
+            console.log(boxen(chalk.red(`❌ Installation failed at: ${step.name}\n\nError: ${error}`), {
+                padding: 1,
+                margin: 1,
+                borderStyle: 'double',
+                borderColor: 'red'
+            }));
+            process.exit(1);
+        }
+        await sleep(150); // Smooth progression
+    }
+    // Verification with style
+    console.log(chalk.gray('\n🔍 Verifying Installation\n'));
+    await verifyInstallation();
+    // Beautiful success message
+    const successTitle = fastRainbow('🎉 INSTALLATION COMPLETE! 🎉');
+    const successMessage = `
+${chalk.bold('How your new memory system works:')}
+
+${chalk.green('•')} When you start Claude Code, claude-mem loads your latest memories automatically
+${chalk.green('•')} Save your work by typing ${chalk.cyan('/compact')} or ${chalk.cyan('/clear')} (takes ~30s to process)
+${chalk.green('•')} Ask Claude to search your memories anytime with natural language
+${chalk.green('•')} Instructions added to ${chalk.cyan('~/.claude/CLAUDE.md')} teach Claude how to use the system
+
+${chalk.bold('Quick Start:')}
+${chalk.yellow('1.')} Restart Claude Code to activate your memory system
+${chalk.yellow('2.')} Start using Claude normally - memories save automatically
+${chalk.yellow('3.')} Search memories by asking: ${chalk.italic('"Search my memories for X"')}`;
+    // Check Claude path detection result and inform user
+    const finalClaudePath = detectClaudePath();
+    const finalClaudePathNote = finalClaudePath
+        ? `\n\n${chalk.green('✓')} Claude binary detected at: ${chalk.cyan(finalClaudePath)}`
+        : `\n\n${chalk.yellow('⚠️')} Claude binary not found in PATH. Features will still work with manual configuration.`;
+    const finalSmartTrashNote = config.enableSmartTrash ?
+        `\n\n${chalk.blue('🗑️  Smart Trash Enabled:')}
+${chalk.gray('  • rm commands now move files to ~/.claude-mem/trash')}
+${chalk.gray('  • View trash:')} ${chalk.cyan('claude-mem trash view')}
+${chalk.gray('  • Restore files:')} ${chalk.cyan('claude-mem restore')}
+${chalk.gray('  • Empty trash:')} ${chalk.cyan('claude-mem trash empty')}
+${chalk.yellow('  • Restart terminal for alias to activate')}` : '';
+    const finalClearHookNote = config.saveMemoriesOnClear ?
+        `\n\n${chalk.magenta('💾 Save-on-clear enabled:')}
+${chalk.gray('  • /clear now saves memories automatically (takes ~1 minute)')}` : '';
+    console.log(boxen(successTitle + successMessage + finalClaudePathNote + finalSmartTrashNote + finalClearHookNote, {
+        padding: 2,
+        margin: 1,
+        borderStyle: 'double',
+        borderColor: 'green',
+        backgroundColor: '#001122'
+    }));
+    // Final flourish
+    console.log(fastRainbow('\n✨ Welcome to the future of persistent AI conversations! ✨\n'));
+}