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

pixi_ros/init.py

@@ -4,14 +4,19 @@ from pathlib import Path
 
 import tomlkit
 import typer
-from rattler import Channel, Gateway, Platform
+from rattler import Platform
 from rich.console import Console
 from rich.panel import Panel
 from rich.table import Table
 from rich.text import Text
 
-from pixi_ros.mappings import expand_gl_requirements, map_ros_to_conda, validate_distro
+from pixi_ros.mappings import (
+    expand_gl_requirements,
+    get_mappings,
+    map_ros_to_conda,
+)
 from pixi_ros.utils import detect_cmake_version_requirement
+from pixi_ros.validator import PackageSource, RosDistroValidator
 from pixi_ros.workspace import discover_packages, find_workspace_root
 
 console = Console()
@@ -36,12 +41,6 @@ def init_workspace(
     Raises:
         typer.Exit: If validation fails or workspace not found
     """
-    # Validate distro
-    if not validate_distro(distro):
-        typer.echo(f"Error: Unsupported ROS distribution '{distro}'", err=True)
-        typer.echo("Supported distros: humble, iron, jazzy, rolling", err=True)
-        raise typer.Exit(code=1)
-
     # Find workspace root
     if workspace_path is None:
         workspace_path = find_workspace_root()
@@ -88,13 +87,32 @@ def init_workspace(
         typer.echo(f"Creating new {pixi_toml_path}")
         pixi_config = tomlkit.document()
 
+    # Create validator for package validation
+    validator = None
+    with console.status(
+        f"[cyan]Fetching ROS {distro} distribution index...[/cyan]",
+        spinner="dots",
+    ):
+        validator = RosDistroValidator(distro)
+
+    if validator._init_error:
+        typer.echo(
+            f"Warning: Could not initialize ROS distro validator: "
+            f"{validator._init_error}",
+            err=True,
+        )
+        typer.echo("Continuing with fallback package resolution...", err=True)
+        validator = None
+
     # Display discovered dependencies
-    _display_dependencies(packages, distro)
+    not_found_packages = _display_dependencies(packages, distro, validator)
 
     # Update configuration
     _ensure_workspace_section(pixi_config, workspace_path, platforms)
     _ensure_channels(pixi_config, distro)
-    _ensure_dependencies(pixi_config, packages, distro, platforms)
+    _ensure_dependencies(
+        pixi_config, packages, distro, platforms, validator, not_found_packages
+    )
     _ensure_tasks(pixi_config)
     _ensure_activation(pixi_config)
 
@@ -153,16 +171,97 @@ def init_workspace(
         raise typer.Exit(code=1) from e
 
 
-def _display_dependencies(packages, distro: str):
-    """Display discovered dependencies in a rich table."""
+def _display_dependencies(packages, distro: str, validator=None):
+    """Display discovered dependencies in a rich table.
+
+    Returns:
+        Dict of NOT_FOUND packages: {ros_package: (source_pkgs, conda_pkgs)}
+    """
     if not packages:
-        return
+        return {}
 
     workspace_pkg_names = {pkg.name for pkg in packages}
 
-    # Collect dependencies organized by ROS package and type
-    # Structure: {pkg_name: {dep_type: {ros_dep: [conda_packages]}}}
-    pkg_deps: dict[str, dict[str, dict[str, list[str]]]] = {}
+    # First, collect all unique dependencies to avoid duplicate validation
+    all_unique_deps: dict[str, set[str]] = {}  # {ros_dep: set of source packages}
+    # {ros_dep: set of dep types (Build/Runtime/Test)}
+    dep_types: dict[str, set[str]] = {}
+
+    for pkg in packages:
+        for ros_dep in pkg.get_all_build_dependencies():
+            if ros_dep not in workspace_pkg_names:
+                if ros_dep not in all_unique_deps:
+                    all_unique_deps[ros_dep] = set()
+                    dep_types[ros_dep] = set()
+                all_unique_deps[ros_dep].add(pkg.name)
+                dep_types[ros_dep].add("Build")
+
+        for ros_dep in pkg.get_all_runtime_dependencies():
+            if ros_dep not in workspace_pkg_names:
+                if ros_dep not in all_unique_deps:
+                    all_unique_deps[ros_dep] = set()
+                    dep_types[ros_dep] = set()
+                all_unique_deps[ros_dep].add(pkg.name)
+                dep_types[ros_dep].add("Runtime")
+
+        for ros_dep in pkg.get_all_test_dependencies():
+            if ros_dep not in workspace_pkg_names:
+                if ros_dep not in all_unique_deps:
+                    all_unique_deps[ros_dep] = set()
+                    dep_types[ros_dep] = set()
+                all_unique_deps[ros_dep].add(pkg.name)
+                dep_types[ros_dep].add("Test")
+
+    # Validate each unique dependency once
+    # {ros_dep: (conda_packages, source_label)}
+    validation_results: dict[str, tuple[list[str], str]] = {}
+    validation_stats = {
+        "workspace": 0,
+        "mapping": 0,
+        "ros_distro": 0,
+        "conda_forge": 0,
+        "not_found": 0,
+    }
+    not_found_packages: dict[str, tuple[set[str], list[str]]] = {}
+
+    for ros_dep, source_pkgs in all_unique_deps.items():
+        source_label = "Fallback"
+        if validator:
+            mappings = get_mappings()
+            result = validator.validate_package(
+                ros_dep, workspace_pkg_names, mappings, str(Platform.current())
+            )
+            if result.source == PackageSource.WORKSPACE:
+                validation_stats["workspace"] += 1
+                source_label = "[dim]Workspace[/dim]"
+            elif result.source == PackageSource.MAPPING:
+                validation_stats["mapping"] += 1
+                source_label = "[cyan]Mapping[/cyan]"
+            elif result.source == PackageSource.ROS_DISTRO:
+                validation_stats["ros_distro"] += 1
+                source_label = f"[green]ROS {distro}[/green]"
+            elif result.source == PackageSource.CONDA_FORGE:
+                validation_stats["conda_forge"] += 1
+                source_label = "[blue]conda-forge[/blue]"
+            elif result.source == PackageSource.NOT_FOUND:
+                validation_stats["not_found"] += 1
+                source_label = "[red]NOT FOUND[/red]"
+                # Track NOT_FOUND packages
+                not_found_packages[ros_dep] = (
+                    source_pkgs.copy(),
+                    result.conda_packages,
+                )
+
+        conda_packages = map_ros_to_conda(
+            ros_dep,
+            distro,
+            validator=validator,
+            workspace_packages=workspace_pkg_names,
+        )
+        validation_results[ros_dep] = (conda_packages, source_label)
+
+    # Now organize by package and type for display
+    pkg_deps: dict[str, dict[str, dict[str, tuple[list[str], str]]]] = {}
 
     for pkg in packages:
         pkg_deps[pkg.name] = {"Build": {}, "Runtime": {}, "Test": {}}
@@ -171,25 +270,37 @@ def _display_dependencies(packages, distro: str):
         for ros_dep in pkg.get_all_build_dependencies():
             if ros_dep in workspace_pkg_names:
                 continue
-            conda_packages = map_ros_to_conda(ros_dep, distro)
-            if conda_packages:
-                pkg_deps[pkg.name]["Build"][ros_dep] = conda_packages
+
+            if ros_dep in validation_results:
+                conda_packages, source_label = validation_results[ros_dep]
+                if conda_packages:
+                    pkg_deps[pkg.name]["Build"][ros_dep] = (
+                        conda_packages,
+                        source_label,
+                    )
 
         # Runtime dependencies
         for ros_dep in pkg.get_all_runtime_dependencies():
             if ros_dep in workspace_pkg_names:
                 continue
-            conda_packages = map_ros_to_conda(ros_dep, distro)
-            if conda_packages:
-                pkg_deps[pkg.name]["Runtime"][ros_dep] = conda_packages
+
+            if ros_dep in validation_results:
+                conda_packages, source_label = validation_results[ros_dep]
+                if conda_packages:
+                    pkg_deps[pkg.name]["Runtime"][ros_dep] = (
+                        conda_packages,
+                        source_label,
+                    )
 
         # Test dependencies
         for ros_dep in pkg.get_all_test_dependencies():
             if ros_dep in workspace_pkg_names:
                 continue
-            conda_packages = map_ros_to_conda(ros_dep, distro)
-            if conda_packages:
-                pkg_deps[pkg.name]["Test"][ros_dep] = conda_packages
+
+            if ros_dep in validation_results:
+                conda_packages, source_label = validation_results[ros_dep]
+                if conda_packages:
+                    pkg_deps[pkg.name]["Test"][ros_dep] = (conda_packages, source_label)
 
     # Check if any external dependencies exist
     has_deps = any(
@@ -211,9 +322,18 @@ def _display_dependencies(packages, distro: str):
         all_deps = []
         for dep_type in ["Build", "Runtime", "Test"]:
             for ros_dep in sorted(pkg_info[dep_type].keys()):
-                conda_pkgs = pkg_info[dep_type][ros_dep]
-                conda_str = ", ".join(conda_pkgs)
-                all_deps.append((ros_dep, dep_type, conda_str))
+                dep_info = pkg_info[dep_type][ros_dep]
+                # Handle both tuple format (with source) and list format
+                # (backward compat)
+                if isinstance(dep_info, tuple):
+                    conda_pkgs, source = dep_info
+                else:
+                    conda_pkgs = dep_info
+                    source = "Fallback"
+                conda_str = (
+                    ", ".join(conda_pkgs) if conda_pkgs else "[red]NOT FOUND[/red]"
+                )
+                all_deps.append((ros_dep, dep_type, conda_str, source))
 
         # Skip packages with no external dependencies
         if not all_deps:
@@ -228,14 +348,58 @@ def _display_dependencies(packages, distro: str):
         table.add_column("ROS Dependency", style="yellow")
         table.add_column("Type", style="blue")
         table.add_column("Conda Packages", style="green")
+        if validator:
+            table.add_column("Source", style="magenta")
 
         # Add all dependencies for this package
-        for ros_dep, dep_type, conda_str in all_deps:
-            table.add_row(ros_dep, dep_type, conda_str)
+        for dep_data in all_deps:
+            if validator:
+                ros_dep, dep_type, conda_str, source = dep_data
+                table.add_row(ros_dep, dep_type, conda_str, source)
+            else:
+                ros_dep, dep_type, conda_str, _ = dep_data
+                table.add_row(ros_dep, dep_type, conda_str)
 
         console.print(table)
         console.print("")
 
+    # Display validation summary if validator was used
+    if validator:
+        console.print("\n[bold cyan]Validation Summary:[/bold cyan]")
+        total_deps = sum(validation_stats.values())
+
+        if validation_stats["workspace"] > 0:
+            console.print(
+                f"  [green]✓[/green] {validation_stats['workspace']} "
+                f"workspace packages (skipped)"
+            )
+        if validation_stats["mapping"] > 0:
+            console.print(
+                f"  [green]✓[/green] {validation_stats['mapping']} "
+                f"packages from mappings"
+            )
+        if validation_stats["ros_distro"] > 0:
+            console.print(
+                f"  [green]✓[/green] {validation_stats['ros_distro']} "
+                f"packages from ROS {distro} distro"
+            )
+        if validation_stats["conda_forge"] > 0:
+            console.print(
+                f"  [green]✓[/green] {validation_stats['conda_forge']} "
+                f"packages from conda-forge (auto-detected)"
+            )
+        if validation_stats["not_found"] > 0:
+            console.print(
+                f"  [yellow]⚠[/yellow] {validation_stats['not_found']} "
+                f"packages NOT FOUND (will be commented out)"
+            )
+
+        total_external = total_deps - validation_stats["workspace"]
+        console.print(f"\n  Total external dependencies: {total_external}")
+        console.print("")
+
+    return not_found_packages
+
 
 def _ensure_workspace_section(
     config: dict, workspace_path: Path, platforms: list[str] | None = None
@@ -254,8 +418,8 @@ def _ensure_workspace_section(
     if "channels" not in workspace:
         workspace["channels"] = []
 
-    # Set platforms if not present or if platforms were provided
-    if "platforms" not in workspace or platforms:
+    # Set or extend platforms
+    if "platforms" not in workspace:
         if platforms:
             # Platforms are already in pixi format (linux-64, osx-64, etc.)
             workspace["platforms"] = platforms
@@ -263,6 +427,18 @@ def _ensure_workspace_section(
             # 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):
@@ -284,65 +460,20 @@ def _ensure_channels(config: dict, distro: str):
     workspace["channels"] = channels
 
 
-def _check_package_availability(
-    packages: list[str], channels: list[str], platform: Platform
-) -> dict[str, bool]:
-    """
-    Check if packages are available in the given channels.
-
-    Args:
-        packages: List of conda package names to check
-        channels: List of channel URLs
-        platform: Platform to check for
-
-    Returns:
-        Dictionary mapping package names to availability (True/False)
-    """
-    import asyncio
-
-    availability = dict.fromkeys(packages, False)
-
-    try:
-        # Create gateway for fetching repo data
-        gateway = Gateway()
-
-        # Convert channel URLs to Channel objects
-        channel_objects = [Channel(url) for url in channels]
-
-        # Query all channels at once (gateway.query is async)
-        repo_data_by_channel = asyncio.run(
-            gateway.query(
-                channel_objects,
-                [platform],
-                specs=packages,  # Correct parameter name
-                recursive=False,  # Don't fetch dependencies
-            )
-        )
-
-        # repo_data_by_channel is a list of lists (one per channel)
-        # Check all channels for each package
-        for channel_records in repo_data_by_channel:
-            for record in channel_records:
-                # Check if any of our packages match this record
-                for package_name in packages:
-                    if record.name.normalized == package_name.lower():
-                        availability[package_name] = True
-
-    except Exception as e:
-        # If query fails, log the error but continue (all marked as unavailable)
-        console.print(
-            f"[yellow]Warning: Could not check package availability: {e}[/yellow]"
-        )
-
-    return availability
-
-
 def _ensure_dependencies(
-    config: dict, packages, distro: str, platforms: list[str] | None = None
+    config: dict,
+    packages,
+    distro: str,
+    platforms: list[str] | None = None,
+    validator=None,
+    not_found_from_display: dict[str, tuple[set[str], list[str]]] | None = None,
 ):
     """
     Ensure all ROS dependencies are present with comments showing source.
 
+    Args:
+        not_found_from_display: NOT_FOUND packages from _display_dependencies
+
     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].
