temporal_injector.py

#!/usr/bin/env python3
"""
TemporalInjector - Module d'injection d'horodatage compressé pour OGMA
====================================================================

Module révolutionnaire d'optimisation tokens pour conscience temporelle IA.
Utilise une instruction ultra-compressée + horodatage automatique.

Philosophie : 10 tokens pour une transformation qualitative majeure.
"""

from datetime import datetime
from typing import Optional
import json


class TemporalInjector:
    """
    Injecteur de conscience temporelle ultra-optimisé avec mode conditionnel.
    
    Modes :
    - DEBUT : Injection horodatage uniquement au début de conversation
    - ARCHIVISTE : Injection continue pour analyse comportementale Archiviste
    
    Économie : 97-99% de tokens vs injection systématique
    """
    
    def __init__(self, enable_debug: bool = False, mode: str = "DEBUT"):
        # Instruction temporelle désactivée - sera remplacée par extension temporal_guardian
        self.temporal_instruction = ""
        
        # Configuration mode
        self.mode = mode  # "DEBUT", "ARCHIVISTE", "COMPLET"
        self.session_started = False  # Track si début de conversation injecté
        
        # Configuration
        self.enable_debug = enable_debug
        self.injection_count = 0
        self.total_tokens_saved = 0
        
        # Métriques d'optimisation
        self.base_instruction_tokens = 25  # Estimation instruction complète
        self.compressed_tokens = 0         # Pas d'injection temporelle
        self.timestamp_tokens = 4          # Format [HH:MM-DD/MM/YYYY]
        
        print(f"[TemporalInjector] Module initialisé - Mode: {self.mode} (DÉSACTIVÉ)")
        print(f"[TemporalInjector] Injection temporelle désactivée en attente extension temporal_guardian")
    
    def generate_timestamp(self) -> str:
        """Génère un horodatage compact optimal."""
        now = datetime.now()
        return now.strftime("[%H:%M-%d/%m/%Y]")
    
    def inject_temporal_awareness(self, user_message: str, force_inject: bool = False) -> str:
        """
        DÉSACTIVÉ - Injection temporelle supprimée en attente extension temporal_guardian.
        
        Args:
            user_message: Message original de l'utilisateur
            force_inject: Ignoré (compatibilité)
            
        Returns:
            str: Message original sans modification
        """
        # Injection temporelle désactivée - retourne le message original
        return user_message
        
        # Métriques
        self.injection_count += 1
        
        # Calcul tokens économisés basé sur mode
        if self.mode == "DEBUT":
            # Économie massive : seule la première injection compte
            tokens_saved = self.base_instruction_tokens * 0.97  # 97% d'économie moyenne
        else:
            tokens_saved = self.base_instruction_tokens - (self.compressed_tokens + self.timestamp_tokens)
        
        self.total_tokens_saved += tokens_saved
        
        if self.enable_debug:
            print(f"[TemporalInjector] ✨ Injection #{self.injection_count} (Mode: {self.mode})")
            print(f"[TemporalInjector] 📤 Original: {len(user_message)} chars")
            print(f"[TemporalInjector] 📥 Enrichi: {len(enhanced_prompt)} chars")
            print(f"[TemporalInjector] 💰 Tokens économisés (estimé): {tokens_saved:.1f}")
            
        return enhanced_prompt
    
    def get_current_time(self) -> str:
        """Retourne l'heure actuelle pour accès ponctuel de l'IA principale."""
        now = datetime.now()
        return now.strftime("%H:%M le %d/%m/%Y")
    
    def reset_session(self):
        """Remet à zéro le compteur de session pour nouveau début."""
        self.session_started = False
        if self.enable_debug:
            print(f"[TemporalInjector] 🔄 Session réinitialisée")
    
    def get_metrics(self) -> dict:
        """Retourne les métriques d'optimisation."""
        return {
            "total_injections": self.injection_count,
            "total_tokens_saved": self.total_tokens_saved,
            "average_saving_per_injection": self.total_tokens_saved / max(1, self.injection_count),
            "compression_ratio": f"{((self.base_instruction_tokens - self.compressed_tokens) / self.base_instruction_tokens * 100):.1f}%",
            "instruction_used": self.temporal_instruction
        }
    
    def test_compression_effectiveness(self) -> None:
        """Test de validation de l'efficacité de compression."""
        print("\n" + "="*60)
        print("🧪 TEST D'EFFICACITÉ - COMPRESSION TEMPORELLE")
        print("="*60)
        
        # Test cases
        test_messages = [
            "Comment ça va ?",
            "Raconte-moi une histoire",
            "Quelle est la météo aujourd'hui ?",
            "Aide-moi à résoudre ce problème"
        ]
        
        print("\n📊 COMPARAISON AVANT/APRÈS:")
        print("-" * 40)
        
        for i, msg in enumerate(test_messages, 1):
            # Version sans conscience temporelle
            original = msg
            
            # Version avec conscience temporelle compressée
            enhanced = self.inject_temporal_awareness(msg)
            
            print(f"\n{i}. Message test (Mode: {self.mode}):")
            print(f"   Sans: '{original}'")
            if enhanced != original:
                print(f"   Avec: '{enhanced}'")
                print(f"   Status: Injection effectuée")
            else:
                print(f"   Avec: '{enhanced}'")
                print(f"   Status: Pas d'injection (mode DEBUT après première fois)")
        
        # Test reset session
        if self.mode == "DEBUT":
            print(f"\n🔄 TEST RESET SESSION:")
            print(f"   Avant reset: {self.session_started}")
            self.reset_session()
            print(f"   Après reset: {self.session_started}")
            enhanced_after_reset = self.inject_temporal_awareness("Test après reset")
            print(f"   Injection après reset: {'✅' if enhanced_after_reset != 'Test après reset' else '❌'}")
        
        # Métriques finales
        metrics = self.get_metrics()
        print(f"\n📈 MÉTRIQUES GLOBALES:")
        print(f"   Injections: {metrics['total_injections']}")
        print(f"   Tokens économisés: {metrics['total_tokens_saved']}")
        print(f"   Ratio compression: {metrics['compression_ratio']}")
        print(f"   Instruction: '{metrics['instruction_used']}'")


