tool_registration.cc

Go to the documentation of this file.

#include "cli/service/agent/tool_registration.h"
#include "cli/service/agent/tool_registry.h"
 
#include "cli/handlers/game/dialogue_commands.h"
#include "cli/handlers/game/dungeon_collision_commands.h"
#include "cli/handlers/game/dungeon_commands.h"
#include "cli/handlers/game/message_commands.h"
#include "cli/handlers/game/minecart_commands.h"
#include "cli/handlers/game/music_commands.h"
#include "cli/handlers/game/overworld_commands.h"
#include "cli/handlers/graphics/sprite_commands.h"
#include "cli/handlers/tools/test_helpers_commands.h"
#include "cli/service/resources/command_context.h"
#ifdef YAZE_WITH_GRPC
#include "cli/handlers/tools/emulator_commands.h"
#endif
#include "cli/handlers/tools/gui_commands.h"
#include "cli/handlers/tools/resource_commands.h"
#include "cli/service/agent/tools/build_tool.h"
#include "cli/service/agent/tools/code_gen_tool.h"
#include "cli/service/agent/tools/filesystem_tool.h"
#include "cli/service/agent/tools/memory_inspector_tool.h"
#include "cli/service/agent/tools/project_graph_tool.h"  // New tool
#include "cli/service/agent/tools/project_tool.h"
#include "cli/service/agent/tools/visual_analysis_tool.h"
 
namespace yaze {
namespace cli {
namespace agent {
 
using namespace yaze::cli::handlers;
using namespace yaze::cli::agent::tools;
 
namespace {
 
template <typename HandlerClass>
void RegisterBuiltinTool(ToolRegistry& registry, ToolDefinition definition) {
  registry.RegisterTool(std::move(definition),
                        []() { return std::make_unique<HandlerClass>(); });
}
 
#define REGISTER_BUILTIN_AGENT_TOOL(Name, Category, Desc, Usage, Examples, \
                                    ReqRom, ReqProject, HandlerClass)      \
  RegisterBuiltinTool<HandlerClass>(registry, {Name,                       \
                                               Category,                   \
                                               Desc,                       \
                                               Usage,                      \
                                               Examples,                   \
                                               ReqRom,                     \
                                               ReqProject,                 \
                                               ToolAccess::kReadOnly,      \
                                               {},                         \
                                               {}});
 
}  // namespace
 
// Placeholder classes for meta-tools (they're handled specially in the
// dispatcher) but still need handlers for registry metadata.
class MetaToolsListHandler : public resources::CommandHandler {
 public:
  std::string GetName() const override { return "tools-list"; }
  std::string GetUsage() const override { return "tools-list"; }
  bool RequiresRom() const override { return false; }
 
 protected:
  absl::Status ValidateArgs(const resources::ArgumentParser&) override {
    return absl::OkStatus();
  }
  absl::Status Execute(Rom*, const resources::ArgumentParser&,
                       resources::OutputFormatter&) override {
    return absl::UnimplementedError(
        "Handled by ToolDispatcher meta-tool handler");
  }
};
 
class MetaToolsDescribeHandler : public resources::CommandHandler {
 public:
  std::string GetName() const override { return "tools-describe"; }
  std::string GetUsage() const override {
    return "tools-describe --name=<tool>";
  }
  bool RequiresRom() const override { return false; }
 
 protected:
  absl::Status ValidateArgs(const resources::ArgumentParser&) override {
    return absl::OkStatus();
  }
  absl::Status Execute(Rom*, const resources::ArgumentParser&,
                       resources::OutputFormatter&) override {
    return absl::UnimplementedError(
        "Handled by ToolDispatcher meta-tool handler");
  }
};
 
class MetaToolsSearchHandler : public resources::CommandHandler {
 public:
  std::string GetName() const override { return "tools-search"; }
  std::string GetUsage() const override {
    return "tools-search --query=<keyword>";
  }
  bool RequiresRom() const override { return false; }
 
