refactor: extract xlings abstraction layer (mcpp.xlings module)

Consolidate all xlings (external package manager) interactions into a
single leaf module `mcpp.xlings`. This eliminates:

- Duplicate NDJSON pipe implementations in config.cppm and
  package_fetcher.cppm (existed due to cyclic import workaround)
- Triplicated xpkgs directory climb logic in flags.cppm,
  ninja_backend.cppm, and stdmod.cppm
- Scattered hardcoded version strings and magic paths

The new module provides:
- Env struct + pinned version constants
- Pure path helpers (xpkgs_base, xim_tool, find_sibling_binary, etc.)
- Unified NDJSON event parser and subprocess call
- Bootstrap lifecycle (ensure_init, ensure_patchelf, ensure_ninja)
- Shell command builders and run_capture utility

Net result: +750 lines (new module), -618 lines (removed duplication)
= net -528 lines across 7 refactored files.

Author: Sunrisepeak

src/build/flags.cppm

@@ -10,6 +10,7 @@ export module mcpp.build.flags;
 
 import std;
 import mcpp.build.plan;
+import mcpp.xlings;
 
 export namespace mcpp::build {
 
@@ -101,27 +102,9 @@ CompileFlags compute_flags(const BuildPlan& plan) {
     bool isMuslTc = plan.toolchain.targetTriple.find("-musl") != std::string::npos;
     std::filesystem::path binutilsBin;
     if (!isMuslTc) {
-        auto bp = plan.toolchain.binaryPath;
-        std::filesystem::path xpkgsDir;
-        for (auto p = bp.parent_path(); p.has_parent_path() && p != p.root_path();
-             p = p.parent_path()) {
-            if (p.filename() == "xpkgs") {
-                xpkgsDir = p;
-                break;
-            }
-        }
-        if (!xpkgsDir.empty()) {
-            auto root = xpkgsDir / "xim-x-binutils";
-            std::error_code ec;
-            if (std::filesystem::exists(root, ec)) {
-                for (auto& v : std::filesystem::directory_iterator(root, ec)) {
-                    auto candidate = v.path() / "bin";
-                    if (std::filesystem::exists(candidate / "ar", ec)) {
-                        binutilsBin = candidate;
-                        break;
-                    }
-                }
-            }
+        if (auto ar = mcpp::xlings::paths::find_sibling_binary(
+                plan.toolchain.binaryPath, "binutils", "bin/ar")) {
+            binutilsBin = ar->parent_path();  // bin/ar → bin/
         }
     }
     std::string b_flag;

src/build/ninja_backend.cppm

@@ -23,6 +23,7 @@ import mcpp.build.plan;
 import mcpp.build.flags;
 import mcpp.build.compile_commands;
 import mcpp.dyndep;
+import mcpp.xlings;
 
 export namespace mcpp::build {
 
@@ -456,30 +457,9 @@ std::expected<BuildResult, BuildError> NinjaBackend::build(const BuildPlan& plan
     // -B<binutils-bin> flag we emit into cxxflags/ldflags (see
     // emit_ninja_string). No PATH injection needed here.
     std::filesystem::path ninjaBin;
-    {
-        auto bp = plan.toolchain.binaryPath;
-        std::filesystem::path xpkgsDir;
-        for (auto p = bp.parent_path(); p.has_parent_path() && p != p.root_path();
-             p = p.parent_path()) {
-            if (p.filename() == "xpkgs") {
-                xpkgsDir = p;
-                break;
-            }
-        }
-        if (!xpkgsDir.empty()) {
-            // xim's ninja xpkg puts the binary at <v>/ninja (no bin/ subdir).
-            auto root = xpkgsDir / "xim-x-ninja";
-            std::error_code ec;
-            if (std::filesystem::exists(root, ec)) {
-                for (auto& v : std::filesystem::directory_iterator(root, ec)) {
-                    auto candidate = v.path() / "ninja";
-                    if (std::filesystem::exists(candidate, ec)) {
-                        ninjaBin = candidate;
-                        break;
-                    }
-                }
-            }
-        }
+    if (auto nb = mcpp::xlings::paths::find_sibling_binary(
+            plan.toolchain.binaryPath, "ninja", "ninja")) {
+        ninjaBin = *nb;
     }
 
     std::string ninjaProgram =

src/cli.cppm

@@ -29,6 +29,7 @@ import mcpp.lockfile;
 import mcpp.publish.xpkg_emit;
 import mcpp.pack;
 import mcpp.config;
+import mcpp.xlings;
 import mcpp.fetcher;
 import mcpp.pm.resolver;   // PR-R4: extracted from cli.cppm
 import mcpp.pm.commands;   // PR-R5: cmd_add / cmd_remove / cmd_update live here now
@@ -675,7 +676,7 @@ void fixup_gcc_specs(const std::filesystem::path& gccPkgRoot,
     if (!std::filesystem::exists(specsParent)) return;
 
     constexpr std::string_view kBakedDir =
-        "/home/xlings/.xlings_data/subos/linux/lib";
+        mcpp::xlings::pinned::kXlingsBuildHostLib;
     auto kBakedLoader = std::format("{}/ld-linux-x86-64.so.2", kBakedDir);
 
     auto loaderReplacement = (glibcLibDir / "ld-linux-x86-64.so.2").string();
@@ -2375,10 +2376,8 @@ int cmd_index_update(const mcpplibs::cmdline::ParsedArgs& /*parsed*/) {
     auto cfg = mcpp::config::load_or_init(/*quiet=*/false, make_bootstrap_progress_callback());
     if (!cfg) { mcpp::ui::error(cfg.error().message); return 4; }
     mcpp::ui::status("Updating", "all index repos");
-    std::string cmd = std::format(
-        "env -u XLINGS_PROJECT_DIR XLINGS_HOME='{}' '{}' update 2>&1",
-        cfg->xlingsHome().string(),
-        cfg->xlingsBinary.string());
+    auto xlEnv = mcpp::config::make_xlings_env(*cfg);
+    std::string cmd = mcpp::xlings::build_command_prefix(xlEnv) + " update 2>&1";
     std::array<char, 4096> buf{};
     std::FILE* fp = ::popen(cmd.c_str(), "r");
     if (!fp) { mcpp::ui::error("failed to spawn index updater"); return 1; }
@@ -2506,19 +2505,12 @@ int cmd_test(const mcpplibs::cmdline::ParsedArgs& /*parsed*/,
         // visible to test binaries that shell out to them. The
         // toolchain binary's path encodes the registry root — derive it.
         std::string pathPrefix;
-        {
-            auto tcBin = ctx->tc.binaryPath;
-            // tc binary at <registry>/data/xpkgs/xim-x-*/ver/bin/g++
-            // Climb to <registry> = .../(xpkgs)/../..
-            for (auto p = tcBin; !p.empty() && p != p.root_path(); p = p.parent_path()) {
-                if (p.filename() == "xpkgs") {
-                    auto registryDir = p.parent_path().parent_path();
-                    auto sandboxBin  = registryDir / "subos" / "default" / "bin";
-                    if (std::filesystem::exists(sandboxBin))
-                        pathPrefix = std::format("PATH='{}':\"$PATH\" ", sandboxBin.string());
-                    break;
-                }
-            }
+        if (auto xpkgs = mcpp::xlings::paths::xpkgs_from_compiler(ctx->tc.binaryPath)) {
+            // xpkgs is <registry>/data/xpkgs → registry = xpkgs/../..
+            auto registryDir = xpkgs->parent_path().parent_path();
+            auto sandboxBin  = registryDir / "subos" / "default" / "bin";
+            if (std::filesystem::exists(sandboxBin))
+                pathPrefix = std::format("PATH='{}':\"$PATH\" ", sandboxBin.string());
         }
 
         std::string cmd = std::format("{}'{}'", pathPrefix, exe.string());
@@ -2874,6 +2866,7 @@ int cmd_toolchain(const mcpplibs::cmdline::ParsedArgs& parsed) {
     if (!cfg) { mcpp::ui::error(cfg.error().message); return 4; }
 
     auto pkgsDir = cfg->xlingsHome() / "data" / "xpkgs";
+    auto xlEnv = mcpp::config::make_xlings_env(*cfg);
 
     if (subname == "list") {
         // `gcc 15.1.0-musl` and `musl-gcc@15.1.0` describe the same xpkg
@@ -3062,7 +3055,7 @@ int cmd_toolchain(const mcpplibs::cmdline::ParsedArgs& parsed) {
         // `<root>/x86_64-linux-musl/{include,lib}` and doesn't link against
         // xim:glibc, so this fixup is both unnecessary and harmful for it.
         if (compiler == "gcc" && !isMusl) {
-            auto glibcRoot = pkgsDir / "xim-x-glibc";
+            auto glibcRoot = mcpp::xlings::paths::xim_tool_root(xlEnv, "glibc");
             std::filesystem::path glibcLibDir;
             if (std::filesystem::exists(glibcRoot)) {
                 for (auto& v : std::filesystem::directory_iterator(glibcRoot)) {
@@ -3074,7 +3067,8 @@ int cmd_toolchain(const mcpplibs::cmdline::ParsedArgs& parsed) {
                 }
             }
             auto gccLibDir = payload->root / "lib64";
-            auto patchelfBin = pkgsDir / "xim-x-patchelf" / "0.18.0" / "bin" / "patchelf";
+            auto patchelfBin = mcpp::xlings::paths::xim_tool(xlEnv, "patchelf",
+                mcpp::xlings::pinned::kPatchelfVersion) / "bin" / "patchelf";
 
             if (!glibcLibDir.empty() && std::filesystem::exists(gccLibDir)
                 && std::filesystem::exists(patchelfBin))
@@ -3085,7 +3079,7 @@ int cmd_toolchain(const mcpplibs::cmdline::ParsedArgs& parsed) {
 
                 // (1) patchelf walk: rewrite PT_INTERP + RUNPATH for binutils
                 //     and gcc xpkgs so they're self-contained in sandbox.
-                auto binutilsRoot = pkgsDir / "xim-x-binutils";
+                auto binutilsRoot = mcpp::xlings::paths::xim_tool_root(xlEnv, "binutils");
                 if (std::filesystem::exists(binutilsRoot)) {
                     for (auto& v : std::filesystem::directory_iterator(binutilsRoot))
                         patchelf_walk(v.path(), loader, rpath, patchelfBin);
@@ -3150,7 +3144,7 @@ int cmd_toolchain(const mcpplibs::cmdline::ParsedArgs& parsed) {
                   compiler == "musl-gcc" ? "musl-gcc" : compiler, ximVersion)
             : std::format("{}@{}", compiler, ximVersion);
 
-        auto installDir = pkgsDir / std::format("xim-x-{}", ximName) / ximVersion;
+        auto installDir = mcpp::xlings::paths::xim_tool(xlEnv, ximName, ximVersion);
         if (!std::filesystem::exists(installDir)) {
             mcpp::ui::error(std::format(
                 "{} is not installed. Run `mcpp toolchain install {} {}` first.",
@@ -3177,7 +3171,7 @@ int cmd_toolchain(const mcpplibs::cmdline::ParsedArgs& parsed) {
         }
         std::string compiler = spec.substr(0, at);
         std::string version  = spec.substr(at + 1);
-        auto installDir = pkgsDir / std::format("xim-x-{}", compiler) / version;
+        auto installDir = mcpp::xlings::paths::xim_tool(xlEnv, compiler, version);
         std::error_code ec;
         if (!std::filesystem::exists(installDir, ec)) {
             mcpp::ui::error(std::format("{} is not installed", spec));