fix(build): support xlings mcpp build dependencies

Support xlings source builds via mcpp, tighten package dependency compatibility, and bump mcpp to 0.0.31.

Author: Sunrisepeak

CHANGELOG.md

@@ -3,6 +3,18 @@
 > 本文件追踪 `mcpp-community/mcpp` 公开仓的版本演进。
 > 格式参考 [Keep a Changelog](https://keepachangelog.com/zh-CN/1.1.0/)。
 
+## [0.0.31] — 2026-05-30
+
+### 修复
+
+- 修复 xlings 项目使用 mcpp 构建时 custom index 首次同步、project data
+  root 查找和 local index 相对路径解析的问题。
+- 支持 canonical nested dependency 写法:
+  `[dependencies] capi.lua = "0.0.3"` 和
+  `[dependencies.mcpplibs] capi.lua = "0.0.3"`。
+- 将 legacy flat dotted dependency key 兼容解析集中到 `mcpp.pm.compat`,
+  并标注该兼容路径将在 mcpp 1.0.0 移除。
+
 ## [0.0.14] — 2026-05-13
 
 LLVM / Clang 工具链支持与 xlings 镜像配置完善。

mcpp.toml

@@ -1,6 +1,6 @@
 [package]
 name        = "mcpp"
-version     = "0.0.30"
+version     = "0.0.31"
 description = "Modern C++ build & package management tool"
 license     = "Apache-2.0"
 authors     = ["mcpp-community"]

src/build/compile_commands.cppm

@@ -81,6 +81,15 @@ std::vector<std::string> split_flags(std::string_view s) {
     return out;
 }
 
+std::vector<std::string> local_include_args(const CompileUnit& cu) {
+    std::vector<std::string> args;
+    args.reserve(cu.localIncludeDirs.size());
+    for (auto const& inc : cu.localIncludeDirs) {
+        args.push_back("-I" + inc.string());
+    }
+    return args;
+}
+
 }  // namespace
 
 std::string emit_compile_commands(const BuildPlan& plan, const CompileFlags& flags) {
@@ -96,6 +105,8 @@ std::string emit_compile_commands(const BuildPlan& plan, const CompileFlags& fla
         // Build arguments array.
         nlohmann::json args = nlohmann::json::array();
         args.push_back(compiler.string());
+        for (auto& f : local_include_args(cu))
+            args.push_back(std::move(f));
         for (auto& f : split_flags(flagStr))
             args.push_back(std::move(f));
         args.push_back("-c");

src/build/ninja_backend.cppm

@@ -72,6 +72,27 @@ std::string escape_ninja_path(const std::filesystem::path& p) {
     return out;
 }
 
+std::string escape_flag_path(const std::filesystem::path& p) {
+    auto s = p.string();
+    std::string out;
+    out.reserve(s.size());
+    for (char c : s) {
+        if (c == ' ' || c == '$' || c == ':')
+            out.push_back('$');
+        out.push_back(c);
+    }
+    return out;
+}
+
+std::string local_include_flags(const CompileUnit& cu) {
+    std::string flags;
+    for (auto const& inc : cu.localIncludeDirs) {
+        flags += " -I";
+        flags += escape_flag_path(inc);
+    }
+    return flags;
+}
+
 void write_file(const std::filesystem::path& p, std::string_view content) {
     std::filesystem::create_directories(p.parent_path());
     std::ofstream os(p);
@@ -294,13 +315,13 @@ std::string emit_ninja_string(const BuildPlan& plan) {
     if constexpr (mcpp::platform::is_windows) {
         // Windows: skip BMI restat optimization (requires POSIX shell).
         append(std::format("  command = "
-               "$cxx $cxxflags{} -c $in -o $out\n", module_output_flag));
+               "$cxx $local_includes $cxxflags{} -c $in -o $out\n", module_output_flag));
     } else {
         append(std::format("  command = "
                "if [ -n \"$bmi_out\" ] && [ -f \"$bmi_out\" ]; then "
                  "cp -p \"$bmi_out\" \"$bmi_out.bak\"; "
                "fi && "
-               "$cxx $cxxflags{} -c $in -o $out && "
+               "$cxx $local_includes $cxxflags{} -c $in -o $out && "
                "if [ -n \"$bmi_out\" ] && [ -f \"$bmi_out.bak\" ] && "
                   "cmp -s \"$bmi_out\" \"$bmi_out.bak\"; then "
                  "mv \"$bmi_out.bak\" \"$bmi_out\"; "
@@ -314,15 +335,15 @@ std::string emit_ninja_string(const BuildPlan& plan) {
     append("\n");
 
     append("rule cxx_object\n");
-    append("  command = $cxx $cxxflags -c $in -o $out\n");
+    append("  command = $cxx $local_includes $cxxflags -c $in -o $out\n");
     append("  description = OBJ $out\n");
     if (dyndep)
         append("  restat = 1\n");
     append("\n");
 
     if (need_c_rule) {
         append("rule c_object\n");
-        append("  command = $cc $cflags -c $in -o $out\n");
+        append("  command = $cc $local_includes $cflags -c $in -o $out\n");
         append("  description = CC $out\n");
         if (dyndep)
             append("  restat = 1\n");
@@ -348,7 +369,7 @@ std::string emit_ninja_string(const BuildPlan& plan) {
         append("rule cxx_scan\n");
         if (plan.scanDepsPath.empty()) {
             // GCC path: compiler-integrated P1689 scanning.
-            append("  command = $cxx $cxxflags -fmodules "
+            append("  command = $cxx $local_includes $cxxflags -fmodules "
                    "-fdeps-format=p1689r5 "
                    "-fdeps-file=$out -fdeps-target=$compile_target "
                    "-M -MM -MF $out.dep -E $in -o $compile_target\n");
@@ -358,10 +379,10 @@ std::string emit_ninja_string(const BuildPlan& plan) {
                 // Wrap in cmd /c for shell redirection (ninja on Windows uses
                 // CreateProcess which doesn't interpret > as redirect).
                 append("  command = cmd /c \"$scan_deps -format=p1689 -- "
-                       "$cxx $cxxflags -c $in -o $compile_target > $out\"\n");
+                       "$cxx $local_includes $cxxflags -c $in -o $compile_target > $out\"\n");
             } else {
                 append("  command = $scan_deps -format=p1689 -- "
-                       "$cxx $cxxflags -c $in -o $compile_target > $out\n");
+                       "$cxx $local_includes $cxxflags -c $in -o $compile_target > $out\n");
             }
         }
         append("  description = SCAN $out\n\n");
@@ -438,6 +459,8 @@ std::string emit_ninja_string(const BuildPlan& plan) {
             append(std::format("build {} : cxx_scan {}\n", escape_ninja_path(ddi),
                                escape_ninja_path(cu.source)));
             append(std::format("  compile_target = {}\n", escape_ninja_path(cu.object)));
+            if (auto includes = local_include_flags(cu); !includes.empty())
+                append(std::format("  local_includes ={}\n", includes));
         }
         append("\n");
 
@@ -481,6 +504,8 @@ std::string emit_ninja_string(const BuildPlan& plan) {
             } else {
                 out_line += "\n";
             }
+            if (auto includes = local_include_flags(cu); !includes.empty())
+                out_line += "  local_includes =" + includes + "\n";
             append(std::move(out_line));
         }
         append("\n");
@@ -519,6 +544,8 @@ std::string emit_ninja_string(const BuildPlan& plan) {
             if (!implicit.empty())
                 out_line += " |" + implicit;
             out_line += "\n";
+            if (auto includes = local_include_flags(cu); !includes.empty())
+                out_line += "  local_includes =" + includes + "\n";
             // Clang needs $bmi_out to emit -fmodule-output=$bmi_out
             if (cu.providesModule) {
                 out_line += "  bmi_out = " + bmi_path(*cu.providesModule) + "\n";

src/build/plan.cppm

@@ -17,6 +17,7 @@ export namespace mcpp::build {
 struct CompileUnit {
     std::filesystem::path           source;
     std::filesystem::path           object;            // relative to plan.outputDir
+    std::vector<std::filesystem::path> localIncludeDirs;
     std::optional<std::string>      providesModule;   // logical name, if .cppm export
     std::vector<std::string>        imports;           // logical names imported
 };
@@ -119,6 +120,7 @@ BuildPlan make_plan(const mcpp::manifest::Manifest&         manifest,
         auto& u = graph.units[idx];
         CompileUnit cu;
         cu.source = u.path;
+        cu.localIncludeDirs = u.localIncludeDirs;
         const auto fname = object_filename_for(u.path);
         if (basenameCount[fname] > 1) {
             // Use <sanitized-pkg>/<parent-dir-name> as prefix to handle

src/cli.cppm

@@ -1368,42 +1368,27 @@ prepare_build(bool print_fingerprint,
     }
 
     // Set up project-level .mcpp/ directory for custom indices.
-    // This creates .mcpp/.xlings.json with non-builtin, non-local index
+    // This creates .mcpp/.xlings.json with custom non-builtin index
     // entries so xlings can clone them into the project-scoped data dir.
     if (!m->indices.empty()) {
         auto cfg2 = get_cfg();
         if (cfg2) {
             mcpp::config::ensure_project_index_dir(**cfg2, *root, m->indices);
 
-            // Gap 1: On first build, .mcpp/data/ may be empty because
+            // On first build, the project xlings data root may be empty because
             // ensure_project_index_dir only writes .xlings.json but doesn't
-            // trigger the actual clone. Check if there are any non-local,
-            // non-builtin indices and whether .mcpp/data/ exists with content.
-            // If not, run xlings update to clone them before dependency resolution.
-            bool hasCustomGitIndices = false;
+            // trigger clone/link creation. Check whether there are any custom
+            // non-builtin indices and whether the project data roots have index content.
+            // If not, run xlings update before dependency resolution.
+            bool hasCustomIndices = false;
             for (auto& [idxName, spec] : m->indices) {
-                if (!spec.is_local() && !spec.is_builtin()) {
-                    hasCustomGitIndices = true;
+                if (!spec.is_builtin()) {
+                    hasCustomIndices = true;
                     break;
                 }
             }
-            if (hasCustomGitIndices) {
-                auto dataDir = *root / ".mcpp" / "data";
-                bool needsClone = !std::filesystem::exists(dataDir);
-                if (!needsClone) {
-                    // Check if data/ has any index directories (dirs with pkgs/ subdir)
-                    std::error_code ec;
-                    bool hasIndexRepo = false;
-                    if (std::filesystem::is_directory(dataDir, ec)) {
-                        for (auto& entry : std::filesystem::directory_iterator(dataDir, ec)) {
-                            if (entry.is_directory() && std::filesystem::exists(entry.path() / "pkgs")) {
-                                hasIndexRepo = true;
-                                break;
-                            }
-                        }
-                    }
-                    needsClone = !hasIndexRepo;
-                }
+            if (hasCustomIndices) {
+                bool needsClone = !mcpp::config::project_index_data_initialized(*root);
                 if (needsClone) {
                     mcpp::ui::status("Fetching", "custom index repos (first use)");
                     auto projEnv = mcpp::config::make_project_xlings_env(**cfg2, *root);
@@ -1513,17 +1498,20 @@ prepare_build(bool print_fingerprint,
         // validate the lua exists, then fall through to the normal install
         // flow below.
         if (idxSpec && idxSpec->is_local()) {
+            auto indexPath = mcpp::config::resolve_project_index_path(*root, *idxSpec);
             auto luaCheck = mcpp::fetcher::Fetcher::read_xpkg_lua_from_path(
-                idxSpec->path, shortName);
+                indexPath, shortName);
             if (!luaCheck) return std::unexpected(std::format(
                 "dependency '{}': not found in local index at '{}'",
-                depName, idxSpec->path.string()));
+                depName, indexPath.string()));
             // lua found — fall through to normal install path resolution.
         }
 
-        // For custom git indices, try project-level .mcpp/data/ first.
+        const bool useProjectEnv = idxSpec && !idxSpec->is_builtin();
+
+        // For custom indices, try project-level xlings data roots first.
         std::optional<std::filesystem::path> installed;
-        if (idxSpec && !idxSpec->is_local() && !idxSpec->is_builtin()) {
+        if (useProjectEnv) {
             installed = mcpp::fetcher::Fetcher::install_path_from_project_data(
                 *root, ns, shortName, version);
         }
@@ -1539,11 +1527,6 @@ prepare_build(bool print_fingerprint,
                 : std::format("{}.{}", ns, shortName);
             mcpp::ui::info("Downloading", std::format("{} v{}", fqname, version));
 
-            // Gap 2: For custom git indices, install using the project-level
-            // xlings env so packages land in .mcpp/data/xpkgs/ and the custom
-            // index clone is visible to xlings during resolution.
-            bool useProjectEnv = idxSpec && !idxSpec->is_local() && !idxSpec->is_builtin();
-
             auto install_one = [&](std::string target) -> std::expected<mcpp::xlings::CallResult, mcpp::pm::CallError> {
                 if (useProjectEnv) {
                     auto projEnv = mcpp::config::make_project_xlings_env(**cfg, *root);
@@ -1559,7 +1542,7 @@ prepare_build(bool print_fingerprint,
                 return fetcher.install(targets, &progress);
             };
             auto target = std::format("{}@{}", fqname, version);
-            // For custom git indices, use indexName:shortName@version format
+            // For custom indices, use indexName:shortName@version format
             // so xlings knows which index to resolve from.
             if (useProjectEnv) {
                 target = std::format("{}:{}@{}", ns, shortName, version);
@@ -1800,6 +1783,9 @@ prepare_build(bool print_fingerprint,
         const auto& name = item.name;
         auto& spec = item.spec;
 
+        mcpp::pm::compat::normalize_nested_namespace(
+            spec.namespace_, spec.shortName, spec.legacyDottedKey);
+
         // Pin SemVer constraint before dedup/fetch.
         if (auto r = resolveSemver(spec, name); !r) {
             return std::unexpected(r.error());
@@ -2965,7 +2951,7 @@ int cmd_index_update(const mcpplibs::cmdline::ParsedArgs& parsed) {
                 } else {
                     mcpp::ui::status("Updated", std::format("project index `{}`", idxName));
                 }
-                break;  // ensure_project_index_dir handles all non-local indices at once
+                break;  // ensure_project_index_dir handles all custom indices at once
             }
         }
     }

src/config.cppm

@@ -104,6 +104,51 @@ mcpp::xlings::Env make_project_xlings_env(const GlobalConfig& cfg,
     return { cfg.xlingsBinary, cfg.xlingsHome(), projectDir / ".mcpp" };
 }
 
+std::vector<std::filesystem::path>
+project_xlings_data_roots(const std::filesystem::path& projectDir)
+{
+    auto dotMcpp = projectDir / ".mcpp";
+    return {
+        dotMcpp / "data",
+        dotMcpp / ".xlings" / "data",
+    };
+}
+
+std::filesystem::path
+resolve_project_index_path(const std::filesystem::path& projectDir,
+                           const mcpp::pm::IndexSpec& spec)
+{
+    auto source = spec.path;
+    if (source.is_relative()) source = projectDir / source;
+    return source.lexically_normal();
+}
+
+bool project_index_data_initialized(const std::filesystem::path& projectDir)
+{
+    std::error_code ec;
+    for (auto const& data : project_xlings_data_roots(projectDir)) {
+        auto reposDir = data / "xim-index-repos";
+        if (std::filesystem::exists(reposDir / "xim-indexrepos.json", ec)) {
+            return true;
+        }
+        if (std::filesystem::is_directory(reposDir, ec)) {
+            for (auto const& entry : std::filesystem::directory_iterator(reposDir, ec)) {
+                if (entry.is_directory(ec) && std::filesystem::exists(entry.path() / "pkgs", ec)) {
+                    return true;
+                }
+            }
+        }
+        if (std::filesystem::is_directory(data, ec)) {
+            for (auto const& entry : std::filesystem::directory_iterator(data, ec)) {
+                if (entry.is_directory(ec) && std::filesystem::exists(entry.path() / "pkgs", ec)) {
+                    return true;
+                }
+            }
+        }
+    }
+    return false;
+}
+
 // Check that the sandbox bootstrap completed successfully.
 // Returns empty string if ok, or a description of what's missing.
 std::string check_base_init(const GlobalConfig& cfg) {
@@ -160,7 +205,7 @@ void reset_registry(const GlobalConfig& cfg) {
 }
 
 // Ensure the project-level .mcpp/ directory exists and contains a
-// .xlings.json seeded with the custom (non-builtin, non-local) index
+// .xlings.json seeded with custom non-builtin index entries
 // entries. Returns true if a .mcpp/ directory was created/updated.
 bool ensure_project_index_dir(
     const GlobalConfig& cfg,
@@ -613,11 +658,17 @@ bool ensure_project_index_dir(
     const std::filesystem::path& projectDir,
     const std::map<std::string, mcpp::pm::IndexSpec>& indices)
 {
-    // Collect custom (non-builtin, non-local) indices that need xlings cloning.
+    // Collect custom non-builtin indices that need xlings project-scope data.
+    // Local path indices are also seeded so xlings can create its own
+    // project-local repo link and install packages from that index.
     std::vector<std::pair<std::string,std::string>> customRepos;
     for (auto& [name, spec] : indices) {
         if (spec.is_builtin()) continue;
-        if (spec.is_local())   continue;   // local path, mcpp reads directly
+        if (spec.is_local()) {
+            auto source = resolve_project_index_path(projectDir, spec);
+            customRepos.emplace_back(name, source.string());
+            continue;
+        }
         customRepos.emplace_back(name, spec.url);
     }