f38946118c
- Added functionality for listing, reading, and searching messages in the ROM. - Introduced new commands: `message-list`, `message-read`, and `message-search` with appropriate parameters and descriptions. - Enhanced the CLI to support these commands, including JSON and text output formats. - Updated system prompts and function schemas to reflect the new message handling capabilities.
327 lines
10 KiB
C++
327 lines
10 KiB
C++
#include <cstdlib>
|
|
#include <iostream>
|
|
#include <optional>
|
|
#include <string>
|
|
#include <string_view>
|
|
#include <vector>
|
|
|
|
#include "absl/flags/declare.h"
|
|
#include "absl/flags/flag.h"
|
|
#include "absl/strings/match.h"
|
|
#include "absl/strings/str_format.h"
|
|
#include "cli/modern_cli.h"
|
|
#include "cli/tui.h"
|
|
#include "cli/z3ed_ascii_logo.h"
|
|
#include "yaze_config.h"
|
|
|
|
// Define all CLI flags
|
|
ABSL_FLAG(bool, tui, false, "Launch interactive Text User Interface");
|
|
ABSL_FLAG(bool, quiet, false, "Suppress non-essential output");
|
|
ABSL_FLAG(bool, version, false, "Show version information");
|
|
ABSL_DECLARE_FLAG(std::string, rom);
|
|
ABSL_DECLARE_FLAG(std::string, ai_provider);
|
|
ABSL_DECLARE_FLAG(std::string, ai_model);
|
|
ABSL_DECLARE_FLAG(std::string, gemini_api_key);
|
|
ABSL_DECLARE_FLAG(std::string, ollama_host);
|
|
ABSL_DECLARE_FLAG(std::string, prompt_version);
|
|
ABSL_DECLARE_FLAG(bool, use_function_calling);
|
|
|
|
namespace {
|
|
|
|
void PrintVersion() {
|
|
std::cout << yaze::cli::GetColoredLogo() << "\n";
|
|
std::cout << absl::StrFormat(" Version %d.%d.%d\n",
|
|
YAZE_VERSION_MAJOR,
|
|
YAZE_VERSION_MINOR,
|
|
YAZE_VERSION_PATCH);
|
|
std::cout << " Yet Another Zelda3 Editor - Command Line Interface\n";
|
|
std::cout << " https://github.com/scawful/yaze\n\n";
|
|
}
|
|
|
|
void PrintCompactHelp() {
|
|
std::cout << yaze::cli::GetColoredLogo() << "\n";
|
|
std::cout << " \033[1;37mYet Another Zelda3 Editor - AI-Powered CLI\033[0m\n\n";
|
|
|
|
std::cout << "\033[1;36mUSAGE:\033[0m\n";
|
|
std::cout << " z3ed [command] [flags]\n";
|
|
std::cout << " z3ed --tui # Interactive TUI mode\n";
|
|
std::cout << " z3ed --version # Show version\n";
|
|
std::cout << " z3ed --help <category> # Category help\n\n";
|
|
|
|
std::cout << "\033[1;36mCOMMANDS:\033[0m\n";
|
|
std::cout << " \033[1;33magent\033[0m AI conversational agent for ROM inspection\n";
|
|
std::cout << " \033[1;33mrom\033[0m ROM operations (info, validate, diff)\n";
|
|
std::cout << " \033[1;33mdungeon\033[0m Dungeon inspection and editing\n";
|
|
std::cout << " \033[1;33moverworld\033[0m Overworld inspection and editing\n";
|
|
std::cout << " \033[1;33mmessage\033[0m Message/dialogue inspection\n";
|
|
std::cout << " \033[1;33mgfx\033[0m Graphics operations (export, import)\n";
|
|
std::cout << " \033[1;33mpalette\033[0m Palette operations\n";
|
|
std::cout << " \033[1;33mpatch\033[0m Apply patches (BPS, Asar)\n";
|
|
std::cout << " \033[1;33mproject\033[0m Project management (init, build)\n\n";
|
|
|
|
std::cout << "\033[1;36mCOMMON FLAGS:\033[0m\n";
|
|
std::cout << " --rom=<path> Path to ROM file\n";
|
|
std::cout << " --tui Launch interactive TUI\n";
|
|
std::cout << " --quiet, -q Suppress output\n";
|
|
std::cout << " --version Show version\n";
|
|
std::cout << " --help <category> Show category help\n\n";
|
|
|
|
std::cout << "\033[1;36mEXAMPLES:\033[0m\n";
|
|
std::cout << " z3ed agent test-conversation --rom=zelda3.sfc\n";
|
|
std::cout << " z3ed rom info --rom=zelda3.sfc\n";
|
|
std::cout << " z3ed agent message-search --rom=zelda3.sfc --query=\"Master Sword\"\n";
|
|
std::cout << " z3ed dungeon export --rom=zelda3.sfc --id=1\n\n";
|
|
|
|
std::cout << "For detailed help: z3ed --help <command>\n";
|
|
std::cout << "For all commands: z3ed --list-commands\n\n";
|
|
}
|
|
|
|
struct ParsedGlobals {
|
|
std::vector<char*> positional;
|
|
bool show_help = false;
|
|
bool show_version = false;
|
|
bool list_commands = false;
|
|
std::optional<std::string> help_category;
|
|
std::optional<std::string> error;
|
|
};
|
|
|
|
ParsedGlobals ParseGlobalFlags(int argc, char* argv[]) {
|
|
ParsedGlobals result;
|
|
if (argc <= 0 || argv == nullptr) {
|
|
result.error = "Invalid argv provided";
|
|
return result;
|
|
}
|
|
|
|
result.positional.reserve(argc);
|
|
result.positional.push_back(argv[0]);
|
|
|
|
bool passthrough = false;
|
|
for (int i = 1; i < argc; ++i) {
|
|
char* current = argv[i];
|
|
std::string_view token(current);
|
|
|
|
if (!passthrough) {
|
|
if (token == "--") {
|
|
passthrough = true;
|
|
continue;
|
|
}
|
|
|
|
// Help flags
|
|
if (absl::StartsWith(token, "--help=")) {
|
|
std::string category(token.substr(7));
|
|
if (!category.empty()) {
|
|
result.help_category = category;
|
|
} else {
|
|
result.show_help = true;
|
|
}
|
|
continue;
|
|
}
|
|
if (token == "--help" || token == "-h") {
|
|
if (i + 1 < argc && argv[i + 1][0] != '-') {
|
|
result.help_category = std::string(argv[++i]);
|
|
} else {
|
|
result.show_help = true;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
// Version flag
|
|
if (token == "--version" || token == "-v") {
|
|
result.show_version = true;
|
|
continue;
|
|
}
|
|
|
|
// List commands
|
|
if (token == "--list-commands" || token == "--list") {
|
|
result.list_commands = true;
|
|
continue;
|
|
}
|
|
|
|
// TUI mode
|
|
if (token == "--tui" || token == "--interactive") {
|
|
absl::SetFlag(&FLAGS_tui, true);
|
|
continue;
|
|
}
|
|
|
|
// Quiet mode
|
|
if (token == "--quiet" || token == "-q") {
|
|
absl::SetFlag(&FLAGS_quiet, true);
|
|
continue;
|
|
}
|
|
if (absl::StartsWith(token, "--quiet=")) {
|
|
std::string value(token.substr(8));
|
|
absl::SetFlag(&FLAGS_quiet, value == "true" || value == "1");
|
|
continue;
|
|
}
|
|
|
|
// ROM path
|
|
if (absl::StartsWith(token, "--rom=")) {
|
|
absl::SetFlag(&FLAGS_rom, std::string(token.substr(6)));
|
|
continue;
|
|
}
|
|
if (token == "--rom") {
|
|
if (i + 1 >= argc) {
|
|
result.error = "--rom flag requires a value";
|
|
return result;
|
|
}
|
|
absl::SetFlag(&FLAGS_rom, std::string(argv[++i]));
|
|
continue;
|
|
}
|
|
|
|
// AI provider flags
|
|
if (absl::StartsWith(token, "--ai_provider=") ||
|
|
absl::StartsWith(token, "--ai-provider=")) {
|
|
size_t eq_pos = token.find('=');
|
|
absl::SetFlag(&FLAGS_ai_provider, std::string(token.substr(eq_pos + 1)));
|
|
continue;
|
|
}
|
|
if (token == "--ai_provider" || token == "--ai-provider") {
|
|
if (i + 1 >= argc) {
|
|
result.error = "--ai-provider flag requires a value";
|
|
return result;
|
|
}
|
|
absl::SetFlag(&FLAGS_ai_provider, std::string(argv[++i]));
|
|
continue;
|
|
}
|
|
|
|
if (absl::StartsWith(token, "--ai_model=") ||
|
|
absl::StartsWith(token, "--ai-model=")) {
|
|
size_t eq_pos = token.find('=');
|
|
absl::SetFlag(&FLAGS_ai_model, std::string(token.substr(eq_pos + 1)));
|
|
continue;
|
|
}
|
|
if (token == "--ai_model" || token == "--ai-model") {
|
|
if (i + 1 >= argc) {
|
|
result.error = "--ai-model flag requires a value";
|
|
return result;
|
|
}
|
|
absl::SetFlag(&FLAGS_ai_model, std::string(argv[++i]));
|
|
continue;
|
|
}
|
|
|
|
if (absl::StartsWith(token, "--gemini_api_key=") ||
|
|
absl::StartsWith(token, "--gemini-api-key=")) {
|
|
size_t eq_pos = token.find('=');
|
|
absl::SetFlag(&FLAGS_gemini_api_key, std::string(token.substr(eq_pos + 1)));
|
|
continue;
|
|
}
|
|
if (token == "--gemini_api_key" || token == "--gemini-api-key") {
|
|
if (i + 1 >= argc) {
|
|
result.error = "--gemini-api-key flag requires a value";
|
|
return result;
|
|
}
|
|
absl::SetFlag(&FLAGS_gemini_api_key, std::string(argv[++i]));
|
|
continue;
|
|
}
|
|
|
|
if (absl::StartsWith(token, "--ollama_host=") ||
|
|
absl::StartsWith(token, "--ollama-host=")) {
|
|
size_t eq_pos = token.find('=');
|
|
absl::SetFlag(&FLAGS_ollama_host, std::string(token.substr(eq_pos + 1)));
|
|
continue;
|
|
}
|
|
if (token == "--ollama_host" || token == "--ollama-host") {
|
|
if (i + 1 >= argc) {
|
|
result.error = "--ollama-host flag requires a value";
|
|
return result;
|
|
}
|
|
absl::SetFlag(&FLAGS_ollama_host, std::string(argv[++i]));
|
|
continue;
|
|
}
|
|
|
|
if (absl::StartsWith(token, "--prompt_version=") ||
|
|
absl::StartsWith(token, "--prompt-version=")) {
|
|
size_t eq_pos = token.find('=');
|
|
absl::SetFlag(&FLAGS_prompt_version, std::string(token.substr(eq_pos + 1)));
|
|
continue;
|
|
}
|
|
if (token == "--prompt_version" || token == "--prompt-version") {
|
|
if (i + 1 >= argc) {
|
|
result.error = "--prompt-version flag requires a value";
|
|
return result;
|
|
}
|
|
absl::SetFlag(&FLAGS_prompt_version, std::string(argv[++i]));
|
|
continue;
|
|
}
|
|
|
|
if (absl::StartsWith(token, "--use_function_calling=") ||
|
|
absl::StartsWith(token, "--use-function-calling=")) {
|
|
size_t eq_pos = token.find('=');
|
|
std::string value(token.substr(eq_pos + 1));
|
|
absl::SetFlag(&FLAGS_use_function_calling, value == "true" || value == "1");
|
|
continue;
|
|
}
|
|
if (token == "--use_function_calling" || token == "--use-function-calling") {
|
|
if (i + 1 >= argc) {
|
|
result.error = "--use-function-calling flag requires a value";
|
|
return result;
|
|
}
|
|
std::string value(argv[++i]);
|
|
absl::SetFlag(&FLAGS_use_function_calling, value == "true" || value == "1");
|
|
continue;
|
|
}
|
|
}
|
|
|
|
result.positional.push_back(current);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
} // namespace
|
|
|
|
int main(int argc, char* argv[]) {
|
|
// Parse global flags
|
|
ParsedGlobals globals = ParseGlobalFlags(argc, argv);
|
|
|
|
if (globals.error.has_value()) {
|
|
std::cerr << "Error: " << *globals.error << "\n";
|
|
std::cerr << "Use --help for usage information.\n";
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
// Handle version flag
|
|
if (globals.show_version) {
|
|
PrintVersion();
|
|
return EXIT_SUCCESS;
|
|
}
|
|
|
|
// Handle TUI mode
|
|
if (absl::GetFlag(FLAGS_tui)) {
|
|
yaze::cli::ShowMain();
|
|
return EXIT_SUCCESS;
|
|
}
|
|
|
|
// Create CLI instance
|
|
yaze::cli::ModernCLI cli;
|
|
|
|
// Handle category-specific help
|
|
if (globals.help_category.has_value()) {
|
|
cli.PrintCategoryHelp(*globals.help_category);
|
|
return EXIT_SUCCESS;
|
|
}
|
|
|
|
// Handle list commands
|
|
if (globals.list_commands) {
|
|
cli.PrintCommandSummary();
|
|
return EXIT_SUCCESS;
|
|
}
|
|
|
|
// Handle general help or no arguments
|
|
if (globals.show_help || globals.positional.size() <= 1) {
|
|
PrintCompactHelp();
|
|
return EXIT_SUCCESS;
|
|
}
|
|
|
|
// Run CLI commands
|
|
auto status = cli.Run(static_cast<int>(globals.positional.size()),
|
|
globals.positional.data());
|
|
|
|
if (!status.ok()) {
|
|
std::cerr << "\n\033[1;31mError:\033[0m " << status.message() << "\n";
|
|
std::cerr << "Use --help for usage information.\n";
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
return EXIT_SUCCESS;
|
|
} |