shiftgate 0.1.2__tar.gz → 0.1.4__tar.gz

{shiftgate-0.1.2 → shiftgate-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shiftgate
-Version: 0.1.2
+Version: 0.1.4
 Summary: Intelligent routing layer that automatically selects the right LoRA adapter for each task in your local agent loop.
 Project-URL: Homepage, https://github.com/shiftgate-ai/shiftgate
 Project-URL: Repository, https://github.com/shiftgate-ai/shiftgate

{shiftgate-0.1.2 → shiftgate-0.1.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "shiftgate"
-version = "0.1.2"
+version = "0.1.4"
 description = "Intelligent routing layer that automatically selects the right LoRA adapter for each task in your local agent loop."
 readme = "README.md"
 requires-python = ">=3.10"
@@ -47,9 +47,25 @@ Homepage = "https://github.com/shiftgate-ai/shiftgate"
 Repository = "https://github.com/shiftgate-ai/shiftgate"
 Issues = "https://github.com/shiftgate-ai/shiftgate/issues"
 
+# Wheel: ship the whole importable package. Non-.py data files inside the
+# package directory (e.g. shiftgate/data/default_tasks.json) are included
+# automatically because they live under the packaged directory.
 [tool.hatch.build.targets.wheel]
 packages = ["shiftgate"]
 
+# Sdist: must contain the FULL source tree. The wheel published to PyPI is
+# built from the sdist, so a restrictive sdist `include` here silently strips
+# the .py modules out of the resulting wheel (the 0.1.3 regression). Include
+# the entire package plus tests so `uv build` / `python -m build` reproduce a
+# complete wheel.
+[tool.hatch.build.targets.sdist]
+include = [
+  "/shiftgate",
+  "/tests",
+  "/README.md",
+  "/pyproject.toml",
+]
+
 [tool.pytest.ini_options]
 asyncio_mode = "auto"
 testpaths = ["tests"]

shiftgate-0.1.4/shiftgate/data/__init__.py

@@ -0,0 +1 @@
+"""Bundled package data for shiftgate."""

{shiftgate-0.1.2 → shiftgate-0.1.4}/shiftgate/registry/task_registry.py

@@ -3,7 +3,7 @@ Task registry: load, persist, and manage TaskCluster definitions.
 
 The registry reads from (in priority order):
   1. ``~/.shiftgate/tasks.json``  — user-edited / previously saved
-  2. ``<package>/../../data/default_tasks.json``  — bundled defaults
+  2. ``shiftgate.data/default_tasks.json``  — bundled defaults (via importlib.resources)
 
 On first run (``shiftgate init``) the ``compute_embeddings`` method is called
 to populate ``embedding_centroid`` for every cluster and cache them to
@@ -12,6 +12,7 @@ to populate ``embedding_centroid`` for every cluster and cache them to
 
 from __future__ import annotations
 
+import importlib.resources
 import json
 import logging
 from pathlib import Path
@@ -31,8 +32,24 @@ _SHIFTGATE_DIR = Path.home() / ".shiftgate"
 _USER_TASKS_PATH = _SHIFTGATE_DIR / "tasks.json"
 _CACHE_PATH = _SHIFTGATE_DIR / "embeddings_cache.npy"
 
-# Path to the bundled default tasks, resolved relative to this file's location.
-_DEFAULT_TASKS_PATH = Path(__file__).parent.parent.parent / "data" / "default_tasks.json"
+# Legacy dev-checkout path kept for backwards compatibility with source trees
+# that still ship repo-root ``data/default_tasks.json``.
+_LEGACY_DEFAULT_TASKS_PATH = Path(__file__).parent.parent.parent / "data" / "default_tasks.json"
+_BUNDLED_DEFAULT_TASKS_LABEL = "shiftgate.data/default_tasks.json"
+
+
+def _read_bundled_default_tasks() -> str:
+    """Return the bundled default task registry JSON from the installed package."""
+    try:
+        resource = importlib.resources.files("shiftgate.data") / "default_tasks.json"
+        return resource.read_text(encoding="utf-8")
+    except (FileNotFoundError, ModuleNotFoundError, TypeError):
+        pass
+
+    if _LEGACY_DEFAULT_TASKS_PATH.exists():
+        return _LEGACY_DEFAULT_TASKS_PATH.read_text(encoding="utf-8")
+
+    raise FileNotFoundError(_BUNDLED_DEFAULT_TASKS_LABEL)
 
 
 class TaskRegistry:
@@ -58,22 +75,25 @@ class TaskRegistry:
         """Load the task registry from disk.
 
         Prefers the user's ``~/.shiftgate/tasks.json`` and falls back to the
-        bundled ``data/default_tasks.json`` if the user file does not exist.
+        bundled ``shiftgate.data/default_tasks.json`` if the user file does not exist.
         """
         if _USER_TASKS_PATH.exists():
             source = _USER_TASKS_PATH
-        elif _DEFAULT_TASKS_PATH.exists():
-            source = _DEFAULT_TASKS_PATH
+            raw = json.loads(source.read_text(encoding="utf-8"))
         else:
-            raise FileNotFoundError(
-                f"No task registry found. Expected one of:\n"
-                f"  {_USER_TASKS_PATH}\n"
-                f"  {_DEFAULT_TASKS_PATH}\n"
-                "Run `shiftgate init` to set up the default registry."
-            )
+            try:
+                raw_text = _read_bundled_default_tasks()
+            except FileNotFoundError:
+                raise FileNotFoundError(
+                    f"No task registry found. Expected one of:\n"
+                    f"  {_USER_TASKS_PATH}\n"
+                    f"  {_BUNDLED_DEFAULT_TASKS_LABEL}\n"
+                    "Run `shiftgate init` to set up the default registry."
+                ) from None
+            source = Path(_BUNDLED_DEFAULT_TASKS_LABEL)
+            raw = json.loads(raw_text)
 
         logger.debug("Loading task registry from %s", source)
-        raw = json.loads(source.read_text(encoding="utf-8"))
         tasks = [TaskCluster.model_validate(t) for t in raw]
         instance = cls(tasks, source_path=source)
 

shiftgate-0.1.4/tests/test_packaging.py

@@ -0,0 +1,178 @@
+"""
+Packaging tests — guard against the 0.1.3 regression where the published wheel
+shipped without its Python modules (``ModuleNotFoundError: shiftgate.cli``).
+
+Why these tests build the *full* pipeline
+-----------------------------------------
+PyPI (and ``uv build`` / ``python -m build`` with no flags) builds the sdist
+first, then builds the wheel **from the extracted sdist**.  A wheel built
+directly from the source tree can look complete while the real published wheel
+(built from a too-restrictive sdist) is missing modules.  So the regression
+guard below uses the default ``uv build`` (sdist + wheel-from-sdist), exactly
+like a release, and inspects the resulting wheel.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import shutil
+import subprocess
+import sys
+import tarfile
+import zipfile
+from pathlib import Path
+
+import pytest
+
+PROJECT_ROOT = Path(__file__).resolve().parent.parent
+
+# Skip the whole module gracefully if `uv` isn't on PATH (e.g. minimal CI image).
+_UV = shutil.which("uv")
+pytestmark = pytest.mark.skipif(_UV is None, reason="uv is required to build the package")
+
+
+def _run_build(*args: str, out_dir: Path) -> None:
+    """Build into ``out_dir``. With no extra args, builds sdist then wheel-from-sdist."""
+    subprocess.run(
+        [_UV, "build", *args, "-o", str(out_dir)],
+        cwd=PROJECT_ROOT,
+        check=True,
+        capture_output=True,
+        text=True,
+    )
+
+
+@pytest.fixture(scope="module")
+def full_dist(tmp_path_factory: pytest.TempPathFactory) -> dict[str, Path]:
+    """Build the sdist and a wheel-from-sdist once, like a real release.
+
+    Returns a dict with ``wheel`` and ``sdist`` paths.
+    """
+    dist_dir = tmp_path_factory.mktemp("dist")
+    _run_build(out_dir=dist_dir)  # no flags → sdist + wheel built from that sdist
+
+    wheels = list(dist_dir.glob("*.whl"))
+    sdists = list(dist_dir.glob("*.tar.gz"))
+    assert len(wheels) == 1, f"expected one wheel, got {wheels}"
+    assert len(sdists) == 1, f"expected one sdist, got {sdists}"
+    return {"wheel": wheels[0], "sdist": sdists[0]}
+
+
+def _wheel_names(wheel: Path) -> list[str]:
+    with zipfile.ZipFile(wheel) as archive:
+        return archive.namelist()
+
+
+def _sdist_names(sdist: Path) -> list[str]:
+    with tarfile.open(sdist, "r:gz") as archive:
+        return archive.getnames()
+
+
+# ---------------------------------------------------------------------------
+# Wheel content tests
+# ---------------------------------------------------------------------------
+
+class TestWheelContents:
+    def test_wheel_contains_cli_module(self, full_dist: dict[str, Path]) -> None:
+        """The 0.1.3 regression guard: shiftgate/cli.py must be in the wheel."""
+        names = _wheel_names(full_dist["wheel"])
+        assert "shiftgate/cli.py" in names, (
+            "shiftgate/cli.py missing from wheel — this is the 0.1.3 packaging bug. "
+            f"Wheel contained: {names}"
+        )
+
+    def test_wheel_contains_all_subpackages(self, full_dist: dict[str, Path]) -> None:
+        """Every shiftgate subpackage module should ship in the wheel."""
+        names = set(_wheel_names(full_dist["wheel"]))
+        expected = {
+            "shiftgate/__init__.py",
+            "shiftgate/cli.py",
+            "shiftgate/registry/schemas.py",
+            "shiftgate/registry/adapter_registry.py",
+            "shiftgate/registry/task_registry.py",
+            "shiftgate/router/router.py",
+            "shiftgate/router/matcher.py",
+            "shiftgate/router/embedder.py",
+            "shiftgate/runtime/backend.py",
+            "shiftgate/feedback/loop.py",
+            "shiftgate/utils/display.py",
+        }
+        missing = expected - names
+        assert not missing, f"wheel is missing modules: {sorted(missing)}"
+
+    def test_wheel_contains_default_tasks_json(self, full_dist: dict[str, Path]) -> None:
+        names = _wheel_names(full_dist["wheel"])
+        assert "shiftgate/data/default_tasks.json" in names
+
+    def test_wheel_default_tasks_json_is_valid(self, full_dist: dict[str, Path]) -> None:
+        with zipfile.ZipFile(full_dist["wheel"]) as archive:
+            raw = archive.read("shiftgate/data/default_tasks.json")
+        tasks = json.loads(raw)
+        assert isinstance(tasks, list)
+        assert len(tasks) == 10
+        assert tasks[0]["id"]
+
+    def test_wheel_is_not_truncated(self, full_dist: dict[str, Path]) -> None:
+        """A healthy wheel is well above the ~8 KB broken build."""
+        size_kb = full_dist["wheel"].stat().st_size / 1024
+        assert size_kb > 15, f"wheel is suspiciously small ({size_kb:.1f} KB)"
+
+
+# ---------------------------------------------------------------------------
+# Sdist content tests
+# ---------------------------------------------------------------------------
+
+class TestSdistContents:
+    def test_sdist_contains_cli_module(self, full_dist: dict[str, Path]) -> None:
+        names = _sdist_names(full_dist["sdist"])
+        assert any(n.endswith("shiftgate/cli.py") for n in names), (
+            "shiftgate/cli.py missing from sdist — wheels built from it will be broken."
+        )
+
+    def test_sdist_contains_default_tasks_json(self, full_dist: dict[str, Path]) -> None:
+        names = _sdist_names(full_dist["sdist"])
+        assert any(n.endswith("shiftgate/data/default_tasks.json") for n in names)
+
+
+# ---------------------------------------------------------------------------
+# Integration test: install the wheel into a fresh venv and run the CLI
+# ---------------------------------------------------------------------------
+
+class TestWheelInstall:
+    def test_installed_wheel_cli_help_runs(
+        self, full_dist: dict[str, Path], tmp_path: Path
+    ) -> None:
+        """Install the wheel into a clean venv and run `shiftgate --help`.
+
+        Verifies the console-script entry point resolves and ``shiftgate.cli``
+        imports cleanly from the installed package (exit code 0).
+        """
+        venv_dir = tmp_path / "venv"
+        subprocess.run([_UV, "venv", str(venv_dir)], check=True, capture_output=True, text=True)
+
+        # Install the freshly built wheel (deps resolved from uv's cache).
+        subprocess.run(
+            [_UV, "pip", "install", "--python", str(venv_dir), str(full_dist["wheel"])],
+            check=True,
+            capture_output=True,
+            text=True,
+        )
+
+        # Locate the installed console script (cross-platform).
+        if os.name == "nt":
+            script = venv_dir / "Scripts" / "shiftgate.exe"
+        else:
+            script = venv_dir / "bin" / "shiftgate"
+        assert script.exists(), f"console script not installed at {script}"
+
+        result = subprocess.run(
+            [str(script), "--help"],
+            capture_output=True,
+            text=True,
+        )
+        assert result.returncode == 0, (
+            f"`shiftgate --help` failed (rc={result.returncode}).\n"
+            f"stdout:\n{result.stdout}\nstderr:\n{result.stderr}"
+        )
+        assert "shiftgate" in result.stdout.lower()

{shiftgate-0.1.2 → shiftgate-0.1.4}/tests/test_registry.py

@@ -319,6 +319,29 @@ class TestTaskRegistry:
         assert len(reg) == 1
         assert reg.get_task("test_task").name == "Updated Task"
 
+    def test_load_bundled_defaults_when_no_user_registry(self, tmp_shiftgate):
+        """Packaged defaults load via importlib when ~/.shiftgate/tasks.json is absent."""
+        reg = TaskRegistry.load()
+        assert len(reg) == 10
+        assert reg.get_task("code_python") is not None
+        assert reg.get_task("code_sql") is not None
+
+    def test_user_registry_takes_priority_over_bundled_defaults(self, tmp_shiftgate, sample_task):
+        """Existing user registries continue to win over bundled defaults."""
+        import shiftgate.registry.task_registry as tr_mod
+
+        user_path = tmp_shiftgate / "tasks.json"
+        user_path.write_text(
+            json.dumps([sample_task.model_dump()]),
+            encoding="utf-8",
+        )
+        assert tr_mod._USER_TASKS_PATH == user_path
+
+        reg = TaskRegistry.load()
+        assert len(reg) == 1
+        assert reg.get_task("test_task") is not None
+        assert reg.get_task("code_python") is None
+
 
 # ---------------------------------------------------------------------------
 # _auto_link_adapter helper tests

shiftgate-0.1.2/.github/workflows/release.yml

@@ -1,59 +0,0 @@
-name: Release and Publish
-
-on:
-  push:
-    tags:
-      - 'v*' # Triggers the pipeline whenever a version tag is pushed, e.g., v0.1.0
-
-jobs:
-  validate:
-    name: Validate and Test Code
-    runs-on: ubuntu-latest
-    steps:
-      - name: Check out repository
-        uses: actions/checkout@v4
-
-      - name: Install uv
-        uses: astral-sh/setup-uv@v5
-        with:
-          enable-cache: true
-
-      - name: Set up Python
-        uses: actions/setup-python@v5
-        with:
-          python-version-file: "pyproject.toml"
-
-      - name: Install dependencies & run tests
-        run: |
-          uv sync --all-extras --dev
-          uv run pytest
-
-  publish:
-    name: Build and Publish to PyPI
-    needs: validate
-    runs-on: ubuntu-latest
-    
-    # Define the target environment configured on PyPI
-    environment:
-      name: pypi
-      url: https://pypi.org/p/shiftgate
-
-    # CRITICAL: This gives the job permission to request an OIDC id-token from GitHub
-    permissions:
-      id-token: write
-      contents: read
-
-    steps:
-      - name: Check out repository
-        uses: actions/checkout@v4
-
-      - name: Install uv
-        uses: astral-sh/setup-uv@v5
-        with:
-          enable-cache: true
-
-      - name: Build distribution packages
-        run: uv build
-
-      - name: Publish to PyPI via Trusted Publishing
-        run: uv publish --trusted-publishing always