Import compile commands into build graph

Author: GaspardKirira

include/vix/cli/build/BuildGraph.hpp

@@ -26,6 +26,7 @@
 
 #include <vix/cli/build/BuildNode.hpp>
 #include <vix/cli/build/BuildTask.hpp>
+#include <vix/cli/build/CompileCommands.hpp>
 #include <vix/cli/build/DependencyFile.hpp>
 
 namespace vix::cli::build
@@ -214,6 +215,18 @@ namespace vix::cli::build
      */
     BuildGraphScanResult scan_project();
 
+    /**
+     * @brief Load compile tasks from compile_commands.json.
+     *
+     * This imports the real compiler commands generated by CMake/Ninja and
+     * replaces guessed scan_project() compile commands with exact argv, working
+     * directory and object output paths.
+     *
+     * @param path Path to compile_commands.json
+     * @return Number of imported compile commands
+     */
+    std::size_t load_compile_commands(const fs::path &path);
+
     /**
      * @brief Load dependency files from the object directory and connect nodes.
      *

include/vix/cli/build/CompileCommands.hpp

@@ -0,0 +1,136 @@
+/**
+ *
+ *  @file CompileCommands.hpp
+ *  @author Gaspard Kirira
+ *
+ *  Copyright 2026, 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
+ *
+ *  compile_commands.json parser
+ *
+ */
+
+#ifndef VIX_CLI_BUILD_COMPILE_COMMANDS_HPP
+#define VIX_CLI_BUILD_COMPILE_COMMANDS_HPP
+
+#include <filesystem>
+#include <optional>
+#include <string>
+#include <vector>
+
+namespace vix::cli::build
+{
+  namespace fs = std::filesystem;
+
+  /**
+   * @brief One entry from compile_commands.json.
+   *
+   * CMake/Ninja can generate compile_commands.json with the exact compiler
+   * command used for every translation unit. Vix imports this data to build
+   * graph tasks without guessing include paths, defines, flags, object paths,
+   * or compiler arguments.
+   */
+  struct CompileCommandEntry
+  {
+    fs::path directory;                 ///< Working directory used by the compiler
+    fs::path source;                    ///< Source file being compiled
+    fs::path output;                    ///< Object file when available
+    std::vector<std::string> arguments; ///< Compiler argv
+    std::string rawCommand;             ///< Raw command string when provided
+
+    /**
+     * @brief Check whether this entry has enough data to create a compile task.
+     *
+     * @return true when directory, source and arguments are present
+     */
+    bool valid() const;
+
+    /**
+     * @brief Check whether the entry has an object output path.
+     *
+     * @return true when output is not empty
+     */
+    bool has_output() const;
+  };
+
+  /**
+   * @brief Return the default compile_commands.json path for a build directory.
+   *
+   * @param buildDir Build directory
+   * @return buildDir / compile_commands.json
+   */
+  fs::path default_compile_commands_path(const fs::path &buildDir);
+
+  /**
+   * @brief Split a compiler command string into argv tokens.
+   *
+   * This supports the shell forms usually emitted by CMake:
+   *   - whitespace separated tokens
+   *   - single quotes
+   *   - double quotes
+   *   - backslash escaping
+   *
+   * It does not expand environment variables, globs, or shell substitutions.
+   *
+   * @param command Raw command string
+   * @return Parsed argv tokens
+   */
+  std::vector<std::string> split_compile_command(const std::string &command);
+
+  /**
+   * @brief Parse compile_commands.json content.
+   *
+   * The parser accepts both formats supported by the compilation database:
+   *   - "command": "c++ ..."
+   *   - "arguments": ["c++", "..."]
+   *
+   * @param text JSON content
+   * @param sourcePath Path of the compile_commands.json file
+   * @return Parsed entries, or std::nullopt on invalid JSON/schema
+   */
+  std::optional<std::vector<CompileCommandEntry>> parse_compile_commands_text(
+      const std::string &text,
+      const fs::path &sourcePath = {});
+
+  /**
+   * @brief Read and parse compile_commands.json from disk.
+   *
+   * @param path Path to compile_commands.json
+   * @return Parsed entries, or std::nullopt when missing/invalid
+   */
+  std::optional<std::vector<CompileCommandEntry>> read_compile_commands(
+      const fs::path &path);
+
+  /**
+   * @brief Resolve a possibly relative path against a base directory.
+   *
+   * @param base Base directory
+   * @param path Path to resolve
+   * @return Absolute normalized path when possible
+   */
+  fs::path resolve_compile_command_path(
+      const fs::path &base,
+      const fs::path &path);
+
+  /**
+   * @brief Extract the object output path from compiler argv.
+   *
+   * Supports:
+   *   - -o file.o
+   *   - -ofile.o
+   *
+   * @param arguments Compiler argv
+   * @param workingDirectory Working directory used to resolve relative paths
+   * @return Object path, or empty path if not found
+   */
+  fs::path extract_compile_output_path(
+      const std::vector<std::string> &arguments,
+      const fs::path &workingDirectory);
+
+} // namespace vix::cli::build
+
+#endif

src/build/BuildGraph.cpp

@@ -15,6 +15,7 @@
  */
 
 #include <vix/cli/build/BuildGraph.hpp>
+#include <vix/cli/build/CompileCommands.hpp>
 
 #include <algorithm>
 #include <cstdint>
