workset 0.1.0__py3-none-any.whl

workset/__init__.py

@@ -0,0 +1,10 @@
+"""Workset — create and initialize isolated git worktree worksets."""
+
+from __future__ import annotations
+
+from workset.config import WorksetError
+from workset.core import RepoResult, WorksetResult, create_workset
+
+__all__ = ["WorksetError", "RepoResult", "WorksetResult", "create_workset"]
+
+__version__ = "0.1.0"

workset/cli.py

@@ -0,0 +1,142 @@
+"""Command-line interface for workset."""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from workset.config import WorksetError
+from workset.core import WorksetResult, create_workset
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    """Run the workset command-line interface."""
+    args = list(sys.argv[1:] if argv is None else argv)
+    try:
+        return _main(args)
+    except WorksetError as exc:
+        print(f"workset: {exc}", file=sys.stderr)
+        return 2
+    except KeyboardInterrupt:
+        return 130
+
+
+def _main(args: list[str]) -> int:
+    if not args or args[0] in {"-h", "--help"}:
+        _print_help()
+        return 0
+
+    command = args[0]
+
+    if command == "new":
+        return _cmd_new(args[1:])
+
+    print(f"workset: unknown command {command!r}", file=sys.stderr)
+    _print_help()
+    return 2
+
+
+def _cmd_new(args: list[str]) -> int:
+    """Handle ``workset new``."""
+    if not args or args[0] in {"-h", "--help"}:
+        _print_new_help()
+        return 0
+
+    slug = args[0]
+    rest = args[1:]
+
+    dest: Path | None = None
+    no_env = False
+    no_smoke = False
+    repo_specs: list[str] = []
+
+    i = 0
+    while i < len(rest):
+        arg = rest[i]
+        if arg in {"--dest", "-d"}:
+            if i + 1 >= len(rest):
+                print("workset: --dest requires a path", file=sys.stderr)
+                return 2
+            dest = Path(rest[i + 1]).expanduser()
+            i += 2
+        elif arg == "--no-env":
+            no_env = True
+            i += 1
+        elif arg == "--no-smoke":
+            no_smoke = True
+            i += 1
+        elif arg.startswith("-"):
+            print(f"workset: unknown option {arg!r}", file=sys.stderr)
+            return 2
+        else:
+            repo_specs.append(arg)
+            i += 1
+
+    if not repo_specs:
+        print("workset: at least one repo spec required", file=sys.stderr)
+        _print_new_help()
+        return 2
+
+    result = create_workset(
+        slug=slug,
+        repo_specs=repo_specs,
+        dest=dest,
+        no_env=no_env,
+        no_smoke=no_smoke,
+    )
+    _print_result(result)
+    return 0 if result.ok else 1
+
+
+def _print_result(result: WorksetResult) -> None:
+    """Print a human-readable summary of the workset result."""
+    print(f"\nworkset ready: {result.path}")
+    for repo in result.repos:
+        smoke = _smoke_symbol(repo.smoke_passed)
+        env_label = (
+            f"[{repo.env_backend}]" if repo.env_backend != "none" else "[no env]"
+        )
+        print(f"  {smoke} {repo.name}  {env_label}  {repo.branch}")
+        if not repo.env_ok:
+            print(f"    ! {repo.env_message}")
+
+
+def _smoke_symbol(smoke_passed: bool | None) -> str:
+    """Return a status symbol for the smoke test result."""
+    if smoke_passed is True:
+        return "✓"
+    if smoke_passed is False:
+        return "✗"
+    return "~"
+
+
+def _print_help() -> None:
+    print(
+        "usage: workset <command> [args]\n"
+        "\nCommands:\n"
+        "  new    Create a new workset\n"
+        "\nRun 'workset new --help' for details.",
+    )
+
+
+def _print_new_help() -> None:
+    print(
+        "usage: workset new <slug> [--dest <path>] [--no-env] [--no-smoke]"
+        " <repo>:<branch> ...\n"
+        "\nArguments:\n"
+        "  slug             Short identifier for this workset\n"
+        "  repo:branch      Repo name (from config or path) and branch\n"
+        "\nOptions:\n"
+        "  --dest <path>    Override destination path\n"
+        "  --no-env         Skip environment setup\n"
+        "  --no-smoke       Skip smoke tests\n"
+        "\nExamples:\n"
+        "  workset new improve-viewer minerva_mujoco_viewer:feat/improve-viewer\n"
+        "  workset new leansim2sim minerva_lab:feat/leansim2sim"
+        " motion_data_processing:main\n"
+        "  workset new quick-fix --dest /tmp/quick minerva_lab:main",
+    )

