xenfra 0.4.4__py3-none-any.whl → 0.4.5__py3-none-any.whl

xenfra/blueprints/validation.py

@@ -0,0 +1,182 @@
+"""
+Tier 1: Local validation - Fast syntax and import checking.
+
+This module provides lightning-fast (~100ms) validation of project files
+before any expensive operations. It checks:
+- Python syntax errors
+- Import errors (missing dependencies)
+- Config file validity
+- Basic project structure
+"""
+
+import ast
+import json
+import sys
+from pathlib import Path
+from typing import Optional
+from dataclasses import dataclass, field
+
+
+@dataclass
+class ValidationResult:
+    """Result of Tier 1 validation."""
+    success: bool
+    errors: list[str] = field(default_factory=list)
+    warnings: list[str] = field(default_factory=list)
+    
+    def add_error(self, message: str):
+        self.errors.append(message)
+        self.success = False
+    
+    def add_warning(self, message: str):
+        self.warnings.append(message)
+
+
+class LocalValidator:
+    """Fast local validation for common project issues."""
+    
+    def validate(self, project_path: Path) -> ValidationResult:
+        """
+        Run all Tier 1 validations.
+        
+        Args:
+            project_path: Path to the project directory
+            
+        Returns:
+            ValidationResult with any errors or warnings
+        """
+        result = ValidationResult(success=True)
+        
+        # Check Python files for syntax errors
+        self._validate_python_syntax(project_path, result)
+        
+        # Validate config files
+        self._validate_configs(project_path, result)
+        
+        # Check for required files
+        self._validate_required_files(project_path, result)
+        
+        return result
+    
+    def _validate_python_syntax(self, project_path: Path, result: ValidationResult):
+        """Check all Python files for syntax errors."""
+        python_files = list(project_path.rglob("*.py"))
+        
+        for py_file in python_files:
+            # Skip common virtual environment directories
+            if any(part.startswith(".") or part in ["venv", ".venv", "env", ".env", "__pycache__"] 
+                   for part in py_file.parts):
+                continue
+            
+            try:
+                content = py_file.read_text(encoding="utf-8")
+                ast.parse(content)
+            except SyntaxError as e:
+                result.add_error(
+                    f"Syntax error in {py_file.relative_to(project_path)}:{e.lineno}: {e.msg}"
+                )
+            except UnicodeDecodeError:
+                result.add_warning(f"Could not read {py_file.relative_to(project_path)} (encoding issue)")
+    
+    def _validate_configs(self, project_path: Path, result: ValidationResult):
+        """Validate configuration files."""
+        # requirements.txt - check format
+        req_file = project_path / "requirements.txt"
+        if req_file.exists():
+            try:
+                content = req_file.read_text(encoding="utf-8")
+                for line_num, line in enumerate(content.split("\n"), 1):
+                    line = line.strip()
+                    if not line or line.startswith("#"):
+                        continue
+                    # Basic format check
+                    if ";" in line and "sys_platform" not in line and "python_version" not in line:
+                        # Might be an error, but could also be valid
+                        pass
+            except Exception as e:
+                result.add_error(f"Error reading requirements.txt: {e}")
+        
+        # package.json - validate JSON
+        pkg_file = project_path / "package.json"
+        if pkg_file.exists():
+            try:
+                content = pkg_file.read_text(encoding="utf-8")
+                json.loads(content)
+            except json.JSONDecodeError as e:
+                result.add_error(f"Invalid package.json: {e}")
+        
+        # pyproject.toml - basic check
+        pyproject = project_path / "pyproject.toml"
+        if pyproject.exists():
+            try:
+                import tomllib
+                content = pyproject.read_bytes()
+                tomllib.loads(content.decode("utf-8"))
+            except ImportError:
+                # Python < 3.11, try toml library
+                try:
+                    import toml
+                    toml.load(pyproject)
+                except ImportError:
+                    pass  # Skip if no toml library
+                except Exception as e:
+                    result.add_error(f"Invalid pyproject.toml: {e}")
+            except Exception as e:
+                result.add_error(f"Invalid pyproject.toml: {e}")
+    
+    def _validate_required_files(self, project_path: Path, result: ValidationResult):
+        """Check for required files based on detected project type."""
+        # Detect project type
+        has_requirements = (project_path / "requirements.txt").exists()
+        has_pyproject = (project_path / "pyproject.toml").exists()
+        has_package_json = (project_path / "package.json").exists()
+        has_go_mod = (project_path / "go.mod").exists()
+        has_cargo = (project_path / "Cargo.toml").exists()
+        
+        # Check for main entry point (Python)
+        if has_requirements or has_pyproject:
+            main_files = [
+                project_path / "main.py",
+                project_path / "app.py",
+                project_path / "manage.py",  # Django
+            ]
+            app_dirs = [
+                project_path / "app",
+                project_path / project_path.name.lower().replace("-", "_").replace(" ", "_"),
+            ]
+            
+            if not any(f.exists() for f in main_files):
+                # Check if there's a package directory with __main__.py or similar
+                has_entry = False
+                for app_dir in app_dirs:
+                    if app_dir.is_dir():
+                        if (app_dir / "__main__.py").exists() or (app_dir / "main.py").exists():
+                            has_entry = True
+                            break
+                
+                if not has_entry:
+                    result.add_warning(
+                        "No clear Python entry point found (main.py, app.py, or package/__main__.py)"
+                    )
+        
+        # Check for main entry point (Node.js)
+        if has_package_json:
+            pkg_json = json.loads((project_path / "package.json").read_text())
+            if "main" not in pkg_json and "start" not in str(pkg_json.get("scripts", {})):
+                result.add_warning(
+                    "No 'main' field or 'start' script found in package.json"
+                )
+
+
+def validate_project(project_path: Path) -> ValidationResult:
+    """
+    Convenience function for Tier 1 validation.
+    
+    Args:
+        project_path: Path to the project directory
+        
+    Returns:
+        ValidationResult with errors and warnings
+    """
+    validator = LocalValidator()
+    return validator.validate(project_path)

xenfra/commands/deployments.py

@@ -3,6 +3,7 @@ Deployment commands for Xenfra CLI.
 """
 
 import os
+from pathlib import Path
 
 import click
 from rich.console import Console
@@ -15,6 +16,7 @@ from xenfra_sdk.privacy import scrub_logs
 from ..utils.auth import API_BASE_URL, get_auth_token
 from ..utils.codebase import has_xenfra_config
 from ..utils.config import apply_patch, read_xenfra_yaml
+from ..blueprints import run_dry_run
 from ..utils.validation import (
     validate_branch_name,
     validate_deployment_id,
@@ -419,23 +421,47 @@ def delete(project_id, show_details):
 @click.option("--size", help="DigitalOcean size slug override")
 @click.option("--no-heal", is_flag=True, help="Disable auto-healing on failure")
 @click.option("--cleanup-on-failure", is_flag=True, help="Automatically cleanup resources if deployment fails")
-def deploy(project_name, git_repo, branch, framework, region, size, no_heal, cleanup_on_failure):
+@click.option("--force-sandbox", is_flag=True, help="Force full sandbox validation (Tier 3)")
+@click.option("--skip-sandbox", is_flag=True, help="Skip sandbox validation for faster iteration")
+def deploy(project_name, git_repo, branch, framework, region, size, no_heal, cleanup_on_failure, force_sandbox, skip_sandbox):
     """
-    Deploy current project to DigitalOcean with auto-healing.
+    Deploy current project to DigitalOcean with 3-tier dry-run validation.
 
+    Every deployment is validated before touching real infrastructure:
+
+    \b
+    [bold]Tier 1[/bold]: Local validation (~100ms) - Syntax, imports, config
+    [bold]Tier 2[/bold]: Railpack plan (~1-2s) - Build plan generation
+    [bold]Tier 3[/bold]: E2B Sandbox (~30-60s) - Full build validation (smart detection)
+
+    This "Dry Run First" architecture ensures deployments never fail due to
+    avoidable errors. Set E2B_API_KEY for full sandbox validation.
+
+    \b
     Deploys your application with zero configuration. The CLI will:
