PureScript MCP Server

Instructions

Implementation Reference

• index.js:813-821 (handler)

  The core handler function for the 'getFunctionNames' tool. Parses PureScript code using Tree-sitter parser, executes a Tree-sitter query to capture function names, extracts the names from capture nodes, and returns them as a JSON array.

  "getFunctionNames": async (args) => {
      if (!treeSitterInitialized) throw new Error("Tree-sitter not initialized.");
      const code = await getCodeFromInput(args, false);
      const tree = purescriptTsParser.parse(code);
      const query = new Query(PureScriptLanguage, `(function name: (variable) @func.name)`);
      const captures = query.captures(tree.rootNode);
      const functionNames = captures.map(capture => capture.node.text);
      return { content: [{ type: "text", text: JSON.stringify(functionNames, null, 2) }] };
  },

• index.js:616-623 (schema)

  The input schema definition for the 'getFunctionNames' tool, specifying that it requires a 'code' parameter of type string.

  name: "getFunctionNames",
  description: "Extract only function names from PureScript code snippets. Focuses specifically on functions, ignoring data types and classes. Quick analysis for code understanding.",
  inputSchema: {
      type: "object",
      properties: { code: { type: "string", description: "PureScript code snippet." } },
      required: ["code"],
      additionalProperties: false
  }

• index.js:1158-1163 (registration)

  Registration via the tools/list MCP method, which returns the TOOL_DEFINITIONS array containing the schema for 'getFunctionNames'.

  if (method === 'tools/list') {
      const toolsToExclude = ['query_purescript_ast', 'query_purs_ide']; // Keep query_purs_ide for now, for direct access if needed
      const filteredToolDefinitions = TOOL_DEFINITIONS.filter(
          tool => !toolsToExclude.includes(tool.name)
      );
      return createSuccessResponse(id, { tools: filteredToolDefinitions });

• index.js:1166-1179 (registration)

  The tools/call MCP request handler that dispatches to the specific tool handler by looking up in INTERNAL_TOOL_HANDLERS map.

  if (method === 'tools/call') {
      if (!params || typeof params.name !== 'string') {
          return createErrorResponse(id, -32602, "Invalid params: 'name' of tool is required for tools/call.");
      }
      const toolName = params.name;
      const toolArgs = params.arguments || {};
  
      const handler = INTERNAL_TOOL_HANDLERS[toolName];
      if (!handler) {
          return createErrorResponse(id, -32601, `Method not found (tool): ${toolName}`);
      }
      
      const result = await handler(toolArgs); // This now returns { content: [...] }
      return createSuccessResponse(id, result); // The entire { content: [...] } is the result for tools/call

• index.js:125-151 (helper)

  Helper function called by the handler to obtain the code from arguments. For getFunctionNames (snippet-oriented), it validates and returns args.code.

  // Helper to get code from input args (filePath or code string)
  async function getCodeFromInput(args, isModuleOriented = true) {
      if (isModuleOriented) {
          const hasFilePath = args && typeof args.filePath === 'string';
          const hasCode = args && typeof args.code === 'string';
  
          if ((hasFilePath && hasCode) || (!hasFilePath && !hasCode)) {
              throw new Error("Invalid input: Exactly one of 'filePath' or 'code' must be provided for module-oriented tools.");
          }
          if (hasFilePath) {
              if (!path.isAbsolute(args.filePath)) {
                  throw new Error(`Invalid filePath: '${args.filePath}' is not an absolute path. Only absolute paths are supported.`);
              }
              try {
                  return await fs.readFile(args.filePath, 'utf-8');
              } catch (e) {
                  throw new Error(`Failed to read file at ${args.filePath}: ${e.message}`);
              }
          }
          return args.code;
      } else { // Snippet-oriented
          if (!args || typeof args.code !== 'string') {
              throw new Error("Invalid input: 'code' (string) is required for snippet-oriented tools.");
          }
          return args.code;
      }
  }