refactor: eliminate remaining platform macros (P0-P6)

P0: Remove all #define popen/_popen macros from 6 files — migrate
    every raw popen/pclose/std::system call to platform::process APIs.
    Files: cli, ninja_backend, msvc, stdmod, pack, publisher, p1689.
    Add run_passthrough() and extract_exit_code() to platform::process.

P1: Replace all manual shell quoting #ifdefs in cli.cppm with
    platform::shell::quote(). Covers git clone, ninja -C, cmd_run,
    cmd_test (5 locations).

P2: Create platform/terminal.cppm — absorbs is_tty() and
    terminal_cols() from ui.cppm. Eliminates #ifdef __unix__ blocks.

P3: Move kXpkgPlatform constant to platform::common::xpkg_platform.
    resolver.cppm now uses it without #if defined blocks.

P4: Add link strategy constants (supports_full_static, supports_rpath,
    needs_explicit_libcxx) to platform::common. flags.cppm now uses
    if constexpr instead of #if defined blocks.

P5: Replace #if defined(_WIN32) in xlings.cppm build_command_prefix,
    install_with_progress, ensure_init with if constexpr.

P6: Eliminate all #if defined blocks in ninja_backend.cppm rule
    generation. Introduce constexpr $toolenv prefix variable, use
    if constexpr for platform-specific rules (cp_bmi, scan_deps).

Net: ~440 lines of #ifdef removed, 315 lines of clean constexpr/
platform API code added. Zero raw popen calls remain outside
src/platform/.

Author: Sunrisepeak

.agents/docs/platform-remaining-ifdefs-report.md

@@ -0,0 +1,49 @@
+# Remaining Platform Macros Outside src/platform/ — Analysis Report
+
+## Summary
+
+14 files, 39 occurrences of platform-specific macros/conditionals outside `src/platform/`.
+
+## P0: Eliminate `#define popen _popen` (6 files, ~16 occurrences)
+
+Migrate all raw popen/pclose calls to `platform::process::capture()` / `run_streaming()` / `run_silent()`.
+
+Files: cli.cppm, ninja_backend.cppm, msvc.cppm, stdmod.cppm, pack/pack.cppm, pm/publisher.cppm, modgraph/p1689.cppm
+
+## P1: Shell quoting in cli.cppm (5 occurrences)
+
+Replace manual `'...'` vs `"..."` with `platform::shell::quote()`.
+
+Lines: 1954, 1965, 2527, 2620, 3178
+
+## P2: Terminal abstraction — ui.cppm (3 occurrences)
+
+Create `platform/terminal.cppm` for isatty, terminal width detection.
+
+Lines: 8-9, 149, 329
+
+## P3: kXpkgPlatform in resolver.cppm (1 occurrence)
+
+Move to `platform::common` as a constant.
+
+Line: 30
+
+## P4: Link strategy constants in flags.cppm (3 occurrences)
+
+Add `supports_full_static`, `supports_rpath`, `needs_explicit_libcxx` to `platform::common`.
+
+Lines: 162, 175, 183
+
+## P5: xlings.cppm build_command_prefix (3 occurrences)
+
+Abstract Windows env-setting vs POSIX shell-prefix into platform layer.
+
+Lines: 401, 612, 739
+
+## P6: ninja_backend.cppm rule generation (10 occurrences)
+
+Abstract `$toolenv` prefix and shell syntax differences.
+
+Lines: 178, 207, 231, 243, 254, 287, 297, 548, 560
+
+## Priority: P0+P1 = 54% elimination with minimal risk.

src/build/flags.cppm

@@ -10,6 +10,7 @@ export module mcpp.build.flags;
 
 import std;
 import mcpp.build.plan;
+import mcpp.platform;
 import mcpp.toolchain.clang;
 import mcpp.toolchain.detect;
 import mcpp.toolchain.provider;