-    1. Check for xenfra.yaml (or run init if missing)
+    1. Run 3-tier dry-run validation
     2. Create a deployment
-    3. Auto-diagnose and fix failures (unless --no-heal is set or XENFRA_NO_AI=1)
-
-    Set XENFRA_NO_AI=1 environment variable to disable all AI features.
+    3. Auto-diagnose and fix failures (unless --no-heal is set)
+
+    Environment Variables:
+    - E2B_API_KEY: API key for sandbox validation
+    - XENFRA_AI=off: Disable AI features
+    - XENFRA_SANDBOX=force: Always run Tier 3
+    - XENFRA_SANDBOX=skip: Skip Tier 3 validation
+    - XENFRA_SANDBOX=auto: Smart detection (default)
     """
-    # Check XENFRA_NO_AI environment variable
-    no_ai = os.environ.get("XENFRA_NO_AI", "0") == "1"
+    # Check XENFRA_AI environment variable
+    ai_mode = os.environ.get("XENFRA_AI", "on").lower()
+    no_ai = ai_mode == "off"
     if no_ai:
-        console.print("[yellow]XENFRA_NO_AI is set. Auto-healing disabled.[/yellow]")
+        console.print("[yellow]XENFRA_AI=off is set. Auto-healing disabled.[/yellow]")
         no_heal = True
 
+    # ==========================================
+    # 3-TIER DRY-RUN VALIDATION ("Dry Run First")
+    # ==========================================
+    project_path = Path(os.getcwd())
+
     # Check for xenfra.yaml
     if not has_xenfra_config():
         console.print("[yellow]No xenfra.yaml found.[/yellow]")
@@ -579,9 +605,134 @@ def deploy(project_name, git_repo, branch, framework, region, size, no_heal, cle
     # Retry loop for auto-healing
     attempt = 0
     deployment_id = None
-
+    
+    # Context manager for temp dir (if cloning)
+    import tempfile
+    import shutil
+    import subprocess
+    
+    temp_dir_obj = None
+    original_project_path = project_path
+    
     try:
         with get_client() as client:
+            from ..utils.file_sync import scan_project_files_cached, ensure_gitignore_ignored
+            
+            # --- 1. PREPARE SOURCE CODE ---
+            if git_repo:
+                console.print(f"[cyan]📥 Cloning {git_repo}...[/cyan]")
+                temp_dir_obj = tempfile.TemporaryDirectory()
+                temp_dir_path = Path(temp_dir_obj.name)
+                
+                try:
+                    # Shallow clone for speed
+                    cmd = ["git", "clone", "--depth", "1"]
+                    if branch:
+                        cmd.extend(["-b", branch])
+                    cmd.extend([git_repo, str(temp_dir_path)])
+                    
+                    subprocess.run(cmd, check=True, capture_output=True)
+                    project_path = temp_dir_path
+                    console.print("[green]✓ Repository cloned[/green]")
+                except subprocess.CalledProcessError as e:
+                    console.print(f"[bold red]Failed to clone repository: {e}[/bold red]")
+                    raise click.Abort()
+            else:
+                # Local directory
+                 # Protect privacy: ensure .xenfra is in .gitignore
+                if ensure_gitignore_ignored():
+                    console.print("[dim]   - Added .xenfra to .gitignore for privacy[/dim]")
+
+            # --- 2. SCAN FILES ---
+            console.print("[cyan]📁 Scanning project files...[/cyan]")
+            
+            # We need to temporarily change CWD for scan_project_files_cached to work if we cloned
+            # OR pass path to it. Assuming it scans CWD, we might need chdir
+            import os
+            cwd = os.getcwd()
+            try:
+                if project_path != Path(cwd):
+                    os.chdir(project_path)
+                file_manifest = scan_project_files_cached()
+            finally:
+                os.chdir(cwd)
+
+            console.print(f"[dim]Found {len(file_manifest)} files[/dim]")
+            
+            if not file_manifest:
+                console.print("[bold red]Error: No files found.[/bold red]")
+                raise click.Abort()
+
+            # --- 3. UPLOAD FILES (Required for Tier 3 & Deployment) ---
+            # Check which files need uploading
+            console.print("[cyan]🔍 Checking file cache...[/cyan]")
+            check_result = client.files.check(file_manifest)
+            missing = check_result.get('missing', [])
+            cached = check_result.get('cached', 0)
+            
+            if cached > 0:
+                console.print(f"[green]✓ {cached} files already cached on server[/green]")
+            
+            # Upload missing files
+            if missing:
+                console.print(f"[cyan]☁️ Uploading {len(missing)} files...[/cyan]")
+                # We need absolute paths for upload reading
+                # If we cloned, file_manifest paths are relative to temp_dir
+                # But upload_files needs to know where to read from.
+                # Let's patch file_manifest with abs_paths for the uploader
+                
+                upload_manifest = []
+                for f in file_manifest:
+                    f_copy = f.copy()
+                    f_copy["abs_path"] = str(project_path / f["path"])
+                    upload_manifest.append(f_copy)
+
+                uploaded = client.files.upload_files(
+                    upload_manifest,
+                    missing,
+                    progress_callback=lambda done, total: console.print(f"[dim]   Progress: {done}/{total}[/dim]") if done % 10 == 0 or done == total else None
+                )
+                console.print(f"[green]✓ Uploaded {uploaded} files[/green]")
+            else:
+                console.print("[green]✓ All files synced[/green]")
+            
+            # --- 4. RUN DRY RUN ---
+            console.print(Panel(
+                "[bold]🔍 Running 3-Tier Dry-Run Validation[/bold]\n"
+                "Tier 1: Local syntax check (~100ms)\n"
+                "Tier 2: Railpack build plan (~1-2s)\n"
+                "Tier 3: E2B sandbox via Xenfra API (smart detection)",
+                title="[bold cyan]Dry Run First Architecture[/bold cyan]",
+                border_style="cyan"
+            ))
+            
+            with console.status("[cyan]Running validation...[/cyan]"):
+                dry_run_result = run_dry_run(
+                    project_path,
+                    force_sandbox=force_sandbox, # or (force_sandbox or check_result['missing'])?
+                    skip_sandbox=skip_sandbox,
+                    api_client=client,
+                    file_manifest=file_manifest
+                )
+            
+            # Display results
+            console.print(dry_run_result.get_summary())
+            console.print()
+            
+            # Check if dry-run failed
+            if not dry_run_result.success:
+                console.print("[bold red]❌ Dry-run validation failed[/bold red]")
+                console.print("[yellow]Fix the errors above before deploying.[/yellow]")
+                console.print()
+                console.print("[dim]Tip: Run with --skip-sandbox to skip Tier 3[/dim]")
+                raise click.Abort()
+            
+            console.print("[bold green]✅ Dry-run validation passed[/bold green]")
+            console.print()
+            
+            # Prepare manifest for API (remove local-only fields if any, strictly path/sha/size)
+            api_file_manifest = [{"path": f["path"], "sha": f["sha"], "size": f["size"]} for f in file_manifest]
+
             while attempt < MAX_RETRY_ATTEMPTS:
                 attempt += 1
 
@@ -594,75 +745,60 @@ def deploy(project_name, git_repo, branch, framework, region, size, no_heal, cle
 
                 # Detect framework if not provided (AI-powered Zen Mode)
                 if not framework:
-                    console.print("[cyan]🔍 AI Auto-detecting project type...[/cyan]")
-                    try:
-                        from ..utils.codebase import scan_codebase
-                        code_snippets = scan_codebase()
-                        if code_snippets:
-                            analysis = client.intelligence.analyze_codebase(code_snippets)
-                            framework = analysis.framework
-                            # Only use AI's is_dockerized if config didn't explicitly set it
-                            if not is_dockerized_from_config:
-                                is_dockerized = analysis.is_dockerized
-                            # Override port if AI detected it and config didn't set one
-                            if not port_from_config and analysis.port:
-                                port = analysis.port
-                            # Override port and size if AI has strong recommendations
-                            if not size and analysis.instance_size:
-                                size = "s-1vcpu-1gb" if analysis.instance_size == "basic" else "s-2vcpu-4gb"
-                            
-                            mode_str = "Docker" if is_dockerized else "Bare Metal"
-                            console.print(f"[green]✓ Detected {framework.upper()} project ({mode_str} Mode)[/green] (Port: {port})")
+                    if no_ai:
+                        # ... static logic existing ...
+                        console.print("[yellow]⚠ AI disabled. Using static detection...[/yellow]")
+                        # Simple static checks based on Tier 2 result potentially?
+                        if dry_run_result.tier2:
+                             framework = dry_run_result.tier2.framework
+                             port = dry_run_result.tier2.port
+                             is_dockerized = True
+                             console.print(f"[green]✓ Detected {framework.upper()} (from Dry Run)[/green]")
                         else:
-                            console.print("[yellow]⚠ No code files found for AI analysis. Defaulting to 'fastapi'[/yellow]")
-                            framework = "fastapi"
-                            is_dockerized = True
-                    except Exception as e:
-                        console.print(f"[yellow]⚠ AI detection failed: {e}. Defaulting to 'fastapi'[/yellow]")
-                        framework = "fastapi"
-                        is_dockerized = True
-
-                # Delta upload: if no git_repo, scan and upload local files
-                file_manifest = None
-                if not git_repo:
-                    from ..utils.file_sync import scan_project_files_cached, ensure_gitignore_ignored
-                    
-                    # Protect privacy: ensure .xenfra is in .gitignore
-                    if ensure_gitignore_ignored():
-                        console.print("[dim]   - Added .xenfra to .gitignore for privacy[/dim]")
-                    
-                    console.print("[cyan]📁 Scanning project files...[/cyan]")
-
-                    file_manifest = scan_project_files_cached()
-                    console.print(f"[dim]Found {len(file_manifest)} files[/dim]")
-                    
-                    if not file_manifest:
-                        console.print("[bold red]Error: No files found to deploy.[/bold red]")
-                        raise click.Abort()
-                    
-                    # Check which files need uploading
-                    console.print("[cyan]🔍 Checking file cache...[/cyan]")
-                    check_result = client.files.check(file_manifest)
-                    missing = check_result.get('missing', [])
-                    cached = check_result.get('cached', 0)
-                    
-                    if cached > 0:
-                        console.print(f"[green]✓ {cached} files already cached[/green]")
-                    
-                    # Upload missing files
-                    if missing:
-                        console.print(f"[cyan]☁️ Uploading {len(missing)} files...[/cyan]")
-                        uploaded = client.files.upload_files(
-                            file_manifest,
-                            missing,
-                            progress_callback=lambda done, total: console.print(f"[dim]   Progress: {done}/{total}[/dim]") if done % 10 == 0 or done == total else None
-                        )
-                        console.print(f"[green]✓ Uploaded {uploaded} files[/green]")
+                             framework = "fastapi"
+                             port = 8000
                     else:
-                        console.print("[green]✓ All files already cached[/green]")
-                    
-                    # Remove abs_path from manifest before sending to API
-                    file_manifest = [{"path": f["path"], "sha": f["sha"], "size": f["size"]} for f in file_manifest]
+                        # AI-powered detection
+                        # We can use Tier 2 result for speed instead of full AI scan if available
+                        if dry_run_result.tier2 and dry_run_result.tier2.framework != "unknown":
+                            framework = dry_run_result.tier2.framework
+                            # config overrides...
+                            if not is_dockerized_from_config:
+                                is_dockerized = True # Railpack is docker based
+                            if not port_from_config:
+                                port = dry_run_result.tier2.port
+                            console.print(f"[green]✓ Detected {framework.upper()} (from Railpack)[/green]")
+                        else:
+                             # Fallback to AI
+                             console.print("[cyan]🔍 AI Auto-detecting project type...[/cyan]")
+                             try:
+                                 # We need to scan code snippet from PROJECT_PATH (temp or local)
+                                 from ..utils.codebase import scan_codebase
+                                 # scan_codebase needs CWD to be correct
+                                 curr = os.getcwd()
+                                 os.chdir(project_path)
+                                 try:
+                                     code_snippets = scan_codebase()
+                                 finally:
+                                     os.chdir(curr)
+                                     
+                                 if code_snippets:
+                                     analysis = client.intelligence.analyze_codebase(code_snippets)
+                                     framework = analysis.framework
+                                     if not is_dockerized_from_config: is_dockerized = analysis.is_dockerized
+                                     if not port_from_config and analysis.port: port = analysis.port
+                                     if not size and analysis.instance_size: size = "s-1vcpu-1gb" if analysis.instance_size == "basic" else "s-2vcpu-4gb"
+                                     mode_str = "Docker" if is_dockerized else "Bare Metal"
+                                     console.print(f"[green]✓ Detected {framework.upper()} project ({mode_str} Mode)[/green] (Port: {port})")
+                                 else:
+                                     framework = "fastapi"
+                                     is_dockerized = True
+                             except Exception as e:
+                                 framework = "fastapi"
+                                 is_dockerized = True
+
+                # Delta upload was already done above!
+                # file_manifest is ready (api_file_manifest)
 
                 # Create deployment with real-time streaming
                 try:
@@ -681,7 +817,7 @@ def deploy(project_name, git_repo, branch, framework, region, size, no_heal, cle
                         database=database,
                         package_manager=package_manager,
                         dependency_file=dependency_file,
-                        file_manifest=file_manifest,
+                        file_manifest=api_file_manifest,
                         cleanup_on_failure=cleanup_on_failure,
                         services=services,  # Microservices support
                         mode=mode,  # Deployment mode
@@ -1131,3 +1267,92 @@ def report(deployment_id, output_format):
         pass
     except Exception as e:
         console.print(f"[bold red]Unexpected error: {e}[/bold red]")
+
+
+
+@click.command(name="dry-run")
+@click.option("--force-sandbox", is_flag=True, help="Force full sandbox validation (Tier 3)")
+@click.option("--skip-sandbox", is_flag=True, help="Skip sandbox validation for faster iteration")
+@click.option("--verbose", "-v", is_flag=True, help="Show detailed output")
+def dry_run_command(force_sandbox, skip_sandbox, verbose):
+    """
+    Run 3-tier dry-run validation without deploying.
+
+    Validates your project through all three tiers without
+    actually deploying to infrastructure:
+
+    \b
+    [bold]Tier 1[/bold]: Local validation - Syntax, imports, config files
+    [bold]Tier 2[/bold]: Railpack plan - Generate build plan
+    [bold]Tier 3[/bold]: E2B Sandbox - Full build validation via Xenfra API
+
+    This is useful for:
+    - Validating changes before deploying
+    - CI/CD pipelines
+    - Checking for syntax errors quickly
+
+    Tier 3 runs on Xenfra's servers - no local setup needed.
+    """
+    from pathlib import Path
+    from ..blueprints import run_dry_run
+    from ..utils.file_sync import scan_project_files_cached, ensure_gitignore_ignored
+    
+    project_path = Path(os.getcwd())
+    
+    # Get authenticated client for Tier 3 sandbox
+    try:
+        client = get_client()
+    except click.Abort:
+        return
+    
+    # Scan project files
+    if ensure_gitignore_ignored():
+        console.print("[dim]   - Added .xenfra to .gitignore for privacy[/dim]")
+    
+    console.print("[cyan]📁 Scanning project files...[/cyan]")
+    file_manifest = scan_project_files_cached()
+    console.print(f"[dim]Found {len(file_manifest)} files[/dim]")
+    
+    if not file_manifest:
+        console.print("[bold red]Error: No files found to validate.[/bold red]")
+        raise click.Abort()
+    
+    console.print(Panel(
+        "[bold]🔍 Running 3-Tier Dry-Run Validation[/bold]\n"
+        "Validating your project without deploying...",
+        title="[bold cyan]Dry Run[/bold cyan]",
+        border_style="cyan"
+    ))
+    
+    # Run dry-run
+    with console.status("[cyan]Running validation...[/cyan]"):
+        result = run_dry_run(
+            project_path,
+            force_sandbox=force_sandbox,
+            skip_sandbox=skip_sandbox,
+            api_client=client,
+            file_manifest=file_manifest
+        )
+    
+    # Display results
+    console.print(result.get_summary())
+    console.print()
+    
+    # Detailed output if verbose
+    if verbose and result.tier2:
+        console.print("[bold]Build Plan Details:[/bold]")
+        console.print(f"  Framework: {result.tier2.framework}")
+        console.print(f"  Language: {result.tier2.language}")
+        console.print(f"  Package Manager: {result.tier2.package_manager}")
+        console.print(f"  Port: {result.tier2.port}")
+        if result.tier2.start_command:
+            console.print(f"  Start Command: {result.tier2.start_command}")
+        console.print()
+    
+    # Final status
+    if result.success:
+        console.print("[bold green]✅ All validations passed - Ready to deploy![/bold green]")
+        console.print("[dim]Run 'xenfra deploy' to deploy to infrastructure.[/dim]")
+    else:
+        console.print("[bold red]❌ Validation failed - Fix errors before deploying[/bold red]")
+        raise click.Abort()

xenfra/commands/intelligence.py

@@ -87,7 +87,7 @@ def init(manual, accept_all):
     For microservices projects (multiple services), generates xenfra-services.yaml.
 
     Use --manual to skip AI and configure interactively.
-    Set XENFRA_NO_AI=1 environment variable to force manual mode globally.
+    Set XENFRA_AI=off environment variable to force manual mode globally.
     """
     # Check if config already exists
     if has_xenfra_config():
