refactor: Improve type hints and MyPy configuration

silversurfer562 · claude · silversurfer562 · commit 126c61f9d4eb · 2026-01-09T00:53:51.000-05:00
- Add explicit type hints to adapters and wizards for better type safety
- Update MyPy configuration to exclude non-production directories
- Update learned patterns from recent workflow executions

Changes:
- Code inspection adapters: Add type annotations to findings lists
- Wizard modules: Improve type hints across debugging, performance, and security wizards
- pyproject.toml: Exclude build/, backend/, scripts/, docs/, and archived directories from MyPy
- patterns/: Update debugging patterns and health check memory data

Co-Authored-By: Claude Sonnet 4.5 &lt;noreply@anthropic.com&gt;
diff --git a/agents/code_inspection/adapters/code_health_adapter.py b/agents/code_inspection/adapters/code_health_adapter.py
@@ -59,7 +59,7 @@ async def analyze(self) -> ToolResult:
             report = await runner.run_all()
 
             # Convert findings to unified format
-            findings = []
+            findings: list[dict[str, Any]] = []
             findings_by_severity: dict[str, int] = {
                 "critical": 0,
                 "high": 0,
diff --git a/agents/code_inspection/adapters/code_review_adapter.py b/agents/code_inspection/adapters/code_review_adapter.py
@@ -151,7 +151,7 @@ async def analyze(
             report = await wizard.analyze(context)
 
             # Convert findings to unified format
-            findings = []
+            findings: list[dict[str, Any]] = []
             findings_by_severity: dict[str, int] = {
                 "critical": 0,
                 "high": 0,
diff --git a/agents/code_inspection/adapters/debugging_adapter.py b/agents/code_inspection/adapters/debugging_adapter.py
@@ -51,7 +51,7 @@ async def analyze_memory_enhanced(self) -> ToolResult:
 
         start_time = time.time()
 
-        findings = []
+        findings: list[dict[str, Any]] = []
         findings_by_severity: dict[str, int] = {
             "critical": 0,
             "high": 0,
@@ -161,7 +161,7 @@ async def analyze_advanced(self) -> ToolResult:
             )
 
             # Convert to unified format
-            findings = []
+            findings: list[dict[str, Any]] = []
             findings_by_severity: dict[str, int] = {
                 "critical": 0,
                 "high": 0,
diff --git a/agents/code_inspection/adapters/security_adapter.py b/agents/code_inspection/adapters/security_adapter.py
@@ -59,7 +59,7 @@ async def analyze(self) -> ToolResult:
             scanner = VulnerabilityScanner()
 
             # Collect all findings
-            findings = []
+            findings: list[dict[str, Any]] = []
             findings_by_severity: dict[str, int] = {
                 "critical": 0,
                 "high": 0,
diff --git a/agents/code_inspection/adapters/tech_debt_adapter.py b/agents/code_inspection/adapters/tech_debt_adapter.py
@@ -62,7 +62,7 @@ async def analyze(self) -> ToolResult:
             )
 
             # Convert findings to unified format
-            findings = []
+            findings: list[dict[str, Any]] = []
             findings_by_severity: dict[str, int] = {
                 "critical": 0,
                 "high": 0,
@@ -143,7 +143,7 @@ async def _fallback_analyze(self, start_time: float) -> ToolResult:
             "XXX": re.compile(r"#\s*XXX[:\s](.*)$", re.IGNORECASE | re.MULTILINE),
         }
 
-        findings = []
+        findings: list[dict[str, Any]] = []
         findings_by_severity: dict[str, int] = {
             "critical": 0,
             "high": 0,
diff --git a/agents/code_inspection/adapters/test_quality_adapter.py b/agents/code_inspection/adapters/test_quality_adapter.py
@@ -54,7 +54,7 @@ async def analyze(self) -> ToolResult:
             analyzer = TestQualityAnalyzer()
 
             # Collect all findings
-            findings = []
+            findings: list[dict[str, Any]] = []
             findings_by_severity: dict[str, int] = {
                 "critical": 0,
                 "high": 0,
diff --git a/agents/code_inspection/nodes/dynamic_analysis.py b/agents/code_inspection/nodes/dynamic_analysis.py
@@ -15,6 +15,7 @@
 import asyncio
 import logging
 from datetime import datetime
+from typing import Any
 
 from ..adapters import CodeReviewAdapter, DebuggingAdapter
 from ..state import CodeInspectionState, InspectionPhase, add_audit_entry
@@ -41,7 +42,7 @@ async def run_dynamic_analysis(state: CodeInspectionState) -> CodeInspectionStat
     enabled_tools = state["enabled_tools"]
 
     # Get security context from Phase 1 for informed review
-    security_context = []
+    security_context: list[dict[str, Any]] = []
     if state.get("security_scan_result"):
         security_context = state["security_scan_result"].get("findings", [])
 
diff --git a/empathy_software_plugin/wizards/advanced_debugging_wizard.py b/empathy_software_plugin/wizards/advanced_debugging_wizard.py
@@ -47,8 +47,8 @@ def __init__(self):
         super().__init__()
         self.bug_analyzer = BugRiskAnalyzer()
         self.pattern_library = get_pattern_library()
-        self._name = "Advanced Debugging Wizard"
-        self._level = 4
+        self._name: str = "Advanced Debugging Wizard"
+        self._level: int = 4
 
     @property
     def name(self) -> str:
@@ -126,7 +126,8 @@ async def analyze(self, context: dict[str, Any]) -> dict[str, Any]:
         # Phase 4: Group by fixability
         fixability_by_linter = {}
         for linter_name, result in linter_results.items():
-            fixability = group_issues_by_fixability(linter_name, result["issues"])
+            issues_for_fixability: list[LintIssue] = result["issues"]  # type: ignore[assignment]
+            fixability = group_issues_by_fixability(linter_name, issues_for_fixability)
             fixability_by_linter[linter_name] = {
                 "auto_fixable": len(fixability["auto_fixable"]),
                 "manual": len(fixability["manual"]),
@@ -138,7 +139,8 @@ async def analyze(self, context: dict[str, Any]) -> dict[str, Any]:
             logger.info("Applying auto-fixes...")
 
             for linter_name, result in linter_results.items():
-                fixes = apply_fixes(linter_name, result["issues"], dry_run=False, auto_only=True)
+                issues_for_fixing: list[LintIssue] = result["issues"]  # type: ignore[assignment]
+                fixes = apply_fixes(linter_name, issues_for_fixing, dry_run=False, auto_only=True)
 
                 successful = [f for f in fixes if f.success]
                 failed = [f for f in fixes if not f.success]
@@ -155,7 +157,8 @@ async def analyze(self, context: dict[str, Any]) -> dict[str, Any]:
             logger.info("Verifying fixes...")
 
             for linter_name, result in linter_results.items():
-                verification = verify_fixes(linter_name, project_path, result["issues"])
+                issues_for_verification: list[LintIssue] = result["issues"]  # type: ignore[assignment]
+                verification = verify_fixes(linter_name, project_path, issues_for_verification)
 
                 verification_results[linter_name] = verification.to_dict()
 
@@ -201,7 +204,7 @@ def _generate_cross_language_insights(self, issues: list[LintIssue]) -> list[dic
         insights = []
 
         # Group issues by language
-        by_language = {}
+        by_language: dict[str, list[LintIssue]] = {}
         for issue in issues:
             lang = issue.linter
             if lang not in by_language:
diff --git a/empathy_software_plugin/wizards/debugging/bug_risk_analyzer.py b/empathy_software_plugin/wizards/debugging/bug_risk_analyzer.py
@@ -335,7 +335,7 @@ def generate_summary(self, assessments: list[RiskAssessment]) -> dict[str, Any]:
         This is the Level 4 alert format.
         """
         # Count by risk level
-        by_risk = {
+        by_risk: dict[BugRisk, list[RiskAssessment]] = {
             BugRisk.CRITICAL: [],
             BugRisk.HIGH: [],
             BugRisk.MEDIUM: [],
diff --git a/empathy_software_plugin/wizards/debugging/config_loaders.py b/empathy_software_plugin/wizards/debugging/config_loaders.py
@@ -246,15 +246,19 @@ def _load_pyproject(self, path: Path) -> LintConfig:
         """Load from pyproject.toml"""
         try:
             import tomli
+
+            toml_loader = tomli
         except ImportError:
             # Fallback for Python 3.11+
             try:
-                import tomllib as tomli
+                import tomllib
+
+                toml_loader = tomllib
             except ImportError as e:
                 raise ImportError("tomli or tomllib required for pyproject.toml") from e
 
         with open(path, "rb") as f:
-            data = tomli.load(f)
+            data = toml_loader.load(f)
 
         pylint_config = data.get("tool", {}).get("pylint", {})
 
diff --git a/empathy_software_plugin/wizards/debugging/language_patterns.py b/empathy_software_plugin/wizards/debugging/language_patterns.py
@@ -278,6 +278,7 @@ def find_pattern_for_rule(self, linter: str, rule: str) -> UniversalPattern | No
             UniversalPattern if found, None otherwise
 
         """
+        pattern: UniversalPattern
         for pattern in self.patterns.values():
             if linter in pattern.language_manifestations:
                 if pattern.language_manifestations[linter] == rule:
@@ -295,11 +296,12 @@ def get_fix_strategy(self, pattern_name: str, language: str) -> list[str] | None
             List of fix steps, or None if not found
 
         """
-        pattern = self.patterns.get(pattern_name)
+        pattern: UniversalPattern | None = self.patterns.get(pattern_name)
         if not pattern:
             return None
 
-        return pattern.language_specific_fixes.get(language)
+        result: list[str] | None = pattern.language_specific_fixes.get(language)
+        return result
 
     def suggest_cross_language_insight(
         self,
diff --git a/empathy_software_plugin/wizards/debugging/linter_parsers.py b/empathy_software_plugin/wizards/debugging/linter_parsers.py
@@ -360,7 +360,7 @@ def parse(self, output: str, format: str = "auto") -> list[LintIssue]:
 
         # Pattern: warning: unused variable: `x`
         #   --> src/main.rs:5:9
-        current_issue = {}
+        current_issue: dict[str, Any] = {}
 
         for line in output.split("\n"):
             # Check for severity line
diff --git a/empathy_software_plugin/wizards/performance/profiler_parsers.py b/empathy_software_plugin/wizards/performance/profiler_parsers.py
@@ -167,20 +167,20 @@ def parse(self, data: str) -> list[FunctionProfile]:
                     function_times[name]["call_count"] += 1
 
             # Convert to FunctionProfile
-            total_time = sum(data["total_time"] for data in function_times.values())
+            total_time = sum(stats["total_time"] for stats in function_times.values())
 
-            for func_name, data in function_times.items():
+            for func_name, stats in function_times.items():
                 profiles.append(
                     FunctionProfile(
                         function_name=func_name,
                         file_path="",  # Chrome doesn't always provide
                         line_number=0,
-                        total_time=data["total_time"],
-                        self_time=data["total_time"],
-                        call_count=data["call_count"],
-                        cumulative_time=data["total_time"],
+                        total_time=stats["total_time"],
+                        self_time=stats["total_time"],
+                        call_count=stats["call_count"],
+                        cumulative_time=stats["total_time"],
                         percent_total=(
-                            (data["total_time"] / total_time * 100) if total_time > 0 else 0
+                            (stats["total_time"] / total_time * 100) if total_time > 0 else 0
                         ),
                         profiler=self.profiler_name,
                     ),
diff --git a/empathy_software_plugin/wizards/security/vulnerability_scanner.py b/empathy_software_plugin/wizards/security/vulnerability_scanner.py
@@ -225,7 +225,7 @@ def _scan_for_secrets(
         lines: list[str],
     ) -> list[Vulnerability]:
         """Scan for hardcoded secrets"""
-        vulnerabilities = []
+        vulnerabilities: list[Vulnerability] = []
 
         # Skip certain file types
         if file_path.suffix in [".md", ".txt", ".json", ".xml"]:
diff --git a/empathy_software_plugin/wizards/security_analysis_wizard.py b/empathy_software_plugin/wizards/security_analysis_wizard.py
@@ -168,10 +168,10 @@ def _group_by_severity(self, vulnerabilities: list[dict[str, Any]]) -> dict[str,
 
     def _group_by_category(self, vulnerabilities: list[dict[str, Any]]) -> dict[str, int]:
         """Group vulnerabilities by OWASP category"""
-        by_category = {}
+        by_category: dict[str, int] = {}
 
         for vuln in vulnerabilities:
-            category = vuln.get("category", "unknown")
+            category: str = str(vuln.get("category", "unknown"))
             by_category[category] = by_category.get(category, 0) + 1
 
         return by_category
diff --git a/patterns/debugging/all_patterns.json b/patterns/debugging/all_patterns.json
diff --git a/patterns/health_check_memory.json b/patterns/health_check_memory.json
diff --git a/pyproject.toml b/pyproject.toml