@@ -365,6 +496,33 @@ def _ensure_dependencies(
         if cmake_version:
             dep_versions["cmake"] = cmake_version
 
+        # 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 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,
+                validator=validator,
+                workspace_packages=workspace_pkg_names,
+            )
+
+            # Apply version constraint to all mapped conda packages
+            for conda_dep in conda_packages:
+                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 = {
@@ -389,6 +547,22 @@ def _ensure_dependencies(
         mapping_platform: {} for mapping_platform in platform_groups.keys()
     }
 
+    # Track NOT_FOUND packages per platform
+    # Structure: mapping_platform -> ros_package -> (set of sources, conda_packages)
+    not_found_packages: dict[str, dict[str, tuple[set[str], list[str]]]] = {
+        mapping_platform: {} for mapping_platform in platform_groups.keys()
+    }
+
+    # Use NOT_FOUND data from _display_dependencies (already validated there)
+    if not_found_from_display:
+        # Populate not_found_packages for all platforms with the data from display
+        for mapping_platform in platform_groups.keys():
+            for ros_dep, (source_pkgs, conda_pkgs) in not_found_from_display.items():
+                not_found_packages[mapping_platform][ros_dep] = (
+                    source_pkgs.copy(),
+                    conda_pkgs,
+                )
+
     # Collect dependencies from each package, mapped for each platform
     for mapping_platform in platform_groups.keys():
         for pkg in packages:
@@ -397,9 +571,17 @@ def _ensure_dependencies(
                 if ros_dep in workspace_pkg_names:
                     continue
 
-                # Map to conda packages for this mapping platform
+                # Skip NOT_FOUND packages (already tracked from display)
+                if not_found_from_display and ros_dep in not_found_from_display:
+                    continue
+
+                # Map to conda packages WITHOUT validator (already validated in display)
                 conda_packages = map_ros_to_conda(
-                    ros_dep, distro, platform_override=mapping_platform
+                    ros_dep,
+                    distro,
+                    platform_override=mapping_platform,
+                    validator=None,
+                    workspace_packages=workspace_pkg_names,
                 )
 
                 # Skip if no conda packages were returned
@@ -444,12 +626,26 @@ def _ensure_dependencies(
         # Single mapping platform - all deps are "common"
         common_deps = set(platform_deps[mapping_platform_list[0]].keys())
 
+    # Determine common NOT_FOUND packages (present in all mapping platforms)
+    common_not_found = set()
+    if len(mapping_platform_list) > 1:
+        common_not_found = set(not_found_packages[mapping_platform_list[0]].keys())
+        for mapping_platform in mapping_platform_list[1:]:
+            common_not_found &= set(not_found_packages[mapping_platform].keys())
+
+    # Will be set later when processing unix deps
+    unix_not_found = set()
+
     # 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]]
-    }
+    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:
@@ -459,6 +655,9 @@ def _ensure_dependencies(
     # Add base ROS dependencies with comment
     base_deps = {
         f"ros-{distro}-ros-base": "*",
+    }
+
+    build_deps = {
         "pkg-config": "*",
         "compilers": "*",
         "make": "*",
@@ -473,8 +672,14 @@ def _ensure_dependencies(
         if dep not in dependencies:
             dependencies[dep] = version
 
+    for dep, version in build_deps.items():
+        if dep not in dependencies:
+            dependencies[dep] = version
+
     # Add ros2cli packages
-    ros2cli_deps = map_ros_to_conda("ros2cli", distro)
+    ros2cli_deps = map_ros_to_conda(
+        "ros2cli", distro, validator=validator, workspace_packages=workspace_pkg_names
+    )
     if ros2cli_deps:
         for conda_pkg in ros2cli_deps:
             if conda_pkg and conda_pkg not in dependencies:
@@ -491,60 +696,43 @@ def _ensure_dependencies(
         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())
         if len(mapping_platform_list) > 1:
-            dependencies.add(tomlkit.comment("Workspace dependencies (common across platforms)"))
+            dependencies.add(
+                tomlkit.comment("Workspace dependencies (common across platforms)")
+            )
         else:
             dependencies.add(tomlkit.comment("Workspace dependencies"))
 
-        # For common deps, check on first pixi platform as representative
-        first_pixi_platform = platforms[0]
-        first_platform = Platform(first_pixi_platform)
-
-        packages_to_check = [
-            conda_dep
-            for conda_dep in dep_sources.keys()
-            if conda_dep not in dependencies
-        ]
-
-        availability = {}
-        if channels and packages_to_check:
-            typer.echo(f"Checking common package availability for {first_pixi_platform}...")
-            availability = _check_package_availability(
-                packages_to_check, channels, first_platform
-            )
-
-        available_packages = []
-        unavailable_packages = []
-
+        # Add all dependencies (validation already checked availability)
         for conda_dep in sorted(dep_sources.keys()):
             if conda_dep not in dependencies:
-                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, "*")
-            dependencies[conda_dep] = version
+                version = dep_versions.get(conda_dep, "*")
+                dependencies[conda_dep] = version
 
-        if unavailable_packages:
+    # Add NOT_FOUND packages as comments (common across all platforms)
+    if len(mapping_platform_list) > 1:
+        if common_not_found:
             dependencies.add(tomlkit.nl())
-            dependencies.add(
-                tomlkit.comment(
-                    "The following packages were not found in the configured channels:"
-                )
-            )
-            for conda_dep in unavailable_packages:
-                version = dep_versions.get(conda_dep, "*")
-                dependencies.add(
-                    tomlkit.comment(f'{conda_dep} = "{version}"  # NOT FOUND')
-                )
+            dependencies.add(tomlkit.comment("The following packages were not found:"))
+            for ros_pkg in sorted(common_not_found):
+                _, conda_pkgs = not_found_packages[mapping_platform_list[0]][ros_pkg]
+                # Use conda package name if available, otherwise ros package name
+                pkg_name = conda_pkgs[0] if conda_pkgs else ros_pkg
+                dependencies.add(tomlkit.comment(f'{pkg_name} = "*"'))
+    else:
+        # Single platform - add all NOT_FOUND packages
+        mapping_platform = mapping_platform_list[0]
+        if not_found_packages[mapping_platform]:
+            dependencies.add(tomlkit.nl())
+            dependencies.add(tomlkit.comment("The following packages were not found:"))
+            for ros_pkg in sorted(not_found_packages[mapping_platform].keys()):
+                _, conda_pkgs = not_found_packages[mapping_platform][ros_pkg]
+                # Use conda package name if available, otherwise ros package name
+                pkg_name = conda_pkgs[0] if conda_pkgs else ros_pkg
+                dependencies.add(tomlkit.comment(f'{pkg_name} = "*"'))
 
     config["dependencies"] = dependencies
 
@@ -564,7 +752,9 @@ def _ensure_dependencies(
 
             # 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())
+                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
@@ -590,43 +780,37 @@ def _ensure_dependencies(
                     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 = []
-
+            # Add unix-specific dependencies
             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)
+                    version = dep_versions.get(conda_dep, "*")
+                    target_deps[conda_dep] = version
 
-            for conda_dep in available_packages:
-                version = dep_versions.get(conda_dep, "*")
-                target_deps[conda_dep] = version
+            # Calculate and add unix-specific NOT_FOUND packages as comments
+            if has_linux and has_osx:
+                linux_not_found = set(not_found_packages.get("linux", {}).keys())
+                osx_not_found = set(not_found_packages.get("osx", {}).keys())
+                unix_not_found_candidates = (
+                    linux_not_found & osx_not_found
+                ) - common_not_found
+
+                if has_win:
+                    win_not_found = set(
+                        not_found_packages.get("win64", {}).keys()
+                    ) | set(not_found_packages.get("win", {}).keys())
+                    unix_not_found = unix_not_found_candidates - win_not_found
+                else:
+                    unix_not_found = unix_not_found_candidates
 
-            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, "*")
+                if unix_not_found:
+                    target_deps.add(tomlkit.nl())
                     target_deps.add(
-                        tomlkit.comment(f'{conda_dep} = "{version}"  # NOT FOUND')
+                        tomlkit.comment("The following packages were not found:")
                     )
+                    for ros_pkg in sorted(unix_not_found):
+                        _, conda_pkgs = not_found_packages["linux"][ros_pkg]
+                        pkg_name = conda_pkgs[0] if conda_pkgs else ros_pkg
+                        target_deps.add(tomlkit.comment(f'{pkg_name} = "*"'))
 
     # Now add remaining platform-specific dependencies (not in common, not in unix)
     if len(mapping_platform_list) > 1:
@@ -651,47 +835,39 @@ def _ensure_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
+                        tomlkit.comment(
+                            f"Platform-specific dependencies for {mapping_platform}"
+                        )
                     )
 
-                available_packages = []
-                unavailable_packages = []
-
+                # Add platform-specific dependencies
                 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
+                        version = dep_versions.get(conda_dep, "*")
+                        target_deps[conda_dep] = version
 
-                if unavailable_packages:
+                # Add platform-specific NOT_FOUND packages as comments
+                # Determine which NOT_FOUND packages are platform-specific
+                common_set = (
+                    common_not_found if len(mapping_platform_list) > 1 else set()
+                )
+                platform_not_found = {
+                    ros_pkg: (sources, conda_pkgs)
+                    for ros_pkg, (sources, conda_pkgs) in not_found_packages[
+                        mapping_platform
+                    ].items()
+                    if ros_pkg not in common_set and ros_pkg not in unix_not_found
+                }
+
+                if platform_not_found:
                     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')
-                        )
+                    for ros_pkg in sorted(platform_not_found.keys()):
+                        _, conda_pkgs = platform_not_found[ros_pkg]
+                        pkg_name = conda_pkgs[0] if conda_pkgs else ros_pkg
+                        target_deps.add(tomlkit.comment(f'{pkg_name} = "*"'))
 
 
 def _ensure_tasks(config: dict):
@@ -700,14 +876,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