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

empathy_os/workflows/history.py

@@ -0,0 +1,512 @@
+"""SQLite-backed workflow history storage.
+
+Replaces JSON file-based history with structured, queryable storage.
+Provides concurrent-safe workflow execution history with fast queries.
+
+Copyright 2025 Smart-AI-Memory
+Licensed under Fair Source License 0.9
+"""
+
+from __future__ import annotations
+
+import sqlite3
+from datetime import datetime
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+from empathy_os.logging_config import get_logger
+
+if TYPE_CHECKING:
+    from .base import WorkflowResult
+
+logger = get_logger(__name__)
+
+
+class WorkflowHistoryStore:
+    """SQLite-backed workflow history with migrations.
+
+    Provides concurrent-safe storage with fast queries for workflow execution history.
+
+    Features:
+        - Concurrent-safe (SQLite ACID guarantees)
+        - Fast queries with indexes
+        - Unlimited history (no artificial limits)
+        - Flexible filtering by workflow, provider, date range
+        - Analytics-ready with aggregate queries
+
+    Example:
+        >>> store = WorkflowHistoryStore()
+        >>> store.record_run("run-123", "test-gen", "anthropic", result)
+        >>> stats = store.get_stats()
+        >>> recent = store.query_runs(limit=10)
+        >>> store.close()
+    """
+
+    SCHEMA_VERSION = 1
+    DEFAULT_DB = ".empathy/history.db"
+
+    def __init__(self, db_path: str = DEFAULT_DB):
+        """Initialize history store.
+
+        Args:
+            db_path: Path to SQLite database file (default: .empathy/history.db)
+        """
+        self.db_path = db_path
+        Path(db_path).parent.mkdir(parents=True, exist_ok=True)
+
+        # Enable thread-safe access
+        self.conn = sqlite3.connect(db_path, check_same_thread=False)
+        self.conn.row_factory = sqlite3.Row
+
+        self._migrate()
+
+    def _migrate(self) -> None:
+        """Create schema if needed.
+
+        Creates workflow_runs and workflow_stages tables with appropriate indexes.
+        Idempotent - safe to call multiple times.
+        """
+        # Main workflow runs table
+        self.conn.execute("""
+            CREATE TABLE IF NOT EXISTS workflow_runs (
+                run_id TEXT PRIMARY KEY,
+                workflow_name TEXT NOT NULL,
+                provider TEXT NOT NULL,
+                success INTEGER NOT NULL,
+                started_at TEXT NOT NULL,
+                completed_at TEXT NOT NULL,
+                duration_ms INTEGER NOT NULL,
+                total_cost REAL NOT NULL,
+                baseline_cost REAL NOT NULL,
+                savings REAL NOT NULL,
+                savings_percent REAL NOT NULL,
+                error TEXT,
+                error_type TEXT,
+                transient INTEGER DEFAULT 0,
+                xml_parsed INTEGER DEFAULT 0,
+                summary TEXT,
+                created_at TEXT DEFAULT CURRENT_TIMESTAMP
+            )
+        """)
+
+        # Workflow stages (1:many relationship)
+        self.conn.execute("""
+            CREATE TABLE IF NOT EXISTS workflow_stages (
+                stage_id INTEGER PRIMARY KEY AUTOINCREMENT,
+                run_id TEXT NOT NULL,
+                stage_name TEXT NOT NULL,
+                tier TEXT NOT NULL,
+                skipped INTEGER NOT NULL DEFAULT 0,
+                skip_reason TEXT,
+                cost REAL NOT NULL DEFAULT 0.0,
+                duration_ms INTEGER NOT NULL DEFAULT 0,
+                input_tokens INTEGER DEFAULT 0,
+                output_tokens INTEGER DEFAULT 0,
+                FOREIGN KEY (run_id) REFERENCES workflow_runs(run_id)
+            )
+        """)
+
+        # Indexes for common queries
+        self.conn.execute("""
+            CREATE INDEX IF NOT EXISTS idx_workflow_name
+            ON workflow_runs(workflow_name)
+        """)
+
+        self.conn.execute("""
+            CREATE INDEX IF NOT EXISTS idx_started_at
+            ON workflow_runs(started_at DESC)
+        """)
+
+        self.conn.execute("""
+            CREATE INDEX IF NOT EXISTS idx_provider
+            ON workflow_runs(provider)
+        """)
+
+        self.conn.execute("""
+            CREATE INDEX IF NOT EXISTS idx_success
+            ON workflow_runs(success)
+        """)
+
+        # Index for stage queries
+        self.conn.execute("""
+            CREATE INDEX IF NOT EXISTS idx_run_stages
+            ON workflow_stages(run_id)
+        """)
+
+        self.conn.commit()
+        logger.debug(f"History store initialized: {self.db_path}")
+
+    def record_run(
+        self,
+        run_id: str,
+        workflow_name: str,
+        provider: str,
+        result: WorkflowResult,
+    ) -> None:
+        """Record a workflow execution.
+
+        Args:
+            run_id: Unique identifier for this run
+            workflow_name: Name of the workflow
+            provider: Provider used (anthropic, openai, google)
+            result: WorkflowResult object with execution details
+
+        Raises:
+            sqlite3.IntegrityError: If run_id already exists
+            sqlite3.OperationalError: If database is locked
+        """
+        cursor = self.conn.cursor()
+
+        try:
+            # Insert run record
+            cursor.execute(
+                """
+                INSERT INTO workflow_runs (
+                    run_id, workflow_name, provider, success,
+                    started_at, completed_at, duration_ms,
+                    total_cost, baseline_cost, savings, savings_percent,
+                    error, error_type, transient,
+                    xml_parsed, summary
+                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            """,
+                (
+                    run_id,
+                    workflow_name,
+                    provider,
+                    1 if result.success else 0,
+                    result.started_at.isoformat(),
+                    result.completed_at.isoformat(),
+                    result.total_duration_ms,
+                    result.cost_report.total_cost,
+                    result.cost_report.baseline_cost,
+                    result.cost_report.savings,
+                    result.cost_report.savings_percent,
+                    result.error,
+                    result.error_type,
+                    1 if result.transient else 0,
+                    1
+                    if isinstance(result.final_output, dict)
+                    and result.final_output.get("xml_parsed")
+                    else 0,
+                    result.final_output.get("summary")
+                    if isinstance(result.final_output, dict)
+                    else None,
+                ),
+            )
+
+            # Insert stage records
+            for stage in result.stages:
+                cursor.execute(
+                    """
+                    INSERT INTO workflow_stages (
+                        run_id, stage_name, tier, skipped, skip_reason,
+                        cost, duration_ms, input_tokens, output_tokens
+                    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+                """,
+                    (
+                        run_id,
+                        stage.name,
+                        stage.tier.value,
+                        1 if stage.skipped else 0,
+                        stage.skip_reason,
+                        stage.cost,
+                        stage.duration_ms,
+                        stage.input_tokens,
+                        stage.output_tokens,
+                    ),
+                )
+
+            self.conn.commit()
+            logger.debug(f"Recorded workflow run: {run_id} ({workflow_name})")
+
+        except sqlite3.IntegrityError as e:
+            self.conn.rollback()
+            logger.warning(f"Run ID already exists: {run_id}")
+            raise ValueError(f"Duplicate run_id: {run_id}") from e
+        except sqlite3.OperationalError as e:
+            self.conn.rollback()
+            logger.error(f"Database error recording run: {e}")
+            raise
+
+    def query_runs(
+        self,
+        workflow_name: str | None = None,
+        provider: str | None = None,
+        since: datetime | None = None,
+        until: datetime | None = None,
+        success_only: bool = False,
+        limit: int = 100,
+    ) -> list[dict]:
+        """Query workflow runs with flexible filters.
+
+        Args:
+            workflow_name: Filter by workflow name (optional)
+            provider: Filter by provider (optional)
+            since: Filter runs after this datetime (optional)
+            until: Filter runs before this datetime (optional)
+            success_only: Only return successful runs (default: False)
+            limit: Maximum number of runs to return (default: 100)
+
+        Returns:
+            List of workflow run dictionaries with stages included
+
+        Example:
+            >>> # Get recent successful test-gen runs
+            >>> runs = store.query_runs(
+            ...     workflow_name="test-gen",
+            ...     success_only=True,
+            ...     limit=10
+            ... )
+        """
+        query = "SELECT * FROM workflow_runs WHERE 1=1"
+        params: list[Any] = []
+
+        if workflow_name:
+            query += " AND workflow_name = ?"
+            params.append(workflow_name)
+
+        if provider:
+            query += " AND provider = ?"
+            params.append(provider)
+
+        if since:
+            query += " AND started_at >= ?"
+            params.append(since.isoformat())
+
+        if until:
+            query += " AND started_at <= ?"
+            params.append(until.isoformat())
+
+        if success_only:
+            query += " AND success = 1"
+
+        query += " ORDER BY started_at DESC LIMIT ?"
+        params.append(limit)
+
+        cursor = self.conn.cursor()
+        cursor.execute(query, params)
+
+        runs = []
+        for row in cursor.fetchall():
+            run = dict(row)
+
+            # Fetch stages for this run
+            cursor.execute(
+                """
+                SELECT * FROM workflow_stages
+                WHERE run_id = ?
+                ORDER BY stage_id
+            """,
+                (run["run_id"],),
+            )
+
+            run["stages"] = [dict(s) for s in cursor.fetchall()]
+            runs.append(run)
+
+        return runs
+
+    def get_stats(self) -> dict[str, Any]:
+        """Get aggregate statistics across all workflow runs.
+
+        Returns:
+            Dictionary with statistics including:
+                - total_runs: Total number of runs
+                - successful_runs: Number of successful runs
+                - by_workflow: Stats grouped by workflow name
+                - by_provider: Stats grouped by provider
+                - by_tier: Total cost grouped by tier
+                - recent_runs: Last 10 runs
+                - total_cost: Total cost across all runs
+                - total_savings: Total savings from tier optimization
+                - avg_savings_percent: Average savings percentage
+
+        Example:
+            >>> stats = store.get_stats()
+            >>> print(f"Total savings: ${stats['total_savings']:.2f}")
+            >>> print(f"Success rate: {stats['successful_runs'] / stats['total_runs']:.1%}")
+        """
+        cursor = self.conn.cursor()
+
+        # Total runs by workflow
+        cursor.execute("""
+            SELECT
+                workflow_name,
+                COUNT(*) as runs,
+                SUM(total_cost) as cost,
+                SUM(savings) as savings,
+                SUM(success) as successful
+            FROM workflow_runs
+            GROUP BY workflow_name
+        """)
+        by_workflow = {row["workflow_name"]: dict(row) for row in cursor.fetchall()}
+
+        # Total runs by provider
+        cursor.execute("""
+            SELECT
+                provider,
+                COUNT(*) as runs,
+                SUM(total_cost) as cost
+            FROM workflow_runs
+            GROUP BY provider
+        """)
+        by_provider = {row["provider"]: dict(row) for row in cursor.fetchall()}
+
+        # Total cost by tier
+        cursor.execute("""
+            SELECT
+                tier,
+                SUM(cost) as total_cost
+            FROM workflow_stages
+            WHERE skipped = 0
+            GROUP BY tier
+        """)
+        by_tier = {row["tier"]: row["total_cost"] for row in cursor.fetchall()}
+
+        # Recent runs (last 10)
+        cursor.execute("""
+            SELECT * FROM workflow_runs
+            ORDER BY started_at DESC
+            LIMIT 10
+        """)
+        recent_runs = [dict(row) for row in cursor.fetchall()]
+
+        # Totals
+        cursor.execute("""
+            SELECT
+                COUNT(*) as total_runs,
+                SUM(success) as successful_runs,
+                SUM(total_cost) as total_cost,
+                SUM(savings) as total_savings,
+                AVG(CASE WHEN success = 1 THEN savings_percent ELSE NULL END) as avg_savings_percent
+            FROM workflow_runs
+        """)
+        totals = dict(cursor.fetchone())
+
+        return {
+            "total_runs": totals["total_runs"] or 0,
+            "successful_runs": totals["successful_runs"] or 0,
+            "by_workflow": by_workflow,
+            "by_provider": by_provider,
+            "by_tier": by_tier,
+            "recent_runs": recent_runs,
+            "total_cost": totals["total_cost"] or 0.0,
+            "total_savings": totals["total_savings"] or 0.0,
+            "avg_savings_percent": totals["avg_savings_percent"] or 0.0,
+        }
+
+    def get_run_by_id(self, run_id: str) -> dict | None:
+        """Get a specific run by ID.
+
+        Args:
+            run_id: The run ID to fetch
+
+        Returns:
+            Run dictionary with stages, or None if not found
+        """
+        cursor = self.conn.cursor()
+        cursor.execute("SELECT * FROM workflow_runs WHERE run_id = ?", (run_id,))
+
+        row = cursor.fetchone()
+        if not row:
+            return None
+
+        run = dict(row)
+
+        # Fetch stages
+        cursor.execute(
+            """
+            SELECT * FROM workflow_stages
+            WHERE run_id = ?
+            ORDER BY stage_id
+        """,
+            (run_id,),
+        )
+        run["stages"] = [dict(s) for s in cursor.fetchall()]
+
+        return run
+
+    def delete_run(self, run_id: str) -> bool:
+        """Delete a workflow run and its stages.
+
+        Args:
+            run_id: The run ID to delete
+
+        Returns:
+            True if run was deleted, False if not found
+        """
+        cursor = self.conn.cursor()
+
+        # Delete stages first (foreign key)
+        cursor.execute("DELETE FROM workflow_stages WHERE run_id = ?", (run_id,))
+
+        # Delete run
+        cursor.execute("DELETE FROM workflow_runs WHERE run_id = ?", (run_id,))
+
+        deleted = cursor.rowcount > 0
+        self.conn.commit()
+
+        if deleted:
+            logger.debug(f"Deleted workflow run: {run_id}")
+
+        return deleted
+
+    def cleanup_old_runs(self, keep_days: int = 90) -> int:
+        """Delete runs older than specified days.
+
+        Args:
+            keep_days: Number of days to keep (default: 90)
+
+        Returns:
+            Number of runs deleted
+        """
+        cutoff = datetime.now().replace(
+            hour=0, minute=0, second=0, microsecond=0
+        ).isoformat()
+
+        cursor = self.conn.cursor()
+
+        # Get run IDs to delete
+        cursor.execute(
+            """
+            SELECT run_id FROM workflow_runs
+            WHERE started_at < datetime('now', '-' || ? || ' days')
+        """,
+            (keep_days,),
+        )
+
+        run_ids = [row["run_id"] for row in cursor.fetchall()]
+
+        if not run_ids:
+            return 0
+
+        # Delete stages for these runs
+        placeholders = ",".join("?" * len(run_ids))
+        cursor.execute(
+            f"DELETE FROM workflow_stages WHERE run_id IN ({placeholders})", run_ids
+        )
+
+        # Delete runs
+        cursor.execute(
+            f"DELETE FROM workflow_runs WHERE run_id IN ({placeholders})", run_ids
+        )
+
+        self.conn.commit()
+        logger.info(f"Cleaned up {len(run_ids)} runs older than {keep_days} days")
+
+        return len(run_ids)
+
+    def close(self) -> None:
+        """Close database connection.
+
+        Should be called when done with the store.
+        """
+        self.conn.close()
+        logger.debug("History store closed")
+
+    def __enter__(self):
+        """Context manager entry."""
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Context manager exit - closes connection."""
+        self.close()

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
@@ -268,10 +269,10 @@ class PerformanceAuditWorkflow(BaseWorkflow):
         # Analyze each file
         analysis: list[dict] = []
         for file_path, file_findings in by_file.items():
-            # Calculate file complexity score
-            high_count = len([f for f in file_findings if f["impact"] == "high"])
-            medium_count = len([f for f in file_findings if f["impact"] == "medium"])
-            low_count = len([f for f in file_findings if f["impact"] == "low"])
+            # Calculate file complexity score (generator expressions for memory efficiency)
+            high_count = sum(1 for f in file_findings if f["impact"] == "high")
+            medium_count = sum(1 for f in file_findings if f["impact"] == "medium")
+            low_count = sum(1 for f in file_findings if f["impact"] == "low")
 
             complexity_score = high_count * 10 + medium_count * 5 + low_count * 1
 
@@ -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())