sprout-cli 0.2.0__py3-none-any.whl

sprout/__init__.py

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

sprout/__main__.py

@@ -0,0 +1,13 @@
+#!/usr/bin/env python3
+"""Entry point for the sprout CLI."""
+
+from sprout.cli import app
+
+
+def main() -> None:
+    """Run the sprout CLI application."""
+    app()
+
+
+if __name__ == "__main__":
+    main()

sprout/cli.py

@@ -0,0 +1,83 @@
+"""Main CLI interface for sprout."""
+
+import typer
+from rich.console import Console
+
+from sprout import __version__
+from sprout.commands.create import create_worktree
+from sprout.commands.ls import list_worktrees
+from sprout.commands.path import get_worktree_path
+from sprout.commands.rm import remove_worktree
+from sprout.types import BranchName
+
+app = typer.Typer(
+    name="sprout",
+    help="CLI tool to automate git worktree and Docker Compose development workflows.",
+    add_completion=False,
+)
+console = Console()
+
+
+def version_callback(value: bool) -> None:
+    """Show version and exit."""
+    if value:
+        console.print(f"sprout version {__version__}")
+        raise typer.Exit()
+
+
+@app.callback()
+def callback(
+    version: bool = typer.Option(
+        None,
+        "--version",
+        "-v",
+        help="Show version and exit.",
+        callback=version_callback,
+        is_eager=True,
+    ),
+) -> None:
+    """sprout - Manage git worktrees with Docker Compose environments."""
+    pass
+
+
+@app.command()
+def create(
+    branch_name: BranchName = typer.Argument(
+        ...,
+        help="Name of the branch to create worktree for",
+    ),
+) -> None:
+    """Create a new development environment."""
+    create_worktree(branch_name)
+
+
+@app.command()
+def ls() -> None:
+    """List all managed development environments."""
+    list_worktrees()
+
+
+@app.command()
+def rm(
+    branch_name: BranchName = typer.Argument(
+        ...,
+        help="Name of the branch to remove",
+    ),
+) -> None:
+    """Remove a development environment."""
+    remove_worktree(branch_name)
+
+
+@app.command()
+def path(
+    branch_name: BranchName = typer.Argument(
+        ...,
+        help="Name of the branch to get path for",
+    ),
+) -> None:
+    """Get the path of a development environment."""
+    get_worktree_path(branch_name)
+
+
+if __name__ == "__main__":
+    app()

sprout/commands/__init__.py

@@ -0,0 +1 @@
+"""Command implementations for sprout."""

sprout/commands/create.py

