kollabor 0.4.9__py3-none-any.whl → 0.4.15__py3-none-any.whl

core/io/core_status_views.py

@@ -1,410 +1,330 @@
-"""Core status views for the Kollabor CLI application."""
+"""Core status views for the Kollabor CLI application.
+
+All views use the agnoster powerline style with lime/cyan color scheme.
+"""
 
 import logging
-import psutil
+from pathlib import Path
 from typing import List
 
 from .status_renderer import StatusViewConfig, BlockConfig
+from .visual_effects import AgnosterSegment, ColorPalette
 
 logger = logging.getLogger(__name__)
 
 
 class CoreStatusViews:
-    """Provides default core status views for the application."""
-
-    def __init__(self, llm_service=None, config=None):
-        """Initialize core status views.
+    """Provides agnoster-styled core status views."""
 
-        Args:
-            llm_service: LLM service instance for status data.
-            config: Configuration manager for toggleable sections.
-        """
+    def __init__(self, llm_service=None, config=None, profile_manager=None, agent_manager=None):
+        """Initialize core status views."""
         self.llm_service = llm_service
         self.config = config
+        self.profile_manager = profile_manager
+        self.agent_manager = agent_manager
 
     def register_all_views(self, status_registry) -> None:
-        """Register all core status views with the registry.
-
-        Args:
-            status_registry: StatusViewRegistry to register views with.
-        """
+        """Register all core status views."""
         try:
-            # View 0: Overview - Consolidated view with everything (priority 1100 - highest)
-            overview_view = StatusViewConfig(
+            # View 1: Overview (priority 1100 - highest)
+            status_registry.register_status_view("core", StatusViewConfig(
                 name="Overview",
                 plugin_source="core",
                 priority=1100,
-                blocks=[
-                    BlockConfig(
-                        width_fraction=0.33,
-                        content_provider=self._get_overview_ai_session_content,
-                        title="AI & Session",
-                        priority=100,
-                    ),
-                    BlockConfig(
-                        width_fraction=0.33,
-                        content_provider=self._get_overview_model_content,
-                        title="Model",
-                        priority=90,
-                    ),
-                    BlockConfig(
-                        width_fraction=0.34,
-                        content_provider=self._get_overview_performance_content,
-                        title="Performance",
-                        priority=80,
-                    ),
-                ],
-            )
-            status_registry.register_status_view("core", overview_view)
-
-            # View 1: Session Stats (priority 1000)
-            session_view = StatusViewConfig(
-                name="Session Stats",
+                blocks=[BlockConfig(
+                    width_fraction=1.0,
+                    content_provider=self._overview_content,
+                    title="Overview",
+                    priority=100,
+                )],
+            ))
+
+            # View 2: Session Stats (priority 1000)
+            status_registry.register_status_view("core", StatusViewConfig(
+                name="Session",
                 plugin_source="core",
                 priority=1000,
-                blocks=[
-                    BlockConfig(
-                        width_fraction=0.5,
-                        content_provider=self._get_session_stats_content,
-                        title="Session Stats",
-                        priority=100,
-                    ),
-                    BlockConfig(
-                        width_fraction=0.5,
-                        content_provider=self._get_ai_status_content,
-                        title="AI Status",
-                        priority=90,
-                    ),
-                ],
-            )
-            status_registry.register_status_view("core", session_view)
-
-            # View 2: Performance (priority 800)
-            performance_view = StatusViewConfig(
-                name="Performance",
+                blocks=[BlockConfig(
+                    width_fraction=1.0,
+                    content_provider=self._session_content,
+                    title="Session",
+                    priority=100,
+                )],
+            ))
+
+            # View 3: LLM Details (priority 900)
+            status_registry.register_status_view("core", StatusViewConfig(
+                name="LLM Details",
                 plugin_source="core",
-                priority=800,
-                blocks=[
-                    BlockConfig(
-                        width_fraction=1.0,
-                        content_provider=self._get_performance_content,
-                        title="Performance",
-                        priority=100,
-                    )
-                ],
-            )
-            status_registry.register_status_view("core", performance_view)
-
-            # View 3: Minimal (priority 600)
-            minimal_view = StatusViewConfig(
+                priority=900,
+                blocks=[BlockConfig(
+                    width_fraction=1.0,
+                    content_provider=self._llm_details_content,
+                    title="LLM",
+                    priority=100,
+                )],
+            ))
+
+            # View 4: Minimal (priority 600)
+            status_registry.register_status_view("core", StatusViewConfig(
                 name="Minimal",
                 plugin_source="core",
                 priority=600,
-                blocks=[
-                    BlockConfig(
-                        width_fraction=1.0,
-                        content_provider=self._get_minimal_content,
-                        title="Minimal",
-                        priority=100,
-                    )
-                ],
-            )
-            status_registry.register_status_view("core", minimal_view)
-
-            # View 4: LLM Details (priority 700)
-            llm_view = StatusViewConfig(
-                name="LLM Details",
-                plugin_source="core",
-                priority=700,
-                blocks=[
-                    BlockConfig(
-                        width_fraction=1.0,
-                        content_provider=self._get_llm_details_content,
-                        title="LLM Configuration",
-                        priority=100,
-                    )
-                ],
-            )
-            status_registry.register_status_view("core", llm_view)
-
-            logger.info(
-                "Registered 5 core status views: "
-                "Overview, Session Stats, Performance, LLM Details, Minimal"
-            )
+                blocks=[BlockConfig(
+                    width_fraction=1.0,
+                    content_provider=self._minimal_content,
+                    title="Minimal",
+                    priority=100,
+                )],
+            ))
+
+            logger.info("Registered 4 core status views")
 
         except Exception as e:
             logger.error(f"Failed to register core status views: {e}")
 
