@ngocsangairvds/vsaf 4.1.8 → 4.1.9

package/skills/vds-skill/vds-scripts/bitbucket_orchestrator/src/vds_bitbucket_orchestrator/config.py

@@ -1,186 +0,0 @@
-"""Strongly-typed Bitbucket settings using pydantic-settings (consistent with VDS orchestrators)."""
-
-from __future__ import annotations
-
-from collections.abc import Mapping
-from pathlib import Path
-from typing import Any
-
-from pydantic import AliasChoices, Field, ValidationError
-from pydantic_settings import (
-    BaseSettings,
-    PydanticBaseSettingsSource,
-    SettingsConfigDict,
-)
-from vds_cli_common.env import DEFAULT_ENV_PATHS, load_shared_env
-from vds_platform_core.config import (
-    VDS_BASE_SETTINGS_CONFIG,
-    HTTPClientSettings,
-    vds_settings_customise_sources,
-)
-from vds_platform_core.errors import SettingsError
-
-
-class BitbucketSettings(HTTPClientSettings, BaseSettings):
-    model_config = SettingsConfigDict(**VDS_BASE_SETTINGS_CONFIG, env_prefix="BITBUCKET_")
-
-    # Override HTTPClientSettings retry default to match bitbucket's legacy
-    # behavior (1.0s initial backoff vs platform_core's 0.5s default); alias
-    # preserves the BITBUCKET_RETRY_BACKOFF env var contract.
-    retry_backoff_initial: float = Field(default=1.0, alias="BITBUCKET_RETRY_BACKOFF", ge=0)
-
-    # Backward-compat alias for code consumers (client.py uses retry_backoff_factor)
-    @property
-    def retry_backoff_factor(self) -> float:
-        """Legacy alias for retry_backoff_initial."""
-        return self.retry_backoff_initial
-
-    username: str | None = Field(default=None, alias="VDS_USERNAME")
-    password: str | None = Field(default=None, alias="VDS_PASSWORD")
-
-    # Bitbucket Server/DC URL (for on-premise installations)
-    # Primary: VDS_BITBUCKET_URL (FR-21.1.1)
-    # Backward-compatible aliases: BITBUCKET_BASE_URL, VDS_BITBUCKET_HTTP_BASE
-    # Priority: VDS_BITBUCKET_URL > BITBUCKET_BASE_URL > VDS_BITBUCKET_HTTP_BASE
-    base_url: str = Field(
-        default="http://bitbucket.digital.vn",
-        validation_alias=AliasChoices(
-            "VDS_BITBUCKET_URL",  # Primary (highest priority)
-            "BITBUCKET_BASE_URL",  # Legacy alias
-            "VDS_BITBUCKET_HTTP_BASE",  # git_orchestrator alias
-        ),
-    )
-
-    # Bitbucket Cloud workspace (for cloud.bitbucket.com)
-    cloud_workspace: str | None = Field(default=None, alias="BITBUCKET_CLOUD_WORKSPACE")
-
-    # Optional: Personal Access Token for Bitbucket Cloud or Server
-    token: str | None = Field(default=None, alias="BITBUCKET_TOKEN")
-
-    # Default mode: 'cloud' or 'server'
-    mode: str = Field(default="server", alias="BITBUCKET_MODE")
-
-    # Note: max_retries is inherited from HTTPClientSettings with env_prefix
-    # BITBUCKET_ → binds to BITBUCKET_MAX_RETRIES. retry_backoff_initial is
-    # declared above with explicit BITBUCKET_RETRY_BACKOFF alias override.
-
-    @classmethod
-    def settings_customise_sources(
-        cls,
-        settings_cls: type[BaseSettings],
-        init_settings: PydanticBaseSettingsSource,
-        env_settings: PydanticBaseSettingsSource,
-        dotenv_settings: PydanticBaseSettingsSource,
-        file_secret_settings: PydanticBaseSettingsSource,
-    ) -> tuple[PydanticBaseSettingsSource, ...]:
-        """Delegate to platform_core helper with local DEFAULT_ENV_PATHS."""
-        return vds_settings_customise_sources(
-            settings_cls,
-            init_settings,
-            env_settings,
-            dotenv_settings,
-            file_secret_settings,
-            env_paths=DEFAULT_ENV_PATHS,
-        )
-
-    def require_basic_or_token(self) -> None:
-        if not ((self.username and self.password) or self.token):
-            raise ValueError("Missing credentials: set VDS_USERNAME/VDS_PASSWORD or BITBUCKET_TOKEN")
-
-    @property
-    def is_cloud_mode(self) -> bool:
-        return self.mode.lower() == "cloud"
-
-    @property
-    def is_server_mode(self) -> bool:
-        return self.mode.lower() == "server"
-
-    def get_url(self) -> str:
-        """Get appropriate URL based on mode."""
-        if self.is_cloud_mode:
-            if not self.cloud_workspace:
-                raise ValueError("BITBUCKET_CLOUD_WORKSPACE is required for cloud mode")
-            return f"https://api.bitbucket.org/workspace/{self.cloud_workspace}"
-        return str(self.base_url)
-
-    def get_auth_kwargs(self) -> dict[str, str]:
-        """Get authentication kwargs for atlassian-python-api."""
-        if self.token:
-            return {"token": self.token}
-        elif self.username and self.password:
-            return {"username": self.username, "password": self.password}
-        else:
-            raise ValueError("No valid authentication credentials available")
-
-
-def load_settings(
-    *,
-    env_path: Path | None = None,
-    overrides: Mapping[str, Any] | None = None,
-    strict: bool = False,
-) -> BitbucketSettings:
-    """Load orchestrator settings using native pydantic-settings.
-
-    Args:
-        env_path: Optional path to a specific .env file (for testing).
-                 When provided, uses custom settings source instead of DEFAULT_ENV_PATHS.
-        overrides: Optional mapping of values to override settings.
-        strict: If True, require valid credentials (basic auth or token).
-
-    Returns:
-        BitbucketSettings instance with loaded configuration.
-
-    Raises:
-        SettingsError: If validation fails or strict mode requirements not met.
-    """
-    load_shared_env(path=env_path)
-    try:
-        kwargs: dict[str, Any] = dict(overrides) if overrides else {}
-
-        if env_path is not None:
-            from pydantic_settings.sources import DotEnvSettingsSource
-
-            class CustomBitbucketSettings(BitbucketSettings):
-                @classmethod
-                def settings_customise_sources(
-                    cls,
-                    settings_cls: type[BaseSettings],
-                    init_settings: PydanticBaseSettingsSource,
-                    env_settings: PydanticBaseSettingsSource,
-                    dotenv_settings: PydanticBaseSettingsSource,
-                    file_secret_settings: PydanticBaseSettingsSource,
-                ) -> tuple[PydanticBaseSettingsSource, ...]:
-                    """Custom source chain: init → custom env_path → env vars.
-
-                    env_path precedes env_settings so explicit test/override
-                    files beat ambient runtime env (preserves legacy
-                    load_shared_env(override=True) semantics).
-                    """
-                    sources: list[PydanticBaseSettingsSource] = [init_settings]
-                    if env_path.exists():
-                        sources.append(
-                            DotEnvSettingsSource(
-                                settings_cls,
-                                env_file=env_path,
-                                env_file_encoding="utf-8",
-                            )
-                        )
-                    sources.append(env_settings)
-                    return tuple(sources)
-
-            settings = CustomBitbucketSettings(**kwargs)
-        else:
-            settings = BitbucketSettings(**kwargs)
-
-    except ValidationError as exc:
-        raise SettingsError(str(exc)) from exc
-
-    if strict:
-        # Let ValueError propagate unwrapped (matches legacy contract; tests
-        # use pytest.raises(ValueError, match="Missing credentials"))
-        settings.require_basic_or_token()
-
-    return settings
-
-
-__all__ = ["DEFAULT_ENV_PATHS", "BitbucketSettings", "SettingsError", "load_settings"]

package/skills/vds-skill/vds-scripts/bitbucket_orchestrator/src/vds_bitbucket_orchestrator/errors.py

@@ -1,34 +0,0 @@
-"""Bitbucket error types — re-exports from vds_platform_core with service tag."""
-
-from vds_platform_core.errors import (
-    AuthError,
-    ClientPermissionError,
-    ClientTimeoutError,
-    ConflictError,
-    NotFoundError,
-    RateLimitError,
-    ResponseError,
-    RetryError,
-    SettingsError,
-    TransportError,
-    VDSClientError,
-    VDSError,
-)
-
-SERVICE_NAME = "bitbucket"
-
-__all__ = [
-    "SERVICE_NAME",
-    "AuthError",
-    "ClientPermissionError",
-    "ClientTimeoutError",
-    "ConflictError",
-    "NotFoundError",
-    "RateLimitError",
-    "ResponseError",
-    "RetryError",
-    "SettingsError",
-    "TransportError",
-    "VDSClientError",
-    "VDSError",
-]

package/skills/vds-skill/vds-scripts/bitbucket_orchestrator/src/vds_bitbucket_orchestrator/factory.py

@@ -1,185 +0,0 @@
-"""Factory functions for creating Bitbucket clients with automatic credential loading.
-
-This module provides convenient factory functions that automatically load credentials
-from the shared VDS environment loader (`vds_cli_common.env`), simplifying client instantiation.
-
-Usage:
-    from vds_bitbucket_orchestrator import create_client, create_async_client
-
-    # Create a sync client with auto-loaded credentials
-    client = create_client()
-
-    # Create a sync client with explicit mode
-    client = create_client(mode="cloud")
-
-    # Create an async client for non-blocking operations
-    async_client = create_async_client()
-
-References:
-    - FR-21.2.2: Factory functions that load credentials from the shared VDS env file automatically
-    - FR-21.2.3: AsyncBitbucketClient using asyncio.to_thread()
-    - TSK-223: Factory functions for Bitbucket
-    - TSK-225: Async Bitbucket wrapper
-"""
-
-from __future__ import annotations
-
-from pathlib import Path
-from typing import Literal
-
-from vds_cli_common.paths import get_shared_env_path
-
-from .async_client import AsyncBitbucketClient
-from .client import BitbucketClient
-from .config import load_settings
-
-# Default path for the shared VDS environment file
-DEFAULT_VDS_ENV_PATH = get_shared_env_path()
-
-
-def create_client(
-    *,
-    mode: Literal["server", "cloud"] | None = None,
-    env_path: Path | None = None,
-    timeout: int | None = 30,
-    strict: bool = True,
-) -> BitbucketClient:
-    """Create a Bitbucket client with auto-loaded credentials from the shared VDS env file.
-
-    This factory function simplifies client creation by automatically loading
-    credentials from the standard VDS environment file location.
-
-    Args:
-        mode: Bitbucket mode - 'server' (default) for Bitbucket Server/DC,
-              'cloud' for Bitbucket Cloud. If None, uses value from env file
-              or defaults to 'server'.
-        env_path: Optional custom path to .env file. Defaults to the shared VDS env path.
-        timeout: HTTP timeout in seconds (default: 30).
-        strict: If True (default), validates that credentials are present.
-                Set to False to allow creating client without validation.
-
-    Returns:
-        BitbucketClient: Configured Bitbucket client instance.
-
-    Raises:
-        ValueError: If strict=True and credentials are missing.
-        SettingsError: If environment configuration cannot be loaded.
-
-    Example:
-        # Simple usage with defaults (server mode, shared VDS env path)
-        client = create_client()
-
-        # Cloud mode
-        client = create_client(mode="cloud")
-
-        # Custom env file
-        client = create_client(env_path=Path("/custom/path/.env"))
-
-        # Non-strict mode (for testing)
-        client = create_client(strict=False)
-
-    Note:
-        The client implements BitbucketFullClient protocol, enabling type-safe
-        dependency injection:
-
-            def audit_repo(client: BitbucketFullClient, project: str, repo: str):
-                return client.get_repository(project, repo)
-
-            client = create_client()
-            result = audit_repo(client, "INS", "insurance-core")
-    """
-    # Build overrides dict for mode if specified
-    overrides: dict[str, str] | None = None
-    if mode is not None:
-        overrides = {"BITBUCKET_MODE": mode}
-
-    # Load settings from env file with optional overrides
-    settings = load_settings(
-        env_path=env_path or DEFAULT_VDS_ENV_PATH,
-        overrides=overrides,
-        strict=strict,
-    )
-
-    # Create and return the client
-    return BitbucketClient(settings, timeout=timeout)
-
-
-def create_async_client(
-    *,
-    mode: Literal["server", "cloud"] | None = None,
-    env_path: Path | None = None,
-    timeout: int | None = 30,
-    strict: bool = True,
-) -> AsyncBitbucketClient:
-    """Create an async Bitbucket client with auto-loaded credentials from the shared VDS env file.
-
-    This factory function creates an AsyncBitbucketClient that wraps the synchronous
-    BitbucketClient methods using asyncio.to_thread() for non-blocking execution.
-
-    Args:
-        mode: Bitbucket mode - 'server' (default) for Bitbucket Server/DC,
-              'cloud' for Bitbucket Cloud. If None, uses value from env file
-              or defaults to 'server'.
-        env_path: Optional custom path to .env file. Defaults to the shared VDS env path.
-        timeout: HTTP timeout in seconds (default: 30).
-        strict: If True (default), validates that credentials are present.
-                Set to False to allow creating client without validation.
-
-    Returns:
-        AsyncBitbucketClient: Async Bitbucket client instance.
-
-    Raises:
-        ValueError: If strict=True and credentials are missing.
-        SettingsError: If environment configuration cannot be loaded.
-
-    Example:
-        import asyncio
-        from vds_bitbucket_orchestrator import create_async_client
-
-        async def audit_repos():
-            client = create_async_client()
-
-            # Non-blocking API calls
-            repos = await client.list_repositories("INS")
-
-            # Concurrent API calls
-            repo_info, branches = await asyncio.gather(
-                client.get_repository("INS", "insurance-core"),
-                client.get_branches("INS", "insurance-core"),
-            )
-            return repos, repo_info, branches
-
-        # Run the async function
-        result = asyncio.run(audit_repos())
-
-    Note:
-        The AsyncBitbucketClient implements the same protocols as BitbucketClient:
-        - BitbucketRepositoryClient
-        - BitbucketBranchClient
-        - BitbucketCodeClient
-        - BitbucketFullClient
-
-        The underlying HTTP calls are synchronous but run in a thread pool,
-        preventing them from blocking the async event loop.
-    """
-    # Build overrides dict for mode if specified
-    overrides: dict[str, str] | None = None
-    if mode is not None:
-        overrides = {"BITBUCKET_MODE": mode}
-
-    # Load settings from env file with optional overrides
-    settings = load_settings(
-        env_path=env_path or DEFAULT_VDS_ENV_PATH,
-        overrides=overrides,
-        strict=strict,
-    )
-
-    # Create and return the async client
-    return AsyncBitbucketClient(settings, timeout=timeout)
-
-
-__all__ = [
-    "DEFAULT_VDS_ENV_PATH",
-    "create_async_client",
-    "create_client",
-]

