xyberos-linear 0.1.0__tar.gz

xyberos_linear-0.1.0/PKG-INFO

@@ -0,0 +1,56 @@
+Metadata-Version: 2.4
+Name: xyberos-linear
+Version: 0.1.0
+Summary: Linear GraphQL plugin (RFC-0019, M7): search and create issues
+License: Apache-2.0
+Keywords: xyberos,plugin,linear,tool
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: xyberos>=1.0
+
+# xyberos-linear
+
+**Linear GraphQL plugin — RFC-0019, M7 (community wave).** Search and create
+issues from Xyberos agents via the Linear GraphQL API. Stdlib-only with an
+injectable transport for tests.
+
+## Install
+
+```bash
+pip install -e ./linear
+```
+
+## Usage
+
+```python
+from xyberos import create_app
+from xyberos_linear import LinearPlugin
+
+app = create_app()
+app.load_plugin(LinearPlugin())          # key from LINEAR_API_KEY
+
+app.tools.execute("linear_search_issues", None, query="bug", first=10)
+app.tools.execute("linear_create_issue", None, team_id="TEAM_ID", title="New issue", description="...")
+```
+
+## Tools
+
+| Tool | Notes |
+| ---- | ----- |
+| `linear_search_issues(query="", first=10)` | search by title |
+| `linear_create_issue(team_id, title, description="")` | create an issue |
+
+Requires `LINEAR_API_KEY` (sent as the `Authorization` header).
+
+## Tests
+
+```bash
+pip install pytest
+pytest tests/
+```
+
+Canned responses via an injectable transport — no network.
+
+## Ship location
+
+Plugin (`xyberos.plugins` entry point) — community wave (M7).

xyberos_linear-0.1.0/README.md

@@ -0,0 +1,46 @@
+# xyberos-linear
+
+**Linear GraphQL plugin — RFC-0019, M7 (community wave).** Search and create
+issues from Xyberos agents via the Linear GraphQL API. Stdlib-only with an
+injectable transport for tests.
+
+## Install
+
+```bash
+pip install -e ./linear
+```
+
+## Usage
+
+```python
+from xyberos import create_app
+from xyberos_linear import LinearPlugin
+
+app = create_app()
+app.load_plugin(LinearPlugin())          # key from LINEAR_API_KEY
+
+app.tools.execute("linear_search_issues", None, query="bug", first=10)
+app.tools.execute("linear_create_issue", None, team_id="TEAM_ID", title="New issue", description="...")
+```
+
+## Tools
+
+| Tool | Notes |
+| ---- | ----- |
+| `linear_search_issues(query="", first=10)` | search by title |
+| `linear_create_issue(team_id, title, description="")` | create an issue |
+
+Requires `LINEAR_API_KEY` (sent as the `Authorization` header).
+
+## Tests
+
+```bash
+pip install pytest
+pytest tests/
+```
+
+Canned responses via an injectable transport — no network.
+
+## Ship location
+
+Plugin (`xyberos.plugins` entry point) — community wave (M7).

xyberos_linear-0.1.0/pyproject.toml

