curupira-plugins 0.1.0.dev0__tar.gz

curupira_plugins-0.1.0.dev0/.gitignore

@@ -0,0 +1,190 @@
+# 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/
+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

curupira_plugins-0.1.0.dev0/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.5
+Name: curupira-plugins
+Version: 0.1.0.dev0
+Summary: Official Curupira trigger extensions (GitHub, Azure, Trello, monday.com)
+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.dev0/curupira-extension.toml

@@ -0,0 +1,23 @@
+manifest_version = 1
+name = "curupira-plugins"
+version = "0.1.0.dev0"
+protocol_version = 1
+runtime = "python"
+kind = "trigger"
+trigger_types = [
+  "github-issues",
+  "github-pull-requests",
+  "azure-cli-pull-requests",
+  "trello-cli-cards",
+  "monday-items",
+]
+
+[launch]
+type = "executable"
+program = "python3"
+args = ["-m", "curupira_plugins"]
+
+[package]
+source = "bundled"
+name = "curupira-plugins"
+version = "0.1.0.dev0"

curupira_plugins-0.1.0.dev0/pyproject.toml

@@ -0,0 +1,30 @@
+[project]
+name = "curupira-plugins"
+dynamic = ["version"]
+description = "Official Curupira trigger extensions (GitHub, Azure, Trello, monday.com)"
+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.dev0/src/curupira_plugins/__init__.py

@@ -0,0 +1,6 @@
+"""Official Curupira trigger extensions (GitHub, Azure, Trello, monday.com)."""
+
+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.dev0/src/curupira_plugins/__main__.py

@@ -0,0 +1,62 @@
+"""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.azure.triggers import register as register_azure
+from curupira_plugins.github.triggers import register as register_github
+from curupira_plugins.monday.triggers import register as register_monday
+from curupira_plugins.trello.triggers import register as register_trello
+
+app = Curupira(name="curupira-plugins", version=__version__)
+register_github(app)
+register_azure(app)
+register_trello(app)
+register_monday(app)
+
+MANIFEST = """
+manifest_version = 1
+name = "curupira-plugins"
+version = "{version}"
+protocol_version = 1
+runtime = "python"
+kind = "trigger"
+trigger_types = [
+  "github-issues",
+  "github-pull-requests",
+  "azure-cli-pull-requests",
+  "trello-cli-cards",
+  "monday-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.dev0/src/curupira_plugins/azure/__init__.py

@@ -0,0 +1 @@
+"""Azure DevOps pull-request discovery."""

curupira_plugins-0.1.0.dev0/src/curupira_plugins/azure/triggers.py

@@ -0,0 +1,56 @@
+"""Official Azure DevOps pull-request trigger."""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+
+from curupira_sdk import Curupira, RpcError
+
+_REPO_RE = re.compile(r"^[A-Za-z0-9_.-]+/[A-Za-z0-9_.-]+/[A-Za-z0-9_.-]+$")
+
+
+@dataclass
+class AzurePullRequest:
+    pull_request_number: int
+    pull_request_title: str
+    pull_request_url: str
+    pull_request_body: str = ""
+    pull_request_head_ref: str = ""
+    pull_request_base_ref: str = ""
+    id: str = ""
+
+    def __post_init__(self) -> None:
+        if not self.id:
+            self.id = str(self.pull_request_number)
+
+
+def _validate_repo(repo: str) -> None:
+    if _REPO_RE.fullmatch(repo) is None:
+        raise RpcError(-32003, "repo must use the organization/project/repository format")
+    if any(part in {".", ".."} for part in repo.split("/")):
+        raise RpcError(-32003, "repo must not contain traversal segments")
+
+
+def _check_repo(kwargs: dict[str, object]) -> None:
+    repo = kwargs.get("repo")
+    if not isinstance(repo, str):
+        raise RpcError(-32003, "repo must use the organization/project/repository format")
+    _validate_repo(repo)
+
+
+def register(app: Curupira) -> None:
+    """Register Azure DevOps triggers on ``app``."""
+
+    @app.trigger
+    def azure_cli_pull_requests(
+        repo: str,
+        status: str | None = None,
+        source_branch: str | None = None,
+        target_branch: str | None = None,
+    ) -> AzurePullRequest | None:
+        """Return the next eligible Azure DevOps pull request, or None."""
+        del repo, status, source_branch, target_branch
+        return None
+
+    app.param_check("azure-cli-pull-requests", _check_repo)

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

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

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

@@ -0,0 +1,203 @@
+"""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 IssueNode, 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
+
+SEARCH_QUERY = """
+query CuripiraSearch($query: String!, $first: Int!, $after: String) {
+  search(query: $query, type: ISSUE, first: $first, after: $after) {
+    pageInfo { hasNextPage endCursor }
+    nodes {
+      ... on Issue {
+        id number title body url state
+        author { login }
+        labels(first: 100) { nodes { name } }
+      }
+      ... on PullRequest {
+        id number title body url state
+        author { login }
+        labels(first: 100) { nodes { name } }
+        headRefName baseRefName headRefOid isDraft mergeable mergeStateStatus
+      }
+    }
+  }
+}
+"""
+
+NodeT = TypeVar("NodeT", bound=IssueNode)
+ItemT = TypeVar("ItemT")
+
+
+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},
+        }
+        body = self._post(payload)
+        try:
+            response = SearchResponse.model_validate_json(body)
+        except ValidationError as exc:
+            raise RpcError(-32002, f"unexpected GitHub GraphQL response: {exc}") from exc
+        if response.errors:
+            messages = "; ".join(error.message for error in response.errors)
+            raise RpcError(-32002, f"GitHub GraphQL error: {messages}")
+        if response.data is None:
+            raise RpcError(-32002, "GitHub GraphQL response has no data")
+        return response.data.search
+
+    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