feat(build): consume package.xml manifest for ROS

crates/pixi_build_discovery/Cargo.toml

@@ -23,6 +23,7 @@ rattler_conda_types = { workspace = true }
 pixi_build_type_conversions = { workspace = true }
 pixi_build_types = { workspace = true }
 pixi_config = { workspace = true }
+pixi_consts = { workspace = true }
 pixi_manifest = { workspace = true }
 pixi_spec = { workspace = true }
 pixi_spec_containers = { workspace = true }

crates/pixi_build_discovery/src/discovery.rs

@@ -9,6 +9,7 @@ use ordermap::OrderMap;
 use pixi_build_type_conversions::{to_project_model_v1, to_target_selector_v1};
 use pixi_build_types::{ProjectModelV1, TargetSelectorV1};
 use pixi_config::Config;
+use pixi_consts::consts::{RATTLER_BUILD_DIRS, RATTLER_BUILD_FILE_NAMES, ROS_BACKEND_FILE_NAMES};
 use pixi_manifest::{
     DiscoveryStart, ExplicitManifestError, PackageManifest, PrioritizedChannel, WithProvenance,
     WorkspaceDiscoverer, WorkspaceDiscoveryError, WorkspaceManifest,
@@ -23,10 +24,6 @@ use crate::{
     backend_spec::{CommandSpec, EnvironmentSpec, JsonRpcBackendSpec},
 };
 
-const RATTLER_BUILD_FILE_NAMES: [&str; 2] = ["recipe.yaml", "recipe.yml"];
-const RATTLER_BUILD_DIRS: [&str; 2] = ["", "recipe"];
-const ROS_BACKEND_FILE_NAMES: [&str; 1] = ["package.xml"];
-
 /// Describes a backend discovered for a given source location.
 #[derive(Debug, Clone)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize))]

crates/pixi_cli/src/build.rs

@@ -1,4 +1,4 @@
-use std::path::PathBuf;
+use std::{ffi::OsStr, path::PathBuf};
 
 use clap::Parser;
 use indicatif::ProgressBar;
@@ -7,6 +7,7 @@ use pixi_command_dispatcher::{
     BuildBackendMetadataSpec, BuildEnvironment, BuildProfile, CacheDirs, SourceBuildSpec,
 };
 use pixi_config::ConfigCli;
+use pixi_consts::consts::{RATTLER_BUILD_FILE_NAMES, ROS_BACKEND_FILE_NAMES, WORKSPACE_MANIFEST};
 use pixi_core::WorkspaceLocator;
 use pixi_manifest::FeaturesExt;
 use pixi_progress::global_multi_progress;
@@ -46,6 +47,50 @@ pub struct Args {
     /// Whether to clean the build directory before building.
     #[clap(long, short)]
     pub clean: bool,
+
+    /// The path to `package.xml`, `recipe.yaml`, or `pixi.toml` that can be built.
+    #[arg(long)]
+    pub build_manifest: Option<PathBuf>,
+}
+
+/// Validate that the full path of build manifest exists and is a supported format.
+fn validate_build_manifest(path: &PathBuf) -> miette::Result<()> {
+    if path.is_dir() {
+        miette::bail!(
+            "the build manifest path '{}' is a directory, please provide the path to the manifest file",
+            path.display()
+        );
+    }
+
+    let filename = path
+        .file_name()
+        .and_then(OsStr::to_str)
+        .ok_or_else(|| miette::miette!("Failed to extract file name from {:?}", path))?;
+
+    let supported_file_names: Vec<&str> = [
+        &ROS_BACKEND_FILE_NAMES[..],
+        &RATTLER_BUILD_FILE_NAMES[..],
+        // manifest that can contain a package section in it
+        &[WORKSPACE_MANIFEST],
+    ]
+    .concat();
+
+    if !supported_file_names
+        .iter()
+        .any(|names| names.contains(filename))
+    {
+        miette::bail!(
+            "the build manifest file '{}' is not a supported format.\n Supported formats are: {}",
+            path.display(),
+            supported_file_names
+                .iter()
+                .map(|name| format!("'{name}'"))
+                .collect::<Vec<_>>()
+                .join(", ")
+        );
+    }
+
+    Ok(())
 }
 
 pub async fn execute(args: Args) -> miette::Result<()> {
@@ -105,18 +150,27 @@ pub async fn execute(args: Args) -> miette::Result<()> {
     let Ok(manifest_path) = workspace_locator.path() else {
         miette::bail!("could not determine the current working directory to locate the workspace");
     };
-    let manifest_path_canonical = dunce::canonicalize(&manifest_path)
+
+    let build_manifest_path = match args.build_manifest {
+        Some(path) => {
+            validate_build_manifest(&path)?;
+            path
+        }
+        None => manifest_path.clone(),
+    };
+
+    let build_manifest_path_canonical = dunce::canonicalize(&build_manifest_path)
         .into_diagnostic()
         .with_context(|| {
             format!(
                 "failed to canonicalize manifest path '{}'",
-                manifest_path.display()
+                build_manifest_path.display()
             )
         })?;
     // Store the manifest location relative to the workspace root when possible to
     // keep the pinned path relocatable and avoid double-prefixing during resolution.
-    let manifest_spec_path = pathdiff::diff_paths(&manifest_path_canonical, workspace.root())
-        .unwrap_or(manifest_path_canonical.clone());
+    let manifest_spec_path = pathdiff::diff_paths(&build_manifest_path_canonical, workspace.root())
+        .unwrap_or(build_manifest_path_canonical.clone());
     let channel_config = workspace.channel_config();
     let channels = workspace
         .default_environment()

crates/pixi_consts/src/consts.rs

@@ -105,6 +105,11 @@ pub const CLAP_GIT_OPTIONS: &str = "Git Options";
 pub const CLAP_GLOBAL_OPTIONS: &str = "Global Options";
 pub const CLAP_UPDATE_OPTIONS: &str = "Update Options";
 
+// Build backends constants
+pub const RATTLER_BUILD_FILE_NAMES: [&str; 2] = ["recipe.yaml", "recipe.yml"];
+pub const RATTLER_BUILD_DIRS: [&str; 2] = ["", "recipe"];
+pub const ROS_BACKEND_FILE_NAMES: [&str; 1] = ["package.xml"];
+
 pub static TASK_STYLE: LazyLock<Style> = LazyLock::new(|| Style::new().blue());
 pub static TASK_ERROR_STYLE: LazyLock<Style> = LazyLock::new(|| Style::new().red());
 pub static PLATFORM_STYLE: LazyLock<Style> = LazyLock::new(|| Style::new().yellow());

crates/pixi_manifest/src/discovery.rs

@@ -479,7 +479,6 @@ impl WorkspaceDiscoverer {
                         source: source.clone(),
                     }),
             );
-
             // Incorporate the workspace information into the package manifest.
             let closest_package_manifest = match closest_package_manifest {
                 None => {

crates/pixi_manifest/src/error.rs

@@ -138,11 +138,7 @@ impl Display for TomlError {
             TomlError::Error(err) => write!(f, "{}", err.message()),
             TomlError::TomlError(err) => write!(f, "{err}"),
             TomlError::NoPixiTable(manifest_kind, detail) => {
-                let filename = match manifest_kind {
-                    ManifestKind::Pyproject => "pyproject.toml",
-                    ManifestKind::Pixi => "pixi.toml",
-                    ManifestKind::MojoProject => "mojoproject.toml",
-                };
+                let filename = manifest_kind.file_name();
                 if let Some(detail) = detail {
                     write!(f, "Missing table in manifest {filename}:\n{detail}")
                 } else {

docs/reference/cli/pixi/build.md

@@ -25,6 +25,8 @@ pixi build [OPTIONS]
 :  The directory to use for incremental builds artifacts
 - <a id="arg---clean" href="#arg---clean">`--clean (-c)`</a>
 :  Whether to clean the build directory before building
+- <a id="arg---build-manifest" href="#arg---build-manifest">`--build-manifest <BUILD_MANIFEST>`</a>
+:  The path to `package.xml`, `recipe.yaml`, or `pixi.toml` that can be built
 
 ## Config Options
 - <a id="arg---auth-file" href="#arg---auth-file">`--auth-file <AUTH_FILE>`</a>