empathy-framework 5.2.1__py3-none-any.whl → 5.4.0__py3-none-any.whl

empathy_os/workflows/xml_enhanced_crew.py

@@ -1,285 +0,0 @@
-"""XML-Enhanced Agent and Task Templates for CrewAI Workflows
-
-This module provides reusable base classes for creating XML-enhanced CrewAI
-agents and tasks based on Anthropic's prompting best practices.
-
-Benefits:
-- 40-60% reduction in misinterpreted instructions
-- 30-50% better output consistency
-- 20-30% fewer retry attempts
-- Better debugging with separated thinking/answer
-
-Usage:
-    from empathy_os.workflows.xml_enhanced_crew import XMLAgent, XMLTask, parse_xml_response
-
-    agent = XMLAgent(
-        role="Documentation Analyst",
-        goal="Scan codebase for documentation gaps",
-        backstory="Expert in code documentation best practices"
-    )
-
-    task = XMLTask(
-        description="Analyze Python files for missing docstrings",
-        expected_output="JSON list of files with missing documentation",
-        agent=agent
-    )
-
-Copyright 2026 Smart-AI-Memory
-Licensed under Fair Source License 0.9
-"""
-
-import re
-from dataclasses import dataclass, field
-from typing import Any
-
-
-@dataclass
-class XMLAgent:
-    """Agent with XML-enhanced prompting (Anthropic best practice).
-
-    This class generates structured prompts using XML tags for better clarity
-    and reduces ambiguity in agent instructions.
-
-    Attributes:
-        role: The agent's role (e.g., "Documentation Analyst")
-        goal: What the agent aims to achieve
-        backstory: Domain expertise and personality
-        expertise_level: Level of expertise (expert, world-class, etc.)
-        use_xml_structure: Enable/disable XML formatting (default: True)
-        custom_instructions: Additional instructions to append
-    """
-
-    role: str
-    goal: str
-    backstory: str
-    expertise_level: str = "expert"
-    use_xml_structure: bool = True
-    custom_instructions: list[str] = field(default_factory=list)
-
-    def get_system_prompt(self) -> str:
-        """Generate XML-enhanced system prompt for this agent.
-
-        Returns:
-            Structured prompt with XML tags for role, goal, backstory, etc.
-        """
-        if not self.use_xml_structure:
-            # Legacy format for backward compatibility
-            return self._get_legacy_prompt()
-
-        # XML-enhanced format (Anthropic best practice)
-        instructions = [
-            "Carefully review all provided context data",
-            "Think through your analysis step-by-step",
-            "Provide thorough, actionable analysis",
-            "Be specific and cite file paths when relevant",
-            "Structure your output according to the requested format",
-        ]
-
-        # Add custom instructions
-        instructions.extend(self.custom_instructions)
-
-        instructions_text = "\n".join(f"{i}. {inst}" for i, inst in enumerate(instructions, 1))
-
-        return f"""<agent_role>
-You are a {self.role} with {self.expertise_level}-level expertise.
-</agent_role>
-
-<agent_goal>
-{self.goal}
-</agent_goal>
-
-<agent_backstory>
-{self.backstory}
-</agent_backstory>
-
-<instructions>
-{instructions_text}
-</instructions>
-
-<output_structure>
-Always structure your response as:
-
-<thinking>
-[Your step-by-step reasoning process]
-- What you observe in the context
-- How you analyze the situation
-- What conclusions you draw
-</thinking>
-
-<answer>
-[Your final output in the requested format]
-</answer>
-</output_structure>"""
-
-    def _get_legacy_prompt(self) -> str:
-        """Generate legacy non-XML prompt for backward compatibility."""
-        return f"""You are a {self.role} with {self.expertise_level}-level expertise.
-
-Goal: {self.goal}
-
-Background: {self.backstory}
-
-Provide thorough, actionable analysis. Be specific and cite file paths when relevant."""
-
-
-@dataclass
-class XMLTask:
-    """Task with XML-enhanced prompting (Anthropic best practice).
-
-    This class generates structured task prompts using XML tags to clearly
-    separate task description, context, and expected output.
-
-    Attributes:
-        description: What the task entails
-        expected_output: Format and content of expected output
-        agent: The XMLAgent assigned to this task
-        examples: Optional list of example inputs/outputs
-    """
-
-    description: str
-    expected_output: str
-    agent: XMLAgent
-    examples: list[dict[str, Any]] = field(default_factory=list)
-
-    def get_user_prompt(self, context: dict) -> str:
-        """Generate XML-enhanced user prompt for this task.
-
-        Args:
-            context: Dictionary of context data for the task
-
-        Returns:
-            Structured prompt with XML tags for description, context, etc.
-        """
-        if not self.agent.use_xml_structure:
-            # Legacy format for backward compatibility
-            return self._get_legacy_prompt(context)
-
-        # XML-enhanced format (Anthropic best practice)
-        # Build structured context with proper XML tags
-        context_sections = []
-        for key, value in context.items():
-            if value:
-                # Use underscores for tag names (valid XML)
-                tag_name = key.replace(" ", "_").replace("-", "_").lower()
-                # Wrap in appropriate tags
-                context_sections.append(f"<{tag_name}>\n{value}\n</{tag_name}>")
-
-        context_xml = "\n".join(context_sections)
-
-        # Build examples XML if provided
-        examples_xml = ""
-        if self.examples:
-            examples_xml = "<examples>\n"
-            for i, ex in enumerate(self.examples, 1):
-                examples_xml += f'<example number="{i}">\n'
-                examples_xml += f"<input>\n{ex.get('input', '')}\n</input>\n"
-                examples_xml += f"<expected_output>\n{ex.get('output', '')}\n</expected_output>\n"
-                examples_xml += "</example>\n"
-            examples_xml += "</examples>\n\n"
-
-        return f"""{examples_xml}<task_description>
-{self.description}
-</task_description>
-
-<context>
-{context_xml}
-</context>
-
-<expected_output>
-{self.expected_output}
-</expected_output>
-
-<instructions>
-1. Review all context data in the <context> tags above
-2. Structure your response using <thinking> and <answer> tags as defined in your system prompt
-3. Match the expected output format exactly
-4. Be thorough and specific in your analysis
-{"5. Use the examples above as a guide for output structure" if self.examples else ""}
-</instructions>"""
-
-    def _get_legacy_prompt(self, context: dict) -> str:
-        """Generate legacy non-XML prompt for backward compatibility."""
-        context_str = "\n".join(f"- {k}: {v}" for k, v in context.items() if v)
-        return f"""{self.description}
-
-Context:
-{context_str}
-
-Expected output format: {self.expected_output}"""
-
-
-def parse_xml_response(response: str) -> dict[str, Any]:
-    """Parse XML-structured agent response.
-
-    Extracts <thinking> and <answer> tags from agent responses for better
-    debugging and transparency.
-
-    Args:
-        response: Raw agent response potentially containing XML tags
-
-    Returns:
-        Dictionary with:
-            - thinking: Agent's reasoning process (empty if not found)
-            - answer: Agent's final output (or full response if no tags)
-            - raw: Original unprocessed response
-            - has_structure: True if both thinking and answer tags found
-
-    Example:
-        >>> response = "<thinking>I analyzed...</thinking><answer>Result</answer>"
-        >>> parsed = parse_xml_response(response)
-        >>> parsed['thinking']
-        'I analyzed...'
-        >>> parsed['answer']
-        'Result'
-        >>> parsed['has_structure']
-        True
-    """
-    thinking_match = re.search(r"<thinking>(.*?)</thinking>", response, re.DOTALL)
-    answer_match = re.search(r"<answer>(.*?)</answer>", response, re.DOTALL)
-
-    return {
-        "thinking": thinking_match.group(1).strip() if thinking_match else "",
-        "answer": answer_match.group(1).strip() if answer_match else response.strip(),
-        "raw": response,
-        "has_structure": bool(thinking_match and answer_match),
-    }
-
-
-def extract_json_from_answer(answer: str) -> dict | None:
-    """Extract JSON from answer tag if present.
-
-    Attempts to parse JSON from code blocks or the entire answer.
-
-    Args:
-        answer: The answer portion of a parsed response
-
-    Returns:
-        Parsed JSON dict if found, None otherwise
-
-    Example:
-        >>> answer = "Here's the result: ```json\\n{'status': 'ok'}\\n```"
-        >>> extract_json_from_answer(answer)
-        {'status': 'ok'}
-    """
-    import json
-
-    # Try to find JSON in code blocks first
-    json_match = re.search(r"```json\s*(.*?)\s*```", answer, re.DOTALL)
-    if json_match:
-        try:
-            result = json.loads(json_match.group(1))
-            return result if isinstance(result, dict) else None
-        except json.JSONDecodeError:
-            pass
-
-    # Try to parse entire answer as JSON
-    try:
-        result = json.loads(answer)
-        return result if isinstance(result, dict) else None
-    except json.JSONDecodeError:
-        return None
-
-
-# Backward compatibility aliases
-Agent = XMLAgent
-Task = XMLTask

