@anyproto/anytype-mcp 1.0.2 → 1.0.3

package/cli/__tests__/openapi-client.test.ts

@@ -0,0 +1,119 @@
+import axios from "axios";
+import fs from "fs/promises";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { loadSpec } from "../openapi-client";
+
+vi.mock("fs/promises");
+vi.mock("axios");
+
+const validOpenApiSpec = {
+  openapi: "3.1.0",
+  info: {
+    title: "Test API",
+    version: "1.0.0",
+  },
+  servers: [{ url: "http://localhost:3000" }],
+  paths: {
+    "/pets": {
+      get: {
+        operationId: "getPets",
+        responses: {
+          "200": { description: "A list of pets" },
+        },
+      },
+    },
+  },
+};
+
+describe("loadSpec", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe("Local file loading", () => {
+    it("should load a valid OpenAPI spec from local JSON file", async () => {
+      // Mock fs.readFile to return a valid spec
+      vi.mocked(fs.readFile).mockResolvedValue(JSON.stringify(validOpenApiSpec));
+
+      const result = await loadSpec("./test-spec.json");
+
+      expect(result).toEqual(validOpenApiSpec);
+      expect(fs.readFile).toHaveBeenCalledWith("./test-spec.json", "utf-8");
+    });
+
+    it("should load a valid OpenAPI spec from local YAML file", async () => {
+      // Mock fs.readFile to return a valid YAML spec
+      const yamlSpec = JSON.stringify(validOpenApiSpec);
+      vi.mocked(fs.readFile).mockResolvedValue(yamlSpec);
+
+      const result = await loadSpec("./test-spec.yaml");
+
+      expect(result).toEqual(validOpenApiSpec);
+      expect(fs.readFile).toHaveBeenCalledWith("./test-spec.yaml", "utf-8");
+    });
+
+    it("should handle file not found error", async () => {
+      // Mock fs.readFile to throw ENOENT
+      vi.mocked(fs.readFile).mockImplementation(() => {
+        throw new Error("ENOENT: no such file or directory");
+      });
+
+      await expect(loadSpec("./non-existent.json")).rejects.toThrow("ENOENT: no such file or directory");
+    });
+
+    it("should handle invalid JSON", async () => {
+      // Mock fs.readFile to return invalid JSON
+      vi.mocked(fs.readFile).mockResolvedValue("invalid json");
+
+      await expect(loadSpec("./invalid.json")).rejects.toThrow("Unexpected token i in JSON at position 0");
+    });
+
+    it("should handle invalid YAML", async () => {
+      // Mock fs.readFile to return invalid YAML
+      vi.mocked(fs.readFile).mockResolvedValue("invalid: yaml: :");
+
+      await expect(loadSpec("./invalid.yaml")).rejects.toThrow(
+        "end of the stream or a document separator is expected at line 1, column 15:",
+      );
+    });
+  });
+
+  describe("URL loading", () => {
+    it("should load a valid OpenAPI spec from URL", async () => {
+      // Mock axios.get to return a valid spec
+      vi.mocked(axios.get).mockResolvedValue({ data: validOpenApiSpec });
+
+      const result = await loadSpec("http://example.com/api-spec.json");
+
+      expect(result).toEqual(validOpenApiSpec);
+      expect(axios.get).toHaveBeenCalledWith("http://example.com/api-spec.json");
+    });
+
+    it("should load a valid OpenAPI spec from YAML URL", async () => {
+      // Mock axios.get to return a valid YAML spec
+      const yamlSpec = JSON.stringify(validOpenApiSpec);
+      vi.mocked(axios.get).mockResolvedValue({ data: yamlSpec });
+
+      const result = await loadSpec("http://example.com/api-spec.yaml");
+
+      expect(result).toEqual(validOpenApiSpec);
+      expect(axios.get).toHaveBeenCalledWith("http://example.com/api-spec.yaml");
+    });
+
+    it("should handle network errors", async () => {
+      // Mock axios.get to throw network error
+      vi.mocked(axios.get).mockRejectedValue(new Error("Network Error"));
+
+      await expect(loadSpec("http://example.com/api-spec.json")).rejects.toThrow("Network Error");
+    });
+
+    it("should handle invalid response data", async () => {
+      // Mock axios.get to return invalid data
+      vi.mocked(axios.get).mockResolvedValue({ data: "invalid data" });
+
+      await expect(loadSpec("http://example.com/api-spec.json")).rejects.toThrow(
+        "Unexpected token i in JSON at position 0",
+      );
+    });
+  });
+});