@@ -0,0 +1,23 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "xyberos-linear"
+version = "0.1.0"
+description = "Linear GraphQL plugin (RFC-0019, M7): search and create issues"
+readme = "README.md"
+requires-python = ">=3.10"
+license = {text = "Apache-2.0"}
+dependencies = ["xyberos>=1.0"]
+keywords = ["xyberos", "plugin", "linear", "tool"]
+
+[project.entry-points."xyberos.plugins"]
+linear = "xyberos_linear.plugin:plugin"
+
+[tool.setuptools]
+packages = ["xyberos_linear"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["."]

xyberos_linear-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

xyberos_linear-0.1.0/tests/test_client.py

@@ -0,0 +1,48 @@
+"""Tests for the Linear GraphQL client (injectable transport, no network)."""
+
+from __future__ import annotations
+
+import pytest
+from xyberos.exceptions.provider import ProviderError
+
+from xyberos_linear import LinearClient
+
+
+def _fake_request():
+    def request(method, url, **kwargs):
+        body = kwargs.get("json_body", {})
+        if "issueCreate" in body.get("query", ""):
+            return 200, {"data": {"issueCreate": {"success": True, "issue": {"id": "i1", "url": "https://linear.app/x/ISSUE-1"}}}}
+        return 200, {"data": {"issues": {"nodes": [{"id": "i1", "identifier": "TEAM-1", "title": "Fix bug", "url": "https://linear.app/x/TEAM-1"}]}}}
+
+    return request
+
+
+def test_search_issues():
+    request = _fake_request()
+    client = LinearClient(api_key="k", request=request)
+    issues = client.search_issues("bug", first=5)
+    assert issues == [{"id": "i1", "identifier": "TEAM-1", "title": "Fix bug", "url": "https://linear.app/x/TEAM-1"}]
+
+
+def test_create_issue():
+    request = _fake_request()
+    client = LinearClient(api_key="k", request=request)
+    result = client.create_issue("team1", "New issue", "details")
+    assert result == {"id": "i1", "url": "https://linear.app/x/ISSUE-1", "success": True}
+
+
+def test_requires_api_key():
+    request = _fake_request()
+    client = LinearClient(api_key=None, request=request)
+    with pytest.raises(ProviderError, match="LINEAR_API_KEY"):
+        client.search_issues()
+
+
+def test_graphql_error_raises():
+    def request(method, url, **kwargs):
+        return 200, {"errors": [{"message": "Unauthorized"}]}
+
+    client = LinearClient(api_key="k", request=request)
+    with pytest.raises(ProviderError, match="Unauthorized"):
+        client.search_issues()

xyberos_linear-0.1.0/tests/test_plugin.py

@@ -0,0 +1,26 @@
+"""Tests for loading the Linear plugin into a Xyberos app."""
+
+from __future__ import annotations
+
+from xyberos import create_app
+
+from xyberos_linear import LinearPlugin
+
+
+def _fake_request():
+    def request(method, url, **kwargs):
+        return 200, {"data": {"issues": {"nodes": [{"id": "i1", "identifier": "TEAM-1", "title": "Fix bug", "url": "https://linear.app/x/TEAM-1"}]}}}
+
+    return request
+
+
+def test_plugin_registers_and_executes():
+    app = create_app()
+    app.load_plugin(LinearPlugin(api_key="k", request=_fake_request()))
+    assert "linear_search_issues" in app.tools.names
+    assert "linear_create_issue" in app.tools.names
+
+    issues = app.tools.execute("linear_search_issues", None, query="bug")
+    assert issues[0]["identifier"] == "TEAM-1"
+
+    app.unload_plugin("linear")

xyberos_linear-0.1.0/xyberos_linear/__init__.py

@@ -0,0 +1,6 @@
+"""Linear GraphQL plugin (RFC-0019, M7)."""
+
+from .client import LinearClient
+from .plugin import LinearPlugin
+
+__all__ = ["LinearClient", "LinearPlugin"]

xyberos_linear-0.1.0/xyberos_linear/client.py

@@ -0,0 +1,70 @@
+"""A minimal Linear GraphQL client (stdlib ``urllib``, injectable transport)."""
+
+from __future__ import annotations
+
+import json
+import os
+from typing import Any
+
+from xyberos.exceptions.provider import ProviderError
+
+from .http import RequestTransport, default_request
+
+
+def _raise_for_status(status: int, body: Any) -> None:
+    if 200 <= status < 300:
+        return
+    message = body if isinstance(body, str) else str(body)
+    raise ProviderError(f"Linear API returned HTTP {status}: {message[:200]}")
+
+
+class LinearClient:
+    """Thin client for the Linear GraphQL API."""
+
+    def __init__(
+        self,
+        api_key: str | None = None,
+        *,
+        base_url: str = "https://api.linear.app/graphql",
+        request: RequestTransport | None = None,
+        timeout: float = 30.0,
+    ) -> None:
+        self._api_key = api_key if api_key is not None else os.getenv("LINEAR_API_KEY")
+        self._base_url = base_url
+        self._request = request or default_request
+        self._timeout = timeout
+
+    def search_issues(self, query: str = "", *, first: int = 10) -> list[dict[str, Any]]:
+        filter_clause = f'filter: {{title: {{contains: {json.dumps(query)}}}}}, ' if query else ""
+        graphql = f"{{ issues({filter_clause}first: {first}) {{ nodes {{ id identifier title url }} }} }}"
+        data = self._graphql(graphql)
+        return [
+            {"id": node.get("id"), "identifier": node.get("identifier"), "title": node.get("title"), "url": node.get("url")}
+            for node in data.get("issues", {}).get("nodes", [])
+        ]
+
+    def create_issue(self, team_id: str, title: str, description: str = "") -> dict[str, Any]:
+        graphql = (
+            "mutation { issueCreate(input: {"
+            f'teamId: {json.dumps(team_id)}, title: {json.dumps(title)}, description: {json.dumps(description)}'
+            "}) { success issue { id url } } }"
+        )
+        data = self._graphql(graphql)
+        created = data.get("issueCreate", {})
+        issue = created.get("issue") or {}
+        return {"id": issue.get("id"), "url": issue.get("url"), "success": created.get("success")}
+
+    def _graphql(self, query: str) -> dict[str, Any]:
+        if not self._api_key:
+            raise ProviderError("Linear requires an API key (set LINEAR_API_KEY)")
+        status, body = self._request(
+            "POST",
+            self._base_url,
+            json_body={"query": query},
+            headers={"Authorization": self._api_key},
+            timeout=self._timeout,
+        )
+        _raise_for_status(status, body)
+        if body.get("errors"):
+            raise ProviderError(f"Linear GraphQL error: {body['errors']}")
+        return body.get("data") or {}

xyberos_linear-0.1.0/xyberos_linear/http.py

@@ -0,0 +1,57 @@
+"""A tiny stdlib HTTP helper (no third-party deps).
+
+``default_request`` performs one HTTP request with ``urllib`` and returns
+``(status, body)`` where ``body`` is parsed JSON when the response is JSON,
+otherwise raw text. Injectable so tests run without a network.
+"""
+
+from __future__ import annotations
+
+import json
+import urllib.error
+import urllib.parse
+import urllib.request
+from typing import Any, Callable
+
+#: (method, url, *, json_body, headers, query, timeout) -> (status, body)
+RequestTransport = Callable[..., tuple[int, Any]]
+
+
+def default_request(
+    method: str,
+    url: str,
+    *,
+    json_body: Any = None,
+    headers: dict[str, str] | None = None,
+    query: dict[str, Any] | None = None,
+    timeout: float = 30.0,
+) -> tuple[int, Any]:
+    """Send one request and return ``(status, parsed_json_or_text)``."""
+    final_url = url
+    if query:
+        separator = "&" if "?" in url else "?"
+        final_url = url + separator + urllib.parse.urlencode(query)
+
+    data: bytes | None = None
+    request_headers = dict(headers or {})
+    if json_body is not None:
+        data = json.dumps(json_body).encode("utf-8")
+        request_headers.setdefault("Content-Type", "application/json")
+
+    request = urllib.request.Request(
+        final_url, data=data, headers=request_headers, method=method
+    )
+    try:
+        with urllib.request.urlopen(request, timeout=timeout) as response:
+            raw = response.read()
+            content_type = response.headers.get("Content-Type", "")
+    except urllib.error.HTTPError as exc:
+        return exc.code, exc.read().decode("utf-8", errors="replace")
+
+    text = raw.decode("utf-8", errors="replace")
+    if "application/json" in content_type or text.lstrip().startswith("{"):
+        try:
+            return 200, json.loads(text)
+        except json.JSONDecodeError:
+            return 200, text
+    return 200, text

xyberos_linear-0.1.0/xyberos_linear/plugin.py

@@ -0,0 +1,60 @@
+"""Linear plugin entry point (RFC-0019, M7)."""
+
+from __future__ import annotations
+
+from typing import Any, cast
+
+from xyberos.contracts import Plugin, Tool
+from xyberos.tools import FunctionTool
+
+from .client import LinearClient
+from .http import RequestTransport
+
+
+def _pop_tool(registry: Any, name: str) -> None:
+    unregister = getattr(registry, "unregister", None)
+    if callable(unregister):
+        unregister(name)
+        return
+    store = getattr(registry, "_tools", None)
+    if isinstance(store, dict):
+        cast(dict[str, Any], store).pop(name, None)
+
+
+class LinearPlugin(Plugin):
+    """Registers Linear tools (search / create issues)."""
+
+    def __init__(self, api_key: str | None = None, *, request: RequestTransport | None = None) -> None:
+        self._client = LinearClient(api_key, request=request)
+
+    @property
+    def name(self) -> str:
+        return "linear"
+
+    def tools(self) -> list[Tool]:
+        client = self._client
+
+        def _search_issues(query: str = "", first: int = 10) -> list[dict[str, Any]]:
+            return client.search_issues(query, first=first)
+
+        def _create_issue(team_id: str, title: str, description: str = "") -> dict[str, Any]:
+            return client.create_issue(team_id, title, description)
+
+        return [
+            FunctionTool("linear_search_issues", _search_issues, description="Search Linear issues by title."),
+            FunctionTool("linear_create_issue", _create_issue, description="Create a Linear issue in a team."),
+        ]
+
+    def register(self, kernel: object) -> None:
+        registry = kernel.resolve("tools")
+        for tool in self.tools():
+            registry.register(tool)
+
+    def unregister(self, kernel: object) -> None:
+        registry = kernel.resolve("tools")
+        for tool in self.tools():
+            _pop_tool(registry, tool.name)
+
+
+#: Auto-discovered by ``app.load_entry_points()``.
+plugin = LinearPlugin()

xyberos_linear-0.1.0/xyberos_linear.egg-info/PKG-INFO

@@ -0,0 +1,56 @@
+Metadata-Version: 2.4
+Name: xyberos-linear
+Version: 0.1.0
+Summary: Linear GraphQL plugin (RFC-0019, M7): search and create issues
+License: Apache-2.0
+Keywords: xyberos,plugin,linear,tool
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: xyberos>=1.0
+
+# xyberos-linear
+
+**Linear GraphQL plugin — RFC-0019, M7 (community wave).** Search and create
+issues from Xyberos agents via the Linear GraphQL API. Stdlib-only with an
+injectable transport for tests.
+
+## Install
+
+```bash
+pip install -e ./linear
+```
+
+## Usage
+
+```python
+from xyberos import create_app
+from xyberos_linear import LinearPlugin
+
+app = create_app()
+app.load_plugin(LinearPlugin())          # key from LINEAR_API_KEY
+
+app.tools.execute("linear_search_issues", None, query="bug", first=10)
+app.tools.execute("linear_create_issue", None, team_id="TEAM_ID", title="New issue", description="...")
+```
+
+## Tools
+
+| Tool | Notes |
+| ---- | ----- |
+| `linear_search_issues(query="", first=10)` | search by title |
+| `linear_create_issue(team_id, title, description="")` | create an issue |
+
+Requires `LINEAR_API_KEY` (sent as the `Authorization` header).
+
+## Tests
+
+```bash
+pip install pytest
+pytest tests/
+```
+
+Canned responses via an injectable transport — no network.
+
+## Ship location
+
+Plugin (`xyberos.plugins` entry point) — community wave (M7).

xyberos_linear-0.1.0/xyberos_linear.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+README.md
+pyproject.toml
+tests/test_client.py
+tests/test_plugin.py
+xyberos_linear/__init__.py
+xyberos_linear/client.py
+xyberos_linear/http.py
+xyberos_linear/plugin.py
+xyberos_linear.egg-info/PKG-INFO
+xyberos_linear.egg-info/SOURCES.txt
+xyberos_linear.egg-info/dependency_links.txt
+xyberos_linear.egg-info/entry_points.txt
+xyberos_linear.egg-info/requires.txt
+xyberos_linear.egg-info/top_level.txt

xyberos_linear-0.1.0/xyberos_linear.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

xyberos_linear-0.1.0/xyberos_linear.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[xyberos.plugins]
+linear = xyberos_linear.plugin:plugin

xyberos_linear-0.1.0/xyberos_linear.egg-info/requires.txt

@@ -0,0 +1 @@
+xyberos>=1.0

xyberos_linear-0.1.0/xyberos_linear.egg-info/top_level.txt

@@ -0,0 +1 @@
+xyberos_linear