claude-mem 3.0.2 → 3.0.4

package/dist/commands/status.js

@@ -0,0 +1,159 @@
+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 checkScript = (path, name) => {
+        if (existsSync(path)) {
+            const stats = statSync(path);
+            const isExecutable = (stats.mode & 0o111) !== 0;
+            console.log(`  ✅ ${name}: Found`);
+            console.log(`     Path: ${path}`);
+            console.log(`     Executable: ${isExecutable ? 'Yes' : 'No (run: chmod +x ' + path + ')'}`);
+        }
+        else {
+            console.log(`  ❌ ${name}: Not found at ${path}`);
+        }
+    };
+    checkScript(preCompactScript, 'pre-compact.js');
+    checkScript(sessionStartScript, 'session-start.js');
+    console.log('');
+    console.log('⚙️  Settings Configuration:');
+    const checkSettings = (name, path) => {
+        if (!existsSync(path)) {
+            console.log(`  ⏭️  ${name}: No settings file`);
+            return;
+        }
+        try {
+            const content = readFileSync(path, 'utf8');
+            const settings = JSON.parse(content);
+            console.log(`  📋 ${name}: ${path}`);
+            let hasOurPreCompact = false;
+            let hasOurSessionStart = false;
+            if (settings.hooks?.PreCompact) {
+                hasOurPreCompact = settings.hooks.PreCompact.some((matcher) => matcher.hooks?.some((hook) => hook.command?.includes('pre-compact.js') ||
+                    hook.command?.includes('claude-mem')));
+            }
+            if (settings.hooks?.SessionStart) {
+                hasOurSessionStart = settings.hooks.SessionStart.some((matcher) => matcher.hooks?.some((hook) => hook.command?.includes('session-start.js') ||
+                    hook.command?.includes('claude-mem')));
+            }
+            console.log(`     PreCompact hook: ${hasOurPreCompact ? '✅ Configured' : '❌ Not configured'}`);
+            console.log(`     SessionStart hook: ${hasOurSessionStart ? '✅ Configured' : '❌ Not configured'}`);
+            const hookTypes = Object.keys(settings.hooks || {});
+            if (hookTypes.length > 0) {
+                console.log(`     Total hook types: ${hookTypes.length} (${hookTypes.join(', ')})`);
+            }
+        }
+        catch (error) {
+            console.log(`  ⚠️  ${name}: Error reading settings - ${error.message}`);
+        }
+    };
+    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('🧠 Embedded Weaviate Status:');
+    try {
+        // Import and test WeaviateMCPAdapter
+        const { WeaviateMCPAdapter } = await import('../utils/weaviate-mcp-adapter.js');
+        const client = new WeaviateMCPAdapter();
+        console.log('  ✅ Embedded Weaviate client: Ready');
+        console.log('  📍 Storage: In-memory embedded instance');
+        console.log('  🔍 Features: Vector search, semantic similarity');
+        // Test connectivity (don't actually connect to avoid starting instance)
+        console.log('  ℹ️  Instance starts automatically when needed');
+    }
+    catch (error) {
+        console.log(`  ❌ Embedded Weaviate client: Error - ${error.message}`);
+    }
+    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) {
+                isInstalled = true;
+                installLocation = 'Global';
+            }
+        }
+        if (existsSync(projectPath)) {
+            const settings = JSON.parse(readFileSync(projectPath, 'utf8'));
+            if (settings.hooks?.PreCompact || settings.hooks?.SessionStart) {
+                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/uninstall.d.ts

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

package/dist/commands/uninstall.js

@@ -0,0 +1,105 @@
+import { readFileSync, writeFileSync, existsSync } from 'fs';
+import { join, resolve, dirname } from 'path';
+import { homedir } from 'os';
+import { fileURLToPath } from 'url';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+export async function uninstall(options = {}) {
+    console.log('🔄 Uninstalling Claude Memory System hooks...');
+    const locations = [];
+    if (options.all) {
+        locations.push({
+            name: 'Global',
+            path: join(homedir(), '.claude', 'settings.json')
+        });
+        locations.push({
+            name: 'Project',
+            path: join(process.cwd(), '.claude', 'settings.json')
+        });
+    }
+    else {
+        const isProject = options.project;
+        locations.push({
+            name: isProject ? 'Project' : 'Global',
+            path: join(isProject ? process.cwd() : homedir(), '.claude', 'settings.json')
+        });
+    }
+    const projectRoot = resolve(join(__dirname, '..', '..'));
+    const preCompactScript = join(projectRoot, 'hooks', 'pre-compact.js');
+    const sessionStartScript = join(projectRoot, 'hooks', 'session-start.js');
+    let removedCount = 0;
+    for (const location of locations) {
+        if (!existsSync(location.path)) {
+            console.log(`⏭️  No settings found at ${location.name} location`);
+            continue;
+        }
+        try {
+            const content = readFileSync(location.path, 'utf8');
+            const settings = JSON.parse(content);
+            if (!settings.hooks) {
+                console.log(`⏭️  No hooks configured in ${location.name} settings`);
+                continue;
+            }
+            let modified = false;
+            if (settings.hooks.PreCompact) {
+                const filteredPreCompact = settings.hooks.PreCompact.filter((matcher) => {
+                    const hasOurHook = matcher.hooks?.some((hook) => hook.command === preCompactScript ||
+                        hook.command?.includes('pre-compact.js') ||
+                        hook.command?.includes('claude-mem'));
+                    return !hasOurHook;
+                });
+                if (filteredPreCompact.length !== settings.hooks.PreCompact.length) {
+                    settings.hooks.PreCompact = filteredPreCompact.length > 0 ? filteredPreCompact : undefined;
+                    modified = true;
+                    console.log(`✅ Removed PreCompact hook from ${location.name} settings`);
+                }
+            }
+            if (settings.hooks.SessionStart) {
+                const filteredSessionStart = settings.hooks.SessionStart.filter((matcher) => {
+                    const hasOurHook = matcher.hooks?.some((hook) => hook.command === sessionStartScript ||
+                        hook.command?.includes('session-start.js') ||
+                        hook.command?.includes('claude-mem'));
+                    return !hasOurHook;
+                });
+                if (filteredSessionStart.length !== settings.hooks.SessionStart.length) {
+                    settings.hooks.SessionStart = filteredSessionStart.length > 0 ? filteredSessionStart : undefined;
+                    modified = true;
+                    console.log(`✅ Removed SessionStart hook from ${location.name} settings`);
+                }
+            }
+            if (settings.hooks.PreCompact === undefined) {
+                delete settings.hooks.PreCompact;
+            }
+            if (settings.hooks.SessionStart === undefined) {
+                delete settings.hooks.SessionStart;
+            }
+            if (Object.keys(settings.hooks).length === 0) {
+                delete settings.hooks;
+            }
+            if (modified) {
+                const backupPath = location.path + '.backup.' + Date.now();
+                writeFileSync(backupPath, content);
+                console.log(`📋 Created backup: ${backupPath}`);
+                writeFileSync(location.path, JSON.stringify(settings, null, 2));
+                removedCount++;
+                console.log(`✅ Updated ${location.name} settings: ${location.path}`);
+            }
+            else {
+                console.log(`ℹ️  No Claude Memory System hooks found in ${location.name} settings`);
+            }
+        }
+        catch (error) {
+            console.warn(`Could not process ${location.name} settings: ${error.message}`);
+        }
+    }
+    console.log('');
+    if (removedCount > 0) {
+        console.log('✨ Uninstallation complete!');
+        console.log('The Claude Memory System hooks have been removed from your settings.');
+        console.log('');
+        console.log('Note: Your compressed transcripts and archives are preserved.');
+        console.log('To reinstall: claude-mem install');
+    }
+    else {
+        console.log('ℹ️  No Claude Memory System hooks were found to remove.');
+    }
+}

package/dist/config.d.ts

@@ -0,0 +1,6 @@
+export declare const PACKAGE_NAME: string;
+export declare const PACKAGE_VERSION: string;
+export declare const PACKAGE_DESCRIPTION: string;
+export declare const CLI_NAME: string;
+export declare const MCP_SERVER_NAME = "claude-mem-server";
+export declare const MCP_SERVER_SCRIPT = "mcp-server-cli.js";

package/dist/config.js

@@ -0,0 +1,33 @@
+import { readFileSync, existsSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+// Default values for compiled binaries
+const DEFAULT_PACKAGE_NAME = 'claude-mem';
+const DEFAULT_PACKAGE_VERSION = '2.0.6';
+const DEFAULT_PACKAGE_DESCRIPTION = 'Memory compression system for Claude Code - persist context across sessions';
+let packageName = DEFAULT_PACKAGE_NAME;
+let packageVersion = DEFAULT_PACKAGE_VERSION;
+let packageDescription = DEFAULT_PACKAGE_DESCRIPTION;
+// Try to read package.json if it exists (for development)
+try {
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = dirname(__filename);
+    const packageJsonPath = join(__dirname, '..', 'package.json');
+    if (existsSync(packageJsonPath)) {
+        const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+        packageName = packageJson.name || DEFAULT_PACKAGE_NAME;
+        packageVersion = packageJson.version || DEFAULT_PACKAGE_VERSION;
+        packageDescription = packageJson.description || DEFAULT_PACKAGE_DESCRIPTION;
+    }
+}
+catch {
+    // Use defaults if package.json can't be read (compiled binary)
+}
+// Export package configuration
+export const PACKAGE_NAME = packageName;
+export const PACKAGE_VERSION = packageVersion;
+export const PACKAGE_DESCRIPTION = packageDescription;
+// Export commonly used names
+export const CLI_NAME = PACKAGE_NAME; // The CLI command name
+export const MCP_SERVER_NAME = 'claude-mem-server';
+export const MCP_SERVER_SCRIPT = 'mcp-server-cli.js';