package/cli/openapi-client.ts

@@ -0,0 +1,91 @@
+#!/usr/bin/env node
+
+import axios from "axios";
+import fs from "fs/promises";
+import { OpenAPIV3 } from "openapi-types";
+import { HttpClient, OpenAPIToMCPConverter } from "../src";
+
+export async function loadSpec(specPath: string): Promise<OpenAPIV3.Document> {
+  let content: string;
+  if (specPath.startsWith("http://") || specPath.startsWith("https://")) {
+    const response = await axios.get(specPath);
+    content = JSON.stringify(response.data);
+  } else {
+    content = await fs.readFile(specPath, "utf-8");
+  }
+
+  return JSON.parse(content);
+}
+
+async function main() {
+  const [, , specPath, command, ...args] = process.argv;
+
+  if (!specPath || !command) {
+    console.log("Usage: openapi-client <spec-path> <command> [args]");
+    console.log("\nCommands:");
+    console.log("  list                     List all available methods");
+    console.log("  call <method> [params]   Call a method with optional JSON params");
+    process.exit(1);
+  }
+
+  const spec = await loadSpec(specPath);
+  const converter = new OpenAPIToMCPConverter(spec);
+  const baseUrl = spec.servers?.[0]?.url;
+  if (!baseUrl) {
+    throw new Error("No base URL found in OpenAPI spec");
+  }
+
+  const httpClient = new HttpClient({ baseUrl }, spec);
+
+  if (command === "list") {
+    // List all available methods
+    const { tools } = converter.convertToMCPTools();
+    console.log("\nAvailable methods:");
+    Object.entries(tools).forEach(([name, def]) => {
+      def.methods.forEach((method) => {
+        console.log(`\n${name}-${method.name}:`);
+        console.log(`  Description: ${method.description}`);
+        console.log("  Parameters:");
+        const params = method.inputSchema.properties || {};
+        Object.entries(params).forEach(([paramName, schema]) => {
+          const required = method.inputSchema.required?.includes(paramName) ? " (required)" : "";
+          console.log(`    - ${paramName}${required}: ${(schema as any).type}`);
+        });
+      });
+    });
+  } else if (command === "call") {
+    const [methodName, ...paramArgs] = args;
+    if (!methodName) {
+      console.error("Error: Method name required");
+      process.exit(1);
+    }
+
+    // Parse parameters if provided
+    const params = paramArgs.length ? JSON.parse(paramArgs[0]) : {};
+
+    // Get operation details
+    const { openApiLookup } = converter.convertToMCPTools();
+    const operation = openApiLookup[methodName];
+    if (!operation) {
+      console.error(`Error: Method ${methodName} not found`);
+      process.exit(1);
+    }
+
+    try {
+      // Execute the operation
+      const response = await httpClient.executeOperation(operation, params);
+      console.log("Response:", JSON.stringify(response.data, null, 2));
+    } catch (error: any) {
+      console.error("Error:", error.response?.data || error.message);
+      process.exit(1);
+    }
+  } else {
+    console.error(`Error: Unknown command ${command}`);
+    process.exit(1);
+  }
+}
+
+main().catch((error) => {
+  console.error("Error:", error.message);
+  process.exit(1);
+});

package/eslint.config.js

@@ -0,0 +1,49 @@
+import eslint from "@eslint/js";
+import tseslint from "@typescript-eslint/eslint-plugin";
+import tsparser from "@typescript-eslint/parser";
+
+export default [
+  {
+    ignores: ["build/**/*", "bin/**/*"],
+  },
+  eslint.configs.recommended,
+  {
+    files: ["**/*.ts", "**/*.tsx"],
+    languageOptions: {
+      parser: tsparser,
+      parserOptions: {
+        ecmaVersion: "latest",
+        sourceType: "module",
+      },
+      globals: {
+        process: "readonly",
+        console: "readonly",
+      },
+    },
+    plugins: {
+      "@typescript-eslint": tseslint,
+    },
+    rules: {
+      ...tseslint.configs.recommended.rules,
+      "@typescript-eslint/no-explicit-any": "off",
+      "@typescript-eslint/no-unused-vars": "off",
+    },
+  },
+  {
+    files: ["**/*.js", "**/*.jsx"],
+    languageOptions: {
+      parserOptions: {
+        ecmaVersion: "latest",
+        sourceType: "module",
+      },
+      globals: {
+        process: "readonly",
+        console: "readonly",
+      },
+    },
+    rules: {
+      ...eslint.configs.recommended.rules,
+      "no-unused-vars": "off",
+    },
+  },
+];

