empathy-framework 3.9.2__py3-none-any.whl → 3.10.1__py3-none-any.whl

empathy_os/cli.py

@@ -41,11 +41,15 @@ from empathy_os.workflows import list_workflows as get_workflow_list
 # Import telemetry CLI commands
 try:
     from empathy_os.telemetry.cli import (
+        cmd_agent_performance,
+        cmd_task_routing_report,
         cmd_telemetry_compare,
         cmd_telemetry_export,
         cmd_telemetry_reset,
         cmd_telemetry_savings,
         cmd_telemetry_show,
+        cmd_test_status,
+        cmd_tier1_status,
     )
 
     TELEMETRY_CLI_AVAILABLE = True
@@ -2148,7 +2152,20 @@ def cmd_workflow(args):
 
                 wf_config = WorkflowConfig.load()
                 provider = wf_config.default_provider
-            workflow = workflow_cls(provider=provider)
+
+            # Initialize workflow with tier fallback if requested
+            use_tier_fallback = getattr(args, "use_recommended_tier", False)
+            workflow_kwargs = {
+                "provider": provider,
+                "enable_tier_fallback": use_tier_fallback,
+            }
+
+            # Add health-check specific parameters
+            if name == "health-check":
+                health_score_threshold = getattr(args, "health_score_threshold", 100)
+                workflow_kwargs["health_score_threshold"] = health_score_threshold
+
+            workflow = workflow_cls(**workflow_kwargs)
 
             # Parse input
             input_data = {}
@@ -2244,25 +2261,76 @@ def cmd_workflow(args):
                 }
                 print(json_mod.dumps(output, indent=2))
             # Display the actual results - this is what users want to see
-            elif result.success:
-                if output_content:
-                    print(f"\n{output_content}\n")
-                else:
-                    print("\n✓ Workflow completed successfully.\n")
             else:
-                # Extract error from various result types
-                error_msg = getattr(result, "error", None)
-                if not error_msg:
-                    # Check for blockers (CodeReviewPipelineResult)
-                    blockers = getattr(result, "blockers", [])
-                    if blockers:
-                        error_msg = "; ".join(blockers)
+                # Show tier progression if tier fallback was used
+                if use_tier_fallback and hasattr(workflow, "_tier_progression"):
+                    tier_progression = workflow._tier_progression
+                    if tier_progression:
+                        print("\n" + "=" * 60)
+                        print("  TIER PROGRESSION (Intelligent Fallback)")
+                        print("=" * 60)
+
+                        # Group by stage
+                        stage_tiers: dict[str, list[tuple[str, bool]]] = {}
+                        for stage, tier, success in tier_progression:
+                            if stage not in stage_tiers:
+                                stage_tiers[stage] = []
+                            stage_tiers[stage].append((tier, success))
+
+                        # Display progression for each stage
+                        for stage, attempts in stage_tiers.items():
+                            status = "✓" if any(success for _, success in attempts) else "✗"
+                            print(f"\n{status} Stage: {stage}")
+
+                            for idx, (tier, success) in enumerate(attempts, 1):
+                                attempt_status = "✓ SUCCESS" if success else "✗ FAILED"
+                                if idx == 1:
+                                    print(f"  Attempt {idx}: {tier.upper():8} → {attempt_status}")
+                                else:
+                                    prev_tier = attempts[idx - 2][0]
+                                    print(
+                                        f"  Attempt {idx}: {tier.upper():8} → {attempt_status} "
+                                        f"(upgraded from {prev_tier.upper()})"
+                                    )
+
+                        # Calculate cost savings (only if result has stages attribute)
+                        if hasattr(result, "stages") and result.stages:
+                            actual_cost = sum(stage.cost for stage in result.stages if stage.cost)
+                            # Estimate what cost would be if all stages used PREMIUM
+                            premium_cost = actual_cost * 3  # Conservative estimate
+
+                            savings = premium_cost - actual_cost
+                            savings_pct = (savings / premium_cost * 100) if premium_cost > 0 else 0
+
+                            print("\n" + "-" * 60)
+                            print("💰 Cost Savings:")
+                            print(f"  Actual cost:   ${actual_cost:.4f}")
+                            print(f"  Premium cost:  ${premium_cost:.4f} (if all PREMIUM)")
+                            print(f"  Savings:       ${savings:.4f} ({savings_pct:.1f}%)")
+                        print("=" * 60 + "\n")
+
+                # Display workflow result
+                if result.success:
+                    if output_content:
+                        print(f"\n{output_content}\n")
                     else:
