clue2app-cli 0.2.7__py3-none-any.whl

clue2app_cli/tui/data.py

@@ -0,0 +1,316 @@
+"""Reusable data fetching layer for TUI.
+
+Provides async-compatible data fetching functions that can be used
+by both Textual and ncurses TUI implementations.
+"""
+
+from typing import Any, Dict, List, Optional, Generator
+from dataclasses import dataclass
+from enum import Enum
+
+
+class AppStatus(Enum):
+    """Application runtime status."""
+    RUNNING = "Running"
+    SCALED_TO_ZERO = "Scaled to Zero"
+    STOPPED = "Stopped"
+    BUILDING = "Building"
+    FAILED = "Failed"
+    UNKNOWN = "Unknown"
+
+
+class BuildStatus(Enum):
+    """Application build status."""
+    READY = "Ready"
+    BUILDING = "Building"
+    FAILED = "Failed"
+    UNKNOWN = "Unknown"
+
+
+@dataclass
+class AppInfo:
+    """Unified app information combining build and runtime data."""
+    name: str
+    display_name: str
+    namespace: str
+    project_id: Optional[str]
+    project_name: Optional[str]
+
+    # Build info
+    build_status: BuildStatus
+    build_count: int
+    build_reason: Optional[str]
+    stack: Optional[str]
+
+    # Source info
+    git_url: Optional[str]
+    git_revision: Optional[str]
+
+    # Runtime info
+    runtime_status: AppStatus
+    pod_count: int
+    url: Optional[str]
+
+    # Image info
+    latest_image: Optional[str]
+
+
+@dataclass
+class ProjectInfo:
+    """Project information."""
+    id: str
+    name: str
+    namespace: str
+    app_count: int
+
+
+class DataProvider:
+    """Reusable data fetching for TUI.
+
+    This class provides methods to fetch and transform data from the SDK
+    into formats suitable for TUI display.
+    """
+
+    UNLINKED_PROJECT_ID = "00000000-0000-0000-0000-000000000000"
+
+    def __init__(self):
+        from clue2app_cli.sdk import Clue2AppSDK
+        self.sdk = Clue2AppSDK()
+        self._project_cache: Dict[str, ProjectInfo] = {}
+
+    def get_projects(self) -> List[ProjectInfo]:
+        """Get all projects."""
+        # Use suppress_errors=False so we get exceptions we can catch
+        projects = self.sdk.list_projects(suppress_errors=False)
+
+        result = []
+        for p in projects:
+            info = ProjectInfo(
+                id=p.get('id', ''),
+                name=p.get('name', 'Unknown'),
+                namespace=p.get('namespace', ''),
+                app_count=0  # Will be populated when we fetch apps
+            )
+            self._project_cache[info.id] = info
+            result.append(info)
+        return result
+
+    def get_project(self, project_id: str) -> Optional[ProjectInfo]:
+        """Get a single project by ID."""
+        if project_id in self._project_cache:
+            return self._project_cache[project_id]
+
+        try:
+            project = self.sdk.get_project(project_id, quiet=True)
+            if project:
+                info = ProjectInfo(
+                    id=project.get('id', ''),
+                    name=project.get('name', 'Unknown'),
+                    namespace=project.get('namespace', ''),
+                    app_count=0
+                )
+                self._project_cache[info.id] = info
+                return info
+        except Exception:
+            # Silently fail - project lookup is non-critical
+            pass
+        return None
+
+    def get_apps(self, project_id: Optional[str] = None, include_unlinked: bool = False) -> List[AppInfo]:
+        """Get apps with merged build and runtime info.
+
+        Args:
+            project_id: Filter by project ID (None for all projects in context)
+            include_unlinked: Include apps not linked to any project
+        """
+        # Fetch apps from SDK (suppress_errors=False to get exceptions we can catch)
+        if include_unlinked:
+            apps = self.sdk.list_apps(use_context=False, unlinked_only=True, suppress_errors=False)
+        elif project_id:
+            apps = self.sdk.list_apps(project_id=project_id, use_context=True, suppress_errors=False)
+        else:
+            apps = self.sdk.list_apps(use_context=False, suppress_errors=False)
+
+        # Fetch runtime metrics
+        metrics = self.sdk.get_app_runtime_metrics(project_id=project_id)
+        metrics_map = {}
+        for m in metrics:
+            svc_name = m.get('serviceName', '')
+            metrics_map[svc_name] = m
+
+        # Merge and transform
+        result = []
+        for app in apps:
+            info = self._transform_app(app, metrics_map)
+            result.append(info)
+
+        return result
+
+    def _transform_app(self, app: Dict[str, Any], metrics_map: Dict[str, Any]) -> AppInfo:
+        """Transform raw app data into AppInfo."""
+        meta = app.get('metadata', {})
+        spec = app.get('spec', {})
+        status = app.get('status', {})
+        labels = meta.get('labels', {})
+        git = spec.get('source', {}).get('git', {})
+
+        name = meta.get('name', '')
+        display_name = meta.get('displayName', name)
+
+        # Get project info
+        app_group_id = labels.get('appGroupId', '')
+        project_name = None
+        if app_group_id and app_group_id != self.UNLINKED_PROJECT_ID:
+            project = self.get_project(app_group_id)
+            if project:
+                project_name = project.name
+
+        # Determine build status
+        conditions = status.get('conditions', [])
+        build_status = BuildStatus.UNKNOWN
+        for cond in conditions:
+            if cond.get('type') == 'Ready':
+                if cond.get('status') == 'True':
+                    build_status = BuildStatus.READY
+                elif cond.get('status') == 'False':
+                    build_status = BuildStatus.FAILED
+                break
+
+        if status.get('buildCounter', 0) > 0 and build_status == BuildStatus.UNKNOWN:
+            # Check if currently building
+            latest_build = status.get('latestBuildRef', '')
+            if latest_build:
+                build_status = BuildStatus.BUILDING
+
+        # Get runtime info from metrics
+        runtime_status = AppStatus.UNKNOWN
+        pod_count = 0
+        url = None
+
+        # Try to match by name (strip timestamp prefix if present)
+        base_name = name
+        if '-' in name:
+            parts = name.split('-', 1)
+            if parts[0].isdigit():
+                base_name = parts[1]
+
+        metric = metrics_map.get(name) or metrics_map.get(base_name) or metrics_map.get(display_name)
+        if metric:
+            ready_replicas = metric.get('readyReplicas', 0)
+            desired_replicas = metric.get('desiredReplicas', 0)
+
+            if ready_replicas > 0:
+                runtime_status = AppStatus.RUNNING
+            elif desired_replicas == 0:
+                runtime_status = AppStatus.SCALED_TO_ZERO
+            else:
+                runtime_status = AppStatus.STOPPED
+
+            pod_count = ready_replicas
+            url = metric.get('url')
+
+        return AppInfo(
+            name=name,
+            display_name=display_name,
+            namespace=meta.get('namespace', ''),
+            project_id=app_group_id if app_group_id != self.UNLINKED_PROJECT_ID else None,
+            project_name=project_name,
+            build_status=build_status,
+            build_count=status.get('buildCounter', 0),
+            build_reason=status.get('latestBuildReason', ''),
+            stack=status.get('stack', {}).get('id', ''),
+            git_url=git.get('url'),
+            git_revision=git.get('revision', 'main'),
+            runtime_status=runtime_status,
+            pod_count=pod_count,
+            url=url,
+            latest_image=status.get('latestImage', '')
+        )
+
+    def get_app_details(self, app_name: str) -> Optional[AppInfo]:
+        """Get detailed info for a single app."""
+        app = self.sdk.get_app(app_name)
+        if not app:
+            return None
+
+        # Get runtime metrics for this app
+        meta = app.get('metadata', {})
+        labels = meta.get('labels', {})
+        project_id = labels.get('appGroupId')
+
+        metrics = self.sdk.get_app_runtime_metrics(project_id=project_id)
+        metrics_map = {m.get('serviceName', ''): m for m in metrics}
+
+        return self._transform_app(app, metrics_map)
+
+    def stream_logs(self, app_name: str, lines: int = 100) -> Generator[str, None, None]:
+        """Stream instance logs for an app.
+
+        Yields log lines as they become available.
+        """
+        yield from self.sdk.get_instance_logs(app_name, lines=lines, follow=True)
+
+    def get_instance_logs(self, app_name: str, lines: int = 100) -> str:
+        """Get recent instance (runtime) logs for an app."""
+        try:
+            return self.sdk.get_instance_logs(app_name, lines=lines, follow=False)
+        except Exception as e:
+            return f"Error getting instance logs: {e}"
+
+    def get_build_logs(self, app_name: str) -> str:
+        """Get build logs for the latest build of an app."""
+        return self.sdk.get_latest_build_logs(app_name)
+
+    def get_logs(self, app_name: str, lines: int = 100, log_type: str = "auto") -> str:
+        """Get logs for an app.
+
+        Args:
+            app_name: The application name
+            lines: Number of lines for instance logs
+            log_type: "instance", "build", or "auto" (tries instance first, falls back to build)
+
+        Returns:
+            Log content string
+        """
+        if log_type == "build":
+            return self.get_build_logs(app_name)
+        elif log_type == "instance":
+            return self.get_instance_logs(app_name, lines)
+        else:
+            # Auto mode: try instance logs first, fall back to build logs
+            instance_logs = self.get_instance_logs(app_name, lines)
+            if instance_logs and not instance_logs.startswith("Error") and len(instance_logs.strip()) > 0:
+                return instance_logs
+            # No instance logs (probably scaled to zero), try build logs
+            build_logs = self.get_build_logs(app_name)
+            if build_logs:
+                return f"[No running instances - showing build logs]\n\n{build_logs}"
+            return "No logs available (no running instances and no build logs found)"
+
+    def rebuild_app(self, app_name: str) -> Optional[Dict[str, Any]]:
+        """Trigger app rebuild."""
+        return self.sdk.rebuild_app(app_name)
+
+    def link_app(self, app_name: str, project_id: str) -> Optional[Dict[str, Any]]:
+        """Link app to project."""
+        return self.sdk.link_app_to_project(app_name, project_id)
+
+    def delete_app(self, app_name: str) -> bool:
+        """Delete an app."""
+        return self.sdk.delete_app(app_name)
+
+    def restart_service(self, app_name: str, namespace: Optional[str] = None) -> Dict[str, Any]:
+        """Restart/wake up a service (useful for scaled-to-zero apps).
+
+        Returns:
+            Dict with 'success' bool and 'error' message if failed
+        """
+        return self.sdk.restart_service(app_name, namespace=namespace)
+
+    def get_current_project(self) -> Optional[ProjectInfo]:
+        """Get the currently selected project from context."""
+        from clue2app_cli.config import get_config_value
+        project_id = get_config_value("context.project.id")
+        if project_id:
+            return self.get_project(project_id)
+        return None

clue2app_cli/tui/screens/__init__.py

@@ -0,0 +1 @@
+"""TUI screens."""