chore: bump version to 0.1.3 and include default tasks JSON in package

- Updated project version to 0.1.3.
- Added `default_tasks.json` to the package, ensuring it is included in both wheel and sdist builds.
- Modified task registry to load bundled defaults using `importlib.resources`.
- Added tests to verify the inclusion and validity of the bundled tasks.

Author: mdrazak2001

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "shiftgate"
-version = "0.1.2"
+version = "0.1.3"
 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"
@@ -50,6 +50,14 @@ Issues = "https://github.com/shiftgate-ai/shiftgate/issues"
 [tool.hatch.build.targets.wheel]
 packages = ["shiftgate"]
 
+[tool.hatch.build.targets.wheel.force-include]
+"shiftgate/data/default_tasks.json" = "shiftgate/data/default_tasks.json"
+
+[tool.hatch.build.targets.sdist]
+include = [
+  "/shiftgate/data/default_tasks.json",
+]
+
 [tool.pytest.ini_options]
 asyncio_mode = "auto"
 testpaths = ["tests"]

shiftgate/data/__init__.py

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

shiftgate/data/default_tasks.json

@@ -0,0 +1,187 @@
+[
+  {
+    "id": "code_python",
+    "name": "Python Code Generation",
+    "description": "Writing, completing, or refactoring Python code including functions, classes, scripts, and modules.",
+    "validation_examples": [
+      "Write a Python function to reverse a linked list",
+      "Create a Python class for a binary search tree",
+      "Implement quicksort in Python",
+      "Write a decorator that caches function results in Python",
+      "Refactor this Python code to use list comprehensions",
+      "Write a Python script to parse CSV files and compute statistics",
+      "Create a Python context manager for database connections",
+      "Generate a Python dataclass for a user profile"
+    ],
+    "embedding_centroid": null,
+    "preferred_adapters": [],
+    "fallback_adapters": []
+  },
+  {
+    "id": "code_sql",
+    "name": "SQL Query Writing",
+    "description": "Writing SQL queries including SELECT, JOIN, aggregations, CTEs, window functions, and schema design.",
+    "validation_examples": [
+      "Write a SQL query to find duplicate rows in a table",
+      "Create a SQL query with a LEFT JOIN between orders and customers",
+      "Write a SQL window function to calculate running totals",
+      "Generate a SQL CTE to rank employees by department salary",
+      "Write a SQL query to find users who made purchases in the last 30 days",
+      "Create a SQL stored procedure for bulk inserts",
+      "Write a SQL query using GROUP BY and HAVING to filter aggregates",
+      "Generate a SQL schema for an e-commerce database"
+    ],
+    "embedding_centroid": null,
+    "preferred_adapters": [],
+    "fallback_adapters": []
+  },
+  {
+    "id": "code_javascript",
+    "name": "JavaScript and TypeScript",
+    "description": "Writing or reviewing JavaScript and TypeScript code for frontend, Node.js, or full-stack applications.",
+    "validation_examples": [
+      "Write a React hook to fetch data from an API",
+      "Create a TypeScript interface for a REST API response",
+      "Implement a JavaScript debounce function",
+      "Write an async function to handle file uploads in Node.js",
+      "Create a TypeScript generic type for a paginated API response",
+      "Write a JavaScript event listener for form validation",
+      "Implement a Promise-based queue in JavaScript",
+      "Write a Next.js API route that authenticates with JWT"
+    ],
+    "embedding_centroid": null,
+    "preferred_adapters": [],
+    "fallback_adapters": []
+  },
+  {
+    "id": "code_debug",
+    "name": "Debugging and Error Fixing",
+    "description": "Diagnosing, explaining, and fixing bugs, exceptions, and unexpected behaviour in any programming language.",
+    "validation_examples": [
+      "Fix the KeyError in this Python dictionary access code",
+      "Why is this JavaScript async function returning undefined?",
+      "Debug this SQL query that returns no results",
+      "Find the memory leak in this C++ code",
+      "Why does this React component re-render infinitely?",
+      "Fix the NullPointerException in this Java method",
+      "Explain and fix this Python TypeError: unsupported operand",
+      "Debug why this API call returns 403 Forbidden",
+      "Fix the off-by-one error in this loop"
+    ],
+    "embedding_centroid": null,
+    "preferred_adapters": [],
+    "fallback_adapters": []
+  },
+  {
+    "id": "text_summarize",
+    "name": "Text Summarization",
+    "description": "Condensing long documents, articles, papers, or conversations into concise summaries.",
+    "validation_examples": [
+      "Summarise this research paper in 3 bullet points",
+      "Give me a TL;DR of this news article",
+      "Write an executive summary of this annual report",
+      "Condense this meeting transcript into action items",
+      "Summarise the key findings from this dataset description",
+      "Create a one-paragraph abstract for this technical documentation",
+      "What are the main takeaways from this blog post?",
+      "Summarise this legal contract in plain English"
+    ],
+    "embedding_centroid": null,
+    "preferred_adapters": [],
+    "fallback_adapters": []
+  },
+  {
+    "id": "text_classify",
+    "name": "Text Classification and Labeling",
+    "description": "Classifying, categorising, or labelling text — sentiment, intent, topic, or custom taxonomy.",
+    "validation_examples": [
+      "Classify this customer review as positive, negative, or neutral",
+      "Label these support tickets by urgency level",
+      "Categorise these product descriptions by department",
+      "Detect the intent behind this user message: book a flight",
+      "Tag these news headlines with their topic",
+      "Classify this email as spam or legitimate",
+      "Label this text for named entity recognition",
+      "Determine the sentiment of these tweets",
+      "Categorise these bug reports by severity"
+    ],
+    "embedding_centroid": null,
+    "preferred_adapters": [],
+    "fallback_adapters": []
+  },
+  {
+    "id": "text_translate",
+    "name": "Language Translation",
+    "description": "Translating text between languages, including idioms, technical content, and cultural adaptation.",
+    "validation_examples": [
+      "Translate this paragraph from English to French",
+      "Translate this technical document to Spanish",
+      "Convert this German medical text to English",
+      "Translate this Japanese product description to English",
+      "Localise this marketing copy from English to Portuguese",
+      "Translate this legal clause from Latin to English",
+      "Convert this Chinese business email to English",
+      "Translate this Python error message to plain English"
+    ],
+    "embedding_centroid": null,
+    "preferred_adapters": [],
+    "fallback_adapters": []
+  },
+  {
+    "id": "math_reasoning",
+    "name": "Math and Quantitative Reasoning",
+    "description": "Solving arithmetic, algebra, calculus, statistics, logic puzzles, and word problems step by step.",
+    "validation_examples": [
+      "Solve this system of linear equations",
+      "Calculate the derivative of this function",
+      "What is the probability of drawing two aces from a deck?",
+      "Solve this word problem: if a train leaves at 3 PM at 60 mph...",
+      "Compute the integral of x^2 from 0 to 5",
+      "Find the eigenvalues of this matrix",
+      "How many ways can 5 people be seated in a row?",
+      "What is 15% compound interest on $10,000 over 3 years?",
+      "Prove that the square root of 2 is irrational"
+    ],
+    "embedding_centroid": null,
+    "preferred_adapters": [],
+    "fallback_adapters": []
+  },
+  {
+    "id": "qa_factual",
+    "name": "Factual Q&A",
+    "description": "Answering factual questions about history, science, geography, technology, or general knowledge.",
+    "validation_examples": [
+      "What is the capital of Australia?",
+      "Who invented the telephone?",
+      "What year did World War II end?",
+      "What is the speed of light in a vacuum?",
+      "Explain how HTTPS encryption works",
+      "What is the difference between RAM and ROM?",
+      "What causes the aurora borealis?",
+      "How many bones are in the human body?",
+      "What is the GDP of Germany?"
+    ],
+    "embedding_centroid": null,
+    "preferred_adapters": [],
+    "fallback_adapters": []
+  },
+  {
+    "id": "agent_planning",
+    "name": "Task Decomposition and Agent Planning",
+    "description": "Breaking down complex goals into step-by-step plans, sub-tasks, or agent workflows.",
+    "validation_examples": [
+      "Create a step-by-step plan to build a REST API from scratch",
+      "Decompose the task of launching a product into weekly milestones",
+      "Write a plan for migrating a database to the cloud",
+      "Break down the goal 'build a recommendation system' into sub-tasks",
+      "Create an agent workflow to automate data ingestion and reporting",
+      "Plan the steps to refactor a monolith into microservices",
+      "What are the subtasks needed to onboard a new engineer?",
+      "Outline a research plan for evaluating three competing ML models",
+      "Create a checklist for deploying a web app to production"
+    ],
+    "embedding_centroid": null,
+    "preferred_adapters": [],
+    "fallback_adapters": []
+  }
+]

