sprout-cli 0.3.0__tar.gz → 0.5.0__tar.gz

{sprout_cli-0.3.0 → sprout_cli-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sprout-cli
-Version: 0.3.0
+Version: 0.5.0
 Summary: CLI tool to automate git worktree and Docker Compose development workflows
 Author: SecDevLab Inc.
 License: MIT
@@ -41,7 +41,7 @@ A CLI tool to automate git worktree and Docker Compose development workflows.
 ## Installation
 
 ```bash
-pip install sprout
+pip install sprout-cli
 ```
 
 For development:
@@ -56,7 +56,9 @@ pip install -e ".[dev]"
 
 ## Quick Start
 
-1. Create a `.env.example` template in your project root:
+**Note**: Sprout works in any git repository. `.env.example` files are optional - if you don't have them, sprout will simply create worktrees without `.env` generation.
+
+1. (Optional) Create a `.env.example` template in your project root (and optionally in subdirectories) for automatic `.env` generation:
 ```env
 # API Configuration
 API_KEY={{ API_KEY }}
@@ -71,14 +73,28 @@ DB_PORT={{ auto_port() }}
 # DB_NAME=${DB_NAME}
 ```
 
+For monorepo or multi-service projects, you can create `.env.example` files in subdirectories:
+```
+repo/
+  .env.example          # Root configuration
+  service-a/
+    .env.example        # Service A specific config
+  service-b/
+    .env.example        # Service B specific config
+```
+
 2. Create and navigate to a new development environment in one command:
 ```bash
 cd $(sprout create feature-branch --path)
 ```
 
+**What happens when you run `sprout create`:**
+- If `.env.example` files exist: Sprout will generate corresponding `.env` files with populated variables and unique port assignments
+- If no `.env.example` files exist: Sprout will show a warning and create the worktree without `.env` generation
+
 This single command:
 - Creates a new git worktree for `feature-branch`
-- Generates a `.env` file from your template
+- Generates `.env` files from your templates (if `.env.example` files exist)
 - Outputs the path to the new environment
 - Changes to that directory when wrapped in `cd $(...)`
 
@@ -173,8 +189,9 @@ sprout supports two types of placeholders in `.env.example`:
 
 2. **Auto Port Assignment**: `{{ auto_port() }}`
    - Automatically assigns available ports
-   - Avoids conflicts with other sprout environments
+   - Avoids conflicts across ALL services in ALL sprout environments
    - Checks system port availability
+   - Ensures global uniqueness even in monorepo setups
 
 3. **Docker Compose Syntax (Preserved)**: `${VARIABLE}`
    - NOT processed by sprout - passed through as-is
@@ -196,6 +213,54 @@ sprout create another-branch
 # → Enter a value for 'DATABASE_URL': [user input required]
 ```
 
+## Monorepo Tutorial
+
+Try out the monorepo functionality with the included sample:
+
+1. **Navigate to the sample monorepo**:
+   ```bash
+   cd sample/monorepo
+   ```
+
+2. **Set required environment variables**:
+   ```bash
+   export API_KEY="your-api-key"
+   export DATABASE_URL="postgresql://postgres:postgres@localhost:5432/myapp"
+   export REACT_APP_API_KEY="your-frontend-api-key"
+   export JWT_SECRET="your-jwt-secret"
+   export SMTP_USER="your-smtp-username"
+   export SMTP_PASS="your-smtp-password"
+   ```
+
+3. **Create a development environment**:
+   ```bash
+   sprout create monorepo-feature
+   ```
+
+4. **Navigate to the created environment**:
+   ```bash
+   cd .sprout/monorepo-feature
+   ```
+
+5. **Verify all services have unique ports**:
+   ```bash
+   find . -name "*.env" -exec echo "=== {} ===" \; -exec cat {} \;
+   ```
+
+6. **Start all services**:
+   ```bash
+   cd sample/monorepo
+   docker-compose up -d
+   ```
+
+The sample includes:
+- **Root service**: Database and Redis with shared configuration
+- **Frontend**: React app with API integration
+- **Backend**: REST API with authentication
+- **Shared**: Utilities with message queue and monitoring
+
+Each service gets unique, conflict-free ports automatically!
+
 ## Documentation
 
 - [Architecture Overview](docs/sprout-cli/overview.md) - Design philosophy, architecture, and implementation details

{sprout_cli-0.3.0 → sprout_cli-0.5.0}/README.md

@@ -13,7 +13,7 @@ A CLI tool to automate git worktree and Docker Compose development workflows.
 ## Installation
 
 ```bash
-pip install sprout
+pip install sprout-cli
 ```
 
 For development:
@@ -28,7 +28,9 @@ pip install -e ".[dev]"
 
 ## Quick Start
 
-1. Create a `.env.example` template in your project root:
+**Note**: Sprout works in any git repository. `.env.example` files are optional - if you don't have them, sprout will simply create worktrees without `.env` generation.
+
+1. (Optional) Create a `.env.example` template in your project root (and optionally in subdirectories) for automatic `.env` generation:
 ```env
 # API Configuration
 API_KEY={{ API_KEY }}
@@ -43,14 +45,28 @@ DB_PORT={{ auto_port() }}
 # DB_NAME=${DB_NAME}
 ```
 
+For monorepo or multi-service projects, you can create `.env.example` files in subdirectories:
+```
+repo/
+  .env.example          # Root configuration
+  service-a/
+    .env.example        # Service A specific config
+  service-b/
+    .env.example        # Service B specific config
+```
+
 2. Create and navigate to a new development environment in one command:
 ```bash
 cd $(sprout create feature-branch --path)
 ```
 
+**What happens when you run `sprout create`:**
+- If `.env.example` files exist: Sprout will generate corresponding `.env` files with populated variables and unique port assignments
+- If no `.env.example` files exist: Sprout will show a warning and create the worktree without `.env` generation
+
 This single command:
 - Creates a new git worktree for `feature-branch`
-- Generates a `.env` file from your template
+- Generates `.env` files from your templates (if `.env.example` files exist)
 - Outputs the path to the new environment
 - Changes to that directory when wrapped in `cd $(...)`
 
@@ -145,8 +161,9 @@ sprout supports two types of placeholders in `.env.example`:
 
 2. **Auto Port Assignment**: `{{ auto_port() }}`
    - Automatically assigns available ports
-   - Avoids conflicts with other sprout environments
+   - Avoids conflicts across ALL services in ALL sprout environments
    - Checks system port availability
+   - Ensures global uniqueness even in monorepo setups
 
 3. **Docker Compose Syntax (Preserved)**: `${VARIABLE}`
    - NOT processed by sprout - passed through as-is
@@ -168,6 +185,54 @@ sprout create another-branch
 # → Enter a value for 'DATABASE_URL': [user input required]
 ```
 
+## Monorepo Tutorial
+
+Try out the monorepo functionality with the included sample:
+
+1. **Navigate to the sample monorepo**:
+   ```bash
+   cd sample/monorepo
+   ```
+
+2. **Set required environment variables**:
+   ```bash
+   export API_KEY="your-api-key"
+   export DATABASE_URL="postgresql://postgres:postgres@localhost:5432/myapp"
+   export REACT_APP_API_KEY="your-frontend-api-key"
+   export JWT_SECRET="your-jwt-secret"
+   export SMTP_USER="your-smtp-username"
+   export SMTP_PASS="your-smtp-password"
+   ```
+
+3. **Create a development environment**:
+   ```bash
+   sprout create monorepo-feature
+   ```
+
+4. **Navigate to the created environment**:
+   ```bash
+   cd .sprout/monorepo-feature
+   ```
+
+5. **Verify all services have unique ports**:
+   ```bash
+   find . -name "*.env" -exec echo "=== {} ===" \; -exec cat {} \;
+   ```
+
+6. **Start all services**:
+   ```bash
+   cd sample/monorepo
+   docker-compose up -d
+   ```
+
+The sample includes:
+- **Root service**: Database and Redis with shared configuration
+- **Frontend**: React app with API integration
+- **Backend**: REST API with authentication
+- **Shared**: Utilities with message queue and monitoring
+
+Each service gets unique, conflict-free ports automatically!
+
 ## Documentation
 
 - [Architecture Overview](docs/sprout-cli/overview.md) - Design philosophy, architecture, and implementation details

{sprout_cli-0.3.0 → sprout_cli-0.5.0}/src/sprout/__init__.py

@@ -1,3 +1,3 @@
 """sprout - CLI tool to automate git worktree and Docker Compose development workflows."""
 
-__version__ = "0.3.0"
+__version__ = "0.5.0"

sprout_cli-0.5.0/src/sprout/commands/create.py

@@ -0,0 +1,161 @@
+"""Implementation of the create command."""
+
+import re
+from pathlib import Path
+from typing import Never
+
+import typer
+from rich.console import Console
+
+from sprout.exceptions import SproutError
+from sprout.types import BranchName
+from sprout.utils import (
+    branch_exists,
+    ensure_sprout_dir,
+    get_git_root,
+    get_used_ports,
+    is_git_repository,
+    parse_env_template,
+    run_command,
+    worktree_exists,
+)
+
+console = Console()
+
+
+def create_worktree(branch_name: BranchName, path_only: bool = False) -> Never:
+    """Create a new worktree with development environment."""
+    # Check prerequisites
+    if not is_git_repository():
+        if not path_only:
+            console.print("[red]Error: Not in a git repository[/red]")
+            console.print("Please run this command from the root of a git repository.")
+        else:
+            typer.echo("Error: Not in a git repository", err=True)
+        raise typer.Exit(1)
+
+    git_root = get_git_root()
+
+    # Find all .env.example files that are tracked by git
+    result = run_command(["git", "ls-files", "*.env.example", "**/*.env.example"])
+    env_examples = []
+    if result.stdout.strip():
+        for file_path in result.stdout.strip().split("\n"):
+            full_path = git_root / file_path
+            if full_path.exists():
+                env_examples.append(full_path)
+
+    if not env_examples:
+        if not path_only:
+            console.print("[yellow]Warning: No .env.example files found[/yellow]")
+            console.print(f"Proceeding without .env generation in: {git_root}")
+        # Continue execution without exiting
+
+    # Check if worktree already exists
+    if worktree_exists(branch_name):
+        if not path_only:
+            console.print(f"[red]Error: Worktree for branch '{branch_name}' already exists[/red]")
+        else:
+            typer.echo(f"Error: Worktree for branch '{branch_name}' already exists", err=True)
+        raise typer.Exit(1)
+
+    # Ensure .sprout directory exists
+    sprout_dir = ensure_sprout_dir()
+    worktree_path = sprout_dir / branch_name
+
+    # Create the worktree
+    if not path_only:
+        console.print(f"Creating worktree for branch [cyan]{branch_name}[/cyan]...")
+
+    # Check if branch exists, create if it doesn't
+    if not branch_exists(branch_name):
+        if not path_only:
+            console.print(f"Branch '{branch_name}' doesn't exist. Creating new branch...")
+        # Create branch with -b flag
+        cmd = ["git", "worktree", "add", "-b", branch_name, str(worktree_path)]
+    else:
+        cmd = ["git", "worktree", "add", str(worktree_path), branch_name]
+
+    try:
+        run_command(cmd)
+    except SproutError as e:
+        if not path_only:
+            console.print(f"[red]Error creating worktree: {e}[/red]")
+        else:
+            typer.echo(f"Error creating worktree: {e}", err=True)
+        raise typer.Exit(1) from e
+
+    # Generate .env files only if .env.example files exist
+    if env_examples:
+        if not path_only:
+            console.print(f"Generating .env files from {len(env_examples)} template(s)...")
+
+        # Get all currently used ports to avoid conflicts
+        all_used_ports = get_used_ports()
+        session_ports: set[int] = set()
+
+        try:
+            for env_example in env_examples:
+                # Calculate relative path from git root
+                relative_dir = env_example.parent.relative_to(git_root)
+
+                # Create target directory in worktree if needed
+                if relative_dir != Path("."):
+                    target_dir = worktree_path / relative_dir
+                    target_dir.mkdir(parents=True, exist_ok=True)
+                    env_file = target_dir / ".env"
+                else:
+                    env_file = worktree_path / ".env"
+
+                # Parse template with combined used ports
+                env_content = parse_env_template(
+                    env_example, silent=path_only, used_ports=all_used_ports | session_ports
+                )
+
+                # Extract ports from generated content and add to session_ports
+                port_matches = re.findall(r"=(\d{4,5})\b", env_content)
+                for port_str in port_matches:
+                    port = int(port_str)
+                    if 1024 <= port <= 65535:
+                        session_ports.add(port)
+
+                # Write the .env file
+                env_file.write_text(env_content)
+
+        except SproutError as e:
+            if not path_only:
+                console.print(f"[red]Error generating .env file: {e}[/red]")
+            else:
+                typer.echo(f"Error generating .env file: {e}", err=True)
+            # Clean up worktree on failure
+            run_command(["git", "worktree", "remove", str(worktree_path)], check=False)
+            raise typer.Exit(1) from e
+        except KeyboardInterrupt:
+            if not path_only:
+                console.print("\n[yellow]Cancelled by user[/yellow]")
+            else:
+                typer.echo("Cancelled by user", err=True)
+            # Clean up worktree on cancellation
+            run_command(["git", "worktree", "remove", str(worktree_path)], check=False)
+            raise typer.Exit(130) from None
+
+    # Success message or path output
+    if path_only:
+        # Output only the path for shell command substitution
+        print(str(worktree_path))
+    else:
+        console.print(f"\n[green]✅ Workspace '{branch_name}' created successfully![/green]\n")
+        if env_examples:
+            console.print(f"Generated .env files from {len(env_examples)} template(s)")
+        else:
+            console.print("No .env files generated (no .env.example templates found)")
+        console.print("Navigate to your new environment with:")
+        try:
+            relative_path = worktree_path.relative_to(Path.cwd())
+            console.print(f"  [cyan]cd {relative_path}[/cyan]")
+        except ValueError:
+            # If worktree_path is not relative to current directory, show absolute path
+            console.print(f"  [cyan]cd {worktree_path}[/cyan]")
+
+    # Exit successfully
+    raise typer.Exit(0)

{sprout_cli-0.3.0 → sprout_cli-0.5.0}/src/sprout/utils.py

@@ -83,8 +83,8 @@ def get_used_ports() -> PortSet:
     if not sprout_dir.exists():
         return used_ports
 
-    # Scan all .env files in .sprout/*/
-    for env_file in sprout_dir.glob("*/.env"):
+    # Scan all .env files recursively in .sprout/
+    for env_file in sprout_dir.rglob("*.env"):
         if env_file.is_file():
             try:
                 content = env_file.read_text()
@@ -125,8 +125,16 @@ def find_available_port() -> PortNumber:
     raise SproutError("Could not find an available port after 1000 attempts")
 
 
-def parse_env_template(template_path: Path, silent: bool = False) -> str:
-    """Parse .env.example template and process placeholders."""
+def parse_env_template(
+    template_path: Path, silent: bool = False, used_ports: PortSet | None = None
+) -> str:
+    """Parse .env.example template and process placeholders.
+
+    Args:
+        template_path: Path to the .env.example template file
+        silent: If True, use stderr for prompts to keep stdout clean
+        used_ports: Set of ports already in use (in addition to system-wide used ports)
+    """
     if not template_path.exists():
         raise SproutError(f".env.example file not found at {template_path}")
 
@@ -138,6 +146,9 @@ def parse_env_template(template_path: Path, silent: bool = False) -> str:
     lines: list[str] = []
     # Track used ports within this file to avoid duplicates
     file_ports: PortSet = set()
+    # Include any additional used ports passed in
+    if used_ports:
+        file_ports.update(used_ports)
 
     for line in content.splitlines():
         # Process {{ auto_port() }} placeholders
@@ -156,13 +167,24 @@ def parse_env_template(template_path: Path, silent: bool = False) -> str:
             # Check environment variable first
             value = os.environ.get(var_name)
             if value is None:
-                # Prompt user for value
+                # Create a relative path for display
+                try:
+                    display_path = template_path.relative_to(Path.cwd())
+                except ValueError:
+                    display_path = template_path
+
+                # Prompt user for value with file context
                 if silent:
                     # Use stderr for prompts in silent mode to keep stdout clean
-                    typer.echo(f"Enter a value for '{var_name}': ", err=True, nl=False)
+                    prompt = f"Enter a value for '{var_name}' (from {display_path}): "
+                    typer.echo(prompt, err=True, nl=False)
                     value = input()
                 else:
-                    value = console.input(f"Enter a value for '{var_name}': ")
+                    prompt = (
+                        f"Enter a value for '[cyan]{var_name}[/cyan]' "
+                        f"(from [dim]{display_path}[/dim]): "
+                    )
+                    value = console.input(prompt)
             return value
 
         line = re.sub(r"{{\s*([^}]+)\s*}}", replace_variable, line)

{sprout_cli-0.3.0 → sprout_cli-0.5.0}/tests/test_commands.py

@@ -38,6 +38,18 @@ class TestCreateCommand:
 
         # Mock command execution
         mock_run = mocker.patch("sprout.commands.create.run_command")
+        # Mock git ls-files to return .env.example
+        mock_run.side_effect = lambda cmd, **kwargs: (
+            Mock(stdout=".env.example\n", returncode=0)
+            if cmd[1] == "ls-files"
+            else Mock(returncode=0)
+        )
+        # Mock git ls-files to return .env.example
+        mock_run.side_effect = lambda cmd, **kwargs: (
+            Mock(stdout=".env.example\n", returncode=0)
+            if cmd[1] == "ls-files"
+            else Mock(returncode=0)
+        )
 
         # Run command
         result = runner.invoke(app, ["create", "feature-branch"])
@@ -84,6 +96,12 @@ class TestCreateCommand:
 
         # Mock command execution
         mock_run = mocker.patch("sprout.commands.create.run_command")
+        # Mock git ls-files to return .env.example
+        mock_run.side_effect = lambda cmd, **kwargs: (
+            Mock(stdout=".env.example\n", returncode=0)
+            if cmd[1] == "ls-files"
+            else Mock(returncode=0)
+        )
 
         # Run command with --path flag
         result = runner.invoke(app, ["create", "feature-branch", "--path"])
@@ -108,35 +126,80 @@ class TestCreateCommand:
         # stdout should be empty
         assert result.stdout == ""
 
-    def test_create_no_env_example(self, mocker):
-        """Test error when .env.example doesn't exist."""
+    def test_create_no_env_example(self, mocker, tmp_path):
+        """Test success when .env.example doesn't exist."""
         mocker.patch("sprout.commands.create.is_git_repository", return_value=True)
-        mocker.patch("sprout.commands.create.get_git_root", return_value=Path("/project"))
+        mock_git_root = tmp_path / "project"
+        mock_git_root.mkdir()
+        mocker.patch("sprout.commands.create.get_git_root", return_value=mock_git_root)
+        mocker.patch("sprout.commands.create.worktree_exists", return_value=False)
+        sprout_dir = tmp_path / ".sprout"
+        sprout_dir.mkdir()
+        mocker.patch("sprout.commands.create.ensure_sprout_dir", return_value=sprout_dir)
+        mocker.patch("sprout.commands.create.branch_exists", return_value=False)
 
-        mock_env_example = Mock()
-        mock_env_example.exists.return_value = False
-        mocker.patch("pathlib.Path.__truediv__", return_value=mock_env_example)
+        # Mock git ls-files to return empty list (no .env.example files)
+        mock_run = mocker.patch("sprout.commands.create.run_command")
+        mock_run.return_value = Mock(stdout="", returncode=0)
 
-        result = runner.invoke(app, ["create", "feature-branch"])
+        # Change to project directory to make relative path calculation work
+        import os
 
-        assert result.exit_code == 1
-        assert ".env.example file not found" in result.stdout
+        old_cwd = os.getcwd()
+        os.chdir(str(mock_git_root))
+
+        try:
+            result = runner.invoke(app, ["create", "feature-branch"])
+
+            assert result.exit_code == 0
+            assert "Warning: No .env.example files found" in result.stdout
+            assert "Workspace 'feature-branch' created successfully!" in result.stdout
+            assert "No .env files generated (no .env.example templates found)" in result.stdout
+        finally:
+            os.chdir(old_cwd)
 
     def test_create_worktree_exists(self, mocker):
         """Test error when worktree already exists."""
         mocker.patch("sprout.commands.create.is_git_repository", return_value=True)
-        mocker.patch("sprout.commands.create.get_git_root", return_value=Path("/project"))
+        mock_git_root = Path("/project")
+        mocker.patch("sprout.commands.create.get_git_root", return_value=mock_git_root)
         mocker.patch("sprout.commands.create.worktree_exists", return_value=True)
 
-        mock_env_example = Mock()
-        mock_env_example.exists.return_value = True
-        mocker.patch("pathlib.Path.__truediv__", return_value=mock_env_example)
+        # Mock git ls-files to return .env.example
+        mock_run = mocker.patch("sprout.commands.create.run_command")
+        mock_run.return_value = Mock(stdout=".env.example\n", returncode=0)
+
+        # Mock Path.exists to return True for .env.example
+        mock_exists = mocker.patch("pathlib.Path.exists")
+        mock_exists.return_value = True
 
         result = runner.invoke(app, ["create", "feature-branch"])
 
         assert result.exit_code == 1
         assert "Worktree for branch 'feature-branch' already exists" in result.stdout
 
+    def test_create_without_env_example_path_mode(self, mocker, tmp_path):
+        """Test path mode with no .env.example files."""
+        mocker.patch("sprout.commands.create.is_git_repository", return_value=True)
+        mock_git_root = tmp_path / "project"
+        mock_git_root.mkdir()
+        mocker.patch("sprout.commands.create.get_git_root", return_value=mock_git_root)
+        mocker.patch("sprout.commands.create.worktree_exists", return_value=False)
+        sprout_dir = tmp_path / ".sprout"
+        sprout_dir.mkdir()
+        mocker.patch("sprout.commands.create.ensure_sprout_dir", return_value=sprout_dir)
+        mocker.patch("sprout.commands.create.branch_exists", return_value=False)
+
+        # Mock git ls-files to return empty list (no .env.example files)
+        mock_run = mocker.patch("sprout.commands.create.run_command")
+        mock_run.return_value = Mock(stdout="", returncode=0)
+
+        result = runner.invoke(app, ["create", "feature-branch", "--path"])
+
+        assert result.exit_code == 0
+        # In path mode, only the path should be printed to stdout
+        assert result.stdout.strip() == str(sprout_dir / "feature-branch")
+
 
 class TestLsCommand:
     """Test sprout ls command."""

{sprout_cli-0.3.0 → sprout_cli-0.5.0}/tests/test_integration.py

@@ -57,6 +57,10 @@ def git_repo(tmp_path):
         "COMPOSE_VAR=${COMPOSE_VAR:-default}\n"
     )
 