-                        # Check metadata for error
-                        metadata = getattr(result, "metadata", {})
-                        error_msg = metadata.get("error") if isinstance(metadata, dict) else None
-                error_msg = error_msg or "Unknown error"
-                print(f"\n✗ Workflow failed: {error_msg}\n")
+                        print("\n✓ Workflow completed successfully.\n")
+                else:
+                    # Extract error from various result types
+                    error_msg = getattr(result, "error", None)
+                    if not error_msg:
+                        # Check for blockers (CodeReviewPipelineResult)
+                        blockers = getattr(result, "blockers", [])
+                        if blockers:
+                            error_msg = "; ".join(blockers)
+                        else:
+                            # Check metadata for error
+                            metadata = getattr(result, "metadata", {})
+                            error_msg = (
+                                metadata.get("error") if isinstance(metadata, dict) else None
+                            )
+                    error_msg = error_msg or "Unknown error"
+                    print(f"\n✗ Workflow failed: {error_msg}\n")
 
         except KeyError as e:
             print(f"Error: {e}")
@@ -2436,6 +2504,38 @@ def _cmd_telemetry_export(args):
     return cmd_telemetry_export(args)
 
 
+def _cmd_tier1_status(args):
+    """Wrapper for tier1 status command."""
+    if not TELEMETRY_CLI_AVAILABLE:
+        print("Tier 1 monitoring commands not available. Install telemetry dependencies.")
+        return 1
+    return cmd_tier1_status(args)
+
+
+def _cmd_task_routing_report(args):
+    """Wrapper for task routing report command."""
+    if not TELEMETRY_CLI_AVAILABLE:
+        print("Tier 1 monitoring commands not available. Install telemetry dependencies.")
+        return 1
+    return cmd_task_routing_report(args)
+
+
+def _cmd_test_status(args):
+    """Wrapper for test status command."""
+    if not TELEMETRY_CLI_AVAILABLE:
+        print("Tier 1 monitoring commands not available. Install telemetry dependencies.")
+        return 1
+    return cmd_test_status(args)
+
+
+def _cmd_agent_performance(args):
+    """Wrapper for agent performance command."""
+    if not TELEMETRY_CLI_AVAILABLE:
+        print("Tier 1 monitoring commands not available. Install telemetry dependencies.")
+        return 1
+    return cmd_agent_performance(args)
+
+
 def main():
     """Main CLI entry point"""
     # Configure Windows-compatible asyncio event loop policy
@@ -2929,6 +3029,60 @@ def main():
     )
     parser_telemetry_export.set_defaults(func=lambda args: _cmd_telemetry_export(args))
 
+    # Tier 1 automation monitoring commands
+
+    # tier1 command - comprehensive status
+    parser_tier1 = subparsers.add_parser(
+        "tier1",
+        help="Show Tier 1 automation status (tasks, tests, coverage, agents)",
+    )
+    parser_tier1.add_argument(
+        "--hours",
+        type=int,
+        default=24,
+        help="Hours to analyze (default: 24)",
+    )
+    parser_tier1.set_defaults(func=lambda args: _cmd_tier1_status(args))
+
+    # tasks command - task routing report
+    parser_tasks = subparsers.add_parser(
+        "tasks",
+        help="Show task routing report",
+    )
+    parser_tasks.add_argument(
+        "--hours",
+        type=int,
+        default=24,
+        help="Hours to analyze (default: 24)",
+    )
+    parser_tasks.set_defaults(func=lambda args: _cmd_task_routing_report(args))
+
+    # tests command - test execution status
+    parser_tests = subparsers.add_parser(
+        "tests",
+        help="Show test execution status",
+    )
+    parser_tests.add_argument(
+        "--hours",
+        type=int,
+        default=24,
+        help="Hours to analyze (default: 24)",
+    )
+    parser_tests.set_defaults(func=lambda args: _cmd_test_status(args))
+
+    # agents command - agent performance
+    parser_agents = subparsers.add_parser(
+        "agents",
+        help="Show agent performance metrics",
+    )
+    parser_agents.add_argument(
+        "--hours",
+        type=int,
+        default=168,
+        help="Hours to analyze (default: 168 / 7 days)",
+    )
+    parser_agents.set_defaults(func=lambda args: _cmd_agent_performance(args))
+
     # New command (project scaffolding)
     parser_new = subparsers.add_parser("new", help="Create a new project from a template")
     parser_new.add_argument(
@@ -3018,6 +3172,11 @@ def main():
         help="Force overwrite existing config file",
     )
     parser_workflow.add_argument("--json", action="store_true", help="Output as JSON")
