@cliangdev/flux-plugin 0.2.0 → 0.3.0

package/src/server/tools/__tests__/mcp-interface.test.ts

@@ -0,0 +1,479 @@
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+// Set up test environment BEFORE any imports
+const TEST_DIR = `/tmp/flux-test-mcp-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+const FLUX_DIR = join(TEST_DIR, ".flux");
+process.env.FLUX_PROJECT_ROOT = TEST_DIR;
+
+import { z } from "zod";
+import { config } from "../../config.js";
+import { closeDb, initDb } from "../../db/index.js";
+import {
+  createError,
+  createProjectNotInitializedError,
+  registerTools,
+  type ToolDefinition,
+} from "../index.js";
+
+describe("MCP Interface", () => {
+  beforeEach(() => {
+    closeDb();
+    config.clearCache();
+    process.env.FLUX_PROJECT_ROOT = TEST_DIR;
+
+    mkdirSync(FLUX_DIR, { recursive: true });
+    writeFileSync(
+      join(FLUX_DIR, "project.json"),
+      JSON.stringify({ name: "test-project", ref_prefix: "TEST" }),
+    );
+    initDb();
+  });
+
+  afterEach(() => {
+    closeDb();
+    config.clearCache();
+    if (existsSync(TEST_DIR)) {
+      rmSync(TEST_DIR, { recursive: true, force: true });
+    }
+  });
+
+  describe("createError", () => {
+    test("creates error object with message and code", () => {
+      const error = createError("Test error", "TEST_ERROR");
+      expect(error).toEqual({
+        error: true,
+        message: "Test error",
+        code: "TEST_ERROR",
+      });
+    });
+  });
+
+  describe("createProjectNotInitializedError", () => {
+    test("creates error with setup instructions", () => {
+      const error = createProjectNotInitializedError("/test/cwd", "/test/root");
+
+      expect(error.error).toBe(true);
+      expect(error.code).toBe("PROJECT_NOT_INITIALIZED");
+      expect(error.message).toContain("/test/cwd");
+      expect(error.message).toContain("/test/root");
+      expect(error.setup.instructions).toBeDefined();
+      expect(error.setup.options).toHaveLength(2);
+    });
+
+    test("includes command option for interactive setup", () => {
+      const error = createProjectNotInitializedError("/cwd", "/root");
+      const commandOption = error.setup.options.find(
+        (o) => o.method === "command",
+      );
+
+      expect(commandOption).toBeDefined();
+      expect(commandOption?.name).toBe("/flux");
+      expect(commandOption?.description).toContain("Interactive");
+    });
+
+    test("includes tool option with required params", () => {
+      const error = createProjectNotInitializedError("/cwd", "/root");
+      const toolOption = error.setup.options.find((o) => o.method === "tool");
+
+      expect(toolOption).toBeDefined();
+      expect(toolOption?.name).toBe("init_project");
+      expect(toolOption?.params).toBeDefined();
+      expect(toolOption?.params?.name).toBeDefined();
+      expect(toolOption?.params?.vision).toBeDefined();
+      expect(toolOption?.params?.adapter).toBeDefined();
+    });
+  });
+
+  describe("registerTools", () => {
+    test("sets up list tools handler", () => {
+      const handlers: Record<string, Function> = {};
+      const mockServer = {
+        setRequestHandler: mock((schema: any, handler: Function) => {
+          handlers[schema.method || "unknown"] = handler;
+        }),
+      };
+
+      const testTool: ToolDefinition = {
+        name: "test_tool",
+        description: "A test tool",
+        inputSchema: z.object({ input: z.string() }),
+        handler: async () => ({ success: true }),
+      };
+
+      registerTools(mockServer as any, [testTool]);
+
+      // Should have registered two handlers
+      expect(mockServer.setRequestHandler).toHaveBeenCalledTimes(2);
+    });
+
+    test("list tools returns tool definitions with JSON schema", async () => {
+      const handlers: Record<string, Function> = {};
+      const mockServer = {
+        setRequestHandler: mock((schema: any, handler: Function) => {
+          // Store handler by a key we can identify
+          if (schema.shape?.method?.value === "tools/list") {
+            handlers.list = handler;
+          } else if (schema.shape?.method?.value === "tools/call") {
+            handlers.call = handler;
+          }
+        }),
+      };
+
+      const testTool: ToolDefinition = {
+        name: "test_tool",
+        description: "A test tool",
+        inputSchema: z.object({
+          input: z.string(),
+          optional: z.number().optional(),
+        }),
+        handler: async () => ({ success: true }),
+      };
+
+      registerTools(mockServer as any, [testTool]);
+
+      // Call the list handler
+      const listHandler = handlers.list;
+      expect(listHandler).toBeDefined();
+
+      const result = await listHandler();
+      expect(result.tools).toBeDefined();
+      expect(result.tools.length).toBe(1);
+      expect(result.tools[0].name).toBe("test_tool");
+      expect(result.tools[0].description).toBe("A test tool");
+      expect(result.tools[0].inputSchema).toBeDefined();
+      // JSON schema should have properties
+      expect(result.tools[0].inputSchema.type).toBe("object");
+      expect(result.tools[0].inputSchema.properties).toBeDefined();
+    });
+
+    test("call tool executes handler with arguments", async () => {
+      const handlers: Record<string, Function> = {};
+      const mockServer = {
+        setRequestHandler: mock((schema: any, handler: Function) => {
+          if (schema.shape?.method?.value === "tools/list") {
+            handlers.list = handler;
+          } else if (schema.shape?.method?.value === "tools/call") {
+            handlers.call = handler;
+          }
+        }),
+      };
+
+      const handlerMock = mock(async (input: any) => ({
+        received: input.input,
+      }));
+
+      const testTool: ToolDefinition = {
+        name: "test_tool",
+        description: "A test tool",
+        inputSchema: z.object({ input: z.string() }),
+        handler: handlerMock,
+      };
+
+      registerTools(mockServer as any, [testTool]);
+
+      const callHandler = handlers.call;
+      expect(callHandler).toBeDefined();
+
+      const result = await callHandler({
+        params: {
+          name: "test_tool",
+          arguments: { input: "hello" },
+        },
+      });
+
+      expect(handlerMock).toHaveBeenCalledWith({ input: "hello" });
+      expect(result.content).toBeDefined();
+      expect(result.content[0].type).toBe("text");
+      const parsedResult = JSON.parse(result.content[0].text);
+      expect(parsedResult.received).toBe("hello");
+    });
+
+    test("call unknown tool returns error", async () => {
+      const handlers: Record<string, Function> = {};
+      const mockServer = {
+        setRequestHandler: mock((schema: any, handler: Function) => {
+          if (schema.shape?.method?.value === "tools/list") {
+            handlers.list = handler;
+          } else if (schema.shape?.method?.value === "tools/call") {
+            handlers.call = handler;
+          }
+        }),
+      };
+
+      registerTools(mockServer as any, []);
+
+      const callHandler = handlers.call;
+      const result = await callHandler({
+        params: {
+          name: "nonexistent_tool",
+          arguments: {},
+        },
+      });
+
+      expect(result.isError).toBe(true);
+      const parsedError = JSON.parse(result.content[0].text);
+      expect(parsedError.error).toBe(true);
+      expect(parsedError.code).toBe("UNKNOWN_TOOL");
+    });
+
+    test("call tool with handler error returns error response", async () => {
+      const handlers: Record<string, Function> = {};
+      const mockServer = {
+        setRequestHandler: mock((schema: any, handler: Function) => {
+          if (schema.shape?.method?.value === "tools/list") {
+            handlers.list = handler;
+          } else if (schema.shape?.method?.value === "tools/call") {
+            handlers.call = handler;
+          }
+        }),
+      };
+
+      const testTool: ToolDefinition = {
+        name: "failing_tool",
+        description: "A tool that fails",
+        inputSchema: z.object({}),
+        handler: async () => {
+          throw new Error("Something went wrong");
+        },
+      };
+
+      registerTools(mockServer as any, [testTool]);
+
+      const callHandler = handlers.call;
+      const result = await callHandler({
+        params: {
+          name: "failing_tool",
+          arguments: {},
+        },
+      });
+
+      expect(result.isError).toBe(true);
+      const parsedError = JSON.parse(result.content[0].text);
+      expect(parsedError.error).toBe(true);
+      expect(parsedError.code).toBe("TOOL_ERROR");
+      expect(parsedError.message).toBe("Something went wrong");
+    });
+
+    test("call tool with non-Error throw returns string error", async () => {
+      const handlers: Record<string, Function> = {};
+      const mockServer = {
+        setRequestHandler: mock((schema: any, handler: Function) => {
+          if (schema.shape?.method?.value === "tools/list") {
+            handlers.list = handler;
+          } else if (schema.shape?.method?.value === "tools/call") {
+            handlers.call = handler;
+          }
+        }),
+      };
+
+      const testTool: ToolDefinition = {
+        name: "string_throw_tool",
+        description: "A tool that throws a string",
+        inputSchema: z.object({}),
+        handler: async () => {
+          throw "String error message";
+        },
+      };
+
+      registerTools(mockServer as any, [testTool]);
+
+      const callHandler = handlers.call;
+      const result = await callHandler({
+        params: {
+          name: "string_throw_tool",
+          arguments: {},
+        },
+      });
+
+      expect(result.isError).toBe(true);
+      const parsedError = JSON.parse(result.content[0].text);
+      expect(parsedError.message).toBe("String error message");
+    });
+  });
+});
+
+describe("Tool JSON Schema Generation", () => {
+  test("generates correct JSON schema for complex input", () => {
+    const complexSchema = z.object({
+      required_string: z.string().min(1),
+      optional_number: z.number().optional(),
+      enum_field: z.enum(["A", "B", "C"]),
+      array_field: z.array(z.string()).optional(),
+    });
+
+    const jsonSchema = z.toJSONSchema(complexSchema);
+
+    expect(jsonSchema.type).toBe("object");
+    expect(jsonSchema.properties).toBeDefined();
+    expect(jsonSchema.required).toContain("required_string");
+    expect(jsonSchema.required).toContain("enum_field");
+    expect(jsonSchema.required).not.toContain("optional_number");
+  });
+});
+
+describe("Project Validation", () => {
+  const NO_PROJECT_DIR = `/tmp/flux-test-no-project-${Date.now()}`;
+
+  beforeEach(() => {
+    config.clearCache();
+    process.env.FLUX_PROJECT_ROOT = NO_PROJECT_DIR;
+    mkdirSync(NO_PROJECT_DIR, { recursive: true });
+  });
+
+  afterEach(() => {
+    config.clearCache();
+    if (existsSync(NO_PROJECT_DIR)) {
+      rmSync(NO_PROJECT_DIR, { recursive: true, force: true });
+    }
+  });
+
+  test("returns PROJECT_NOT_INITIALIZED with setup instructions for tools requiring project", async () => {
+    const handlers: Record<string, Function> = {};
+    const mockServer = {
+      setRequestHandler: mock((schema: any, handler: Function) => {
+        if (schema.shape?.method?.value === "tools/call") {
+          handlers.call = handler;
+        }
+      }),
+    };
+
+    const testTool: ToolDefinition = {
+      name: "create_prd",
+      description: "Creates a PRD",
+      inputSchema: z.object({ title: z.string() }),
+      handler: async () => ({ success: true }),
+    };
+
+    registerTools(mockServer as any, [testTool]);
+
+    const callHandler = handlers.call;
+    const result = await callHandler({
+      params: {
+        name: "create_prd",
+        arguments: { title: "Test" },
+      },
+    });
+
+    expect(result.isError).toBe(true);
+    const parsedError = JSON.parse(result.content[0].text);
+    expect(parsedError.error).toBe(true);
+    expect(parsedError.code).toBe("PROJECT_NOT_INITIALIZED");
+    expect(parsedError.setup).toBeDefined();
+    expect(parsedError.setup.instructions).toBeDefined();
+    expect(parsedError.setup.options).toBeDefined();
+    expect(parsedError.setup.options.length).toBe(2);
+  });
+
+  test("allows init_project without existing project", async () => {
+    const handlers: Record<string, Function> = {};
+    const mockServer = {
+      setRequestHandler: mock((schema: any, handler: Function) => {
+        if (schema.shape?.method?.value === "tools/call") {
+          handlers.call = handler;
+        }
+      }),
+    };
+
+    const handlerMock = mock(async () => ({ success: true }));
+
+    const testTool: ToolDefinition = {
+      name: "init_project",
+      description: "Initialize project",
+      inputSchema: z.object({ name: z.string() }),
+      handler: handlerMock,
+    };
+
+    registerTools(mockServer as any, [testTool]);
+
+    const callHandler = handlers.call;
+    const result = await callHandler({
+      params: {
+        name: "init_project",
+        arguments: { name: "test" },
+      },
+    });
+
+    expect(result.isError).toBeUndefined();
+    expect(handlerMock).toHaveBeenCalled();
+  });
+
+  test("allows get_version without existing project", async () => {
+    const handlers: Record<string, Function> = {};
+    const mockServer = {
+      setRequestHandler: mock((schema: any, handler: Function) => {
+        if (schema.shape?.method?.value === "tools/call") {
+          handlers.call = handler;
+        }
+      }),
+    };
+
+    const handlerMock = mock(async () => ({ version: "1.0.0" }));
+
+    const testTool: ToolDefinition = {
+      name: "get_version",
+      description: "Get version",
+      inputSchema: z.object({}),
+      handler: handlerMock,
+    };
+
+    registerTools(mockServer as any, [testTool]);
+
+    const callHandler = handlers.call;
+    const result = await callHandler({
+      params: {
+        name: "get_version",
+        arguments: {},
+      },
+    });
+
+    expect(result.isError).toBeUndefined();
+    expect(handlerMock).toHaveBeenCalled();
+  });
+
+  test("setup options have correct structure", async () => {
+    const handlers: Record<string, Function> = {};
+    const mockServer = {
+      setRequestHandler: mock((schema: any, handler: Function) => {
+        if (schema.shape?.method?.value === "tools/call") {
+          handlers.call = handler;
+        }
+      }),
+    };
+
+    const testTool: ToolDefinition = {
+      name: "query_entities",
+      description: "Query entities",
+      inputSchema: z.object({ type: z.string() }),
+      handler: async () => ({ items: [] }),
+    };
+
+    registerTools(mockServer as any, [testTool]);
+
+    const callHandler = handlers.call;
+    const result = await callHandler({
+      params: {
+        name: "query_entities",
+        arguments: { type: "prd" },
+      },
+    });
+
+    expect(result.isError).toBe(true);
+    const parsedError = JSON.parse(result.content[0].text);
+
+    const commandOption = parsedError.setup.options.find(
+      (o: any) => o.method === "command",
+    );
+    expect(commandOption.name).toBe("/flux");
+    expect(commandOption.description).toBeTruthy();
+
+    const toolOption = parsedError.setup.options.find(
+      (o: any) => o.method === "tool",
+    );
+    expect(toolOption.name).toBe("init_project");
+    expect(toolOption.params.name).toBeTruthy();
+    expect(toolOption.params.vision).toBeTruthy();
+    expect(toolOption.params.adapter).toBeTruthy();
+  });
+});