pymelos 0.1.3__py3-none-any.whl

pymelos/cli/commands/init.py

@@ -0,0 +1,151 @@
+"""Init command implementation."""
+
+from __future__ import annotations
+
+import contextlib
+import subprocess
+from pathlib import Path
+
+from pymelos.errors import ConfigurationError
+
+DEFAULT_PYMELOS_YAML = """# pymelos workspace configuration
+name: {name}
+
+packages:
+  - packages/*
+
+scripts:
+  test:
+    run: pytest tests/ -v
+    description: Run tests
+
+  lint:
+    run: ruff check .
+    description: Run linting
+
+  format:
+    run: ruff format .
+    description: Format code
+
+  typecheck:
+    run: type check
+    description: Run type checking
+
+command_defaults:
+  concurrency: 4
+  fail_fast: false
+  topological: true
+
+clean:
+  patterns:
+    - "__pycache__"
+    - "*.pyc"
+    - ".pytest_cache"
+    - ".mypy_cache"
+    - ".ruff_cache"
+    - "*.egg-info"
+    - "dist"
+    - "build"
+  protected:
+    - ".venv"
+    - ".git"
+
+versioning:
+  commit_format: conventional
+  tag_format: "{{name}}@{{version}}"
+  changelog:
+    enabled: true
+    filename: CHANGELOG.md
+"""
+
+DEFAULT_PYPROJECT_TOML = """[project]
+name = "{name}"
+version = "0.0.0"
+description = "Python monorepo"
+requires-python = ">=3.12"
+
+[tool.uv]
+workspace = {{ members = ["packages/*"] }}
+
+dev-dependencies = [
+    "pytest>=8.0.0",
+    "ruff>=0.8.0",
+    "mypy>=1.10.0",
+]
+"""
+
+
+def init_workspace(path: Path, name: str | None = None) -> None:
+    """Initialize a new pymelos workspace.
+
+    Args:
+        path: Directory to initialize.
+        name: Workspace name (defaults to directory name).
+
+    Raises:
+        ConfigurationError: If workspace already exists.
+    """
+    path = path.resolve()
+
+    if not path.exists():
+        path.mkdir(parents=True)
+
+    # Check if already initialized
+    if (path / "pymelos.yaml").exists():
+        raise ConfigurationError("Workspace already initialized", path=path / "pymelos.yaml")
+
+    # Use directory name as default
+    if not name:
+        name = path.name
+
+    # Create pymelos.yaml
+    pymelos_yaml = path / "pymelos.yaml"
+    pymelos_yaml.write_text(DEFAULT_PYMELOS_YAML.format(name=name), encoding="utf-8")
+
+    # Create pyproject.toml if it doesn't exist
+    pyproject = path / "pyproject.toml"
+    if not pyproject.exists():
+        pyproject.write_text(DEFAULT_PYPROJECT_TOML.format(name=name), encoding="utf-8")
+
+    # Create packages directory
+    packages_dir = path / "packages"
+    packages_dir.mkdir(exist_ok=True)
+
+    # Create .gitignore if it doesn't exist
+    gitignore = path / ".gitignore"
+    if not gitignore.exists():
+        gitignore.write_text(
+            """# Python
+__pycache__/
+*.py[cod]
+*.so
+.venv/
+dist/
+build/
+*.egg-info/
+
+# Testing
+.pytest_cache/
+.coverage
+htmlcov/
+
+# Type checking
+.mypy_cache/
+
+# Linting
+.ruff_cache/
+
+# IDE
+.vscode/
+.idea/
+
+# OS
+.DS_Store
+""",
+            encoding="utf-8",
+        )
+
+    # Initialize git if not already a repo
+    if not (path / ".git").exists():
+        with contextlib.suppress(subprocess.CalledProcessError, FileNotFoundError):
+            subprocess.run(["git", "init"], cwd=path, capture_output=True, check=True)

pymelos/commands/__init__.py

