wraptc 1.0.3 → 1.0.4

package/src/mcp/__tests__/server.test.ts

@@ -0,0 +1,295 @@
+import { beforeEach, describe, expect, mock, spyOn, test } from "bun:test";
+import type { CodingRequest } from "../../core/index.js";
+import { WrapTerminalCoderMCPServer } from "../server.js";
+
+// Mock WrapTerminalCoder
+const mockRoute = mock(async (request: CodingRequest) => ({
+  provider: "gemini",
+  text: "Generated response",
+  usage: { inputTokens: 10, outputTokens: 20 },
+  meta: { elapsedMs: 1500 },
+}));
+
+const mockGetProviderInfo = mock(async () => [
+  {
+    id: "gemini",
+    displayName: "Gemini CLI",
+    requestsToday: 5,
+    outOfCreditsUntil: null,
+    available: true,
+  },
+  {
+    id: "codex",
+    displayName: "Codex CLI",
+    requestsToday: 2,
+    outOfCreditsUntil: new Date(Date.now() + 3600000), // 1 hour from now
+    available: true,
+  },
+]);
+
+const mockWrapTerminalCoder = {
+  route: mockRoute,
+  getProviderInfo: mockGetProviderInfo,
+};
+
+mock.module("../../core/index.js", () => ({
+  WrapTerminalCoder: {
+    create: mock(async () => mockWrapTerminalCoder),
+  },
+  CodingRequestSchema: {
+    safeParse: mock((data: any) => ({
+      success: true,
+      data,
+    })),
+  },
+}));
+
+// Mock MCP SDK
+const mockSetRequestHandler = mock();
+const mockConnect = mock(async () => {});
+
+const mockServer = {
+  setRequestHandler: mockSetRequestHandler,
+  connect: mockConnect,
+};
+
+mock.module("@modelcontextprotocol/sdk/server/index.js", () => ({
+  Server: mock(() => mockServer),
+}));
+
+mock.module("@modelcontextprotocol/sdk/server/stdio.js", () => ({
+  StdioServerTransport: mock(() => ({})),
+}));
+
+mock.module("@modelcontextprotocol/sdk/types.js", () => ({
+  CallToolRequestSchema: "call-tool-schema",
+  ListToolsRequestSchema: "list-tools-schema",
+}));
+
+describe("WrapTerminalCoderMCPServer", () => {
+  let server: WrapTerminalCoderMCPServer;
+
+  beforeEach(() => {
+    // Reset mocks
+    mockSetRequestHandler.mockClear();
+    mockConnect.mockClear();
+    mockRoute.mockClear();
+    mockGetProviderInfo.mockClear();
+
+    server = new WrapTerminalCoderMCPServer();
+  });
+
+  describe("constructor", () => {
+    test("should create server with request handlers", () => {
+      expect(mockSetRequestHandler).toHaveBeenCalledTimes(2);
+    });
+  });
+
+  describe("tool handlers", () => {
+    describe("ListTools", () => {
+      test("should return list of available tools", async () => {
+        const listToolsHandler = mockSetRequestHandler.mock.calls.find(
+          (call: any[]) => call[0] === "list-tools-schema",
+        )?.[1];
+
+        expect(listToolsHandler).toBeDefined();
+        const result = await listToolsHandler?.();
+
+        expect(result.tools).toHaveLength(3);
+        expect(result.tools.map((t: any) => t.name)).toEqual([
+          "run_coding_task",
+          "get_providers",
+          "dry_run",
+        ]);
+      });
+
+      test("should include tool schemas with correct properties", async () => {
+        const listToolsHandler = mockSetRequestHandler.mock.calls.find(
+          (call: any[]) => call[0] === "list-tools-schema",
+        )?.[1];
+
+        const result = await listToolsHandler?.();
+
+        const runCodingTask = result.tools.find((t: any) => t.name === "run_coding_task");
+        expect(runCodingTask.inputSchema.properties.prompt.type).toBe("string");
+        expect(runCodingTask.inputSchema.properties.mode.enum).toEqual([
+          "generate",
+          "edit",
+          "explain",
+          "test",
+        ]);
+        expect(runCodingTask.inputSchema.required).toEqual(["prompt"]);
+      });
+    });
+
+    describe("CallTool - run_coding_task", () => {
+      let callToolHandler: Function;
+
+      beforeEach(() => {
+        const handler = mockSetRequestHandler.mock.calls.find(
+          (call: any[]) => call[0] === "call-tool-schema",
+        )?.[1];
+        callToolHandler = handler!;
+      });
+
+      test("should execute coding task successfully", async () => {
+        const request = {
+          params: {
+            name: "run_coding_task",
+            arguments: {
+              prompt: "Write a function to calculate fibonacci",
+              mode: "generate",
+              language: "typescript",
+              files: ["utils.ts"],
+              provider: "gemini",
+            },
+          },
+        };
+
+        const result = await callToolHandler(request);
+
+        expect(result.content[0].type).toBe("text");
+        const parsed = JSON.parse(result.content[0].text);
+        expect(parsed).toEqual({
+          provider: "gemini",
+          text: "Generated response",
+          usage: { inputTokens: 10, outputTokens: 20 },
+          meta: { elapsedMs: 1500 },
+        });
+      });
+
+      test("should handle errors gracefully", async () => {
+        // Mock route to throw
+        mockRoute.mockImplementationOnce(async () => {
+          throw new Error("Provider failed");
+        });
+
+        const request = {
+          params: {
+            name: "run_coding_task",
+            arguments: {
+              prompt: "Test prompt",
+            },
+          },
+        };
+
+        const result = await callToolHandler(request);
+
+        expect(result.isError).toBe(true);
+        expect(result.content[0].text).toContain("Error:");
+      });
+    });
+
+    describe("CallTool - get_providers", () => {
+      let callToolHandler: Function;
+
+      beforeEach(() => {
+        const handler = mockSetRequestHandler.mock.calls.find(
+          (call: any[]) => call[0] === "call-tool-schema",
+        )?.[1];
+        callToolHandler = handler!;
+      });
+
+      test("should return provider information", async () => {
+        const request = {
+          params: {
+            name: "get_providers",
+            arguments: {},
+          },
+        };
+
+        const result = await callToolHandler(request);
+
+        expect(result.content[0].type).toBe("text");
+        const parsed = JSON.parse(result.content[0].text);
+        expect(parsed).toHaveLength(2);
+        expect(parsed[0].id).toBe("gemini");
+      });
+    });
+
+    describe("CallTool - dry_run", () => {
+      let callToolHandler: Function;
+
+      beforeEach(() => {
+        const handler = mockSetRequestHandler.mock.calls.find(
+          (call: any[]) => call[0] === "call-tool-schema",
+        )?.[1];
+        callToolHandler = handler!;
+      });
+
+      test("should return available providers for request", async () => {
+        const request = {
+          params: {
+            name: "dry_run",
+            arguments: {
+              prompt: "Test prompt",
+              mode: "generate",
+            },
+          },
+        };
+
+        const result = await callToolHandler(request);
+
+        expect(result.content[0].type).toBe("text");
+        const parsed = JSON.parse(result.content[0].text);
+
+        expect(parsed.request.prompt).toBe("Test prompt");
+        expect(parsed.request.mode).toBe("generate");
+        expect(parsed.availableProviders).toBeDefined();
+      });
+
+      test("should filter out providers that are out of credits", async () => {
+        const request = {
+          params: {
+            name: "dry_run",
+            arguments: {
+              prompt: "Test prompt",
+            },
+          },
+        };
+
+        const result = await callToolHandler(request);
+
+        const parsed = JSON.parse(result.content[0].text);
+        // Should only include gemini since codex is out of credits
+        expect(parsed.availableProviders).toHaveLength(1);
+        expect(parsed.availableProviders[0].id).toBe("gemini");
+      });
+    });
+
+    describe("CallTool - unknown tool", () => {
+      let callToolHandler: Function;
+
+      beforeEach(() => {
+        const handler = mockSetRequestHandler.mock.calls.find(
+          (call: any[]) => call[0] === "call-tool-schema",
+        )?.[1];
+        callToolHandler = handler!;
+      });
+
+      test("should return error for unknown tool", async () => {
+        const request = {
+          params: {
+            name: "unknown_tool",
+            arguments: {},
+          },
+        };
+
+        const result = await callToolHandler(request);
+
+        expect(result.isError).toBe(true);
+        expect(result.content[0].text).toBe("Unknown tool: unknown_tool");
+      });
+    });
+  });
+
+  describe("run", () => {
+    test("should connect server to transport", async () => {
+      spyOn(console, "error").mockImplementation(() => {});
+
+      await server.run();
+
+      expect(mockConnect).toHaveBeenCalledTimes(1);
+    });
+  });
+});

