curupira-plugins 0.1.0__tar.gz

curupira_plugins-0.1.0/.gitignore

@@ -0,0 +1,198 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+# The npm CLI wrapper lives in packages/curupira-npm/lib/. The rule above is the
+# Python packaging ignore and would hide those sources.
+!packages/curupira-npm/lib/
+!packages/curupira-npm/lib/**
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Local curupira configuration and runtime state
+/*-dispatch.toml
+*.sqlite3
+*.sqlite3-journal
+workspaces/
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# Ruff stuff:
+.ruff_cache/
+
+# Pyrefly stuff:
+.pyrefly/
+
+# PyPI configuration file
+.pypirc
+
+# Cursor
+#  Cursor is an AI-powered code editor.`.cursorignore` specifies files/directories to
+#  exclude from AI features like autocomplete and code analysis. Recommended for sensitive data
+#  refer to https://docs.cursor.com/context/ignore-files
+.cursorignore
+.cursorindexingignore
+
+# Node.js (JS/TS SDK and fixtures)
+node_modules/
+

curupira_plugins-0.1.0/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.5
+Name: curupira-plugins
+Version: 0.1.0
+Summary: Official Curupira trigger extensions (GitHub issues, pull requests, and Projects)
+Project-URL: Homepage, https://github.com/caipora-labs/curupira
+Project-URL: Repository, https://github.com/caipora-labs/curupira
+License-Expression: MIT
+Requires-Python: >=3.11
+Requires-Dist: curupira-sdk[pydantic]>=0.1.0.dev0

curupira_plugins-0.1.0/curupira-extension.toml

@@ -0,0 +1,21 @@
+manifest_version = 1
+name = "curupira-plugins"
+version = "0.1.0"
+protocol_version = 2
+runtime = "python"
+kind = "trigger"
+trigger_types = [
+  "github-issues",
+  "github-pull-requests",
+  "github-project-items",
+]
+
+[launch]
+type = "executable"
+program = "python3"
+args = ["-m", "curupira_plugins"]
+
+[package]
+source = "bundled"
+name = "curupira-plugins"
+version = "0.1.0"

curupira_plugins-0.1.0/pyproject.toml

@@ -0,0 +1,30 @@
+[project]
+name = "curupira-plugins"
+dynamic = ["version"]
+description = "Official Curupira trigger extensions (GitHub issues, pull requests, and Projects)"
+requires-python = ">=3.11"
+license = "MIT"
+# Pre-releases need an explicit pre-release specifier, or pip ignores them.
+dependencies = ["curupira-sdk[pydantic]>=0.1.0.dev0"]
+
+[project.scripts]
+curupira-plugins = "curupira_plugins.__main__:main"
+
+[project.urls]
+Homepage = "https://github.com/caipora-labs/curupira"
+Repository = "https://github.com/caipora-labs/curupira"
+
+[build-system]
+requires = ["hatchling>=1.32.4,<2", "hatch-vcs>=0.5,<1"]
+build-backend = "hatchling.build"
+
+# The version is the publish/curupira-plugins/<version> git tag (see curupira-sdk).
+[tool.hatch.version]
+source = "vcs"
+raw-options = { root = "../..", tag_regex = "^publish/curupira-plugins/(?P<version>.+)$", git_describe_command = "git describe --tags --long --match publish/curupira-plugins/*", fallback_version = "0.1.0.dev0" }
+
+[tool.uv.sources]
+curupira-sdk = { workspace = true }
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/curupira_plugins"]

curupira_plugins-0.1.0/src/curupira_plugins/__init__.py

@@ -0,0 +1,6 @@
+"""Official Curupira trigger extensions (GitHub issues, pull requests, and Projects)."""
+
+from importlib.metadata import version
+
+# Read from the installed distribution, whose version comes from the release tag.
+__version__ = version("curupira-plugins")

curupira_plugins-0.1.0/src/curupira_plugins/__main__.py

@@ -0,0 +1,54 @@
+"""Official Curupira trigger extension process (all providers).
+
+Console script ``curupira-plugins`` (also ``python -m curupira_plugins``) speaks
+the extension protocol on stdin/stdout. End-user settings typically launch with::
+
+    uvx --from curupira-plugins curupira-plugins
+"""
+
+from __future__ import annotations
+
+import sys
+
+from curupira_sdk import Curupira
+
+from curupira_plugins import __version__
+from curupira_plugins.github.triggers import register as register_github
+
+app = Curupira(name="curupira-plugins", version=__version__)
+register_github(app)
+
+MANIFEST = """
+manifest_version = 1
+name = "curupira-plugins"
+version = "{version}"
+protocol_version = 2
+runtime = "python"
+kind = "trigger"
+trigger_types = [
+  "github-issues",
+  "github-pull-requests",
+  "github-project-items",
+]
+
+[launch]
+type = "uvx"
+package = "curupira-plugins"
+executable = "curupira-plugins"
+
+[package]
+source = "pip"
+name = "curupira-plugins"
+version = "{version}"
+""".strip()
+
+
+def main() -> None:
+    if "--curupira-print-manifest" in sys.argv:
+        app.print_manifest(MANIFEST)
+        return
+    app.run()
+
+
+if __name__ == "__main__":
+    main()

curupira_plugins-0.1.0/src/curupira_plugins/github/__init__.py

@@ -0,0 +1 @@
+"""GitHub issues and pull-request discovery."""

curupira_plugins-0.1.0/src/curupira_plugins/github/client.py

@@ -0,0 +1,298 @@
+"""GitHub access through the authenticated gh CLI: bearer token, GraphQL search, and paging."""
+
+from __future__ import annotations
+
+import json
+import subprocess
+import time
+import urllib.error
+import urllib.request
+from collections import deque
+from collections.abc import Callable
+from typing import Any, Generic, TypeVar
+
+from curupira_sdk import RpcError
+from pydantic import ValidationError
+
+from curupira_plugins.github.models import (
+    Node,
+    ProjectItems,
+    ProjectResponse,
+    ProjectV2,
+    SearchConnection,
+    SearchResponse,
+)
+
+GRAPHQL_URL = "https://api.github.com/graphql"
+TOKEN_CACHE_SECONDS = 300.0
+PAGE_SIZE = 100
+_RETRY_STATUSES = frozenset({429, 500, 502, 503, 504})
+_ATTEMPTS = 3
+_GH_TIMEOUT_SECONDS = 30
+_HTTP_TIMEOUT_SECONDS = 30
+
+COMMON_FIELDS = """
+  id number title body url state createdAt
+  author { login }
+  labels(first: 50) { nodes { name } }
+  assignees(first: 20) { nodes { login } }
+  milestone { title }
+"""
+
+ISSUE_FIELDS = (
+    COMMON_FIELDS
+    + """
+  stateReason
+"""
+)
+
+PULL_REQUEST_FIELDS = (
+    COMMON_FIELDS
+    + """
+  headRefName baseRefName headRefOid isDraft mergeable mergeStateStatus
+  changedFiles additions deletions
+  closingIssuesReferences(first: 10) { nodes { number url } }
+"""
+)
+
+CONTENT_FRAGMENTS = f"""
+... on Issue {{ {ISSUE_FIELDS} repository {{ nameWithOwner }} }}
+... on PullRequest {{ {PULL_REQUEST_FIELDS} repository {{ nameWithOwner }} }}
+"""
+
+SEARCH_QUERY = f"""
+query CuripiraSearch($query: String!, $first: Int!, $after: String) {{
+  search(query: $query, type: ISSUE, first: $first, after: $after) {{
+    pageInfo {{ hasNextPage endCursor }}
+    nodes {{
+      ... on Issue {{ {ISSUE_FIELDS} }}
+      ... on PullRequest {{ {PULL_REQUEST_FIELDS} }}
+    }}
+  }}
+}}
+"""
+
+# `repositoryOwner` resolves users and organizations alike. `query` is the Projects view filter
+# syntax (for example `status:"In Progress",Review`) and is applied by GitHub.
+PROJECT_ITEMS_QUERY = f"""
+query CuripiraProjectItems($owner: String!, $number: Int!, $first: Int!, $after: String,
+                           $query: String) {{
+  repositoryOwner(login: $owner) {{
+    ... on ProjectV2Owner {{
+      projectV2(number: $number) {{
+        title url
+        items(first: $first, after: $after, query: $query) {{
+          pageInfo {{ hasNextPage endCursor }}
+          nodes {{
+            id isArchived
+            fieldValues(first: 50) {{
+              nodes {{
+                ... on ProjectV2ItemFieldSingleSelectValue {{ name field {{ ... on ProjectV2FieldCommon {{ name }} }} }}
+                ... on ProjectV2ItemFieldTextValue {{ text field {{ ... on ProjectV2FieldCommon {{ name }} }} }}
+                ... on ProjectV2ItemFieldNumberValue {{ number field {{ ... on ProjectV2FieldCommon {{ name }} }} }}
+                ... on ProjectV2ItemFieldDateValue {{ date field {{ ... on ProjectV2FieldCommon {{ name }} }} }}
+                ... on ProjectV2ItemFieldIterationValue {{ title field {{ ... on ProjectV2FieldCommon {{ name }} }} }}
+              }}
+            }}
+            content {{ __typename {CONTENT_FRAGMENTS} }}
+          }}
+        }}
+      }}
+    }}
+  }}
+}}
+"""
+
+NodeT = TypeVar("NodeT", bound=Node)
+ItemT = TypeVar("ItemT")
+ResponseT = TypeVar("ResponseT", SearchResponse, ProjectResponse)
+
+
+class GitHubCliToken:
+    """Read the bearer token from `gh auth token`, caching it for five minutes."""
+
+    def __init__(
+        self,
+        *,
+        clock: Callable[[], float] = time.monotonic,
+        run: Callable[..., subprocess.CompletedProcess[str]] = subprocess.run,
+    ) -> None:
+        self._clock = clock
+        self._run = run
+        self._token: str | None = None
+        self._expires_at = 0.0
+
+    def token(self) -> str:
+        now = self._clock()
+        if self._token is not None and now < self._expires_at:
+            return self._token
+        try:
+            completed = self._run(
+                ["gh", "auth", "token"],
+                capture_output=True,
+                text=True,
+                timeout=_GH_TIMEOUT_SECONDS,
+                check=False,
+            )
+        except FileNotFoundError as exc:
+            raise RpcError(-32002, "Required executable not found: gh") from exc
+        except subprocess.TimeoutExpired as exc:
+            raise RpcError(-32002, "gh auth token timed out") from exc
+        if completed.returncode != 0:
+            detail = completed.stderr.strip() or f"exit status {completed.returncode}"
+            raise RpcError(-32002, f"gh auth token failed: {detail}")
+        token = completed.stdout.strip()
+        if not token:
+            raise RpcError(-32002, "gh auth token returned an empty token")
+        self._token = token
+        self._expires_at = now + TOKEN_CACHE_SECONDS
+        return token
+
+
+class GitHubClient:
+    """Run GraphQL search requests with the gh CLI token and bounded retries."""
+
+    def __init__(
+        self,
+        tokens: GitHubCliToken,
+        *,
+        endpoint: str = GRAPHQL_URL,
+        sleep: Callable[[float], None] = time.sleep,
+    ) -> None:
+        self._tokens = tokens
+        self._endpoint = endpoint
+        self._sleep = sleep
+
+    def search(self, query: str, *, after: str | None) -> SearchConnection:
+        """Return one page of issue/pull-request search results for `query`."""
+        payload = {
+            "query": SEARCH_QUERY,
+            "variables": {"query": query, "first": PAGE_SIZE, "after": after},
+        }
+        response = self._parse(self._post(payload), SearchResponse)
+        if response.data is None:
+            raise RpcError(-32002, "GitHub GraphQL response has no data")
+        return response.data.search
+
+    def project_items(
+        self, owner: str, number: int, *, view_filter: str | None, after: str | None
+    ) -> tuple[ProjectV2, ProjectItems]:
+        """Return the project and one page of its items, filtered server-side by `view_filter`."""
+        payload = {
+            "query": PROJECT_ITEMS_QUERY,
+            "variables": {
+                "owner": owner,
+                "number": number,
+                "first": PAGE_SIZE,
+                "after": after,
+                "query": view_filter,
+            },
+        }
+        response = self._parse(self._post(payload), ProjectResponse)
+        owner_node = response.data.repository_owner if response.data else None
+        project = owner_node.project_v2 if owner_node else None
+        if project is None:
+            raise RpcError(
+                -32002,
+                f"GitHub project {number} not found for {owner!r}; check the owner, the project "
+                "number, and that your token has the read:project scope "
+                "(gh auth refresh -s read:project)",
+            )
+        return project, project.items
+
+    @staticmethod
+    def _parse(body: bytes, model: type[ResponseT]) -> ResponseT:
+        try:
+            response = model.model_validate_json(body)
+        except ValidationError as exc:
+            raise RpcError(-32002, f"unexpected GitHub GraphQL response: {exc}") from exc
+        errors = getattr(response, "errors", [])
+        data = getattr(response, "data", None)
+        # A missing project is reported as a NOT_FOUND error next to partial data; let the
+        # caller explain that one, and surface everything else.
+        if errors and not (
+            data is not None and all("Could not resolve" in e.message for e in errors)
+        ):
+            messages = "; ".join(error.message for error in errors)
+            raise RpcError(-32002, f"GitHub GraphQL error: {messages}")
+        return response
+
+    def _post(self, payload: dict[str, Any]) -> bytes:
+        data = json.dumps(payload).encode("utf-8")
+        for attempt in range(1, _ATTEMPTS + 1):
+            request = urllib.request.Request(
+                self._endpoint,
+                data=data,
+                method="POST",
+                headers={
+                    "Authorization": f"Bearer {self._tokens.token()}",
+                    "Content-Type": "application/json",
+                    "Accept": "application/json",
+                    "User-Agent": "curupira-plugins",
+                },
+            )
+            try:
+                with urllib.request.urlopen(request, timeout=_HTTP_TIMEOUT_SECONDS) as response:
+                    return bytes(response.read())
+            except urllib.error.HTTPError as exc:
+                # Close the response so the connection is released before retrying or raising.
+                status = exc.code
+                exc.close()
+                if status not in _RETRY_STATUSES or attempt == _ATTEMPTS:
+                    raise RpcError(
+                        -32002, f"GitHub GraphQL request failed with status {status}"
+                    ) from exc
+            except urllib.error.URLError as exc:
+                if attempt == _ATTEMPTS:
+                    raise RpcError(-32002, f"GitHub GraphQL request failed: {exc.reason}") from exc
+            self._sleep(2.0 ** (attempt - 1))
+        raise RpcError(-32002, "GitHub GraphQL request failed")
+
+
+def parse_nodes(connection: SearchConnection, model: type[NodeT]) -> list[NodeT]:
+    """Validate raw search nodes into `model` (IssueNode or PullRequestNode)."""
+    try:
+        return [model.model_validate(node) for node in connection.nodes]
+    except ValidationError as exc:
+        raise RpcError(-32002, f"unexpected GitHub search node: {exc}") from exc
+
+
+class Discovery(Generic[NodeT, ItemT]):
+    """Yield each matching item once per process, fetching result pages lazily.
+
+    The host starts a new extension process for every poll cycle, so the seen set only has
+    to hold for one cycle. Items already completed are filtered by the host.
+    """
+
+    def __init__(
+        self,
+        *,
+        fetch_page: Callable[[str | None], SearchConnection],
+        parse_page: Callable[[SearchConnection], list[NodeT]],
+        keep: Callable[[NodeT], bool],
+        to_item: Callable[[NodeT], ItemT],
+    ) -> None:
+        self._fetch_page = fetch_page
+        self._parse_page = parse_page
+        self._keep = keep
+        self._to_item = to_item
+        self._pending: deque[NodeT] = deque()
+        self._cursor: str | None = None
+        self._has_more = True
+        self._seen: set[str] = set()
+
+    def next_item(self) -> ItemT | None:
+        while True:
+            while self._pending:
+                node = self._pending.popleft()
+                if node.id in self._seen:
+                    continue
+                self._seen.add(node.id)
+                if self._keep(node):
+                    return self._to_item(node)
+            if not self._has_more:
+                return None
+            connection = self._fetch_page(self._cursor)
+            self._pending.extend(self._parse_page(connection))
+            self._has_more = connection.page_info.has_next_page
+            self._cursor = connection.page_info.end_cursor