@@ -0,0 +1,84 @@
+"""pymelos commands."""
+
+from pymelos.commands.add import AddProjectCommand, AddProjectOptions, AddProjectResult, add_project
+from pymelos.commands.base import Command, CommandContext, SyncCommand
+from pymelos.commands.bootstrap import (
+    BootstrapCommand,
+    BootstrapOptions,
+    BootstrapResult,
+    bootstrap,
+)
+from pymelos.commands.changed import (
+    ChangedCommand,
+    ChangedOptions,
+    ChangedPackage,
+    ChangedResult,
+    get_changed_packages,
+)
+from pymelos.commands.clean import CleanCommand, CleanOptions, CleanResult, clean
+from pymelos.commands.exec import ExecCommand, ExecOptions, exec_command
+from pymelos.commands.list import (
+    ListCommand,
+    ListFormat,
+    ListOptions,
+    ListResult,
+    PackageInfo,
+    list_packages,
+)
+from pymelos.commands.release import (
+    PackageRelease,
+    ReleaseCommand,
+    ReleaseOptions,
+    ReleaseResult,
+    release,
+)
+from pymelos.commands.run import RunCommand, RunOptions, run_script
+
+__all__ = [
+    # Base
+    "Command",
+    "SyncCommand",
+    "CommandContext",
+    # Bootstrap
+    "BootstrapCommand",
+    "BootstrapOptions",
+    "BootstrapResult",
+    "bootstrap",
+    # Run
+    "RunCommand",
+    "RunOptions",
+    "run_script",
+    # Exec
+    "ExecCommand",
+    "ExecOptions",
+    "exec_command",
+    # List
+    "ListCommand",
+    "ListOptions",
+    "ListResult",
+    "ListFormat",
+    "PackageInfo",
+    "list_packages",
+    # Clean
+    "CleanCommand",
+    "CleanOptions",
+    "CleanResult",
+    "clean",
+    # Changed
+    "ChangedCommand",
+    "ChangedOptions",
+    "ChangedResult",
+    "ChangedPackage",
+    "get_changed_packages",
+    # Release
+    "ReleaseCommand",
+    "ReleaseOptions",
+    "ReleaseResult",
+    "PackageRelease",
+    "release",
+    # Add Project
+    "AddProjectCommand",
+    "AddProjectOptions",
+    "AddProjectResult",
+    "add_project",
+]

pymelos/commands/add.py

@@ -0,0 +1,77 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Literal
+
+from pymelos import Workspace
+from pymelos.commands.base import Command, CommandContext, pip_install_editable
+from pymelos.execution import run_command
+
+
+@dataclass
+class AddProjectOptions:
+    name: str
+    project_type: Literal["lib", "app"] = "lib"
+    folder: str | None = None  # default to workspace default folder
+    bare: bool = False
+    editable: bool = True  # whether to pip install -e after creation
+
+
+class AddProjectResult:
+    """Result of AddProjectCommand."""
+
+    def __init__(self, success: bool, path: Path, message: str):
+        self.success = success
+        self.path = path
+        self.message = message
+
+
+class AddProjectCommand(Command[AddProjectResult]):
+    """Add a new library or app to the workspace."""
+
+    DEFAULT_FOLDERS = {
+        "lib": "packages",
+        "app": "examples",
+    }
+
+    def __init__(self, context: CommandContext, options: AddProjectOptions) -> None:
+        super().__init__(context)
+        self.options = options
+
+    async def execute(self) -> AddProjectResult:
+        name = self.options.name
+        project_type = self.options.project_type
+
+        # determine target folder
+        folder = self.options.folder or self.DEFAULT_FOLDERS[project_type]
+        target_dir = self.workspace.root / folder
+        project_path = target_dir / name
+
+        if project_path.exists():
+            raise RuntimeError(f"Project {name} already exists at {project_path}")
+
+        # run command
+        exit_code, stdout, stderr, _ = await run_command(
+            f"uv init {name} --{project_type} {'--bare' if self.options.bare else ''}",
+            cwd=target_dir,
+            env=self.context.env,
+        )
+
+        if project_type == "lib" and self.options.editable:
+            pip_install_editable(project_path)
+        # return result
+        return AddProjectResult(True, project_path, f"Created project {name} at {project_path}")
+
+
+async def add_project(
+    workspace: Workspace,
+    name: str,
+    project_type: Literal["lib", "app"] = "lib",
+    folder: str | None = None,
+    editable: bool = True,
+) -> AddProjectResult:
+    context = CommandContext(workspace=workspace)
+    return await AddProjectCommand(
+        context, AddProjectOptions(name, project_type, folder, editable=editable)
+    ).execute()

