xenfra 0.4.4__tar.gz → 0.4.5__tar.gz

{xenfra-0.4.4 → xenfra-0.4.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: xenfra
-Version: 0.4.4
+Version: 0.4.5
 Summary: Xenfra CLI: Hands for AI to deploy on DigitalOcean.
 Author: xenfra-cloud
 Author-email: xenfra-cloud <xenfracloud@gmail.com>

{xenfra-0.4.4 → xenfra-0.4.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "xenfra"
-version = "0.4.4"
+version = "0.4.5"
 description = "Xenfra CLI: Hands for AI to deploy on DigitalOcean."
 readme = "README.md"
 authors = [
@@ -17,6 +17,8 @@ classifiers = [
     "Topic :: System :: Systems Administration",
 ]
 
+requires-python = ">=3.11"
+
 dependencies = [
     "click>=8.1.7",
     "rich>=14.2.0",
@@ -33,12 +35,6 @@ dependencies = [
     "cryptography>=43.0.0", # For encrypted file-based token storage
     "toml>=0.10.2",
 ]
-requires-python = ">=3.11"
-
-
-[project.urls]
-Homepage = "https://github.com/xenfra-cloud/xenfra-cli"
-Issues = "https://github.com/xenfra-cloud/xenfra-cli/issues"
 
 [project.optional-dependencies]
 test = [
@@ -46,6 +42,10 @@ test = [
     "pytest-mock>=3.12.0",
 ]
 
+[project.urls]
+Homepage = "https://github.com/xenfra-cloud/xenfra-cli"
+Issues = "https://github.com/xenfra-cloud/xenfra-cli/issues"
+
 [project.scripts]
 xenfra = "xenfra.main:main"
 

xenfra-0.4.5/src/xenfra/blueprints/__init__.py

@@ -0,0 +1,55 @@
+"""
+Blueprint factory for framework detection and build plan generation.
+
+Implements Railpack-first routing with 3-tier dry-run validation:
+- Tier 1: Local validation (~100ms) - Syntax, imports, config
+- Tier 2: Railpack plan (~1-2s) - Build plan generation  
+- Tier 3: E2B Sandbox (~30-60s) - Full build validation via Xenfra API
+
+Tier 3 runs on Xenfra's servers - users don't need E2B installed.
+
+Environment Variables:
+- XENFRA_AI=off: Disable all AI features
+- XENFRA_SANDBOX=force: Always run Tier 3 validation
+- XENFRA_SANDBOX=skip: Skip Tier 3 validation  
+- XENFRA_SANDBOX=auto: Smart detection (default)
+"""
+
+from .base import Blueprint, BuildPlan
+from .factory import BlueprintFactory, get_factory, detect_project
+from .railpack import RailpackBlueprint
+from .dry_run import (
+    DryRunEngine,
+    DryRunResult,
+    run_dry_run,
+    quick_validate,
+)
+from .validation import ValidationResult, validate_project
+from .e2b import E2BSandbox, SandboxResult, get_sandbox
+
+__all__ = [
+    # Base classes
+    "Blueprint",
+    "BuildPlan",
+    
+    # Factory
+    "BlueprintFactory",
+    "get_factory",
+    "detect_project",
+    "RailpackBlueprint",
+    
+    # 3-Tier Dry Run
+    "DryRunEngine",
+    "DryRunResult",
+    "run_dry_run",
+    "quick_validate",
+    
+    # Tier 1
+    "ValidationResult",
+    "validate_project",
+    
+    # Tier 3
+    "E2BSandbox",
+    "SandboxResult",
+    "get_sandbox",
+]

xenfra-0.4.5/src/xenfra/blueprints/base.py

@@ -0,0 +1,85 @@
+"""
+Base blueprint interface for build plan generation.
+"""
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from typing import Optional
+from pathlib import Path
+
+
+@dataclass
+class BuildPlan:
+    """A build plan containing all information needed to build and deploy."""
+    
+    framework: str
+    language: str
+    package_manager: str
+    dependency_file: str
+    build_command: Optional[str] = None
+    start_command: Optional[str] = None
+    port: int = 8000
+    dockerfile: Optional[str] = None
+    env_vars: dict = field(default_factory=dict)
+    detected_from: str = "unknown"  # How the framework was detected
+    
+    def to_dict(self) -> dict:
+        """Convert build plan to dictionary."""
+        return {
+            "framework": self.framework,
+            "language": self.language,
+            "package_manager": self.package_manager,
+            "dependency_file": self.dependency_file,
+            "build_command": self.build_command,
+            "start_command": self.start_command,
+            "port": self.port,
+            "dockerfile": self.dockerfile,
+            "env_vars": self.env_vars,
+            "detected_from": self.detected_from,
+        }
+
+
+class Blueprint(ABC):
+    """
+    Abstract base class for deployment blueprints.
+    
+    Blueprints analyze project structure and generate build plans.
+    """
+    
+    name: str = "base"
+    languages: list[str] = []
+    
+    @abstractmethod
+    def detect(self, project_path: Path) -> bool:
+        """
+        Detect if this blueprint applies to the given project.
+        
+        Args:
+            project_path: Path to the project directory
+            
+        Returns:
+            True if this blueprint can handle the project
+        """
+        pass
+    
+    @abstractmethod
+    def generate_plan(self, project_path: Path) -> BuildPlan:
+        """
+        Generate a build plan for the project.
+        
+        Args:
+            project_path: Path to the project directory
+            
+        Returns:
+            BuildPlan with all build/deployment information
+        """
+        pass
+    
+    def get_priority(self) -> int:
+        """
+        Get the priority of this blueprint (higher = tried first).
+        
+        Returns:
+            Priority integer
+        """
+        return 100

xenfra-0.4.5/src/xenfra/blueprints/cache.py

@@ -0,0 +1,286 @@
+"""
+Smart detection and caching for Tier 3 validation decisions.
+
+Tracks build state to determine when full sandbox validation is needed.
+"""
+
+import hashlib
+import json
+import os
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+from dataclasses import dataclass, asdict
+
+
+@dataclass
+class BuildState:
+    """Cached state of a successful build."""
+    project_name: str
+    framework: str
+    language: str
+    dependency_hash: str
+    config_hash: str
+    build_plan_hash: str
+    status: str  # "success" or "failed"
+    timestamp: str
+    
+    def to_dict(self) -> dict:
+        return asdict(self)
+    
+    @classmethod
+    def from_dict(cls, data: dict) -> "BuildState":
+        return cls(**data)
+
+
+class BuildCache:
+    """
+    Manages build state cache for smart detection.
+    
+    Stores hashes of key files to detect changes that would
+    require re-validation in the sandbox.
+    """
+    
+    CACHE_DIR_NAME = ".xenfra"
+    CACHE_FILE_NAME = "build_state.json"
+    
+    def __init__(self, project_path: Path):
+        self.project_path = project_path
+        self.cache_dir = project_path / self.CACHE_DIR_NAME
+        self.cache_file = self.cache_dir / self.CACHE_FILE_NAME
+    
+    def get_cached_state(self) -> Optional[BuildState]:
+        """
+        Get the cached build state if it exists.
+        
+        Returns:
+            BuildState if cache exists, None otherwise
+        """
+        if not self.cache_file.exists():
+            return None
+        
+        try:
+            content = self.cache_file.read_text()
+            data = json.loads(content)
+            return BuildState.from_dict(data)
+        except (json.JSONDecodeError, KeyError, TypeError):
+            return None
+    
+    def save_state(self, state: BuildState):
+        """
+        Save the build state to cache.
+        
+        Args:
+            state: BuildState to cache
+        """
+        self.cache_dir.mkdir(exist_ok=True)
+        # Add to .gitignore if not already there
+        self._ensure_gitignore()
+        
+        self.cache_file.write_text(json.dumps(state.to_dict(), indent=2))
+    
+    def _ensure_gitignore(self):
+        """Ensure .xenfra is in .gitignore."""
+        gitignore = self.project_path / ".gitignore"
+        entry = ".xenfra/"
+        
+        if gitignore.exists():
+            content = gitignore.read_text()
+            if entry not in content:
+                with open(gitignore, "a") as f:
+                    f.write(f"\n{entry}\n")
+        else:
+            gitignore.write_text(f"{entry}\n")
+    
+    def compute_dependency_hash(self, plan: "BuildPlan") -> str:
+        """
+        Compute hash of dependency files.
+        
+        Args:
+            plan: BuildPlan with dependency information
+            
+        Returns:
+            Hash string of dependency files
+        """
+        hasher = hashlib.sha256()
+        
+        # Main dependency file
+        dep_file = self.project_path / plan.dependency_file
+        if dep_file.exists():
+            hasher.update(dep_file.read_bytes())
+        
+        # Lock files
+        lock_files = {
+            "python": ["poetry.lock", "uv.lock", "Pipfile.lock"],
+            "node": ["package-lock.json", "yarn.lock", "pnpm-lock.yaml", "bun.lockb"],
+            "go": ["go.sum"],
+            "rust": ["Cargo.lock"],
+            "ruby": ["Gemfile.lock"],
+        }
+        
+        for lock in lock_files.get(plan.language, []):
+            lock_path = self.project_path / lock
+            if lock_path.exists():
+                hasher.update(lock_path.read_bytes())
+        
+        return hasher.hexdigest()[:16]
+    
+    def compute_config_hash(self, plan: "BuildPlan") -> str:
+        """
+        Compute hash of configuration files.
+        
+        Args:
+            plan: BuildPlan with configuration information
+            
+        Returns:
+            Hash string of config files
+        """
+        hasher = hashlib.sha256()
+        
+        # xenfra.yaml
+        config_file = self.project_path / "xenfra.yaml"
+        if config_file.exists():
+            hasher.update(config_file.read_bytes())
+        
+        # Dockerfile
+        dockerfile = self.project_path / "Dockerfile"
+        if dockerfile.exists():
+            hasher.update(dockerfile.read_bytes())
+        
+        # Docker Compose
+        compose_files = ["docker-compose.yml", "docker-compose.yaml"]
+        for cf in compose_files:
+            cf_path = self.project_path / cf
+            if cf_path.exists():
+                hasher.update(cf_path.read_bytes())
+        
+        return hasher.hexdigest()[:16]
+    
+    def compute_build_plan_hash(self, plan: "BuildPlan") -> str:
+        """
+        Compute hash of the build plan itself.
+        
+        Args:
+            plan: BuildPlan to hash
+            
+        Returns:
+            Hash string of build plan
+        """
+        plan_dict = plan.to_dict()
+        plan_str = json.dumps(plan_dict, sort_keys=True)
+        return hashlib.sha256(plan_str.encode()).hexdigest()[:16]
+
+
+class SmartDetector:
+    """
+    Smart detection for Tier 3 (E2B) validation.
+    
+    Determines when full sandbox validation is needed based on
+    changes to dependencies, config, or previous build failures.
+    """
+    
+    def __init__(self, project_path: Path):
+        self.project_path = project_path
+        self.cache = BuildCache(project_path)
+    
+    def should_run_sandbox(
+        self, 
+        plan: "BuildPlan",
+        force: bool = False
+    ) -> tuple[bool, str]:
+        """
+        Determine if Tier 3 (E2B) validation should run.
+        
+        Args:
+            plan: BuildPlan for the project
+            force: If True, always run sandbox
+            
+        Returns:
+            Tuple of (should_run, reason)
+        """
+        if force:
+            return True, "Forced by --force flag"
+        
+        # Check for environment variable override
+        sandbox_mode = os.environ.get("XENFRA_SANDBOX", "auto").lower()
+        
+        if sandbox_mode == "force":
+            return True, "Forced by XENFRA_SANDBOX=force"
+        
+        if sandbox_mode == "skip":
+            return False, "Skipped by XENFRA_SANDBOX=skip"
+        
+        # Get cached state
+        cached = self.cache.get_cached_state()
+        if not cached:
+            return True, "First deployment - validation required"
+        
+        # Compute current hashes
+        current_dep_hash = self.cache.compute_dependency_hash(plan)
+        current_config_hash = self.cache.compute_config_hash(plan)
+        current_plan_hash = self.cache.compute_build_plan_hash(plan)
+        
+        # Check for failures
+        if cached.status == "failed":
+            return True, "Previous build failed - re-validation required"
+        
+        # Check for dependency changes
+        if current_dep_hash != cached.dependency_hash:
+            return True, "Dependencies changed - validation required"
+        
+        # Check for config changes
+        if current_config_hash != cached.config_hash:
+            return True, "Build configuration changed - validation required"
+        
+        # Check for framework changes
+        if plan.framework != cached.framework:
+            return True, "Framework changed - validation required"
+        
+        # Check for build plan changes
+        if current_plan_hash != cached.build_plan_hash:
+            return True, "Build plan changed - validation required"
+        
+        return False, "No significant changes - skipping sandbox"
+    
+    def record_success(self, plan: "BuildPlan"):
+        """
+        Record a successful build.
+        
+        Args:
+            plan: BuildPlan that succeeded
+        """
+        state = BuildState(
+            project_name=self.project_path.name,
+            framework=plan.framework,
+            language=plan.language,
+            dependency_hash=self.cache.compute_dependency_hash(plan),
+            config_hash=self.cache.compute_config_hash(plan),
+            build_plan_hash=self.cache.compute_build_plan_hash(plan),
+            status="success",
+            timestamp=datetime.utcnow().isoformat()
+        )
+        self.cache.save_state(state)
+    
+    def record_failure(self, plan: "BuildPlan"):
+        """
+        Record a failed build.
+        
+        Args:
+            plan: BuildPlan that failed
+        """
+        state = BuildState(
+            project_name=self.project_path.name,
+            framework=plan.framework,
+            language=plan.language,
+            dependency_hash=self.cache.compute_dependency_hash(plan),
+            config_hash=self.cache.compute_config_hash(plan),
+            build_plan_hash=self.cache.compute_build_plan_hash(plan),
+            status="failed",
+            timestamp=datetime.utcnow().isoformat()
+        )
+        self.cache.save_state(state)
+
+
+def get_detector(project_path: Path) -> SmartDetector:
+    """Get smart detector for a project."""
+    return SmartDetector(project_path)