workset/config.py

@@ -0,0 +1,125 @@
+"""Configuration loading and repo-spec resolution for workset."""
+
+from __future__ import annotations
+
+import datetime
+import os
+import tomllib
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+
+class WorksetError(Exception):
+    """User-facing workset error."""
+
+
+@dataclass(frozen=True)
+class RepoSpec:
+    """A resolved repo specification."""
+
+    canonical: Path
+    branch: str
+    name: str
+
+
+@dataclass(frozen=True)
+class WorksetConfig:
+    """Loaded workset configuration."""
+
+    workset_root: Path
+    date_prefix: bool
+    repos: dict[str, Path]
+
+    def resolve_dest(self, slug: str, dest_override: Path | None = None) -> Path:
+        """Resolve the workset destination path for a given slug."""
+        if dest_override is not None:
+            return dest_override
+        if self.date_prefix:
+            today = datetime.datetime.now(tz=datetime.UTC).date()
+            return self.workset_root / today.strftime("%Y/%m/%d") / slug
+        return self.workset_root / slug
+
+    def resolve_spec(self, spec: str) -> RepoSpec:
+        """Resolve a repo-spec string to a canonical path and branch.
+
+        Accepts ``name:branch`` (looked up in config) or ``/path/to/repo:branch``.
+        """
+        if ":" not in spec:
+            raise WorksetError(
+                f"invalid repo spec {spec!r}: expected <name>:<branch> or <path>:<branch>",  # noqa: E501
+            )
+        repo_part, branch = spec.rsplit(":", 1)
+        if not branch.strip():
+            raise WorksetError(f"invalid repo spec {spec!r}: branch cannot be empty")
+
+        canonical, name = self._resolve_canonical(repo_part)
+        _require_git_repo(canonical)
+        return RepoSpec(canonical=canonical, branch=branch.strip(), name=name)
+
+    def _resolve_canonical(self, repo_part: str) -> tuple[Path, str]:
+        """Return (canonical_path, short_name) for a repo identifier."""
+        candidate = Path(repo_part).expanduser()
+        if candidate.is_absolute():
+            return candidate.resolve(), candidate.name
+
+        if repo_part in self.repos:
+            return self.repos[repo_part], repo_part
+
+        repos_dir = os.environ.get("WORKSET_REPOS_DIR")
+        if repos_dir:
+            via_env = Path(repos_dir).expanduser() / repo_part
+            if via_env.is_dir():
+                return via_env.resolve(), repo_part
+
+        tried: list[str] = ["~/.config/workset/repos.toml [repos]"]
+        if repos_dir:
+            tried.append(f"$WORKSET_REPOS_DIR/{repo_part}")
+        raise WorksetError(
+            f"repo {repo_part!r} not found. Tried:\n"
+            + "\n".join(f"  {t}" for t in tried)
+            + "\nAdd it to [repos] in ~/.config/workset/repos.toml or use a full path.",
+        )
+
+
+_DEFAULT_CONFIG = Path.home() / ".config" / "workset" / "repos.toml"
+
+
+def load_config(config_path: Path | None = None) -> WorksetConfig:
+    """Load workset configuration, returning defaults if no config file exists."""
+    path = config_path or _DEFAULT_CONFIG
+
+    if not path.is_file():
+        return WorksetConfig(
+            workset_root=Path.home() / "Projects" / "worksets",
+            date_prefix=False,
+            repos={},
+        )
+
+    try:
+        with path.open("rb") as f:
+            raw: dict[str, Any] = tomllib.load(f)
+    except tomllib.TOMLDecodeError as exc:
+        raise WorksetError(f"invalid repos.toml at {path}: {exc}") from exc
+
+    ws = raw.get("workset", {})
+    workset_root = (
+        Path(str(ws.get("root", "~/Projects/worksets"))).expanduser().resolve()
+    )
+    date_prefix = bool(ws.get("date_prefix", False))
+
+    repos = {
+        name: Path(str(p)).expanduser().resolve()
+        for name, p in raw.get("repos", {}).items()
+    }
+    return WorksetConfig(
+        workset_root=workset_root, date_prefix=date_prefix, repos=repos
+    )
+
+
+def _require_git_repo(path: Path) -> None:
+    """Raise WorksetError if path is not an existing git repository."""
+    if not path.is_dir():
+        raise WorksetError(f"canonical repo path does not exist: {path}")
+    if not (path / ".git").exists():
+        raise WorksetError(f"not a git repository: {path}")