-    def _get_overview_ai_session_content(self) -> List[str]:
-        """Get AI and Session stats for Overview (left column)."""
+    def _get_dir_display(self) -> str:
+        """Get formatted directory display."""
         try:
-            import os
-            from pathlib import Path
-
-            lines = []
-
-            # Get config toggles
-            show_ai = self._get_config("terminal.status.overview.show_ai", True)
-            show_session = self._get_config("terminal.status.overview.show_session", True)
-            show_directory = self._get_config("terminal.status.overview.show_directory", True)
-
-            # Current Directory
-            if show_directory:
-                cwd = Path.cwd()
-                # Show just the directory name, or full path if configured
-                show_full_path = self._get_config("terminal.status.overview.show_full_path", False)
-                if show_full_path:
-                    dir_display = str(cwd)
-                else:
-                    # Show home as ~ and just the folder name
-                    try:
-                        home = Path.home()
-                        if cwd == home:
-                            dir_display = "~"
-                        elif cwd.is_relative_to(home):
-                            rel_path = cwd.relative_to(home)
-                            # Show last 2 parts of path for context
-                            parts = rel_path.parts
-                            if len(parts) > 2:
-                                dir_display = f"~/{'/'.join(parts[-2:])}"
-                            else:
-                                dir_display = f"~/{rel_path}"
-                        else:
-                            # Show last 2 parts of absolute path
-                            parts = cwd.parts
-                            if len(parts) > 2:
-                                dir_display = f"{'/'.join(parts[-2:])}"
-                            else:
-                                dir_display = str(cwd)
-                    except Exception:
-                        dir_display = cwd.name or str(cwd)
+            cwd = Path.cwd()
+            home = Path.home()
+            if cwd == home:
+                return "~"
+            elif cwd.is_relative_to(home):
+                rel_path = cwd.relative_to(home)
+                parts = rel_path.parts
+                if len(parts) > 2:
+                    return f"~/{'/'.join(parts[-2:])}"
+                return f"~/{rel_path}"
+            return cwd.name or str(cwd)
+        except Exception:
+            return "?"
+
+    def _get_profile_name(self) -> str:
+        """Get active profile name."""
+        if self.profile_manager:
+            profile = self.profile_manager.get_active_profile()
+            if profile:
+                return profile.name
+        return "default"
+
+    def _get_agent_info(self) -> tuple:
+        """Get active agent name, all skills, and active skills."""
+        agent_name = None
+        all_skills = []
+        active_skills = set()
+        if self.agent_manager:
+            agent = self.agent_manager.get_active_agent()
+            if agent:
+                agent_name = agent.name
+                all_skills = [s.name for s in agent.list_skills()]
+                active_skills = set(agent.active_skills)
+        return agent_name, all_skills, active_skills
+
+    def _format_agent_skills_line(self, agent_name: str, all_skills: list, active_skills: set, max_width: int = 80) -> str:
+        """Format agent/skills line with active skills bright, others dimmed.
+
+        Format: agent: skill1* skill2 skill3 +N more
+        Active skills are bright with *, inactive are dimmed.
+        """
+        if not agent_name:
+            return ""
 
