strix-agent 0.4.0__py3-none-any.whl

strix/interface/tool_components/base_renderer.py

@@ -0,0 +1,62 @@
+from abc import ABC, abstractmethod
+from typing import Any, ClassVar, cast
+
+from rich.markup import escape as rich_escape
+from textual.widgets import Static
+
+
+class BaseToolRenderer(ABC):
+    tool_name: ClassVar[str] = ""
+
+    css_classes: ClassVar[list[str]] = ["tool-call"]
+
+    @classmethod
+    @abstractmethod
+    def render(cls, tool_data: dict[str, Any]) -> Static:
+        pass
+
+    @classmethod
+    def escape_markup(cls, text: str) -> str:
+        return cast("str", rich_escape(text))
+
+    @classmethod
+    def format_args(cls, args: dict[str, Any], max_length: int = 500) -> str:
+        if not args:
+            return ""
+
+        args_parts = []
+        for k, v in args.items():
+            str_v = str(v)
+            if len(str_v) > max_length:
+                str_v = str_v[: max_length - 3] + "..."
+            args_parts.append(f"  [dim]{k}:[/] {cls.escape_markup(str_v)}")
+        return "\n".join(args_parts)
+
+    @classmethod
+    def format_result(cls, result: Any, max_length: int = 1000) -> str:
+        if result is None:
+            return ""
+
+        str_result = str(result).strip()
+        if not str_result:
+            return ""
+
+        if len(str_result) > max_length:
+            str_result = str_result[: max_length - 3] + "..."
+        return cls.escape_markup(str_result)
+
+    @classmethod
+    def get_status_icon(cls, status: str) -> str:
+        status_icons = {
+            "running": "[#f59e0b]●[/#f59e0b] In progress...",
+            "completed": "[#22c55e]✓[/#22c55e] Done",
+            "failed": "[#dc2626]✗[/#dc2626] Failed",
+            "error": "[#dc2626]✗[/#dc2626] Error",
+        }
+        return status_icons.get(status, "[dim]○[/dim] Unknown")
+
+    @classmethod
+    def get_css_classes(cls, status: str) -> str:
+        base_classes = cls.css_classes.copy()
+        base_classes.append(f"status-{status}")
+        return " ".join(base_classes)

strix/interface/tool_components/browser_renderer.py

