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

empathy_os/plugins/registry.py

@@ -9,7 +9,7 @@ Licensed under Fair Source 0.9
 import logging
 from importlib.metadata import entry_points
 
-from .base import BasePlugin, BaseWizard, PluginValidationError
+from .base import BasePlugin, BaseWorkflow, PluginValidationError
 
 logger = logging.getLogger(__name__)
 
@@ -118,11 +118,11 @@ class PluginRegistry:
 
         return list(self._plugins.keys())
 
-    def list_all_wizards(self) -> dict[str, list[str]]:
-        """List all wizards from all plugins.
+    def list_all_workflows(self) -> dict[str, list[str]]:
+        """List all workflows from all plugins.
 
         Returns:
-            Dictionary mapping plugin_name -> list of wizard_ids
+            Dictionary mapping plugin_name -> list of workflow_ids
 
         """
         if not self._auto_discovered:
@@ -130,19 +130,19 @@ class PluginRegistry:
 
         result = {}
         for plugin_name, plugin in self._plugins.items():
-            result[plugin_name] = plugin.list_wizards()
+            result[plugin_name] = plugin.list_workflows()
 
         return result
 
-    def get_wizard(self, plugin_name: str, wizard_id: str) -> type[BaseWizard] | None:
-        """Get a wizard from a specific plugin.
+    def get_workflow(self, plugin_name: str, workflow_id: str) -> type[BaseWorkflow] | None:
+        """Get a workflow from a specific plugin.
 
         Args:
             plugin_name: Plugin identifier
-            wizard_id: Wizard identifier within plugin
+            workflow_id: Workflow identifier within plugin
 
         Returns:
-            Wizard class or None if not found
+            Workflow class or None if not found
 
         """
         plugin = self.get_plugin(plugin_name)
@@ -150,33 +150,33 @@ class PluginRegistry:
             self.logger.warning(f"Plugin '{plugin_name}' not found")
             return None
 
-        return plugin.get_wizard(wizard_id)
+        return plugin.get_workflow(workflow_id)
 
-    def get_wizard_info(self, plugin_name: str, wizard_id: str) -> dict | None:
-        """Get information about a wizard.
+    def get_workflow_info(self, plugin_name: str, workflow_id: str) -> dict | None:
+        """Get information about a workflow.
 
         Args:
             plugin_name: Plugin identifier
-            wizard_id: Wizard identifier
+            workflow_id: Workflow identifier
 
         Returns:
-            Dictionary with wizard metadata or None
+            Dictionary with workflow metadata or None
 
         """
         plugin = self.get_plugin(plugin_name)
         if not plugin:
             return None
 
-        return plugin.get_wizard_info(wizard_id)
+        return plugin.get_workflow_info(workflow_id)
 
-    def find_wizards_by_level(self, empathy_level: int) -> list[dict]:
-        """Find all wizards operating at a specific empathy level.
+    def find_workflows_by_level(self, empathy_level: int) -> list[dict]:
+        """Find all workflows operating at a specific empathy level.
 
         Args:
             empathy_level: Target empathy level (1-5)
 
         Returns:
-            List of wizard info dictionaries
+            List of workflow info dictionaries
 
         """
         if not self._auto_discovered:
@@ -184,22 +184,22 @@ class PluginRegistry:
 
         results = []
         for plugin_name, plugin in self._plugins.items():
-            for wizard_id in plugin.list_wizards():
-                info = plugin.get_wizard_info(wizard_id)
+            for workflow_id in plugin.list_workflows():
+                info = plugin.get_workflow_info(workflow_id)
                 if info and info.get("empathy_level") == empathy_level:
                     info["plugin"] = plugin_name
                     results.append(info)
 
         return results
 
-    def find_wizards_by_domain(self, domain: str) -> list[dict]:
-        """Find all wizards for a specific domain.
+    def find_workflows_by_domain(self, domain: str) -> list[dict]:
+        """Find all workflows for a specific domain.
 
         Args:
             domain: Domain identifier (e.g., 'software', 'healthcare')
 
         Returns:
-            List of wizard info dictionaries
+            List of workflow info dictionaries
 
         """
         if not self._auto_discovered:
@@ -209,8 +209,8 @@ class PluginRegistry:
         for plugin_name, plugin in self._plugins.items():
             metadata = plugin.get_metadata()
             if metadata.domain == domain:
-                for wizard_id in plugin.list_wizards():
-                    info = plugin.get_wizard_info(wizard_id)
+                for workflow_id in plugin.list_workflows():
+                    info = plugin.get_workflow_info(workflow_id)
                     if info:
                         info["plugin"] = plugin_name
                         results.append(info)
@@ -227,26 +227,26 @@ class PluginRegistry:
         if not self._auto_discovered:
             self.auto_discover()
 
-        total_wizards = sum(len(plugin.list_wizards()) for plugin in self._plugins.values())
+        total_workflows = sum(len(plugin.list_workflows()) for plugin in self._plugins.values())
 
-        # Count wizards by level
-        wizards_by_level = {}
+        # Count workflows by level
+        workflows_by_level = {}
         for level in range(1, 6):
-            wizards_by_level[f"level_{level}"] = len(self.find_wizards_by_level(level))
+            workflows_by_level[f"level_{level}"] = len(self.find_workflows_by_level(level))
 
         return {
             "total_plugins": len(self._plugins),
-            "total_wizards": total_wizards,
+            "total_workflows": total_workflows,
             "plugins": [
                 {
                     "name": name,
                     "domain": plugin.get_metadata().domain,
                     "version": plugin.get_metadata().version,
-                    "wizard_count": len(plugin.list_wizards()),
+                    "workflow_count": len(plugin.list_workflows()),
                 }
                 for name, plugin in self._plugins.items()
             ],
-            "wizards_by_level": wizards_by_level,
+            "workflows_by_level": workflows_by_level,
         }
 
 

empathy_os/project_index/index.py

@@ -8,6 +8,7 @@ Licensed under Fair Source 0.9
 
 import json
 import logging
+from collections.abc import Iterator
 from datetime import datetime
 from pathlib import Path
 from typing import Any
@@ -278,37 +279,70 @@ class ProjectIndex:
         """Get project summary."""
         return self._summary
 
+    def iter_all_files(self) -> Iterator[FileRecord]:
+        """Iterate over all file records (memory-efficient).
+
+        Use this when you don't need all records at once.
+        """
+        yield from self._records.values()
+
     def get_all_files(self) -> list[FileRecord]:
-        """Get all file records."""
-        return list(self._records.values())
+        """Get all file records as a list.
+
+        Note: For large indexes, prefer iter_all_files() to avoid
+        loading all records into memory at once.
+        """
+        return list(self.iter_all_files())
+
+    def iter_files_needing_tests(self) -> Iterator[FileRecord]:
+        """Iterate over files that need tests (memory-efficient)."""
+        for r in self._records.values():
+            if r.test_requirement.value == "required" and not r.tests_exist:
+                yield r
 
     def get_files_needing_tests(self) -> list[FileRecord]:
         """Get files that need tests but don't have them."""
-        return [
-            r
-            for r in self._records.values()
-            if r.test_requirement.value == "required" and not r.tests_exist
-        ]
+        return list(self.iter_files_needing_tests())
+
+    def iter_stale_files(self) -> Iterator[FileRecord]:
+        """Iterate over files with stale tests (memory-efficient)."""
+        for r in self._records.values():
+            if r.is_stale:
+                yield r
 
     def get_stale_files(self) -> list[FileRecord]:
         """Get files with stale tests."""