@@ -148,10 +148,10 @@ def init(manual, accept_all):
         console.print(f"[dim]Note: Microservices detection skipped: {e}[/dim]\n")
 
 
-    # Check for XENFRA_NO_AI environment variable
-    no_ai = os.environ.get("XENFRA_NO_AI", "0") == "1"
-    if no_ai and not manual:
-        console.print("[yellow]XENFRA_NO_AI is set. Using manual mode.[/yellow]")
+    # Check for XENFRA_AI environment variable
+    ai_mode = os.environ.get("XENFRA_AI", "on").lower()
+    if ai_mode == "off" and not manual:
+        console.print("[yellow]XENFRA_AI=off is set. Using manual mode.[/yellow]")
         manual = True
 
     # Manual mode - interactive prompts

xenfra/main.py

@@ -10,7 +10,7 @@ import click
 from rich.console import Console
 
 from .commands.auth import auth
-from .commands.deployments import delete, deploy, logs, report, status
+from .commands.deployments import delete, deploy, dry_run_command, logs, report, status
 from .commands.intelligence import analyze, diagnose, init
 from .commands.projects import projects
 from .commands.security_cmd import security
@@ -30,12 +30,14 @@ def cli():
     Quick Start:
       xenfra auth login     # Authenticate with Xenfra
       xenfra init           # Initialize your project (AI-powered)
+      xenfra dry-run        # Validate before deploying (3-tier)
       xenfra deploy         # Deploy to DigitalOcean
 
     Commands:
       auth        Authentication (login, logout, whoami)
       projects    Manage projects (list, show, delete)
       init        Smart project initialization (AI-powered)
+      dry-run     Validate project without deploying (3-tier)
       diagnose    Diagnose deployment failures (AI-powered)
       analyze     Analyze codebase without creating config
 
@@ -61,6 +63,7 @@ cli.add_command(analyze)
 
 # Register deployment commands at root level
 cli.add_command(deploy)
+cli.add_command(dry_run_command)
 cli.add_command(status)
 cli.add_command(logs)
 cli.add_command(report)