@@ -0,0 +1,120 @@
+from typing import Any, ClassVar
+
+from textual.widgets import Static
+
+from .base_renderer import BaseToolRenderer
+from .registry import register_tool_renderer
+
+
+@register_tool_renderer
+class BrowserRenderer(BaseToolRenderer):
+    tool_name: ClassVar[str] = "browser_action"
+    css_classes: ClassVar[list[str]] = ["tool-call", "browser-tool"]
+
+    @classmethod
+    def render(cls, tool_data: dict[str, Any]) -> Static:
+        args = tool_data.get("args", {})
+        status = tool_data.get("status", "unknown")
+
+        action = args.get("action", "unknown")
+
+        content = cls._build_sleek_content(action, args)
+
+        css_classes = cls.get_css_classes(status)
+        return Static(content, classes=css_classes)
+
+    @classmethod
+    def _build_sleek_content(cls, action: str, args: dict[str, Any]) -> str:
+        browser_icon = "🌐"
+
+        url = args.get("url")
+        text = args.get("text")
+        js_code = args.get("js_code")
+        key = args.get("key")
+        file_path = args.get("file_path")
+
+        if action in [
+            "launch",
+            "goto",
+            "new_tab",
+            "type",
+            "execute_js",
+            "click",
+            "double_click",
+            "hover",
+            "press_key",
+            "save_pdf",
+        ]:
+            if action == "launch":
+                display_url = cls._format_url(url) if url else None
+                message = (
+                    f"launching {display_url} on browser" if display_url else "launching browser"
+                )
+            elif action == "goto":
+                display_url = cls._format_url(url) if url else None
+                message = f"navigating to {display_url}" if display_url else "navigating"
+            elif action == "new_tab":
+                display_url = cls._format_url(url) if url else None
+                message = f"opening tab {display_url}" if display_url else "opening tab"
+            elif action == "type":
+                display_text = cls._format_text(text) if text else None
+                message = f"typing {display_text}" if display_text else "typing"
+            elif action == "execute_js":
+                display_js = cls._format_js(js_code) if js_code else None
+                message = (
+                    f"executing javascript\n{display_js}" if display_js else "executing javascript"
+                )
+            elif action == "press_key":
+                display_key = cls.escape_markup(key) if key else None
+                message = f"pressing key {display_key}" if display_key else "pressing key"
+            elif action == "save_pdf":
+                display_path = cls.escape_markup(file_path) if file_path else None
+                message = f"saving PDF to {display_path}" if display_path else "saving PDF"
+            else:
+                action_words = {
+                    "click": "clicking",
+                    "double_click": "double clicking",
+                    "hover": "hovering",
+                }
+                message = cls.escape_markup(action_words[action])
+
+            return f"{browser_icon} [#06b6d4]{message}[/]"
+
+        simple_actions = {
+            "back": "going back in browser history",
+            "forward": "going forward in browser history",
+            "scroll_down": "scrolling down",
+            "scroll_up": "scrolling up",
+            "refresh": "refreshing browser tab",
+            "close_tab": "closing browser tab",
+            "switch_tab": "switching browser tab",
+            "list_tabs": "listing browser tabs",
+            "view_source": "viewing page source",
+            "get_console_logs": "getting console logs",
+            "screenshot": "taking screenshot of browser tab",
+            "wait": "waiting...",
+            "close": "closing browser",
+        }
+
+        if action in simple_actions:
+            return f"{browser_icon} [#06b6d4]{cls.escape_markup(simple_actions[action])}[/]"
+
+        return f"{browser_icon} [#06b6d4]{cls.escape_markup(action)}[/]"
+
+    @classmethod
+    def _format_url(cls, url: str) -> str:
+        if len(url) > 300:
+            url = url[:297] + "..."
+        return cls.escape_markup(url)
+
+    @classmethod
+    def _format_text(cls, text: str) -> str:
+        if len(text) > 200:
+            text = text[:197] + "..."
+        return cls.escape_markup(text)
+
+    @classmethod
+    def _format_js(cls, js_code: str) -> str:
+        if len(js_code) > 200:
+            js_code = js_code[:197] + "..."
+        return f"[white]{cls.escape_markup(js_code)}[/white]"

strix/interface/tool_components/file_edit_renderer.py

@@ -0,0 +1,99 @@
+from typing import Any, ClassVar
+
+from textual.widgets import Static
+
+from .base_renderer import BaseToolRenderer
+from .registry import register_tool_renderer
+
+
+@register_tool_renderer
+class StrReplaceEditorRenderer(BaseToolRenderer):
+    tool_name: ClassVar[str] = "str_replace_editor"
+    css_classes: ClassVar[list[str]] = ["tool-call", "file-edit-tool"]
+
+    @classmethod
+    def render(cls, tool_data: dict[str, Any]) -> Static:
+        args = tool_data.get("args", {})
+        result = tool_data.get("result")
+
+        command = args.get("command", "")
+        path = args.get("path", "")
+
+        if command == "view":
+            header = "📖 [bold #10b981]Reading file[/]"
+        elif command == "str_replace":
+            header = "✏️ [bold #10b981]Editing file[/]"
+        elif command == "create":
+            header = "📝 [bold #10b981]Creating file[/]"
+        elif command == "insert":
+            header = "✏️ [bold #10b981]Inserting text[/]"
+        elif command == "undo_edit":
+            header = "↩️ [bold #10b981]Undoing edit[/]"
+        else:
+            header = "📄 [bold #10b981]File operation[/]"
+
+        if (result and isinstance(result, dict) and "content" in result) or path:
+            path_display = path[-60:] if len(path) > 60 else path
+            content_text = f"{header} [dim]{cls.escape_markup(path_display)}[/]"
+        else:
+            content_text = f"{header} [dim]Processing...[/]"
+
+        css_classes = cls.get_css_classes("completed")
+        return Static(content_text, classes=css_classes)
+
+
+@register_tool_renderer
+class ListFilesRenderer(BaseToolRenderer):
+    tool_name: ClassVar[str] = "list_files"
+    css_classes: ClassVar[list[str]] = ["tool-call", "file-edit-tool"]
+
+    @classmethod
+    def render(cls, tool_data: dict[str, Any]) -> Static:
+        args = tool_data.get("args", {})
+
+        path = args.get("path", "")
+
+        header = "📂 [bold #10b981]Listing files[/]"
+
+        if path:
+            path_display = path[-60:] if len(path) > 60 else path
+            content_text = f"{header} [dim]{cls.escape_markup(path_display)}[/]"
+        else:
+            content_text = f"{header} [dim]Current directory[/]"
+
+        css_classes = cls.get_css_classes("completed")
+        return Static(content_text, classes=css_classes)
+
+
+@register_tool_renderer
+class SearchFilesRenderer(BaseToolRenderer):
+    tool_name: ClassVar[str] = "search_files"
+    css_classes: ClassVar[list[str]] = ["tool-call", "file-edit-tool"]
+
+    @classmethod
+    def render(cls, tool_data: dict[str, Any]) -> Static:
+        args = tool_data.get("args", {})
+
+        path = args.get("path", "")
+        regex = args.get("regex", "")
+
+        header = "🔍 [bold purple]Searching files[/]"
+
+        if path and regex:
+            path_display = path[-30:] if len(path) > 30 else path
+            regex_display = regex[:30] if len(regex) > 30 else regex
+            content_text = (
+                f"{header} [dim]{cls.escape_markup(path_display)} for "
+                f"'{cls.escape_markup(regex_display)}'[/]"
+            )
+        elif path:
+            path_display = path[-60:] if len(path) > 60 else path
+            content_text = f"{header} [dim]{cls.escape_markup(path_display)}[/]"
+        elif regex:
+            regex_display = regex[:60] if len(regex) > 60 else regex
+            content_text = f"{header} [dim]'{cls.escape_markup(regex_display)}'[/]"
+        else:
+            content_text = f"{header} [dim]Searching...[/]"
+
+        css_classes = cls.get_css_classes("completed")
+        return Static(content_text, classes=css_classes)