+    # Add .env.example to git
+    subprocess.run(["git", "add", ".env.example"], cwd=tmp_path, check=True)
+    subprocess.run(["git", "commit", "-m", "Add .env.example"], cwd=tmp_path, check=True)
+
     return tmp_path, default_branch
 
 
@@ -84,6 +88,10 @@ class TestIntegrationWorkflow:
             "COMPOSE_VAR=${COMPOSE_VAR:-default}\n"
         )
 
+        # Add to git
+        subprocess.run(["git", "add", ".env.example"], cwd=git_repo, check=True)
+        subprocess.run(["git", "commit", "-m", "Add .env.example"], cwd=git_repo, check=True)
+
         # Create worktree - SECRET_TOKEN should be prompted but we can't test that
         # So let's set it too
         monkeypatch.setenv("SECRET_TOKEN", "secret123")
@@ -215,11 +223,12 @@ class TestIntegrationWorkflow:
         result = runner.invoke(app, ["path", "nonexistent"])
         assert result.exit_code == 1
 
-        # Remove .env.example and try to create
+        # Remove .env.example and try to create (should succeed now)
         (git_repo / ".env.example").unlink()
         result = runner.invoke(app, ["create", "another-branch"])
-        assert result.exit_code == 1
-        assert ".env.example file not found" in result.stdout
+        assert result.exit_code == 0
+        assert "Warning: No .env.example files found" in result.stdout
+        assert "Workspace 'another-branch' created successfully!" in result.stdout
 
         # Test outside git repo using a separate temp directory
         import tempfile

