xenfra-sdk 0.2.2__py3-none-any.whl → 0.2.4__py3-none-any.whl

xenfra_sdk/resources/files.py

@@ -1,101 +1,101 @@
-"""
-Files resource manager for delta uploads.
-
-Provides methods to check file cache status and upload files to the server.
-"""
-
-from typing import Dict, List
-
-
-class FilesManager:
-    """Manager for file upload operations."""
-    
-    def __init__(self, client):
-        """
-        Initialize the FilesManager.
-        
-        Args:
-            client: The XenfraClient instance.
-        """
-        self._client = client
-    
-    def check(self, files: List[Dict]) -> Dict:
-        """
-        Check which files are missing from server cache.
-        
-        Args:
-            files: List of file info dicts with keys: path, sha, size
-        
-        Returns:
-            Dict with keys:
-                - missing: List of SHA hashes that need to be uploaded
-                - cached: Number of files already cached on server
-        """
-        payload = {
-            "files": [
-                {"path": f["path"], "sha": f["sha"], "size": f["size"]}
-                for f in files
-            ]
-        }
-        
-        response = self._client._request("POST", "/files/check", json=payload)
-        return response.json()
-    
-    def upload(self, content: bytes, sha: str, path: str) -> Dict:
-        """
-        Upload a single file to the server.
-        
-        Args:
-            content: Raw file content as bytes
-            sha: SHA256 hash of the content
-            path: Relative file path
-        
-        Returns:
-            Dict with keys: sha, size, stored
-        """
-        import httpx
-        
-        headers = {
-            "Authorization": f"Bearer {self._client._token}",
-            "Content-Type": "application/octet-stream",
-            "X-Xenfra-Sha": sha,
-            "X-Xenfra-Path": path,
-        }
-        
-        response = httpx.post(
-            f"{self._client.api_url}/files/upload",
-            content=content,
-            headers=headers,
-            timeout=120.0,  # 2 minutes for large files
-        )
-        response.raise_for_status()
-        return response.json()
-    
-    def upload_files(self, files: List[Dict], missing_shas: List[str], progress_callback=None) -> int:
-        """
-        Upload multiple files that are missing from the server.
-        
-        Args:
-            files: List of file info dicts with keys: path, sha, size, abs_path
-            missing_shas: List of SHA hashes that need to be uploaded
-            progress_callback: Optional callback(uploaded_count, total_count)
-        
-        Returns:
-            Number of files uploaded
-        """
-        missing_set = set(missing_shas)
-        files_to_upload = [f for f in files if f["sha"] in missing_set]
-        total = len(files_to_upload)
-        uploaded = 0
-        
-        for file_info in files_to_upload:
-            with open(file_info["abs_path"], "rb") as f:
-                content = f.read()
-            
-            self.upload(content, file_info["sha"], file_info["path"])
-            uploaded += 1
-            
-            if progress_callback:
-                progress_callback(uploaded, total)
-        
-        return uploaded
+"""
+Files resource manager for delta uploads.
+
+Provides methods to check file cache status and upload files to the server.
+"""
+
+from typing import Dict, List
+
+
+class FilesManager:
+    """Manager for file upload operations."""
+    
+    def __init__(self, client):
+        """
+        Initialize the FilesManager.
+        
+        Args:
+            client: The XenfraClient instance.
+        """
+        self._client = client
+    
+    def check(self, files: List[Dict]) -> Dict:
+        """
+        Check which files are missing from server cache.
+        
+        Args:
+            files: List of file info dicts with keys: path, sha, size
+        
+        Returns:
+            Dict with keys:
+                - missing: List of SHA hashes that need to be uploaded
+                - cached: Number of files already cached on server
+        """
+        payload = {
+            "files": [
+                {"path": f["path"], "sha": f["sha"], "size": f["size"]}
+                for f in files
+            ]
+        }
+        
+        response = self._client._request("POST", "/files/check", json=payload)
+        return response.json()
+    
+    def upload(self, content: bytes, sha: str, path: str) -> Dict:
+        """
+        Upload a single file to the server.
+        
+        Args:
+            content: Raw file content as bytes
+            sha: SHA256 hash of the content
+            path: Relative file path
+        
+        Returns:
+            Dict with keys: sha, size, stored
+        """
+        import httpx
+        
+        headers = {
+            "Authorization": f"Bearer {self._client._token}",
+            "Content-Type": "application/octet-stream",
+            "X-Xenfra-Sha": sha,
+            "X-Xenfra-Path": path,
+        }
+        
+        response = httpx.post(
+            f"{self._client.api_url}/files/upload",
+            content=content,
+            headers=headers,
+            timeout=120.0,  # 2 minutes for large files
+        )
+        response.raise_for_status()
+        return response.json()
+    
+    def upload_files(self, files: List[Dict], missing_shas: List[str], progress_callback=None) -> int:
+        """
+        Upload multiple files that are missing from the server.
+        
+        Args:
+            files: List of file info dicts with keys: path, sha, size, abs_path
+            missing_shas: List of SHA hashes that need to be uploaded
+            progress_callback: Optional callback(uploaded_count, total_count)
+        
+        Returns:
+            Number of files uploaded
+        """
+        missing_set = set(missing_shas)
+        files_to_upload = [f for f in files if f["sha"] in missing_set]
+        total = len(files_to_upload)
+        uploaded = 0
+        
+        for file_info in files_to_upload:
+            with open(file_info["abs_path"], "rb") as f:
+                content = f.read()
+            
+            self.upload(content, file_info["sha"], file_info["path"])
+            uploaded += 1
+            
+            if progress_callback:
+                progress_callback(uploaded, total)
+        
+        return uploaded

