empathy-framework 3.2.3__py3-none-any.whl → 3.8.2__py3-none-any.whl

empathy_os/{workflows.py → workflow_commands.py}

@@ -1,5 +1,4 @@
-"""
-One-Command Workflows for Empathy Framework
+"""One-Command Workflows for Empathy Framework
 
 Power-user commands that automate common developer workflows:
 - morning: Start-of-day briefing with patterns, debt, and focus areas
@@ -30,7 +29,7 @@ def _load_patterns(patterns_dir: str = "./patterns") -> dict[str, list]:
     if not patterns_path.exists():
         return patterns
 
-    for pattern_type in patterns.keys():
+    for pattern_type in patterns:
         file_path = patterns_path / f"{pattern_type}.json"
         if file_path.exists():
             try:
@@ -68,7 +67,7 @@ def _save_stats(stats: dict, empathy_dir: str = ".empathy") -> None:
 def _run_command(cmd: list, capture: bool = True) -> tuple:
     """Run a shell command and return (success, output)."""
     try:
-        result = subprocess.run(cmd, capture_output=capture, text=True, timeout=300)
+        result = subprocess.run(cmd, check=False, capture_output=capture, text=True, timeout=300)
         return result.returncode == 0, result.stdout + result.stderr
     except subprocess.TimeoutExpired:
         return False, "Command timed out"
@@ -97,19 +96,19 @@ def _get_tech_debt_trend(patterns_dir: str = "./patterns") -> str:
 
         if recent > previous:
             return "increasing"
-        elif recent < previous:
+        if recent < previous:
             return "decreasing"
-        else:
-            return "stable"
+        return "stable"
     except (OSError, json.JSONDecodeError, KeyError):
         return "unknown"
 
 
 def morning_workflow(
-    patterns_dir: str = "./patterns", project_root: str = ".", verbose: bool = False
+    patterns_dir: str = "./patterns",
+    project_root: str = ".",
+    verbose: bool = False,
 ) -> int:
-    """
-    Start-of-day developer briefing.
+    """Start-of-day developer briefing.
 
     Shows:
     - Health check summary
@@ -231,7 +230,7 @@ def morning_workflow(
     ]
     if investigating_bugs:
         suggestions.append(
-            f"Resolve {len(investigating_bugs)} investigating bug(s) via 'empathy patterns resolve'"
+            f"Resolve {len(investigating_bugs)} investigating bug(s) via 'empathy patterns resolve'",
         )
 
     if trend == "increasing":
