phi-complexity 0.1.0__py3-none-any.whl

phi_complexity/__init__.py

@@ -0,0 +1,65 @@
+"""
+__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 .analyseur import AnalyseurPhi
+from .metriques import CalculateurRadiance
+from .rapport import GenerateurRapport
+
+
+def auditer(fichier: str) -> dict:
+    """
+    Lance un audit complet sur un fichier Python.
+    Retourne un dictionnaire de métriques.
+
+    Usage:
+        from phi_complexity import auditer
+        result = auditer("mon_script.py")
+        print(result["radiance"])  # → 82.4
+    """
+    analyseur = AnalyseurPhi(fichier)
+    resultat = analyseur.analyser()
+    calculateur = CalculateurRadiance(resultat)
+    return calculateur.calculer()
+
+
+def rapport_console(fichier: str) -> str:
+    """Retourne le rapport ASCII formaté pour le terminal."""
+    metriques = auditer(fichier)
+    return GenerateurRapport(metriques).console()
+
+
+def rapport_markdown(fichier: str, sortie: 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)
+    if sortie:
+        gen.sauvegarder_markdown(sortie)
+    return gen.markdown()
+
+
+def rapport_json(fichier: str) -> str:
+    """Retourne le rapport JSON pour CI/CD."""
+    metriques = auditer(fichier)
+    return GenerateurRapport(metriques).json()
+
+
+__version__ = VERSION
+__author__ = AUTEUR
+__all__ = [
+    "auditer",
+    "rapport_console",
+    "rapport_markdown",
+    "rapport_json",
+    "PHI",
+    "TAXE_SUTURE",
+    "ETA_GOLDEN",
+    "AnalyseurPhi",
+    "CalculateurRadiance",
+    "GenerateurRapport",
+]

phi_complexity/__main__.py

@@ -0,0 +1,3 @@
+"""Point d'entrée pour python -m phi_complexity"""
+from phi_complexity.cli import main
+main()

phi_complexity/analyseur.py

@@ -0,0 +1,281 @@
+"""
+analyseur.py — Dissection fractale du code Python via AST.
+Suturée selon les recommandations de phi-complexity v0.1.0 (Protocole BMAD).
+_analyser_micro() décomposée en 4 règles hermétiques — Cycles 13:20 → 33:33.
+"""
+import ast
+from dataclasses import dataclass, field
+from typing import List, Optional
+
+from .core import fibonacci_plus_proche, distance_fibonacci
+
+
+# ────────────────────────────────────────────────────────
+# STRUCTURES DE DONNÉES (dataclasses immuables)
+# ────────────────────────────────────────────────────────
+
+@dataclass
+class MetriqueFonction:
+    """Représente une fonction analysée avec toutes ses métriques brutes."""
+    nom: str
+    ligne: int
+    complexite: int       # Nombre de nœuds AST (pression morphique)
+    nb_args: int          # Nombre d'arguments
+    nb_lignes: int        # Longueur en lignes
+    profondeur_max: int   # Imbrication maximale
+    distance_fib: float   # Éloignement de la séquence naturelle
+    phi_ratio: float      # Rapport complexité/moyenne (idéal: φ)
+
+
+@dataclass
+class Annotation:
+    """Une observation chirurgicale sur une ligne spécifique du code."""
+    ligne: int
+    message: str
+    niveau: str           # 'INFO', 'WARNING', 'CRITICAL'
+    extrait: str          # La ligne de code concernée
+    categorie: str        # 'LILITH', 'SUTURE', 'SOUVERAINETE', 'FIBONACCI'
+
+
+@dataclass
+class ResultatAnalyse:
+    """Contient tous les résultats bruts d'une analyse de fichier."""
+    fichier: str
+    fonctions: List[MetriqueFonction] = field(default_factory=list)
+    annotations: List[Annotation] = field(default_factory=list)
+    nb_classes: int = 0
+    nb_imports: int = 0
+    nb_lignes_total: int = 0
+    nb_commentaires: int = 0
+    oudjat: Optional[MetriqueFonction] = None
+
+
+# ────────────────────────────────────────────────────────
+# ANALYSEUR PRINCIPAL
+# ────────────────────────────────────────────────────────
+
+class AnalyseurPhi:
+    """
+    Analyseur fractal basé sur AST.
+    Dissèque le code Python pour extraire ses métriques souveraines.
+    """
+
+    def __init__(self, fichier: str):
+        self.fichier = fichier
+        self.tree: Optional[ast.AST] = None
+        self.lignes: List[str] = []
+        self.resultat = ResultatAnalyse(fichier=fichier)
+
+    def charger(self) -> "AnalyseurPhi":
+        """Charge et parse le fichier Python avec gestionnaire de contexte (Règle II)."""
+        with open(self.fichier, "r", encoding="utf-8") as f:
+            contenu = f.read()
+        self.lignes = contenu.splitlines()
+        self.tree = ast.parse(contenu, filename=self.fichier)
+        self._injecter_parents()
+        return self
+
+    def analyser(self) -> ResultatAnalyse:
+        """Lance l'analyse complète. Orchestre — ne calcule pas directement."""
+        if self.tree is None:
+            self.charger()
+        self.resultat.nb_lignes_total = len(self.lignes)
+        self._compter_elements_globaux()
+        self._analyser_fonctions()
+        self._appliquer_regles_souveraines()
+        self._identifier_oudjat()
+        return self.resultat
+
+    # ────────────────────────────────────────────────────────
+    # PRÉPARATION DE L'ARBRE AST
+    # ────────────────────────────────────────────────────────
+
+    def _injecter_parents(self):
+        """Injecte les références parent dans l'arbre AST pour la remontée."""
+        for node in ast.walk(self.tree):
+            for child in ast.iter_child_nodes(node):
+                child.parent = node
+
+    def _compter_elements_globaux(self):
+        """Compte classes, imports et commentaires (éléments macro)."""
+        for node in ast.walk(self.tree):
+            if isinstance(node, ast.ClassDef):
+                self.resultat.nb_classes += 1
+            elif isinstance(node, (ast.Import, ast.ImportFrom)):
+                self.resultat.nb_imports += 1
+        self.resultat.nb_commentaires = sum(
+            1 for ligne in self.lignes if ligne.strip().startswith("#")
+        )
+
+    # ────────────────────────────────────────────────────────
+    # ANALYSE DES FONCTIONS
+    # ────────────────────────────────────────────────────────
+
+    def _analyser_fonctions(self):
+        """Extrait les métriques de chaque fonction définie dans le fichier."""
+        for node in ast.walk(self.tree):
+            if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                metrique = self._mesurer_fonction(node)
+                self.resultat.fonctions.append(metrique)
+
+    def _mesurer_fonction(self, node: ast.AST) -> MetriqueFonction:
+        """Calcule toutes les métriques d'une seule fonction."""
+        end_line = getattr(node, "end_lineno", node.lineno)
+        nb_lignes = end_line - node.lineno + 1
+        return MetriqueFonction(
+            nom=node.name,
+            ligne=node.lineno,
+            complexite=len(list(ast.walk(node))),
+            nb_args=len(node.args.args),
+            nb_lignes=nb_lignes,
+            profondeur_max=self._profondeur_imbrication(node),
+            distance_fib=distance_fibonacci(nb_lignes),
+            phi_ratio=1.0,  # Calculé après, quand la moyenne est connue
+        )
+
+    def _identifier_oudjat(self):
+        """Identifie la fonction dominante et calcule les φ-ratios."""
+        if not self.resultat.fonctions:
+            return
+        self.resultat.oudjat = max(
+            self.resultat.fonctions, key=lambda f: f.complexite
+        )
+        self._calculer_phi_ratios()
+
+    def _calculer_phi_ratios(self):
+        """Normalise la complexité de chaque fonction par la moyenne."""
+        moyenne = sum(f.complexite for f in self.resultat.fonctions) / len(
+            self.resultat.fonctions
+        )
+        if moyenne == 0:
+            return
+        for f in self.resultat.fonctions:
+            f.phi_ratio = f.complexite / moyenne
+
+    # ────────────────────────────────────────────────────────
+    # RÈGLES DE CODAGE SOUVERAIN (4 règles hermétiques)
+    # ────────────────────────────────────────────────────────
+
+    def _appliquer_regles_souveraines(self):
+        """Applique les 4 règles souveraines à chaque nœud de l'AST."""
+        for node in ast.walk(self.tree):
+            self._regle_lilith(node)
+            self._regle_raii(node)
+            self._regle_fibonacci(node)
+            self._regle_hermeticite(node)
+
+    def _regle_lilith(self, node: ast.AST):
+        """Règle I — Nœuds d'Entropie : détecte les boucles trop imbriquées."""
+        if not isinstance(node, (ast.For, ast.While)):
+            return
+        depth = self._profondeur_noeud(node)
+        if depth >= 2:
+            self._annoter(
+                node.lineno,
+                f"LILITH : Boucle imbriquée (profondeur {depth}). "
+                "La variance s'accumule — envisagez une fonction auxiliaire.",
+                "CRITICAL" if depth >= 3 else "WARNING",
+                "LILITH"
+            )
+
+    def _regle_raii(self, node: ast.AST):
+        """Règle II — Intégrité du Cycle de Vie : open() exige un gestionnaire."""
+        if not isinstance(node, ast.Call):
+            return
+        if not self._est_appel_open(node):
+            return
+        parent = getattr(node, "parent", None)
+        grand_parent = getattr(parent, "parent", None)
+        if isinstance(parent, ast.withitem) or isinstance(grand_parent, ast.With):
+            return
+        self._annoter(
+            node.lineno,
+            "SUTURE : 'open()' sans gestionnaire de contexte (with). "
+            "Risque de traînée d'entropie (fuite de ressource).",
+            "WARNING",
+            "SUTURE"
+        )
+
+    def _regle_fibonacci(self, node: ast.AST):
+        """Règle III — Taille Naturelle : les fonctions suivent Fibonacci."""
+        if not isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            return
+        end_line = getattr(node, "end_lineno", node.lineno)
+        nb_lignes = end_line - node.lineno + 1
+        fib_proche = fibonacci_plus_proche(nb_lignes)
+        if nb_lignes > 55 and abs(nb_lignes - fib_proche) > 10:
+            self._annoter(
+                node.lineno,
+                f"FIBONACCI : '{node.name}' ({nb_lignes} lignes) s'éloigne "
+                f"de la séquence naturelle (idéal: {fib_proche}). "
+                "Scinder pour réduire la pression morphique.",
+                "WARNING",
+                "FIBONACCI"
+            )
+
+    def _regle_hermeticite(self, node: ast.AST):
+        """Règle IV — Herméticité : une fonction ne reçoit pas plus de 5 args."""
+        if not isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            return
+        nb_args = len(node.args.args)
+        if nb_args > 5:
+            self._annoter(
+                node.lineno,
+                f"SOUVERAINETÉ : '{node.name}' reçoit {nb_args} arguments. "
+                "Encapsuler dans un objet (max: 5 / idéal φ: 3).",
+                "INFO",
+                "SOUVERAINETE"
+            )
+
+    # ────────────────────────────────────────────────────────
+    # UTILITAIRES (fonctions pures, sans effets de bord)
+    # ────────────────────────────────────────────────────────
+
+    def _est_appel_open(self, node: ast.Call) -> bool:
+        """Retourne True si le nœud est un appel à open()."""
+        func = node.func
+        if isinstance(func, ast.Name):
+            return func.id == "open"
+        if isinstance(func, ast.Attribute):
+            return func.attr == "open"
+        return False
+
+    def _annoter(self, ligne: int, msg: str, niveau: str, categorie: str):
+        """Enregistre une annotation chirurgicale sur une ligne de code."""
+        extrait = self.lignes[ligne - 1].strip() if ligne <= len(self.lignes) else ""
+        self.resultat.annotations.append(
+            Annotation(ligne=ligne, message=msg, niveau=niveau,
+                       extrait=extrait, categorie=categorie)
+        )
+
+    def _profondeur_imbrication(self, fn_node: ast.AST) -> int:
+        """
+        Profondeur max d'imbrication à l'intérieur d'une fonction.
+        Utilise une pile explicite (pas de récursion) — Règle III (Fibonacci).
+        """
+        _NOEUD_CONTROLE = (ast.For, ast.While, ast.If, ast.With)
+        pile = [(fn_node, 0)]
+        max_depth = 0
+        while pile:
+            noeud, depth = pile.pop()
+            est_controle = isinstance(noeud, _NOEUD_CONTROLE)
+            profondeur_courante = depth + 1 if est_controle else depth
+            max_depth = max(max_depth, profondeur_courante if est_controle else depth)
+            for child in ast.iter_child_nodes(noeud):
+                pile.append((child, profondeur_courante))
+        return max_depth
+
+    def _profondeur_noeud(self, node: ast.AST) -> int:
+        """Profondeur globale d'un nœud via remontée des parents injectés."""
+        _NOEUD_COMPTABLE = (ast.For, ast.While, ast.If, ast.FunctionDef)
+        ancetres = self._remonter_parents(node)
+        return sum(1 for a in ancetres if isinstance(a, _NOEUD_COMPTABLE))
+
+    def _remonter_parents(self, node: ast.AST) -> list:
+        """Retourne la liste des nœuds ancêtres en remontant l'arbre."""
+        ancetres = []
+        curr = getattr(node, "parent", None)
+        while curr is not None:
+            ancetres.append(curr)
+            curr = getattr(curr, "parent", None)
+        return ancetres

phi_complexity/cli.py

@@ -0,0 +1,155 @@
+"""
+cli.py — Interface en ligne de commande souveraine.
+Suturée selon les recommandations de phi-complexity v0.1.0 (Protocole BMAD).
+main() décomposée en 5 fonctions hermétiques — Règle I : Herméticité de la Portée.
+"""
+import sys
+import os
+import argparse
+
+from . import auditer, rapport_console, rapport_markdown, rapport_json
+from .core import VERSION
+
+
+# ────────────────────────────────────────────────────────
+# CONSTRUCTION DU PARSEUR (hermétique, sans effets de bord)
+# ────────────────────────────────────────────────────────
+
+def _construire_parseur() -> argparse.ArgumentParser:
+    """Construit et retourne le parseur d'arguments. Aucun état global."""
+    parser = argparse.ArgumentParser(
+        prog="phi",
+        description="phi-complexity — Audit de code par les invariants du nombre d'or (φ)",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Exemples :
+  phi check mon_script.py
+  phi check ./src/ --min-radiance 75
+  phi report mon_script.py --output rapport.md
+  phi check mon_script.py --format json
+        """
+    )
+    parser.add_argument("--version", action="version", version=f"phi-complexity {VERSION}")
+
+    subparsers = parser.add_subparsers(dest="commande")
+
+    check = subparsers.add_parser("check", help="Auditer un fichier ou un dossier")
+    check.add_argument("cible", help="Fichier .py ou dossier à auditer")
+    check.add_argument("--min-radiance", type=float, default=0,
+                       help="Score minimum (exit code 1 si en-dessous)")
+    check.add_argument("--format", choices=["console", "json"], default="console",
+                       help="Format de sortie")
+
+    report = subparsers.add_parser("report", help="Générer un rapport Markdown")
+    report.add_argument("cible", help="Fichier .py à analyser")
+    report.add_argument("--output", "-o", default=None,
+                        help="Fichier de sortie (ex: rapport.md)")
+    return parser
+
+
+# ────────────────────────────────────────────────────────
+# COLLECTE DES FICHIERS (Suture des boucles LILITH)
+# ────────────────────────────────────────────────────────
+
+def _fichiers_depuis_dossier(dossier: str) -> list:
+    """Collecte récursivement les .py d'un dossier (boucles isolées)."""
+    fichiers = []
+    for racine, _, noms in os.walk(dossier):
+        fichiers.extend(
+            os.path.join(racine, nom)
+            for nom in noms
+            if nom.endswith(".py")
+        )
+    return sorted(fichiers)
+
+
+def _collecter_fichiers(cible: str) -> list:
+    """Retourne la liste des fichiers Python à auditer depuis un chemin."""
+    if os.path.isfile(cible):
+        return [cible] if cible.endswith(".py") else []
+    if os.path.isdir(cible):
+        return _fichiers_depuis_dossier(cible)
+    return []
+
+
+# ────────────────────────────────────────────────────────
+# EXÉCUTION DES SOUS-COMMANDES (une fonction par rôle)
+# ────────────────────────────────────────────────────────
+
+def _executer_check(args: argparse.Namespace, fichiers: list) -> int:
+    """Exécute la sous-commande 'check'. Retourne le code de sortie."""
+    exit_code = 0
+    for fichier in fichiers:
+        exit_code = max(exit_code, _auditer_un_fichier(fichier, args))
+    return exit_code
+
+
+def _auditer_un_fichier(fichier: str, args: argparse.Namespace) -> int:
+    """Audite un seul fichier et affiche le résultat. Retourne 0 ou 1."""
+    try:
+        if args.format == "json":
+            print(rapport_json(fichier))
+        else:
+            print(rapport_console(fichier))
+            print()
+
+        if args.min_radiance > 0:
+            metriques = auditer(fichier)
+            if metriques["radiance"] < args.min_radiance:
+                return 1
+    except SyntaxError as e:
+        print(f"⚠ Erreur de syntaxe dans {fichier}: {e}")
+        return 1
+    except Exception as e:
+        print(f"⚠ Erreur lors de l'analyse de {fichier}: {e}")
+        return 1
+    return 0
+
+
+def _executer_report(args: argparse.Namespace, fichiers: list) -> int:
+    """Exécute la sous-commande 'report'. Retourne le code de sortie."""
+    for fichier in fichiers:
+        sortie = _nom_rapport(fichier, args.output)
+        try:
+            rapport_markdown(fichier, sortie=sortie)
+            print(f"✦ Rapport sauvegardé : {sortie}")
+        except Exception as e:
+            print(f"❌ Erreur : {e}")
+            return 1
+    return 0
+
+
+def _nom_rapport(fichier: str, sortie_demandee: str) -> str:
+    """Calcule le nom du fichier rapport de sortie."""
+    if sortie_demandee:
+        return sortie_demandee
+    base = os.path.splitext(os.path.basename(fichier))[0]
+    return f"RAPPORT_PHI_{base}.md"
+
+
+# ────────────────────────────────────────────────────────
+# POINT D'ENTRÉE (hermétique — orchestre uniquement)
+# ────────────────────────────────────────────────────────
+
+def main():
+    """Point d'entrée principal. Délègue à des fonctions spécialisées."""
+    parser = _construire_parseur()
+    args = parser.parse_args()
+
+    if not args.commande:
+        parser.print_help()
+        sys.exit(0)
+
+    fichiers = _collecter_fichiers(args.cible)
+    if not fichiers:
+        print(f"❌ Aucun fichier Python trouvé dans : {args.cible}")
+        sys.exit(1)
+
+    if args.commande == "check":
+        sys.exit(_executer_check(args, fichiers))
+    elif args.commande == "report":
+        sys.exit(_executer_report(args, fichiers))
+
+
+if __name__ == "__main__":
+    main()

phi_complexity/core.py

@@ -0,0 +1,65 @@
+"""
+phi_complexity — Mesure de la qualité du code par les invariants du nombre d'or.
+Constantes Souveraines issues du Morphic Phi Framework (Tomy Verreault, 2026).
+"""
+import math
+
+# ============================================================
+# CONSTANTES SOUVERAINES (Bibliothèque Céleste — φ-Meta)
+# ============================================================
+
+PHI = (1 + math.sqrt(5)) / 2
+"""Le nombre d'or. CM-001. L'attracteur universel de l'harmonie."""
+
+PHI_INV = 1 / PHI
+"""Inverse du nombre d'or. φ⁻¹ = φ - 1 ≈ 0.6180"""
+
+TAXE_SUTURE = 3 / math.sqrt(7)
+"""Taxe de Suture (CM-018). Coût minimal d'une correction morphique."""
+
+ETA_GOLDEN = 1 - PHI_INV
+"""Facteur η doré. Seuil de tolérance: si phi_ratio < ETA, le code est fragmenté."""
+
+ZETA_PLANCHER = PHI_INV ** 2
+"""Plancher Zeta. En-dessous, le système perd sa résonance."""
+
+SEUIL_RADIANCE_HARMONIEUX = 85
+"""Score au-delà duquel le code est considéré 'Hermétique' (stable + harmonieux)."""
+
+SEUIL_RADIANCE_EN_EVEIL = 60
+"""Score intermédiaire. Le code 'En Éveil' a du potentiel mais des zones d'entropie."""
+
+SEUIL_RADIANCE_DORMANT = 0
+"""En-dessous de 60: le code 'Dormant' nécessite une suture profonde."""
+
+SEQUENCE_FIBONACCI = [1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377]
+"""Première séquence de Fibonacci. Tailles naturelles d'une fonction harmonieuse."""
+
+VERSION = "0.1.0"
+AUTEUR = "Tomy Verreault"
+FRAMEWORK = "Morphic Phi Framework (φ-Meta)"
+
+
+def statut_gnostique(score: float) -> str:
+    """Retourne le verdict gnostique basé sur le score de radiance."""
+    if score >= SEUIL_RADIANCE_HARMONIEUX:
+        return "HERMÉTIQUE ✦"
+    elif score >= SEUIL_RADIANCE_EN_EVEIL:
+        return "EN ÉVEIL ◈"
+    else:
+        return "DORMANT ░"
+
+
+def fibonacci_plus_proche(n: int) -> int:
+    """Retourne le nombre de Fibonacci le plus proche de n."""
+    closest = SEQUENCE_FIBONACCI[0]
+    for f in SEQUENCE_FIBONACCI:
+        if abs(f - n) < abs(closest - n):
+            closest = f
+    return closest
+
+
+def distance_fibonacci(n: int) -> float:
+    """Mesure l'écart entre n et son Fibonacci idéal (normalise par φ)."""
+    fib = fibonacci_plus_proche(n)
+    return abs(n - fib) / PHI

phi_complexity/metriques.py

@@ -0,0 +1,206 @@
+"""
+metriques.py — Calcul de l'Indice de Radiance et des métriques φ-Meta.
+Suturée selon les recommandations de phi-complexity v0.1.0 (Protocole BMAD).
+'calculer()' décomposée en fonctions hermétiques — Règle I + Règle IV (Fibonacci).
+Formule fondatrice : Radiance = 100 - f(Var_Lilith) - g(Entropie) - h(Anomalies) - i(Fibonacci)
+"""
+import math
+from typing import List
+
+from .core import (
+    PHI, TAXE_SUTURE, ETA_GOLDEN,
+    statut_gnostique
+)
+from .analyseur import ResultatAnalyse
+
+
+class CalculateurRadiance:
+    """
+    Transforme les métriques brutes en Indice de Radiance (0-100).
+    Ancrage : AX-A39 (Attracteur Doré) + EQ-AFR-BMAD (Loi Antifragile).
+    """
+
+    def __init__(self, resultat: ResultatAnalyse):
+        self.r = resultat
+
+    # ────────────────────────────────────────────────────────
+    # API PUBLIQUE
+    # ────────────────────────────────────────────────────────
+
+    def calculer(self) -> dict:
+        """Orchestre le calcul — délègue tout aux fonctions spécialisées."""
+        if not self.r.fonctions:
+            return self._resultat_vide()
+        brutes = self._extraire_mesures()
+        radiance = self._indice_radiance(brutes)
+        return self._assembler_resultat(brutes, radiance)
+
+    # ────────────────────────────────────────────────────────
+    # EXTRACTION DES MESURES BRUTES (hermétique)
+    # ────────────────────────────────────────────────────────
+
+    def _extraire_mesures(self) -> dict:
+        """Extrait toutes les mesures brutes depuis le résultat d'analyse."""
+        complexites = [f.complexite for f in self.r.fonctions]
+        return {
+            "complexites": complexites,
+            "lilith_variance": self._variance(complexites),
+            "shannon_entropy": self._entropie_shannon(complexites),
+            "phi_ratio": self._phi_ratio(complexites),
+            "fibonacci_distance": sum(f.distance_fib for f in self.r.fonctions),
+            "zeta_score": self._zeta_score(complexites),
+            "nb_anomalies": len([
+                a for a in self.r.annotations
+                if a.niveau in ("WARNING", "CRITICAL")
+            ]),
+        }
+
+    # ────────────────────────────────────────────────────────
+    # ASSEMBLAGE DU RÉSULTAT (hermétique)
+    # ────────────────────────────────────────────────────────
+
+    def _assembler_resultat(self, brutes: dict, radiance: float) -> dict:
+        """Construit le dictionnaire final à partir des mesures et du score."""
+        phi_ratio = brutes["phi_ratio"]
+        return {
+            "fichier": self.r.fichier,
+            "radiance": round(radiance, 2),
+            "statut_gnostique": statut_gnostique(radiance),
+            "lilith_variance": round(brutes["lilith_variance"], 3),
+            "shannon_entropy": round(brutes["shannon_entropy"], 3),
+            "phi_ratio": round(phi_ratio, 3),
+            "phi_ratio_delta": round(abs(phi_ratio - PHI), 3),
+            "fibonacci_distance": round(brutes["fibonacci_distance"], 3),
+            "zeta_score": round(brutes["zeta_score"], 4),
+            "nb_fonctions": len(self.r.fonctions),
+            "nb_classes": self.r.nb_classes,
+            "nb_imports": self.r.nb_imports,
+            "nb_lignes_total": self.r.nb_lignes_total,
+            "ratio_commentaires": round(
+                self.r.nb_commentaires / max(1, self.r.nb_lignes_total), 3
+            ),
+            "oudjat": self._serialiser_oudjat(),
+            "annotations": self._serialiser_annotations(),
+        }
+
+    def _serialiser_oudjat(self) -> dict:
+        """Sérialise la fonction Oudjat (la plus complexe) en dictionnaire."""
+        if not self.r.oudjat:
+            return None
+        o = self.r.oudjat
+        return {
+            "nom": o.nom,
+            "ligne": o.ligne,
+            "complexite": o.complexite,
+            "nb_lignes": o.nb_lignes,
+            "phi_ratio": round(o.phi_ratio, 3),
+        }
+
+    def _serialiser_annotations(self) -> list:
+        """Sérialise la liste des annotations en dictionnaires."""
+        return [
+            {
+                "ligne": a.ligne,
+                "niveau": a.niveau,
+                "categorie": a.categorie,
+                "message": a.message,
+                "extrait": a.extrait,
+            }
+            for a in self.r.annotations
+        ]
+
+    # ────────────────────────────────────────────────────────
+    # FORMULE FONDATRICE — INDICE DE RADIANCE
+    # ────────────────────────────────────────────────────────
+
+    def _indice_radiance(self, brutes: dict) -> float:
+        """
+        R = 100 - f(Lilith) - g(Shannon) - h(Anomalies) - i(Fibonacci)
+        Chaque déduction est plafonnée (Loi d'Indulgence).
+        Plancher : 40 (Loi Antifragile — EQ-AFR-BMAD).
+        """
+        score = 100.0
+        score -= self._deduction_lilith(brutes["lilith_variance"])
+        score -= self._deduction_entropie(brutes["shannon_entropy"])
+        score -= self._deduction_anomalies(brutes["nb_anomalies"])
+        score -= self._deduction_fibonacci(brutes["fibonacci_distance"])
+        return max(40.0, score)
+
+    def _deduction_lilith(self, variance: float) -> float:
+        """f(Lilith) = min(25, (σ²_L / seuil) × 25). Seuil naturel = φ² × 100."""
+        seuil = PHI ** 2 * 100
+        return min(25.0, (variance / seuil) * 25.0)
+
+    def _deduction_entropie(self, entropie: float) -> float:
+        """g(H) = min(20, max(0, H - H_max) × 5). H_max = log₂(φ⁴) ≈ 2.88 bits."""
+        seuil = math.log2(PHI ** 4)
+        return min(20.0, max(0.0, entropie - seuil) * 5.0)
+
+    def _deduction_anomalies(self, nb: int) -> float:
+        """h(A) = min(30, A × τ_L × 3). τ_L = Taxe de Suture (CM-018)."""
+        return min(30.0, nb * TAXE_SUTURE * 3)
+
+    def _deduction_fibonacci(self, distance: float) -> float:
+        """i(D_F) = min(10, D_F × η_golden)."""
+        return min(10.0, distance * ETA_GOLDEN)
+
+    # ────────────────────────────────────────────────────────
+    # FORMULES MATHÉMATIQUES SOUVERAINES (atomiques)
+    # ────────────────────────────────────────────────────────
+
+    def _variance(self, valeurs: List[float]) -> float:
+        """σ²_L = (1/n) · Σ(κᵢ - μ)². Variance de Lilith."""
+        if not valeurs:
+            return 0.0
+        mean = sum(valeurs) / len(valeurs)
+        return sum((v - mean) ** 2 for v in valeurs) / len(valeurs)
+
+    def _entropie_shannon(self, valeurs: List[float]) -> float:
+        """H = -Σ pᵢ · log₂(pᵢ). Entropie de Shannon normalisée."""
+        if not valeurs:
+            return 0.0
+        total = sum(valeurs)
+        if total == 0:
+            return 0.0
+        probas = [v / total for v in valeurs]
+        return -sum(p * math.log2(p) for p in probas if p > 0)
+
+    def _phi_ratio(self, valeurs: List[float]) -> float:
+        """φ-ratio = max(κ) / μ. Doit tendre vers φ = 1.618."""
+        if not valeurs or len(valeurs) < 2:
+            return 1.0
+        mean = sum(valeurs) / len(valeurs)
+        return (max(valeurs) / mean) if mean else 1.0
+
+    def _zeta_score(self, valeurs: List[float]) -> float:
+        """ζ_meta = min(1, [Σ 1/(i+1)^φ / n] × φ). Résonance globale."""
+        if not valeurs:
+            return 0.0
+        n = len(valeurs)
+        zeta = sum(1.0 / ((i + 1) ** PHI) for i in range(n)) / n
+        return min(1.0, zeta * PHI)
+
+    # ────────────────────────────────────────────────────────
+    # RÉSULTAT NEUTRE (fichiers sans fonctions)
+    # ────────────────────────────────────────────────────────
+
+    def _resultat_vide(self) -> dict:
+        """Score neutre (60) pour les fichiers de constantes ou de configuration."""
+        return {
+            "fichier": self.r.fichier,
+            "radiance": 60.0,
+            "statut_gnostique": statut_gnostique(60.0),
+            "lilith_variance": 0.0,
+            "shannon_entropy": 0.0,
+            "phi_ratio": 1.0,
+            "phi_ratio_delta": PHI - 1.0,
+            "fibonacci_distance": 0.0,
+            "zeta_score": 0.0,
+            "nb_fonctions": 0,
+            "nb_classes": self.r.nb_classes,
+            "nb_imports": self.r.nb_imports,
+            "nb_lignes_total": self.r.nb_lignes_total,
+            "ratio_commentaires": 0.0,
+            "oudjat": None,
+            "annotations": [],
+        }

phi_complexity/rapport.py

@@ -0,0 +1,166 @@
+"""
+rapport.py — Génération du Rapport de Radiance Premium (Markdown + Console).
+Style "CodeRabbit × Bibliothèque Céleste".
+"""
+import datetime
+import json
+
+
+class GenerateurRapport:
+    """Transforme un dictionnaire de métriques en rapport premium."""
+
+    def __init__(self, metriques: dict):
+        self.m = metriques
+
+    # ──────────────────────────────────────────────
+    # RENDU CONSOLE (ASCII Premium)
+    # ──────────────────────────────────────────────
+
+    def console(self) -> str:
+        """Sortie console premium avec barres visuelles."""
+        m = self.m
+        score = m["radiance"]
+        barre = self._barre(score)
+        phi_r = m.get("phi_ratio", 1.0)
+        delta = m.get("phi_ratio_delta", 0.0)
+        phi_icon = "✦" if delta < 0.15 else "◈" if delta < 0.5 else "░"
+
+        lignes = [
+            "╔══════════════════════════════════════════════════╗",
+            "║      PHI-COMPLEXITY — AUDIT DE RADIANCE          ║",
+            "╚══════════════════════════════════════════════════╝",
+            "",
+            f"  📄 Fichier : {m['fichier']}",
+            f"  📅 Date    : {datetime.datetime.now().strftime('%Y-%m-%d %H:%M')}",
+            "",
+            f"  ☼  RADIANCE     : {barre}  {score} / 100",
+            f"  ⚖  LILITH       : {m['lilith_variance']:.2f}  (Variance structurelle)",
+            f"  🌊 ENTROPIE     : {m['shannon_entropy']:.3f} bits  (Shannon)",
+            f"  {phi_icon}  PHI-RATIO    : {phi_r:.3f}  (idéal: φ = 1.618, Δ={delta:.3f})",
+            f"  ζ  ZETA-SCORE   : {m['zeta_score']:.4f}  (Résonance globale)",
+            "",
+        ]
+
+        # Statut gnostique
+        lignes.append(f"  STATUT : {m['statut_gnostique']}")
+        lignes.append("")
+
+        # Oudjat
+        if m.get("oudjat"):
+            o = m["oudjat"]
+            lignes.append(
+                f"  🔎 OUDJAT : '{o['nom']}' (Ligne {o['ligne']}, "
+                f"Complexité: {o['complexite']}, φ-ratio: {o['phi_ratio']})"
+            )
+            lignes.append("")
+
+        # Annotations
+        annotations = m.get("annotations", [])
+        if annotations:
+            lignes.append(f"  ⚠  SUTURES IDENTIFIÉES ({len(annotations)}) :")
+            for ann in annotations:
+                icon = "🔴" if ann["niveau"] == "CRITICAL" else "🟡" if ann["niveau"] == "WARNING" else "🔵"
+                lignes.append(f"  {icon} Ligne {ann['ligne']} [{ann['categorie']}] : {ann['message']}")
+                lignes.append(f"     >> {ann['extrait']}")
+        else:
+            lignes.append("  ✦  Aucune rupture de radiance majeure détectée.")
+
+        lignes.append("")
+        lignes.append("  ─────────────────────────────────────────────────")
+        lignes.append(f"  Ancré dans le Morphic Phi Framework — φ-Meta 2026")
+
+        return "\n".join(lignes)
+
+    # ──────────────────────────────────────────────
+    # RENDU MARKDOWN (Premium)
+    # ──────────────────────────────────────────────
+
+    def markdown(self) -> str:
+        """Rapport Markdown complet, style Bibliothèque Céleste."""
+        m = self.m
+        score = m["radiance"]
+        barre = self._barre_md(score)
+        date = datetime.datetime.now().strftime("%Y-%m-%d %H:%M")
+
+        rapport = f"# ☼ RAPPORT DE RADIANCE : {m['fichier']}\n\n"
+        rapport += f"**Date de l'Audit** : {date}  \n"
+        rapport += f"**Statut Gnostique** : **{m['statut_gnostique']}**\n\n"
+
+        # Section 1 — Score
+        rapport += "## 1. INDICE DE RADIANCE\n\n"
+        rapport += f"**Score : {score} / 100**\n\n"
+        rapport += f"`[{barre}]` {score}%\n\n"
+
+        # Section 2 — Métriques brutes
+        rapport += "## 2. MÉTRIQUES SOUVERAINES\n\n"
+        rapport += "| Métrique | Valeur | Interprétation |\n"
+        rapport += "|---|---|---|\n"
+        rapport += f"| **Variance de Lilith** | {m['lilith_variance']} | Instabilité structurelle |\n"
+        rapport += f"| **Entropie de Shannon** | {m['shannon_entropy']} bits | Densité informationnelle |\n"
+        rapport += f"| **φ-Ratio** | {m['phi_ratio']} (Δ={m['phi_ratio_delta']}) | Idéal: 1.618 |\n"
+        rapport += f"| **Zeta-Score** | {m['zeta_score']} | Résonance globale |\n"
+        rapport += f"| **Distance Fibonacci** | {m['fibonacci_distance']} | Éloignement des tailles naturelles |\n"
+        rapport += f"| **Fonctions analysées** | {m['nb_fonctions']} | — |\n"
+        rapport += f"| **Ratio commentaires** | {m['ratio_commentaires']} | Densité de sagesse |\n\n"
+
+        # Section 3 — Oudjat
+        if m.get("oudjat"):
+            o = m["oudjat"]
+            rapport += "## 3. IDENTIFICATION DE L'OUDJAT\n\n"
+            rapport += f"La fonction la plus 'chargée' est **`{o['nom']}`** (Ligne {o['ligne']}).\n\n"
+            rapport += f"- Pression : **{o['complexite']}** unités de complexité\n"
+            rapport += f"- Taille   : **{o['nb_lignes']}** lignes\n"
+            rapport += f"- φ-Ratio  : **{o['phi_ratio']}** (idéal: 1.618)\n\n"
+
+        # Section 4 — Audit Fractal
+        rapport += "## 4. REVUE DE DÉTAIL (AUDIT FRACTAL)\n\n"
+        annotations = m.get("annotations", [])
+        if not annotations:
+            rapport += "☼ Aucune rupture de radiance majeure détectée au niveau micro.\n\n"
+        else:
+            rapport += f"Phidélia a identifié **{len(annotations)}** zones nécessitant une suture :\n\n"
+            for ann in annotations:
+                niveau_md = (
+                    "CAUTION" if ann["niveau"] == "CRITICAL"
+                    else "WARNING" if ann["niveau"] == "WARNING"
+                    else "NOTE"
+                )
+                rapport += f"> [!{niveau_md}]\n"
+                rapport += f"> **Ligne {ann['ligne']}** `[{ann['categorie']}]` : {ann['message']}\n"
+                rapport += f"> `>> {ann['extrait']}`\n\n"
+
+        # Pied de page
+        rapport += "---\n"
+        rapport += "*phi-complexity — Morphic Phi Framework (φ-Meta) — Tomy Verreault, 2026*\n"
+        return rapport
+
+    # ──────────────────────────────────────────────
+    # RENDU JSON (CI/CD)
+    # ──────────────────────────────────────────────
+
+    def json(self) -> str:
+        """Sortie JSON structurée pour intégrations CI/CD."""
+        return json.dumps(self.m, ensure_ascii=False, indent=2)
+
+    def sauvegarder_markdown(self, chemin: str) -> str:
+        """Sauvegarde le rapport Markdown dans un fichier."""
+        contenu = self.markdown()
+        with open(chemin, "w", encoding="utf-8") as f:
+            f.write(contenu)
+        return chemin
+
+    # ──────────────────────────────────────────────
+    # UTILITAIRES INTERNES
+    # ──────────────────────────────────────────────
+
+    def _barre(self, score: float, largeur: int = 20) -> str:
+        """Barre de progression ASCII pour le terminal."""
+        rempli = int(score / 100 * largeur)
+        vide = largeur - rempli
+        return "█" * rempli + "░" * vide
+
+    def _barre_md(self, score: float, largeur: int = 10) -> str:
+        """Barre de progression pour Markdown (blocs compacts)."""
+        rempli = int(score / 100 * largeur)
+        vide = largeur - rempli
+        return "█" * rempli + "░" * vide

phi_complexity-0.1.0.dist-info/METADATA

@@ -0,0 +1,195 @@
+Metadata-Version: 2.4
+Name: phi-complexity
+Version: 0.1.0
+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)](LICENSE)
+[![Tests](https://img.shields.io/badge/tests-26%20passed-brightgreen)](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](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.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+phi_complexity/__init__.py,sha256=xGQww_n93XUN5riPyfL3B5H24y2OQLugHBtD8TYNqFo,1741
+phi_complexity/__main__.py,sha256=wTpiY2HgLrOwkC0d8xaxdQKMlfTdxYD5VsEURBNbAes,95
+phi_complexity/analyseur.py,sha256=-noONOZZDtbE-PRUIEza0sBIxMupcv5oewK5l0cwBDk,12654
+phi_complexity/cli.py,sha256=R2EfOohIKXX0VMp87mWVj_YWIbxo4LE1rWiQNmlnxEQ,6343
+phi_complexity/core.py,sha256=Ve-l8unuTiM8r0p1Uh6NY0ilnZppLUEKyPLJvjM8BbY,2212
+phi_complexity/metriques.py,sha256=wqSS7yPeI3SYUl9SR6TFvopT5xvxAXhtkMpMMERiGFE,9627
+phi_complexity/rapport.py,sha256=j36Kd_CAZcOBNvWnNd2bjYts6rINRSgDVms4ZMW9PPU,8263
+phi_complexity-0.1.0.dist-info/licenses/LICENSE,sha256=md-TjCTfPjXoeOP4XvvtJKBHPId5AkIOvVwuWbprrs4,1366
+phi_complexity-0.1.0.dist-info/METADATA,sha256=ekB6vX59qXJz68fnod0LCySW1qpKAGVWMJa4zn_Xf4o,6725
+phi_complexity-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+phi_complexity-0.1.0.dist-info/entry_points.txt,sha256=B0x1ktY2xjWDo2k-gtVGmyXfJ3CFOhJdf1hFmfOdjmI,48
+phi_complexity-0.1.0.dist-info/top_level.txt,sha256=6s7VRAAiW9wHbIBuCR-ZKdIfmi6GPzxj02ZRKcMDB5Q,15
+phi_complexity-0.1.0.dist-info/RECORD,,

phi_complexity-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

phi_complexity-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+phi = phi_complexity.cli:main

phi_complexity-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,28 @@
+MIT License
+
+Copyright (c) 2026 Tomy Verreault
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+---
+
+This software is anchored in the Bibliothèque Céleste — Morphic Phi Framework (φ-Meta).
+The mathematical foundations are derived from the work of Tomy Verreault (2026),
+integrating principles from the Quasicrystal Axioms (AX-A0–AX-A58) and the
+Antifragility Protocol (EQ-AFR-BMAD).

phi_complexity-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+phi_complexity