package/package.json

@@ -6,7 +6,7 @@
     "mcp",
     "server"
   ],
-  "version": "1.0.2",
+  "version": "1.0.3",
   "license": "MIT",
   "type": "module",
   "scripts": {
@@ -17,18 +17,16 @@
     "dev": "tsx watch scripts/start-server.ts",
     "parse-openapi": "tsx scripts/parse-openapi.ts",
     "format": "prettier --write \"src/**/*.{ts,tsx}\" \"scripts/**/*.{ts,tsx}\"",
-    "lint": "prettier --check \"src/**/*.{ts,tsx}\" \"scripts/**/*.{ts,tsx}\" && eslint . --ext .ts,.tsx",
-    "fix-lint": "eslint . --ext .ts,.tsx --fix",
+    "lint": "prettier --check \"src/**/*.{ts,tsx}\" \"scripts/**/*.{ts,tsx}\"",
     "type-check": "tsc --noEmit"
   },
   "bin": {
     "anytype-mcp": "bin/cli.mjs"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.4.1",
-    "axios": "^1.7.9",
+    "@modelcontextprotocol/sdk": "1.8.0",
+    "axios": "^1.8.4",
     "form-data": "^4.0.1",
-    "js-yaml": "^4.1.0",
     "mustache": "^4.2.0",
     "openapi-client-axios": "^7.5.5",
     "openapi-schema-validator": "^12.1.3",
@@ -37,21 +35,18 @@
   },
   "devDependencies": {
     "@anthropic-ai/sdk": "^0.33.1",
-    "@types/js-yaml": "^4.0.9",
     "@types/json-schema": "^7.0.15",
     "@types/mustache": "^4.2.5",
     "@types/node": "^20.17.16",
-    "@typescript-eslint/eslint-plugin": "^8.32.1",
-    "@typescript-eslint/parser": "^8.32.1",
-    "@vitest/coverage-v8": "2.1.8",
-    "esbuild": "^0.24.2",
-    "eslint": "^9.26.0",
-    "openai": "^4.80.1",
+    "@types/which": "^3.0.4",
+    "@vitest/coverage-v8": "3.1.1",
+    "esbuild": "^0.25.2",
+    "openai": "^4.91.1",
     "prettier": "^3.5.3",
     "prettier-plugin-organize-imports": "^4.1.0",
-    "tsx": "^4.19.2",
-    "typescript": "^5.7.3",
-    "vitest": "^2.1.8"
+    "tsx": "^4.19.3",
+    "typescript": "^5.8.2",
+    "vitest": "^3.1.1"
   },
   "description": "Official MCP server for Anytype API",
   "repository": {
@@ -62,14 +57,5 @@
   "bugs": {
     "url": "https://github.com/anyproto/anytype-mcp/issues"
   },
-  "homepage": "https://github.com/anyproto/anytype-mcp#readme",
-  "files": [
-    "bin",
-    "dist",
-    "src",
-    "README.md"
-  ],
-  "engines": {
-    "node": ">=16"
-  }
+  "homepage": "https://github.com/anyproto/anytype-mcp#readme"
 }

package/scripts/__tests__/parse-openapi.test.ts

