phi-complexity 0.1.2__tar.gz → 0.1.9__tar.gz

{phi_complexity-0.1.2 → phi_complexity-0.1.9}/PKG-INFO

@@ -1,195 +1,195 @@
-Metadata-Version: 2.4
-Name: phi-complexity
-Version: 0.1.2
-Summary: Code quality metrics based on Golden Ratio (φ) mathematical invariants
-Author-email: Tomy Verreault <contact@phidelia.dev>
-License: MIT
-Project-URL: Homepage, https://github.com/spockoo/phi-complexity
-Project-URL: Repository, https://github.com/spockoo/phi-complexity
-Project-URL: Documentation, https://github.com/spockoo/phi-complexity/blob/main/docs/GUIDE.md
-Project-URL: Bug Tracker, https://github.com/spockoo/phi-complexity/issues
-Keywords: code-quality,complexity,golden-ratio,fibonacci,static-analysis,ast,phi,metrics,entropy
-Classifier: Development Status :: 3 - Alpha
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Topic :: Software Development :: Quality Assurance
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Python: >=3.9
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Dynamic: license-file
-
-# phi-complexity
-
-> *Code quality metrics based on Golden Ratio (φ) mathematical invariants*
-
-[![PyPI version](https://img.shields.io/pypi/v/phi-complexity.svg)](https://pypi.org/project/phi-complexity/)
-[![Python 3.9+](https://img.shields.io/badge/python-3.9+-blue.svg)](https://www.python.org/downloads/)
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://github.com/spockoo/phi-complexity/blob/main/LICENSE)
-[![Tests](https://img.shields.io/badge/tests-26%20passed-brightgreen)](https://github.com/spockoo/phi-complexity/tree/main/tests)
-
-`phi-complexity` is the **first code quality library** that measures the health of your Python code using **universal mathematical invariants** derived from the Golden Ratio (φ = 1.618...).
-
-Unlike `pylint` (cultural rules) or `radon` (McCabe metrics), `phi-complexity` answers:
-
-> *"Is this code in resonance with the natural laws of order, or is it collapsing under its own entropy?"*
-
----
-
-## ⚡ Quick Start
-
-```bash
-pip install phi-complexity
-```
-
-```bash
-# Audit a file
-phi check my_script.py
-
-# Audit a folder
-phi check ./src/
-
-# Generate a Markdown report
-phi report my_script.py --output report.md
-
-# CI/CD strict mode (exit 1 if radiance < 75)
-phi check ./src/ --min-radiance 75
-```
-
-### Python API
-
-```python
-from phi_complexity import auditer, rapport_console, rapport_markdown
-
-# Get metrics as a dict
-metrics = auditer("my_script.py")
-print(metrics["radiance"])          # → 82.4
-print(metrics["statut_gnostique"])  # → "EN ÉVEIL ◈"
-print(metrics["oudjat"])            # → {"nom": "process_data", "ligne": 42, ...}
-
-# Print console report
-print(rapport_console("my_script.py"))
-
-# Save Markdown report
-rapport_markdown("my_script.py", sortie="report.md")
-```
-
----
-
-## 📊 Metrics
-
-| Metric | Description | Mathematical basis |
-|---|---|---|
-| **Radiance Score** | Global quality score (0–100) | `100 - f(Lilith) - g(H) - h(Anomalies) - i(Fib)` |
-| **Variance de Lilith** | Structural instability | Population variance of function complexities |
-| **Shannon Entropy** | Information density | `H = -Σ p·log₂(p)` |
-| **φ-Ratio** | Dominant function ratio | `max_complexity / mean` → should tend toward φ |
-| **Fibonacci Distance** | Natural size alignment | `Σ|n_i - Fib_k| / φ` |
-| **Zeta-Score** | Global resonance | `ζ_meta(functions, φ)` converging series |
-
-### Gnostic Status Levels
-
-| Score | Status | Meaning |
-|---|---|---|
-| ≥ 85 | **HERMÉTIQUE ✦** | Stable, harmonious, production-ready |
-| 60–84 | **EN ÉVEIL ◈** | Potential exists, some entropy zones |
-| < 60 | **DORMANT ░** | Deep restructuring recommended |
-
----
-
-## 🔍 Sample Output
-
-```
-╔══════════════════════════════════════════════════╗
-║      PHI-COMPLEXITY — AUDIT DE RADIANCE          ║
-╚══════════════════════════════════════════════════╝
-
-  📄 Fichier : my_script.py
-  📅 Date    : 2026-04-08 17:11
-
-  ☼  RADIANCE     : ██████████████░░░░░░  72.6 / 100
-  ⚖  LILITH       : 11221.9  (Structural variance)
-  🌊 ENTROPIE     : 2.48 bits  (Shannon)
-  ◈  PHI-RATIO    : 3.43  (ideal: φ = 1.618, Δ=1.81)
-  ζ  ZETA-SCORE   : 0.3656  (Global resonance)
-
-  STATUT : EN ÉVEIL ◈
-
-  🔎 OUDJAT : 'process_data' (Line 42, Complexity: 376)
-
-  ⚠  SUTURES IDENTIFIED (2):
-  🟡 Line 18 [LILITH] : Nested loop (depth 2). Consider a helper function.
-     >> for j in range(b):
-  🔵 Line 67 [SOUVERAINETE] : 'load_data' receives 6 arguments. Encapsulate in an object.
-     >> def load_data(path, sep, enc, cols, dtype, na):
-```
-
----
-
-## 🧮 Mathematical Foundations
-
-The **Radiance Formula** is derived from:
-
-- **φ-Meta Framework** (Tomy Verreault, 2026) — Axioms AX-A0 through AX-A58
-- **Law of Antifragility** (EQ-AFR-BMAD): `φ_{t+1} = P_φ(φ_t + k·Var(E_t)·E_t)`
-- **Cybernetics** (Korchounov, Mir, 1975) — Feedback and variance as control metrics
-- **Shannon Information Theory** — Code as an information channel
-
-The **Sovereign Coding Rules** are derived from:
-- **The C Book** (Banahan, Brady, Doran) — Scope hermeticity, resource lifecycle
-- **JaCaMo / Multi-Agent Programming** — Agent independence and encapsulation
-
-Full mathematical proof: [docs/MATHEMATIQUES.md](https://github.com/spockoo/phi-complexity/blob/main/docs/MATHEMATIQUES.md)
-
----
-
-## 🏗 Sovereign Architecture
-
-```
-Zero external dependencies.
-Pure Python standard library (ast, math, json).
-```
-
-```
-phi_complexity/
-├── core.py        ← Golden constants (PHI, TAXE_SUTURE, ETA_GOLDEN...)
-├── analyseur.py   ← AST fractal dissection
-├── metriques.py   ← Radiance Index calculation
-├── rapport.py     ← Console / Markdown / JSON rendering
-└── cli.py         ← phi check / phi report
-```
-
----
-
-## 🔗 Integration
-
-### Pre-commit Hook
-```yaml
-repos:
-  - repo: https://github.com/spockoo/phi-complexity
-    rev: v0.1.0
-    hooks:
-      - id: phi-check
-        args: [--min-radiance, "70"]
-```
-
-### GitHub Action
-```yaml
-- name: Phi-Complexity Audit
-  run: |
-    pip install phi-complexity
-    phi check ./src/ --min-radiance 75
-```
-
----
-
-## 📜 License
-
-MIT — Tomy Verreault, 2026
-
-*Anchored in the Bibliothèque Céleste — Morphic Phi Framework (φ-Meta)*
+Metadata-Version: 2.4
+Name: phi-complexity
+Version: 0.1.9
+Summary: Code quality metrics based on Golden Ratio (φ) mathematical invariants
+Author-email: Tomy Verreault <contact@phidelia.dev>
+License: MIT
+Project-URL: Homepage, https://github.com/spockoo/phi-complexity
+Project-URL: Repository, https://github.com/spockoo/phi-complexity
+Project-URL: Documentation, https://github.com/spockoo/phi-complexity/blob/main/docs/GUIDE.md
+Project-URL: Bug Tracker, https://github.com/spockoo/phi-complexity/issues
+Keywords: code-quality,complexity,golden-ratio,fibonacci,static-analysis,ast,phi,metrics,entropy
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# phi-complexity
+
+> *Code quality metrics based on Golden Ratio (φ) mathematical invariants*
+
+[![PyPI version](https://img.shields.io/pypi/v/phi-complexity.svg)](https://pypi.org/project/phi-complexity/)
+[![Python 3.9+](https://img.shields.io/badge/python-3.9+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://github.com/spockoo/phi-complexity/blob/main/LICENSE)
+[![Tests](https://img.shields.io/badge/tests-26%20passed-brightgreen)](https://github.com/spockoo/phi-complexity/tree/main/tests)
+
+`phi-complexity` is the **first code quality library** that measures the health of your Python code using **universal mathematical invariants** derived from the Golden Ratio (φ = 1.618...).
+
+Unlike `pylint` (cultural rules) or `radon` (McCabe metrics), `phi-complexity` answers:
+
+> *"Is this code in resonance with the natural laws of order, or is it collapsing under its own entropy?"*
+
+---
+
+## ⚡ Quick Start
+
+```bash
+pip install phi-complexity
+```
+
+```bash
+# Audit a file
+phi check my_script.py
+
+# Audit a folder
+phi check ./src/
+
+# Generate a Markdown report
+phi report my_script.py --output report.md
+
+# CI/CD strict mode (exit 1 if radiance < 75)
+phi check ./src/ --min-radiance 75
+```
+
+### Python API
+
+```python
+from phi_complexity import auditer, rapport_console, rapport_markdown
+
+# Get metrics as a dict
+metrics = auditer("my_script.py")
+print(metrics["radiance"])          # → 82.4
+print(metrics["statut_gnostique"])  # → "EN ÉVEIL ◈"
+print(metrics["oudjat"])            # → {"nom": "process_data", "ligne": 42, ...}
+
+# Print console report
+print(rapport_console("my_script.py"))
+
+# Save Markdown report
+rapport_markdown("my_script.py", sortie="report.md")
+```
+
+---
+
+## 📊 Metrics
+
+| Metric | Description | Mathematical basis |
+|---|---|---|
+| **Radiance Score** | Global quality score (0–100) | `100 - f(Lilith) - g(H) - h(Anomalies) - i(Fib)` |
+| **Variance de Lilith** | Structural instability | Population variance of function complexities |
+| **Shannon Entropy** | Information density | `H = -Σ p·log₂(p)` |
+| **φ-Ratio** | Dominant function ratio | `max_complexity / mean` → should tend toward φ |
+| **Fibonacci Distance** | Natural size alignment | `Σ|n_i - Fib_k| / φ` |
+| **Zeta-Score** | Global resonance | `ζ_meta(functions, φ)` converging series |
+
+### Gnostic Status Levels
+
+| Score | Status | Meaning |
+|---|---|---|
+| ≥ 85 | **HERMÉTIQUE ✦** | Stable, harmonious, production-ready |
+| 60–84 | **EN ÉVEIL ◈** | Potential exists, some entropy zones |
+| < 60 | **DORMANT ░** | Deep restructuring recommended |
+
+---
+
+## 🔍 Sample Output
+
+```
+╔══════════════════════════════════════════════════╗
+║      PHI-COMPLEXITY — AUDIT DE RADIANCE          ║
+╚══════════════════════════════════════════════════╝
+
+  📄 Fichier : my_script.py
+  📅 Date    : 2026-04-08 17:11
+
+  ☼  RADIANCE     : ██████████████░░░░░░  72.6 / 100
+  ⚖  LILITH       : 11221.9  (Structural variance)
+  🌊 ENTROPIE     : 2.48 bits  (Shannon)
+  ◈  PHI-RATIO    : 3.43  (ideal: φ = 1.618, Δ=1.81)
+  ζ  ZETA-SCORE   : 0.3656  (Global resonance)
+
+  STATUT : EN ÉVEIL ◈
+
+  🔎 OUDJAT : 'process_data' (Line 42, Complexity: 376)
+
+  ⚠  SUTURES IDENTIFIED (2):
+  🟡 Line 18 [LILITH] : Nested loop (depth 2). Consider a helper function.
+     >> for j in range(b):
+  🔵 Line 67 [SOUVERAINETE] : 'load_data' receives 6 arguments. Encapsulate in an object.
+     >> def load_data(path, sep, enc, cols, dtype, na):
+```
+
+---
+
+## 🧮 Mathematical Foundations
+
+The **Radiance Formula** is derived from:
+
+- **φ-Meta Framework** (Tomy Verreault, 2026) — Axioms AX-A0 through AX-A58
+- **Law of Antifragility** (EQ-AFR-BMAD): `φ_{t+1} = P_φ(φ_t + k·Var(E_t)·E_t)`
+- **Cybernetics** (Korchounov, Mir, 1975) — Feedback and variance as control metrics
+- **Shannon Information Theory** — Code as an information channel
+
+The **Sovereign Coding Rules** are derived from:
+- **The C Book** (Banahan, Brady, Doran) — Scope hermeticity, resource lifecycle
+- **JaCaMo / Multi-Agent Programming** — Agent independence and encapsulation
+
+Full mathematical proof: [docs/MATHEMATIQUES.md](https://github.com/spockoo/phi-complexity/blob/main/docs/MATHEMATIQUES.md)
+
+---
+
+## 🏗 Sovereign Architecture
+
+```
+Zero external dependencies.
+Pure Python standard library (ast, math, json).
+```
+
+```
+phi_complexity/
+├── core.py        ← Golden constants (PHI, TAXE_SUTURE, ETA_GOLDEN...)
+├── analyseur.py   ← AST fractal dissection
+├── metriques.py   ← Radiance Index calculation
+├── rapport.py     ← Console / Markdown / JSON rendering
+└── cli.py         ← phi check / phi report
+```
+
+---
+
+## 🔗 Integration
+
+### Pre-commit Hook
+```yaml
+repos:
+  - repo: https://github.com/spockoo/phi-complexity
+    rev: v0.1.0
+    hooks:
+      - id: phi-check
+        args: [--min-radiance, "70"]
+```
+
+### GitHub Action
+```yaml
+- name: Phi-Complexity Audit
+  run: |
+    pip install phi-complexity
+    phi check ./src/ --min-radiance 75
+```
+
+---
+
+## 📜 License
+
+MIT — Tomy Verreault, 2026
+
+*Anchored in the Bibliothèque Céleste — Morphic Phi Framework (φ-Meta)*

{phi_complexity-0.1.2 → phi_complexity-0.1.9}/phi_complexity/__init__.py

@@ -1,14 +1,13 @@
-"""
-__init__.py — API publique de phi-complexity.
-Expose les fonctions de haut niveau pour une utilisation simple.
-"""
-from .core import PHI, TAXE_SUTURE, ETA_GOLDEN, VERSION, AUTEUR, FRAMEWORK
+from __future__ import annotations
+from typing import Dict, Any, Optional
+from .core import PHI, TAXE_SUTURE, ETA_GOLDEN, VERSION, AUTEUR
 from .analyseur import AnalyseurPhi
 from .metriques import CalculateurRadiance
 from .rapport import GenerateurRapport
+from .suture import SutureAgent
 
 
-def auditer(fichier: str) -> dict:
+def auditer(fichier: str) -> Dict[str, Any]:
     """
     Lance un audit complet sur un fichier Python.
     Retourne un dictionnaire de métriques.
@@ -18,9 +17,9 @@ def auditer(fichier: str) -> dict:
         result = auditer("mon_script.py")
         print(result["radiance"])  # → 82.4
     """
-    analyseur = AnalyseurPhi(fichier)
+    analyseur: AnalyseurPhi = AnalyseurPhi(fichier)
     resultat = analyseur.analyser()
-    calculateur = CalculateurRadiance(resultat)
+    calculateur: CalculateurRadiance = CalculateurRadiance(resultat)
     return calculateur.calculer()
 
 
@@ -30,14 +29,14 @@ def rapport_console(fichier: str) -> str:
     return GenerateurRapport(metriques).console()
 
 
-def rapport_markdown(fichier: str, sortie: str = None) -> str:
+def rapport_markdown(fichier: str, sortie: Optional[str] = None) -> str:
     """
     Génère un rapport Markdown.
     Si `sortie` est spécifié, sauvegarde dans ce fichier.
     Retourne le contenu Markdown.
     """
-    metriques = auditer(fichier)
-    gen = GenerateurRapport(metriques)
+    metriques: Dict[str, Any] = auditer(fichier)
+    gen: GenerateurRapport = GenerateurRapport(metriques)
     if sortie:
         gen.sauvegarder_markdown(sortie)
     return gen.markdown()
@@ -49,6 +48,26 @@ def rapport_json(fichier: str) -> str:
     return GenerateurRapport(metriques).json()
 
 
+def suture(fichier: str, api_url: Optional[str] = None) -> str:
+    """
+    Invoque Phidélia pour proposer une suture du fichier.
+    Retourne la suggestion de l'IA (Markdown).
+    """
+    from .analyseur import AnalyseurPhi
+    from .metriques import CalculateurRadiance
+    
+    analyseur = AnalyseurPhi(fichier)
+    resultat = analyseur.analyser()
+    
+    # On injecte les métriques de radiance dans le résultat pour Phidélia
+    calculateur = CalculateurRadiance(resultat)
+    metriques = calculateur.calculer()
+    resultat.radiance = metriques["radiance"]
+    
+    agent = SutureAgent(api_url) if api_url else SutureAgent()
+    return agent.suturer(resultat)
+
+
 __version__ = VERSION
 __author__ = AUTEUR
 __all__ = [
@@ -62,4 +81,6 @@ __all__ = [
     "AnalyseurPhi",
     "CalculateurRadiance",
     "GenerateurRapport",
+    "SutureAgent",
+    "suture",
 ]

phi_complexity-0.1.9/phi_complexity/akasha.py

@@ -0,0 +1,158 @@
+from __future__ import annotations
+import os
+import json
+import time
+import math
+from typing import Dict, Any, List, Optional
+from .core import PHI
+
+# ────────────────────────────────────────────────────────
+# MOTEUR DE MATRICE HOLOGRAPHIQUE BINAIRE (Phidélia v11.6)
+# ────────────────────────────────────────────────────────
+
+class MatriceHolographique:
+    """
+    Transforme un dictionnaire de métriques en résonances harmoniques
+    dans l'anneau Z[φ]. (Inspiré de EQ-BIN-010 et EQ-CIA-023).
+    """
+    
+    def __init__(self, donnees: Dict[str, Any]) -> None:
+        self.axes = ["radiance", "resistance", "lilith_variance", "shannon_entropy", "phi_ratio"]
+        self.valeurs = [float(donnees.get(axe, 0.0)) for axe in self.axes]
+        self.vecteur = self._encoder(donnees)
+
+    def _encoder(self, d: Dict[str, Any]) -> List[float]:
+        """Convertit les métriques en vecteur normalisé pour la similitude cosinus."""
+        v = []
+        v.append(float(d.get("radiance", 0)) / 100.0)
+        v.append(min(1.0, float(d.get("resistance", 0))))
+        v.append(min(1.0, float(d.get("lilith_variance", 0)) / 1000.0))
+        v.append(min(1.0, float(d.get("shannon_entropy", 0)) / 10.0))
+        v.append(min(1.0, abs(float(d.get("phi_ratio", 0)) - PHI)))
+        return v
+
+    def transmuter(self) -> List[Dict[str, float]]:
+        """
+        Transmutation Maat (EQ-BIN-010) : convertit chaque axe en coordonnée Z[φ].
+        a = ⌊val × 1000⌋ (Matière)
+        b = ⌊val × 1370⌋ (Phi - Résonance α⁻¹)
+        Retourne la résonance (a + bφ) × φ = b + (a+b)φ.
+        """
+        coords = []
+        for val in self.valeurs:
+            a = math.floor(val * 1000)
+            b = math.floor(val * 1370)
+            coords.append({
+                "a": float(b),
+                "b": float(a + b)
+            })
+        return coords
+
+    def calculer_masse_harmonique(self) -> float:
+        """Calcule la Masse Harmonique M_bit (EQ-BIN-003)."""
+        return sum(self.valeurs) / len(self.axes)
+
+    def calculer_coherence(self) -> float:
+        """Calcule la Cohérence Interne C_bit (EQ-BIN-005)."""
+        stabilite_theo = 1.0 / PHI
+        moyenne = sum(v for v in self.valeurs if v > 0) / max(1, len(self.valeurs))
+        return (1.0 - abs(moyenne / 100.0 - stabilite_theo)) * 100.0
+
+    def calculer_similitude(self, autre: MatriceHolographique) -> float:
+        """Calcule la similitude cosinus entre deux architectures holographiques."""
+        dot = sum(a * b for a, b in zip(self.vecteur, autre.vecteur))
+        norm_a = math.sqrt(sum(a*a for a in self.vecteur))
+        norm_b = math.sqrt(sum(b*b for b in autre.vecteur))
+        if norm_a == 0 or norm_b == 0:
+            return 0.0
+        return dot / (norm_a * norm_b)
+
+    def vers_grille(self) -> str:
+        """Exporte la matrice sous forme de dôme de résonance transparent."""
+        res = "  AXE            | VALEUR | DÔME DE RÉSONANCE\n"
+        res += "  ---------------|--------|------------------\n"
+        for i, axe in enumerate(self.axes):
+            intensite = "█" * int(self.vecteur[i] * 15)
+            res += f"  {axe:<14} | {self.vecteur[i]:.4f} | {intensite}\n"
+        return res
+
+
+class RegistreAkashique:
+    """
+    Gestionnaire souverain des Annales Akashiques.
+    Utilise le moteur de Matrice Holographique pour la navigation temporelle.
+    """
+    
+    def __init__(self, workspace_root: str = ".") -> None:
+        self.phi_dir = os.path.join(workspace_root, ".phi")
+        self.db_path = os.path.join(self.phi_dir, "akasha.json")
+        self._initialiser_espace()
+
+    def _initialiser_espace(self) -> None:
+        if not os.path.exists(self.phi_dir):
+            os.makedirs(self.phi_dir)
+        if not os.path.exists(self.db_path):
+            with open(self.db_path, "w", encoding="utf-8") as f:
+                json.dump({"annales": [], "version": "11.6"}, f)
+
+    def enregistrer(self, resultat: Dict[str, Any]) -> None:
+        """Archive un audit sous forme de signature holographique."""
+        try:
+            with open(self.db_path, "r", encoding="utf-8") as f:
+                data = json.load(f)
+            
+            mat = MatriceHolographique(resultat)
+            evenement = {
+                "timestamp": time.time(),
+                "fichier": resultat.get("fichier", "inconnu"),
+                "radiance": resultat.get("radiance", 0),
+                "masse_harmonique": round(mat.calculer_masse_harmonique(), 4),
+                "coherence_c_bit": round(mat.calculer_coherence(), 2),
+                "coords_maat": mat.transmuter(),
+                "vecteur": mat.vecteur,
+                "signature": resultat.get("signature", "")
+            }
+            
+            data["annales"].append(evenement)
+            if len(data["annales"]) > 1000:
+                data["annales"] = data["annales"][-1000:]
+                
+            with open(self.db_path, "w", encoding="utf-8") as f:
+                json.dump(data, f, indent=2)
+        except Exception:
+            pass
+
+    def consulter_historique(self, limite: int = 7) -> List[Dict[str, Any]]:
+        """Retourne les dernières annales."""
+        try:
+            with open(self.db_path, "r", encoding="utf-8") as f:
+                data = json.load(f)
+            return [dict(e) for e in data.get("annales", [])[-limite:]]
+        except Exception:
+            return []
+
+    def trouver_similitude(self, dictionnaire_cible: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+        """Recherche par proximité holographique (> 0.98 de gnose)."""
+        cible_mat = MatriceHolographique(dictionnaire_cible)
+        annales = self.consulter_historique(500)
+        
+        meilleure_entree = None
+        max_sim = 0.98
+        
+        for entry in annales:
+            if "vecteur" not in entry:
+                continue
+            if entry["fichier"] == dictionnaire_cible.get("fichier"):
+                continue
+            
+            # Reconstruction de la matrice pour comparaison
+            pseudo_dict = {axe: val for axe, val in zip(cible_mat.axes, entry["vecteur"])}
+            mat_compare = MatriceHolographique(pseudo_dict)
+            mat_compare.vecteur = entry["vecteur"]
+            
+            sim = cible_mat.calculer_similitude(mat_compare)
+            if sim > max_sim:
+                max_sim = sim
+                meilleure_entree = entry
+                
+        return meilleure_entree