superqode 0.1.5__py3-none-any.whl

superqode/tui_widgets/__init__.py

@@ -0,0 +1,27 @@
+"""
+SuperQode TUI Widgets - Reusable UI components.
+
+Provides enhanced widgets for the TUI:
+- ToolDisplay: Shows tool calls with status
+- ProgressPanel: Session progress tracking
+
+Usage:
+    from superqode.tui_widgets import ToolDisplay, ProgressPanel
+"""
+
+# Re-export widgets
+from .widgets import (
+    ToolDisplay,
+    ToolCall,
+    ToolStatus,
+    ProgressPanel,
+    ProgressStep,
+)
+
+__all__ = [
+    "ToolDisplay",
+    "ToolCall",
+    "ToolStatus",
+    "ProgressPanel",
+    "ProgressStep",
+]

superqode/tui_widgets/widgets/__init__.py

@@ -0,0 +1,18 @@
+"""
+SuperQode TUI Widgets - Reusable UI components.
+
+Provides enhanced widgets for the TUI:
+- ToolDisplay: Shows tool calls with status
+- ProgressPanel: Session progress tracking
+"""
+
+from .tool_display import ToolDisplay, ToolCall, ToolStatus
+from .progress import ProgressPanel, ProgressStep
+
+__all__ = [
+    "ToolDisplay",
+    "ToolCall",
+    "ToolStatus",
+    "ProgressPanel",
+    "ProgressStep",
+]

superqode/tui_widgets/widgets/progress.py

@@ -0,0 +1,185 @@
+"""
+Progress Panel Widget - Shows session progress.
+
+Displays the current session progress with steps:
+- Completed steps
+- Current step (with spinner)
+- Pending steps
+"""
+
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import List, Optional
+
+from rich.console import Console, Group
+from rich.panel import Panel
+from rich.text import Text
+from rich.box import ROUNDED
+
+
+class StepStatus(Enum):
+    """Status of a progress step."""
+
+    PENDING = "pending"
+    IN_PROGRESS = "in_progress"
+    COMPLETE = "complete"
+    SKIPPED = "skipped"
+    ERROR = "error"
+
+
+@dataclass
+class ProgressStep:
+    """Represents a single progress step."""
+
+    name: str
+    description: str = ""
+    status: StepStatus = StepStatus.PENDING
+    substeps: List[str] = field(default_factory=list)
+
+    @property
+    def status_icon(self) -> str:
+        """Get status icon."""
+        return {
+            StepStatus.PENDING: "[dim]○[/dim]",
+            StepStatus.IN_PROGRESS: "[yellow]⟳[/yellow]",
+            StepStatus.COMPLETE: "[green]✓[/green]",
+            StepStatus.SKIPPED: "[dim]⊘[/dim]",
+            StepStatus.ERROR: "[red]✗[/red]",
+        }.get(self.status, "?")
+
+    @property
+    def style(self) -> str:
+        """Get text style based on status."""
+        return {
+            StepStatus.PENDING: "dim",
+            StepStatus.IN_PROGRESS: "bold yellow",
+            StepStatus.COMPLETE: "green",
+            StepStatus.SKIPPED: "dim",
+            StepStatus.ERROR: "red",
+        }.get(self.status, "")
+
+
+class ProgressPanel:
+    """
+    Widget for displaying session progress.
+
+    Shows a panel with progress steps and their status.
+    """
+
+    def __init__(
+        self,
+        title: str = "Session Progress",
+        role: Optional[str] = None,
+        mode: Optional[str] = None,
+    ):
+        """
+        Initialize the progress panel.
+
+        Args:
+            title: Panel title
+            role: Current role (e.g., "qe.security")
+            mode: Current mode (e.g., "Deep Scan")
+        """
+        self.title = title
+        self.role = role
+        self.mode = mode
+        self.steps: List[ProgressStep] = []
+        self.console = Console()
+
+    def add_step(self, name: str, description: str = "") -> ProgressStep:
+        """Add a new step."""
+        step = ProgressStep(name=name, description=description)
+        self.steps.append(step)
+        return step
+
+    def start_step(self, step: ProgressStep) -> None:
+        """Mark a step as in progress."""
+        step.status = StepStatus.IN_PROGRESS
+
+    def complete_step(self, step: ProgressStep) -> None:
+        """Mark a step as complete."""
+        step.status = StepStatus.COMPLETE
+
+    def error_step(self, step: ProgressStep) -> None:
+        """Mark a step as errored."""
+        step.status = StepStatus.ERROR
+
+    def skip_step(self, step: ProgressStep) -> None:
+        """Mark a step as skipped."""
+        step.status = StepStatus.SKIPPED
+
+    def get_current_step(self) -> Optional[ProgressStep]:
+        """Get the current in-progress step."""
+        for step in self.steps:
+            if step.status == StepStatus.IN_PROGRESS:
+                return step
+        return None
+
+    def render(self) -> Panel:
+        """Render the progress panel as a Rich Panel."""
+        lines = []
+
+        # Header with role and mode
+        if self.role or self.mode:
+            header_parts = []
+            if self.role:
+                header_parts.append(f"[cyan]Role:[/cyan] {self.role}")
+            if self.mode:
+                header_parts.append(f"[cyan]Mode:[/cyan] {self.mode}")
+            lines.append(Text.from_markup("  ".join(header_parts)))
+            lines.append(Text())  # Empty line
+
+        # Progress steps
+        if not self.steps:
+            lines.append(Text("No steps defined", style="dim"))
+        else:
+            for step in self.steps:
+                # Main step line
+                step_text = Text()
+                step_text.append(step.status_icon)
+                step_text.append(" ")
+                step_text.append(step.name, style=step.style)
+                if step.description and step.status == StepStatus.IN_PROGRESS:
+                    step_text.append(f" - {step.description}", style="dim")
+                lines.append(step_text)
+
+                # Substeps (indented)
+                if step.substeps and step.status == StepStatus.IN_PROGRESS:
+                    for substep in step.substeps[-3:]:  # Show last 3 substeps
+                        lines.append(Text(f"    {substep}", style="dim"))
+
+        content = Group(*lines)
+
+        return Panel(
+            content,
+            title=f"[bold]{self.title}[/bold]",
+            border_style="cyan",
+            box=ROUNDED,
+        )
+
+    def print(self) -> None:
+        """Print the progress panel to console."""
+        self.console.print(self.render())
+
+
+def create_qe_progress(role: str, mode: str) -> ProgressPanel:
+    """
+    Create a progress panel for a QE session.
+
+    Pre-populates with standard QE steps.
+    """
+    panel = ProgressPanel(
+        title="SuperQE Session",
+        role=role,
+        mode=mode,
+    )
+
+    panel.add_step("Initializing workspace", "Setting up ephemeral environment")
+    panel.add_step("Running test discovery", "Finding test files and suites")
+    panel.add_step("Executing tests", "Running smoke/sanity/regression")
+    panel.add_step("Analyzing results", "Processing test outcomes")
+    panel.add_step("Detecting issues", "Proactive vulnerability scanning")
+    panel.add_step("Generating QR", "Creating quality report")
+    panel.add_step("Cleaning up", "Reverting changes, preserving artifacts")
+
+    return panel

superqode/tui_widgets/widgets/tool_display.py

@@ -0,0 +1,188 @@
+"""
+Tool Display Widget - Shows tool calls with status.
+
+Displays tool invocations in a clear, structured format:
+- Tool name and type
+- Arguments (truncated for readability)
+- Status (pending, running, complete, error)
+- Duration and result summary
+"""
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from enum import Enum
+from typing import Any, Dict, List, Optional
+
+from rich.console import Console, Group
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+from rich.box import ROUNDED
+
+
+class ToolStatus(Enum):
+    """Status of a tool call."""
+
+    PENDING = "pending"
+    RUNNING = "running"
+    COMPLETE = "complete"
+    ERROR = "error"
+
+
+@dataclass
+class ToolCall:
+    """Represents a single tool invocation."""
+
+    name: str
+    tool_type: str  # e.g., "file_read", "shell_exec", "edit"
+    arguments: Dict[str, Any] = field(default_factory=dict)
+    status: ToolStatus = ToolStatus.PENDING
+    start_time: Optional[datetime] = None
+    end_time: Optional[datetime] = None
+    result_summary: str = ""
+    error_message: str = ""
+
+    @property
+    def duration_ms(self) -> Optional[float]:
+        """Get duration in milliseconds."""
+        if self.start_time and self.end_time:
+            return (self.end_time - self.start_time).total_seconds() * 1000
+        return None
+
+    @property
+    def duration_str(self) -> str:
+        """Get human-readable duration."""
+        if self.duration_ms is None:
+            return "-"
+        if self.duration_ms < 1000:
+            return f"{self.duration_ms:.0f}ms"
+        return f"{self.duration_ms / 1000:.1f}s"
+
+    @property
+    def status_icon(self) -> str:
+        """Get status icon."""
+        return {
+            ToolStatus.PENDING: "[dim]○[/dim]",
+            ToolStatus.RUNNING: "[yellow]⟳[/yellow]",
+            ToolStatus.COMPLETE: "[green]✓[/green]",
+            ToolStatus.ERROR: "[red]✗[/red]",
+        }.get(self.status, "?")
+
+
+class ToolDisplay:
+    """
+    Widget for displaying tool calls in the TUI.
+
+    Shows a panel with recent tool invocations and their status.
+    """
+
+    def __init__(self, max_display: int = 5, show_arguments: bool = False):
+        """
+        Initialize the tool display.
+
+        Args:
+            max_display: Maximum number of tools to show
+            show_arguments: Whether to show tool arguments
+        """
+        self.max_display = max_display
+        self.show_arguments = show_arguments
+        self.calls: List[ToolCall] = []
+        self.console = Console()
+
+    def add_call(self, call: ToolCall) -> None:
+        """Add a new tool call."""
+        self.calls.append(call)
+        # Keep only the most recent calls
+        if len(self.calls) > self.max_display * 2:
+            self.calls = self.calls[-self.max_display :]
+
+    def start_call(self, name: str, tool_type: str, arguments: Dict[str, Any] = None) -> ToolCall:
+        """Create and start a new tool call."""
+        call = ToolCall(
+            name=name,
+            tool_type=tool_type,
+            arguments=arguments or {},
+            status=ToolStatus.RUNNING,
+            start_time=datetime.now(),
+        )
+        self.add_call(call)
+        return call
+
+    def complete_call(self, call: ToolCall, result_summary: str = "") -> None:
+        """Mark a tool call as complete."""
+        call.status = ToolStatus.COMPLETE
+        call.end_time = datetime.now()
+        call.result_summary = result_summary
+
+    def error_call(self, call: ToolCall, error_message: str) -> None:
+        """Mark a tool call as errored."""
+        call.status = ToolStatus.ERROR
+        call.end_time = datetime.now()
+        call.error_message = error_message
+
+    def _truncate(self, text: str, max_len: int = 50) -> str:
+        """Truncate text to max length."""
+        if len(text) <= max_len:
+            return text
+        return text[: max_len - 3] + "..."
+
+    def _format_arguments(self, args: Dict[str, Any]) -> str:
+        """Format arguments for display."""
+        if not args:
+            return ""
+        parts = []
+        for key, value in args.items():
+            if isinstance(value, str):
+                parts.append(f"{key}={self._truncate(repr(value), 30)}")
+            else:
+                parts.append(f"{key}={value}")
+        return ", ".join(parts[:3])  # Show at most 3 args
+
+    def render(self) -> Panel:
+        """Render the tool display as a Rich Panel."""
+        recent = self.calls[-self.max_display :]
+
+        if not recent:
+            content = Text("No tool calls yet", style="dim")
+        else:
+            table = Table(show_header=False, box=None, padding=(0, 1))
+            table.add_column("Status", width=3)
+            table.add_column("Tool", style="cyan")
+            table.add_column("Info", style="dim")
+            table.add_column("Time", width=8, justify="right")
+
+            for call in recent:
+                # Build info column
+                if call.status == ToolStatus.ERROR:
+                    info = Text(self._truncate(call.error_message, 40), style="red")
+                elif call.result_summary:
+                    info = Text(self._truncate(call.result_summary, 40))
+                elif self.show_arguments:
+                    info = Text(self._truncate(self._format_arguments(call.arguments), 40))
+                else:
+                    info = Text(call.tool_type, style="dim")
+
+                table.add_row(
+                    call.status_icon,
+                    call.name,
+                    info,
+                    call.duration_str,
+                )
+
+            content = table
+
+        return Panel(
+            content,
+            title="[bold]Tool Calls[/bold]",
+            border_style="dim",
+            box=ROUNDED,
+        )
+
+    def print(self) -> None:
+        """Print the tool display to console."""
+        self.console.print(self.render())
+
+
+def create_tool_display(max_display: int = 5) -> ToolDisplay:
+    """Factory function to create a ToolDisplay."""
+    return ToolDisplay(max_display=max_display)