@misterscan/sesi 1.1.2 → 1.2.0

package/main/terminal_chat.py

@@ -0,0 +1,385 @@
+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()

package/main/tests/temp_math_mod.sesi

@@ -0,0 +1,3 @@
+// Temporary Sesi module for import testing
+export let magic_number = 1337
+export fn multiply(a, b) {return a * b}

package/main/tests/test_image_input.sesi

@@ -0,0 +1,40 @@
+print "=== Image Input Tests ==="
+print ""
+print "Test 1: Single image (literal path)..."
+try 
+{let result = model("gemini-3-flash-preview") {images: "docs/logo.png"} {"In one sentence, describe the dominant shape and color in this image."}
+print "PASS — model() single image:"
+print result
+} catch (e) {print "FAIL — Test 1 error:"
+print e}
+print ""
+print "Test 2: Single image (variable path)..."
+try 
+{let imgPath = "docs/logo.png"
+let reading = model("gemini-3-flash-preview") {images: imgPath} {"What text, if any, is visible in this image? Reply in one line."}
+print "PASS — model() variable path:"
+print reading
+} catch (e) {print "FAIL — Test 2 error:"
+print e}
+print ""
+print "Test 3: Multiple images (array)..."
+try 
+{let shots = ["docs/logo.png", "docs/logo.png"]
+let comparison = model("gemini-3-flash-preview") {images: shots} {"Are these two images identical? Answer yes or no and give one reason."}
+print "PASS — model() array of images:"
+print comparison
+} catch (e) 
+{print "FAIL — Test 3 error:"
+print e}
+print ""
+print "Test 4: images combined with temperature and max_tokens..."
+try 
+{let ref = "docs/logo.png"
+let analysis = model("gemini-3.1-flash-lite") {images: ref, temperature: 0, max_tokens: 128} {"What programming language or brand does this logo represent? One word answer."}
+print "PASS — model() with mixed config:"
+print analysis
+} catch (e) 
+{print "FAIL — Test 4 error:"
+print e}
+print ""
+print "=== All image input tests complete ==="

package/main/tests/test_v2_features.sesi

@@ -0,0 +1,48 @@
+// Sesi Native V2.0 Upgrades Test Script
+
+print "=== 1. Testing Standard Math Module (std/math) ==="
+import { PI, sqrt, pow } from "std/math"
+print "PI:" + str(PI)
+print "sqrt(100):" + str(sqrt(100))
+print "pow(3, 3):" + str(pow(3, 3))
+
+print "\n=== 2. Testing Standard JSON Module (std/json) ==="
+import { stringify, parse } from "std/json"
+let data = { "message": "hello from native Sesi", "code": 200 }
+let serialized = stringify(data)
+print "Serialized JSON:" + serialized
+let parsed = parse(serialized)
+print "Parsed Message:" + parsed["message"]
+
+print "\n=== 3. Testing HTTP Client web_get ==="
+let response = web_get("https://jsonplaceholder.typicode.com/posts/1")
+print "Fetched Title:" + parse(response)["title"]
+
+print "\n=== 4. Testing Concurrency with multi_req ==="
+import { sleep, now } from "std/time"
+
+fn job1() {
+  sleep(100)
+  return "job1_done"
+}
+
+fn job2() {
+  sleep(100)
+  return "job2_done"
+}
+
+let start_t = now()
+let parallel_results = multi_req([job1, job2])
+let elapsed = now() - start_t
+
+print "Parallel Results:" + str(parallel_results)
+print "Elapsed time for parallel jobs:" + str(elapsed) + "ms"
+
+print "\n=== 5. Testing Executable Sesi Module Import/Export ==="
+// Note: Since importing relative path loads and interprets that module,
+// we will import our helper module "tests/temp_math_mod".
+// First, the host test runner will write the temp module file, or we can write a let binding check.
+import { magic_number } from "tests/temp_math_mod"
+print "Imported magic number from local module:" + str(magic_number)
+
+print "\n=== All Native Sesi Tests Completed Successfully! ==="