etki 0.1.0a2__py3-none-any.whl

etki/__init__.py

@@ -0,0 +1,3 @@
+"""Etki — PMO decision-support system (Faz 0 walking skeleton)."""
+
+__version__ = "0.0.0"

etki/adapters/ast_code_index.py

@@ -0,0 +1,131 @@
+"""Dependency-free Python-AST code indexer (CodeRepositoryProvider).
+
+Real static analysis via the stdlib `ast`: imports → dependencies, functions +
+control structures → complexity. Produces the same normalized schema as Joern;
+lets the demo run without Joern too (for Python sources only).
+"""
+
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+from etki.adapters.code_index import CodeIndex, FileNode, IndexBackedCodeRepository
+from etki.adapters.manifests import parse_manifests
+
+_CONTROL = (ast.If, ast.For, ast.AsyncFor, ast.While, ast.Try, ast.With, ast.AsyncWith)
+
+
+def _imports(tree: ast.AST) -> list[str]:
+    names: set[str] = set()
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Import):
+            for alias in node.names:
+                names.add(alias.name.split(".")[0])
+        elif isinstance(node, ast.ImportFrom) and node.module and node.level == 0:
+            names.add(node.module.split(".")[0])
+    return sorted(names)
+
+
+def _api_uses(tree: ast.AST) -> dict[str, list[str]]:
+    """Which SYMBOLS of each imported package the file actually touches — the
+    call-site surface a version change must be audited against.
+
+    Two capture paths: `from pkg import name` (the name itself) and attribute
+    access on an imported alias (`requests.get`, `np.array` → numpy.array).
+    Keys are TOP-LEVEL package names (alias-resolved); internal/stdlib keys are
+    filtered later in parse_code_index, same as plain imports."""
+    alias_to_pkg: dict[str, str] = {}
+    uses: dict[str, set[str]] = {}
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Import):
+            for alias in node.names:
+                top = alias.name.split(".")[0]
+                alias_to_pkg[(alias.asname or alias.name).split(".")[0]] = top
+        elif isinstance(node, ast.ImportFrom) and node.module and node.level == 0:
+            top = node.module.split(".")[0]
+            for alias in node.names:
+                if alias.name != "*":
+                    uses.setdefault(top, set()).add(alias.name)
+    for node in ast.walk(tree):
+        if (
+            isinstance(node, ast.Attribute)
+            and isinstance(node.value, ast.Name)
+            and node.value.id in alias_to_pkg
+        ):
+            uses.setdefault(alias_to_pkg[node.value.id], set()).add(node.attr)
+    return {pkg: sorted(symbols) for pkg, symbols in sorted(uses.items())}
+
+
+def _dotted_chain(node: ast.Attribute) -> list[str] | None:
+    """`np.linalg.norm` → ["np", "linalg", "norm"]; None if the base isn't a Name."""
+    parts: list[str] = []
+    current: ast.expr = node
+    while isinstance(current, ast.Attribute):
+        parts.append(current.attr)
+        current = current.value
+    if isinstance(current, ast.Name):
+        parts.append(current.id)
+        return list(reversed(parts))
+    return None
+
+
+def _api_paths(tree: ast.AST) -> dict[str, list[str]]:
+    """QUALIFIED use paths per package — the precise audit input for version
+    diffs (`from faker.providers.credit_card import CreditCard` →
+    "faker.providers.credit_card.CreditCard"; `np.linalg.norm` →
+    "numpy.linalg.norm", alias-resolved). Keys = top-level package; only
+    absolute imports (level == 0) — relative imports are internal."""
+    alias_to_module: dict[str, str] = {}
+    paths: dict[str, set[str]] = {}
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Import):
+            for alias in node.names:
+                alias_to_module[(alias.asname or alias.name).split(".")[0]] = (
+                    alias.name if alias.asname else alias.name.split(".")[0]
+                )
+        elif isinstance(node, ast.ImportFrom) and node.module and node.level == 0:
+            top = node.module.split(".")[0]
+            for alias in node.names:
+                if alias.name != "*":  # original name, never the asname
+                    paths.setdefault(top, set()).add(f"{node.module}.{alias.name}")
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Attribute):
+            chain = _dotted_chain(node)
+            if chain and chain[0] in alias_to_module:
+                resolved = [*alias_to_module[chain[0]].split("."), *chain[1:]]
+                paths.setdefault(resolved[0], set()).add(".".join(resolved))
+    return {pkg: sorted(qualified) for pkg, qualified in sorted(paths.items())}
+
+
+def build_ast_index(src_root: str | Path) -> CodeIndex:
+    root = Path(src_root)
+    files: list[FileNode] = []
+    for py in sorted(root.rglob("*.py")):
+        source = py.read_text(encoding="utf-8")
+        tree = ast.parse(source)
+        functions = [
+            node.name
+            for node in ast.walk(tree)
+            if isinstance(node, ast.FunctionDef | ast.AsyncFunctionDef)
+        ]
+        control = sum(1 for node in ast.walk(tree) if isinstance(node, _CONTROL))
+        files.append(
+            FileNode(
+                path=str(py.relative_to(root)),
+                loc=len(source.splitlines()),
+                functions=functions,
+                control_structures=control,
+                imports=_imports(tree),
+                api_uses=_api_uses(tree),
+                api_paths=_api_paths(tree),
+            )
+        )
+    return CodeIndex(
+        root=str(root), producer="ast", files=files, dependencies=parse_manifests(root)
+    )
+
+
+class AstCodeRepositoryProvider(IndexBackedCodeRepository):
+    def __init__(self, src_root: str | Path, churn: dict[str, int] | None = None) -> None:
+        super().__init__(build_ast_index(src_root), churn, supports_incremental_diff=False)