sprout_cli-0.5.0/tests/test_multi_env.py

@@ -0,0 +1,190 @@
+"""Tests for multiple .env.example files functionality."""
+
+import subprocess
+
+from typer.testing import CliRunner
+
+from sprout.cli import app
+from sprout.utils import get_used_ports
+
+from .test_integration import git_repo  # noqa: F401
+
+runner = CliRunner()
+
+
+class TestMultipleEnvExamples:
+    """Test handling of multiple .env.example files."""
+
+    def test_create_with_multiple_env_examples(self, git_repo, monkeypatch):  # noqa: F811
+        """Test creating worktree with multiple .env.example files."""
+        git_repo, default_branch = git_repo
+        monkeypatch.chdir(git_repo)
+        monkeypatch.setenv("API_KEY", "test_key")
+        monkeypatch.setenv("DB_PASSWORD", "test_password")
+
+        # Create service directories with .env.example files
+        service_a = git_repo / "service-a"
+        service_a.mkdir()
+        (service_a / ".env.example").write_text("""# Service A Configuration
+API_KEY={{ API_KEY }}
+API_PORT={{ auto_port() }}
+""")
+
+        service_b = git_repo / "service-b"
+        service_b.mkdir()
+        (service_b / ".env.example").write_text("""# Service B Configuration
+DB_PASSWORD={{ DB_PASSWORD }}
+DB_PORT={{ auto_port() }}
+""")
+
+        # Add files to git
+        subprocess.run(["git", "add", "."], cwd=git_repo, check=True)
+        subprocess.run(["git", "commit", "-m", "Add services"], cwd=git_repo, check=True)
+
+        # Create worktree
+        result = runner.invoke(app, ["create", "feature-multi"])
+        assert result.exit_code == 0
+        assert "Generating .env files from 3 template(s)" in result.stdout
+
+        # Check that all .env files were created with correct structure
+        worktree_path = git_repo / ".sprout" / "feature-multi"
+        assert (worktree_path / ".env").exists()
+        assert (worktree_path / "service-a" / ".env").exists()
+        assert (worktree_path / "service-b" / ".env").exists()
+
+        # Check content
+        root_env = (worktree_path / ".env").read_text()
+        assert "API_KEY=test_key" in root_env
+
+        service_a_env = (worktree_path / "service-a" / ".env").read_text()
+        assert "API_KEY=test_key" in service_a_env
+        assert "API_PORT=" in service_a_env
+
+        service_b_env = (worktree_path / "service-b" / ".env").read_text()
+        assert "DB_PASSWORD=test_password" in service_b_env
+        assert "DB_PORT=" in service_b_env
+
+    def test_port_uniqueness_across_services(self, git_repo, monkeypatch):  # noqa: F811
+        """Test that auto_port() generates unique ports across all services."""
+        git_repo, default_branch = git_repo
+        monkeypatch.chdir(git_repo)
+        monkeypatch.setenv("API_KEY", "test_key")  # Set env var for root .env.example
+
+        # Create multiple services with port requirements
+        for i in range(3):
+            service_dir = git_repo / f"service-{i}"
+            service_dir.mkdir()
+            (service_dir / ".env.example").write_text(f"""# Service {i}
+PORT1={{{{ auto_port() }}}}
+PORT2={{{{ auto_port() }}}}
+""")
+
+        # Add files to git
+        subprocess.run(["git", "add", "."], cwd=git_repo, check=True)
+        subprocess.run(["git", "commit", "-m", "Add services"], cwd=git_repo, check=True)
+
+        # Create worktree
+        result = runner.invoke(app, ["create", "test-ports"])
+        assert result.exit_code == 0
+
+        # Collect all ports
+        all_ports = set()
+        worktree_path = git_repo / ".sprout" / "test-ports"
+
+        for i in range(3):
+            env_content = (worktree_path / f"service-{i}" / ".env").read_text()
+            lines = env_content.strip().split("\n")
+            for line in lines:
+                if "=" in line and not line.startswith("#"):
+                    port = int(line.split("=")[1])
+                    assert port not in all_ports, f"Port {port} is duplicated"
+                    all_ports.add(port)
+
+        # Should have 6 unique ports (2 per service × 3 services)
+        assert len(all_ports) == 6
+
+    def test_global_port_uniqueness_across_worktrees(self, git_repo, monkeypatch):  # noqa: F811
+        """Test that ports are unique across different worktrees."""
+        git_repo, default_branch = git_repo
+        monkeypatch.chdir(git_repo)
+        monkeypatch.setenv("API_KEY", "test_key")  # Set env var for root .env.example
+
+        # Create service with ports
+        service_dir = git_repo / "service"
+        service_dir.mkdir()
+        (service_dir / ".env.example").write_text("""
+PORT1={{ auto_port() }}
+PORT2={{ auto_port() }}
+""")
+
+        # Add files to git
+        subprocess.run(["git", "add", "."], cwd=git_repo, check=True)
+        subprocess.run(["git", "commit", "-m", "Add service"], cwd=git_repo, check=True)
+
+        # Create first worktree
+        result = runner.invoke(app, ["create", "branch1"])
+        assert result.exit_code == 0
+
+        # Get ports from first worktree
+        env1 = (git_repo / ".sprout" / "branch1" / "service" / ".env").read_text()
+        ports1 = set()
+        for line in env1.strip().split("\n"):
+            if "=" in line and not line.startswith("#"):
+                ports1.add(int(line.split("=")[1]))
+
+        # Create second worktree
+        result = runner.invoke(app, ["create", "branch2"])
+        assert result.exit_code == 0
+
+        # Get ports from second worktree
+        env2 = (git_repo / ".sprout" / "branch2" / "service" / ".env").read_text()
+        ports2 = set()
+        for line in env2.strip().split("\n"):
+            if "=" in line and not line.startswith("#"):
+                ports2.add(int(line.split("=")[1]))
+
+        # Ensure no overlap
+        assert len(ports1.intersection(ports2)) == 0, "Ports should not overlap between worktrees"
+
+    def test_nested_directory_structure(self, git_repo, monkeypatch):  # noqa: F811
+        """Test handling of nested directory structures."""
+        git_repo, default_branch = git_repo
+        monkeypatch.chdir(git_repo)
+        monkeypatch.setenv("API_KEY", "test_key")  # Set env var for root .env.example
+
+        # Create nested structure
+        nested_path = git_repo / "services" / "backend" / "api"
+        nested_path.mkdir(parents=True)
+        (nested_path / ".env.example").write_text("NESTED_PORT={{ auto_port() }}")
+
+        # Add files to git
+        subprocess.run(["git", "add", "."], cwd=git_repo, check=True)
+        subprocess.run(["git", "commit", "-m", "Add nested service"], cwd=git_repo, check=True)
+
+        # Create worktree
+        result = runner.invoke(app, ["create", "nested-test"])
+        assert result.exit_code == 0
+
+        # Check nested .env was created
+        worktree_path = git_repo / ".sprout" / "nested-test"
+        nested_env_path = worktree_path / "services" / "backend" / "api" / ".env"
+        assert nested_env_path.exists()
+        assert "NESTED_PORT=" in nested_env_path.read_text()
+
+    def test_get_used_ports_recursive(self, tmp_path, monkeypatch):
+        """Test that get_used_ports now searches recursively."""
+        monkeypatch.setattr("sprout.utils.get_sprout_dir", lambda: tmp_path)
+
+        # Create nested structure with .env files
+        (tmp_path / "branch1").mkdir()
+        (tmp_path / "branch1" / ".env").write_text("PORT1=8080")
+
+        (tmp_path / "branch1" / "service-a").mkdir()
+        (tmp_path / "branch1" / "service-a" / ".env").write_text("PORT2=8081")
+
+        (tmp_path / "branch2" / "nested" / "deep").mkdir(parents=True)
+        (tmp_path / "branch2" / "nested" / "deep" / ".env").write_text("PORT3=8082")
+
+        # Test recursive port collection
+        ports = get_used_ports()
+        assert ports == {8080, 8081, 8082}

