empathy-framework 4.6.6__py3-none-any.whl → 4.7.0__py3-none-any.whl

empathy_os/cost_tracker.py

@@ -142,8 +142,12 @@ class CostTracker:
                 with open(self.costs_summary) as f:
                     summary_data = json.load(f)
                     self.data["daily_totals"] = summary_data.get("daily_totals", {})
-                    self.data["created_at"] = summary_data.get("created_at", self.data["created_at"])
-                    self.data["last_updated"] = summary_data.get("last_updated", self.data["last_updated"])
+                    self.data["created_at"] = summary_data.get(
+                        "created_at", self.data["created_at"]
+                    )
+                    self.data["last_updated"] = summary_data.get(
+                        "last_updated", self.data["last_updated"]
+                    )
                     return  # Summary loaded, done
             except (OSError, json.JSONDecodeError):
                 pass  # Fall through to JSON fallback
@@ -155,7 +159,9 @@ class CostTracker:
                     json_data = json.load(f)
                     self.data["daily_totals"] = json_data.get("daily_totals", {})
                     self.data["created_at"] = json_data.get("created_at", self.data["created_at"])
-                    self.data["last_updated"] = json_data.get("last_updated", self.data["last_updated"])
+                    self.data["last_updated"] = json_data.get(
+                        "last_updated", self.data["last_updated"]
+                    )
                     # Don't load requests here - they'll be lazy-loaded
             except (OSError, json.JSONDecodeError):
                 pass  # Use defaults

empathy_os/dashboard/server.py

@@ -42,6 +42,14 @@ except ImportError:
     list_workflows = None  # type: ignore[assignment]
     HAS_WORKFLOWS = False
 
+try:
+    from empathy_os.models.telemetry import TelemetryStore
+
+    HAS_TELEMETRY = True
+except ImportError:
+    TelemetryStore = None  # type: ignore[misc, assignment]
+    HAS_TELEMETRY = False
+
 
 class DashboardHandler(http.server.BaseHTTPRequestHandler):
     """HTTP request handler for the dashboard."""
@@ -69,6 +77,8 @@ class DashboardHandler(http.server.BaseHTTPRequestHandler):
             self._serve_health()
         elif path == "/api/workflows":
             self._serve_workflows()
+        elif path == "/api/tests":
+            self._serve_tests()
         else:
             self.send_error(404, "Not Found")
 
@@ -119,6 +129,70 @@ class DashboardHandler(http.server.BaseHTTPRequestHandler):
             data = {"error": "Workflows not available"}
         self._send_json(data)
 
+    def _serve_tests(self):
+        """Serve test tracking data as JSON."""
+        data = self._get_test_stats()
+        self._send_json(data)
+
+    def _get_test_stats(self) -> dict:
+        """Get test tracking statistics.
+
+        Returns:
+            Dictionary with test tracking data including:
+            - total_files: Total files with test records
+            - passed_files: Files with passing tests
+            - failed_files: Files with failing tests
+            - coverage_avg: Average coverage percentage
+            - recent_tests: Recent test executions
+            - files_needing_tests: Files that need attention
+        """
+        if not HAS_TELEMETRY or TelemetryStore is None:
+            return {"error": "Telemetry not available"}
+
+        try:
+            store = TelemetryStore(Path(self.empathy_dir))
+
+            # Get file test records and convert to dicts
+            file_tests_raw = store.get_file_tests(limit=100)
+            file_tests = [t.to_dict() if hasattr(t, "to_dict") else t for t in file_tests_raw]
+
+            # Calculate stats
+            total_files = len(file_tests)
+            passed_files = sum(1 for t in file_tests if t.get("last_test_result") == "passed")
+            failed_files = sum(1 for t in file_tests if t.get("last_test_result") == "failed")
+
+            # Coverage average (field is coverage_percent)
+            coverages = [
+                t.get("coverage_percent", 0) for t in file_tests if t.get("coverage_percent")
+            ]
+            coverage_avg = sum(coverages) / len(coverages) if coverages else 0
+
+            # If no coverage data, use pass rate as a proxy
+            if coverage_avg == 0 and total_files > 0:
+                coverage_avg = (passed_files / total_files) * 100
+
+            # Get files needing attention (failed or stale) and convert to dicts
+            files_needing_raw = store.get_files_needing_tests(stale_only=False, failed_only=False)
+            files_needing_tests = [
+                t.to_dict() if hasattr(t, "to_dict") else t for t in files_needing_raw[:10]
+            ]
+
+            # Get recent test executions and convert to dicts
+            recent_raw = store.get_test_executions(limit=10)
+            recent_executions = [t.to_dict() if hasattr(t, "to_dict") else t for t in recent_raw]
+
+            return {
+                "total_files": total_files,
+                "passed_files": passed_files,
+                "failed_files": failed_files,
+                "coverage_avg": round(coverage_avg, 1),
+                "files_needing_tests": files_needing_tests,
+                "recent_executions": recent_executions,
+                "file_tests": file_tests[:20],  # Most recent 20
+            }
+        except Exception as e:
+            return {"error": str(e)}
+
     def _send_json(self, data):
         """Send JSON response."""
         content = json.dumps(data, indent=2, default=str)
