coding-client 1.21.2__py3-none-any.whl

coding_client/clients/coding_security.py

@@ -0,0 +1,51 @@
+"""HTTP client for the coding-security service."""
+
+from __future__ import annotations
+
+import os
+from typing import Any
+
+from .base import ServiceClient
+
+_ENV_VAR = "CODING_SECURITY_URL"
+
+
+class CodingSecurityClient(ServiceClient):
+    """Client for coding-security endpoints."""
+
+    def __init__(
+        self,
+        base_url: str | None = None,
+        timeout: float = 30.0,
+        max_retries: int = 3,
+    ):
+        url = base_url or os.environ.get(_ENV_VAR, "")
+        if not url:
+            raise RuntimeError(
+                f"CodingSecurityClient requires base_url or {_ENV_VAR} env var. "
+                "See the platform configuration policy."
+            )
+        super().__init__(url, timeout=timeout, max_retries=max_retries)
+
+    async def scan(
+        self, container_name: str, headers: dict[str, str] | None = None, **kwargs: Any
+    ) -> Any:
+        return await self.post(f"/api/security/scan/{container_name}", headers=headers, json=kwargs)
+
+    async def get_scan_results(
+        self, container_name: str, headers: dict[str, str] | None = None, **kwargs: Any
+    ) -> Any:
+        return await self.get(f"/api/security/report/{container_name}", headers=headers, **kwargs)
+
+    async def analyze_vulnerabilities(
+        self,
+        file_paths: list[str],
+        max_files: int = 20,
+        headers: dict[str, str] | None = None,
+        **kwargs: Any,
+    ) -> Any:
+        return await self.post(
+            "/api/security/analyze-vulnerabilities",
+            headers=headers,
+            json={"file_paths": file_paths, "max_files": max_files, **kwargs},
+        )

coding_client/clients/coding_testing.py

@@ -0,0 +1,31 @@
+"""HTTP client for the coding-testing service."""
+
+from __future__ import annotations
+
+import os
+from typing import Any
+
+from .base import ServiceClient
+
+_ENV_VAR = "CODING_TESTING_URL"
+
+
+class CodingTestingClient(ServiceClient):
+    """Client for coding-testing endpoints."""
+
+    def __init__(
+        self,
+        base_url: str | None = None,
+        timeout: float = 30.0,
+        max_retries: int = 3,
+    ):
+        url = base_url or os.environ.get(_ENV_VAR, "")
+        if not url:
+            raise RuntimeError(
+                f"CodingTestingClient requires base_url or {_ENV_VAR} env var. "
+                "See the platform configuration policy."
+            )
+        super().__init__(url, timeout=timeout, max_retries=max_retries)
+
+    async def run_tests(self, headers: dict[str, str] | None = None, **kwargs: Any) -> Any:
+        return await self.post("/api/tests/execute", headers=headers, json=kwargs)

coding_client/clients/coding_workspaces.py