etki/adapters/azure_devops_work_item.py

@@ -0,0 +1,101 @@
+"""Azure DevOps (Boards) WorkItemProvider — REST 7.x, PAT auth.
+
+Effort comes from `Microsoft.VSTS.Scheduling.CompletedWork` (float HOURS on
+task-level items) → normalized to `WorkItem.effort_seconds` inside the adapter.
+Similar-item search runs a WIQL query over title/description, then batch-fetches
+fields. Requires a live organization → integration is CI-skipped; pure parsing is
+unit-tested. Config example:
+
+    connectors:
+      work_items:
+        adapter: azure_devops
+        options:
+          organization: myorg            # dev.azure.com/myorg
+          project: MyProject
+          pat: env:AZDO_PAT               # scope: Work Items (Read)
+"""
+
+from __future__ import annotations
+
+import base64
+from typing import Any
+
+import httpx
+
+from etki.core.models import WorkItem
+from etki.core.ports import Capabilities
+
+_FIELDS = (
+    "System.Title,System.State,System.WorkItemType,System.Description,"
+    "Microsoft.VSTS.Scheduling.CompletedWork"
+)
+_API = "api-version=7.1"
+
+
+class AzureDevOpsWorkItemProvider:
+    def __init__(
+        self, organization: str, project: str, pat: str, timeout: float = 30.0
+    ) -> None:
+        self._base_url = f"https://dev.azure.com/{organization}/{project}"
+        token = base64.b64encode(f":{pat}".encode()).decode()  # PAT: empty user + token
+        self._auth = f"Basic {token}"
+        self._timeout = timeout
+
+    def _headers(self) -> dict[str, str]:
+        return {"Authorization": self._auth, "Content-Type": "application/json"}
+
+    def _to_work_item(self, raw: dict[str, Any]) -> WorkItem:
+        fields = raw.get("fields") or {}
+        completed_hours = float(
+            fields.get("Microsoft.VSTS.Scheduling.CompletedWork") or 0.0
+        )
+        return WorkItem(
+            id=str(raw.get("id", "?")),
+            title=fields.get("System.Title", "") or "",
+            description=str(fields.get("System.Description") or ""),
+            category=str(fields.get("System.WorkItemType") or "") or None,
+            status=str(fields.get("System.State") or ""),
+            effort_seconds=int(completed_hours * 3600),
+        )
+
+    async def get_work_item(self, item_id: str) -> WorkItem:
+        async with httpx.AsyncClient(timeout=self._timeout) as client:
+            response = await client.get(
+                f"{self._base_url}/_apis/wit/workitems/{item_id}?fields={_FIELDS}&{_API}",
+                headers=self._headers(),
+            )
+            response.raise_for_status()
+            return self._to_work_item(response.json())
+
+    async def find_similar(self, description: str, *, limit: int = 5) -> list[WorkItem]:
+        term = description.replace("'", " ").strip()[:200]
+        wiql = (
+            "SELECT [System.Id] FROM WorkItems "
+            f"WHERE [System.Title] CONTAINS '{term}' "
+            "ORDER BY [System.ChangedDate] DESC"
+        )
+        async with httpx.AsyncClient(timeout=self._timeout) as client:
+            response = await client.post(
+                f"{self._base_url}/_apis/wit/wiql?$top={limit}&{_API}",
+                headers=self._headers(),
+                json={"query": wiql},
+            )
+            response.raise_for_status()
+            ids = [str(w["id"]) for w in response.json().get("workItems", [])][:limit]
+            if not ids:
+                return []
+            batch = await client.get(
+                f"{self._base_url}/_apis/wit/workitems?ids={','.join(ids)}"
+                f"&fields={_FIELDS}&{_API}",
+                headers=self._headers(),
+            )
+            batch.raise_for_status()
+            return [self._to_work_item(w) for w in batch.json().get("value", [])]
+
+    def capabilities(self) -> Capabilities:
+        return Capabilities(
+            supports_webhooks=True,  # service hooks
+            supports_realtime=False,
+            supports_effort_tracking=True,  # CompletedWork (hours → seconds here)
+            supports_incremental_diff=False,
+        )

