xenfra-sdk 0.2.2__py3-none-any.whl → 0.2.4__py3-none-any.whl

xenfra_sdk/exceptions.py

@@ -1,19 +1,19 @@
-class XenfraError(Exception):
-    """Base exception for all SDK errors."""
-
-    pass
-
-
-class AuthenticationError(XenfraError):
-    """Raised for issues related to authentication."""
-
-    pass
-
-
-class XenfraAPIError(XenfraError):
-    """Raised when the API returns a non-2xx status code."""
-
-    def __init__(self, status_code: int, detail: str):
-        self.status_code = status_code
-        self.detail = detail
-        super().__init__(f"API Error {status_code}: {detail}")
+class XenfraError(Exception):
+    """Base exception for all SDK errors."""
+
+    pass
+
+
+class AuthenticationError(XenfraError):
+    """Raised for issues related to authentication."""
+
+    pass
+
+
+class XenfraAPIError(XenfraError):
+    """Raised when the API returns a non-2xx status code."""
+
+    def __init__(self, status_code: int, detail: str):
+        self.status_code = status_code
+        self.detail = detail
+        super().__init__(f"API Error {status_code}: {detail}")

xenfra_sdk/manifest.py

@@ -0,0 +1,212 @@
+"""
+Xenfra Microservices Manifest - Schema and Parser for xenfra.yaml services array.
+
+This module defines the Pydantic models for microservices deployment configuration.
+For microservices projects, xenfra.yaml includes a 'services' array:
+
+  project_name: my-app
+  framework: fastapi
+  services:   # <-- This makes it a microservices project
+    - name: users
+      port: 8001
+    - name: orders
+      port: 8002
+"""
+
+from pathlib import Path
+from typing import List, Literal, Optional
+
+import yaml
+from pydantic import BaseModel, Field, field_validator
+
+
+class ServiceDefinition(BaseModel):
+    """
+    Single service definition in a microservices project.
+    
+    Example in xenfra.yaml:
+        services:
+          - name: users
+            path: ./services/users
+            port: 8001
+            framework: fastapi
+            entrypoint: users_api.main:app
+    """
+    
+    name: str = Field(..., min_length=1, max_length=50, description="Service name (unique)")
+    path: str = Field(default=".", description="Relative path to service directory")
+    port: int = Field(..., ge=1, le=65535, description="Service port")
+    framework: Literal["fastapi", "flask", "django", "other"] = Field(
+        default="fastapi", description="Web framework"
+    )
+    entrypoint: Optional[str] = Field(
+        default=None, description="Application entrypoint (e.g., 'users_api.main:app')"
+    )
+    command: Optional[str] = Field(
+        default=None, description="Custom start command"
+    )
+    env: Optional[dict] = Field(
+        default_factory=dict, description="Environment variables"
+    )
+    package_manager: Optional[str] = Field(
+        default="pip", description="Package manager (pip, uv)"
+    )
+    dependency_file: Optional[str] = Field(
+        default="requirements.txt", description="Dependency file"
+    )
+    missing_deps: List[str] = Field(
+        default_factory=list, description="Proactively detected missing dependencies"
+    )
+    
+    @field_validator("name")
+    @classmethod
+    def validate_name(cls, v: str) -> str:
+        """Ensure name is URL-safe (alphanumeric + hyphens)."""
+        import re
+        if not re.match(r'^[a-z][a-z0-9-]*$', v.lower()):
+            raise ValueError(
+                f"Service name '{v}' must start with a letter and contain only "
+                "lowercase letters, numbers, and hyphens"
+            )
+        return v.lower()
+
+
+def validate_unique_names(services: List[ServiceDefinition]) -> List[ServiceDefinition]:
+    """Ensure all service names are unique."""
+    names = [s.name for s in services]
+    if len(names) != len(set(names)):
+        duplicates = [n for n in names if names.count(n) > 1]
+        raise ValueError(f"Duplicate service names: {set(duplicates)}")
+    return services
+
+
+def validate_unique_ports(services: List[ServiceDefinition]) -> List[ServiceDefinition]:
+    """Ensure all service ports are unique."""
+    ports = [s.port for s in services]
+    if len(ports) != len(set(ports)):
+        duplicates = [p for p in ports if ports.count(p) > 1]
+        raise ValueError(f"Duplicate service ports: {set(duplicates)}")
+    return services
+
+
+def load_services_from_xenfra_yaml(project_path: str = ".") -> Optional[List[ServiceDefinition]]:
+    """
+    Load services array from xenfra.yaml if present.
+    
+    Args:
+        project_path: Path to the project directory (default: current directory)
+    
+    Returns:
+        List of ServiceDefinition if 'services' key found, None otherwise
+    
+    Raises:
+        ValueError: If services array is invalid
+    """
+    yaml_path = Path(project_path) / "xenfra.yaml"
+    
+    if not yaml_path.exists():
+        return None
+    
+    with open(yaml_path, "r", encoding="utf-8") as f:
+        try:
+            data = yaml.safe_load(f)
+        except yaml.YAMLError:
+            return None
+    
+    if not data or "services" not in data:
+        return None
+    
+    services_data = data.get("services", [])
+    if not services_data or not isinstance(services_data, list):
+        return None
+    
+    try:
+        services = [ServiceDefinition(**svc) for svc in services_data]
+        validate_unique_names(services)
+        validate_unique_ports(services)
+        return services
+    except Exception as e:
+        raise ValueError(f"Invalid services configuration in xenfra.yaml: {e}")
+
+
+def is_microservices_project(project_path: str = ".") -> bool:
+    """
+    Check if project has multiple services defined in xenfra.yaml.
+    
+    Returns:
+        True if xenfra.yaml has 'services' array with 2+ services
+    """
+    try:
+        services = load_services_from_xenfra_yaml(project_path)
+        return services is not None and len(services) > 1
+    except ValueError:
+        return False
+
+
+def get_deployment_mode(project_path: str = ".") -> Optional[str]:
+    """
+    Get deployment mode from xenfra.yaml if specified.
+    
+    Returns:
+        "single-droplet", "multi-droplet", or None if not specified
+    """
+    yaml_path = Path(project_path) / "xenfra.yaml"
+    
+    if not yaml_path.exists():
+        return None
+    
+    with open(yaml_path, "r", encoding="utf-8") as f:
+        try:
+            data = yaml.safe_load(f)
+        except yaml.YAMLError:
+            return None
+    
+    return data.get("mode") if data else None
+
+
+def add_services_to_xenfra_yaml(
+    project_path: str,
+    services: List[dict],
+    mode: str = "single-droplet"
+) -> Path:
+    """
+    Add or update services array in existing xenfra.yaml.
+    
+    Args:
+        project_path: Path to the project directory
+        services: List of service dictionaries from auto-detection
+        mode: Deployment mode
+    
+    Returns:
+        Path to the updated xenfra.yaml
+    """
+    yaml_path = Path(project_path) / "xenfra.yaml"
+    
+    # Load existing xenfra.yaml if present
+    existing_data = {}
+    if yaml_path.exists():
+        with open(yaml_path, "r", encoding="utf-8") as f:
+            existing_data = yaml.safe_load(f) or {}
+    
+    # Add services array
+    existing_data["services"] = services
+    existing_data["mode"] = mode
+    
+    # Write back
+    with open(yaml_path, "w", encoding="utf-8") as f:
+        yaml.dump(existing_data, f, default_flow_style=False, sort_keys=False)
+    
+    return yaml_path
+
+
+def create_services_from_detected(services: List[dict]) -> List[ServiceDefinition]:
+    """
+    Create ServiceDefinition list from detected services.
+    
+    Args:
+        services: List of service dictionaries from auto-detection
+    
+    Returns:
+        List of ServiceDefinition instances
+    """
+    return [ServiceDefinition(**svc) for svc in services]

xenfra_sdk/mcp_client.py

@@ -1,154 +1,154 @@
-# src/xenfra/mcp_client.py
-
-import base64
-import json
-import os
-import subprocess
-import tempfile
-from pathlib import Path
-
-
-class MCPClient:
-    """
-    A client for communicating with a local github-mcp-server process.
-
-    This client starts the MCP server as a subprocess and interacts with it
-    over stdin and stdout to download a full repository to a temporary directory.
-    """
-
-    def __init__(self, mcp_server_path="github-mcp-server"):
-        """
-        Initializes the MCPClient.
-
-        Args:
-            mcp_server_path (str): The path to the github-mcp-server executable.
-                                   Assumes it's in the system's PATH by default.
-        """
-        self.mcp_server_path = mcp_server_path
-        self.process = None
-
-    def _start_server(self):
-        """Starts the github-mcp-server subprocess."""
-        if self.process and self.process.poll() is None:
-            return
-        try:
-            self.process = subprocess.Popen(
-                [self.mcp_server_path],
-                stdin=subprocess.PIPE,
-                stdout=subprocess.PIPE,
-                stderr=subprocess.PIPE,
-                text=True,
-                env=os.environ,
-            )
-        except FileNotFoundError:
-            raise RuntimeError(
-                f"'{self.mcp_server_path}' not found. Ensure github-mcp-server is installed and in your PATH."
-            )
-        except Exception as e:
-            raise RuntimeError(f"Failed to start MCP server: {e}")
-
-    def _stop_server(self):
-        """Stops the MCP server process."""
-        if self.process:
-            self.process.terminate()
-            self.process.wait()
-            self.process = None
-
-    def _send_request(self, method: str, params: dict) -> dict:
-        """Sends a JSON-RPC request and returns the response."""
-        if not self.process or self.process.poll() is not None:
-            self._start_server()
-
-        request = {"jsonrpc": "2.0", "id": os.urandom(4).hex(), "method": method, "params": params}
-
-        try:
-            self.process.stdin.write(json.dumps(request) + "\n")
-            self.process.stdin.flush()
-            response_line = self.process.stdout.readline()
-            if not response_line:
-                error_output = self.process.stderr.read()
-                raise RuntimeError(f"MCP server closed stream unexpectedly. Error: {error_output}")
-
-            response = json.loads(response_line)
-            if "error" in response:
-                raise RuntimeError(f"MCP server returned an error: {response['error']}")
-            return response.get("result", {})
-        except (BrokenPipeError, json.JSONDecodeError) as e:
-            raise RuntimeError(f"Failed to communicate with MCP server: {e}")
-
-    def download_repo_to_tempdir(self, repo_url: str, commit_sha: str = "HEAD") -> str:
-        """
-        Downloads an entire repository at a specific commit to a local temporary directory.
-
-        Args:
-            repo_url (str): The full URL of the GitHub repository.
-            commit_sha (str): The commit SHA to download. Defaults to "HEAD".
-
-        Returns:
-            The path to the temporary directory containing the downloaded code.
-        """
-        try:
-            parts = repo_url.strip("/").split("/")
-            owner = parts[-2]
-            repo_name = parts[-1].replace(".git", "")
-        except IndexError:
-            raise ValueError(
-                "Invalid repository URL format. Expected format: https://github.com/owner/repo"
-            )
-
-        print(f"   [MCP] Fetching file tree for {owner}/{repo_name} at {commit_sha}...")
-        tree_result = self._send_request(
-            method="git.get_repository_tree",
-            params={"owner": owner, "repo": repo_name, "tree_sha": commit_sha, "recursive": True},
-        )
-
-        tree = tree_result.get("tree", [])
-        if not tree:
-            raise RuntimeError("Could not retrieve repository file tree.")
-
-        temp_dir = tempfile.mkdtemp(prefix=f"xenfra_{repo_name}_")
-        print(f"   [MCP] Downloading to temporary directory: {temp_dir}")
-
-        for item in tree:
-            item_path = item.get("path")
-            item_type = item.get("type")
-
-            if not item_path or item_type != "blob":  # Only handle files
-                continue
-
-            # For downloading content, we can use the commit_sha in the 'ref' parameter
-            # to ensure we get the content from the correct version.
-            content_result = self._send_request(
-                method="repos.get_file_contents",
-                params={"owner": owner, "repo": repo_name, "path": item_path, "ref": commit_sha},
-            )
-
-            content_b64 = content_result.get("content")
-            if content_b64 is None:
-                print(f"   [MCP] [Warning] Could not get content for {item_path}")
-                continue
-
-            try:
-                # Content is base64 encoded, with newlines.
-                decoded_content = base64.b64decode(content_b64.replace("\n", ""))
-            except (base64.binascii.Error, TypeError):
-                print(f"   [MCP] [Warning] Could not decode content for {item_path}")
-                continue
-
-            # Create file and parent directories in the temp location
-            local_file_path = Path(temp_dir) / item_path
-            local_file_path.parent.mkdir(parents=True, exist_ok=True)
-
-            # Write the file content
-            with open(local_file_path, "wb") as f:
-                f.write(decoded_content)
-
-        print("   [MCP] ✅ Repository download complete.")
-        return temp_dir
-
-    def __enter__(self):
-        self._start_server()
-        return self
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        self._stop_server()
+# src/xenfra/mcp_client.py
+
+import base64
+import json
+import os
+import subprocess
+import tempfile
+from pathlib import Path
+
+
+class MCPClient:
+    """
+    A client for communicating with a local github-mcp-server process.
+
+    This client starts the MCP server as a subprocess and interacts with it
+    over stdin and stdout to download a full repository to a temporary directory.
+    """
+
+    def __init__(self, mcp_server_path="github-mcp-server"):
+        """
+        Initializes the MCPClient.
+
+        Args:
+            mcp_server_path (str): The path to the github-mcp-server executable.
+                                   Assumes it's in the system's PATH by default.
+        """
+        self.mcp_server_path = mcp_server_path
+        self.process = None
+
+    def _start_server(self):
+        """Starts the github-mcp-server subprocess."""
+        if self.process and self.process.poll() is None:
+            return
+        try:
+            self.process = subprocess.Popen(
+                [self.mcp_server_path],
+                stdin=subprocess.PIPE,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+                env=os.environ,
+            )
+        except FileNotFoundError:
+            raise RuntimeError(
+                f"'{self.mcp_server_path}' not found. Ensure github-mcp-server is installed and in your PATH."
+            )
+        except Exception as e:
+            raise RuntimeError(f"Failed to start MCP server: {e}")
+
+    def _stop_server(self):
+        """Stops the MCP server process."""
+        if self.process:
+            self.process.terminate()
+            self.process.wait()
+            self.process = None
+
+    def _send_request(self, method: str, params: dict) -> dict:
+        """Sends a JSON-RPC request and returns the response."""
+        if not self.process or self.process.poll() is not None:
+            self._start_server()
+
+        request = {"jsonrpc": "2.0", "id": os.urandom(4).hex(), "method": method, "params": params}
+
+        try:
+            self.process.stdin.write(json.dumps(request) + "\n")
+            self.process.stdin.flush()
+            response_line = self.process.stdout.readline()
+            if not response_line:
+                error_output = self.process.stderr.read()
+                raise RuntimeError(f"MCP server closed stream unexpectedly. Error: {error_output}")
+
+            response = json.loads(response_line)
+            if "error" in response:
+                raise RuntimeError(f"MCP server returned an error: {response['error']}")
+            return response.get("result", {})
+        except (BrokenPipeError, json.JSONDecodeError) as e:
+            raise RuntimeError(f"Failed to communicate with MCP server: {e}")
+
+    def download_repo_to_tempdir(self, repo_url: str, commit_sha: str = "HEAD") -> str:
+        """
+        Downloads an entire repository at a specific commit to a local temporary directory.
+
+        Args:
+            repo_url (str): The full URL of the GitHub repository.
+            commit_sha (str): The commit SHA to download. Defaults to "HEAD".
+
+        Returns:
+            The path to the temporary directory containing the downloaded code.
+        """
+        try:
+            parts = repo_url.strip("/").split("/")
+            owner = parts[-2]
+            repo_name = parts[-1].replace(".git", "")
+        except IndexError:
+            raise ValueError(
+                "Invalid repository URL format. Expected format: https://github.com/owner/repo"
+            )
+
+        print(f"   [MCP] Fetching file tree for {owner}/{repo_name} at {commit_sha}...")
+        tree_result = self._send_request(
+            method="git.get_repository_tree",
+            params={"owner": owner, "repo": repo_name, "tree_sha": commit_sha, "recursive": True},
+        )
+
+        tree = tree_result.get("tree", [])
+        if not tree:
+            raise RuntimeError("Could not retrieve repository file tree.")
+
+        temp_dir = tempfile.mkdtemp(prefix=f"xenfra_{repo_name}_")
+        print(f"   [MCP] Downloading to temporary directory: {temp_dir}")
+
+        for item in tree:
+            item_path = item.get("path")
+            item_type = item.get("type")
+
+            if not item_path or item_type != "blob":  # Only handle files
+                continue
+
+            # For downloading content, we can use the commit_sha in the 'ref' parameter
+            # to ensure we get the content from the correct version.
+            content_result = self._send_request(
+                method="repos.get_file_contents",
+                params={"owner": owner, "repo": repo_name, "path": item_path, "ref": commit_sha},
+            )
+
+            content_b64 = content_result.get("content")
+            if content_b64 is None:
+                print(f"   [MCP] [Warning] Could not get content for {item_path}")
+                continue
+
+            try:
+                # Content is base64 encoded, with newlines.
+                decoded_content = base64.b64decode(content_b64.replace("\n", ""))
+            except (base64.binascii.Error, TypeError):
+                print(f"   [MCP] [Warning] Could not decode content for {item_path}")
+                continue
+
+            # Create file and parent directories in the temp location
+            local_file_path = Path(temp_dir) / item_path
+            local_file_path.parent.mkdir(parents=True, exist_ok=True)
+
+            # Write the file content
+            with open(local_file_path, "wb") as f:
+                f.write(decoded_content)
+
+        print("   [MCP] ✅ Repository download complete.")
+        return temp_dir
+
+    def __enter__(self):
+        self._start_server()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self._stop_server()