empathy-framework 2.4.0__py3-none-any.whl → 3.8.2__py3-none-any.whl

empathy_llm_toolkit/code_health.py

@@ -1,5 +1,4 @@
-"""
-Code Health Assistant Module
+"""Code Health Assistant Module
 
 A comprehensive system for running health checks, tracking trends,
 and auto-fixing common issues in codebases.
@@ -10,6 +9,7 @@ Licensed under Fair Source 0.9
 
 import asyncio
 import json
+import logging
 import shutil
 import subprocess
 from dataclasses import dataclass, field
@@ -18,6 +18,8 @@ from enum import Enum
 from pathlib import Path
 from typing import Any
 
+logger = logging.getLogger(__name__)
+
 
 class HealthStatus(Enum):
     """Health check result status."""
@@ -224,12 +226,12 @@ class HealthCheckRunner:
         project_root: str = ".",
         config: dict | None = None,
     ):
-        """
-        Initialize the health check runner.
+        """Initialize the health check runner.
 
         Args:
             project_root: Root directory of the project
             config: Configuration dictionary (uses defaults if not provided)
+
         """
         self.project_root = Path(project_root).resolve()
         self.config = {**DEFAULT_CONFIG, **(config or {})}
@@ -312,13 +314,23 @@ class HealthCheckRunner:
         handler,
         config: dict,
     ) -> CheckResult:
-        """Run a check handler asynchronously."""
+        """Run a check handler asynchronously.
+
+        This uses broad exception handling intentionally for graceful degradation.
+        Health checks are optional features - the system should continue even if some checks fail.
+
+        Note:
+            Full exception context is preserved via logger.exception() for debugging.
+        """
         start_time = datetime.now()
         try:
             result: CheckResult = await asyncio.to_thread(handler, config)
             result.duration_ms = int((datetime.now() - start_time).total_seconds() * 1000)
             return result
         except Exception as e:
+            # INTENTIONAL: Broad exception handler for graceful degradation of optional checks
+            # Full traceback preserved for debugging
+            logger.exception(f"Health check failed for {category.value}: {e}")
             return CheckResult(
                 category=category,
                 status=HealthStatus.ERROR,
@@ -345,6 +357,7 @@ class HealthCheckRunner:
             if tool == "ruff":
                 result = subprocess.run(
                     ["ruff", "check", "--output-format=json", str(self.project_root)],
+                    check=False,
                     capture_output=True,
                     text=True,
                     cwd=str(self.project_root),
@@ -364,12 +377,13 @@ class HealthCheckRunner:
                                 ),
                                 fixable=item.get("fix") is not None,
                                 fix_command="ruff check --fix" if item.get("fix") else None,
-                            )
+                            ),
                         )
             else:
                 # Fallback to flake8
                 result = subprocess.run(
                     ["flake8", "--format=json", str(self.project_root)],
+                    check=False,
                     capture_output=True,
                     text=True,
                     cwd=str(self.project_root),
@@ -389,7 +403,30 @@ class HealthCheckRunner:
                 details={"total_files_checked": len({i.file_path for i in issues}) or "all"},
             )
 
+        except json.JSONDecodeError as e:
+            # Tool output not in expected JSON format
+            logger.warning(f"Lint check JSON parse error ({tool}): {e}")
+            return CheckResult(
+                category=CheckCategory.LINT,
+                status=HealthStatus.ERROR,
+                score=0,
+                tool_used=tool,
+                details={"error": f"Failed to parse {tool} output: {e}"},
+            )
+        except subprocess.SubprocessError as e:
+            # Tool execution failed
+            logger.error(f"Lint check subprocess error ({tool}): {e}")
+            return CheckResult(
+                category=CheckCategory.LINT,
+                status=HealthStatus.ERROR,
+                score=0,
+                tool_used=tool,
+                details={"error": f"Failed to run {tool}: {e}"},
+            )
         except Exception as e:
+            # Unexpected errors - preserve full context for debugging
+            # INTENTIONAL: Broad handler for graceful degradation of optional check
+            logger.exception(f"Unexpected error in lint check ({tool}): {e}")
             return CheckResult(
                 category=CheckCategory.LINT,
                 status=HealthStatus.ERROR,
@@ -416,6 +453,7 @@ class HealthCheckRunner:
             if tool == "black":
                 result = subprocess.run(
                     ["black", "--check", "--diff", str(self.project_root)],
+                    check=False,
                     capture_output=True,
                     text=True,
                     cwd=str(self.project_root),
@@ -439,7 +477,7 @@ class HealthCheckRunner:
                                     severity="warning",
                                     fixable=True,
                                     fix_command=f"black {current_file}",
-                                )
+                                ),
                             )
 
                     # Also check stderr for files that would be reformatted
@@ -458,7 +496,7 @@ class HealthCheckRunner:
                                             severity="warning",
                                             fixable=True,
                                             fix_command=f"black {file_path}",
-                                        )
+                                        ),
                                     )
 
             score = max(0, 100 - len(issues) * 10)  # -10 per file
@@ -473,7 +511,20 @@ class HealthCheckRunner:
                 details={"files_need_formatting": len(issues)},
             )
 
+        except subprocess.SubprocessError as e:
+            # Tool execution failed
+            logger.error(f"Format check subprocess error ({tool}): {e}")
+            return CheckResult(
+                category=CheckCategory.FORMAT,
+                status=HealthStatus.ERROR,
+                score=0,
+                tool_used=tool,
+                details={"error": f"Failed to run {tool}: {e}"},
+            )
         except Exception as e:
+            # Unexpected errors - preserve full context for debugging
+            # INTENTIONAL: Broad handler for graceful degradation of optional check
+            logger.exception(f"Unexpected error in format check ({tool}): {e}")
             return CheckResult(
                 category=CheckCategory.FORMAT,
                 status=HealthStatus.ERROR,
@@ -500,6 +551,7 @@ class HealthCheckRunner:
             if tool == "pyright":
                 result = subprocess.run(
                     ["pyright", "--outputjson"],
+                    check=False,
                     capture_output=True,
                     text=True,
                     cwd=str(self.project_root),
@@ -519,7 +571,7 @@ class HealthCheckRunner:
                                     message=diag.get("message", ""),
                                     severity="error" if diag.get("severity") == 1 else "warning",
                                     fixable=False,
-                                )
+                                ),
                             )
                     except json.JSONDecodeError:
                         pass
@@ -527,6 +579,7 @@ class HealthCheckRunner:
             elif tool == "mypy":
                 result = subprocess.run(
                     ["mypy", "--show-error-codes", "--no-error-summary", str(self.project_root)],
+                    check=False,
                     capture_output=True,
                     text=True,
                     cwd=str(self.project_root),
@@ -546,7 +599,7 @@ class HealthCheckRunner:
                                         message=parts[3].strip() if len(parts) > 3 else "",
                                         severity="error",
                                         fixable=False,
-                                    )
+                                    ),
                                 )
 
             score = max(0, 100 - len(issues) * 10)  # -10 per type error
@@ -565,7 +618,30 @@ class HealthCheckRunner:
                 details={"type_errors": len(issues)},
             )
 
+        except json.JSONDecodeError as e:
+            # Tool output not in expected JSON format (pyright specific)
+            logger.warning(f"Type check JSON parse error ({tool}): {e}")
+            return CheckResult(
+                category=CheckCategory.TYPES,
+                status=HealthStatus.ERROR,
+                score=0,
+                tool_used=tool,
+                details={"error": f"Failed to parse {tool} output: {e}"},
+            )
+        except subprocess.SubprocessError as e:
+            # Tool execution failed
+            logger.error(f"Type check subprocess error ({tool}): {e}")
+            return CheckResult(
+                category=CheckCategory.TYPES,
+                status=HealthStatus.ERROR,
+                score=0,
+                tool_used=tool,
+                details={"error": f"Failed to run {tool}: {e}"},
+            )
         except Exception as e:
+            # Unexpected errors - preserve full context for debugging
+            # INTENTIONAL: Broad handler for graceful degradation of optional check
+            logger.exception(f"Unexpected error in type check ({tool}): {e}")
             return CheckResult(
                 category=CheckCategory.TYPES,
                 status=HealthStatus.ERROR,
@@ -590,6 +666,7 @@ class HealthCheckRunner:
         try:
             result = subprocess.run(
                 ["pytest", "--tb=no", "-q", "--co", "-q"],  # Collect only, quiet
+                check=False,
                 capture_output=True,
                 text=True,
                 cwd=str(self.project_root),
@@ -604,6 +681,7 @@ class HealthCheckRunner:
             # Run actual tests
             result = subprocess.run(
                 ["pytest", "--tb=short", "-q"],
+                check=False,
                 capture_output=True,
                 text=True,
                 cwd=str(self.project_root),
@@ -654,7 +732,7 @@ class HealthCheckRunner:
                                     message=f"Test failed: {test_path}",
                                     severity="error",
                                     fixable=False,
-                                )
+                                ),
                             )
 
             total = passed + failed
@@ -675,6 +753,8 @@ class HealthCheckRunner:
             )
 
         except subprocess.TimeoutExpired:
+            # Tests took too long - specific timeout error
+            logger.error(f"Test check timeout ({tool}): Tests took longer than 5 minutes")
             return CheckResult(
                 category=CheckCategory.TESTS,
                 status=HealthStatus.ERROR,
@@ -682,7 +762,20 @@ class HealthCheckRunner:
                 tool_used=tool,
                 details={"error": "Test suite timed out after 5 minutes"},
             )
+        except subprocess.SubprocessError as e:
+            # Tool execution failed
+            logger.error(f"Test check subprocess error ({tool}): {e}")
+            return CheckResult(
+                category=CheckCategory.TESTS,
+                status=HealthStatus.ERROR,
+                score=0,
+                tool_used=tool,
+                details={"error": f"Failed to run {tool}: {e}"},
+            )
         except Exception as e:
+            # Unexpected errors - preserve full context for debugging
+            # INTENTIONAL: Broad handler for graceful degradation of optional check
+            logger.exception(f"Unexpected error in test check ({tool}): {e}")
             return CheckResult(
                 category=CheckCategory.TESTS,
                 status=HealthStatus.ERROR,
@@ -708,6 +801,7 @@ class HealthCheckRunner:
         try:
             result = subprocess.run(
                 ["bandit", "-r", "-f", "json", str(self.project_root)],
+                check=False,
                 capture_output=True,
                 text=True,
                 cwd=str(self.project_root),
@@ -727,7 +821,7 @@ class HealthCheckRunner:
                                 message=item.get("issue_text", ""),
                                 severity="error" if severity in ["HIGH", "MEDIUM"] else "warning",
                                 fixable=False,
-                            )
+                            ),
                         )
                 except json.JSONDecodeError:
                     pass
@@ -754,7 +848,30 @@ class HealthCheckRunner:
                 },
             )
 
+        except json.JSONDecodeError as e:
+            # Tool output not in expected JSON format
+            logger.warning(f"Security check JSON parse error ({tool}): {e}")
+            return CheckResult(
+                category=CheckCategory.SECURITY,
+                status=HealthStatus.ERROR,
+                score=0,
+                tool_used=tool,
+                details={"error": f"Failed to parse {tool} output: {e}"},
+            )
+        except subprocess.SubprocessError as e:
+            # Tool execution failed
+            logger.error(f"Security check subprocess error ({tool}): {e}")
+            return CheckResult(
+                category=CheckCategory.SECURITY,
+                status=HealthStatus.ERROR,
+                score=0,
+                tool_used=tool,
+                details={"error": f"Failed to run {tool}: {e}"},
+            )
         except Exception as e:
+            # Unexpected errors - preserve full context for debugging
+            # INTENTIONAL: Broad handler for graceful degradation of optional check
+            logger.exception(f"Unexpected error in security check ({tool}): {e}")
             return CheckResult(
                 category=CheckCategory.SECURITY,
                 status=HealthStatus.ERROR,
@@ -780,6 +897,7 @@ class HealthCheckRunner:
         try:
             result = subprocess.run(
                 ["pip-audit", "--format=json"],
+                check=False,
                 capture_output=True,
                 text=True,
                 cwd=str(self.project_root),
@@ -795,15 +913,11 @@ class HealthCheckRunner:
                                 file_path="requirements.txt",
                                 line=None,
                                 code=item.get("id", "VULN"),
-                                message=f"{item.get('name')}: {item.get('description', 'Vulnerability found')}",
+                                message=f"{item.get('name')}: {item.get('description', 'Vuln')}",
                                 severity="error" if item.get("fix_versions") else "warning",
                                 fixable=bool(item.get("fix_versions")),
-                                fix_command=(
-                                    f"pip install {item.get('name')}=={item.get('fix_versions', ['latest'])[0]}"
-                                    if item.get("fix_versions")
-                                    else None
-                                ),
-                            )
+                                fix_command=self._get_fix_cmd(item),
+                            ),
                         )
                 except json.JSONDecodeError:
                     pass
@@ -820,7 +934,30 @@ class HealthCheckRunner:
                 details={"vulnerable_packages": len(issues)},
             )
 
+        except json.JSONDecodeError as e:
+            # Tool output not in expected JSON format
+            logger.warning(f"Dependency check JSON parse error ({tool}): {e}")
+            return CheckResult(
+                category=CheckCategory.DEPS,
+                status=HealthStatus.ERROR,
+                score=0,
+                tool_used=tool,
+                details={"error": f"Failed to parse {tool} output: {e}"},
+            )
+        except subprocess.SubprocessError as e:
+            # Tool execution failed
+            logger.error(f"Dependency check subprocess error ({tool}): {e}")
+            return CheckResult(
+                category=CheckCategory.DEPS,
+                status=HealthStatus.ERROR,
+                score=0,
+                tool_used=tool,
+                details={"error": f"Failed to run {tool}: {e}"},
+            )
         except Exception as e:
+            # Unexpected errors - preserve full context for debugging
+            # INTENTIONAL: Broad handler for graceful degradation of optional check
+            logger.exception(f"Unexpected error in dependency check ({tool}): {e}")
             return CheckResult(
                 category=CheckCategory.DEPS,
                 status=HealthStatus.ERROR,
@@ -829,6 +966,13 @@ class HealthCheckRunner:
                 details={"error": str(e)},
             )
 
+    def _get_fix_cmd(self, item: dict) -> str | None:
+        """Get pip install command to fix a vulnerable package."""
+        fix_versions = item.get("fix_versions")
+        if fix_versions:
+            return f"pip install {item.get('name')}=={fix_versions[0]}"
+        return None
+
 
 class AutoFixer:
     """Apply automatic fixes to code health issues."""
@@ -852,7 +996,7 @@ class AutoFixer:
                             "issue": issue.message,
                             "fix_command": issue.fix_command,
                             "safe": self._is_safe_fix(issue),
-                        }
+                        },
                     )
         return fixes
 
@@ -909,7 +1053,14 @@ class AutoFixer:
         return results
 
     async def _apply_fix(self, issue: HealthIssue) -> bool:
-        """Apply a single fix."""
+        """Apply a single fix.
+
+        This uses broad exception handling intentionally for graceful degradation.
+        Auto-fixes are optional - the system should continue even if some fixes fail.
+
+        Note:
+            Full exception context is preserved via logger.exception() for debugging.
+        """
         if not issue.fix_command:
             return False
 
@@ -921,7 +1072,14 @@ class AutoFixer:
                 text=True,
             )
             return result.returncode == 0
-        except Exception:
+        except subprocess.SubprocessError as e:
+            # Fix command execution failed
+            logger.error(f"Auto-fix subprocess error for {issue.file_path}: {e}")
+            return False
+        except Exception as e:
+            # Unexpected errors - preserve full context for debugging
+            # INTENTIONAL: Broad handler for graceful degradation of optional auto-fix
+            logger.exception(f"Unexpected error applying fix to {issue.file_path}: {e}")
             return False
 
 
@@ -955,7 +1113,7 @@ class HealthTrendTracker:
                 "status": report.status.value,
                 "total_issues": report.total_issues,
                 "results": {r.category.value: r.score for r in report.results},
-            }
+            },
         )
 
         filepath.write_text(json.dumps(history, indent=2))
@@ -986,7 +1144,7 @@ class HealthTrendTracker:
                             {
                                 "date": date,
                                 "score": entry.get("overall_score", 0),
-                            }
+                            },
                         )
                 except json.JSONDecodeError:
                     pass
@@ -1040,13 +1198,13 @@ def format_health_output(
     level: int = 1,
     thresholds: dict | None = None,
 ) -> str:
-    """
-    Format health report for display.
+    """Format health report for display.
 
     Args:
         report: The health report to format
         level: Detail level (1=summary, 2=details, 3=full)
         thresholds: Score thresholds for status icons
+
     """
     thresholds = thresholds or DEFAULT_THRESHOLDS
     lines = []