etki/adapters/code_index.py

@@ -0,0 +1,246 @@
+"""Normalized 'code index' schema — the contract between any indexer (Joern, AST...)
+and the core. Pure and testable: the indexer produces this schema,
+`parse_code_index` converts it into a `CodeModule` graph.
+"""
+
+from __future__ import annotations
+
+from pathlib import PurePosixPath
+
+from pydantic import BaseModel, Field
+
+from etki.adapters.manifests import NOISE_IMPORTS
+from etki.core.models import DeclaredDependency
+from etki_api import Capabilities, Churn, CodeModule, CodeRepositoryProvider, Complexity
+
+
+class FileNode(BaseModel):
+    path: str  # root-relative, e.g. "auth/service.py"
+    loc: int = 0
+    functions: list[str] = Field(default_factory=list)
+    control_structures: int = 0
+    imports: list[str] = Field(default_factory=list)  # top-level imported names
+    # Per-package symbols the file touches (`requests` → ["get", "post"]) — the
+    # call-site surface for API-change checks. Filled by the ast producer;
+    # joern/graphify leave it empty (defaulted → schema stays compatible).
+    api_uses: dict[str, list[str]] = Field(default_factory=dict)
+    # QUALIFIED use paths ("faker" → ["faker.providers.credit_card.CreditCard"])
+    # — precise version-diff auditing incl. non-exported imports. ast only.
+    api_paths: dict[str, list[str]] = Field(default_factory=dict)
+
+
+class CodeIndex(BaseModel):
+    root: str
+    producer: str = "unknown"  # "joern" | "ast"
+    files: list[FileNode] = Field(default_factory=list)
+    # Declared manifest dependencies (filled by parse_manifests; defaulted so
+    # existing producers/JSON stay valid).
+    dependencies: list[DeclaredDependency] = Field(default_factory=list)
+
+
+def _module_of(path: str) -> str:
+    parts = PurePosixPath(path.replace("\\", "/")).parts
+    return parts[0] if parts else path
+
+
+def parse_code_index(index: CodeIndex) -> list[CodeModule]:
+    """Groups files into modules by top-level directory; builds the dependency
+    graph from imports and complexity from the metrics."""
+    groups: dict[str, list[FileNode]] = {}
+    for node in index.files:
+        groups.setdefault(_module_of(node.path), []).append(node)
+    module_ids = set(groups)
+
+    modules: list[CodeModule] = []
+    dep_map: dict[str, list[str]] = {}
+    for module_id, files in groups.items():
+        loc = sum(f.loc for f in files)
+        functions = sorted({fn for f in files for fn in f.functions})
+        control = sum(f.control_structures for f in files)
+        imports = {imp for f in files for imp in f.imports}
+        depends_on = sorted((imports & module_ids) - {module_id})
+        # The complement of the internal-module intersection is the EXTERNAL
+        # usage surface (third-party packages) — previously discarded here.
+        packages = sorted(imports - module_ids - {module_id} - NOISE_IMPORTS)
+        package_apis: dict[str, set[str]] = {}
+        package_api_paths: dict[str, set[str]] = {}
+        for f in files:
+            for pkg, symbols in f.api_uses.items():
+                if pkg in packages:  # external only — internal/stdlib filtered
+                    package_apis.setdefault(pkg, set()).update(symbols)
+            for pkg, qualified in f.api_paths.items():
+                if pkg in packages:
+                    package_api_paths.setdefault(pkg, set()).update(qualified)
+        dep_map[module_id] = depends_on
+        complexity = Complexity(loc=loc, cyclomatic=control + len(functions), files=len(files))
+        modules.append(
+            CodeModule(
+                id=module_id,
+                path=f"{module_id}/",
+                responsibilities=functions,
+                depends_on=depends_on,
+                packages=packages,
+                package_apis={p: sorted(s) for p, s in sorted(package_apis.items())},
+                package_api_paths={
+                    p: sorted(s) for p, s in sorted(package_api_paths.items())
+                },
+                complexity=complexity,
+                churn=Churn(),
+            )
+        )
+
+    by_id = {m.id: m for m in modules}
+    for module_id, deps in dep_map.items():
+        for dep in deps:
+            if dep in by_id:
+                by_id[dep].depended_by.append(module_id)
+    for module in modules:
+        module.depended_by.sort()
+    return sorted(modules, key=lambda m: m.id)
+
+
+def impacted_modules(
+    modules: list[CodeModule], module_hint: str | None, *, depth: int = 1
+) -> list[CodeModule]:
+    """Module(s) matching the hint + ``depth`` degrees of dependency propagation (BFS)."""
+    if not module_hint:
+        return []
+    hint = module_hint.lower()
+    by_id = {m.id: m for m in modules}
+    ordered: list[str] = [
+        m.id
+        for m in modules
+        if hint in m.id.lower() or any(hint in r.lower() for r in m.responsibilities)
+    ]
+    seen = set(ordered)
+    frontier = list(ordered)
+    for _ in range(max(0, depth)):
+        nxt: list[str] = []
+        for mid in frontier:
+            module = by_id.get(mid)
+            if module is None:
+                continue
+            for dep in (*module.depends_on, *module.depended_by):
+                if dep in by_id and dep not in seen:
+                    seen.add(dep)
+                    ordered.append(dep)
+                    nxt.append(dep)
+        frontier = nxt
+    return [by_id[mid] for mid in ordered]
+
+
+class StaticCodeRepository:
+    """Online CodeRepositoryProvider serving a precomputed module graph
+    (read from the persisted Index — no Joern run at triage time)."""
+
+    def __init__(
+        self,
+        modules: list[CodeModule],
+        dependencies: list[DeclaredDependency] | None = None,
+    ) -> None:
+        self._modules = list(modules)
+        self._dependencies = list(dependencies or [])
+
+    async def list_modules(self) -> list[CodeModule]:
+        return list(self._modules)
+
+    def list_dependencies(self) -> list[DeclaredDependency]:
+        # Structural degradation seam (hasattr, like WorkItemProvider.all_items):
+        # the CodeRepositoryProvider Protocol stays untouched.
+        return list(self._dependencies)
+
+    async def get_impacted(self, module_hint: str | None) -> list[CodeModule]:
+        # depth=1 already yields the seed + its direct dependency/dependent neighbors;
+        # preserves risk separation on small graphs (deeper propagation is possible via BFS).
+        return impacted_modules(self._modules, module_hint, depth=1)
+
+    def capabilities(self) -> Capabilities:
+        return Capabilities(supports_incremental_diff=True)
+
+
+class MergedCodeRepository:
+    """Merges multiple code repos into a single graph (multi-repo impact analysis).
+
+    With ≥2 repos, module ids and dependency edges are namespaced by repo name
+    (collisions prevented; intra-repo edges preserved).
+    """
+
+    def __init__(self, providers: list[tuple[str, CodeRepositoryProvider]]) -> None:
+        self._providers = providers
+
+    async def list_modules(self) -> list[CodeModule]:
+        multi = len(self._providers) > 1
+        out: list[CodeModule] = []
+        for name, provider in self._providers:
+            for module in await provider.list_modules():
+                if multi:
+                    prefix = f"{name}:"
+                    module = module.model_copy(
+                        update={
+                            "id": prefix + module.id,
+                            "depends_on": [prefix + d for d in module.depends_on],
+                            "depended_by": [prefix + d for d in module.depended_by],
+                        }
+                    )
+                out.append(module)
+        return out
+
+    async def get_impacted(self, module_hint: str | None) -> list[CodeModule]:
+        return impacted_modules(await self.list_modules(), module_hint, depth=1)
+
+    def list_dependencies(self) -> list[DeclaredDependency]:
+        """Union across repos. Package names stay GLOBAL (the same artifact
+        everywhere — unlike module ids); only the `manifest` provenance gets
+        the repo prefix when there is more than one repo."""
+        multi = len(self._providers) > 1
+        seen: set[tuple[str, str, str]] = set()
+        out: list[DeclaredDependency] = []
+        for name, provider in self._providers:
+            lister = getattr(provider, "list_dependencies", None)
+            for dep in lister() if lister else []:
+                key = (dep.ecosystem, dep.name, dep.raw_spec)
+                if key in seen:
+                    continue
+                seen.add(key)
+                if multi:
+                    dep = dep.model_copy(update={"manifest": f"{name}:{dep.manifest}"})
+                out.append(dep)
+        return out
+
+    def capabilities(self) -> Capabilities:
+        return Capabilities(supports_incremental_diff=True)
+
+
+class IndexBackedCodeRepository:
+    """Common CodeRepositoryProvider base fed from a `CodeIndex`."""
+
+    def __init__(
+        self,
+        index: CodeIndex,
+        churn: dict[str, int] | None = None,
+        *,
+        supports_incremental_diff: bool = False,
+    ) -> None:
+        self._modules = parse_code_index(index)
+        self._dependencies = list(index.dependencies)
+        if churn:
+            for module in self._modules:
+                module.churn.commits_last_6mo = churn.get(module.id, 0)
+        self._incremental = supports_incremental_diff
+
+    async def list_modules(self) -> list[CodeModule]:
+        return list(self._modules)
+
+    def list_dependencies(self) -> list[DeclaredDependency]:
+        return list(self._dependencies)
+
+    async def get_impacted(self, module_hint: str | None) -> list[CodeModule]:
+        return impacted_modules(self._modules, module_hint)
+
+    def capabilities(self) -> Capabilities:
+        return Capabilities(
+            supports_webhooks=False,
+            supports_realtime=False,
+            supports_effort_tracking=False,
+            supports_incremental_diff=self._incremental,
+        )

