strix-agent 0.4.0__py3-none-any.whl

strix/interface/tool_components/python_renderer.py

@@ -0,0 +1,34 @@
+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 PythonRenderer(BaseToolRenderer):
+    tool_name: ClassVar[str] = "python_action"
+    css_classes: ClassVar[list[str]] = ["tool-call", "python-tool"]
+
+    @classmethod
+    def render(cls, tool_data: dict[str, Any]) -> Static:
+        args = tool_data.get("args", {})
+
+        action = args.get("action", "")
+        code = args.get("code", "")
+
+        header = "</> [bold #3b82f6]Python[/]"
+
+        if code and action in ["new_session", "execute"]:
+            code_display = code[:600] + "..." if len(code) > 600 else code
+            content_text = f"{header}\n  [italic white]{cls.escape_markup(code_display)}[/]"
+        elif action == "close":
+            content_text = f"{header}\n  [dim]Closing session...[/]"
+        elif action == "list_sessions":
+            content_text = f"{header}\n  [dim]Listing sessions...[/]"
+        else:
+            content_text = f"{header}\n  [dim]Running...[/]"
+
+        css_classes = cls.get_css_classes("completed")
+        return Static(content_text, classes=css_classes)

strix/interface/tool_components/registry.py

@@ -0,0 +1,72 @@
+from typing import Any, ClassVar
+
+from textual.widgets import Static
+
+from .base_renderer import BaseToolRenderer
+
+
+class ToolTUIRegistry:
+    _renderers: ClassVar[dict[str, type[BaseToolRenderer]]] = {}
+
+    @classmethod
+    def register(cls, renderer_class: type[BaseToolRenderer]) -> None:
+        if not renderer_class.tool_name:
+            raise ValueError(f"Renderer {renderer_class.__name__} must define tool_name")
+
+        cls._renderers[renderer_class.tool_name] = renderer_class
+
+    @classmethod
+    def get_renderer(cls, tool_name: str) -> type[BaseToolRenderer] | None:
+        return cls._renderers.get(tool_name)
+
+    @classmethod
+    def list_tools(cls) -> list[str]:
+        return list(cls._renderers.keys())
+
+    @classmethod
+    def has_renderer(cls, tool_name: str) -> bool:
+        return tool_name in cls._renderers
+
+
+def register_tool_renderer(renderer_class: type[BaseToolRenderer]) -> type[BaseToolRenderer]:
+    ToolTUIRegistry.register(renderer_class)
+    return renderer_class
+
+
+def get_tool_renderer(tool_name: str) -> type[BaseToolRenderer] | None:
+    return ToolTUIRegistry.get_renderer(tool_name)
+
+
+def render_tool_widget(tool_data: dict[str, Any]) -> Static:
+    tool_name = tool_data.get("tool_name", "")
+    renderer = get_tool_renderer(tool_name)
+
+    if renderer:
+        return renderer.render(tool_data)
+    return _render_default_tool_widget(tool_data)
+
+
+def _render_default_tool_widget(tool_data: dict[str, Any]) -> Static:
+    tool_name = BaseToolRenderer.escape_markup(tool_data.get("tool_name", "Unknown Tool"))
+    args = tool_data.get("args", {})
+    status = tool_data.get("status", "unknown")
+    result = tool_data.get("result")
+
+    status_text = BaseToolRenderer.get_status_icon(status)
+
+    header = f"→ Using tool [bold blue]{BaseToolRenderer.escape_markup(tool_name)}[/]"
+    content_parts = [header]
+
+    args_str = BaseToolRenderer.format_args(args)
+    if args_str:
+        content_parts.append(args_str)
+
+    if status in ["completed", "failed", "error"] and result is not None:
+        result_str = BaseToolRenderer.format_result(result)
+        if result_str:
+            content_parts.append(f"[bold]Result:[/] {result_str}")
+    else:
+        content_parts.append(status_text)
+
+    css_classes = BaseToolRenderer.get_css_classes(status)
+    return Static("\n".join(content_parts), classes=css_classes)

strix/interface/tool_components/reporting_renderer.py