@@ -183,7 +257,8 @@ class DashboardHandler(http.server.BaseHTTPRequestHandler):
             try:
                 tracker = CostTracker(self.empathy_dir)
                 cost_summary = tracker.get_summary(30)  # noqa: F841
-            except Exception:
+            except Exception:  # noqa: BLE001
+                # INTENTIONAL: Dashboard should render even if cost tracking unavailable.
                 pass
 
         # Get workflow stats
@@ -198,9 +273,13 @@ class DashboardHandler(http.server.BaseHTTPRequestHandler):
         if HAS_WORKFLOWS and get_workflow_stats is not None:
             try:
                 workflow_stats = get_workflow_stats()
-            except Exception:
+            except Exception:  # noqa: BLE001
+                # INTENTIONAL: Dashboard should render even if workflow stats unavailable.
                 pass
 
+        # Get test stats
+        test_stats = self._get_test_stats()
+
         return f"""<!DOCTYPE html>
 <html lang="en">
 <head>
@@ -507,6 +586,12 @@ class DashboardHandler(http.server.BaseHTTPRequestHandler):
                 <div class="value">${workflow_stats.get("total_savings", 0):.2f}</div>
                 <div class="label">workflows + API</div>
             </div>
+
+            <div class="card {"success" if test_stats.get("failed_files", 0) == 0 else "warning"}">
+                <h2>Test Coverage</h2>
+                <div class="value">{test_stats.get("coverage_avg", 0):.0f}%</div>
+                <div class="label">{test_stats.get("total_files", 0)} files tracked</div>
+            </div>
         </div>
 
         <div class="section">
@@ -539,6 +624,11 @@ class DashboardHandler(http.server.BaseHTTPRequestHandler):
             {self._render_recent_runs(workflow_stats)}
         </div>
 
+        <div class="section">
+            <h2>Test Tracking</h2>
+            {self._render_test_tracking(test_stats)}
+        </div>
+
         <div class="section">
             <h2>Quick Commands</h2>
             <p>Run these commands for common tasks:</p>
@@ -684,6 +774,114 @@ class DashboardHandler(http.server.BaseHTTPRequestHandler):
 
         return "".join(runs_html)
 
+    def _render_test_tracking(self, test_stats: dict) -> str:
+        """Render test tracking section."""
+        if "error" in test_stats:
+            return f'<p style="color: var(--text-muted);">{test_stats["error"]}</p>'
+
+        total = test_stats.get("total_files", 0)
+        passed = test_stats.get("passed_files", 0)
+        failed = test_stats.get("failed_files", 0)
+        coverage = test_stats.get("coverage_avg", 0)
+
+        if total == 0:
+            return '<p style="color: var(--text-muted);">No test tracking data yet. Run tests with empathy to start tracking.</p>'
+
+        # Calculate pass rate
+        pass_rate = (passed / total * 100) if total > 0 else 0
+
+        # Stats grid
+        html = f"""
+        <div style="display: grid; grid-template-columns: repeat(4, 1fr); gap: 1rem; margin-bottom: 1.5rem;">
+            <div style="text-align: center; padding: 1rem; background: var(--bg); border-radius: 8px;">
+                <div style="font-size: 1.5rem; font-weight: 600; color: var(--success);">{passed}</div>
+                <div style="font-size: 0.75rem; color: var(--text-muted);">Passing</div>
+            </div>
+            <div style="text-align: center; padding: 1rem; background: var(--bg); border-radius: 8px;">
+                <div style="font-size: 1.5rem; font-weight: 600; color: var(--danger);">{failed}</div>
+                <div style="font-size: 0.75rem; color: var(--text-muted);">Failing</div>
+            </div>
+            <div style="text-align: center; padding: 1rem; background: var(--bg); border-radius: 8px;">
+                <div style="font-size: 1.5rem; font-weight: 600; color: var(--primary);">{pass_rate:.0f}%</div>
+                <div style="font-size: 0.75rem; color: var(--text-muted);">Pass Rate</div>
+            </div>
+            <div style="text-align: center; padding: 1rem; background: var(--bg); border-radius: 8px;">
+                <div style="font-size: 1.5rem; font-weight: 600; color: var(--warning);">{coverage:.0f}%</div>
+                <div style="font-size: 0.75rem; color: var(--text-muted);">Coverage</div>
+            </div>
+        </div>
+        """
+
+        # Files needing attention
+        files_needing = test_stats.get("files_needing_tests", [])
+        if files_needing:
+            html += """
+            <h3 style="margin-bottom: 0.5rem; font-size: 1rem;">Files Needing Attention</h3>
+            <table>
+                <thead>
+                    <tr>
+                        <th>File</th>
+                        <th>Status</th>
+                        <th>Last Run</th>
+                    </tr>
+                </thead>
+                <tbody>
+            """
+            for file_record in files_needing[:5]:
+                file_path = file_record.get("file_path", "unknown")
+                # Truncate long paths
+                display_path = ("..." + file_path[-40:]) if len(file_path) > 40 else file_path
+                result = file_record.get("last_test_result", "unknown")
+                timestamp = (
+                    file_record.get("timestamp", "")[:10] if file_record.get("timestamp") else "-"
+                )
+                status_class = "resolved" if result == "passed" else "investigating"
+                html += f"""
+                    <tr>
+                        <td title="{file_path}">{display_path}</td>
+                        <td><span class="status {status_class}">{result}</span></td>
+                        <td>{timestamp}</td>
+                    </tr>
+                """
+            html += "</tbody></table>"
+
+        # Recent test executions
+        recent = test_stats.get("recent_executions", [])
+        if recent:
+            html += """
+            <h3 style="margin-top: 1.5rem; margin-bottom: 0.5rem; font-size: 1rem;">Recent Test Runs</h3>
+            """
+            for execution in recent[:5]:
+                suite = execution.get("test_suite", "unknown")
+                total_tests = execution.get("total_tests", 0)
+                exec_passed = execution.get("passed", 0)
+                exec_failed = execution.get("failed", 0)
+                duration = execution.get("duration_seconds", 0)
+                timestamp = (
+                    execution.get("timestamp", "")[:16].replace("T", " ")
+                    if execution.get("timestamp")
+                    else "-"
+                )
+                success = execution.get("success", False)
+
+                status_icon = "&#10003;" if success else "&#10007;"
+                status_color = "var(--success)" if success else "var(--danger)"
+
+                html += f"""
+                <div class="recent-run">
+                    <span style="color: {status_color};">{status_icon}</span>
+                    <span class="name">{suite}</span>
+                    <span class="provider">{total_tests} tests</span>
+                    <span class="result">
+                        <span style="color: var(--success);">{exec_passed} passed</span>
+                        {f'<span style="color: var(--danger);">{exec_failed} failed</span>' if exec_failed > 0 else ""}
+                        <span class="time">{duration:.1f}s | {timestamp}</span>
+                    </span>
+                </div>
+                """
+
+        return html
+
 
 class ThreadedHTTPServer(socketserver.ThreadingMixIn, socketserver.TCPServer):
     """Threaded HTTP server."""

empathy_os/hot_reload/__init__.py

@@ -1,6 +1,6 @@
-"""Hot-Reload Infrastructure for Wizard Factory.
+"""Hot-Reload Infrastructure for Workflow Factory.
 
-Enables real-time wizard reloading during development without server restarts.
+Enables real-time workflow reloading during development without server restarts.
 
 Features:
 - File system monitoring with watchdog
@@ -13,7 +13,7 @@ Usage:
     from hot_reload.integration import HotReloadIntegration
 
     app = FastAPI()
-    hot_reload = HotReloadIntegration(app, register_wizard)
+    hot_reload = HotReloadIntegration(app, register_workflow)
 
     @app.on_event("startup")
     async def startup():
@@ -35,8 +35,8 @@ Licensed under Fair Source 0.9
 
 from .config import HotReloadConfig, get_hot_reload_config
 from .integration import HotReloadIntegration
-from .reloader import ReloadResult, WizardReloader
-from .watcher import WizardFileWatcher
+from .reloader import ReloadResult, WorkflowReloader
+from .watcher import WorkflowFileWatcher
 from .websocket import (
     ReloadNotificationManager,
     create_notification_callback,
@@ -45,8 +45,8 @@ from .websocket import (
 
 __all__ = [
     # Core components
-    "WizardFileWatcher",
-    "WizardReloader",
+    "WorkflowFileWatcher",
+    "WorkflowReloader",
     "ReloadResult",
     # WebSocket
     "ReloadNotificationManager",

empathy_os/hot_reload/config.py

@@ -16,7 +16,7 @@ class HotReloadConfig:
         # Development mode (enables hot-reload)
         self.enabled = os.getenv("HOT_RELOAD_ENABLED", "false").lower() == "true"
 
-        # Wizard directories to watch
+        # Workflow directories to watch
         self.watch_dirs = self._get_watch_dirs()
 
         # WebSocket endpoint for notifications
@@ -26,20 +26,19 @@ class HotReloadConfig:
         self.reload_delay = float(os.getenv("HOT_RELOAD_DELAY", "0.5"))
 
     def _get_watch_dirs(self) -> list[Path]:
-        """Get directories to watch for wizard changes.
+        """Get directories to watch for workflow changes.
 
         Returns:
             List of directories to watch
 
         """