workset/core.py

@@ -0,0 +1,134 @@
+"""Core workset creation logic and result types."""
+
+from __future__ import annotations
+
+import sys
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+from workset.config import RepoSpec, WorksetConfig, WorksetError, load_config
+from workset.env import detect_backend, run_smoke_test, setup_env
+from workset.git import submodule_init, worktree_add
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+
+@dataclass(frozen=True)
+class RepoResult:
+    """Result for one repo in a workset."""
+
+    name: str
+    path: Path
+    branch: str
+    env_backend: str
+    env_ok: bool
+    env_message: str
+    smoke_passed: bool | None
+
+
+@dataclass(frozen=True)
+class WorksetResult:
+    """Result of a workset creation."""
+
+    path: Path
+    repos: tuple[RepoResult, ...]
+
+    @property
+    def ok(self) -> bool:
+        """Return True if all repos were set up without errors."""
+        return all(r.env_ok for r in self.repos)
+
+
+def create_workset(
+    slug: str,
+    repo_specs: list[str],
+    dest: Path | None = None,
+    *,
+    no_env: bool = False,
+    no_smoke: bool = False,
+    config: WorksetConfig | None = None,
+) -> WorksetResult:
+    """Create a workset: one worktree per repo-spec, env set up, smoke tested.
+
+    Args:
+        slug: Short identifier used in the path and worklog.
+        repo_specs: List of ``name:branch`` or ``/path:branch`` strings.
+        dest: Override destination path. Uses config default when None.
+        no_env: Skip environment setup.
+        no_smoke: Skip smoke tests.
+        config: Override config. Loaded from disk when None.
+
+    Returns:
+        WorksetResult with per-repo status.
+
+    Raises:
+        WorksetError: On unrecoverable errors (branch collision, missing repo).
+    """
+    cfg = config or load_config()
+    workset_path = cfg.resolve_dest(slug, dest)
+
+    specs = [cfg.resolve_spec(s) for s in repo_specs]
+    _check_name_collisions(specs)
+
+    print(f"Creating workset at {workset_path}", file=sys.stderr)
+
+    results: list[RepoResult] = []
+    for spec in specs:
+        result = _setup_repo(spec, workset_path, no_env=no_env, no_smoke=no_smoke)
+        results.append(result)
+
+    return WorksetResult(path=workset_path, repos=tuple(results))
+
+
+def _setup_repo(
+    spec: RepoSpec,
+    workset_path: Path,
+    *,
+    no_env: bool,
+    no_smoke: bool,
+) -> RepoResult:
+    """Set up a single repo worktree and return its result."""
+    worktree_path = workset_path / spec.name
+    print(
+        f"  {spec.name}: {spec.canonical.name} → {spec.branch}",
+        file=sys.stderr,
+    )
+
+    worktree_add(spec.canonical, worktree_path, spec.branch)
+    submodule_init(worktree_path)
+
+    backend = detect_backend(worktree_path)
+    env_ok = True
+    env_message = "env skipped"
+
+    if not no_env and backend != "none":
+        env_ok, env_message = setup_env(worktree_path, backend)
+        if not env_ok:
+            print(f"    warning: {env_message}", file=sys.stderr)
+
+    smoke_passed: bool | None = None
+    if not no_smoke and env_ok and backend != "none":
+        smoke_passed = run_smoke_test(worktree_path, backend)
+
+    return RepoResult(
+        name=spec.name,
+        path=worktree_path,
+        branch=spec.branch,
+        env_backend=backend,
+        env_ok=env_ok,
+        env_message=env_message,
+        smoke_passed=smoke_passed,
+    )
+
+
+def _check_name_collisions(specs: list[RepoSpec]) -> None:
+    """Raise WorksetError if two specs would produce the same worktree name."""
+    seen: dict[str, RepoSpec] = {}
+    for spec in specs:
+        if spec.name in seen:
+            raise WorksetError(
+                f"two repo specs resolve to the same name {spec.name!r}: "
+                f"{seen[spec.name].canonical} and {spec.canonical}",
+            )
+        seen[spec.name] = spec

