xenfra-sdk 0.2.5__py3-none-any.whl → 0.2.6__py3-none-any.whl

xenfra_sdk/manifest.py

@@ -1,42 +1,52 @@
-"""
-Xenfra Microservices Manifest - Schema and Parser for xenfra.yaml services array.
+from pathlib import Path
+from typing import List, Literal, Optional, Dict, Any
 
-This module defines the Pydantic models for microservices deployment configuration.
-For microservices projects, xenfra.yaml includes a 'services' array:
+import yaml
+from pydantic import BaseModel, Field, field_validator, ConfigDict
 
-  project_name: my-app
-  framework: fastapi
-  services:   # <-- This makes it a microservices project
-    - name: users
-      port: 8001
-    - name: orders
-      port: 8002
-"""
+from xenfra_sdk.constants import DEFAULT_REGION, DEFAULT_SIZE, DEFAULT_OS
 
-from pathlib import Path
-from typing import List, Literal, Optional
 
-import yaml
-from pydantic import BaseModel, Field, field_validator
+class ProviderConfig(BaseModel):
+    """Configuration for cloud providers (currently DigitalOcean)."""
+    region: str = Field(default=DEFAULT_REGION)
+    size: str = Field(default=DEFAULT_SIZE)
+    image: str = Field(default=DEFAULT_OS)
+
+
+class InfrastructureService(BaseModel):
+    """Managed infrastructure dependency (e.g., PostgreSQL, Kafka)."""
+    type: Literal["postgres", "kafka", "redis", "mongodb"]
+    name: str
+    version: Optional[str] = None
+    env_vars: Dict[str, str] = Field(default_factory=dict)
 
 
 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
     """
+    model_config = ConfigDict(extra="ignore")
     
     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(
+    framework: Literal[
+        # Python
+        "fastapi", "flask", "django", "python",
+        # Node.js
+        "nodejs", "nextjs", "react", "express", "nestjs",
+        # Go
+        "go", "gin", "echo",
+        # AI Agents
+        "langgraph", "crewai", "mcp",
+        # Other languages
+        "rust", "ruby", "rails", "php", "java",
+        # Alternative runtimes
+        "bun", "deno",
+        # Custom
+        "static", "docker", "other"
+    ] = Field(
         default="fastapi", description="Web framework"
     )
     entrypoint: Optional[str] = Field(
@@ -45,17 +55,14 @@ class ServiceDefinition(BaseModel):
     command: Optional[str] = Field(
         default=None, description="Custom start command"
     )
-    env: Optional[dict] = Field(
+    env: Dict[str, str] = Field(
         default_factory=dict, description="Environment variables"
     )
     package_manager: Optional[str] = Field(
-        default="pip", description="Package manager (pip, uv)"
+        default="pip", description="Package manager (pip, uv, poetry, pipenv, npm, yarn, pnpm, bun, cargo, go, bundler, composer, maven, gradle)"
     )
     dependency_file: Optional[str] = Field(
-        default="requirements.txt", description="Dependency file"
-    )
-    missing_deps: List[str] = Field(
-        default_factory=list, description="Proactively detected missing dependencies"
+        default=None, description="Dependency file"
     )
     
     @field_validator("name")
@@ -71,97 +78,69 @@ class ServiceDefinition(BaseModel):
         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
+class XenfraConfig(BaseModel):
+    """The root configuration model for xenfra.yaml."""
+    model_config = ConfigDict(extra="ignore")
 
+    name: str = Field(..., min_length=1, description="Project identity")
+    digitalocean: ProviderConfig = Field(default_factory=ProviderConfig)
+    infrastructure: List[InfrastructureService] = Field(default_factory=list)
+    services: List[ServiceDefinition] = Field(default_factory=list)
+    mode: Literal["single-droplet", "multi-droplet"] = Field(default="single-droplet")
 
-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
+    @field_validator("services")
+    @classmethod
+    def validate_unique_services(cls, services: List[ServiceDefinition]) -> List[ServiceDefinition]:
+        """Ensure all service names and ports are unique."""
+        names = [s.name for s in services]
+        if len(names) != len(set(names)):
+            raise ValueError(f"Duplicate service names detected: {set([n for n in names if names.count(n) > 1])}")
+        
+        ports = [s.port for s in services]
+        if len(ports) != len(set(ports)):
+            raise ValueError(f"Duplicate service ports detected: {set([p for p in ports if ports.count(p) > 1])}")
+            
+        return services
 
+    def to_yaml(self, path: Path):
+        """Write the config to a YAML file."""
+        data = self.model_dump(exclude_none=True)
+        with open(path, "w", encoding="utf-8") as f:
+            yaml.dump(data, f, default_flow_style=False, sort_keys=False)
 
-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
-    """
+
+def load_xenfra_config(project_path: str = ".") -> Optional[XenfraConfig]:
+    """Load and validate the entire xenfra.yaml config."""
     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}")
+            if not data:
+                return None
+            return XenfraConfig(**data)
+        except (yaml.YAMLError, Exception) as e:
+            raise ValueError(f"Invalid xenfra.yaml: {e}")
+
+
+# Legacy helper for backwards compatibility
+def load_services_from_xenfra_yaml(project_path: str = ".") -> Optional[List[ServiceDefinition]]:
+    config = load_xenfra_config(project_path)
+    return config.services if config else None
 
 
 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
+    """Check if project has multiple services defined in xenfra.yaml."""
+    config = load_xenfra_config(project_path)
+    return config is not None and len(config.services) > 1
 
 
 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
+    """Get deployment mode from xenfra.yaml."""
+    config = load_xenfra_config(project_path)
+    return config.mode if config else None
 
 
 def add_services_to_xenfra_yaml(
@@ -169,44 +148,20 @@ def add_services_to_xenfra_yaml(
     services: List[dict],
     mode: str = "single-droplet"
 ) -> Path:
-    """
-    Add or update services array in existing xenfra.yaml.
+    """Add or update services array in existing xenfra.yaml."""
+    config = load_xenfra_config(project_path)
+    if not config:
+        # Create new config if missing
+        config = XenfraConfig(name=Path(project_path).name, mode=mode)
     
-    Args:
-        project_path: Path to the project directory
-        services: List of service dictionaries from auto-detection
-        mode: Deployment mode
+    config.services = [ServiceDefinition(**svc) for svc in services]
+    config.mode = 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)
-    
+    config.to_yaml(yaml_path)
     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
-    """
+    """Create ServiceDefinition list from detected services."""
     return [ServiceDefinition(**svc) for svc in services]

xenfra_sdk/mcp_client.py

@@ -7,6 +7,8 @@ import subprocess
 import tempfile
 from pathlib import Path
 
+from xenfra_sdk.privacy import scrubbed_print
+
 
 class MCPClient:
     """
@@ -96,7 +98,7 @@ class MCPClient:
                 "Invalid repository URL format. Expected format: https://github.com/owner/repo"
             )
 
-        print(f"   [MCP] Fetching file tree for {owner}/{repo_name} at {commit_sha}...")
+        scrubbed_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},
@@ -107,7 +109,7 @@ class MCPClient:
             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}")
+        scrubbed_print(f"   [MCP] Downloading to temporary directory: {temp_dir}")
 
         for item in tree:
             item_path = item.get("path")
@@ -125,14 +127,14 @@ class MCPClient:
 
             content_b64 = content_result.get("content")
             if content_b64 is None:
-                print(f"   [MCP] [Warning] Could not get content for {item_path}")
+                scrubbed_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}")
+                scrubbed_print(f"   [MCP] [Warning] Could not decode content for {item_path}")
                 continue
 
             # Create file and parent directories in the temp location
@@ -143,7 +145,7 @@ class MCPClient:
             with open(local_file_path, "wb") as f:
                 f.write(decoded_content)
 
-        print("   [MCP] ✅ Repository download complete.")
+        scrubbed_print("   [MCP] ✅ Repository download complete.")
         return temp_dir
 
     def __enter__(self):

xenfra_sdk/{models.py → models/__init__.py}

@@ -4,7 +4,7 @@ These models are used for data validation, serialization, and providing clear sc
 for external tools like OpenAI function calling.
 """
 
-from datetime import datetime
+from datetime import datetime, timezone
 from enum import Enum
 
 from pydantic import BaseModel, Field
@@ -39,6 +39,9 @@ class Deployment(BaseModel):
     projectId: str = Field(..., description="Identifier of the project being deployed")
     status: DeploymentStatus = Field(..., description="Current status of the deployment")
     source: str = Field(..., description="Source of the deployment (e.g., 'cli', 'api')")
+    mode: str = Field("monolithic", description="Deployment mode: monolithic or microservices")
+    services_json: str | None = Field(None, description="JSON string describing microservices (if mode is microservices)")
+    is_dockerized: bool = Field(True, description="Whether the deployment is dockerized")
     created_at: datetime = Field(..., description="Timestamp when the deployment was created")
     finished_at: datetime | None = Field(None, description="Timestamp when the deployment finished")
 
@@ -115,6 +118,19 @@ class ProjectRead(BaseModel):
         None, description="The estimated monthly cost of the project's infrastructure in USD."
     )
     created_at: datetime = Field(..., description="The timestamp when the project was created.")