+    parser_workflow.add_argument(
+        "--use-recommended-tier",
+        action="store_true",
+        help="Enable intelligent tier fallback: start with CHEAP tier and automatically upgrade if quality gates fail",
+    )
     parser_workflow.add_argument(
         "--write-tests",
         action="store_true",
@@ -3028,6 +3187,12 @@ def main():
         default="tests/generated",
         help="(test-gen workflow) Output directory for generated tests",
     )
+    parser_workflow.add_argument(
+        "--health-score-threshold",
+        type=int,
+        default=95,
+        help="(health-check workflow) Minimum health score required (0-100, default: 95 for very strict quality)",
+    )
     parser_workflow.set_defaults(func=cmd_workflow)
 
     # Sync-claude command (sync patterns to Claude Code)

empathy_os/cli_unified.py

@@ -462,11 +462,36 @@ def workflow_list():
 def workflow_run(
     name: str = typer.Argument(..., help="Workflow name"),
     path: Path = typer.Option(Path(), "--path", "-p", help="Path to run on"),
+    use_recommended_tier: bool = typer.Option(
+        False,
+        "--use-recommended-tier",
+        help="Enable intelligent tier fallback: start with CHEAP tier and automatically upgrade if quality gates fail",
+    ),
+    health_score_threshold: int = typer.Option(
+        95,
+        "--health-score-threshold",
+        help="(health-check workflow) Minimum health score required (0-100, default: 95 for very strict quality)",
+    ),
 ):
     """Run a multi-model workflow."""
-    subprocess.run(
-        [sys.executable, "-m", "empathy_os.cli", "workflow", "run", name, str(path)], check=False
-    )
+    cmd = [
+        sys.executable,
+        "-m",
+        "empathy_os.cli",
+        "workflow",
+        "run",
+        name,
+        "--input",
+        f'{{"path": "{path}"}}',
+    ]
+
+    if use_recommended_tier:
+        cmd.append("--use-recommended-tier")
+
+    if health_score_threshold != 95:
+        cmd.extend(["--health-score-threshold", str(health_score_threshold)])
+
+    subprocess.run(cmd, check=False)
 
 
 @workflow_app.command("create")
@@ -513,6 +538,85 @@ def workflow_recommend(
     )
 
 
+# =============================================================================
+# TELEMETRY SUBCOMMAND GROUP
+# =============================================================================
+
+telemetry_app = typer.Typer(help="View and manage local usage telemetry")
+app.add_typer(telemetry_app, name="telemetry")
+
+
+@telemetry_app.command("show")
+def telemetry_show(
+    limit: int = typer.Option(20, "--limit", "-l", help="Number of entries to show"),
+    days: int | None = typer.Option(None, "--days", "-d", help="Only show last N days"),
+):
+    """Show recent LLM calls and usage stats."""
+    args = [sys.executable, "-m", "empathy_os.cli", "telemetry", "show", "--limit", str(limit)]
+    if days:
+        args.extend(["--days", str(days)])
+    subprocess.run(args, check=False)
+
+
+@telemetry_app.command("savings")
+def telemetry_savings(
+    days: int = typer.Option(30, "--days", "-d", help="Number of days to analyze"),
+):
+    """Calculate cost savings vs baseline (all PREMIUM)."""
+    subprocess.run(
+        [sys.executable, "-m", "empathy_os.cli", "telemetry", "savings", "--days", str(days)],
+        check=False,
+    )
+
+
+@telemetry_app.command("compare")
+def telemetry_compare(
+    period1: int = typer.Option(7, "--period1", "-p1", help="First period in days"),
+    period2: int = typer.Option(30, "--period2", "-p2", help="Second period in days"),
+):
+    """Compare usage across two time periods."""
+    subprocess.run(
+        [
+            sys.executable,
+            "-m",
+            "empathy_os.cli",
+            "telemetry",
+            "compare",
+            "--period1",
+            str(period1),
+            "--period2",
+            str(period2),
+        ],
+        check=False,
+    )
+
+
+@telemetry_app.command("export")
+def telemetry_export(
+    format_type: str = typer.Option("json", "--format", "-f", help="Export format (json, csv)"),
+    output: Path | None = typer.Option(None, "--output", "-o", help="Output file path"),
+    days: int | None = typer.Option(None, "--days", "-d", help="Only export last N days"),
+):
+    """Export telemetry data to JSON or CSV."""
+    args = [sys.executable, "-m", "empathy_os.cli", "telemetry", "export", "--format", format_type]
+    if output:
+        args.extend(["--output", str(output)])
+    if days:
+        args.extend(["--days", str(days)])
+    subprocess.run(args, check=False)
+
+
+@telemetry_app.command("reset")
+def telemetry_reset(
+    confirm: bool = typer.Option(False, "--confirm", help="Confirm deletion"),
+):
+    """Clear all telemetry data (use with caution)."""
+    args = [sys.executable, "-m", "empathy_os.cli", "telemetry", "reset"]
+    if confirm:
+        args.append("--confirm")
+    subprocess.run(args, check=False)
+
+
 # =============================================================================
 # TIER RECOMMENDATION SUBCOMMAND GROUP
 # =============================================================================
