empathy-framework 5.1.1__py3-none-any.whl → 5.3.0__py3-none-any.whl

empathy_os/workflows/base.py

@@ -142,8 +142,12 @@ class ModelProvider(Enum):
     CUSTOM = "custom"  # User-defined custom models
 
     def to_unified(self) -> UnifiedModelProvider:
-        """Convert to unified ModelProvider from empathy_os.models."""
-        return UnifiedModelProvider(self.value)
+        """Convert to unified ModelProvider from empathy_os.models.
+
+        As of v5.0.0, framework is Claude-native. All providers map to ANTHROPIC.
+        """
+        # v5.0.0: Framework is Claude-native, only ANTHROPIC supported
+        return UnifiedModelProvider.ANTHROPIC
 
 
 # Import unified MODEL_REGISTRY as single source of truth

empathy_os/workflows/code_review.py

@@ -645,6 +645,9 @@ Code to review:
                 "Code will proceed to architectural review."
             )
 
+        # Calculate security score
+        security_score = 70 if has_critical else 90
+
         # Determine preliminary verdict based on scan
         if has_critical:
             preliminary_verdict = "request_changes"
@@ -661,7 +664,7 @@ Code to review:
             "bug_patterns": [],
             "quality_issues": [],
             "has_critical_issues": has_critical,
-            "security_score": 70 if has_critical else 90,
+            "security_score": security_score,
             "verdict": preliminary_verdict,  # Add verdict for when architect_review is skipped
             "needs_architect_review": input_data.get("needs_architect_review", False)
             or has_critical,

empathy_os/workflows/document_gen/__init__.py

@@ -0,0 +1,25 @@
+"""Document Generation Workflow Package.
+
+Cost-optimized documentation generation pipeline.
+
+Copyright 2025 Smart-AI-Memory
+Licensed under Fair Source License 0.9
+"""
+
+# Core workflow
+# Configuration
+from .config import DOC_GEN_STEPS, TOKEN_COSTS
+
+# Report formatter
+from .report_formatter import format_doc_gen_report
+from .workflow import DocumentGenerationWorkflow
+
+__all__ = [
+    # Workflow
+    "DocumentGenerationWorkflow",
+    # Configuration
+    "DOC_GEN_STEPS",
+    "TOKEN_COSTS",
+    # Report formatter
+    "format_doc_gen_report",
+]

empathy_os/workflows/document_gen/config.py

@@ -0,0 +1,30 @@
+"""Document Generation Configuration.
+
+Token costs and step configurations for documentation generation workflow.
+
+Copyright 2025 Smart-AI-Memory
+Licensed under Fair Source License 0.9
+"""
+
+from ..base import ModelTier
+from ..step_config import WorkflowStepConfig
+
+# Approximate cost per 1K tokens (USD) - used for cost estimation
+# These are estimates and should be updated as pricing changes
+TOKEN_COSTS = {
+    ModelTier.CHEAP: {"input": 0.00025, "output": 0.00125},  # Haiku
+    ModelTier.CAPABLE: {"input": 0.003, "output": 0.015},  # Sonnet
+    ModelTier.PREMIUM: {"input": 0.015, "output": 0.075},  # Opus
+}
+
+# Define step configurations for executor-based execution
+# Note: max_tokens for polish is dynamically set based on input size
+DOC_GEN_STEPS = {
+    "polish": WorkflowStepConfig(
+        name="polish",
+        task_type="final_review",  # Premium tier task
+        tier_hint="premium",
+        description="Polish and improve documentation for consistency and quality",
+        max_tokens=20000,  # Increased to handle large chunked documents
+    ),
+}

empathy_os/workflows/document_gen/report_formatter.py

@@ -0,0 +1,162 @@
+"""Document Generation Report Formatter.
+
+Format documentation generation output as human-readable reports.
+
+Copyright 2025 Smart-AI-Memory
+Licensed under Fair Source License 0.9
+"""
+
+
+def format_doc_gen_report(result: dict, input_data: dict) -> str:
+    """Format document generation output as a human-readable report.
+
+    Args:
+        result: The polish stage result
+        input_data: Input data from previous stages
+
+    Returns:
+        Formatted report string
+
+    """
+    lines = []
+
+    # Header
+    doc_type = result.get("doc_type", "general").replace("_", " ").title()
+    audience = result.get("audience", "developers").replace("_", " ").title()
+
+    lines.append("=" * 60)
+    lines.append("DOCUMENTATION GENERATION REPORT")
+    lines.append("=" * 60)
+    lines.append("")
+    lines.append(f"Document Type: {doc_type}")
+    lines.append(f"Target Audience: {audience}")
+    lines.append("")
+
+    # Outline summary
+    outline = input_data.get("outline", "")
+    if outline:
+        lines.append("-" * 60)
+        lines.append("DOCUMENT OUTLINE")
+        lines.append("-" * 60)
+        # Show just a preview of the outline
+        outline_lines = outline.split("\n")[:10]
+        lines.extend(outline_lines)
+        if len(outline.split("\n")) > 10:
+            lines.append("...")
+        lines.append("")
+
+    # Generated document
+    document = result.get("document", "")
+    if document:
+        lines.append("-" * 60)
+        lines.append("GENERATED DOCUMENTATION")
+        lines.append("-" * 60)
+        lines.append("")
+        lines.append(document)
+        lines.append("")
+
+    # Statistics
+    word_count = len(document.split()) if document else 0
+    section_count = document.count("##") if document else 0  # Count markdown headers
+    was_chunked = input_data.get("chunked", False)
+    chunk_count = input_data.get("chunk_count", 0)
+    chunks_completed = input_data.get("chunks_completed", chunk_count)
+    stopped_early = input_data.get("stopped_early", False)
+    accumulated_cost = result.get("accumulated_cost", 0)
+    polish_chunked = result.get("polish_chunked", False)
+
+    lines.append("-" * 60)
+    lines.append("STATISTICS")
+    lines.append("-" * 60)
+    lines.append(f"Word Count: {word_count}")
+    lines.append(f"Section Count: ~{section_count}")
+    if was_chunked:
+        if stopped_early:
+            lines.append(
+                f"Generation Mode: Chunked ({chunks_completed}/{chunk_count} chunks completed)",
+            )
+        else:
+            lines.append(f"Generation Mode: Chunked ({chunk_count} chunks)")
+    if polish_chunked:
+        polish_chunks = result.get("polish_chunks", 0)
+        lines.append(f"Polish Mode: Chunked ({polish_chunks} sections)")
+    if accumulated_cost > 0:
+        lines.append(f"Estimated Cost: ${accumulated_cost:.2f}")
+    lines.append("")
+
+    # Export info
+    export_path = result.get("export_path")
+    if export_path:
+        lines.append("-" * 60)
+        lines.append("FILE EXPORT")
+        lines.append("-" * 60)
+        lines.append(f"Documentation saved to: {export_path}")
+        report_path = result.get("report_path")
+        if report_path:
+            lines.append(f"Report saved to: {report_path}")
+        lines.append("")
+        lines.append("Full documentation is available in the exported file.")
+        lines.append("")
+
+    # Warning notice (cost limit, errors, etc.)
+    warning = input_data.get("warning") or result.get("warning")
+    if warning or stopped_early:
+        lines.append("-" * 60)
+        lines.append("⚠️  WARNING")
+        lines.append("-" * 60)
+        if warning:
+            lines.append(warning)
+        if stopped_early and not warning:
+            lines.append("Generation stopped early due to cost or error limits.")
+        lines.append("")
+
+    # Truncation detection and scope notice
+    truncation_indicators = []
+    if document:  # Handle None or empty document
+        truncation_indicators = [
+            document.rstrip().endswith("..."),
+            document.rstrip().endswith("-"),
+            "```" in document and document.count("```") % 2 != 0,  # Unclosed code block
+            any(
+                phrase in document.lower()
+                for phrase in ["continued in", "see next section", "to be continued"]
+            ),
+        ]
+
+    # Count planned sections from outline (top-level only)
+    import re
+
+    planned_sections = 0
+    top_level_pattern = re.compile(r"^(\d+)\.\s+([A-Za-z].*)")
+    if outline:
+        for line in outline.split("\n"):
+            stripped = line.strip()
+            if top_level_pattern.match(stripped):
+                planned_sections += 1
+
+    is_truncated = any(truncation_indicators) or (
+        planned_sections > 0 and section_count < planned_sections - 1
+    )
+
+    if is_truncated or planned_sections > section_count + 1:
+        lines.append("-" * 60)
+        lines.append("SCOPE NOTICE")
+        lines.append("-" * 60)
+        lines.append("⚠️  DOCUMENTATION MAY BE INCOMPLETE")
+        if planned_sections > 0:
+            lines.append(f"   Planned sections: {planned_sections}")
+            lines.append(f"   Generated sections: {section_count}")
+        lines.append("")
+        lines.append("To generate missing sections, re-run with section_focus:")
+        lines.append("   workflow = DocumentGenerationWorkflow(")
+        lines.append('       section_focus=["Testing Guide", "API Reference"]')
+        lines.append("   )")
+        lines.append("")
+
+    # Footer
+    lines.append("=" * 60)
+    model_tier = result.get("model_tier_used", "unknown")
+    lines.append(f"Generated using {model_tier} tier model")
+    lines.append("=" * 60)
+
+    return "\n".join(lines)

empathy_os/workflows/{document_gen.py → document_gen/workflow.py}

@@ -1,15 +1,6 @@
-"""Document Generation Workflow
+"""Document Generation Workflow.
 
-A cost-optimized, enterprise-safe documentation pipeline:
-1. Haiku: Generate outline from code/specs (cheap, fast)
-2. Sonnet: Write each section (capable, chunked for large projects)
-3. Opus: Final review + consistency polish (premium, chunked if needed)
-
-Enterprise Features:
-- Auto-scaling tokens based on project complexity
-- Chunked polish for large documents
-- Cost guardrails with configurable max_cost
-- Graceful degradation with partial results on errors
+Main workflow orchestration for documentation generation.
 
 Copyright 2025 Smart-AI-Memory
 Licensed under Fair Source License 0.9
@@ -22,31 +13,12 @@ from typing import Any
 
 from empathy_os.config import _validate_file_path
 
-from .base import BaseWorkflow, ModelTier
-from .step_config import WorkflowStepConfig
+from ..base import BaseWorkflow, ModelTier
+from .config import DOC_GEN_STEPS, TOKEN_COSTS
+from .report_formatter import format_doc_gen_report
 
 logger = logging.getLogger(__name__)
 
-# Approximate cost per 1K tokens (USD) - used for cost estimation
-# These are estimates and should be updated as pricing changes
-TOKEN_COSTS = {
-    ModelTier.CHEAP: {"input": 0.00025, "output": 0.00125},  # Haiku
-    ModelTier.CAPABLE: {"input": 0.003, "output": 0.015},  # Sonnet
-    ModelTier.PREMIUM: {"input": 0.015, "output": 0.075},  # Opus
-}
-
-# Define step configurations for executor-based execution
-# Note: max_tokens for polish is dynamically set based on input size
-DOC_GEN_STEPS = {
-    "polish": WorkflowStepConfig(
-        name="polish",
-        task_type="final_review",  # Premium tier task
-        tier_hint="premium",
-        description="Polish and improve documentation for consistency and quality",
-        max_tokens=20000,  # Increased to handle large chunked documents
-    ),
-}
-
 
 class DocumentGenerationWorkflow(BaseWorkflow):
     """Multi-tier document generation workflow.
@@ -1452,154 +1424,3 @@ None
         return full_doc
 
 
-def format_doc_gen_report(result: dict, input_data: dict) -> str:
-    """Format document generation output as a human-readable report.
-
-    Args:
-        result: The polish stage result
-        input_data: Input data from previous stages
-
-    Returns:
-        Formatted report string
-
-    """
-    lines = []
-
-    # Header
-    doc_type = result.get("doc_type", "general").replace("_", " ").title()
-    audience = result.get("audience", "developers").title()
-
-    lines.append("=" * 60)
-    lines.append("DOCUMENTATION GENERATION REPORT")
-    lines.append("=" * 60)
-    lines.append("")
-    lines.append(f"Document Type: {doc_type}")
-    lines.append(f"Target Audience: {audience}")
-    lines.append("")
-
-    # Outline summary
-    outline = input_data.get("outline", "")
-    if outline:
-        lines.append("-" * 60)
-        lines.append("DOCUMENT OUTLINE")
-        lines.append("-" * 60)
-        # Show just a preview of the outline
-        outline_lines = outline.split("\n")[:10]
-        lines.extend(outline_lines)
-        if len(outline.split("\n")) > 10:
-            lines.append("...")
-        lines.append("")
-
-    # Generated document
-    document = result.get("document", "")
-    if document:
-        lines.append("-" * 60)
-        lines.append("GENERATED DOCUMENTATION")
-        lines.append("-" * 60)
-        lines.append("")
-        lines.append(document)
-        lines.append("")
-
-    # Statistics
-    word_count = len(document.split()) if document else 0
-    section_count = document.count("##") if document else 0  # Count markdown headers
-    was_chunked = input_data.get("chunked", False)
-    chunk_count = input_data.get("chunk_count", 0)
-    chunks_completed = input_data.get("chunks_completed", chunk_count)
-    stopped_early = input_data.get("stopped_early", False)
-    accumulated_cost = result.get("accumulated_cost", 0)
-    polish_chunked = result.get("polish_chunked", False)
-
-    lines.append("-" * 60)
-    lines.append("STATISTICS")
-    lines.append("-" * 60)
-    lines.append(f"Word Count: {word_count}")
-    lines.append(f"Section Count: ~{section_count}")
-    if was_chunked:
-        if stopped_early:
-            lines.append(
-                f"Generation Mode: Chunked ({chunks_completed}/{chunk_count} chunks completed)",
-            )
-        else:
-            lines.append(f"Generation Mode: Chunked ({chunk_count} chunks)")
-    if polish_chunked:
-        polish_chunks = result.get("polish_chunks", 0)
-        lines.append(f"Polish Mode: Chunked ({polish_chunks} sections)")
-    if accumulated_cost > 0:
-        lines.append(f"Estimated Cost: ${accumulated_cost:.2f}")
-    lines.append("")
-
-    # Export info
-    export_path = result.get("export_path")
-    if export_path:
-        lines.append("-" * 60)
-        lines.append("FILE EXPORT")
-        lines.append("-" * 60)
-        lines.append(f"Documentation saved to: {export_path}")
-        report_path = result.get("report_path")
-        if report_path:
-            lines.append(f"Report saved to: {report_path}")
-        lines.append("")
-        lines.append("Full documentation is available in the exported file.")
-        lines.append("")
-
-    # Warning notice (cost limit, errors, etc.)
-    warning = input_data.get("warning") or result.get("warning")
-    if warning or stopped_early:
-        lines.append("-" * 60)
-        lines.append("⚠️  WARNING")
-        lines.append("-" * 60)
-        if warning:
-            lines.append(warning)
-        if stopped_early and not warning:
-            lines.append("Generation stopped early due to cost or error limits.")
-        lines.append("")
-
-    # Truncation detection and scope notice
-    truncation_indicators = [
-        document.rstrip().endswith("..."),
-        document.rstrip().endswith("-"),
-        "```" in document and document.count("```") % 2 != 0,  # Unclosed code block
-        any(
-            phrase in document.lower()
-            for phrase in ["continued in", "see next section", "to be continued"]
-        ),
-    ]
-
-    # Count planned sections from outline (top-level only)
-    import re
-
-    planned_sections = 0
-    top_level_pattern = re.compile(r"^(\d+)\.\s+([A-Za-z].*)")
-    if outline:
-        for line in outline.split("\n"):
-            stripped = line.strip()
-            if top_level_pattern.match(stripped):
-                planned_sections += 1
-
-    is_truncated = any(truncation_indicators) or (
-        planned_sections > 0 and section_count < planned_sections - 1
-    )
-
-    if is_truncated or planned_sections > section_count + 1:
-        lines.append("-" * 60)
-        lines.append("SCOPE NOTICE")
-        lines.append("-" * 60)
-        lines.append("⚠️  DOCUMENTATION MAY BE INCOMPLETE")
-        if planned_sections > 0:
-            lines.append(f"   Planned sections: {planned_sections}")
-            lines.append(f"   Generated sections: {section_count}")
-        lines.append("")
-        lines.append("To generate missing sections, re-run with section_focus:")
-        lines.append("   workflow = DocumentGenerationWorkflow(")
-        lines.append('       section_focus=["Testing Guide", "API Reference"]')
-        lines.append("   )")
-        lines.append("")
-
-    # Footer
-    lines.append("=" * 60)
-    model_tier = result.get("model_tier_used", "unknown")
-    lines.append(f"Generated using {model_tier} tier model")
-    lines.append("=" * 60)
-
-    return "\n".join(lines)

empathy_os/workflows/output.py

@@ -326,7 +326,10 @@ class MetricsPanel:
             Rich Panel with formatted score
         """
         if not RICH_AVAILABLE or Panel is None:
-            raise RuntimeError("Rich is not available")
+            raise RuntimeError(
+                "Rich library not available. "
+                "Install with: pip install rich"
+            )
 
         style = cls.get_style(score)
         icon = cls.get_icon(score)

empathy_os/workflows/progress.py

@@ -590,7 +590,10 @@ class RichProgressReporter:
             stage_names: List of stage names for progress tracking
         """
         if not RICH_AVAILABLE:
-            raise RuntimeError("Rich library required for RichProgressReporter")
+            raise RuntimeError(
+                "Rich library required for RichProgressReporter. "
+                "Install with: pip install rich"
+            )
 
         self.workflow_name = workflow_name
         self.stage_names = stage_names
@@ -674,7 +677,10 @@ class RichProgressReporter:
             Rich Panel containing progress information
         """
         if not RICH_AVAILABLE or Panel is None or Table is None:
-            raise RuntimeError("Rich not available")
+            raise RuntimeError(
+                "Rich library not available. "
+                "Install with: pip install rich"
+            )
 
         # Build metrics table
         metrics = Table(show_header=False, box=None, padding=(0, 2))

empathy_os/workflows/security_audit.py

@@ -618,8 +618,8 @@ class SecurityAuditWorkflow(BaseWorkflow):
         """
         line = line_content.strip()
 
-        # Check if line is a comment
-        if line.startswith("#") or line.startswith("//") or line.startswith("*"):
+        # Check if line is a comment or documentation
+        if line.startswith("#") or line.startswith("//") or line.startswith("*") or line.startswith("-"):
             return True
 
         # Check if inside a docstring (triple quotes)

empathy_os/workflows/security_audit_phase3.py

@@ -9,6 +9,7 @@ Related: docs/SECURITY_PHASE2_COMPLETE.md
 
 import ast
 import logging
+import re
 from pathlib import Path
 from typing import Any
 
@@ -167,12 +168,14 @@ def is_in_docstring_or_comment(line_content: str, file_content: str, line_num: i
     try:
         tree = ast.parse(file_content)
 
-        # Get all docstrings
+        # Get all docstrings - only from nodes that can have docstrings
         docstrings = []
         for node in ast.walk(tree):
-            docstring = ast.get_docstring(node)
-            if docstring:
-                docstrings.append(docstring)
+            # Only these node types can have docstrings
+            if isinstance(node, (ast.FunctionDef, ast.ClassDef, ast.AsyncFunctionDef, ast.Module)):
+                docstring = ast.get_docstring(node)
+                if docstring:
+                    docstrings.append(docstring)
 
         # Check if any docstring contains this line content
         for docstring in docstrings: