@stackmemoryai/stackmemory 0.2.8 → 0.3.0

package/dist/integrations/mcp/__tests__/server.test.js

@@ -0,0 +1,798 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import Database from "better-sqlite3";
+import LocalStackMemoryMCP from "../server.js";
+import { join } from "path";
+import { mkdtempSync, rmSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { tmpdir } from "os";
+let mockServerInstance = null;
+vi.mock("@modelcontextprotocol/sdk/server/index.js", () => {
+  const MockServer = vi.fn().mockImplementation(function() {
+    if (mockServerInstance) {
+      Object.assign(this, mockServerInstance);
+    } else {
+      this.setRequestHandler = vi.fn();
+      this.connect = vi.fn();
+    }
+    return this;
+  });
+  return { Server: MockServer };
+});
+vi.mock("@modelcontextprotocol/sdk/server/stdio.js", () => ({
+  StdioServerTransport: vi.fn()
+}));
+vi.mock("child_process", () => ({
+  execSync: vi.fn(() => Buffer.from("mocked git output"))
+}));
+vi.mock("../../features/browser/browser-mcp.js", () => ({
+  BrowserMCPIntegration: vi.fn().mockImplementation(() => ({
+    initialize: vi.fn().mockResolvedValue(void 0)
+  }))
+}));
+vi.mock("../../integrations/linear/auth.js", async () => {
+  const actual = await vi.importActual("../../integrations/linear/auth.js");
+  return {
+    ...actual,
+    LinearAuthManager: vi.fn().mockImplementation(() => ({
+      loadTokens: vi.fn(),
+      isConfigured: vi.fn(() => false)
+    }))
+  };
+});
+vi.mock("../../integrations/linear/client.js", async () => {
+  const actual = await vi.importActual("../../integrations/linear/client.js");
+  return {
+    ...actual,
+    LinearClient: vi.fn().mockImplementation(() => ({
+      getIssue: vi.fn(),
+      findIssueByIdentifier: vi.fn(),
+      updateIssue: vi.fn(),
+      getTeam: vi.fn(),
+      getWorkflowStates: vi.fn(),
+      getViewer: vi.fn(),
+      getIssues: vi.fn()
+    }))
+  };
+});
+vi.mock("../../integrations/linear/sync.js", async () => {
+  const actual = await vi.importActual("../../integrations/linear/sync.js");
+  return {
+    ...actual,
+    LinearSyncEngine: vi.fn().mockImplementation(() => ({
+      sync: vi.fn()
+    })),
+    DEFAULT_SYNC_CONFIG: {
+      enabled: true,
+      direction: "bidirectional",
+      conflictResolution: "newest_wins"
+    }
+  };
+});
+describe("LocalStackMemoryMCP", () => {
+  let tempDir;
+  let mcpServer;
+  let mockServer;
+  let originalCwd;
+  let originalArgv;
+  beforeEach(() => {
+    tempDir = mkdtempSync(join(tmpdir(), "stackmemory-mcp-test-"));
+    originalCwd = process.cwd();
+    originalArgv = [...process.argv];
+    const gitDir = join(tempDir, ".git");
+    mkdirSync(gitDir, { recursive: true });
+    writeFileSync(
+      join(gitDir, "config"),
+      "[core]\n	repositoryformatversion = 0"
+    );
+    writeFileSync(
+      join(tempDir, "package.json"),
+      JSON.stringify({
+        name: "test-project",
+        version: "1.0.0"
+      })
+    );
+    vi.spyOn(process, "cwd").mockReturnValue(tempDir);
+    mockServer = {
+      setRequestHandler: vi.fn(),
+      connect: vi.fn()
+    };
+    mockServerInstance = mockServer;
+  });
+  afterEach(() => {
+    if (mcpServer) {
+    }
+    vi.spyOn(process, "cwd").mockRestore();
+    process.argv = originalArgv;
+    if (tempDir) {
+      rmSync(tempDir, { recursive: true, force: true });
+    }
+    vi.clearAllMocks();
+  });
+  describe("Initialization", () => {
+    it("should initialize server with correct project detection", () => {
+      mcpServer = new LocalStackMemoryMCP();
+      expect(Server).toHaveBeenCalledWith(
+        {
+          name: "stackmemory-local",
+          version: "0.1.0"
+        },
+        {
+          capabilities: {
+            tools: {}
+          }
+        }
+      );
+    });
+    it("should create .stackmemory directory if it does not exist", () => {
+      mcpServer = new LocalStackMemoryMCP();
+      const stackmemoryDir = join(tempDir, ".stackmemory");
+      expect(existsSync(stackmemoryDir)).toBe(true);
+    });
+    it("should initialize database and frame manager", () => {
+      mcpServer = new LocalStackMemoryMCP();
+      const dbPath = join(tempDir, ".stackmemory", "context.db");
+      expect(existsSync(dbPath)).toBe(true);
+    });
+    it("should handle missing .git directory gracefully", () => {
+      rmSync(join(tempDir, ".git"), { recursive: true });
+      expect(() => {
+        mcpServer = new LocalStackMemoryMCP();
+      }).not.toThrow();
+    });
+    it("should setup tool handlers correctly", () => {
+      mockServer.setRequestHandler.mockClear();
+      mcpServer = new LocalStackMemoryMCP();
+      expect(
+        mockServer.setRequestHandler.mock.calls.length
+      ).toBeGreaterThanOrEqual(2);
+      const toolsListCall = mockServer.setRequestHandler.mock.calls.find(
+        (call) => {
+          try {
+            return call[0].parse({ method: "tools/list" }).method === "tools/list";
+          } catch {
+            return false;
+          }
+        }
+      );
+      expect(toolsListCall).toBeDefined();
+      const toolsCallCall = mockServer.setRequestHandler.mock.calls.find(
+        (call) => {
+          try {
+            return call[0].parse({
+              method: "tools/call",
+              params: { name: "test", arguments: {} }
+            }).method === "tools/call";
+          } catch {
+            return false;
+          }
+        }
+      );
+      expect(toolsCallCall).toBeDefined();
+    });
+  });
+  describe("Tool Listing", () => {
+    beforeEach(() => {
+      mcpServer = new LocalStackMemoryMCP();
+    });
+    it("should list all available tools", async () => {
+      const toolsListHandler = mockServer.setRequestHandler.mock.calls[0][1];
+      const result = await toolsListHandler({ method: "tools/list" });
+      expect(result.tools).toBeDefined();
+      expect(Array.isArray(result.tools)).toBe(true);
+      expect(result.tools.length).toBeGreaterThan(0);
+      const toolNames = result.tools.map((tool) => tool.name);
+      expect(toolNames).toContain("get_context");
+      expect(toolNames).toContain("add_decision");
+      expect(toolNames).toContain("start_frame");
+      expect(toolNames).toContain("close_frame");
+      expect(toolNames).toContain("add_anchor");
+      expect(toolNames).toContain("get_hot_stack");
+      expect(toolNames).toContain("create_task");
+      expect(toolNames).toContain("update_task_status");
+      expect(toolNames).toContain("get_active_tasks");
+    });
+    it("should include Linear integration tools", async () => {
+      const toolsListHandler = mockServer.setRequestHandler.mock.calls[0][1];
+      const result = await toolsListHandler({ method: "tools/list" });
+      const toolNames = result.tools.map((tool) => tool.name);
+      expect(toolNames).toContain("linear_sync");
+      expect(toolNames).toContain("linear_update_task");
+      expect(toolNames).toContain("linear_get_tasks");
+      expect(toolNames).toContain("linear_status");
+    });
+    it("should include proper tool schemas", async () => {
+      const toolsListHandler = mockServer.setRequestHandler.mock.calls[0][1];
+      const result = await toolsListHandler({ method: "tools/list" });
+      const getContextTool = result.tools.find(
+        (tool) => tool.name === "get_context"
+      );
+      expect(getContextTool).toBeDefined();
+      expect(getContextTool.description).toBeDefined();
+      expect(getContextTool.inputSchema).toBeDefined();
+      expect(getContextTool.inputSchema.type).toBe("object");
+      expect(getContextTool.inputSchema.properties).toBeDefined();
+      const startFrameTool = result.tools.find(
+        (tool) => tool.name === "start_frame"
+      );
+      expect(startFrameTool.inputSchema.required).toContain("name");
+      expect(startFrameTool.inputSchema.required).toContain("type");
+    });
+  });
+  describe("Tool Execution - Context Management", () => {
+    let toolsCallHandler;
+    beforeEach(() => {
+      mockServer.setRequestHandler.mockClear();
+      mcpServer = new LocalStackMemoryMCP();
+      toolsCallHandler = mockServer.setRequestHandler.mock.calls[1][1];
+    });
+    it("should handle get_context tool", async () => {
+      const result = await toolsCallHandler({
+        method: "tools/call",
+        params: {
+          name: "get_context",
+          arguments: { query: "test", limit: 5 }
+        }
+      });
+      expect(result.content).toBeDefined();
+      expect(Array.isArray(result.content)).toBe(true);
+      expect(result.content[0].type).toBe("text");
+    });
+    it("should handle add_decision tool", async () => {
+      const result = await toolsCallHandler({
+        method: "tools/call",
+        params: {
+          name: "add_decision",
+          arguments: { content: "Test decision", type: "decision" }
+        }
+      });
+      expect(result.content).toBeDefined();
+      expect(result.content[0].text).toContain("Added decision");
+      expect(result.content[0].text).toContain("Test decision");
+    });
+    it("should handle start_frame tool", async () => {
+      const result = await toolsCallHandler({
+        method: "tools/call",
+        params: {
+          name: "start_frame",
+          arguments: {
+            name: "Test Frame",
+            type: "task",
+            constraints: ["constraint1", "constraint2"]
+          }
+        }
+      });
+      expect(result.content).toBeDefined();
+      expect(result.content[0].text).toContain("Started task");
+      expect(result.content[0].text).toContain("Test Frame");
+      expect(result.content[0].text).toContain("Frame ID:");
+      expect(result.content[0].text).toContain("Stack depth:");
+    });
+    it("should handle close_frame tool", async () => {
+      await toolsCallHandler({
+        method: "tools/call",
+        params: {
+          name: "start_frame",
+          arguments: { name: "Test Frame", type: "task" }
+        }
+      });
+      const result = await toolsCallHandler({
+        method: "tools/call",
+        params: {
+          name: "close_frame",
+          arguments: {
+            result: "Completed successfully",
+            outputs: { key: "value" }
+          }
+        }
+      });
+      expect(result.content).toBeDefined();
+      expect(result.content[0].text).toContain("Closed frame");
+      expect(result.content[0].text).toContain("Completed successfully");
+    });
+    it("should handle close_frame with no active frame", async () => {
+      const result = await toolsCallHandler({
+        method: "tools/call",
+        params: {
+          name: "close_frame",
+          arguments: { result: "Test" }
+        }
+      });
+      expect(result.content[0].text).toContain("No active frame to close");
+    });
+    it("should handle add_anchor tool", async () => {
+      await toolsCallHandler({
+        method: "tools/call",
+        params: {
+          name: "start_frame",
+          arguments: { name: "Test Frame", type: "task" }
+        }
+      });
+      const result = await toolsCallHandler({
+        method: "tools/call",
+        params: {
+          name: "add_anchor",
+          arguments: {
+            type: "FACT",
+            text: "Important fact",
+            priority: 9
+          }
+        }
+      });
+      expect(result.content[0].text).toContain("Added FACT");
+      expect(result.content[0].text).toContain("Important fact");
+      expect(result.content[0].text).toContain("Anchor ID:");
+    });
+    it("should handle get_hot_stack tool", async () => {
+      await toolsCallHandler({
+        method: "tools/call",
+        params: {
+          name: "start_frame",
+          arguments: { name: "Root Frame", type: "task" }
+        }
+      });
+      await toolsCallHandler({
+        method: "tools/call",
+        params: {
+          name: "start_frame",
+          arguments: { name: "Child Frame", type: "subtask" }
+        }
+      });
+      const result = await toolsCallHandler({
+        method: "tools/call",
+        params: {
+          name: "get_hot_stack",
+          arguments: { maxEvents: 10 }
+        }
+      });
+      expect(result.content[0].text).toContain("Active Call Stack");
+      expect(result.content[0].text).toContain("Root Frame");
+      expect(result.content[0].text).toContain("Child Frame");
+      expect(result.content[0].text).toContain("Total stack depth");
+    });
+    it("should handle get_hot_stack with no active frames", async () => {
+      const result = await toolsCallHandler({
+        method: "tools/call",
+        params: {
+          name: "get_hot_stack",
+          arguments: {}
+        }
+      });
+      expect(result.content[0].text).toContain("No active frames");
+    });
+  });
+  describe("Tool Execution - Task Management", () => {
+    let toolsCallHandler;
+    beforeEach(async () => {
+      mockServer.setRequestHandler.mockClear();
+      mcpServer = new LocalStackMemoryMCP();
+      toolsCallHandler = mockServer.setRequestHandler.mock.calls[1][1];
+      await toolsCallHandler({
+        method: "tools/call",
+        params: {
+          name: "start_frame",
+          arguments: { name: "Task Frame", type: "task" }
+        }
+      });
+    });
+    it("should handle create_task tool", async () => {
+      const result = await toolsCallHandler({
+        method: "tools/call",
+        params: {
+          name: "create_task",
+          arguments: {
+            title: "Test Task",
+            description: "A test task",
+            priority: "high",
+            estimatedEffort: 120,
+            tags: ["test", "urgent"]
+          }
+        }
+      });
+      expect(result.content[0].text).toContain("Created task");
+      expect(result.content[0].text).toContain("Test Task");
+      expect(result.content[0].text).toContain("ID:");
+      expect(result.content[0].text).toContain("tasks.jsonl");
+    });
+    it("should handle create_task without active frame", async () => {
+      await new Promise((resolve) => setTimeout(resolve, 10));
+      try {
+        await toolsCallHandler({
+          method: "tools/call",
+          params: {
+            name: "close_frame",
+            arguments: { result: "closed" }
+          }
+        });
+      } catch {
+      }
+      mockServer.setRequestHandler.mockClear();
+      mcpServer = new LocalStackMemoryMCP();
+      const freshToolsHandler = mockServer.setRequestHandler.mock.calls[1][1];
+      const result = await freshToolsHandler({
+        method: "tools/call",
+        params: {
+          name: "create_task",
+          arguments: { title: "No Frame Task" }
+        }
+      });
+      expect(result.content[0].text).toContain("No active frame");
+    });
+    it("should handle update_task_status tool", async () => {
+      const createResult = await toolsCallHandler({
+        method: "tools/call",
+        params: {
+          name: "create_task",
+          arguments: { title: "Update Test Task" }
+        }
+      });
+      const taskIdMatch = createResult.content[0].text.match(
+        /ID: (tsk-[a-f0-9]{8})/
+      );
+      expect(taskIdMatch).toBeTruthy();
+      const taskId = taskIdMatch[1];
+      const result = await toolsCallHandler({
+        method: "tools/call",
+        params: {
+          name: "update_task_status",
+          arguments: {
+            taskId,
+            status: "in_progress",
+            reason: "Starting work"
+          }
+        }
+      });
+      expect(result.content[0].text).toContain("Updated task");
+      expect(result.content[0].text).toContain("in_progress");
+      expect(result.content[0].text).toContain("Starting work");
+    });
+    it("should handle update_task_status with invalid task", async () => {
+      const result = await toolsCallHandler({
+        method: "tools/call",
+        params: {
+          name: "update_task_status",
+          arguments: {
+            taskId: "invalid-task-id",
+            status: "completed"
+          }
+        }
+      });
+      expect(result.content[0].text).toContain("Failed to update task");
+    });
+    it("should handle get_active_tasks tool", async () => {
+      await toolsCallHandler({
+        method: "tools/call",
+        params: {
+          name: "create_task",
+          arguments: { title: "Active Task 1", priority: "high" }
+        }
+      });
+      await toolsCallHandler({
+        method: "tools/call",
+        params: {
+          name: "create_task",
+          arguments: { title: "Active Task 2", priority: "low" }
+        }
+      });
+      const result = await toolsCallHandler({
+        method: "tools/call",
+        params: {
+          name: "get_active_tasks",
+          arguments: {}
+        }
+      });
+      expect(result.content[0].text).toContain("Tasks");
+      expect(result.content[0].text).toContain("Active Task 1");
+      expect(result.content[0].text).toContain("Active Task 2");
+    });
+    it("should handle get_active_tasks with no tasks", async () => {
+      const result = await toolsCallHandler({
+        method: "tools/call",
+        params: {
+          name: "get_active_tasks",
+          arguments: {}
+        }
+      });
+      expect(result.content[0].text).toContain("No active tasks");
+    });
+    it("should handle get_task_metrics tool", async () => {
+      const taskId1 = await toolsCallHandler({
+        method: "tools/call",
+        params: {
+          name: "create_task",
+          arguments: { title: "Metrics Task 1" }
+        }
+      });
+      const result = await toolsCallHandler({
+        method: "tools/call",
+        params: {
+          name: "get_task_metrics",
+          arguments: {}
+        }
+      });
+      expect(result.content[0].text).toContain("Task Metrics");
+      expect(result.content[0].text).toContain("Total Tasks");
+      expect(result.content[0].text).toContain("Completion Rate");
+      expect(result.content[0].text).toContain("By Status");
+      expect(result.content[0].text).toContain("By Priority");
+    });
+    it("should handle add_task_dependency tool", async () => {
+      const task1Result = await toolsCallHandler({
+        method: "tools/call",
+        params: {
+          name: "create_task",
+          arguments: { title: "Dependency Task" }
+        }
+      });
+      const task2Result = await toolsCallHandler({
+        method: "tools/call",
+        params: {
+          name: "create_task",
+          arguments: { title: "Dependent Task" }
+        }
+      });
+      const task1Id = task1Result.content[0].text.match(
+        /ID: (tsk-[a-f0-9]{8})/
+      )[1];
+      const task2Id = task2Result.content[0].text.match(
+        /ID: (tsk-[a-f0-9]{8})/
+      )[1];
+      const result = await toolsCallHandler({
+        method: "tools/call",
+        params: {
+          name: "add_task_dependency",
+          arguments: {
+            taskId: task2Id,
+            dependsOnId: task1Id
+          }
+        }
+      });
+      expect(result.content[0].text).toContain("Added dependency");
+      expect(result.content[0].text).toContain(task2Id);
+      expect(result.content[0].text).toContain(task1Id);
+    });
+  });
+  describe("Tool Execution - Linear Integration", () => {
+    let toolsCallHandler;
+    beforeEach(() => {
+      mcpServer = new LocalStackMemoryMCP();
+      toolsCallHandler = mockServer.setRequestHandler.mock.calls[1][1];
+    });
+    it("should handle linear_status tool when not configured", async () => {
+      const result = await toolsCallHandler({
+        method: "tools/call",
+        params: {
+          name: "linear_status",
+          arguments: {}
+        }
+      });
+      expect(result.content[0].text).toContain(
+        "Linear integration not configured"
+      );
+      expect(result.content[0].text).toContain("stackmemory linear setup");
+    });
+    it("should handle linear_sync tool when not authenticated", async () => {
+      const result = await toolsCallHandler({
+        method: "tools/call",
+        params: {
+          name: "linear_sync",
+          arguments: { direction: "bidirectional" }
+        }
+      });
+      expect(result.content[0].text).toContain("Linear not authenticated");
+    });
+    it("should handle linear_update_task when not authenticated", async () => {
+      const result = await toolsCallHandler({
+        method: "tools/call",
+        params: {
+          name: "linear_update_task",
+          arguments: { issueId: "STA-123", status: "done" }
+        }
+      });
+      expect(result.content[0].text).toContain("Linear not authenticated");
+    });
+    it("should handle linear_get_tasks when not authenticated", async () => {
+      const result = await toolsCallHandler({
+        method: "tools/call",
+        params: {
+          name: "linear_get_tasks",
+          arguments: { status: "todo", limit: 10 }
+        }
+      });
+      expect(result.content[0].text).toContain("Linear not authenticated");
+    });
+    it("should handle linear integration errors gracefully", async () => {
+      const result = await toolsCallHandler({
+        method: "tools/call",
+        params: {
+          name: "linear_status",
+          arguments: {}
+        }
+      });
+      expect(result.content[0].text).toContain("Linear");
+    });
+  });
+  describe("Error Handling", () => {
+    let toolsCallHandler;
+    beforeEach(() => {
+      mcpServer = new LocalStackMemoryMCP();
+      toolsCallHandler = mockServer.setRequestHandler.mock.calls[1][1];
+    });
+    it("should handle unknown tool calls", async () => {
+      await expect(
+        toolsCallHandler({
+          method: "tools/call",
+          params: {
+            name: "unknown_tool",
+            arguments: {}
+          }
+        })
+      ).rejects.toThrow("Unknown tool: unknown_tool");
+    });
+    it("should handle malformed tool arguments gracefully", async () => {
+      await toolsCallHandler({
+        method: "tools/call",
+        params: {
+          name: "start_frame",
+          arguments: { name: "Test Frame", type: "task" }
+        }
+      });
+      const result = await toolsCallHandler({
+        method: "tools/call",
+        params: {
+          name: "update_task_status",
+          arguments: { taskId: "non-existent-task", status: "in_progress" }
+        }
+      });
+      expect(result).toBeDefined();
+    });
+    it("should maintain error context in responses", async () => {
+      await toolsCallHandler({
+        method: "tools/call",
+        params: {
+          name: "start_frame",
+          arguments: { name: "Test Frame", type: "task" }
+        }
+      });
+      const result = await toolsCallHandler({
+        method: "tools/call",
+        params: {
+          name: "add_anchor",
+          arguments: {
+            type: "FACT",
+            text: "Test fact"
+          }
+        }
+      });
+      expect(result).toBeDefined();
+      expect(result.content[0].text).toContain("Added");
+    });
+  });
+  describe("Project Detection and Context Loading", () => {
+    it("should detect git repository information", () => {
+      mcpServer = new LocalStackMemoryMCP();
+      expect(mcpServer).toBeDefined();
+    });
+    it("should handle missing git repository gracefully", () => {
+      expect(() => {
+        mcpServer = new LocalStackMemoryMCP();
+      }).not.toThrow();
+    });
+    it("should load README.md if present", () => {
+      const readmePath = join(tempDir, "README.md");
+      writeFileSync(
+        readmePath,
+        "# Test Project\n\nThis is a test project for MCP server testing."
+      );
+      mcpServer = new LocalStackMemoryMCP();
+      expect(existsSync(readmePath)).toBe(true);
+    });
+    it("should handle missing README.md gracefully", () => {
+      const readmePath = join(tempDir, "README.md");
+      if (existsSync(readmePath)) {
+        rmSync(readmePath);
+      }
+      expect(() => {
+        mcpServer = new LocalStackMemoryMCP();
+      }).not.toThrow();
+    });
+  });
+  describe("Database Schema and Persistence", () => {
+    beforeEach(() => {
+      mcpServer = new LocalStackMemoryMCP();
+    });
+    it("should create required database tables", () => {
+      const dbPath = join(tempDir, ".stackmemory", "context.db");
+      const db = new Database(dbPath);
+      const tables = db.prepare(
+        `
+        SELECT name FROM sqlite_master 
+        WHERE type='table' AND name IN ('contexts', 'frames', 'attention_log')
+      `
+      ).all();
+      expect(tables).toHaveLength(3);
+      db.close();
+    });
+    it("should handle database initialization errors gracefully", () => {
+      expect(() => {
+        mcpServer = new LocalStackMemoryMCP();
+      }).not.toThrow();
+    });
+  });
+  describe("Server Lifecycle", () => {
+    it("should start server successfully", async () => {
+      mcpServer = new LocalStackMemoryMCP();
+      const mockTransport = { connect: vi.fn() };
+      vi.doMock("@modelcontextprotocol/sdk/server/stdio.js", () => ({
+        StdioServerTransport: vi.fn(() => mockTransport)
+      }));
+      mockServer.connect.mockResolvedValue(void 0);
+      await expect(mcpServer.start()).resolves.not.toThrow();
+      expect(mockServer.connect).toHaveBeenCalled();
+    });
+    it("should handle server start errors", async () => {
+      mcpServer = new LocalStackMemoryMCP();
+      mockServer.connect.mockRejectedValue(new Error("Connection failed"));
+      await expect(mcpServer.start()).rejects.toThrow("Connection failed");
+    });
+  });
+  describe("Integration with Framework Components", () => {
+    let toolsCallHandler;
+    beforeEach(() => {
+      mockServer.setRequestHandler.mockClear();
+      mcpServer = new LocalStackMemoryMCP();
+      toolsCallHandler = mockServer.setRequestHandler.mock.calls[1][1];
+    });
+    it("should integrate frame manager operations", async () => {
+      const startResult = await toolsCallHandler({
+        method: "tools/call",
+        params: {
+          name: "start_frame",
+          arguments: { name: "Integration Test", type: "task" }
+        }
+      });
+      expect(startResult.content[0].text).toContain("Started");
+      const hotStackResult = await toolsCallHandler({
+        method: "tools/call",
+        params: {
+          name: "get_hot_stack",
+          arguments: {}
+        }
+      });
+      expect(hotStackResult.content[0].text).toContain("Integration Test");
+      const closeResult = await toolsCallHandler({
+        method: "tools/call",
+        params: {
+          name: "close_frame",
+          arguments: { result: "Integration complete" }
+        }
+      });
+      expect(closeResult.content[0].text).toContain("Closed frame");
+    });
+    it("should integrate task store operations", async () => {
+      await toolsCallHandler({
+        method: "tools/call",
+        params: {
+          name: "start_frame",
+          arguments: { name: "Task Integration", type: "task" }
+        }
+      });
+      const createResult = await toolsCallHandler({
+        method: "tools/call",
+        params: {
+          name: "create_task",
+          arguments: { title: "Integration Task" }
+        }
+      });
+      expect(createResult.content[0].text).toContain("Created task");
+      const activeResult = await toolsCallHandler({
+        method: "tools/call",
+        params: {
+          name: "get_active_tasks",
+          arguments: {}
+        }
+      });
+      expect(activeResult.content[0].text).toContain("Integration Task");
+    });
+  });
+});
+//# sourceMappingURL=server.test.js.map