workset/env.py

@@ -0,0 +1,153 @@
+"""Environment backend detection, setup, and smoke testing."""
+
+from __future__ import annotations
+
+import subprocess
+import tomllib
+from pathlib import Path
+
+
+def detect_backend(worktree_path: Path) -> str:
+    """Detect the Python environment backend for a worktree.
+
+    Returns ``"veneer"``, ``"uv"``, or ``"none"``.
+    Veneer takes priority if ``veneer.toml`` is present.
+    If veneer.toml uses ``extends`` (pointer style), still returns ``"veneer"``
+    but setup may fail if the stack file does not exist yet.
+    """
+    if (worktree_path / "veneer.toml").is_file():
+        return "veneer"
+    if (worktree_path / "pyproject.toml").is_file():
+        return "uv"
+    return "none"
+
+
+def setup_env(worktree_path: Path, backend: str) -> tuple[bool, str]:
+    """Run environment setup for a worktree.
+
+    Returns (success, message).
+    """
+    if backend == "veneer":
+        return _setup_veneer(worktree_path)
+    if backend == "uv":
+        return _setup_uv(worktree_path)
+    return True, "no env backend detected"
+
+
+def _setup_veneer(worktree_path: Path) -> tuple[bool, str]:
+    """Run ``veneer update-editables`` in the worktree."""
+    result = subprocess.run(
+        ["veneer", "update-editables"],  # noqa: S607
+        cwd=worktree_path,
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    if result.returncode != 0:
+        stderr = result.stderr.strip()
+        if "missing veneer.toml" in stderr or "extends" in stderr:
+            return False, (
+                "veneer setup skipped: veneer.toml uses 'extends' but stack file "
+                "not found — create the parent stack file or run veneer manually"
+            )
+        return False, f"veneer update-editables failed: {stderr}"
+    return True, "veneer ok"
+
+
+def _setup_uv(worktree_path: Path) -> tuple[bool, str]:
+    """Run ``uv sync`` in the worktree."""
+    result = subprocess.run(
+        ["uv", "sync"],  # noqa: S607
+        cwd=worktree_path,
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    if result.returncode != 0:
+        return False, f"uv sync failed: {result.stderr.strip()}"
+    return True, "uv ok"
+
+
+def infer_import_name(worktree_path: Path) -> str | None:
+    """Infer the importable package name for a worktree.
+
+    Uses the first editable package from ``veneer.toml`` if present,
+    then looks for a single directory under ``src/`` or ``source/``.
+    Returns None if the import name cannot be determined.
+    """
+    veneer_toml = worktree_path / "veneer.toml"
+    if veneer_toml.is_file():
+        name = _import_name_from_veneer_toml(veneer_toml, worktree_path)
+        if name:
+            return name
+
+    for src_dir in ("src", "source"):
+        candidate = worktree_path / src_dir
+        if candidate.is_dir():
+            name = _single_package_dir(candidate)
+            if name:
+                return name
+
+    return None
+
+
+def _import_name_from_veneer_toml(
+    veneer_toml: Path,
+    worktree_path: Path,
+) -> str | None:
+    """Extract import name from the first editables.packages entry."""
+    try:
+        with veneer_toml.open("rb") as f:
+            raw = tomllib.load(f)
+    except (tomllib.TOMLDecodeError, OSError):
+        return None
+
+    packages = raw.get("editables", {}).get("packages", [])
+    if not packages:
+        return None
+
+    first = packages[0]
+    resolved = (worktree_path / Path(first).expanduser()).resolve()
+    return resolved.name
+
+
+def _single_package_dir(src_dir: Path) -> str | None:
+    """Return the name of the single Python package directory under src_dir."""
+    candidates = [
+        d
+        for d in src_dir.iterdir()
+        if d.is_dir()
+        and not d.name.startswith(".")
+        and not d.name.endswith(".dist-info")
+        and not d.name.endswith(".egg-info")
+        and (d / "__init__.py").is_file()
+    ]
+    if len(candidates) == 1:
+        return candidates[0].name
+    return None
+
+
+def run_smoke_test(worktree_path: Path, backend: str) -> bool | None:
+    """Try to import the main package to verify the environment works.
+
+    Returns True on success, False on failure, None if import name unknown.
+    Never raises — smoke test failures are advisory, not fatal.
+    """
+    name = infer_import_name(worktree_path)
+    if name is None:
+        return None
+
+    if backend == "veneer":
+        cmd = ["veneer", "python", "-c", f"import {name}"]
+    elif backend == "uv":
+        cmd = ["uv", "run", "python", "-c", f"import {name}"]
+    else:
+        return None
+
+    result = subprocess.run(  # noqa: S603
+        cmd,
+        cwd=worktree_path,
+        capture_output=True,
+        check=False,
+    )
+    return result.returncode == 0

workset/git.py

@@ -0,0 +1,117 @@
+"""Git worktree and submodule operations."""
+
+from __future__ import annotations
+
+import subprocess
+import sys
+from pathlib import Path
+
+from workset.config import WorksetError
+
+
+def get_branch_worktrees(canonical: Path) -> dict[str, Path]:
+    """Return a mapping of branch name → worktree path for a canonical repo.
+
+    Only includes worktrees that have a branch checked out (not detached HEAD).
+    """
+    result = subprocess.run(
+        ["git", "worktree", "list", "--porcelain"],  # noqa: S607
+        cwd=canonical,
+        text=True,
+        capture_output=True,
+        check=False,
+    )
+    if result.returncode != 0:
+        raise WorksetError(
+            f"git worktree list failed in {canonical}:\n{result.stderr.strip()}",
+        )
+    return _parse_worktree_list(result.stdout)
+
+
+def _parse_worktree_list(output: str) -> dict[str, Path]:
+    """Parse ``git worktree list --porcelain`` output into {branch: path}."""
+    branch_to_path: dict[str, Path] = {}
+    current_path: Path | None = None
+
+    for line in output.splitlines():
+        if line.startswith("worktree "):
+            current_path = Path(line[len("worktree ") :])
+        elif line.startswith("branch refs/heads/") and current_path is not None:
+            branch = line[len("branch refs/heads/") :]
+            branch_to_path[branch] = current_path
+            current_path = None
+        elif not line and current_path is not None:
+            current_path = None
+
+    return branch_to_path
+
+
+def branch_exists(canonical: Path, branch: str) -> bool:
+    """Return True if a local branch exists in the canonical repo."""
+    result = subprocess.run(  # noqa: S603
+        ["git", "show-ref", "--verify", "--quiet", f"refs/heads/{branch}"],  # noqa: S607
+        cwd=canonical,
+        capture_output=True,
+        check=False,
+    )
+    return result.returncode == 0
+
+
+def worktree_add(canonical: Path, dest: Path, branch: str) -> None:
+    """Add a git worktree at dest, checking out or creating branch.
+
+    Pre-checks for branch collision and raises WorksetError with a clear
+    message instead of letting git fail with a raw fatal.
+    """
+    checked_out = get_branch_worktrees(canonical)
+    if branch in checked_out:
+        conflict = checked_out[branch]
+        raise WorksetError(
+            f"branch {branch!r} is already checked out in:\n"
+            f"  {conflict}\n\n"
+            f"Check out a different branch, or remove that worktree first:\n"
+            f"  git worktree remove {conflict}",
+        )
+
+    dest.mkdir(parents=True, exist_ok=True)
+
+    exists = branch_exists(canonical, branch)
+    cmd = (
+        ["git", "worktree", "add", str(dest), branch]
+        if exists
+        else ["git", "worktree", "add", "-b", branch, str(dest)]
+    )
+
+    result = subprocess.run(  # noqa: S603
+        cmd,
+        cwd=canonical,
+        text=True,
+        capture_output=True,
+        check=False,
+    )
+    if result.returncode != 0:
+        raise WorksetError(
+            f"git worktree add failed for {branch!r} in {canonical}:\n"
+            f"{result.stderr.strip()}",
+        )
+
+
+def submodule_init(worktree_path: Path) -> None:
+    """Initialize all submodules in the worktree recursively.
+
+    This may be slow for repos with large binary submodules (e.g. STL files).
+    Progress is streamed to stderr so it does not appear hung.
+    """
+    print(
+        f"  initializing submodules in {worktree_path.name}...",
+        file=sys.stderr,
+    )
+    result = subprocess.run(
+        ["git", "submodule", "update", "--init", "--recursive"],  # noqa: S607
+        cwd=worktree_path,
+        check=False,
+    )
+    if result.returncode != 0:
+        raise WorksetError(
+            f"git submodule update failed in {worktree_path}",
+        )

workset-0.1.0.dist-info/METADATA

@@ -0,0 +1,65 @@
+Metadata-Version: 2.4
+Name: workset
+Version: 0.1.0
+Summary: Create and initialize isolated git worktree worksets.
+Project-URL: Homepage, https://github.com/alik-git/workset
+Project-URL: Repository, https://github.com/alik-git/workset
+Project-URL: Issues, https://github.com/alik-git/workset/issues
+Author-email: Ali K <akuwajerwala@minervahumanoids.com>
+Maintainer-email: Ali K <akuwajerwala@minervahumanoids.com>
+Keywords: devtools,git,python,workset,worktree
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Requires-Dist: colorlog>=6.10
+Provides-Extra: dev
+Requires-Dist: build>=1.2; extra == 'dev'
+Requires-Dist: mypy>=1.15; extra == 'dev'
+Requires-Dist: pre-commit>=4.0; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.11; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# workset
+
+Create and initialize isolated git worktree worksets in one command.
+
+A workset is a directory containing one or more git worktrees for related
+repos, each on their own branch, with submodules initialized and the Python
+environment ready to go. `workset` automates the setup so you can go from
+"I have a task" to a working environment without the manual back-and-forth.
+
+## Installation
+
+```bash
+uv tool install workset
+```
+
+Or install from source:
+
+```bash
+uv tool install --editable path/to/workset
+```
+
+## Usage
+
+```bash
+workset --help
+```
+
+## Development
+
+```bash
+uv sync --extra dev
+uv run ruff format --check .
+uv run ruff check .
+uv run mypy
+uv run pytest
+```
+
+## Publishing
+
+Releases are published to PyPI automatically when a GitHub Release is created.

workset-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+workset/__init__.py,sha256=1Tc__O5VrtZ_qSkbVs5zZsQw4EvPzljY1eobHFSMct8,316
+workset/cli.py,sha256=5ejVrYl90BnWoHYPG7vsDxMzG9Fvu-vKhmXwZGwb_-E,3989
+workset/config.py,sha256=Oj9u-rE9zmCZ-oAMPB_4KN16HW9EHi6coTKcy__UF8o,4141
+workset/core.py,sha256=zSWbUao0oxaQ1WB_YIZh0TsTLtjteL6Nwj5B7OttjM0,3778
+workset/env.py,sha256=c49CM9RmirZPA6iiI0u_Ed5QCHCiWItljyOrOAwjEdM,4694
+workset/git.py,sha256=meaay6FLv3lsZEjRxjYsfvekux58cLx6YhpFckedxDE,3760
+workset/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+workset-0.1.0.dist-info/METADATA,sha256=Mfmv4ccfMBmPTO_QBt4lcXHK41gNnhVBxlJphqOOchw,1794
+workset-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+workset-0.1.0.dist-info/entry_points.txt,sha256=vBbftowk1WGZG7jyMUZZ9murKXQejz1awidVM4tj4U0,45
+workset-0.1.0.dist-info/RECORD,,

workset-0.1.0.dist-info/WHEEL

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

workset-0.1.0.dist-info/entry_points.txt

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