empathy-framework 4.7.1__py3-none-any.whl → 4.8.0__py3-none-any.whl

empathy_os/workflows/output.py

@@ -0,0 +1,410 @@
+"""Unified output formatting for workflows.
+
+Provides consistent Rich-based output components for workflow results:
+- WorkflowReport: Main report container with sections
+- FindingsTable: Render findings as Rich Table or plain text
+- MetricsPanel: Color-coded score display
+- ReportSection: Individual report sections
+
+Supports graceful fallback to plain text when Rich is unavailable.
+
+Copyright 2025 Smart-AI-Memory
+Licensed under Fair Source License 0.9
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any
+
+# Rich imports with fallback
+try:
+    from rich.console import Console
+    from rich.panel import Panel
+    from rich.table import Table
+    from rich.text import Text
+
+    RICH_AVAILABLE = True
+except ImportError:
+    RICH_AVAILABLE = False
+    Console = None  # type: ignore
+    Panel = None  # type: ignore
+    Table = None  # type: ignore
+    Text = None  # type: ignore
+
+if TYPE_CHECKING:
+    from rich.console import Console as ConsoleType
+
+
+# =============================================================================
+# DATA CLASSES
+# =============================================================================
+
+
+@dataclass
+class Finding:
+    """Individual finding from a workflow."""
+
+    severity: str  # "high", "medium", "low", "info"
+    file: str
+    line: int | None = None
+    message: str = ""
+    code: str | None = None
+
+    @property
+    def severity_icon(self) -> str:
+        """Get icon for severity level."""
+        icons = {
+            "high": "[red]:x:[/red]" if RICH_AVAILABLE else "X",
+            "medium": "[yellow]:warning:[/yellow]" if RICH_AVAILABLE else "!",
+            "low": "[blue]:information:[/blue]" if RICH_AVAILABLE else "i",
+            "info": "[dim]o[/dim]" if RICH_AVAILABLE else "o",
+        }
+        return icons.get(self.severity.lower(), "o")
+
+    @property
+    def location(self) -> str:
+        """Get file:line location string."""
+        if self.line:
+            return f"{self.file}:{self.line}"
+        return self.file
+
+
+@dataclass
+class ReportSection:
+    """Individual section of a workflow report."""
+
+    title: str
+    content: Any  # str, list[Finding], dict, or Rich renderable
+    collapsed: bool = False
+    style: str = "default"  # "default", "success", "warning", "error"
+
+
+@dataclass
+class WorkflowReport:
+    """Main workflow report container."""
+
+    title: str
+    summary: str = ""
+    sections: list[ReportSection] = field(default_factory=list)
+    score: int | None = None
+    level: str = "info"  # "info", "success", "warning", "error"
+    metadata: dict[str, Any] = field(default_factory=dict)
+
+    def add_section(
+        self,
+        title: str,
+        content: Any,
+        collapsed: bool = False,
+        style: str = "default",
+    ) -> None:
+        """Add a section to the report."""
+        self.sections.append(
+            ReportSection(title=title, content=content, collapsed=collapsed, style=style)
+        )
+
+    def render(self, console: ConsoleType | None = None, use_rich: bool = True) -> str:
+        """Render the report.
+
+        Args:
+            console: Rich Console instance (optional)
+            use_rich: Whether to use Rich formatting
+
+        Returns:
+            Rendered report as string (for plain text) or prints to console (for Rich)
+        """
+        if use_rich and RICH_AVAILABLE and console is not None:
+            self._render_rich(console)
+            return ""
+        return self._render_plain()
+
+    def _render_rich(self, console: ConsoleType) -> None:
+        """Render report using Rich."""
+        # Header with score
+        header_parts = [f"[bold]{self.title}[/bold]"]
+        if self.score is not None:
+            score_panel = MetricsPanel.render_score(self.score)
+            console.print(score_panel)
+
+        if self.summary:
+            console.print(f"\n{self.summary}\n")
+
+        # Sections
+        for section in self.sections:
+            self._render_section_rich(console, section)
+
+    def _render_section_rich(self, console: ConsoleType, section: ReportSection) -> None:
+        """Render a single section using Rich."""
+        border_style = {
+            "success": "green",
+            "warning": "yellow",
+            "error": "red",
+            "default": "blue",
+        }.get(section.style, "blue")
+
+        if isinstance(section.content, str):
+            console.print(
+                Panel(section.content, title=section.title, border_style=border_style)
+            )
+        elif isinstance(section.content, list) and all(
+            isinstance(f, Finding) for f in section.content
+        ):
+            table = FindingsTable(section.content).to_rich_table()
+            console.print(Panel(table, title=section.title, border_style=border_style))
+        elif isinstance(section.content, dict):
+            # Render dict as key-value table
+            table = Table(show_header=False, box=None)
+            table.add_column("Key", style="cyan")
+            table.add_column("Value")
+            for key, value in section.content.items():
+                table.add_row(str(key), str(value))
+            console.print(Panel(table, title=section.title, border_style=border_style))
+        else:
+            # Try to print directly (might be a Rich renderable)
+            try:
+                console.print(
+                    Panel(section.content, title=section.title, border_style=border_style)
+                )
+            except Exception:  # noqa: BLE001
+                # INTENTIONAL: Graceful fallback for unknown content types
+                console.print(f"\n[bold]{section.title}[/bold]")
+                console.print(str(section.content))
+
+    def _render_plain(self) -> str:
+        """Render report as plain text."""
+        lines = []
+        separator = "=" * 60
+
+        # Header
+        lines.append(separator)
+        lines.append(self.title.upper())
+        lines.append(separator)
+
+        if self.score is not None:
+            level = MetricsPanel.get_level(self.score)
+            lines.append(f"Score: {self.score}/100 ({level.upper()})")
+            lines.append("")
+
+        if self.summary:
+            lines.append(self.summary)
+            lines.append("")
+
+        # Sections
+        for section in self.sections:
+            lines.append("-" * 60)
+            lines.append(section.title.upper())
+            lines.append("-" * 60)
+
+            if isinstance(section.content, str):
+                lines.append(section.content)
+            elif isinstance(section.content, list) and all(
+                isinstance(f, Finding) for f in section.content
+            ):
+                lines.append(FindingsTable(section.content).to_plain())
+            elif isinstance(section.content, dict):
+                for key, value in section.content.items():
+                    lines.append(f"  {key}: {value}")
+            else:
+                lines.append(str(section.content))
+
+            lines.append("")
+
+        lines.append(separator)
+        return "\n".join(lines)
+
+
+# =============================================================================
+# FINDINGS TABLE
+# =============================================================================
+
+
+class FindingsTable:
+    """Render findings as Rich Table or plain text."""
+
+    def __init__(self, findings: list[Finding]) -> None:
+        """Initialize with list of findings."""
+        self.findings = findings
+
+    def to_rich_table(self) -> Table:
+        """Convert findings to Rich Table."""
+        table = Table(show_header=True, header_style="bold magenta")
+        table.add_column("Severity", style="bold", width=8)
+        table.add_column("Location", style="cyan")
+        table.add_column("Message")
+
+        for finding in self.findings:
+            severity_style = {
+                "high": "red",
+                "medium": "yellow",
+                "low": "blue",
+                "info": "dim",
+            }.get(finding.severity.lower(), "white")
+
+            table.add_row(
+                Text(finding.severity.upper(), style=severity_style),
+                finding.location,
+                finding.message,
+            )
+
+        return table
+
+    def to_plain(self) -> str:
+        """Convert findings to plain text."""
+        if not self.findings:
+            return "  No findings."
+
+        lines = []
+        for finding in self.findings:
+            lines.append(f"  [{finding.severity.upper()}] {finding.location}")
+            if finding.message:
+                lines.append(f"      {finding.message}")
+
+        return "\n".join(lines)
+
+
+# =============================================================================
+# METRICS PANEL
+# =============================================================================
+
+
+class MetricsPanel:
+    """Display score with color-coded indicator."""
+
+    @staticmethod
+    def get_level(score: int) -> str:
+        """Get level name for score."""
+        if score >= 85:
+            return "excellent"
+        elif score >= 70:
+            return "good"
+        elif score >= 50:
+            return "needs work"
+        return "critical"
+
+    @staticmethod
+    def get_style(score: int) -> str:
+        """Get Rich style for score."""
+        if score >= 85:
+            return "green"
+        elif score >= 70:
+            return "yellow"
+        elif score >= 50:
+            return "orange1"
+        return "red"
+
+    @staticmethod
+    def get_icon(score: int) -> str:
+        """Get icon for score."""
+        if score >= 85:
+            return "[green]:heavy_check_mark:[/green]"
+        elif score >= 70:
+            return "[yellow]:large_yellow_circle:[/yellow]"
+        elif score >= 50:
+            return "[orange1]:warning:[/orange1]"
+        return "[red]:x:[/red]"
+
+    @staticmethod
+    def get_plain_icon(score: int) -> str:
+        """Get plain text icon for score."""
+        if score >= 85:
+            return "[OK]"
+        elif score >= 70:
+            return "[--]"
+        elif score >= 50:
+            return "[!!]"
+        return "[XX]"
+
+    @classmethod
+    def render_score(cls, score: int, label: str = "Score") -> Panel:
+        """Render score as Rich Panel.
+
+        Args:
+            score: Score value (0-100)
+            label: Label for the score
+
+        Returns:
+            Rich Panel with formatted score
+        """
+        if not RICH_AVAILABLE or Panel is None:
+            raise RuntimeError("Rich is not available")
+
+        style = cls.get_style(score)
+        icon = cls.get_icon(score)
+        level = cls.get_level(score)
+
+        content = f"{icon} [bold]{score}[/bold]/100 ({level.upper()})"
+        return Panel(content, title=f"[bold]{label}[/bold]", border_style=style)
+
+    @classmethod
+    def render_plain(cls, score: int, label: str = "Score") -> str:
+        """Render score as plain text.
+
+        Args:
+            score: Score value (0-100)
+            label: Label for the score
+
+        Returns:
+            Plain text score display
+        """
+        icon = cls.get_plain_icon(score)
+        level = cls.get_level(score)
+        return f"{label}: {icon} {score}/100 ({level.upper()})"
+
+
+# =============================================================================
+# HELPER FUNCTIONS
+# =============================================================================
+
+
+def format_workflow_result(
+    title: str,
+    summary: str = "",
+    findings: list[dict] | None = None,
+    score: int | None = None,
+    recommendations: str = "",
+    metadata: dict[str, Any] | None = None,
+) -> WorkflowReport:
+    """Create a standardized workflow report.
+
+    Args:
+        title: Report title
+        summary: Brief summary text
+        findings: List of finding dicts with severity, file, line, message
+        score: Overall score (0-100)
+        recommendations: Recommendations text
+        metadata: Additional metadata
+
+    Returns:
+        WorkflowReport instance
+    """
+    report = WorkflowReport(
+        title=title,
+        summary=summary,
+        score=score,
+        metadata=metadata or {},
+    )
+
+    if findings:
+        finding_objs = [
+            Finding(
+                severity=f.get("severity", "info"),
+                file=f.get("file", "unknown"),
+                line=f.get("line"),
+                message=f.get("message", ""),
+                code=f.get("code"),
+            )
+            for f in findings
+        ]
+        report.add_section("Findings", finding_objs)
+
+    if recommendations:
+        report.add_section("Recommendations", recommendations)
+
+    return report
+
+
+def get_console() -> Console | None:
+    """Get Rich Console if available."""
+    if RICH_AVAILABLE and Console is not None:
+        return Console()
+    return None

empathy_os/workflows/perf_audit.py

@@ -20,6 +20,7 @@ from pathlib import Path
 from typing import Any
 
 from .base import BaseWorkflow, ModelTier
+from .output import Finding, WorkflowReport, get_console
 from .step_config import WorkflowStepConfig
 
 # Define step configurations for executor-based execution
@@ -483,6 +484,9 @@ Provide detailed optimization strategies."""
         # Add formatted report for human readability
         result["formatted_report"] = format_perf_audit_report(result, input_data)
 