-        return [r for r in self._records.values() if r.is_stale]
+        return list(self.iter_stale_files())
+
+    def iter_files_needing_attention(self) -> Iterator[FileRecord]:
+        """Iterate over files that need attention (memory-efficient).
+
+        Note: For sorted results, use get_files_needing_attention().
+        """
+        for r in self._records.values():
+            if r.needs_attention:
+                yield r
 
     def get_files_needing_attention(self) -> list[FileRecord]:
-        """Get files that need attention."""
+        """Get files that need attention, sorted by impact score."""
         return sorted(
-            [r for r in self._records.values() if r.needs_attention],
+            self.iter_files_needing_attention(),
             key=lambda r: -r.impact_score,
         )
 
+    def iter_high_impact_files(self) -> Iterator[FileRecord]:
+        """Iterate over high-impact files (memory-efficient).
+
+        Note: For sorted results, use get_high_impact_files().
+        """
+        for r in self._records.values():
+            if r.impact_score >= self.config.high_impact_threshold:
+                yield r
+
     def get_high_impact_files(self) -> list[FileRecord]:
         """Get high-impact files sorted by impact score."""
         return sorted(
-            [
-                r
-                for r in self._records.values()
-                if r.impact_score >= self.config.high_impact_threshold
-            ],
+            self.iter_high_impact_files(),
             key=lambda r: -r.impact_score,
         )
 

empathy_os/project_index/models.py

@@ -369,7 +369,7 @@ class IndexConfig:
             "**/poetry.lock",
             "**/Pipfile.lock",
             # Archive directories
-            "**/archived_wizards/**",
+            "**/archived_workflows/**",
         ],
     )
 
@@ -453,7 +453,6 @@ class IndexConfig:
         default_factory=lambda: [
             "src",
             "empathy_llm_toolkit",
-            "coach_wizards",
             "empathy_software_plugin",
             "empathy_healthcare_plugin",
         ],

empathy_os/project_index/reports.py