@@ -0,0 +1,53 @@
+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 CreateVulnerabilityReportRenderer(BaseToolRenderer):
+    tool_name: ClassVar[str] = "create_vulnerability_report"
+    css_classes: ClassVar[list[str]] = ["tool-call", "reporting-tool"]
+
+    @classmethod
+    def render(cls, tool_data: dict[str, Any]) -> Static:
+        args = tool_data.get("args", {})
+
+        title = args.get("title", "")
+        severity = args.get("severity", "")
+        content = args.get("content", "")
+
+        header = "🐞 [bold #ea580c]Vulnerability Report[/]"
+
+        if title:
+            content_parts = [f"{header}\n  [bold]{cls.escape_markup(title)}[/]"]
+
+            if severity:
+                severity_color = cls._get_severity_color(severity.lower())
+                content_parts.append(
+                    f"  [dim]Severity: [{severity_color}]"
+                    f"{cls.escape_markup(severity.upper())}[/{severity_color}][/]"
+                )
+
+            if content:
+                content_parts.append(f"  [dim]{cls.escape_markup(content)}[/]")
+
+            content_text = "\n".join(content_parts)
+        else:
+            content_text = f"{header}\n  [dim]Creating report...[/]"
+
+        css_classes = cls.get_css_classes("completed")
+        return Static(content_text, classes=css_classes)
+
+    @classmethod
+    def _get_severity_color(cls, severity: str) -> str:
+        severity_colors = {
+            "critical": "#dc2626",
+            "high": "#ea580c",
+            "medium": "#d97706",
+            "low": "#65a30d",
+            "info": "#0284c7",
+        }
+        return severity_colors.get(severity, "#6b7280")

strix/interface/tool_components/scan_info_renderer.py

@@ -0,0 +1,64 @@
+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 ScanStartInfoRenderer(BaseToolRenderer):
+    tool_name: ClassVar[str] = "scan_start_info"
+    css_classes: ClassVar[list[str]] = ["tool-call", "scan-info-tool"]
+
+    @classmethod
+    def render(cls, tool_data: dict[str, Any]) -> Static:
+        args = tool_data.get("args", {})
+        status = tool_data.get("status", "unknown")
+
+        targets = args.get("targets", [])
+
+        if len(targets) == 1:
+            target_display = cls._build_single_target_display(targets[0])
+            content = f"🚀 Starting penetration test on {target_display}"
+        elif len(targets) > 1:
+            content = f"🚀 Starting penetration test on {len(targets)} targets"
+            for target_info in targets:
+                target_display = cls._build_single_target_display(target_info)
+                content += f"\n   • {target_display}"
+        else:
+            content = "🚀 Starting penetration test"
+
+        css_classes = cls.get_css_classes(status)
+        return Static(content, classes=css_classes)
+
+    @classmethod
+    def _build_single_target_display(cls, target_info: dict[str, Any]) -> str:
+        original = target_info.get("original")
+        if original:
+            return cls.escape_markup(str(original))
+
+        return "unknown target"
+
+
+@register_tool_renderer
+class SubagentStartInfoRenderer(BaseToolRenderer):
+    tool_name: ClassVar[str] = "subagent_start_info"
+    css_classes: ClassVar[list[str]] = ["tool-call", "subagent-info-tool"]
+
+    @classmethod
+    def render(cls, tool_data: dict[str, Any]) -> Static:
+        args = tool_data.get("args", {})
+        status = tool_data.get("status", "unknown")
+
+        name = args.get("name", "Unknown Agent")
+        task = args.get("task", "")
+
+        name = cls.escape_markup(str(name))
+        content = f"🤖 Spawned subagent {name}"
+        if task:
+            task = cls.escape_markup(str(task))
+            content += f"\n    Task: {task}"
+
+        css_classes = cls.get_css_classes(status)
+        return Static(content, classes=css_classes)

strix/interface/tool_components/terminal_renderer.py

@@ -0,0 +1,131 @@
+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 TerminalRenderer(BaseToolRenderer):
+    tool_name: ClassVar[str] = "terminal_execute"
+    css_classes: ClassVar[list[str]] = ["tool-call", "terminal-tool"]
+
+    @classmethod
+    def render(cls, tool_data: dict[str, Any]) -> Static:
+        args = tool_data.get("args", {})
+        status = tool_data.get("status", "unknown")
+        result = tool_data.get("result", {})
+
+        command = args.get("command", "")
+        is_input = args.get("is_input", False)
+        terminal_id = args.get("terminal_id", "default")
+        timeout = args.get("timeout")
+
+        content = cls._build_sleek_content(command, is_input, terminal_id, timeout, result)
+
+        css_classes = cls.get_css_classes(status)
+        return Static(content, classes=css_classes)
+
+    @classmethod
+    def _build_sleek_content(
+        cls,
+        command: str,
+        is_input: bool,
+        terminal_id: str,  # noqa: ARG003
+        timeout: float | None,  # noqa: ARG003
+        result: dict[str, Any],  # noqa: ARG003
+    ) -> str:
+        terminal_icon = ">_"
+
+        if not command.strip():
+            return f"{terminal_icon} [dim]getting logs...[/]"
+
+        control_sequences = {
+            "C-c",
+            "C-d",
+            "C-z",
+            "C-a",
+            "C-e",
+            "C-k",
+            "C-l",
+            "C-u",
+            "C-w",
+            "C-r",
+            "C-s",
+            "C-t",
+            "C-y",
+            "^c",
+            "^d",
+            "^z",
+            "^a",
+            "^e",
+            "^k",
+            "^l",
+            "^u",
+            "^w",
+            "^r",
+            "^s",
+            "^t",
+            "^y",
+        }
+        special_keys = {
+            "Enter",
+            "Escape",
+            "Space",
+            "Tab",
+            "BTab",
+            "BSpace",
+            "DC",
+            "IC",
+            "Up",
+            "Down",
+            "Left",
+            "Right",
+            "Home",
+            "End",
+            "PageUp",
+            "PageDown",
+            "PgUp",
+            "PgDn",
+            "PPage",
+            "NPage",
+            "F1",
+            "F2",
+            "F3",
+            "F4",
+            "F5",
+            "F6",
+            "F7",
+            "F8",
+            "F9",
+            "F10",
+            "F11",
+            "F12",
+        }
+
+        is_special = (
+            command in control_sequences
+            or command in special_keys
+            or command.startswith(("M-", "S-", "C-S-", "C-M-", "S-M-"))
+        )
+
+        if is_special:
+            return f"{terminal_icon} [#ef4444]{cls.escape_markup(command)}[/]"
+
+        if is_input:
+            formatted_command = cls._format_command_display(command)
+            return f"{terminal_icon} [#3b82f6]>>>[/] [#22c55e]{formatted_command}[/]"
+
+        formatted_command = cls._format_command_display(command)
+        return f"{terminal_icon} [#22c55e]$ {formatted_command}[/]"
+
+    @classmethod
+    def _format_command_display(cls, command: str) -> str:
+        if not command:
+            return ""
+
+        if len(command) > 400:
+            command = command[:397] + "..."
+
+        return cls.escape_markup(command)

