diff --git a/pldmtool/oem/ibm/pldm_oem_ibm.cpp b/pldmtool/oem/ibm/pldm_oem_ibm.cpp
index b1da2a6..317dbfa 100644
--- a/pldmtool/oem/ibm/pldm_oem_ibm.cpp
+++ b/pldmtool/oem/ibm/pldm_oem_ibm.cpp
@@ -50,8 +50,8 @@
 
     std::pair<int, std::vector<uint8_t>> createRequestMsg() override
     {
-        std::vector<uint8_t> requestMsg(sizeof(pldm_msg_hdr) +
-                                        PLDM_GET_ALERT_STATUS_REQ_BYTES);
+        std::vector<uint8_t> requestMsg(
+            sizeof(pldm_msg_hdr) + PLDM_GET_ALERT_STATUS_REQ_BYTES);
         auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
 
         auto rc = encode_get_alert_status_req(instanceId, versionId, request,
@@ -64,9 +64,9 @@
         uint8_t completionCode = 0;
         uint32_t rack_entry = 0;
         uint32_t pri_cec_node = 0;
-        auto rc = decode_get_alert_status_resp(responsePtr, payloadLength,
-                                               &completionCode, &rack_entry,
-                                               &pri_cec_node);
+        auto rc = decode_get_alert_status_resp(
+            responsePtr, payloadLength, &completionCode, &rack_entry,
+            &pri_cec_node);
 
         if (rc != PLDM_SUCCESS || completionCode != PLDM_SUCCESS)
         {
@@ -111,8 +111,8 @@
     void parseResponseMsg(pldm_msg*, size_t) override {}
     void exec() override
     {
-        std::vector<uint8_t> requestMsg(sizeof(pldm_msg_hdr) +
-                                        PLDM_GET_FILE_TABLE_REQ_BYTES);
+        std::vector<uint8_t> requestMsg(
+            sizeof(pldm_msg_hdr) + PLDM_GET_FILE_TABLE_REQ_BYTES);
 
         auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
 
@@ -152,8 +152,8 @@
             return;
         }
 
-        auto tableData = reinterpret_cast<uint8_t*>((responsePtr->payload) +
-                                                    table_data_start_offset);
+        auto tableData = reinterpret_cast<uint8_t*>(
+            (responsePtr->payload) + table_data_start_offset);
         printFileAttrTable(tableData, fileTableDataLength);
     }
 
@@ -208,8 +208,8 @@
     commands.push_back(std::make_unique<GetAlertStatus>(
         "oem_ibm", "getAlertStatus", getAlertStatus));
 
-    auto getFileTable = oem_ibm->add_subcommand("GetFileTable",
-                                                "get file table");
+    auto getFileTable =
+        oem_ibm->add_subcommand("GetFileTable", "get file table");
 
     commands.push_back(std::make_unique<GetFileTable>("oem_ibm", "getFileTable",
                                                       getFileTable));
diff --git a/pldmtool/pldm_base_cmd.cpp b/pldmtool/pldm_base_cmd.cpp
index 9d6449a..5d02a7f 100644
--- a/pldmtool/pldm_base_cmd.cpp
+++ b/pldmtool/pldm_base_cmd.cpp
@@ -162,8 +162,8 @@
     }
     std::pair<int, std::vector<uint8_t>> createRequestMsg() override
     {
-        std::vector<uint8_t> requestMsg(sizeof(pldm_msg_hdr) +
-                                        PLDM_GET_VERSION_REQ_BYTES);
+        std::vector<uint8_t> requestMsg(
+            sizeof(pldm_msg_hdr) + PLDM_GET_VERSION_REQ_BYTES);
         auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
 
         auto rc = encode_get_version_req(instanceId, 0, PLDM_GET_FIRSTPART,
@@ -176,9 +176,9 @@
         uint8_t cc = 0, transferFlag = 0;
         uint32_t transferHandle = 0;
         ver32_t version;
-        auto rc = decode_get_version_resp(responsePtr, payloadLength, &cc,
-                                          &transferHandle, &transferFlag,
-                                          &version);
+        auto rc =
+            decode_get_version_resp(responsePtr, payloadLength, &cc,
+                                    &transferHandle, &transferFlag, &version);
         if (rc != PLDM_SUCCESS || cc != PLDM_SUCCESS)
         {
             std::cerr << "Response Message Error: "
@@ -252,8 +252,7 @@
     GetPLDMCommands& operator=(GetPLDMCommands&&) = delete;
 
     explicit GetPLDMCommands(const char* type, const char* name,
-                             CLI::App* app) :
-        CommandInterface(type, name, app)
+                             CLI::App* app) : CommandInterface(type, name, app)
     {
         app->add_option("-t,--type", pldmType, "pldm supported type")
             ->required()
@@ -266,8 +265,8 @@
 
     std::pair<int, std::vector<uint8_t>> createRequestMsg() override
     {
-        std::vector<uint8_t> requestMsg(sizeof(pldm_msg_hdr) +
-                                        PLDM_GET_COMMANDS_REQ_BYTES);
+        std::vector<uint8_t> requestMsg(
+            sizeof(pldm_msg_hdr) + PLDM_GET_COMMANDS_REQ_BYTES);
         auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
         ver32_t version{0xFF, 0xFF, 0xFF, 0xFF};
         if (inputVersion.size() != 0)
@@ -285,8 +284,8 @@
                 version.alpha = inputVersion[0];
             }
         }
-        auto rc = encode_get_commands_req(instanceId, pldmType, version,
-                                          request);
+        auto rc =
+            encode_get_commands_req(instanceId, pldmType, version, request);
         return {rc, requestMsg};
     }
 
@@ -367,13 +366,13 @@
     auto base = app.add_subcommand("base", "base type command");
     base->require_subcommand(1);
 
-    auto getPLDMTypes = base->add_subcommand("GetPLDMTypes",
-                                             "get pldm supported types");
+    auto getPLDMTypes =
+        base->add_subcommand("GetPLDMTypes", "get pldm supported types");
     commands.push_back(
         std::make_unique<GetPLDMTypes>("base", "GetPLDMTypes", getPLDMTypes));
 
-    auto getPLDMVersion = base->add_subcommand("GetPLDMVersion",
-                                               "get version of a certain type");
+    auto getPLDMVersion =
+        base->add_subcommand("GetPLDMVersion", "get version of a certain type");
     commands.push_back(std::make_unique<GetPLDMVersion>(
         "base", "GetPLDMVersion", getPLDMVersion));
 
diff --git a/pldmtool/pldm_bios_cmd.cpp b/pldmtool/pldm_bios_cmd.cpp
index 1510617..160afd7 100644
--- a/pldmtool/pldm_bios_cmd.cpp
+++ b/pldmtool/pldm_bios_cmd.cpp
@@ -60,9 +60,9 @@
 
         uint8_t seconds, minutes, hours, day, month;
         uint16_t year;
-        auto rc = decode_get_date_time_resp(responsePtr, payloadLength, &cc,
-                                            &seconds, &minutes, &hours, &day,
-                                            &month, &year);
+        auto rc =
+            decode_get_date_time_resp(responsePtr, payloadLength, &cc, &seconds,
+                                      &minutes, &hours, &day, &month, &year);
         if (rc != PLDM_SUCCESS || cc != PLDM_SUCCESS)
         {
             std::cerr << "Response Message Error: "
@@ -110,8 +110,8 @@
 
     std::pair<int, std::vector<uint8_t>> createRequestMsg() override
     {
-        std::vector<uint8_t> requestMsg(sizeof(pldm_msg_hdr) +
-                                        sizeof(struct pldm_set_date_time_req));
+        std::vector<uint8_t> requestMsg(
+            sizeof(pldm_msg_hdr) + sizeof(struct pldm_set_date_time_req));
         auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
         uint16_t year = 0;
         uint8_t month = 0;
@@ -195,8 +195,8 @@
 
     std::optional<Table> getBIOSTable(pldm_bios_table_types tableType)
     {
-        std::vector<uint8_t> requestMsg(sizeof(pldm_msg_hdr) +
-                                        PLDM_GET_BIOS_TABLE_REQ_BYTES);
+        std::vector<uint8_t> requestMsg(
+            sizeof(pldm_msg_hdr) + PLDM_GET_BIOS_TABLE_REQ_BYTES);
         auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
 
         auto rc = encode_get_bios_table_req(instanceId, 0, PLDM_GET_FIRSTPART,
@@ -266,9 +266,9 @@
         return nullptr;
     }
 
-    std::optional<uint16_t> findAttrHandleByName(const std::string& name,
-                                                 const Table& attrTable,
-                                                 const Table& stringTable)
+    std::optional<uint16_t>
+        findAttrHandleByName(const std::string& name, const Table& attrTable,
+                             const Table& stringTable)
     {
         auto attribute = findAttrEntryByName(name, attrTable, stringTable);
         if (attribute == nullptr)
@@ -334,8 +334,8 @@
             return displayString;
         }
         uint8_t pvNum;
-        int rc = pldm_bios_table_attr_entry_enum_decode_pv_num(attrEntry,
-                                                               &pvNum);
+        int rc =
+            pldm_bios_table_attr_entry_enum_decode_pv_num(attrEntry, &pvNum);
         if (rc != PLDM_SUCCESS)
         {
             return displayString;
@@ -628,9 +628,9 @@
                         entry, defString.data(), defString.size());
 
                     std::stringstream stringtype;
-                    stringtype << "0x" << std::hex << std::setw(2)
-                               << std::setfill('0') << (int)strType << std::dec
-                               << std::setw(0);
+                    stringtype
+                        << "0x" << std::hex << std::setw(2) << std::setfill('0')
+                        << (int)strType << std::dec << std::setw(0);
                     attrdata["StringType"] = stringtype.str();
                     attrdata["MinimumStringLength"] = (int)min;
                     attrdata["MaximumStringLength"] = (int)max;
@@ -640,8 +640,8 @@
                 }
                 case PLDM_BIOS_PASSWORD:
                 case PLDM_BIOS_PASSWORD_READ_ONLY:
-                    std::cout << "Password attribute: Not Supported"
-                              << std::endl;
+                    std::cout
+                        << "Password attribute: Not Supported" << std::endl;
             }
             output.emplace_back(std::move(attrdata));
         }
@@ -682,9 +682,8 @@
     GetBIOSAttributeCurrentValueByHandle&
         operator=(GetBIOSAttributeCurrentValueByHandle&&) = delete;
 
-    explicit GetBIOSAttributeCurrentValueByHandle(const char* type,
-                                                  const char* name,
-                                                  CLI::App* app) :
+    explicit GetBIOSAttributeCurrentValueByHandle(
+        const char* type, const char* name, CLI::App* app) :
         GetBIOSTableHandler(type, name, app)
     {
         app->add_option("-a, --attribute", attrName, "pldm BIOS attribute name")
@@ -796,8 +795,8 @@
             return;
         }
 
-        auto attrEntry = findAttrEntryByName(attrName, *attrTable,
-                                             *stringTable);
+        auto attrEntry =
+            findAttrEntryByName(attrName, *attrTable, *stringTable);
         if (attrEntry == nullptr)
         {
             std::cout << "Could not find attribute :" << attrName << std::endl;
@@ -963,8 +962,8 @@
     commands.push_back(
         std::make_unique<GetDateTime>("bios", "GetDateTime", getDateTime));
 
-    auto setDateTime = bios->add_subcommand("SetDateTime",
-                                            "set host date time");
+    auto setDateTime =
+        bios->add_subcommand("SetDateTime", "set host date time");
     commands.push_back(
         std::make_unique<SetDateTime>("bios", "setDateTime", setDateTime));
 
diff --git a/pldmtool/pldm_cmd_helper.cpp b/pldmtool/pldm_cmd_helper.cpp
index afd49dd..1de5b8d 100644
--- a/pldmtool/pldm_cmd_helper.cpp
+++ b/pldmtool/pldm_cmd_helper.cpp
@@ -73,9 +73,9 @@
         void* responseMessage = nullptr;
         size_t responseMessageSize{};
 
-        rc = pldmTransport.sendRecvMsg(tid, requestMsg.data(),
-                                       requestMsg.size(), responseMessage,
-                                       responseMessageSize);
+        rc =
+            pldmTransport.sendRecvMsg(tid, requestMsg.data(), requestMsg.size(),
+                                      responseMessage, responseMessageSize);
         if (rc)
         {
             std::cerr << "[" << unsigned(retry) << "] pldm_send_recv error rc "
diff --git a/pldmtool/pldm_cmd_helper.hpp b/pldmtool/pldm_cmd_helper.hpp
index a59bb66..e668974 100644
--- a/pldmtool/pldm_cmd_helper.hpp
+++ b/pldmtool/pldm_cmd_helper.hpp
@@ -78,9 +78,8 @@
   public:
     explicit CommandInterface(const char* type, const char* name,
                               CLI::App* app) :
-        pldmType(type),
-        commandName(name), mctp_eid(PLDM_ENTITY_ID), pldmVerbose(false),
-        instanceId(0)
+        pldmType(type), commandName(name), mctp_eid(PLDM_ENTITY_ID),
+        pldmVerbose(false), instanceId(0)
     {
         app->add_option("-m,--mctp_eid", mctp_eid, "MCTP endpoint ID");
         app->add_flag("-v, --verbose", pldmVerbose);
diff --git a/pldmtool/pldm_fru_cmd.cpp b/pldmtool/pldm_fru_cmd.cpp
index 6d57656..b67d1bd 100644
--- a/pldmtool/pldm_fru_cmd.cpp
+++ b/pldmtool/pldm_fru_cmd.cpp
@@ -100,8 +100,8 @@
                 reinterpret_cast<const pldm_fru_record_data_format*>(p);
             output["FRU Record Set Identifier"] =
                 (int)le16toh(record->record_set_id);
-            output["FRU Record Type"] = typeToString(fruRecordTypes,
-                                                     record->record_type);
+            output["FRU Record Type"] =
+                typeToString(fruRecordTypes, record->record_type);
             output["Number of FRU fields"] = (int)record->num_fru_fields;
             output["Encoding Type for FRU fields"] =
                 typeToString(fruEncodingType, record->encoding_type);
@@ -124,22 +124,22 @@
                                            fruGeneralFieldTypes.end());
                     if (tlv->type == PLDM_FRU_FIELD_TYPE_IANA)
                     {
-                        fruFieldValue = fruFieldParserU32(tlv->value,
-                                                          tlv->length);
+                        fruFieldValue =
+                            fruFieldParserU32(tlv->value, tlv->length);
                     }
                     else if (tlv->type == PLDM_FRU_FIELD_TYPE_MANUFAC_DATE)
                     {
-                        fruFieldValue = fruFieldParserTimestamp(tlv->value,
-                                                                tlv->length);
+                        fruFieldValue =
+                            fruFieldParserTimestamp(tlv->value, tlv->length);
                     }
                     else
                     {
-                        fruFieldValue = fruFieldValuestring(tlv->value,
-                                                            tlv->length);
+                        fruFieldValue =
+                            fruFieldValuestring(tlv->value, tlv->length);
                     }
 
-                    frudata["FRU Field Type"] = typeToString(FruFieldTypeMap,
-                                                             tlv->type);
+                    frudata["FRU Field Type"] =
+                        typeToString(FruFieldTypeMap, tlv->type);
                     frudata["FRU Field Length"] = (int)(tlv->length);
                     frudata["FRU Field Value"] = fruFieldValue;
                     frufielddata.emplace_back(frudata);
@@ -149,8 +149,8 @@
 #ifdef OEM_IBM
                     if (tlv->type == PLDM_OEM_FRU_FIELD_TYPE_RT)
                     {
-                        auto oemIPZValue = fruFieldValuestring(tlv->value,
-                                                               tlv->length);
+                        auto oemIPZValue =
+                            fruFieldValuestring(tlv->value, tlv->length);
 
                         if (populateMaps.contains(oemIPZValue))
                         {
@@ -167,21 +167,21 @@
                     }
                     if (tlv->type == PLDM_OEM_FRU_FIELD_TYPE_IANA)
                     {
-                        fruFieldValue = fruFieldParserU32(tlv->value,
-                                                          tlv->length);
+                        fruFieldValue =
+                            fruFieldParserU32(tlv->value, tlv->length);
                     }
                     else if (tlv->type != 2)
                     {
-                        fruFieldValue = fruFieldIPZParser(tlv->value,
-                                                          tlv->length);
+                        fruFieldValue =
+                            fruFieldIPZParser(tlv->value, tlv->length);
                     }
                     else
                     {
-                        fruFieldValue = fruFieldValuestring(tlv->value,
-                                                            tlv->length);
+                        fruFieldValue =
+                            fruFieldValuestring(tlv->value, tlv->length);
                     }
-                    frudata["FRU Field Type"] = typeToString(FruFieldTypeMap,
-                                                             tlv->type);
+                    frudata["FRU Field Type"] =
+                        typeToString(FruFieldTypeMap, tlv->type);
                     frudata["FRU Field Length"] = (int)(tlv->length);
                     frudata["FRU Field Value"] = fruFieldValue;
                     frufielddata.emplace_back(frudata);
@@ -412,8 +412,8 @@
     using CommandInterface::CommandInterface;
     std::pair<int, std::vector<uint8_t>> createRequestMsg() override
     {
-        std::vector<uint8_t> requestMsg(sizeof(pldm_msg_hdr) +
-                                        PLDM_GET_FRU_RECORD_TABLE_REQ_BYTES);
+        std::vector<uint8_t> requestMsg(
+            sizeof(pldm_msg_hdr) + PLDM_GET_FRU_RECORD_TABLE_REQ_BYTES);
         auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
 
         auto rc = encode_get_fru_record_table_req(
@@ -456,13 +456,13 @@
     commands.push_back(std::make_unique<GetFruRecordTableMetadata>(
         "fru", "GetFruRecordTableMetadata", getFruRecordTableMetadata));
 
-    auto getFRURecordByOption = fru->add_subcommand("GetFRURecordByOption",
-                                                    "get FRU Record By Option");
+    auto getFRURecordByOption =
+        fru->add_subcommand("GetFRURecordByOption", "get FRU Record By Option");
     commands.push_back(std::make_unique<GetFRURecordByOption>(
         "fru", "GetFRURecordByOption", getFRURecordByOption));
 
-    auto getFruRecordTable = fru->add_subcommand("GetFruRecordTable",
-                                                 "get FRU Record Table");
+    auto getFruRecordTable =
+        fru->add_subcommand("GetFruRecordTable", "get FRU Record Table");
     commands.push_back(std::make_unique<GetFruRecordTable>(
         "fru", "GetFruRecordTable", getFruRecordTable));
 }
diff --git a/pldmtool/pldm_fw_update_cmd.cpp b/pldmtool/pldm_fw_update_cmd.cpp
index 25ab259..cfd4608 100644
--- a/pldmtool/pldm_fw_update_cmd.cpp
+++ b/pldmtool/pldm_fw_update_cmd.cpp
@@ -86,8 +86,8 @@
 
     std::pair<int, std::vector<uint8_t>> createRequestMsg() override
     {
-        std::vector<uint8_t> requestMsg(sizeof(pldm_msg_hdr) +
-                                        PLDM_GET_STATUS_REQ_BYTES);
+        std::vector<uint8_t> requestMsg(
+            sizeof(pldm_msg_hdr) + PLDM_GET_STATUS_REQ_BYTES);
         auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
         auto rc = encode_get_status_req(instanceId, request,
                                         PLDM_GET_STATUS_REQ_BYTES);
@@ -176,8 +176,8 @@
 
     std::pair<int, std::vector<uint8_t>> createRequestMsg() override
     {
-        std::vector<uint8_t> requestMsg(sizeof(pldm_msg_hdr) +
-                                        PLDM_GET_FIRMWARE_PARAMETERS_REQ_BYTES);
+        std::vector<uint8_t> requestMsg(
+            sizeof(pldm_msg_hdr) + PLDM_GET_FIRMWARE_PARAMETERS_REQ_BYTES);
         auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
         auto rc = encode_get_firmware_parameters_req(
             instanceId, PLDM_GET_FIRMWARE_PARAMETERS_REQ_BYTES, request);
@@ -397,9 +397,9 @@
 
             compParamPtr += sizeof(pldm_component_parameter_entry) +
                             activeCompVerStr.length + pendingCompVerStr.length;
-            compParamTableLen -= sizeof(pldm_component_parameter_entry) +
-                                 activeCompVerStr.length +
-                                 pendingCompVerStr.length;
+            compParamTableLen -=
+                sizeof(pldm_component_parameter_entry) +
+                activeCompVerStr.length + pendingCompVerStr.length;
             compDataEntries.push_back(compData);
         }
         data["ComponentParameterEntries"] = compDataEntries;
@@ -493,9 +493,9 @@
             }
         }
         // Entry is not present, add type and value to json response
-        ordered_json descriptor =
-            ordered_json::object({{"Type", descriptorName.at(descriptorType)},
-                                  {"Value", ordered_json::array()}});
+        ordered_json descriptor = ordered_json::object(
+            {{"Type", descriptorName.at(descriptorType)},
+             {"Value", ordered_json::array()}});
         if (descriptorType != PLDM_FWUP_VENDOR_DEFINED)
         {
             descriptor["Value"].emplace_back(descDataStream.str());
@@ -517,8 +517,8 @@
 }
 std::pair<int, std::vector<uint8_t>> QueryDeviceIdentifiers::createRequestMsg()
 {
-    std::vector<uint8_t> requestMsg(sizeof(pldm_msg_hdr) +
-                                    PLDM_QUERY_DEVICE_IDENTIFIERS_REQ_BYTES);
+    std::vector<uint8_t> requestMsg(
+        sizeof(pldm_msg_hdr) + PLDM_QUERY_DEVICE_IDENTIFIERS_REQ_BYTES);
     auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
     auto rc = encode_query_device_identifiers_req(
         instanceId, PLDM_QUERY_DEVICE_IDENTIFIERS_REQ_BYTES, request);
@@ -613,8 +613,8 @@
 
 void registerCommand(CLI::App& app)
 {
-    auto fwUpdate = app.add_subcommand("fw_update",
-                                       "firmware update type commands");
+    auto fwUpdate =
+        app.add_subcommand("fw_update", "firmware update type commands");
     fwUpdate->require_subcommand(1);
 
     auto getStatus = fwUpdate->add_subcommand("GetStatus", "Status of the FD");
diff --git a/pldmtool/pldm_platform_cmd.cpp b/pldmtool/pldm_platform_cmd.cpp
index b952534..6a07a38 100644
--- a/pldmtool/pldm_platform_cmd.cpp
+++ b/pldmtool/pldm_platform_cmd.cpp
@@ -100,14 +100,15 @@
             "eg: The recordHandle value for the PDR to be retrieved and 0 "
             "means get first PDR in the repository.");
         pdrRecType = "";
-        pdrOptionGroup->add_option("-t, --type", pdrRecType,
-                                   "retrieve all PDRs of the requested type\n"
-                                   "supported types:\n"
-                                   "[terminusLocator, stateSensor, "
-                                   "numericEffecter, stateEffecter, "
-                                   "compactNumericSensor, sensorauxname, "
-                                   "efffecterAuxName, numericsensor, "
-                                   "EntityAssociation, fruRecord, ... ]");
+        pdrOptionGroup->add_option(
+            "-t, --type", pdrRecType,
+            "retrieve all PDRs of the requested type\n"
+            "supported types:\n"
+            "[terminusLocator, stateSensor, "
+            "numericEffecter, stateEffecter, "
+            "compactNumericSensor, sensorauxname, "
+            "efffecterAuxName, numericsensor, "
+            "EntityAssociation, fruRecord, ... ]");
 
         getPDRGroupOption = pdrOptionGroup->add_option(
             "-i, --terminusID", pdrTerminus,
@@ -190,8 +191,8 @@
                 }
 
                 // check for circular references.
-                auto result = recordsSeen.emplace(recordHandle,
-                                                  prevRecordHandle);
+                auto result =
+                    recordsSeen.emplace(recordHandle, prevRecordHandle);
                 if (!result.second && !nextPartRequired)
                 {
                     std::cerr
@@ -223,8 +224,8 @@
 
     std::pair<int, std::vector<uint8_t>> createRequestMsg() override
     {
-        std::vector<uint8_t> requestMsg(sizeof(pldm_msg_hdr) +
-                                        PLDM_GET_PDR_REQ_BYTES);
+        std::vector<uint8_t> requestMsg(
+            sizeof(pldm_msg_hdr) + PLDM_GET_PDR_REQ_BYTES);
         auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
 
         auto rc = encode_get_pdr_req(
@@ -718,9 +719,8 @@
         }
     }
 
-    std::vector<std::string>
-        getStateSetPossibleStateNames(uint16_t stateId,
-                                      const std::vector<uint8_t>& value)
+    std::vector<std::string> getStateSetPossibleStateNames(
+        uint16_t stateId, const std::vector<uint8_t>& value)
     {
         std::vector<std::string> data{};
 
@@ -957,12 +957,12 @@
             ptr += sizeof(uint8_t);
             for (auto j : std::views::iota(0, (int)nameStringCount))
             {
-                std::string nameLanguageTagKey = sPrefix + std::to_string(j) +
-                                                 "_nameLanguageTag" +
-                                                 std::to_string(i);
-                std::string entityAuxNameKey = sPrefix + std::to_string(j) +
-                                               "_entityAuxName" +
-                                               std::to_string(i);
+                std::string nameLanguageTagKey =
+                    sPrefix + std::to_string(j) + "_nameLanguageTag" +
+                    std::to_string(i);
+                std::string entityAuxNameKey =
+                    sPrefix + std::to_string(j) + "_entityAuxName" +
+                    std::to_string(i);
                 std::string nameLanguageTag(reinterpret_cast<const char*>(ptr),
                                             0, PLDM_STR_UTF_8_MAX_LEN);
                 ptr += nameLanguageTag.size() + sizeof(nullTerminator);
@@ -1122,8 +1122,8 @@
         output["containerID"] = pdr->container_id;
         output["effecterSemanticID"] = pdr->effecter_semantic_id;
         output["effecterInit"] = effecterInit[pdr->effecter_init];
-        output["effecterDescriptionPDR"] = (pdr->has_description_pdr ? true
-                                                                     : false);
+        output["effecterDescriptionPDR"] =
+            (pdr->has_description_pdr ? true : false);
         output["compositeEffecterCount"] =
             unsigned(pdr->composite_effecter_count);
 
@@ -1269,8 +1269,8 @@
                                ordered_json& output)
     {
         struct pldm_numeric_sensor_value_pdr pdr;
-        int rc = decode_numeric_sensor_pdr_data(data, (size_t)data_length,
-                                                &pdr);
+        int rc =
+            decode_numeric_sensor_pdr_data(data, (size_t)data_length, &pdr);
         if (rc != PLDM_SUCCESS)
         {
             std::cerr << "Failed to get numeric sensor PDR" << std::endl;
@@ -1617,8 +1617,7 @@
     static constexpr auto minEffecterCount = 1;
     static constexpr auto maxEffecterCount = 8;
     explicit SetStateEffecter(const char* type, const char* name,
-                              CLI::App* app) :
-        CommandInterface(type, name, app)
+                              CLI::App* app) : CommandInterface(type, name, app)
     {
         app->add_option(
                "-i, --id", effecterId,
@@ -1882,8 +1881,7 @@
     GetSensorReading& operator=(GetSensorReading&&) = delete;
 
     explicit GetSensorReading(const char* type, const char* name,
-                              CLI::App* app) :
-        CommandInterface(type, name, app)
+                              CLI::App* app) : CommandInterface(type, name, app)
     {
         app->add_option(
                "-i, --sensor_id", sensorId,
@@ -1897,12 +1895,12 @@
 
     std::pair<int, std::vector<uint8_t>> createRequestMsg() override
     {
-        std::vector<uint8_t> requestMsg(sizeof(pldm_msg_hdr) +
-                                        PLDM_GET_SENSOR_READING_REQ_BYTES);
+        std::vector<uint8_t> requestMsg(
+            sizeof(pldm_msg_hdr) + PLDM_GET_SENSOR_READING_REQ_BYTES);
         auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
 
-        auto rc = encode_get_sensor_reading_req(instanceId, sensorId, rearm,
-                                                request);
+        auto rc =
+            encode_get_sensor_reading_req(instanceId, sensorId, rearm, request);
 
         return {rc, requestMsg};
     }
@@ -1934,15 +1932,15 @@
         }
 
         ordered_json output;
-        output["sensorDataSize"] = getSensorState(sensorDataSize,
-                                                  &sensorDataSz);
+        output["sensorDataSize"] =
+            getSensorState(sensorDataSize, &sensorDataSz);
         output["sensorOperationalState"] =
             getSensorState(sensorOperationalState, &sensorOpState);
         output["sensorEventMessageEnable"] =
             getSensorState(sensorEventMessageEnable, &sensorEventMsgEnable);
         output["presentState"] = getSensorState(presentState, &sensorPresState);
-        output["previousState"] = getSensorState(previousState,
-                                                 &sensorPresState);
+        output["previousState"] =
+            getSensorState(previousState, &sensorPresState);
         output["eventState"] = getSensorState(eventState, &sensorPresState);
 
         switch (sensorDataSize)
@@ -2070,9 +2068,8 @@
         if (rc || resp.completion_code != PLDM_SUCCESS)
         {
             std::cerr << "Response Message Error: "
-                      << "rc=" << rc
-                      << ",cc=" << static_cast<int>(resp.completion_code)
-                      << std::endl;
+                      << "rc=" << rc << ",cc="
+                      << static_cast<int>(resp.completion_code) << std::endl;
             return;
         }
         ordered_json output;
@@ -2150,9 +2147,8 @@
         if (rc != PLDM_SUCCESS || completionCode != PLDM_SUCCESS)
         {
             std::cerr << "Response Message Error: "
-                      << "rc=" << rc
-                      << ",cc=" << static_cast<int>(completionCode)
-                      << std::endl;
+                      << "rc=" << rc << ",cc="
+                      << static_cast<int>(completionCode) << std::endl;
             return;
         }
 
@@ -2231,8 +2227,8 @@
     auto platform = app.add_subcommand("platform", "platform type command");
     platform->require_subcommand(1);
 
-    auto getPDR = platform->add_subcommand("GetPDR",
-                                           "get platform descriptor records");
+    auto getPDR =
+        platform->add_subcommand("GetPDR", "get platform descriptor records");
     commands.push_back(std::make_unique<GetPDR>("platform", "getPDR", getPDR));
 
     auto setStateEffecterStates = platform->add_subcommand(
diff --git a/pldmtool/pldmtool.cpp b/pldmtool/pldmtool.cpp
index ff898d0..cdd157a 100644
--- a/pldmtool/pldmtool.cpp
+++ b/pldmtool/pldmtool.cpp
@@ -55,8 +55,8 @@
 
 void registerCommand(CLI::App& app)
 {
-    auto raw = app.add_subcommand("raw",
-                                  "send a raw request and print response");
+    auto raw =
+        app.add_subcommand("raw", "send a raw request and print response");
     commands.push_back(std::make_unique<RawOp>("raw", "raw", raw));
 }