@@ -159,46 +160,23 @@ CompileFlags compute_flags(const BuildPlan& plan) {
     // Link flags
     f.staticStdlib = plan.manifest.buildConfig.staticStdlib;
     f.linkage = plan.manifest.buildConfig.linkage;
-#if defined(_WIN32)
-    // Windows: MSVC linker handles static/dynamic linking differently
-    std::string full_static;
-    std::string static_stdlib;
-#elif defined(__APPLE__)
-    // macOS does not support full static linking (libSystem must be dynamic)
-    std::string full_static;
-    std::string static_stdlib = (f.staticStdlib && !isClang) ? " -static-libstdc++" : "";
-#else
-    std::string full_static = (f.linkage == "static") ? " -static" : "";
-    std::string static_stdlib = (f.staticStdlib && !isClang) ? " -static-libstdc++" : "";
-#endif
+    std::string full_static = (mcpp::platform::supports_full_static && f.linkage == "static") ? " -static" : "";
+    std::string static_stdlib = (f.staticStdlib && !isClang && !mcpp::platform::is_windows) ? " -static-libstdc++" : "";
     std::string runtime_dirs;
-#if !defined(_WIN32)
-    // -L and -rpath are ELF/Mach-O linker flags; MSVC linker doesn't use them.
-    for (auto& dir : plan.toolchain.linkRuntimeDirs) {
-        runtime_dirs += " -L" + escape_path(dir);
-        runtime_dirs += " -Wl,-rpath," + escape_path(dir);
+    if constexpr (mcpp::platform::supports_rpath) {
+        for (auto& dir : plan.toolchain.linkRuntimeDirs) {
+            runtime_dirs += " -L" + escape_path(dir);
+            runtime_dirs += " -Wl,-rpath," + escape_path(dir);
+        }
+    }
+
+    if constexpr (mcpp::platform::is_windows) {
+        f.ld = "";
+    } else if constexpr (mcpp::platform::needs_explicit_libcxx) {
+        f.ld = std::format("{}{}{} -lc++", full_static, static_stdlib, b_flag);
+    } else {
+        f.ld = std::format("{}{}{}{}{}", full_static, static_stdlib, sysroot_flag, b_flag, runtime_dirs);
     }
-#endif
-
-#if defined(_WIN32)
-    // Windows: Clang targeting MSVC links against MSVC runtime automatically.
-    // No -L/-rpath/-static flags needed.
-    f.ld = "";
-#elif defined(__APPLE__)
-    // macOS linking strategy:
-    // - No --sysroot: SDK .tbd stubs miss libc++abi exports.
-    // - No -L<llvm>/lib: xlings LLVM's libc++.dylib doesn't pull in
-    //   libc++abi. System /usr/lib/libc++ does (and is ABI-compatible
-    //   with LLVM 20 headers since macOS ships a recent libc++).
-    // - No -rpath for LLVM lib: binary should use system libc++ at runtime.
-    // - Explicit -lc++: clang++.cfg's -nostdinc++ suppresses implicit linkage.
-    // Result: compile with LLVM headers, link with system libc++ + libc++abi.
-    f.ld = std::format("{}{}{} -lc++", full_static, static_stdlib, b_flag);
-#else
-    // Linux: sysroot + runtime dirs needed (glibc/libc++ live in sandbox)
-    f.ld = std::format("{}{}{}{}{}", full_static, static_stdlib, sysroot_flag, b_flag,
-                       runtime_dirs);
-#endif
 
     return f;
 }

src/build/ninja_backend.cppm

@@ -14,10 +14,6 @@
 module;
 #include <cstdio>
 #include <cstdlib>
-#if defined(_WIN32)
-#define popen  _popen
-#define pclose _pclose
-#endif
 
 export module mcpp.build.ninja;
 
@@ -90,20 +86,14 @@ void write_file(const std::filesystem::path& p, std::string_view content) {
     os << content;
 }
 
-bool run(const std::string& cmd, std::string& output_capture, bool capture = true) {
-    std::array<char, 8192> buf{};
+bool run(const std::string& cmd, std::string& output_capture, bool capture_output = true) {
     output_capture.clear();
-    std::FILE* fp = ::popen(cmd.c_str(), "r");
-    if (!fp)
-        return false;
-    while (std::fgets(buf.data(), buf.size(), fp) != nullptr) {
-        if (capture)
-            output_capture += buf.data();
-        else
-            std::fputs(buf.data(), stdout);
+    if (capture_output) {
+        auto r = mcpp::platform::process::capture(cmd);
+        output_capture = r.output;
+        return r.exit_code == 0;
     }
-    int rc = ::pclose(fp);
-    return rc == 0;
+    return mcpp::platform::process::run_passthrough(cmd) == 0;
 }
 
 bool dyndep_mode_enabled() {
@@ -175,13 +165,13 @@ std::string emit_ninja_string(const BuildPlan& plan) {
     append("\n");
 
     append("rule cp_bmi\n");
-#if defined(_WIN32)
-    // Use PowerShell Copy-Item which handles both forward and back slashes.
-    // cmd.exe `copy` breaks on forward-slash paths from ninja.
-    append("  command = powershell -NoProfile -Command \"Copy-Item -Force '$in' -Destination '$out'\"\n");
-#else
-    append("  command = mkdir -p $$(dirname $out) && cp -f $in $out\n");
-#endif
+    if constexpr (mcpp::platform::is_windows) {
+        // Use PowerShell Copy-Item which handles both forward and back slashes.
+        // cmd.exe `copy` breaks on forward-slash paths from ninja.
+        append("  command = powershell -NoProfile -Command \"Copy-Item -Force '$in' -Destination '$out'\"\n");
+    } else {
+        append("  command = mkdir -p $$(dirname $out) && cp -f $in $out\n");
+    }
     append("  description = STAGE $out\n\n");
 
     // P1: per-file dyndep rule. Converts one .ddi → .dd independently.
@@ -201,81 +191,63 @@ std::string emit_ninja_string(const BuildPlan& plan) {
     //
     // $bmi_out is set per build edge to the BMI path (gcm.cache/<module>.gcm).
     // If $bmi_out is empty (no module provided), we just compile normally.
+    // On POSIX, $toolenv prefixes commands with LD_LIBRARY_PATH etc.
+    // On Windows, $toolenv is empty and its leading space breaks CreateProcess,
+    // so we omit it entirely.
+    constexpr std::string_view te = mcpp::platform::is_windows ? "" : "$toolenv ";
+
     std::string module_output_flag = traits.needsExplicitModuleOutput
         ? " -fmodule-output=$bmi_out" : "";
     append("rule cxx_module\n");
-#if defined(_WIN32)
-    // Windows: skip BMI restat optimization (requires POSIX shell).
-    // No $toolenv (empty on Windows; its leading space breaks CreateProcess).
-    append(std::format("  command = "
-           "$cxx $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 && "
-           "$toolenv $cxx $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\"; "
-           "else "
-             "rm -f \"$bmi_out.bak\"; "
-           "fi\n", module_output_flag));
-#endif
+    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));
+    } 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 && "
+               "if [ -n \"$bmi_out\" ] && [ -f \"$bmi_out.bak\" ] && "
+                  "cmp -s \"$bmi_out\" \"$bmi_out.bak\"; then "
+                 "mv \"$bmi_out.bak\" \"$bmi_out\"; "
+               "else "
+                 "rm -f \"$bmi_out.bak\"; "
+               "fi\n", te, module_output_flag));
+    }
     append("  description = MOD $out\n");
     if (dyndep)
         append("  restat = 1\n");
     append("\n");
 
     append("rule cxx_object\n");
