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

empathy_os/test_generator/generator.py

@@ -1,6 +1,6 @@
 """Test generator core implementation.
 
-Generates comprehensive tests for wizards using Jinja2 templates
+Generates comprehensive tests for workflows using Jinja2 templates
 and risk-based prioritization.
 
 Copyright 2025 Smart AI Memory, LLC
@@ -46,7 +46,7 @@ def _get_default_template_dir() -> Path:
 
         # Last resort: Try to find from sys.modules
         this_module = sys.modules.get(__name__)
-        if this_module and hasattr(this_module, "__file__"):
+        if this_module and hasattr(this_module, "__file__") and this_module.__file__:
             return Path(this_module.__file__).parent / "templates"
 
         # Final fallback: Use current working directory
@@ -54,7 +54,7 @@ def _get_default_template_dir() -> Path:
 
 
 class TestGenerator:
-    """Generates tests for wizards based on patterns and risk analysis.
+    """Generates tests for workflows based on patterns and risk analysis.
 
     Uses Jinja2 templates to generate:
     - Unit tests with risk-prioritized coverage
@@ -87,18 +87,18 @@ class TestGenerator:
 
     def generate_tests(
         self,
-        wizard_id: str,
+        workflow_id: str,
         pattern_ids: list[str],
-        wizard_module: str | None = None,
-        wizard_class: str | None = None,
+        workflow_module: str | None = None,
+        workflow_class: str | None = None,
     ) -> dict[str, str | None]:
-        """Generate tests for a wizard.
+        """Generate tests for a workflow.
 
         Args:
-            wizard_id: Wizard identifier
-            pattern_ids: List of pattern IDs used by wizard
-            wizard_module: Python module path (e.g., "wizards.soap_note")
-            wizard_class: Wizard class name (e.g., "SOAPNoteWizard")
+            workflow_id: Workflow identifier
+            pattern_ids: List of pattern IDs used by workflow
+            workflow_module: Python module path (e.g., "workflows.soap_note")
+            workflow_class: Workflow class name (e.g., "SOAPNoteWorkflow")
 
         Returns:
             Dictionary with test types:
@@ -109,31 +109,31 @@ class TestGenerator:
                 }
 
         """
-        logger.info(f"Generating tests for wizard: {wizard_id}")
+        logger.info(f"Generating tests for workflow: {workflow_id}")
 
         # Perform risk analysis
-        risk_analysis = self.risk_analyzer.analyze(wizard_id, pattern_ids)
+        risk_analysis = self.risk_analyzer.analyze(workflow_id, pattern_ids)
 
         # Infer module and class if not provided
-        if not wizard_module:
-            wizard_module = self._infer_module(wizard_id)
+        if not workflow_module:
+            workflow_module = self._infer_module(workflow_id)
 
-        if not wizard_class:
-            wizard_class = self._infer_class_name(wizard_id)
+        if not workflow_class:
+            workflow_class = self._infer_class_name(workflow_id)
 
         # Gather template context
         context = self._build_template_context(
-            wizard_id=wizard_id,
+            workflow_id=workflow_id,
             pattern_ids=pattern_ids,
-            wizard_module=wizard_module,
-            wizard_class=wizard_class,
+            workflow_module=workflow_module,
+            workflow_class=workflow_class,
             risk_analysis=risk_analysis,
         )
 
         # Generate unit tests (always)
         unit_tests = self._generate_unit_tests(context)
 
-        # Generate integration tests (for multi-step wizards)
+        # Generate integration tests (for multi-step workflows)
         integration_tests = None
         if self._needs_integration_tests(pattern_ids):
             integration_tests = self._generate_integration_tests(context)
