uvrev 0.1__py3-none-any.whl

uvrev/__init__.py

@@ -0,0 +1,4 @@
+#!/usr/bin/env python3
+"""
+uvrev - UV package manager with conda-style revision tracking
+"""

uvrev/cli.py

@@ -0,0 +1,222 @@
+import os
+import sys
+from pathlib import Path
+
+import click
+from platformdirs import user_data_path
+
+from uvrev.exceptions import RevisionNotFoundError
+
+from . import constants
+from .commands import uv
+from .operations import (
+    add_packages,
+    create_env,
+    list_installed_packages,
+    list_projects,
+    remove_packages,
+    restore_revision,
+    show_history,
+    upgrade_packages,
+)
+from .terminal import fatal_error, success, warning
+from .types import Revision, UVRevProject
+
+
+def get_base_dir() -> Path:
+    """Get the base directory for uvrev projects.
+
+    Returns:
+        Path UVREV_BASE or user data path for uvrev
+    """
+    if custom_base := os.getenv("UVREV_BASE"):
+        base = Path(custom_base)
+    else:
+        base = user_data_path("uvrev")
+    base.mkdir(parents=True, exist_ok=True)
+    return base
+
+
+def env_option_callback(
+    ctx: click.Context | None, param: click.Parameter | None, value: str | None
+) -> UVRevProject:
+    if value is None and (venv := os.getenv("VIRTUAL_ENV")) and venv != sys.prefix:
+        proj = UVRevProject(Path(venv).parent)
+        if proj.exists():
+            return proj
+        else:
+            warning(
+                f"Currently activated VIRTUAL_ENV ({venv}) is not a uvrev env. Ignoring."
+            )
+
+    name = value or constants.DEFAULT_ENV
+    proj = UVRevProject(get_base_dir() / name)
+
+    if not proj.exists():
+        raise click.BadParameter(
+            f"❌ Project '{name}' does not exist. Create it with 'uvrev env create'",
+        )
+
+    return proj
+
+
+def env_option(f):
+    """Reusable option decorator for environment selection with project lookup"""
+
+    return click.option(
+        "--env",
+        "-e",
+        "project",
+        default=None,
+        show_default=constants.DEFAULT_ENV,
+        callback=env_option_callback,
+        help="Project/environment name (env: UVREV_ENV, default: base)",
+    )(f)
+
+
+@click.group()
+@click.version_option()
+def cli() -> None:
+    """uvrev - UV package manager with conda-style revision tracking
+
+    Manage UV projects with full revision history and easy rollback capabilities.
+    Each package change is tracked in git with detailed changelogs.
+    """
+
+
+@cli.group()
+def env() -> None:
+    """Manage environments"""
+    pass
+
+
+@env.command("create")
+@click.argument("name", required=False)
+@click.option(
+    "--python",
+    default=constants.DEFAULT_PYTHON,
+    show_default=True,
+    help="Python version",
+)
+def env_create(name: str | None, python: str) -> None:
+    """Create a new UV project with revision tracking"""
+    project_name = name or constants.DEFAULT_ENV
+
+    try:
+        project = create_env(get_base_dir(), project_name, python)
+        success(f"Project '{project_name}' created at {project.project_path}")
+    except FileExistsError as e:
+        fatal_error(str(e))
+
+
+@env.command("list")
+def env_list() -> None:
+    """List all UV projects"""
+    projects = list_projects(get_base_dir())
+
+    if not projects:
+        click.echo("No projects found. Create one with 'uvrev env create'")
+        return
+
+    click.echo("Projects:")
+    for proj in projects:
+        click.echo(f"  • {proj}")
+
+
+@cli.command()
+@click.argument("packages", nargs=-1, required=True)
+@env_option
+def add(project: UVRevProject, packages: tuple[str, ...]) -> None:
+    """Add packages to the current project"""
+    rev_num = add_packages(project, packages)
+    if rev_num:
+        success(f"Created revision {rev_num}")
+
+
+@cli.command()
+@click.argument("packages", nargs=-1, required=True)
+@env_option
+def remove(project: UVRevProject, packages: tuple[str, ...]) -> None:
+    """Remove packages from the current project"""
+    rev_num = remove_packages(project, packages)
+    success(f"Removed {' '.join(packages)}.  Created revision {rev_num}.")
+
+
+@cli.command()
+@env_option
+def sync(project: UVRevProject) -> None:
+    """Sync project dependencies"""
+    uv("sync", "--frozen", project=project)
+    success("Sync complete.")
+
+
+@cli.command()
+@click.argument("packages", nargs=-1)
+@env_option
+def upgrade(project: UVRevProject, packages: tuple[str, ...]) -> None:
+    """Upgrade packages or all dependencies if no packages specified
+
+    Examples:
+        uvrev upgrade           # Upgrade all packages
+        uvrev upgrade pandas    # Upgrade only pandas
+    """
+    rev_num = upgrade_packages(project, packages)
+    if packages:
+        success(f"Upgraded {len(packages)} package(s), created revision {rev_num}")
+    else:
+        success(f"Upgraded all packages, created revision {rev_num}")
+
+
+@cli.command("list")
+@env_option
+def list_packages(project: UVRevProject) -> None:
+    """List installed packages in the current environment"""
+    all_packages = list_installed_packages(project)
+
+    click.echo("Installed packages:")
+    for pkg, version, in_pyproject_toml in all_packages:
+        click.secho(
+            f"  • {pkg}=={version} {'[dep]' if in_pyproject_toml else ''}",
+            bold=in_pyproject_toml,
+        )
+
+
+@cli.command()
+@env_option
+def history(project: UVRevProject) -> None:
+    """Show revision history for the current project"""
+    output = show_history(project)
+    click.echo(output)
+
+
+@cli.command()
+@click.argument("revision", type=int)
+@env_option
+def restore(project: UVRevProject, revision: Revision) -> None:
+    """Restore project to a specific revision"""
+    try:
+        restore_revision(project, revision)
+        success(f"Restored to revision {revision}")
+    except RevisionNotFoundError as e:
+        fatal_error(str(e))
+
+
+@cli.command()
+@env_option
+def path(project: UVRevProject) -> None:
+    """Show the path to the current project"""
+    click.echo(project.project_path)
+
+
+@cli.command(context_settings={"ignore_unknown_options": True})
+@click.argument("run_args", nargs=-1, type=click.UNPROCESSED, required=True)
+@env_option
+def run(project: UVRevProject, run_args: tuple[str, ...]) -> None:
+    """Run commands in the project using uv run with locked dependencies
+
+    Examples:
+        uvrev run python script.py
+        uvrev run pytest
+        uvrev run -- myapp --help
+    """
+    uv("run", "--locked", *run_args, project=project)

uvrev/commands.py

@@ -0,0 +1,99 @@
+import shlex
+import subprocess
+from functools import cache
+from pathlib import Path
+from typing import Literal, overload
+
+import click
+from coverage.core import os
+
+from uvrev.types import SubprocessFailure, UVRevProject
+
+
+def show_cmd(cmd: tuple[str, ...]) -> None:
+    """Display command being executed"""
+    click.echo(
+        click.style("$ ", fg="red", bold=True)
+        + click.style(shlex.join(cmd), fg="magenta")
+    )
+
+
+@cache
+def show_cwd_change(project_path: Path) -> None:
+    """Show cd command once per project"""
+    show_cmd(("cd", str(project_path)))
+
+
+@overload
+def git(
+    *args: str,
+    project: UVRevProject,
+    capture_output: Literal[False] = False,
+) -> None: ...
+
+
+@overload
+def git(
+    *args: str,
+    project: UVRevProject,
+    capture_output: Literal[True],
+) -> str: ...
+def git(
+    *args: str,
+    project: UVRevProject,
+    capture_output: bool = False,
+) -> str | None:
+    """
+    Execute git command in project directory
+
+    Args:
+        *args: Git command arguments
+        project: Project to run command in
+        capture_output: If True, capture and return stdout
+
+    Returns:
+        Command stdout if capture_output=True, empty string otherwise
+    """
+    show_cwd_change(project.project_path)
+    cmd = ("git", *args)
+    show_cmd(cmd)
+
+    stdout = subprocess.PIPE if capture_output else None
+    try:
+        result = subprocess.run(
+            cmd,
+            cwd=project.project_path,
+            stdout=stdout,
+            text=True,
+            check=True,
+        )
+    except subprocess.CalledProcessError as e:
+        raise SubprocessFailure(e) from e
+    if capture_output:
+        return result.stdout
+    return None
+
+
+def uv(*args: str, project: UVRevProject) -> None:
+    """
+    Execute uv command in project directory
+
+    Args:
+        *args: UV command arguments
+        project: Project to run command in
+        capture_output: If True, capture and return stdout
+
+    Returns:
+        Command stdout if capture_output=True, empty string otherwise
+    """
+    show_cwd_change(project.project_path)
+    cmd = ("uv", *args)
+    show_cmd(cmd)
+    env = os.environ.copy()
+    if "VIRTUAL_ENV" in env:
+        # disable VIRTUAL_ENV warning
+        del env["VIRTUAL_ENV"]
+    try:
+        subprocess.run(cmd, cwd=project.project_path, check=True, env=env)
+    except subprocess.CalledProcessError as e:
+        raise SubprocessFailure(e) from e

