documcp

/** * Memory MCP Tools Integration Tests * Tests integration between memory system and MCP tools * Part of Issue #56 - Memory MCP Tools Integration Tests */ import { promises as fs } from "fs"; import path from "path"; import os from "os"; import { initializeMemory, rememberAnalysis, rememberRecommendation, rememberDeployment, rememberConfiguration, recallProjectHistory, getProjectInsights, getSimilarProjects, getMemoryStatistics, } from "../../src/memory/integration.js"; import { analyzeRepository } from "../../src/tools/analyze-repository.js"; import { recommendSSG } from "../../src/tools/recommend-ssg.js"; describe("Memory MCP Tools Integration", () => { let tempDir: string; let testProjectDir: string; beforeEach(async () => { // Create unique temp directory for each test tempDir = path.join( os.tmpdir(), `memory-mcp-integration-${Date.now()}-${Math.random() .toString(36) .substr(2, 9)}`, ); await fs.mkdir(tempDir, { recursive: true }); // Create a mock project structure for testing testProjectDir = path.join(tempDir, "test-project"); await createMockProject(testProjectDir); }); afterEach(async () => { // Cleanup temp directory try { await fs.rm(tempDir, { recursive: true, force: true }); } catch (error) { // Ignore cleanup errors } }); async function createMockProject(projectPath: string) { await fs.mkdir(projectPath, { recursive: true }); // Create package.json await fs.writeFile( path.join(projectPath, "package.json"), JSON.stringify( { name: "test-project", version: "1.0.0", dependencies: { react: "^18.0.0", typescript: "^5.0.0", }, devDependencies: { jest: "^29.0.0", }, }, null, 2, ), ); // Create README.md await fs.writeFile( path.join(projectPath, "README.md"), `# Test Project A test project for memory integration testing. ## Features - TypeScript support - React components - Jest testing `, ); // Create src directory with TypeScript files await fs.mkdir(path.join(projectPath, "src")); await fs.writeFile( path.join(projectPath, "src/index.ts"), 'export const hello = "world";', ); await fs.writeFile( path.join(projectPath, "src/component.tsx"), 'import React from "react"; export const Component = () => <div>Hello</div>;', ); // Create tests directory await fs.mkdir(path.join(projectPath, "__tests__")); await fs.writeFile( path.join(projectPath, "__tests__/index.test.ts"), 'test("hello world", () => { expect(true).toBe(true); });', ); // Create docs directory await fs.mkdir(path.join(projectPath, "docs")); await fs.writeFile( path.join(projectPath, "docs/setup.md"), "# Setup Guide\n\nHow to set up the project.", ); } describe("Memory Integration Initialization", () => { test("should initialize memory system for MCP tools", async () => { const memoryManager = await initializeMemory(); expect(memoryManager).toBeDefined(); expect(memoryManager.constructor.name).toBe("MemoryManager"); }); test("should handle memory system events", async () => { const memoryManager = await initializeMemory(); let eventsFired = 0; memoryManager.on("memory-created", () => { eventsFired++; }); // Create a memory entry await memoryManager.remember("analysis", { test: true }); // Give events time to fire await new Promise((resolve) => setTimeout(resolve, 50)); expect(eventsFired).toBeGreaterThanOrEqual(1); }); }); describe("Repository Analysis Integration", () => { test("should integrate repository analysis with memory system", async () => { // Run repository analysis tool const analysisResult = await analyzeRepository({ path: testProjectDir, depth: "standard", }); expect(analysisResult.isError).toBeFalsy(); expect(analysisResult.content).toBeDefined(); // Extract analysis data from MCP response const analysisContent = analysisResult.content.find( (c) => c.type === "text" && c.text.includes("Analysis Complete"), ); expect(analysisContent).toBeDefined(); // Remember analysis in memory system const analysisData = { projectId: "test-project", language: { primary: "typescript" }, framework: { name: "react" }, stats: { files: 5 }, repository: { url: "github.com/test/project" }, }; const memoryId = await rememberAnalysis(testProjectDir, analysisData); expect(memoryId).toBeDefined(); expect(typeof memoryId).toBe("string"); // Verify memory was stored const memoryManager = await initializeMemory(); const recalled = await memoryManager.recall(memoryId); expect(recalled).not.toBeNull(); expect(recalled?.data.language.primary).toBe("typescript"); expect(recalled?.data.framework.name).toBe("react"); }); test("should store analysis metadata correctly", async () => { const analysisData = { projectId: "metadata-test", language: { primary: "javascript" }, framework: { name: "vue" }, stats: { files: 25 }, repository: { url: "github.com/test/vue-project" }, }; const memoryId = await rememberAnalysis( "/test/vue-project", analysisData, ); const memoryManager = await initializeMemory(); const recalled = await memoryManager.recall(memoryId); expect(recalled?.metadata.repository).toBe("github.com/test/vue-project"); expect(recalled?.metadata.tags).toContain("analysis"); expect(recalled?.metadata.tags).toContain("javascript"); expect(recalled?.metadata.tags).toContain("vue"); }); }); describe("SSG Recommendation Integration", () => { test("should integrate SSG recommendation with memory system", async () => { // First create an analysis const analysisData = { projectId: "ssg-test", language: { primary: "typescript" }, framework: { name: "react" }, }; const analysisId = await rememberAnalysis( "/test/ssg-project", analysisData, ); // Run SSG recommendation tool const recommendationResult = await recommendSSG({ analysisId, preferences: { priority: "features", ecosystem: "javascript", }, }); expect(recommendationResult.content).toBeDefined(); // Extract recommendation data const recommendationData = { recommended: "docusaurus", confidence: 0.85, reasoning: ["React-based", "TypeScript support"], analysisId, }; const memoryId = await rememberRecommendation( analysisId, recommendationData, ); expect(memoryId).toBeDefined(); // Verify memory linking const memoryManager = await initializeMemory(); const recalled = await memoryManager.recall(memoryId); expect(recalled?.data.recommended).toBe("docusaurus"); expect(recalled?.metadata.ssg).toBe("docusaurus"); expect(recalled?.metadata.tags).toContain("recommendation"); expect(recalled?.metadata.tags).toContain("docusaurus"); }); test("should link recommendations to analysis", async () => { // Create analysis const analysisData = { projectId: "linked-test", language: { primary: "python" }, }; const analysisId = await rememberAnalysis( "/test/python-project", analysisData, ); // Create recommendation const recommendationData = { recommended: "mkdocs", confidence: 0.9, }; const recommendationId = await rememberRecommendation( analysisId, recommendationData, ); // Verify linking const memoryManager = await initializeMemory(); const recommendation = await memoryManager.recall(recommendationId); const analysis = await memoryManager.recall(analysisId); expect(recommendation?.metadata.projectId).toBe( analysis?.metadata.projectId, ); expect(recommendation?.metadata.projectId).toBe("linked-test"); }); }); describe("Deployment Memory Integration", () => { test("should store deployment results in memory", async () => { const deploymentData = { ssg: "hugo", status: "success", duration: 120, url: "https://test-project.github.io", branch: "gh-pages", }; const memoryId = await rememberDeployment( "github.com/test/project", deploymentData, ); const memoryManager = await initializeMemory(); const recalled = await memoryManager.recall(memoryId); expect(recalled?.data.ssg).toBe("hugo"); expect(recalled?.data.status).toBe("success"); expect(recalled?.metadata.repository).toBe("github.com/test/project"); expect(recalled?.metadata.tags).toContain("deployment"); expect(recalled?.metadata.tags).toContain("success"); expect(recalled?.metadata.tags).toContain("hugo"); }); test("should track deployment failures", async () => { const failedDeployment = { ssg: "jekyll", status: "failed", error: "Build failed: missing dependency", duration: 45, }; const memoryId = await rememberDeployment( "github.com/test/failed-project", failedDeployment, ); const memoryManager = await initializeMemory(); const recalled = await memoryManager.recall(memoryId); expect(recalled?.data.status).toBe("failed"); expect(recalled?.data.error).toContain("Build failed"); expect(recalled?.metadata.tags).toContain("failed"); }); }); describe("Configuration Memory Integration", () => { test("should store configuration data in memory", async () => { const configData = { title: "Test Documentation", theme: "material", plugins: ["search", "navigation"], build: { outputDir: "_site", baseUrl: "/docs/", }, }; const memoryId = await rememberConfiguration( "test-docs", "mkdocs", configData, ); const memoryManager = await initializeMemory(); const recalled = await memoryManager.recall(memoryId); expect(recalled?.data.title).toBe("Test Documentation"); expect(recalled?.data.theme).toBe("material"); expect(recalled?.metadata.ssg).toBe("mkdocs"); expect(recalled?.metadata.tags).toContain("configuration"); expect(recalled?.metadata.tags).toContain("mkdocs"); expect(recalled?.metadata.tags).toContain("test-docs"); }); }); describe("Project History and Insights", () => { test("should recall comprehensive project history", async () => { const projectId = "history-test"; // Create a complete project workflow in memory const analysisData = { projectId, language: { primary: "typescript" }, framework: { name: "react" }, }; await rememberAnalysis("/test/history-project", analysisData); const recommendationData = { recommended: "docusaurus", confidence: 0.8, }; await rememberRecommendation("analysis-id", recommendationData); const deploymentData = { ssg: "docusaurus", status: "success", duration: 90, }; await rememberDeployment( "github.com/test/history-project", deploymentData, ); // Recall project history const history = await recallProjectHistory(projectId); expect(history.projectId).toBe(projectId); expect(history.history).toBeDefined(); expect(history.insights).toBeDefined(); expect(Array.isArray(history.insights)).toBe(true); }); test("should generate meaningful project insights", async () => { const projectId = "insights-test"; // Create deployment history const successfulDeployment = { ssg: "hugo", status: "success", duration: 60, }; await rememberDeployment( "github.com/test/insights-project", successfulDeployment, ); const failedDeployment = { ssg: "hugo", status: "failed", error: "Build timeout", }; await rememberDeployment( "github.com/test/insights-project", failedDeployment, ); const insights = await getProjectInsights(projectId); expect(Array.isArray(insights)).toBe(true); // Insights may be empty if memories don't meet criteria, that's ok if (insights.length > 0) { // Should include deployment success rate if deployments exist const successRateInsight = insights.find((i) => i.includes("success rate"), ); expect(successRateInsight).toBeDefined(); } }); }); describe("Similar Projects Discovery", () => { test("should find similar projects based on characteristics", async () => { // Create multiple projects with different characteristics await rememberAnalysis("/project1", { projectId: "project1", language: { primary: "typescript" }, framework: { name: "react" }, }); await rememberAnalysis("/project2", { projectId: "project2", language: { primary: "typescript" }, framework: { name: "vue" }, }); await rememberAnalysis("/project3", { projectId: "project3", language: { primary: "python" }, framework: { name: "django" }, }); // Search for similar projects const targetProject = { language: { primary: "typescript" }, framework: { name: "react" }, stats: { files: 100 }, }; const similarProjects = await getSimilarProjects(targetProject, 3); expect(Array.isArray(similarProjects)).toBe(true); // Similar projects may be empty if no matches found, that's ok if (similarProjects.length > 0) { // Should find TypeScript projects first const tsProjects = similarProjects.filter((p) => p.similarity > 0); expect(tsProjects.length).toBeGreaterThan(0); } }); test("should calculate similarity scores correctly", async () => { // Create projects with known characteristics await rememberAnalysis("/exact-match", { projectId: "exact-match", language: { primary: "javascript" }, framework: { name: "vue" }, stats: { files: 50 }, documentation: { type: "api" }, }); await rememberAnalysis("/partial-match", { projectId: "partial-match", language: { primary: "javascript" }, framework: { name: "react" }, stats: { files: 45 }, }); const targetProject = { language: { primary: "javascript" }, framework: { name: "vue" }, stats: { files: 52 }, documentation: { type: "api" }, }; const similarProjects = await getSimilarProjects(targetProject, 5); expect(Array.isArray(similarProjects)).toBe(true); // Similar projects may be empty, but if found should have similarity scores if (similarProjects.length > 0) { const exactMatch = similarProjects.find( (p) => p.projectId === "exact-match", ); const partialMatch = similarProjects.find( (p) => p.projectId === "partial-match", ); if (exactMatch && partialMatch) { expect(exactMatch.similarity).toBeGreaterThan( partialMatch.similarity, ); } } }); }); describe("Memory Statistics and Analytics", () => { test("should provide memory statistics for tools", async () => { // Create some test data await rememberAnalysis("/stats-test", { projectId: "stats-test", language: { primary: "go" }, }); await rememberDeployment("github.com/test/stats", { ssg: "hugo", status: "success", }); const stats = await getMemoryStatistics(); expect(stats).toBeDefined(); expect(typeof stats).toBe("object"); }); }); describe("Error Handling and Edge Cases", () => { test("should handle malformed analysis data gracefully", async () => { const malformedData = { // Missing required fields language: null, framework: undefined, }; // Should not throw but handle gracefully const memoryId = await rememberAnalysis("/malformed", malformedData); expect(memoryId).toBeDefined(); const memoryManager = await initializeMemory(); const recalled = await memoryManager.recall(memoryId); expect(recalled).not.toBeNull(); }); test("should handle missing analysis when creating recommendations", async () => { const recommendationData = { recommended: "jekyll", confidence: 0.7, }; // Reference non-existent analysis const memoryId = await rememberRecommendation( "non-existent-analysis", recommendationData, ); expect(memoryId).toBeDefined(); const memoryManager = await initializeMemory(); const recalled = await memoryManager.recall(memoryId); expect(recalled?.data.recommended).toBe("jekyll"); }); test("should handle empty project history gracefully", async () => { const history = await recallProjectHistory("non-existent-project"); expect(history.projectId).toBe("non-existent-project"); expect(history.history).toBeDefined(); expect(Array.isArray(history.insights)).toBe(true); }); test("should handle similar projects search with no matches", async () => { const uniqueProject = { language: { primary: "rust" }, framework: { name: "actix" }, stats: { files: 500 }, }; const similarProjects = await getSimilarProjects(uniqueProject, 5); expect(Array.isArray(similarProjects)).toBe(true); // Should return empty array or minimal matches expect(similarProjects.length).toBeGreaterThanOrEqual(0); }); }); });