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

empathy_os/plugins/registry.py

@@ -1,268 +0,0 @@
-"""Empathy Framework - Plugin Registry
-
-Auto-discovery and management of domain plugins.
-
-Copyright 2025 Smart AI Memory, LLC
-Licensed under Fair Source 0.9
-"""
-
-import logging
-from importlib.metadata import entry_points
-
-from .base import BasePlugin, BaseWorkflow, PluginValidationError
-
-logger = logging.getLogger(__name__)
-
-
-class PluginRegistry:
-    """Central registry for managing domain plugins.
-
-    Features:
-    - Auto-discovery via entry points
-    - Manual registration
-    - Lazy initialization
-    - Graceful degradation (missing plugins don't crash)
-    """
-
-    def __init__(self):
-        self._plugins: dict[str, BasePlugin] = {}
-        self._auto_discovered = False
-        self.logger = logging.getLogger("empathy.plugins.registry")
-
-    def auto_discover(self) -> None:
-        """Automatically discover plugins via entry points.
-
-        Plugins register themselves in setup.py/pyproject.toml:
-
-        [project.entry-points."empathy_framework.plugins"]
-        software = "empathy_software.plugin:SoftwarePlugin"
-        healthcare = "empathy_healthcare.plugin:HealthcarePlugin"
-        """
-        if self._auto_discovered:
-            return
-
-        self.logger.info("Auto-discovering plugins...")
-
-        # Python 3.10+ has modern entry_points API with group parameter
-        discovered = entry_points(group="empathy_framework.plugins")
-
-        for ep in discovered:
-            try:
-                self.logger.info(f"Loading plugin '{ep.name}' from entry point")
-                plugin_class = ep.load()
-                plugin_instance = plugin_class()
-                self.register_plugin(ep.name, plugin_instance)
-                self.logger.info(f"Successfully loaded plugin: {ep.name}")
-            except Exception as e:
-                # Graceful degradation: log but don't crash
-                self.logger.warning(f"Failed to load plugin '{ep.name}': {e}", exc_info=True)
-
-        self._auto_discovered = True
-        self.logger.info(f"Auto-discovery complete. {len(self._plugins)} plugins loaded.")
-
-    def register_plugin(self, name: str, plugin: BasePlugin) -> None:
-        """Manually register a plugin.
-
-        Args:
-            name: Plugin identifier (e.g., 'software', 'healthcare')
-            plugin: Plugin instance
-
-        Raises:
-            PluginValidationError: If plugin is invalid
-
-        """
-        # Validate plugin
-        try:
-            metadata = plugin.get_metadata()
-            if not metadata.name:
-                raise PluginValidationError("Plugin metadata missing 'name'")
-            if not metadata.domain:
-                raise PluginValidationError("Plugin metadata missing 'domain'")
-        except Exception as e:
-            raise PluginValidationError(f"Invalid plugin metadata: {e}") from e
-
-        # Register
-        self._plugins[name] = plugin
-        self.logger.info(
-            f"Registered plugin '{name}' (domain: {metadata.domain}, version: {metadata.version})",
-        )
-
-    def get_plugin(self, name: str) -> BasePlugin | None:
-        """Get a plugin by name.
-
-        Args:
-            name: Plugin identifier
-
-        Returns:
-            Plugin instance or None if not found
-
-        """
-        if not self._auto_discovered:
-            self.auto_discover()
-
-        plugin = self._plugins.get(name)
-        if plugin and not plugin._initialized:
-            plugin.initialize()
-
-        return plugin
-
-    def list_plugins(self) -> list[str]:
-        """List all registered plugin names.
-
-        Returns:
-            List of plugin identifiers
-
-        """
-        if not self._auto_discovered:
-            self.auto_discover()
-
-        return list(self._plugins.keys())
-
-    def list_all_workflows(self) -> dict[str, list[str]]:
-        """List all workflows from all plugins.
-
-        Returns:
-            Dictionary mapping plugin_name -> list of workflow_ids
-
-        """
-        if not self._auto_discovered:
-            self.auto_discover()
-
-        result = {}
-        for plugin_name, plugin in self._plugins.items():
-            result[plugin_name] = plugin.list_workflows()
-
-        return result
-
-    def get_workflow(self, plugin_name: str, workflow_id: str) -> type[BaseWorkflow] | None:
-        """Get a workflow from a specific plugin.
-
-        Args:
-            plugin_name: Plugin identifier
-            workflow_id: Workflow identifier within plugin
-
-        Returns:
-            Workflow class or None if not found
-
-        """
-        plugin = self.get_plugin(plugin_name)
-        if not plugin:
-            self.logger.warning(f"Plugin '{plugin_name}' not found")
-            return None
-
-        return plugin.get_workflow(workflow_id)
-
-    def get_workflow_info(self, plugin_name: str, workflow_id: str) -> dict | None:
-        """Get information about a workflow.
-
-        Args:
-            plugin_name: Plugin identifier
-            workflow_id: Workflow identifier
-
-        Returns:
-            Dictionary with workflow metadata or None
-
-        """
-        plugin = self.get_plugin(plugin_name)
-        if not plugin:
-            return None
-
-        return plugin.get_workflow_info(workflow_id)
-
-    def find_workflows_by_level(self, empathy_level: int) -> list[dict]:
-        """Find all workflows operating at a specific empathy level.
-
-        Args:
-            empathy_level: Target empathy level (1-5)
-
-        Returns:
-            List of workflow info dictionaries
-
-        """
-        if not self._auto_discovered:
-            self.auto_discover()
-
-        results = []
-        for plugin_name, plugin in self._plugins.items():
-            for workflow_id in plugin.list_workflows():
-                info = plugin.get_workflow_info(workflow_id)
-                if info and info.get("empathy_level") == empathy_level:
-                    info["plugin"] = plugin_name
-                    results.append(info)
-
-        return results
-
-    def find_workflows_by_domain(self, domain: str) -> list[dict]:
-        """Find all workflows for a specific domain.
-
-        Args:
-            domain: Domain identifier (e.g., 'software', 'healthcare')
-
-        Returns:
-            List of workflow info dictionaries
-
-        """
-        if not self._auto_discovered:
-            self.auto_discover()
-
-        results = []
-        for plugin_name, plugin in self._plugins.items():
-            metadata = plugin.get_metadata()
-            if metadata.domain == domain:
-                for workflow_id in plugin.list_workflows():
-                    info = plugin.get_workflow_info(workflow_id)
-                    if info:
-                        info["plugin"] = plugin_name
-                        results.append(info)
-
-        return results
-
-    def get_statistics(self) -> dict:
-        """Get registry statistics.
-
-        Returns:
-            Dictionary with counts and metadata
-
-        """
-        if not self._auto_discovered:
-            self.auto_discover()
-
-        total_workflows = sum(len(plugin.list_workflows()) for plugin in self._plugins.values())
-
-        # Count workflows by level
-        workflows_by_level = {}
-        for level in range(1, 6):
-            workflows_by_level[f"level_{level}"] = len(self.find_workflows_by_level(level))
-
-        return {
-            "total_plugins": len(self._plugins),
-            "total_workflows": total_workflows,
-            "plugins": [
-                {
-                    "name": name,
-                    "domain": plugin.get_metadata().domain,
-                    "version": plugin.get_metadata().version,
-                    "workflow_count": len(plugin.list_workflows()),
-                }
-                for name, plugin in self._plugins.items()
-            ],
-            "workflows_by_level": workflows_by_level,
-        }
-
-
-# Global registry instance
-_global_registry: PluginRegistry | None = None
-
-
-def get_global_registry() -> PluginRegistry:
-    """Get the global plugin registry instance (singleton).
-
-    Returns:
-        Global PluginRegistry instance
-
-    """
-    global _global_registry
-    if _global_registry is None:
-        _global_registry = PluginRegistry()
-        _global_registry.auto_discover()
-    return _global_registry