-#if defined(_WIN32)
-    append("  command = $cxx $cxxflags -c $in -o $out\n");
-#else
-    append("  command = $toolenv $cxx $cxxflags -c $in -o $out\n");
-#endif
+    append(std::format("  command = {}$cxx $cxxflags -c $in -o $out\n", te));
     append("  description = OBJ $out\n");
     if (dyndep)
         append("  restat = 1\n");
     append("\n");
 
     if (need_c_rule) {
         append("rule c_object\n");
-#if defined(_WIN32)
-        append("  command = $cc $cflags -c $in -o $out\n");
-#else
-        append("  command = $toolenv $cc $cflags -c $in -o $out\n");
-#endif
+        append(std::format("  command = {}$cc $cflags -c $in -o $out\n", te));
         append("  description = CC $out\n");
         if (dyndep)
             append("  restat = 1\n");
         append("\n");
     }
 
-#if defined(_WIN32)
     append("rule cxx_link\n");
-    append("  command = $cxx $in -o $out $ldflags\n");
+    append(std::format("  command = {}$cxx $in -o $out $ldflags\n", te));
     append("  description = LINK $out\n\n");
 
     append("rule cxx_archive\n");
-    append("  command = $ar rcs $out $in\n");
+    append(std::format("  command = {}$ar rcs $out $in\n", te));
     append("  description = AR $out\n\n");
 
     append("rule cxx_shared\n");
