Merge pull request #27 from BruinGrowly/claude/reca-implementation-011CV1d52gvgXZqoYNqR66kt

Guardian self-healing: Auto-format entire codebase with black

Author: BruinGrowly

guardian/advanced/gap_analyzer.py

@@ -30,8 +30,9 @@ def __init__(self, vocab_manager: VocabularyManager):
         self.entity_database = {}
         self.analysis_history = []
 
-    def analyze_entity_posture(self, entity_name: str, entity_type: str,
-                             recent_actions: str, historical_context: str = "") -> Dict:
+    def analyze_entity_posture(
+        self, entity_name: str, entity_type: str, recent_actions: str, historical_context: str = ""
+    ) -> Dict:
         """
         Analyze geopolitical entity posture
 
@@ -48,13 +49,12 @@ def analyze_entity_posture(self, entity_name: str, entity_type: str,
         recent_coords = self.vocab.analyze_concept(recent_actions)
 
         # Analyze historical context if provided
-        historical_coords = (self.vocab.analyze_concept(historical_context)
-                           if historical_context else Coordinates(0, 0, 0, 0))
+        historical_coords = (
+            self.vocab.analyze_concept(historical_context) if historical_context else Coordinates(0, 0, 0, 0)
+        )
 
         # Combine analyses (recent weighted higher)
-        combined_coords = self._calculate_weighted_average(
-            [recent_coords, historical_coords], [0.7, 0.3]
-        )
+        combined_coords = self._calculate_weighted_average([recent_coords, historical_coords], [0.7, 0.3])
 
         result = self._determine_posture_type(combined_coords, entity_name, entity_type)
 
@@ -64,8 +64,7 @@ def analyze_entity_posture(self, entity_name: str, entity_type: str,
 
         return result
 
-    def _calculate_weighted_average(self, coords_list: List[Coordinates],
-                                   weights: List[float]) -> Coordinates:
+    def _calculate_weighted_average(self, coords_list: List[Coordinates], weights: List[float]) -> Coordinates:
         """Calculate weighted average coordinates"""
         if not coords_list:
             return Coordinates(0, 0, 0, 0)
@@ -86,11 +85,10 @@ def _calculate_weighted_average(self, coords_list: List[Coordinates],
             love=weighted_love / total_weight,
             justice=weighted_justice / total_weight,
             power=weighted_power / total_weight,
-            wisdom=weighted_wisdom / total_weight
+            wisdom=weighted_wisdom / total_weight,
         )
 
-    def _determine_posture_type(self, coords: Coordinates, entity_name: str,
-                               entity_type: str) -> Dict:
+    def _determine_posture_type(self, coords: Coordinates, entity_name: str, entity_type: str) -> Dict:
         """Determine geopolitical posture type based on coordinates"""
         distance = self.vocab.get_distance_from_anchor(coords)
         clarity = self.vocab.get_semantic_clarity(coords)
@@ -151,7 +149,7 @@ def _determine_posture_type(self, coords: Coordinates, entity_name: str,
             "stability_indicator": 1.0 / distance if distance > 0 else 0,
             "cooperation_level": coords.love + coords.justice if distance < 2.0 else 0,
             "aggression_level": coords.power if distance > 2.0 else 0,
-            "wisdom_level": coords.wisdom if distance < 2.0 else 0
+            "wisdom_level": coords.wisdom if distance < 2.0 else 0,
         }
 
     def analyze_global_dynamics(self, entity_results: List[Dict]) -> Dict:
@@ -183,11 +181,9 @@ def analyze_global_dynamics(self, entity_results: List[Dict]) -> Dict:
         avg_stability = total_stability / len(entity_results)
 
         # Determine global trend
-        global_stability_trend = ("improving" if avg_stability > 0.7 else
-                                "stable" if avg_stability > 0.4 else "volatile")
+        global_stability_trend = "improving" if avg_stability > 0.7 else "stable" if avg_stability > 0.4 else "volatile"
 
-        logger.info(f"Global dynamics analysis: {len(entity_results)} entities, "
-                   f"trend={global_stability_trend}")
+        logger.info(f"Global dynamics analysis: {len(entity_results)} entities, " f"trend={global_stability_trend}")
 
         return {
             "status": "Analysis Complete",
@@ -197,8 +193,8 @@ def analyze_global_dynamics(self, entity_results: List[Dict]) -> Dict:
                 "global_trend": global_stability_trend,
                 "total_cooperation": total_cooperation / len(entity_results),
                 "total_aggression": total_aggression / len(entity_results),
-                "total_wisdom": total_wisdom / len(entity_results)
+                "total_wisdom": total_wisdom / len(entity_results),
             },
             "posture_distribution": posture_distribution,
-            "global_stability_indicator": avg_stability
+            "global_stability_indicator": avg_stability,
         }

guardian/analyzers/geopolitical.py

@@ -28,10 +28,9 @@ def __init__(self, vocab_manager: VocabularyManager):
         """
         self.vocab = vocab_manager
 