@@ -142,7 +142,7 @@ class TestGenerator:
         fixtures = self._generate_fixtures(context)
 
         logger.info(
-            f"Generated tests for {wizard_id}: "
+            f"Generated tests for {workflow_id}: "
             f"unit={len(unit_tests)} chars, "
             f"integration={'yes' if integration_tests else 'no'}, "
             f"fixtures={len(fixtures)} chars"
@@ -156,19 +156,19 @@ class TestGenerator:
 
     def _build_template_context(
         self,
-        wizard_id: str,
+        workflow_id: str,
         pattern_ids: list[str],
-        wizard_module: str,
-        wizard_class: str,
+        workflow_module: str,
+        workflow_class: str,
         risk_analysis: Any,
     ) -> dict:
         """Build Jinja2 template context.
 
         Args:
-            wizard_id: Wizard identifier
+            workflow_id: Workflow identifier
             pattern_ids: Pattern IDs
-            wizard_module: Module path
-            wizard_class: Class name
+            workflow_module: Module path
+            workflow_class: Class name
             risk_analysis: RiskAnalysis object
 
         Returns:
@@ -182,7 +182,7 @@ class TestGenerator:
         has_linear_flow = "linear_flow" in pattern_ids
         has_phased = "phased_processing" in pattern_ids
         has_approval = "approval" in pattern_ids
-        has_async = True  # Assume async by default for modern wizards
+        has_async = True  # Assume async by default for modern workflows
 
         # Get linear flow details if present
         total_steps = None
@@ -199,9 +199,9 @@ class TestGenerator:
                 phases = phased_pattern.phases
 
         return {
-            "wizard_id": wizard_id,
-            "wizard_module": wizard_module,
-            "wizard_class": wizard_class,
+            "workflow_id": workflow_id,
+            "workflow_module": workflow_module,
+            "workflow_class": workflow_class,
             "pattern_ids": pattern_ids,
             "patterns": patterns,
             "risk_analysis": risk_analysis,
@@ -239,30 +239,30 @@ class TestGenerator:
         """
         # For now, return a simple integration test template
         # In full implementation, would use integration_test.py.jinja2
-        return f'''"""Integration tests for {context["wizard_id"]} wizard.
+        return f'''"""Integration tests for {context["workflow_id"]} workflow.
 
 Auto-generated by Empathy Framework Test Generator
-Tests end-to-end wizard workflows.
+Tests end-to-end workflow workflows.
 """
 
 import pytest
-from {context["wizard_module"]} import {context["wizard_class"]}
+from {context["workflow_module"]} import {context["workflow_class"]}
 
 
-class TestIntegration{context["wizard_class"]}:
-    """Integration tests for {context["wizard_id"]} wizard."""
+class TestIntegration{context["workflow_class"]}:
+    """Integration tests for {context["workflow_id"]} workflow."""
 
     @pytest.fixture
-    async def wizard(self):
-        """Create wizard instance."""
-        return {context["wizard_class"]}()
+    async def workflow(self):
+        """Create workflow instance."""
+        return {context["workflow_class"]}()
 
     @pytest.mark.asyncio
-    async def test_complete_wizard_workflow(self, wizard):
-        """Test complete wizard workflow end-to-end."""
-        # Start wizard
-        session = await wizard.start()
-        wizard_id = session["wizard_id"]
+    async def test_complete_workflow_workflow(self, workflow):
+        """Test complete workflow workflow end-to-end."""
+        # Start workflow
+        session = await workflow.start()
+        workflow_id = session["workflow_id"]
 
         # Complete all steps with valid data
         # TODO: Add step completion logic
@@ -281,7 +281,7 @@ class TestIntegration{context["wizard_class"]}:
             Generated fixture code
 
         """
-        return f'''"""Test fixtures for {context["wizard_id"]} wizard.
+        return f'''"""Test fixtures for {context["workflow_id"]} workflow.
 
 Auto-generated by Empathy Framework Test Generator
 Provides common test data and mocks.
@@ -292,8 +292,8 @@ from unittest.mock import MagicMock
 
 
 @pytest.fixture
-def sample_{context["wizard_id"]}_data():
-    """Sample data for {context["wizard_id"]} wizard."""
+def sample_{context["workflow_id"]}_data():
+    """Sample data for {context["workflow_id"]} workflow."""
     return {{
         "field1": "test value 1",
         "field2": "test value 2",
@@ -301,8 +301,8 @@ def sample_{context["wizard_id"]}_data():
 
 
 @pytest.fixture
-def mock_{context["wizard_id"]}_dependencies():
-    """Mock dependencies for {context["wizard_id"]} wizard."""
+def mock_{context["workflow_id"]}_dependencies():
+    """Mock dependencies for {context["workflow_id"]} workflow."""
     return {{
         "database": MagicMock(),
         "api_client": MagicMock(),
@@ -319,39 +319,37 @@ def mock_{context["wizard_id"]}_dependencies():
             True if integration tests recommended
 
         """
-        # Integration tests for multi-step or phased wizards
+        # Integration tests for multi-step or phased workflows
         return "linear_flow" in pattern_ids or "phased_processing" in pattern_ids
 
-    def _infer_module(self, wizard_id: str) -> str:
-        """Infer module path from wizard ID.
+    def _infer_module(self, workflow_id: str) -> str:
+        """Infer module path from workflow ID.
 
         Args:
-            wizard_id: Wizard identifier
+            workflow_id: Workflow identifier
 
         Returns:
             Inferred module path
 
         """
-        # Try to determine wizard location
+        # Try to determine workflow location
         # This is a simple heuristic - can be improved
-        if wizard_id in ["soap_note", "sbar", "care_plan"]:
-            return f"wizards.{wizard_id}"
-        elif wizard_id in ["debugging", "testing", "security"]:
-            return f"coach_wizards.{wizard_id}_wizard"
+        if workflow_id in ["soap_note", "sbar", "care_plan"]:
+            return f"workflows.{workflow_id}"
         else:
-            return f"wizards.{wizard_id}_wizard"
+            return f"workflows.{workflow_id}_workflow"
 
-    def _infer_class_name(self, wizard_id: str) -> str:
-        """Infer wizard class name from ID.
+    def _infer_class_name(self, workflow_id: str) -> str:
+        """Infer workflow class name from ID.
 
         Args:
-            wizard_id: Wizard identifier
+            workflow_id: Workflow identifier
 
         Returns:
             Inferred class name
 
         """
-        # Convert snake_case to PascalCase and add "Wizard"
-        parts = wizard_id.split("_")
+        # Convert snake_case to PascalCase and add "Workflow"
+        parts = workflow_id.split("_")
         class_name = "".join(part.capitalize() for part in parts)
-        return f"{class_name}Wizard"
+        return f"{class_name}Workflow"

empathy_os/test_generator/risk_analyzer.py

@@ -1,6 +1,6 @@
 """Risk analyzer for test generation.
 
-Analyzes wizard patterns to identify critical paths and determine
+Analyzes workflow patterns to identify critical paths and determine
 appropriate test coverage levels.
 
 Copyright 2025 Smart AI Memory, LLC
@@ -20,9 +20,9 @@ logger = logging.getLogger(__name__)
 
 @dataclass
 class RiskAnalysis:
-    """Risk analysis results for a wizard."""
+    """Risk analysis results for a workflow."""
 
-    wizard_id: str
+    workflow_id: str
     pattern_ids: list[str]
     critical_paths: list[str] = field(default_factory=list)
     high_risk_inputs: list[str] = field(default_factory=list)
@@ -54,7 +54,7 @@ class RiskAnalysis:
     def to_dict(self) -> dict:
         """Convert to dictionary."""
         return {
-            "wizard_id": self.wizard_id,
+            "workflow_id": self.workflow_id,
             "pattern_ids": self.pattern_ids,
             "critical_paths": self.critical_paths,
             "high_risk_inputs": self.high_risk_inputs,
@@ -65,7 +65,7 @@ class RiskAnalysis:
 
 
 class RiskAnalyzer:
-    """Analyzes wizard patterns to determine testing requirements.
+    """Analyzes workflow patterns to determine testing requirements.
 
     Uses pattern analysis to identify:
     - Critical execution paths
@@ -78,21 +78,21 @@ class RiskAnalyzer:
         """Initialize risk analyzer."""
         self.registry = get_pattern_registry()
 
-    def analyze(self, wizard_id: str, pattern_ids: list[str]) -> RiskAnalysis:
-        """Analyze wizard patterns for risk.
+    def analyze(self, workflow_id: str, pattern_ids: list[str]) -> RiskAnalysis:
+        """Analyze workflow patterns for risk.
 
         Args:
-            wizard_id: Wizard identifier
-            pattern_ids: List of pattern IDs used by wizard
+            workflow_id: Workflow identifier
+            pattern_ids: List of pattern IDs used by workflow
 
         Returns:
             RiskAnalysis with recommendations
 
         """
-        logger.info(f"Analyzing risk for wizard: {wizard_id}")
+        logger.info(f"Analyzing risk for workflow: {workflow_id}")
 
         analysis = RiskAnalysis(
-            wizard_id=wizard_id,
+            workflow_id=workflow_id,
             pattern_ids=pattern_ids,
         )
 

empathy_os/vscode_bridge.py

@@ -0,0 +1,173 @@
+"""VS Code Extension Bridge
+
+Provides functions to write data that the VS Code extension can pick up.
+Enables Claude Code CLI output to appear in VS Code webview panels.
+
+Copyright 2026 Smart-AI-Memory
+Licensed under Fair Source License 0.9
+"""
+
+import json
+from dataclasses import asdict, dataclass
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+
+@dataclass
+class ReviewFinding:
+    """A code review finding."""
+
+    id: str
+    file: str
+    line: int
+    severity: str  # 'critical' | 'high' | 'medium' | 'low' | 'info'
+    category: str  # 'security' | 'performance' | 'maintainability' | 'style' | 'correctness'
+    message: str
+    column: int = 1
+    details: str | None = None
+    recommendation: str | None = None
+
+
+@dataclass
+class CodeReviewResult:
+    """Code review results for VS Code bridge."""
+
+    findings: list[dict[str, Any]]
+    summary: dict[str, Any]
+    verdict: str  # 'approve' | 'approve_with_suggestions' | 'request_changes' | 'reject'
+    security_score: int
+    formatted_report: str
+    model_tier_used: str
+    timestamp: str
+
+
+def get_empathy_dir() -> Path:
+    """Get the .empathy directory, creating if needed."""
+    empathy_dir = Path(".empathy")
+    empathy_dir.mkdir(exist_ok=True)
+    return empathy_dir
+
+
+def write_code_review_results(
+    findings: list[dict[str, Any]] | None = None,
+    summary: dict[str, Any] | None = None,
+    verdict: str = "approve_with_suggestions",
+    security_score: int = 85,
+    formatted_report: str = "",
+    model_tier_used: str = "capable",
+) -> Path:
+    """Write code review results for VS Code extension to pick up.
+
+    Args:
+        findings: List of finding dicts with keys: id, file, line, severity, category, message
+        summary: Summary dict with keys: total_findings, by_severity, by_category, files_affected
+        verdict: One of 'approve', 'approve_with_suggestions', 'request_changes', 'reject'
+        security_score: 0-100 score
+        formatted_report: Markdown formatted report
+        model_tier_used: 'cheap', 'capable', or 'premium'
+
+    Returns:
+        Path to the written file
+    """
+    findings = findings or []
+
+    # Build summary if not provided
+    if summary is None:
+        by_severity: dict[str, int] = {}
+        by_category: dict[str, int] = {}
+        files_affected: set[str] = set()
+
+        for f in findings:
+            sev = f.get("severity", "info")
+            cat = f.get("category", "correctness")
+            by_severity[sev] = by_severity.get(sev, 0) + 1
+            by_category[cat] = by_category.get(cat, 0) + 1
+            if f.get("file"):
+                files_affected.add(f["file"])
+
+        summary = {
+            "total_findings": len(findings),
+            "by_severity": by_severity,
+            "by_category": by_category,
+            "files_affected": list(files_affected),
+        }
+
+    result = CodeReviewResult(
+        findings=findings,
+        summary=summary,
+        verdict=verdict,
+        security_score=security_score,
+        formatted_report=formatted_report,
+        model_tier_used=model_tier_used,
+        timestamp=datetime.now().isoformat(),
+    )
+
+    output_path = get_empathy_dir() / "code-review-results.json"
+
+    with open(output_path, "w") as f:
+        json.dump(asdict(result), f, indent=2)
+
+    return output_path
+
+
+def write_pr_review_results(
+    pr_number: int | str,
+    title: str,
+    findings: list[dict[str, Any]],
+    verdict: str = "approve_with_suggestions",
+    summary_text: str = "",
+) -> Path:
+    """Write PR review results for VS Code extension.
+
+    Convenience wrapper for PR reviews from GitHub.
+
+    Args:
+        pr_number: The PR number
+        title: PR title
+        findings: List of review findings
+        verdict: Review verdict
+        summary_text: Summary of the review
+
+    Returns:
+        Path to the written file
+    """
+    formatted_report = f"""## PR #{pr_number}: {title}
+
+{summary_text}
+
+### Findings ({len(findings)})
+
+"""
+    for f in findings:
+        formatted_report += f"- **{f.get('severity', 'info').upper()}** [{f.get('file', 'unknown')}:{f.get('line', 0)}]: {f.get('message', '')}\n"
+
+    return write_code_review_results(
+        findings=findings,
+        verdict=verdict,
+        formatted_report=formatted_report,
+        model_tier_used="capable",
+    )
+
+
+# Quick helper for Claude Code to call
+def send_to_vscode(
+    message: str,
+    findings: list[dict[str, Any]] | None = None,
+    verdict: str = "approve_with_suggestions",
+) -> str:
+    """Quick helper to send review results to VS Code.
+
+    Usage in Claude Code:
+        from empathy_os.vscode_bridge import send_to_vscode
+        send_to_vscode("Review complete", findings=[...])
+
+    Returns:
+        Confirmation message
+    """
+    path = write_code_review_results(
+        findings=findings or [],
+        formatted_report=message,
+        verdict=verdict,
+    )
+    return f"Results written to {path} - VS Code will update automatically"