xenfra 0.4.3__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/__init__.py

@@ -1,3 +1,3 @@
-"""
-CLI command modules for Xenfra.
-"""
+"""
+CLI command modules for Xenfra.
+"""

xenfra/commands/auth.py

@@ -1,144 +1,144 @@
-"""
-Authentication commands for Xenfra CLI.
-"""
-
-import base64
-import hashlib
-import secrets
-import urllib.parse
-import webbrowser
-from http.server import HTTPServer
-
-import click
-import httpx
-import keyring
-from rich.console import Console
-from tenacity import (
-    retry,
-    retry_if_exception_type,
-    stop_after_attempt,
-    wait_exponential,
-)
-
-from ..utils.auth import (
-    API_BASE_URL,
-    CLI_CLIENT_ID,
-    CLI_LOCAL_SERVER_END_PORT,
-    CLI_LOCAL_SERVER_START_PORT,
-    CLI_REDIRECT_PATH,
-    SERVICE_ID,
-    AuthCallbackHandler,
-    clear_tokens,
-    get_auth_token,
-)
-
-console = Console()
-
-# HTTP request timeout (30 seconds)
-HTTP_TIMEOUT = 30.0
-
-
-@click.group()
-def auth():
-    """Authentication commands (login, logout, whoami)."""
-    pass
-
-
-@retry(
-    stop=stop_after_attempt(3),
-    wait=wait_exponential(multiplier=1, min=2, max=10),
-    retry=retry_if_exception_type((httpx.TimeoutException, httpx.NetworkError)),
-    reraise=True,
-)
-def _exchange_code_for_tokens_with_retry(code: str, code_verifier: str, redirect_uri: str) -> dict:
-    """
-    Exchange authorization code for tokens with retry logic.
-
-    Returns token data dictionary.
-    """
-    with httpx.Client(timeout=HTTP_TIMEOUT) as client:
-        response = client.post(
-            f"{API_BASE_URL}/auth/token",
-            data={
-                "grant_type": "authorization_code",
-                "client_id": CLI_CLIENT_ID,
-                "code": code,
-                "code_verifier": code_verifier,
-                "redirect_uri": redirect_uri,
-            },
-            headers={"Accept": "application/json"},
-        )
-        response.raise_for_status()
-
-        # Safe JSON parsing with content-type check
-        content_type = response.headers.get("content-type", "")
-        if "application/json" not in content_type:
-            raise ValueError(f"Expected JSON response, got {content_type}")
-
-        try:
-            token_data = response.json()
-        except (ValueError, TypeError) as e:
-            raise ValueError(f"Failed to parse JSON response: {e}")
-
-        return token_data
-
-
-@auth.command()
-def login():
-    """Login to Xenfra using Device Authorization Flow (like GitHub CLI, Claude Code)."""
-    from .auth_device import device_login
-    device_login()
-
-    # Removed old PKCE flow - now using Device Authorization Flow
-
-
-@auth.command()
-def logout():
-    """Logout and clear stored tokens."""
-    try:
-        clear_tokens()
-        console.print("[bold green]Logged out successfully.[/bold green]")
-    except Exception as e:
-        console.print(f"[yellow]Warning: Error during logout: {e}[/yellow]")
-        console.print("[dim]Tokens may still be stored in keyring.[/dim]")
-
-
-@auth.command()
-@click.option("--token", is_flag=True, help="Show access token")
-def whoami(token):
-    """Show current authenticated user."""
-    access_token = get_auth_token()
-
-    if not access_token:
-        console.print("[bold red]Not logged in. Run 'xenfra login' first.[/bold red]")
-        return
-
-    try:
-        import base64
-        import json
-
-        # Manually decode JWT payload without verification
-        # JWT format: header.payload.signature
-        parts = access_token.split(".")
-        if len(parts) != 3:
-            console.print("[bold red]Invalid token format[/bold red]")
-            return
-
-        # Decode payload (second part)
-        payload_b64 = parts[1]
-        # Add padding if needed
-        padding = 4 - len(payload_b64) % 4
-        if padding != 4:
-            payload_b64 += "=" * padding
-
-        payload_bytes = base64.urlsafe_b64decode(payload_b64)
-        claims = json.loads(payload_bytes)
-
-        console.print("[bold green]Logged in as:[/bold green]")
-        console.print(f"  Email: {claims.get('sub', 'N/A')}")
-        console.print(f"  User ID: {claims.get('user_id', 'N/A')}")
-
-        if token:
-            console.print(f"\n[dim]Access Token:[/dim]\n{access_token}")
-    except Exception as e:
-        console.print(f"[bold red]Failed to decode token: {e}[/bold red]")
+"""
+Authentication commands for Xenfra CLI.
+"""
+
+import base64
+import hashlib
+import secrets
+import urllib.parse
+import webbrowser
+from http.server import HTTPServer
+
+import click
+import httpx
+import keyring
+from rich.console import Console
+from tenacity import (
+    retry,
+    retry_if_exception_type,
+    stop_after_attempt,
+    wait_exponential,
+)
+
+from ..utils.auth import (
+    API_BASE_URL,
+    CLI_CLIENT_ID,
+    CLI_LOCAL_SERVER_END_PORT,
+    CLI_LOCAL_SERVER_START_PORT,
+    CLI_REDIRECT_PATH,
+    SERVICE_ID,
+    AuthCallbackHandler,
+    clear_tokens,
+    get_auth_token,
+)
+
+console = Console()
+
+# HTTP request timeout (30 seconds)
+HTTP_TIMEOUT = 30.0
+
+
+@click.group()
+def auth():
+    """Authentication commands (login, logout, whoami)."""
+    pass
+
+
+@retry(
+    stop=stop_after_attempt(3),
+    wait=wait_exponential(multiplier=1, min=2, max=10),
+    retry=retry_if_exception_type((httpx.TimeoutException, httpx.NetworkError)),
+    reraise=True,
+)
+def _exchange_code_for_tokens_with_retry(code: str, code_verifier: str, redirect_uri: str) -> dict:
+    """
+    Exchange authorization code for tokens with retry logic.
+
+    Returns token data dictionary.
+    """
+    with httpx.Client(timeout=HTTP_TIMEOUT) as client:
+        response = client.post(
+            f"{API_BASE_URL}/auth/token",
+            data={
+                "grant_type": "authorization_code",
+                "client_id": CLI_CLIENT_ID,
+                "code": code,
+                "code_verifier": code_verifier,
+                "redirect_uri": redirect_uri,
+            },
+            headers={"Accept": "application/json"},
+        )
+        response.raise_for_status()
+
+        # Safe JSON parsing with content-type check
+        content_type = response.headers.get("content-type", "")
+        if "application/json" not in content_type:
+            raise ValueError(f"Expected JSON response, got {content_type}")
+
+        try:
+            token_data = response.json()
+        except (ValueError, TypeError) as e:
+            raise ValueError(f"Failed to parse JSON response: {e}")
+
+        return token_data
+
+
+@auth.command()
+def login():
+    """Login to Xenfra using Device Authorization Flow (like GitHub CLI, Claude Code)."""
+    from .auth_device import device_login
+    device_login()
+
+    # Removed old PKCE flow - now using Device Authorization Flow
+
+
+@auth.command()
+def logout():
+    """Logout and clear stored tokens."""
+    try:
+        clear_tokens()
+        console.print("[bold green]Logged out successfully.[/bold green]")
+    except Exception as e:
+        console.print(f"[yellow]Warning: Error during logout: {e}[/yellow]")
+        console.print("[dim]Tokens may still be stored in keyring.[/dim]")
+
+
+@auth.command()
+@click.option("--token", is_flag=True, help="Show access token")
+def whoami(token):
+    """Show current authenticated user."""
+    access_token = get_auth_token()
+
+    if not access_token:
+        console.print("[bold red]Not logged in. Run 'xenfra login' first.[/bold red]")
+        return
+
+    try:
+        import base64
+        import json
+
+        # Manually decode JWT payload without verification
+        # JWT format: header.payload.signature
+        parts = access_token.split(".")
+        if len(parts) != 3:
+            console.print("[bold red]Invalid token format[/bold red]")
+            return
+
+        # Decode payload (second part)
+        payload_b64 = parts[1]
+        # Add padding if needed
+        padding = 4 - len(payload_b64) % 4
+        if padding != 4:
+            payload_b64 += "=" * padding
+
+        payload_bytes = base64.urlsafe_b64decode(payload_b64)
+        claims = json.loads(payload_bytes)
+
+        console.print("[bold green]Logged in as:[/bold green]")
+        console.print(f"  Email: {claims.get('sub', 'N/A')}")
+        console.print(f"  User ID: {claims.get('user_id', 'N/A')}")
+
+        if token:
+            console.print(f"\n[dim]Access Token:[/dim]\n{access_token}")
+    except Exception as e:
+        console.print(f"[bold red]Failed to decode token: {e}[/bold red]")