empathy-framework 5.1.0__py3-none-any.whl → 5.2.1__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)