@@ -669,7 +773,12 @@ def cheatsheet():
   empathy wizard list       Show available wizards
   empathy wizard run <name> Execute a wizard
   empathy wizard create <name> -d <domain>  Create wizard (12x faster)
-  empathy wizard list-patterns              List available patterns""",
+  empathy wizard list-patterns              List available patterns
+
+[bold]Usage Telemetry[/bold]
+  empathy telemetry show    View recent LLM calls & costs
+  empathy telemetry savings Calculate cost savings (tier routing)
+  empathy telemetry export  Export usage data (JSON/CSV)""",
             title="[bold blue]Empathy Framework Cheatsheet[/bold blue]",
         ),
     )

empathy_os/config.py

@@ -14,7 +14,10 @@ import json
 import os
 from dataclasses import asdict, dataclass, field
 from pathlib import Path
-from typing import Any
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from empathy_os.workflows.config import ModelConfig
 
 try:
     import yaml
@@ -23,8 +26,6 @@ try:
 except ImportError:
     YAML_AVAILABLE = False
 
-from empathy_os.workflows.config import ModelConfig
-
 
 def _validate_file_path(path: str, allowed_dir: str | None = None) -> Path:
     """Validate file path to prevent path traversal and arbitrary writes.
@@ -120,7 +121,7 @@ class EmpathyConfig:
     metadata: dict[str, Any] = field(default_factory=dict)
 
     # Model settings
-    models: list[ModelConfig] = field(default_factory=list)
+    models: list["ModelConfig"] = field(default_factory=list)
     default_model: str | None = None
     log_path: str | None = None
     max_threads: int = 4
@@ -181,6 +182,8 @@ class EmpathyConfig:
 
         # Handle nested ModelConfig objects
         if filtered_data.get("models"):
+            from empathy_os.workflows.config import ModelConfig
+
             filtered_data["models"] = [ModelConfig(**m) for m in filtered_data["models"]]
 
         return cls(**filtered_data)

empathy_os/hot_reload/integration.py

@@ -7,6 +7,7 @@ Licensed under Fair Source 0.9
 """
 
 import logging
+from collections.abc import Callable
 
 from fastapi import FastAPI, WebSocket, WebSocketDisconnect
 
@@ -45,7 +46,7 @@ class HotReloadIntegration:
     def __init__(
         self,
         app: FastAPI,
-        register_callback: callable,
+        register_callback: Callable[[str, type], bool],
     ):
         """Initialize hot-reload integration.
 

empathy_os/hot_reload/watcher.py

@@ -19,16 +19,16 @@ logger = logging.getLogger(__name__)
 class WizardFileHandler(FileSystemEventHandler):
     """Handles file system events for wizard files."""
 
-    def __init__(self, reload_callback: Callable[[str], None]):
+    def __init__(self, reload_callback: Callable[[str, str], None]):
         """Initialize handler.
 
         Args:
-            reload_callback: Function to call when wizard file changes
+            reload_callback: Function to call when wizard file changes (wizard_id, file_path)
 
         """
         super().__init__()
         self.reload_callback = reload_callback
-        self._processing = set()  # Prevent duplicate events
+        self._processing: set[str] = set()  # Prevent duplicate events
 
     def on_modified(self, event: FileSystemEvent) -> None:
         """Handle file modification events.
@@ -40,7 +40,11 @@ class WizardFileHandler(FileSystemEventHandler):
         if event.is_directory:
             return
 
-        file_path = event.src_path
+        # Convert file_path to str if it's bytes
+        file_path_raw = event.src_path
+        file_path = (
+            file_path_raw.decode("utf-8") if isinstance(file_path_raw, bytes) else file_path_raw
+        )
 
         # Only process Python files
         if not file_path.endswith(".py"):

empathy_os/hot_reload/websocket.py

@@ -8,6 +8,7 @@ Licensed under Fair Source 0.9
 
 import asyncio
 import logging
+from collections.abc import Callable
 from typing import Any
 
 from fastapi import WebSocket
@@ -141,7 +142,7 @@ def get_notification_manager() -> ReloadNotificationManager:
     return _notification_manager
 
 
-def create_notification_callback() -> callable:
+def create_notification_callback() -> Callable[[dict[str, Any]], None]:
     """Create a callback function for the wizard reloader.
 
     Returns: