project_tool.h

Go to the documentation of this file.

 
#ifndef YAZE_SRC_CLI_SERVICE_AGENT_TOOLS_PROJECT_TOOL_H_
#define YAZE_SRC_CLI_SERVICE_AGENT_TOOLS_PROJECT_TOOL_H_
 
#include <array>
#include <chrono>
#include <cstdint>
#include <map>
#include <string>
#include <vector>
 
#include "absl/status/status.h"
#include "absl/status/statusor.h"
#include "cli/service/agent/agent_context.h"
#include "cli/service/resources/command_handler.h"
 
namespace yaze {
namespace cli {
namespace agent {
namespace tools {
 
struct EditFileHeader {
  uint32_t magic = 0x59415A45;  // "YAZE" in hex
  uint32_t version = 1;
  uint32_t edit_count;
  std::array<uint8_t, 32> base_rom_sha256;
 
  static constexpr uint32_t kMagic = 0x59415A45;
  static constexpr uint32_t kCurrentVersion = 1;
};
 
struct SerializedEdit {
  uint32_t address;
  uint32_t length;
  // Followed by: old_value[length], new_value[length]
};
 
struct ProjectSnapshot {
  std::string name;
  std::string description;
  std::chrono::system_clock::time_point created;
  std::vector<RomEdit> edits;  // From AgentContext
  std::map<std::string, std::string> metadata;
  std::array<uint8_t, 32> rom_checksum;  // SHA-256 of base ROM
 
  // Serialization
  absl::Status SaveToFile(const std::string& filepath) const;
  static absl::StatusOr<ProjectSnapshot> LoadFromFile(
      const std::string& filepath);
};
 
class ProjectManager {
 public:
  ProjectManager() = default;
 
  absl::Status Initialize(const std::string& base_path);
 
  absl::Status CreateSnapshot(const std::string& name,
                               const std::string& description,
                               const std::vector<RomEdit>& edits,
                               const std::array<uint8_t, 32>& rom_checksum);
 
  absl::Status RestoreSnapshot(const std::string& name, Rom* rom);
 
  std::vector<std::string> ListSnapshots() const;
 
  absl::StatusOr<ProjectSnapshot> GetSnapshot(const std::string& name) const;
 
  absl::Status DeleteSnapshot(const std::string& name);
 
  absl::Status ExportProject(const std::string& export_path,
                              bool include_rom = false);
 
  absl::Status ImportProject(const std::string& archive_path);
 
  absl::StatusOr<std::string> DiffSnapshots(const std::string& snapshot1,
                                             const std::string& snapshot2) const;
 
  const std::string& GetProjectPath() const { return project_path_; }
 
  bool IsInitialized() const { return !project_path_.empty(); }
 
 private:
  std::string project_path_;
  std::string snapshots_path_;
  std::map<std::string, ProjectSnapshot> snapshots_;
 
  absl::Status LoadSnapshots();
  absl::Status SaveProjectMetadata();
  std::string GetSnapshotFilePath(const std::string& name) const;
};
 
class ProjectToolUtils {
 public:
  static std::array<uint8_t, 32> ComputeRomChecksum(const Rom* rom);
 
  static std::array<uint8_t, 32> ComputeSHA256(const uint8_t* data,
                                                size_t length);
 
  static std::string FormatChecksum(const std::array<uint8_t, 32>& checksum);
 
  static std::string FormatTimestamp(
      const std::chrono::system_clock::time_point& time);
 
  static absl::StatusOr<std::chrono::system_clock::time_point> ParseTimestamp(
      const std::string& timestamp);
};
 
class ProjectToolBase : public resources::CommandHandler {
 protected:
  absl::StatusOr<ProjectManager*> GetProjectManager(
      AgentContext* context) const;
 
  std::string FormatEdits(const std::vector<RomEdit>& edits) const;
 
  std::string FormatSnapshot(const ProjectSnapshot& snapshot) const;
};
 
class ProjectStatusTool : public ProjectToolBase {
 public:
  std::string GetName() const override { return "project-status"; }
 