-    def analyze_comprehensive_ice(self, concept: str,
-                                 intent_words: List[str],
-                                 context_words: List[str],
-                                 execution_words: List[str]) -> Dict:
+    def analyze_comprehensive_ice(
+        self, concept: str, intent_words: List[str], context_words: List[str], execution_words: List[str]
+    ) -> Dict:
         """
         Comprehensive ICE analysis
 
@@ -45,9 +44,9 @@ def analyze_comprehensive_ice(self, concept: str,
             Dictionary with ICE analysis results
         """
         # Analyze individual components
-        intent_coords = self.vocab.analyze_concept(' '.join(intent_words))
-        context_coords = self.vocab.analyze_concept(' '.join(context_words))
-        execution_coords = self.vocab.analyze_concept(' '.join(execution_words))
+        intent_coords = self.vocab.analyze_concept(" ".join(intent_words))
+        context_coords = self.vocab.analyze_concept(" ".join(context_words))
+        execution_coords = self.vocab.analyze_concept(" ".join(execution_words))
 
         # Analyze overall concept
         all_coords = [intent_coords, context_coords, execution_coords]
@@ -69,42 +68,44 @@ def analyze_comprehensive_ice(self, concept: str,
         # Calculate benevolence score
         benevolence_score = (execution_coords.love + context_coords.love) / 2
 
-        logger.debug(f"ICE analysis for '{concept}': balance={ice_balance:.3f}, "
-                    f"coherence={ice_coherence:.3f}")
+        logger.debug(f"ICE analysis for '{concept}': balance={ice_balance:.3f}, " f"coherence={ice_coherence:.3f}")
 
         return {
             "concept": concept,
             "ice_components": {
                 "intent": {
                     "coordinates": intent_coords,
                     "distance_from_anchor": intent_distance,
-                    "clarity": self.vocab.get_semantic_clarity(intent_coords)
+                    "clarity": self.vocab.get_semantic_clarity(intent_coords),
                 },
                 "context": {
                     "coordinates": context_coords,
                     "distance_from_anchor": context_distance,
-                    "clarity": self.vocab.get_semantic_clarity(context_coords)
+                    "clarity": self.vocab.get_semantic_clarity(context_coords),
                 },
                 "execution": {
                     "coordinates": execution_coords,
                     "distance_from_anchor": execution_distance,
-                    "clarity": self.vocab.get_semantic_clarity(execution_coords)
+                    "clarity": self.vocab.get_semantic_clarity(execution_coords),
                 },
                 "overall": {
                     "coordinates": overall_coords,
                     "combined_distance": (intent_distance + context_distance + execution_distance) / 3,
-                    "combined_clarity": (self.vocab.get_semantic_clarity(intent_coords) +
-                                       self.vocab.get_semantic_clarity(context_coords) +
-                                       self.vocab.get_semantic_clarity(execution_coords)) / 3
-                }
+                    "combined_clarity": (
+                        self.vocab.get_semantic_clarity(intent_coords)
+                        + self.vocab.get_semantic_clarity(context_coords)
+                        + self.vocab.get_semantic_clarity(execution_coords)
+                    )
+                    / 3,
+                },
             },
             "ice_metrics": {
                 "ice_balance": ice_balance,
                 "ice_coherence": ice_coherence,
-                "benevolence_score": benevolence_score
+                "benevolence_score": benevolence_score,
             },
             "ice_harmony_level": self._determine_ice_harmony_level(ice_balance),
-            "is_ice_aligned": ice_balance > 0.8
+            "is_ice_aligned": ice_balance > 0.8,
         }
 
     def _determine_ice_harmony_level(self, ice_balance: float) -> str:
@@ -128,8 +129,7 @@ def _determine_ice_harmony_level(self, ice_balance: float) -> str:
         else:
             return "POOR_ICE_BALANCE"
 
