pixi-ros 0.1.0__py3-none-any.whl → 0.2.0__py3-none-any.whl

pixi_ros/__init__.py

@@ -1,3 +0,0 @@
-"""Pixi-ROS: A Pixi extension for ROS package management."""
-
-__version__ = "0.1.0"

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,14 @@ 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 +58,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 +73,56 @@ 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}. Please choose 1-{len(available_platforms)}",
+                        err=True,
+                    )
+                    raise typer.Exit(code=1)
+            except ValueError:
+                # 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)
+
+        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/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,15 @@ def _ensure_workspace_section(config: dict, workspace_path: Path):
     if "channels" not in workspace:
         workspace["channels"] = []
 
-    # Set platforms if not present
-    if "platforms" not in workspace:
-        # Only add the current platform by default
-        current_platform = str(Platform.current())
-        workspace["platforms"] = [current_platform]
+    # Set platforms if not present or if platforms were provided
+    if "platforms" not in workspace or platforms:
+        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]
 
 
 def _ensure_channels(config: dict, distro: str):
@@ -326,8 +337,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 +365,91 @@ 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)
-            if ros_dep in workspace_pkg_names:
-                continue
+    # 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",
+    }
 
-            # Map to conda packages
-            conda_packages = map_ros_to_conda(ros_dep, distro)
+    # 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()
+    }
 
-            # Skip if no conda packages were returned
-            if not conda_packages:
-                continue
+    # 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
+        )
 
-            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
+        # 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 +491,48 @@ 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 +548,151 @@ 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."""

pixi_ros/mappings.py

@@ -255,6 +255,41 @@ 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-0.1.0.dist-info → pixi_ros-0.2.0.dist-info}/METADATA

@@ -1,10 +1,12 @@
 Metadata-Version: 2.4
 Name: pixi-ros
-Version: 0.1.0
+Version: 0.2.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
 Author-email: Ruben Arts <ruben@prefix.dev>
+License-Expression: MIT
+License-File: LICENSE
 Requires-Python: >=3.10
 Requires-Dist: lxml>=5.0.0
 Requires-Dist: pathspec>=0.11.0
@@ -88,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
 
@@ -130,24 +135,101 @@ 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
+- Maps ROS dependencies to conda packages for each platform
 - 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.2.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+pixi_ros/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pixi_ros/cli.py,sha256=ifctksMHxa6NlCimnnovYe7HEz-0YUcZ-UHvVPiZCc0,4337
+pixi_ros/config.py,sha256=JevtFXh96UJj7aMUWp18J1xcPeQPoLzh3hdiu5uPR0s,834
+pixi_ros/init.py,sha256=oqpgt-yEywDxQ410kpka5VTsmHalTHxoUyBrCMEj5YA,28507
+pixi_ros/mappings.py,sha256=3wr4uPlGBtc8BO-06RZEpZZzxkiGxd9zxNfV3OzAoxI,10344
+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.2.0.dist-info/METADATA,sha256=H3IAkgh95uynWynNrOZrXGn6GzOZaYj41yMMlAdakT0,9436
+pixi_ros-0.2.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+pixi_ros-0.2.0.dist-info/entry_points.txt,sha256=DpBwU4Djcej8gT42q8Ccuv-R9pdmGHyFV5p57_ogqfQ,47
+pixi_ros-0.2.0.dist-info/licenses/LICENSE,sha256=pAZXnNE2dxxwXFIduGyn1gpvPefJtUYOYZOi3yeGG94,1068
+pixi_ros-0.2.0.dist-info/RECORD,,

pixi_ros-0.2.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) [year] [fullname]
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pixi_ros-0.1.0.dist-info/RECORD

@@ -1,15 +0,0 @@
-pixi_ros/__init__.py,sha256=ovhhu7PJry3WtvhA2PgelrFWnWvrQkQKD798sW9GWjs,84
-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.0.dist-info/METADATA,sha256=L1MyvMRZKUZxx90hlCNgur5k9VDQy3_PBhfJtN2PWVw,6475
-pixi_ros-0.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-pixi_ros-0.1.0.dist-info/entry_points.txt,sha256=DpBwU4Djcej8gT42q8Ccuv-R9pdmGHyFV5p57_ogqfQ,47
-pixi_ros-0.1.0.dist-info/RECORD,,