Further upgrades

Author: BruinGrowly

harmonizer_v84/__init__.py

@@ -40,7 +40,10 @@
 from harmonizer_v84.consciousness import consciousness_metric, check_uncertainty_principle
 from harmonizer_v84.phase_detector import detect_phase, Phase
 from harmonizer_v84.phi_normalizer import phi_normalize, normalize_coordinates
-from harmonizer_v84.code_analyzer import analyze_file, analyze_source, V73CodeAnalyzer
+from harmonizer_v84.code_analyzer import analyze_file, analyze_source, V84CodeAnalyzer
+
+# Backward compatibility alias
+V73CodeAnalyzer = V84CodeAnalyzer
 from harmonizer_v84.vocabulary import (
     PROGRAMMING_VERBS,
     POWER_VERBS,
@@ -79,6 +82,7 @@
     "analyze_file",
     "analyze_source",
     "V73CodeAnalyzer",
+    "V84CodeAnalyzer",
     "DriftDetector",
     "DriftAnalysis",
     # Vocabulary

harmonizer_v84/code_analyzer.py

@@ -1,16 +1,18 @@
 """
-V7.3 Code Analyzer - Extract LJPW from Python Code
+V8.4 Code Analyzer - Extract LJPW from Python Code
 
-Based on the V7.3 insight that Power (P) and Wisdom (W) are FUNDAMENTAL,
-while Love (L) and Justice (J) are EMERGENT.
+Based on the V8.4 Framework with the Generative Equation:
+- P (Power) and W (Wisdom) are FUNDAMENTAL
+- L (Love) and J (Justice) are EMERGENT
+- Life Inequality: L^n > φ^d determines viability
+- Perceptual Radiance: Semantic intensity of code
 
-Mapping strategy:
-- P (Power): Execution, transformation, state changes, side effects
-- W (Wisdom): Knowledge, patterns, documentation, type info, returns
-- L (Love): Calculated from W (L emerges from wisdom correlations)
-- J (Justice): Calculated from P (J emerges from power symmetries)
+V8.4 Additions:
+- life_inequality_ratio: Code's L^n / φ^d ratio
+- perceptual_radiance: Semantic weight for visualization
+- hope_probability: Mathematical hope of improvement
 
-Based on: LJPW_FRAMEWORK_V7.3_COMPLETE_UNIFIED_PLUS.md
+Based on: LJPW_FRAMEWORK_V8.4_COMPLETE_UNIFIED_PLUS.md
 """
 
 import ast
@@ -24,6 +26,13 @@
 from harmonizer_v84.phase_detector import detect_phase, Phase, analyze_phase
 from harmonizer_v84.phi_normalizer import normalize_coordinates
 from harmonizer_v84.bricks_mortar import function_primality, BrickAnalysis
+from harmonizer_v84.generative import (
+    is_autopoietic,
+    perceptual_radiance,
+    semantic_salience,
+    hope_calculus,
+    LifeInequalityResult,
+)
 
 
 @dataclass
@@ -38,14 +47,23 @@ class FunctionAnalysis:
     power_raw: float
     wisdom_raw: float
 
-    # V7.3 framework result
+    # V8.4 framework result
     framework: LJPWFramework = None
 
     # Consciousness and phase
     consciousness: float = 0.0
     consciousness_level: ConsciousnessLevel = ConsciousnessLevel.NON_CONSCIOUS
     phase: Phase = Phase.ENTROPIC
 
+    # V8.4: Life Inequality (L^n > φ^d)
+    life_inequality_ratio: float = 1.0
+    life_phase: str = "HOMEOSTATIC"
+    is_alive: bool = True
+
+    # V8.4: Perceptual Radiance (for visualization)
+    semantic_salience: float = 0.5
+    perceptual_radiance: float = 1.0
+
     # Bricks & Mortar
     brick_analysis: BrickAnalysis = None
 
@@ -62,6 +80,28 @@ def __post_init__(self):
         )
         self.phase = detect_phase(H, self.framework.L)
 