+    user_id: int = Field(..., description="The ID of the user who owns the project.")
+
+
+class ActivityLog(BaseModel):
+    """
+    Represents a user activity log entry.
+    """
+
+    id: int | None = Field(None, description="Unique identifier for the log entry")
+    user_id: int = Field(..., description="The ID of the user associated with the activity")
+    action: str = Field(..., description="The action performed (e.g., 'Deployment Successful')")
+    details: str = Field(..., description="Detailed description of the action")
+    timestamp: datetime = Field(default_factory=lambda: datetime.now(timezone.utc), description="When the activity occurred")
 
 
 # Intelligence Service Models

xenfra_sdk/models/context.py

@@ -0,0 +1,61 @@
+"""
+Deployment Context Models - Type-safe configuration for the Xenfra Engine.
+Follows XENFRA_PROTOCOL.md by ensuring all data structures are Pydantic models.
+"""
+
+from typing import Dict, List, Optional, Any
+from pydantic import BaseModel, Field, ConfigDict
+from xenfra_sdk.constants import DEFAULT_PORT_RANGE_START, DEFAULT_REGION, DEFAULT_SIZE, DEFAULT_OS
+
+
+class DeploymentContext(BaseModel):
+    """
+    Unified context for a single project or service deployment.
+    This model serves as the source of truth for all template rendering and 
+    infrastructure provisioning.
+    """
+    model_config = ConfigDict(extra="ignore")
+
+    # Project Identity
+    project_name: str = Field(..., description="Name of the project")
+    email: str = Field(..., description="User email for SSL/Caddy")
+    
+    # Infrastructure (Single Droplet Defaults)
+    region: str = Field(default=DEFAULT_REGION)
+    size: str = Field(default=DEFAULT_SIZE)
+    image: str = Field(default=DEFAULT_OS)
+    
+    # Application Specification
+    framework: str = Field(..., description="Web framework (fastapi, flask, django, etc.)")
+    port: int = Field(default=DEFAULT_PORT_RANGE_START)
+    entrypoint: Optional[str] = Field(None, description="App entrypoint (e.g. main:app)")
+    python_version: str = Field(default="3.11-slim")
+    
+    # Deployment Strategy
+    is_dockerized: bool = Field(default=True)
+    branch: str = Field(default="main")
+    source_type: str = Field(default="local") # local or git
+    
+    # Environment & Secrets (Scrubbed by default)
+    env_vars: Dict[str, str] = Field(default_factory=dict)
+    
+    # Infrastructure Flags
+    include_postgres: bool = Field(default=False)
+    include_redis: bool = Field(default=False)
+    include_kafka: bool = Field(default=False)
+    
+    # Resource Governance
+    tier: str = Field(default="FREE")
+    cpu_limit: Optional[float] = None
+    memory_limit: Optional[str] = None
+    
+    # Internal Metadata
+    phase_logs: List[str] = Field(default_factory=list)
+    file_manifest: List[Dict[str, Any]] = Field(default_factory=list)
+    source_path: Optional[str] = None
+    repo_path: Optional[str] = None
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "DeploymentContext":
+        """Backwards compatibility helper to convert legacy dicts."""
+        return cls(**data)