ocp-client 0.1.0__tar.gz

ocp_client-0.1.0/.gitignore

@@ -0,0 +1,19 @@
+__pycache__/
+*.py[cod]
+*.egg-info/
+.eggs/
+dist/
+build/
+*.so
+.venv/
+.uv/
+.mypy_cache/
+.ruff_cache/
+.pytest_cache/
+*.db
+*.db-shm
+*.db-wal
+*.vec
+.env
+.env.local
+.env.*.local

ocp_client-0.1.0/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.4
+Name: ocp-client
+Version: 0.1.0
+Summary: Open Context Protocol — Python client SDK
+Project-URL: Homepage, https://github.com/Rajesh1213/OCP
+Project-URL: Repository, https://github.com/Rajesh1213/OCP
+Project-URL: Documentation, https://github.com/Rajesh1213/OCP/blob/main/docs/integrations.md
+Project-URL: Bug Tracker, https://github.com/Rajesh1213/OCP/issues
+License: Apache-2.0
+Requires-Python: >=3.11
+Requires-Dist: mcp>=1.0
+Requires-Dist: pydantic>=2.7

ocp_client-0.1.0/ocp_client/__init__.py

@@ -0,0 +1,5 @@
+"""OCP Python client SDK."""
+from .client import OCPClient
+
+__version__ = "0.1.0"
+__all__ = ["OCPClient"]

ocp_client-0.1.0/ocp_client/client.py