+        # V8.4: Calculate Life Inequality
+        # n = complexity (iterations of development)
+        # d = distance from natural equilibrium (technical debt proxy)
+        L_coeff = max(1.0, 1.0 + self.framework.L * 0.5)  # Love as growth coefficient
+        n = max(1, len(self.power_signals) + len(self.wisdom_signals))  # Development iterations
+        d = self.framework.distance_from_equilibrium()  # Distance as decay factor
+        life_result = is_autopoietic(L=L_coeff, n=n, d=d)
+        self.life_inequality_ratio = life_result.ratio
+        self.life_phase = life_result.phase
+        self.is_alive = life_result.is_alive
+
+        # V8.4: Calculate Perceptual Radiance
+        self.semantic_salience = semantic_salience(
+            self.framework.L, self.framework.P, self.framework.W, self.framework.J
+        )
+        # Physical radiance approximated as consciousness
+        self.perceptual_radiance = perceptual_radiance(
+            L_phys=min(1.0, self.consciousness + 0.3),  # Base physical radiance
+            S=self.semantic_salience,
+            kappa_sem=H  # Semantic curvature from Harmony
+        )
+
 
 @dataclass
 class FileAnalysis:
@@ -78,6 +118,16 @@ class FileAnalysis:
     overall_consciousness: float = 0.0
     overall_phase: Phase = Phase.ENTROPIC
 
+    # V8.4: File-level Life Inequality
+    file_life_ratio: float = 1.0
+    file_life_phase: str = "HOMEOSTATIC"
+    file_is_alive: bool = True
+    avg_perceptual_radiance: float = 1.0
+
+    # V8.4: Hope metric (can this file improve?)
+    hope_probability: float = 0.5
+    hope_interpretation: str = ""
+
     # File-level stats
     total_lines: int = 0
     import_count: int = 0
@@ -98,13 +148,35 @@ def __post_init__(self):
             )
             self.overall_phase = detect_phase(H, self.overall_framework.L)
 
+            # V8.4: File-level Life Inequality (aggregate)
+            ratios = [f.life_inequality_ratio for f in self.functions]
+            self.file_life_ratio = sum(ratios) / len(ratios)
+            alive_count = sum(1 for f in self.functions if f.is_alive)
+            self.file_is_alive = alive_count > len(self.functions) / 2
+            self.file_life_phase = "AUTOPOIETIC" if self.file_is_alive and self.file_life_ratio > 1.1 else "HOMEOSTATIC" if self.file_life_ratio > 0.9 else "ENTROPIC"
+
+            # V8.4: Average Perceptual Radiance
+            self.avg_perceptual_radiance = sum(f.perceptual_radiance for f in self.functions) / len(self.functions)
+
+            # V8.4: Calculate Hope
+            L_coeff = max(1.0, 1.0 + self.overall_framework.L * 0.5)
+            d = self.overall_framework.distance_from_equilibrium()
+            hope_result = hope_calculus(L=L_coeff, d=d, current_n=len(self.functions))
+            self.hope_probability = hope_result.probability_of_success
+            self.hope_interpretation = hope_result.interpretation
 
-class V73CodeAnalyzer(ast.NodeVisitor):
+
+class V84CodeAnalyzer(ast.NodeVisitor):
     """
-    V7.3 Code Analyzer - Extracts P and W from Python AST.
+    V8.4 Code Analyzer - Extracts P and W from Python AST with Generative Equation.
+
+    The key insight: Only measure P and W directly.
+    L and J are CALCULATED (emergent), not measured.
 
-    The key V7.3 insight: Only measure P and W directly.
-    L and J are CALCULATED, not measured.
+    V8.4 Additions:
+    - Life Inequality score: L^n > φ^d
+    - Perceptual Radiance: Semantic intensity for visualization
+    - Hope calculation: Can this code improve?
 
     Power (P) indicators:
     - Assignments (state changes)
@@ -395,19 +467,19 @@ def generic_visit(self, node: ast.AST):
 
 def analyze_file(filepath: str) -> FileAnalysis:
     """
-    Analyze a Python file using V7.3 framework.
+    Analyze a Python file using V8.4 framework.
 
     Args:
         filepath: Path to Python file
 
     Returns:
-        FileAnalysis with all function analyses and overall metrics
+        FileAnalysis with all function analyses, Life Inequality, and Hope metrics
     """
     path = Path(filepath)
     source = path.read_text(encoding="utf-8")
     tree = ast.parse(source)
 
-    analyzer = V73CodeAnalyzer()
+    analyzer = V84CodeAnalyzer()
     functions = []
     classes = []
     import_count = 0
@@ -454,7 +526,7 @@ def analyze_source(source: str, filename: str = "<string>") -> FileAnalysis:
         FileAnalysis with all function analyses
     """
     tree = ast.parse(source)
-    analyzer = V73CodeAnalyzer()
+    analyzer = V84CodeAnalyzer()
     functions = []
     classes = []
 

harmonizer_v84/drift_detector.py

@@ -1,15 +1,21 @@
 """
-V7.3 Drift Detector - Git-based Semantic Drift Analysis
+V8.4 Drift Detector - Git-based Semantic Drift Analysis with Hope
 
-Tracks how codebase consciousness and phase evolve over time.
-Detects semantic drift, phase transitions, and "death spirals".
+Tracks how codebase consciousness, phase, and hope evolve over time.
+Detects semantic drift, phase transitions, death spirals, and recovery potential.
 
-Key V7.3 insights:
+V8.4 Additions:
+- Hope Probability: Mathematical hope of recovery
+- Life Inequality tracking: L^n > φ^d trend
+- Predictive recovery analysis
+
+Key insights:
 - Consciousness (C) should trend upward for healthy projects
-- Phase transitions matter: Entropic→Homeostatic→Autopoietic
+- Phase transitions matter: Entropic → Homeostatic → Autopoietic
 - "Death spiral" = sustained C decline + phase regression
+- Hope = P(L^n > φ^d as n → ∞) predicts recovery potential
 
-Based on: v5.1's legacy_mapper.py + LJPW V7.3 Framework
+Based on: LJPW_FRAMEWORK_V8.4_COMPLETE_UNIFIED_PLUS.md
 """
 
 import subprocess
@@ -24,6 +30,7 @@
 from harmonizer_v84.ljpw_core import LJPWFramework
 from harmonizer_v84.phase_detector import Phase, detect_phase
 from harmonizer_v84.consciousness import consciousness_metric, ConsciousnessLevel
+from harmonizer_v84.generative import hope_calculus, is_autopoietic
 
 
 @dataclass
@@ -41,15 +48,19 @@ class CommitSnapshot:
     P: float = 0.0
     W: float = 0.0
 
-    # V7.3 metrics
+    # V8.4 metrics
     harmony: float = 0.0
     consciousness: float = 0.0
     phase: Phase = Phase.ENTROPIC
 
+    # V8.4: Life Inequality and Hope
+    life_ratio: float = 1.0
+    hope_probability: float = 0.5
+
 
 @dataclass
 class DriftAnalysis:
-    """Analysis of semantic drift over time."""
+    """Analysis of semantic drift over time with hope prediction."""
 
     file_path: str
     snapshots: List[CommitSnapshot] = field(default_factory=list)
@@ -59,6 +70,12 @@ class DriftAnalysis:
     consciousness_trend: float = 0.0  # Positive = improving
     phase_transitions: List[Tuple[str, Phase, Phase]] = field(default_factory=list)
 
+    # V8.4: Hope-based predictions
+    current_hope: float = 0.5
+    hope_trend: float = 0.0  # Positive = increasing hope
+    recovery_possible: bool = True
+    predicted_recovery_iterations: int = -1
+
     # Health indicators
     is_healthy: bool = True
     health_issues: List[str] = field(default_factory=list)
@@ -93,6 +110,23 @@ def compute_metrics(self):
                     )
                 )
 