@@ -0,0 +1,89 @@
+"""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) -> Never:
+    """Create a new worktree with development environment."""
+    # Check prerequisites
+    if not is_git_repository():
+        console.print("[red]Error: Not in a git repository[/red]")
+        console.print("Please run this command from the root of a git repository.")
+        raise typer.Exit(1)
+
+    git_root = get_git_root()
+    env_example = git_root / ".env.example"
+
+    if not env_example.exists():
+        console.print("[red]Error: .env.example file not found[/red]")
+        console.print(f"Expected at: {env_example}")
+        raise typer.Exit(1)
+
+    # Check if worktree already exists
+    if worktree_exists(branch_name):
+        console.print(f"[red]Error: Worktree for branch '{branch_name}' already exists[/red]")
+        raise typer.Exit(1)
+
+    # Ensure .sprout directory exists
+    sprout_dir = ensure_sprout_dir()
+    worktree_path = sprout_dir / branch_name
+
+    # Create the worktree
+    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):
+        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:
+        console.print(f"[red]Error creating worktree: {e}[/red]")
+        raise typer.Exit(1) from e
+
+    # Generate .env file
+    console.print("Generating .env file...")
+    try:
+        env_content = parse_env_template(env_example)
+        env_file = worktree_path / ".env"
+        env_file.write_text(env_content)
+    except SproutError as e:
+        console.print(f"[red]Error generating .env file: {e}[/red]")
+        # Clean up worktree on failure
+        run_command(["git", "worktree", "remove", str(worktree_path)], check=False)
+        raise typer.Exit(1) from e
+    except KeyboardInterrupt:
+        console.print("\n[yellow]Cancelled by user[/yellow]")
+        # Clean up worktree on cancellation
+        run_command(["git", "worktree", "remove", str(worktree_path)], check=False)
+        raise typer.Exit(130) from None
+
+    # Success message
+    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)

sprout/commands/ls.py

@@ -0,0 +1,93 @@
+"""Implementation of the ls command."""
+
+from datetime import datetime
+from pathlib import Path
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from sprout.exceptions import SproutError
+from sprout.types import WorktreeInfo
+from sprout.utils import get_sprout_dir, is_git_repository, run_command
+
+console = Console()
+
+
+def list_worktrees() -> None:
+    """List all managed development environments."""
+    if not is_git_repository():
+        console.print("[red]Error: Not in a git repository[/red]")
+        raise typer.Exit(1)
+
+    sprout_dir = get_sprout_dir()
+
+    # Get worktree list from git
+    try:
+        result = run_command(["git", "worktree", "list", "--porcelain"])
+    except SproutError as e:
+        console.print(f"[red]Error listing worktrees: {e}[/red]")
+        raise typer.Exit(1) from e
+
+    # Parse worktree output
+    worktrees: list[WorktreeInfo] = []
+    current_worktree: WorktreeInfo = {}
+
+    for line in result.stdout.strip().split("\n"):
+        if not line:
+            if current_worktree:
+                worktrees.append(current_worktree)
+                current_worktree = {}
+            continue
+
+        if line.startswith("worktree "):
+            current_worktree["path"] = Path(line[9:])
+        elif line.startswith("branch "):
+            current_worktree["branch"] = line[7:]
+        elif line.startswith("HEAD "):
+            current_worktree["head"] = line[5:]
+
+    if current_worktree:
+        worktrees.append(current_worktree)
+
+    # Filter for sprout-managed worktrees
+    sprout_worktrees: list[WorktreeInfo] = []
+    current_path = Path.cwd().resolve()
+
+    for wt in worktrees:
+        wt_path = wt["path"].resolve()
+        if wt_path.parent == sprout_dir:
+            # Check if we're currently in this worktree
+            wt["is_current"] = current_path == wt_path or current_path.is_relative_to(wt_path)
+
+            # Get last modified time
+            if wt_path.exists():
+                stat = wt_path.stat()
+                wt["modified"] = datetime.fromtimestamp(stat.st_mtime)
+            else:
+                wt["modified"] = None
+
+            sprout_worktrees.append(wt)
+
+    if not sprout_worktrees:
+        console.print("[yellow]No sprout-managed worktrees found.[/yellow]")
+        console.print("Use 'sprout create <branch-name>' to create one.")
+        return None
+
+    # Create table
+    table = Table(title="Sprout Worktrees", show_lines=True)
+    table.add_column("Branch", style="cyan", no_wrap=True)
+    table.add_column("Path", style="blue")
+    table.add_column("Status", style="green")
+    table.add_column("Last Modified", style="yellow")
+
+    for wt in sprout_worktrees:
+        branch = wt.get("branch", wt.get("head", "detached"))
+        path = str(wt["path"].relative_to(Path.cwd()))
+        status = "[green]● current[/green]" if wt["is_current"] else ""
+        modified_dt = wt.get("modified")
+        modified = modified_dt.strftime("%Y-%m-%d %H:%M") if modified_dt else "N/A"
+
+        table.add_row(branch, path, status, modified)
+
+    console.print(table)

sprout/commands/path.py

@@ -0,0 +1,28 @@
+"""Implementation of the path command."""
+
+from typing import Never, TextIO
+
+import typer
+
+from sprout.types import BranchName
+from sprout.utils import get_sprout_dir, is_git_repository, worktree_exists
+
+console: TextIO = typer.get_text_stream("stdout")
+
+
+def get_worktree_path(branch_name: BranchName) -> Never:
+    """Get the path of a development environment."""
+    if not is_git_repository():
+        typer.echo("Error: Not in a git repository", err=True)
+        raise typer.Exit(1)
+
+    # Check if worktree exists
+    if not worktree_exists(branch_name):
+        typer.echo(f"Error: Worktree for branch '{branch_name}' does not exist", err=True)
+        raise typer.Exit(1)
+
+    worktree_path = get_sprout_dir() / branch_name
+
+    # Output only the path, no extra formatting
+    print(str(worktree_path))
+    raise typer.Exit(0)

sprout/commands/rm.py

@@ -0,0 +1,84 @@
+"""Implementation of the rm command."""
+
+import typer
+from rich.console import Console
+
+from sprout.exceptions import SproutError
+from sprout.types import BranchName
+from sprout.utils import (
+    get_sprout_dir,
+    is_git_repository,
+    run_command,
+    worktree_exists,
+)
+
+console = Console()
+
+
+def remove_worktree(branch_name: BranchName) -> None:
+    """Remove a development environment."""
+    if not is_git_repository():
+        console.print("[red]Error: Not in a git repository[/red]")
+        raise typer.Exit(1)
+
+    # Check if worktree exists
+    if not worktree_exists(branch_name):
+        console.print(f"[red]Error: Worktree for branch '{branch_name}' does not exist[/red]")
+        raise typer.Exit(1)
+
+    worktree_path = get_sprout_dir() / branch_name
+
+    # Confirm removal
+    if not typer.confirm(
+        f"Are you sure you want to remove the worktree for branch '{branch_name}'?"
+    ):
+        console.print("[yellow]Cancelled[/yellow]")
+        raise typer.Exit(0)
+
+    # Remove worktree
+    console.print(f"Removing worktree for branch [cyan]{branch_name}[/cyan]...")
+    try:
+        result = run_command(["git", "worktree", "remove", str(worktree_path)], check=False)
+        if result.returncode != 0:
+            # Try force removal if normal removal fails
+            result = run_command(
+                ["git", "worktree", "remove", "--force", str(worktree_path)], check=False
+            )
+            if result.returncode != 0:
+                console.print(f"[red]Error removing worktree: {result.stderr}[/red]")
+                raise typer.Exit(1)
+        console.print("[green]✅ Worktree removed successfully[/green]")
+    except SproutError as e:
+        console.print(f"[red]Error removing worktree: {e}[/red]")
+        raise typer.Exit(1) from e
+
+    # Ask about branch deletion
+    try:
+        if typer.confirm(f"Do you also want to delete the git branch '{branch_name}'?"):
+            try:
+                # Try normal deletion first
+                result = run_command(["git", "branch", "-d", branch_name], check=False)
+                if result.returncode != 0:
+                    # If normal deletion fails, show the error and ask about force delete
+                    console.print(f"[yellow]Warning: {result.stderr.strip()}[/yellow]")
+                    if typer.confirm("Force delete the branch?"):
+                        run_command(["git", "branch", "-D", branch_name])
+                        console.print("[green]✅ Branch deleted successfully[/green]")
+                    else:
+                        console.print("[yellow]Branch deletion cancelled[/yellow]")
+                else:
+                    console.print("[green]✅ Branch deleted successfully[/green]")
+            except SproutError as e:
+                console.print(f"[red]Error deleting branch: {e}[/red]")
+                console.print(
+                    "[yellow]Note: The worktree has been removed, "
+                    "but the branch still exists[/yellow]"
+                )
+    except Exception as e:
+        # Catch any exception during the confirmation prompt
+        console.print(f"[red]Error during branch deletion prompt: {e}[/red]")
+        # Don't fail the whole command if branch deletion has issues
+        pass
+
+    # Exit successfully - return instead of raising Exit for proper testing
+    return

sprout/exceptions.py

@@ -0,0 +1,12 @@
+"""Custom exceptions for sprout."""
+
+from typing import Any
+
+
+class SproutError(Exception):
+    """Base exception for sprout errors."""
+
+    def __init__(self, message: str, *args: Any) -> None:
+        """Initialize the exception with a message."""
+        super().__init__(message, *args)
+        self.message = message

sprout/types.py

@@ -0,0 +1,28 @@
+"""Type definitions for sprout."""
+
+from datetime import datetime
+from pathlib import Path
+from typing import TypeAlias, TypedDict
+
+# Type aliases
+BranchName: TypeAlias = str
+WorktreePath: TypeAlias = Path
+EnvContent: TypeAlias = str
+
+
+class WorktreeInfo(TypedDict, total=False):
+    """Information about a git worktree."""
+
+    path: Path
+    branch: str | None
+    head: str | None
+    is_current: bool
+    modified: datetime | None
+
+
+class GitWorktreeOutput(TypedDict):
+    """Parsed output from git worktree list."""
+
+    path: Path
+    branch: str | None
+    head: str | None

sprout/utils.py

@@ -0,0 +1,177 @@
+"""Common utilities for sprout."""
+
+import os
+import random
+import re
+import socket
+import subprocess
+from pathlib import Path
+from typing import TypeAlias
+
+from rich.console import Console
+
+from sprout.exceptions import SproutError
+from sprout.types import BranchName
+
+# Type aliases
+PortNumber: TypeAlias = int
+PortSet: TypeAlias = set[PortNumber]
+
+console = Console()
+
+
+def is_git_repository() -> bool:
+    """Check if current directory is inside a git repository."""
+    try:
+        result = subprocess.run(
+            ["git", "rev-parse", "--git-dir"],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+        return result.returncode == 0
+    except (subprocess.SubprocessError, FileNotFoundError):
+        return False
+
+
+def get_git_root() -> Path:
+    """Get the root directory of the git repository."""
+    if not is_git_repository():
+        raise SproutError("Not in a git repository")
+
+    result = subprocess.run(
+        ["git", "rev-parse", "--show-toplevel"],
+        capture_output=True,
+        text=True,
+        check=True,
+    )
+    return Path(result.stdout.strip())
+
+
+def run_command(cmd: list[str], check: bool = True) -> subprocess.CompletedProcess[str]:
+    """Run a command and return the result."""
+    try:
+        return subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            check=check,
+        )
+    except subprocess.CalledProcessError as e:
+        raise SproutError(f"Command failed: {' '.join(cmd)}\n{e.stderr}") from e
+
+
+def get_sprout_dir() -> Path:
+    """Get the .sprout directory path."""
+    return get_git_root() / ".sprout"
+
+
+def ensure_sprout_dir() -> Path:
+    """Ensure .sprout directory exists and return its path."""
+    sprout_dir = get_sprout_dir()
+    sprout_dir.mkdir(exist_ok=True)
+    return sprout_dir
+
+
+def get_used_ports() -> PortSet:
+    """Get all ports currently used by sprout worktrees."""
+    used_ports: PortSet = set()
+    sprout_dir = get_sprout_dir()
+
+    if not sprout_dir.exists():
+        return used_ports
+
+    # Scan all .env files in .sprout/*/
+    for env_file in sprout_dir.glob("*/.env"):
+        if env_file.is_file():
+            try:
+                content = env_file.read_text()
+                # Find all port assignments (e.g., PORT=8080)
+                port_matches = re.findall(r"=(\d{4,5})\b", content)
+                for port_str in port_matches:
+                    port = int(port_str)
+                    if 1024 <= port <= 65535:
+                        used_ports.add(port)
+            except (OSError, ValueError):
+                continue
+
+    return used_ports
+
+
+def is_port_available(port: PortNumber) -> bool:
+    """Check if a port is available for binding."""
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
+        try:
+            sock.bind(("127.0.0.1", port))
+            return True
+        except OSError:
+            return False
+
+
+def find_available_port() -> PortNumber:
+    """Find an available port that's not used by sprout or system."""
+    used_ports = get_used_ports()
+    max_attempts = 1000
+
+    for _ in range(max_attempts):
+        # Random port between 1024 and 65535
+        port = random.randint(1024, 65535)
+
+        if port not in used_ports and is_port_available(port):
+            return port
+
+    raise SproutError("Could not find an available port after 1000 attempts")
+
+
+def parse_env_template(template_path: Path) -> str:
+    """Parse .env.example template and process placeholders."""
+    if not template_path.exists():
+        raise SproutError(f".env.example file not found at {template_path}")
+
+    try:
+        content = template_path.read_text()
+    except OSError as e:
+        raise SproutError(f"Failed to read .env.example: {e}") from e
+
+    lines: list[str] = []
+    # Track used ports within this file to avoid duplicates
+    file_ports: PortSet = set()
+
+    for line in content.splitlines():
+        # Process {{ auto_port() }} placeholders
+        def replace_auto_port(match: re.Match[str]) -> str:
+            port = find_available_port()
+            while port in file_ports:
+                port = find_available_port()
+            file_ports.add(port)
+            return str(port)
+
+        line = re.sub(r"{{\s*auto_port\(\)\s*}}", replace_auto_port, line)
+
+        # Process {{ VARIABLE }} placeholders
+        def replace_variable(match: re.Match[str]) -> str:
+            var_name = match.group(1).strip()
+            # Check environment variable first
+            value = os.environ.get(var_name)
+            if value is None:
+                # Prompt user for value
+                value = console.input(f"Enter a value for '{var_name}': ")
+            return value
+
+        line = re.sub(r"{{\s*([^}]+)\s*}}", replace_variable, line)
+
+        lines.append(line)
+
+    return "\n".join(lines)
+
+
+def worktree_exists(branch_name: BranchName) -> bool:
+    """Check if a worktree already exists for the given branch."""
+    worktree_path = get_sprout_dir() / branch_name
+    return worktree_path.exists()
+
+
+def branch_exists(branch_name: BranchName) -> bool:
+    """Check if a git branch exists."""
+    result = run_command(["git", "rev-parse", "--verify", f"refs/heads/{branch_name}"], check=False)
+    return result.returncode == 0

