TypeScript Definitions MCP Server

Instructions

Implementation Reference

• src/mcp-server.ts:305-319 (handler)

  Executes the tool logic by calling the type indexer's findInterfaces method with the pattern and returns a formatted JSON response containing matching interfaces.

  private async handleFindInterfaces(pattern: string) {
    const results = await this.typeIndexer.findInterfaces(pattern);
    
    return {
      content: [
        {
          type: "text",
          text: JSON.stringify({
            pattern,
            results,
            count: results.length
          }, null, 2)
        }
      ]
    };

• src/mcp-server.ts:115-123 (schema)

  JSON Schema defining the input for the find_interfaces tool: an object with a required 'pattern' string property.

  inputSchema: {
    type: "object",
    properties: {
      pattern: {
        type: "string",
        description: "Pattern to match interface names (supports wildcards with *)"
      }
    },
    required: ["pattern"]

• src/mcp-server.ts:112-125 (registration)

  Registration of the find_interfaces tool in the ListToolsRequestSchema response, including name, description, and input schema.

  {
    name: "find_interfaces",
    description: "Find interfaces matching a pattern",
    inputSchema: {
      type: "object",
      properties: {
        pattern: {
          type: "string",
          description: "Pattern to match interface names (supports wildcards with *)"
        }
      },
      required: ["pattern"]
    }
  },

• src/type-indexer.ts:384-400 (helper)

  Supporting method in TypeIndexer that implements the core logic: scans source files, extracts type definitions, filters interfaces matching the regex-converted pattern.

  async findInterfaces(pattern: string): Promise<TypeDefinition[]> {
    if (!this.program) {
      throw new Error("TypeIndexer not initialized. Call initialize() first.");
    }
  
    const results: TypeDefinition[] = [];
    const regex = new RegExp(pattern.replace(/\*/g, ".*"));
    
    for (const sourceFile of this.program.getSourceFiles()) {
      const definitions = this.extractTypeDefinitions(sourceFile);
      const matching = definitions.filter(def => 
        def.kind === "interface" && regex.test(def.name)
      );
      results.push(...matching);
    }
    
    return results;

• src/mcp-server.ts:222-225 (registration)

  Handler dispatch registration in the CallToolRequestSchema switch statement for routing find_interfaces calls to the handler.

  case "find_interfaces": {
    const interfaceArgs = this.validateArgs<ToolArguments["find_interfaces"]>(args);
    return await this.handleFindInterfaces(interfaceArgs.pattern);
  }