@@ -0,0 +1,189 @@
+import { OpenAPIV3 } from "openapi-types";
+import { describe, expect, it } from "vitest";
+import { OpenAPIToMCPConverter } from "../../src/openapi/parser";
+
+describe("OpenAPI Tool Conversion", () => {
+  const sampleSpec: OpenAPIV3.Document = {
+    openapi: "3.0.0",
+    info: {
+      title: "Test API",
+      version: "1.0.0",
+    },
+    paths: {
+      "/pets/{petId}": {
+        get: {
+          operationId: "getPet",
+          summary: "Get a pet by ID",
+          parameters: [
+            {
+              name: "petId",
+              in: "path",
+              required: true,
+              description: "The ID of the pet",
+              schema: {
+                type: "integer",
+              },
+            },
+          ],
+          responses: {
+            "200": {
+              description: "Pet found",
+              content: {
+                "application/json": {
+                  schema: {
+                    type: "object",
+                    properties: {
+                      id: { type: "integer" },
+                      name: { type: "string" },
+                    },
+                  },
+                },
+              },
+            },
+          },
+        },
+      },
+    },
+  };
+
+  describe("convertToOpenAITools", () => {
+    it("converts OpenAPI spec to OpenAI tools format", () => {
+      const converter = new OpenAPIToMCPConverter(sampleSpec);
+      const tools = converter.convertToOpenAITools();
+
+      expect(tools).toHaveLength(1);
+      const tool = tools[0];
+
+      expect(tool.type).toBe("function");
+      expect(tool.function.name).toBe("getPet");
+      expect(tool.function.description).toBe("Get a pet by ID");
+      expect(tool.function.parameters).toEqual({
+        $defs: {},
+        type: "object",
+        properties: {
+          petId: {
+            type: "integer",
+            description: "The ID of the pet",
+          },
+        },
+        required: ["petId"],
+      });
+    });
+  });
+
+  describe("convertToAnthropicTools", () => {
+    it("converts OpenAPI spec to Anthropic tools format", () => {
+      const converter = new OpenAPIToMCPConverter(sampleSpec);
+      const tools = converter.convertToAnthropicTools();
+
+      expect(tools).toHaveLength(1);
+      const tool = tools[0];
+
+      expect(tool.name).toBe("getPet");
+      expect(tool.description).toBe("Get a pet by ID");
+      expect(tool.input_schema).toEqual({
+        $defs: {},
+        type: "object",
+        properties: {
+          petId: {
+            type: "integer",
+            description: "The ID of the pet",
+          },
+        },
+        required: ["petId"],
+      });
+    });
+  });
+
+  describe("Complex API Conversion", () => {
+    const complexSpec: OpenAPIV3.Document = {
+      openapi: "3.0.0",
+      info: { title: "Complex API", version: "1.0.0" },
+      paths: {
+        "/pets": {
+          post: {
+            operationId: "createPet",
+            summary: "Create a pet",
+            requestBody: {
+              required: true,
+              content: {
+                "application/json": {
+                  schema: {
+                    type: "object",
+                    required: ["name", "type"],
+                    properties: {
+                      name: { type: "string", description: "The name of the pet" },
+                      type: { type: "string", description: "The type of pet", enum: ["dog", "cat", "bird"] },
+                      age: { type: "integer", description: "The age of the pet in years" },
+                    },
+                  },
+                },
+              },
+            },
+            responses: {
+              "201": {
+                description: "Pet created successfully",
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object",
+                      properties: {
+                        id: { type: "integer" },
+                        name: { type: "string" },
+                        type: { type: "string" },
+                        age: { type: "integer" },
+                      },
+                    },
+                  },
+                },
+              },
+            },
+          },
+        },
+      },
+    };
+
+    it("converts complex OpenAPI spec to OpenAI tools format", () => {
+      const converter = new OpenAPIToMCPConverter(complexSpec);
+      const tools = converter.convertToOpenAITools();
+
+      expect(tools).toHaveLength(1);
+      const tool = tools[0];
+
+      expect(tool.type).toBe("function");
+      expect(tool.function.name).toBe("createPet");
+      expect(tool.function.description).toBe("Create a pet");
+      expect(tool.function.parameters).toEqual({
+        $defs: {},
+        type: "object",
+        properties: {
+          name: { type: "string", description: "The name of the pet" },
+          type: { type: "string", description: "The type of pet", enum: ["dog", "cat", "bird"] },
+          age: { type: "integer", description: "The age of the pet in years" },
+        },
+        required: ["name", "type"],
+      });
+    });
+
+    it("converts complex OpenAPI spec to Anthropic tools format", () => {
+      const converter = new OpenAPIToMCPConverter(complexSpec);
+      const tools = converter.convertToAnthropicTools();
+
+      expect(tools).toHaveLength(1);
+      const tool = tools[0];
+
+      expect(tool.name).toBe("createPet");
+      expect(tool.description).toBe("Create a pet");
+      expect(tool.input_schema).toEqual({
+        $defs: {},
+        type: "object",
+        properties: {
+          name: { type: "string", description: "The name of the pet" },
+          type: { type: "string", description: "The type of pet", enum: ["dog", "cat", "bird"] },
+          age: { type: "integer", description: "The age of the pet in years" },
+        },
+        required: ["name", "type"],
+      });
+    });
+  });
+});