@drumcode/runner 0.1.0

package/dist/chunk-5NEEOHT4.mjs

@@ -0,0 +1,632 @@
+// src/runner.ts
+import { CORE_TOOLSET, redactSecrets } from "@drumcode/core";
+var DrumcodeRunner = class {
+  options;
+  toolCache = /* @__PURE__ */ new Map();
+  manifestCache = null;
+  constructor(options) {
+    this.options = options;
+    this.log("info", "Drumcode Runner initialized", {
+      registryUrl: options.registryUrl,
+      cacheEnabled: options.cacheEnabled
+    });
+  }
+  // ---------------------------------------------------------------------------
+  // Tool Discovery
+  // ---------------------------------------------------------------------------
+  /**
+   * Get the list of tools to expose to the client
+   * Uses Polyfill strategy for non-Anthropic clients
+   */
+  async getToolList(capabilities) {
+    if (capabilities.supportsAdvancedToolUse && capabilities.supportsDeferredLoading) {
+      this.log("debug", "Using Strategy A: Full manifest with deferred loading");
+      return this.getFullManifest();
+    }
+    this.log("debug", "Using Strategy B: Polyfill mode with core toolset");
+    return CORE_TOOLSET;
+  }
+  /**
+   * Fetch the full tool manifest from the Registry
+   */
+  async getFullManifest() {
+    if (this.manifestCache && this.options.cacheEnabled) {
+      return this.manifestCache;
+    }
+    try {
+      const response = await fetch(`${this.options.registryUrl}/v1/manifest`, {
+        headers: this.getAuthHeaders()
+      });
+      if (!response.ok) {
+        throw new Error(`Registry returned ${response.status}`);
+      }
+      const data = await response.json();
+      this.manifestCache = data.tools;
+      return this.manifestCache;
+    } catch (error) {
+      this.log("warn", "Failed to fetch manifest, using cached or fallback", { error });
+      return this.manifestCache || CORE_TOOLSET;
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Tool Execution
+  // ---------------------------------------------------------------------------
+  /**
+   * Execute a tool call
+   */
+  async executeTool(request) {
+    const startTime = Date.now();
+    try {
+      if (request.name === "drumcode_search_tools") {
+        return this.handleSearchTools(request.arguments);
+      }
+      if (request.name === "drumcode_get_tool_schema") {
+        return this.handleGetToolSchema(request.arguments);
+      }
+      return this.executeRegularTool(request);
+    } catch (error) {
+      const latency = Date.now() - startTime;
+      this.log("error", "Tool execution failed", {
+        tool: request.name,
+        error,
+        latencyMs: latency
+      });
+      return {
+        content: [{
+          type: "text",
+          text: `Error executing tool: ${error instanceof Error ? error.message : "Unknown error"}`
+        }],
+        isError: true
+      };
+    }
+  }
+  /**
+   * Handle drumcode_search_tools meta-tool
+   */
+  async handleSearchTools(args) {
+    this.log("debug", "Searching tools", { query: args.query });
+    try {
+      const response = await fetch(`${this.options.registryUrl}/v1/tools/search`, {
+        method: "POST",
+        headers: {
+          ...this.getAuthHeaders(),
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          query: args.query,
+          project_token: this.options.token,
+          limit: 5
+        })
+      });
+      if (!response.ok) {
+        throw new Error(`Search failed with status ${response.status}`);
+      }
+      const data = await response.json();
+      const resultText = data.matches.length > 0 ? data.matches.map(
+        (m, i) => `${i + 1}. **${m.name}** (relevance: ${(m.relevance * 100).toFixed(0)}%)
+   ${m.description}`
+      ).join("\n\n") : "No matching tools found. Try a different search query.";
+      return {
+        content: [{
+          type: "text",
+          text: `Found ${data.matches.length} matching tools:
+
+${resultText}
+
+Use \`drumcode_get_tool_schema\` to get detailed arguments for any of these tools.`
+        }]
+      };
+    } catch (error) {
+      this.log("error", "Search failed", { error });
+      return {
+        content: [{
+          type: "text",
+          text: `Search failed: ${error instanceof Error ? error.message : "Unknown error"}`
+        }],
+        isError: true
+      };
+    }
+  }
+  /**
+   * Handle drumcode_get_tool_schema meta-tool
+   */
+  async handleGetToolSchema(args) {
+    this.log("debug", "Fetching tool schema", { toolName: args.tool_name });
+    if (this.toolCache.has(args.tool_name)) {
+      const cached = this.toolCache.get(args.tool_name);
+      return {
+        content: [{
+          type: "text",
+          text: this.formatToolSchema(cached)
+        }]
+      };
+    }
+    try {
+      const response = await fetch(
+        `${this.options.registryUrl}/v1/tools/${encodeURIComponent(args.tool_name)}`,
+        { headers: this.getAuthHeaders() }
+      );
+      if (!response.ok) {
+        if (response.status === 404) {
+          return {
+            content: [{
+              type: "text",
+              text: `Tool "${args.tool_name}" not found. Use drumcode_search_tools to find available tools.`
+            }],
+            isError: true
+          };
+        }
+        throw new Error(`Failed to fetch schema: ${response.status}`);
+      }
+      const schema = await response.json();
+      const tool = {
+        name: schema.name,
+        description: schema.description,
+        input_schema: schema.input_schema
+      };
+      this.toolCache.set(args.tool_name, tool);
+      return {
+        content: [{
+          type: "text",
+          text: this.formatToolSchema(tool)
+        }]
+      };
+    } catch (error) {
+      this.log("error", "Schema fetch failed", { error });
+      return {
+        content: [{
+          type: "text",
+          text: `Failed to fetch schema: ${error instanceof Error ? error.message : "Unknown error"}`
+        }],
+        isError: true
+      };
+    }
+  }
+  /**
+   * Execute a regular (non-meta) tool
+   */
+  async executeRegularTool(request) {
+    if (request.name === "drumcode_echo") {
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(request.arguments, null, 2)
+        }]
+      };
+    }
+    if (request.name === "drumcode_http_get") {
+      const url = request.arguments.url;
+      try {
+        const response = await fetch(url);
+        const text = await response.text();
+        return {
+          content: [{
+            type: "text",
+            text: `Status: ${response.status}
+
+${text.slice(0, 5e3)}${text.length > 5e3 ? "...(truncated)" : ""}`
+          }]
+        };
+      } catch (error) {
+        return {
+          content: [{
+            type: "text",
+            text: `HTTP request failed: ${error instanceof Error ? error.message : "Unknown error"}`
+          }],
+          isError: true
+        };
+      }
+    }
+    if (request.name.startsWith("arxiv_")) {
+      return this.executeArxivTool(request);
+    }
+    return {
+      content: [{
+        type: "text",
+        text: `Tool "${request.name}" is not yet implemented. This tool needs to be fetched and executed via the Registry.`
+      }],
+      isError: true
+    };
+  }
+  /**
+   * Execute arXiv tools via the arXiv API
+   */
+  async executeArxivTool(request) {
+    const baseUrl = "http://export.arxiv.org/api/query";
+    try {
+      switch (request.name) {
+        case "arxiv_search_papers": {
+          const { query, max_results = 10, categories } = request.arguments;
+          let searchQuery = query;
+          if (categories && categories.length > 0) {
+            const catFilter = categories.map((c) => `cat:${c}`).join(" OR ");
+            searchQuery = `(${query}) AND (${catFilter})`;
+          }
+          const params = new URLSearchParams({
+            search_query: `all:${searchQuery}`,
+            start: "0",
+            max_results: String(Math.min(max_results, 20)),
+            sortBy: "submittedDate",
+            sortOrder: "descending"
+          });
+          const response = await fetch(`${baseUrl}?${params}`);
+          const xml = await response.text();
+          const papers = this.parseArxivResponse(xml);
+          return {
+            content: [{
+              type: "text",
+              text: `Found ${papers.length} papers:
+
+${papers.map(
+                (p, i) => `${i + 1}. **${p.title}**
+   ID: ${p.id}
+   Authors: ${p.authors}
+   Published: ${p.published}
+   ${p.summary.slice(0, 200)}...`
+              ).join("\n\n")}`
+            }]
+          };
+        }
+        case "arxiv_get_paper":
+        case "arxiv_get_abstract": {
+          const { paper_id } = request.arguments;
+          const params = new URLSearchParams({ id_list: paper_id });
+          const response = await fetch(`${baseUrl}?${params}`);
+          const xml = await response.text();
+          const papers = this.parseArxivResponse(xml);
+          if (papers.length === 0) {
+            return {
+              content: [{ type: "text", text: `Paper ${paper_id} not found.` }],
+              isError: true
+            };
+          }
+          const p = papers[0];
+          return {
+            content: [{
+              type: "text",
+              text: `**${p.title}**
+
+ID: ${p.id}
+Authors: ${p.authors}
+Published: ${p.published}
+Categories: ${p.categories}
+PDF: ${p.pdf_url}
+
+**Abstract:**
+${p.summary}`
+            }]
+          };
+        }
+        case "arxiv_search_by_author": {
+          const { author, max_results = 10 } = request.arguments;
+          const params = new URLSearchParams({
+            search_query: `au:${author}`,
+            start: "0",
+            max_results: String(Math.min(max_results, 20)),
+            sortBy: "submittedDate",
+            sortOrder: "descending"
+          });
+          const response = await fetch(`${baseUrl}?${params}`);
+          const xml = await response.text();
+          const papers = this.parseArxivResponse(xml);
+          return {
+            content: [{
+              type: "text",
+              text: `Found ${papers.length} papers by "${author}":
+
+${papers.map(
+                (p, i) => `${i + 1}. **${p.title}** (${p.id})
+   ${p.published}`
+              ).join("\n\n")}`
+            }]
+          };
+        }
+        case "arxiv_search_by_category": {
+          const { category, max_results = 10 } = request.arguments;
+          const params = new URLSearchParams({
+            search_query: `cat:${category}`,
+            start: "0",
+            max_results: String(Math.min(max_results, 20)),
+            sortBy: "submittedDate",
+            sortOrder: "descending"
+          });
+          const response = await fetch(`${baseUrl}?${params}`);
+          const xml = await response.text();
+          const papers = this.parseArxivResponse(xml);
+          return {
+            content: [{
+              type: "text",
+              text: `Found ${papers.length} recent papers in ${category}:
+
+${papers.map(
+                (p, i) => `${i + 1}. **${p.title}** (${p.id})
+   Authors: ${p.authors}
+   ${p.published}`
+              ).join("\n\n")}`
+            }]
+          };
+        }
+        default:
+          return {
+            content: [{
+              type: "text",
+              text: `arXiv tool "${request.name}" is not yet implemented.`
+            }],
+            isError: true
+          };
+      }
+    } catch (error) {
+      this.log("error", "arXiv API call failed", { error });
+      return {
+        content: [{
+          type: "text",
+          text: `arXiv API error: ${error instanceof Error ? error.message : "Unknown error"}`
+        }],
+        isError: true
+      };
+    }
+  }
+  /**
+   * Parse arXiv Atom XML response
+   */
+  parseArxivResponse(xml) {
+    const papers = [];
+    const entryRegex = /<entry>([\s\S]*?)<\/entry>/g;
+    let match;
+    while ((match = entryRegex.exec(xml)) !== null) {
+      const entry = match[1];
+      const getId = (s) => {
+        const m = s.match(/<id>(.*?)<\/id>/);
+        return m ? m[1].replace("http://arxiv.org/abs/", "") : "";
+      };
+      const getTitle = (s) => {
+        const m = s.match(/<title>([\s\S]*?)<\/title>/);
+        return m ? m[1].replace(/\s+/g, " ").trim() : "";
+      };
+      const getSummary = (s) => {
+        const m = s.match(/<summary>([\s\S]*?)<\/summary>/);
+        return m ? m[1].replace(/\s+/g, " ").trim() : "";
+      };
+      const getAuthors = (s) => {
+        const authors = [];
+        const authorRegex = /<author>\s*<name>(.*?)<\/name>/g;
+        let authorMatch;
+        while ((authorMatch = authorRegex.exec(s)) !== null) {
+          authors.push(authorMatch[1]);
+        }
+        return authors.join(", ");
+      };
+      const getPublished = (s) => {
+        const m = s.match(/<published>(.*?)<\/published>/);
+        return m ? m[1].split("T")[0] : "";
+      };
+      const getCategories = (s) => {
+        const cats = [];
+        const catRegex = /<category[^>]*term="([^"]+)"/g;
+        let catMatch;
+        while ((catMatch = catRegex.exec(s)) !== null) {
+          cats.push(catMatch[1]);
+        }
+        return cats.join(", ");
+      };
+      const getPdfUrl = (s) => {
+        const m = s.match(/<link[^>]*title="pdf"[^>]*href="([^"]+)"/);
+        return m ? m[1] : "";
+      };
+      papers.push({
+        id: getId(entry),
+        title: getTitle(entry),
+        summary: getSummary(entry),
+        authors: getAuthors(entry),
+        published: getPublished(entry),
+        categories: getCategories(entry),
+        pdf_url: getPdfUrl(entry)
+      });
+    }
+    return papers;
+  }
+  // ---------------------------------------------------------------------------
+  // Helpers
+  // ---------------------------------------------------------------------------
+  getAuthHeaders() {
+    const headers = {
+      "User-Agent": "drumcode-runner/0.1.0"
+    };
+    if (this.options.token) {
+      headers["Authorization"] = `Bearer ${this.options.token}`;
+    }
+    return headers;
+  }
+  formatToolSchema(tool) {
+    const props = tool.input_schema.properties;
+    const required = tool.input_schema.required || [];
+    const argsDescription = Object.entries(props).map(([name, prop]) => {
+      const req = required.includes(name) ? " (required)" : " (optional)";
+      return `  - ${name}${req}: ${prop.type}${prop.description ? ` - ${prop.description}` : ""}`;
+    }).join("\n");
+    return `## ${tool.name}
+
+${tool.description}
+
+### Arguments:
+${argsDescription || "  No arguments required."}
+
+### Usage:
+Call this tool with the arguments above to execute it.`;
+  }
+  log(level, message, data) {
+    const levels = ["debug", "info", "warn", "error"];
+    const currentLevel = levels.indexOf(this.options.logLevel);
+    const messageLevel = levels.indexOf(level);
+    if (messageLevel >= currentLevel) {
+      const safeData = data ? JSON.parse(redactSecrets(JSON.stringify(data))) : void 0;
+      console.error(`[drumcode] ${message}`, safeData ? safeData : "");
+    }
+  }
+};
+
+// src/server.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+async function createServer(options) {
+  const runner = new DrumcodeRunner(options);
+  const server = new Server(
+    {
+      name: "drumcode",
+      version: "0.1.0"
+    },
+    {
+      capabilities: {
+        tools: {}
+      }
+    }
+  );
+  server.setRequestHandler(ListToolsRequestSchema, async (request) => {
+    const capabilities = detectClientCapabilities(request);
+    const tools = await runner.getToolList(capabilities);
+    const demoTools = [
+      {
+        name: "drumcode_echo",
+        description: "Echo back the input arguments. Useful for testing.",
+        input_schema: {
+          type: "object",
+          properties: {
+            message: {
+              type: "string",
+              description: "The message to echo back"
+            }
+          },
+          required: ["message"]
+        }
+      },
+      {
+        name: "drumcode_http_get",
+        description: "Make an HTTP GET request to a URL and return the response.",
+        input_schema: {
+          type: "object",
+          properties: {
+            url: {
+              type: "string",
+              description: "The URL to fetch"
+            }
+          },
+          required: ["url"]
+        }
+      }
+    ];
+    const arxivTools = [
+      {
+        name: "arxiv_search_papers",
+        description: "Search for academic papers on arXiv. Returns papers matching the query with optional filters.",
+        input_schema: {
+          type: "object",
+          properties: {
+            query: {
+              type: "string",
+              description: 'Search query keywords (e.g., "machine learning", "quantum computing")'
+            },
+            max_results: {
+              type: "number",
+              description: "Maximum number of results to return (1-20)"
+            },
+            categories: {
+              type: "string",
+              description: 'Comma-separated arXiv categories to filter by (e.g., "cs.AI,cs.LG")'
+            }
+          },
+          required: ["query"]
+        }
+      },
+      {
+        name: "arxiv_get_paper",
+        description: "Get detailed metadata and abstract for a specific paper by its arXiv ID.",
+        input_schema: {
+          type: "object",
+          properties: {
+            paper_id: {
+              type: "string",
+              description: 'The arXiv paper ID (e.g., "2301.07041" or "1706.03762")'
+            }
+          },
+          required: ["paper_id"]
+        }
+      },
+      {
+        name: "arxiv_search_by_author",
+        description: "Search for papers by a specific author on arXiv.",
+        input_schema: {
+          type: "object",
+          properties: {
+            author: {
+              type: "string",
+              description: "Author name to search for"
+            },
+            max_results: {
+              type: "number",
+              description: "Maximum number of results (1-20)"
+            }
+          },
+          required: ["author"]
+        }
+      },
+      {
+        name: "arxiv_search_by_category",
+        description: "Search for recent papers in a specific arXiv category.",
+        input_schema: {
+          type: "object",
+          properties: {
+            category: {
+              type: "string",
+              description: 'arXiv category (e.g., "cs.AI", "math.CO", "physics.hep-th")'
+            },
+            max_results: {
+              type: "number",
+              description: "Maximum number of results (1-20)"
+            }
+          },
+          required: ["category"]
+        }
+      }
+    ];
+    const allTools = [...tools, ...demoTools, ...arxivTools].map((t) => ({
+      name: t.name,
+      description: t.description,
+      inputSchema: {
+        type: "object",
+        properties: t.input_schema.properties,
+        required: t.input_schema.required
+      }
+    }));
+    return { tools: allTools };
+  });
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    const result = await runner.executeTool({
+      name,
+      arguments: args ?? {}
+    });
+    return {
+      content: result.content,
+      isError: result.isError
+    };
+  });
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("[drumcode] MCP Server started");
+}
+function detectClientCapabilities(_request) {
+  return {
+    type: "unknown",
+    supportsAdvancedToolUse: false,
+    supportsDeferredLoading: false
+  };
+}
+
+export {
+  DrumcodeRunner,
+  createServer
+};