codrspot-processor-mcp 0.1.0__py3-none-any.whl

codepreproc_client/__init__.py

@@ -0,0 +1,14 @@
+"""codepreproc package."""
+
+import os
+
+# GitPython raises ImportError at import time if it can't find a `git`
+# executable on PATH, which would take down every module that does
+# `from git import Repo` (tools, indexer, registry, ...) even when the
+# caller never touches git. Downgrade that to a warning so git-dependent
+# features fail only when actually used.
+os.environ.setdefault("GIT_PYTHON_REFRESH", "warn")
+
+__all__ = ["__version__"]
+
+__version__ = "0.1.0"

codepreproc_client/__main__.py

@@ -0,0 +1,9 @@
+"""Module entrypoint."""
+
+import asyncio
+
+from codepreproc_client.layer1_business.mcp.server import main
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

codepreproc_client/layer1_business/allowed_scope_cache.py

@@ -0,0 +1,62 @@
+"""Local, on-disk cache of the projects the caller's tenant/API key is allowed
+to see (registry_client.list_projects, backed by GET /v1/projects).
+
+Mirrors local_registry.py: the server is the source of truth, but the
+client shouldn't need a network round trip just to know which project_ids
+it's allowed to use. Refreshed once after mint if the cache is empty, and
+whenever the server rejects a project_id as unauthorized (the cache may be
+stale - a project was added to or removed from the tenant since).
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from contracts.dtos import ProjectConfig
+
+_FILENAME = "allowed_projects.json"
+
+
+def _cache_path(home_dir: Path) -> Path:
+    return home_dir / _FILENAME
+
+
+def load_allowed_projects(home_dir: Path) -> list[ProjectConfig]:
+    path = _cache_path(home_dir)
+    if not path.exists():
+        return []
+    raw = json.loads(path.read_text(encoding="utf-8"))
+    return [ProjectConfig.model_validate(data) for data in raw]
+
+
+def save_allowed_projects(home_dir: Path, projects: list[ProjectConfig]) -> None:
+    path = _cache_path(home_dir)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(
+        json.dumps([p.model_dump(mode="json") for p in projects], indent=2),
+        encoding="utf-8",
+    )
+
+
+def clear_allowed_projects(home_dir: Path) -> None:
+    path = _cache_path(home_dir)
+    if path.exists():
+        path.unlink()
+
+
+async def get_allowed_projects(
+    *, home_dir: Path, base_url: str, jwt: str, force_refresh: bool = False
+) -> list[ProjectConfig]:
+    """Return the cached allowed-project list, fetching and caching it first if needed."""
+
+    if not force_refresh:
+        cached = load_allowed_projects(home_dir)
+        if cached:
+            return cached
+
+    from codepreproc_client.layer1_business.api_client.registry_client import list_projects
+
+    projects = await list_projects(base_url=base_url, jwt=jwt)
+    save_allowed_projects(home_dir, projects)
+    return projects

codepreproc_client/layer1_business/api_client/lease_client.py

@@ -0,0 +1,34 @@
+"""Client for POST /v1/lease_world_model (contracts/openapi.yaml).
+
+Hands out a temporary, session-scoped copy of the licensed-scope world
+model so the client can plan/apply edits locally without a round-trip per
+operation (architecture doc S5). The returned lease MUST be discarded on
+the client's last MCP call - see mcp/lifecycle.py, which owns teardown.
+"""
+
+from __future__ import annotations
+
+import httpx
+
+from contracts.dtos import LensContract, WorldModelLease
+
+DEFAULT_TIMEOUT_S = 30.0
+
+
+async def lease_world_model(
+    *,
+    base_url: str,
+    jwt: str,
+    project_scope: LensContract,
+    timeout: float = DEFAULT_TIMEOUT_S,
+) -> WorldModelLease:
+    """Request a temporary world-model copy scoped to `project_scope`."""
+
+    async with httpx.AsyncClient(base_url=base_url, timeout=timeout) as client:
+        response = await client.post(
+            "/v1/lease_world_model",
+            json={"project_scope": project_scope.model_dump(mode="json")},
+            headers={"Authorization": f"Bearer {jwt}"},
+        )
+        response.raise_for_status()
+        return WorldModelLease.model_validate(response.json())

codepreproc_client/layer1_business/api_client/net_guard.py

@@ -0,0 +1,98 @@
+"""Outbound payload invariant: no raw source, no source-derived vectors.
+
+Architecture doc S3/S12: every call through ``api_client`` must cross the
+network boundary carrying only condensate (``Gist``/``EdgeRef``/etc.), never
+raw source text or embeddings computed over raw source. This module is the
+single chokepoint that asserts that invariant before a payload is sent -
+CI-tested, not trusted to code review (S3).
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic import BaseModel
+
+# DTOs that are allowed to cross the network boundary (contracts/openapi.yaml).
+# Anything else nested inside an outbound payload is rejected.
+_ALLOWED_DTO_NAMES = {
+    "Manifest",
+    "FingerprintAttestation",
+    "MintRequest",
+    "MintResponse",
+    "Gist",
+    "EdgeRef",
+    "Completeness",
+    "LensContract",
+    "PromoteRequest",
+    "StampedResult",
+    "LeaseWorldModelRequest",
+    "WorldModelLease",
+    "ResolveCouplingRequest",
+    "CouplingReport",
+    "RegisterProjectRequest",
+    "SetSuperkgIdRequest",
+    "ErrorResponse",
+    "SuperkgBootstrapRequest",
+    "SuperkgSessionOpenRequest",
+    "SuperkgSessionCloseRequest",
+    "SuperkgDecisionRequest",
+    "SuperkgLogActivityRequest",
+    "SuperkgTransitionRequest",
+    "SuperkgQueryRequest",
+    "SuperkgChunkMetadata",
+    "SuperkgIngestRequest",
+    "SuperkgEnrichRequest",
+}
+
+# Field names that would indicate raw source or source-derived vectors leaking
+# into an otherwise-allowed DTO (defense in depth beyond the type check).
+_FORBIDDEN_FIELD_NAMES = {
+    "body",
+    "source",
+    "source_code",
+    "raw_source",
+    "file_contents",
+    "embedding",
+    "embeddings",
+    "vector",
+    "vectors",
+}
+
+
+class NetGuardViolation(RuntimeError):
+    """Raised when an outbound payload would leak raw source or source vectors."""
+
+
+def assert_safe_to_send(payload: BaseModel | dict[str, Any] | list[Any]) -> None:
+    """Raise ``NetGuardViolation`` if ``payload`` is unsafe to cross the network boundary.
+
+    Call this immediately before every ``api_client`` HTTP call.
+    """
+
+    _check(payload, path="$")
+
+
+def _check(value: Any, *, path: str) -> None:
+    if isinstance(value, BaseModel):
+        type_name = type(value).__name__
+        if type_name not in _ALLOWED_DTO_NAMES:
+            raise NetGuardViolation(
+                f"net_guard: disallowed DTO type {type_name!r} at {path} "
+                "is not part of contracts/openapi.yaml"
+            )
+        _check(value.model_dump(mode="python"), path=path)
+        return
+
+    if isinstance(value, dict):
+        for key, sub_value in value.items():
+            key_lower = str(key).lower()
+            if key_lower in _FORBIDDEN_FIELD_NAMES:
+                raise NetGuardViolation(f"net_guard: forbidden field {key!r} at {path}")
+            _check(sub_value, path=f"{path}.{key}")
+        return
+
+    if isinstance(value, (list, tuple, set)):
+        for i, item in enumerate(value):
+            _check(item, path=f"{path}[{i}]")
+        return