-                lines.append(f"Dir: {dir_display}")
+        # Start with electric arrow symbol and agent name
+        line = f"{ColorPalette.BRIGHT_YELLOW}⌁{ColorPalette.RESET}{ColorPalette.LIME}{agent_name}{ColorPalette.RESET}⋮"
+        current_len = len(agent_name) + 3  # " name: "
 
-            # AI Status
-            if show_ai and self.llm_service:
-                processing = "* Processing" if self.llm_service.is_processing else "✓ Ready"
-                queue_size = 0
-                if hasattr(self.llm_service, "processing_queue"):
-                    queue_size = self.llm_service.processing_queue.qsize()
+        # Sort skills: active first, then inactive
+        sorted_skills = sorted(all_skills, key=lambda s: (s not in active_skills, s))
 
-                lines.append(f"AI: {processing}")
-                if queue_size > 0:
-                    lines.append(f"Queue: {queue_size}")
+        skills_shown = 0
+        max_skills_to_show = 3  # Show at most 3 skills before truncating
 
-            # Session Stats
-            if show_session and self.llm_service and hasattr(self.llm_service, "session_stats"):
-                stats = self.llm_service.session_stats
-                msgs = stats.get('messages', 0)
-                tokens_in = stats.get('input_tokens', 0)
-                tokens_out = stats.get('output_tokens', 0)
-                total_tokens = tokens_in + tokens_out
+        for skill in sorted_skills:
+            is_active = skill in active_skills
 
-                # Format tokens
-                if total_tokens < 1000:
-                    token_display = f"{total_tokens}"
-                elif total_tokens < 1000000:
-                    token_display = f"{total_tokens/1000:.1f}K"
-                else:
-                    token_display = f"{total_tokens/1000000:.1f}M"
+            # Check if we need to truncate
+            if skills_shown >= max_skills_to_show and len(all_skills) > max_skills_to_show:
+                remaining = len(all_skills) - skills_shown
+                line += f"⋮{ColorPalette.DIM}+{remaining} more{ColorPalette.RESET}"
+                break
 
-                lines.append(f"Messages: {msgs}")
-                lines.append(f"Tokens: {token_display}")
-                lines.append(f"In/Out: {tokens_in}/{tokens_out}")
-
-            return lines if lines else ["Hidden"]
+            # Format skill
+            if is_active:
+                skill_text = f"{ColorPalette.BRIGHT_CYAN} ⏵{ColorPalette.BRIGHT_WHITE}{skill}{ColorPalette.RESET}"
+            else:
+                skill_text = f"{ColorPalette.DIM}⋮{skill}{ColorPalette.RESET}"
 
-        except Exception as e:
-            logger.error(f"Error getting AI/Session content: {e}")
-            return ["Error"]
+            line += skill_text
+            skills_shown += 1
 
-    def _get_overview_model_content(self) -> List[str]:
-        """Get Model info for Overview (middle column)."""
-        try:
-            lines = []
+        return line.rstrip()
 
-            show_model = self._get_config("terminal.status.overview.show_model", True)
+    def _get_model_info(self) -> tuple:
+        """Get model name and endpoint from active profile."""
+        model = "unknown"
+        endpoint = ""
 