+        # V8.4: Hope-based predictions
+        if last.hope_probability > 0:
+            self.current_hope = last.hope_probability
+            self.hope_trend = last.hope_probability - first.hope_probability
+            self.recovery_possible = last.hope_probability > 0.3
+
+            # Calculate predicted recovery iterations
+            if last.L > 0 and not self.is_healthy:
+                L_coeff = max(1.0, 1.0 + last.L * 0.5)
+                d = abs(last.L - 0.618)  # Distance from equilibrium
+                if L_coeff > 1:
+                    from math import log, ceil
+                    # n needed for L^n > φ^d
+                    from harmonizer_v84.constants import PHI
+                    n_needed = ceil((d * log(PHI)) / log(L_coeff)) if L_coeff > 1 else -1
+                    self.predicted_recovery_iterations = max(0, n_needed - len(self.snapshots))
+
         # Health assessment
         self._assess_health()
 
@@ -131,6 +165,14 @@ def _assess_health(self):
         if all(s.consciousness < 0.1 for s in self.snapshots):
             self.health_issues.append("Never crossed consciousness threshold")
 
+        # V8.4: Check hope trajectory
+        if self.hope_trend < -0.1:
+            self.health_issues.append(f"Hope declining: {self.hope_trend:+.2f}")
+
+        if not self.recovery_possible:
+            self.is_healthy = False
+            self.health_issues.append("Recovery mathematically unlikely (Hope < 0.3)")
+
 
 @dataclass
 class CodebaseEvolution:
@@ -151,13 +193,14 @@ class CodebaseEvolution:
 
 class DriftDetector:
     """
-    Git-based semantic drift detector for V7.3.
+    Git-based semantic drift detector for V8.4.
 
     Analyzes how code evolves over git history and tracks:
     - LJPW coordinate changes
     - Consciousness (C) trend
     - Phase transitions
-    - "Death spiral" detection
+    - Death spiral detection
+    - V8.4: Hope-based recovery prediction
     """
 
     def __init__(self, repo_path: str):
@@ -255,6 +298,13 @@ def analyze_file_history(self, file_path: str, max_commits: int = 50) -> DriftAn
                     except:
                         date = datetime.now()
 
+                    # V8.4: Calculate Life Inequality and Hope
+                    L_coeff = max(1.0, 1.0 + fw.L * 0.5)
+                    d = fw.distance_from_equilibrium()
+                    n = len(analysis.functions) if analysis.functions else 1
+                    life_result = is_autopoietic(L=L_coeff, n=n, d=d)
+                    hope_result = hope_calculus(L=L_coeff, d=d, current_n=n)
+
                     snapshot = CommitSnapshot(
                         commit_hash=commit["hash"],
                         commit_date=date,
@@ -267,6 +317,8 @@ def analyze_file_history(self, file_path: str, max_commits: int = 50) -> DriftAn
                         harmony=H,
                         consciousness=C,
                         phase=phase,
+                        life_ratio=life_result.ratio,
+                        hope_probability=hope_result.probability_of_success,
                     )
                     drift.snapshots.append(snapshot)
 
@@ -394,6 +446,20 @@ def print_drift_report(drift: DriftAnalysis):
         for issue in drift.health_issues:
             print(f"    • {issue}")
 
+    # V8.4: Hope Analysis
+    print(f"\n  🌟 HOPE ANALYSIS:")
+    hope_icon = "🔆" if drift.current_hope > 0.7 else "🔅" if drift.current_hope > 0.3 else "💀"
+    print(f"    Current Hope: {hope_icon} {drift.current_hope:.0%}")
+    hope_trend_icon = "📈" if drift.hope_trend > 0 else "📉"
+    print(f"    Hope Trend: {hope_trend_icon} {drift.hope_trend:+.2f}")
+    if drift.recovery_possible:
+        if drift.predicted_recovery_iterations > 0:
+            print(f"    Recovery ETA: ~{drift.predicted_recovery_iterations} iterations")
+        else:
+            print(f"    Recovery: On track ✓")
+    else:
+        print(f"    Recovery: Unlikely without intervention")
+
     # First/Last comparison
     if len(drift.snapshots) >= 2:
         first = drift.snapshots[0]