strix-agent 0.1.1__py3-none-any.whl

strix/cli/tool_components/agents_graph_renderer.py

@@ -0,0 +1,129 @@
+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 ViewAgentGraphRenderer(BaseToolRenderer):
+    tool_name: ClassVar[str] = "view_agent_graph"
+    css_classes: ClassVar[list[str]] = ["tool-call", "agents-graph-tool"]
+
+    @classmethod
+    def render(cls, tool_data: dict[str, Any]) -> Static:  # noqa: ARG003
+        content_text = "🕸️ [bold #fbbf24]Viewing agents graph[/]"
+
+        css_classes = cls.get_css_classes("completed")
+        return Static(content_text, classes=css_classes)
+
+
+@register_tool_renderer
+class CreateAgentRenderer(BaseToolRenderer):
+    tool_name: ClassVar[str] = "create_agent"
+    css_classes: ClassVar[list[str]] = ["tool-call", "agents-graph-tool"]
+
+    @classmethod
+    def render(cls, tool_data: dict[str, Any]) -> Static:
+        args = tool_data.get("args", {})
+
+        task = args.get("task", "")
+        name = args.get("name", "Agent")
+
+        header = f"🤖 [bold #fbbf24]Creating {name}[/]"
+
+        if task:
+            task_display = task[:400] + "..." if len(task) > 400 else task
+            content_text = f"{header}\n  [dim]{cls.escape_markup(task_display)}[/]"
+        else:
+            content_text = f"{header}\n  [dim]Spawning agent...[/]"
+
+        css_classes = cls.get_css_classes("completed")
+        return Static(content_text, classes=css_classes)
+
+
+@register_tool_renderer
+class SendMessageToAgentRenderer(BaseToolRenderer):
+    tool_name: ClassVar[str] = "send_message_to_agent"
+    css_classes: ClassVar[list[str]] = ["tool-call", "agents-graph-tool"]
+
+    @classmethod
+    def render(cls, tool_data: dict[str, Any]) -> Static:
+        args = tool_data.get("args", {})
+
+        message = args.get("message", "")
+
+        header = "💬 [bold #fbbf24]Sending message[/]"
+
+        if message:
+            message_display = message[:400] + "..." if len(message) > 400 else message
+            content_text = f"{header}\n  [dim]{cls.escape_markup(message_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 AgentFinishRenderer(BaseToolRenderer):
+    tool_name: ClassVar[str] = "agent_finish"
+    css_classes: ClassVar[list[str]] = ["tool-call", "agents-graph-tool"]
+
+    @classmethod
+    def render(cls, tool_data: dict[str, Any]) -> Static:
+        args = tool_data.get("args", {})
+
+        result_summary = args.get("result_summary", "")
+        findings = args.get("findings", [])
+        success = args.get("success", True)
+
+        header = (
+            "🏁 [bold #fbbf24]Agent completed[/]" if success else "🏁 [bold #fbbf24]Agent failed[/]"
+        )
+
+        if result_summary:
+            summary_display = (
+                result_summary[:400] + "..." if len(result_summary) > 400 else result_summary
+            )
+            content_parts = [f"{header}\n  [bold]{cls.escape_markup(summary_display)}[/]"]
+
+            if findings and isinstance(findings, list):
+                finding_lines = [f"• {finding}" for finding in findings[:3]]
+                if len(findings) > 3:
+                    finding_lines.append(f"• ... +{len(findings) - 3} more findings")
+
+                content_parts.append(
+                    f"  [dim]{chr(10).join([cls.escape_markup(line) for line in finding_lines])}[/]"
+                )
+
+            content_text = "\n".join(content_parts)
+        else:
+            content_text = f"{header}\n  [dim]Completing task...[/]"
+
+        css_classes = cls.get_css_classes("completed")
+        return Static(content_text, classes=css_classes)
+
+
+@register_tool_renderer
+class WaitForMessageRenderer(BaseToolRenderer):
+    tool_name: ClassVar[str] = "wait_for_message"
+    css_classes: ClassVar[list[str]] = ["tool-call", "agents-graph-tool"]
+
+    @classmethod
+    def render(cls, tool_data: dict[str, Any]) -> Static:
+        args = tool_data.get("args", {})
+
+        reason = args.get("reason", "Waiting for messages from other agents or user input")
+
+        header = "⏸️ [bold #fbbf24]Waiting for messages[/]"
+
+        if reason:
+            reason_display = reason[:400] + "..." if len(reason) > 400 else reason
+            content_text = f"{header}\n  [dim]{cls.escape_markup(reason_display)}[/]"
+        else:
+            content_text = f"{header}\n  [dim]Agent paused until message received...[/]"
+
+        css_classes = cls.get_css_classes("completed")
+        return Static(content_text, classes=css_classes)

strix/cli/tool_components/base_renderer.py

@@ -0,0 +1,61 @@
+from abc import ABC, abstractmethod
+from typing import Any, ClassVar
+
+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 text.replace("[", "\\[").replace("]", "\\]")
+
+    @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/cli/tool_components/browser_renderer.py

@@ -0,0 +1,107 @@
+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")
+
+        if action in [
+            "launch",
+            "goto",
+            "new_tab",
+            "type",
+            "execute_js",
+            "click",
+            "double_click",
+            "hover",
+        ]:
+            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"
+                )
+            else:
+                action_words = {
+                    "click": "clicking",
+                    "double_click": "double clicking",
+                    "hover": "hovering",
+                }
+                message = action_words[action]
+
+            return f"{browser_icon} [#06b6d4]{message}[/]"
+
+        simple_actions = {
+            "back": "going back in browser history",
+            "forward": "going forward in browser history",
+            "refresh": "refreshing browser tab",
+            "close_tab": "closing browser tab",
+            "switch_tab": "switching browser tab",
+            "list_tabs": "listing browser tabs",
+            "view_source": "viewing page source",
+            "screenshot": "taking screenshot of browser tab",
+            "wait": "waiting...",
+            "close": "closing browser",
+        }
+
+        if action in simple_actions:
+            return f"{browser_icon} [#06b6d4]{simple_actions[action]}[/]"
+
+        return f"{browser_icon} [#06b6d4]{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/cli/tool_components/file_edit_renderer.py

@@ -0,0 +1,95 @@
+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[/]"
+        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/cli/tool_components/finish_renderer.py

@@ -0,0 +1,32 @@
+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_display = content[:600] + "..." if len(content) > 600 else content
+            content_text = f"{header}\n  [bold]{cls.escape_markup(content_display)}[/]"
+        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/cli/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)