strix/interface/tool_components/thinking_renderer.py

@@ -0,0 +1,29 @@
+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 ThinkRenderer(BaseToolRenderer):
+    tool_name: ClassVar[str] = "think"
+    css_classes: ClassVar[list[str]] = ["tool-call", "thinking-tool"]
+
+    @classmethod
+    def render(cls, tool_data: dict[str, Any]) -> Static:
+        args = tool_data.get("args", {})
+
+        thought = args.get("thought", "")
+
+        header = "🧠 [bold #a855f7]Thinking[/]"
+
+        if thought:
+            thought_display = thought[:600] + "..." if len(thought) > 600 else thought
+            content = f"{header}\n  [italic dim]{cls.escape_markup(thought_display)}[/]"
+        else:
+            content = f"{header}\n  [italic dim]Thinking...[/]"
+
+        css_classes = cls.get_css_classes("completed")
+        return Static(content, classes=css_classes)

strix/interface/tool_components/user_message_renderer.py

@@ -0,0 +1,43 @@
+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 UserMessageRenderer(BaseToolRenderer):
+    tool_name: ClassVar[str] = "user_message"
+    css_classes: ClassVar[list[str]] = ["chat-message", "user-message"]
+
+    @classmethod
+    def render(cls, message_data: dict[str, Any]) -> Static:
+        content = message_data.get("content", "")
+
+        if not content:
+            return Static("", classes=cls.css_classes)
+
+        if len(content) > 300:
+            content = content[:297] + "..."
+
+        lines = content.split("\n")
+        bordered_lines = [f"[#3b82f6]▍[/#3b82f6] {line}" for line in lines]
+        bordered_content = "\n".join(bordered_lines)
+        formatted_content = f"[#3b82f6]▍[/#3b82f6] [bold]You:[/]\n{bordered_content}"
+
+        css_classes = " ".join(cls.css_classes)
+        return Static(formatted_content, classes=css_classes)
+
+    @classmethod
+    def render_simple(cls, content: str) -> str:
+        if not content:
+            return ""
+
+        if len(content) > 300:
+            content = content[:297] + "..."
+
+        lines = content.split("\n")
+        bordered_lines = [f"[#3b82f6]▍[/#3b82f6] {line}" for line in lines]
+        bordered_content = "\n".join(bordered_lines)
+        return f"[#3b82f6]▍[/#3b82f6] [bold]You:[/]\n{bordered_content}"

strix/interface/tool_components/web_search_renderer.py

@@ -0,0 +1,28 @@
+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 WebSearchRenderer(BaseToolRenderer):
+    tool_name: ClassVar[str] = "web_search"
+    css_classes: ClassVar[list[str]] = ["tool-call", "web-search-tool"]
+
+    @classmethod
+    def render(cls, tool_data: dict[str, Any]) -> Static:
+        args = tool_data.get("args", {})
+        query = args.get("query", "")
+
+        header = "🌐 [bold #60a5fa]Searching the web...[/]"
+
+        if query:
+            query_display = query[:100] + "..." if len(query) > 100 else query
+            content_text = f"{header}\n  [dim]{cls.escape_markup(query_display)}[/]"
+        else:
+            content_text = f"{header}"
+
+        css_classes = cls.get_css_classes("completed")
+        return Static(content_text, classes=css_classes)