codepreproc_client/layer1_business/api_client/promote_client.py

@@ -0,0 +1,59 @@
+"""Client for POST /v1/promote (contracts/openapi.yaml).
+
+Sends condensate (gists + edge structure) to the server for SuperKG
+augmentation and canonical world-model persistence, and returns the
+stamped result. This is a real network call, not an in-process shim -
+`promote` is one of the two named write operations of the single API
+surface (architecture doc S4).
+"""
+
+from __future__ import annotations
+
+import httpx
+
+from codepreproc_client.layer1_business.api_client.net_guard import assert_safe_to_send
+from contracts.dtos import (
+    Completeness,
+    EdgeRef,
+    FingerprintAttestation,
+    Gist,
+    StampedResult,
+)
+
+DEFAULT_TIMEOUT_S = 30.0
+
+
+async def promote(
+    *,
+    base_url: str,
+    jwt: str,
+    project_id: str,
+    gists: list[Gist],
+    edges: list[EdgeRef],
+    fingerprint_attestation: FingerprintAttestation,
+    completeness: Completeness | None = None,
+    timeout: float = DEFAULT_TIMEOUT_S,
+) -> StampedResult:
+    """Augment condensate against SuperKG and persist to the canonical world model."""
+
+    request_body = {
+        "project_id": project_id,
+        "gists": [g.model_dump(mode="json") for g in gists],
+        "edges": [e.model_dump(mode="json") for e in edges],
+        "completeness": completeness.model_dump(mode="json") if completeness else None,
+        "fingerprint_attestation": fingerprint_attestation.model_dump(mode="json"),
+    }
+    for gist in gists:
+        assert_safe_to_send(gist)
+    for edge in edges:
+        assert_safe_to_send(edge)
+    assert_safe_to_send(fingerprint_attestation)
+
+    async with httpx.AsyncClient(base_url=base_url, timeout=timeout) as client:
+        response = await client.post(
+            "/v1/promote",
+            json=request_body,
+            headers={"Authorization": f"Bearer {jwt}"},
+        )
+        response.raise_for_status()
+        return StampedResult.model_validate(response.json())

