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

empathy_os/workflows/__init__.py

@@ -34,9 +34,41 @@ import importlib.util
 import os
 from typing import TYPE_CHECKING
 
+# =============================================================================
+# LAZY IMPORTS - Deferred loading for faster startup
+# =============================================================================
+# Workflow imports are deferred until actually accessed, reducing initial
+# import time from ~0.5s to ~0.05s for simple use cases.
+
 if TYPE_CHECKING:
     from .base import BaseWorkflow
-
+    from .bug_predict import BugPredictionWorkflow
+    from .code_review import CodeReviewWorkflow
+    from .code_review_pipeline import CodeReviewPipeline, CodeReviewPipelineResult
+    from .config import DEFAULT_MODELS, ModelConfig, WorkflowConfig
+    from .dependency_check import DependencyCheckWorkflow
+    from .document_gen import DocumentGenerationWorkflow
+    from .document_manager import DocumentManagerWorkflow
+    from .documentation_orchestrator import DocumentationOrchestrator, OrchestratorResult
+    from .keyboard_shortcuts import KeyboardShortcutWorkflow
+    from .manage_documentation import ManageDocumentationCrew, ManageDocumentationCrewResult
+    from .orchestrated_health_check import HealthCheckReport, OrchestratedHealthCheckWorkflow
+    from .orchestrated_release_prep import OrchestratedReleasePrepWorkflow, ReleaseReadinessReport
+    from .perf_audit import PerformanceAuditWorkflow
+    from .pr_review import PRReviewResult, PRReviewWorkflow
+    from .refactor_plan import RefactorPlanWorkflow
+    from .release_prep import ReleasePreparationWorkflow
+    from .release_prep_crew import ReleasePreparationCrew, ReleasePreparationCrewResult
+    from .research_synthesis import ResearchSynthesisWorkflow
+    from .secure_release import SecureReleasePipeline, SecureReleaseResult
+    from .security_audit import SecurityAuditWorkflow
+    from .step_config import WorkflowStepConfig
+    from .test5 import Test5Workflow
+    from .test_coverage_boost_crew import TestCoverageBoostCrew, TestCoverageBoostCrewResult
+    from .test_gen import TestGenerationWorkflow
+    from .xml_enhanced_crew import XMLAgent, XMLTask
+
+# Only import base module eagerly (small, needed for type checks)
 from .base import (
     PROVIDER_MODELS,
     BaseWorkflow,
@@ -48,122 +80,164 @@ from .base import (
     get_workflow_stats,
 )
 
-# New high-value workflows
-from .bug_predict import BugPredictionWorkflow
-from .code_review import CodeReviewWorkflow
-
-# Code review crew integration (v3.1)
-from .code_review_pipeline import CodeReviewPipeline, CodeReviewPipelineResult
+# Config is small and frequently needed
 from .config import DEFAULT_MODELS, ModelConfig, WorkflowConfig, create_example_config, get_model
-from .dependency_check import DependencyCheckWorkflow
-from .document_gen import DocumentGenerationWorkflow
-
-# User-generated workflows
-from .document_manager import DocumentManagerWorkflow
-from .documentation_orchestrator import DocumentationOrchestrator, OrchestratorResult
-
-# Removed deprecated: health_check.py, health_check_crew.py (use orchestrated_health_check instead)
-# Keyboard Conductor (v3.6) - keyboard shortcut generation
-from .keyboard_shortcuts import KeyboardShortcutWorkflow
-from .manage_documentation import ManageDocumentationCrew, ManageDocumentationCrewResult
-
-# Meta-orchestration workflows (v4.0)
-from .orchestrated_health_check import HealthCheckReport, OrchestratedHealthCheckWorkflow
-from .orchestrated_release_prep import OrchestratedReleasePrepWorkflow, ReleaseReadinessReport
-from .perf_audit import PerformanceAuditWorkflow
-from .pr_review import PRReviewResult, PRReviewWorkflow
-from .refactor_plan import RefactorPlanWorkflow
-from .release_prep import ReleasePreparationWorkflow
-
-# CrewAI-based crews (working replacements for broken orchestrator)
-from .release_prep_crew import ReleasePreparationCrew, ReleasePreparationCrewResult
-from .research_synthesis import ResearchSynthesisWorkflow
-
-# Security crew integration (v3.0)
-from .secure_release import SecureReleasePipeline, SecureReleaseResult
-from .security_audit import SecurityAuditWorkflow
 from .step_config import WorkflowStepConfig, steps_from_tier_map, validate_step_config
-from .test5 import Test5Workflow
 
-# Removed deprecated: test_coverage_boost.py (use test_coverage_boost_crew or orchestrated versions)
-from .test_coverage_boost_crew import TestCoverageBoostCrew, TestCoverageBoostCrewResult
-from .test_gen import TestGenerationWorkflow
+# Lazy import mapping for workflow classes
+_LAZY_WORKFLOW_IMPORTS: dict[str, tuple[str, str]] = {
+    # Core workflows
+    "BugPredictionWorkflow": (".bug_predict", "BugPredictionWorkflow"),
+    "CodeReviewWorkflow": (".code_review", "CodeReviewWorkflow"),
+    "CodeReviewPipeline": (".code_review_pipeline", "CodeReviewPipeline"),
+    "CodeReviewPipelineResult": (".code_review_pipeline", "CodeReviewPipelineResult"),
+    "DependencyCheckWorkflow": (".dependency_check", "DependencyCheckWorkflow"),
+    "DocumentGenerationWorkflow": (".document_gen", "DocumentGenerationWorkflow"),
+    "DocumentManagerWorkflow": (".document_manager", "DocumentManagerWorkflow"),
+    "DocumentationOrchestrator": (".documentation_orchestrator", "DocumentationOrchestrator"),
+    "OrchestratorResult": (".documentation_orchestrator", "OrchestratorResult"),
+    "KeyboardShortcutWorkflow": (".keyboard_shortcuts", "KeyboardShortcutWorkflow"),
+    "ManageDocumentationCrew": (".manage_documentation", "ManageDocumentationCrew"),
+    "ManageDocumentationCrewResult": (".manage_documentation", "ManageDocumentationCrewResult"),
+    "OrchestratedHealthCheckWorkflow": (".orchestrated_health_check", "OrchestratedHealthCheckWorkflow"),
+    "HealthCheckReport": (".orchestrated_health_check", "HealthCheckReport"),
+    "OrchestratedReleasePrepWorkflow": (".orchestrated_release_prep", "OrchestratedReleasePrepWorkflow"),
+    "ReleaseReadinessReport": (".orchestrated_release_prep", "ReleaseReadinessReport"),
+    "PerformanceAuditWorkflow": (".perf_audit", "PerformanceAuditWorkflow"),
+    "PRReviewWorkflow": (".pr_review", "PRReviewWorkflow"),
+    "PRReviewResult": (".pr_review", "PRReviewResult"),
+    "RefactorPlanWorkflow": (".refactor_plan", "RefactorPlanWorkflow"),
+    "ReleasePreparationWorkflow": (".release_prep", "ReleasePreparationWorkflow"),
+    "ReleasePreparationCrew": (".release_prep_crew", "ReleasePreparationCrew"),
+    "ReleasePreparationCrewResult": (".release_prep_crew", "ReleasePreparationCrewResult"),
+    "ResearchSynthesisWorkflow": (".research_synthesis", "ResearchSynthesisWorkflow"),
+    "SecureReleasePipeline": (".secure_release", "SecureReleasePipeline"),
+    "SecureReleaseResult": (".secure_release", "SecureReleaseResult"),
+    "SecurityAuditWorkflow": (".security_audit", "SecurityAuditWorkflow"),
+    "Test5Workflow": (".test5", "Test5Workflow"),
+    "TestCoverageBoostCrew": (".test_coverage_boost_crew", "TestCoverageBoostCrew"),
+    "TestCoverageBoostCrewResult": (".test_coverage_boost_crew", "TestCoverageBoostCrewResult"),
+    "TestGenerationWorkflow": (".test_gen", "TestGenerationWorkflow"),
+    "XMLAgent": (".xml_enhanced_crew", "XMLAgent"),
+    "XMLTask": (".xml_enhanced_crew", "XMLTask"),
+    "parse_xml_response": (".xml_enhanced_crew", "parse_xml_response"),
+}
+
+# Cache for loaded workflow classes
+_loaded_workflow_modules: dict[str, object] = {}
+
+
+def _lazy_import_workflow(name: str) -> object:
+    """Import a workflow class lazily."""
+    if name not in _LAZY_WORKFLOW_IMPORTS:
+        raise AttributeError(f"module 'empathy_os.workflows' has no attribute '{name}'")
 
-# XML-enhanced prompting (for Socratic workflow generator)
-from .xml_enhanced_crew import XMLAgent, XMLTask, parse_xml_response
+    module_path, attr_name = _LAZY_WORKFLOW_IMPORTS[name]
 
-# Re-export CLI commands from workflow_commands.py
+    # Check cache first
+    cache_key = f"{module_path}.{attr_name}"
+    if cache_key in _loaded_workflow_modules:
+        return _loaded_workflow_modules[cache_key]
+
+    # Import the module and get the attribute
+    import importlib
+    module = importlib.import_module(module_path, package="empathy_os.workflows")
+    attr = getattr(module, attr_name)
+
+    # Cache and return
+    _loaded_workflow_modules[cache_key] = attr
+    return attr
+
+# Re-export CLI commands from workflow_commands.py (lazy loaded)
 _parent_dir = os.path.dirname(os.path.dirname(__file__))
 _workflows_module_path = os.path.join(_parent_dir, "workflow_commands.py")
 
-# Initialize to None for type checking
+# Initialize to None for type checking - loaded lazily via __getattr__
 cmd_morning = None
 cmd_ship = None
 cmd_fix_all = None
 cmd_learn = None
+_cli_loaded = False
+
+
+def _load_cli_commands() -> None:
+    """Load CLI commands lazily."""
+    global cmd_morning, cmd_ship, cmd_fix_all, cmd_learn, _cli_loaded
+    if _cli_loaded:
+        return
+
+    if os.path.exists(_workflows_module_path):
+        _spec = importlib.util.spec_from_file_location("_workflows_cli", _workflows_module_path)
+        if _spec is not None and _spec.loader is not None:
+            _workflows_cli = importlib.util.module_from_spec(_spec)
+            _spec.loader.exec_module(_workflows_cli)
+
+            # Re-export CLI commands
+            cmd_morning = _workflows_cli.cmd_morning
+            cmd_ship = _workflows_cli.cmd_ship
+            cmd_fix_all = _workflows_cli.cmd_fix_all
+            cmd_learn = _workflows_cli.cmd_learn
 
-if os.path.exists(_workflows_module_path):
-    _spec = importlib.util.spec_from_file_location("_workflows_cli", _workflows_module_path)
-    if _spec is not None and _spec.loader is not None:
-        _workflows_cli = importlib.util.module_from_spec(_spec)
-        _spec.loader.exec_module(_workflows_cli)
-
-        # Re-export CLI commands
-        cmd_morning = _workflows_cli.cmd_morning
-        cmd_ship = _workflows_cli.cmd_ship
-        cmd_fix_all = _workflows_cli.cmd_fix_all
-        cmd_learn = _workflows_cli.cmd_learn
-
-# Default workflow registry (statically defined for backwards compatibility)
-# Note: Some entries are composite pipelines, not direct BaseWorkflow subclasses
-_DEFAULT_WORKFLOWS: dict[str, type] = {
+    _cli_loaded = True
+
+
+# Default workflow registry - uses CLASS NAMES (strings) for lazy loading
+# Actual classes are loaded on first access via _get_workflow_class()
+_DEFAULT_WORKFLOW_NAMES: dict[str, str] = {
     # Core workflows
-    "code-review": CodeReviewWorkflow,
-    "doc-gen": DocumentGenerationWorkflow,
+    "code-review": "CodeReviewWorkflow",
+    "doc-gen": "DocumentGenerationWorkflow",
     # Analysis workflows
-    "bug-predict": BugPredictionWorkflow,
-    "security-audit": SecurityAuditWorkflow,
-    "perf-audit": PerformanceAuditWorkflow,
+    "bug-predict": "BugPredictionWorkflow",
+    "security-audit": "SecurityAuditWorkflow",
+    "perf-audit": "PerformanceAuditWorkflow",
     # Generation workflows
-    "test-gen": TestGenerationWorkflow,  # Enabled by default for test coverage
-    "refactor-plan": RefactorPlanWorkflow,
+    "test-gen": "TestGenerationWorkflow",
+    "refactor-plan": "RefactorPlanWorkflow",
     # Operational workflows
-    "dependency-check": DependencyCheckWorkflow,
-    "release-prep-legacy": ReleasePreparationWorkflow,  # Old single-agent version
+    "dependency-check": "DependencyCheckWorkflow",
+    "release-prep-legacy": "ReleasePreparationWorkflow",
     # Composite security pipeline (v3.0)
-    "secure-release": SecureReleasePipeline,
+    "secure-release": "SecureReleasePipeline",
     # Code review crew integration (v3.1)
-    "pro-review": CodeReviewPipeline,
-    "pr-review": PRReviewWorkflow,
+    "pro-review": "CodeReviewPipeline",
+    "pr-review": "PRReviewWorkflow",
     # Documentation management (v3.5)
-    "doc-orchestrator": DocumentationOrchestrator,
-    "manage-docs": ManageDocumentationCrew,
-    # Keyboard Conductor (v3.6) - keyboard shortcut generation
-    "keyboard-shortcuts": KeyboardShortcutWorkflow,
+    "doc-orchestrator": "DocumentationOrchestrator",
+    "manage-docs": "DocumentationOrchestrator",  # Points to orchestrator (crew deprecated)
+    # Keyboard Conductor (v3.6)
+    "keyboard-shortcuts": "KeyboardShortcutWorkflow",
     # User-generated workflows
-    "document-manager": DocumentManagerWorkflow,
-    "test5": Test5Workflow,
-    # CrewAI-based multi-agent workflows (v3.x - deprecated, use orchestrated-* versions)
-    # Removed: "health-check" (use orchestrated-health-check instead)
-    "release-prep": ReleasePreparationCrew,  # DEPRECATED: Use orchestrated-release-prep instead
-    "test-coverage-boost": TestCoverageBoostCrew,  # DISABLED: Poor quality (0% pass rate), needs redesign
-    # Backward compatibility aliases
-    "orchestrated-test-coverage": TestCoverageBoostCrew,  # DISABLED: Coverage boost needs redesign
-    # Meta-orchestration workflows (v4.0.0 - CANONICAL with real analysis tools)
-    "orchestrated-health-check": OrchestratedHealthCheckWorkflow,  # ✅ v4.0.0 CANONICAL: Real security/coverage/quality analysis
-    "orchestrated-release-prep": OrchestratedReleasePrepWorkflow,  # ✅ v4.0.0 CANONICAL: Real quality gate validation
-    # Experimental aliases (backward compat)
-    "orchestrated-health-check-experimental": OrchestratedHealthCheckWorkflow,  # ALIAS
-    "orchestrated-release-prep-experimental": OrchestratedReleasePrepWorkflow,  # ALIAS
+    "document-manager": "DocumentManagerWorkflow",
+    "test5": "Test5Workflow",
+    # Meta-orchestration workflows (v4.0.0 - CANONICAL)
+    "orchestrated-health-check": "OrchestratedHealthCheckWorkflow",
+    "orchestrated-release-prep": "OrchestratedReleasePrepWorkflow",
+    # Backward compatibility aliases (point to orchestrated versions)
+    "release-prep": "OrchestratedReleasePrepWorkflow",
+    "orchestrated-health-check-experimental": "OrchestratedHealthCheckWorkflow",
+    "orchestrated-release-prep-experimental": "OrchestratedReleasePrepWorkflow",
 }
 
-# Opt-in workflows - not included by default, must be explicitly enabled
-# Currently empty - all workflows are enabled by default
-# Use disabled_workflows in config to turn off specific workflows
-_OPT_IN_WORKFLOWS: dict[str, type] = {}
+# Opt-in workflows - class names for lazy loading
+_OPT_IN_WORKFLOW_NAMES: dict[str, str] = {}
 
-# Workflow registry populated at module load
+# Workflow registry - populated lazily on first access
 WORKFLOW_REGISTRY: dict[str, type[BaseWorkflow]] = {}
+_registry_initialized = False
+
+
+def _get_workflow_class(class_name: str) -> type[BaseWorkflow]:
+    """Get a workflow class by name (lazy loading)."""
+    return _lazy_import_workflow(class_name)
+
+
+def _ensure_registry_initialized() -> None:
+    """Initialize workflow registry on first access."""
+    global _registry_initialized
+    if not _registry_initialized:
+        WORKFLOW_REGISTRY.update(discover_workflows())
+        _registry_initialized = True
 
 
 def discover_workflows(
@@ -176,12 +250,8 @@ def discover_workflows(
     'empathy.workflows' group. This allows third-party packages to register
     custom workflows that integrate with the Empathy Framework.
 
-    Workflow availability is controlled by:
-    1. Default workflows (always included unless disabled)
-    2. Opt-in workflows (test-gen) - must be explicitly enabled OR compliance_mode=hipaa
-    3. enabled_workflows config - explicitly enable specific workflows
-    4. disabled_workflows config - explicitly disable specific workflows
-    5. Entry point discovery - third-party workflows
+    Note: Workflows are loaded lazily - classes are only imported when
+    the workflow is actually used, reducing initial import time.
 
     Args:
         include_defaults: Whether to include default built-in workflows
@@ -191,36 +261,41 @@ def discover_workflows(
         Dictionary mapping workflow names to workflow classes
 
     Example:
-        # In your pyproject.toml:
-        [project.entry-points."empathy.workflows"]
-        my-workflow = "my_package.workflows:MyCustomWorkflow"
-
-        # In your code:
         from empathy_os.workflows import discover_workflows
         workflows = discover_workflows()
-        MyWorkflow = workflows.get("my-workflow")
-
-        # With HIPAA mode (enables test-gen):
-        config = WorkflowConfig.load()  # compliance_mode: hipaa
-        workflows = discover_workflows(config=config)
+        MyWorkflow = workflows.get("code-review")
 
     """
     discovered: dict[str, type[BaseWorkflow]] = {}
 
-    # Include default workflows if requested
+    # Include default workflows if requested (lazy load each)
     if include_defaults:
-        discovered.update(_DEFAULT_WORKFLOWS)
+        for workflow_id, class_name in _DEFAULT_WORKFLOW_NAMES.items():
+            try:
+                discovered[workflow_id] = _get_workflow_class(class_name)
+            except (ImportError, AttributeError):
+                # Skip workflows that fail to load
+                pass
 
     # Add opt-in workflows based on config
     if config is not None:
         # HIPAA mode auto-enables healthcare workflows
         if config.is_hipaa_mode():
-            discovered.update(_OPT_IN_WORKFLOWS)
+            for workflow_id, class_name in _OPT_IN_WORKFLOW_NAMES.items():
+                try:
+                    discovered[workflow_id] = _get_workflow_class(class_name)
+                except (ImportError, AttributeError):
+                    pass
 
         # Explicitly enabled workflows
         for workflow_name in config.enabled_workflows:
-            if workflow_name in _OPT_IN_WORKFLOWS:
-                discovered[workflow_name] = _OPT_IN_WORKFLOWS[workflow_name]
+            if workflow_name in _OPT_IN_WORKFLOW_NAMES:
+                try:
+                    discovered[workflow_name] = _get_workflow_class(
+                        _OPT_IN_WORKFLOW_NAMES[workflow_name]
+                    )
+                except (ImportError, AttributeError):
+                    pass
 
         # Explicitly disabled workflows
         for workflow_name in config.disabled_workflows:
@@ -232,16 +307,12 @@ def discover_workflows(
         for ep in eps:
             try:
                 workflow_cls = ep.load()
-                # Validate it's a proper workflow class
                 if isinstance(workflow_cls, type) and hasattr(workflow_cls, "execute"):
-                    # Check if disabled in config
                     if config is None or ep.name not in config.disabled_workflows:
                         discovered[ep.name] = workflow_cls
             except Exception:
-                # Skip invalid entry points silently
                 pass
     except Exception:
-        # If entry point discovery fails, just use defaults
         pass
 
     return discovered
@@ -269,11 +340,17 @@ def get_opt_in_workflows() -> dict[str, type]:
         Dictionary of workflow name to class for opt-in workflows
 
     """
-    return dict(_OPT_IN_WORKFLOWS)
+    result = {}
+    for name, class_name in _OPT_IN_WORKFLOW_NAMES.items():
+        try:
+            result[name] = _get_workflow_class(class_name)
+        except (ImportError, AttributeError):
+            pass
+    return result
 
 
-# Initialize registry on module load
-WORKFLOW_REGISTRY.update(discover_workflows())
+# Note: Registry is initialized lazily on first access via _ensure_registry_initialized()
+# Do NOT call discover_workflows() here - it defeats lazy loading
 
 
 def get_workflow(name: str) -> type[BaseWorkflow]:
@@ -289,6 +366,7 @@ def get_workflow(name: str) -> type[BaseWorkflow]:
         KeyError: If workflow not found
 
     """
+    _ensure_registry_initialized()
     if name not in WORKFLOW_REGISTRY:
         available = ", ".join(WORKFLOW_REGISTRY.keys())
         raise KeyError(f"Unknown workflow: {name}. Available: {available}")
@@ -302,6 +380,7 @@ def list_workflows() -> list[dict]:
         List of workflow info dicts
 
     """
+    _ensure_registry_initialized()
     workflows = []
     for name, cls in WORKFLOW_REGISTRY.items():
         # Handle both BaseWorkflow subclasses and composite pipelines
@@ -321,6 +400,19 @@ def list_workflows() -> list[dict]:
     return workflows
 
 
+def __getattr__(name: str) -> object:
+    """Lazy import handler for workflow classes."""
+    if name in _LAZY_WORKFLOW_IMPORTS:
+        return _lazy_import_workflow(name)
+
+    # Handle CLI commands
+    if name in ("cmd_morning", "cmd_ship", "cmd_fix_all", "cmd_learn"):
+        _load_cli_commands()
+        return globals().get(name)
+
+    raise AttributeError(f"module 'empathy_os.workflows' has no attribute '{name}'")
+
+
 __all__ = [
     "DEFAULT_MODELS",
     "PROVIDER_MODELS",

empathy_os/workflows/batch_processing.py

@@ -129,10 +129,7 @@ class BatchProcessingWorkflow:
         logger.info(f"Submitting batch of {len(requests)} requests")
         batch_id = self.batch_provider.create_batch(api_requests)
 
-        logger.info(
-            f"Batch {batch_id} created, polling every {poll_interval}s "
-            f"(max {timeout}s)"
-        )
+        logger.info(f"Batch {batch_id} created, polling every {poll_interval}s (max {timeout}s)")
 
         # Wait for completion
         try:
@@ -152,9 +149,7 @@ class BatchProcessingWorkflow:
         except RuntimeError as e:
             logger.error(f"Batch {batch_id} failed: {e}")
             return [
-                BatchResult(
-                    task_id=req.task_id, success=False, error=f"Batch failed: {e}"
-                )
+                BatchResult(task_id=req.task_id, success=False, error=f"Batch failed: {e}")
                 for req in requests
             ]
 
@@ -165,21 +160,15 @@ class BatchProcessingWorkflow:
 
             if "error" in raw:
                 error_msg = raw["error"].get("message", "Unknown error")
-                results.append(
-                    BatchResult(task_id=task_id, success=False, error=error_msg)
-                )
+                results.append(BatchResult(task_id=task_id, success=False, error=error_msg))
             else:
                 results.append(
-                    BatchResult(
-                        task_id=task_id, success=True, output=raw.get("response")
-                    )
+                    BatchResult(task_id=task_id, success=True, output=raw.get("response"))
                 )
 
         # Log summary
         success_count = sum(r.success for r in results)
-        logger.info(
-            f"Batch {batch_id} completed: {success_count}/{len(results)} successful"
-        )
+        logger.info(f"Batch {batch_id} completed: {success_count}/{len(results)} successful")
 
         return results
 
@@ -203,17 +192,14 @@ class BatchProcessingWorkflow:
         }
 
         # Get prompt template or use default
-        prompt_template = task_prompts.get(
-            request.task_type, "Process the following:\n\n{input}"
-        )
+        prompt_template = task_prompts.get(request.task_type, "Process the following:\n\n{input}")
 
         # Format with input data
         try:
             content = prompt_template.format(**request.input_data)
         except KeyError as e:
             logger.warning(
-                f"Missing required field {e} for task {request.task_type}, "
-                f"using raw input"
+                f"Missing required field {e} for task {request.task_type}, using raw input"
             )
             content = prompt_template.format(input=json.dumps(request.input_data))
 
@@ -282,9 +268,7 @@ class BatchProcessingWorkflow:
 
         return requests
 
-    def save_results_to_file(
-        self, results: list[BatchResult], output_path: str
-    ) -> None:
+    def save_results_to_file(self, results: list[BatchResult], output_path: str) -> None:
         """Save batch results to JSON file.
 
         Args:

empathy_os/workflows/bug_predict.py

@@ -372,7 +372,7 @@ def _remove_docstrings(content: str) -> str:
     """
     # Remove triple-quoted strings (docstrings)
     # Match """ ... """ and ''' ... ''' including multiline
-    content = re.sub(r'"""[\s\S]*?"""', '# [docstring removed]', content)
+    content = re.sub(r'"""[\s\S]*?"""', "# [docstring removed]", content)
     content = re.sub(r"'''[\s\S]*?'''", "# [docstring removed]", content)
     return content
 

empathy_os/workflows/code_review.py

@@ -359,11 +359,26 @@ Code:
         """
         await self._initialize_crew()
 
-        from .code_review_adapters import (
-            _check_crew_available,
-            _get_crew_review,
-            crew_report_to_workflow_format,
-        )
+        try:
+            from .code_review_adapters import (
+                _check_crew_available,
+                _get_crew_review,
+                crew_report_to_workflow_format,
+            )
+        except ImportError:
+            # Crew adapters removed - return fallback
+            return (
+                {
+                    "crew_review": {
+                        "available": False,
+                        "fallback": True,
+                        "reason": "Crew adapters not installed",
+                    },
+                    **input_data,
+                },
+                0,
+                0,
+            )
 
         # Get code to review
         diff = input_data.get("diff", "") or input_data.get("code_to_review", "")

empathy_os/workflows/code_review_pipeline.py

@@ -276,18 +276,23 @@ class CodeReviewPipeline:
     ) -> tuple[dict | None, Any]:  # Second element is WorkflowResult or None
         """Run full mode with crew and workflow."""
         from .code_review import CodeReviewWorkflow
-        from .code_review_adapters import (
-            _check_crew_available,
-            _get_crew_review,
-            crew_report_to_workflow_format,
-        )
+
+        try:
+            from .code_review_adapters import (
+                _check_crew_available,
+                _get_crew_review,
+                crew_report_to_workflow_format,
+            )
+            crew_available = _check_crew_available()
+        except ImportError:
+            # Crew adapters removed - fall back to workflow only
+            crew_available = False
+            _get_crew_review = None
+            crew_report_to_workflow_format = None
 
         crew_report: dict | None = None
         workflow_result: Any = None  # WorkflowResult or None
 
-        # Check if crew is available
-        crew_available = _check_crew_available()
-
         if crew_available and self.parallel_crew:
             # Run crew and workflow in parallel
             crew_task = asyncio.create_task(

empathy_os/workflows/keyboard_shortcuts/workflow.py

@@ -358,7 +358,9 @@ class KeyboardShortcutWorkflow(BaseWorkflow):
             if isinstance(result, dict):
                 return result
             return None
-        except Exception:
+        except Exception:  # noqa: BLE001
+            # INTENTIONAL: LLM responses may have unparseable YAML.
+            # Return None and let caller handle fallback gracefully.
             return None
 
     def _parse_json_response(self, response: str) -> dict[str, Any] | None:
@@ -376,7 +378,9 @@ class KeyboardShortcutWorkflow(BaseWorkflow):
             if isinstance(result, dict):
                 return result
             return None
-        except Exception:
+        except Exception:  # noqa: BLE001
+            # INTENTIONAL: LLM responses may have unparseable JSON.
+            # Return None and let caller handle fallback gracefully.
             return None
 
     def _update_manifest_from_analysis(

empathy_os/workflows/manage_documentation.py

@@ -19,6 +19,7 @@ See: docs/guides/WORKFLOW_PATTERNS.md
 Copyright 2025 Smart-AI-Memory
 Licensed under Fair Source License 0.9
 """
+
 import asyncio
 import os
 import warnings