Add batch and analysis tools for Ghidra MCP v1.5.x

Introduces batch operations and analysis tools for comments, functions, labels, structs, types, and variables in the Ghidra MCP bridge. Adds new Python tools for batch setting comments, renaming function components, creating labels, analyzing struct field usage, suggesting field names, and batch setting variable types. Implements corresponding Java handlers for finding the next undefined function and batch setting variable types. Improves documentation and validation throughout the tool modules. Also updates server shutdown behavior for cleaner resource release.

Author: DaCodeChick

bridge_mcp_ghidra/tools/__init__.py

@@ -11,7 +11,6 @@
 from .labels import register_label_tools
 from .misc import register_misc_tools
 from .namespaces import register_namespace_tools
-from .security import register_security_tools
 from .strings import register_string_tools
 from .structs import register_struct_tools
 from .types import register_type_tools
@@ -32,7 +31,6 @@ def register_all_tools():
 	register_label_tools()
 	register_misc_tools()
 	register_namespace_tools()
-	register_security_tools()
 	register_string_tools()
 	register_struct_tools()
 	register_type_tools()

bridge_mcp_ghidra/tools/comments.py

@@ -4,6 +4,37 @@
 def register_comment_tools(mcp: FastMCP):
 	"""Register comment tools for Ghidra context."""
 
+	@mcp.tool()
+	def batch_set_comments(
+		function_address: str,
+		decompiler_comments: list = None,
+		disassembly_comments: list = None,
+		plate_comment: str = None
+	) -> str:
+		"""
+		Set multiple comments in a single operation (v1.5.0).
+		Reduces API calls from 10+ to 1 for typical function documentation.
+
+		Args:
+			function_address: Function address for plate comment
+			decompiler_comments: List of {"address": "0x...", "comment": "..."} for PRE_COMMENT
+			disassembly_comments: List of {"address": "0x...", "comment": "..."} for EOL_COMMENT
+			plate_comment: Function header summary comment
+
+		Returns:
+			JSON with success status and counts of comments set
+		"""
+		validate_hex_address(function_address)
+
+		payload = {
+			"function_address": function_address,
+			"decompiler_comments": decompiler_comments or [],
+			"disassembly_comments": disassembly_comments or [],
+			"plate_comment": plate_comment
+		}
+
+		return ghidra_context.http_client.safe_post_json("batch_set_comments", payload)
+
 	@mcp.tool()
 	def set_decompiler_comment(address: str, comment: str) -> str:
 		"""
@@ -39,3 +70,25 @@ def set_disassembly_comment(address: str, comment: str) -> str:
 			raise GhidraValidationError(f"Invalid hexadecimal address: {address}")
 
 		return ghidra_context.http_client.safe_post("set_disassembly_comment", {"address": address, "comment": comment})
+
+
+	@mcp.tool()
+	def set_plate_comment(
+		function_address: str,
+		comment: str
+	) -> str:
+		"""
+		Set function plate (header) comment (v1.5.0).
+		This comment appears above the function in both disassembly and decompiler views.
+
+		Args:
+			function_address: Function address in hex format (e.g., "0x401000")
+			comment: Function header summary comment
+
+		Returns:
+			Success or failure message
+		"""
+		validate_hex_address(function_address)
+
+		params = {"function_address": function_address, "comment": comment}
+		return ghidra_context.http_client.safe_post("set_plate_comment", params)

bridge_mcp_ghidra/tools/functions.py

@@ -1,9 +1,65 @@
 from mcp.server.fastmcp import FastMCP
-from ..context import ghidra_context, GhidraValidationError, validate_function_name, validate_hex_address
+from ..context import ghidra_context, GhidraValidationError, validate_hex_address
 
 def register_function_tools(mcp: FastMCP):
 	"""Register function-related tools to the FastMCP instance."""
 
+	@mcp.tool()
+	def analyze_function_completeness(
+		function_address: str
+	) -> str:
+		"""
+		Analyze how completely a function has been documented (v1.5.0).
+		Checks for custom names, prototypes, comments, and undefined variables.
+
+		Args:
+			function_address: Function address in hex format
+
+		Returns:
+			JSON with completeness analysis including:
+			- has_custom_name, has_prototype, has_calling_convention
+			- has_plate_comment, undefined_variables
+			- completeness_score (0-100)
+		"""
+		validate_hex_address(function_address)
+
+		params = {"function_address": function_address}
+		return ghidra_context.http_client.safe_get("analyze_function_completeness", params)
+
+	@mcp.tool()
+	def batch_rename_function_components(
+		function_address: str,
+		function_name: str = None,
+		parameter_renames: dict = None,
+		local_renames: dict = None,
+		return_type: str = None
+	) -> str:
+		"""
+		Rename function and all its components atomically (v1.5.0).
+		Combines multiple rename operations into a single transaction.
+
+		Args:
+			function_address: Function address in hex format
+			function_name: New name for the function (optional)
+			parameter_renames: Dict of {"old_name": "new_name"} for parameters
+			local_renames: Dict of {"old_name": "new_name"} for local variables
+			return_type: New return type (optional)
+
+		Returns:
+			JSON with success status and counts of renamed components
+		"""
+		validate_hex_address(function_address)
+
+		payload = {
+			"function_address": function_address,
+			"function_name": function_name,
+			"parameter_renames": parameter_renames or {},
+			"local_renames": local_renames or {},
+			"return_type": return_type
+		}
+
+		return ghidra_context.http_client.safe_post_json("batch_rename_function_components", payload)
+
 	@mcp.tool()
 	def create_function_signature(name: str, return_type: str, parameters: str = None) -> str:
 		"""