etki/adapters/composite_document.py

@@ -0,0 +1,44 @@
+"""Composite DocumentSourceProvider — merges multiple document sources behind one port.
+
+The architecture's example: some documents live in FileSystem, some in SharePoint →
+composite. The core sees a single DocumentSourceProvider; strong proof of pluggability.
+"""
+
+from __future__ import annotations
+
+from etki.core.models import DocumentRef
+from etki.core.ports import Capabilities, DocumentSourceProvider
+
+
+class CompositeDocumentSourceProvider:
+    def __init__(self, sources: list[DocumentSourceProvider]) -> None:
+        self._sources = list(sources)
+
+    async def list_documents(self) -> list[DocumentRef]:
+        docs: list[DocumentRef] = []
+        for idx, source in enumerate(self._sources):
+            for doc in await source.list_documents():
+                docs.append(doc.model_copy(update={"id": f"{idx}:{doc.id}"}))
+        return docs
+
+    async def fetch_content(self, document_id: str) -> bytes:
+        prefix, _, real_id = document_id.partition(":")
+        try:
+            idx = int(prefix)
+        except ValueError as exc:
+            raise KeyError(f"Composite id beklenen formatta değil: {document_id}") from exc
+        if not 0 <= idx < len(self._sources):
+            raise KeyError(f"Geçersiz kaynak indeksi: {idx}")
+        return await self._sources[idx].fetch_content(real_id)
+
+    def capabilities(self) -> Capabilities:
+        caps = [s.capabilities() for s in self._sources]
+        if not caps:
+            return Capabilities()
+        # Graceful degradation: a capability is guaranteed only if ALL children support it.
+        return Capabilities(
+            supports_webhooks=all(c.supports_webhooks for c in caps),
+            supports_realtime=all(c.supports_realtime for c in caps),
+            supports_effort_tracking=all(c.supports_effort_tracking for c in caps),
+            supports_incremental_diff=all(c.supports_incremental_diff for c in caps),
+        )