@@ -258,14 +257,93 @@ def morning_workflow(
     return 0
 
 
+def _run_tests_only(project_root: str = ".", verbose: bool = False) -> int:
+    """Run tests only (used by ship --tests-only)."""
+    print("\n" + "=" * 60)
+    print("  TEST RESULTS")
+    print("=" * 60 + "\n")
+
+    # Try pytest first
+    success, output = _run_command(["python", "-m", "pytest", project_root, "-v", "--tb=short"])
+
+    if success:
+        print("All tests passed!")
+        print("\n" + "=" * 60 + "\n")
+        return 0
+    print("Test Results:")
+    print("-" * 40)
+    print(output)
+    print("\n" + "=" * 60 + "\n")
+    return 1
+
+
+def _run_security_only(project_root: str = ".", verbose: bool = False) -> int:
+    """Run security checks only (used by ship --security-only)."""
+    print("\n" + "=" * 60)
+    print("  SECURITY SCAN")
+    print("=" * 60 + "\n")
+
+    issues = []
+
+    # Try bandit (Python security scanner)
+    print("1. Running Bandit security scan...")
+    success, output = _run_command(["bandit", "-r", project_root, "-ll", "-q"])
+    if success:
+        print("   PASS - No high/medium security issues")
+    elif "bandit" in output.lower() and "not found" in output.lower():
+        print("   SKIP - Bandit not installed (pip install bandit)")
+    else:
+        issue_count = output.count(">> Issue:")
+        issues.append(f"Bandit: {issue_count} security issues")
+        print(f"   WARN - {issue_count} issues found")
+        if verbose:
+            print(output)
+
+    # Check for secrets in code
+    print("2. Checking for hardcoded secrets...")
+    success, output = _run_command(
+        ["grep", "-rn", "--include=*.py", "password.*=.*['\"]", project_root],
+    )
+    if not success or not output.strip():
+        print("   PASS - No obvious hardcoded secrets")
+    else:
+        lines = len([line for line in output.split("\n") if line.strip()])
+        issues.append(f"Secrets: {lines} potential hardcoded secrets")
+        print(f"   WARN - {lines} potential hardcoded values found")
+
+    # Check for .env files that might be committed
+    print("3. Checking for sensitive files...")
+    success, output = _run_command(["git", "ls-files", ".env", "*.pem", "*.key"])
+    if not output.strip():
+        print("   PASS - No sensitive files tracked")
+    else:
+        files = len([line for line in output.split("\n") if line.strip()])
+        issues.append(f"Files: {files} sensitive files in git")
+        print(f"   WARN - {files} sensitive files tracked in git")
+
+    # Summary
+    print("\n" + "-" * 60)
+    if issues:
+        print("\nSECURITY ISSUES FOUND:")
+        for issue in issues:
+            print(f"  - {issue}")
+        print("\n" + "=" * 60 + "\n")
+        return 1
+
+    print("\nNo security issues found!")
+    print("\n" + "=" * 60 + "\n")
+    return 0
+
+
 def ship_workflow(
     patterns_dir: str = "./patterns",
     project_root: str = ".",
     skip_sync: bool = False,
+    tests_only: bool = False,
+    security_only: bool = False,
     verbose: bool = False,
 ) -> int:
-    """
-    Pre-commit validation pipeline.
+    """Pre-commit validation pipeline.
 
     Runs:
     1. empathy inspect (code analysis)
@@ -273,8 +351,23 @@ def ship_workflow(
     3. empathy sync-claude (pattern sync)
     4. Summary
 
+    Args:
+        patterns_dir: Path to patterns directory
+        project_root: Project root directory
+        skip_sync: Skip syncing patterns to Claude
+        tests_only: Run tests only (skip lint/format checks)
+        security_only: Run security checks only
+        verbose: Show detailed output
+
     Returns exit code (0 = ready to ship, non-zero = issues found).
+
     """
+    if tests_only:
+        return _run_tests_only(project_root, verbose)
+
+    if security_only:
+        return _run_security_only(project_root, verbose)
+
     print("\n" + "=" * 60)
     print("  PRE-SHIP CHECKLIST")
     print("=" * 60 + "\n")
@@ -289,7 +382,7 @@ def ship_workflow(
         print("   PASS - No lint issues")
     else:
         issue_count = len(
-            [line for line in output.split("\n") if line.strip() and not line.startswith("Found")]
+            [line for line in output.split("\n") if line.strip() and not line.startswith("Found")],
         )
         issues.append(f"Lint: {issue_count} issues")
         print(f"   FAIL - {issue_count} issues found")
@@ -307,7 +400,7 @@ def ship_workflow(
                 line
                 for line in output.split("\n")
                 if "would be reformatted" in line.lower() or line.strip().endswith(".py")
-            ]
+            ],
         )
         warnings.append(f"Format: {files} files need formatting")
         print(f"   WARN - {files} files need formatting (run 'empathy fix-all')")
@@ -330,7 +423,7 @@ def ship_workflow(
     success, output = _run_command(["git", "status", "--porcelain"])
     if success:
         staged = len(
-            [line for line in output.split("\n") if line.startswith(("A ", "M ", "D ", "R "))]
+            [line for line in output.split("\n") if line.startswith(("A ", "M ", "D ", "R "))],
         )
         unstaged = len([line for line in output.split("\n") if line.startswith((" M", " D", "??"))])
         if staged > 0:
@@ -346,15 +439,14 @@ def ship_workflow(
         print("5. Syncing patterns to Claude Code...")
         # Import here to avoid circular imports
         try:
-            from empathy_llm_toolkit.cli.sync_claude import (
-                sync_patterns_to_claude,  # type: ignore[attr-defined]
-            )
-
-            result = sync_patterns_to_claude(
-                patterns_dir=patterns_dir, output_dir=".claude/rules/empathy"
-            )
-            if result.get("success"):
-                print(f"   PASS - {result.get('patterns_synced', 0)} patterns synced")
+            from pathlib import Path
+
+            from empathy_llm_toolkit.cli.sync_claude import sync_patterns
+
+            result = sync_patterns(project_root=Path(), verbose=False)
+            synced_count = len(result.get("synced", []))
+            if synced_count > 0:
+                print(f"   PASS - {synced_count} patterns synced")
             else:
                 print("   SKIP - No patterns to sync")
         except ImportError:
@@ -395,8 +487,7 @@ def ship_workflow(
 
 
 def fix_all_workflow(project_root: str = ".", dry_run: bool = False, verbose: bool = False) -> int:
-    """
-    Auto-fix all fixable issues.
+    """Auto-fix all fixable issues.
 
     Runs:
     1. ruff --fix (lint fixes)
@@ -444,7 +535,7 @@ def fix_all_workflow(project_root: str = ".", dry_run: bool = False, verbose: bo
                 line
                 for line in output.split("\n")
                 if line.strip().endswith(".py") and "reformatted" in output.lower()
-            ]
+            ],
         )
 
     print(f"   Formatted {formatted} files")
@@ -488,8 +579,7 @@ def learn_workflow(
     watch: bool = False,
     verbose: bool = False,
 ) -> int:
-    """
-    Watch for bug fixes and extract patterns.
+    """Watch for bug fixes and extract patterns.
 
     Modes:
     - analyze: Analyze recent commits for bug fix patterns
@@ -516,7 +606,7 @@ def learn_workflow(
 
     # Get recent commits
     success, output = _run_command(
-        ["git", "log", f"-{commit_count}", "--oneline", "--format=%H|%s|%an|%ai"]
+        ["git", "log", f"-{commit_count}", "--oneline", "--format=%H|%s|%an|%ai"],
     )
 
     if not success:
@@ -660,6 +750,8 @@ def cmd_ship(args):
         patterns_dir=getattr(args, "patterns_dir", "./patterns"),
         project_root=getattr(args, "project_root", "."),
         skip_sync=getattr(args, "skip_sync", False),
+        tests_only=getattr(args, "tests_only", False),
+        security_only=getattr(args, "security_only", False),
         verbose=getattr(args, "verbose", False),
     )
 

empathy_os/workflows/__init__.py

@@ -0,0 +1,360 @@
+"""Multi-Model Workflow Templates for Empathy Framework
+
+Cost-optimized workflow patterns that leverage 3-tier model routing:
+- Haiku (cheap): Summarization, classification, triage
+- Sonnet (capable): Analysis, code generation, security review
+- Opus (premium): Synthesis, architectural decisions, coordination
+
+Usage:
+    from empathy_os.workflows import ResearchSynthesisWorkflow
+
+    workflow = ResearchSynthesisWorkflow()
+    result = await workflow.execute(
+        sources=["doc1.md", "doc2.md"],
+        question="What are the key patterns?"
+    )
+
+    print(f"Cost: ${result.cost_report.total_cost:.4f}")
+    print(f"Saved: {result.cost_report.savings_percent:.1f}% vs premium-only")
+
+Workflow Discovery:
+    Workflows can be discovered via entry points (pyproject.toml):
+
+    [project.entry-points."empathy.workflows"]
+    my-workflow = "my_package.workflows:MyWorkflow"
+
+    Then call discover_workflows() to load all registered workflows.
+
+Copyright 2025 Smart-AI-Memory
+Licensed under Fair Source License 0.9
+"""
+
+import importlib.metadata
+import importlib.util
+import os
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .base import BaseWorkflow
+
+from .base import (
+    PROVIDER_MODELS,
+    BaseWorkflow,
+    CostReport,
+    ModelProvider,
+    ModelTier,
+    WorkflowResult,
+    WorkflowStage,
+    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
+from .config import DEFAULT_MODELS, ModelConfig, WorkflowConfig, create_example_config, get_model
+from .dependency_check import DependencyCheckWorkflow
+from .document_gen import DocumentGenerationWorkflow
+from .documentation_orchestrator import DocumentationOrchestrator, OrchestratorResult
+from .health_check import HealthCheckWorkflow
+
+# Keyboard Conductor (v3.6) - keyboard shortcut generation
+from .keyboard_shortcuts import KeyboardShortcutWorkflow
+from .manage_documentation import ManageDocumentationCrew, ManageDocumentationCrewResult
+from .perf_audit import PerformanceAuditWorkflow
+from .pr_review import PRReviewResult, PRReviewWorkflow
+from .refactor_plan import RefactorPlanWorkflow
+from .release_prep import ReleasePreparationWorkflow
+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
+
+# User-generated workflows
+from .test5 import Test5Workflow
+from .test_gen import TestGenerationWorkflow
+
+# Re-export CLI commands from workflow_commands.py
+_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
+cmd_morning = None
+cmd_ship = None
+cmd_fix_all = None
+cmd_learn = None
+
+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] = {
+    # Core workflows
+    "code-review": CodeReviewWorkflow,
+    "doc-gen": DocumentGenerationWorkflow,
+    # Analysis workflows
+    "bug-predict": BugPredictionWorkflow,
+    "security-audit": SecurityAuditWorkflow,
+    "perf-audit": PerformanceAuditWorkflow,
+    # Generation workflows
+    "test-gen": TestGenerationWorkflow,  # Enabled by default for test coverage
+    "refactor-plan": RefactorPlanWorkflow,
+    # Operational workflows
+    "dependency-check": DependencyCheckWorkflow,
+    "release-prep": ReleasePreparationWorkflow,
+    # Composite security pipeline (v3.0)
+    "secure-release": SecureReleasePipeline,
+    # Code review crew integration (v3.1)
+    "pro-review": CodeReviewPipeline,
+    "pr-review": PRReviewWorkflow,
+    # Health check crew integration (v3.1)
+    "health-check": HealthCheckWorkflow,
+    # Documentation management (v3.5)
+    "doc-orchestrator": DocumentationOrchestrator,
+    "manage-docs": ManageDocumentationCrew,
+    # Keyboard Conductor (v3.6) - keyboard shortcut generation
+    "keyboard-shortcuts": KeyboardShortcutWorkflow,
+    # User-generated workflows
+    "test5": Test5Workflow,
+}
+
+# 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] = {}
+
+# Workflow registry populated at module load
+WORKFLOW_REGISTRY: dict[str, type[BaseWorkflow]] = {}
+
+
+def discover_workflows(
+    include_defaults: bool = True,
+    config: "WorkflowConfig | None" = None,
+) -> dict[str, type[BaseWorkflow]]:
+    """Discover workflows via entry points and config.
+
+    This function loads workflows registered as entry points under the
+    '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
+
+    Args:
+        include_defaults: Whether to include default built-in workflows
+        config: Optional WorkflowConfig for enabled/disabled workflows
+
+    Returns:
+        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)
+
+    """
+    discovered: dict[str, type[BaseWorkflow]] = {}
+
+    # Include default workflows if requested
+    if include_defaults:
+        discovered.update(_DEFAULT_WORKFLOWS)
+
+    # 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)
+
+        # 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]
+
+        # Explicitly disabled workflows
+        for workflow_name in config.disabled_workflows:
+            discovered.pop(workflow_name, None)
+
+    # Discover via entry points
+    try:
+        eps = importlib.metadata.entry_points(group="empathy.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
+
+
+def refresh_workflow_registry(config: "WorkflowConfig | None" = None) -> None:
+    """Refresh the global WORKFLOW_REGISTRY by re-discovering all workflows.
+
+    Call this after installing new packages that register workflows,
+    or after changing the WorkflowConfig (e.g., enabling HIPAA mode).
+
+    Args:
+        config: Optional WorkflowConfig for enabled/disabled workflows
+
+    """
+    global WORKFLOW_REGISTRY
+    WORKFLOW_REGISTRY.clear()
+    WORKFLOW_REGISTRY.update(discover_workflows(config=config))
+
+
+def get_opt_in_workflows() -> dict[str, type]:
+    """Get the list of opt-in workflows that require explicit enabling.
+
+    Returns:
+        Dictionary of workflow name to class for opt-in workflows
+
+    """
+    return dict(_OPT_IN_WORKFLOWS)
+
+
+# Initialize registry on module load
+WORKFLOW_REGISTRY.update(discover_workflows())
+
+
+def get_workflow(name: str) -> type[BaseWorkflow]:
+    """Get a workflow class by name.
+
+    Args:
+        name: Workflow name (e.g., "research", "code-review", "doc-gen")
+
+    Returns:
+        Workflow class
+
+    Raises:
+        KeyError: If workflow not found
+
+    """
+    if name not in WORKFLOW_REGISTRY:
+        available = ", ".join(WORKFLOW_REGISTRY.keys())
+        raise KeyError(f"Unknown workflow: {name}. Available: {available}")
+    return WORKFLOW_REGISTRY[name]
+
+
+def list_workflows() -> list[dict]:
+    """List all available workflows with descriptions.
+
+    Returns:
+        List of workflow info dicts
+
+    """
+    workflows = []
+    for name, cls in WORKFLOW_REGISTRY.items():
+        # Handle both BaseWorkflow subclasses and composite pipelines
+        stages = getattr(cls, "stages", [])
+        tier_map = getattr(cls, "tier_map", {})
+        description = getattr(cls, "description", "No description")
+
+        workflows.append(
+            {
+                "name": name,
+                "class": cls.__name__,
+                "description": description,
+                "stages": stages,
+                "tier_map": {k: v.value for k, v in tier_map.items()} if tier_map else {},
+            },
+        )
+    return workflows
+
+
+__all__ = [
+    "DEFAULT_MODELS",
+    "PROVIDER_MODELS",
+    # Registry and discovery
+    "WORKFLOW_REGISTRY",
+    # Base classes
+    "BaseWorkflow",
+    # New high-value workflows
+    "BugPredictionWorkflow",
+    # Code review crew integration (v3.1)
+    "CodeReviewPipeline",
+    "CodeReviewPipelineResult",
+    "CodeReviewWorkflow",
+    "CostReport",
+    "DependencyCheckWorkflow",
+    "DocumentGenerationWorkflow",
+    # Documentation management (v3.5)
+    "DocumentationOrchestrator",
+    # Health check crew integration (v3.1)
+    "HealthCheckWorkflow",
+    # Keyboard Conductor (v3.6)
+    "KeyboardShortcutWorkflow",
+    "ManageDocumentationCrew",
+    "ManageDocumentationCrewResult",
+    "ModelConfig",
+    "ModelProvider",
+    "ModelTier",
+    "OrchestratorResult",
+    "PRReviewResult",
+    "PRReviewWorkflow",
+    "PerformanceAuditWorkflow",
+    "RefactorPlanWorkflow",
+    "ReleasePreparationWorkflow",
+    # Workflow implementations
+    "ResearchSynthesisWorkflow",
+    # Security crew integration (v3.0)
+    "SecureReleasePipeline",
+    "SecureReleaseResult",
+    "SecurityAuditWorkflow",
+    "TestGenerationWorkflow",
+    # Configuration
+    "WorkflowConfig",
+    "WorkflowResult",
+    "WorkflowStage",
+    # Step configuration (new)
+    "WorkflowStepConfig",
+    "cmd_fix_all",
+    "cmd_learn",
+    # CLI commands (re-exported from workflow_commands.py)
+    "cmd_morning",
+    "cmd_ship",
+    "create_example_config",
+    "discover_workflows",
+    "get_model",
+    "get_workflow",
+    # Stats for dashboard
+    "get_workflow_stats",
+    "list_workflows",
+    "refresh_workflow_registry",
+    "steps_from_tier_map",
+    "validate_step_config",
+]