command_context.h

Go to the documentation of this file.

#ifndef YAZE_SRC_CLI_SERVICE_RESOURCES_COMMAND_CONTEXT_H_
#define YAZE_SRC_CLI_SERVICE_RESOURCES_COMMAND_CONTEXT_H_
 
#include <optional>
#include <string>
#include <vector>
 
#include "absl/status/status.h"
#include "absl/status/statusor.h"
#include "app/emu/debug/symbol_provider.h"
#include "core/features.h"
#include "core/project.h"
#include "rom/rom.h"
#include "zelda3/dungeon/custom_object.h"
 
namespace yaze {
namespace cli {
namespace resources {
 
class CommandContext {
 public:
  struct Config {
    std::optional<std::string> rom_path;
    std::optional<std::string> symbols_path;
    std::optional<std::string> project_context_path;
    bool use_mock_rom = false;
    std::string format = "json";  // "json" or "text"
    bool verbose = false;
 
    // ROM context can be provided externally (e.g., from Agent class)
    Rom* external_rom_context = nullptr;
  };
 
  explicit CommandContext(const Config& config);
  ~CommandContext();
 
  absl::Status Initialize();
 
  absl::StatusOr<Rom*> GetRom();
 
  emu::debug::SymbolProvider* GetSymbolProvider();
 
  const std::string& GetFormat() const { return config_.format; }
 
  bool IsVerbose() const { return config_.verbose; }
 
  absl::Status EnsureLabelsLoaded(Rom* rom);
 
  project::YazeProject* GetProjectContext() {
    return loaded_project_.has_value() ? &loaded_project_.value() : nullptr;
  }
 
 private:
  absl::Status ApplyProjectRuntimeContext();
  void RestoreProjectRuntimeContext();
 
  Config config_;
  Rom rom_storage_;  // Owned ROM if loaded from file
  Rom* active_rom_ =
      nullptr;  // Points to either rom_storage_ or external_rom_context
  emu::debug::SymbolProvider symbol_provider_;
  std::optional<project::YazeProject> loaded_project_;
  std::optional<core::FeatureFlags::Flags> previous_feature_flags_;
  std::optional<zelda3::CustomObjectManager::State>
      previous_custom_object_state_;
  bool project_runtime_applied_ = false;
  bool initialized_ = false;
};
 
class ArgumentParser {
 public:
  explicit ArgumentParser(const std::vector<std::string>& args);
 
  std::optional<std::string> GetString(const std::string& name) const;
 
  absl::StatusOr<int> GetInt(const std::string& name) const;
 
  absl::StatusOr<int> GetHex(const std::string& name) const;
 
  bool HasFlag(const std::string& name) const;
 
  std::vector<std::string> GetPositional() const;
 
  absl::Status RequireArgs(const std::vector<std::string>& required) const;
 
 private:
  std::vector<std::string> args_;
 
  std::optional<std::string> FindArgValue(const std::string& name) const;
};
 
class OutputFormatter {
 public:
  enum class Format { kJson, kText };
 
  explicit OutputFormatter(Format format) : format_(format) {}
 
  static absl::StatusOr<OutputFormatter> FromString(const std::string& format);
 
  void BeginObject(const std::string& title = "");
 
  void EndObject();
 
  void AddField(const std::string& key, const std::string& value);
  void AddField(const std::string& key, const char* value);
  void AddField(const std::string& key, int value);
  void AddField(const std::string& key, uint64_t value);
  void AddField(const std::string& key, bool value);
 
  void AddHexField(const std::string& key, uint64_t value, int width = 2);
 
  void BeginArray(const std::string& key);
 
  void EndArray();
 
  void AddArrayItem(const std::string& item);
 
  std::string GetOutput() const;
 
  void Print() const;
 
  bool IsJson() const { return format_ == Format::kJson; }
 
  bool IsText() const { return format_ == Format::kText; }
 
 private:
  Format format_;
  std::string buffer_;
  int indent_level_ = 0;
  bool first_field_ = true;
  bool in_array_ = false;
  int array_item_count_ = 0;
 
  void AddIndent();
  std::string EscapeJson(const std::string& str) const;
};
 
}  // namespace resources
}  // namespace cli
}  // namespace yaze
 
#endif  // YAZE_SRC_CLI_SERVICE_RESOURCES_COMMAND_CONTEXT_H_