@misterscan/sesi 1.2.3 → 1.3.2

package/main/terminal_chat.py

@@ -1,385 +0,0 @@
-import json
-import random
-import time
-import sys
-import math
-
-# Force system stdout to use UTF-8 encoding to prevent Windows cp1252 character maps exceptions
-try:
-    sys.stdout.reconfigure(encoding='utf-8')
-except Exception:
-    pass
-
-# Color codes for terminal aesthetics
-RESET = "\033[0m"
-BOLD = "\033[1m"
-GREEN = "\033[32m"
-CYAN = "\033[36m"
-MAGENTA = "\033[35m"
-YELLOW = "\033[33m"
-BLUE = "\033[34m"
-RED = "\033[31m"
-WHITE = "\033[37m"
-
-# HSL-aligned color palette for terminal visual excellence
-COLOR_AUDIO = CYAN
-COLOR_MECH = YELLOW
-COLOR_SYS = MAGENTA
-
-VOCAB = ["synthesizer", "vinyl", "record", "wood", "gears", "clock", "compiler", "framework", "memory", "offline"]
-CLASSES = ["audio", "mechanical", "systems"]
-
-def print_ascii_header():
-    print(BOLD + CYAN + "======================================================================" + RESET)
-    print(BOLD + BLUE + "   [NEURAL]  SESI NATIVELY NEURAL-EMPATHETIC TERMINAL CHAT REPL v4.0" + RESET)
-    print(BOLD + CYAN + "======================================================================" + RESET)
-    print(WHITE + "Welcome, Operator! Interactive neural dial-in gateway is online.")
-    print("Zero-shot character bios trained offline. Synapses fully operational.\n" + RESET)
-
-def get_persona_category(persona):
-    desc = (persona["personality"] + " " + persona["tone"]).lower()
-    audio_keys = ["synthesizer", "jazz", "music", "audio", "chiptune", "beatmaker", "record"]
-    mech_keys = ["wood", "furniture", "watch", "clock", "gears", "game boy", "botanist", "architect"]
-    
-    for k in audio_keys:
-        if k in desc:
-            return "audio"
-    for k in mech_keys:
-        if k in desc:
-            return "mechanical"
-    return "systems"
-
-def build_markov_brain(category, responses):
-    # Slice the 300 varied responses based on category pool
-    if category == "audio":
-        corpus_responses = responses[0:100]
-    elif category == "mechanical":
-        corpus_responses = responses[100:200]
-    else:
-        corpus_responses = responses[200:300]
-        
-    full_text = " ".join(corpus_responses)
-    words = full_text.split()
-    w_len = len(words)
-    
-    transitions = {}
-    for i in range(w_len - 1):
-        w1 = words[i]
-        w2 = words[i+1]
-        if w1 not in transitions:
-            transitions[w1] = []
-        transitions[w1].append(w2)
-        
-    return transitions, words, w_len
-
-def walk_complete_sentence_penalized(transitions, words_list, c_len, start_word):
-    current_word = start_word
-    sentence = [current_word.capitalize()]
-    history = [current_word]
-    steps = 1
-    max_steps = 22
-    
-    while steps < max_steps:
-        if current_word.endswith((".", "!", "?")):
-            break
-            
-        choices = transitions.get(current_word, [])
-        next_word = ""
-        
-        if not choices:
-            # Fallback: select random non-repeating word from vocab list
-            attempts = 0
-            found_candidate = False
-            while attempts < 15:
-                candidate = random.choice(words_list)
-                if candidate not in history[-15:]:
-                    next_word = candidate
-                    found_candidate = True
-                    break
-                attempts += 1
-            if not found_candidate:
-                next_word = random.choice(words_list)
-        else:
-            # Select transition choice with 15-word lookback & bigram blocking
-            attempts = 0
-            found_candidate = False
-            while attempts < 20:
-                candidate = random.choice(choices)
-                is_repeat = False
-                
-                # 1. 15-word lookback window check
-                if candidate in history[-15:]:
-                    is_repeat = True
-                    
-                # 2. Strict Bigram Blocking check
-                if not is_repeat:
-                    for b_idx in range(len(history) - 1):
-                        p1 = history[b_idx]
-                        p2 = history[b_idx + 1]
-                        if p1 == current_word and p2 == candidate:
-                            is_repeat = True
-                            break
-                            
-                if not is_repeat:
-                    next_word = candidate
-                    found_candidate = True
-                    break
-                attempts += 1
-                
-            if not found_candidate:
-                next_word = random.choice(choices)
-                
-        sentence.append(next_word)
-        history.append(next_word)
-        current_word = next_word
-        steps += 1
-        
-    result = " ".join(sentence)
-    if not result.endswith((".", "!", "?")):
-        result += "."
-    return result
-
-def predict_neural_class(user_msg, weights, biases):
-    # Normalize input and extract features
-    words = [w.lower().replace(".", "").replace("!", "").replace("?", "").strip() for w in user_msg.split()]
-    x = [0.0] * len(VOCAB)
-    for i, keyword in enumerate(VOCAB):
-        if keyword in words:
-            x[i] = 1.0
-            
-    # Matrix vector multiplication
-    outputs = [0.0] * len(CLASSES)
-    for c in range(len(CLASSES)):
-        val = biases[c]
-        for i in range(len(VOCAB)):
-            val += x[i] * weights[c][i]
-        outputs[c] = val
-        
-    # Softmax probabilities
-    try:
-        e_x = [math.exp(v) for v in outputs]
-        sum_e_x = sum(e_x)
-        probs = [v / sum_e_x for v in e_x]
-    except Exception:
-        probs = [0.33, 0.33, 0.33]
-        
-    max_idx = probs.index(max(probs))
-    return CLASSES[max_idx], probs
-
-def render_probability_bars(probs):
-    bar_len = 16
-    out_lines = []
-    colors = [COLOR_AUDIO, COLOR_MECH, COLOR_SYS]
-    labels = ["AUDIO ", "MECH  ", "SYSTEM"]
-    
-    for i in range(3):
-        p = probs[i]
-        filled = int(round(p * bar_len))
-        bar = "█" * filled + "▒" * (bar_len - filled)
-        pct = p * 100.0
-        out_lines.append(f"    {colors[i]}[ {labels[i]} {bar} ({pct:5.1f}%) ]{RESET}")
-    return "\n".join(out_lines)
-
-# Dynamic Varied Empathetic Prefix Dictionary to prevent prefix loops
-EMPATHETIC_VARIATIONS = {
-    # Match cases
-    ("audio", "audio"): [
-        "The resonant audio waves strike a deep harmonic balance in my core! ",
-        "Your rhythmic frequency perfectly matches my acoustic focus! ",
-        "That statement vibrates at exactly the right pitch and groove! ",
-        "A beautiful sonic resonance aligns our conversational pathways here! "
-    ],
-    ("mechanical", "mechanical"): [
-        "The precise physical alignments of your statement click together like a masterfully crafted gear! ",
-        "Your words have absolute structural integrity, locked in perfect spatial precision! ",
-        "That fits flawlessly, like a fine gemstone fitted into a museum timepiece escapement! ",
-        "A magnificent mechanical cohesion! Every segment of your logic is perfectly synced! "
-    ],
-    ("systems", "systems"): [
-        "Your structural logic converges warning-free under our tight memory constraints! ",
-        "A clean thread execution! Your statement optimizes perfectly in-memory! ",
-        "Highly optimized telemetry! Your logic compiles with zero friction! ",
-        "That is an exceptionally clean, low-latency construct you have deployed! "
-    ],
-    
-    # Mismatch cases (bridges)
-    # Native: audio
-    ("audio", "mechanical"): [
-        "Just like the gears of a mechanical clock, the tape reels of my vintage tape recorder rotate in perfect synchronization! ",
-        "While you describe physical structures, I hear them as rhythmic acoustic spacing and mechanical beats! ",
-        "Bridging physical leverage to acoustic latency: mechanical ticking is just natural chiptune rhythm! "
-    ],
-    ("audio", "systems"): [
-        "Just like a compiled systems loop, a rhythmic audio sample loops indefinitely without latency! ",
-        "Routing database streams feels a lot like managing discrete sound waves through a digital synthesizer! ",
-        "Systems architectures and audio tracks both require low latency and high-fidelity routing! "
-    ],
-    
-    # Native: mechanical
-    ("mechanical", "audio"): [
-        "Just like the rhythmic beats of a synthesizer, the repeating ticks of my mechanical escapement keep perfect physical timing! ",
-        "I can translate that musical groove into physical rotational kinetic energy! ",
-        "Acoustic waveforms have their own beautiful geometry, just like the teeth of fine wooden gears! "
-    ],
-    ("mechanical", "systems"): [
-        "Just like a warning-free software compiler, the carefully cut wood gears of my mechanical clock require absolute structural precision! ",
-        "Software compilers build virtual structures, but watchmaking builds them in physical memory! ",
-        "Tight constraints are physical to me: gears must mesh with absolute zero margin of code error! "
-    ],
-    
-    # Native: systems
-    ("systems", "audio"): [
-        "Just like a resonant audio sound wave, a high-performance database queries and reverberates in perfect memory synchronization! ",
-        "Acoustic channels are just low-level physical packet networks carrying complex waveforms! ",
-        "Your rhythmic tone maps perfectly to an optimized circular array buffer processing data! "
-    ],
-    ("systems", "mechanical"): [
-        "Just like the physical leverage of mechanical gears, our system compilers leverage low-level pointers to optimize execution speed! ",
-        "Mechanical segments translate beautifully to hardware memory addresses and clock cycles! ",
-        "I bridge physical wood structures to logical system memory layouts: both require absolute architecture! "
-    ]
-}
-
-def get_empathetic_prefix(partner_native, predicted):
-    key = (partner_native, predicted)
-    if key in EMPATHETIC_VARIATIONS:
-        choices = EMPATHETIC_VARIATIONS[key]
-        return random.choice(choices)
-    return ""
-
-def main():
-    # 1. Load Persona Database
-    try:
-        with open("main/personas.json", "r") as f:
-            parsed_personas = json.load(f)
-            personas = parsed_personas["personas"]
-    except Exception as e:
-        print(RED + "Error: Failed to load main/personas.json!" + RESET)
-        return
-        
-    # 2. Load Responses Corpus
-    try:
-        with open("main/varied_responses.json", "r") as f:
-            parsed_responses = json.load(f)
-            responses = parsed_responses["responses"]
-    except Exception as e:
-        print(RED + "Error: Failed to load main/varied_responses.json!" + RESET)
-        return
-        
-    # 3. Load Calibrated Neural Weights
-    try:
-        with open("main/response_classifier_weights.json", "r") as f:
-            weights_data = json.load(f)
-            weights = weights_data["weights"]
-            biases = weights_data["biases"]
-    except Exception as e:
-        print(RED + "Error: Failed to load main/response_classifier_weights.json!" + RESET)
-        print("Please train your response classifier weights first by running the Sesi trainer!")
-        return
-
-    print_ascii_header()
-    
-    # 4. Print beautiful interactive directory
-    print(BOLD + WHITE + "[ DIRECTORY ] AVAILABLE CONVERSATIONAL EXPERTS:" + RESET)
-    print(BLUE + "-" * 70 + RESET)
-    for i, p in enumerate(personas):
-        cat = get_persona_category(p)
-        if cat == "audio":
-            color = COLOR_AUDIO
-        elif cat == "mechanical":
-            color = COLOR_MECH
-        else:
-            color = COLOR_SYS
-            
-        print(f"[{BOLD}{i:2d}{RESET}] {color}{p['name']:22s}{RESET} (Age: {p['age']}) [{BOLD}{cat.upper()}{RESET}]")
-    print(BLUE + "-" * 70 + RESET)
-    
-    # 5. User selection loop
-    while True:
-        try:
-            choice = input(BOLD + WHITE + "\n>> Select persona number [0-19]: " + RESET).strip()
-            if choice.lower() == "exit":
-                print("Goodbye!")
-                return
-            idx = int(choice)
-            if 0 <= idx < len(personas):
-                partner = personas[idx]
-                break
-            else:
-                print(RED + "Please enter a valid index between 0 and 19." + RESET)
-        except ValueError:
-            print(RED + "Please enter a numeric index." + RESET)
-
-    # 6. Initialize dynamic neural brains
-    partner_native = get_persona_category(partner)
-    partner_color = COLOR_AUDIO if partner_native == "audio" else (COLOR_MECH if partner_native == "mechanical" else COLOR_SYS)
-    
-    print(BOLD + "\n[+] LOADING CALIBRATED 10x3 NEURAL WEIGHTS...")
-    time.sleep(0.4)
-    print(GREEN + "[ok] Synapses calibrated. Initializing speech transitions..." + RESET)
-    
-    # Pre-build vocabulary brains for all 3 categories dynamically
-    brains = {
-        "audio": build_markov_brain("audio", responses),
-        "mechanical": build_markov_brain("mechanical", responses),
-        "systems": build_markov_brain("systems", responses)
-    }
-    time.sleep(0.4)
-    print(GREEN + "[ok] All vocabulary matrices mapped. Speech brain active!\n" + RESET)
-
-    print("=" * 70)
-    print(f"[ONLINE] {BOLD}{partner['name']}{RESET} (Age: {partner['age']}) is ONLINE!")
-    print(f"[CLASS]  {BOLD}Personality Class:{RESET} {partner_color}{partner_native.upper()}{RESET}")
-    print(f"[BIO]    {BOLD}Bio Description:{RESET} {partner['personality']}")
-    print(f"[TONE]   {BOLD}Conversational Tone:{RESET} {partner['tone']}")
-    print(BOLD + WHITE + "Type your message below! Type 'exit' or 'quit' to shut down connection." + RESET)
-    print("=" * 70 + "\n")
-
-    # 7. Interactive Neural-Empathetic Loop
-    while True:
-        try:
-            user_msg = input(BOLD + WHITE + "You: " + RESET).strip()
-            if not user_msg:
-                continue
-                
-            if user_msg.lower() in ["exit", "quit", "close"]:
-                print(BOLD + BLUE + f"\n[!] Terminating connection with {partner['name']}. Offline gateway closed. Goodbye!\n" + RESET)
-                break
-                
-            # A. Execute Neural Classification
-            predicted_class, probs = predict_neural_class(user_msg, weights, biases)
-            
-            # Print visually outstanding probability bars
-            print(BOLD + BLUE + "\n[ NEURAL RESPONSE CLASSIFICATION ]" + RESET)
-            print(render_probability_bars(probs))
-            print(BOLD + BLUE + f"[ ROUTING COGNITIVE FLOW -> {predicted_class.upper()} CLASS ]\n" + RESET)
-            time.sleep(0.2)
-            
-            # B. Morph Speech Brain dynamically (Cognitive Resonance!)
-            transitions, words_list, c_len = brains[predicted_class]
-            
-            # C. Extract matching vocabulary seeds to trigger speech
-            user_words = [w.lower().replace(".", "").replace("!", "").replace("?", "") for w in user_msg.split()]
-            matched_words = [w for w in user_words if w in transitions]
-            
-            if matched_words:
-                start_word = random.choice(matched_words)
-            else:
-                start_word = random.choice(words_list)
-                
-            # D. Synthesize loop-free, penalized sentence reply
-            reply_sentence = walk_complete_sentence_penalized(transitions, words_list, c_len, start_word)
-            
-            # E. Prepend Neural Empathy Bridge Prefix
-            empathetic_prefix = get_empathetic_prefix(partner_native, predicted_class)
-            full_reply = empathetic_prefix + reply_sentence
-            
-            # Print stylized character dialogue
-            print(BOLD + partner_color + f"{partner['name']}: " + RESET + full_reply + "\n")
-            
-        except KeyboardInterrupt:
-            print(BOLD + BLUE + f"\n[!] Terminating connection with {partner['name']}. Offline gateway closed. Goodbye!\n" + RESET)
-            break
-
-if __name__ == "__main__":
-    main()