@stackmemoryai/stackmemory 0.3.1 → 0.3.3

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

@@ -1,798 +0,0 @@
-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