fix(pm): tighten dependency namespace compatibility

Author: Sunrisepeak

src/cli.cppm

@@ -1368,17 +1368,17 @@ 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);
 
-            // 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 clone/link creation. Check whether there are any custom
-            // non-builtin indices and whether .mcpp/data/ has index content.
+            // 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) {
@@ -1388,22 +1388,7 @@ prepare_build(bool print_fingerprint,
                 }
             }
             if (hasCustomIndices) {
-                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;
-                }
+                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,18 @@ 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.
         }
 
         const bool useProjectEnv = idxSpec && !idxSpec->is_builtin();
 
-        // For custom indices, try project-level .mcpp/data/ first.
+        // For custom indices, try project-level xlings data roots first.
         std::optional<std::filesystem::path> installed;
         if (useProjectEnv) {
             installed = mcpp::fetcher::Fetcher::install_path_from_project_data(
@@ -1798,7 +1784,7 @@ prepare_build(bool print_fingerprint,
         auto& spec = item.spec;
 
         mcpp::pm::compat::normalize_nested_namespace(
-            spec.namespace_, spec.shortName);
+            spec.namespace_, spec.shortName, spec.legacyDottedKey);
 
         // Pin SemVer constraint before dedup/fetch.
         if (auto r = resolveSemver(spec, name); !r) {
@@ -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,
@@ -620,9 +665,8 @@ bool ensure_project_index_dir(
     for (auto& [name, spec] : indices) {
         if (spec.is_builtin()) continue;
         if (spec.is_local()) {
-            auto source = spec.path;
-            if (source.is_relative()) source = projectDir / source;
-            customRepos.emplace_back(name, source.lexically_normal().string());
+            auto source = resolve_project_index_path(projectDir, spec);
+            customRepos.emplace_back(name, source.string());
             continue;
         }
         customRepos.emplace_back(name, spec.url);

src/libs/toml.cppm

@@ -69,7 +69,8 @@ private:
 
 class Document {
 public:
-    explicit Document(Table root) : root_(std::move(root)) {}
+    explicit Document(Table root, std::set<std::string, std::less<>> explicitTables = {})
+        : root_(std::move(root)), explicitTables_(std::move(explicitTables)) {}
 
     const Table& root() const { return root_; }
     Table&       root()       { return root_; }
@@ -83,9 +84,13 @@ public:
     std::optional<bool>                   get_bool(std::string_view path) const;
     std::optional<std::vector<std::string>> get_string_array(std::string_view path) const;
     const Table*                          get_table(std::string_view path) const;
+    bool                                  has_explicit_table(std::string_view path) const {
+        return explicitTables_.contains(path);
+    }
 
 private:
     Table root_;
+    std::set<std::string, std::less<>> explicitTables_;
 };
 
 std::expected<Document, ParseError> parse(std::string_view src);
@@ -328,6 +333,13 @@ inline Table* dive(Table& root, const std::vector<std::string>& path, bool creat
     return cur;
 }
 
+inline std::string join_path(const std::vector<std::string>& path) {
+    return std::accumulate(path.begin(), path.end(), std::string{},
+        [](std::string a, const std::string& b){
+            return a.empty() ? b : a + "." + b;
+        });
+}
+
 } // namespace detail
 
 const Value* Document::get(std::string_view dotted_path) const {
@@ -390,6 +402,7 @@ std::expected<Document, ParseError> parse(std::string_view src) {
     using namespace detail;
     Lexer L { src };
     Table root;
+    std::set<std::string, std::less<>> explicitTables;
     Table* current_table = &root;
 
     while (true) {
@@ -412,11 +425,9 @@ std::expected<Document, ParseError> parse(std::string_view src) {
             auto* t = dive(root, *path);
             if (!t) return std::unexpected(ParseError{
                 std::format("table path '{}' conflicts with non-table value",
-                            std::accumulate(path->begin(), path->end(), std::string{},
-                                [](std::string a, const std::string& b){
-                                    return a.empty() ? b : a + "." + b;
-                                })),
+                            join_path(*path)),
                 L.position()});
+            explicitTables.insert(join_path(*path));
             current_table = t;
         } else {
             // key = value
@@ -441,7 +452,7 @@ std::expected<Document, ParseError> parse(std::string_view src) {
         }
     }
 
-    return Document{std::move(root)};
+    return Document{std::move(root), std::move(explicitTables)};
 }
 
 std::expected<Document, ParseError> parse_file(const std::filesystem::path& p) {