xenfra 0.3.4__py3-none-any.whl → 0.3.6__py3-none-any.whl

xenfra/commands/deployments.py

@@ -167,13 +167,11 @@ def deploy(project_name, git_repo, branch, framework, no_heal):
             console.print(f"[bold red]Invalid git repository URL: {error_msg}[/bold red]")
             raise click.Abort()
         console.print(f"[cyan]Deploying {project_name} from git repository...[/cyan]")
+        console.print(f"[dim]Repository: {git_repo} (branch: {branch})[/dim]")
     else:
         console.print(f"[cyan]Deploying {project_name} from local directory...[/cyan]")
-        console.print(
-            "[yellow]Local deployment requires code upload (not yet fully implemented).[/yellow]"
-        )
-        console.print("[dim]Please use --git-repo for now.[/dim]")
-        return
+        console.print("[dim]Code will be uploaded to the droplet[/dim]")
+        # Note: SDK's InfraEngine handles local upload via fabric.transfer.Upload()
 
     # Validate branch name
     is_valid, error_msg = validate_branch_name(branch)
@@ -215,12 +213,26 @@ def deploy(project_name, git_repo, branch, framework, no_heal):
 
                 # Create deployment
                 try:
-                    deployment = client.deployments.create(
-                        project_name=project_name,
-                        git_repo=git_repo,
-                        branch=branch,
-                        framework=framework,
-                    )
+                    from rich.progress import Progress, SpinnerColumn, TextColumn, BarColumn
+                    
+                    with Progress(
+                        SpinnerColumn(),
+                        TextColumn("[bold blue]{task.description}"),
+                        BarColumn(),
+                        TextColumn("[progress.percentage]{task.percentage:>3.0f}%"),
+                        console=console,
+                    ) as progress:
+                        # Track deployment phases
+                        task = progress.add_task("Creating deployment...", total=100)
+                        
+                        deployment = client.deployments.create(
+                            project_name=project_name,
+                            git_repo=git_repo,
+                            branch=branch,
+                            framework=framework,
+                        )
+                        
+                        progress.update(task, advance=100, description="Deployment created!")
 
                     deployment_id = deployment["deployment_id"]
                     console.print(
@@ -237,6 +249,8 @@ def deploy(project_name, git_repo, branch, framework, no_heal):
                     if git_repo:
                         details_table.add_row("Repository", git_repo)
                         details_table.add_row("Branch", branch)
+                    else:
+                        details_table.add_row("Source", "Local directory")
                     details_table.add_row("Framework", framework)
                     details_table.add_row("Status", deployment.get("status", "PENDING"))
 
@@ -260,8 +274,17 @@ def deploy(project_name, git_repo, branch, framework, no_heal):
                     break
 
                 except XenfraAPIError as e:
-                    # Deployment failed
-                    console.print(f"[bold red]✗ Deployment failed: {e.detail}[/bold red]")
+                    # Deployment failed - try to provide helpful error
+                    from ..utils.errors import detect_error_type, show_error_with_solution
+                    
+                    console.print(f"[bold red]✗ Deployment failed[/bold red]")
+                    
+                    # Try to detect error type and show solution
+                    error_type, error_kwargs = detect_error_type(str(e.detail))
+                    if error_type:
+                        show_error_with_solution(error_type, **error_kwargs)
+                    else:
+                        console.print(f"[red]{e.detail}[/red]")
 
                     # Check if we should auto-heal
                     if no_heal or attempt >= MAX_RETRY_ATTEMPTS:

xenfra/commands/intelligence.py

@@ -131,6 +131,20 @@ def init(manual, accept_all):
             # Call Intelligence Service
             analysis = client.intelligence.analyze_codebase(code_snippets)
 
+            # Client-side conflict detection (ensures Zen Nod always triggers)
+            from ..utils.codebase import detect_package_manager_conflicts
+            has_conflict_local, detected_managers_local = detect_package_manager_conflicts(code_snippets)
+
+            if has_conflict_local and not analysis.has_conflict:
+                # AI missed the conflict - fix it client-side
+                console.print("[dim]Note: Enhanced conflict detection activated[/dim]\n")
+                analysis.has_conflict = True
+                # Convert dict to object for compatibility
+                from types import SimpleNamespace
+                analysis.detected_package_managers = [
+                    SimpleNamespace(**pm) for pm in detected_managers_local
+                ]
+
         # Display results
         console.print("\n[bold green]Analysis Complete![/bold green]\n")
 

xenfra/utils/codebase.py

@@ -120,6 +120,49 @@ def scan_codebase(max_files: int = 10, max_size: int = 50000) -> dict[str, str]:
 
     return code_snippets
 
+def detect_package_manager_conflicts(code_snippets: dict[str, str]) -> tuple[bool, list[dict]]:
+    """
+    Deterministically detect package manager conflicts from scanned files.
+    
+    This ensures Zen Nod (conflict resolution) always triggers when multiple
+    package managers are present, regardless of AI detection.
+    
+    Args:
+        code_snippets: Dictionary of filename -> content from scan_codebase()
+    
+    Returns:
+        (has_conflict, detected_managers) where detected_managers is a list of
+        {"manager": str, "file": str} dictionaries
+    """
+    detected = []
+    
+    # Check for Python package managers
+    if "pyproject.toml" in code_snippets:
+        content = code_snippets["pyproject.toml"]
+        if "[tool.poetry]" in content or "poetry.lock" in code_snippets:
+            detected.append({"manager": "poetry", "file": "pyproject.toml"})
+        elif "[tool.uv]" in content or "uv.lock" in code_snippets or "[project]" in content:
+            detected.append({"manager": "uv", "file": "pyproject.toml"})
+    
+    if "Pipfile" in code_snippets:
+        detected.append({"manager": "pipenv", "file": "Pipfile"})
+    
+    if "requirements.txt" in code_snippets:
+        detected.append({"manager": "pip", "file": "requirements.txt"})
+    
+    # Check for Node.js package managers (all independent checks)
+    if "pnpm-lock.yaml" in code_snippets:
+        detected.append({"manager": "pnpm", "file": "pnpm-lock.yaml"})
+    
+    if "yarn.lock" in code_snippets:
+        detected.append({"manager": "yarn", "file": "yarn.lock"})
+    
+    if "package-lock.json" in code_snippets:
+        detected.append({"manager": "npm", "file": "package-lock.json"})
+    
+    has_conflict = len(detected) > 1
+    return has_conflict, detected
+
 
 def has_xenfra_config() -> bool:
     """Check if xenfra.yaml already exists."""

xenfra/utils/config.py

@@ -280,6 +280,68 @@ def apply_patch(patch: dict, target_file: str = None, create_backup_file: bool =
             # Replace entire file
             with open(file_to_patch, "w") as f:
                 f.write(str(value))
+
+    # For TOML files (pyproject.toml)
+    elif file_to_patch.endswith(".toml"):
+        import toml
+
+        with open(file_to_patch, "r") as f:
+            config_data = toml.load(f)
+
+        operation = patch.get("operation")
+        path = patch.get("path", "").strip("/")
+        value = patch.get("value")
+
+        if operation == "add":
+            # Special case for pyproject.toml dependencies
+            is_pyproject = os.path.basename(file_to_patch) == "pyproject.toml"
+            if is_pyproject and (not path or path == "project/dependencies"):
+                # Ensure project and dependencies exist
+                if "project" not in config_data:
+                    config_data["project"] = {}
+                if "dependencies" not in config_data["project"]:
+                    config_data["project"]["dependencies"] = []
+                
+                # Add value if not already present
+                if value not in config_data["project"]["dependencies"]:
+                    config_data["project"]["dependencies"].append(value)
+            elif path:
+                path_parts = path.split("/")
+                current = config_data
+                for part in path_parts[:-1]:
+                    if part not in current:
+                        current[part] = {}
+                    current = current[part]
+                
+                # If target is a list (like dependencies), append
+                target_key = path_parts[-1]
+                if target_key in current and isinstance(current[target_key], list):
+                    if value not in current[target_key]:
+                        current[target_key].append(value)
+                else:
+                    current[target_key] = value
+            else:
+                # Root level add
+                if isinstance(value, dict):
+                    config_data.update(value)
+                else:
+                    # Ignore root-level non-dict adds for structured files
+                    # to prevent overwriting the entire config with a string
+                    pass
+
+        elif operation == "replace":
+            if path:
+                path_parts = path.split("/")
+                current = config_data
+                for part in path_parts[:-1]:
+                    current = current[part]
+                current[path_parts[-1]] = value
+            else:
+                config_data = value
+
+        # Write back
+        with open(file_to_patch, "w") as f:
+            toml.dump(config_data, f)
     else:
         # Design decision: Only support auto-patching for common dependency files
         # Other file types should be manually edited to avoid data loss

xenfra/utils/errors.py

@@ -0,0 +1,116 @@
+"""Human-friendly error messages with actionable solutions."""
+
+from rich.console import Console
+
+console = Console()
+
+
+ERROR_SOLUTIONS = {
+    "port_in_use": {
+        "message": "Port {port} is already in use on the droplet",
+        "solution": "Change the port in xenfra.yaml or stop the conflicting service",
+        "command": "ssh root@{{ip}} 'lsof -i :{port}'  # Find process using port",
+    },
+    "missing_dependency": {
+        "message": "Missing dependency: {package}",
+        "solution": "Add {package} to dependencies in {file}",
+        "command": "uv add {package}  # OR: echo '{package}' >> requirements.txt",
+    },
+    "ssh_failure": {
+        "message": "Cannot connect to droplet via SSH",
+        "solution": "Check firewall rules, wait for droplet boot, or verify SSH keys",
+        "command": "ssh -v root@{ip}  # Verbose SSH for debugging",
+    },
+    "docker_build_failed": {
+        "message": "Docker build failed",
+        "solution": "Check Dockerfile syntax and base image availability",
+        "command": "docker build . --no-cache  # Test locally",
+    },
+    "health_check_failed": {
+        "message": "Application failed health check",
+        "solution": "Ensure your app responds on port {port} at /health or /",
+        "command": "curl http://{{ip}}:{port}/health",
+    },
+    "out_of_memory": {
+        "message": "Container out of memory",
+        "solution": "Upgrade to a larger instance size in xenfra.yaml",
+        "command": "docker stats  # Check memory usage",
+    },
+}
+
+
+def show_error_with_solution(error_type: str, **kwargs) -> None:
+    """
+    Display error with actionable solution.
+    
+    Args:
+        error_type: Key from ERROR_SOLUTIONS
+        **kwargs: Template variables (port, ip, package, file, etc.)
+    """
+    error = ERROR_SOLUTIONS.get(error_type)
+    
+    if not error:
+        # Fallback for unknown errors
+        console.print(f"[red]❌ Error: {error_type}[/red]")
+        return
+    
+    # Format message with provided kwargs
+    try:
+        message = error["message"].format(**kwargs)
+        solution = error["solution"].format(**kwargs)
+        command = error.get("command", "").format(**kwargs)
+    except KeyError as e:
+        console.print(f"[red]❌ Error formatting message: missing {e}[/red]")
+        return
+    
+    console.print()
+    console.print(f"[red]❌ {message}[/red]")
+    console.print(f"[yellow]💡 Solution: {solution}[/yellow]")
+    
+    if command:
+        console.print(f"[dim]Try: {command}[/dim]")
+    console.print()
+
+
+def detect_error_type(error_message: str) -> tuple[str, dict]:
+    """
+    Attempt to detect error type from message.
+    
+    Returns:
+        (error_type, kwargs) for show_error_with_solution()
+    """
+    error_lower = error_message.lower()
+    
+    # Port detection
+    if "port" in error_lower and ("in use" in error_lower or "already" in error_lower):
+        # Try to extract port number
+        import re
+        port_match = re.search(r"port\s+(\d+)", error_lower)
+        port = port_match.group(1) if port_match else "8000"
+        return "port_in_use", {"port": port}
+    
+    # SSH detection
+    if "ssh" in error_lower or "connection refused" in error_lower:
+        return "ssh_failure", {"ip": "DROPLET_IP"}
+    
+    # Docker detection
+    if "docker" in error_lower and "build" in error_lower:
+        return "docker_build_failed", {}
+    
+    # Health check detection
+    if "health" in error_lower and ("fail" in error_lower or "timeout" in error_lower):
+        return "health_check_failed", {"port": "8000"}
+    
+    # Memory detection
+    if "memory" in error_lower or "oom" in error_lower:
+        return "out_of_memory", {}
+    
+    # Module not found
+    if "modulenotfounderror" in error_lower or "no module named" in error_lower:
+        import re
+        module_match = re.search(r"no module named ['\"]([^'\"]+)['\"]", error_lower)
+        package = module_match.group(1) if module_match else "PACKAGE_NAME"
+        return "missing_dependency", {"package": package, "file": "pyproject.toml"}
+    
+    # Unknown
+    return None, {}

{xenfra-0.3.4.dist-info → xenfra-0.3.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: xenfra
-Version: 0.3.4
+Version: 0.3.6
 Summary: A 'Zen Mode' infrastructure engine for Python developers.
 Author: xenfra-cloud
 Author-email: xenfra-cloud <xenfracloud@gmail.com>
@@ -24,6 +24,7 @@ Requires-Dist: keyring>=25.7.0
 Requires-Dist: keyrings-alt>=5.0.2
 Requires-Dist: tenacity>=8.2.3
 Requires-Dist: cryptography>=43.0.0
+Requires-Dist: toml>=0.10.2
 Requires-Dist: pytest>=8.0.0 ; extra == 'test'
 Requires-Dist: pytest-mock>=3.12.0 ; extra == 'test'
 Requires-Python: >=3.13

{xenfra-0.3.4.dist-info → xenfra-0.3.6.dist-info}/RECORD

@@ -2,18 +2,19 @@ xenfra/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 xenfra/commands/__init__.py,sha256=kTTwVnTvoxikyPUhQiyTAbnw4PYafktuE1----TqQoA,43
 xenfra/commands/auth.py,sha256=ecReVCGl7Ys2d77mv_e4mCbs4ug6FLIb3S9dl2FUhr4,4178
 xenfra/commands/auth_device.py,sha256=caD2UdveEZtAFjgjmnA-l5bjbbPONFjXJXgeJN7mhbk,6710
-xenfra/commands/deployments.py,sha256=bI6d9lVYPhCDoQE3nke7s80MUQ75ILPqiEGhcbXDExo,28609
-xenfra/commands/intelligence.py,sha256=U4nYh1aoJJ3Pxv_eliG3tmJUhCzX9iOiWg5yFALXtvE,15799
+xenfra/commands/deployments.py,sha256=bVpQ9kuFDT5a9M7ADwXZzXIXYyPS92saZEuYmiI_lU8,30016
+xenfra/commands/intelligence.py,sha256=jDQa2Bx4blTFoqtyutf1xsf6fHjIjRYEFW5G3mrz-Ks,16594
 xenfra/commands/projects.py,sha256=SAxF_pOr95K6uz35U-zENptKndKxJNZn6bcD45PHcpI,6696
 xenfra/commands/security_cmd.py,sha256=EI5sjX2lcMxgMH-LCFmPVkc9YqadOrcoSgTiKknkVRY,7327
 xenfra/main.py,sha256=2EPPuIdxjhW-I-e-Mc0i2ayeLaSJdmzddNThkXq7B7c,2033
 xenfra/utils/__init__.py,sha256=4ZRYkrb--vzoXjBHG8zRxz2jCXNGtAoKNtkyu2WRI2A,45
 xenfra/utils/auth.py,sha256=9JbFnv0-rdlJF-4hKD2uWd9h9ehqC1iIHee1O5e-3RM,13769
-xenfra/utils/codebase.py,sha256=57GthXOvOQnUHiDwIHqxK6hNUGWlWf6Nfs3T8647Wrc,4144
-xenfra/utils/config.py,sha256=F2zedd3JXP7TBdul0u8b4NVx-C1N6Hq4sH5szyWim6M,11947
+xenfra/utils/codebase.py,sha256=GMrqhOJWX8q5ZXSLI9P3hJZBpufXMQA3Z4fKh2XSTNo,5949
+xenfra/utils/config.py,sha256=UjTRIINSg6vPdtC3akJGxnisX621uoh8_JkhhfHl2RE,14519
+xenfra/utils/errors.py,sha256=6G91YzzDDNkKHANTgfAMiOiMElEyi57wo6-FzRa4VuQ,4211
 xenfra/utils/security.py,sha256=EA8CIPLt8Y-QP5uZ7c5NuC6ZLRV1aZS8NapS9ix_vok,11479
 xenfra/utils/validation.py,sha256=cvuL_AEFJ2oCoP0abCqoOIABOwz79Gkf-jh_dcFIQlM,6912
-xenfra-0.3.4.dist-info/WHEEL,sha256=RRVLqVugUmFOqBedBFAmA4bsgFcROUBiSUKlERi0Hcg,79
-xenfra-0.3.4.dist-info/entry_points.txt,sha256=a_2cGhYK__X6eW05Ba8uB6RIM_61c2sHtXsPY8N0mic,45
-xenfra-0.3.4.dist-info/METADATA,sha256=0b3lQ-vh0J5Wyeaa7_UKA9HKfRRnw9CjkD068to65os,3870
-xenfra-0.3.4.dist-info/RECORD,,
+xenfra-0.3.6.dist-info/WHEEL,sha256=KSLUh82mDPEPk0Bx0ScXlWL64bc8KmzIPNcpQZFV-6E,79
+xenfra-0.3.6.dist-info/entry_points.txt,sha256=a_2cGhYK__X6eW05Ba8uB6RIM_61c2sHtXsPY8N0mic,45
+xenfra-0.3.6.dist-info/METADATA,sha256=t9JZDfEXmmUIj8_BYUlhNVTd_bymZSDDdqzVaxgbMl8,3898
+xenfra-0.3.6.dist-info/RECORD,,

{xenfra-0.3.4.dist-info → xenfra-0.3.6.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: uv 0.9.21
+Generator: uv 0.9.22
 Root-Is-Purelib: true
 Tag: py3-none-any