curupira-plugins 0.1.0.dev0__py3-none-any.whl

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/__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/azure/__init__.py

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

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/github/__init__.py

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

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

curupira_plugins/github/filters.py

@@ -0,0 +1,136 @@
+"""Typed automation filters and their compilation into GitHub Search query strings."""
+
+from __future__ import annotations
+
+from typing import Literal
+
+from pydantic import BaseModel, ConfigDict, Field, field_validator
+
+REPO_PATTERN = r"^[A-Za-z0-9_.-]+/[A-Za-z0-9_.-]+$"
+
+SearchState = Literal["open", "closed", "all"]
+SortOrder = Literal[
+    "created-asc",
+    "created-desc",
+    "updated-asc",
+    "updated-desc",
+    "comments-asc",
+    "comments-desc",
+]
+MergeState = Literal[
+    "BEHIND", "BLOCKED", "CLEAN", "DIRTY", "DRAFT", "HAS_HOOKS", "UNKNOWN", "UNSTABLE"
+]
+
+
+class SearchFilters(BaseModel):
+    """Filters shared by issue and pull-request automations."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    repo: str = Field(pattern=REPO_PATTERN)
+    state: SearchState = "open"
+    labels: list[str] | None = None
+    exclude_labels: list[str] | None = None
+    assignee: str | None = None
+    author: str | None = None
+    milestone: str | None = None
+    project: str | None = None
+    sort: SortOrder | None = None
+
+    @field_validator("repo")
+    @classmethod
+    def _reject_traversal(cls, value: str) -> str:
+        if any(part in {".", ".."} for part in value.split("/")):
+            raise ValueError("repo must not contain traversal segments")
+        return value
+
+    def shared_qualifiers(self) -> list[str]:
+        """Return the Search qualifiers that both issues and pull requests accept."""
+        qualifiers = [f"repo:{self.repo}", _STATE_QUALIFIERS[self.state]]
+        qualifiers += [_qualifier("label", label) for label in self.labels or []]
+        qualifiers += [f"-{_qualifier('label', label)}" for label in self.exclude_labels or []]
+        qualifiers += _assignee_qualifiers(self.assignee)
+        if self.author:
+            qualifiers.append(_qualifier("author", self.author))
+        if self.milestone:
+            qualifiers.append(_qualifier("milestone", self.milestone))
+        if self.project:
+            qualifiers.append(_qualifier("project", self.project))
+        return qualifiers
+
+
+class IssueFilters(SearchFilters):
+    """Filters for `github-issues` automations."""
+
+    linked_pull_request: bool | None = None
+
+    def search_query(self) -> str:
+        qualifiers = ["is:issue", *self.shared_qualifiers()]
+        if self.linked_pull_request is not None:
+            qualifiers.append("linked:pr" if self.linked_pull_request else "-linked:pr")
+        return _join(qualifiers, self.sort)
+
+
+class PullRequestFilters(SearchFilters):
+    """Filters for `github-pull-requests` automations."""
+
+    draft: bool | None = None
+    base: str | None = None
+    head: str | None = None
+    review: Literal["none", "required", "approved", "changes_requested"] | None = None
+    ci_status: Literal["success", "failure", "pending"] | None = None
+    linked_issue: bool | None = None
+    mergeable: bool | None = None
+    merge_state: list[MergeState] | None = None
+
+    def search_query(self) -> str:
+        qualifiers = ["is:pr", *self.shared_qualifiers()]
+        if self.draft is not None:
+            qualifiers.append(f"draft:{str(self.draft).lower()}")
+        if self.base:
+            qualifiers.append(_qualifier("base", self.base))
+        if self.head:
+            qualifiers.append(_qualifier("head", self.head))
+        if self.review:
+            qualifiers.append(f"review:{self.review}")
+        if self.ci_status:
+            qualifiers.append(f"status:{self.ci_status}")
+        if self.linked_issue is not None:
+            qualifiers.append("linked:issue" if self.linked_issue else "-linked:issue")
+        return _join(qualifiers, self.sort)
+
+    def keeps(self, *, mergeable_state: str, merge_state_status: str) -> bool:
+        """Apply the GraphQL post-filters that Search cannot express."""
+        if self.mergeable is not None:
+            expected = "MERGEABLE" if self.mergeable else "CONFLICTING"
+            if mergeable_state != expected:
+                return False
+        return not self.merge_state or merge_state_status in self.merge_state
+
+
+_STATE_QUALIFIERS: dict[str, str] = {"open": "is:open", "closed": "is:closed", "all": ""}
+
+
+def _join(qualifiers: list[str], sort: str | None) -> str:
+    """Join qualifiers in a stable order, appending the sort qualifier last."""
+    parts = [part for part in qualifiers if part]
+    parts.append(f"sort:{sort or 'created-asc'}")
+    return " ".join(parts)
+
+
+def _assignee_qualifiers(assignee: str | None) -> list[str]:
+    if assignee is None:
+        return []
+    if assignee == "none":
+        return ["no:assignee"]
+    if assignee == "any":
+        return ["assignee:*"]
+    return [_qualifier("assignee", assignee)]
+
+
+def _qualifier(name: str, value: str) -> str:
+    """Render `name:value`, quoting values that contain whitespace or `"`, `:`, `,`."""
+    if any(char in value for char in ' \t\n":,'):
+        escaped = value.replace('"', '\\"')
+        return f'{name}:"{escaped}"'
+    return f"{name}:{value}"

curupira_plugins/github/models.py

@@ -0,0 +1,110 @@
+"""Typed models for GitHub GraphQL responses and the task items returned to the host."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic import BaseModel, ConfigDict, Field
+from pydantic.alias_generators import to_camel
+
+
+class _GraphQLModel(BaseModel):
+    """Parse GitHub's camelCase payloads and ignore fields the plugin does not use."""
+
+    model_config = ConfigDict(alias_generator=to_camel, populate_by_name=True, extra="ignore")
+
+
+class Actor(_GraphQLModel):
+    login: str
+
+
+class LabelName(_GraphQLModel):
+    name: str
+
+
+class LabelConnection(_GraphQLModel):
+    nodes: list[LabelName] = Field(default_factory=list)
+
+
+class IssueNode(_GraphQLModel):
+    id: str
+    number: int
+    title: str
+    body: str | None = None
+    url: str
+    state: str
+    author: Actor | None = None
+    labels: LabelConnection = Field(default_factory=LabelConnection)
+
+
+class PullRequestNode(IssueNode):
+    head_ref_name: str
+    base_ref_name: str
+    head_ref_oid: str
+    is_draft: bool
+    mergeable: str
+    merge_state_status: str
+
+
+class PageInfo(_GraphQLModel):
+    has_next_page: bool
+    end_cursor: str | None = None
+
+
+class SearchConnection(_GraphQLModel):
+    page_info: PageInfo
+    nodes: list[Any] = Field(default_factory=list)
+
+
+class SearchData(_GraphQLModel):
+    search: SearchConnection
+
+
+class GraphQLErrorEntry(_GraphQLModel):
+    message: str
+
+
+class SearchResponse(_GraphQLModel):
+    data: SearchData | None = None
+    errors: list[GraphQLErrorEntry] = Field(default_factory=list)
+
+
+class IssueItem(BaseModel):
+    """Issue task item; field names match the `${issue_*}` prompt placeholders."""
+
+    model_config = ConfigDict(frozen=True)
+
+    id: str
+    title: str
+    url: str
+    repo: str
+    issue_number: int
+    issue_title: str
+    issue_body: str
+    issue_url: str
+    issue_state: str
+    issue_author: str
+    issue_labels: list[str]
+
+
+class PullRequestItem(BaseModel):
+    """Pull-request task item; field names match the `${pull_request_*}` prompt placeholders."""
+
+    model_config = ConfigDict(frozen=True)
+
+    id: str
+    title: str
+    url: str
+    repo: str
+    pull_request_number: int
+    pull_request_title: str
+    pull_request_body: str
+    pull_request_url: str
+    pull_request_is_draft: bool
+    pull_request_head_ref: str
+    pull_request_base_ref: str
+    pull_request_head_sha: str
+    pull_request_author: str
+    pull_request_labels: list[str]
+    pull_request_mergeable: str
+    pull_request_merge_state_status: str