@@ -0,0 +1,232 @@
+"""OCP client — async, typed wrapper over MCP tool calls."""
+from __future__ import annotations
+
+import json
+from contextlib import asynccontextmanager
+from typing import Any, AsyncIterator
+
+from mcp import ClientSession, StdioServerParameters
+from mcp.client.stdio import stdio_client
+from mcp.types import TextContent
+
+from ocp_client.types import (
+    Chunk,
+    CheckpointResult,
+    HandoffResult,
+    IndexResult,
+    InvalidateResult,
+    OCPError,
+    PackResult,
+    SearchResult,
+    SessionResult,
+    SetResult,
+    StateEntry,
+    SubscriptionResult,
+    WorkspaceRegistered,
+)
+
+
+class OCPClient:
+    """High-level async client for an OCP server.
+
+    Usage::
+
+        async with OCPClient.stdio(["ocp-server"]) as client:
+            ws = await client.workspace_register("file:///my/repo")
+            await client.workspace_index(ws.workspace_id)
+            results = await client.context_search(ws.workspace_id, "auth middleware")
+    """
+
+    def __init__(self, session: ClientSession) -> None:
+        self._session = session
+
+    # ------------------------------------------------------------------ #
+    # Factory                                                              #
+    # ------------------------------------------------------------------ #
+
+    @staticmethod
+    @asynccontextmanager
+    async def stdio(command: list[str], env: dict[str, str] | None = None) -> AsyncIterator["OCPClient"]:
+        params = StdioServerParameters(command=command[0], args=command[1:], env=env)
+        async with stdio_client(params) as (read, write):
+            async with ClientSession(read, write) as session:
+                await session.initialize()
+                yield OCPClient(session)
+
+    # ------------------------------------------------------------------ #
+    # Internal                                                             #
+    # ------------------------------------------------------------------ #
+
+    async def _call(self, tool: str, **kwargs: Any) -> Any:
+        args = {k: v for k, v in kwargs.items() if v is not None}
+        result = await self._session.call_tool(tool, args)
+        if not result.content:
+            return {}
+        item = result.content[0]
+        if not isinstance(item, TextContent):
+            return {}
+        raw = item.text
+        data = json.loads(raw)
+        if "error" in data:
+            raise OCPError(data["error"]["code"], data["error"]["message"])
+        return data
+
+    # ------------------------------------------------------------------ #
+    # Workspace — §4.1                                                     #
+    # ------------------------------------------------------------------ #
+
+    async def workspace_register(
+        self, root_uri: str, name: str | None = None, metadata: dict | None = None
+    ) -> WorkspaceRegistered:
+        data = await self._call("workspace.register", root_uri=root_uri, name=name, metadata=metadata)
+        return WorkspaceRegistered(**data)
+
+    async def workspace_index(
+        self, workspace_id: str, paths: list[str] | None = None, wait: bool | None = None
+    ) -> IndexResult:
+        data = await self._call("workspace.index", workspace_id=workspace_id, paths=paths, wait=wait)
+        return IndexResult(**data)
+
+    async def workspace_invalidate(self, workspace_id: str, paths: list[str]) -> InvalidateResult:
+        data = await self._call("workspace.invalidate", workspace_id=workspace_id, paths=paths)
+        return InvalidateResult(**data)
+
+    async def workspace_list_chunks(
+        self, workspace_id: str, filters: dict | None = None, cursor: str | None = None
+    ) -> tuple[list[Chunk], str | None]:
+        data = await self._call("workspace.list_chunks", workspace_id=workspace_id, filters=filters, cursor=cursor)
+        return [Chunk(**c) for c in data["chunks"]], data.get("next_cursor")
+
+    # ------------------------------------------------------------------ #
+    # Retrieval — §4.2                                                     #
+    # ------------------------------------------------------------------ #
+
+    async def context_search(
+        self, workspace_id: str, query: str, k: int = 5, filters: dict | None = None
+    ) -> SearchResult:
+        data = await self._call("context.search", workspace_id=workspace_id, query=query, k=k, filters=filters)
+        return SearchResult(chunks=[Chunk(**c) for c in data["chunks"]], scores=data["scores"])
+
+    async def context_get_chunk(self, chunk_id: str) -> Chunk:
+        data = await self._call("context.get_chunk", chunk_id=chunk_id)
+        return Chunk(**data["chunk"])
+
+    async def context_pack(
+        self, workspace_id: str, intent: str, budget_tokens: int, include_state: bool = False
+    ) -> PackResult:
+        data = await self._call(
+            "context.pack", workspace_id=workspace_id, intent=intent,
+            budget_tokens=budget_tokens, include_state=include_state,
+        )
+        return PackResult(**data)
+
+    # ------------------------------------------------------------------ #
+    # State — §4.3                                                         #
+    # ------------------------------------------------------------------ #
+
+    async def state_set(
+        self, key: str, value: Any, scope: str,
+        workspace_id: str | None = None, session_id: str | None = None,
+        agent_id: str | None = None, ttl_seconds: int | None = None,
+        if_version: int | None = None,
+    ) -> SetResult:
+        data = await self._call(
+            "state.set", key=key, value=value, scope=scope,
+            workspace_id=workspace_id, session_id=session_id,
+            agent_id=agent_id, ttl_seconds=ttl_seconds, if_version=if_version,
+        )
+        return SetResult(**data)
+
+    async def state_get(
+        self, key: str, scope: str | None = None,
+        workspace_id: str | None = None, session_id: str | None = None,
+        agent_id: str | None = None,
+    ) -> StateEntry | None:
+        data = await self._call(
+            "state.get", key=key, scope=scope,
+            workspace_id=workspace_id, session_id=session_id, agent_id=agent_id,
+        )
+        entry = data.get("entry")
+        return StateEntry(**entry) if entry else None
+
+    async def state_list(
+        self, prefix: str | None = None, scope: str | None = None,
+        workspace_id: str | None = None, session_id: str | None = None,
+        agent_id: str | None = None, cursor: str | None = None,
+    ) -> tuple[list[StateEntry], str | None]:
+        data = await self._call(
+            "state.list", prefix=prefix, scope=scope,
+            workspace_id=workspace_id, session_id=session_id,
+            agent_id=agent_id, cursor=cursor,
+        )
+        return [StateEntry(**e) for e in data["entries"]], data.get("next_cursor")
+
+    async def state_delete(
+        self, key: str, scope: str,
+        workspace_id: str | None = None, session_id: str | None = None,
+        agent_id: str | None = None, if_version: int | None = None,
+    ) -> bool:
+        data = await self._call(
+            "state.delete", key=key, scope=scope,
+            workspace_id=workspace_id, session_id=session_id,
+            agent_id=agent_id, if_version=if_version,
+        )
+        return data["deleted"]
+
+    # ------------------------------------------------------------------ #
+    # Coordination — §4.4                                                  #
+    # ------------------------------------------------------------------ #
+
+    async def session_open(
+        self, workspace_id: str, session_id: str | None = None,
+        ttl_seconds: int | None = None, metadata: dict | None = None,
+    ) -> SessionResult:
+        data = await self._call(
+            "session.open", workspace_id=workspace_id, session_id=session_id,
+            ttl_seconds=ttl_seconds, metadata=metadata,
+        )
+        return SessionResult(**data)
+
+    async def session_close(self, session_id: str) -> bool:
+        data = await self._call("session.close", session_id=session_id)
+        return data["closed"]
+
+    async def session_handoff(
+        self, session_id: str, from_agent: str, to_agent: str, message: Any
+    ) -> HandoffResult:
+        data = await self._call(
+            "session.handoff", session_id=session_id,
+            from_agent=from_agent, to_agent=to_agent, message=message,
+        )
+        return HandoffResult(**data)
+
+    async def session_checkpoint(
+        self, session_id: str, label: str, include_state: bool = False
+    ) -> CheckpointResult:
+        data = await self._call(
+            "session.checkpoint", session_id=session_id,
+            label=label, include_state=include_state,
+        )
+        return CheckpointResult(**data)
+
+    async def session_restore(self, checkpoint_id: str) -> SessionResult:
+        data = await self._call("session.restore", checkpoint_id=checkpoint_id)
+        return SessionResult(**data)
+
+    # ------------------------------------------------------------------ #
+    # Events — §4.5                                                        #
+    # ------------------------------------------------------------------ #
+
+    async def events_subscribe(
+        self, workspace_id: str, types: list[str] | None = None,
+        session_id: str | None = None, since: str | None = None,
+    ) -> SubscriptionResult:
+        data = await self._call(
+            "events.subscribe", workspace_id=workspace_id,
+            types=types, session_id=session_id, since=since,
+        )
+        return SubscriptionResult(**data)
+
+    async def events_unsubscribe(self, subscription_id: str) -> bool:
+        data = await self._call("events.unsubscribe", subscription_id=subscription_id)
+        return data["unsubscribed"]