-    append("  command = $cxx -shared $in -o $out $ldflags\n");
+    append(std::format("  command = {}$cxx -shared $in -o $out $ldflags\n", te));
     append("  description = SHARED $out\n\n");
-#else
-    append("rule cxx_link\n");
-    append("  command = $toolenv $cxx $in -o $out $ldflags\n");
-    append("  description = LINK $out\n\n");
-
-    append("rule cxx_archive\n");
-    append("  command = $toolenv $ar rcs $out $in\n");
-    append("  description = AR $out\n\n");
-
-    append("rule cxx_shared\n");
-    append("  command = $toolenv $cxx -shared $in -o $out $ldflags\n");
-    append("  description = SHARED $out\n\n");
-#endif
 
     if (dyndep) {
         // Scan rule: produce P1689 .ddi for one TU.
@@ -284,25 +256,21 @@ std::string emit_ninja_string(const BuildPlan& plan) {
         append("rule cxx_scan\n");
         if (plan.scanDepsPath.empty()) {
             // GCC path: compiler-integrated P1689 scanning.
-#if defined(_WIN32)
-            append("  command = $cxx $cxxflags -fmodules "
-#else
-            append("  command = $toolenv $cxx $cxxflags -fmodules "
-#endif
+            append(std::format("  command = {}$cxx $cxxflags -fmodules "
                    "-fdeps-format=p1689r5 "
                    "-fdeps-file=$out -fdeps-target=$compile_target "
-                   "-M -MM -MF $out.dep -E $in -o $compile_target\n");
+                   "-M -MM -MF $out.dep -E $in -o $compile_target\n", te));
         } else {
             // Clang path: clang-scan-deps produces P1689 JSON to stdout.
-#if defined(_WIN32)
-            // 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");
-#else
-            append("  command = $toolenv $scan_deps -format=p1689 -- "
-                   "$cxx $cxxflags -c $in -o $compile_target > $out\n");
-#endif
+            if constexpr (mcpp::platform::is_windows) {
+                // 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");
+            } else {
+                append(std::format("  command = {}$scan_deps -format=p1689 -- "
+                       "$cxx $cxxflags -c $in -o $compile_target > $out\n", te));
+            }
         }
         append("  description = SCAN $out\n\n");
 
@@ -545,27 +513,21 @@ 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;
-#if defined(_WIN32)
+    auto ninja_name = std::string("ninja") + std::string(mcpp::platform::exe_suffix);
     if (auto nb = mcpp::xlings::paths::find_sibling_binary(
-            plan.toolchain.binaryPath, "ninja", "ninja.exe")) {
+            plan.toolchain.binaryPath, "ninja", ninja_name)) {
         ninjaBin = *nb;
     }
-#else
-    if (auto nb = mcpp::xlings::paths::find_sibling_binary(
-            plan.toolchain.binaryPath, "ninja", "ninja")) {
-        ninjaBin = *nb;
+
+    std::string ninjaProgram;
+    if (!ninjaBin.empty()) {
+        if constexpr (mcpp::platform::is_windows)
+            ninjaProgram = ninjaBin.string();
+        else
+            ninjaProgram = mcpp::platform::shell::quote(ninjaBin.string());
+    } else {
+        ninjaProgram = "ninja";
     }
-#endif
-
-#if defined(_WIN32)
-    // Windows: no quotes on first token (cmd.exe strips leading quotes),
-    // use shq only for the -C argument which may contain spaces.
-    std::string ninjaProgram =
-        !ninjaBin.empty() ? ninjaBin.string() : std::string{"ninja"};
-#else
-    std::string ninjaProgram =
-        !ninjaBin.empty() ? mcpp::xlings::shq(ninjaBin.string()) : std::string{"ninja"};
-#endif
 
     // Record ninja binary for P0 fast-path cache.
     BuildResult r;