empathy_os/project_index/__init__.py

@@ -1,32 +0,0 @@
-"""Project Index - Codebase Intelligence Layer
-
-Tracks metadata about all files in a project to enable:
-- Test coverage gap analysis
-- Staleness detection (code changed, tests didn't)
-- Dependency mapping
-- Project health reports
-- Workflow intelligence
-
-Storage:
-- Primary: .empathy/project_index.json
-- Real-time: Redis (when short-term memory enabled)
-
-Copyright 2025 Smart AI Memory, LLC
-Licensed under Fair Source 0.9
-"""
-
-from .index import ProjectIndex
-from .models import FileRecord, IndexConfig, ProjectSummary
-from .reports import ReportGenerator
-from .scanner import ProjectScanner
-from .scanner_parallel import ParallelProjectScanner
-
-__all__ = [
-    "FileRecord",
-    "IndexConfig",
-    "ParallelProjectScanner",
-    "ProjectIndex",
-    "ProjectScanner",
-    "ProjectSummary",
-    "ReportGenerator",
-]

empathy_os/project_index/cli.py

@@ -1,335 +0,0 @@
-"""CLI for Project Index
-
-Commands for generating, querying, and reporting on the project index.
-
-Usage:
-    python -m empathy_os.project_index.cli refresh
-    python -m empathy_os.project_index.cli report health
-    python -m empathy_os.project_index.cli query needing_tests
-    python -m empathy_os.project_index.cli summary
-
-Copyright 2025 Smart AI Memory, LLC
-Licensed under Fair Source 0.9
-"""
-
-import argparse
-import json
-import sys
-from pathlib import Path
-
-from .index import ProjectIndex
-from .reports import ReportGenerator
-
-
-def main() -> int:
-    """Main CLI entry point."""
-    parser = argparse.ArgumentParser(
-        description="Project Index - Codebase Intelligence",
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-        epilog="""
-Examples:
-    # Generate/refresh the index
-    python -m empathy_os.project_index.cli refresh
-
-    # View project summary
-    python -m empathy_os.project_index.cli summary
-
-    # Generate health report
-    python -m empathy_os.project_index.cli report health
-
-    # Find files needing tests
-    python -m empathy_os.project_index.cli query needing_tests
-
-    # Find stale test files
-    python -m empathy_os.project_index.cli query stale
-        """,
-    )
-
-    parser.add_argument(
-        "--project",
-        "-p",
-        default=".",
-        help="Project root directory (default: current directory)",
-    )
-
-    parser.add_argument(
-        "--json",
-        "-j",
-        action="store_true",
-        help="Output in JSON format",
-    )
-
-    subparsers = parser.add_subparsers(dest="command", help="Command to run")
-
-    # refresh command
-    refresh_parser = subparsers.add_parser("refresh", help="Refresh the project index")
-    refresh_parser.add_argument(
-        "--force",
-        "-f",
-        action="store_true",
-        help="Force full re-scan even if index exists",
-    )
-
-    # summary command
-    subparsers.add_parser("summary", help="Show project summary")
-
-    # report command
-    report_parser = subparsers.add_parser("report", help="Generate a report")
-    report_parser.add_argument(
-        "report_type",
-        choices=["health", "test_gap", "staleness", "coverage", "sprint"],
-        help="Type of report to generate",
-    )
-    report_parser.add_argument(
-        "--markdown",
-        "-m",
-        action="store_true",
-        help="Output in markdown format",
-    )
-
-    # query command
-    query_parser = subparsers.add_parser("query", help="Query the index")
-    query_parser.add_argument(
-        "query_type",
-        choices=["needing_tests", "stale", "high_impact", "attention", "all"],
-        help="Type of query",
-    )
-    query_parser.add_argument(
-        "--limit",
-        "-l",
-        type=int,
-        default=20,
-        help="Maximum number of results",
-    )
-
-    # file command
-    file_parser = subparsers.add_parser("file", help="Get info about a specific file")
-    file_parser.add_argument("path", help="Path to the file")
-
-    args = parser.parse_args()
-
-    if not args.command:
-        parser.print_help()
-        return 1
-
-    # Initialize index
-    project_root = Path(args.project).resolve()
-    index = ProjectIndex(str(project_root))
-
-    # Execute command
-    if args.command == "refresh":
-        return cmd_refresh(index, args)
-    if args.command == "summary":
-        return cmd_summary(index, args)
-    if args.command == "report":
-        return cmd_report(index, args)
-    if args.command == "query":
-        return cmd_query(index, args)
-    if args.command == "file":
-        return cmd_file(index, args)
-
-    return 0
-
-
-def cmd_refresh(index: ProjectIndex, args: argparse.Namespace) -> int:
-    """Refresh the index."""
-    print(f"Refreshing index for: {index.project_root}")
-    print()
-
-    index.refresh()
-
-    summary = index.get_summary()
-
-    print("Index refreshed successfully!")
-    print(f"  Files indexed: {summary.total_files}")
-    print(f"  Source files: {summary.source_files}")
-    print(f"  Test files: {summary.test_files}")
-    print(f"  Files needing tests: {summary.files_without_tests}")
-    print(f"  Files needing attention: {summary.files_needing_attention}")
-    print()
-    print(f"Index saved to: {index._index_path}")
-
-    return 0
-
-
-def cmd_summary(index: ProjectIndex, args: argparse.Namespace) -> int:
-    """Show project summary."""
-    if not index.load():
-        print("No index found. Run 'refresh' first.")
-        return 1
-
-    summary = index.get_summary()
-
-    if args.json:
-        print(json.dumps(summary.to_dict(), indent=2))
-        return 0
-
-    print("=" * 60)
-    print("PROJECT INDEX SUMMARY")
-    print("=" * 60)
-    print()
-    print("FILE COUNTS")
-    print(f"  Total files:     {summary.total_files}")
-    print(f"  Source files:    {summary.source_files}")
-    print(f"  Test files:      {summary.test_files}")
-    print(f"  Config files:    {summary.config_files}")
-    print(f"  Doc files:       {summary.doc_files}")
-    print()
-    print("TEST HEALTH")
-    print(f"  Files requiring tests: {summary.files_requiring_tests}")
-    print(f"  Files with tests:      {summary.files_with_tests}")
-    print(f"  Files WITHOUT tests:   {summary.files_without_tests}")
-    print(f"  Average coverage:      {summary.test_coverage_avg:.1f}%")
-    print(f"  Test-to-code ratio:    {summary.test_to_code_ratio:.2f}")
-    print()
-    print("ATTENTION NEEDED")
-    print(f"  Stale test count:      {summary.stale_file_count}")
-    print(f"  Files need attention:  {summary.files_needing_attention}")
-    print()
-
-    if summary.critical_untested_files:
-        print("CRITICAL UNTESTED FILES (high impact)")
-        for f in summary.critical_untested_files[:5]:
-            print(f"  - {f}")
-        print()
-
-    return 0
-
-
-def cmd_report(index: ProjectIndex, args: argparse.Namespace) -> int:
-    """Generate a report."""
-    if not index.load():
-        print("No index found. Run 'refresh' first.")
-        return 1
-
-    generator = ReportGenerator(index.get_summary(), index.get_all_files())
-
-    report_type = args.report_type
-    if report_type == "sprint":
-        report_type = "sprint_planning"
-
-    # Generate report
-    if args.markdown:
-        print(generator.to_markdown(report_type))
-    elif args.json:
-        if report_type == "health":
-            print(json.dumps(generator.health_report(), indent=2))
-        elif report_type == "test_gap":
-            print(json.dumps(generator.test_gap_report(), indent=2))
-        elif report_type == "staleness":
-            print(json.dumps(generator.staleness_report(), indent=2))
-        elif report_type == "coverage":
-            print(json.dumps(generator.coverage_report(), indent=2))
-        elif report_type == "sprint_planning":
-            print(json.dumps(generator.sprint_planning_report(), indent=2))
-    else:
-        # Human-readable format
-        print(generator.to_markdown(report_type))
-
-    return 0
-
-
-def cmd_query(index: ProjectIndex, args: argparse.Namespace) -> int:
-    """Query the index."""
-    if not index.load():
-        print("No index found. Run 'refresh' first.")
-        return 1
-
-    query_type = args.query_type
-    limit = args.limit
-
-    # Execute query
-    if query_type == "needing_tests":
-        files = index.get_files_needing_tests()[:limit]
-        title = "FILES NEEDING TESTS"
-    elif query_type == "stale":
-        files = index.get_stale_files()[:limit]
-        title = "STALE TEST FILES"
-    elif query_type == "high_impact":
-        files = index.get_high_impact_files()[:limit]
-        title = "HIGH IMPACT FILES"
-    elif query_type == "attention":
-        files = index.get_files_needing_attention()[:limit]
-        title = "FILES NEEDING ATTENTION"
-    elif query_type == "all":
-        files = index.get_all_files()[:limit]
-        title = "ALL FILES"
-    else:
-        files = []
-        title = "RESULTS"
-
-    if args.json:
-        print(json.dumps([f.to_dict() for f in files], indent=2))
-        return 0
-
-    print(f"\n{title} ({len(files)} results)")
-    print("=" * 60)
-
-    for f in files:
-        print(f"\n{f.path}")
-        print(f"  Category: {f.category.value}")
-        print(f"  Impact Score: {f.impact_score:.1f}")
-        print(f"  Has Tests: {f.tests_exist}")
-        print(f"  Coverage: {f.coverage_percent:.1f}%")
-        if f.is_stale:
-            print(f"  STALE: {f.staleness_days} days")
-        if f.attention_reasons:
-            print(f"  Attention: {', '.join(f.attention_reasons)}")
-
-    print()
-    return 0
-
-
-def cmd_file(index: ProjectIndex, args: argparse.Namespace) -> int:
-    """Get info about a specific file."""
-    if not index.load():
-        print("No index found. Run 'refresh' first.")
-        return 1
-
-    record = index.get_file(args.path)
-
-    if not record:
-        print(f"File not found in index: {args.path}")
-        return 1
-
-    if args.json:
-        print(json.dumps(record.to_dict(), indent=2))
-        return 0
-
-    print(f"\nFILE: {record.path}")
-    print("=" * 60)
-    print(f"  Name:         {record.name}")
-    print(f"  Category:     {record.category.value}")
-    print(f"  Language:     {record.language}")
-    print()
-    print("TESTING")
-    print(f"  Requires Tests: {record.test_requirement.value}")
-    print(f"  Has Tests:      {record.tests_exist}")
-    print(f"  Test File:      {record.test_file_path or 'None'}")
-    print(f"  Coverage:       {record.coverage_percent:.1f}%")
-    print(f"  Test Count:     {record.test_count}")
-    print()
-    print("METRICS")
-    print(f"  Lines of Code:  {record.lines_of_code}")
-    print(f"  Complexity:     {record.complexity_score:.1f}")
-    print(f"  Has Docstrings: {record.has_docstrings}")
-    print(f"  Has Type Hints: {record.has_type_hints}")
-    print()
-    print("DEPENDENCIES")
-    print(f"  Imports:        {record.import_count} modules")
-    print(f"  Imported By:    {record.imported_by_count} files")
-    print(f"  Impact Score:   {record.impact_score:.1f}")
-    print()
-    print("STATUS")
-    print(f"  Needs Attention: {record.needs_attention}")
-    if record.attention_reasons:
-        print(f"  Reasons:         {', '.join(record.attention_reasons)}")
-    if record.is_stale:
-        print(f"  STALE:           {record.staleness_days} days")
-    print()
-
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())