package/skills/vds-skill/vds-scripts/bitbucket_orchestrator/src/vds_bitbucket_orchestrator/parsers.py

@@ -1,113 +0,0 @@
-"""Shared Bitbucket REST API JSON parsers.
-
-Pure-function extractors for clone URLs and default branch metadata from
-Bitbucket Server REST API response dicts.  Both ``vds_sync_orchestrator``
-and ``audit_orchestrator`` import from here instead of maintaining inline
-extraction logic.
-
-Phase 4 — FR-P1 (TSK-P1.1).
-"""
-
-from __future__ import annotations
-
-from dataclasses import dataclass
-
-
-@dataclass(frozen=True)
-class BitbucketBranchInfo:
-    """Default branch metadata extracted from a Bitbucket repo dict.
-
-    Attributes:
-        display_id: Human-readable branch name (e.g. ``"release"``, ``"main"``).
-                     When the server has no default branch this equals
-                     *missing_sentinel*.
-        ref: Full git ref (e.g. ``"refs/heads/release"``), or ``None`` when
-             the server omits it.
-        missing: ``True`` when the server did not report a default branch and
-                 *display_id* was filled from the sentinel.
-    """
-
-    display_id: str
-    ref: str | None
-    missing: bool
-
-
-def parse_clone_url(repo_dict: dict) -> str | None:
-    """Extract the HTTP(S) clone URL from a Bitbucket repo dict.
-
-    Iterates the ``links.clone`` array looking for the entry named ``"http"``.
-    Falls back to the ``"ssh"`` entry when HTTP is absent.  Returns ``None``
-    when neither is available.
-    """
-    links = repo_dict.get("links") or {}
-    clone_entries = links.get("clone") or []
-
-    http_url: str | None = None
-    ssh_url: str | None = None
-
-    for entry in clone_entries:
-        name = (entry.get("name") or "").lower()
-        href = entry.get("href")
-        if not href:
-            continue
-        if name == "http":
-            http_url = str(href)
-        elif name == "ssh":
-            ssh_url = str(href)
-
-    return http_url or ssh_url
-
-
-def parse_default_branch(
-    repo_dict: dict,
-    *,
-    missing_sentinel: str = "main",
-) -> BitbucketBranchInfo:
-    """Extract default-branch metadata from a Bitbucket repo dict.
-
-    The Bitbucket Server REST API may represent ``defaultBranch`` as:
-
-    * A **dict** with ``displayId``, ``id`` (full ref), and optional
-      ``latestCommit``.
-    * A **plain string** (the branch name directly).
-    * **Absent** — the server has no default branch configured.
-
-    When absent, *missing_sentinel* is used as the ``display_id`` value and
-    ``missing`` is set to ``True``.  This replaces the inconsistent hardcoded
-    sentinels (``"release"`` in sync, ``"main"`` in audit) with a single
-    parameterised entry point.
-    """
-    payload = repo_dict.get("defaultBranch")
-
-    if isinstance(payload, dict):
-        display_id = str(payload.get("displayId") or "").strip()
-        ref_raw = str(payload.get("id") or payload.get("latestCommit") or "").strip()
-        ref = ref_raw or None
-
-        if not display_id:
-            return BitbucketBranchInfo(
-                display_id=missing_sentinel,
-                ref=ref,
-                missing=True,
-            )
-        return BitbucketBranchInfo(
-            display_id=display_id,
-            ref=ref,
-            missing=False,
-        )
-
-    if isinstance(payload, str):
-        stripped = payload.strip()
-        if stripped:
-            return BitbucketBranchInfo(
-                display_id=stripped,
-                ref=None,
-                missing=False,
-            )
-
-    # No defaultBranch at all (None, empty string, or unexpected type)
-    return BitbucketBranchInfo(
-        display_id=missing_sentinel,
-        ref=None,
-        missing=True,
-    )