empathy_software_plugin/SOFTWARE_PLUGIN_README.md

@@ -1,57 +0,0 @@
-# Software Development Plugin
-
-> **DEPRECATION NOTICE (January 2026):** The `empathy_software_plugin.wizards` module has been removed. Please use CLI workflows instead.
-
-Production-ready analysis tools for software development.
-
-**Copyright 2025-2026 Smart AI Memory, LLC**
-**Licensed under Fair Source 0.9**
-
-## Overview
-
-The Software Development Plugin provides analysis capabilities through CLI workflows.
-
-## Recommended Approach
-
-```bash
-# Security analysis
-empathy workflow run security-audit --path ./src
-
-# Bug prediction
-empathy workflow run bug-predict --path ./src
-
-# Test coverage analysis
-empathy workflow run test-coverage --path ./src
-```
-
-Or use the Python workflow API:
-
-```python
-from empathy_os.workflows import BugPredictWorkflow
-
-workflow = BugPredictWorkflow()
-result = await workflow.execute(target_path="./src")
-```
-
-## Migration Guide
-
-| Old Wizard | New Approach |
-|------------|--------------|
-| `EnhancedTestingWizard` | `empathy workflow run test-coverage` |
-| `PerformanceProfilingWizard` | `empathy workflow run profile` |
-| `SecurityAnalysisWizard` | `empathy workflow run security-audit` |
-
-## Installation
-
-```bash
-pip install empathy-framework
-```
-
-## Support
-
-- **Documentation:** [docs/](../docs/)
-- **Issues:** [GitHub Issues](https://github.com/deepstudyai/empathy/issues)
-
-## License
-
-Copyright 2025-2026 Smart AI Memory, LLC - Licensed under Fair Source 0.9

empathy_software_plugin/cli/__init__.py

@@ -1,120 +0,0 @@
-"""CLI tools for the Empathy Software Plugin.
-
-This package exists alongside a legacy ``cli.py`` module at the
-package root. To maintain backwards compatibility with existing
-callers and tests, we dynamically import the root ``cli.py`` and
-re-export its public API from here.
-
-Tests also expect a couple of small helper functions to exist at the
-package level:
-
-* ``get_logger()`` – returns the configured logger instance
-* ``get_global_registry()`` – indirection around the plugin registry
-
-These helpers make the CLI easier to patch in tests while keeping the
-core implementation in the shared registry module.
-"""
-
-import importlib.util
-import os
-from typing import Any
-
-from .inspect import main as inspect_main
-
-# Re-export from parent cli.py module for backwards compatibility
-# This handles the cli/ package shadowing the cli.py file
-_parent_dir = os.path.dirname(os.path.dirname(__file__))
-_cli_module_path = os.path.join(_parent_dir, "cli.py")
-
-logger = None  # Will be populated if cli.py is found
-Colors = None  # type: ignore[assignment]
-analyze_project = None  # type: ignore[assignment]
-display_wizard_results = None  # type: ignore[assignment]
-gather_project_context = None  # type: ignore[assignment]
-list_wizards = None  # type: ignore[assignment]
-main = None  # type: ignore[assignment]
-scan_command = None  # type: ignore[assignment]
-wizard_info = None  # type: ignore[assignment]
-print_header = None  # type: ignore[assignment]
-print_alert = None  # type: ignore[assignment]
-print_success = None  # type: ignore[assignment]
-print_error = None  # type: ignore[assignment]
-print_info = None  # type: ignore[assignment]
-print_summary = None  # type: ignore[assignment]
-parse_ai_calls = None  # type: ignore[assignment]
-parse_git_history = None  # type: ignore[assignment]
-prepare_wizard_context = None  # type: ignore[assignment]
-
-
-if os.path.exists(_cli_module_path):
-    _spec = importlib.util.spec_from_file_location("_cli_module", _cli_module_path)
-    if _spec is not None and _spec.loader is not None:
-        _cli_module = importlib.util.module_from_spec(_spec)
-        _spec.loader.exec_module(_cli_module)
-
-        # Re-export all items from cli.py
-        logger = _cli_module.logger
-        Colors = _cli_module.Colors
-        analyze_project = _cli_module.analyze_project
-        display_wizard_results = _cli_module.display_wizard_results
-        gather_project_context = _cli_module.gather_project_context
-        list_wizards = _cli_module.list_wizards
-        main = _cli_module.main
-        scan_command = _cli_module.scan_command
-        wizard_info = _cli_module.wizard_info
-        print_header = _cli_module.print_header
-        print_alert = _cli_module.print_alert
-        print_success = _cli_module.print_success
-        print_error = _cli_module.print_error
-        print_info = _cli_module.print_info
-        print_summary = _cli_module.print_summary
-        parse_ai_calls = _cli_module.parse_ai_calls
-        parse_git_history = _cli_module.parse_git_history
-        prepare_wizard_context = _cli_module.prepare_wizard_context
-
-
-def get_logger():
-    """Return the CLI logger instance.
-
-    This thin wrapper exists so tests can patch the logger via
-    ``empathy_software_plugin.cli.get_logger`` without reaching into
-    the underlying implementation module.
-    """
-    return logger
-
-
-def get_global_registry() -> Any:
-    """Return the global plugin registry used by the software plugin.
-
-    The concrete implementation lives in the core plugin registry
-    module. We import lazily to avoid import cycles and to keep this
-    function easy to patch in tests via ``unittest.mock.patch``.
-    """
-    from empathy_os.plugins.registry import get_global_registry as _get_global_registry
-
-    return _get_global_registry()
-
-
-__all__ = [
-    "Colors",
-    "analyze_project",
-    "display_wizard_results",
-    "gather_project_context",
-    "get_global_registry",
-    "get_logger",
-    "inspect_main",
-    "list_wizards",
-    "logger",
-    "main",
-    "parse_ai_calls",
-    "parse_git_history",
-    "prepare_wizard_context",
-    "print_alert",
-    "print_error",
-    "print_header",
-    "print_info",
-    "print_success",
-    "print_summary",
-    "scan_command",
-    "wizard_info",
-]