fix(run): reuse last build preset instead of defaulting to dev-ninja

Author: GaspardKirira

include/vix/cli/commands/run/RunDetail.hpp

@@ -148,4 +148,10 @@ namespace vix::commands::RunCommand::detail
         apply_log_color_env(opt);
     }
 
+    std::string choose_configure_preset_smart(const std::filesystem::path &projectDir,
+                                              const std::string &userPreset);
+
+    std::filesystem::path resolve_build_dir_smart(const std::filesystem::path &projectDir,
+                                                  const std::string &configurePreset);
+
 } // namespace vix::commands::RunCommand::detail

src/commands/RunCommand.cpp

@@ -176,18 +176,22 @@ namespace vix::commands::RunCommand
 
         if (has_presets(projectDir))
         {
+            const std::string configurePreset =
+                choose_configure_preset_smart(projectDir, opt.preset);
+
+            const std::string runPreset =
+                choose_run_preset(projectDir, configurePreset, opt.runPreset);
+
+            const fs::path buildDir = resolve_build_dir_smart(projectDir, configurePreset);
+            const bool alreadyConfigured = has_cmake_cache(buildDir);
+
             RunProgress progress(/*totalSteps=*/2);
 
             // 1) Configure (only if needed)
             {
-                progress.phase_start("Configure project (preset: " + opt.preset + ")");
+                progress.phase_start("Configure project (preset: " + configurePreset + ")");
 
-                bool needConfigure = true;
-                if (auto binDir = detail::preset_binary_dir(projectDir, opt.preset))
-                {
-                    if (detail::has_cmake_cache(*binDir))
-                        needConfigure = false;
-                }
+                bool needConfigure = !alreadyConfigured;
 
                 if (!needConfigure)
                 {
@@ -198,34 +202,31 @@ namespace vix::commands::RunCommand
                     std::ostringstream oss;
 #ifdef _WIN32
                     oss << "cmd /C \"cd /D " << quote(projectDir.string())
-                        << " && cmake --preset " << quote(opt.preset) << "\"";
+                        << " && cmake --preset " << quote(configurePreset) << "\"";
 #else
                     oss << "cd " << quote(projectDir.string())
-                        << " && cmake --log-level=WARNING --preset " << quote(opt.preset);
+                        << " && cmake --log-level=WARNING --preset " << quote(configurePreset);
 #endif
                     const std::string cmd = oss.str();
 
                     const int code = run_cmd_live_filtered(
                         cmd,
-                        "Configuring project (preset \"" + opt.preset + "\")");
+                        "Configuring project (preset \"" + configurePreset + "\")");
 
                     if (code != 0)
                     {
-                        error("CMake configure failed with preset '" + opt.preset + "'.");
+                        error("CMake configure failed with preset '" + configurePreset + "'.");
                         hint("Run the same command manually to inspect the error:");
                         step("cd " + projectDir.string());
-                        step("cmake --preset " + opt.preset);
+                        step("cmake --preset " + configurePreset);
                         return code != 0 ? code : 2;
                     }
 
                     progress.phase_done("Configure project", "completed");
                 }
             }
 
-            // 2) run preset
-            const std::string runPreset =
-                choose_run_preset(projectDir, opt.preset, opt.runPreset);
-
+            // 2) Build & run preset
             {
                 progress.phase_start("Build & run (preset: " + runPreset + ")");
                 const std::string mode = opt.watch ? "dev" : "run";
@@ -489,7 +490,7 @@ namespace vix::commands::RunCommand
     {
         std::ostream &out = std::cout;
 
-        out << "Usage:\n";
+        out << "Usageddd:\n";
         out << "  vix run [name|file.cpp|manifest.vix] [options] [-- compiler/linker flags]\n\n";
 
         out << "Description:\n";

src/commands/run/RunFlow.cpp

@@ -15,6 +15,7 @@
 
 #ifndef _WIN32
 #include <sys/wait.h>
+#include <chrono>
 #endif
 
 using namespace vix::cli::style;
@@ -507,6 +508,28 @@ namespace vix::commands::RunCommand::detail
 #endif
     }
 
+    fs::path resolve_build_dir_smart(const fs::path &projectDir,
+                                     const std::string &configurePreset)
+    {
+        fs::path buildDir = projectDir / "build";
+
+        if (auto binDir = preset_binary_dir(projectDir, configurePreset))
+            return *binDir;
+
+        fs::path p = projectDir / ("build-" + configurePreset);
+        if (fs::exists(p))
+            return p;
+
+        if (configurePreset.rfind("dev-", 0) == 0)
+        {
+            fs::path p2 = projectDir / ("build-" + configurePreset.substr(4));
+            if (fs::exists(p2))
+                return p2;
+        }
+
+        return buildDir;
+    }
+
     static std::vector<std::string> list_presets(const fs::path &dir, const std::string &kind)
     {
 #ifdef _WIN32
@@ -577,6 +600,87 @@ namespace vix::commands::RunCommand::detail
         return fs::exists(buildDir / "CMakeCache.txt", ec);
     }
 
+#ifndef _WIN32
+    static std::optional<std::chrono::file_clock::time_point>
+    mtime_if_exists(const fs::path &p)
+    {
+        std::error_code ec;
+        if (!fs::exists(p, ec) || ec)
+            return std::nullopt;
+        auto t = fs::last_write_time(p, ec);
+        if (ec)
+            return std::nullopt;
+        return t;
+    }
+
+    std::string choose_configure_preset_smart(const fs::path &projectDir,
+                                              const std::string &userPreset)
+    {
+
+        // Respect user choice always
+        if (!userPreset.empty())
+            return userPreset;
+
+        auto cfgs = list_presets(projectDir, "configure");
+        if (cfgs.empty())
+            return "dev-ninja";
+
+        struct Candidate
+        {
+            std::string preset;
+            fs::path buildDir;
+            std::chrono::file_clock::time_point stamp{};
+        };
+
+        std::optional<Candidate> best;
+
+        for (const auto &preset : cfgs)
+        {
+            // IMPORTANT: do NOT rely on parsing binaryDir from presets json
+            const fs::path buildDir = resolve_build_dir_smart(projectDir, preset);
+
+            if (!has_cmake_cache(buildDir))
+                continue;
+
+            auto t = mtime_if_exists(buildDir / "CMakeCache.txt");
+            if (!t)
+                continue;
+
+            Candidate c{preset, buildDir, *t};
+
+            if (!best || c.stamp > best->stamp)
+                best = c;
+        }
+
+        if (std::getenv("VIX_DEBUG_PRESET"))
+        {
+            info("Preset candidates:");
+            for (const auto &preset : cfgs)
+            {
+                const auto buildDir = resolve_build_dir_smart(projectDir, preset);
+                step("• " + preset + " -> " + buildDir.string() +
+                     (has_cmake_cache(buildDir) ? " [cache]" : " [no-cache]"));
+            }
+        }
+
+        // If we found an existing configured preset, prefer it.
+        if (best)
+            return best->preset;
+
+        // Otherwise keep a stable default:
+        if (std::find(cfgs.begin(), cfgs.end(), "dev-ninja") != cfgs.end())
+            return "dev-ninja";
+
+        return cfgs.front();
+    }
+
+#else
+    std::string choose_configure_preset_smart(const fs::path &, const std::string &userPreset)
+    {
+        return userPreset.empty() ? std::string("dev-ninja") : userPreset;
+    }
+#endif
+
     std::optional<fs::path> choose_project_dir(const Options &opt, const fs::path &cwd)
     {
         auto exists_cml = [](const fs::path &p)