@@ -0,0 +1,265 @@
+"""HTTP client for canonical repository-workspace operations."""
+
+from __future__ import annotations
+
+import os
+from typing import Any
+
+from .base import ServiceClient
+
+_ENV_VAR = "CODING_CONTAINERS_URL"
+
+
+class CodingWorkspacesClient(ServiceClient):
+    """Client for workspaces owned by the coding-containers service.
+
+    A workspace is a checked-out GitHub repository plus its isolated runtime.
+    The runtime may be Docker or Kubernetes, so callers should use this client
+    instead of coupling domain operations to the legacy container API.
+    """
+
+    def __init__(
+        self,
+        base_url: str | None = None,
+        timeout: float = 30.0,
+        max_retries: int = 3,
+    ) -> None:
+        url = base_url or os.environ.get(_ENV_VAR, "")
+        if not url:
+            raise RuntimeError(
+                f"CodingWorkspacesClient requires base_url or {_ENV_VAR} env var. "
+                "See the platform configuration policy."
+            )
+        super().__init__(url, timeout=timeout, max_retries=max_retries)
+
+    async def list_workspaces(self, headers: dict[str, str] | None = None, **filters: Any) -> Any:
+        return await self.get("/api/workspaces/", headers=headers, params=filters)
+
+    async def create_workspace(
+        self, headers: dict[str, str] | None = None, **workspace: Any
+    ) -> Any:
+        return await self.post("/api/workspaces/", headers=headers, json=workspace)
+
+    async def get_workspace(
+        self, workspace_name: str, headers: dict[str, str] | None = None
+    ) -> Any:
+        return await self.get(f"/api/workspaces/{workspace_name}", headers=headers)
+
+    async def get_status(self, workspace_name: str, headers: dict[str, str] | None = None) -> Any:
+        return await self.get(f"/api/workspaces/{workspace_name}/status", headers=headers)
+
+    async def delete_workspace(
+        self,
+        workspace_name: str,
+        headers: dict[str, str] | None = None,
+        **options: Any,
+    ) -> Any:
+        return await self.delete(
+            f"/api/workspaces/{workspace_name}", headers=headers, params=options
+        )
+
+    async def delete_all_workspaces(self, headers: dict[str, str] | None = None) -> Any:
+        return await self.delete("/api/workspaces/all", headers=headers)
+
+    async def list_files(
+        self,
+        workspace_name: str,
+        headers: dict[str, str] | None = None,
+        **query: Any,
+    ) -> Any:
+        return await self.get(
+            f"/api/workspaces/{workspace_name}/files", headers=headers, params=query
+        )
+
+    async def create_directory(
+        self, workspace_name: str, headers: dict[str, str] | None = None, **body: Any
+    ) -> Any:
+        return await self.post(
+            f"/api/workspaces/{workspace_name}/mkdir", headers=headers, json=body
+        )
+
+    async def create_file(
+        self, workspace_name: str, headers: dict[str, str] | None = None, **body: Any
+    ) -> Any:
+        return await self.post(
+            f"/api/workspaces/{workspace_name}/touch", headers=headers, json=body
+        )
+
+    async def write_file(
+        self, workspace_name: str, headers: dict[str, str] | None = None, **body: Any
+    ) -> Any:
+        return await self.post(
+            f"/api/workspaces/{workspace_name}/write-file", headers=headers, json=body
+        )
+
+    async def move_path(
+        self, workspace_name: str, headers: dict[str, str] | None = None, **body: Any
+    ) -> Any:
+        return await self.post(f"/api/workspaces/{workspace_name}/move", headers=headers, json=body)
+
+    async def delete_path(
+        self,
+        workspace_name: str,
+        headers: dict[str, str] | None = None,
+        **query: Any,
+    ) -> Any:
+        return await self.delete(
+            f"/api/workspaces/{workspace_name}/files", headers=headers, params=query
+        )
+
+    async def get_git_status(
+        self, workspace_name: str, headers: dict[str, str] | None = None
+    ) -> Any:
+        return await self.get(f"/api/workspaces/{workspace_name}/git/status", headers=headers)
+
+    async def commit(
+        self, workspace_name: str, headers: dict[str, str] | None = None, **body: Any
+    ) -> Any:
+        return await self.post(
+            f"/api/workspaces/{workspace_name}/git/commit", headers=headers, json=body
+        )
+
+    async def push(
+        self, workspace_name: str, headers: dict[str, str] | None = None, **body: Any
+    ) -> Any:
+        return await self.post(
+            f"/api/workspaces/{workspace_name}/git/push", headers=headers, json=body
+        )
+
+    async def exec(
+        self, workspace_name: str, headers: dict[str, str] | None = None, **body: Any
+    ) -> Any:
+        return await self.post(f"/api/workspaces/{workspace_name}/exec", headers=headers, json=body)
+
+    async def install_dependencies(
+        self, workspace_name: str, headers: dict[str, str] | None = None, **body: Any
+    ) -> Any:
+        return await self.post(
+            f"/api/workspaces/{workspace_name}/install-dependencies",
+            headers=headers,
+            json=body,
+        )
+
+    async def get_dependency_status(
+        self, workspace_name: str, headers: dict[str, str] | None = None
+    ) -> Any:
+        return await self.get(
+            f"/api/workspaces/{workspace_name}/dependency-status", headers=headers
+        )
+
+    async def package_upgrade(
+        self, workspace_name: str, headers: dict[str, str] | None = None, **body: Any
+    ) -> Any:
+        return await self.post(
+            f"/api/workspaces/{workspace_name}/package-upgrade", headers=headers, json=body
+        )
+
+    async def package_modify(
+        self, workspace_name: str, headers: dict[str, str] | None = None, **body: Any
+    ) -> Any:
+        return await self.post(
+            f"/api/workspaces/{workspace_name}/package-modify", headers=headers, json=body
+        )
+
+    async def execute_agent(
+        self, workspace_name: str, headers: dict[str, str] | None = None, **body: Any
+    ) -> Any:
+        return await self.post(
+            f"/api/workspaces/{workspace_name}/execute-agent", headers=headers, json=body
+        )
+
+    async def get_agent_capabilities(
+        self, workspace_name: str, headers: dict[str, str] | None = None
+    ) -> Any:
+        return await self.get(
+            f"/api/workspaces/{workspace_name}/agent-capabilities", headers=headers
+        )
+
+    # ------------------------------------------------------------------
+    # Async exec jobs (coding-containers ``src/routers/exec_async.py``)
+    # ------------------------------------------------------------------
+
+    async def exec_async(
+        self,
+        workspace_name: str,
+        command: list[str],
+        workdir: str | None = None,
+        timeout: int | None = None,
+        callback_url: str | None = None,
+        headers: dict[str, str] | None = None,
+    ) -> Any:
+        """Start ``command`` as an async job: ``POST {ws}/exec/async`` (202).
+
+        Returns the accepted document (``job_id``, ``container_name``, ``status``,
+        ``links.status``). ``timeout`` is the job's wall-clock limit in seconds
+        (server range 1-14400, default 3600), not the HTTP timeout. Omitted
+        arguments are not sent, so the server's defaults apply.
+
+        Sent exactly once (no transport retry): a retried POST without
+        ``callback_url`` would start a second job. With ``callback_url`` the
+        server de-duplicates a replay itself (same ``job_id``).
+        """
+        body: dict[str, Any] = {"command": command}
+        if workdir is not None:
+            body["workdir"] = workdir
+        if timeout is not None:
+            body["timeout"] = timeout
+        if callback_url is not None:
+            body["callback_url"] = callback_url
+        return await self.post(
+            f"/api/workspaces/{workspace_name}/exec/async",
+            headers=headers,
+            json=body,
+            max_attempts=1,
+        )
+
+    async def get_exec_job(
+        self, workspace_name: str, job_id: str, headers: dict[str, str] | None = None
+    ) -> Any:
+        """Read an async exec job: ``GET {ws}/exec/jobs/{job_id}``.
+
+        Status is ``queued | running | completed | failed``; a job of another
+        tenant or workspace is a 404 (:class:`ServiceError`).
+        """
+        return await self.get(
+            f"/api/workspaces/{workspace_name}/exec/jobs/{job_id}", headers=headers
+        )
+
+    # ------------------------------------------------------------------
+    # Secondary read-only repositories
+    # (coding-containers ``src/routers/containers/secondary_repos.py``)
+    # ------------------------------------------------------------------
+
+    async def add_repo(
+        self,
+        workspace_name: str,
+        repo_url: str,
+        ref: str | None = None,
+        refresh: bool = False,
+        headers: dict[str, str] | None = None,
+        request_timeout: float | None = None,
+    ) -> Any:
+        """Check out a read-only secondary repository: ``POST {ws}/repos``.
+
+        ``repo_url`` is ``https://github.com/<owner>/<repo>`` or ``<owner>/<repo>``;
+        ``ref`` a branch, tag or full commit SHA (default: the repository's default
+        branch). The checkout lands at ``/workspace/.repos/<owner>__<repo>`` (the
+        response's ``path``) and is always read-only: it has no remote and no push
+        credential. ``request_timeout`` overrides the client's HTTP timeout for a
+        large clone.
+        """
+        body: dict[str, Any] = {"repo_url": repo_url}
+        if ref is not None:
+            body["ref"] = ref
+        if refresh:
+            body["refresh"] = True
+        kwargs: dict[str, Any] = {}
+        if request_timeout is not None:
+            kwargs["timeout"] = request_timeout
+        return await self.post(
+            f"/api/workspaces/{workspace_name}/repos", headers=headers, json=body, **kwargs
+        )
+
+    async def list_repos(self, workspace_name: str, headers: dict[str, str] | None = None) -> Any:
+        """List the workspace's secondary repositories: ``GET {ws}/repos``."""
+        return await self.get(f"/api/workspaces/{workspace_name}/repos", headers=headers)

coding_client/config/__init__.py

@@ -0,0 +1,12 @@
+"""Configuration loading for coding-client.
+
+Provides YAML configuration loading with schema versioning support.
+"""
+
+from .base_settings import BaseMicroserviceSettings
+from .yaml_config_loader import YamlConfigLoader
+
+__all__ = [
+    "BaseMicroserviceSettings",
+    "YamlConfigLoader",
+]

coding_client/config/base_settings.py

@@ -0,0 +1,61 @@
+"""Shared base settings for coding-* microservices.
+
+Centralises the fail-loud-in-production pattern repeated across every service:
+each service lists the env-var-backed fields that must be non-empty when
+``ENVIRONMENT=production`` via ``_REQUIRED_IN_PRODUCTION``; this base raises a
+single combined ``RuntimeError`` at startup if any are missing, instead of
+silently routing traffic to a dead default.
+
+Per ``the platform configuration policy``: service
+addresses must come from gitops env, and missing env in production must crash
+boot loudly.
+
+Usage::
+
+    class Settings(BaseMicroserviceSettings):
+        model_config = SettingsConfigDict(env_prefix="CODING_FOO_")
+        _SERVICE_NAME = "coding-foo"
+        _REQUIRED_IN_PRODUCTION = ("database_url", "redis_url")
+
+        environment: str = "production"
+        database_url: str = ""
+        redis_url: str = ""
+
+Services whose environment field is named ``ENVIRONMENT`` (rather than
+``environment``) set ``_ENV_ATTR = "ENVIRONMENT"``. Subclasses that need extra
+post-init behaviour must call ``super().model_post_init(context)``.
+"""
+
+from __future__ import annotations
+
+from typing import ClassVar
+
+from pydantic_settings import BaseSettings
+
+
+class BaseMicroserviceSettings(BaseSettings):
+    """Base settings providing required-in-production enforcement."""
+
+    # ── Subclass-overridable contract ─────────────────────────────────
+    # Fields (by attribute name) that must be non-empty in production.
+    _REQUIRED_IN_PRODUCTION: ClassVar[tuple[str, ...]] = ()
+    # Service name used in the missing-fields error message.
+    _SERVICE_NAME: ClassVar[str] = "service"
+    # Attribute that holds the environment string ("environment" or "ENVIRONMENT").
+    _ENV_ATTR: ClassVar[str] = "environment"
+
+    def model_post_init(self, __context: object) -> None:
+        self._enforce_required_in_production()
+
+    def _enforce_required_in_production(self) -> None:
+        """Crash boot if any required field is empty in production."""
+        environment = getattr(self, self._ENV_ATTR, "production")
+        if environment != "production":
+            return
+        missing = [name for name in self._REQUIRED_IN_PRODUCTION if not getattr(self, name)]
+        if missing:
+            raise RuntimeError(
+                f"{self._SERVICE_NAME} settings missing required fields in production: "
+                f"{missing}. Set them via env vars on the Deployment "
+                "(see the platform repo)."
+            )