sprout_cli-0.2.0.dist-info/METADATA

@@ -0,0 +1,182 @@
+Metadata-Version: 2.4
+Name: sprout-cli
+Version: 0.2.0
+Summary: CLI tool to automate git worktree and Docker Compose development workflows
+Author: SecDevLab Inc.
+License: MIT
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: Topic :: Software Development :: Version Control :: Git
+Requires-Python: >=3.11
+Requires-Dist: rich>=13.0.0
+Requires-Dist: typer>=0.9.0
+Provides-Extra: dev
+Requires-Dist: mypy>=1.5.0; extra == 'dev'
+Requires-Dist: pytest-cov>=4.0; extra == 'dev'
+Requires-Dist: pytest-mock>=3.0; extra == 'dev'
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Requires-Dist: ruff>=0.1.0; extra == 'dev'
+Requires-Dist: types-setuptools>=68.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# sprout
+
+A CLI tool to automate git worktree and Docker Compose development workflows.
+
+## Features
+
+- 🌱 Create isolated development environments using git worktrees
+- 🔧 Automatic `.env` file generation from templates
+- 🚢 Smart port allocation to avoid conflicts
+- 📁 Centralized worktree management in `.sprout/` directory
+- 🎨 Beautiful CLI interface with colors and tables
+
+## Installation
+
+```bash
+pip install sprout
+```
+
+For development:
+```bash
+# Clone the repository
+git clone https://github.com/SecDev-Lab/sprout.git
+cd sprout
+
+# Install in development mode
+pip install -e ".[dev]"
+```
+
+## Quick Start
+
+1. Create a `.env.example` template in your project root:
+```env
+# API Configuration
+API_KEY={{ API_KEY }}
+API_PORT={{ auto_port() }}
+
+# Database Configuration  
+DB_HOST=localhost
+DB_PORT={{ auto_port() }}
+
+# Example: Docker Compose variables (preserved as-is)
+# sprout will NOT process ${...} syntax - it's passed through unchanged
+# DB_NAME=${DB_NAME}
+```
+
+2. Create a new development environment:
+```bash
+sprout create feature-branch
+```
+
+3. Navigate to your new environment:
+```bash
+cd $(sprout path feature-branch)
+```
+
+4. Start your services:
+```bash
+docker compose up -d
+```
+
+## Commands
+
+### `sprout create <branch-name>`
+Create a new development environment with automated setup.
+
+### `sprout ls`
+List all managed development environments with their status.
+
+### `sprout rm <branch-name>`
+Remove a development environment (with confirmation prompts).
+
+### `sprout path <branch-name>`
+Get the filesystem path of a development environment.
+
+### `sprout --version`
+Show the version of sprout.
+
+## Template Syntax
+
+sprout supports two types of placeholders in `.env.example`:
+
+1. **Variable Placeholders**: `{{ VARIABLE_NAME }}`
+   - **First**: Checks if the variable exists in your environment (e.g., `export API_KEY=xxx`)
+   - **Then**: If not found in environment, prompts for user input
+   - Example: `{{ API_KEY }}` will use `$API_KEY` if set, otherwise asks you to enter it
+
+2. **Auto Port Assignment**: `{{ auto_port() }}`
+   - Automatically assigns available ports
+   - Avoids conflicts with other sprout environments
+   - Checks system port availability
+
+3. **Docker Compose Syntax (Preserved)**: `${VARIABLE}`
+   - NOT processed by sprout - passed through as-is
+   - Useful for Docker Compose variable substitution
+   - Example: `${DB_NAME:-default}` remains unchanged in generated `.env`
+
+### Environment Variable Resolution Example
+
+```bash
+# Set environment variable
+export API_KEY="my-secret-key"
+
+# Create sprout environment - API_KEY will be automatically used
+sprout create feature-branch
+# → API_KEY in .env will be set to "my-secret-key" without prompting
+
+# For unset variables, sprout will prompt
+sprout create another-branch
+# → Enter a value for 'DATABASE_URL': [user input required]
+```
+
+## Documentation
+
+- [Architecture Overview](docs/sprout-cli/overview.md) - Design philosophy, architecture, and implementation details
+- [Detailed Usage Guide](docs/sprout-cli/usage.md) - Comprehensive usage examples and troubleshooting
+
+## Development
+
+### Setup
+```bash
+# Install development dependencies
+make setup
+```
+
+### Testing
+```bash
+# Run tests
+make test
+
+# Run tests with coverage
+make test-cov
+```
+
+### Code Quality
+```bash
+# Run linter
+make lint
+
+# Format code
+make format
+
+# Run type checking
+make typecheck
+```
+
+## Requirements
+
+- Python 3.11+
+- Git
+- Docker Compose (optional, for Docker-based workflows)
+
+## License
+
+See LICENSE file.