pymelos/commands/base.py

@@ -0,0 +1,108 @@
+"""Base command infrastructure."""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from collections.abc import Sequence
+from dataclasses import dataclass, field
+from pathlib import Path
+from subprocess import run
+from typing import Generic, TypeVar
+
+from pymelos.workspace import Workspace
+
+TResult = TypeVar("TResult")
+
+
+@dataclass
+class CommandContext:
+    """Context passed to all commands.
+
+    Attributes:
+        workspace: The workspace instance.
+        dry_run: If True, show what would happen without making changes.
+        verbose: If True, show detailed output.
+    """
+
+    workspace: Workspace
+    dry_run: bool = False
+    verbose: bool = False
+    env: dict[str, str] = field(default_factory=dict)
+
+
+class Command(ABC, Generic[TResult]):
+    """Base class for all pymelos commands.
+
+    Commands encapsulate the logic for a specific operation.
+    They receive a context and return a result.
+    """
+
+    def __init__(self, context: CommandContext) -> None:
+        """Initialize command.
+
+        Args:
+            context: Command context.
+        """
+        self.context = context
+        self.workspace = context.workspace
+
+    @abstractmethod
+    async def execute(self) -> TResult:
+        """Execute the command.
+
+        Returns:
+            Command-specific result.
+        """
+        ...
+
+    def validate(self) -> list[str]:
+        """Validate that the command can be executed.
+
+        Returns:
+            List of validation errors (empty if valid).
+        """
+        return []
+
+
+class SyncCommand(ABC, Generic[TResult]):
+    """Base class for synchronous commands."""
+
+    def __init__(self, context: CommandContext) -> None:
+        """Initialize command.
+
+        Args:
+            context: Command context.
+        """
+        self.context = context
+        self.workspace = context.workspace
+
+    @abstractmethod
+    def execute(self) -> TResult:
+        """Execute the command synchronously.
+
+        Returns:
+            Command-specific result.
+        """
+        ...
+
+    def validate(self) -> list[str]:
+        """Validate that the command can be executed.
+
+        Returns:
+            List of validation errors (empty if valid).
+        """
+        return []
+
+
+def pip_install_editable(paths: Path | Sequence[Path | str]) -> None:
+    """
+    Install one or more workspace packages in editable mode.
+    """
+    if isinstance(paths, Path | str):
+        paths = [paths]  # wrap single path into list
+
+    # Convert all to strings
+    paths_str = [str(p) for p in paths]
+
+    # Run uv pip install -e for all packages
+    run(["uv", "pip", "install", "-e", *paths_str], check=True)

pymelos/commands/bootstrap.py