@@ -49,7 +49,7 @@ class ReportGenerator:
             "summary": {
                 "total_files_needing_tests": len(needing_tests),
                 "total_loc_untested": sum(r.lines_of_code for r in needing_tests),
-                "high_impact_untested": len([r for r in needing_tests if r.impact_score >= 5.0]),
+                "high_impact_untested": sum(1 for r in needing_tests if r.impact_score >= 5.0),
             },
             "priority_files": [
                 {

empathy_os/project_index/scanner.py

@@ -478,6 +478,7 @@ class ProjectScanner:
         nested ast.walk() calls. Previous implementation was O(n²) due to
         walking each function's subtree separately. This version is O(n).
         """
+
         # Use inner class to maintain state during traversal
         class MetricsVisitor(ast.NodeVisitor):
             def __init__(self) -> None:

empathy_os/redis_memory.py

@@ -757,7 +757,9 @@ class RedisShortTermMemory:
             return False
         try:
             return bool(self._client.ping())
-        except Exception:
+        except Exception:  # noqa: BLE001
+            # INTENTIONAL: Health check is best-effort. Connection failure is non-fatal.
+            # Consumers will handle disconnection gracefully.
             return False
 
     def get_stats(self) -> dict:
@@ -768,17 +770,18 @@ class RedisShortTermMemory:
 
         """
         if self.use_mock:
+            # Use generator expressions for memory-efficient counting
             return {
                 "mode": "mock",
                 "total_keys": len(self._mock_storage),
-                "working_keys": len(
-                    [k for k in self._mock_storage if k.startswith(self.PREFIX_WORKING)],
+                "working_keys": sum(
+                    1 for k in self._mock_storage if k.startswith(self.PREFIX_WORKING)
                 ),
-                "staged_keys": len(
-                    [k for k in self._mock_storage if k.startswith(self.PREFIX_STAGED)],
+                "staged_keys": sum(
+                    1 for k in self._mock_storage if k.startswith(self.PREFIX_STAGED)
                 ),
-                "conflict_keys": len(
-                    [k for k in self._mock_storage if k.startswith(self.PREFIX_CONFLICT)],
+                "conflict_keys": sum(
+                    1 for k in self._mock_storage if k.startswith(self.PREFIX_CONFLICT)
                 ),
             }
 

empathy_os/resilience/__init__.py

@@ -1,6 +1,6 @@
 """Empathy Framework Resilience Module
 
-Provides reliability patterns for fault-tolerant wizard operations.
+Provides reliability patterns for fault-tolerant workflow operations.
 
 Usage:
     from empathy_os.resilience import retry, circuit_breaker, timeout, fallback

empathy_os/resilience/health.py

@@ -229,18 +229,18 @@ def get_health_check() -> HealthCheck:
 def register_default_checks(health: HealthCheck) -> None:
     """Register default health checks for Empathy Framework."""
 
-    @health.register("wizard_registry")
-    async def check_wizard_registry() -> dict[str, Any]:
-        """Check wizard registry is loaded."""
+    @health.register("workflow_registry")
+    async def check_workflow_registry() -> dict[str, Any]:
+        """Check workflow registry is loaded."""
         try:
-            from empathy_os.routing import WizardRegistry
+            from empathy_os.routing import WorkflowRegistry
 
-            registry = WizardRegistry()
-            wizard_count = len(registry.list_all())
+            registry = WorkflowRegistry()
+            workflow_count = len(registry.list_all())
             return {
-                "healthy": wizard_count > 0,
-                "wizard_count": wizard_count,
-                "message": f"{wizard_count} wizards registered",
+                "healthy": workflow_count > 0,
+                "workflow_count": workflow_count,
+                "message": f"{workflow_count} workflows registered",
             }
         except Exception as e:
             return {"healthy": False, "message": str(e)}
@@ -279,7 +279,7 @@ def register_default_checks(health: HealthCheck) -> None:
             decision = router.route_sync("test request")
             return {
                 "healthy": decision is not None,
-                "primary_wizard": decision.primary_wizard,
+                "primary_workflow": decision.primary_workflow,
             }
         except Exception as e:
             return {"healthy": False, "message": str(e)}

empathy_os/routing/__init__.py

@@ -1,6 +1,6 @@
 """Empathy Framework Routing Module
 
-Intelligent request routing to wizards using LLM classification.
+Intelligent request routing to workflows using LLM classification.
 
 Usage:
     from empathy_os.routing import SmartRouter, quick_route
@@ -8,7 +8,7 @@ Usage:
     # Full router
     router = SmartRouter()
     decision = await router.route("Fix security issue in auth.py")
-    print(f"Use: {decision.primary_wizard}")
+    print(f"Use: {decision.primary_workflow}")
 
     # Quick helper
     decision = await quick_route("Optimize database queries")
@@ -20,10 +20,10 @@ Licensed under Fair Source 0.9
 from .chain_executor import ChainConfig, ChainExecution, ChainExecutor, ChainStep, ChainTrigger
 from .classifier import ClassificationResult, HaikuClassifier
 from .smart_router import RoutingDecision, SmartRouter, quick_route
-from .wizard_registry import WIZARD_REGISTRY, WizardInfo, WizardRegistry
+from .workflow_registry import WORKFLOW_REGISTRY, WorkflowInfo, WorkflowRegistry
 
 __all__ = [
-    "WIZARD_REGISTRY",
+    "WORKFLOW_REGISTRY",
     "ChainConfig",
     "ChainExecution",
     # Chain Executor
@@ -36,8 +36,8 @@ __all__ = [
     "RoutingDecision",
     # Smart Router
     "SmartRouter",
-    "WizardInfo",
-    # Wizard Registry
-    "WizardRegistry",
+    "WorkflowInfo",
+    # Workflow Registry
+    "WorkflowRegistry",
     "quick_route",
 ]

empathy_os/routing/chain_executor.py

@@ -1,6 +1,6 @@
 """Chain Executor
 
-Executes wizard chains based on triggers and conditions.
+Executes workflow chains based on triggers and conditions.
 Handles auto-chaining, approval workflows, and chain tracking.
 
 Copyright 2025 Smart AI Memory, LLC
@@ -14,7 +14,7 @@ from typing import Any
 
 import yaml
 
-from .wizard_registry import WizardRegistry
+from .workflow_registry import WorkflowRegistry
 
 
 @dataclass
@@ -22,16 +22,16 @@ class ChainTrigger:
     """A trigger condition for auto-chaining."""
 
     condition: str
-    next_wizard: str
+    next_workflow: str
     approval_required: bool = False
     reason: str = ""
 
 
 @dataclass
 class ChainConfig:
-    """Configuration for a wizard's chaining behavior."""
+    """Configuration for a workflow's chaining behavior."""
 
-    wizard_name: str
+    workflow_name: str
     auto_chain: bool = True
     description: str = ""
     triggers: list[ChainTrigger] = field(default_factory=list)
@@ -41,7 +41,7 @@ class ChainConfig:
 class ChainStep:
     """A step in an executed chain."""
 
-    wizard_name: str
+    workflow_name: str
     triggered_by: str  # condition or manual
     approval_required: bool
     approved: bool | None = None  # None = pending
@@ -55,7 +55,7 @@ class ChainExecution:
     """Record of a chain execution."""
 
     chain_id: str
-    initial_wizard: str
+    initial_workflow: str
     steps: list[ChainStep] = field(default_factory=list)
     started_at: datetime = field(default_factory=datetime.now)
     completed_at: datetime | None = None
@@ -64,12 +64,12 @@ class ChainExecution:
 
 
 class ChainExecutor:
-    """Executes wizard chains based on configuration and results.
+    """Executes workflow chains based on configuration and results.
 
     Usage:
         executor = ChainExecutor()
 
-        # Check for triggered chains after a wizard run
+        # Check for triggered chains after a workflow run
         result = {"high_severity_count": 5, "vulnerability_type": "injection"}
         next_steps = executor.get_triggered_chains("security-audit", result)
 
@@ -79,19 +79,19 @@ class ChainExecutor:
 
     def __init__(
         self,
-        config_path: str | Path = ".empathy/wizard_chains.yaml",
+        config_path: str | Path = ".empathy/workflow_chains.yaml",
     ):
         """Initialize the chain executor.
 
         Args:
-            config_path: Path to wizard_chains.yaml
+            config_path: Path to workflow_chains.yaml
 
         """
         self.config_path = Path(config_path)
         self._configs: dict[str, ChainConfig] = {}
         self._templates: dict[str, list[str]] = {}
         self._global_settings: dict[str, Any] = {}
-        self._registry = WizardRegistry()
+        self._registry = WorkflowRegistry()
         self._executions: list[ChainExecution] = []
 
         self._load_config()
@@ -110,20 +110,20 @@ class ChainExecutor:
 
             # Load chain configs
             chains = data.get("chains", {})
-            for wizard_name, config in chains.items():
+            for workflow_name, config in chains.items():
                 triggers = []
                 for t in config.get("triggers", []):
                     triggers.append(
                         ChainTrigger(
                             condition=t.get("condition", ""),
-                            next_wizard=t.get("next", ""),
+                            next_workflow=t.get("next", ""),
                             approval_required=t.get("approval_required", False),
                             reason=t.get("reason", ""),
                         ),
                     )
 
-                self._configs[wizard_name] = ChainConfig(
-                    wizard_name=wizard_name,
+                self._configs[workflow_name] = ChainConfig(
+                    workflow_name=workflow_name,
                     auto_chain=config.get("auto_chain", True),
                     description=config.get("description", ""),
                     triggers=triggers,
@@ -139,14 +139,14 @@ class ChainExecutor:
 
     def get_triggered_chains(
         self,
-        wizard_name: str,
+        workflow_name: str,
         result: dict[str, Any],
     ) -> list[ChainTrigger]:
-        """Get triggered chain steps based on wizard result.
+        """Get triggered chain steps based on workflow result.
 
         Args:
-            wizard_name: The wizard that just completed
-            result: The wizard's result dictionary
+            workflow_name: The workflow that just completed
+            result: The workflow's result dictionary
 
         Returns:
             List of triggered ChainTriggers
@@ -155,7 +155,7 @@ class ChainExecutor:
         if not self._global_settings.get("auto_chain_enabled", True):
             return []
 
-        config = self._configs.get(wizard_name)
+        config = self._configs.get(workflow_name)
         if not config or not config.auto_chain:
             return []
 
@@ -227,25 +227,25 @@ class ChainExecutor:
 
     def should_trigger_chain(
         self,
-        wizard_name: str,
+        workflow_name: str,
         result: dict[str, Any],
     ) -> tuple[bool, list[ChainTrigger]]:
         """Check if a chain should be triggered and return triggers.
 
         Args:
-            wizard_name: The wizard that completed
-            result: The wizard's result
+            workflow_name: The workflow that completed
+            result: The workflow's result
 
         Returns:
             Tuple of (should_trigger, list_of_triggers)
 
         """
-        triggers = self.get_triggered_chains(wizard_name, result)
+        triggers = self.get_triggered_chains(workflow_name, result)
         return len(triggers) > 0, triggers
 
-    def get_chain_config(self, wizard_name: str) -> ChainConfig | None:
-        """Get chain configuration for a wizard."""
-        return self._configs.get(wizard_name)
+    def get_chain_config(self, workflow_name: str) -> ChainConfig | None:
+        """Get chain configuration for a workflow."""
+        return self._configs.get(workflow_name)
 
     def get_template(self, template_name: str) -> list[str] | None:
         """Get a chain template by name."""
@@ -257,13 +257,13 @@ class ChainExecutor:
 
     def create_execution(
         self,
-        initial_wizard: str,
+        initial_workflow: str,
         triggered_steps: list[ChainTrigger] | None = None,
     ) -> ChainExecution:
         """Create a new chain execution record.
 
         Args:
-            initial_wizard: The starting wizard
+            initial_workflow: The starting workflow
             triggered_steps: Optional list of triggered next steps
 
         Returns:
@@ -272,13 +272,13 @@ class ChainExecutor:
         """
         execution = ChainExecution(
             chain_id=f"chain_{datetime.now().strftime('%Y%m%d%H%M%S')}",
-            initial_wizard=initial_wizard,
+            initial_workflow=initial_workflow,
         )
 
         # Add initial step
         execution.steps.append(
             ChainStep(
-                wizard_name=initial_wizard,
+                workflow_name=initial_workflow,
                 triggered_by="manual",
                 approval_required=False,
                 approved=True,
@@ -290,7 +290,7 @@ class ChainExecutor:
             for trigger in triggered_steps:
                 execution.steps.append(
                     ChainStep(
-                        wizard_name=trigger.next_wizard,
+                        workflow_name=trigger.next_workflow,
                         triggered_by=trigger.condition,
                         approval_required=trigger.approval_required,
                     ),
@@ -358,15 +358,15 @@ class ChainExecutor:
         step.result = result
 
         # Check for new triggers
-        new_triggers = self.get_triggered_chains(step.wizard_name, result)
+        new_triggers = self.get_triggered_chains(step.workflow_name, result)
 
         # Add new steps (if not already in chain)
-        existing_wizards = {s.wizard_name for s in execution.steps}
+        existing_workflows = {s.workflow_name for s in execution.steps}
         for trigger in new_triggers:
-            if trigger.next_wizard not in existing_wizards:
+            if trigger.next_workflow not in existing_workflows:
                 execution.steps.append(
                     ChainStep(
-                        wizard_name=trigger.next_wizard,
+                        workflow_name=trigger.next_workflow,
                         triggered_by=trigger.condition,
                         approval_required=trigger.approval_required,
                     ),