sprout_cli-0.2.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+sprout/__init__.py,sha256=V8j_TQkzXee4z5xpA2Df1Ftxg7_nHaX9ziEIDvh9My8,114
+sprout/__main__.py,sha256=EmC6MLtl-OTnx1BNUe9QuWLaDrK1mWNAp8JvyYoJNKE,203
+sprout/cli.py,sha256=YfTeMqWvAIjUCc5KWV0FBk3wO30K7qgCL4Fsw2y1MoM,1869
+sprout/exceptions.py,sha256=eqF5Lu5kGqKG8TQgJOxHrbUoNdN5NhdM08ZFL77g3-w,322
+sprout/types.py,sha256=5r5FnaKELADni_ERN_ssle71QBwsjWgHO0abSLn0qx0,581
+sprout/utils.py,sha256=XTebUx-_w4No4vuT_mPweLDYGgGiQ_JsgglKkdJ0fdg,5296
+sprout/commands/__init__.py,sha256=79j9h82iK-jDI0RE7N1v4qaqG-HWBMTBn32BauSKxDk,42
+sprout/commands/create.py,sha256=CK6fQXipQq_-BN3rBw-fIJkcQ-dKTPnnd6gllbVs3V4,3044
+sprout/commands/ls.py,sha256=M9iDln9weYrHI_3k4AXrPLUq1tufYIfxiime68jb6vU,3083
+sprout/commands/path.py,sha256=beZmRegtlOwgg2EzijXh6SxdbrKY69PtQ6CpXJeNV_U,836
+sprout/commands/rm.py,sha256=736YuIP6qH6KRXO2Ls6Cl3V-68CyQXOQKz5Tg_6IwM8,3358
+sprout_cli-0.2.0.dist-info/METADATA,sha256=U3gmR5pPcST7yNwuQJFf04_g6LnXsFFfcHKb-yZmNds,4578
+sprout_cli-0.2.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+sprout_cli-0.2.0.dist-info/entry_points.txt,sha256=DZX8C87ZujVYIx_3a7A_WtMYQiilbRuDfGj8sN2Mw9E,48
+sprout_cli-0.2.0.dist-info/licenses/LICENSE,sha256=pj5IbIXKP9QvvhNPeVMwApeWIkW26t9A9BwgulzFtkI,1066
+sprout_cli-0.2.0.dist-info/RECORD,,

sprout_cli-0.2.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

sprout_cli-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+sprout = sprout.__main__:main

sprout_cli-0.2.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 SecDevLab
+
+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.