feat(build): make graph executor production-safe

Author: GaspardKirira

include/vix/cli/build/BuildGraphExecutor.hpp

@@ -10,13 +10,14 @@
  *
  *  Vix.cpp
  *
- *  Target-aware build graph executor
+ *  Production-safe target-aware build graph executor
  *
  */
 
 #ifndef VIX_CLI_BUILD_BUILD_GRAPH_EXECUTOR_HPP
 #define VIX_CLI_BUILD_BUILD_GRAPH_EXECUTOR_HPP
 
+#include <cstddef>
 #include <filesystem>
 #include <string>
 #include <vector>
@@ -28,6 +29,46 @@ namespace vix::cli::build
 {
   namespace fs = std::filesystem;
 
+  enum class BuildGraphExecutorStatus
+  {
+    Success,
+    UpToDate,
+    DelegatedToNinja,
+    InvalidRequest,
+    InvalidGraph,
+    UnsupportedTarget,
+    CompileFailed,
+    NinjaFailed,
+    CacheFailed
+  };
+
+  inline const char *to_string(BuildGraphExecutorStatus status)
+  {
+    switch (status)
+    {
+    case BuildGraphExecutorStatus::Success:
+      return "success";
+    case BuildGraphExecutorStatus::UpToDate:
+      return "up-to-date";
+    case BuildGraphExecutorStatus::DelegatedToNinja:
+      return "delegated-to-ninja";
+    case BuildGraphExecutorStatus::InvalidRequest:
+      return "invalid-request";
+    case BuildGraphExecutorStatus::InvalidGraph:
+      return "invalid-graph";
+    case BuildGraphExecutorStatus::UnsupportedTarget:
+      return "unsupported-target";
+    case BuildGraphExecutorStatus::CompileFailed:
+      return "compile-failed";
+    case BuildGraphExecutorStatus::NinjaFailed:
+      return "ninja-failed";
+    case BuildGraphExecutorStatus::CacheFailed:
+      return "cache-failed";
+    default:
+      return "unknown";
+    }
+  }
+
   struct BuildGraphExecutorOptions
   {
     fs::path buildDir;
@@ -36,13 +77,36 @@ namespace vix::cli::build
     int jobs{0};
     bool quiet{false};
     bool verbose{false};
+
+    /*
+     * Production rule:
+     * The graph executor is an optimization layer.
+     * Ninja remains the source of truth when the graph is incomplete,
+     * ambiguous, unsupported or too risky.
+     */
+    bool allowNinjaFallback{true};
+
+    /*
+     * 0 means no artificial limit.
+     * Production builds should not fail just because many files are dirty.
+     * Large dirty sets can be delegated to Ninja instead.
+     */
+    std::size_t maxGraphDirtyCompileTasks{0};
   };
 
   struct BuildGraphExecutorResult
   {
     bool ok{false};
 
+    BuildGraphExecutorStatus status{BuildGraphExecutorStatus::InvalidRequest};
+
     std::string target;
+    std::string reason;
+
+    bool usedGraph{false};
+    bool usedNinja{false};
+    bool usedFallback{false};
+
     std::size_t selectedTasks{0};
     std::size_t selectedCompileTasks{0};
     std::size_t dirtyCompileTasks{0};
@@ -51,6 +115,11 @@ namespace vix::cli::build
 
     int exitCode{0};
     std::string output;
+
+    bool success() const
+    {
+      return ok && exitCode == 0;
+    }
   };
 
   class BuildGraphExecutor

src/build/BuildGraph.cpp

@@ -30,6 +30,7 @@ namespace vix::cli::build
   {
     static constexpr std::uint64_t FNV_OFFSET = 1469598103934665603ull;
     static constexpr std::uint64_t FNV_PRIME = 1099511628211ull;
+    static constexpr const char *BUILD_GRAPH_MAGIC = "vix-build-graph";
 
     static std::uint64_t fnv_mix(
         std::uint64_t h,
@@ -1269,7 +1270,7 @@ namespace vix::cli::build
   bool BuildGraph::save(const fs::path &path) const
   {
     std::ostringstream out;
-    out << "vix-build-graph-v1\n";
+    out << BUILD_GRAPH_MAGIC << "\n";
     out << "project=" << escape_field(config_.projectDir.string()) << "\n";
     out << "build=" << escape_field(config_.buildDir.string()) << "\n";
     out << "object=" << escape_field(config_.objectDir.string()) << "\n";
@@ -1326,7 +1327,7 @@ namespace vix::cli::build
     if (!std::getline(in, magic))
       return std::nullopt;
 
-    if (magic != "vix-build-graph-v1")
+    if (magic != BUILD_GRAPH_MAGIC)
       return std::nullopt;
 
     BuildGraph graph;

src/build/BuildGraphExecutor.cpp

@@ -67,6 +67,25 @@ namespace vix::cli::build
       return false;
     }
 
+    static BuildGraphExecutorResult make_failed_result(
+        const BuildGraphExecutorOptions &options,
+        BuildGraphExecutorStatus status,
+        int exitCode,
+        const std::string &reason)
+    {
+      BuildGraphExecutorResult result;
+      result.ok = false;
+      result.status = status;
+      result.target = options.target;
+      result.reason = reason;
+      result.exitCode = exitCode;
+
+      if (!reason.empty())
+        result.output = reason + "\n";
+
+      return result;
+    }
+
     static std::unordered_map<std::string, std::string>
     make_output_to_task_map(const BuildGraph &graph)
     {
@@ -107,9 +126,10 @@ namespace vix::cli::build
         const BuildTask &task = kv.second;
 
         /*
-         * Safe V1:
-         *   Link/Archive -> Graph Executor can handle target closure.
-         *   Copy/Install/Generate/Utility/phony -> fallback CMake/Ninja.
+         * Production policy:
+         * Only real link/archive targets are executed through the graph path.
+         * Generated, phony, copy and install targets are delegated to Ninja because
+         * Ninja remains the authoritative executor for complex build semantics.
          */
         if (!is_real_graph_target_task(task))
           continue;
@@ -374,6 +394,64 @@ namespace vix::cli::build
       return task;
     }
 
+    static BuildGraphExecutorResult run_ninja_target_fallback(
+        const BuildGraphExecutorOptions &options,
+        BuildGraphExecutorStatus status,
+        const std::string &reason)
+    {
+      if (!options.allowNinjaFallback)
+      {
+        return make_failed_result(
+            options,
+            status,
+            2,
+            reason);
+      }
+
+      BuildGraphExecutorResult result;
+      result.target = options.target;
+      result.status = BuildGraphExecutorStatus::DelegatedToNinja;
+      result.reason = reason;
+      result.usedNinja = true;
+      result.usedFallback = true;
+
+      BuildTask ninjaTargetTask =
+          make_ninja_target_task(
+              options.buildDir,
+              options.target);
+
+      const process::ExecResult ninjaResult =
+          run_process_live_to_log(
+              ninjaTargetTask.command,
+              {},
+              options.buildDir / "build.log",
+              options.quiet,
+              /*cmakeVerbose=*/false,
+              /*progressOnly=*/false);
+
+      result.exitCode = ninjaResult.exitCode;
+
+      if (!reason.empty())
+        result.output = reason + "\n";
+
+      if (ninjaResult.producedOutput && !ninjaResult.capturedFirstLine.empty())
+        result.output += ninjaResult.capturedFirstLine + "\n";
+
+      if (ninjaResult.exitCode == 0)
+      {
+        result.ok = true;
+        return result;
+      }
+
+      result.ok = false;
+      result.status = BuildGraphExecutorStatus::NinjaFailed;
+
+      if (!ninjaResult.displayCommand.empty())
+        result.output += ninjaResult.displayCommand + "\n";
+
+      return result;
+    }
+
     static bool graph_debug_logs_enabled()
     {
       const char *level = std::getenv("VIX_LOG_LEVEL");
@@ -441,13 +519,10 @@ namespace vix::cli::build
 
     if (!targetTask)
     {
-      result.ok = false;
-      result.exitCode = 2;
-      result.output =
-          "Unable to resolve a unique real graph output target: " +
-          options_.target +
-          "\n";
-      return result;
+      return run_ninja_target_fallback(
+          options_,
+          BuildGraphExecutorStatus::UnsupportedTarget,
+          "Unable to resolve a unique graph output target: " + options_.target);
     }
 
     graph_log(
@@ -503,18 +578,17 @@ namespace vix::cli::build
         "graph: dirty compile tasks: " +
             std::to_string(result.dirtyCompileTasks));
 
-    if (result.dirtyCompileTasks > 128)
+    if (options_.maxGraphDirtyCompileTasks > 0 &&
+        result.dirtyCompileTasks > options_.maxGraphDirtyCompileTasks)
     {
-      result.ok = false;
-      result.exitCode = 2;
-      result.output =
+      return run_ninja_target_fallback(
+          options_,
+          BuildGraphExecutorStatus::DelegatedToNinja,
           "Graph target has too many dirty compile tasks: " +
-          std::to_string(result.dirtyCompileTasks) +
-          " dirty tasks from " +
-          std::to_string(result.selectedCompileTasks) +
-          " selected compile tasks. Falling back to Ninja.\n";
-
-      return result;
+              std::to_string(result.dirtyCompileTasks) +
+              " dirty tasks from " +
+              std::to_string(result.selectedCompileTasks) +
+              " selected compile tasks. Delegating to Ninja.");
     }
 
     if (!dirtyCompileTasks.empty())