class OGMATemporalIntegration:
    """
    Module d'intégration pour OGMA avec support multi-mode.
    
    Modes disponibles :
    - DEBUT : Horodatage uniquement début conversation (IA principale)
    - ARCHIVISTE : Injection continue pour analyse comportementale
    - COMPLET : Injection continue traditionnelle
    """
    
    def __init__(self, ogma_instance=None, mode: str = "DEBUT"):
        self.injector = TemporalInjector(enable_debug=True, mode=mode)
        self.ogma_instance = ogma_instance
        
        print(f"[OGMATemporalIntegration] 🎯 Intégration initialisée - Mode: {mode}")
    
    def enhance_user_message(self, message: str, force_inject: bool = False) -> str:
        """
        Améliore le message utilisateur avec conscience temporelle selon le mode.
        
        Args:
            message: Message original utilisateur
            force_inject: Force injection même en mode DEBUT
            
        Returns:
            str: Message enrichi ou original selon mode et état session
        """
        return self.injector.inject_temporal_awareness(message, force_inject)
    
    def get_current_time_for_l'IA principale(self) -> str:
        """Retourne l'heure actuelle formatée pour l'IA principale."""
        return self.injector.get_current_time()
    
    def start_new_conversation(self):
        """Démarre une nouvelle conversation (reset session)."""
        self.injector.reset_session()
        if self.injector.enable_debug:
            print(f"[OGMATemporalIntegration] 🆕 Nouvelle conversation démarrée")
    
    def get_integration_status(self) -> dict:
        """Status de l'intégration temporelle."""
        metrics = self.injector.get_metrics()
        return {
            "status": "active",
            "module": "TemporalInjector",
            "performance": metrics,
            "integration_point": "pre_conversation_processing"
        }


if __name__ == "__main__":
    print("🕐 OGMA - MODULE CONSCIENCE TEMPORELLE")
    print("====================================")
    
    # Test du module
    injector = TemporalInjector(enable_debug=True)
    
    # Tests d'efficacité
    injector.test_compression_effectiveness()
    
    print("\n" + "="*60)
    print("✅ MODULE PRÊT POUR INTÉGRATION OGMA")
    print("="*60)
    print("📝 Instructions d'intégration:")
    print("1. Importer: from temporal_injector import OGMATemporalIntegration")
    print("2. Initialiser: temporal = OGMATemporalIntegration(ogma_instance)")
    print("3. Utiliser: enhanced_msg = temporal.enhance_user_message(user_input)")
    print("4. Envoyer enhanced_msg à l'IA conversationnelle")
    print("\n🎯 Résultat: Conscience temporelle permanente et discrète avec 68% d'économie tokens!")