uvrev/constants.py

@@ -0,0 +1,5 @@
+from typing import Final
+
+DEFAULT_PYTHON: Final[str] = "3.12"
+DEFAULT_ENV: Final[str] = "base"
+INITIAL_COMMIT_MSG: Final[str] = "(rev 0) Initial project creation"

uvrev/differ.py

@@ -0,0 +1,140 @@
+from collections.abc import Mapping
+
+from packaging.specifiers import SpecifierSet
+from packaging.utils import NormalizedName
+from packaging.version import Version
+
+
+def version2str(ver: Version | SpecifierSet | str | None) -> str:
+    """
+    Convert a version to a string
+
+    >> version2str(None)
+    ''
+    >>version2str(SpecifierSet(">=1.2"))
+    '>=1.2'
+    >> version2str(Version("1.2"))
+    '==1.2'
+    """
+    if ver is None:
+        return ""
+    elif isinstance(ver, Version):
+        return f"=={ver}"
+    return str(ver)
+
+
+def compute_diff(
+    old_items: Mapping[NormalizedName, Version | SpecifierSet | None | str],
+    new_items: Mapping[NormalizedName, Version | SpecifierSet | None | str],
+) -> tuple[str, ...]:
+    """Compute diff between two package states.
+
+    Args:
+        old_items: Previous package state (name -> version string).
+        new_items: New package state (name -> version string).
+
+    Returns:
+        Sorted list of change strings (additions, removals, updates).
+
+    Examples:
+        >>> old = {'pandas': '>=1.0', 'numpy': ''}
+        >>> new = {'pandas': '>=2.0', 'scipy': '>=1.5'}
+        >>> diff = compute_diff(old, new)
+        >>> diff[0]  # Added scipy
+        '    +scipy>=1.5'
+        >>> diff[1]  # Removed numpy
+        '    -numpy'
+        >>> diff[2]  # Updated pandas
+        '    ^pandas>=1.0 → pandas>=2.0'
+
+        >>> # No changes case
+        >>> old = {'pandas': '>=1.0'}
+        >>> new = {'pandas': '>=1.0'}
+        >>> compute_diff(old, new)
+        ()
+
+        >>> # Only additions
+        >>> old = {}
+        >>> new = {'pandas': '>=2.0', 'numpy': ''}
+        >>> diff = compute_diff(old, new)
+        >>> len(diff)
+        2
+        >>> diff[0]
+        '    +numpy'
+        >>> diff[1]
+        '    +pandas>=2.0'
+    """
+    changes = []
+
+    # Removed
+    for pkg, ver in old_items.items():
+        if pkg not in new_items:
+            changes.append(f"    -{pkg}{version2str(ver)}")
+
+    # Added
+    for pkg, ver in new_items.items():
+        if pkg not in old_items:
+            changes.append(f"    +{pkg}{version2str(ver)}")
+
+    # Updated
+    for pkg, ver in new_items.items():
+        if pkg in old_items and old_items[pkg] != ver:
+            changes.append(
+                f"    ^{pkg}{version2str(old_items[pkg])} → {pkg}{version2str(ver)}"
+            )
+
+    return tuple(sorted(changes))
+
+
+def create_changelog(
+    old_deps: Mapping[NormalizedName, SpecifierSet | None],
+    new_deps: Mapping[NormalizedName, SpecifierSet | None],
+    old_packages: Mapping[NormalizedName, Version],
+    new_packages: Mapping[NormalizedName, Version],
+) -> str:
+    """Create a formatted changelog from dependency and lockfile diffs.
+
+    Args:
+        old_deps: Previous dependency constraints.
+        new_deps: New dependency constraints.
+        old_packages: Previous pinned package versions.
+        new_packages: New pinned package versions.
+
+    Returns:
+        Formatted changelog string with Dependencies and Pinned Versions sections.
+
+    Examples:
+        >>> old_d = {'pandas': None}
+        >>> new_d = {'pandas': None, 'numpy': None}
+        >>> old_p = {'pandas': Version('1.0.0')}
+        >>> new_p = {'pandas': Version('2.0.0'), 'numpy': Version('1.24.0')}
+        >>> print(create_changelog(old_d, new_d, old_p, new_p))
+        <BLANKLINE>
+          Dependencies:
+            +numpy
+          Pinned Versions:
+            +numpy==1.24.0
+            ^pandas==1.0.0 → pandas==2.0.0
+        <BLANKLINE>
+
+        >>> # No changes case
+        >>> old_d = {'pandas': None}
+        >>> new_d = {'pandas': None}
+        >>> old_p = {'pandas': Version('1.0.0')}
+        >>> new_p = {'pandas': Version('1.0.0')}
+        >>> print(create_changelog(old_d, new_d, old_p, new_p))
+        (no changes)
+    """
+    # Convert to string representation for diff
+    deps_diff = compute_diff(old_deps, new_deps)
+    lock_diff = compute_diff(old_packages, new_packages)
+    result = ""
+    if deps_diff:
+        result = "\n  Dependencies:\n"
+        result += "\n".join(deps_diff)
+    if lock_diff:
+        result += "\n  Pinned Versions:\n"
+        result += "\n".join(lock_diff) + "\n"
+    if result:
+        return result
+    return "(no changes)"

