resource_catalog.cc

Go to the documentation of this file.

#include "cli/service/resources/resource_catalog.h"
 
#include <sstream>
 
#include "absl/strings/str_cat.h"
#include "absl/strings/str_join.h"
#include "absl/strings/string_view.h"
 
namespace yaze {
namespace cli {
 
namespace {
 
ResourceSchema MakePaletteSchema() {
  ResourceSchema schema;
  schema.resource = "palette";
  schema.description =
      "Palette manipulation commands covering export, import, and color "
      "editing.";
 
  ResourceAction export_action;
  export_action.name = "export";
  export_action.synopsis =
      "z3ed palette export --group <group> --id <id> --to <file>";
  export_action.stability = "experimental";
  export_action.arguments = {
      ResourceArgument{"--group", "integer", true, "Palette group id (0-31)."},
      ResourceArgument{"--id", "integer", true,
                       "Palette index inside the group."},
      ResourceArgument{"--to", "path", true,
                       "Destination file path for binary export."},
  };
  export_action.effects = {
      "Reads ROM palette buffer and writes binary palette data to disk."};
 
  ResourceAction import_action;
  import_action.name = "import";
  import_action.synopsis =
      "z3ed palette import --group <group> --id <id> --from <file>";
  import_action.stability = "experimental";
  import_action.arguments = {
      ResourceArgument{"--group", "integer", true, "Palette group id (0-31)."},
      ResourceArgument{"--id", "integer", true,
                       "Palette index inside the group."},
      ResourceArgument{"--from", "path", true, "Source binary palette file."},
  };
  import_action.effects = {
      "Writes imported palette bytes into ROM buffer and marks project dirty."};
 
  schema.actions = {export_action, import_action};
  return schema;
}
 
ResourceSchema MakeRomSchema() {
  ResourceSchema schema;
  schema.resource = "rom";
  schema.description = "ROM validation, diffing, and snapshot helpers.";
 
  ResourceAction info_action;
  info_action.name = "info";
  info_action.synopsis = "z3ed rom info --rom <file>";
  info_action.stability = "stable";
  info_action.arguments = {
      ResourceArgument{"--rom", "path", true,
                       "Path to ROM file configured via global flag."},
  };
  info_action.effects = {
      "Reads ROM from disk and displays basic information (title, size, "
      "filename)."};
  info_action.returns = {{"title", "string", "ROM internal title from header."},
                         {"size", "integer", "ROM file size in bytes."},
                         {"filename", "string", "Full path to the ROM file."}};
 
  ResourceAction validate_action;
  validate_action.name = "validate";
  validate_action.synopsis = "z3ed rom validate --rom <file>";
  validate_action.stability = "stable";
  validate_action.arguments = {
      ResourceArgument{"--rom", "path", true,
                       "Path to ROM file configured via global flag."},
  };
  validate_action.effects = {
      "Reads ROM from disk, verifies checksum, and reports header status."};
  validate_action.returns = {
      {"report", "object",
       "Structured validation summary with checksum and header results."}};
 
  ResourceAction diff_action;
  diff_action.name = "diff";
  diff_action.synopsis = "z3ed rom diff <rom_a> <rom_b>";
  diff_action.stability = "beta";
  diff_action.arguments = {
      ResourceArgument{"rom_a", "path", true, "Reference ROM path."},
      ResourceArgument{"rom_b", "path", true, "Candidate ROM path."},
  };
  diff_action.effects = {
      "Reads two ROM images, compares bytes, and streams differences to "
      "stdout."};
  diff_action.returns = {
      {"differences", "integer", "Count of mismatched bytes between ROMs."}};
 
  ResourceAction generate_action;
  generate_action.name = "generate-golden";
  generate_action.synopsis =
      "z3ed rom generate-golden <rom_file> <golden_file>";
  generate_action.stability = "experimental";
  generate_action.arguments = {
      ResourceArgument{"rom_file", "path", true, "Source ROM to snapshot."},
      ResourceArgument{"golden_file", "path", true,
                       "Output path for golden image."},
  };
  generate_action.effects = {
      "Writes out exact ROM image for tooling baselines and diff workflows."};
  generate_action.returns = {
      {"artifact", "path", "Absolute path to the generated golden image."}};
 
  schema.actions = {info_action, validate_action, diff_action, generate_action};
  return schema;
}
 
ResourceSchema MakePatchSchema() {
  ResourceSchema schema;
  schema.resource = "patch";
  schema.description =
      "Patch authoring and application commands covering BPS and Asar flows.";
 
  ResourceAction apply_action;
  apply_action.name = "apply";
  apply_action.synopsis = "z3ed patch apply <rom_file> <bps_patch>";
  apply_action.stability = "beta";
  apply_action.arguments = {
      ResourceArgument{"rom_file", "path", true,
                       "Source ROM image that will receive the patch."},
      ResourceArgument{"bps_patch", "path", true,
                       "BPS patch to apply to the ROM."},
  };
  apply_action.effects = {
      "Loads ROM from disk, applies a BPS patch, and writes `patched.sfc`."};
  apply_action.returns = {
      {"artifact", "path",
       "Absolute path to the patched ROM image produced on success."}};
 
  ResourceAction asar_action;
  asar_action.name = "apply-asar";
  asar_action.synopsis = "z3ed patch apply-asar <patch.asm>";
  asar_action.stability = "prototype";
  asar_action.arguments = {
      ResourceArgument{"patch.asm", "path", true,
                       "Assembly patch consumed by the bundled Asar runtime."},
      ResourceArgument{"--rom", "path", false,
                       "ROM path supplied via global --rom flag."},
  };
  asar_action.effects = {
      "Invokes Asar against the active ROM buffer and applies assembled "
      "changes."};
  asar_action.returns = {
      {"log", "string", "Assembler diagnostics emitted during application."}};
 
  ResourceAction create_action;
  create_action.name = "create";
  create_action.synopsis =
      "z3ed patch create --source <rom> --target <rom> --out <patch.bps>";
  create_action.stability = "experimental";
  create_action.arguments = {
      ResourceArgument{"--source", "path", true,
                       "Baseline ROM used when computing the patch."},
      ResourceArgument{"--target", "path", true,
                       "Modified ROM to diff against the baseline."},
      ResourceArgument{"--out", "path", true,
                       "Output path for the generated BPS patch."},
  };
  create_action.effects = {
      "Compares source and target images to synthesize a distributable BPS "
      "patch."};
  create_action.returns = {
      {"artifact", "path", "File system path to the generated patch."}};
 
  schema.actions = {apply_action, asar_action, create_action};
  return schema;
}
 
ResourceSchema MakeOverworldSchema() {
  ResourceSchema schema;
  schema.resource = "overworld";
  schema.description = "Overworld tile inspection and manipulation commands.";
 
  ResourceAction get_tile;
  get_tile.name = "get-tile";
  get_tile.synopsis = "z3ed overworld get-tile --map <map_id> --x <x> --y <y>";
  get_tile.stability = "stable";
  get_tile.arguments = {
      ResourceArgument{"--map", "integer", true,
                       "Overworld map identifier (0-63)."},
      ResourceArgument{"--x", "integer", true, "Tile x coordinate."},
      ResourceArgument{"--y", "integer", true, "Tile y coordinate."},
  };
  get_tile.returns = {
      {"tile", "integer", "Tile id located at the supplied coordinates."}};
 
  ResourceAction set_tile;
  set_tile.name = "set-tile";
  set_tile.synopsis =
      "z3ed overworld set-tile --map <map_id> --x <x> --y <y> --tile <tile_id>";
  set_tile.stability = "experimental";
  set_tile.arguments = {
      ResourceArgument{"--map", "integer", true,
                       "Overworld map identifier (0-63)."},
      ResourceArgument{"--x", "integer", true, "Tile x coordinate."},
      ResourceArgument{"--y", "integer", true, "Tile y coordinate."},
      ResourceArgument{"--tile", "integer", true, "Tile id to write."},
  };
  set_tile.effects = {
      "Mutates overworld tile map and enqueues render invalidation."};
 
  schema.actions = {get_tile, set_tile};
  return schema;
}
 
ResourceSchema MakeDungeonSchema() {
  ResourceSchema schema;
  schema.resource = "dungeon";
  schema.description = "Dungeon room export and inspection utilities.";
 
  ResourceAction export_action;
  export_action.name = "export";
  export_action.synopsis = "z3ed dungeon export <room_id>";
  export_action.stability = "prototype";
  export_action.arguments = {
      ResourceArgument{"room_id", "integer", true,
                       "Dungeon room identifier to inspect."},
  };
  export_action.effects = {
      "Loads the active ROM via --rom and prints metadata for the requested "
      "room."};
  export_action.returns = {{"metadata", "object",
                            "Structured room summary including blockset, "
                            "spriteset, palette, and layout."}};
 
  ResourceAction list_objects_action;
  list_objects_action.name = "list-objects";
  list_objects_action.synopsis = "z3ed dungeon list-objects <room_id>";
  list_objects_action.stability = "prototype";
  list_objects_action.arguments = {
      ResourceArgument{
          "room_id", "integer", true,
          "Dungeon room identifier whose objects should be listed."},
  };
  list_objects_action.effects = {
      "Streams parsed dungeon object records for the requested room to "
      "stdout."};
  list_objects_action.returns = {
      {"objects", "array",
       "Collection of tile object records with ids, coordinates, and layers."}};
 
  schema.actions = {export_action, list_objects_action};
  return schema;
}
 
ResourceSchema MakeAgentSchema() {
  ResourceSchema schema;
  schema.resource = "agent";
  schema.description =
      "Agent workflow helpers including planning, diffing, listing, and schema "
      "discovery.";
 
  ResourceAction describe_action;
  describe_action.name = "describe";
  describe_action.synopsis = "z3ed agent describe --resource <name>";
  describe_action.stability = "prototype";
  describe_action.arguments = {
      ResourceArgument{"--resource", "string", false,
                       "Optional resource name to filter results."},
  };
  describe_action.returns = {
      {"schema", "object",
       "JSON schema describing resource arguments and semantics."}};
 
  ResourceAction list_action;
  list_action.name = "list";
  list_action.synopsis = "z3ed agent list";
  list_action.stability = "prototype";
  list_action.arguments = {};
  list_action.effects = {{"reads", "proposal_registry"}};
  list_action.returns = {
      {"proposals", "array",
       "List of all proposals with ID, status, prompt, and metadata."}};
 
  ResourceAction diff_action;
  diff_action.name = "diff";
  diff_action.synopsis = "z3ed agent diff [--proposal-id <id>]";
  diff_action.stability = "prototype";
  diff_action.arguments = {
      ResourceArgument{"--proposal-id", "string", false,
                       "Optional proposal ID to view specific proposal. "
                       "Defaults to latest pending."},
  };
  diff_action.effects = {{"reads", "proposal_registry"}, {"reads", "sandbox"}};
  diff_action.returns = {
      {"diff", "string", "Unified diff showing changes to ROM."},
      {"log", "string", "Execution log of commands run."},
      {"metadata", "object",
       "Proposal metadata including status and timestamps."}};
 
  schema.actions = {describe_action, list_action, diff_action};
  return schema;
}
 
}  // namespace
 
const ResourceCatalog& ResourceCatalog::Instance() {
  static ResourceCatalog* instance = new ResourceCatalog();
  return *instance;
}
 
ResourceCatalog::ResourceCatalog()
    : resources_({MakeRomSchema(), MakePatchSchema(), MakePaletteSchema(),
                  MakeOverworldSchema(), MakeDungeonSchema(),
                  MakeAgentSchema()}) {}
 
absl::StatusOr<ResourceSchema> ResourceCatalog::GetResource(
    absl::string_view name) const {
  for (const auto& resource : resources_) {
    if (resource.resource == name) {
      return resource;
    }
  }
  return absl::NotFoundError(absl::StrCat("Resource not found: ", name));
}
 
const std::vector<ResourceSchema>& ResourceCatalog::AllResources() const {
  return resources_;
}
 
std::string ResourceCatalog::SerializeResource(
    const ResourceSchema& schema) const {
  return SerializeResources({schema});
}
 
std::string ResourceCatalog::SerializeResources(
    const std::vector<ResourceSchema>& schemas) const {
  std::vector<std::string> entries;
  entries.reserve(schemas.size());
  for (const auto& resource : schemas) {
    std::vector<std::string> action_entries;
    action_entries.reserve(resource.actions.size());
    for (const auto& action : resource.actions) {
      std::vector<std::string> arg_entries;
      arg_entries.reserve(action.arguments.size());
      for (const auto& arg : action.arguments) {
        arg_entries.push_back(absl::StrCat(
            "{\"flag\":\"", EscapeJson(arg.flag), "\",\"type\":\"",
            EscapeJson(arg.type),
            "\",\"required\":", arg.required ? "true" : "false",
            ",\"description\":\"", EscapeJson(arg.description), "\"}"));
      }
      std::vector<std::string> effect_entries;
      effect_entries.reserve(action.effects.size());
      for (const auto& effect : action.effects) {
        effect_entries.push_back(absl::StrCat("\"", EscapeJson(effect), "\""));
      }
      std::vector<std::string> return_entries;
      return_entries.reserve(action.returns.size());
      for (const auto& ret : action.returns) {
        return_entries.push_back(absl::StrCat(
            "{\"field\":\"", EscapeJson(ret.field), "\",\"type\":\"",
            EscapeJson(ret.type), "\",\"description\":\"",
            EscapeJson(ret.description), "\"}"));
      }
      action_entries.push_back(absl::StrCat(
          "{\"name\":\"", EscapeJson(action.name), "\",\"synopsis\":\"",
          EscapeJson(action.synopsis), "\",\"stability\":\"",
          EscapeJson(action.stability), "\",\"arguments\":[",
          absl::StrJoin(arg_entries, ","), "],", "\"effects\":[",
          absl::StrJoin(effect_entries, ","), "],", "\"returns\":[",
          absl::StrJoin(return_entries, ","), "]}"));
    }
    entries.push_back(absl::StrCat(
        "{\"resource\":\"", EscapeJson(resource.resource),
        "\",\"description\":\"", EscapeJson(resource.description),
        "\",\"actions\":[", absl::StrJoin(action_entries, ","), "]}"));
  }
  return absl::StrCat("{\"resources\":[", absl::StrJoin(entries, ","), "]}");
}
 
std::string ResourceCatalog::EscapeJson(absl::string_view value) {
  std::string out;
  out.reserve(value.size());
  for (char c : value) {
    switch (c) {
      case '\\':
        out += "\\\\";
        break;
      case '\"':
        out += "\\\"";
        break;
      case '\n':
        out += "\\n";
        break;
      case '\r':
        out += "\\r";
        break;
      case '\t':
        out += "\\t";
        break;
      default:
        out += c;
        break;
    }
  }
  return out;
}
 
std::string ResourceCatalog::SerializeResourcesAsYaml(
    const std::vector<ResourceSchema>& schemas, absl::string_view version,
    absl::string_view last_updated) const {
  std::string out;
  absl::StrAppend(&out, "# Auto-generated resource catalogue\n");
  absl::StrAppend(&out, "version: ", EscapeYaml(version), "\n");
  absl::StrAppend(&out, "last_updated: ", EscapeYaml(last_updated), "\n");
  absl::StrAppend(&out, "resources:\n");
 
  for (const auto& resource : schemas) {
    absl::StrAppend(&out, "  - name: ", EscapeYaml(resource.resource), "\n");
    absl::StrAppend(&out, "    description: ", EscapeYaml(resource.description),
                    "\n");
 
    if (resource.actions.empty()) {
      absl::StrAppend(&out, "    actions: []\n");
      continue;
    }
 
    absl::StrAppend(&out, "    actions:\n");
    for (const auto& action : resource.actions) {
      absl::StrAppend(&out, "      - name: ", EscapeYaml(action.name), "\n");
      absl::StrAppend(&out, "        synopsis: ", EscapeYaml(action.synopsis),
                      "\n");
      absl::StrAppend(&out, "        stability: ", EscapeYaml(action.stability),
                      "\n");
 
      if (action.arguments.empty()) {
        absl::StrAppend(&out, "        args: []\n");
      } else {
        absl::StrAppend(&out, "        args:\n");
        for (const auto& arg : action.arguments) {
          absl::StrAppend(&out, "          - flag: ", EscapeYaml(arg.flag),
                          "\n");
          absl::StrAppend(&out, "            type: ", EscapeYaml(arg.type),
                          "\n");
          absl::StrAppend(&out, "            required: ",
                          arg.required ? "true\n" : "false\n");
          absl::StrAppend(&out, "            description: ",
                          EscapeYaml(arg.description), "\n");
        }
      }
 
      if (action.effects.empty()) {
        absl::StrAppend(&out, "        effects: []\n");
      } else {
        absl::StrAppend(&out, "        effects:\n");
        for (const auto& effect : action.effects) {
          absl::StrAppend(&out, "          - ", EscapeYaml(effect), "\n");
        }
      }
 
      if (action.returns.empty()) {
        absl::StrAppend(&out, "        returns: []\n");
      } else {
        absl::StrAppend(&out, "        returns:\n");
        for (const auto& ret : action.returns) {
          absl::StrAppend(&out, "          - field: ", EscapeYaml(ret.field),
                          "\n");
          absl::StrAppend(&out, "            type: ", EscapeYaml(ret.type),
                          "\n");
          absl::StrAppend(&out, "            description: ",
                          EscapeYaml(ret.description), "\n");
        }
      }
    }
  }
 
  return out;
}
 
std::string ResourceCatalog::EscapeYaml(absl::string_view value) {
  std::string out;
  out.reserve(value.size() + 2);
  out.push_back('"');
  for (char c : value) {
    switch (c) {
      case '\\':
        out += "\\\\";
        break;
      case '"':
        out += "\\\"";
        break;
      case '\n':
        out += "\\n";
        break;
      case '\r':
        out += "\\r";
        break;
      case '\t':
        out += "\\t";
        break;
      default:
        out.push_back(c);
        break;
    }
  }
  out.push_back('"');
  return out;
}
 
}  // namespace cli
}  // namespace yaze