-        # Default wizard directories
+        # Default workflow directories
         project_root = Path(__file__).parent.parent
 
         default_dirs = [
-            project_root / "wizards",
-            project_root / "coach_wizards",
-            project_root / "empathy_software_plugin" / "wizards",
-            project_root / "empathy_llm_toolkit" / "wizards",
+            project_root / "workflows",
+            project_root / "empathy_software_plugin" / "workflows",
+            project_root / "empathy_llm_toolkit" / "workflows",
         ]
 
         # Filter to only existing directories

empathy_os/hot_reload/integration.py

@@ -1,6 +1,6 @@
-"""Integration example for hot-reload with wizard API.
+"""Integration example for hot-reload with workflow API.
 
-Shows how to integrate hot-reload into the existing wizard_api.py.
+Shows how to integrate hot-reload into the existing workflow_api.py.
 
 Copyright 2025 Smart AI Memory, LLC
 Licensed under Fair Source 0.9
@@ -12,17 +12,17 @@ from collections.abc import Callable
 from fastapi import FastAPI, WebSocket, WebSocketDisconnect
 
 from .config import get_hot_reload_config
-from .reloader import WizardReloader
-from .watcher import WizardFileWatcher
+from .reloader import WorkflowReloader
+from .watcher import WorkflowFileWatcher
 from .websocket import create_notification_callback, get_notification_manager
 
 logger = logging.getLogger(__name__)
 
 
 class HotReloadIntegration:
-    """Integrates hot-reload with wizard API.
+    """Integrates hot-reload with workflow API.
 
-    Example usage in wizard_api.py:
+    Example usage in workflow_api.py:
 
         from hot_reload.integration import HotReloadIntegration
 
@@ -30,11 +30,11 @@ class HotReloadIntegration:
         app = FastAPI()
 
         # Initialize hot-reload (if enabled)
-        hot_reload = HotReloadIntegration(app, register_wizard)
+        hot_reload = HotReloadIntegration(app, register_workflow)
 
         @app.on_event("startup")
         async def startup_event():
-            init_wizards()  # Initialize wizards
+            init_workflows()  # Initialize workflows
             hot_reload.start()  # Start hot-reload watcher
 
         @app.on_event("shutdown")
@@ -52,7 +52,7 @@ class HotReloadIntegration:
 
         Args:
             app: FastAPI application instance
-            register_callback: Function to register wizard (wizard_id, wizard_class) -> bool
+            register_callback: Function to register workflow (workflow_id, workflow_class) -> bool
 
         """
         self.app = app
@@ -61,32 +61,32 @@ class HotReloadIntegration:
 
         # Initialize components
         self.notification_callback = create_notification_callback()
-        self.reloader = WizardReloader(
-            register_callback=self._register_wizard_wrapper,
+        self.reloader = WorkflowReloader(
+            register_callback=self._register_workflow_wrapper,
             notification_callback=self.notification_callback,
         )
 
-        self.watcher: WizardFileWatcher | None = None
+        self.watcher: WorkflowFileWatcher | None = None
 
         # Add WebSocket endpoint to app
         if self.config.enabled:
             self._setup_websocket_endpoint()
 
-    def _register_wizard_wrapper(self, wizard_id: str, wizard_class: type) -> bool:
+    def _register_workflow_wrapper(self, workflow_id: str, workflow_class: type) -> bool:
         """Wrapper for register callback that handles errors.
 
         Args:
-            wizard_id: Wizard identifier
-            wizard_class: Wizard class to register
+            workflow_id: Workflow identifier
+            workflow_class: Workflow class to register
 
         Returns:
             True if registration succeeded
 
         """
         try:
-            return self.register_callback(wizard_id, wizard_class)
+            return self.register_callback(workflow_id, workflow_class)
         except Exception as e:
-            logger.error(f"Error registering wizard {wizard_id}: {e}")
+            logger.error(f"Error registering workflow {workflow_id}: {e}")
             return False
 
     def _setup_websocket_endpoint(self) -> None:
@@ -120,7 +120,7 @@ class HotReloadIntegration:
             return
 
         if not self.config.watch_dirs:
-            logger.warning("No wizard directories found to watch")
+            logger.warning("No workflow directories found to watch")
             return
 
         if self.watcher and self.watcher.is_running():
@@ -128,8 +128,8 @@ class HotReloadIntegration:
             return
 
         # Create watcher
-        self.watcher = WizardFileWatcher(
-            wizard_dirs=self.config.watch_dirs,
+        self.watcher = WorkflowFileWatcher(
+            workflow_dirs=self.config.watch_dirs,
             reload_callback=self._on_file_change,
         )
 
@@ -145,18 +145,18 @@ class HotReloadIntegration:
             self.watcher = None
             logger.info("Hot-reload stopped")
 
-    def _on_file_change(self, wizard_id: str, file_path: str) -> None:
+    def _on_file_change(self, workflow_id: str, file_path: str) -> None:
         """Handle file change event.
 
         Args:
-            wizard_id: ID of wizard that changed
+            workflow_id: ID of workflow that changed
             file_path: Path to changed file
 
         """
-        logger.info(f"File change detected: {wizard_id} ({file_path})")
+        logger.info(f"File change detected: {workflow_id} ({file_path})")
 
-        # Reload wizard
-        result = self.reloader.reload_wizard(wizard_id, file_path)
+        # Reload workflow
+        result = self.reloader.reload_workflow(workflow_id, file_path)
 
         if result.success:
             logger.info(f"✓ {result.message}")
@@ -180,25 +180,25 @@ class HotReloadIntegration:
         }
 
 
-# Example usage in wizard_api.py:
+# Example usage in workflow_api.py:
 """
 from fastapi import FastAPI
 from hot_reload.integration import HotReloadIntegration
 
-app = FastAPI(title="Empathy Wizard API")
+app = FastAPI(title="Empathy Workflow API")
 
 # Global hot-reload instance
 hot_reload = None
 
 
-def register_wizard(wizard_id: str, wizard_class: type, *args, **kwargs) -> bool:
-    '''Register wizard with WIZARDS dict'''
+def register_workflow(workflow_id: str, workflow_class: type, *args, **kwargs) -> bool:
+    '''Register workflow with WORKFLOWS dict'''
     try:
-        WIZARDS[wizard_id] = wizard_class(*args, **kwargs)
-        logger.info(f"✓ Registered wizard: {wizard_id}")
+        WORKFLOWS[workflow_id] = workflow_class(*args, **kwargs)
+        logger.info(f"✓ Registered workflow: {workflow_id}")
         return True
     except Exception as e:
-        logger.error(f"Failed to register {wizard_id}: {e}")
+        logger.error(f"Failed to register {workflow_id}: {e}")
         return False
 
 
@@ -206,11 +206,11 @@ def register_wizard(wizard_id: str, wizard_class: type, *args, **kwargs) -> bool
 async def startup_event():
     global hot_reload
 
-    # Initialize wizards
-    init_wizards()
+    # Initialize workflows
+    init_workflows()
 
     # Start hot-reload
-    hot_reload = HotReloadIntegration(app, register_wizard)
+    hot_reload = HotReloadIntegration(app, register_workflow)
     hot_reload.start()