+        # Add structured WorkflowReport for Rich rendering
+        result["workflow_report"] = create_perf_audit_workflow_report(result, input_data)
+
         return (result, input_tokens, output_tokens)
 
     def _get_optimization_action(self, concern: str) -> dict | None:
@@ -532,6 +536,92 @@ Provide detailed optimization strategies."""
         return actions.get(concern)
 
 
+def create_perf_audit_workflow_report(result: dict, input_data: dict) -> WorkflowReport:
+    """Create a WorkflowReport from performance audit results.
+
+    Args:
+        result: The optimize stage result
+        input_data: Input data from previous stages
+
+    Returns:
+        WorkflowReport instance for Rich or plain text rendering
+    """
+    perf_score = result.get("perf_score", 0)
+    perf_level = result.get("perf_level", "unknown")
+
+    # Determine report level
+    if perf_score >= 85:
+        level = "success"
+    elif perf_score >= 50:
+        level = "warning"
+    else:
+        level = "error"
+
+    # Build summary
+    files_scanned = input_data.get("files_scanned", 0)
+    finding_count = input_data.get("finding_count", 0)
+    by_impact = input_data.get("by_impact", {})
+
+    summary = (
+        f"Scanned {files_scanned} files, found {finding_count} issues. "
+        f"High: {by_impact.get('high', 0)}, Medium: {by_impact.get('medium', 0)}, "
+        f"Low: {by_impact.get('low', 0)}"
+    )
+
+    report = WorkflowReport(
+        title="Performance Audit Report",
+        summary=summary,
+        score=perf_score,
+        level=level,
+        metadata={
+            "perf_level": perf_level,
+            "files_scanned": files_scanned,
+            "finding_count": finding_count,
+        },
+    )
+
+    # Add top issues section
+    top_issues = result.get("top_issues", [])
+    if top_issues:
+        issues_content = {
+            issue.get("type", "unknown").replace("_", " ").title(): f"{issue.get('count', 0)} occurrences"
+            for issue in top_issues
+        }
+        report.add_section("Top Performance Issues", issues_content)
+
+    # Add hotspots section
+    hotspot_result = input_data.get("hotspot_result", {})
+    hotspots = hotspot_result.get("hotspots", [])
+    if hotspots:
+        hotspot_content = {
+            "Critical Hotspots": hotspot_result.get("critical_count", 0),
+            "Moderate Hotspots": hotspot_result.get("moderate_count", 0),
+        }
+        report.add_section("Hotspot Summary", hotspot_content)
+
+    # Add findings section
+    findings = input_data.get("findings", [])
+    high_impact = [f for f in findings if f.get("impact") == "high"]
+    if high_impact:
+        finding_objs = [
+            Finding(
+                severity="high",
+                file=f.get("file", "unknown"),
+                line=f.get("line"),
+                message=f.get("description", ""),
+            )
+            for f in high_impact[:10]
+        ]
+        report.add_section("High Impact Findings", finding_objs, style="error")
+
+    # Add recommendations section
+    optimization_plan = result.get("optimization_plan", "")
+    if optimization_plan:
+        report.add_section("Optimization Recommendations", optimization_plan)
+
+    return report
+
+
 def format_perf_audit_report(result: dict, input_data: dict) -> str:
     """Format performance audit output as a human-readable report.
 
