Persist backup metadata and improve MCP config detection + path normalization. Now all paths shown in memory stats for easier access.

chrisribe · chrisribe · commit 4301e748aeb8 · 2025-10-17T00:23:36.000-04:00
diff --git a/scripts/setup-vscode.js b/scripts/setup-vscode.js
@@ -19,14 +19,14 @@ const MCP_CONFIG_WITH_COMMENTS = `{
   "servers": {
     "simple-memory-mcp": {
       "command": "simple-memory"
-      // 💡 Customize with environment variables:
+      // 💡 Uncomment and customize environment variables as needed:
       // "env": {
-      //   "MEMORY_DB": "/path/to/your/memory.db",
-      //   "MEMORY_BACKUP_PATH": "/path/to/backups",
-      //   "MEMORY_BACKUP_INTERVAL": "1440",
-      //   "DEBUG": "false"
+      //   "MEMORY_DB": "./memory.db",              // Custom database location
+      //   "MEMORY_BACKUP_PATH": "./backups",       // Enable automatic backups
+      //   "MEMORY_BACKUP_INTERVAL": "1440",        // Backup interval in minutes
+      //   "MEMORY_BACKUP_RETENTION": "30",         // Keep backups for N days
+      //   "DEBUG": "false"                         // Enable debug logging
       // }
-      // See README for more options: https://github.com/chrisribe/simple-memory-mcp#configuration
     }
   }
 }`;