sprout_cli-0.3.0/src/sprout/commands/create.py

@@ -1,114 +0,0 @@
-"""Implementation of the create command."""
-
-from pathlib import Path
-from typing import Never
-
-import typer
-from rich.console import Console
-
-from sprout.exceptions import SproutError
-from sprout.types import BranchName
-from sprout.utils import (
-    branch_exists,
-    ensure_sprout_dir,
-    get_git_root,
-    is_git_repository,
-    parse_env_template,
-    run_command,
-    worktree_exists,
-)
-
-console = Console()
-
-
-def create_worktree(branch_name: BranchName, path_only: bool = False) -> Never:
-    """Create a new worktree with development environment."""
-    # Check prerequisites
-    if not is_git_repository():
-        if not path_only:
-            console.print("[red]Error: Not in a git repository[/red]")
-            console.print("Please run this command from the root of a git repository.")
-        else:
-            typer.echo("Error: Not in a git repository", err=True)
-        raise typer.Exit(1)
-
-    git_root = get_git_root()
-    env_example = git_root / ".env.example"
-
-    if not env_example.exists():
-        if not path_only:
-            console.print("[red]Error: .env.example file not found[/red]")
-            console.print(f"Expected at: {env_example}")
-        else:
-            typer.echo(f"Error: .env.example file not found at {env_example}", err=True)
-        raise typer.Exit(1)
-
-    # Check if worktree already exists
-    if worktree_exists(branch_name):
-        if not path_only:
-            console.print(f"[red]Error: Worktree for branch '{branch_name}' already exists[/red]")
-        else:
-            typer.echo(f"Error: Worktree for branch '{branch_name}' already exists", err=True)
-        raise typer.Exit(1)
-
-    # Ensure .sprout directory exists
-    sprout_dir = ensure_sprout_dir()
-    worktree_path = sprout_dir / branch_name
-
-    # Create the worktree
-    if not path_only:
-        console.print(f"Creating worktree for branch [cyan]{branch_name}[/cyan]...")
-
-    # Check if branch exists, create if it doesn't
-    if not branch_exists(branch_name):
-        if not path_only:
-            console.print(f"Branch '{branch_name}' doesn't exist. Creating new branch...")
-        # Create branch with -b flag
-        cmd = ["git", "worktree", "add", "-b", branch_name, str(worktree_path)]
-    else:
-        cmd = ["git", "worktree", "add", str(worktree_path), branch_name]
-
-    try:
-        run_command(cmd)
-    except SproutError as e:
-        if not path_only:
-            console.print(f"[red]Error creating worktree: {e}[/red]")
-        else:
-            typer.echo(f"Error creating worktree: {e}", err=True)
-        raise typer.Exit(1) from e
-
-    # Generate .env file
-    if not path_only:
-        console.print("Generating .env file...")
-    try:
-        env_content = parse_env_template(env_example, silent=path_only)
-        env_file = worktree_path / ".env"
-        env_file.write_text(env_content)
-    except SproutError as e:
-        if not path_only:
-            console.print(f"[red]Error generating .env file: {e}[/red]")
-        else:
-            typer.echo(f"Error generating .env file: {e}", err=True)
-        # Clean up worktree on failure
-        run_command(["git", "worktree", "remove", str(worktree_path)], check=False)
-        raise typer.Exit(1) from e
-    except KeyboardInterrupt:
-        if not path_only:
-            console.print("\n[yellow]Cancelled by user[/yellow]")
-        else:
-            typer.echo("Cancelled by user", err=True)
-        # Clean up worktree on cancellation
-        run_command(["git", "worktree", "remove", str(worktree_path)], check=False)
-        raise typer.Exit(130) from None
-
-    # Success message or path output
-    if path_only:
-        # Output only the path for shell command substitution
-        print(str(worktree_path))
-    else:
-        console.print(f"\n[green]✅ Workspace '{branch_name}' created successfully![/green]\n")
-        console.print("Navigate to your new environment with:")
-        console.print(f"  [cyan]cd {worktree_path.relative_to(Path.cwd())}[/cyan]")
-
-    # Exit successfully
-    raise typer.Exit(0)