-            if show_model and self.llm_service and hasattr(self.llm_service, "api_service"):
-                api_service = self.llm_service.api_service
-                model = getattr(api_service, "model", "Unknown")
-                temp = getattr(api_service, "temperature", None)
-                max_tok = getattr(api_service, "max_tokens", None)
-                api_url = getattr(api_service, "api_url", "Unknown")
-
-                # Extract endpoint from URL
-                endpoint = "Unknown"
-                if api_url != "Unknown":
+        # Prefer profile_manager as source of truth (supports env vars and reload)
+        if self.profile_manager:
+            profile = self.profile_manager.get_active_profile()
+            if profile:
+                model = profile.get_model() or "unknown"
+                api_url = profile.get_endpoint() or ""
+                if api_url:
                     try:
                         from urllib.parse import urlparse
-                        parsed = urlparse(api_url)
-                        endpoint = parsed.hostname or api_url
+                        endpoint = urlparse(api_url).hostname or ""
                     except Exception:
-                        endpoint = api_url
+                        pass
+                return model, endpoint
+
+        # Fallback to api_service if no profile_manager
+        if self.llm_service and hasattr(self.llm_service, "api_service"):
+            api_service = self.llm_service.api_service
+            model = getattr(api_service, "model", "unknown")
+            api_url = getattr(api_service, "api_url", "")
+            if api_url:
+                try:
+                    from urllib.parse import urlparse
+                    endpoint = urlparse(api_url).hostname or ""
+                except Exception:
+                    pass
+        return model, endpoint
+
+    def _get_status(self) -> tuple:
+        """Get status text and variant."""
+        if self.llm_service and self.llm_service.is_processing:
+            return "* Working", "light"
+        return "* Ready", "normal"
+
+    def _get_stats(self) -> tuple:
+        """Get message count and token display."""
+        msgs = 0
+        tokens = 0
+        if self.llm_service and hasattr(self.llm_service, "session_stats"):
+            stats = self.llm_service.session_stats
+            msgs = stats.get("messages", 0)
+            tokens = stats.get("input_tokens", 0) + stats.get("output_tokens", 0)
+
+        if tokens < 1000:
+            token_display = f"{tokens}"
+        elif tokens < 1000000:
+            token_display = f"{tokens/1000:.1f}K"
+        else:
+            token_display = f"{tokens/1000000:.1f}M"
+
+        return msgs, token_display
+
+    def _overview_content(self) -> List[str]:
+        """Agnoster overview: dir | profile | model@endpoint | status | stats.
+
+        If an agent is active, adds a second line showing agent and skills.
+        """
+        try:
+            seg = AgnosterSegment()
 
-                lines.append(f"Model: {model}")
-                if endpoint != "Unknown":
-                    lines.append(f"Endpoint: {endpoint}")
-                if temp is not None:
-                    lines.append(f"Temp: {temp}")
-                if max_tok is not None:
-                    lines.append(f"Max Tokens: {max_tok}")
+            # Directory (lime dark)
+            seg.add_lime(self._get_dir_display(), "dark")
 
-            return lines if lines else ["Hidden"]
+            # Profile (cyan dark)
+            seg.add_cyan(self._get_profile_name(), "dark")
 
-        except Exception as e:
-            logger.error(f"Error getting model content: {e}")
-            return ["Error"]
+            # Model @ Endpoint (lime)
+            model, endpoint = self._get_model_info()
+            model_text = f"{model} @ {endpoint}" if endpoint else model
+            seg.add_lime(model_text)
 
-    def _get_overview_performance_content(self) -> List[str]:
-        """Get Performance info for Overview (right column)."""
-        try:
-            # Performance metrics disabled per user request
-            return []
+            # Status (cyan)
+            status_text, variant = self._get_status()
+            seg.add_cyan(status_text, variant)
 
-        except Exception as e:
-            logger.error(f"Error getting performance content: {e}")
-            return ["Error"]
+            # Stats (neutral)
+            msgs, token_display = self._get_stats()
+            seg.add_neutral(f"{msgs} msg | {token_display} tok", "mid")
 