uvrev/exceptions.py

@@ -0,0 +1 @@
+class RevisionNotFoundError(Exception): ...

uvrev/io.py

@@ -0,0 +1,25 @@
+import tomlkit
+
+from .types import UVRevProject
+
+
+def read_pyproject(project: UVRevProject) -> tomlkit.TOMLDocument:
+    """Read pyproject.toml using tomlkit.
+
+    Args:
+        project: Project to read from.
+
+    Returns:
+        Dictionary containing pyproject.toml content.
+    """
+    return tomlkit.loads(project.pyproject_path.read_text())
+
+
+def write_pyproject(project: UVRevProject, data: tomlkit.TOMLDocument) -> None:
+    """Write pyproject.toml using tomlkit to preserve comments.
+
+    Args:
+        project: Project to write to.
+        data: Dictionary to write as TOML.
+    """
+    project.pyproject_path.write_text(tomlkit.dumps(data))

uvrev/operations.py

@@ -0,0 +1,282 @@
+import contextlib
+from pathlib import Path
+
+from packaging.utils import NormalizedName
+from packaging.version import Version
+
+from . import constants
+from .commands import git, uv
+from .differ import create_changelog
+from .exceptions import RevisionNotFoundError
+from .io import read_pyproject, write_pyproject
+from .parser import parse_pyproject_deps, parse_uv_lock_packages
+from .types import Revision, SubprocessFailure, UVRevProject
+
+
+def create_env(base_dir: Path, name: str, python: str) -> UVRevProject:
+    """Create a new UV project with revision tracking.
+
+    Args:
+        base_dir: Base directory to create project in.
+        name: Name of the project.
+        python: Python version to use.
+
+    Returns:
+        Created UVRevProject instance.
+
+    Raises:
+        ValueError: If project already exists.
+    """
+    target = base_dir.joinpath(name)
+    if target.exists():
+        raise FileExistsError(f"Folder for project '{name}' ({target}) already exists.")
+    project = UVRevProject(target)
+    target.mkdir(parents=True)
+    # Create project using uv
+    uv(
+        "init",
+        "--python",
+        python,
+        "--no-package",
+        "--no-readme",
+        "--no-description",
+        "--no-workspace",
+        "--name",
+        f"uvrev-venv-{name}",
+        ".",
+        project=project,
+    )
+    target.joinpath("main.py").unlink(missing_ok=True)
+    # Configure pyproject.toml
+    data = read_pyproject(project)
+    data.setdefault("tool", {}).setdefault("uv", {})["package"] = False
+    data.setdefault("project", {})["version"] = "0"
+    write_pyproject(project, data)
+    uv("sync", project=project)
+
+    # Create initial revision
+    git("add", ".", project=project)
+    git("commit", "-m", constants.INITIAL_COMMIT_MSG, project=project)
+    git("tag", "rev_0", project=project)
+
+    return project
+
+
+def list_projects(base_dir: Path) -> tuple[str, ...]:
+    """List all projects.
+
+    Args:
+        base_dir: Base directory containing projects.
+
+    Returns:
+        List of project names.
+    """
+    if not base_dir.exists():
+        return ()
+    return tuple(
+        p.name
+        for p in base_dir.iterdir()
+        if p.is_dir() and (p / "pyproject.toml").exists()
+    )
+
+
+def get_next_revision_number(project: UVRevProject) -> Revision:
+    """Get the next revision number.
+
+    Uses git tag -l to list all numeric tags, sorts them, and returns the highest + 1.
+
+    Args:
+        project: Project to get revision number for.
+
+    Returns:
+        Next revision number (0 if no revisions exist).
+    """
+    output = git(
+        "tag",
+        "--list",
+        "rev_[0-9]*",
+        project=project,
+        capture_output=True,
+    )
+
+    last_rev = 0
+
+    for rev in output.splitlines(keepends=False):
+        with contextlib.suppress(ValueError):
+            last_rev = max(last_rev, int(rev.removeprefix("rev_")))
+
+    return Revision(last_rev + 1)
+
+
+def create_revision(
+    project: UVRevProject, message: str = "Update packages"
+) -> Revision | None:
+    """Create a new revision (commit + tag).
+
+    Args:
+        project: Project to create revision in.
+        message: Commit message.
+
+    Returns:
+        New revision number or None if nothing was changed
+    """
+    # Get previous and current state
+    old_pyproject = git(
+        "show", "HEAD:pyproject.toml", project=project, capture_output=True
+    )
+    old_lock = git("show", "HEAD:uv.lock", project=project, capture_output=True)
+    current_pyproject = project.pyproject_path.read_text()
+    current_lock = project.lock_path.read_text()
+    if old_pyproject == current_pyproject and old_lock == current_lock:
+        return None
+
+    old_deps = parse_pyproject_deps(old_pyproject)
+    old_packages = parse_uv_lock_packages(old_lock)
+    new_deps = parse_pyproject_deps(current_pyproject)
+    new_packages = parse_uv_lock_packages(current_lock)
+
+    # Build changelog
+    changelog = create_changelog(old_deps, new_deps, old_packages, new_packages)
+
+    # Get next revision number (which is also the version)
+    rev_num = get_next_revision_number(project)
+
+    # Commit changes
+    git("add", "pyproject.toml", "uv.lock", project=project)
+
+    commit_msg = f"(rev {rev_num}) {message}\n{changelog}"
+    git("commit", "-m", commit_msg, project=project)
+
+    # Create lightweight tag
+    git("tag", f"rev_{rev_num}", project=project)
+
+    return Revision(rev_num)
+
+
+def restore_revision(project: UVRevProject, rev_num: Revision) -> None:
+    """Restore to a specific revision.
+
+    Args:
+        project: Project to restore.
+        rev_num: Revision number to restore to.
+
+    Raises:
+        ValueError: If revision does not exist.
+    """
+    tag_name = f"rev_{rev_num}"
+
+    # Check if tag exists
+    try:
+        git("rev-parse", tag_name, project=project, capture_output=True)
+    except SubprocessFailure:
+        raise RevisionNotFoundError(f"Revision {rev_num} does not exist") from None
+
+    # Checkout files from that revision
+    git("checkout", tag_name, "--", "pyproject.toml", "uv.lock", project=project)
+
+    # Run uv sync
+    uv("sync", "--locked", project=project)
+
+    # Create new revision for the restore
+    create_revision(project, f"Restored to revision {rev_num}")
+
+
+def list_installed_packages(
+    project: UVRevProject,
+) -> tuple[tuple[NormalizedName, Version, bool], ...]:
+    """Get installed packages and which are in pyproject.toml.
+
+    Args:
+        project: Project to list packages for.
+
+    Returns:
+        Tuple of (pkg, version, defined_in_pyproject.toml)
+    """
+    all_packages = parse_uv_lock_packages(project.lock_path.read_text())
+    pyproject_deps = set(
+        parse_pyproject_deps(project.pyproject_path.read_text()).keys()
+    )
+    return tuple(
+        (pkg, version, pkg in pyproject_deps)
+        for pkg, version in sorted(all_packages.items())
+    )
+
+
+def add_packages(project: UVRevProject, packages: tuple[str, ...]) -> int | None:
+    """Add packages to project.
+
+    Args:
+        project: Project to add packages to.
+        packages: Package names to add.
+
+    Returns:
+        New revision number.
+    """
+    uv("add", "--raw", *packages, project=project)
+    return create_revision(project, f"Added: {', '.join(packages)}")
+
+
+RemoveCount = int
+
+
+def remove_packages(
+    project: UVRevProject, packages: tuple[str, ...]
+) -> Revision | None:
+    """Remove packages from project.
+
+    Args:
+        project: Project to remove packages from.
+        packages: Package names to remove.
+
+    Returns:
+        Tuple of (new_revision_number, number_of_packages_removed).
+    """
+    # Use uv to remove packages
+    uv("remove", *packages, project=project)
+
+    # Create revision
+    rev_num = create_revision(project, f"Removed: {', '.join(packages)}")
+    return rev_num
+
+
+def show_history(project: UVRevProject) -> str:
+    """Get revision history.
+
+    Args:
+        project: Project to get history for.
+
+    Returns:
+        Formatted git log output.
+    """
+    return git(
+        "log",
+        "--tags",
+        "--color=always",
+        "--format=%ai  %C(bold)%C(green)%s%C(reset)%n%b",
+        "--reverse",
+        project=project,
+        capture_output=True,
+    )
+
+
+def upgrade_packages(
+    project: UVRevProject, packages: tuple[str, ...]
+) -> Revision | None:
+    """Upgrade packages or all if no packages specified.
+
+    Args:
+        project: Project to upgrade packages in.
+        packages: Package names to upgrade (empty for all).
+
+    Returns:
+        New revision number.
+    """
+    if packages:
+        for pkg in packages:
+            uv("sync", "--upgrade-package", pkg, project=project)
+        message = f"Upgraded: {', '.join(packages)}"
+    else:
+        uv("sync", "--upgrade", project=project)
+        message = "Upgraded all packages"
+
+    return create_revision(project, message)

uvrev/parser.py

@@ -0,0 +1,105 @@
+import tomllib
+
+from packaging.specifiers import SpecifierSet
+from packaging.utils import NormalizedName, canonicalize_name
+from packaging.version import Version
+
+from .types import NormalizedRequirement
+
+
+def parse_pyproject_deps(
+    toml_content: str,
+) -> dict[NormalizedName, SpecifierSet | None]:
+    """Parse dependencies from pyproject.toml content.
+
+    Args:
+        toml_content: TOML file content as string.
+
+    Returns:
+        Dictionary mapping canonical package names to their version specifiers.
+
+    Examples:
+        >>> content = '''
+        ... [project]
+        ... dependencies = ["pandas>=2.0", "numpy", "scipy~=1.5.0"]
+        ... '''
+        >>> deps = parse_pyproject_deps(content)
+        >>> 'pandas' in deps
+        True
+        >>> deps['numpy'] is None
+        True
+        >>> str(deps['pandas'])
+        '>=2.0'
+        >>> str(deps['scipy'])
+        '~=1.5.0'
+
+        >>> # Empty content
+        >>> parse_pyproject_deps('')
+        {}
+
+        >>> # No dependencies
+        >>> parse_pyproject_deps('[project]\\nname = "test"')
+        {}
+    """
+    if not toml_content.strip():
+        return {}
+
+    data = tomllib.loads(toml_content)
+    deps = {}
+
+    for dep_str in data.get("project", {}).get("dependencies", []):
+        req = NormalizedRequirement(dep_str)
+        deps[req.name] = req.specifier if req.specifier else None
+
+    return deps
+
+
+def parse_uv_lock_packages(toml_content: str) -> dict[NormalizedName, Version]:
+    """Parse packages from uv.lock content.
+
+    Args:
+        toml_content: TOML file content as string.
+
+    Returns:
+        Dictionary mapping canonical package names to their installed versions.
+
+    Examples:
+        >>> content = '''
+        ... [[package]]
+        ... name = "pandas"
+        ... version = "2.0.0"
+        ...
+        ... [[package]]
+        ... name = "NumPy"
+        ... version = "1.24.3"
+        ...
+        ... [[package]]
+        ... name = "ignored"
+        ... '''
+        >>> pkgs = parse_uv_lock_packages(content)
+        >>> 'pandas' in pkgs
+        True
+        >>> 'numpy' in pkgs
+        True
+        >>> str(pkgs['pandas'])
+        '2.0.0'
+        >>> str(pkgs['numpy'])
+        '1.24.3'
+        >>> "ignore" not in pkgs
+        True
+        >>> # Empty content
+        >>> parse_uv_lock_packages('')
+        {}
+    """
+    if not toml_content.strip():
+        return {}
+
+    data = tomllib.loads(toml_content)
+    packages = {}
+
+    for pkg in data.get("package", []):
+        if "name" in pkg and "version" in pkg:
+            canonical_name = canonicalize_name(pkg["name"])
+            packages[canonical_name] = Version(pkg["version"])
+
+    return packages

uvrev/terminal.py

@@ -0,0 +1,21 @@
+import sys
+from typing import NoReturn
+
+import click
+
+
+def success(msg: str) -> None:
+    click.secho(f"✅ {msg}", fg="green", err=True)
+
+
+def warning(msg: str) -> None:
+    click.secho(f"⚠️ {msg}", fg="yellow", err=True)
+
+
+def error(msg: str) -> None:
+    click.secho(f"❌ {msg}", fg="red", err=True)
+
+
+def fatal_error(msg: str, exit_code: int = 1) -> NoReturn:
+    error(msg)
+    sys.exit(exit_code)

uvrev/types.py

@@ -0,0 +1,63 @@
+import shlex
+import subprocess
+import tomllib
+from dataclasses import dataclass
+from pathlib import Path
+from typing import NewType
+
+import click
+from packaging.requirements import Requirement
+from packaging.utils import NormalizedName, canonicalize_name
+
+Revision = NewType("Revision", int)
+
+
+@dataclass(frozen=True)
+class UVRevProject:
+    """Represents a UV project with revision tracking"""
+
+    project_path: Path
+
+    @property
+    def pyproject_path(self) -> Path:
+        return self.project_path / "pyproject.toml"
+
+    @property
+    def lock_path(self) -> Path:
+        return self.project_path / "uv.lock"
+
+    def exists(self) -> bool:
+        """
+        Check if project exists
+
+        >>> import tempfile
+        >>> with tempfile.TemporaryDirectory() as td:
+        ...     p = UVRevProject(Path(td))
+        ...     p.exists()
+        False
+        """
+        if not self.project_path.exists() or not self.pyproject_path.exists():
+            return False
+        data = tomllib.loads(self.pyproject_path.read_text())
+        return data.get("tool", {}).get("uv", {}).get("package") is False
+
+
+class NormalizedRequirement(Requirement):
+    """Requirement with normalized name"""
+
+    name: NormalizedName
+
+    def __init__(self, requirement_string: str):
+        super().__init__(requirement_string)
+        self.name = canonicalize_name(self.name)
+
+
+class SubprocessFailure(click.ClickException):
+    """
+    SubprocessFailure Exception that will quit the program without stacktrace
+    """
+
+    def __init__(self, error: subprocess.CalledProcessError) -> None:
+        if isinstance(error.cmd, tuple):  # pragma: no branch
+            error.cmd = shlex.join(error.cmd)
+        super().__init__(str(error))