shiftgate/registry/task_registry.py

@@ -3,7 +3,7 @@
 
 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 @@
 
 from __future__ import annotations
 
+import importlib.resources
 import json
 import logging
 from pathlib import Path
@@ -31,8 +32,24 @@
 _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 @@ def load(cls) -> "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)
 

tests/test_packaging.py

@@ -0,0 +1,65 @@
+"""
+Packaging tests: verify bundled data ships in wheel and sdist builds.
+"""
+
+from __future__ import annotations
+
+import json
+import subprocess
+import tarfile
+import zipfile
+from pathlib import Path
+
+PROJECT_ROOT = Path(__file__).resolve().parent.parent
+
+
+def _run_build(*args: str, out_dir: Path) -> None:
+    subprocess.run(
+        ["uv", "build", *args, "-o", str(out_dir)],
+        cwd=PROJECT_ROOT,
+        check=True,
+        capture_output=True,
+        text=True,
+    )
+
+
+class TestPackaging:
+    def test_wheel_contains_default_tasks_json(self, tmp_path: Path) -> None:
+        dist_dir = tmp_path / "dist"
+        dist_dir.mkdir()
+        _run_build("--wheel", out_dir=dist_dir)
+
+        wheels = list(dist_dir.glob("*.whl"))
+        assert len(wheels) == 1
+
+        with zipfile.ZipFile(wheels[0]) as archive:
+            names = archive.namelist()
+
+        assert "shiftgate/data/default_tasks.json" in names
+
+    def test_wheel_default_tasks_json_is_valid(self, tmp_path: Path) -> None:
+        dist_dir = tmp_path / "dist"
+        dist_dir.mkdir()
+        _run_build("--wheel", out_dir=dist_dir)
+        wheel = next(dist_dir.glob("*.whl"))
+
+        with zipfile.ZipFile(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_sdist_contains_default_tasks_json(self, tmp_path: Path) -> None:
+        dist_dir = tmp_path / "dist"
+        dist_dir.mkdir()
+        _run_build("--sdist", out_dir=dist_dir)
+
+        sdists = list(dist_dir.glob("*.tar.gz"))
+        assert len(sdists) == 1
+
+        with tarfile.open(sdists[0], "r:gz") as archive:
+            members = archive.getnames()
+
+        assert any(member.endswith("shiftgate/data/default_tasks.json") for member in members)

tests/test_registry.py

@@ -319,6 +319,29 @@ def test_add_task_overwrites_existing(self, tmp_shiftgate, sample_task):
         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