@misterscan/sesi 1.1.1 → 1.2.0

package/main/native_chatbot.sesi

@@ -0,0 +1,180 @@
+// Sesi Script: native_chatbot.sesi
+// 100% NATIVE DATA-TRAINED DEVELOEPR CO-PILOT CHATBOT!
+// Trained entirely inside Sesi on 14 keywords across 6 distinct functional categories!
+
+// ==================================================
+// 💬 1. CHOOSE YOUR ADVANCED TECHNICAL QUERY HERE!
+// (Test it with custom phrases containing our keywords!)
+let queryText = "create an svg"
+// ==================================================
+
+print "=================================================="
+print "🧠 WELCOME TO THE NATIVE-TRAINED SESI DEVELOEPR CO-PILOT!"
+print "=================================================="
+print "⚙️  Vectorizing training vocabulary..."
+
+// Sigmoid math
+fn activate(x) {
+  return 1.0 / (1.0 + exp(0.0 - x))
+}
+
+fn derivative(y) {
+  return y * (1.0 - y)
+}
+
+// 2. Advanced Bag-of-Words Vectorizer (14 keywords)
+fn vectorize(text) {
+  let words = split(text, " ")
+  let vec = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
+  
+  let w = 0
+  while w < len(words) {
+    let word = words[w]
+    if word == "print" { vec[0] = 1.0 }
+    if word == "str" { vec[1] = 1.0 }
+    if word == "type" { vec[2] = 1.0 }
+    if word == "num" { vec[3] = 1.0 }
+    if word == "bool" { vec[4] = 1.0 }
+    if word == "json" { vec[5] = 1.0 }
+    if word == "convert" { vec[6] = 1.0 }
+    if word == "array" { vec[7] = 1.0 }
+    if word == "len" { vec[8] = 1.0 }
+    if word == "file" { vec[9] = 1.0 }
+    if word == "write" { vec[10] = 1.0 }
+    if word == "dir" { vec[11] = 1.0 }
+    if word == "exp" { vec[12] = 1.0 }
+    if word == "random" { vec[13] = 1.0 }
+    w = w + 1
+  }
+  return vec
+}
+
+// Helper to calculate neuron forward dot product
+fn compute_output(x, w, b) {
+  let sum = 0.0
+  let i = 0
+  while i < 14 {
+    sum = sum + (x[i] * w[i])
+    i = i + 1
+  }
+  return activate(sum + b)
+}
+
+// 3. Setup Comprehensive Labeled Dataset (6 classes, declared strictly on single continuous lines)
+let inputs = [vectorize("how to print str logging output"), vectorize("type check and num bool conversion"), vectorize("convert objects to json format"), vectorize("array length len split push pop keys"), vectorize("file write list dir read image"), vectorize("math exp random synaptic calculations")]
+
+let targets = [[1.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 1.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 1.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 1.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 1.0]]
+
+// 4. Initialize synaptic weights and biases for the 6 output units
+let w0 = [0.1, 0.2, -0.1, 0.3, -0.2, 0.1, -0.1, 0.2, -0.1, 0.1, -0.2, 0.1, -0.3, 0.2]
+let w1 = [-0.1, 0.1, 0.3, 0.2, 0.1, -0.2, 0.1, -0.3, 0.2, -0.1, 0.1, -0.2, 0.1, -0.1]
+let w2 = [0.2, -0.2, 0.1, -0.1, 0.2, 0.3, 0.3, 0.1, -0.2, 0.2, -0.1, 0.1, -0.2, 0.1]
+let w3 = [-0.1, 0.1, -0.2, 0.1, -0.1, 0.2, -0.1, 0.3, 0.3, -0.2, 0.1, -0.1, 0.2, -0.2]
+let w4 = [0.1, -0.1, 0.2, -0.2, 0.1, -0.1, 0.2, -0.1, 0.2, 0.4, 0.4, 0.3, -0.1, 0.1]
+let w5 = [-0.2, 0.2, -0.1, 0.1, -0.2, 0.1, -0.2, 0.1, -0.2, 0.1, -0.2, 0.1, 0.4, 0.4]
+
+let b0 = -0.1
+let b1 = 0.1
+let b2 = -0.2
+let b3 = 0.2
+let b4 = -0.1
+let b5 = 0.0
+
+print "🧠 Training 14x6 multi-class Sesi neural synapses..."
+
+// 5. Run native single-layer gradient descent training loop (2,000 epochs)
+let lr = 0.4
+let epoch = 1
+while epoch <= 2000 {
+  let c = 0
+  while c < 6 {
+    let x = inputs[c]
+    let t = targets[c]
+    
+    // Forward Propagation
+    let o0 = compute_output(x, w0, b0)
+    let o1 = compute_output(x, w1, b1)
+    let o2 = compute_output(x, w2, b2)
+    let o3 = compute_output(x, w3, b3)
+    let o4 = compute_output(x, w4, b4)
+    let o5 = compute_output(x, w5, b5)
+    
+    // Backpropagation deltas
+    let delta0 = (t[0] - o0) * derivative(o0)
+    let delta1 = (t[1] - o1) * derivative(o1)
+    let delta2 = (t[2] - o2) * derivative(o2)
+    let delta3 = (t[3] - o3) * derivative(o3)
+    let delta4 = (t[4] - o4) * derivative(o4)
+    let delta5 = (t[5] - o5) * derivative(o5)
+    
+    // Synaptic Weight Updates
+    let k = 0
+    while k < 14 {
+      w0[k] = w0[k] + (lr * delta0 * x[k])
+      w1[k] = w1[k] + (lr * delta1 * x[k])
+      w2[k] = w2[k] + (lr * delta2 * x[k])
+      w3[k] = w3[k] + (lr * delta3 * x[k])
+      w4[k] = w4[k] + (lr * delta4 * x[k])
+      w5[k] = w5[k] + (lr * delta5 * x[k])
+      k = k + 1
+    }
+    
+    b0 = b0 + (lr * delta0)
+    b1 = b1 + (lr * delta1)
+    b2 = b2 + (lr * delta2)
+    b3 = b3 + (lr * delta3)
+    b4 = b4 + (lr * delta4)
+    b5 = b5 + (lr * delta5)
+    
+    c = c + 1
+  }
+  epoch = epoch + 1
+}
+
+print "🎯 Synaptic parameters optimized! Brain ready."
+print "--------------------------------------------------"
+
+// 6. Comprehensive Technical Reference Database (Declared strictly on single continuous lines to satisfy Sesi parser!)
+let responses = ["📖 SESI MANUAL: I/O & CONSOLE LOGGING\n   🎯 Function: print(...args) -> null\n      - Prints multiple values to stdout separated by spaces.\n      - Example: print \"Value:\", 42\n   🎯 Function: str(value) -> string\n      - Convers any primitive, array, or object into a clean string representation.\n      - Example: let s = str([1, 2])", "📖 SESI MANUAL: TYPE CHECKING & CASTING\n   🎯 Function: type(value) -> string\n      - Returns native Sesi types: 'number', 'string', 'bool', 'null', 'array', 'object'.\n   🎯 Function: num(value) -> number / bool(value) -> bool\n      - Converts values to numbers or booleans using strict truthiness rules.\n      - Example: num(\"3.14\") -> 3.14 / bool(0) -> false", "📖 SESI MANUAL: JSON UTILITIES\n   🎯 Function: to_json(value) -> string\n      - Serializes an array or object into a formatted JSON string.\n   🎯 Function: from_json(string) -> any\n      - Parses valid JSON strings back into native Sesi arrays and objects.\n      - Example: let obj = from_json(\"{\\\"a\\\": 1}\")\n      - Note: Critical for offline parameters loading!", "📖 SESI MANUAL: ARRAYS & COLLECTIONS\n   🎯 Function: len(col) -> number / range(n) -> array\n      - len() returns collection size. range(n) creates a sequence from 0 to n-1.\n   🎯 Function: push(arr, v) -> pop(arr) -> any\n      - Adds/removes elements in-place.\n   🎯 Function: join(arr, sep) / split(str, sep)\n      - Joins array elements or splits strings into array components.", "📖 SESI MANUAL: FILE SYSTEM OPERATIONS\n   🎯 Function: read_file(path) / write_file(path, text)\n      - Reads or writes text files relative to the workspace directory.\n   🎯 Function: write_image(path, base64_content) -> bool\n      - Writes base64 strings directly as binary image files (e.g. logos).\n   🎯 Function: list_dir(path) / make_dir(path)\n      - Lists directory items or recursively creates new directories.", "📖 SESI MANUAL: MATH & DEEP LEARNING\n   🎯 Function: exp(x) -> number\n      - Computes high-speed exponential function Math.exp(x).\n      - Fundamental for native neural networks: Sigmoid = 1.0 / (1.0 + exp(-x))\n   🎯 Function: random() -> number\n      - Returns a pseudo-random decimal float between 0.0 and 1.0.\n      - Essential for seed randomization and breaking saddle points!"]
+
+// 7. Query User String!
+print "📥 User Query Input: \"" + queryText + "\""
+let query_vec = vectorize(queryText)
+print "📊 Vectorized Input: " + str(query_vec)
+print "--------------------------------------------------"
+
+// Forward propagation on user query
+let q_o0 = compute_output(query_vec, w0, b0)
+let q_o1 = compute_output(query_vec, w1, b1)
+let q_o2 = compute_output(query_vec, w2, b2)
+let q_o3 = compute_output(query_vec, w3, b3)
+let q_o4 = compute_output(query_vec, w4, b4)
+let q_o5 = compute_output(query_vec, w5, b5)
+
+let outputs = [q_o0, q_o1, q_o2, q_o3, q_o4, q_o5]
+print "🧠 Neural Activation Scores: " + str(outputs)
+
+// Determine class index with highest score
+let best_class = 0
+let max_score = -1.0
+let j = 0
+while j < 6 {
+  if outputs[j] > max_score {
+    max_score = outputs[j]
+    best_class = j
+  }
+  j = j + 1
+}
+
+print "--------------------------------------------------"
+print "🤖 SESI CO-PILOT RESPONDING:"
+print "--------------------------------------------------"
+if max_score < 0.40 {
+  print "🤔 Sesi's native synapses evaluated this query with low confidence: " + str(max_score)
+  print "   It seems your question does not contain any Sesi keywords in our vocabulary!"
+  print "   Please try asking about: 'print', 'str', 'files', 'json', 'exp', or 'random'!"
+} else {
+  print responses[best_class]
+  print "📐 Neural Classification Confidence: " + str(max_score)
+}
+print "=================================================="

