fix: namespace-aware dependency lookup + bump to 0.0.10

The dependency pipeline (read_xpkg_lua, install_path, resolve_semver,
try_merge_semver) previously used raw package-name strings and inferred
namespace from filename/directory patterns via ad-hoc fallback logic.
This meant the caller's declared namespace was never propagated — a
dep declared under [dependencies] (default "mcpp" namespace) could
silently resolve to a "compat" package through filename guessing.

Fix: add namespace-aware overloads that accept structured (ns, shortName)
as the primary API surface. All call sites in cli.cppm and resolver.cppm
now pass DependencySpec.namespace_ and DependencySpec.shortName through
the entire pipeline.

Compat changes (compat.cppm):
- xpkg_lua_candidates(ns, shortName): generates candidate filenames
  with canonical form first, fallback forms annotated for removal in 1.0.0
- install_dir_candidates(ns, shortName, indexName): same for install dirs

Legacy string-based overloads are preserved as thin wrappers that infer
namespace via resolve_package_name() — marked COMPAT, remove in 1.0.0.

Also bumps version to 0.0.10 (not released yet).

Author: Sunrisepeak

mcpp.toml

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

src/cli.cppm

@@ -1088,7 +1088,10 @@ prepare_build(bool print_fingerprint,
         auto cfg = get_cfg();
         if (!cfg) return std::unexpected(cfg.error());
         mcpp::fetcher::Fetcher fetcher(**cfg);
-        auto resolved = mcpp::pm::resolve_semver(depName, s.version, fetcher);
+        // 0.0.10+: use structured namespace from DependencySpec.
+        auto resolved = mcpp::pm::resolve_semver(
+            s.namespace_, s.shortName.empty() ? depName : s.shortName,
+            s.version, fetcher);
         if (!resolved) return std::unexpected(resolved.error());
         mcpp::ui::info("Resolved",
             std::format("{} {} → v{}", depName, s.version, *resolved));
@@ -1101,17 +1104,24 @@ prepare_build(bool print_fingerprint,
     // different version is needed. Returns the dep's effective root (where
     // mcpp.toml lives) and a fully loaded manifest.
     using LoadedDep = std::pair<std::filesystem::path, mcpp::manifest::Manifest>;
+    // 0.0.10+: loadVersionDep accepts structured (ns, shortName) for
+    // namespace-aware lookup. depName is the map key (qualified or bare),
+    // kept for install() target formatting and error messages.
     auto loadVersionDep = [&](const std::string& depName,
+                              const std::string& ns,
+                              const std::string& shortName,
                               const std::string& version)
         -> std::expected<LoadedDep, std::string>
     {
         auto cfg = get_cfg();
         if (!cfg) return std::unexpected(cfg.error());
         mcpp::fetcher::Fetcher fetcher(**cfg);
 
-        auto installed = fetcher.install_path(depName, version);
+        auto installed = fetcher.install_path(ns, shortName, version);
         if (!installed) {
             mcpp::ui::info("Downloading", std::format("{} v{}", depName, version));
+            // install() target uses the map key (depName) which xlings
+            // knows how to resolve via its own index lookup.
             std::vector<std::string> targets{ std::format("{}@{}", depName, version) };
             CliInstallProgress progress;
             auto r = fetcher.install(targets, &progress);
@@ -1123,13 +1133,13 @@ prepare_build(bool print_fingerprint,
                 if (r->error) err += ": " + r->error->message;
                 return std::unexpected(err);
             }
-            installed = fetcher.install_path(depName, version);
+            installed = fetcher.install_path(ns, shortName, version);
             if (!installed) return std::unexpected(std::format(
                 "package '{}@{}' install path missing after fetch", depName, version));
         }
         std::filesystem::path verRoot = *installed;
 
-        auto luaContent = fetcher.read_xpkg_lua(depName);
+        auto luaContent = fetcher.read_xpkg_lua(ns, shortName);
         if (!luaContent) return std::unexpected(std::format(
             "dependency '{}': index entry not found in local clone", depName));
         auto field = mcpp::manifest::extract_mcpp_field(*luaContent);
@@ -1361,7 +1371,7 @@ prepare_build(bool print_fingerprint,
                 mcpp::fetcher::Fetcher fetcher(**cfg);
 
                 auto merged = mcpp::pm::try_merge_semver(
-                    name,
+                    key.ns, key.shortName,
                     it->second.constraint,
                     item.originalConstraint,
                     fetcher);
@@ -1397,7 +1407,7 @@ prepare_build(bool print_fingerprint,
                             merged.error()));
                     }
 
-                    auto loaded = loadVersionDep(name, spec.version);
+                    auto loaded = loadVersionDep(name, key.ns, key.shortName, spec.version);
                     if (!loaded) return std::unexpected(loaded.error());
                     auto& [secondaryRoot, secondaryManifest] = *loaded;
 
@@ -1511,7 +1521,7 @@ prepare_build(bool print_fingerprint,
                     std::format("{}{}{} {} ⨯ {} → v{}",
                         key.ns, key.ns.empty() ? "" : ".", key.shortName,
                         it->second.version, spec.version, *merged));
-                auto reloaded = loadVersionDep(name, *merged);
+                auto reloaded = loadVersionDep(name, key.ns, key.shortName, *merged);
                 if (!reloaded) return std::unexpected(reloaded.error());
                 auto& [newRoot, newManifest] = *reloaded;
 
@@ -1649,7 +1659,7 @@ prepare_build(bool print_fingerprint,
             }
             dep_manifest = std::move(*dm);
         } else {
-            auto loaded = loadVersionDep(name, spec.version);
+            auto loaded = loadVersionDep(name, key.ns, key.shortName, spec.version);
             if (!loaded) return std::unexpected(loaded.error());
             dep_root     = std::move(loaded->first);
             dep_manifest = std::move(loaded->second);

src/pm/compat.cppm

@@ -103,4 +103,92 @@ inline std::string xpkg_dir_name(std::string_view indexName,
     return std::format("{}-x-{}", indexName, qname);
 }
 
+// ─── xpkg .lua filename candidates (namespace-aware) ────────────────
+//
+// Given a structured (namespace, shortName), return the list of candidate
+// filenames to search for in the index's pkgs/<letter>/ directories.
+//
+// The FIRST candidate is the canonical form; subsequent candidates are
+// backward-compatibility fallbacks.
+//
+// DEPRECATION SCHEDULE (fallback candidates):
+//   Fallback candidates are slated for removal in mcpp 1.0.0.
+//   Package indices should use the canonical filename form by then.
+
+inline std::vector<std::string> xpkg_lua_candidates(std::string_view ns,
+                                                     std::string_view shortName)
+{
+    std::vector<std::string> candidates;
+    auto qname = qualified_name(ns, shortName);
+
+    // Canonical: <ns>.<shortName>.lua  (e.g. "compat.mbedtls.lua",
+    //            "mcpplibs.cmdline.lua") — namespace is part of the filename.
+    // For default namespace ("mcpp"), canonical is just "<shortName>.lua".
+    if (ns.empty() || ns == mcpp::pm::kDefaultNamespace) {
+        candidates.push_back(std::string(shortName) + ".lua");
+    } else {
+        candidates.push_back(qname + ".lua");
+    }
+
+    // ── Fallback candidates (COMPAT, remove in 1.0.0) ──────────────
+
+    // Fallback 1: bare short name — covers mcpplibs packages whose
+    // index files are named "<shortName>.lua" without namespace prefix.
+    if (!ns.empty() && ns != mcpp::pm::kDefaultNamespace) {
+        candidates.push_back(std::string(shortName) + ".lua");
+    }
+
+    // Fallback 2: compat.<shortName>.lua — covers compat packages
+    // when the caller didn't specify the "compat" namespace.
+    if (ns.empty() || ns == mcpp::pm::kDefaultNamespace) {
+        candidates.push_back("compat." + std::string(shortName) + ".lua");
+    }
+
+    // Fallback 3: compat.<qname>.lua — covers edge cases where the
+    // qualified name itself is used with a compat prefix.
+    if (!ns.empty() && ns != mcpp::pm::kDefaultNamespace && ns != "compat") {
+        candidates.push_back("compat." + qname + ".lua");
+        candidates.push_back("compat." + std::string(shortName) + ".lua");
+    }
+
+    return candidates;
+}
+
+// ─── install_path directory candidates (namespace-aware) ─────────────
+//
+// Given a structured (namespace, shortName) and index name, return the
+// list of candidate directory names under <xpkgs>/ to search for.
+//
+// DEPRECATION SCHEDULE (fallback candidates):
+//   Fallback candidates are slated for removal in mcpp 1.0.0.
+//   By then xlings should use a consistent directory layout.
+
+inline std::vector<std::string> install_dir_candidates(std::string_view ns,
+                                                        std::string_view shortName,
+                                                        std::string_view indexName)
+{
+    std::vector<std::string> candidates;
+    auto qname = qualified_name(ns, shortName);
+
+    // Canonical: <index>-x-<ns>.<shortName>  (e.g. "mcpp-index-x-compat.mbedtls")
+    // For default namespace: <index>-x-<shortName>  (e.g. "mcpp-index-x-gtest")
+    candidates.push_back(std::format("{}-x-{}", indexName, qname));
+
+    // ── Fallback candidates (COMPAT, remove in 1.0.0) ──────────────
+
+    // Fallback 1: namespace-prefixed dir without index
+    // e.g. "compat-x-mbedtls" (new-style ns-aware layout)
+    if (!ns.empty() && ns != mcpp::pm::kDefaultNamespace) {
+        candidates.push_back(std::format("{}-x-{}", ns, shortName));
+    }
+
+    // Fallback 2: index-prefixed with bare short name
+    // e.g. "mcpp-index-x-mbedtls" (old pre-namespace layout)
+    if (!ns.empty() && ns != mcpp::pm::kDefaultNamespace) {
+        candidates.push_back(std::format("{}-x-{}", indexName, shortName));
+    }
+
+    return candidates;
+}
+
 } // namespace mcpp::pm::compat