claude-mem 3.2.0 → 3.2.1

package/dist/commands/install.js

@@ -1,649 +0,0 @@
-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 * as p from '@clack/prompts';
-import { PACKAGE_NAME } from '../shared/config.js';
-// <Block> Prerequisites validation
-async function validatePrerequisites() {
-    const s = p.spinner();
-    s.start('Checking prerequisites');
-    const issues = [];
-    // Check Node.js version
-    const nodeVersion = process.versions.node;
-    const [major] = nodeVersion.split('.').map(Number);
-    if (major < 18) {
-        issues.push(`Node.js version ${nodeVersion} is below minimum required (18.0.0)`);
-    }
-    // Check if Claude Code is installed
-    try {
-        execSync('which claude', { stdio: 'ignore' });
-    }
-    catch {
-        issues.push('Claude Code CLI is not installed or not in PATH');
-    }
-    // Check write permissions to home directory
-    const testDir = join(homedir(), '.claude-mem-test');
-    try {
-        mkdirSync(testDir, { recursive: true });
-        writeFileSync(join(testDir, 'test'), 'test');
-        execSync(`rm -rf ${testDir}`, { stdio: 'ignore' });
-    }
-    catch {
-        issues.push('No write permissions to home directory');
-    }
-    if (issues.length > 0) {
-        s.stop('Prerequisites check failed');
-        return false;
-    }
-    s.stop('Prerequisites check passed');
-    return true;
-}
-// </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 action = await p.select({
-            message: 'Existing installation detected. What would you like to do?',
-            options: [
-                { value: 'update', label: 'Update existing installation' },
-                { value: 'reinstall', label: 'Clean reinstall (removes existing configuration)' },
-                { value: 'cancel', label: 'Cancel installation' }
-            ]
-        });
-        if (p.isCancel(action) || action === 'cancel') {
-            p.cancel('Installation cancelled');
-            return null;
-        }
-        config.forceReinstall = action === 'reinstall';
-    }
-    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;
-    // Ask about Chroma MCP installation
-    if (!existingInstall.hasChromaMcp) {
-        const installChroma = await p.confirm({
-            message: 'Install Chroma MCP server for vector storage?',
-            initialValue: true
-        });
-        if (p.isCancel(installChroma)) {
-            p.cancel('Installation cancelled');
-            return null;
-        }
-        config.skipMcpInstall = !installChroma;
-    }
-    else {
-        config.skipMcpInstall = true; // Already installed
-    }
-    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');
-    // For binary distribution, write minimal wrapper hooks that call the binary
-    const hookWrapper = (command) => `#!/usr/bin/env node
-// Hook wrapper for claude-mem binary distribution
-const { execSync } = require('child_process');
-const path = require('path');
-
-// Try to find the claude-mem binary
-const possiblePaths = [
-  'claude-mem',  // In PATH
-  path.join(__dirname, '..', '..', 'claude-mem'),  // Relative to hooks dir
-  process.env.CLAUDE_MEM_BINARY  // Environment variable override
-].filter(Boolean);
-
-let binaryPath;
-for (const testPath of possiblePaths) {
-  try {
-    execSync(\`which \${testPath}\`, { stdio: 'ignore' });
-    binaryPath = testPath;
-    break;
-  } catch {
-    // Try next path
-  }
-}
-
-if (!binaryPath) {
-  console.error('Could not find claude-mem binary');
-  process.exit(1);
-}
-
-try {
-  execSync(\`\${binaryPath} ${command}\`, { stdio: 'inherit' });
-  process.exit(0);
-} catch (error) {
-  process.exit(error.status || 1);
-}
-`;
-    // Write hook wrappers
-    const hooks = [
-        { name: 'pre-compact.js', command: 'hook:pre-compact' },
-        { name: 'session-start.js', command: 'hook:session-start' },
-        { name: 'session-end.js', command: 'hook:session-end' }
-    ];
-    for (const hook of hooks) {
-        const hookPath = join(hooksDir, hook.name);
-        writeFileSync(hookPath, hookWrapper(hook.command));
-        chmodSync(hookPath, 0o755);
-    }
-    // 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 chromaMcpCommand = `claude mcp add claude-mem -- uvx chroma-mcp --client-type persistent --data-dir ${homedir()}/.claude-mem/chroma`;
-    const s = p.spinner();
-    s.start('Installing Chroma MCP server');
-    try {
-        execSync(chromaMcpCommand, { stdio: 'pipe' });
-        s.stop('Chroma MCP server installed successfully');
-        return true;
-    }
-    catch (error) {
-        s.stop('Chroma MCP server installation failed');
-        p.log.warn('You may need to install it manually:');
-        p.log.info(chromaMcpCommand);
-        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 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');
-    }
-    // Check Chroma MCP configuration
-    const userMcpPath = join(homedir(), '.claude.json');
-    const projectMcpPath = join(process.cwd(), '.mcp.json');
-    let chromaMcpConfigured = false;
-    if (existsSync(userMcpPath)) {
-        try {
-            const config = JSON.parse(readFileSync(userMcpPath, 'utf8'));
-            if (config.mcpServers?.['claude-mem']) {
-                chromaMcpConfigured = true;
-            }
-        }
-        catch { }
-    }
-    if (!chromaMcpConfigured && existsSync(projectMcpPath)) {
-        try {
-            const config = JSON.parse(readFileSync(projectMcpPath, 'utf8'));
-            if (config.mcpServers?.['claude-mem']) {
-                chromaMcpConfigured = true;
-            }
-        }
-        catch { }
-    }
-    if (!chromaMcpConfigured) {
-        issues.push('Chroma MCP server not configured');
-    }
-    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 = {}) {
-    p.intro(`🧠 Claude Memory Installation`);
-    // 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,
-            skipMcpInstall: !!options.skipMcp
-        };
-    }
-    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}`);
-        }
-    }
-    // Installation steps
-    await p.group({
-        directories: async () => {
-            const s = p.spinner();
-            s.start('Creating directory structure');
-            ensureDirectoryStructure();
-            s.stop('Directory structure created');
-        },
-        chromaMcp: async () => {
-            if (!config.skipMcpInstall) {
-                await installChromaMcp();
-            }
-        },
-        instructions: async () => {
-            const s = p.spinner();
-            s.start('Adding CLAUDE.md instructions');
-            ensureClaudeMdInstructions();
-            s.stop('CLAUDE.md instructions added');
-        },
-        hooks: async () => {
-            const s = p.spinner();
-            s.start('Installing hooks');
-            writeHookFiles(config.hookTimeout);
-            s.stop('Hooks installed');
-        },
-        settings: async () => {
-            const s = p.spinner();
-            s.start('Configuring Claude settings');
-            // 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;
-            writeFileSync(userSettingsPath, JSON.stringify(userSettings, null, 2));
-            s.stop('Settings configured');
-        }
-    }, {
-        onCancel: () => {
-            p.cancel('Installation cancelled');
-            process.exit(0);
-        }
-    });
-    // Verify installation
-    await verifyInstallation();
-    p.outro(`✅ Claude Memory installed successfully!
-
-How it works:
-  • When you start Claude Code, claude-mem will load the latest memories as a startup message
-  • To save your work, do /compact or /clear, wait for it to process (takes about 30s)
-  • You'll see an updated context message with your latest memories
-  • We added instructions to your ~/.claude/CLAUDE.md that teaches Claude Code how to use its new memory system
-
-To search memories, just ask Claude to search claude-mem. That's it.
-
-Restart Claude Code to begin using your new memory system.`);
-}

package/dist/commands/load-context.d.ts

@@ -1,2 +0,0 @@
-import { OptionValues } from 'commander';
-export declare function loadContext(options?: OptionValues): Promise<void>;