@@ -660,26 +750,42 @@ def main():
         workflow = PerformanceAuditWorkflow()
         result = await workflow.execute(path=".", file_types=[".py"])
 
-        print("\nPerformance Audit Results")
-        print("=" * 50)
-        print(f"Provider: {result.provider}")
-        print(f"Success: {result.success}")
-
         output = result.final_output
-        print(f"Performance Level: {output.get('perf_level', 'N/A')}")
-        print(f"Performance Score: {output.get('perf_score', 0)}/100")
-        print(f"Recommendations: {output.get('recommendation_count', 0)}")
-
-        if output.get("top_issues"):
-            print("\nTop Issues:")
-            for issue in output["top_issues"]:
-                print(f"  - {issue['type']}: {issue['count']} occurrences")
-
-        print("\nCost Report:")
-        print(f"  Total Cost: ${result.cost_report.total_cost:.4f}")
-        savings = result.cost_report.savings
-        pct = result.cost_report.savings_percent
-        print(f"  Savings: ${savings:.4f} ({pct:.1f}%)")
+
+        # Try Rich output first
+        console = get_console()
+        workflow_report = output.get("workflow_report")
+
+        if console and workflow_report:
+            # Render with Rich
+            workflow_report.render(console, use_rich=True)
+            console.print()
+            console.print(f"[dim]Provider: {result.provider}[/dim]")
+            console.print(f"[dim]Cost: ${result.cost_report.total_cost:.4f}[/dim]")
+            savings = result.cost_report.savings
+            pct = result.cost_report.savings_percent
+            console.print(f"[dim]Savings: ${savings:.4f} ({pct:.1f}%)[/dim]")
+        else:
+            # Fallback to plain text
+            print("\nPerformance Audit Results")
+            print("=" * 50)
+            print(f"Provider: {result.provider}")
+            print(f"Success: {result.success}")
+
+            print(f"Performance Level: {output.get('perf_level', 'N/A')}")
+            print(f"Performance Score: {output.get('perf_score', 0)}/100")
+            print(f"Recommendations: {output.get('recommendation_count', 0)}")
+
+            if output.get("top_issues"):
+                print("\nTop Issues:")
+                for issue in output["top_issues"]:
+                    print(f"  - {issue['type']}: {issue['count']} occurrences")
+
+            print("\nCost Report:")
+            print(f"  Total Cost: ${result.cost_report.total_cost:.4f}")
+            savings = result.cost_report.savings
+            pct = result.cost_report.savings_percent
+            print(f"  Savings: ${savings:.4f} ({pct:.1f}%)")
 
     asyncio.run(run())