strix/interface/tool_components/finish_renderer.py

@@ -0,0 +1,31 @@
+from typing import Any, ClassVar
+
+from textual.widgets import Static
+
+from .base_renderer import BaseToolRenderer
+from .registry import register_tool_renderer
+
+
+@register_tool_renderer
+class FinishScanRenderer(BaseToolRenderer):
+    tool_name: ClassVar[str] = "finish_scan"
+    css_classes: ClassVar[list[str]] = ["tool-call", "finish-tool"]
+
+    @classmethod
+    def render(cls, tool_data: dict[str, Any]) -> Static:
+        args = tool_data.get("args", {})
+
+        content = args.get("content", "")
+        success = args.get("success", True)
+
+        header = (
+            "🏁 [bold #dc2626]Finishing Scan[/]" if success else "🏁 [bold #dc2626]Scan Failed[/]"
+        )
+
+        if content:
+            content_text = f"{header}\n  [bold]{cls.escape_markup(content)}[/]"
+        else:
+            content_text = f"{header}\n  [dim]Generating final report...[/]"
+
+        css_classes = cls.get_css_classes("completed")
+        return Static(content_text, classes=css_classes)

strix/interface/tool_components/notes_renderer.py

@@ -0,0 +1,108 @@
+from typing import Any, ClassVar
+
+from textual.widgets import Static
+
+from .base_renderer import BaseToolRenderer
+from .registry import register_tool_renderer
+
+
+@register_tool_renderer
+class CreateNoteRenderer(BaseToolRenderer):
+    tool_name: ClassVar[str] = "create_note"
+    css_classes: ClassVar[list[str]] = ["tool-call", "notes-tool"]
+
+    @classmethod
+    def render(cls, tool_data: dict[str, Any]) -> Static:
+        args = tool_data.get("args", {})
+
+        title = args.get("title", "")
+        content = args.get("content", "")
+
+        header = "📝 [bold #fbbf24]Note[/]"
+
+        if title:
+            title_display = title[:100] + "..." if len(title) > 100 else title
+            note_parts = [f"{header}\n  [bold]{cls.escape_markup(title_display)}[/]"]
+
+            if content:
+                content_display = content[:200] + "..." if len(content) > 200 else content
+                note_parts.append(f"  [dim]{cls.escape_markup(content_display)}[/]")
+
+            content_text = "\n".join(note_parts)
+        else:
+            content_text = f"{header}\n  [dim]Creating note...[/]"
+
+        css_classes = cls.get_css_classes("completed")
+        return Static(content_text, classes=css_classes)
+
+
+@register_tool_renderer
+class DeleteNoteRenderer(BaseToolRenderer):
+    tool_name: ClassVar[str] = "delete_note"
+    css_classes: ClassVar[list[str]] = ["tool-call", "notes-tool"]
+
+    @classmethod
+    def render(cls, tool_data: dict[str, Any]) -> Static:  # noqa: ARG003
+        header = "🗑️ [bold #fbbf24]Delete Note[/]"
+        content_text = f"{header}\n  [dim]Deleting...[/]"
+
+        css_classes = cls.get_css_classes("completed")
+        return Static(content_text, classes=css_classes)
+
+
+@register_tool_renderer
+class UpdateNoteRenderer(BaseToolRenderer):
+    tool_name: ClassVar[str] = "update_note"
+    css_classes: ClassVar[list[str]] = ["tool-call", "notes-tool"]
+
+    @classmethod
+    def render(cls, tool_data: dict[str, Any]) -> Static:
+        args = tool_data.get("args", {})
+
+        title = args.get("title", "")
+        content = args.get("content", "")
+
+        header = "✏️ [bold #fbbf24]Update Note[/]"
+
+        if title or content:
+            note_parts = [header]
+
+            if title:
+                title_display = title[:100] + "..." if len(title) > 100 else title
+                note_parts.append(f"  [bold]{cls.escape_markup(title_display)}[/]")
+
+            if content:
+                content_display = content[:200] + "..." if len(content) > 200 else content
+                note_parts.append(f"  [dim]{cls.escape_markup(content_display)}[/]")
+
+            content_text = "\n".join(note_parts)
+        else:
+            content_text = f"{header}\n  [dim]Updating...[/]"
+
+        css_classes = cls.get_css_classes("completed")
+        return Static(content_text, classes=css_classes)
+
+
+@register_tool_renderer
+class ListNotesRenderer(BaseToolRenderer):
+    tool_name: ClassVar[str] = "list_notes"
+    css_classes: ClassVar[list[str]] = ["tool-call", "notes-tool"]
+
+    @classmethod
+    def render(cls, tool_data: dict[str, Any]) -> Static:
+        result = tool_data.get("result")
+
+        header = "📋 [bold #fbbf24]Listing notes[/]"
+
+        if result and isinstance(result, dict) and "notes" in result:
+            notes = result["notes"]
+            if isinstance(notes, list):
+                count = len(notes)
+                content_text = f"{header}\n  [dim]{count} notes found[/]"
+            else:
+                content_text = f"{header}\n  [dim]No notes found[/]"
+        else:
+            content_text = f"{header}\n  [dim]Listing notes...[/]"
+
+        css_classes = cls.get_css_classes("completed")
+        return Static(content_text, classes=css_classes)