@@ -66,6 +122,37 @@ def disassemble_function(address: str) -> list:
 
 		return ghidra_context.http_client.safe_get("disassemble_function", {"address": address})
 
+	@mcp.tool()
+	def find_next_undefined_function(
+		start_address: str = None,
+		criteria: str = "name_pattern",
+		pattern: str = "FUN_",
+		direction: str = "ascending"
+	) -> str:
+		"""
+		Find the next function needing analysis (v1.5.0).
+		Intelligently searches for functions matching specified criteria.
+
+		Args:
+			start_address: Starting address for search (default: program min address)
+			criteria: Search criteria (default: "name_pattern")
+			pattern: Name pattern to match (default: "FUN_")
+			direction: Search direction "ascending" or "descending" (default: "ascending")
+
+		Returns:
+			JSON with found function details or {"found": false}
+		"""
+		if start_address:
+			validate_hex_address(start_address)
+
+		params = {
+			"start_address": start_address,
+			"criteria": criteria,
+			"pattern": pattern,
+			"direction": direction
+		}
+		return ghidra_context.http_client.safe_get("find_next_undefined_function", params)
+
 	@mcp.tool()
 	def get_current_function() -> str:
 		"""

bridge_mcp_ghidra/tools/labels.py

@@ -4,6 +4,47 @@
 def register_label_tools(mcp: FastMCP):
 	"""Register label-related tools in the MCP instance."""
 
+	@mcp.tool()
+	def batch_create_labels(labels: list) -> str:
+		"""
+		Create multiple labels in a single atomic operation (v1.5.1).
+
+		This tool creates multiple labels in one transaction, dramatically reducing API calls
+		and preventing user interruption hooks from triggering repeatedly. This is the
+		preferred method for creating multiple labels during function documentation.
+
+		Performance impact:
+		- Reduces N API calls to 1 call
+		- Prevents interruption after each label creation
+		- Atomic transaction ensures all-or-nothing semantics
+
+		Args:
+			labels: List of label objects, each with "address" and "name" fields
+					Example: [{"address": "0x6faeb266", "name": "begin_slot_processing"},
+							{"address": "0x6faeb280", "name": "loop_check_slot_active"}]
+
+		Returns:
+			JSON string with success status, counts, and any errors:
+			{"success": true, "labels_created": 5, "labels_skipped": 1, "labels_failed": 0}
+		"""
+		if not labels or not isinstance(labels, list):
+			raise GhidraValidationError("labels must be a non-empty list")
+
+		# Validate each label entry
+		for i, label in enumerate(labels):
+			if not isinstance(label, dict):
+				raise GhidraValidationError(f"Label at index {i} must be a dictionary")
+
+			if "address" not in label or "name" not in label:
+				raise GhidraValidationError(f"Label at index {i} must have 'address' and 'name' fields")
+
+			if not validate_hex_address(label["address"]):
+				raise GhidraValidationError(f"Invalid hexadecimal address at index {i}: {label['address']}")
+
+		return safe_post_json("batch_create_labels", {
+			"labels": labels
+		})
+
 	@mcp.tool()
 	def create_label(address: str, name: str) -> str:
 		"""
@@ -49,12 +90,29 @@ def rename_data(address: str, new_name: str) -> str:
 		"""
 		Rename a data label at the specified address.
 		
+		IMPORTANT: This tool only works for DEFINED data (data with an existing symbol/type).
+		For undefined memory addresses, use create_label() or rename_or_label() instead.
+
+		What is "defined data"?
+		- Data that has been typed (e.g., dword, struct, array)
+		- Data created via apply_data_type() or Ghidra's "D" key
+		- Data with existing symbols in the Symbol Tree
+
+		If you get an error like "No defined data at address", use:
+		- create_label(address, name) for undefined addresses
+		- rename_or_label(address, name) for automatic detection (recommended)
+
 		Args:
 			address: Memory address in hex format (e.g., "0x1400010a0")
 			new_name: New name for the data label
-			
+
 		Returns:
 			Success or failure message indicating the result of the rename operation
+
+		See Also:
+			- create_label(): Create label at undefined address
+			- rename_or_label(): Automatically detect and use correct method
+			- apply_data_type(): Define data type before renaming
 		"""
 
 		if not validate_hex_address(address):