curupira_plugins/github/triggers.py

@@ -0,0 +1,189 @@
+"""Official GitHub issues / pull-requests triggers.
+
+Discovery authenticates through `gh auth token`; no GitHub credentials are stored here.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from curupira_sdk import Curupira, RpcError
+from pydantic import ValidationError
+
+from curupira_plugins.github.client import Discovery, GitHubClient, GitHubCliToken, parse_nodes
+from curupira_plugins.github.filters import IssueFilters, PullRequestFilters
+from curupira_plugins.github.models import IssueItem, IssueNode, PullRequestItem, PullRequestNode
+
+_CLIENT = GitHubClient(GitHubCliToken())
+# One discovery feed per distinct filter set, kept for the lifetime of this process.
+_FEEDS: dict[str, Discovery[Any, Any]] = {}
+
+
+def _validation_message(exc: ValidationError) -> str:
+    return "; ".join(
+        f"{'.'.join(str(part) for part in error['loc'])}: {error['msg']}" for error in exc.errors()
+    )
+
+
+def _check_issue_filters(kwargs: dict[str, object]) -> None:
+    try:
+        IssueFilters(**kwargs)  # type: ignore[arg-type]
+    except ValidationError as exc:
+        raise RpcError(-32003, _validation_message(exc)) from exc
+
+
+def _check_pull_request_filters(kwargs: dict[str, object]) -> None:
+    try:
+        PullRequestFilters(**kwargs)  # type: ignore[arg-type]
+    except ValidationError as exc:
+        raise RpcError(-32003, _validation_message(exc)) from exc
+
+
+def _issue_item(repo: str, node: IssueNode) -> IssueItem:
+    return IssueItem(
+        id=str(node.number),
+        title=node.title,
+        url=node.url,
+        repo=repo,
+        issue_number=node.number,
+        issue_title=node.title,
+        issue_body=node.body or "",
+        issue_url=node.url,
+        issue_state=node.state,
+        issue_author=node.author.login if node.author else "",
+        issue_labels=[label.name for label in node.labels.nodes],
+    )
+
+
+def _pull_request_item(repo: str, node: PullRequestNode) -> PullRequestItem:
+    return PullRequestItem(
+        id=str(node.number),
+        title=node.title,
+        url=node.url,
+        repo=repo,
+        pull_request_number=node.number,
+        pull_request_title=node.title,
+        pull_request_body=node.body or "",
+        pull_request_url=node.url,
+        pull_request_is_draft=node.is_draft,
+        pull_request_head_ref=node.head_ref_name,
+        pull_request_base_ref=node.base_ref_name,
+        pull_request_head_sha=node.head_ref_oid,
+        pull_request_author=node.author.login if node.author else "",
+        pull_request_labels=[label.name for label in node.labels.nodes],
+        pull_request_mergeable=node.mergeable,
+        pull_request_merge_state_status=node.merge_state_status,
+    )
+
+
+def _issue_feed(filters: IssueFilters) -> Discovery[IssueNode, IssueItem]:
+    key = f"issue:{filters.model_dump_json()}"
+    feed = _FEEDS.get(key)
+    if feed is None:
+        query = filters.search_query()
+        feed = Discovery(
+            fetch_page=lambda after: _CLIENT.search(query, after=after),
+            parse_page=lambda connection: parse_nodes(connection, IssueNode),
+            keep=lambda node: True,
+            to_item=lambda node: _issue_item(filters.repo, node),
+        )
+        _FEEDS[key] = feed
+    return feed
+
+
+def _pull_request_feed(
+    filters: PullRequestFilters,
+) -> Discovery[PullRequestNode, PullRequestItem]:
+    key = f"pull_request:{filters.model_dump_json()}"
+    feed = _FEEDS.get(key)
+    if feed is None:
+        query = filters.search_query()
+        feed = Discovery(
+            fetch_page=lambda after: _CLIENT.search(query, after=after),
+            parse_page=lambda connection: parse_nodes(connection, PullRequestNode),
+            keep=lambda node: filters.keeps(
+                mergeable_state=node.mergeable,
+                merge_state_status=node.merge_state_status,
+            ),
+            to_item=lambda node: _pull_request_item(filters.repo, node),
+        )
+        _FEEDS[key] = feed
+    return feed
+
+
+def github_issues(
+    repo: str,
+    labels: list[str] | None = None,
+    exclude_labels: list[str] | None = None,
+    state: str = "open",
+    assignee: str | None = None,
+    author: str | None = None,
+    milestone: str | None = None,
+    project: str | None = None,
+    linked_pull_request: bool | None = None,
+    sort: str | None = None,
+) -> IssueItem | None:
+    """Return the next eligible GitHub issue, or None when none are available."""
+    filters = IssueFilters(
+        repo=repo,
+        labels=labels,
+        exclude_labels=exclude_labels,
+        state=state,  # type: ignore[arg-type]
+        assignee=assignee,
+        author=author,
+        milestone=milestone,
+        project=project,
+        linked_pull_request=linked_pull_request,
+        sort=sort,  # type: ignore[arg-type]
+    )
+    return _issue_feed(filters).next_item()
+
+
+def github_pull_requests(
+    repo: str,
+    labels: list[str] | None = None,
+    exclude_labels: list[str] | None = None,
+    state: str = "open",
+    assignee: str | None = None,
+    author: str | None = None,
+    milestone: str | None = None,
+    project: str | None = None,
+    draft: bool | None = None,
+    base: str | None = None,
+    head: str | None = None,
+    review: str | None = None,
+    ci_status: str | None = None,
+    linked_issue: bool | None = None,
+    mergeable: bool | None = None,
+    merge_state: list[str] | None = None,
+    sort: str | None = None,
+) -> PullRequestItem | None:
+    """Return the next eligible GitHub pull request, or None when none are available."""
+    filters = PullRequestFilters(
+        repo=repo,
+        labels=labels,
+        exclude_labels=exclude_labels,
+        state=state,  # type: ignore[arg-type]
+        assignee=assignee,
+        author=author,
+        milestone=milestone,
+        project=project,
+        draft=draft,
+        base=base,
+        head=head,
+        review=review,  # type: ignore[arg-type]
+        ci_status=ci_status,  # type: ignore[arg-type]
+        linked_issue=linked_issue,
+        mergeable=mergeable,
+        merge_state=merge_state,  # type: ignore[arg-type]
+        sort=sort,  # type: ignore[arg-type]
+    )
+    return _pull_request_feed(filters).next_item()
+
+
+def register(app: Curupira) -> None:
+    """Register GitHub triggers on ``app``."""
+    app.trigger(github_issues)
+    app.trigger(github_pull_requests)
+    app.param_check("github-issues", _check_issue_filters)
+    app.param_check("github-pull-requests", _check_pull_request_filters)

curupira_plugins/monday/__init__.py

@@ -0,0 +1 @@
+"""monday.com item discovery."""

curupira_plugins/monday/triggers.py

@@ -0,0 +1,30 @@
+"""Official monday.com items trigger."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from curupira_sdk import Curupira
+
+
+@dataclass
+class MondayItem:
+    id: str
+    name: str
+    url: str
+    board_id: str = ""
+    group_title: str = ""
+
+
+def register(app: Curupira) -> None:
+    """Register monday.com triggers on ``app``."""
+
+    @app.trigger
+    async def monday_items(
+        board_id: str,
+        group_ids: list[str] | None = None,
+        token_env: str | None = None,
+    ) -> MondayItem | None:
+        """Return the next eligible monday.com item, or None when none are available."""
+        del board_id, group_ids, token_env
+        return None