  std::string GetDescription() const {
    return "Show current project state and pending edits";
  }
 
  std::string GetUsage() const override {
    return "project-status [--format <json|text>]";
  }
 
  bool RequiresLabels() const override { return false; }
 
 protected:
  absl::Status ValidateArgs(
      const resources::ArgumentParser& /*parser*/) override {
    return absl::OkStatus();
  }
 
  absl::Status Execute(Rom* rom, const resources::ArgumentParser& parser,
                       resources::OutputFormatter& formatter) override;
};
 
class ProjectSnapshotTool : public ProjectToolBase {
 public:
  std::string GetName() const override { return "project-snapshot"; }
 
  std::string GetDescription() const {
    return "Create named checkpoint with edit deltas";
  }
 
  std::string GetUsage() const override {
    return "project-snapshot --name <name> [--description <desc>] [--format <json|text>]";
  }
 
  bool RequiresLabels() const override { return false; }
 
 protected:
  absl::Status ValidateArgs(const resources::ArgumentParser& parser) override {
    return parser.RequireArgs({"name"});
  }
 
  absl::Status Execute(Rom* rom, const resources::ArgumentParser& parser,
                       resources::OutputFormatter& formatter) override;
};
 
class ProjectRestoreTool : public ProjectToolBase {
 public:
  std::string GetName() const override { return "project-restore"; }
 
  std::string GetDescription() const {
    return "Restore ROM to named checkpoint";
  }
 
  std::string GetUsage() const override {
    return "project-restore --name <name> [--format <json|text>]";
  }
 
  bool RequiresLabels() const override { return false; }
 
 protected:
  absl::Status ValidateArgs(const resources::ArgumentParser& parser) override {
    return parser.RequireArgs({"name"});
  }
 
  absl::Status Execute(Rom* rom, const resources::ArgumentParser& parser,
                       resources::OutputFormatter& formatter) override;
};
 
class ProjectExportTool : public ProjectToolBase {
 public:
  std::string GetName() const override { return "project-export"; }
 
  std::string GetDescription() const {
    return "Export project as portable archive";
  }
 
  std::string GetUsage() const override {
    return "project-export --path <path> [--include-rom] [--format <json|text>]";
  }
 
  bool RequiresLabels() const override { return false; }
 
 protected:
  absl::Status ValidateArgs(const resources::ArgumentParser& parser) override {
    return parser.RequireArgs({"path"});
  }
 
  absl::Status Execute(Rom* rom, const resources::ArgumentParser& parser,
                       resources::OutputFormatter& formatter) override;
};
 
class ProjectImportTool : public ProjectToolBase {
 public:
  std::string GetName() const override { return "project-import"; }
 
  std::string GetDescription() const { return "Import project archive"; }
 
  std::string GetUsage() const override {
    return "project-import --path <path> [--format <json|text>]";
  }
 
  bool RequiresLabels() const override { return false; }
 
 protected:
  absl::Status ValidateArgs(const resources::ArgumentParser& parser) override {
    return parser.RequireArgs({"path"});
  }
 
  absl::Status Execute(Rom* rom, const resources::ArgumentParser& parser,
                       resources::OutputFormatter& formatter) override;
};
 
class ProjectDiffTool : public ProjectToolBase {
 public:
  std::string GetName() const override { return "project-diff"; }
 
  std::string GetDescription() const { return "Compare two project states"; }
 
  std::string GetUsage() const override {
    return "project-diff --snapshot1 <name> --snapshot2 <name> [--format <json|text>]";
  }
 
  bool RequiresLabels() const override { return false; }
 
 protected:
  absl::Status ValidateArgs(const resources::ArgumentParser& parser) override {
    return parser.RequireArgs({"snapshot1", "snapshot2"});
  }
 
  absl::Status Execute(Rom* rom, const resources::ArgumentParser& parser,
                       resources::OutputFormatter& formatter) override;
};
 
}  // namespace tools
}  // namespace agent
}  // namespace cli
}  // namespace yaze
 
#endif  // YAZE_SRC_CLI_SERVICE_AGENT_TOOLS_PROJECT_TOOL_H_