 protected:
  absl::Status ValidateArgs(const resources::ArgumentParser&) override {
    return absl::OkStatus();
  }
  absl::Status Execute(Rom*, const resources::ArgumentParser&,
                       resources::OutputFormatter&) override {
    return absl::UnimplementedError(
        "Handled by ToolDispatcher meta-tool handler");
  }
};
 
void RegisterBuiltinAgentTools(ToolRegistry& registry) {
  // Meta-tools (handled specially but registered for discovery)
  REGISTER_BUILTIN_AGENT_TOOL("tools-list", "meta", "List all available tools",
                              "tools-list", {}, false, false,
                              MetaToolsListHandler)
  REGISTER_BUILTIN_AGENT_TOOL("tools-describe", "meta",
                              "Get detailed information about a tool",
                              "tools-describe --name=<tool>", {}, false, false,
                              MetaToolsDescribeHandler)
  REGISTER_BUILTIN_AGENT_TOOL("tools-search", "meta", "Search tools by keyword",
                              "tools-search --query=<keyword>", {}, false,
                              false, MetaToolsSearchHandler)
 
  // Resource commands
  REGISTER_BUILTIN_AGENT_TOOL(
      "resource-list", "resource", "List resource labels",
      "resource-list --type=<type>", {"resource-list --type=dungeon"}, true,
      false, ResourceListCommandHandler)
  REGISTER_BUILTIN_AGENT_TOOL(
      "resource-search", "resource", "Search resource labels",
      "resource-search --query=<query>", {"resource-search --query=castle"},
      true, false, ResourceSearchCommandHandler)
 
  // Dungeon commands
  REGISTER_BUILTIN_AGENT_TOOL("dungeon-list-sprites", "dungeon",
                              "List sprites in a dungeon room",
                              "dungeon-list-sprites --room=<id>", {}, true,
                              false, DungeonListSpritesCommandHandler)
  REGISTER_BUILTIN_AGENT_TOOL("dungeon-describe-room", "dungeon",
                              "Describe a room",
                              "dungeon-describe-room --room=<id>", {}, true,
                              false, DungeonDescribeRoomCommandHandler)
  REGISTER_BUILTIN_AGENT_TOOL("dungeon-export-room", "dungeon",
                              "Export room data",
                              "dungeon-export-room --room=<id>", {}, true,
                              false, DungeonExportRoomCommandHandler)
  REGISTER_BUILTIN_AGENT_TOOL("dungeon-list-objects", "dungeon",
                              "List room objects",
                              "dungeon-list-objects --room=<id>", {}, true,
                              false, DungeonListObjectsCommandHandler)
  REGISTER_BUILTIN_AGENT_TOOL("dungeon-list-custom-collision", "dungeon",
                              "List custom collision tiles for a room",
                              "dungeon-list-custom-collision --room=<id>", {},
                              true, false,
                              DungeonListCustomCollisionCommandHandler)
  REGISTER_BUILTIN_AGENT_TOOL(
      "dungeon-export-custom-collision-json", "dungeon",
      "Export custom collision maps to JSON",
      "dungeon-export-custom-collision-json --out=<path> "
      "[--room=<id>|--rooms=<ids>|--all] [--report=<path>]",
      {}, true, true, DungeonExportCustomCollisionJsonCommandHandler)
  RegisterBuiltinTool<DungeonImportCustomCollisionJsonCommandHandler>(
      registry,
      {"dungeon-import-custom-collision-json",
       "dungeon",
       "Import custom collision maps and immediately save unless --dry-run",
       "dungeon-import-custom-collision-json --in=<path> "
       "[--dry-run [--report=<path>]] [--sandbox | --mock-rom] "
       "[--replace-all --force]",
       {},
       true,
       true,
       ToolAccess::kMutating,
       {},
       {"dry-run", "sandbox", "mock-rom", "replace-all", "force"}});
  REGISTER_BUILTIN_AGENT_TOOL(
      "dungeon-export-water-fill-json", "dungeon",
      "Export water fill zones to JSON",
      "dungeon-export-water-fill-json --out=<path> "
      "[--room=<id>|--rooms=<ids>|--all] [--report=<path>]",
      {}, true, true, DungeonExportWaterFillJsonCommandHandler)
  RegisterBuiltinTool<DungeonImportWaterFillJsonCommandHandler>(
      registry,
      {"dungeon-import-water-fill-json",
       "dungeon",
       "Import water fill zones and immediately save unless --dry-run",
       "dungeon-import-water-fill-json --in=<path> "
       "[--dry-run [--report=<path>]] [--sandbox | --mock-rom] "
       "[--strict-masks]",
       {},
       true,
       true,
       ToolAccess::kMutating,
       {},
       {"dry-run", "sandbox", "mock-rom", "strict-masks"}});
  REGISTER_BUILTIN_AGENT_TOOL(
      "dungeon-minecart-audit", "dungeon",
      "Audit minecart-related room data (objects/sprites/collision)",
      "dungeon-minecart-audit --room=<id>", {}, true, false,
      DungeonMinecartAuditCommandHandler)
  REGISTER_BUILTIN_AGENT_TOOL(
      "dungeon-minecart-map", "dungeon",
      "Enumerate track tile positions/types with ASCII grid for "
      "spatial reasoning",
      "dungeon-minecart-map --room=<id>", {}, true, false,
      DungeonMinecartMapCommandHandler)
  REGISTER_BUILTIN_AGENT_TOOL("dungeon-get-room-tiles", "dungeon",
                              "Get room tiles",
                              "dungeon-get-room-tiles --room=<id>", {}, true,
                              false, DungeonGetRoomTilesCommandHandler)
  REGISTER_BUILTIN_AGENT_TOOL(
      "dungeon-set-room-property", "dungeon", "Set room property",
      "dungeon-set-room-property --room=<id> --key=<key> --value=<val>", {},
      true, false, DungeonSetRoomPropertyCommandHandler)
  REGISTER_BUILTIN_AGENT_TOOL("dungeon-room-header", "dungeon",
                              "Debug room header bytes",
                              "dungeon-room-header --room=<id>", {}, true,
                              false, DungeonRoomHeaderCommandHandler)
 
  // Overworld commands
  REGISTER_BUILTIN_AGENT_TOOL("overworld-get-tile", "overworld",
                              "Get tile by map/x/y",
                              "overworld-get-tile --map=<id> --x=<x> --y=<y>",
                              {}, true, false, OverworldGetTileCommandHandler)
  REGISTER_BUILTIN_AGENT_TOOL(
      "overworld-set-tile", "overworld", "Set tile by map/x/y",
      "overworld-set-tile --map=<id> --x=<x> --y=<y> --tile=<tile>", {}, true,
      true, OverworldSetTileCommandHandler)
  REGISTER_BUILTIN_AGENT_TOOL("overworld-find-tile", "overworld",
                              "Find tile locations",
                              "overworld-find-tile --tile=<id>", {}, true,
                              false, OverworldFindTileCommandHandler)
  REGISTER_BUILTIN_AGENT_TOOL("overworld-describe-map", "overworld",
                              "Describe a map",
                              "overworld-describe-map --map=<id>", {}, true,
                              false, OverworldDescribeMapCommandHandler)
  REGISTER_BUILTIN_AGENT_TOOL("overworld-list-warps", "overworld", "List warps",
                              "overworld-list-warps --map=<id>", {}, true,
                              false, OverworldListWarpsCommandHandler)
  REGISTER_BUILTIN_AGENT_TOOL("overworld-list-sprites", "overworld",
                              "List sprites",
                              "overworld-list-sprites --map=<id>", {}, true,
                              false, OverworldListSpritesCommandHandler)
  REGISTER_BUILTIN_AGENT_TOOL("overworld-get-entrance", "overworld",
                              "Get entrance info",
                              "overworld-get-entrance --id=<id>", {}, true,
                              false, OverworldGetEntranceCommandHandler)
  REGISTER_BUILTIN_AGENT_TOOL("overworld-tile-stats", "overworld",
                              "Get tile statistics", "overworld-tile-stats", {},
                              true, false, OverworldTileStatsCommandHandler)
 
  // Message & Dialogue commands
  REGISTER_BUILTIN_AGENT_TOOL("message-list", "message", "List messages",
                              "message-list", {}, true, false,
                              MessageListCommandHandler)
  REGISTER_BUILTIN_AGENT_TOOL("message-read", "message", "Read message",
                              "message-read --id=<id>", {}, true, false,
                              MessageReadCommandHandler)
  REGISTER_BUILTIN_AGENT_TOOL("message-search", "message", "Search messages",
                              "message-search --query=<text>", {}, true, false,
                              MessageSearchCommandHandler)
  REGISTER_BUILTIN_AGENT_TOOL("dialogue-list", "dialogue", "List dialogues",
                              "dialogue-list", {}, true, false,
                              DialogueListCommandHandler)
  REGISTER_BUILTIN_AGENT_TOOL("dialogue-read", "dialogue", "Read dialogue",
                              "dialogue-read --id=<id>", {}, true, false,
                              DialogueReadCommandHandler)
  REGISTER_BUILTIN_AGENT_TOOL("dialogue-search", "dialogue", "Search dialogues",
                              "dialogue-search --query=<text>", {}, true, false,
                              DialogueSearchCommandHandler)
 
  // GUI Automation commands
  REGISTER_BUILTIN_AGENT_TOOL("gui-place-tile", "gui", "Place a tile on canvas",
                              "gui-place-tile --x=<x> --y=<y> --tile=<id>", {},
                              false, false, GuiPlaceTileCommandHandler)
  REGISTER_BUILTIN_AGENT_TOOL(
      "gui-click", "gui", "Click GUI element",
      "gui-click --target=<type:label> [--widget-key=<key>] "
      "[--click-type=<left|right|middle|double>]",
      {}, false, false, GuiClickCommandHandler)
  REGISTER_BUILTIN_AGENT_TOOL("gui-type", "gui", "Type text into a GUI element",
                              "gui-type --target=<type:label> --text=<text> "
                              "[--widget-key=<key>] [--clear-first]",
                              {}, false, false, GuiTypeCommandHandler)
  REGISTER_BUILTIN_AGENT_TOOL("gui-wait", "gui",
                              "Wait for GUI condition/widget",
                              "gui-wait --condition=<condition> "
                              "[--widget-key=<key>] [--timeout-ms=<ms>]",
                              {}, false, false, GuiWaitCommandHandler)
  REGISTER_BUILTIN_AGENT_TOOL(
      "gui-assert", "gui", "Assert GUI condition/widget",
      "gui-assert --condition=<condition> [--widget-key=<key>]", {}, false,
      false, GuiAssertCommandHandler)
  REGISTER_BUILTIN_AGENT_TOOL("gui-discover-tool", "gui", "Discover GUI tools",
                              "gui-discover-tool", {}, false, false,
                              GuiDiscoverToolCommandHandler)
  REGISTER_BUILTIN_AGENT_TOOL("gui-screenshot", "gui", "Take screenshot",
                              "gui-screenshot", {}, false, false,
                              GuiScreenshotCommandHandler)
  REGISTER_BUILTIN_AGENT_TOOL("gui-summarize-widgets", "gui",
                              "Get a high-level summary of visible GUI widgets",
                              "gui-summarize-widgets", {}, false, false,
                              GuiSummarizeWidgetsCommandHandler)
 
  // Music commands
  REGISTER_BUILTIN_AGENT_TOOL("music-list", "music", "List music tracks",
                              "music-list", {}, true, false,
                              MusicListCommandHandler)
  REGISTER_BUILTIN_AGENT_TOOL("music-info", "music", "Get music info",
                              "music-info --id=<id>", {}, true, false,
                              MusicInfoCommandHandler)
  REGISTER_BUILTIN_AGENT_TOOL("music-tracks", "music", "List tracks",
                              "music-tracks", {}, true, false,
                              MusicTracksCommandHandler)
 
  // Sprite commands
  REGISTER_BUILTIN_AGENT_TOOL("sprite-list", "sprite", "List sprites",
                              "sprite-list", {}, true, false,
                              SpriteListCommandHandler)
  REGISTER_BUILTIN_AGENT_TOOL("sprite-properties", "sprite",
                              "Get sprite properties",
                              "sprite-properties --id=<id>", {}, true, false,
                              SpritePropertiesCommandHandler)
  REGISTER_BUILTIN_AGENT_TOOL("sprite-palette", "sprite", "Get sprite palette",
                              "sprite-palette --id=<id>", {}, true, false,
                              SpritePaletteCommandHandler)
 
  // Filesystem commands
  REGISTER_BUILTIN_AGENT_TOOL(
      "filesystem-list", "filesystem", "List directory contents",
      "filesystem-list --path=<path>", {}, false, false, FileSystemListTool)
  REGISTER_BUILTIN_AGENT_TOOL(
      "filesystem-read", "filesystem", "Read file contents",
      "filesystem-read --path=<path>", {}, false, false, FileSystemReadTool)
  REGISTER_BUILTIN_AGENT_TOOL(
      "filesystem-exists", "filesystem", "Check file existence",
      "filesystem-exists --path=<path>", {}, false, false, FileSystemExistsTool)
  REGISTER_BUILTIN_AGENT_TOOL("filesystem-info", "filesystem", "Get file info",
                              "filesystem-info --path=<path>", {}, false, false,
                              FileSystemInfoTool)
 
  // Build commands
  REGISTER_BUILTIN_AGENT_TOOL(
      "build-configure", "build",
      "Configure the build system with a CMake preset",
      "build-configure --preset <preset> [--build-dir <dir>] "
      "[--verbose]",
      {}, false, false, BuildConfigureCommandHandler)
  REGISTER_BUILTIN_AGENT_TOOL(
      "build-compile", "build", "Build a specific target or all targets",
      "build-compile [--target <target>] [--config <config>] "
      "[--build-dir <dir>] [--verbose]",
      {}, false, false, BuildCompileCommandHandler)
  REGISTER_BUILTIN_AGENT_TOOL(
      "build-test", "build", "Run tests with optional filter",
      "build-test [--filter <pattern>] [--rom-path <path>] "
      "[--build-dir <dir>] [--verbose]",
      {}, false, false, BuildTestCommandHandler)
  REGISTER_BUILTIN_AGENT_TOOL("build-status", "build",
                              "Get current build operation status",
                              "build-status [--build-dir <dir>]", {}, false,
                              false, BuildStatusCommandHandler)
 
  // Memory inspector commands
  REGISTER_BUILTIN_AGENT_TOOL("memory-analyze", "memory",
                              "Analyze memory region",
                              "memory-analyze --address=<addr> --length=<len>",
                              {}, true, false, MemoryAnalyzeTool)
  REGISTER_BUILTIN_AGENT_TOOL(
      "memory-search", "memory", "Search for byte pattern",
      "memory-search --pattern=<hex>", {}, true, false, MemorySearchTool)
  REGISTER_BUILTIN_AGENT_TOOL("memory-compare", "memory",
                              "Compare memory regions", "memory-compare", {},
                              true, false, MemoryCompareTool)
  REGISTER_BUILTIN_AGENT_TOOL("memory-check", "memory", "Check memory",
                              "memory-check", {}, true, false, MemoryCheckTool)
  REGISTER_BUILTIN_AGENT_TOOL("memory-regions", "memory",
                              "List known memory regions", "memory-regions", {},
                              false, false, MemoryRegionsTool)
 
  // Test helper tools
  REGISTER_BUILTIN_AGENT_TOOL("tools-helper-list", "tools",
                              "List test helper tools", "tools-helper-list", {},
                              false, false, ToolsListCommandHandler)
  REGISTER_BUILTIN_AGENT_TOOL("tools-harness-state", "tools",
                              "Generate WRAM state", "tools-harness-state", {},
                              false, false, ToolsHarnessStateCommandHandler)
  REGISTER_BUILTIN_AGENT_TOOL(
      "tools-extract-values", "tools", "Extract vanilla ROM values",
      "tools-extract-values", {}, true, false, ToolsExtractValuesCommandHandler)
  REGISTER_BUILTIN_AGENT_TOOL("tools-extract-golden", "tools",
                              "Extract golden data", "tools-extract-golden", {},
                              true, false, ToolsExtractGoldenCommandHandler)
  REGISTER_BUILTIN_AGENT_TOOL("tools-patch-v3", "tools",
                              "Create v3 patched ROM", "tools-patch-v3", {},
                              true, false, ToolsPatchV3CommandHandler)
 
  // Visual analysis tools
  REGISTER_BUILTIN_AGENT_TOOL(
      "visual-find-similar-tiles", "visual", "Find tiles with similar patterns",
      "visual-find-similar-tiles", {}, true, false, TileSimilarityTool)
  REGISTER_BUILTIN_AGENT_TOOL(
      "visual-analyze-spritesheet", "visual", "Identify unused regions",
      "visual-analyze-spritesheet", {}, true, false, SpritesheetAnalysisTool)
  REGISTER_BUILTIN_AGENT_TOOL("visual-palette-usage", "visual",
                              "Analyze palette usage", "visual-palette-usage",
                              {}, true, false, PaletteUsageTool)
  REGISTER_BUILTIN_AGENT_TOOL(
      "visual-tile-histogram", "visual", "Generate tile usage histogram",
      "visual-tile-histogram", {}, true, false, TileHistogramTool)
 
  // Code generation tools
  REGISTER_BUILTIN_AGENT_TOOL("codegen-asm-hook", "codegen",
                              "Generate ASM hook", "codegen-asm-hook", {}, true,
                              false, CodeGenAsmHookTool)
  REGISTER_BUILTIN_AGENT_TOOL("codegen-freespace-patch", "codegen",
                              "Generate patch", "codegen-freespace-patch", {},
                              true, false, CodeGenFreespacePatchTool)
  REGISTER_BUILTIN_AGENT_TOOL("codegen-sprite-template", "codegen",
                              "Generate sprite ASM", "codegen-sprite-template",
                              {}, false, false, CodeGenSpriteTemplateTool)
  REGISTER_BUILTIN_AGENT_TOOL("codegen-event-handler", "codegen",
                              "Generate event handler", "codegen-event-handler",
                              {}, false, false, CodeGenEventHandlerTool)
 
  // Project management tools
  REGISTER_BUILTIN_AGENT_TOOL("project-status", "project",
                              "Show current project state", "project-status",
                              {}, true, true, ProjectStatusTool)
  REGISTER_BUILTIN_AGENT_TOOL("project-snapshot", "project",
                              "Create named checkpoint", "project-snapshot", {},
                              true, true, ProjectSnapshotTool)
  REGISTER_BUILTIN_AGENT_TOOL("project-restore", "project",
                              "Restore ROM to checkpoint", "project-restore",
                              {}, true, true, ProjectRestoreTool)
  REGISTER_BUILTIN_AGENT_TOOL("project-export", "project", "Export project",
                              "project-export", {}, true, true,
                              ProjectExportTool)
  REGISTER_BUILTIN_AGENT_TOOL("project-import", "project", "Import project",
                              "project-import", {}, false, true,
                              ProjectImportTool)
  REGISTER_BUILTIN_AGENT_TOOL("project-diff", "project",
                              "Compare project states", "project-diff", {},
                              true, true, ProjectDiffTool)
  REGISTER_BUILTIN_AGENT_TOOL(
      "project-graph", "project",
      "Query project graph info (files, symbols, config)",
      "project-graph --query=<info|files|symbols|lookup|writes|bank> "
      "[--path=<folder>] [--symbol=<name>] [--address=<hex>] [--bank=<hex>]",
      {}, true, true, ProjectGraphTool)
 
#ifdef YAZE_WITH_GRPC
  REGISTER_BUILTIN_AGENT_TOOL("emulator-step", "emulator", "Step emulator",
                              "emulator-step", {}, true, false,
                              EmulatorStepCommandHandler)
  REGISTER_BUILTIN_AGENT_TOOL("emulator-run", "emulator", "Run emulator",
                              "emulator-run", {}, true, false,
                              EmulatorRunCommandHandler)
  REGISTER_BUILTIN_AGENT_TOOL("emulator-pause", "emulator", "Pause emulator",
                              "emulator-pause", {}, true, false,
                              EmulatorPauseCommandHandler)
  REGISTER_BUILTIN_AGENT_TOOL("emulator-reset", "emulator", "Reset emulator",
                              "emulator-reset", {}, true, false,
                              EmulatorResetCommandHandler)
  REGISTER_BUILTIN_AGENT_TOOL("emulator-get-state", "emulator",
                              "Get emulator state", "emulator-get-state", {},
                              true, false, EmulatorGetStateCommandHandler)
  REGISTER_BUILTIN_AGENT_TOOL("emulator-set-breakpoint", "emulator",
                              "Set breakpoint", "emulator-set-breakpoint", {},
                              true, false, EmulatorSetBreakpointCommandHandler)
  REGISTER_BUILTIN_AGENT_TOOL("emulator-clear-breakpoint", "emulator",
                              "Clear breakpoint", "emulator-clear-breakpoint",
                              {}, true, false,
                              EmulatorClearBreakpointCommandHandler)
  REGISTER_BUILTIN_AGENT_TOOL("emulator-list-breakpoints", "emulator",
                              "List breakpoints", "emulator-list-breakpoints",
                              {}, true, false,
                              EmulatorListBreakpointsCommandHandler)
  REGISTER_BUILTIN_AGENT_TOOL("emulator-read-memory", "emulator", "Read memory",
                              "emulator-read-memory", {}, true, false,
                              EmulatorReadMemoryCommandHandler)
  REGISTER_BUILTIN_AGENT_TOOL("emulator-write-memory", "emulator",
                              "Write memory", "emulator-write-memory", {}, true,
                              false, EmulatorWriteMemoryCommandHandler)
  REGISTER_BUILTIN_AGENT_TOOL("emulator-get-registers", "emulator",
                              "Get registers", "emulator-get-registers", {},
                              true, false, EmulatorGetRegistersCommandHandler)
  REGISTER_BUILTIN_AGENT_TOOL("emulator-get-metrics", "emulator", "Get metrics",
                              "emulator-get-metrics", {}, true, false,
                              EmulatorGetMetricsCommandHandler)
#endif
}
 
#undef REGISTER_BUILTIN_AGENT_TOOL
 
}  // namespace agent
}  // namespace cli
}  // namespace yaze