@ngocsangairvds/vsaf 4.1.8 → 4.1.9

package/skills/vds-skill/vds-scripts/mcp_server/Dockerfile

@@ -1,63 +0,0 @@
-# syntax=docker/dockerfile:1
-# =============================================================================
-# VDS MCP Server - Dockerfile
-# Phase: ecosystem-infrastructure-evolution v2.12.2 follow-up
-#
-# Build context: vds-scripts workspace root (per docker-compose.cli.yml)
-# Example: docker build -f mcp_server/Dockerfile .
-#
-# Runtime contract:
-#   - MCP (Model Context Protocol) server for VDS
-#   - Reads ~/.vds/.env via env_file
-#   - Long-running service (HEALTHCHECK polls --help)
-# =============================================================================
-
-FROM python:3.14.4-slim
-
-ENV PYTHONDONTWRITEBYTECODE=1 \
-    PYTHONUNBUFFERED=1 \
-    UV_LINK_MODE=copy \
-    UV_COMPILE_BYTECODE=1 \
-    UV_PROJECT_ENVIRONMENT=/opt/venv \
-    PATH="/opt/venv/bin:$PATH"
-
-WORKDIR /app
-
-# System deps (curl for healthcheck; ca-certificates for outbound HTTPS)
-RUN apt-get update && apt-get install -y --no-install-recommends \
-    curl ca-certificates \
-    && rm -rf /var/lib/apt/lists/*
-
-COPY --from=ghcr.io/astral-sh/uv:latest /uv /bin/uv
-
-# Copy mcp_server + its workspace dep (vds_cli_common)
-COPY mcp_server/pyproject.toml /app/mcp_server/
-COPY mcp_server/README.md /app/mcp_server/
-COPY mcp_server/src /app/mcp_server/src
-
-COPY vds_cli_common /app/vds_cli_common
-
-# Canonical workspace pattern: per-path `uv pip install --no-sources`
-# (matches audit/progress/pdf/db-query Dockerfiles; avoids per-package
-# uv.lock requirement that the workspace doesn't carry per-service).
-RUN --mount=type=cache,target=/root/.cache/uv \
-    uv venv --python 3.14 /opt/venv && \
-    uv pip install --python /opt/venv/bin/python --no-sources \
-        /app/vds_cli_common \
-        /app/mcp_server
-
-# Create non-root user for security (matches pattern in all other VDS Dockerfiles)
-RUN groupadd --system vds && useradd --system --no-create-home --gid vds mcp && \
-    chown -R mcp:vds /app /opt/venv
-USER mcp
-
-# Health check
-HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
-    CMD /opt/venv/bin/vds-mcp-server --help || exit 1
-
-ENTRYPOINT ["/opt/venv/bin/vds-mcp-server"]
-CMD ["--help"]
-
-LABEL org.opencontainers.image.title="VDS MCP Server" \
-      org.opencontainers.image.description="Model Context Protocol server for VDS orchestrators" \
-      org.opencontainers.image.created="2026-04-26"

package/skills/vds-skill/vds-scripts/mcp_server/README.md

@@ -1,140 +0,0 @@
-# VDS MCP Server
-
-Model Context Protocol (MCP) server for VDS Platform operations, enabling AI agents to interact with JIRA, Confluence,
-Bitbucket, and Git through a standardized interface.
-
-## Installation
-
-```bash
-cd vds-scripts
-# Optional: sync every package once
-./scripts/bootstrap_uv.sh
-
-# Package-specific sync (only when you need dev extras)
-uv sync --project mcp_server
-```
-
-## Usage
-
-### Start MCP Server
-
-```bash
-# Using stdio transport (default)
-uv run vds-cli mcp
-
-# Or directly
-uv run --project mcp_server python -m vds_mcp_server.server
-```
-
-### Available Tools
-
-The MCP server exposes the following tools:
-
-#### JIRA Tools
-
-- `jira_search` - Search JIRA issues using JQL query
-- `jira_get_issue` - Get JIRA issue details
-- `jira_list_projects` - List all JIRA projects
-
-#### Confluence Tools
-
-- `confluence_search` - Search Confluence content using CQL query
-- `confluence_get_page` - Get Confluence page content
-
-#### Bitbucket Tools
-
-- `bitbucket_list_projects` - List all Bitbucket projects
-- `bitbucket_list_repositories` - List repositories in a project
-
-#### Git Tools
-
-- `git_clone` - Clone a VDS project repository
-- `git_status` - Get Git repository status
-- `git_pull` - Pull latest changes from Git repositories
-
-## Client Integration
-
-### Claude Desktop Configuration
-
-Add to `~/Library/Application Support/Claude/claude_desktop_config.json`:
-
-```json
-{
-  "mcpServers": {
-    "vds-orchestrator": {
-      "command": "uv",
-      "args": [
-        "run",
-        "--project",
-        "/path/to/vds-scripts/mcp_server",
-        "vds-cli mcp"
-      ],
-      "env": {
-        "VDS_USERNAME": "${VDS_USERNAME}",
-        "VDS_PASSWORD": "${VDS_PASSWORD}",
-        "BITBUCKET_ACCESS_TOKEN": "${BITBUCKET_ACCESS_TOKEN}",
-        "INTERNAL_CONFLUENCE_TOKEN": "${INTERNAL_CONFLUENCE_TOKEN}",
-        "EXTERNAL_CONFLUENCE_TOKEN": "${EXTERNAL_CONFLUENCE_TOKEN}"
-      }
-    }
-  }
-}
-```
-
-### Using with Docker
-
-```bash
-cd vds-scripts/docker
-docker-compose up -d mcp-server
-```
-
-## Development
-
-### Running Tests
-
-```bash
-# Unit tests
-uv run --project mcp_server pytest tests/unit/ -v
-
-# Verification tests (requires credentials)
-uv run --project mcp_server pytest tests/verification/ -v
-
-# With coverage
-uv run --project mcp_server pytest tests/ -v --cov=vds_mcp_server --cov-report=term-missing
-```
-
-### Code Quality
-
-```bash
-# Lint check
-uv run --project mcp_server ruff check src/
-
-# Format code
-uv run --project mcp_server ruff format src/
-```
-
-## Architecture
-
-The MCP server uses:
-
-- **FastMCP**: High-level MCP server interface from official Python SDK
-- **VDS CLI**: Executes commands via `vds-cli` subprocess
-- **Tool Registration**: All tools registered at server startup
-
-## Requirements
-
-- Python >= 3.11
-- uv (for package management)
-- vds-cli (must be installed and available in PATH)
-- Shared VDS env file with the required credentials
-
-## Dependencies
-
-- **mcp** >= 1.0.0 - Official MCP Python SDK (Context7: `/modelcontextprotocol/python-sdk`)
-- **typer** >= 0.20.0 - CLI framework
-- **pydantic** >= 2.12.3 - Data validation
-- **pydantic-settings** >= 2.12.0 - Settings management
-
-______________________________________________________________________
-
-*Last updated: 2025-11-12*

package/skills/vds-skill/vds-scripts/mcp_server/pyproject.toml

@@ -1,41 +0,0 @@
-[project]
-name = "vds-mcp-server"
-version = "1.0.0"
-description = "Model Context Protocol server for VDS Platform operations"
-requires-python = ">=3.11"
-dependencies = [
-    "mcp>=1.26.0",                   # Official MCP Python SDK - Context7: /modelcontextprotocol/python-sdk
-    "typer>=0.24.1",                # CLI framework
-    "pydantic>=2.12.5",             # Data validation
-    "pydantic-settings>=2.12.0",    # Settings management
-    "vds-cli-common",
-]
-
-[project.scripts]
-vds-mcp-server = "vds_mcp_server.server:main"
-
-[build-system]
-requires = ["hatchling>=1.20.0"]
-build-backend = "hatchling.build"
-
-[tool.hatch.build.targets.wheel]
-packages = ["src/vds_mcp_server"]
-
-[tool.uv.sources]
-vds-cli-common = { workspace = true }
-
-[project.optional-dependencies]
-dev = [
-    "pytest>=9.0.1",
-    "pytest-cov>=5.0.0",
-    "pytest-asyncio>=0.24.0",
-    "ruff>=0.14.5",
-]
-
-[dependency-groups]
-dev = [
-    "pytest>=9.0.1",
-    "pytest-cov>=5.0.0",
-    "pytest-asyncio>=0.24.0",
-    "ruff>=0.14.5",
-]

package/skills/vds-skill/vds-scripts/mcp_server/src/vds_mcp_server/__init__.py

@@ -1,3 +0,0 @@
-"""VDS MCP Server - Model Context Protocol server for VDS Platform operations."""
-
-__version__ = "1.0.0"

package/skills/vds-skill/vds-scripts/mcp_server/src/vds_mcp_server/config.py

@@ -1,36 +0,0 @@
-"""Configuration management for MCP server.
-
-Based on pydantic-settings v2.12.0+ API
-Context7: /pydantic/pydantic-settings
-"""
-
-from pydantic_settings import BaseSettings, SettingsConfigDict
-from vds_cli_common.env import DEFAULT_ENV_PATHS, load_shared_env
-
-
-class MCPServerSettings(BaseSettings):
-    """MCP server configuration settings."""
-
-    model_config = SettingsConfigDict(
-        env_file=DEFAULT_ENV_PATHS[0],
-        env_file_encoding="utf-8",
-        case_sensitive=False,
-        extra="ignore",  # Ignore extra env vars not defined in this model
-    )
-
-    # VDS credentials (required for orchestrator operations)
-    vds_username: str | None = None
-    vds_password: str | None = None
-    bitbucket_access_token: str | None = None
-    internal_confluence_token: str | None = None
-    external_confluence_token: str | None = None
-
-    # MCP server settings
-    server_name: str = "vds-orchestrator"
-    server_version: str = "1.0.0"
-
-
-def load_settings() -> MCPServerSettings:
-    """Load MCP server settings from environment."""
-    load_shared_env()
-    return MCPServerSettings()

package/skills/vds-skill/vds-scripts/mcp_server/src/vds_mcp_server/server.py

@@ -1,111 +0,0 @@
-"""MCP Server for VDS Platform operations.
-
-Based on MCP Python SDK v1.0.0+
-Context7: /modelcontextprotocol/python-sdk
-Key Features: FastMCP, tool registration, stdio transport
-"""
-
-import subprocess
-import sys
-from typing import Any
-
-from mcp.server.fastmcp import FastMCP
-
-from .config import load_settings
-from .tools import (
-    register_bitbucket_tools,
-    register_confluence_tools,
-    register_git_tools,
-    register_jira_tools,
-    register_vidp_tools,
-)
-
-# Initialize FastMCP server
-mcp = FastMCP("VDS Orchestrator")
-
-
-async def execute_vds_cli(*args: str) -> dict[str, Any]:
-    """Execute VDS CLI command via subprocess.
-
-    Args:
-        *args: Command arguments to pass to vds-cli
-
-    Returns:
-        dict: Command execution result with stdout, stderr, returncode
-    """
-    cmd = ["vds-cli", *list(args)]
-    result = subprocess.run(
-        cmd,
-        capture_output=True,
-        text=True,
-        check=False,
-    )
-    return {
-        "stdout": result.stdout,
-        "stderr": result.stderr,
-        "returncode": result.returncode,
-    }
-
-
-# Register all tool modules
-register_jira_tools(mcp, execute_vds_cli)
-register_confluence_tools(mcp, execute_vds_cli)
-register_bitbucket_tools(mcp, execute_vds_cli)
-register_git_tools(mcp, execute_vds_cli)
-register_vidp_tools(mcp, execute_vds_cli)
-
-
-try:
-    import typer
-
-    app = typer.Typer(
-        name="vds-mcp-server",
-        help="VDS MCP Server — stdio Model Context Protocol server for VDS platform operations.",
-        add_completion=False,
-        no_args_is_help=False,
-    )
-
-    @app.callback(invoke_without_command=True)
-    def _root(ctx: typer.Context) -> None:
-        """Default behavior: start the FastMCP server over stdio transport.
-
-        Requires shared VDS environment configuration to be available.
-        """
-        if ctx.invoked_subcommand is not None:
-            return
-        load_settings()
-        mcp.run()
-
-    @app.command()
-    def serve() -> None:
-        """Start the FastMCP server over stdio transport (explicit form)."""
-        load_settings()
-        mcp.run()
-
-    def main() -> None:
-        """Main entry point for MCP server (Typer-wrapped for help-output consistency)."""
-        app()
-
-except ImportError:
-    # Fallback to argparse-style if typer is unavailable (extreme edge case;
-    # typer is in pyproject.toml core deps, but defensive is better than broken).
-    def main() -> None:  # type: ignore[no-redef]
-        """Main entry point for MCP server (argparse fallback)."""
-        if any(arg in {"-h", "--help", "help"} for arg in sys.argv[1:]):
-            print("Usage: vds-mcp-server [OPTIONS]")
-            print()
-            print("VDS MCP Server - stdio Model Context Protocol server for VDS platform operations")
-            print()
-            print("Options:")
-            print("  -h, --help  Show this message and exit.")
-            print()
-            print("Behavior:")
-            print("  Starts the FastMCP server over stdio transport by default.")
-            print("  Requires shared VDS environment configuration to be available.")
-            return
-        load_settings()
-        mcp.run()
-
-
-if __name__ == "__main__":
-    main()

package/skills/vds-skill/vds-scripts/mcp_server/src/vds_mcp_server/tools/__init__.py

@@ -1,15 +0,0 @@
-"""MCP tools for VDS Platform orchestrators."""
-
-from .bitbucket_tools import register_bitbucket_tools
-from .confluence_tools import register_confluence_tools
-from .git_tools import register_git_tools
-from .jira_tools import register_jira_tools
-from .vidp_tools import register_vidp_tools
-
-__all__ = [
-    "register_bitbucket_tools",
-    "register_confluence_tools",
-    "register_git_tools",
-    "register_jira_tools",
-    "register_vidp_tools",
-]

package/skills/vds-skill/vds-scripts/mcp_server/src/vds_mcp_server/tools/bitbucket_tools.py

@@ -1,47 +0,0 @@
-"""Bitbucket tools for MCP server.
-
-Based on MCP Python SDK v1.0.0+
-Context7: /modelcontextprotocol/python-sdk
-"""
-
-from collections.abc import Callable
-from typing import TYPE_CHECKING, Any
-
-if TYPE_CHECKING:
-    from mcp.server.fastmcp import FastMCP
-
-
-def register_bitbucket_tools(mcp: FastMCP, execute_cli: Callable[..., Any]) -> None:
-    """Register Bitbucket tools with MCP server.
-
-    Args:
-        mcp: FastMCP server instance
-        execute_cli: Function to execute VDS CLI commands
-    """
-
-    @mcp.tool()
-    async def bitbucket_list_projects() -> str:
-        """List all Bitbucket projects.
-
-        Returns:
-            str: JSON-formatted list of projects
-        """
-        result = await execute_cli("bitbucket", "projects")
-        if result["returncode"] != 0:
-            return f"Error: {result['stderr']}"
-        return result["stdout"]
-
-    @mcp.tool()
-    async def bitbucket_list_repositories(project_key: str) -> str:
-        """List repositories in a Bitbucket project.
-
-        Args:
-            project_key: Project key (e.g., "LEP")
-
-        Returns:
-            str: JSON-formatted list of repositories
-        """
-        result = await execute_cli("bitbucket", "repositories", project_key)
-        if result["returncode"] != 0:
-            return f"Error: {result['stderr']}"
-        return result["stdout"]

package/skills/vds-skill/vds-scripts/mcp_server/src/vds_mcp_server/tools/confluence_tools.py

@@ -1,53 +0,0 @@
-"""Confluence tools for MCP server.
-
-Based on MCP Python SDK v1.0.0+
-Context7: /modelcontextprotocol/python-sdk
-"""
-
-from collections.abc import Callable
-from typing import TYPE_CHECKING, Any
-
-if TYPE_CHECKING:
-    from mcp.server.fastmcp import FastMCP
-
-
-def register_confluence_tools(mcp: FastMCP, execute_cli: Callable[..., Any]) -> None:
-    """Register Confluence tools with MCP server.
-
-    Args:
-        mcp: FastMCP server instance
-        execute_cli: Function to execute VDS CLI commands
-    """
-
-    @mcp.tool()
-    async def confluence_search(query: str, server: str = "internal", limit: int = 10) -> str:
-        """Search Confluence content using CQL query.
-
-        Args:
-            query: CQL query string (e.g., "space = TDOV")
-            server: Server to query ("internal" or "external", default: "internal")
-            limit: Maximum number of results (default: 10)
-
-        Returns:
-            str: JSON-formatted search results
-        """
-        result = await execute_cli("confluence", "content", "search", query, f"--server={server}", f"--limit={limit}")
-        if result["returncode"] != 0:
-            return f"Error: {result['stderr']}"
-        return result["stdout"]
-
-    @mcp.tool()
-    async def confluence_get_page(page_id: str, server: str = "internal") -> str:
-        """Get Confluence page content.
-
-        Args:
-            page_id: Page ID (e.g., "99647801")
-            server: Server to query ("internal" or "external", default: "internal")
-
-        Returns:
-            str: JSON-formatted page content
-        """
-        result = await execute_cli("confluence", "content", "page", page_id, f"--server={server}")
-        if result["returncode"] != 0:
-            return f"Error: {result['stderr']}"
-        return result["stdout"]

package/skills/vds-skill/vds-scripts/mcp_server/src/vds_mcp_server/tools/git_tools.py

@@ -1,71 +0,0 @@
-"""Git tools for MCP server.
-
-Based on MCP Python SDK v1.0.0+
-Context7: /modelcontextprotocol/python-sdk
-"""
-
-from collections.abc import Callable
-from typing import TYPE_CHECKING, Any
-
-if TYPE_CHECKING:
-    from mcp.server.fastmcp import FastMCP
-
-
-def register_git_tools(mcp: FastMCP, execute_cli: Callable[..., Any]) -> None:
-    """Register Git tools with MCP server.
-
-    Args:
-        mcp: FastMCP server instance
-        execute_cli: Function to execute VDS CLI commands
-    """
-
-    @mcp.tool()
-    async def git_clone(project: str) -> str:
-        """Clone a VDS project repository.
-
-        Args:
-            project: Project name (e.g., "lep", "insurance")
-
-        Returns:
-            str: Clone operation result
-        """
-        result = await execute_cli("git", "clone", project)
-        if result["returncode"] != 0:
-            return f"Error: {result['stderr']}"
-        return result["stdout"]
-
-    @mcp.tool()
-    async def git_status(match: str | None = None) -> str:
-        """Get Git repository status.
-
-        Args:
-            match: Pattern to match repositories (e.g., "*service*")
-
-        Returns:
-            str: Status information for matching repositories
-        """
-        args = ["git", "status"]
-        if match:
-            args.extend(["--match", match])
-        result = await execute_cli(*args)
-        if result["returncode"] != 0:
-            return f"Error: {result['stderr']}"
-        return result["stdout"]
-
-    @mcp.tool()
-    async def git_pull(project: str | None = None) -> str:
-        """Pull latest changes from Git repositories.
-
-        Args:
-            project: Project name to pull (optional, pulls all if not specified)
-
-        Returns:
-            str: Pull operation result
-        """
-        args = ["git", "pull"]
-        if project:
-            args.extend(["--project", project])
-        result = await execute_cli(*args)
-        if result["returncode"] != 0:
-            return f"Error: {result['stderr']}"
-        return result["stdout"]

package/skills/vds-skill/vds-scripts/mcp_server/src/vds_mcp_server/tools/jira_tools.py

@@ -1,63 +0,0 @@
-"""JIRA tools for MCP server.
-
-Based on MCP Python SDK v1.0.0+
-Context7: /modelcontextprotocol/python-sdk
-"""
-
-from collections.abc import Callable
-from typing import TYPE_CHECKING, Any
-
-if TYPE_CHECKING:
-    from mcp.server.fastmcp import FastMCP
-
-
-def register_jira_tools(mcp: FastMCP, execute_cli: Callable[..., Any]) -> None:
-    """Register JIRA tools with MCP server.
-
-    Args:
-        mcp: FastMCP server instance
-        execute_cli: Function to execute VDS CLI commands
-    """
-
-    @mcp.tool()
-    async def jira_search(query: str, limit: int = 20) -> str:
-        """Search JIRA issues using JQL query.
-
-        Args:
-            query: JQL query string (e.g., "project = NTTC")
-            limit: Maximum number of results (default: 20)
-
-        Returns:
-            str: JSON-formatted search results
-        """
-        result = await execute_cli("jira", "search", query, f"--limit={limit}")
-        if result["returncode"] != 0:
-            return f"Error: {result['stderr']}"
-        return result["stdout"]
-
-    @mcp.tool()
-    async def jira_get_issue(issue_key: str) -> str:
-        """Get JIRA issue details.
-
-        Args:
-            issue_key: Issue key (e.g., "NTTC-123")
-
-        Returns:
-            str: JSON-formatted issue details
-        """
-        result = await execute_cli("jira", "issue", issue_key)
-        if result["returncode"] != 0:
-            return f"Error: {result['stderr']}"
-        return result["stdout"]
-
-    @mcp.tool()
-    async def jira_list_projects() -> str:
-        """List all JIRA projects.
-
-        Returns:
-            str: JSON-formatted list of projects
-        """
-        result = await execute_cli("jira", "projects")
-        if result["returncode"] != 0:
-            return f"Error: {result['stderr']}"
-        return result["stdout"]