coding_client/config/yaml_config_loader.py

@@ -0,0 +1,172 @@
+"""Module for loading YAML configuration files."""
+
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+from typing import Any
+
+try:
+    import yaml
+
+    HAS_YAML = True
+except ImportError:
+    HAS_YAML = False
+    yaml: Any = None
+from pydantic import ValidationError
+
+from ..models.architecture import RepoConfig
+
+logger = logging.getLogger(__name__)
+
+
+class YamlConfigLoader:
+    """Load and validate .codegraph.yml configuration files with versioning support."""
+
+    # Current schema version - update when making breaking changes
+    CURRENT_VERSION = "2.0"
+
+    def __init__(self):
+        """Initialize the YAML config loader with version migration mappings."""
+        self._version_migrations = {
+            # Map from version to migration function
+            "1.0": self._migrate_v1_to_v2,
+        }
+
+    def load_config(self, repo: Path) -> RepoConfig:
+        """Load configuration from .codegraph.yml with version detection and migration.
+
+        Args:
+            repo: Repository root path containing .codegraph.yml
+
+        Returns:
+            Validated RepoConfig object, migrated to current schema if needed
+
+        Raises:
+            ValueError: If config is invalid or cannot be migrated
+        """
+        cfg_path = repo / ".codegraph.yml"
+
+        if not cfg_path.is_file():
+            logger.info("No .codegraph.yml found at %s, using defaults", repo)
+            return RepoConfig()
+
+        if not HAS_YAML:
+            logger.warning("yaml module not available - using defaults")
+            return RepoConfig()
+
+        assert yaml is not None, "yaml module must be available (guarded by HAS_YAML check)"
+        try:
+            # Load raw data for version detection
+            raw_data = yaml.safe_load(cfg_path.read_text()) or {}
+
+            # Check version and migrate if necessary
+            config_version = self._detect_version(raw_data)
+
+            if config_version != self.CURRENT_VERSION:
+                logger.info(
+                    "Config schema version %s detected, migrating to %s",
+                    config_version,
+                    self.CURRENT_VERSION,
+                )
+                raw_data = self._migrate_config(raw_data, config_version)
+
+            # Create and validate the config object
+            config = RepoConfig(**raw_data)
+
+            # Store version information
+            config.schema_version = self.CURRENT_VERSION
+
+            return config
+
+        except ValidationError as e:
+            raise ValueError(f"Invalid .codegraph.yml: {e}") from e
+        except yaml.YAMLError as e:
+            raise ValueError(f"Invalid YAML in .codegraph.yml: {e}") from e
+        except Exception as e:
+            logger.exception("Error processing .codegraph.yml")
+            raise ValueError(f"Error reading .codegraph.yml: {e}") from e
+
+    def _detect_version(self, data: dict[str, Any]) -> str:
+        """Detect the schema version from config data.
+
+        Args:
+            data: Raw configuration dictionary
+
+        Returns:
+            Detected version string, defaults to "1.0" for legacy configs
+        """
+        # Check if version is explicitly provided
+        if "schema_version" in data:
+            return str(data["schema_version"])
+
+        # Legacy detection logic
+        if "detect_by" in data and isinstance(data["detect_by"], list):
+            # This is likely a v1.0 config
+            return "1.0"
+
+        # Default for completely unknown formats
+        return "1.0"
+
+    def _migrate_config(self, data: dict[str, Any], from_version: str) -> dict[str, Any]:
+        """Migrate configuration from one version to another.
+
+        Args:
+            data: Raw configuration dictionary
+            from_version: Source version string
+
+        Returns:
+            Migrated configuration dictionary
+
+        Raises:
+            ValueError: If migration path doesn't exist
+        """
+        current = from_version
+        config_data = data.copy()
+
+        # Find migration path to current version
+        while current != self.CURRENT_VERSION:
+            if current not in self._version_migrations:
+                raise ValueError(
+                    f"No migration path from version {current} to {self.CURRENT_VERSION}"
+                )
+
+            # Apply migration step
+            migration_func = self._version_migrations[current]
+            config_data = migration_func(config_data)
+
+            # Update to next version in chain
+            # The migration function should return the new version
+            current = config_data.get("schema_version", current)
+
+        return config_data
+
+    def _migrate_v1_to_v2(self, data: dict[str, Any]) -> dict[str, Any]:
+        """Migrate from schema v1.0 to v2.0.
+
+        Args:
+            data: v1.0 config data
+
+        Returns:
+            v2.0 config data
+        """
+        # Make a copy to avoid modifying the original
+        result = data.copy()
+
+        # Set the new version
+        result["schema_version"] = "2.0"
+
+        # Handle renamed fields
+        if "detection_strategy" in result:
+            result["detect_by"] = result.pop("detection_strategy")
+
+        # Handle format changes for layer definitions
+        if "layers" in result:
+            layers = result["layers"]
+
+            # In v1, layers could be a basic list of names
+            # In v2, they must be a dict mapping names to glob patterns
+            if isinstance(layers, list):
+                result["layers"] = {layer: ["**/*"] for layer in layers}
+
+        return result