uvrev-0.1.dist-info/METADATA

@@ -0,0 +1,136 @@
+Metadata-Version: 2.4
+Name: uvrev
+Version: 0.1
+Summary: uv env manager to enable conda-style revision tracking
+Author-email: Carli* Freudenberg <kound@posteo.de>
+License-Expression: MIT
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Requires-Dist: click>=8
+Requires-Dist: platformdirs>=4
+Requires-Dist: tomlkit>=0.13
+Description-Content-Type: text/markdown
+
+# uvrev
+
+**uvrev** is a CLI tool that wraps the **uv** package manager and adds **git-based, conda-style revision tracking** for Python environments.
+
+It allows you to manage UV projects as isolated environments with a full, inspectable revision history. Every package change (add, remove, update) creates a new Git commit and tag, making it easy to understand what changed and to roll back to any previous state.
+
+---
+
+## Overview
+
+- Manage UV environments with automatic revision tracking
+- Track dependency changes over time using Git
+- Restore environments to any previous revision
+- Inspect package history in a familiar conda-style format
+
+Each environment is stored as a Git repository. Dependency changes are committed automatically, providing a complete and auditable history of your environment state.
+
+---
+
+## Installation
+
+### Prerequisites
+
+- `git`
+- `uv`
+
+### Install with uv
+
+```bash
+uv tool install uvrev
+```
+
+After installation, ensure that `uvrev` is available on your `PATH`:
+
+```bash
+uvrev --help
+```
+
+---
+
+## Key Features
+
+- Conda-style revision history showing added, removed, and updated packages
+- Git-based storage with automatic commits and tags
+- Rollback to any previous revision
+- Detailed changelog tracking both dependencies and pinned versions
+
+---
+
+## Commands
+
+| Command            | Description |
+|--------------------|-------------|
+| `uvrev env create` | Create a new UV project with revision tracking |
+| `uvrev env list`   | List all UV projects |
+| `uvrev add`        | Add packages to the current project |
+| `uvrev remove`     | Remove packages from the current project |
+| `uvrev sync`       | Sync project dependencies |
+| `uvrev list`       | List installed packages in the current environment |
+| `uvrev history`    | Show revision history with package changes |
+| `uvrev restore`    | Restore project to a specific revision |
+| `uvrev path`       | Show the path to the current project |
+| `uvrev run`        | Run uv commands in the project |
+
+---
+
+## Environment Selection
+
+`uvrev` determines the active environment based on the **currently activated virtual environment**.
+
+Activate an environment as usual:
+
+```bash
+source .venv/bin/activate
+```
+
+Once activated, all `uvrev` commands operate on that environment automatically. No additional flags or environment variables are required.
+
+This mirrors standard Python workflows and avoids implicit global state.
+
+---
+
+## Examples
+
+```bash
+uvrev env create myproject --python 3.12
+
+# activate venv
+source "$(uvrev path -e myproject)/.venv/bin/activate"
+
+uvrev add pandas numpy
+uvrev add requests
+
+uvrev list
+uvrev history
+uvrev restore 3
+uvrev run pip list
+```
+
+---
+
+## Why uvrev?
+
+`uvrev` combines the speed and simplicity of **uv** with the safety and transparency of **Git**, giving you:
+
+- Reproducible environments
+- Clear insight into dependency changes
+- Confidence to experiment, knowing you can always roll back