-    def _calculate_weighted_average(self, coords_list: List[Coordinates],
-                                   weights: List[float]) -> Coordinates:
+    def _calculate_weighted_average(self, coords_list: List[Coordinates], weights: List[float]) -> Coordinates:
         """
         Calculate weighted average coordinates
 
@@ -160,5 +160,5 @@ def _calculate_weighted_average(self, coords_list: List[Coordinates],
             love=weighted_love / total_weight,
             justice=weighted_justice / total_weight,
             power=weighted_power / total_weight,
-            wisdom=weighted_wisdom / total_weight
+            wisdom=weighted_wisdom / total_weight,
         )

guardian/analyzers/ice.py

@@ -48,8 +48,7 @@ def infer_unknown_meaning(self, unknown_word: str, context_words: List[str]) ->
         coords_list = [self.vocab.analyze_concept(word) for word in context_words]
 
         # Filter out zero coordinates
-        coords_list = [c for c in coords_list
-                      if c.love + c.justice + c.power + c.wisdom > 0]
+        coords_list = [c for c in coords_list if c.love + c.justice + c.power + c.wisdom > 0]
 
         if not coords_list:
             logger.warning(f"No valid coordinates in context for '{unknown_word}'")
@@ -62,15 +61,15 @@ def infer_unknown_meaning(self, unknown_word: str, context_words: List[str]) ->
         centroid_wisdom = sum(c.wisdom for c in coords_list) / len(coords_list)
 
         # Find closest concept to centroid
-        min_distance = float('inf')
+        min_distance = float("inf")
         closest_concept_index = 0
 
         for i, coords in enumerate(coords_list):
             distance = math.sqrt(
-                (coords.love - centroid_love) ** 2 +
-                (coords.justice - centroid_justice) ** 2 +
-                (coords.power - centroid_power) ** 2 +
-                (coords.wisdom - centroid_wisdom) ** 2
+                (coords.love - centroid_love) ** 2
+                + (coords.justice - centroid_justice) ** 2
+                + (coords.power - centroid_power) ** 2
+                + (coords.wisdom - centroid_wisdom) ** 2
             )
 
             if distance < min_distance:
@@ -82,16 +81,18 @@ def infer_unknown_meaning(self, unknown_word: str, context_words: List[str]) ->
         # Calculate confidence (inverse of distance, clamped to [0, 1])
         confidence = max(0.0, min(1.0, 1.0 - min_distance))
 
-        logger.info(f"Inferred meaning for '{unknown_word}' from {len(context_words)} "
-                   f"context words, confidence={confidence:.3f}")
+        logger.info(
+            f"Inferred meaning for '{unknown_word}' from {len(context_words)} "
+            f"context words, confidence={confidence:.3f}"
+        )
 
         return SemanticResult(
             coordinates=closest_concept_coords,
             distance_from_anchor=self.vocab.get_distance_from_anchor(closest_concept_coords),
             semantic_clarity=self.vocab.get_semantic_clarity(closest_concept_coords),
             concept_count=len(context_words),
             confidence=confidence,
-            closest_concept=context_words[closest_concept_index]
+            closest_concept=context_words[closest_concept_index],
         )
 
     def _empty_result(self) -> SemanticResult:
@@ -101,5 +102,5 @@ def _empty_result(self) -> SemanticResult:
             distance_from_anchor=2.0,
             semantic_clarity=0.0,
             concept_count=0,
-            confidence=0.0
+            confidence=0.0,
         )

guardian/analyzers/inference.py

@@ -51,8 +51,7 @@ def calculate_phi_optimization(self, coords_list: List[Coordinates]) -> Dict:
         centroid_power = sum(c.power for c in coords_list) / len(coords_list)
         centroid_wisdom = sum(c.wisdom for c in coords_list) / len(coords_list)
 
-        centroid = Coordinates(centroid_love, centroid_justice,
-                             centroid_power, centroid_wisdom)
+        centroid = Coordinates(centroid_love, centroid_justice, centroid_power, centroid_wisdom)
 
         # Calculate phi-weighted distances
         phi_distances = []
@@ -70,8 +69,7 @@ def calculate_phi_optimization(self, coords_list: List[Coordinates]) -> Dict:
         phi_mean = sum(phi_distances) / len(phi_distances)
         phi_variance = sum((d - phi_mean) ** 2 for d in phi_distances) / len(phi_distances)
 
-        logger.debug(f"Phi optimization: perfection={phi_perfection:.2f}%, "
-                    f"optimization={phi_optimization:.3f}")
+        logger.debug(f"Phi optimization: perfection={phi_perfection:.2f}%, " f"optimization={phi_optimization:.3f}")
 
         return {
             "centroid": centroid,
@@ -81,7 +79,7 @@ def calculate_phi_optimization(self, coords_list: List[Coordinates]) -> Dict:
             "phi_variance": phi_variance,
             "phi_mean": phi_mean,
             "min_phi_distance": min_phi_distance,
-            "max_phi_distance": max_phi_distance
+            "max_phi_distance": max_phi_distance,
         }
 
     def get_phi_score(self, coords: Coordinates) -> float:
@@ -108,5 +106,5 @@ def _empty_result(self) -> Dict:
             "phi_variance": 0.0,
             "phi_mean": 0.0,
             "min_phi_distance": 0.0,
-            "max_phi_distance": 0.0
+            "max_phi_distance": 0.0,
         }

guardian/analyzers/phi.py

@@ -69,19 +69,18 @@ def _calculate_cluster_analysis(self, coords_list: List[Coordinates]) -> Semanti
         distances = []
         for coords in coords_list:
             distance = math.sqrt(
-                (coords.love - centroid_love) ** 2 +
-                (coords.justice - centroid_justice) ** 2 +
-                (coords.power - centroid_power) ** 2 +
-                (coords.wisdom - centroid_wisdom) ** 2
+                (coords.love - centroid_love) ** 2
+                + (coords.justice - centroid_justice) ** 2
+                + (coords.power - centroid_power) ** 2
+                + (coords.wisdom - centroid_wisdom) ** 2
             )
             distances.append(distance)
 
         # Calculate harmonic cohesion
         avg_distance = sum(distances) / len(distances)
         harmonic_cohesion = max(0.0, 1.0 - avg_distance)
 
-        logger.debug(f"Cluster analysis: {len(coords_list)} concepts, "
-                    f"cohesion={harmonic_cohesion:.3f}")
+        logger.debug(f"Cluster analysis: {len(coords_list)} concepts, " f"cohesion={harmonic_cohesion:.3f}")
 
         return SemanticResult(
             coordinates=coords_list[0] if coords_list else Coordinates(0, 0, 0, 0),
@@ -90,7 +89,7 @@ def _calculate_cluster_analysis(self, coords_list: List[Coordinates]) -> Semanti
             concept_count=len(coords_list),
             confidence=harmonic_cohesion,
             distances=distances,
-            harmonic_cohesion=harmonic_cohesion
+            harmonic_cohesion=harmonic_cohesion,
         )
 
     def _empty_result(self) -> SemanticResult:
@@ -100,5 +99,5 @@ def _empty_result(self) -> SemanticResult:
             distance_from_anchor=2.0,
             semantic_clarity=0.0,
             concept_count=0,
-            confidence=0.0
+            confidence=0.0,
         )

guardian/analyzers/semantic.py

@@ -63,10 +63,7 @@ def calculate_unified_score(self, concepts: List[str]) -> Dict:
         delta = 0.05  # Resonance index weight
         epsilon = 0.05  # Phi optimization weight
 
-        unified_score = (alpha * harmony_score +
-                        beta * geologic_score +
-                        gamma * phi_score +
-                        delta * epsilon)
+        unified_score = alpha * harmony_score + beta * geologic_score + gamma * phi_score + delta * epsilon
 
         # Determine level and interpretation
         level, interpretation = self._get_level_and_interpretation(unified_score)
@@ -82,8 +79,8 @@ def calculate_unified_score(self, concepts: List[str]) -> Dict:
                 "divine_distance": divine_distance,
                 "harmonic_cohesion": harmony_score,
                 "geologic_precision": geologic_score,
-                "phi_optimization": phi_score
-            }
+                "phi_optimization": phi_score,
+            },
         }
 
     def _get_level_and_interpretation(self, score: float) -> tuple:
@@ -127,6 +124,6 @@ def _empty_result(self) -> Dict:
                 "divine_distance": 2.0,
                 "harmonic_cohesion": 0.0,
                 "geologic_precision": 0.0,
-                "phi_optimization": 0.0
-            }
+                "phi_optimization": 0.0,
+            },
         }

guardian/analyzers/unified.py

@@ -10,22 +10,19 @@
     print_gap_analysis,
     print_creator_profile,
     print_decrypt_report,
-    ProgressTracker
+    ProgressTracker,
 )
 
-from guardian.cli.html_reports import (
-    HTMLReportGenerator,
-    is_html_available
-)
+from guardian.cli.html_reports import HTMLReportGenerator, is_html_available
 
 __all__ = [
-    'print_header',
-    'print_ljpw_table',
-    'print_threat_results',
-    'print_gap_analysis',
-    'print_creator_profile',
-    'print_decrypt_report',
-    'ProgressTracker',
-    'HTMLReportGenerator',
-    'is_html_available'
+    "print_header",
+    "print_ljpw_table",
+    "print_threat_results",
+    "print_gap_analysis",
+    "print_creator_profile",
+    "print_decrypt_report",
+    "ProgressTracker",
+    "HTMLReportGenerator",
+    "is_html_available",
 ]