feat: build profiles ([profile.<name>] + --profile)

Adds bundled build settings: built-in release (-O2) / dev (-O0 -g) / dist
(-O3 -flto -s), overridable/extendable via [profile.<name>] (opt/debug/lto/
strip) in mcpp.toml. --profile selects; flags.cppm applies opt/debug/lto to
compile and lto/strip to link. Verified: release/dev/dist emit distinct flags.

Author: d2learn-org

src/build/flags.cppm

@@ -198,8 +198,14 @@ CompileFlags compute_flags(const BuildPlan& plan) {
     // AR binary
     f.arBinary = mcpp::toolchain::archive_tool(plan.toolchain);
 
-    // Opt level (musl ICE workaround)
-    std::string opt_flag = isMuslTc ? " -Og" : " -O2";
+    // Opt level + debug come from the resolved build profile
+    // ([profile.<name>] → buildConfig). musl keeps -Og as an ICE workaround
+    // unless the profile pins -O0.
+    auto& prof = plan.manifest.buildConfig;
+    std::string opt_flag = isMuslTc && prof.optLevel != "0"
+        ? " -Og" : (" -O" + prof.optLevel);
+    if (prof.debug) opt_flag += " -g";
+    if (prof.lto)   opt_flag += " -flto";
 
     // User link flags
     std::string user_ldflags;
@@ -279,13 +285,17 @@ CompileFlags compute_flags(const BuildPlan& plan) {
             payload_ld += " -Wl,--dynamic-linker=" + escape_path(loader);
     }
 
+    std::string link_extra;
+    if (prof.lto)   link_extra += " -flto";
+    if (prof.strip) link_extra += " -s";
+
     if constexpr (mcpp::platform::is_windows) {
-        f.ld = user_ldflags;
+        f.ld = user_ldflags + link_extra;
     } else if constexpr (mcpp::platform::needs_explicit_libcxx) {
-        f.ld = std::format("{}{}{} -lc++{}", full_static, static_stdlib, b_flag, user_ldflags);
+        f.ld = std::format("{}{}{} -lc++{}{}", full_static, static_stdlib, b_flag, user_ldflags, link_extra);
     } else {
-        f.ld = std::format("{}{}{}{}{}{}{}", full_static, static_stdlib, link_toolchain_flags, b_flag,
-                           runtime_dirs, payload_ld, user_ldflags);
+        f.ld = std::format("{}{}{}{}{}{}{}{}", full_static, static_stdlib, link_toolchain_flags, b_flag,
+                           runtime_dirs, payload_ld, user_ldflags, link_extra);
     }
 
     return f;

src/cli.cppm

@@ -1156,6 +1156,7 @@ struct BuildOverrides {
     std::string target_triple;       // empty = host triple, fall through to [toolchain]
     bool        force_static = false; // --static (or implied by musl target)
     std::string package_filter;      // -p <name>: only build this workspace member
+    std::string profile;             // --profile <name> (default "release")
 };
 
 // `prepare_build` builds the BuildContext for any verb that compiles.
@@ -1312,6 +1313,21 @@ prepare_build(bool print_fingerprint,
     //   1. project mcpp.toml [toolchain].<platform> or .default
     //   2. global ~/.mcpp/config.toml [toolchain].default
     //   3. hard error (no system fallback)
+    // Resolve the build profile: --profile (default "release") → built-in
+    // defaults, overlaid by any [profile.<name>] from the manifest → buildConfig.
+    {
+        std::string pname = overrides.profile.empty() ? "release" : overrides.profile;
+        mcpp::manifest::Profile pr;
+        if (pname == "dev" || pname == "debug") { pr.optLevel = "0"; pr.debug = true; }
+        else if (pname == "dist")               { pr.optLevel = "3"; pr.lto = true; pr.strip = true; }
+        else                                    { pr.optLevel = "2"; } // release
+        if (auto it = m->profiles.find(pname); it != m->profiles.end()) pr = it->second;
+        m->buildConfig.optLevel = pr.optLevel;
+        m->buildConfig.debug    = pr.debug;
+        m->buildConfig.lto      = pr.lto;
+        m->buildConfig.strip    = pr.strip;
+    }
+
     auto tcSpec = m->toolchain.for_platform(kCurrentPlatform);
     if (!tcSpec.has_value()) {
         auto cfg = get_cfg();
@@ -3530,6 +3546,7 @@ int cmd_build(const mcpplibs::cmdline::ParsedArgs& parsed) {
     BuildOverrides ov;
     if (auto t = parsed.value("target")) ov.target_triple = *t;
     if (auto p = parsed.value("package")) ov.package_filter = *p;
+    if (auto pr = parsed.value("profile")) ov.profile = *pr;
     ov.force_static = parsed.is_flag_set("static");
 
     // P0: try fast-path if inputs haven't changed.
@@ -5576,6 +5593,8 @@ int run(int argc, char** argv) {
                 "Force static linking (-static). On Linux, prefer pairing with --target <arch>-linux-musl"))
             .option(cl::Option("package").short_name('p').takes_value().value_name("NAME")
                 .help("Build only the named workspace member"))
+            .option(cl::Option("profile").takes_value().value_name("NAME")
+                .help("Build profile: release (default) | dev | dist | <[profile.*] name>"))
             .action(wrap_rc(cmd_build)))
         .subcommand(cl::App("run")
             .description("Build + run a binary target (after `--`, args are passed to it)")

src/manifest.cppm

@@ -103,6 +103,11 @@ struct BuildConfig {
     std::vector<std::string>           cxxflags;
     std::vector<std::string>           ldflags;
     std::string                         cStandard;
+    // Resolved build-profile knobs (from [profile.<name>] + built-in defaults).
+    std::string                         optLevel = "2";  // -O level
+    bool                                debug    = false; // -g
+    bool                                lto      = false; // -flto
+    bool                                strip    = false; // link -s
 };
 
 // `[runtime]` — requirements needed when launching built binaries.
@@ -175,6 +180,14 @@ struct WorkspaceConfig {
     bool                                                present = false;
 };
 
+// [profile.<name>] — bundled build settings (opt level, debug, lto, strip).
+struct Profile {
+    std::string optLevel = "2";
+    bool        debug    = false;
+    bool        lto      = false;
+    bool        strip    = false;
+};
+
 struct Manifest {
     std::filesystem::path       sourcePath;    // mcpp.toml's filesystem path
 
@@ -191,6 +204,7 @@ struct Manifest {
     Toolchain                   toolchain;     // optional; empty == fallback
     BuildConfig                 buildConfig;
     RuntimeConfig               runtimeConfig;
+    std::map<std::string, Profile> profiles;   // [profile.<name>]
 
     // [target.<triple>] tables — empty if user didn't declare any.
     std::map<std::string, TargetEntry> targetOverrides;
@@ -469,6 +483,24 @@ std::expected<Manifest, ManifestError> parse_string(std::string_view content,
     }
 
     // [targets.*] — M5.0: now optional. If absent, defer to auto-inference (in load()).
+    // [profile.<name>] — bundled build settings.
+    if (auto* profile_table = doc->get_table("profile");
+        profile_table && !profile_table->empty()) {
+        for (auto& [pname, pval] : *profile_table) {
+            if (!pval.is_table()) continue;
+            auto& tt = pval.as_table();
+            Profile pr;
+            if (auto it = tt.find("opt"); it != tt.end()) {
+                if      (it->second.is_string()) pr.optLevel = it->second.as_string();
+                else if (it->second.is_int())    pr.optLevel = std::to_string(it->second.as_int());
+            }
+            if (auto it = tt.find("debug"); it != tt.end() && it->second.is_bool()) pr.debug = it->second.as_bool();
+            if (auto it = tt.find("lto");   it != tt.end() && it->second.is_bool()) pr.lto   = it->second.as_bool();
+            if (auto it = tt.find("strip"); it != tt.end() && it->second.is_bool()) pr.strip = it->second.as_bool();
+            m.profiles[pname] = pr;
+        }
+    }
+
     auto* targets_table = doc->get_table("targets");
     if (targets_table && !targets_table->empty()) {
     for (auto& [tname, tval] : *targets_table) {