etki/adapters/confluence_document.py

@@ -0,0 +1,113 @@
+"""Confluence Cloud DocumentSourceProvider — pages of a space as contract documents.
+
+Auth mirrors the Jira adapter (same Atlassian account): email + API token, basic
+auth. Pages are listed via the REST content API (paginated); `fetch_content`
+returns the page's **storage-format HTML converted to plain text** (UTF-8 bytes)
+so scope extraction sees clean clause lines. Requires a live site → integration
+is CI-skipped; HTML→text conversion is unit-tested. Config example:
+
+    connectors:
+      documents:
+        adapter: confluence
+        options:
+          base_url: https://yoursite.atlassian.net/wiki
+          email: you@company.com
+          api_token: env:CONFLUENCE_TOKEN
+          space_key: CONTRACTS
+"""
+
+from __future__ import annotations
+
+import html as html_lib
+import re
+from datetime import datetime
+from typing import Any
+
+import httpx
+
+from etki.core.models import DocumentRef
+from etki.core.ports import Capabilities
+
+_PAGE_SIZE = 50
+# Block-level closers become newlines so clause lines stay separate lines.
+_BLOCK_RE = re.compile(r"(?i)<\s*(?:br\s*/?|/p|/h[1-6]|/li|/tr|/div)\s*>")
+_TAG_RE = re.compile(r"<[^>]+>")
+
+
+def storage_to_text(storage_html: str) -> str:
+    """Confluence storage-format HTML → plain text (newline per block, entities unescaped)."""
+    text = _BLOCK_RE.sub("\n", storage_html)
+    text = _TAG_RE.sub(" ", text)
+    text = html_lib.unescape(text)
+    lines = [re.sub(r"[ \t]+", " ", line).strip() for line in text.splitlines()]
+    return "\n".join(line for line in lines if line)
+
+
+class ConfluenceDocumentSourceProvider:
+    def __init__(
+        self,
+        base_url: str,
+        email: str,
+        api_token: str,
+        space_key: str,
+        timeout: float = 30.0,
+    ) -> None:
+        self._base_url = base_url.rstrip("/")
+        self._auth = (email, api_token)
+        self._space_key = space_key
+        self._timeout = timeout
+
+    def _to_ref(self, page: dict[str, Any]) -> DocumentRef:
+        version = page.get("version") or {}
+        when = version.get("when")
+        return DocumentRef(
+            id=str(page.get("id", "?")),
+            name=str(page.get("title") or "untitled"),  # no extension → parsed as text
+            path=f"{self._base_url}{(page.get('_links') or {}).get('webui', '')}",
+            mime="text/plain",
+            modified_at=datetime.fromisoformat(when) if when else None,
+            source="confluence",
+        )
+
+    async def list_documents(self) -> list[DocumentRef]:
+        docs: list[DocumentRef] = []
+        start = 0
+        async with httpx.AsyncClient(timeout=self._timeout, auth=self._auth) as client:
+            while True:
+                response = await client.get(
+                    f"{self._base_url}/rest/api/content",
+                    params={
+                        "spaceKey": self._space_key,
+                        "type": "page",
+                        "status": "current",
+                        "start": start,
+                        "limit": _PAGE_SIZE,
+                        "expand": "version",
+                    },
+                )
+                response.raise_for_status()
+                results = response.json().get("results", [])
+                docs.extend(self._to_ref(p) for p in results)
+                if len(results) < _PAGE_SIZE:
+                    return docs
+                start += _PAGE_SIZE
+
+    async def fetch_content(self, document_id: str) -> bytes:
+        async with httpx.AsyncClient(timeout=self._timeout, auth=self._auth) as client:
+            response = await client.get(
+                f"{self._base_url}/rest/api/content/{document_id}",
+                params={"expand": "body.storage"},
+            )
+            response.raise_for_status()
+            storage = (
+                (response.json().get("body") or {}).get("storage") or {}
+            ).get("value", "")
+            return storage_to_text(storage).encode("utf-8")
+
+    def capabilities(self) -> Capabilities:
+        return Capabilities(
+            supports_webhooks=False,  # Cloud webhooks need a Connect/Forge app — not implemented
+            supports_realtime=False,
+            supports_effort_tracking=False,
+            supports_incremental_diff=False,
+        )