feat: Add simple Pixi.toml generation without conflict resolution

This implementation follows the principle of 'Let UniDep translate, let Pixi resolve'.
Instead of pre-resolving conflicts ourselves, we simply translate requirements.yaml
and pyproject.toml files to pixi.toml format and let Pixi handle all dependency
resolution.

Key changes:
- Add minimal _pixi.py module (~180 lines) for simple pixi.toml generation
- Add --pixi flag to merge command to generate pixi.toml instead of environment.yaml
- Support both single file and monorepo configurations with Pixi features
- Add comprehensive tests for pixi.toml generation
- Document implementation plan in PIXI_PLAN.md

This approach is much simpler than the previous implementation (~500+ lines)
that tracked dependency origins and attempted to resolve conflicts ourselves.

Author: basnijholt

PIXI_PLAN.md

@@ -0,0 +1,111 @@
+# Pixi Integration - Simple Implementation Plan
+
+## Core Philosophy
+**Let UniDep translate, let Pixi resolve**
+
+UniDep should act as a simple translator from `requirements.yaml`/`pyproject.toml` to `pixi.toml` format.
+Pixi handles all dependency resolution, conflict management, and lock file generation.
+
+## Current Problem with `pixi` Branch
+- **Over-engineering**: Pre-resolves conflicts that Pixi can handle
+- **Origin tracking**: Complex system to track where each dependency came from
+- **Unnecessary complexity**: ~500+ lines of code for what should be ~100 lines
+
+## New Simple Architecture
+
+### Phase 1: Basic Pixi.toml Generation ✅
+- [x] Create minimal `_pixi.py` module (~100 lines)
+- [ ] Parse requirements WITHOUT resolution
+- [ ] Create features with literal dependencies
+- [ ] Generate pixi.toml with proper structure
+- [ ] Add `--pixi` flag to merge command
+
+### Phase 2: Pixi Lock Command
+- [ ] Add `pixi-lock` subcommand to CLI
+- [ ] Simple wrapper around `pixi lock` command
+- [ ] Support platform selection
+- [ ] Add basic tests
+
+### Phase 3: Monorepo Support (Optional)
+- [ ] Generate sub-lock files if needed
+- [ ] But let Pixi handle the complexity
+
+## Implementation Details
+
+### 1. Simple Pixi.toml Structure
+```python
+def generate_pixi_toml(requirements_files, output_file):
+    pixi_data = {
+        "project": {
+            "name": "myenv",
+            "channels": channels,
+            "platforms": platforms,
+        },
+        "dependencies": {},
+        "pypi-dependencies": {},
+    }
+
+    # For monorepo: create features
+    if len(requirements_files) > 1:
+        pixi_data["feature"] = {}
+        pixi_data["environments"] = {}
+
+        for req_file in requirements_files:
+            feature_name = req_file.parent.stem
+            deps = parse_single_file(req_file)  # NO RESOLUTION!
+
+            pixi_data["feature"][feature_name] = {
+                "dependencies": deps.conda,  # Literal copy
+                "pypi-dependencies": deps.pip,  # Literal copy
+            }
+
+        # Create environments
+        all_features = list(pixi_data["feature"].keys())
+        pixi_data["environments"]["default"] = all_features
+        for feat in all_features:
+            pixi_data["environments"][feat.replace("_", "-")] = [feat]
+```
+
+### 2. Key Simplifications
+- **NO conflict resolution** - Pixi handles this
+- **NO origin tracking** - Not needed
+- **NO version pinning combination** - Pixi does this
+- **NO platform resolution** - Use Pixi's native platform support
+
+### 3. Testing Strategy
+- Test pixi.toml generation (structure validation)
+- Test CLI integration
+- Test with example monorepo
+- Let Pixi handle the actual resolution testing
+
+## Files to Create/Modify
+
+### New Files
+1. `unidep/_pixi.py` - Simple pixi.toml generation (~100 lines)
+2. `tests/test_pixi.py` - Basic tests (~50 lines)
+
+### Modified Files
+1. `unidep/_cli.py` - Add `--pixi` flag and `pixi-lock` command
+2. `README.md` - Document new Pixi support
+
+## Success Criteria
+- [ ] Generate valid pixi.toml files
+- [ ] Pass all tests
+- [ ] Work with monorepo example
+- [ ] Total implementation < 200 lines (vs 500+ in old branch)
+
+## Timeline
+- **Hour 1-2**: Basic pixi.toml generation ✅
+- **Hour 3-4**: CLI integration and testing
+- **Hour 5-6**: Documentation and polish
+
+## Testing Checkpoints
+After each major change:
+1. Run tests: `pytest tests/test_pixi.py -xvs`
+2. Test with monorepo: `unidep merge --pixi tests/simple_monorepo`
+3. Validate pixi.toml: `pixi list`
+
+## Commit Strategy
+- Commit after each working phase
+- Clear commit messages
+- Test before each commit

tests/test_pixi.py

