pixi-ros 0.1.2__py3-none-any.whl → 0.3.0__py3-none-any.whl

pixi_ros/cli.py

@@ -5,7 +5,7 @@ from typing import Annotated
 import typer
 
 from pixi_ros.init import init_workspace
-from pixi_ros.mappings import get_ros_distros
+from pixi_ros.mappings import get_platforms, get_ros_distros
 
 app = typer.Typer(
     name="pixi-ros",
@@ -27,6 +27,15 @@ def init(
             help="ROS distribution (e.g., humble, iron, jazzy)",
         ),
     ] = None,
+    platforms: Annotated[
+        list[str] | None,
+        typer.Option(
+            "--platform",
+            "-p",
+            help="Target platforms (e.g., linux-64, osx-arm64, win-64)."
+            " Can be specified multiple times.",
+        ),
+    ] = None,
 ):
     """Initialize pixi.toml for a ROS workspace."""
     # If distro not provided, prompt user to select one
@@ -50,7 +59,7 @@ def init(
                 distro = available_distros[selection_num - 1]
             else:
                 typer.echo(
-                    f"Error: Invalid selection.Please choose 1-{dist_count}",
+                    f"Error: Invalid selection. Please choose 1-{dist_count}",
                     err=True,
                 )
                 raise typer.Exit(code=1)
@@ -65,7 +74,55 @@ def init(
                 typer.echo(f"Available: {', '.join(available_distros)}", err=True)
                 raise typer.Exit(code=1) from err
 
-    init_workspace(distro)
+    # If platforms not provided, prompt user to select
+    if platforms is None or len(platforms) == 0:
+        available_platforms = get_platforms()
+        typer.echo("\nAvailable target platforms:")
+        for i, p in enumerate(available_platforms, 1):
+            typer.echo(f"  {i}. {p}")
+
+        # Prompt for selection (can be comma-separated or space-separated)
+        selection = typer.prompt(
+            "\nSelect platforms (enter numbers or names, comma or space separated)",
+            type=str,
+        )
+
+        # Parse selection (can be numbers or names, comma or space separated)
+        platforms = []
+        # Split by comma or space
+        selections = selection.replace(",", " ").split()
+
+        for sel in selections:
+            sel = sel.strip()
+            if not sel:
+                continue
+
+            try:
+                # Try parsing as number
+                sel_num = int(sel)
+                if 1 <= sel_num <= len(available_platforms):
+                    platforms.append(available_platforms[sel_num - 1])
+                else:
+                    typer.echo(
+                        f"Error: Invalid selection {sel_num}."
+                        + f"Please choose 1-{len(available_platforms)}",
+                        err=True,
+                    )
+                    raise typer.Exit(code=1)
+            except ValueError as err:
+                # User entered a name instead of number
+                if sel in available_platforms:
+                    platforms.append(sel)
+                else:
+                    typer.echo(f"Error: '{sel}' is not a valid platform", err=True)
+                    typer.echo(f"Available: {', '.join(available_platforms)}", err=True)
+                    raise typer.Exit(code=1) from err
+
+        if not platforms:
+            typer.echo("Error: No platforms selected", err=True)
+            raise typer.Exit(code=1)
+
+    init_workspace(distro, platforms=platforms)
 
 
 def main():

pixi_ros/data/conda-forge.yaml

@@ -792,6 +792,8 @@ python3-importlib-resources:
   pixi: [importlib_resources]
 python3-jinja2:
   pixi: [jinja2]
+python3-jsonschema:
+  pixi: [jsonschema]
 python3-kitchen:
   pixi: [kitchen]
 python3-lark-parser:

pixi_ros/init.py

@@ -17,13 +17,18 @@ from pixi_ros.workspace import discover_packages, find_workspace_root
 console = Console()
 
 
-def init_workspace(distro: str, workspace_path: Path | None = None) -> bool:
+def init_workspace(
+    distro: str,
+    workspace_path: Path | None = None,
+    platforms: list[str] | None = None,
+) -> bool:
     """
     Initialize or update pixi.toml for a ROS workspace.
 
     Args:
         distro: ROS distribution (e.g., "humble", "iron", "jazzy")
         workspace_path: Path to workspace root (defaults to current directory)
+        platforms: Target platforms (e.g., ["linux-64", "osx-arm64"])
 
     Returns:
         True if successful, False otherwise
@@ -87,9 +92,9 @@ def init_workspace(distro: str, workspace_path: Path | None = None) -> bool:
     _display_dependencies(packages, distro)
 
     # Update configuration
-    _ensure_workspace_section(pixi_config, workspace_path)
+    _ensure_workspace_section(pixi_config, workspace_path, platforms)
     _ensure_channels(pixi_config, distro)
-    _ensure_dependencies(pixi_config, packages, distro)
+    _ensure_dependencies(pixi_config, packages, distro, platforms)
     _ensure_tasks(pixi_config)
     _ensure_activation(pixi_config)
 
@@ -232,7 +237,9 @@ def _display_dependencies(packages, distro: str):
         console.print("")
 
 
-def _ensure_workspace_section(config: dict, workspace_path: Path):
+def _ensure_workspace_section(
+    config: dict, workspace_path: Path, platforms: list[str] | None = None
+):
     """Ensure workspace section exists with basic config."""
     if "workspace" not in config:
         config["workspace"] = {}
@@ -247,11 +254,27 @@ def _ensure_workspace_section(config: dict, workspace_path: Path):
     if "channels" not in workspace:
         workspace["channels"] = []
 
-    # Set platforms if not present
+    # Set or extend platforms
     if "platforms" not in workspace:
-        # Only add the current platform by default
-        current_platform = str(Platform.current())
-        workspace["platforms"] = [current_platform]
+        if platforms:
+            # Platforms are already in pixi format (linux-64, osx-64, etc.)
+            workspace["platforms"] = platforms
+        else:
+            # Only add the current platform by default
+            current_platform = str(Platform.current())
+            workspace["platforms"] = [current_platform]
+    elif platforms:
+        # Extend existing platforms list with new ones (avoiding duplicates)
+        existing_platforms = workspace["platforms"]
+        if not isinstance(existing_platforms, list):
+            existing_platforms = [existing_platforms]
+
+        # Add new platforms that aren't already in the list
+        for platform in platforms:
+            if platform not in existing_platforms:
+                existing_platforms.append(platform)
+
+        workspace["platforms"] = existing_platforms
 
 
 def _ensure_channels(config: dict, distro: str):
@@ -326,8 +349,19 @@ def _check_package_availability(
     return availability
 
 
-def _ensure_dependencies(config: dict, packages, distro: str):
-    """Ensure all ROS dependencies are present with comments showing source."""
+def _ensure_dependencies(
+    config: dict, packages, distro: str, platforms: list[str] | None = None
+):
+    """
+    Ensure all ROS dependencies are present with comments showing source.
+
+    Generates platform-specific dependencies if multiple platforms are specified.
+    Common dependencies (available on all platforms) go in [dependencies],
+    platform-specific ones go in [target.{platform}.dependencies].
+    """
+    # Default to current platform if none specified
+    if not platforms:
+        platforms = [str(Platform.current())]
     # Track which packages depend on which conda packages
     # conda_dep -> set of package names
     dep_sources: dict[str, set[str]] = {}
@@ -343,48 +377,117 @@ def _ensure_dependencies(config: dict, packages, distro: str):
         if cmake_version:
             dep_versions["cmake"] = cmake_version
 
-    # Collect dependencies from each package
-    for pkg in packages:
-        for ros_dep in pkg.get_all_dependencies():
-            # Skip workspace packages (they're built locally)
+        # Collect version constraints from package.xml
+        for ros_dep, version_constraint in pkg.dependency_versions.items():
+            # Skip workspace packages
             if ros_dep in workspace_pkg_names:
                 continue
 
-            # Map to conda packages
+            # Map ROS package to conda packages
+            # Note: We use the first platform for mapping since version constraints
+            # should be the same across platforms for a given ROS package
             conda_packages = map_ros_to_conda(ros_dep, distro)
 
-            # Skip if no conda packages were returned
-            if not conda_packages:
-                continue
-
+            # Apply version constraint to all mapped conda packages
             for conda_dep in conda_packages:
-                if conda_dep:
-                    if conda_dep not in dep_sources:
-                        dep_sources[conda_dep] = set()
-                    dep_sources[conda_dep].add(pkg.name)
-
-    # Expand GL requirements (REQUIRE_GL, REQUIRE_OPENGL) to platform-specific packages
-    # This replaces placeholder strings with actual conda packages
-    expanded_dep_sources: dict[str, set[str]] = {}
-    all_conda_packages = list(dep_sources.keys())
-    expanded_packages = expand_gl_requirements(all_conda_packages)
-
-    # Rebuild dep_sources with expanded packages
-    for expanded_pkg in expanded_packages:
-        # For expanded packages, merge the sources from the placeholder packages
-        sources = set()
-        for original_pkg, pkg_sources in dep_sources.items():
-            if original_pkg == expanded_pkg:
-                # Direct match
-                sources.update(pkg_sources)
-            elif original_pkg in ("REQUIRE_GL", "REQUIRE_OPENGL"):
-                # This was a placeholder, include its sources for all expanded packages
-                sources.update(pkg_sources)
-
-        if sources:
-            expanded_dep_sources[expanded_pkg] = sources
-
-    dep_sources = expanded_dep_sources
+                if conda_dep and not conda_dep.startswith("REQUIRE_"):
+                    # If package already has a constraint, combine them
+                    if conda_dep in dep_versions:
+                        dep_versions[conda_dep] = (
+                            f"{dep_versions[conda_dep]},{version_constraint}"
+                        )
+                    else:
+                        dep_versions[conda_dep] = version_constraint
+
+    # Platforms come from CLI as pixi platform names (linux-64, osx-64, etc.)
+    # Map them to mapping platform names for querying the mapping files
+    pixi_to_mapping = {
+        "linux-64": "linux",
+        "osx-64": "osx",
+        "osx-arm64": "osx",
+        "win-64": "win64",
+    }
+
+    # Group pixi platforms by their mapping platform
+    # This way osx-64 and osx-arm64 share the same dependencies
+    platform_groups = {}
+    for platform in platforms:
+        mapping_platform = pixi_to_mapping.get(platform, "linux")
+        if mapping_platform not in platform_groups:
+            platform_groups[mapping_platform] = []
+        platform_groups[mapping_platform].append(platform)
+
+    # Collect dependencies per mapping platform (which groups similar pixi platforms)
+    # Structure: mapping_platform -> conda_dep -> set of ROS package names
+    platform_deps: dict[str, dict[str, set[str]]] = {
+        mapping_platform: {} for mapping_platform in platform_groups.keys()
+    }
+
+    # Collect dependencies from each package, mapped for each platform
+    for mapping_platform in platform_groups.keys():
+        for pkg in packages:
+            for ros_dep in pkg.get_all_dependencies():
+                # Skip workspace packages (they're built locally)
+                if ros_dep in workspace_pkg_names:
+                    continue
+
+                # Map to conda packages for this mapping platform
+                conda_packages = map_ros_to_conda(
+                    ros_dep, distro, platform_override=mapping_platform
+                )
+
+                # Skip if no conda packages were returned
+                if not conda_packages:
+                    continue
+
+                for conda_dep in conda_packages:
+                    if conda_dep:
+                        if conda_dep not in platform_deps[mapping_platform]:
+                            platform_deps[mapping_platform][conda_dep] = set()
+                        platform_deps[mapping_platform][conda_dep].add(pkg.name)
+
+        # Expand GL requirements for this mapping platform
+        all_conda_packages = list(platform_deps[mapping_platform].keys())
+        expanded_packages = expand_gl_requirements(
+            all_conda_packages, platform_override=mapping_platform
+        )
+
+        # Rebuild platform deps with expanded packages
+        expanded_platform_deps: dict[str, set[str]] = {}
+        for expanded_pkg in expanded_packages:
+            sources = set()
+            for original_pkg, pkg_sources in platform_deps[mapping_platform].items():
+                if original_pkg == expanded_pkg:
+                    sources.update(pkg_sources)
+                elif original_pkg in ("REQUIRE_GL", "REQUIRE_OPENGL"):
+                    sources.update(pkg_sources)
+
+            if sources:
+                expanded_platform_deps[expanded_pkg] = sources
+
+        platform_deps[mapping_platform] = expanded_platform_deps
+
+    # Determine common dependencies (present in all mapping platforms)
+    mapping_platform_list = list(platform_groups.keys())
+    if len(mapping_platform_list) > 1:
+        all_deps = set(platform_deps[mapping_platform_list[0]].keys())
+        for mapping_platform in mapping_platform_list[1:]:
+            all_deps &= set(platform_deps[mapping_platform].keys())
+        common_deps = all_deps
+    else:
+        # Single mapping platform - all deps are "common"
+        common_deps = set(platform_deps[mapping_platform_list[0]].keys())
+
+    # For backwards compatibility when single platform, use old behavior
+    dep_sources = (
+        platform_deps[mapping_platform_list[0]]
+        if len(mapping_platform_list) == 1
+        else {
+            dep: platform_deps[mapping_platform_list[0]][dep]
+            for dep in common_deps
+            if dep in platform_deps[mapping_platform_list[0]]
+        }
+    )
 
     # Create or get dependencies table
     if "dependencies" not in config:
@@ -426,51 +529,52 @@ def _ensure_dependencies(config: dict, packages, distro: str):
         dependencies["cmake"] = dep_versions["cmake"]
 
     # Add package dependencies
+    channels = config.get("workspace", {}).get("channels", [])
+
+    # Add common dependencies (available on all platforms)
     if dep_sources:
         dependencies.add(tomlkit.nl())
-        dependencies.add(tomlkit.comment("Workspace dependencies"))
+        if len(mapping_platform_list) > 1:
+            dependencies.add(
+                tomlkit.comment("Workspace dependencies (common across platforms)")
+            )
+        else:
+            dependencies.add(tomlkit.comment("Workspace dependencies"))
 
-        # Get channels and platform for availability checking
-        channels = config.get("workspace", {}).get("channels", [])
-        current_platform = Platform.current()
+        # For common deps, check on first pixi platform as representative
+        first_pixi_platform = platforms[0]
+        first_platform = Platform(first_pixi_platform)
 
-        # Get list of packages to check
         packages_to_check = [
             conda_dep
             for conda_dep in dep_sources.keys()
             if conda_dep not in dependencies
         ]
 
-        # Check package availability if channels are configured
         availability = {}
         if channels and packages_to_check:
-            typer.echo("Checking package availability in channels...")
+            typer.echo(
+                f"Checking common package availability for {first_pixi_platform}..."
+            )
             availability = _check_package_availability(
-                packages_to_check, channels, current_platform
+                packages_to_check, channels, first_platform
             )
 
-        # Add all dependencies in alphabetical order
         available_packages = []
         unavailable_packages = []
 
         for conda_dep in sorted(dep_sources.keys()):
             if conda_dep not in dependencies:
-                # Check if we have availability info
-                is_available = availability.get(
-                    conda_dep, True
-                )  # Default to True if not checked
-
+                is_available = availability.get(conda_dep, True)
                 if is_available:
                     available_packages.append(conda_dep)
                 else:
                     unavailable_packages.append(conda_dep)
 
-        # Add available packages
         for conda_dep in available_packages:
             version = dep_versions.get(conda_dep, "*")
             dependencies[conda_dep] = version
 
-        # Add unavailable packages as comments
         if unavailable_packages:
             dependencies.add(tomlkit.nl())
             dependencies.add(
@@ -486,6 +590,159 @@ def _ensure_dependencies(config: dict, packages, distro: str):
 
     config["dependencies"] = dependencies
 
+    # Add platform-specific dependencies if multiple mapping platforms
+    # First, identify unix dependencies (available on both linux and osx, but not win)
+    unix_deps = {}
+    if len(mapping_platform_list) > 1:
+        has_linux = "linux" in mapping_platform_list
+        has_osx = "osx" in mapping_platform_list
+        has_win = "win64" in mapping_platform_list or "win" in mapping_platform_list
+
+        if has_linux and has_osx:
+            # Find deps that are on both linux and osx
+            linux_only = set(platform_deps.get("linux", {}).keys())
+            osx_only = set(platform_deps.get("osx", {}).keys())
+            unix_candidates = (linux_only & osx_only) - common_deps
+
+            # If we also have windows, only move to unix if NOT on windows
+            if has_win:
+                win_deps = set(platform_deps.get("win64", {}).keys()) | set(
+                    platform_deps.get("win", {}).keys()
+                )
+                unix_deps_keys = unix_candidates - win_deps
+            else:
+                unix_deps_keys = unix_candidates
+
+            # Move to unix section
+            for dep in unix_deps_keys:
+                if dep in platform_deps.get("linux", {}):
+                    unix_deps[dep] = platform_deps["linux"][dep]
+
+        # Add unix section if there are unix-specific dependencies
+        if unix_deps:
+            if "target" not in config:
+                config["target"] = tomlkit.table()
+            if "unix" not in config["target"]:
+                config["target"]["unix"] = tomlkit.table()
+            if "dependencies" not in config["target"]["unix"]:
+                config["target"]["unix"]["dependencies"] = tomlkit.table()
+
+            target_deps = config["target"]["unix"]["dependencies"]
+
+            if len(target_deps) == 0:
+                target_deps.add(
+                    tomlkit.comment("Unix-specific dependencies (Linux and macOS)")
+                )
+
+            # Check availability on linux platform as representative
+            representative_pixi_platform = platform_groups.get(
+                "linux", platform_groups.get("osx", platforms)
+            )[0]
+            platform_obj = Platform(representative_pixi_platform)
+            packages_to_check = list(unix_deps.keys())
+
+            availability = {}
+            if channels and packages_to_check:
+                typer.echo("Checking package availability for unix...")
+                availability = _check_package_availability(
+                    packages_to_check, channels, platform_obj
+                )
+
+            available_packages = []
+            unavailable_packages = []
+
+            for conda_dep in sorted(unix_deps.keys()):
+                if conda_dep not in target_deps:
+                    is_available = availability.get(conda_dep, True)
+                    if is_available:
+                        available_packages.append(conda_dep)
+                    else:
+                        unavailable_packages.append(conda_dep)
+
+            for conda_dep in available_packages:
+                version = dep_versions.get(conda_dep, "*")
+                target_deps[conda_dep] = version
+
+            if unavailable_packages:
+                target_deps.add(tomlkit.nl())
+                target_deps.add(
+                    tomlkit.comment("The following packages were not found:")
+                )
+                for conda_dep in unavailable_packages:
+                    version = dep_versions.get(conda_dep, "*")
+                    target_deps.add(
+                        tomlkit.comment(f'{conda_dep} = "{version}"  # NOT FOUND')
+                    )
+
+    # Now add remaining platform-specific dependencies (not in common, not in unix)
+    if len(mapping_platform_list) > 1:
+        for mapping_platform in mapping_platform_list:
+            platform_specific_deps = {
+                dep: sources
+                for dep, sources in platform_deps[mapping_platform].items()
+                if dep not in common_deps and dep not in unix_deps
+            }
+
+            if platform_specific_deps:
+                # Create target section if needed
+                if "target" not in config:
+                    config["target"] = tomlkit.table()
+                if mapping_platform not in config["target"]:
+                    config["target"][mapping_platform] = tomlkit.table()
+                if "dependencies" not in config["target"][mapping_platform]:
+                    config["target"][mapping_platform]["dependencies"] = tomlkit.table()
+
+                target_deps = config["target"][mapping_platform]["dependencies"]
+
+                # Add comment
+                if len(target_deps) == 0:
+                    target_deps.add(
+                        tomlkit.comment(
+                            f"Platform-specific dependencies for {mapping_platform}"
+                        )
+                    )
+
+                # Check availability for this mapping platform
+                # Use the first pixi platform in the group as representative
+                representative_pixi_platform = platform_groups[mapping_platform][0]
+                platform_obj = Platform(representative_pixi_platform)
+                packages_to_check = list(platform_specific_deps.keys())
+
+                availability = {}
+                if channels and packages_to_check:
+                    typer.echo(
+                        f"Checking package availability for {mapping_platform}..."
+                    )
+                    availability = _check_package_availability(
+                        packages_to_check, channels, platform_obj
+                    )
+
+                available_packages = []
+                unavailable_packages = []
+
+                for conda_dep in sorted(platform_specific_deps.keys()):
+                    if conda_dep not in target_deps:
+                        is_available = availability.get(conda_dep, True)
+                        if is_available:
+                            available_packages.append(conda_dep)
+                        else:
+                            unavailable_packages.append(conda_dep)
+
+                for conda_dep in available_packages:
+                    version = dep_versions.get(conda_dep, "*")
+                    target_deps[conda_dep] = version
+
+                if unavailable_packages:
+                    target_deps.add(tomlkit.nl())
+                    target_deps.add(
+                        tomlkit.comment("The following packages were not found:")
+                    )
+                    for conda_dep in unavailable_packages:
+                        version = dep_versions.get(conda_dep, "*")
+                        target_deps.add(
+                            tomlkit.comment(f'{conda_dep} = "{version}"  # NOT FOUND')
+                        )
+
 
 def _ensure_tasks(config: dict):
     """Ensure common ROS tasks are defined."""
@@ -493,14 +750,27 @@ def _ensure_tasks(config: dict):
 
     # Define common ROS tasks if not present
     default_tasks = {
-        "build": "colcon build",
-        "test": "colcon test",
-        "clean": "rm -rf build install log",
+        "build": {
+            "cmd": "colcon build",
+            "description": "Build the ROS workspace",
+        },
+        "test": {
+            "cmd": "colcon test",
+            "description": "Run tests for the workspace",
+        },
+        "clean": {
+            "cmd": "rm -rf build install log",
+            "description": "Clean build artifacts (build, install, log directories)",
+        },
     }
 
-    for task_name, task_cmd in default_tasks.items():
+    for task_name, task_config in default_tasks.items():
         if task_name not in tasks:
-            tasks[task_name] = task_cmd
+            # Create inline table for task configuration
+            task_table = tomlkit.inline_table()
+            task_table["cmd"] = task_config["cmd"]
+            task_table["description"] = task_config["description"]
+            tasks[task_name] = task_table
 
     config["tasks"] = tasks
 

pixi_ros/mappings.py

@@ -255,6 +255,45 @@ def is_system_package(package_name: str) -> bool:
     return package_name in system_packages
 
 
+def get_platforms() -> list[str]:
+    """
+    Get list of supported pixi platforms based on mapping files.
+
+    Extracts platform names from the mapping data and converts them to
+    standard pixi platform names.
+
+    Mapping files use: linux, osx, win64
+    Pixi uses: linux-64, osx-64, osx-arm64, win-64
+
+    Returns:
+        List of pixi platform names
+    """
+    mappings = get_mappings()
+    mapping_platforms = set()
+
+    # Iterate through mappings to find all platform keys
+    for package_mappings in mappings.values():
+        for channel_mapping in package_mappings.values():
+            if isinstance(channel_mapping, dict):
+                # This is a platform-specific mapping
+                mapping_platforms.update(channel_mapping.keys())
+
+    # Convert mapping platforms to pixi platforms
+    pixi_platforms = []
+    if "linux" in mapping_platforms:
+        pixi_platforms.append("linux-64")
+    if "osx" in mapping_platforms:
+        pixi_platforms.extend(["osx-64", "osx-arm64"])
+    if "win64" in mapping_platforms or "win" in mapping_platforms:
+        pixi_platforms.append("win-64")
+
+    return (
+        pixi_platforms
+        if pixi_platforms
+        else ["linux-64", "osx-64", "osx-arm64", "win-64"]
+    )
+
+
 def get_ros_distros() -> list[str]:
     """
     Get list of supported ROS distributions.

pixi_ros/package_xml.py

@@ -33,6 +33,11 @@ class PackageXML:
     # Generic depends (shorthand for build, export, and exec)
     depends: list[str] = field(default_factory=list)
 
+    # Version constraints for dependencies
+    # Maps package name to version constraint string
+    # (e.g., ">=3.12.4", ">=1.8.0,<2.0.0")
+    dependency_versions: dict[str, str] = field(default_factory=dict)
+
     @classmethod
     def from_file(cls, path: Path) -> "PackageXML":
         """
@@ -90,6 +95,36 @@ class PackageXML:
                 build_type = build_type_elem.text
 
         # Extract dependencies
+        def parse_version_constraint(elem) -> str | None:
+            """
+            Parse version constraint attributes from a dependency element.
+
+            Converts ROS package.xml version attributes to conda/pixi constraint syntax:
+            - version_lt="X" → <X
+            - version_lte="X" → <=X
+            - version_eq="X" → ==X
+            - version_gte="X" → >=X
+            - version_gt="X" → >X
+
+            Multiple constraints are combined with commas.
+            """
+            constraints = []
+
+            version_attrs = [
+                ("version_lt", "<"),
+                ("version_lte", "<="),
+                ("version_eq", "=="),
+                ("version_gte", ">="),
+                ("version_gt", ">"),
+            ]
+
+            for attr, op in version_attrs:
+                value = elem.get(attr)
+                if value:
+                    constraints.append(f"{op}{value}")
+
+            return ",".join(constraints) if constraints else None
+
         def get_deps(tag: str) -> list[str]:
             """Extract all dependencies with the given tag."""
             deps = []
@@ -98,16 +133,41 @@ class PackageXML:
                     deps.append(elem.text.strip())
             return deps
 
-        # Parse all dependency types
-        buildtool_depends = get_deps("buildtool_depend")
-        build_depends = get_deps("build_depend")
-        build_export_depends = get_deps("build_export_depend")
-        exec_depends = get_deps("exec_depend")
-        test_depends = get_deps("test_depend")
-        depends = get_deps("depend")
+        def get_deps_with_versions(tag: str, version_map: dict[str, str]) -> list[str]:
+            """Extract dependencies and populate version constraints."""
+            deps = []
+            for elem in root.findall(tag):
+                if elem.text:
+                    pkg_name = elem.text.strip()
+                    deps.append(pkg_name)
+
+                    # Parse version constraint if present
+                    constraint = parse_version_constraint(elem)
+                    if constraint:
+                        # If package already has a constraint, combine them
+                        if pkg_name in version_map:
+                            version_map[pkg_name] = (
+                                f"{version_map[pkg_name]},{constraint}"
+                            )
+                        else:
+                            version_map[pkg_name] = constraint
+            return deps
+
+        # Parse all dependency types and collect version constraints
+        dependency_versions: dict[str, str] = {}
+        buildtool_depends = get_deps_with_versions(
+            "buildtool_depend", dependency_versions
+        )
+        build_depends = get_deps_with_versions("build_depend", dependency_versions)
+        build_export_depends = get_deps_with_versions(
+            "build_export_depend", dependency_versions
+        )
+        exec_depends = get_deps_with_versions("exec_depend", dependency_versions)
+        test_depends = get_deps_with_versions("test_depend", dependency_versions)
+        depends = get_deps_with_versions("depend", dependency_versions)
 
         # Format 2 compatibility
-        run_depends = get_deps("run_depend")
+        run_depends = get_deps_with_versions("run_depend", dependency_versions)
 
         return cls(
             name=name_elem.text.strip(),
@@ -126,6 +186,7 @@ class PackageXML:
             test_depends=test_depends,
             run_depends=run_depends,
             depends=depends,
+            dependency_versions=dependency_versions,
         )
 
     def get_all_build_dependencies(self) -> list[str]:

{pixi_ros-0.1.2.dist-info → pixi_ros-0.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pixi-ros
-Version: 0.1.2
+Version: 0.3.0
 Summary: Pixi extension for ROS package management
 Project-URL: Homepage, https://github.com/ruben-arts/pixi-ros
 Project-URL: Repository, https://github.com/ruben-arts/pixi-ros
@@ -90,13 +90,16 @@ pixi shell
 
 ### Dependency Mapping
 
-`pixi-ros` reads all dependency types from `package.xml` files. 
+`pixi-ros` reads all dependency types from `package.xml` files.
 It then does a best effort mapping of ROS package names to conda packages.
 
 - **ROS packages**: `ros-{distro}-{package}` from robostack channels (e.g., `ros-humble-rclcpp`)
 - **System packages**: Mapped to conda-forge equivalents (e.g., `cmake`, `eigen`)
+- **Platform-specific packages**: Different mappings per platform (e.g., OpenGL → `libgl-devel` on Linux, X11 packages on macOS)
 
-After the mapping, it validates package availability in the configured channels. This starts a connection with `https://prefix.dev` to check if packages exist.
+The mapping rules are defined in YAML files (see `src/pixi_ros/data/conda-forge.yaml`) and can be customized by placing your own mapping files in `pixi-ros/*.yaml` or `~/.pixi-ros/*.yaml`.
+
+After the mapping, it validates package availability in the configured channels for each target platform. This starts a connection with `https://prefix.dev` to check if packages exist.
 
 ### Example
 
@@ -117,6 +120,41 @@ ros-humble-rclcpp = "*"
 ros-humble-std-msgs = "*"
 ```
 
+### Version Constraints
+
+`pixi-ros` supports version constraints from `package.xml` files and automatically applies them to the generated `pixi.toml`.
+
+#### Supported Version Attributes
+
+You can specify version requirements in your `package.xml` using standard ROS version attributes:
+
+| package.xml attribute | pixi.toml constraint | Description |
+|----------------------|----------------------|-------------|
+| `version_eq="X.Y.Z"` | `==X.Y.Z` | Exactly version X.Y.Z |
+| `version_gte="X.Y.Z"` | `>=X.Y.Z` | Version X.Y.Z or newer |
+| `version_gt="X.Y.Z"` | `>X.Y.Z` | Newer than version X.Y.Z |
+| `version_lte="X.Y.Z"` | `<=X.Y.Z` | Version X.Y.Z or older |
+| `version_lt="X.Y.Z"` | `<X.Y.Z` | Older than version X.Y.Z |
+
+Multiple constraints can be combined on the same dependency and will be joined with commas in the output.
+
+Given a `package.xml` with version constraints:
+
+```xml
+<depend version_gte="3.12.4">cmake</depend>
+<build_depend version_gte="3.3.0" version_lt="4.0.0">eigen</build_depend>
+<exec_depend version_eq="1.2.3">boost</exec_depend>
+```
+
+`pixi-ros init` generates:
+
+```toml
+[dependencies]
+cmake = ">=3.12.4"
+eigen = ">=3.3.0,<4.0.0"
+boost = "==1.2.3"
+```
+
 ## Supported ROS Distributions
 
 - ROS 2 Humble: https://prefix.dev/robostack-humble
@@ -132,24 +170,102 @@ Initialize or update a ROS workspace's `pixi.toml`.
 
 ```bash
 pixi-ros init --distro <ros_distro>
+pixi-ros init --distro humble --platform linux-64 --platform osx-arm64
 pixi-ros init
 ```
 
 **Options:**
-- `--distro`, `-d`: ROS distribution (optional)
+- `--distro`, `-d`: ROS distribution (optional, will prompt if not provided)
+- `--platform`, `-p`: Target platforms (optional, can be specified multiple times, will prompt if not provided)
+  - Available: `linux-64`, `osx-64`, `osx-arm64`, `win-64`
+  - Platforms come from the mapping files and determine which dependencies are available
 
 **What it does:**
 - Scans workspace for `package.xml` files
-- Reads all dependency types (build, exec, test)
-- Maps ROS dependencies to conda packages
+- Reads all dependency types (build, exec, test) and version constraints
+- Maps ROS dependencies to conda packages for each platform
+- Applies version constraints from package.xml to pixi.toml dependencies
 - Configures robostack channels
-- Checks package availability
+- Checks package availability per platform
 - Creates build tasks using colcon
 - Generates helpful `README_PIXI.md`
+- Sets up platform-specific dependencies in `pixi.toml`
 
 **Running multiple times:**
 The command is idempotent - you can run it multiple times to update dependencies as your workspace changes.
 
+## Multi-Platform Support
+
+`pixi-ros` supports generating cross-platform configurations. When you specify multiple platforms, it:
+
+1. **Analyzes dependencies per platform**: Some packages have platform-specific mappings (e.g., OpenGL requirements differ between Linux and macOS)
+
+2. **Organizes dependencies intelligently**:
+   - **Common dependencies** (available on all platforms) → `[dependencies]`
+   - **Unix dependencies** (available on Linux and macOS, but not Windows) → `[target.unix.dependencies]`
+   - **Platform-specific dependencies** → `[target.linux.dependencies]`, `[target.osx.dependencies]`, etc.
+
+3. **Sets up correct platform list**: The `[workspace]` section gets the appropriate pixi platform names
+
+### Platform Naming
+
+pixi-ros uses standard pixi platform names:
+- `linux-64` - Linux x86_64
+- `osx-64` - macOS Intel
+- `osx-arm64` - macOS Apple Silicon (M1/M2/M3)
+- `win-64` - Windows x86_64
+
+Internally, mapping files use a simplified format (`linux`, `osx`, `win64`), but this is transparent to users. When you specify `osx-64` and `osx-arm64`, they both use the same `osx` mapping rules since package availability is typically the same for both architectures.
+
+### Example: Multi-Platform Setup
+
+```bash
+pixi-ros init --distro humble --platform linux-64 --platform osx-arm64
+```
+
+Generates:
+
+```toml
+[workspace]
+name = "my_workspace"
+channels = [
+    "https://prefix.dev/robostack-humble",
+    "https://prefix.dev/conda-forge",
+]
+platforms = ["linux-64", "osx-arm64"]
+
+[dependencies]
+# Common dependencies (available on all platforms)
+ros-humble-rclcpp = "*"
+ros-humble-std-msgs = "*"
+
+[target.unix.dependencies]
+# Unix-specific dependencies (Linux and macOS)
+xorg-libx11 = "*"
+xorg-libxext = "*"
+
+[target.linux.dependencies]
+# Linux-specific dependencies
+libgl-devel = "*"
+libopengl-devel = "*"
+```
+
+### Interactive Platform Selection
+
+If you don't specify platforms, you'll be prompted:
+
+```bash
+$ pixi-ros init --distro humble
+
+Available target platforms:
+  1. linux-64
+  2. osx-64
+  3. osx-arm64
+  4. win-64
+
+Select platforms (enter numbers or names, comma or space separated): 1 3
+```
+
 ## Philosophy
 
 `pixi-ros` aims to be a quick **gateway drug**. It:

pixi_ros-0.3.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+pixi_ros/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pixi_ros/cli.py,sha256=85lRSSsnSWAxqhkwjT0OiObYdTu84YBJXO576k0fOlY,4351
+pixi_ros/config.py,sha256=JevtFXh96UJj7aMUWp18J1xcPeQPoLzh3hdiu5uPR0s,834
+pixi_ros/init.py,sha256=wX7VqJFuh0q3OGNZ7_BLVM3BYyTdbI7_BhzHJfJJLIw,30835
+pixi_ros/mappings.py,sha256=AlXT_VsPV7KeEQxHkbBrnc79LXwizrCk7oG9-fYX5MI,10376
+pixi_ros/package_xml.py,sha256=XnDkKuccSar1ndmvACZMZ7c2yUNXz7CcfQRwluZolqQ,8815
+pixi_ros/utils.py,sha256=uGgB8CYiM_3KfBtqvUKqkEXXTffv8FkkaIC230peHUY,2026
+pixi_ros/workspace.py,sha256=N5Aqcl77J8aLrEDr4T-XR9V5fBjZ1KQHXd4dkbgX8HU,6838
+pixi_ros/data/README.md,sha256=Tdc2sTUuvoyEaHYlmM_C1pf3qr0o0P5Lu2ZUQ88tUjI,1602
+pixi_ros/data/README_PIXI.md.template,sha256=q7g65oHmrEqKTtqOT7lgX6l9RI69w64B0DCLwhf8ocM,3076
+pixi_ros/data/conda-forge.yaml,sha256=DeMfdzEuFCFXLmceV6ENmGpSBo6tMZh-Gx-ZkEAakT8,18941
+pixi_ros-0.3.0.dist-info/METADATA,sha256=fDBOMPyY5DSt4N87s-pugMV0JVCmOOdDU76x8HyND0M,10714
+pixi_ros-0.3.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+pixi_ros-0.3.0.dist-info/entry_points.txt,sha256=DpBwU4Djcej8gT42q8Ccuv-R9pdmGHyFV5p57_ogqfQ,47
+pixi_ros-0.3.0.dist-info/licenses/LICENSE,sha256=pAZXnNE2dxxwXFIduGyn1gpvPefJtUYOYZOi3yeGG94,1068
+pixi_ros-0.3.0.dist-info/RECORD,,

pixi_ros-0.1.2.dist-info/RECORD

@@ -1,16 +0,0 @@
-pixi_ros/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pixi_ros/cli.py,sha256=eLT1GNfq3JY8yzJrxDkNjeUtKI5T8T_57XaDMw_XX-s,2145
-pixi_ros/config.py,sha256=JevtFXh96UJj7aMUWp18J1xcPeQPoLzh3hdiu5uPR0s,834
-pixi_ros/init.py,sha256=Y4k2y_NZOwt0UQ4VMOIWr3Eyg3i2IPU83xtQPd1uW2U,19107
-pixi_ros/mappings.py,sha256=WCo1ftPe8knJROy2NyLuPtk0R-zDGWTgCcQnGp5LkFA,9139
-pixi_ros/package_xml.py,sha256=a1_zJVc73eMOt67BIk2ITnxLPN1RIUOs0oL42q6CLvI,6279
-pixi_ros/utils.py,sha256=uGgB8CYiM_3KfBtqvUKqkEXXTffv8FkkaIC230peHUY,2026
-pixi_ros/workspace.py,sha256=N5Aqcl77J8aLrEDr4T-XR9V5fBjZ1KQHXd4dkbgX8HU,6838
-pixi_ros/data/README.md,sha256=Tdc2sTUuvoyEaHYlmM_C1pf3qr0o0P5Lu2ZUQ88tUjI,1602
-pixi_ros/data/README_PIXI.md.template,sha256=q7g65oHmrEqKTtqOT7lgX6l9RI69w64B0DCLwhf8ocM,3076
-pixi_ros/data/conda-forge.yaml,sha256=O3r31jNNU-lPCgvFlmhytTp_R1UMgIBRwDaeSebI7wI,18900
-pixi_ros-0.1.2.dist-info/METADATA,sha256=tLDuzO87xAZwkHWeSqMyj8IC2hIxXn3q1BeYZM2Dxfs,6521
-pixi_ros-0.1.2.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-pixi_ros-0.1.2.dist-info/entry_points.txt,sha256=DpBwU4Djcej8gT42q8Ccuv-R9pdmGHyFV5p57_ogqfQ,47
-pixi_ros-0.1.2.dist-info/licenses/LICENSE,sha256=pAZXnNE2dxxwXFIduGyn1gpvPefJtUYOYZOi3yeGG94,1068
-pixi_ros-0.1.2.dist-info/RECORD,,