package/main/native_synthesizer.sesi

@@ -0,0 +1,83 @@
+// Sesi Script: native_synthesizer.sesi
+// 100% NATIVE OFFLINE MARKOV TEXT SYNTHESIZER!
+// Generatively types Sesi code syntax word-by-word completely offline with zero API calls!
+
+// ==================================================
+// 💬 1. DEFINE YOUR INSPIRATIONAL TRAINING CORPUS!
+// ==================================================
+let corpus = "let value = 42 print value let raw = to_json(value) let obj = from_json(raw) print obj if value > 10 print value while value < 100 let value = value + 1 print value read_file(path) write_file(path, text) write_image(path, data) list_dir(path) make_dir(path) exp(x) random()"
+
+print "=================================================="
+print "📻 BLUE NOTE SYNTHESIZER: NATIVE TEXT GENERATION"
+print "=================================================="
+print "⚙️  Analyzing corpus structure..."
+
+// Native Floor function (Genius string-splitting floor logic!)
+fn floor(x) {
+  let s = str(x)
+  let parts = split(s, ".")
+  return num(parts[0])
+}
+
+// 2. Tokenize corpus
+let words = split(corpus, " ")
+let num_words = len(words)
+print "📊 Compiled " + str(num_words) + " corpus tokens!"
+
+// 3. Compile Markov Transition Table (Word-to-Word transition dictionary)
+let transitions = {}
+
+let i = 0
+while i < (num_words - 1) {
+  let w1 = words[i]
+  let w2 = words[i + 1]
+  
+  let key_exists = type(transitions[w1]) == "array"
+  if key_exists == false {
+    // Declared strictly on one line to satisfy Sesi parser
+    transitions[w1] = []
+  }
+  
+  let list = transitions[w1]
+  push(list, w2)
+  
+  i = i + 1
+}
+
+print "🎯 State transition probabilities calculated!"
+print "--------------------------------------------------"
+
+// 4. Generate synthetic Sesi code sentences!
+let current_word = "let" // Start word
+let generated = current_word
+let gen_steps = 1
+let max_steps = 25 // Length of synthesized text
+
+while gen_steps < max_steps {
+  let choices = transitions[current_word]
+  let has_choices = type(choices) == "array"
+  
+  if has_choices == false {
+    // If we hit a dead end, wrap back to starting word
+    current_word = "let"
+  } else {
+    let num_choices = len(choices)
+    if num_choices == 0 {
+      current_word = "let"
+    } else {
+      // Pick a mathematically safe random index
+      let rand_idx = floor(random() * num_choices)
+      let next_word = choices[rand_idx]
+      
+      generated = generated + " " + next_word
+      current_word = next_word
+    }
+  }
+  
+  gen_steps = gen_steps + 1
+}
+
+print "🤖 GENERATED NATIVE SESI SYNTHESIS:"
+print "--------------------------------------------------"
+print generated
+print "=================================================="

