TypeScript MCP

Instructions

Implementation Reference

• src/tools/lsp/deleteSymbol.ts:41-203 (handler)

  The core handler function that implements the delete symbol logic using LSP. It finds the symbol position, locates references if requested, creates workspace edits to delete occurrences, and applies the edits.

  async function handleDeleteSymbol(
    {
      root,
      relativePath,
      line,
      textTarget,
      removeReferences = true,
    }: z.infer<typeof schema>,
    client: LSPClient,
  ): Promise<DeleteSymbolResult> {
    if (!client) {
      throw new Error("LSP client not initialized");
    }
  
    // Convert to absolute path
    const absolutePath = path.isAbsolute(relativePath)
      ? relativePath
      : path.join(root, relativePath);
  
    // Convert to file URI
    const fileUri = pathToFileURL(absolutePath).toString();
  
    // Read the file content
    const content = await fs.readFile(absolutePath, "utf-8");
  
    // Open the document in LSP
    client.openDocument(fileUri, content);
  
    let locations: Location[] = [];
  
    try {
      // Resolve line parameter
      const lines = content.split("\n");
      const lineIndex = resolveLineParameter(lines, line);
      const resolvedLine = lineIndex + 1; // Convert back to 1-based
  
      // Find the symbol position on the line
      const lineContent = lines[lineIndex];
      const symbolIndex = lineContent.indexOf(textTarget);
  
      if (symbolIndex === -1) {
        throw new Error(
          `Symbol "${textTarget}" not found on line ${resolvedLine}: "${lineContent.trim()}"`,
        );
      }
  
      // Create position for the symbol
      const position: Position = {
        line: lineIndex, // LSP uses 0-based line numbers
        character: symbolIndex,
      };
  
      // First, find all references if removeReferences is true
      locations = removeReferences
        ? await client.findReferences(fileUri, position)
        : [{ uri: fileUri, range: { start: position, end: position } }];
  
      if (locations.length === 0) {
        return {
          applied: false,
          deletedFromFiles: new Set(),
          totalDeleted: 0,
          failureReason: "No references found for the symbol",
        };
      }
  
      // Create workspace edit
      const workspaceEdit: WorkspaceEdit = {
        changes: {},
      };
  
      // Group locations by file
      const fileChanges = new Map<string, Range[]>();
  
      for (const location of locations) {
        const ranges = fileChanges.get(location.uri) || [];
        ranges.push(location.range);
        fileChanges.set(location.uri, ranges);
      }
  
      // Create text edits for each file
      for (const [uri, ranges] of fileChanges) {
        // Sort ranges in reverse order to avoid position shifts
        const sortedRanges = ranges.sort((a, b) => {
          if (a.start.line !== b.start.line) {
            return b.start.line - a.start.line;
          }
          return b.start.character - a.start.character;
        });
  
        // Read file content if it's different from the current file
        let fileContent: string;
        let fileLines: string[];
  
        if (uri === fileUri) {
          fileContent = content;
          fileLines = lines;
        } else {
          const absoluteFilePath = fileURLToPath(uri);
          fileContent = await fs.readFile(absoluteFilePath, "utf-8");
          fileLines = fileContent.split("\n");
          // Open document for editing
          client.openDocument(uri, fileContent);
        }
  
        const edits: TextEdit[] = [];
  
        for (const range of sortedRanges) {
          // Check if this is a complete line deletion
          const lineText = fileLines[range.start.line];
          const beforeSymbol = lineText
            .substring(0, range.start.character)
            .trim();
          const afterSymbol = lineText.substring(range.end.character).trim();
  
          if (!beforeSymbol && !afterSymbol) {
            // Delete the entire line
            edits.push({
              range: {
                start: { line: range.start.line, character: 0 },
                end: { line: range.start.line + 1, character: 0 },
              },
              newText: "",
            });
          } else {
            // Delete just the symbol
            edits.push({
              range,
              newText: "",
            });
          }
        }
  
        workspaceEdit.changes![uri] = edits;
      }
  
      // Apply the workspace edit
      const result = await client.applyEdit(
        workspaceEdit,
        `Delete symbol "${textTarget}"`,
      );
  
      if (!result.applied) {
        return {
          applied: false,
          deletedFromFiles: new Set(),
          totalDeleted: 0,
          failureReason: result.failureReason || "Failed to apply workspace edit",
        };
      }
  
      return {
        applied: true,
        deletedFromFiles: new Set(fileChanges.keys()),
        totalDeleted: locations.length,
      };
    } finally {
      // Close all opened documents
      for (const uri of new Set([fileUri, ...locations.map((l) => l.uri)])) {
        client.closeDocument(uri);
      }
    }
  }

• src/tools/lsp/deleteSymbol.ts:16-32 (schema)

  Zod schema defining the input parameters for the delete symbol tool.

  const schemaShape = {
    root: z.string().describe("Root directory for resolving relative paths"),
    relativePath: z
      .string()
      .describe("File path containing the symbol (relative to root)"),
    line: z
      .union([z.number(), z.string()])
      .describe("Line number (1-based) or string to match in the line"),
    textTarget: z.string().describe("Name of the symbol to delete"),
    removeReferences: z
      .boolean()
      .optional()
      .default(true)
      .describe("Also delete all references to the symbol"),
  };
  
  const schema = z.object(schemaShape);

• src/tools/lsp/deleteSymbol.ts:224-237 (registration)

  Factory function creating the MCP tool definition named 'lsp_delete_symbol', which wraps the handler.

  export function createDeleteSymbolTool(
    client: LSPClient,
  ): McpToolDef<typeof schema> {
    return {
      name: "lsp_delete_symbol",
      description:
        "Delete a symbol and optionally all its references using LSP. Requires exact line:column position of the symbol.",
      schema,
      execute: async (args) => {
        const result = await handleDeleteSymbol(args, client);
        return formatDeleteSymbolResult(result);
      },
    };
  }

• src/tools/lsp/createLspTools.ts:40-40 (registration)

  The delete symbol tool is included in the list of all LSP tools returned by createLSPTools.

  createDeleteSymbolTool(client),

• src/tools/filterTools.ts:37-39 (helper)

  Helper function in capability checker that determines if the delete_symbol tool is supported based on codeActionProvider capability.

  delete_symbol: (checker) => {
    return checker.hasCapability("codeActionProvider");
  },