package/src/mcp/server.ts

@@ -0,0 +1,284 @@
+#!/usr/bin/env bun
+
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import { z } from "zod";
+import { CodingRequestSchema, WrapTerminalCoder } from "../core/index.js";
+import type { CodingRequest } from "../core/index.js";
+
+// Tool schemas
+const RunCodingTaskSchema = z.object({
+  prompt: z.string().min(1),
+  mode: z.enum(["generate", "edit", "explain", "test"]).default("generate"),
+  language: z.string().optional(),
+  files: z.array(z.string()).optional(),
+  provider: z.string().optional(),
+});
+
+const GetProvidersSchema = z.object({});
+
+const DryRunSchema = z.object({
+  prompt: z.string().min(1),
+  mode: z.enum(["generate", "edit", "explain", "test"]).default("generate"),
+  provider: z.string().optional(),
+});
+
+class WrapTerminalCoderMCPServer {
+  private server: Server;
+  private wtc?: WrapTerminalCoder;
+
+  constructor() {
+    this.server = new Server(
+      {
+        name: "wrap-terminalcoder-mcp",
+        version: "0.1.0",
+      },
+      {
+        capabilities: {
+          tools: {},
+        },
+      },
+    );
+
+    this.setupToolHandlers();
+  }
+
+  private async getWTC(): Promise<WrapTerminalCoder> {
+    if (!this.wtc) {
+      this.wtc = await WrapTerminalCoder.create();
+    }
+    return this.wtc;
+  }
+
+  private setupToolHandlers(): void {
+    // List available tools
+    this.server.setRequestHandler(ListToolsRequestSchema, async () => {
+      return {
+        tools: [
+          {
+            name: "run_coding_task",
+            description: "Execute a coding task using the best available provider",
+            inputSchema: {
+              type: "object",
+              properties: {
+                prompt: {
+                  type: "string",
+                  description: "The coding task prompt",
+                },
+                mode: {
+                  type: "string",
+                  enum: ["generate", "edit", "explain", "test"],
+                  description: "The type of coding task",
+                  default: "generate",
+                },
+                language: {
+                  type: "string",
+                  description: "Language hint for the request",
+                  optional: true,
+                },
+                files: {
+                  type: "array",
+                  items: { type: "string" },
+                  description: "File paths for context",
+                  optional: true,
+                },
+                provider: {
+                  type: "string",
+                  description: "Specific provider to use",
+                  optional: true,
+                },
+              },
+              required: ["prompt"],
+            },
+          },
+          {
+            name: "get_providers",
+            description: "List all available providers and their current status",
+            inputSchema: {
+              type: "object",
+              properties: {},
+            },
+          },
+          {
+            name: "dry_run",
+            description: "Show which provider would be used for a request without executing it",
+            inputSchema: {
+              type: "object",
+              properties: {
+                prompt: {
+                  type: "string",
+                  description: "The coding task prompt",
+                },
+                mode: {
+                  type: "string",
+                  enum: ["generate", "edit", "explain", "test"],
+                  description: "The type of coding task",
+                  default: "generate",
+                },
+                provider: {
+                  type: "string",
+                  description: "Specific provider to use",
+                  optional: true,
+                },
+              },
+              required: ["prompt"],
+            },
+          },
+        ],
+      };
+    });
+
+    // Handle tool calls
+    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+      try {
+        const { name, arguments: args } = request.params;
+
+        switch (name) {
+          case "run_coding_task": {
+            const validated = RunCodingTaskSchema.parse(args);
+
+            const wtc = await this.getWTC();
+
+            const codingRequest: CodingRequest = {
+              prompt: validated.prompt,
+              mode: validated.mode,
+              language: validated.language,
+              fileContext: validated.files,
+              provider: validated.provider,
+              stream: false,
+            };
+
+            // Validate with Zod
+            const validation = CodingRequestSchema.safeParse(codingRequest);
+            if (!validation.success) {
+              return {
+                content: [
+                  {
+                    type: "text" as const,
+                    text: `Invalid request: ${validation.error.message}`,
+                  },
+                ],
+                isError: true,
+              };
+            }
+
+            const response = await wtc.route(codingRequest);
+
+            return {
+              content: [
+                {
+                  type: "text" as const,
+                  text: JSON.stringify(
+                    {
+                      provider: response.provider,
+                      text: response.text,
+                      usage: response.usage,
+                      meta: response.meta,
+                    },
+                    null,
+                    2,
+                  ),
+                },
+              ],
+            };
+          }
+
+          case "get_providers": {
+            const wtc = await this.getWTC();
+            const providers = await wtc.getProviderInfo();
+
+            return {
+              content: [
+                {
+                  type: "text" as const,
+                  text: JSON.stringify(providers, null, 2),
+                },
+              ],
+            };
+          }
+
+          case "dry_run": {
+            const validated = DryRunSchema.parse(args);
+
+            const wtc = await this.getWTC();
+
+            const codingRequest: CodingRequest = {
+              prompt: validated.prompt,
+              mode: validated.mode,
+              provider: validated.provider,
+              stream: false,
+            };
+
+            // We can't directly access router's private methods, so we'll check provider availability
+            const providers = await wtc.getProviderInfo();
+
+            return {
+              content: [
+                {
+                  type: "text" as const,
+                  text: JSON.stringify(
+                    {
+                      request: codingRequest,
+                      availableProviders: providers.filter(
+                        (p: { outOfCreditsUntil?: string | number | null }) =>
+                          p.outOfCreditsUntil ? new Date(p.outOfCreditsUntil) <= new Date() : true,
+                      ),
+                    },
+                    null,
+                    2,
+                  ),
+                },
+              ],
+            };
+          }
+
+          default:
+            return {
+              content: [
+                {
+                  type: "text" as const,
+                  text: `Unknown tool: ${name}`,
+                },
+              ],
+              isError: true,
+            };
+        }
+      } catch (error) {
+        const err = error as Error;
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: `Error: ${err.message}`,
+            },
+          ],
+          isError: true,
+        };
+      }
+    });
+  }
+
+  async run(): Promise<void> {
+    const transport = new StdioServerTransport();
+    await this.server.connect(transport);
+    console.error("Wrap TerminalCoder MCP server running on stdio");
+  }
+}
+
+// Exportable function to run MCP server
+export async function runMCPServer(): Promise<void> {
+  const server = new WrapTerminalCoderMCPServer();
+  await server.run();
+}
+
+// Run server if executed directly
+if (import.meta.main) {
+  const server = new WrapTerminalCoderMCPServer();
+  server.run().catch((error) => {
+    console.error("Fatal error:", error);
+    process.exit(1);
+  });
+}
+
+export { WrapTerminalCoderMCPServer };