coding_client/db/__init__.py

@@ -0,0 +1,42 @@
+"""Database layer for coding-client.
+
+Provides:
+- PostgreSQL connection management (via PgBouncer)
+- Tenant-aware query building
+- Generic database type aliases
+- Custom database exceptions
+"""
+
+from . import db_types, exceptions, postgres_connection, tenant_query_helper
+from .exceptions import (
+    DatabaseConnectionError,
+    DatabaseError,
+    DatabaseIntegrityError,
+    DatabaseLockError,
+    DatabaseMigrationError,
+    DatabaseOperationalError,
+    DatabaseQueryError,
+    DatabaseSchemaError,
+    DatabaseTransactionError,
+)
+from .tenant_query_helper import TenantQueryBuilder
+
+__all__ = [
+    # Submodules
+    "db_types",
+    "exceptions",
+    "postgres_connection",
+    "tenant_query_helper",
+    # Key classes
+    "TenantQueryBuilder",
+    # Exceptions
+    "DatabaseError",
+    "DatabaseConnectionError",
+    "DatabaseIntegrityError",
+    "DatabaseLockError",
+    "DatabaseMigrationError",
+    "DatabaseOperationalError",
+    "DatabaseQueryError",
+    "DatabaseSchemaError",
+    "DatabaseTransactionError",
+]