@@ -390,6 +391,91 @@ namespace vix::cli::build
         return 0;
       }
     }
+
+    static std::string compile_task_id_for_source(const fs::path &source)
+    {
+      std::uint64_t h = FNV_OFFSET;
+
+      const std::string normalized = normalize_path_string(source);
+      h = fnv_mix_string(h, "compile:");
+      h = fnv_mix_string(h, normalized);
+
+      return "compile:" + hex64(h);
+    }
+
+    static std::vector<std::string> make_dependency_enabled_command(
+        const std::vector<std::string> &arguments,
+        const fs::path &dependencyFile)
+    {
+      std::vector<std::string> out;
+      out.reserve(arguments.size() + 6);
+
+      bool hasMMD = false;
+      bool hasMP = false;
+      bool hasMF = false;
+      bool hasDependencyMode = false;
+
+      for (std::size_t i = 0; i < arguments.size(); ++i)
+      {
+        const std::string &arg = arguments[i];
+
+        if (arg == "-MMD")
+          hasMMD = true;
+
+        if (arg == "-MP")
+          hasMP = true;
+
+        if (arg == "-MF")
+        {
+          hasMF = true;
+          out.push_back(arg);
+
+          if (i + 1 < arguments.size())
+          {
+            out.push_back(dependencyFile.string());
+            ++i;
+          }
+          else
+          {
+            out.push_back(dependencyFile.string());
+          }
+
+          continue;
+        }
+
+        if (arg.rfind("-MF", 0) == 0 && arg.size() > 3)
+        {
+          hasMF = true;
+          out.push_back("-MF");
+          out.push_back(dependencyFile.string());
+          continue;
+        }
+
+        if (arg == "-MD" ||
+            arg == "-MMD" ||
+            arg == "-M" ||
+            arg == "-MM")
+        {
+          hasDependencyMode = true;
+        }
+
+        out.push_back(arg);
+      }
+
+      if (!hasDependencyMode && !hasMMD)
+        out.push_back("-MMD");
+
+      if (!hasMP)
+        out.push_back("-MP");
+
+      if (!hasMF)
+      {
+        out.push_back("-MF");
+        out.push_back(dependencyFile.string());
+      }
+
+      return out;
+    }
   } // namespace
 
   bool BuildGraphConfig::valid() const
@@ -573,42 +659,11 @@ namespace vix::cli::build
       add_node(node);
 
       if (kind == BuildNodeKind::Source)
-      {
         ++result.sources;
-
-        const fs::path objectPath = object_path_for_source(current);
-        const fs::path dependencyPath = dependency_path_for_source(current);
-
-        BuildNode objectNode =
-            make_file_build_node(BuildNodeKind::Object, objectPath);
-
-        objectNode.id = make_build_node_id(BuildNodeKind::Object, objectPath);
-        objectNode.hash = hash_file_content(objectPath);
-        objectNode.add_dependency(node.id);
-
-        add_node(objectNode);
-
-        const std::vector<std::string> command =
-            compile_command_for(current, objectPath, dependencyPath);
-
-        BuildTask task =
-            make_compile_task(
-                node.id,
-                objectNode.id,
-                command,
-                config_.projectDir);
-
-        task.logFile = dependencyPath;
-        add_task(task);
-      }
       else if (kind == BuildNodeKind::Header)
-      {
         ++result.headers;
-      }
       else if (kind == BuildNodeKind::Config)
-      {
         ++result.configs;
-      }
 
       ++it;
     }
@@ -617,6 +672,63 @@ namespace vix::cli::build
     return result;
   }
 
+  std::size_t BuildGraph::load_compile_commands(const fs::path &path)
+  {
+    const auto compileCommands = read_compile_commands(path);
+
+    if (!compileCommands)
+      return 0;
+
+    std::size_t imported = 0;
+
+    for (const CompileCommandEntry &entry : *compileCommands)
+    {
+      if (!entry.valid() || !entry.has_output())
+        continue;
+
+      const fs::path sourcePath = entry.source.lexically_normal();
+      const fs::path objectPath = entry.output.lexically_normal();
+      const fs::path dependencyPath = dependency_file_for_object(objectPath);
+
+      BuildNode sourceNode =
+          make_file_build_node(BuildNodeKind::Source, sourcePath);
+
+      sourceNode.hash = hash_file_content(sourcePath);
+      add_node(sourceNode);
+
+      BuildNode objectNode =
+          make_file_build_node(BuildNodeKind::Object, objectPath);
+
+      objectNode.id = make_build_node_id(BuildNodeKind::Object, objectPath);
+      objectNode.hash = hash_file_content(objectPath);
+      objectNode.add_dependency(sourceNode.id);
+
+      add_node(objectNode);
+
+      std::vector<std::string> command =
+          make_dependency_enabled_command(
+              entry.arguments,
+              dependencyPath);
+
+      BuildTask task =
+          make_compile_task(
+              sourceNode.id,
+              objectNode.id,
+              command,
+              entry.directory);
+
+      task.id = compile_task_id_for_source(sourcePath);
+      task.workingDirectory = entry.directory;
+      task.logFile = dependencyPath;
+
+      add_task(task);
+
+      ++imported;
+    }
+
+    return imported;
+  }
+
   void BuildGraph::load_dependency_files()
   {
     for (auto &kv : tasks_)