-    def _get_config(self, key: str, default):
-        """Get config value with fallback to default."""
-        if self.config and hasattr(self.config, "get"):
-            return self.config.get(key, default)
-        return default
+            lines = [seg.render()]
 
-    def _get_session_stats_content(self) -> List[str]:
-        """Get session statistics content."""
-        try:
-            # Get session stats from LLM service
-            if self.llm_service and hasattr(self.llm_service, "session_stats"):
-                stats = self.llm_service.session_stats
-                return [
-                    f"Messages: {stats.get('messages', 0)}",
-                    f"Tokens In: {stats.get('input_tokens', 0)}",
-                    f"Tokens Out: {stats.get('output_tokens', 0)}",
-                ]
-            return ["Messages: 0", "Tokens: 0"]
-        except Exception:
-            return ["Session: N/A"]
+            # Add agent/skills line if agent is active
+            agent_name, all_skills, active_skills = self._get_agent_info()
+            if agent_name:
+                agent_line = self._format_agent_skills_line(agent_name, all_skills, active_skills)
+                if agent_line:
+                    lines.append(agent_line)
 
-    def _get_ai_status_content(self) -> List[str]:
-        """Get AI status content."""
-        try:
-            if self.llm_service:
-                processing = (
-                    "* Processing" if self.llm_service.is_processing else "✓ Ready"
-                )
-                if hasattr(self.llm_service, "processing_queue"):
-                    queue_size = self.llm_service.processing_queue.qsize()
-                else:
-                    queue_size = 0
-
-                # Get model and endpoint info from API service
-                model = "Unknown"
-                endpoint = "Unknown"
-                if hasattr(self.llm_service, "api_service"):
-                    api_service = self.llm_service.api_service
-                    model = getattr(api_service, "model", "Unknown")
-                    api_url = getattr(api_service, "api_url", "Unknown")
-                    # Extract domain from URL for cleaner display
-                    if api_url != "Unknown":
-                        try:
-                            from urllib.parse import urlparse
-
-                            parsed = urlparse(api_url)
-                            endpoint = parsed.hostname or api_url
-                        except Exception:
-                            endpoint = api_url
-
-                return [
-                    f"AI: {processing}",
-                    f"Model: {model}",
-                    f"Endpoint: {endpoint}",
-                    f"Queue: {queue_size}",
-                ]
-            return ["AI: Unknown"]
-        except Exception:
-            return ["AI: N/A"]
+            return lines
 
-    def _get_performance_content(self) -> List[str]:
-        """Get performance content."""
-        try:
-            # Performance metrics disabled per user request
-            return []
-        except Exception:
-            return []
+        except Exception as e:
+            logger.error(f"Overview error: {e}")
+            return [f"{ColorPalette.DIM}Status unavailable{ColorPalette.RESET}"]
 
-    def _get_minimal_content(self) -> List[str]:
-        """Get minimal view content."""
+    def _session_content(self) -> List[str]:
+        """Agnoster session: messages | tokens in | tokens out | total."""
         try:
-            ai_status = "✓ Ready"
-            model = "Unknown"
-            if self.llm_service:
-                if self.llm_service.is_processing:
-                    ai_status = "* Processing"
-
-                # Get model info
-                if hasattr(self.llm_service, "api_service"):
-                    model = getattr(self.llm_service.api_service, "model", "Unknown")
-
-            messages = 0
-            tokens = 0
+            seg = AgnosterSegment()
+
+            msgs = 0
+            tokens_in = 0
+            tokens_out = 0
             if self.llm_service and hasattr(self.llm_service, "session_stats"):
                 stats = self.llm_service.session_stats
-                messages = stats.get("messages", 0)
-                input_tokens = stats.get("input_tokens", 0)
-                output_tokens = stats.get("output_tokens", 0)
-                tokens = input_tokens + output_tokens
+                msgs = stats.get("messages", 0)
+                tokens_in = stats.get("input_tokens", 0)
+                tokens_out = stats.get("output_tokens", 0)
 