ocp_client-0.1.0/ocp_client/types.py

@@ -0,0 +1,96 @@
+"""Typed wrappers for OCP responses."""
+from __future__ import annotations
+
+from typing import Any
+from pydantic import BaseModel
+
+
+class WorkspaceRegistered(BaseModel):
+    workspace_id: str
+    created: bool
+
+
+class IndexResult(BaseModel):
+    indexed: int
+    skipped: int
+    duration_ms: int
+
+
+class InvalidateResult(BaseModel):
+    invalidated: int
+
+
+class SourceRange(BaseModel):
+    start_byte: int | None = None
+    end_byte: int | None = None
+    start_line: int | None = None
+    end_line: int | None = None
+
+
+class ChunkSource(BaseModel):
+    uri: str
+    range: SourceRange | None = None
+    content_hash: str
+
+
+class Chunk(BaseModel):
+    id: str
+    workspace_id: str
+    source: ChunkSource
+    kind: str
+    language: str | None = None
+    symbol: str | None = None
+    content: str
+    metadata: dict[str, Any] = {}
+    version: int = 1
+
+
+class SearchResult(BaseModel):
+    chunks: list[Chunk]
+    scores: list[float]
+
+
+class PackResult(BaseModel):
+    context: str
+    chunks_used: list[str]
+    state_used: list[str]
+    tokens: int
+
+
+class StateEntry(BaseModel):
+    key: str
+    value: Any
+    scope: str
+    workspace_id: str | None = None
+    session_id: str | None = None
+    agent_id: str | None = None
+    ttl_seconds: int | None = None
+    updated_at: str | None = None
+    version: int = 1
+
+
+class SetResult(BaseModel):
+    version: int
+
+
+class SessionResult(BaseModel):
+    session_id: str
+
+
+class HandoffResult(BaseModel):
+    delivered: bool
+    handoff_id: str
+
+
+class CheckpointResult(BaseModel):
+    checkpoint_id: str
+
+
+class SubscriptionResult(BaseModel):
+    subscription_id: str
+
+
+class OCPError(Exception):
+    def __init__(self, code: str, message: str) -> None:
+        self.code = code
+        super().__init__(f"[{code}] {message}")

ocp_client-0.1.0/pyproject.toml

@@ -0,0 +1,23 @@
+[project]
+name = "ocp-client"
+version = "0.1.0"
+description = "Open Context Protocol — Python client SDK"
+license = { text = "Apache-2.0" }
+requires-python = ">=3.11"
+dependencies = [
+    "mcp>=1.0",
+    "pydantic>=2.7",
+]
+
+[project.urls]
+Homepage = "https://github.com/Rajesh1213/OCP"
+Repository = "https://github.com/Rajesh1213/OCP"
+Documentation = "https://github.com/Rajesh1213/OCP/blob/main/docs/integrations.md"
+"Bug Tracker" = "https://github.com/Rajesh1213/OCP/issues"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["ocp_client"]