@@ -0,0 +1,154 @@
+"""Bootstrap command implementation."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from pymelos.commands.base import Command, CommandContext, pip_install_editable
+from pymelos.execution import ExecutionResult
+from pymelos.uv import sync
+from pymelos.workspace.workspace import Workspace
+
+
+@dataclass
+class BootstrapResult:
+    """Result of bootstrap command.
+
+    Attributes:
+        success: Whether bootstrap succeeded.
+        packages_installed: Number of packages in workspace.
+        hook_results: Results of bootstrap hooks.
+        uv_output: Output from uv sync.
+    """
+
+    success: bool
+    packages_installed: int
+    hook_results: list[ExecutionResult]
+    uv_output: str
+
+
+@dataclass
+class BootstrapOptions:
+    """Options for bootstrap command."""
+
+    clean_first: bool = False
+    frozen: bool = False
+    locked: bool = True
+    skip_hooks: bool = False
+    editable: bool = True
+
+
+class BootstrapCommand(Command[BootstrapResult]):
+    """Bootstrap the workspace.
+
+    This command:
+    1. Runs uv sync to install dependencies
+    2. Verifies workspace package linking
+    3. Runs bootstrap hooks from configuration
+    """
+
+    def __init__(self, context: CommandContext, options: BootstrapOptions | None = None) -> None:
+        super().__init__(context)
+        self.options = options or BootstrapOptions()
+
+    async def execute(self) -> BootstrapResult:
+        """Execute bootstrap."""
+        from pymelos.commands.clean import CleanCommand, CleanOptions
+        from pymelos.execution import run_in_package
+
+        hook_results: list[ExecutionResult] = []
+
+        # Optionally clean first
+        if self.options.clean_first:
+            clean_cmd = CleanCommand(self.context, CleanOptions())
+            await clean_cmd.execute()
+
+        # Check if lockfile exists - if not, don't use --locked flag
+        lockfile = self.workspace.root / "uv.lock"
+        use_locked = self.options.locked and lockfile.exists()
+
+        # Run uv sync
+        exit_code, stdout, stderr = sync(
+            self.workspace.root,
+            frozen=self.options.frozen,
+            locked=use_locked,
+            dev=True,
+            all_packages=True,
+        )
+
+        # If --locked failed due to outdated lockfile, retry without --locked
+        if exit_code != 0 and use_locked and "needs to be updated" in stderr:
+            exit_code, stdout, stderr = sync(
+                self.workspace.root,
+                frozen=self.options.frozen,
+                locked=False,
+            )
+
+        if exit_code != 0:
+            return BootstrapResult(
+                success=False,
+                packages_installed=0,
+                hook_results=[],
+                uv_output=stderr or stdout,
+            )
+        # Install workspace packages (editable)
+        if self.options.editable and self.workspace.packages:
+            package_paths = [pkg.path for pkg in self.workspace.packages.values()]
+            pip_install_editable(package_paths)
+
+        # Run bootstrap hooks
+        if not self.options.skip_hooks:
+            for hook in self.workspace.config.bootstrap.hooks:
+                if hook.run_once:
+                    # Run at workspace root
+                    from pymelos.execution.runner import run_command
+
+                    _, out, err, _ = await run_command(
+                        hook.run,
+                        self.workspace.root,
+                        env=self.context.env,
+                    )
+                else:
+                    # Run in matching packages
+                    packages = self.workspace.filter_packages(scope=hook.scope)
+                    for pkg in packages:
+                        result = await run_in_package(pkg, hook.run, env=self.context.env)
+                        hook_results.append(result)
+
+        return BootstrapResult(
+            success=True,
+            packages_installed=len(self.workspace.packages),
+            hook_results=hook_results,
+            uv_output=stdout,
+        )
+
+
+async def bootstrap(
+    workspace: Workspace,
+    *,
+    clean_first: bool = False,
+    frozen: bool = False,
+    skip_hooks: bool = False,
+    verbose: bool = False,
+) -> BootstrapResult:
+    """Convenience function to bootstrap a workspace.
+
+    Args:
+        workspace: Workspace to bootstrap.
+        clean_first: Clean before bootstrap.
+        frozen: Use frozen dependencies.
+        skip_hooks: Skip bootstrap hooks.
+        verbose: Show verbose output.
+
+    Returns:
+        Bootstrap result.
+    """
+
+    context = CommandContext(workspace=workspace, verbose=verbose)
+    options = BootstrapOptions(
+        clean_first=clean_first,
+        frozen=frozen,
+        skip_hooks=skip_hooks,
+    )
+    cmd = BootstrapCommand(context, options)
+    return await cmd.execute()