strix/interface/tool_components/proxy_renderer.py

@@ -0,0 +1,255 @@
+from typing import Any, ClassVar
+
+from textual.widgets import Static
+
+from .base_renderer import BaseToolRenderer
+from .registry import register_tool_renderer
+
+
+@register_tool_renderer
+class ListRequestsRenderer(BaseToolRenderer):
+    tool_name: ClassVar[str] = "list_requests"
+    css_classes: ClassVar[list[str]] = ["tool-call", "proxy-tool"]
+
+    @classmethod
+    def render(cls, tool_data: dict[str, Any]) -> Static:
+        args = tool_data.get("args", {})
+        result = tool_data.get("result")
+
+        httpql_filter = args.get("httpql_filter")
+
+        header = "📋 [bold #06b6d4]Listing requests[/]"
+
+        if result and isinstance(result, dict) and "requests" in result:
+            requests = result["requests"]
+            if isinstance(requests, list) and requests:
+                request_lines = []
+                for req in requests[:3]:
+                    if isinstance(req, dict):
+                        method = req.get("method", "?")
+                        path = req.get("path", "?")
+                        response = req.get("response") or {}
+                        status = response.get("statusCode", "?")
+                        line = f"{method} {path} → {status}"
+                        request_lines.append(line)
+
+                if len(requests) > 3:
+                    request_lines.append(f"... +{len(requests) - 3} more")
+
+                escaped_lines = [cls.escape_markup(line) for line in request_lines]
+                content_text = f"{header}\n  [dim]{chr(10).join(escaped_lines)}[/]"
+            else:
+                content_text = f"{header}\n  [dim]No requests found[/]"
+        elif httpql_filter:
+            filter_display = (
+                httpql_filter[:300] + "..." if len(httpql_filter) > 300 else httpql_filter
+            )
+            content_text = f"{header}\n  [dim]{cls.escape_markup(filter_display)}[/]"
+        else:
+            content_text = f"{header}\n  [dim]All requests[/]"
+
+        css_classes = cls.get_css_classes("completed")
+        return Static(content_text, classes=css_classes)
+
+
+@register_tool_renderer
+class ViewRequestRenderer(BaseToolRenderer):
+    tool_name: ClassVar[str] = "view_request"
+    css_classes: ClassVar[list[str]] = ["tool-call", "proxy-tool"]
+
+    @classmethod
+    def render(cls, tool_data: dict[str, Any]) -> Static:
+        args = tool_data.get("args", {})
+        result = tool_data.get("result")
+
+        part = args.get("part", "request")
+
+        header = f"👀 [bold #06b6d4]Viewing {cls.escape_markup(part)}[/]"
+
+        if result and isinstance(result, dict):
+            if "content" in result:
+                content = result["content"]
+                content_preview = content[:500] + "..." if len(content) > 500 else content
+                content_text = f"{header}\n  [dim]{cls.escape_markup(content_preview)}[/]"
+            elif "matches" in result:
+                matches = result["matches"]
+                if isinstance(matches, list) and matches:
+                    match_lines = [
+                        match["match"]
+                        for match in matches[:3]
+                        if isinstance(match, dict) and "match" in match
+                    ]
+                    if len(matches) > 3:
+                        match_lines.append(f"... +{len(matches) - 3} more matches")
+                    escaped_lines = [cls.escape_markup(line) for line in match_lines]
+                    content_text = f"{header}\n  [dim]{chr(10).join(escaped_lines)}[/]"
+                else:
+                    content_text = f"{header}\n  [dim]No matches found[/]"
+            else:
+                content_text = f"{header}\n  [dim]Viewing content...[/]"
+        else:
+            content_text = f"{header}\n  [dim]Loading...[/]"
+
+        css_classes = cls.get_css_classes("completed")
+        return Static(content_text, classes=css_classes)
+
+
+@register_tool_renderer
+class SendRequestRenderer(BaseToolRenderer):
+    tool_name: ClassVar[str] = "send_request"
+    css_classes: ClassVar[list[str]] = ["tool-call", "proxy-tool"]
+
+    @classmethod
+    def render(cls, tool_data: dict[str, Any]) -> Static:
+        args = tool_data.get("args", {})
+        result = tool_data.get("result")
+
+        method = args.get("method", "GET")
+        url = args.get("url", "")
+
+        header = f"📤 [bold #06b6d4]Sending {cls.escape_markup(method)}[/]"
+
+        if result and isinstance(result, dict):
+            status_code = result.get("status_code")
+            response_body = result.get("body", "")
+
+            if status_code:
+                response_preview = f"Status: {status_code}"
+                if response_body:
+                    body_preview = (
+                        response_body[:300] + "..." if len(response_body) > 300 else response_body
+                    )
+                    response_preview += f"\n{body_preview}"
+                content_text = f"{header}\n  [dim]{cls.escape_markup(response_preview)}[/]"
+            else:
+                content_text = f"{header}\n  [dim]Response received[/]"
+        elif url:
+            url_display = url[:400] + "..." if len(url) > 400 else url
+            content_text = f"{header}\n  [dim]{cls.escape_markup(url_display)}[/]"
+        else:
+            content_text = f"{header}\n  [dim]Sending...[/]"
+
+        css_classes = cls.get_css_classes("completed")
+        return Static(content_text, classes=css_classes)
+
+
+@register_tool_renderer
+class RepeatRequestRenderer(BaseToolRenderer):
+    tool_name: ClassVar[str] = "repeat_request"
+    css_classes: ClassVar[list[str]] = ["tool-call", "proxy-tool"]
+
+    @classmethod
+    def render(cls, tool_data: dict[str, Any]) -> Static:
+        args = tool_data.get("args", {})
+        result = tool_data.get("result")
+
+        modifications = args.get("modifications", {})
+
+        header = "🔄 [bold #06b6d4]Repeating request[/]"
+
+        if result and isinstance(result, dict):
+            status_code = result.get("status_code")
+            response_body = result.get("body", "")
+
+            if status_code:
+                response_preview = f"Status: {status_code}"
+                if response_body:
+                    body_preview = (
+                        response_body[:300] + "..." if len(response_body) > 300 else response_body
+                    )
+                    response_preview += f"\n{body_preview}"
+                content_text = f"{header}\n  [dim]{cls.escape_markup(response_preview)}[/]"
+            else:
+                content_text = f"{header}\n  [dim]Response received[/]"
+        elif modifications:
+            mod_text = str(modifications)
+            mod_display = mod_text[:400] + "..." if len(mod_text) > 400 else mod_text
+            content_text = f"{header}\n  [dim]{cls.escape_markup(mod_display)}[/]"
+        else:
+            content_text = f"{header}\n  [dim]No modifications[/]"
+
+        css_classes = cls.get_css_classes("completed")
+        return Static(content_text, classes=css_classes)
+
+
+@register_tool_renderer
+class ScopeRulesRenderer(BaseToolRenderer):
+    tool_name: ClassVar[str] = "scope_rules"
+    css_classes: ClassVar[list[str]] = ["tool-call", "proxy-tool"]
+
+    @classmethod
+    def render(cls, tool_data: dict[str, Any]) -> Static:  # noqa: ARG003
+        header = "⚙️ [bold #06b6d4]Updating proxy scope[/]"
+        content_text = f"{header}\n  [dim]Configuring...[/]"
+
+        css_classes = cls.get_css_classes("completed")
+        return Static(content_text, classes=css_classes)
+
+
+@register_tool_renderer
+class ListSitemapRenderer(BaseToolRenderer):
+    tool_name: ClassVar[str] = "list_sitemap"
+    css_classes: ClassVar[list[str]] = ["tool-call", "proxy-tool"]
+
+    @classmethod
+    def render(cls, tool_data: dict[str, Any]) -> Static:
+        result = tool_data.get("result")
+
+        header = "🗺️ [bold #06b6d4]Listing sitemap[/]"
+
+        if result and isinstance(result, dict) and "entries" in result:
+            entries = result["entries"]
+            if isinstance(entries, list) and entries:
+                entry_lines = []
+                for entry in entries[:4]:
+                    if isinstance(entry, dict):
+                        label = entry.get("label", "?")
+                        kind = entry.get("kind", "?")
+                        line = f"{kind}: {label}"
+                        entry_lines.append(line)
+
+                if len(entries) > 4:
+                    entry_lines.append(f"... +{len(entries) - 4} more")
+
+                escaped_lines = [cls.escape_markup(line) for line in entry_lines]
+                content_text = f"{header}\n  [dim]{chr(10).join(escaped_lines)}[/]"
+            else:
+                content_text = f"{header}\n  [dim]No entries found[/]"
+        else:
+            content_text = f"{header}\n  [dim]Loading...[/]"
+
+        css_classes = cls.get_css_classes("completed")
+        return Static(content_text, classes=css_classes)
+
+
+@register_tool_renderer
+class ViewSitemapEntryRenderer(BaseToolRenderer):
+    tool_name: ClassVar[str] = "view_sitemap_entry"
+    css_classes: ClassVar[list[str]] = ["tool-call", "proxy-tool"]
+
+    @classmethod
+    def render(cls, tool_data: dict[str, Any]) -> Static:
+        result = tool_data.get("result")
+
+        header = "📍 [bold #06b6d4]Viewing sitemap entry[/]"
+
+        if result and isinstance(result, dict):
+            if "entry" in result:
+                entry = result["entry"]
+                if isinstance(entry, dict):
+                    label = entry.get("label", "")
+                    kind = entry.get("kind", "")
+                    if label and kind:
+                        entry_info = f"{kind}: {label}"
+                        content_text = f"{header}\n  [dim]{cls.escape_markup(entry_info)}[/]"
+                    else:
+                        content_text = f"{header}\n  [dim]Entry details loaded[/]"
+                else:
+                    content_text = f"{header}\n  [dim]Entry details loaded[/]"
+            else:
+                content_text = f"{header}\n  [dim]Loading entry...[/]"
+        else:
+            content_text = f"{header}\n  [dim]Loading...[/]"
+
+        css_classes = cls.get_css_classes("completed")
+        return Static(content_text, classes=css_classes)