// mcpp.cli.selection — which workspace members a command acts on.

//

// `build`, `test`, `mcpp emit build-database` and `pack` read the same

// selection from the same flags, so the members a command plans are the ones

// the flags name whatever the command is (member selection design 2026-09-30,

// S1). The selection is a SET of members: it is kept in `[workspace] members`

// order whatever order `-p` names them in, and a member named twice is

// selected once, so the plan does not depend on how the command line was

// spelled.

//

// The function is split in two. `select_members(ws, ...)` reads nothing but

// the workspace manifest it is given and its members' manifests, which is what

// the unit tests exercise; the overload that takes a directory finds the

// workspace the directory belongs to and the member the directory is inside,

// and is the one the commands call.

export module mcpp.cli.selection;

import std;

import mcpplibs.cmdline;

import mcpp.manifest;

import mcpp.project;

import mcpp.build.prepare_inputs;

export namespace mcpp::cli {

// The selectors of a command line, as written.

struct MemberRequest {

bool all = false; // --workspace

std::vector<std::string> packages; // every -p/--package, in command-line order

std::vector<std::string> excludes; // every --exclude, in command-line order

};

// The workspace a command acts on and the members it selects.

struct MemberSelection {

std::filesystem::path root;

// Each member as `[workspace] members` spells it, in that order; a rooted

// workspace's own package comes first, as "." (workspace design

// 2026-09-29 §7.1).

std::vector<std::string> members;

// True when the selection is the workspace itself less what `--exclude`

// removed: `--workspace`, or a virtual root without `-p`. A command that

// reports per member (`test`) reports in its fan-out form for such a

// selection even when the workspace has one member.

bool whole = false;

};

// The member path `value` names, spelled as `[workspace] members` spells it

// ("." for a rooted workspace's own package). The value is resolved in the

// order docs/07 §5.3 states, by `mcpp::project::resolve_member_dir`: a

// qualified name, then a package name (refused, naming every match, when

// several members share it), then a directory.

std::expected<std::string, std::string>

member_path_of(const mcpp::manifest::Manifest& ws,

const std::filesystem::path& wsRoot,

std::string_view value) {

auto dir = mcpp::project::resolve_member_dir(ws, wsRoot, value);

if (!dir) return std::unexpected(dir.error());

std::string rel = ".";

if (!dir->empty()) {

const auto u8 = dir->lexically_normal()

.lexically_relative(wsRoot.lexically_normal())

.generic_u8string();

rel.assign(reinterpret_cast<const char*>(u8.data()), u8.size());

if (rel.empty()) rel = ".";

}

// The spelling the manifest uses, so that "./libs/core" and "libs/core"

// are one member to every reader of the selection.

for (auto const& mp : ws.workspace.members)

if (std::filesystem::path(mp).lexically_normal() == std::filesystem::path(rel))

return mp;

return rel;

}

// The selection over a workspace whose manifest is `ws` and whose root is

// `wsRoot`. `inside` is the member, as `[workspace] members` spells it, that

// the command's directory is inside; empty at the workspace root.

//

// | request | members |

// |------------------------------------------|----------------------------------|

// | `--workspace` | every member |

// | a virtual root, no `-p` | every member |

// | a rooted root, no `-p` | "." |

// | inside member X, no `-p` | X |

// | `-p X -p Y` | {X, Y} |

// | an "all" form above, with `--exclude Z` | every member but Z |

//

// Refused, before anything is planned: `--workspace` together with `-p`, a

// `-p` that names no member (the refusal lists the members) or several (it

// names every match), `--exclude` together with `-p`, `--exclude` without an

// "all" form, an `--exclude` that names no member, and an `--exclude` that

// removes every member.

std::expected<MemberSelection, std::string>

select_members(const mcpp::manifest::Manifest& ws,

const std::filesystem::path& wsRoot,

std::string_view inside,

const MemberRequest& req) {

// `--workspace` selects every member and `-p` names some of them. The two

// together state two selections, and taking either one would drop the

// other without a word, which is the defect a repeated `-p` had (#750).

if (req.all && !req.packages.empty())

return std::unexpected(std::string(

"--workspace cannot be combined with -p: --workspace selects every member, "

"and -p names the members a command acts on"));

if (!req.excludes.empty() && !req.packages.empty())

return std::unexpected(std::string(

"--exclude cannot be combined with -p: -p names the members a command acts on, "

"and --exclude removes members from a whole-workspace selection"));

const bool rooted = !ws.package.name.empty();

std::vector<std::string> all;

if (rooted) all.push_back(".");

all.insert(all.end(), ws.workspace.members.begin(), ws.workspace.members.end());

MemberSelection sel{wsRoot, {}, false};

if (req.all) {

sel.members = all;

sel.whole = true;

} else if (!req.packages.empty()) {

std::set<std::string> named;

for (auto const& p : req.packages) {

auto mp = member_path_of(ws, wsRoot, p);

if (!mp) return std::unexpected(mp.error());

named.insert(std::move(*mp));

}

// Manifest order, and once each: the selection is a set.

for (auto const& mp : all)

if (named.contains(mp)) sel.members.push_back(mp);

} else if (!inside.empty()) {

sel.members = {std::string(inside)};

} else if (!rooted) {

sel.members = all;

sel.whole = true;

} else {

sel.members = {"."};

}

if (sel.members.empty())

return std::unexpected(std::string("the workspace lists no members"));

if (req.excludes.empty()) return sel;

if (!sel.whole)

return std::unexpected(std::string(

"--exclude removes members from a whole-workspace selection: "

"add --workspace (a virtual workspace root selects every member without it)"));

std::set<std::string> removed;

for (auto const& e : req.excludes) {

auto mp = member_path_of(ws, wsRoot, e);

if (!mp) return std::unexpected(std::format("--exclude '{}': {}", e, mp.error()));

removed.insert(std::move(*mp));

}

std::erase_if(sel.members, [&](const std::string& mp) { return removed.contains(mp); });

if (sel.members.empty())

return std::unexpected(std::string(

"--exclude removes every member of the workspace, so nothing is left to act on"));

return sel;

}

// The selection for a command run in `cwd`: nullopt outside a workspace (the

// command then acts on the one package it is in). Inside a member's directory

// the workspace is the one that lists the member, and `--workspace` there

// still means the whole of it.

std::expected<std::optional<MemberSelection>, std::string>

select_members(const MemberRequest& req,

const std::filesystem::path& cwd = std::filesystem::current_path()) {

auto root = mcpp::project::find_manifest_root(cwd);

if (!root) return std::optional<MemberSelection>{};

auto m = mcpp::manifest::load(*root / "mcpp.toml", {.insideWorkspace = true});

// A manifest that cannot be read is reported by the planner, with its own

// diagnostic; it is not a selection question.

if (!m) return std::optional<MemberSelection>{};

auto outside = [&]() -> std::expected<std::optional<MemberSelection>, std::string> {

if (!req.excludes.empty())

return std::unexpected(std::string(

"--exclude names members of a workspace, and this directory is not in one"));

return std::optional<MemberSelection>{};

};

std::filesystem::path wsRoot = *root;

std::string inside;

if (!m->workspace.present) {

wsRoot = mcpp::project::find_workspace_root(*root);

if (wsRoot.empty()) return outside();

m = mcpp::manifest::load(wsRoot / "mcpp.toml");

if (!m || !m->workspace.present) return outside();

const auto rel = root->lexically_normal().lexically_relative(wsRoot.lexically_normal());

for (auto const& mp : m->workspace.members)

if (std::filesystem::path(mp).lexically_normal() == rel) inside = mp;

if (inside.empty()) return outside();

}

auto sel = select_members(*m, wsRoot, inside, req);

if (!sel) return std::unexpected(sel.error());

return std::optional<MemberSelection>{std::move(*sel)};

}

// The selectors of a command line, as `mcpp::cli::select_members` reads them

// (member selection design 2026-09-30, S1): every command that acts on members

// reads its `-p`, `--workspace` and `--exclude` the same way, so the members a

// command plans are the ones the flags name whatever the command is.

MemberRequest member_request(const mcpplibs::cmdline::ParsedArgs& parsed) {

MemberRequest req;

req.all = parsed.is_flag_set("workspace");

req.packages = parsed.option_or_empty("package").values;

req.excludes = parsed.option_or_empty("exclude").values;

return req;

}

// The workspace a fan-out acts on, and its members grouped by configuration

// (workspace design 2026-09-29 §15): members whose root-position values are

// equal are planned together, in one graph, in one build directory.

//

// A member's conditional configuration rows are evaluated for the target the

// command builds -- `--target`, else the member's `[build] target`, else the

// host -- with prepare's evaluator, so a group and the plan it becomes agree

// on them by construction (W4).

std::expected<std::vector<std::vector<std::string>>, std::string>

workspace_groups(const std::filesystem::path& wsRoot, const std::vector<std::string>& members,

std::string_view targetTriple) {

auto ws = mcpp::manifest::load(wsRoot / "mcpp.toml");

if (!ws) return std::unexpected(ws.error().format());

std::vector<std::vector<std::string>> groups;

std::map<std::string, std::size_t> byKey;

for (auto const& mp : members) {

auto mm = mcpp::project::load_member_manifest(*ws, wsRoot, mp);

if (!mm) return std::unexpected(mm.error());

namespace cfgpred = mcpp::build::cfgpred;

const auto ctx = cfgpred::context_for(

targetTriple.empty() ? std::string_view(mm->buildConfig.target) : targetTriple);

const auto key = mcpp::project::root_position_key(*mm, [&](std::string_view predicate) {

return cfgpred::matches(std::string(predicate), ctx);

});

auto [it, fresh] = byKey.try_emplace(key, groups.size());

if (fresh) groups.emplace_back();

groups[it->second].push_back(mp);

}

return groups;

}

} // namespace mcpp::cli