strix-agent 0.1.1__py3-none-any.whl

strix/cli/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 {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 {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)

strix/cli/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[:250] + "..." if len(code) > 250 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/cli/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]{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/cli/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}]{severity.upper()}[/{severity_color}][/]"
+                )
+
+            if content:
+                content_preview = content[:100] + "..." if len(content) > 100 else content
+                content_parts.append(f"  [dim]{cls.escape_markup(content_preview)}[/]")
+
+            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/cli/tool_components/scan_info_renderer.py

@@ -0,0 +1,58 @@
+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")
+
+        target = args.get("target", {})
+
+        target_display = cls._build_target_display(target)
+
+        content = f"🚀 Starting scan on {target_display}"
+
+        css_classes = cls.get_css_classes(status)
+        return Static(content, classes=css_classes)
+
+    @classmethod
+    def _build_target_display(cls, target: dict[str, Any]) -> str:
+        if target_url := target.get("target_url"):
+            return f"[bold #22c55e]{target_url}[/bold #22c55e]"
+        if target_repo := target.get("target_repo"):
+            return f"[bold #22c55e]{target_repo}[/bold #22c55e]"
+        if target_path := target.get("target_path"):
+            return f"[bold #22c55e]{target_path}[/bold #22c55e]"
+        return "[dim]unknown target[/dim]"
+
+
+@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", "")
+
+        content = f"🤖 Spawned subagent [bold #22c55e]{name}[/bold #22c55e]"
+        if task:
+            display_task = task[:80] + "..." if len(task) > 80 else task
+            content += f"\n    Task: [dim]{display_task}[/dim]"
+
+        css_classes = cls.get_css_classes(status)
+        return Static(content, classes=css_classes)

strix/cli/tool_components/terminal_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 TerminalRenderer(BaseToolRenderer):
+    tool_name: ClassVar[str] = "terminal_action"
+    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", {})
+
+        action = args.get("action", "unknown")
+        inputs = args.get("inputs", [])
+        terminal_id = args.get("terminal_id", "default")
+
+        content = cls._build_sleek_content(action, inputs, terminal_id, result)
+
+        css_classes = cls.get_css_classes(status)
+        return Static(content, classes=css_classes)
+
+    @classmethod
+    def _build_sleek_content(
+        cls,
+        action: str,
+        inputs: list[str],
+        terminal_id: str,  # noqa: ARG003
+        result: dict[str, Any],  # noqa: ARG003
+    ) -> str:
+        terminal_icon = ">_"
+
+        if action in {"create", "new_terminal"}:
+            command = cls._format_command(inputs) if inputs else "bash"
+            return f"{terminal_icon} [#22c55e]${command}[/]"
+
+        if action == "send_input":
+            command = cls._format_command(inputs)
+            return f"{terminal_icon} [#22c55e]${command}[/]"
+
+        if action == "wait":
+            return f"{terminal_icon} [dim]waiting...[/]"
+
+        if action == "close":
+            return f"{terminal_icon} [dim]close[/]"
+
+        if action == "get_snapshot":
+            return f"{terminal_icon} [dim]snapshot[/]"
+
+        return f"{terminal_icon} [dim]{action}[/]"
+
+    @classmethod
+    def _format_command(cls, inputs: list[str]) -> str:
+        if not inputs:
+            return ""
+
+        command_parts = []
+
+        for input_item in inputs:
+            if input_item == "Enter":
+                break
+            if input_item.startswith("literal:"):
+                command_parts.append(input_item[8:])
+            elif input_item in [
+                "Space",
+                "Tab",
+                "Backspace",
+                "Up",
+                "Down",
+                "Left",
+                "Right",
+                "Home",
+                "End",
+                "PageUp",
+                "PageDown",
+                "Insert",
+                "Delete",
+                "Escape",
+            ] or input_item.startswith(("^", "C-", "S-", "A-", "F")):
+                if input_item == "Space":
+                    command_parts.append(" ")
+                elif input_item == "Tab":
+                    command_parts.append("\t")
+                continue
+            else:
+                command_parts.append(input_item)
+
+        command = "".join(command_parts).strip()
+
+        if len(command) > 200:
+            command = command[:197] + "..."
+
+        return cls.escape_markup(command) if command else "bash"

strix/cli/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[:200] + "..." if len(thought) > 200 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/cli/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/cli/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)