{

auto it = std::find(a.begin(), a.end(), flag);

if (it == a.end())

return false;

a.erase(it);

return true;

{

for (const auto &x : candidates)

if (std::find(a.begin(), a.end(), x) != a.end())

return true;

return false;

std::vector<std::string> &a,

const std::vector<std::string> &names)

{

for (const auto &n : names)

{

for (std::size_t i = 0; i < a.size(); ++i)

{

if (a[i] == n)

{

if (i + 1 >= a.size())

return std::nullopt;

std::string v = a[i + 1];

a.erase(a.begin() + static_cast<std::ptrdiff_t>(i), a.begin() + static_cast<std::ptrdiff_t>(i) + 2);

return v;

}

const std::string prefix = n + "=";

if (a[i].rfind(prefix, 0) == 0)

{

std::string v = a[i].substr(prefix.size());

a.erase(a.begin() + static_cast<std::ptrdiff_t>(i));

return v;

}

}

}

return std::nullopt;

{

// Return codes: 0 = success | 2 = user cancelled | 1 = error

if (argsIn.empty())

{

error("Missing project name.");

hint("Usage: vix new <name|path> [-d|--dir <base_dir>] [--app|--lib|--game] [--force]");

return 1;

}

std::vector<std::string> args = argsIn;

const bool force = consume_flag(args, "--force");

const bool apiOnly = consume_flag(args, "--api-only");

const std::optional<std::string> baseOpt = take_option_value(args, {"-d", "--dir"});

const std::optional<std::string> templateOpt =

take_option_value(args, {"--template"});

const bool wantsLib = has_any(args, {"--lib", "--library", "--type=lib", "--type=library"});

const bool wantsApp = has_any(args, {"--app", "--application", "--type=app", "--type=application"});

const bool wantsGame = has_any(args, {"--game", "--type=game"});

for (const auto &f : {"--lib", "--library", "--type=lib", "--type=library",

"--app", "--application", "--type=app", "--type=application",

"--game", "--type=game"})

consume_flag(args, f);

if (args.empty())

{

error("Missing project name.");

hint("Usage: vix new <name|path> [--template vue|game] [--app|--lib|--game] [--force]");

return 1;

}

if ((wantsLib && wantsApp) || (wantsLib && wantsGame) || (wantsApp && wantsGame))

{

error("Conflicting options: choose only one project type.");

return 1;

}

if (!args[0].empty() && args[0][0] == '-' && !gen::is_dot_path(args[0]))

{

error("Missing project name.");

hint("Options must come after a project name or be followed by one.");

step("vix new my-app --template vue");

return 1;

}

if (templateOpt.has_value())

{

const std::string tpl = *templateOpt;

if (tpl != "vue" && tpl != "game" && tpl != "backend" && tpl != "web")

{

error("Unknown template: " + tpl);

hint("Supported templates: backend, web, vue, game");

return 1;

}

if (wantsLib)

{

error("Conflicting options: --template cannot be used with --lib.");

hint("Templates currently supported: vue, game, backend.");

return 1;

}

if (wantsApp && *templateOpt == "game")

{

error("Conflicting options: --template game cannot be used with --app.");

hint("Use --game or --template game.");

return 1;

}

if (wantsGame && *templateOpt == "vue")

{

error("Conflicting options: --template vue cannot be used with --game.");

hint("Use --app, --template vue, or --template game.");

return 1;

}

if (wantsGame && *templateOpt == "backend")

{

error("Conflicting options: --template backend cannot be used with --game.");

hint("Use --template backend.");

return 1;

}

if (wantsGame && *templateOpt == "web")

{

error("Conflicting options: --template web cannot be used with --game.");

hint("Use --template web.");

return 1;

}

}

if (apiOnly && (!templateOpt.has_value() || *templateOpt != "backend"))

{

error("Conflicting options: --api-only requires --template backend.");

hint("Use: vix new <name> --template backend --api-only");

return 1;

}

const std::string nameOrPath = args[0];

const bool inPlace = gen::is_dot_path(nameOrPath);

try

{

tui::SignalGuard sig;

if (tui::g_cancelled.load())

return 2;

// ------------------------------------------------------------------

// Step 0 – Resolve destination path

// ------------------------------------------------------------------

fs::path dest;

fs::path np = fs::path(nameOrPath);

if (baseOpt.has_value())

{

fs::path base = fs::path(*baseOpt);

std::error_code ec;

if (!fs::exists(base, ec) || !fs::is_directory(base, ec))

{

error("Base directory '" + base.string() + "' is not a valid folder.");

hint("Make sure it exists and is a directory, or omit --dir.");

return 1;

}

dest = np.is_absolute() ? np : fs::weakly_canonical(base / np, ec);

if (ec)

dest = base / np;

}

else

{

std::error_code ec;

dest = np.is_absolute() ? np : fs::weakly_canonical(fs::current_path() / np, ec);

if (ec)

dest = fs::current_path() / np;

}

fs::path projectDir = inPlace ? fs::current_path() : dest;

std::string projName = inPlace ? gen::current_dir_name() : projectDir.filename().string();

if (tui::g_cancelled.load())

return 2;

// ------------------------------------------------------------------

// Step 1 – Existing-directory handling

// ------------------------------------------------------------------

if (fs::exists(projectDir))

{

if (!gen::dir_exists(projectDir))

{

error("Path exists but is not a directory: '" + projectDir.string() + "'");

return 1;

}

if (!gen::dir_is_empty(projectDir))

{

if (inPlace)

{

if (!force)

{

if (tui::can_interact())

{

const auto choice = tui::confirm_inplace_dir_interactive(projectDir);

if (choice.cancelled || choice.value == InPlaceDirChoice::Cancel)

return 2;

}

else

{

error("Cannot create project in current directory: directory is not empty.");

hint("Use --force to overwrite template files.");

return 1;

}

}

// force=true → proceed (overwrite files, do NOT delete the dir)

}

else

{

if (force)

{

std::error_code ec;

fs::remove_all(projectDir, ec);

if (ec)

{

error("Failed to remove existing directory.");

hint(ec.message());

return 1;

}

}

else if (tui::can_interact())

{

const auto choice = tui::confirm_overwrite_interactive(projectDir);

if (choice.cancelled || choice.value == OverwriteChoice::Cancel)

return 2;

std::error_code ec;

fs::remove_all(projectDir, ec);

if (ec)

{

error("Failed to remove existing directory.");

hint(ec.message());

return 1;

}

}

else

{

error("Cannot create project in '" + projectDir.string() + "': directory is not empty.");

hint("Use --force to overwrite.");

return 1;

}

}

if (tui::g_cancelled.load())

return 2;

}

}

// ------------------------------------------------------------------

// Step 2 – Choose template

// ------------------------------------------------------------------

TemplateKind kind = TemplateKind::App;

if (templateOpt.has_value() && *templateOpt == "backend")

{

kind = TemplateKind::Backend;

}

else if (templateOpt.has_value() && *templateOpt == "web")

{

kind = TemplateKind::Web;

}

else if (templateOpt.has_value() && *templateOpt == "game")

{

kind = TemplateKind::Game;

}

else if (templateOpt.has_value() && *templateOpt == "vue")

{

kind = TemplateKind::Vue;

}

else if (wantsGame)

{

kind = TemplateKind::Game;

}

else if (wantsLib)

{

kind = TemplateKind::Lib;

}

else if (wantsApp)

{

kind = TemplateKind::App;

}

else if (tui::can_interact())

{

const auto sel = tui::choose_template_interactive();

if (sel.cancelled)

return 2;

kind = sel.value;

}

if (tui::g_cancelled.load())

return 2;

// ------------------------------------------------------------------

// Step 3 – Choose features

// ------------------------------------------------------------------

FeaturesSelection features{};

if ((kind == TemplateKind::App || kind == TemplateKind::Vue || kind == TemplateKind::Backend) &&

tui::can_interact())

{

bool cancelled = false;

features = tui::choose_features_interactive(cancelled);

if (cancelled)

return 2;

}

if (features.full_static)

features.static_rt = true;

if (tui::g_cancelled.load())

return 2;

// ------------------------------------------------------------------

// Step 4 – Create project root

// ------------------------------------------------------------------

{

std::string err;

if (!gen::ensure_dir(projectDir, err))

{

error("Failed to create project directory.");

hint(err);

return 1;

}

}

if (tui::g_cancelled.load())

return 2;

// ------------------------------------------------------------------

// Step 5 – Generate files

// ------------------------------------------------------------------

std::string genErr;

if (kind == TemplateKind::Vue)

{

if (!gen::generate_vue_project(projectDir, projName, features, genErr))

{

vix::cli::util::err_line(std::cerr, "Failed to create project files.");

vix::cli::util::warn_line(std::cerr, genErr);

return 1;

}

vix::cli::util::ok_line(std::cout, "Project created.");

vix::cli::util::kv(std::cout, "Location", projectDir.string());

gen::print_next_steps_vue(projectDir, projName);

return 0;

}

if (kind == TemplateKind::Backend)

{

if (!gen::generate_backend_project(projectDir, projName, features, apiOnly, genErr))

{

vix::cli::util::err_line(std::cerr, "Failed to create project files.");

vix::cli::util::warn_line(std::cerr, genErr);

return 1;

}

vix::cli::util::ok_line(std::cout, "Project created.");

vix::cli::util::kv(std::cout, "Location", projectDir.string());

gen::print_next_steps_backend(projectDir, projName);

return 0;

}

if (kind == TemplateKind::Web)

{

if (!gen::generate_web_project(projectDir, projName, features, genErr))

{

vix::cli::util::err_line(std::cerr, "Failed to create project files.");

vix::cli::util::warn_line(std::cerr, genErr);

return 1;

}

vix::cli::util::ok_line(std::cout, "Project created.");

vix::cli::util::kv(std::cout, "Location", projectDir.string());

gen::print_next_steps_web(projectDir, projName);

return 0;

}

if (kind == TemplateKind::Game)

{

if (!gen::generate_game_project(projectDir, projName, genErr))

{

vix::cli::util::err_line(std::cerr, "Failed to create project files.");

vix::cli::util::warn_line(std::cerr, genErr);

return 1;

}

vix::cli::util::ok_line(std::cout, "Project created.");

vix::cli::util::kv(std::cout, "Location", projectDir.string());

gen::print_next_steps_game(projectDir, projName);

return 0;

}

if (kind == TemplateKind::App)

{

if (!gen::generate_app_project(projectDir, projName, features, genErr))

{

vix::cli::util::err_line(std::cerr, "Failed to create project files.");

vix::cli::util::warn_line(std::cerr, genErr);

return 1;

}

vix::cli::util::ok_line(std::cout, "Project created.");

vix::cli::util::kv(std::cout, "Location", projectDir.string());

gen::print_next_steps_app(projectDir, projName);

return 0;

}

if (!gen::generate_lib_project(projectDir, projName, genErr))

{

vix::cli::util::err_line(std::cerr, "Failed to create project files.");

vix::cli::util::warn_line(std::cerr, genErr);

return 1;

}

vix::cli::util::ok_line(std::cout, "Project created.");

vix::cli::util::kv(std::cout, "Location", projectDir.string());

gen::print_next_steps_lib(projectDir, projName);

return 0;

}

catch (const std::exception &ex)

{

error("Failed to create project.");

hint(ex.what());

return 1;

}

{

std::ostream &out = std::cout;

out

<< "vix new\n"

<< "Create a new Vix project.\n\n"

<< "Usage\n"

<< " vix new <name|path> [options]\n\n"

<< "Examples\n"

<< " vix new api\n"

<< " vix new .\n"

<< " vix new tree --lib\n"

<< " vix new api --template backend\n"

<< " vix new blog --template backend --api-only\n"

<< " vix new blog --template web\n"

<< " vix new mario --game\n"

<< " vix new shop --template vue\n"

<< " vix new platformer --template game\n"

<< " vix new blog -d ./projects\n"

<< " vix new api --force\n\n"

<< "What happens\n"

<< " • Generates a ready-to-run Vix project\n"

<< " • Sets up source structure and config files\n"

<< " • Creates a vix.json manifest\n"

<< " • Creates a vix.app manifest when the template uses the Vix app workflow\n"

<< " • For apps, creates an executable target matching the project name\n"

<< " • For libraries, creates a header-only CMake interface target\n"

<< " • Applies the selected template: app, backend, game, library, or Vue\n\n"

<< "Options\n"

<< " --app Generate an application (default)\n"

<< " --game Generate a Vix game project\n"

<< " --lib Generate a header-only library\n"

<< " --template Project template: backend, web, vue, game\n"

<< " --api-only Generate backend API without public files or views\n"

<< " -d, --dir Base directory for project creation\n"

<< " --force Overwrite existing directory\n\n"

<< "Web workflow\n"

<< " cd blog/\n"

<< " cp .env.example .env\n"

<< " vix dev\n"

<< " open http://127.0.0.1:8080\n\n"

<< "Application workflow\n"

<< " cd api/\n"

<< " vix build\n"

<< " vix run\n\n"

<< "Backend workflow\n"

<< " cd api/\n"

<< " cp .env.example .env\n"

<< " vix dev\n"

<< " curl http://127.0.0.1:8080/health\n\n"

<< "Game workflow\n"

<< " cd mario/\n"

<< " vix build\n"

<< " vix run\n\n"

<< "Library workflow\n"

<< " cd tree/\n"

<< " vix build --build-target all\n"

<< " vix build --build-target all -- -Dtree_BUILD_TESTS=ON\n"

<< " vix tests\n\n"

<< "Environment\n"

<< " VIX_NONINTERACTIVE=1 Disable prompts\n"

<< " CI=1 Disable prompts\n\n"

<< "Notes\n"

<< " • Use '.' to initialize in the current directory\n"

<< " • Use 'vix add <pkg>' to add dependencies\n"

<< " • Use 'vix install' to install from vix.lock\n"

<< " • Use 'vix task <name>' to run generated tasks\n"

<< " • Backend projects are generated with production-oriented folders and config\n"

<< " • For header-only libraries, use '--build-target all' to build the generated project\n"

<< " • Tests for header-only libraries are disabled by default and must be enabled with CMake args\n"

<< " • Designed for fast start with zero setup\n";

return 0;