ida_add_function_comment

Instructions

Implementation Reference

• plugin/ida_mcp_server_plugin/ida_mcp_core.py:669-712 (handler)

  Core IDA Pro implementation of the tool: validates inputs, finds function by name, calls idc.set_func_cmt(func_addr, comment, is_repeatable) to add the comment, refreshes views.

  def add_function_comment(self, function_name: str, comment: str, is_repeatable: bool) -> Dict[str, Any]:
      """Add a comment to a function"""
      return self._add_function_comment_internal(function_name, comment, is_repeatable)
      
  def _add_function_comment_internal(self, function_name: str, comment: str, is_repeatable: bool) -> Dict[str, Any]:
      """Internal implementation for add_function_comment without sync wrapper"""
      try:
          # Parameter validation
          if not function_name:
              return {"success": False, "message": "Function name cannot be empty"}
          if not comment:
              # Allow empty comment to clear the comment
              comment = ""
          
          # Get function address
          func_addr: int = ida_name.get_name_ea(0, function_name)
          if func_addr == idaapi.BADADDR:
              return {"success": False, "message": f"Function '{function_name}' not found"}
          
          # Check if it's a function
          func: Optional[ida_funcs.func_t] = ida_funcs.get_func(func_addr)
          if not func:
              return {"success": False, "message": f"'{function_name}' is not a function"}
          
          # Open pseudocode view
          ida_hexrays.open_pseudocode(func_addr, 0)
          
          # Add function comment
          # is_repeatable=True means show comment at all references to this function
          # is_repeatable=False means show comment only at function definition
          result: bool = idc.set_func_cmt(func_addr, comment, is_repeatable)
          
          if result:
              # Refresh view
              self._refresh_view_internal()
              comment_type: str = "repeatable" if is_repeatable else "regular"
              return {"success": True, "message": f"Added {comment_type} comment to function '{function_name}'"}
          else:
              return {"success": False, "message": f"Failed to add comment to function '{function_name}'"}
      
      except Exception as e:
          print(f"Error adding function comment: {str(e)}")
          traceback.print_exc()
          return {"success": False, "message": str(e)}

• src/mcp_server_ida/server.py:1153-1162 (handler)

  MCP server tool handler: calls IDAProFunctions.add_function_comment with parsed arguments and returns result as TextContent.

  case IDATools.ADD_FUNCTION_COMMENT:
      result: str = ida_functions.add_function_comment(
          arguments["function_name"], 
          arguments["comment"], 
          arguments.get("is_repeatable", False)
      )
      return [TextContent(
          type="text",
          text=result
      )]

• src/mcp_server_ida/server.py:70-73 (schema)

  Pydantic model defining input schema for the tool: function_name, comment, optional is_repeatable.

  class AddFunctionComment(BaseModel):
      function_name: str
      comment: str
      is_repeatable: bool = False  # Whether the comment should be repeatable

• src/mcp_server_ida/server.py:994-997 (registration)

  Tool registration in MCP server's list_tools(): name, description, inputSchema.

      name=IDATools.ADD_FUNCTION_COMMENT,
      description="Add a comment to a function in the IDA database",
      inputSchema=AddFunctionComment.schema(),
  ),

• src/mcp_server_ida/server.py:681-702 (helper)

  Proxy method in IDAProFunctions class that sends 'add_function_comment' request to IDA plugin via communicator and formats response.

  def add_function_comment(self, function_name: str, comment: str, is_repeatable: bool = False) -> str:
      """Add a comment to a function"""
      try:
          response: Dict[str, Any] = self.communicator.send_request(
              "add_function_comment", 
              {"function_name": function_name, "comment": comment, "is_repeatable": is_repeatable}
          )
          
          if "error" in response:
              return f"Error adding comment to function '{function_name}': {response['error']}"
          
          success: bool = response.get("success", False)
          message: str = response.get("message", "")
          
          if success:
              comment_type: str = "repeatable" if is_repeatable else "regular"
              return f"Successfully added {comment_type} comment to function '{function_name}': {message}"
          else:
              return f"Failed to add comment to function '{function_name}': {message}"
      except Exception as e:
          self.logger.error(f"Error adding function comment: {str(e)}", exc_info=True)
          return f"Error adding comment to function '{function_name}': {str(e)}"