package/main/nn_personas_trainer.sesi

@@ -0,0 +1,302 @@
+// Sesi Script: nn_personas_trainer.sesi
+// 🧠 NATIVE NEURAL NETWORK PERSONA & DIALOGUE CLASSIFIER
+// Trains a 10x3 synapse network on 300 sentences from main/conversational_sentences.json,
+// then zero-shot evaluates and classifies the bios of all 20 personas in main/personas.json!
+
+print "=================================================="
+print "🧠 INITIATING Sesi NEURAL PERSONA & DIALOGUE TRAINER"
+print "=================================================="
+
+// Custom integer floor function
+fn floor(x) {
+  let s = str(x)
+  let parts = split(s, ".")
+  return num(parts[0])
+}
+
+// Fast Sigmoid (Softsign) activation
+fn activate(x) {
+  let absX = x
+  if x < 0.0 {
+    absX = 0.0 - x
+  }
+  return 0.5 + (0.5 * (x / (1.0 + absX)))
+}
+
+fn activate_derivative(y) {
+  return y * (1.0 - y)
+}
+
+// 1. Define 10-keyword Vocabulary for Bag-of-Words vectors
+let vocab = ["synthesizer", "vinyl", "record", "wood", "gears", "clock", "compiler", "framework", "memory", "offline"]
+print "📚 Vocabulary Features: " + str(vocab)
+
+// 2. Load 300 conversational sentences
+print "📂 Loading main/conversational_sentences.json dataset..."
+let raw_conversations = read_file("main/conversational_sentences.json")
+let parsed_conv = from_json(raw_conversations)
+let sentences = parsed_conv["sentences"]
+let num_sentences = len(sentences)
+print "📊 Ingested " + str(num_sentences) + " sentences."
+
+// 3. Compile inputs and targets natively in Sesi
+print "🧹 Processing text sentences into Bag-of-Words feature matrices..."
+let inputs = []
+let targets = []
+
+let s_idx = 0
+while s_idx < num_sentences {
+  let sentence = sentences[s_idx]
+  let words = split(sentence, " ")
+  let w_len = len(words)
+  
+  // 10-dimensional input vector
+  let x = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
+  
+  let has_audio = false
+  let has_mech = false
+  let has_sys = false
+  
+  let v_idx = 0
+  while v_idx < 10 {
+    let keyword = vocab[v_idx]
+    let found = 0.0
+    
+    let w = 0
+    while w < w_len {
+      let raw_word = words[w]
+      let word = raw_word
+      let w_char_len = len(word)
+      
+      if w_char_len > 1 {
+        let last_char = word[w_char_len - 1]
+        if last_char == "." { word = split(word, ".")[0] }
+        if last_char == "!" { word = split(word, "!")[0] }
+        if last_char == "?" { word = split(word, "?")[0] }
+        if last_char == "," { word = split(word, ",")[0] }
+      }
+      
+      if word == keyword {
+        found = 1.0
+        if v_idx < 3 { has_audio = true }
+        if v_idx >= 3 {
+          if v_idx < 6 { has_mech = true }
+        }
+        if v_idx >= 6 { has_sys = true }
+      }
+      w = w + 1
+    }
+    
+    x[v_idx] = found
+    v_idx = v_idx + 1
+  }
+  
+  push(inputs, x)
+  
+  // Classify target label dynamically based on keywords or original indices
+  let t = [0.0, 0.0, 0.0]
+  if has_audio {
+    t[0] = 1.0
+  } else {
+    if has_mech {
+      t[1] = 1.0
+    } else {
+      if has_sys {
+        t[2] = 1.0
+      } else {
+        // Fallback default balanced targets using index slices
+        if s_idx < 100 { t[0] = 1.0 } // Audio
+        if s_idx >= 100 {
+          if s_idx < 200 { t[1] = 1.0 } // Mechanical
+        }
+        if s_idx >= 200 { t[2] = 1.0 } // Systems
+      }
+    }
+  }
+  push(targets, t)
+  
+  s_idx = s_idx + 1
+}
+
+print "✅ Dataset vectorization complete!"
+print "--------------------------------------------------"
+
+// 4. Initialize 10x3 Synapse Matrix
+print "🎲 Initializing 10x3 random neural synapses..."
+let weights = []
+let biases = []
+
+let c = 0
+while c < 3 {
+  let w_row = []
+  let k = 0
+  while k < 10 {
+    let w_val = random() - 0.5
+    push(w_row, w_val)
+    k = k + 1
+  }
+  push(weights, w_row)
+  push(biases, 0.0)
+  c = c + 1
+}
+
+// 5. Backpropagation Epoch Training Loop
+let lr = 0.3
+let max_epochs = 1500
+print "🚀 Training synapses across " + str(max_epochs) + " epochs (lr = " + str(lr) + ")..."
+
+let epoch = 1
+while epoch <= max_epochs {
+  let total_loss = 0.0
+  let sample_idx = 0
+  
+  while sample_idx < num_sentences {
+    let x = inputs[sample_idx]
+    let t = targets[sample_idx]
+    
+    // Outputs container
+    let outputs = [0.0, 0.0, 0.0]
+    let deltas = [0.0, 0.0, 0.0]
+    
+    // Forward Pass
+    let c_idx = 0
+    while c_idx < 3 {
+      let sum = 0.0
+      let w_row = weights[c_idx]
+      let k = 0
+      while k < 10 {
+        sum = sum + (x[k] * w_row[k])
+        k = k + 1
+      }
+      let o = activate(sum + biases[c_idx])
+      outputs[c_idx] = o
+      
+      // Calculate Loss and Delta
+      let err = t[c_idx] - o
+      total_loss = total_loss + (err * err)
+      deltas[c_idx] = err * activate_derivative(o)
+      
+      c_idx = c_idx + 1
+    }
+    
+    // Backpropagation Gradient Weight Updates
+    c_idx = 0
+    while c_idx < 3 {
+      let w_row = weights[c_idx]
+      let delta = deltas[c_idx]
+      let k = 0
+      while k < 10 {
+        w_row[k] = w_row[k] + (lr * delta * x[k])
+        k = k + 1
+      }
+      biases[c_idx] = biases[c_idx] + (lr * delta)
+      c_idx = c_idx + 1
+    }
+    
+    sample_idx = sample_idx + 1
+  }
+  
+  let avg_loss = total_loss / (num_sentences * 3.0)
+  
+  if (epoch % 300) == 0 {
+    print "Epoch " + str(epoch) + " - Average Class Loss: " + str(avg_loss)
+  }
+  
+  epoch = epoch + 1
+}
+
+print "--------------------------------------------------"
+print "🎉 Synapse Epoch Training Complete!"
+print "--------------------------------------------------"
+
+// 6. Save calibrated synapses to JSON
+let saved_weights = {}
+saved_weights["weights"] = weights
+saved_weights["biases"] = biases
+write_file("main/conversational_classifier_weights.json", to_json(saved_weights))
+print "💾 Saved trained synapses to main/conversational_classifier_weights.json"
+print "--------------------------------------------------"
+
+// Helper to run forward pass inference on a block of text
+fn predict(bio_text) {
+  let words = split(bio_text, " ")
+  let w_len = len(words)
+  let x = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
+  
+  let v_idx = 0
+  while v_idx < 10 {
+    let keyword = vocab[v_idx]
+    let found = 0.0
+    let w = 0
+    while w < w_len {
+      let raw_word = words[w]
+      let word = raw_word
+      let w_char_len = len(word)
+      if w_char_len > 1 {
+        let last_char = word[w_char_len - 1]
+        if last_char == "." { word = split(word, ".")[0] }
+        if last_char == "!" { word = split(word, "!")[0] }
+        if last_char == "," { word = split(word, ",")[0] }
+      }
+      if word == keyword {
+        found = 1.0
+      }
+      w = w + 1
+    }
+    x[v_idx] = found
+    v_idx = v_idx + 1
+  }
+  
+  // Forward pass
+  let predictions = [0.0, 0.0, 0.0]
+  let c_idx = 0
+  while c_idx < 3 {
+    let sum = 0.0
+    let w_row = weights[c_idx]
+    let k = 0
+    while k < 10 {
+      sum = sum + (x[k] * w_row[k])
+      k = k + 1
+    }
+    predictions[c_idx] = activate(sum + biases[c_idx])
+    c_idx = c_idx + 1
+  }
+  return predictions
+}
+
+// 7. Load Personas and zero-shot evaluate them!
+print "👥 Loading main/personas.json for neural zero-shot evaluation..."
+let raw_personas = read_file("main/personas.json")
+let parsed_personas = from_json(raw_personas)
+let personas = parsed_personas["personas"]
+let num_personas = len(personas)
+
+print "🔮 EVALUATING AND CLASSIFYING ALL 20 DEVELOPER PERSONAS:"
+print "--------------------------------------------------"
+
+let p_idx = 0
+while p_idx < num_personas {
+  let p = personas[p_idx]
+  let name = p["name"]
+  let bio = p["personality"] + " " + p["tone"]
+  
+  let pred = predict(bio)
+  
+  // Classify highest probability category index
+  let max_val = pred[0]
+  let predicted_class = "AUDIO"
+  
+  if pred[1] > max_val {
+    max_val = pred[1]
+    predicted_class = "MECHANICAL"
+  }
+  if pred[2] > max_val {
+    max_val = pred[2]
+    predicted_class = "SYSTEMS"
+  }
+  
+  print "[" + str(p_idx) + "] " + name + " ➜ Predicted: " + predicted_class + " [Audio: " + str(pred[0]) + ", Mech: " + str(pred[1]) + ", Sys: " + str(pred[2]) + "]"
+  p_idx = p_idx + 1
+}
+
+print "=================================================="