dante-watch 0.1.0 → 0.1.2

package/src/bib/ear.mjs

@@ -0,0 +1,102 @@
+// The two ears, trained once from the sorted bib that ships in the package (plain, readable JSON):
+// bib.json — category → intent → [line, level, language]. Levels: G = first bulk run, E1 general,
+// E2 general but in the person's own way, E3 the person's line itself, washed.
+// The ear for what a human wants hears befehle + fragen + nichtdante; the ear for the
+// "HUMAN, HÖR ZU" moment hears fixgespraech. Routing is flat across intents — measured: going
+// category-first passed every category mix-up on (5 wrong instead of 2).
+// Lines were written by DeepSeek playing real users, seeded by washed real goals; the real
+// goals themselves are not in here.
+import { readFileSync } from "node:fs";
+import { train, classify, tokens, sureFor, KNOWN } from "./router.mjs";
+import { wash } from "./wash.mjs";
+import { loadNet, predict } from "./net.mjs";
+import { PROBE } from "./probe.mjs";
+import { SYS_PROBE, MUSTER_PROBE, WISSEN_PROBE } from "./system.mjs";
+
+let bib = null;
+const load = () => (bib ||= JSON.parse(readFileSync(new URL("./bib.json", import.meta.url), "utf8")));
+export const rowsOf = (cats) => cats.flatMap((c) => Object.entries(load().cats[c] || {}).flatMap(([intent, xs]) => xs.map(([text]) => ({ text, intent }))));
+export const bibDate = () => load().date;
+// Three neurons: the counting ear (bayes), the net, and the combiner (bayes^a · net^b, fitted on
+// lines neither saw). WAY decides who may act:
+//   bayes — the counting ear alone
+//   einig — act only when BOTH ears are sure on their own and say the same; else ask back
+//   kombi — the combiner's joint probability decides
+// The ranked list a human sees ("Meinst du …?") always comes from the joint probability.
+// Measured per ear (25.10.): ohr  bayes 131/138 · 1 wrong · einig 130 · 0 wrong · kombi 131 · 3 wrong
+//                            janein bayes 30/33 · einig 30/33 · kombi 33/33 (it can never say yes)
+const WAYS = { ohr: "einig", janein: "kombi", system: "einig", muster: "einig", wissen: "einig" };
+export const setWay = (w) => { WAYS.ohr = WAYS.janein = WAYS.system = WAYS.muster = WAYS.wissen = w; };
+const ears = {};
+let nets = null;
+// Exact memory (like Virgil's value cache): a line that stands 1:1 in the bib — washed, so
+// "server root@1.2.3.4" meets "server {ZIEL}" — is known, no probability in between. This is what
+// makes E3 work: the trust rule keeps one line from deciding for OTHER lines, not for itself.
+const exactKey = (t) => tokens(wash(t).text).join(" ");
+// The domain ears (system, muster, wissen) sit behind the main ear's gap. Each also learns the lines of
+// the OTHER domains as "unklar", so it stays silent on what is not its own and the order they are asked
+// in does not matter. NEG says whose lines those are.
+export const NEG = { system: ["muster", "wissen"], muster: ["systemwissen", "wissen"], wissen: ["muster", "systemwissen"] };
+// ...and a fixed sample of everyday lines ("not Dante's work", small talk), so "write my essay" or "what is
+// the weather" never wakes a domain ear. The sample is chosen by a hash of the line: the same bib gives
+// the same rows, so the nets stay reproducible.
+const fnv = (s) => { let h = 2166136261; for (let i = 0; i < s.length; i++) { h ^= s.charCodeAt(i); h = Math.imul(h, 16777619); } return h >>> 0; };
+const EVERYDAY = [["nichtdante", 4], ["smalltalk", 5]]; // [category, keep one line in n]
+export const negRows = (name) => !NEG[name] ? [] : [
+  ...NEG[name].flatMap((c) => Object.values(load().cats[c] || {}).flatMap((xs) => xs.map(([text]) => ({ text, intent: "unklar" })))),
+  ...EVERYDAY.flatMap(([c, n]) => Object.values(load().cats[c] || {}).flatMap((xs) => xs.filter(([text]) => fnv(text) % n === 0).map(([text]) => ({ text, intent: "unklar" })))),
+];
+function hear(name, cats, extra, line) {
+  const WAY = WAYS[name];
+  const e = (ears[name] ||= (() => { const rows = [...extra, ...rowsOf(cats), ...negRows(name)]; const mem = new Map(rows.map((r) => [exactKey(r.text), r.intent])); return { m: train(rows), mem }; })());
+  const known = e.mem.get(exactKey(line));
+  if (known) return { intent: known, p: 1, known: 1, ranked: [{ intent: known, p: 1 }], exact: true };
+  const b = classify(e.m, line, { all: true });
+  const raw = (nets ||= JSON.parse(readFileSync(new URL("./net.json", import.meta.url), "utf8")))[name];
+  if (WAY === "bayes" || !raw) return { ...b, ranked: b.ranked.slice(0, 3) };
+  const net = (e.net ||= loadNet(raw)), { a, b: bw } = raw.comb;
+  const pn = Object.fromEntries(predict(net, line).map((x) => [x.intent, x.p]));
+  const s = b.ranked.map((x) => [x.intent, a * Math.log(x.p + 1e-9) + bw * Math.log((pn[x.intent] ?? 0) + 1e-9)]);
+  const top = Math.max(...s.map((x) => x[1])), z = s.reduce((p, x) => p + Math.exp(x[1] - top), 0);
+  const ranked = s.map(([intent, v]) => ({ intent, p: Math.exp(v - top) / z })).sort((x, y) => y.p - x.p);
+  const netTop = Object.entries(pn).sort((x, y) => y[1] - x[1])[0];
+  const netSure = netTop[1] >= sureFor(netTop[0]) && netTop[0] !== "unklar" ? netTop[0] : "unklar";
+  const joint = ranked[0].p >= sureFor(ranked[0].intent) && b.known >= KNOWN && ranked[0].intent !== "unklar" ? ranked[0].intent : "unklar";
+  const intent = WAY === "kombi" ? joint : b.intent === netSure ? b.intent : "unklar";
+  return { intent, p: ranked[0].p, known: b.known, ranked: ranked.slice(0, 3), bayes: b.intent, net: netSure };
+}
+export const hearMain = (line) => hear("ohr", ["befehle", "fragen", "smalltalk", "nichtdante"], PROBE, line);
+export const hearConsent = (line) => hear("janein", ["fixgespraech"], [], line);
+// The third ear: only system knowledge (the sixth bib). The main ear decides it is a system job
+// (pruef/server), THEN this ear picks the move: fingerabdruck / finde_php / pruef_php2shell / beleg /
+// fix_php2shell. Kept apart from the five language bibs on purpose — no E1/E2/E3, family is a slot.
+export const hearSystem = (line) => hear("system", ["systemwissen"], SYS_PROBE, line);
+// The fourth ear: the Muster-Bib — the watchman's "go and look for what's wrong" moves. Also sits
+// behind the main ear's gap; conservative (einig) so plain talk is never pulled into a patrol.
+export const hearMuster = (line) => hear("muster", ["muster"], MUSTER_PROBE, line);
+// The fifth ear: the Fachwissen-Bib — when a person asks Dante to EXPLAIN (what he watches, one topic,
+// what stands out, what is normal). It learns the way of asking; the topic comes from the cards.
+export const hearWissen = (line) => hear("wissen", ["wissen"], WISSEN_PROBE, line);
+
+// The domain ears behind the main ear's gap, in the order they are asked. Each knows what is not its
+// own (the negative class), so the first one that speaks is the right one. null = none of them.
+export function hearDomain(line) {
+  for (const [ear, f] of [["muster", hearMuster], ["system", hearSystem], ["wissen", hearWissen]]) {
+    const r = f(line);
+    if (r.intent !== "unklar") return { ear, intent: r.intent, p: r.p };
+  }
+  return null;
+}
+
+// German, English or Spanish? A handful of telling words per language picks the answer's tongue.
+const TELL = {
+  es: /\b(que|qué|es|mi|el|la|los|como|cómo|por|hola|esto|eso|está|estoy|puedes|quiero|tengo|servidor|seguro|gracias|hackearon)\b/gi,
+  en: /\b(the|is|my|what|how|why|you|are|did|do|does|this|that|it|i|me|can|someone|safe|hacked|anywhere|even|wont)\b/gi,
+  de: /\b(der|die|das|ist|mein|meine|was|wie|warum|du|bin|ich|mir|kann|jemand|sicher|gehackt|nicht|und|heißt|überhaupt)\b/gi,
+};
+// No telling word at all ("fix", "demo") → the fallback, so one bare command does not flip him.
+export const langOf = (line, fallback = "de") => {
+  let best = fallback, n = 0;
+  for (const [k, re] of Object.entries(TELL)) { const c = (String(line).match(re) || []).length; if (c > n) { n = c; best = k; } }
+  return best;
+};