@@ -0,0 +1,189 @@
+"""Tests for simple Pixi.toml generation."""
+
+from __future__ import annotations
+
+import textwrap
+from typing import TYPE_CHECKING
+
+from unidep._pixi import generate_pixi_toml
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+
+def test_simple_pixi_generation(tmp_path: Path) -> None:
+    """Test basic pixi.toml generation from a single requirements.yaml."""
+    req_file = tmp_path / "requirements.yaml"
+    req_file.write_text(
+        textwrap.dedent(
+            """\
+            channels:
+              - conda-forge
+            dependencies:
+              - numpy >=1.20
+              - pandas
+              - pip: requests
+            platforms:
+              - linux-64
+              - osx-arm64
+            """,
+        ),
+    )
+
+    output_file = tmp_path / "pixi.toml"
+    generate_pixi_toml(
+        req_file,
+        project_name="test-project",
+        output_file=output_file,
+        verbose=False,
+    )
+
+    assert output_file.exists()
+    content = output_file.read_text()
+
+    # Check basic structure
+    assert "[project]" in content
+    assert 'name = "test-project"' in content
+    assert "conda-forge" in content
+    assert "linux-64" in content
+    assert "osx-arm64" in content
+
+    # Check dependencies
+    assert "[dependencies]" in content
+    assert 'numpy = ">=1.20"' in content
+    assert 'pandas = "*"' in content
+
+    assert "[pypi-dependencies]" in content
+    assert 'requests = "*"' in content
+
+
+def test_monorepo_pixi_generation(tmp_path: Path) -> None:
+    """Test pixi.toml generation with features for multiple requirements files."""
+    # Create project1
+    project1_dir = tmp_path / "project1"
+    project1_dir.mkdir()
+    req1 = project1_dir / "requirements.yaml"
+    req1.write_text(
+        textwrap.dedent(
+            """\
+            channels:
+              - conda-forge
+            dependencies:
+              - numpy
+              - conda: scipy
+            """,
+        ),
+    )
+
+    # Create project2
+    project2_dir = tmp_path / "project2"
+    project2_dir.mkdir()
+    req2 = project2_dir / "requirements.yaml"
+    req2.write_text(
+        textwrap.dedent(
+            """\
+            channels:
+              - conda-forge
+            dependencies:
+              - pandas
+              - pip: requests
+            """,
+        ),
+    )
+
+    output_file = tmp_path / "pixi.toml"
+    generate_pixi_toml(
+        req1,
+        req2,
+        project_name="monorepo",
+        output_file=output_file,
+        verbose=False,
+    )
+
+    assert output_file.exists()
+    content = output_file.read_text()
+
+    # Check project section
+    assert "[project]" in content
+    assert 'name = "monorepo"' in content
+
+    # Check feature dependencies (TOML writes them directly without parent section)
+    assert "[feature.project1.dependencies]" in content
+    assert 'numpy = "*"' in content
+    assert 'scipy = "*"' in content
+
+    assert "[feature.project2.dependencies]" in content
+    assert 'pandas = "*"' in content
+
+    assert "[feature.project2.pypi-dependencies]" in content
+    assert 'requests = "*"' in content
+
+    # Check environments (be flexible with TOML formatting)
+    assert "[environments]" in content
+    assert "default =" in content
+    assert "project1" in content
+    assert "project2" in content
+    # Verify that default includes both projects
+    assert content.count('"project1"') >= 2  # In default and individual env
+    assert content.count('"project2"') >= 2  # In default and individual env
+
+
+def test_pixi_with_version_pins(tmp_path: Path) -> None:
+    """Test that version pins are passed through without resolution."""
+    req_file = tmp_path / "requirements.yaml"
+    req_file.write_text(
+        textwrap.dedent(
+            """\
+            channels:
+              - conda-forge
+            dependencies:
+              - numpy >=1.20,<2.0
+              - conda: scipy =1.9.0
+              - pip: requests >2.20
+            """,
+        ),
+    )
+
+    output_file = tmp_path / "pixi.toml"
+    generate_pixi_toml(
+        req_file,
+        output_file=output_file,
+        verbose=False,
+    )
+
+    content = output_file.read_text()
+
+    # Check that pins are preserved exactly
+    assert 'numpy = ">=1.20,<2.0"' in content
+    assert 'scipy = "=1.9.0"' in content
+    assert 'requests = ">2.20"' in content
+
+
+def test_pixi_empty_dependencies(tmp_path: Path) -> None:
+    """Test handling of requirements file with no dependencies."""
+    req_file = tmp_path / "requirements.yaml"
+    req_file.write_text(
+        textwrap.dedent(
+            """\
+            channels:
+              - conda-forge
+            platforms:
+              - linux-64
+            """,
+        ),
+    )
+
+    output_file = tmp_path / "pixi.toml"
+    generate_pixi_toml(
+        req_file,
+        output_file=output_file,
+        verbose=False,
+    )
+
+    assert output_file.exists()
+    content = output_file.read_text()
+
+    # Should have project section but no dependencies sections
+    assert "[project]" in content
+    assert "[dependencies]" not in content
+    assert "[pypi-dependencies]" not in content