@@ -39,8 +39,8 @@ function getVSCodeConfigPaths() {
   if (platform === 'win32') {
     const appData = process.env.APPDATA || join(home, 'AppData', 'Roaming');
     paths.push(
-      { name: 'VS Code', path: join(appData, 'Code', 'User') },
-      { name: 'VS Code Insiders', path: join(appData, 'Code - Insiders', 'User') }
+      { name: 'VS Code', path: join(appData, 'Code', 'User').replace(/\\/g, '/') },
+      { name: 'VS Code Insiders', path: join(appData, 'Code - Insiders', 'User').replace(/\\/g, '/') }
     );
   } else if (platform === 'darwin') {
     const appSupport = join(home, 'Library', 'Application Support');
@@ -99,8 +99,7 @@ function configureVSCode(name, vscodeUserPath) {
   // Check if already configured
   if (mcpConfig[serversProp]['simple-memory-mcp']) {
     console.log(`✅ Already configured in ${name}`);
-    console.log(`   💡 To customize: ${mcpJsonPath}`);
-    return { success: true, reason: 'already-configured', path: mcpJsonPath };
+    return { success: true, reason: 'already-configured', path: mcpJsonPath.replace(/\\/g, '/') };
   }
   
   // Add simple-memory-mcp config
@@ -110,8 +109,7 @@ function configureVSCode(name, vscodeUserPath) {
     mkdirSync(vscodeUserPath, { recursive: true });
     writeFileSync(mcpJsonPath, JSON.stringify(mcpConfig, null, 2), 'utf8');
     console.log(`✅ Added to ${name} mcp.json`);
-    console.log(`   Location: ${mcpJsonPath}`);
-    return { success: true, reason: 'configured', path: mcpJsonPath };
+    return { success: true, reason: 'configured', path: mcpJsonPath.replace(/\\/g, '/') };
   } catch (error) {
     console.error(`❌ Failed to update ${name} mcp.json:`, error.message);
     return { success: false, reason: 'write-error' };
@@ -142,19 +140,25 @@ function main() {
   if (foundCount === 0) {
     console.log('\nℹ️  No VS Code installations detected');
     console.log('   Add this to your VS Code User/mcp.json manually:');
-    console.log(MCP_CONFIG_WITH_COMMENTS);
   } else if (configuredCount > 0) {
     console.log('\n🎉 Configuration complete!');
     console.log('   Restart VS Code and simple-memory-mcp will be available');
-    console.log('\n💡 Customization Tips:');
-    console.log('   • Set custom database location with MEMORY_DB environment variable');
-    console.log('   • Enable automatic backups with MEMORY_BACKUP_PATH');
-    console.log('   • Run multiple instances for work/personal contexts');
-    console.log('   • See README for all configuration options');
-    console.log('\n📖 Configuration docs: https://github.com/chrisribe/simple-memory-mcp#configuration');
   } else {
     console.log('\n✅ All installations already configured');
   }
+  
+  // Show example config and instructions (for all cases)
+  if (foundCount > 0) {
+    console.log('\n💡 Example configuration with all options:');
+    console.log(MCP_CONFIG_WITH_COMMENTS);
+    console.log('\n💡 To find and edit your config file:');
+    console.log('   Run: node dist/index.js memory-stats');
+    if (configuredCount > 0) {
+      console.log('\n📖 Configuration docs: https://github.com/chrisribe/simple-memory-mcp#configuration');
+    }
+  } else {
+    console.log(MCP_CONFIG_WITH_COMMENTS);
+  }
 }
 
 main();
diff --git a/src/services/backup-service.ts b/src/services/backup-service.ts
@@ -27,53 +27,63 @@ export class BackupService {
       mkdirSync(this.config.backupPath, { recursive: true });
       debugLog(`Backup directory ready: ${this.config.backupPath}`);
       
-      // Initialize lastBackupTime from most recent backup file (for CLI persistence)
-      this.initializeLastBackupTime();
+      // Load lastBackupTime from metadata file (for CLI persistence)
+      this.lastBackupTime = this.getLastBackupTime();
     } catch (error: any) {
       debugLog(`Warning: Could not create backup directory: ${error.message}`);
     }
   }
 
   /**
-   * Initialize lastBackupTime from the most recent backup file
-   * This allows throttling to work across CLI invocations
+   * Get path to backup metadata file
    */
-  private initializeLastBackupTime(): void {
+  private getMetadataPath(): string {
+    return join(this.config.backupPath, '.backup-metadata.json');
+  }
+
+  /**
+   * Save backup metadata
+   * @returns true if saved successfully, false on error
+   */
+  private saveMetadata(): boolean {
+    try {
+      const metadata = {
+        lastBackupTime: this.lastBackupTime,
+        lastBackupDate: new Date(this.lastBackupTime).toISOString()
+      };
+      const { writeFileSync } = require('fs');
+      writeFileSync(this.getMetadataPath(), JSON.stringify(metadata, null, 2));
+      return true;
+    } catch (error: any) {
+      debugLog(`Warning: Could not save backup metadata: ${error.message}`);
+      return false;
+    }
+  }
+
+  /**
+   * Get last backup time from metadata file
+   * @returns timestamp in milliseconds, or 0 if no metadata exists
+   */
+  private getLastBackupTime(): number {
     try {
       if (!existsSync(this.config.backupPath)) {
         debugLog(`Backup path does not exist yet: ${this.config.backupPath}`);
-        return;
+        return 0;
       }
 
-      const files = readdirSync(this.config.backupPath)
-        .filter(f => f.endsWith('.db') && f.includes('_auto'))
-        .map(f => {
-          const filePath = join(this.config.backupPath, f);
-          const stats = statSync(filePath);
-          return {
-            name: f,
-            path: filePath,
-            time: stats.mtime.getTime(),
-            mtimeDate: stats.mtime
-          };
-        })
-        .sort((a, b) => b.time - a.time); // Newest first
-
-      if (files.length > 0) {
-        const mostRecent = files[0];
-        this.lastBackupTime = mostRecent.time;
-        const now = Date.now();
-        const ageMinutes = Math.floor((now - this.lastBackupTime) / 60000);
-        debugLog(`📁 Found ${files.length} existing auto backup(s)`);
-        debugLog(`📅 Most recent: ${mostRecent.name}`);
-        debugLog(`🕐 Last backup time: ${new Date(this.lastBackupTime).toISOString()}`);
-        debugLog(`🕐 Current time: ${new Date(now).toISOString()}`);
-        debugLog(`⏱️  Age: ${ageMinutes} minutes (${Math.floor((now - this.lastBackupTime) / 1000)} seconds)`);
+      const metadataPath = this.getMetadataPath();
+      if (existsSync(metadataPath)) {
+        const { readFileSync } = require('fs');
+        const metadata = JSON.parse(readFileSync(metadataPath, 'utf-8'));
+        debugLog(`📋 Loaded backup metadata: last backup at ${metadata.lastBackupDate}`);
+        return metadata.lastBackupTime;
       } else {
-        debugLog(`No existing auto backups found in ${this.config.backupPath}`);
+        debugLog(`📋 No backup metadata found (will create on first backup)`);
+        return 0;
       }
     } catch (error: any) {
-      debugLog(`Warning: Could not initialize last backup time: ${error.message}`);
+      debugLog(`Warning: Could not read last backup time: ${error.message}`);
+      return 0;
     }
   }
 
@@ -117,6 +127,7 @@ export class BackupService {
       }
       
       this.lastBackupTime = Date.now();
+      this.saveMetadata(); // Persist backup time
       debugLog(`✅ Backup created: ${backupPath}`);
 
       // Clean up old backups
@@ -199,6 +210,7 @@ export class BackupService {
 
   /**
    * Clean up old backups, keeping only the most recent N
+   * Uses filename timestamps for reliable ordering
    */
   private cleanupOldBackups(): void {
     if (!this.config.maxBackups || this.config.maxBackups <= 0) {
@@ -210,10 +222,10 @@ export class BackupService {
         .filter(f => f.endsWith('.db'))
         .map(f => ({
           name: f,
-          path: join(this.config.backupPath, f),
-          time: statSync(join(this.config.backupPath, f)).mtime.getTime()
+          path: join(this.config.backupPath, f)
         }))
-        .sort((a, b) => b.time - a.time); // Newest first
+        // Sort by filename (which contains timestamp) - newest first
+        .sort((a, b) => b.name.localeCompare(a.name));
 
       // Delete backups beyond the max count
       const toDelete = files.slice(this.config.maxBackups);
diff --git a/src/services/memory-service.ts b/src/services/memory-service.ts
@@ -54,7 +54,7 @@ export interface MemoryStats {
   backupCount?: number;
   lastBackupAge?: number; // minutes since last backup
   nextBackupIn?: number; // minutes until next backup (-1 if will backup on next write)
-  mcpConfigPaths?: MCPConfigPath[]; // MCP configuration file paths
+  mcpConfigPaths?: MCPConfigPath[]; // MCP configuration file paths with matching server entries
 }
 
 /**
@@ -673,7 +673,7 @@ export class MemoryService {
       dbSize: (this.db.pragma('page_size', { simple: true }) as number) * 
               (this.db.pragma('page_count', { simple: true }) as number),
       dbPath: this.dbPath,
-      resolvedPath: this.resolvedDbPath, // Use cached value
+      resolvedPath: this.resolvedDbPath.replace(/\\/g, '/'), // Normalize to forward slashes
       schemaVersion
     };
     
@@ -697,8 +697,8 @@ export class MemoryService {
       }
     }
 
-    // Add MCP configuration file paths
-    stats.mcpConfigPaths = getMCPConfigPaths();
+    // Add MCP configuration file paths (only existing ones)
+    stats.mcpConfigPaths = getMCPConfigPaths().filter(p => p.exists);
 
     debugLog('MemoryService: Stats:', stats);
     return stats;
diff --git a/src/tests/memory-server-tests.ts b/src/tests/memory-server-tests.ts
@@ -206,10 +206,20 @@ async function testMemoryStats(): Promise<void> {
     if (!configPath.name || !configPath.path || typeof configPath.exists !== 'boolean') {
       throw new Error('MCP config path missing required fields');
     }
+    // matchingServers is optional, but if present should be an array
+    if (configPath.matchingServers && !Array.isArray(configPath.matchingServers)) {
+      throw new Error('MCP config path matchingServers should be an array');
+    }
   }
 
   console.log(`✓ Database contains ${output.totalMemories} memories, ${output.totalRelationships} relationships`);
   console.log(`✓ Found ${output.mcpConfigPaths.length} MCP config paths`);
+  
+  // Show helpful info about matching configs
+  const matching = output.mcpConfigPaths.filter((c: any) => c.matchingServers?.length > 0);
+  if (matching.length > 0) {
+    console.log(`✓ Found ${matching.length} config(s) with matching server entries`);
+  }
 }
 
 /**
diff --git a/src/utils/mcp-config.ts b/src/utils/mcp-config.ts
@@ -1,19 +1,24 @@
-import { existsSync } from 'fs';
+import { existsSync, readFileSync } from 'fs';
 import { join } from 'path';
 import { homedir } from 'os';
 
 export interface MCPConfigPath {
   name: string;
   path: string;
   exists: boolean;
+  matchingServers?: string[]; // Server names that match current MEMORY_DB
 }
 
 /**
- * Get potential MCP configuration file paths for VS Code installations
- * Returns an array of config paths with their existence status
- * 
- * Note: Currently detects VS Code and VS Code Insiders. Other variants
- * like VSCodium, VS Code OSS, or Cursor are not detected.
+ * Normalize path to use forward slashes for better cross-platform copy/paste
+ */
+function normalizePath(p: string): string {
+  return p.replace(/\\/g, '/');
+}
+
+/**
+ * Get potential MCP configuration file paths across multiple clients
+ * Returns an array of config paths with their existence status and matching server entries
  */
 export function getMCPConfigPaths(): MCPConfigPath[] {
   const platform = process.platform;
@@ -23,26 +28,62 @@ export function getMCPConfigPaths(): MCPConfigPath[] {
   if (platform === 'win32') {
     const appData = process.env.APPDATA || join(home, 'AppData', 'Roaming');
     paths.push(
-      { name: 'VS Code', path: join(appData, 'Code', 'User', 'mcp.json'), exists: false },
-      { name: 'VS Code Insiders', path: join(appData, 'Code - Insiders', 'User', 'mcp.json'), exists: false }
+      { name: 'VS Code', path: normalizePath(join(appData, 'Code', 'User', 'mcp.json')), exists: false },
+      { name: 'VS Code Insiders', path: normalizePath(join(appData, 'Code - Insiders', 'User', 'mcp.json')), exists: false },
+      { name: 'Cursor', path: normalizePath(join(appData, 'Cursor', 'User', 'mcp.json')), exists: false },
+      { name: 'Claude Desktop', path: normalizePath(join(appData, 'Claude', 'claude_desktop_config.json')), exists: false }
     );
   } else if (platform === 'darwin') {
     const appSupport = join(home, 'Library', 'Application Support');
     paths.push(
-      { name: 'VS Code', path: join(appSupport, 'Code', 'User', 'mcp.json'), exists: false },
-      { name: 'VS Code Insiders', path: join(appSupport, 'Code - Insiders', 'User', 'mcp.json'), exists: false }
+      { name: 'VS Code', path: normalizePath(join(appSupport, 'Code', 'User', 'mcp.json')), exists: false },
+      { name: 'VS Code Insiders', path: normalizePath(join(appSupport, 'Code - Insiders', 'User', 'mcp.json')), exists: false },
+      { name: 'Cursor', path: normalizePath(join(appSupport, 'Cursor', 'User', 'mcp.json')), exists: false },
+      { name: 'Claude Desktop', path: normalizePath(join(appSupport, 'Claude', 'claude_desktop_config.json')), exists: false }
     );
   } else {
     const config = join(home, '.config');
     paths.push(
-      { name: 'VS Code', path: join(config, 'Code', 'User', 'mcp.json'), exists: false },
-      { name: 'VS Code Insiders', path: join(config, 'Code - Insiders', 'User', 'mcp.json'), exists: false }
+      { name: 'VS Code', path: normalizePath(join(config, 'Code', 'User', 'mcp.json')), exists: false },
+      { name: 'VS Code Insiders', path: normalizePath(join(config, 'Code - Insiders', 'User', 'mcp.json')), exists: false },
+      { name: 'Cursor', path: normalizePath(join(config, 'Cursor', 'User', 'mcp.json')), exists: false },
+      { name: 'Claude Desktop', path: normalizePath(join(config, 'Claude', 'claude_desktop_config.json')), exists: false }
     );
   }
   
-  // Check which paths actually exist
+  const currentDb = process.env.MEMORY_DB || 'memory.db';
+  
+  // Check which paths exist and find matching server entries
   for (const pathInfo of paths) {
     pathInfo.exists = existsSync(pathInfo.path);
+    
+    if (pathInfo.exists) {
+      try {
+        const content = readFileSync(pathInfo.path, 'utf-8');
+        const config = JSON.parse(content);
+        const servers = pathInfo.name === 'Claude Desktop' ? config.mcpServers : config.servers;
+        
+        if (servers) {
+          const matching: string[] = [];
+          for (const [name, serverConfig] of Object.entries(servers)) {
+            if (typeof serverConfig === 'object' && serverConfig !== null) {
+              const cmd = (serverConfig as any).command || '';
+              if (cmd.includes('simple-memory')) {
+                const configDb = (serverConfig as any).env?.MEMORY_DB || 'memory.db';
+                if (configDb === currentDb) {
+                  matching.push(name);
+                }
+              }
+            }
+          }
+          if (matching.length > 0) {
+            pathInfo.matchingServers = matching;
+          }
+        }
+      } catch {
+        // Ignore parse errors
+      }
+    }
   }
   
   return paths;

Original file line number	Diff line number	Diff line change
`@@ -206,10 +206,20 @@ async function testMemoryStats(): Promise<void> {`
`206`	`206`	`if (!configPath.name \|\| !configPath.path \|\| typeof configPath.exists !== 'boolean') {`
`207`	`207`	`throw new Error('MCP config path missing required fields');`
`208`	`208`	`}`
	`209`	`+ // matchingServers is optional, but if present should be an array`
	`210`	`+ if (configPath.matchingServers && !Array.isArray(configPath.matchingServers)) {`
	`211`	`+ throw new Error('MCP config path matchingServers should be an array');`
	`212`	`+ }`
`209`	`213`	`}`
`210`	`214`
`211`	`215`	console.log(`✓ Database contains ${output.totalMemories} memories, ${output.totalRelationships} relationships`);
`212`	`216`	console.log(`✓ Found ${output.mcpConfigPaths.length} MCP config paths`);
	`217`	`+`
	`218`	`+ // Show helpful info about matching configs`
	`219`	`+ const matching = output.mcpConfigPaths.filter((c: any) => c.matchingServers?.length > 0);`
	`220`	`+ if (matching.length > 0) {`
	`221`	+ console.log(`✓ Found ${matching.length} config(s) with matching server entries`);
	`222`	`+ }`
`213`	`223`	`}`
`214`	`224`
`215`	`225`	`/**`