codepreproc_client/layer1_business/api_client/reasoning_client.py

@@ -0,0 +1,163 @@
+"""HTTP client for server-side LLM reasoning/routing, over POST /v1/reason.
+
+Replaces the former same-process shim that re-exported
+codepreproc_server.layer3_core.reasoning symbols directly - client code must
+never import codepreproc_server. The actual provider calls (local Qwen,
+OpenAI, ...), cost tracking, and fallback logic all now run server-side;
+this module only builds requests and validates typed responses.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Awaitable, Callable
+from typing import Any
+
+import httpx
+from pydantic import BaseModel
+
+from contracts.dtos import (
+    ROUTING_MATRIX,
+    IntentSpec,
+    LLMPolicy,
+    LLMUsageStats,
+    ReasonRequest,
+    TaskType,
+)
+from contracts.dtos import ChunkRelevanceBatch, CompactedContext, OperationStub, StubsResponse
+
+DEFAULT_TIMEOUT_S = 60.0
+
+_SCHEMA_BY_NAME: dict[str, type[BaseModel]] = {
+    "IntentSpec": IntentSpec,
+    "ChunkRelevanceBatch": ChunkRelevanceBatch,
+    "CompactedContext": CompactedContext,
+    "StubsResponse": StubsResponse,
+}
+
+
+class ProviderUnavailableError(RuntimeError):
+    """Raised when the server-side reasoning call fails (mirrors the server's error)."""
+
+
+class LLMRouter:
+    """HTTP-backed stand-in for the server's LLMRouter.chat() - same call
+    signature, but the routing/provider/fallback decision now happens
+    server-side, behind the JWT-gated POST /v1/reason endpoint."""
+
+    def __init__(self, base_url: str, jwt_provider: Callable[[], Awaitable[str]], timeout: float = DEFAULT_TIMEOUT_S) -> None:
+        self._base_url = base_url
+        self._jwt_provider = jwt_provider
+        self._timeout = timeout
+
+    async def chat(
+        self,
+        task_type: TaskType,
+        policy: LLMPolicy,
+        messages: list[dict[str, Any]],
+        schema: type[BaseModel] | None = None,
+        *,
+        max_tokens: int = 1024,
+        temperature: float = 0.1,
+        project_id: str | None = None,
+        task_id: str | None = None,
+    ) -> tuple[BaseModel | dict[str, Any], LLMUsageStats]:
+        request = ReasonRequest(
+            task_type=task_type,
+            policy=policy,
+            messages=messages,
+            schema_name=schema.__name__ if schema is not None else None,
+            max_tokens=max_tokens,
+            temperature=temperature,
+            project_id=project_id,
+            task_id=task_id,
+        )
+        jwt = await self._jwt_provider()
+        try:
+            async with httpx.AsyncClient(base_url=self._base_url, timeout=self._timeout) as client:
+                response = await client.post(
+                    "/v1/reason",
+                    json=request.model_dump(mode="json"),
+                    headers={"Authorization": f"Bearer {jwt}"},
+                )
+                response.raise_for_status()
+        except httpx.HTTPError as exc:
+            raise ProviderUnavailableError(str(exc)) from exc
+
+        body = response.json()
+        usage = LLMUsageStats.model_validate(body["usage"])
+        result = schema.model_validate(body["result"]) if schema is not None else body["result"]
+        return result, usage
+
+    async def health_check(self, provider_name: str = "local_qwen") -> bool:
+        # Provider health now lives entirely server-side; a reachable /v1/reason
+        # call is the only signal the client can observe.
+        return True
+
+
+class LLMRuntime:
+    """HTTP-backed stand-in for the server's LLMRuntime - owns nothing local,
+    just a router pointed at codepreproc-server."""
+
+    def __init__(self, base_url: str, jwt_provider: Callable[[], Awaitable[str]]) -> None:
+        self.router = LLMRouter(base_url, jwt_provider)
+
+    async def close(self) -> None:
+        pass  # no local provider connections to release
+
+
+class IntentExtractor:
+    """Extract structured intent from a user prompt (ported from the server's
+    IntentExtractor - depends only on router.chat(), never on server internals)."""
+
+    def __init__(self, router: LLMRouter) -> None:
+        self.router = router
+
+    async def extract(
+        self,
+        user_prompt: str,
+        project_context: str,
+        *,
+        policy: LLMPolicy,
+        project_id: str,
+        task_id: str,
+    ) -> tuple[IntentSpec, LLMUsageStats]:
+        system_prompt = (
+            "You are a code change intent extractor. Given a user request about a codebase, "
+            "extract a structured intent. Be conservative. Output strict JSON.\n"
+            "If the request is about moving or renaming files/directories, or reorganizing the repo tree, "
+            "set artifact_scope=filesystem instead of pretending it is an in-file edit.\n"
+            "If the request is about creating a new file that does not yet exist (e.g. a new script, "
+            "config file, or module), set artifact_scope=new_file and populate files_to_create with "
+            "the target file path(s) relative to the project root. "
+            "Also set intent=add in this case.\n\n"
+            f"Project context:\n{project_context}"
+        )
+        try:
+            result, usage = await self.router.chat(
+                task_type="intent_extraction",
+                policy=policy,
+                messages=[
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": user_prompt},
+                ],
+                schema=IntentSpec,
+                max_tokens=500,
+                temperature=0.1,
+                project_id=project_id,
+                task_id=task_id,
+            )
+            return IntentSpec.model_validate(result) if not isinstance(result, IntentSpec) else result, usage
+        except Exception:
+            return IntentSpec(change_summary=user_prompt, constraints=[]), LLMUsageStats(provider="fallback", task_type="intent_extraction")
+
+
+__all__ = [
+    "IntentExtractor",
+    "LLMRuntime",
+    "ROUTING_MATRIX",
+    "LLMRouter",
+    "ChunkRelevanceBatch",
+    "CompactedContext",
+    "OperationStub",
+    "StubsResponse",
+]

codepreproc_client/layer1_business/api_client/registry_client.py

@@ -0,0 +1,119 @@
+"""Client for the registry/config surface: /v1/config/defaults, /v1/projects,
+/v1/projects/{id}/superkg_id, /v1/snippets (contracts/openapi.yaml).
+
+Real network calls, not an in-process shim - the shared embedding/retrieval/
+chunking defaults, per-project config, and the shared snippet library all
+live in codepreproc-server's Postgres and cross the same JWT-gated boundary
+as promote/lease_world_model (architecture doc S4). Client code must never
+import codepreproc_server or asyncpg directly.
+"""
+
+from __future__ import annotations
+
+import httpx
+
+from codepreproc_client.layer1_business.api_client.net_guard import assert_safe_to_send
+from contracts.dtos import (
+    DefaultsConfig,
+    FingerprintAttestation,
+    ProjectConfig,
+    RegisterProjectRequest,
+    SetSuperkgIdRequest,
+    SnippetSpec,
+)
+
+DEFAULT_TIMEOUT_S = 30.0
+
+
+async def get_defaults(*, base_url: str, jwt: str, timeout: float = DEFAULT_TIMEOUT_S) -> DefaultsConfig:
+    """Fetch the shared embedding/retrieval/chunking/LLM-provider defaults."""
+
+    async with httpx.AsyncClient(base_url=base_url, timeout=timeout) as client:
+        response = await client.get(
+            "/v1/config/defaults",
+            headers={"Authorization": f"Bearer {jwt}"},
+        )
+        response.raise_for_status()
+        return DefaultsConfig.model_validate(response.json())
+
+
+async def register_project(
+    *,
+    base_url: str,
+    jwt: str,
+    project: ProjectConfig,
+    fingerprint_attestation: FingerprintAttestation,
+    timeout: float = DEFAULT_TIMEOUT_S,
+) -> ProjectConfig:
+    """Register (or update) a project's config. The JWT must already name
+    ``project.project_id`` in its claims - mint it with this project's
+    ``fingerprint_attestation`` first."""
+
+    request = RegisterProjectRequest(project=project, fingerprint_attestation=fingerprint_attestation)
+    assert_safe_to_send(request)
+
+    async with httpx.AsyncClient(base_url=base_url, timeout=timeout) as client:
+        response = await client.post(
+            "/v1/projects",
+            json=request.model_dump(mode="json"),
+            headers={"Authorization": f"Bearer {jwt}"},
+        )
+        response.raise_for_status()
+        return ProjectConfig.model_validate(response.json()["project"])
+
+
+async def set_superkg_id(
+    *,
+    base_url: str,
+    jwt: str,
+    project_id: str,
+    system_id: str,
+    timeout: float = DEFAULT_TIMEOUT_S,
+) -> None:
+    request = SetSuperkgIdRequest(system_id=system_id)
+    assert_safe_to_send(request)
+
+    async with httpx.AsyncClient(base_url=base_url, timeout=timeout) as client:
+        response = await client.patch(
+            f"/v1/projects/{project_id}/superkg_id",
+            json=request.model_dump(mode="json"),
+            headers={"Authorization": f"Bearer {jwt}"},
+        )
+        response.raise_for_status()
+
+
+async def list_projects(*, base_url: str, jwt: str, timeout: float = DEFAULT_TIMEOUT_S) -> list[ProjectConfig]:
+    """List every project the caller's tenant (from the JWT's claims) is allowed to see.
+
+    Callers should cache this locally (allowed_scope_cache.py) rather than
+    calling it on every action - it only needs to be re-fetched when the
+    cache is empty or the server rejects a project_id as unauthorized."""
+
+    async with httpx.AsyncClient(base_url=base_url, timeout=timeout) as client:
+        response = await client.get(
+            "/v1/projects",
+            headers={"Authorization": f"Bearer {jwt}"},
+        )
+        response.raise_for_status()
+        return [ProjectConfig.model_validate(p) for p in response.json()["projects"]]
+
+
+async def list_snippets(
+    *,
+    base_url: str,
+    jwt: str,
+    framework: str | None = None,
+    language: str | None = None,
+    layer: str | None = None,
+    timeout: float = DEFAULT_TIMEOUT_S,
+) -> list[SnippetSpec]:
+    params = {k: v for k, v in {"framework": framework, "language": language, "layer": layer}.items() if v is not None}
+
+    async with httpx.AsyncClient(base_url=base_url, timeout=timeout) as client:
+        response = await client.get(
+            "/v1/snippets",
+            params=params,
+            headers={"Authorization": f"Bearer {jwt}"},
+        )
+        response.raise_for_status()
+        return [SnippetSpec.model_validate(s) for s in response.json()["snippets"]]