@@ -1083,7 +1241,7 @@ def format_health_output(
         if result.category == CheckCategory.TESTS:
             details = result.details
             lines.append(
-                f"{icon} {category_name}: {details.get('passed', 0)} passed, {details.get('failed', 0)} failed"
+                f"{icon} {category_name}: {details.get('passed', 0)}P/{details.get('failed', 0)}F",
             )
         elif result.category == CheckCategory.LINT:
             lines.append(f"{icon} {category_name}: {result.issue_count} warnings")
@@ -1149,7 +1307,7 @@ def format_health_output(
         lines.append("")
         lines.append("━" * 40)
         lines.append(
-            f"[1] Fix {report.total_fixable} auto-fixable issues  [2] See details  [3] Full report"
+            f"[1] Fix {report.total_fixable} auto-fixable issues  [2] See details  [3] Full report",
         )
 
     return "\n".join(lines)

empathy_llm_toolkit/config/__init__.py

@@ -0,0 +1,29 @@
+"""Empathy Framework Configuration Module
+
+Provides unified configuration models for agents, wizards, and workflows.
+
+Copyright 2025 Smart-AI-Memory
+Licensed under Fair Source License 0.9
+"""
+
+from empathy_llm_toolkit.config.unified import (
+                                                AgentOperationError,
+                                                BookProductionConfig,
+                                                MemDocsConfig,
+                                                ModelTier,
+                                                Provider,
+                                                RedisConfig,
+                                                UnifiedAgentConfig,
+                                                WorkflowMode,
+)
+
+__all__ = [
+    "AgentOperationError",
+    "BookProductionConfig",
+    "MemDocsConfig",
+    "ModelTier",
+    "Provider",
+    "RedisConfig",
+    "UnifiedAgentConfig",
+    "WorkflowMode",
+]