feat(build): support global packages in vix build (parity with vix run)

GaspardKirira · GaspardKirira · commit 35fd29b4ba04 · 2026-03-29T12:59:27.000+03:00
diff --git a/include/vix/cli/cmake/GlobalPackages.hpp b/include/vix/cli/cmake/GlobalPackages.hpp
@@ -0,0 +1,40 @@
+/**
+ *
+ *  @file GlobalPackages.hpp
+ *  @author Gaspard Kirira
+ *
+ *  Copyright 2025, Gaspard Kirira.  All rights reserved.
+ *  https://github.com/vixcpp/vix
+ *  Use of this source code is governed by a MIT license
+ *  that can be found in the License file.
+ *
+ *  Vix.cpp
+ */
+#ifndef VIX_CLI_CMAKE_GLOBALPACKAGES_HPP
+#define VIX_CLI_CMAKE_GLOBALPACKAGES_HPP
+
+#include <filesystem>
+#include <string>
+#include <vector>
+
+namespace vix::cli::build
+{
+  namespace fs = std::filesystem;
+
+  struct GlobalPackage
+  {
+    std::string id;
+    std::string pkgDir;
+    std::string includeDir{"include"};
+    std::string type{"header-only"};
+    fs::path installedPath;
+  };
+
+  std::vector<GlobalPackage> load_global_packages();
+
+  std::string make_global_packages_cmake(
+      const std::vector<GlobalPackage> &packages);
+
+} // namespace vix::cli::build
+
+#endif
diff --git a/src/cmake/GlobalPackages.cpp b/src/cmake/GlobalPackages.cpp
@@ -0,0 +1,211 @@
+/**
+ *
+ *  @file GlobalPackages.cpp
+ *  @author Gaspard Kirira
+ *
+ *  Copyright 2025, Gaspard Kirira.  All rights reserved.
+ *  https://github.com/vixcpp/vix
+ *  Use of this source code is governed by a MIT license
+ *  that can be found in the License file.
+ *
+ *  Vix.cpp
+ */
+#include <vix/cli/cmake/GlobalPackages.hpp>
+
+#include <algorithm>
+#include <cstdlib>
+#include <fstream>
+#include <optional>
+#include <sstream>
+#include <string>
+
+#include <nlohmann/json.hpp>
+
+namespace vix::cli::build
+{
+  namespace
+  {
+    static std::optional<std::string> home_dir()
+    {
+#ifdef _WIN32
+      const char *home = std::getenv("USERPROFILE");
+#else
+      const char *home = std::getenv("HOME");
+#endif
+      if (!home || std::string(home).empty())
+        return std::nullopt;
+
+      return std::string(home);
+    }
+
+    static fs::path vix_root()
+    {
+      if (const auto home = home_dir(); home)
+        return fs::path(*home) / ".vix";
+
+      return fs::path(".vix");
+    }
+
+    static fs::path global_manifest_path()
+    {
+      return vix_root() / "global" / "installed.json";
+    }
+
+    static std::string dep_id_to_dir(std::string depId)
+    {
+      depId.erase(std::remove(depId.begin(), depId.end(), '@'), depId.end());
+      std::replace(depId.begin(), depId.end(), '/', '.');
+      return depId;
+    }
+
+    static std::string cmake_quote(const std::string &value)
+    {
+      std::string out;
+      out.reserve(value.size() + 8);
+      out.push_back('"');
+
+      for (char c : value)
+      {
+        if (c == '\\')
+          out += "\\\\";
+        else if (c == '"')
+          out += "\\\"";
+        else
+          out.push_back(c);
+      }
+
+      out.push_back('"');
+      return out;
+    }
+
+    static bool is_header_only_package(const GlobalPackage &pkg)
+    {
+      return pkg.type == "header-only";
+    }
+
+    static fs::path package_include_path(const GlobalPackage &pkg)
+    {
+      return pkg.installedPath / pkg.includeDir;
+    }
+
+    static fs::path package_cmake_lists_path(const GlobalPackage &pkg)
+    {
+      return pkg.installedPath / "CMakeLists.txt";
+    }
+
+    static std::string package_binary_dir_name(const GlobalPackage &pkg)
+    {
+      std::string name = pkg.pkgDir;
+      if (name.empty())
+        name = "pkg";
+
+      for (char &c : name)
+      {
+        if (c == '.' || c == '/' || c == '\\' || c == ':' || c == ' ')
+          c = '_';
+      }
+
+      return name;
+    }
+  } // namespace
+
+  std::vector<GlobalPackage> load_global_packages()
+  {
+    std::vector<GlobalPackage> out;
+
+    const fs::path manifestPath = global_manifest_path();
+    if (!fs::exists(manifestPath))
+      return out;
+
+    std::ifstream ifs(manifestPath);
+    if (!ifs)
+      return out;
+
+    nlohmann::json root;
+    ifs >> root;
+
+    if (!root.is_object())
+      return out;
+
+    if (!root.contains("packages") || !root["packages"].is_array())
+      return out;
+
+    for (const auto &item : root["packages"])
+    {
+      if (!item.is_object())
+        continue;
+
+      if (!item.contains("id") || !item["id"].is_string())
+        continue;
+
+      if (!item.contains("installed_path") || !item["installed_path"].is_string())
+        continue;
+
+      GlobalPackage pkg;
+      pkg.id = item["id"].get<std::string>();
+      pkg.pkgDir = dep_id_to_dir(pkg.id);
+      pkg.installedPath = fs::path(item["installed_path"].get<std::string>());
+
+      if (item.contains("include") && item["include"].is_string())
+        pkg.includeDir = item["include"].get<std::string>();
+
+      if (item.contains("type") && item["type"].is_string())
+        pkg.type = item["type"].get<std::string>();
+
+      out.push_back(std::move(pkg));
+    }
+
+    return out;
+  }
+
+  std::string make_global_packages_cmake(const std::vector<GlobalPackage> &packages)
+  {
+    std::ostringstream out;
+
+    out << "# Auto-generated by Vix\n";
+    out << "# Global packages integration for vix build\n\n";
+
+    if (packages.empty())
+    {
+      out << "# No global packages installed\n";
+      return out.str();
+    }
+
+    for (const auto &pkg : packages)
+    {
+      if (pkg.installedPath.empty())
+        continue;
+
+      const fs::path includePath = package_include_path(pkg);
+      const fs::path cmakeLists = package_cmake_lists_path(pkg);
+
+      out << "# Package: " << pkg.id << "\n";
+
+      if (!pkg.includeDir.empty())
+      {
+        out << "if (EXISTS " << cmake_quote(includePath.string()) << ")\n";
+        out << "  include_directories(" << cmake_quote(includePath.string()) << ")\n";
+        out << "endif()\n";
+      }
+
+      if (!is_header_only_package(pkg) && fs::exists(cmakeLists))
+      {
+        const std::string binDir =
+            "${CMAKE_BINARY_DIR}/_vix_global/" + package_binary_dir_name(pkg);
+
+        out << "if (EXISTS " << cmake_quote(cmakeLists.string()) << ")\n";
+        out << "  add_subdirectory(\n";
+        out << "    " << cmake_quote(pkg.installedPath.string()) << "\n";
+        out << "    " << cmake_quote(binDir) << "\n";
+        out << "    EXCLUDE_FROM_ALL\n";
+        out << "  )\n";
+        out << "endif()\n";
+      }
+
+      out << "\n";
+    }
+
+    return out.str();
+  }
+
+} // namespace vix::cli::build
diff --git a/src/commands/BuildCommand.cpp b/src/commands/BuildCommand.cpp
@@ -36,6 +36,7 @@
 #include <vix/cli/util/Strings.hpp>
 #include <vix/cli/cmake/CMakeBuild.hpp>
 #include <vix/cli/cmake/Toolchain.hpp>
+#include <vix/cli/cmake/GlobalPackages.hpp>
 
 namespace fs = std::filesystem;
 using namespace vix::cli::style;
@@ -468,7 +469,8 @@ namespace vix::commands::BuildCommand
         const process::Preset &p, const process::Options &opt,
         const fs::path &toolchainFile,
         const std::optional<std::string> &launcher,
-        const std::optional<std::string> &fastLinkerFlag)
+        const std::optional<std::string> &fastLinkerFlag,
+        const fs::path &globalPackagesFile)
     {
       std::vector<std::pair<std::string, std::string>> vars;
       vars.reserve(32);
@@ -485,6 +487,9 @@ namespace vix::commands::BuildCommand
       if (!opt.targetTriple.empty())
         vars.emplace_back("VIX_TARGET_TRIPLE", opt.targetTriple);
 
+      if (!globalPackagesFile.empty())
+        vars.emplace_back("CMAKE_PROJECT_TOP_LEVEL_INCLUDES", globalPackagesFile.string());
+
       if (launcher && !launcher->empty())
       {
         vars.emplace_back("CMAKE_C_COMPILER_LAUNCHER", *launcher);
@@ -586,15 +591,21 @@ namespace vix::commands::BuildCommand
       plan.buildLog = plan.buildDir / "build.log";
       plan.sigFile = plan.buildDir / ".vix-config.sig";
       plan.toolchainFile = plan.buildDir / "vix-toolchain.cmake";
+      const fs::path globalPackagesFile = plan.buildDir / "vix-global-packages.cmake";
 
       std::string toolchainContent;
       if (!opt.targetTriple.empty())
         toolchainContent =
             build::toolchain_contents_for_triple(opt.targetTriple, opt.sysroot);
 
+      const auto globalPackages = build::load_global_packages();
+      const std::string globalPackagesCMake =
+          build::make_global_packages_cmake(globalPackages);
+
       plan.cmakeVars = build_cmake_vars(
           plan.preset, opt, plan.toolchainFile,
-          plan.launcher, plan.fastLinkerFlag);
+          plan.launcher, plan.fastLinkerFlag,
+          globalPackagesFile);
       plan.signature = make_signature(plan, opt, toolchainContent);
 
       return plan;
@@ -631,6 +642,7 @@ namespace vix::commands::BuildCommand
         }
 
         plan_ = *planOpt;
+        const fs::path globalPackagesFile = plan_.buildDir / "vix-global-packages.cmake";
 
         const bool defer = (!opt_.quiet && !opt_.cmakeVerbose);
         DeferredConsole out(defer);
@@ -671,7 +683,8 @@ namespace vix::commands::BuildCommand
 
         plan_.cmakeVars = build_cmake_vars(
             plan_.preset, opt_, plan_.toolchainFile,
-            plan_.launcher, plan_.fastLinkerFlag);
+            plan_.launcher, plan_.fastLinkerFlag,
+            globalPackagesFile);
 
         if (!opt_.targetTriple.empty())
           tc = build::toolchain_contents_for_triple(opt_.targetTriple, opt_.sysroot);
@@ -704,6 +717,17 @@ namespace vix::commands::BuildCommand
           }
         }
 
+        const auto globalPackages = build::load_global_packages();
+        const std::string globalPackagesCMake =
+            build::make_global_packages_cmake(globalPackages);
+
+        if (!util::write_text_file_atomic(globalPackagesFile, globalPackagesCMake))
+        {
+          error("Failed to write global packages file: " + globalPackagesFile.string());
+          hint("Check filesystem permissions.");
+          return 1;
+        }
+
         if (!opt_.quiet)
         {
           out.print("  Using project directory:\n");