curupira_plugins/trello/__init__.py

@@ -0,0 +1 @@
+"""Trello card discovery."""

curupira_plugins/trello/triggers.py

@@ -0,0 +1,29 @@
+"""Official Trello card trigger."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from curupira_sdk import Curupira
+
+
+@dataclass
+class Card:
+    id: str
+    name: str
+    url: str
+    desc: str = ""
+    list_name: str = ""
+
+
+def register(app: Curupira) -> None:
+    """Register Trello triggers on ``app``."""
+
+    @app.trigger
+    def trello_cli_cards(
+        board_id: str,
+        list_ids: list[str] | None = None,
+    ) -> Card | None:
+        """Return the next eligible Trello card, or None when none are available."""
+        del board_id, list_ids
+        return None

curupira_plugins-0.1.0.dev0.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,17 @@
+curupira_plugins/__init__.py,sha256=q4tVccbhzGovBhKCP5mwz1jhfzhMlr8t3ROKXm_NT6U,245
+curupira_plugins/__main__.py,sha256=QPOXjh-dVCCHaJSOJ8ifVbADkXkwPBMTBa58KVHqOrM,1464
+curupira_plugins/azure/__init__.py,sha256=2w6cJekJjOdQb09Yw1-g1DwoshG22XcQFoiMrvjf1so,43
+curupira_plugins/azure/triggers.py,sha256=3okzpy8OXkTvkirJxK_sIMjHbbI6pMtORi-tB0Tawe0,1677
+curupira_plugins/github/__init__.py,sha256=ryXNkmrBCwwigyt0qzpwdkzwYdPlabvTimlkuPFxaL0,48
+curupira_plugins/github/client.py,sha256=RMuI0PIAqo2SNzKQgyACBgduN0TFyaMgoaTSGhy_QOI,7419
+curupira_plugins/github/filters.py,sha256=FyDb2Db6UcESxX61sxuHQduexnghwB8DT83IguLEIaA,4953
+curupira_plugins/github/models.py,sha256=Hk4_XVBxuV9sDjI-7DrBC7KWrLzf6IWniu3wcR04Yms,2497
+curupira_plugins/github/triggers.py,sha256=0eLmUH1kLz48c32raO4FDZ_D1wBFtzRfGCG9t-c2Arg,6441
+curupira_plugins/monday/__init__.py,sha256=Rv10WVHt8xoy49aBqu305__VkEnzaL7ZjyIVYJXXjQg,32
+curupira_plugins/monday/triggers.py,sha256=-BICinZBgy9emPcxCRz5KQSblkRKriIeWfQq5l85gFY,687
+curupira_plugins/trello/__init__.py,sha256=KeRfcHvQFI1fqko_GXMowI3UHmqQzDuwlRN2Ol8M-V4,29
+curupira_plugins/trello/triggers.py,sha256=9W6PPbBIMlLKi0FyU-Dx5k6IgOvezatOEFMrYFbDo4g,603
+curupira_plugins-0.1.0.dev0.dist-info/METADATA,sha256=nmMaQiLShcNuznwt93dTDeF0QA6ZUa03oOTIgxgBbQA,375
+curupira_plugins-0.1.0.dev0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+curupira_plugins-0.1.0.dev0.dist-info/entry_points.txt,sha256=65ycZitgY2NoI1K8vepqnHghBab4F4X-TX-9pJoYlZw,68
+curupira_plugins-0.1.0.dev0.dist-info/RECORD,,

curupira_plugins-0.1.0.dev0.dist-info/WHEEL

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

curupira_plugins-0.1.0.dev0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+curupira-plugins = curupira_plugins.__main__:main