-            if tokens < 1000:
-                token_display = f"{tokens}"
-            else:
-                token_display = f"{tokens/1000:.1f}K"
+            seg.add_lime(f"Messages: {msgs}", "dark")
+            seg.add_cyan(f"In: {tokens_in}", "dark")
+            seg.add_lime(f"Out: {tokens_out}")
+            seg.add_cyan(f"Total: {tokens_in + tokens_out}")
 
-            return [
-                f"AI: {ai_status} ({model}) | Messages: {messages} "
-                f"| Tokens: {token_display}"
-            ]
-        except Exception:
-            return ["Status: N/A"]
+            return [seg.render()]
+
+        except Exception as e:
+            logger.error(f"Session error: {e}")
+            return [f"{ColorPalette.DIM}Session unavailable{ColorPalette.RESET}"]
 
-    def _get_llm_details_content(self) -> List[str]:
-        """Get detailed LLM configuration content."""
+    def _llm_details_content(self) -> List[str]:
+        """Agnoster LLM details: status | model | endpoint | temp | max_tokens."""
         try:
-            if not self.llm_service:
-                return ["LLM: Not initialized"]
-
-            ai_status = (
-                "* Processing" if self.llm_service.is_processing else "✓ Ready"
-            )
-            model = "Unknown"
-            endpoint = "Unknown"
-            temperature = "Unknown"
-            max_tokens = "Unknown"
-
-            if hasattr(self.llm_service, "api_service"):
+            seg = AgnosterSegment()
+
+            status_text, _ = self._get_status()
+            model, endpoint = self._get_model_info()
+
+            temp = "?"
+            max_tokens = "?"
+            if self.llm_service and hasattr(self.llm_service, "api_service"):
                 api_service = self.llm_service.api_service
-                model = getattr(api_service, "model", "Unknown")
-                temperature = getattr(api_service, "temperature", "Unknown")
-                max_tokens = getattr(api_service, "max_tokens", "Unknown")
-                api_url = getattr(api_service, "api_url", "Unknown")
+                temp = getattr(api_service, "temperature", "?")
+                max_tokens = getattr(api_service, "max_tokens", None) or "None"
 
-                # Extract domain from URL for cleaner display
-                if api_url != "Unknown":
-                    try:
-                        from urllib.parse import urlparse
+            seg.add_lime(status_text, "dark")
+            seg.add_cyan(f"Model: {model}", "dark")
+            seg.add_lime(f"@ {endpoint}" if endpoint else "local")
+            seg.add_cyan(f"Temp: {temp}")
+            seg.add_neutral(f"Max: {max_tokens}", "mid")
 
-                        parsed = urlparse(api_url)
-                        endpoint = parsed.hostname or api_url
-                    except Exception:
-                        endpoint = api_url
-
-            return [
-                f"Status: {ai_status}",
-                f"Model: {model}",
-                f"Endpoint: {endpoint}",
-                f"Temperature: {temperature}",
-                f"Max Tokens: {max_tokens}",
-            ]
-        except Exception:
-            return ["LLM Details: N/A"]
+            return [seg.render()]
+
+        except Exception as e:
+            logger.error(f"LLM details error: {e}")
+            return [f"{ColorPalette.DIM}LLM unavailable{ColorPalette.RESET}"]
+
+    def _minimal_content(self) -> List[str]:
+        """Agnoster minimal: status | model | msgs | tokens."""
+        try:
+            seg = AgnosterSegment()
+
+            status_text, variant = self._get_status()
+            model, _ = self._get_model_info()
+            msgs, token_display = self._get_stats()
+
+            seg.add_lime(status_text, "dark")
+            seg.add_cyan(model, "dark")
+            seg.add_neutral(f"{msgs} msg | {token_display} tok", "mid")
+
+            return [seg.render()]
+
+        except Exception as e:
+            logger.error(f"Minimal error: {e}")
+            return [f"{ColorPalette.DIM}--{ColorPalette.RESET}"]