uvrev-0.1.dist-info/RECORD

@@ -0,0 +1,15 @@
+uvrev/__init__.py,sha256=qiMYnTiZppLhNj7ScuS5pZ-1dx3xVjYYGresSj-Jw-0,93
+uvrev/cli.py,sha256=ORUP9qhlEAb0J-5VsWH1cGipkyWJBE0RFl68ZsU0Hxc,6139
+uvrev/commands.py,sha256=c-8DP_q5jYPvgqQkOhd4Onw2Y68fcmjmtwr_lzf_9f0,2415
+uvrev/constants.py,sha256=cWRiCWPrJzG0ChmthPAkMH5HnEYJOoPfQNxoSkxcpsA,163
+uvrev/differ.py,sha256=lV7TT5pr3n4RYzg8oQ23KM_BmJUw1HUWEMfKiNnLniU,4225
+uvrev/exceptions.py,sha256=acHXQNguXD69z7hm9hGZ7AvkTEOH8ego-V6N6XIqpuY,44
+uvrev/io.py,sha256=HFWDfG8AWjf9MXWCrqlYzmriinOfGBXSTQx5NiCRq9k,651
+uvrev/operations.py,sha256=IAMOWgt0gNFlX-Q20cpH66TPjRqWXXy5oYtqpunHx94,7799
+uvrev/parser.py,sha256=08F4X3XrQ5oacjAmc6i598tvgaK--zovv--5LOUopIA,2670
+uvrev/terminal.py,sha256=fSK-vXWvjuqII3c8vPgv924-VZumvXQ54JZnmNKHM5A,408
+uvrev/types.py,sha256=VBpMyrGowmzpl06e0ou-ocjZ3ebN2eVwnT6SC4WC-hU,1727
+uvrev-0.1.dist-info/METADATA,sha256=ZApYH5owYiyC4gOdXdHiDiKPp0INXa-y5vYiso3Y-20,4054
+uvrev-0.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+uvrev-0.1.dist-info/entry_points.txt,sha256=G1YjqyIGzUsBZ8FY4Qg8Ay6nOlgbkdxD8m7Uyfan3GE,40
+uvrev-0.1.dist-info/RECORD,,

uvrev-0.1.dist-info/WHEEL

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

uvrev-0.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+uvrev = uvrev:cli.cli