xenfra_sdk/resources/intelligence.py

@@ -1,95 +1,102 @@
-"""
-Intelligence resource manager for Xenfra SDK.
-Provides AI-powered deployment diagnosis and codebase analysis.
-"""
-
-import logging
-
-from ..exceptions import XenfraAPIError, XenfraError
-from ..models import CodebaseAnalysisResponse, DiagnosisResponse
-from ..utils import safe_json_parse
-from .base import BaseManager
-
-logger = logging.getLogger(__name__)
-
-
-class IntelligenceManager(BaseManager):
-    """
-    Manager for AI-powered intelligence operations.
-
-    Provides:
-    - Deployment failure diagnosis (Zen Nod)
-    - Codebase analysis for zero-config init (Zen Init)
-    """
-
-    def diagnose(
-        self, logs: str, package_manager: str | None = None, dependency_file: str | None = None
-    ) -> DiagnosisResponse:
-        """
-        Diagnose deployment failure from logs using AI.
-
-        Args:
-            logs: The deployment logs to analyze
-            package_manager: Optional package manager context (uv, pip, poetry, npm, etc.)
-                           If provided, AI will target this manager's dependency file
-            dependency_file: Optional dependency file context (pyproject.toml, requirements.txt, etc.)
-                           If provided, AI will suggest patches for this file
-
-        Returns:
-            DiagnosisResponse with diagnosis, suggestion, and optional patch
-
-        Raises:
-            XenfraAPIError: If the API request fails
-            XenfraError: If parsing the response fails
-        """
-        try:
-            # Build request payload
-            payload = {"logs": logs}
-            if package_manager:
-                payload["package_manager"] = package_manager
-            if dependency_file:
-                payload["dependency_file"] = dependency_file
-
-            response = self._client._request("POST", "/intelligence/diagnose", json=payload)
-
-            logger.debug(f"IntelligenceManager.diagnose response: status={response.status_code}")
-
-            # Safe JSON parsing
-            data = safe_json_parse(response)
-            return DiagnosisResponse(**data)
-        except XenfraAPIError:
-            raise
-        except Exception as e:
-            raise XenfraError(f"Failed to diagnose logs: {e}")
-
-    def analyze_codebase(self, code_snippets: dict[str, str]) -> CodebaseAnalysisResponse:
-        """
-        Analyze codebase to detect framework, dependencies, and deployment config.
-
-        Args:
-            code_snippets: Dictionary of filename -> content
-                           e.g., {"main.py": "...", "requirements.txt": "..."}
-
-        Returns:
-            CodebaseAnalysisResponse with detected configuration
-
-        Raises:
-            XenfraAPIError: If the API request fails
-            XenfraError: If parsing the response fails
-        """
-        try:
-            response = self._client._request(
-                "POST", "/intelligence/analyze-codebase", json={"code_snippets": code_snippets}
-            )
-
-            logger.debug(
-                f"IntelligenceManager.analyze_codebase response: status={response.status_code}"
-            )
-
-            # Safe JSON parsing
-            data = safe_json_parse(response)
-            return CodebaseAnalysisResponse(**data)
-        except XenfraAPIError:
-            raise
-        except Exception as e:
-            raise XenfraError(f"Failed to analyze codebase: {e}")
+"""
+Intelligence resource manager for Xenfra SDK.
+Provides AI-powered deployment diagnosis and codebase analysis.
+"""
+
+import logging
+
+from ..exceptions import XenfraAPIError, XenfraError
+from ..models import CodebaseAnalysisResponse, DiagnosisResponse
+from ..utils import safe_json_parse
+from .base import BaseManager
+
+logger = logging.getLogger(__name__)
+
+
+class IntelligenceManager(BaseManager):
+    """
+    Manager for AI-powered intelligence operations.
+
+    Provides:
+    - Deployment failure diagnosis (Zen Nod)
+    - Codebase analysis for zero-config init (Zen Init)
+    """
+
+    def diagnose(
+        self, 
+        logs: str, 
+        package_manager: str | None = None, 
+        dependency_file: str | None = None,
+        services: list | None = None
+    ) -> DiagnosisResponse:
+        """
+        Diagnose deployment failure from logs using AI.
+
+        Args:
+            logs: The deployment logs to analyze
+            package_manager: Optional package manager context (uv, pip, poetry, npm, etc.)
+                           If provided, AI will target this manager's dependency file
+            dependency_file: Optional dependency file context (pyproject.toml, requirements.txt, etc.)
+                           If provided, AI will suggest patches for this file
+            services: Optional list of service definitions for project structure context (Zen Mode)
+
+        Returns:
+            DiagnosisResponse with diagnosis, suggestion, and optional patch
+
+        Raises:
+            XenfraAPIError: If the API request fails
+            XenfraError: If parsing the response fails
+        """
+        try:
+            # Build request payload
+            payload = {"logs": logs}
+            if package_manager:
+                payload["package_manager"] = package_manager
+            if dependency_file:
+                payload["dependency_file"] = dependency_file
+            if services:
+                payload["services"] = services
+
+            response = self._client._request("POST", "/intelligence/diagnose", json=payload)
+
+            logger.debug(f"IntelligenceManager.diagnose response: status={response.status_code}")
+
+            # Safe JSON parsing
+            data = safe_json_parse(response)
+            return DiagnosisResponse(**data)
+        except XenfraAPIError:
+            raise
+        except Exception as e:
+            raise XenfraError(f"Failed to diagnose logs: {e}")
+
+    def analyze_codebase(self, code_snippets: dict[str, str]) -> CodebaseAnalysisResponse:
+        """
+        Analyze codebase to detect framework, dependencies, and deployment config.
+
+        Args:
+            code_snippets: Dictionary of filename -> content
+                           e.g., {"main.py": "...", "requirements.txt": "..."}
+
+        Returns:
+            CodebaseAnalysisResponse with detected configuration
+
+        Raises:
+            XenfraAPIError: If the API request fails
+            XenfraError: If parsing the response fails
+        """
+        try:
+            response = self._client._request(
+                "POST", "/intelligence/analyze-codebase", json={"code_snippets": code_snippets}
+            )
+
+            logger.debug(
+                f"IntelligenceManager.analyze_codebase response: status={response.status_code}"
+            )
+
+            # Safe JSON parsing
+            data = safe_json_parse(response)
+            return CodebaseAnalysisResponse(**data)
+        except XenfraAPIError:
+            raise
+        except Exception as e:
+            raise XenfraError(f"Failed to analyze codebase: {e}")

