claude-mem 3.3.7 → 3.3.9

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

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

package/dist/commands/load-context.js

@@ -0,0 +1,151 @@
+import fs from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { PathResolver } from '../shared/paths.js';
+import { createCompletionMessage, createContextualError, createUserFriendlyError, formatTimeAgo, outputSessionStartContent } from '../prompts/templates/context/ContextTemplates.js';
+function formatSize(bytes) {
+    if (bytes === 0)
+        return '0 B';
+    const k = 1024;
+    const sizes = ['B', 'KB', 'MB', 'GB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return parseFloat((bytes / Math.pow(k, i)).toFixed(1)) + ' ' + sizes[i];
+}
+function getTrashStatus() {
+    const trashDir = join(homedir(), '.claude-mem', 'trash');
+    if (!fs.existsSync(trashDir)) {
+        return { folderCount: 0, fileCount: 0, totalSize: 0, isEmpty: true };
+    }
+    const items = fs.readdirSync(trashDir);
+    if (items.length === 0) {
+        return { folderCount: 0, fileCount: 0, totalSize: 0, isEmpty: true };
+    }
+    let folderCount = 0;
+    let fileCount = 0;
+    let totalSize = 0;
+    for (const item of items) {
+        const itemPath = join(trashDir, item);
+        const stats = fs.statSync(itemPath);
+        if (stats.isDirectory()) {
+            folderCount++;
+        }
+        else {
+            fileCount++;
+        }
+        totalSize += stats.size;
+    }
+    return { folderCount, fileCount, totalSize, isEmpty: false };
+}
+export async function loadContext(options = {}) {
+    const pathResolver = new PathResolver();
+    const indexPath = pathResolver.getIndexPath();
+    try {
+        // Check if index file exists
+        if (!fs.existsSync(indexPath)) {
+            if (options.format === 'session-start') {
+                console.log(createContextualError('NO_MEMORIES', options.project || 'this project'));
+            }
+            return;
+        }
+        const content = fs.readFileSync(indexPath, 'utf-8');
+        const lines = content.trim().split('\n').filter(line => line.trim());
+        if (lines.length === 0) {
+            if (options.format === 'session-start') {
+                console.log(createContextualError('NO_MEMORIES', options.project || 'this project'));
+            }
+            return;
+        }
+        // Parse JSONL format - each line is a JSON object
+        const jsonObjects = [];
+        for (const line of lines) {
+            try {
+                // Skip lines that don't look like JSON (could be legacy format)
+                if (!line.trim().startsWith('{')) {
+                    continue;
+                }
+                const obj = JSON.parse(line);
+                jsonObjects.push(obj);
+            }
+            catch (e) {
+                // Skip malformed JSON lines
+                continue;
+            }
+        }
+        if (jsonObjects.length === 0) {
+            if (options.format === 'session-start') {
+                console.log(createContextualError('NO_MEMORIES', options.project || 'this project'));
+            }
+            return;
+        }
+        // Filter by project if specified
+        let filteredObjects = jsonObjects;
+        if (options.project) {
+            // Sanitize project name to match how it's stored (replace hyphens with underscores)
+            const sanitizedProject = options.project.replace(/-/g, '_');
+            // Filter objects by project field
+            filteredObjects = jsonObjects.filter(obj => obj.project === sanitizedProject || obj.project === options.project);
+        }
+        // Take more entries for session-start to get multiple overviews
+        const count = options.format === 'session-start' ? 30 : 10;
+        const recentObjects = filteredObjects.slice(-count);
+        if (options.format === 'session-start') {
+            // Find most recent timestamp for last session info
+            let lastSessionTime = 'recently';
+            const timestamps = recentObjects
+                .map(obj => {
+                // Get timestamp from JSON object
+                return obj.timestamp ? new Date(obj.timestamp) : null;
+            })
+                .filter(date => date !== null)
+                .sort((a, b) => b.getTime() - a.getTime());
+            if (timestamps.length > 0) {
+                lastSessionTime = formatTimeAgo(timestamps[0]);
+            }
+            // Use dual-stream output for session start formatting
+            outputSessionStartContent({
+                projectName: options.project || 'your project',
+                memoryCount: recentObjects.length,
+                lastSessionTime,
+                recentObjects
+            });
+        }
+        else if (options.format === 'json') {
+            console.log(JSON.stringify(recentObjects));
+        }
+        else {
+            // Default format - show completion message and entries
+            console.log(createCompletionMessage('Context loading', recentObjects.length, 'recent memories found'));
+            recentObjects.forEach((obj) => {
+                if (obj.type === 'memory') {
+                    console.log(`${obj.text} | ${obj.document_id} | ${obj.keywords}`);
+                }
+                else if (obj.type === 'overview') {
+                    console.log(`**Overview:** ${obj.content}`);
+                }
+                else if (obj.type === 'session') {
+                    console.log(`# Session: ${obj.session_id} [${obj.timestamp}]`);
+                }
+                else {
+                    console.log(JSON.stringify(obj));
+                }
+            });
+        }
+        // Display trash status if not empty (except for JSON format to avoid breaking JSON parsing)
+        if (options.format !== 'json') {
+            const trashStatus = getTrashStatus();
+            if (!trashStatus.isEmpty) {
+                const formattedSize = formatSize(trashStatus.totalSize);
+                console.log(`🗑️  Trash – ${trashStatus.folderCount} folders | ${trashStatus.fileCount} files | ${formattedSize} – use \`$ claude-mem restore\` for more options.`);
+            }
+        }
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        if (options.format === 'session-start') {
+            console.log(createContextualError('CONNECTION_FAILED', errorMessage));
+        }
+        else {
+            console.log(createUserFriendlyError('Context loading', errorMessage, 'Check file permissions and try again'));
+        }
+    }
+}

package/dist/commands/logs.d.ts

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

package/dist/commands/logs.js

@@ -0,0 +1,76 @@
+import { readFileSync, readdirSync, statSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+// <Block> 1.1 ====================================
+async function showLog(logPath, logType, tail) {
+    // <Block> 1.2 ====================================
+    try {
+        const content = readFileSync(logPath, 'utf8');
+        const lines = content.split('\n').filter(line => line.trim());
+        const displayLines = lines.slice(-tail);
+        console.log(`📋 ${logType} Logs (last ${tail} lines):`);
+        console.log(`   File: ${logPath}`);
+        console.log('');
+        // <Block> 1.3 ====================================
+        if (displayLines.length === 0) {
+            console.log('   No log entries found');
+            // </Block> =======================================
+        }
+        else {
+            displayLines.forEach(line => {
+                console.log(`   ${line}`);
+            });
+        }
+        // </Block> =======================================
+        console.log('');
+        // </Block> =======================================
+    }
+    catch (error) {
+        // <Block> 1.4 ====================================
+        console.log(`❌ Could not read ${logType.toLowerCase()} log: ${logPath}`);
+        // </Block> =======================================
+    }
+    // </Block> =======================================
+}
+// <Block> 2.1 ====================================
+export async function logs(options = {}) {
+    // <Block> 2.2 ====================================
+    const logsDir = join(homedir(), '.claude-mem', 'logs');
+    const tail = parseInt(options.tail) || 20;
+    // </Block> =======================================
+    // Find most recent log file
+    try {
+        const files = readdirSync(logsDir);
+        const logFiles = files
+            .filter(f => f.startsWith('claude-mem-') && f.endsWith('.log'))
+            .map(f => ({
+            name: f,
+            path: join(logsDir, f),
+            mtime: statSync(join(logsDir, f)).mtime
+        }))
+            .sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
+        if (logFiles.length === 0) {
+            console.log('❌ No log files found in ~/.claude-mem/logs/');
+            return;
+        }
+        // Show most recent log
+        await showLog(logFiles[0].path, 'Most Recent', tail);
+        if (options.all && logFiles.length > 1) {
+            console.log(`📚 Found ${logFiles.length} total log files`);
+        }
+    }
+    catch (error) {
+        console.log('❌ Could not read logs directory: ~/.claude-mem/logs/');
+        console.log('   Run a compression first to generate logs');
+    }
+    // <Block> 2.5 ====================================
+    if (options.follow) {
+        console.log('Following logs... (Press Ctrl+C to stop)');
+        // Basic follow implementation - would need more sophisticated watching in real usage
+        setInterval(() => {
+            // This would need proper file watching implementation
+        }, 1000);
+    }
+    // </Block> =======================================
+    // </Block> =======================================
+}

package/dist/commands/migrate-to-jsonl.d.ts

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+/**
+ * One-time migration script to convert claude-mem-index.md to claude-mem-index.jsonl
+ */
+export declare function migrateToJSONL(): void;

package/dist/commands/migrate-to-jsonl.js

@@ -0,0 +1,99 @@
+#!/usr/bin/env node
+/**
+ * One-time migration script to convert claude-mem-index.md to claude-mem-index.jsonl
+ */
+import fs from 'fs';
+import path from 'path';
+import { PathResolver } from '../shared/paths.js';
+export function migrateToJSONL() {
+    const pathResolver = new PathResolver();
+    const oldIndexPath = path.join(pathResolver.getConfigDir(), 'claude-mem-index.md');
+    const newIndexPath = path.join(pathResolver.getConfigDir(), 'claude-mem-index.jsonl');
+    // Check if old index exists
+    if (!fs.existsSync(oldIndexPath)) {
+        console.log('No markdown index found to migrate');
+        return;
+    }
+    // Check if new index already exists
+    if (fs.existsSync(newIndexPath)) {
+        console.log('JSONL index already exists, skipping migration');
+        return;
+    }
+    console.log('Starting migration from MD to JSONL...');
+    const content = fs.readFileSync(oldIndexPath, 'utf-8');
+    const lines = content.split('\n').filter(line => line.trim());
+    const jsonlLines = [];
+    let currentSessionId = '';
+    let currentSessionTimestamp = '';
+    for (const line of lines) {
+        // Parse session headers: # Session: <id> [<timestamp>]
+        const sessionMatch = line.match(/^# Session:\s*([^\[]+)(?:\s*\[([^\]]+)\])?/);
+        if (sessionMatch) {
+            currentSessionId = sessionMatch[1].trim();
+            currentSessionTimestamp = sessionMatch[2]?.trim() || new Date().toISOString();
+            // Extract project from session ID (assuming format like <project>_<uuid>)
+            const projectMatch = currentSessionId.match(/^([^_]+)_/);
+            const project = projectMatch ? projectMatch[1] : 'unknown';
+            jsonlLines.push(JSON.stringify({
+                type: 'session',
+                session_id: currentSessionId,
+                timestamp: currentSessionTimestamp,
+                project
+            }));
+            continue;
+        }
+        // Parse overviews: **Overview:** <text>
+        const overviewMatch = line.match(/^\*\*Overview:\*\*\s*(.+)/);
+        if (overviewMatch) {
+            const overviewText = overviewMatch[1].trim();
+            // Extract project from current session ID
+            const projectMatch = currentSessionId.match(/^([^_]+)_/);
+            const project = projectMatch ? projectMatch[1] : 'unknown';
+            jsonlLines.push(JSON.stringify({
+                type: 'overview',
+                content: overviewText,
+                session_id: currentSessionId,
+                project,
+                timestamp: currentSessionTimestamp
+            }));
+            continue;
+        }
+        // Skip certain lines
+        if (line.startsWith('# NO SUMMARIES EXTRACTED')) {
+            continue;
+        }
+        // Parse memory entries (pipe-separated)
+        if (line.includes(' | ')) {
+            const parts = line.split(' | ').map(p => p.trim());
+            if (parts.length >= 3) {
+                const [text, document_id, keywords, timestamp, archive] = parts;
+                // Extract project from document_id (format: <project>_<session>_<number>)
+                const projectMatch = document_id?.match(/^([^_]+)_/);
+                const project = projectMatch ? projectMatch[1] : 'unknown';
+                jsonlLines.push(JSON.stringify({
+                    type: 'memory',
+                    text,
+                    document_id: document_id || `${currentSessionId}_${Date.now()}`,
+                    keywords: keywords || '',
+                    session_id: currentSessionId,
+                    project,
+                    timestamp: timestamp || currentSessionTimestamp,
+                    archive: archive || `${currentSessionId}.jsonl.archive`
+                }));
+            }
+        }
+    }
+    // Write JSONL file
+    fs.writeFileSync(newIndexPath, jsonlLines.join('\n') + '\n');
+    // Backup old index
+    const backupPath = oldIndexPath + '.backup';
+    fs.renameSync(oldIndexPath, backupPath);
+    console.log(`✅ Migration complete!`);
+    console.log(`   - Converted ${jsonlLines.length} entries`);
+    console.log(`   - New index: ${newIndexPath}`);
+    console.log(`   - Backup: ${backupPath}`);
+}
+// Run if called directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+    migrateToJSONL();
+}

package/dist/commands/restore.d.ts

@@ -0,0 +1 @@
+export declare function restore(): Promise<void>;

package/dist/commands/restore.js

@@ -0,0 +1,20 @@
+import { readdirSync, renameSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import * as p from '@clack/prompts';
+export async function restore() {
+    const trashDir = join(homedir(), '.claude-mem', 'trash');
+    const files = readdirSync(trashDir);
+    if (files.length === 0) {
+        console.log('Trash is empty');
+        return;
+    }
+    const file = await p.select({
+        message: 'Select file to restore:',
+        options: files.map(f => ({ value: f, label: f }))
+    });
+    if (p.isCancel(file))
+        return;
+    renameSync(join(trashDir, file), join(process.cwd(), file));
+    console.log(`Restored ${file}`);
+}

package/dist/commands/status.d.ts

@@ -0,0 +1 @@
+export declare function status(): Promise<void>;

package/dist/commands/status.js

@@ -0,0 +1,136 @@
+import { readFileSync, existsSync, readdirSync, statSync } from 'fs';
+import { join, dirname } from 'path';
+import { homedir } from 'os';
+import { execSync } from 'child_process';
+import { fileURLToPath } from 'url';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+export async function status() {
+    console.log('🔍 Claude Memory System Status Check');
+    console.log('=====================================\n');
+    console.log('📂 Installed Hook Scripts:');
+    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');
+    const checkScript = (path, name) => {
+        if (existsSync(path)) {
+            console.log(`  ✅ ${name}: Found at ${path}`);
+        }
+        else {
+            console.log(`  ❌ ${name}: Not found at ${path}`);
+        }
+    };
+    checkScript(preCompactScript, 'pre-compact.js');
+    checkScript(sessionStartScript, 'session-start.js');
+    checkScript(sessionEndScript, 'session-end.js');
+    console.log('');
+    console.log('⚙️  Settings Configuration:');
+    const checkSettings = (name, path) => {
+        if (!existsSync(path)) {
+            console.log(`  ⏭️  ${name}: No settings file`);
+            return;
+        }
+        console.log(`  📋 ${name}: ${path}`);
+        try {
+            const settings = JSON.parse(readFileSync(path, 'utf8'));
+            const hasPreCompact = settings.hooks?.PreCompact?.some((matcher) => matcher.hooks?.some((hook) => hook.command?.includes('pre-compact.js') || hook.command?.includes('claude-mem')));
+            const hasSessionStart = settings.hooks?.SessionStart?.some((matcher) => matcher.hooks?.some((hook) => hook.command?.includes('session-start.js') || hook.command?.includes('claude-mem')));
+            const hasSessionEnd = settings.hooks?.SessionEnd?.some((matcher) => matcher.hooks?.some((hook) => hook.command?.includes('session-end.js') || hook.command?.includes('claude-mem')));
+            console.log(`     PreCompact: ${hasPreCompact ? '✅' : '❌'}`);
+            console.log(`     SessionStart: ${hasSessionStart ? '✅' : '❌'}`);
+            console.log(`     SessionEnd: ${hasSessionEnd ? '✅' : '❌'}`);
+        }
+        catch (error) {
+            console.log(`     ⚠️  Could not parse settings`);
+        }
+    };
+    checkSettings('Global', join(homedir(), '.claude', 'settings.json'));
+    checkSettings('Project', join(process.cwd(), '.claude', 'settings.json'));
+    console.log('');
+    console.log('📦 Compressed Transcripts:');
+    const claudeProjectsDir = join(homedir(), '.claude', 'projects');
+    if (existsSync(claudeProjectsDir)) {
+        try {
+            let compressedCount = 0;
+            let archiveCount = 0;
+            const searchDir = (dir, depth = 0) => {
+                if (depth > 3)
+                    return;
+                const files = readdirSync(dir);
+                for (const file of files) {
+                    const fullPath = join(dir, file);
+                    const stats = statSync(fullPath);
+                    if (stats.isDirectory() && !file.startsWith('.')) {
+                        searchDir(fullPath, depth + 1);
+                    }
+                    else if (file.endsWith('.jsonl.compressed')) {
+                        compressedCount++;
+                    }
+                    else if (file.endsWith('.jsonl.archive')) {
+                        archiveCount++;
+                    }
+                }
+            };
+            searchDir(claudeProjectsDir);
+            console.log(`  Compressed files: ${compressedCount}`);
+            console.log(`  Archive files: ${archiveCount}`);
+        }
+        catch (error) {
+            console.log(`  ⚠️  Could not scan projects directory`);
+        }
+    }
+    else {
+        console.log(`  ℹ️  No Claude projects directory found`);
+    }
+    console.log('');
+    console.log('🔧 Runtime Environment:');
+    const checkCommand = (cmd, name) => {
+        try {
+            const version = execSync(`${cmd} --version`, { encoding: 'utf8' }).trim();
+            console.log(`  ✅ ${name}: ${version}`);
+        }
+        catch {
+            console.log(`  ❌ ${name}: Not found`);
+        }
+    };
+    checkCommand('node', 'Node.js');
+    checkCommand('bun', 'Bun');
+    console.log('');
+    console.log('🧠 Chroma Storage Status:');
+    console.log('  ✅ Storage backend: Chroma MCP');
+    console.log('  📍 Data location: ~/.claude-mem/chroma');
+    console.log('  🔍 Features: Vector search, semantic similarity, document storage');
+    console.log('');
+    console.log('📊 Summary:');
+    const globalPath = join(homedir(), '.claude', 'settings.json');
+    const projectPath = join(process.cwd(), '.claude', 'settings.json');
+    let isInstalled = false;
+    let installLocation = 'Not installed';
+    try {
+        if (existsSync(globalPath)) {
+            const settings = JSON.parse(readFileSync(globalPath, 'utf8'));
+            if (settings.hooks?.PreCompact || settings.hooks?.SessionStart || settings.hooks?.SessionEnd) {
+                isInstalled = true;
+                installLocation = 'Global';
+            }
+        }
+        if (existsSync(projectPath)) {
+            const settings = JSON.parse(readFileSync(projectPath, 'utf8'));
+            if (settings.hooks?.PreCompact || settings.hooks?.SessionStart || settings.hooks?.SessionEnd) {
+                isInstalled = true;
+                installLocation = installLocation === 'Global' ? 'Global + Project' : 'Project';
+            }
+        }
+    }
+    catch { }
+    if (isInstalled) {
+        console.log(`  ✅ Claude Memory System is installed (${installLocation})`);
+        console.log('');
+        console.log('💡 To test: Use /compact in Claude Code');
+    }
+    else {
+        console.log(`  ❌ Claude Memory System is not installed`);
+        console.log('');
+        console.log('💡 To install: claude-mem install');
+    }
+}

package/dist/commands/trash-empty.d.ts

@@ -0,0 +1,3 @@
+export declare function emptyTrash(options?: {
+    force?: boolean;
+}): Promise<void>;

package/dist/commands/trash-empty.js

@@ -0,0 +1,56 @@
+import { rmSync, readdirSync, existsSync, statSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import * as p from '@clack/prompts';
+export async function emptyTrash(options = {}) {
+    const trashDir = join(homedir(), '.claude-mem', 'trash');
+    // Check if trash directory exists
+    if (!existsSync(trashDir)) {
+        p.log.info('🗑️  Trash is already empty');
+        return;
+    }
+    try {
+        const files = readdirSync(trashDir);
+        if (files.length === 0) {
+            p.log.info('🗑️  Trash is already empty');
+            return;
+        }
+        // Count items
+        let folderCount = 0;
+        let fileCount = 0;
+        for (const file of files) {
+            const filePath = join(trashDir, file);
+            const stats = statSync(filePath);
+            if (stats.isDirectory()) {
+                folderCount++;
+            }
+            else {
+                fileCount++;
+            }
+        }
+        // Confirm deletion unless --force flag is used
+        if (!options.force) {
+            const confirm = await p.confirm({
+                message: `Permanently delete ${folderCount} folders and ${fileCount} files from trash?`,
+                initialValue: false
+            });
+            if (p.isCancel(confirm) || !confirm) {
+                p.log.info('Cancelled - trash not emptied');
+                return;
+            }
+        }
+        // Delete all files in trash
+        const s = p.spinner();
+        s.start('Emptying trash...');
+        for (const file of files) {
+            const filePath = join(trashDir, file);
+            rmSync(filePath, { recursive: true, force: true });
+        }
+        s.stop(`🗑️  Trash emptied - permanently deleted ${folderCount} folders and ${fileCount} files`);
+    }
+    catch (error) {
+        p.log.error('Failed to empty trash');
+        console.error(error);
+        process.exit(1);
+    }
+}

package/dist/commands/trash-view.d.ts

@@ -0,0 +1 @@
+export declare function viewTrash(): Promise<void>;

package/dist/commands/trash-view.js

@@ -0,0 +1,101 @@
+import { readdirSync, statSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import * as p from '@clack/prompts';
+function parseTrashName(filename) {
+    const lastDotIndex = filename.lastIndexOf('.');
+    if (lastDotIndex === -1)
+        return { name: filename, timestamp: 0 };
+    const timestamp = parseInt(filename.substring(lastDotIndex + 1));
+    if (isNaN(timestamp))
+        return { name: filename, timestamp: 0 };
+    return {
+        name: filename.substring(0, lastDotIndex),
+        timestamp
+    };
+}
+function formatSize(bytes) {
+    if (bytes === 0)
+        return '0 B';
+    const k = 1024;
+    const sizes = ['B', 'KB', 'MB', 'GB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
+}
+function getDirectorySize(dirPath) {
+    let size = 0;
+    const files = readdirSync(dirPath);
+    for (const file of files) {
+        const filePath = join(dirPath, file);
+        const stats = statSync(filePath);
+        if (stats.isDirectory()) {
+            size += getDirectorySize(filePath);
+        }
+        else {
+            size += stats.size;
+        }
+    }
+    return size;
+}
+export async function viewTrash() {
+    const trashDir = join(homedir(), '.claude-mem', 'trash');
+    try {
+        const files = readdirSync(trashDir);
+        if (files.length === 0) {
+            p.log.info('🗑️  Trash is empty');
+            return;
+        }
+        const items = files.map(file => {
+            const filePath = join(trashDir, file);
+            const stats = statSync(filePath);
+            const { name, timestamp } = parseTrashName(file);
+            const size = stats.isDirectory() ? getDirectorySize(filePath) : stats.size;
+            return {
+                originalName: name,
+                trashedName: file,
+                size,
+                trashedAt: new Date(timestamp),
+                isDirectory: stats.isDirectory()
+            };
+        });
+        // Sort by date, newest first
+        items.sort((a, b) => b.trashedAt.getTime() - a.trashedAt.getTime());
+        // Display header
+        console.log('\n🗑️  Trash Contents\n');
+        console.log('─'.repeat(80));
+        // Display items
+        let totalSize = 0;
+        let folderCount = 0;
+        let fileCount = 0;
+        for (const item of items) {
+            totalSize += item.size;
+            if (item.isDirectory) {
+                folderCount++;
+            }
+            else {
+                fileCount++;
+            }
+            const type = item.isDirectory ? '📁' : '📄';
+            const date = item.trashedAt.toLocaleString();
+            const size = formatSize(item.size);
+            console.log(`${type} ${item.originalName}`);
+            console.log(`   Size: ${size} | Trashed: ${date}`);
+            console.log(`   ID: ${item.trashedName}`);
+            console.log();
+        }
+        // Display summary
+        console.log('─'.repeat(80));
+        console.log(`Total: ${folderCount} folders, ${fileCount} files (${formatSize(totalSize)})`);
+        console.log('\nTo restore files: claude-mem restore');
+        console.log('To empty trash:   claude-mem trash empty');
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            p.log.info('🗑️  Trash is empty');
+        }
+        else {
+            p.log.error('Failed to read trash directory');
+            console.error(error);
+        }
+    }
+}