documcp

/** * Memory MCP Tool Persistence Tests * Tests persistence and state management for MCP tool memory integration * Part of Issue #56 - Memory MCP Tools Integration Tests */ import { promises as fs } from "fs"; import path from "path"; import os from "os"; import { MemoryManager } from "../../src/memory/manager.js"; import { initializeMemory, rememberAnalysis, rememberRecommendation, rememberDeployment, exportMemories, importMemories, cleanupOldMemories, resetMemoryManager, } from "../../src/memory/integration.js"; describe("Memory MCP Tool Persistence", () => { let tempDir: string; let memoryManager: MemoryManager; beforeEach(async () => { tempDir = path.join( os.tmpdir(), `memory-persistence-test-${Date.now()}-${Math.random() .toString(36) .substr(2, 9)}`, ); await fs.mkdir(tempDir, { recursive: true }); // Reset the global memory manager to use the test directory await resetMemoryManager(tempDir); memoryManager = (await initializeMemory())!; }); afterEach(async () => { try { await resetMemoryManager(); // Reset to default await fs.rm(tempDir, { recursive: true, force: true }); } catch (error) { // Ignore cleanup errors } }); describe("Tool State Persistence", () => { test("should persist tool analysis results across sessions", async () => { memoryManager.setContext({ projectId: "persistence-test" }); // Create analysis data from tool const analysisData = { projectId: "persistence-test", toolVersion: "1.0.0", language: { primary: "rust", secondary: ["javascript"] }, framework: { name: "actix-web", version: "4.0" }, stats: { files: 75, directories: 12, linesOfCode: 8500, testCoverage: 90, }, dependencies: { ecosystem: "rust", packages: ["serde", "tokio", "actix-web"], devPackages: ["criterion", "proptest"], }, documentation: { hasReadme: true, hasContributing: true, hasLicense: true, estimatedComplexity: "moderate", }, timestamp: new Date().toISOString(), }; const memoryId = await rememberAnalysis( "/test/rust-project", analysisData, ); // Simulate session restart by creating new manager with same directory const newManager = new MemoryManager(tempDir); await newManager.initialize(); // Verify persistence const recalled = await newManager.recall(memoryId); expect(recalled).not.toBeNull(); expect(recalled?.data.language.primary).toBe("rust"); expect(recalled?.data.framework.name).toBe("actix-web"); expect(recalled?.data.stats.files).toBe(75); expect(recalled?.data.dependencies.packages).toContain("actix-web"); expect(recalled?.metadata.projectId).toBe("persistence-test"); }); test("should persist recommendation chains across tool invocations", async () => { memoryManager.setContext({ projectId: "chain-test" }); // Create analysis const analysisData = { projectId: "chain-test", language: { primary: "python" }, framework: { name: "fastapi" }, documentation: { type: "api" }, }; const analysisId = await rememberAnalysis( "/test/api-project", analysisData, ); // Create first recommendation const recommendation1 = { recommended: "mkdocs", confidence: 0.8, reasoning: ["Python ecosystem", "API documentation"], toolVersion: "1.0.0", analysisId, }; const rec1Id = await rememberRecommendation(analysisId, recommendation1); // Create updated recommendation after user feedback const recommendation2 = { recommended: "sphinx", confidence: 0.9, reasoning: ["Better API doc generation", "Python native"], toolVersion: "1.1.0", analysisId, previousRecommendation: rec1Id, }; const rec2Id = await rememberRecommendation(analysisId, recommendation2); // Verify chain persistence const analysis = await memoryManager.recall(analysisId); const rec1 = await memoryManager.recall(rec1Id); const rec2 = await memoryManager.recall(rec2Id); expect(analysis?.data.language.primary).toBe("python"); expect(rec1?.data.recommended).toBe("mkdocs"); expect(rec2?.data.recommended).toBe("sphinx"); expect(rec2?.data.previousRecommendation).toBe(rec1Id); // Verify all have same project context expect(analysis?.metadata.projectId).toBe("chain-test"); expect(rec1?.metadata.projectId).toBe("chain-test"); expect(rec2?.metadata.projectId).toBe("chain-test"); }); test("should maintain deployment history with status tracking", async () => { memoryManager.setContext({ projectId: "deployment-history" }); const deployments = [ { ssg: "hugo", status: "failed", error: "Build timeout", duration: 300, attempt: 1, timestamp: new Date(Date.now() - 3600000).toISOString(), // 1 hour ago }, { ssg: "hugo", status: "failed", error: "Missing dependency", duration: 120, attempt: 2, timestamp: new Date(Date.now() - 1800000).toISOString(), // 30 minutes ago }, { ssg: "hugo", status: "success", url: "https://project.github.io", duration: 180, attempt: 3, timestamp: new Date().toISOString(), }, ]; const deploymentIds = []; for (const deployment of deployments) { const id = await rememberDeployment( "github.com/test/deployment-project", deployment, ); deploymentIds.push(id); } // Verify deployment history is preserved const allDeployments = await Promise.all( deploymentIds.map((id) => memoryManager.recall(id)), ); expect(allDeployments.length).toBe(3); expect(allDeployments[0]?.data.status).toBe("failed"); expect(allDeployments[0]?.data.attempt).toBe(1); expect(allDeployments[1]?.data.status).toBe("failed"); expect(allDeployments[1]?.data.attempt).toBe(2); expect(allDeployments[2]?.data.status).toBe("success"); expect(allDeployments[2]?.data.attempt).toBe(3); // Verify chronological ordering can be reconstructed const sortedByTimestamp = allDeployments.sort( (a, b) => new Date(a!.data.timestamp).getTime() - new Date(b!.data.timestamp).getTime(), ); expect(sortedByTimestamp[0]?.data.attempt).toBe(1); expect(sortedByTimestamp[2]?.data.attempt).toBe(3); }); }); describe("Cross-Session State Recovery", () => { test("should recover tool context after process restart", async () => { memoryManager.setContext({ projectId: "context-recovery", repository: "github.com/test/context-project", branch: "main", user: "test-user", session: "session-1", }); // Create memories with rich context await memoryManager.remember("analysis", { sessionActive: true, toolState: "initialized", contextData: "session-specific", }); await memoryManager.remember("configuration", { ssg: "docusaurus", userPreferences: { theme: "dark", language: "en", features: ["search", "versions"], }, }); // Simulate process restart const newManager = new MemoryManager(tempDir); await newManager.initialize(); // Recover project memories const projectMemories = await newManager.search({ projectId: "context-recovery", }); expect(projectMemories.length).toBe(2); const analysisMemory = projectMemories.find((m) => m.type === "analysis"); const configMemory = projectMemories.find( (m) => m.type === "configuration", ); expect(analysisMemory?.data.sessionActive).toBe(true); expect(configMemory?.data.ssg).toBe("docusaurus"); expect(configMemory?.data.userPreferences.theme).toBe("dark"); // Verify context metadata is preserved expect(analysisMemory?.metadata.repository).toBe( "github.com/test/context-project", ); expect(configMemory?.metadata.projectId).toBe("context-recovery"); }); test("should handle concurrent tool operations persistence", async () => { memoryManager.setContext({ projectId: "concurrent-ops" }); // Simulate concurrent tool operations const operations = Array.from({ length: 10 }, (_, i) => ({ type: i % 3 === 0 ? "analysis" : i % 3 === 1 ? "recommendation" : "deployment", data: { operationId: i, timestamp: new Date(Date.now() + i * 1000).toISOString(), concurrentTest: true, }, })); // Execute operations concurrently const promises = operations.map(async (op, index) => { if (op.type === "analysis") { return rememberAnalysis(`/test/concurrent-${index}`, op.data); } else if (op.type === "recommendation") { return rememberRecommendation(`analysis-${index}`, { ...op.data, recommended: "jekyll", }); } else { return rememberDeployment(`github.com/test/concurrent-${index}`, { ...op.data, status: "success", }); } }); const memoryIds = await Promise.all(promises); // Verify all operations were persisted expect(memoryIds.length).toBe(10); expect(memoryIds.every((id) => typeof id === "string")).toBe(true); // Verify no data corruption occurred const recalledMemories = await Promise.all( memoryIds.map((id) => memoryManager.recall(id)), ); expect(recalledMemories.every((m) => m !== null)).toBe(true); expect( recalledMemories.every((m) => m?.data.concurrentTest === true), ).toBe(true); // Verify operation IDs are preserved and unique const operationIds = recalledMemories.map((m) => m?.data.operationId); const uniqueIds = new Set(operationIds); expect(uniqueIds.size).toBe(10); }); }); describe("Data Export and Import for Tools", () => { test("should export tool memories for backup and migration", async () => { memoryManager.setContext({ projectId: "export-test" }); // Create comprehensive tool data const analysisId = await rememberAnalysis("/test/export-project", { projectId: "export-test", language: { primary: "go" }, framework: { name: "gin" }, exportTest: true, }); await memoryManager.remember( "recommendation", { recommended: "hugo", confidence: 0.95, exportTest: true, }, { ssg: "hugo", tags: ["recommendation", "hugo"], }, ); // Temporarily store deployment with correct project context const deploymentData = { ssg: "hugo", status: "success", exportTest: true, }; await memoryManager.remember("deployment", deploymentData, { repository: "github.com/test/export-project", ssg: deploymentData.ssg, tags: ["deployment", deploymentData.status, deploymentData.ssg], }); // Export memories for this project only const exportedData = await exportMemories("json", "export-test"); expect(exportedData).toBeDefined(); expect(typeof exportedData).toBe("string"); // Verify export contains our test data const parsed = JSON.parse(exportedData); expect(Array.isArray(parsed)).toBe(true); const exportTestMemories = parsed.filter( (m: any) => m.data.exportTest === true, ); expect(exportTestMemories.length).toBe(3); // Verify different memory types are present const types = new Set(exportTestMemories.map((m: any) => m.type)); expect(types.has("analysis")).toBe(true); expect(types.has("recommendation")).toBe(true); expect(types.has("deployment")).toBe(true); }); test("should import tool memories with data validation", async () => { // Create export data const exportData = JSON.stringify([ { id: "import-analysis-1", type: "analysis", data: { projectId: "import-test", language: { primary: "javascript" }, framework: { name: "svelte" }, importTest: true, }, metadata: { projectId: "import-test", tags: ["analysis", "javascript", "svelte"], }, timestamp: new Date().toISOString(), }, { id: "import-recommendation-1", type: "recommendation", data: { recommended: "sveltekit", confidence: 0.88, importTest: true, }, metadata: { projectId: "import-test", ssg: "sveltekit", tags: ["recommendation", "sveltekit"], }, timestamp: new Date().toISOString(), }, ]); // Import the data const importedCount = await importMemories(exportData, "json"); expect(importedCount).toBe(2); // Verify imported data is accessible const importedMemories = await memoryManager.search({ projectId: "import-test", }); expect(importedMemories.length).toBe(2); const analysis = importedMemories.find((m) => m.type === "analysis"); const recommendation = importedMemories.find( (m) => m.type === "recommendation", ); expect(analysis?.data.language.primary).toBe("javascript"); expect(analysis?.data.framework.name).toBe("svelte"); expect(recommendation?.data.recommended).toBe("sveltekit"); expect(recommendation?.data.confidence).toBe(0.88); }); test("should handle tool memory migration between environments", async () => { memoryManager.setContext({ projectId: "migration-test" }); // Create source environment data const sourceData = [ { projectId: "migration-project", language: { primary: "python" }, framework: { name: "flask" }, environment: "development", }, { projectId: "migration-project", language: { primary: "python" }, framework: { name: "flask" }, environment: "staging", }, { projectId: "migration-project", language: { primary: "python" }, framework: { name: "flask" }, environment: "production", }, ]; // Store memories in source environment const sourceIds = await Promise.all( sourceData.map((data) => rememberAnalysis("/test/migration-project", data), ), ); expect(sourceIds.length).toBe(3); // Export from source (migration project only) const exportedData = await exportMemories("json", "migration-project"); // Create target environment (new directory) const targetDir = path.join(tempDir, "target-environment"); await fs.mkdir(targetDir, { recursive: true }); const targetManager = new MemoryManager(targetDir); await targetManager.initialize(); // Import to target environment const importedCount = await targetManager.import(exportedData, "json"); expect(importedCount).toBe(3); // Verify migration integrity const migratedMemories = await targetManager.search({ projectId: "migration-project", }); expect(migratedMemories.length).toBe(3); const environments = migratedMemories.map((m) => m.data.environment); expect(environments).toContain("development"); expect(environments).toContain("staging"); expect(environments).toContain("production"); }); }); describe("Memory Cleanup and Maintenance", () => { test("should cleanup old tool memories automatically", async () => { memoryManager.setContext({ projectId: "cleanup-test" }); // Create old memories (simulate by manually setting timestamps) const oldTimestamp = new Date( Date.now() - 45 * 24 * 60 * 60 * 1000, ).toISOString(); // 45 days ago const recentTimestamp = new Date( Date.now() - 5 * 24 * 60 * 60 * 1000, ).toISOString(); // 5 days ago // Create entries directly via storage to control timestamps await memoryManager.getStorage().append({ type: "analysis", timestamp: oldTimestamp, data: { projectId: "cleanup-test", age: "old", }, metadata: { projectId: "cleanup-test", }, }); await memoryManager.getStorage().append({ type: "analysis", timestamp: recentTimestamp, data: { projectId: "cleanup-test", age: "recent", }, metadata: { projectId: "cleanup-test", }, }); await memoryManager.getStorage().append({ type: "recommendation", timestamp: oldTimestamp, data: { recommended: "hugo", age: "old", }, metadata: { projectId: "cleanup-test", }, }); // Verify all memories exist before cleanup const beforeCleanup = await memoryManager.search({ projectId: "cleanup-test", }); expect(beforeCleanup.length).toBe(3); // Cleanup memories older than 30 days const cleanedCount = await cleanupOldMemories(30); expect(cleanedCount).toBeGreaterThanOrEqual(2); // Should cleanup the 2 old memories // Verify recent memories are preserved const afterCleanup = await memoryManager.search({ projectId: "cleanup-test", }); const recentMemories = afterCleanup.filter( (m) => m.data.age === "recent", ); expect(recentMemories.length).toBe(1); expect(recentMemories[0].data.age).toBe("recent"); }); test("should optimize memory storage for tool performance", async () => { memoryManager.setContext({ projectId: "optimization-test" }); // Create many memories to test optimization const memoryPromises = Array.from({ length: 100 }, (_, i) => memoryManager.remember("analysis", { index: i, data: `optimization-test-${i}`, category: i % 10 === 0 ? "heavy" : "light", }), ); await Promise.all(memoryPromises); // Measure search performance const startTime = Date.now(); const searchResults = await memoryManager.search({ projectId: "optimization-test", }); const searchTime = Date.now() - startTime; expect(searchResults.length).toBe(100); expect(searchTime).toBeLessThan(1000); // Should complete within 1 second // Test category-based filtering performance const categoryStartTime = Date.now(); const allMemories = await memoryManager.search(""); const heavyMemories = allMemories.filter( (m) => m.data.category === "heavy", ); const categorySearchTime = Date.now() - categoryStartTime; expect(heavyMemories.length).toBe(10); // 10% of memories marked as 'heavy' expect(categorySearchTime).toBeLessThan(500); // Category search should be fast }); test("should handle memory corruption recovery", async () => { memoryManager.setContext({ projectId: "corruption-test" }); // Create valid memories const valid1Entry = await memoryManager.remember("analysis", { valid: true, data: "good-data", }); const valid2Entry = await memoryManager.remember("recommendation", { recommended: "docusaurus", valid: true, }); // Verify memories are accessible const valid1 = await memoryManager.recall(valid1Entry.id); const valid2 = await memoryManager.recall(valid2Entry.id); expect(valid1?.data.valid).toBe(true); expect(valid2?.data.valid).toBe(true); // Simulate recovery after corruption by creating new manager const recoveryManager = new MemoryManager(tempDir); await recoveryManager.initialize(); // Verify data recovery const recovered1 = await recoveryManager.recall(valid1Entry.id); const recovered2 = await recoveryManager.recall(valid2Entry.id); expect(recovered1?.data.valid).toBe(true); expect(recovered2?.data.recommended).toBe("docusaurus"); // Verify search functionality after recovery const allRecovered = await recoveryManager.search({ projectId: "corruption-test", }); expect(allRecovered.length).toBe(2); }); }); });