xenfra_sdk/security.py

@@ -1,41 +1,41 @@
-# src/xenfra_sdk/security.py
-"""
-Security utilities for the Xenfra SDK.
-Provides token encryption/decryption for storing OAuth credentials.
-"""
-
-import os
-from typing import Optional
-
-from cryptography.fernet import Fernet
-
-# --- Configuration from Environment ---
-# These should be set in the service's environment
-ENCRYPTION_KEY = os.getenv("ENCRYPTION_KEY", "")
-
-
-def _get_fernet() -> Optional[Fernet]:
-    """Get Fernet instance for encryption/decryption."""
-    if not ENCRYPTION_KEY:
-        return None
-    try:
-        return Fernet(ENCRYPTION_KEY.encode())
-    except Exception:
-        return None
-
-
-# --- Token Encryption ---
-def encrypt_token(token: str) -> str:
-    """Encrypts a token using Fernet symmetric encryption."""
-    fernet = _get_fernet()
-    if fernet is None:
-        raise ValueError("ENCRYPTION_KEY environment variable is not set or invalid")
-    return fernet.encrypt(token.encode()).decode()
-
-
-def decrypt_token(encrypted_token: str) -> str:
-    """Decrypts a token."""
-    fernet = _get_fernet()
-    if fernet is None:
-        raise ValueError("ENCRYPTION_KEY environment variable is not set or invalid")
-    return fernet.decrypt(encrypted_token.encode()).decode()
+# src/xenfra_sdk/security.py
+"""
+Security utilities for the Xenfra SDK.
+Provides token encryption/decryption for storing OAuth credentials.
+"""
+
+import os
+from typing import Optional
+
+from cryptography.fernet import Fernet
+
+# --- Configuration from Environment ---
+# These should be set in the service's environment
+ENCRYPTION_KEY = os.getenv("ENCRYPTION_KEY", "")
+
+
+def _get_fernet() -> Optional[Fernet]:
+    """Get Fernet instance for encryption/decryption."""
+    if not ENCRYPTION_KEY:
+        return None
+    try:
+        return Fernet(ENCRYPTION_KEY.encode())
+    except Exception:
+        return None
+
+
+# --- Token Encryption ---
+def encrypt_token(token: str) -> str:
+    """Encrypts a token using Fernet symmetric encryption."""
+    fernet = _get_fernet()
+    if fernet is None:
+        raise ValueError("ENCRYPTION_KEY environment variable is not set or invalid")
+    return fernet.encrypt(token.encode()).decode()
+
+
+def decrypt_token(encrypted_token: str) -> str:
+    """Decrypts a token."""
+    fernet = _get_fernet()
+    if fernet is None:
+        raise ValueError("ENCRYPTION_KEY environment variable is not set or invalid")
+    return fernet.decrypt(encrypted_token.encode()).decode()