@inetafrica/open-claudia 2.6.33 → 2.6.34

package/test-recall-discoverer.js

@@ -0,0 +1,83 @@
+// Discoverer engine: pre-gate, seed → (graph) → fail-open injection. The LLM
+// walker is disabled here (RECALL_DISCOVERER_WALKER=off) so the engine takes
+// its deterministic fail-open path: keep user-origin seeds, drop guesses.
+const assert = require("assert");
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+
+const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "recall-disc-"));
+process.env.RECALL_GRAPH_DB = path.join(tmp, "graph.db");
+process.env.RECALL_DISCOVERER_WALKER = "off";
+process.env.RECALL_METRICS = "off";
+
+const disc = require("./core/recall/discoverer");
+
+// --- pre-gate ---
+assert.strictEqual(disc.needsRecall("", 0), false, "empty → no recall");
+assert.strictEqual(disc.needsRecall("thanks", 0), false, "pleasantry → no recall");
+assert.strictEqual(disc.needsRecall("ok", 0), false, "terse ack → no recall");
+assert.strictEqual(disc.needsRecall("yo", 0), false, "two words, no seeds → no recall");
+assert.strictEqual(disc.needsRecall("how do I deploy the mobile app", 0), true, "substantive → recall");
+assert.strictEqual(disc.needsRecall("k", 5), true, "seeds present always recall");
+
+// --- shared stub corpus + helpers ---
+const packs = {
+  "kazee-mobile": { dir: "kazee-mobile", name: "Kazee Mobile", description: "the app",
+    parent: "kazee", tags: [], sections: { Stance: "lime", Procedure: "", State: "", Journal: "" } },
+  "kazee-theme": { dir: "kazee-theme", name: "Kazee Theme", description: "palette",
+    parent: null, tags: ["shared"], sections: { Stance: "lime palette", Procedure: "", State: "", Journal: "" } },
+};
+const packsLib = {
+  matchPacks: (text) => /mobile/.test(text) ? [{ dir: "kazee-mobile", name: "Kazee Mobile", score: 4 }] : [],
+  readPack: (dir) => packs[dir] || null,
+  listPacks: () => Object.values(packs),
+  PACKS_DIR: tmp,
+};
+const entitiesLib = {
+  matchEntities: () => [],
+  readEntity: () => null,
+  listEntities: () => [],
+  ENTITIES_DIR: tmp,
+};
+const mergeMatches = (primary, secondary, keyOf) => {
+  const out = primary.map((m) => ({ ...m, origin: "user" }));
+  const seen = new Set(primary.map(keyOf));
+  for (const m of secondary) if (!seen.has(keyOf(m))) out.push({ ...m, origin: "context" });
+  return out;
+};
+let builtPacks = null;
+const buildPackBlock = (matches) => { builtPacks = matches; return matches.length ? "PACKBLOCK" : ""; };
+const buildEntityBlock = (matches) => (matches.length ? "ENTITYBLOCK" : "");
+const helpers = { packsLib, entitiesLib, mergeMatches, buildPackBlock, buildEntityBlock };
+
+(async () => {
+  // gated turn: trivial text, no seeds → empty result, builders not called
+  builtPacks = null;
+  const gated = await disc.run({
+    userText: "ok", contextText: "", fullContext: "", packLimit: 6, budget: {}, helpers,
+  });
+  assert.strictEqual(gated.packBlock, "");
+  assert.strictEqual(gated.packMatches.length, 0);
+  assert.strictEqual(builtPacks, null, "gated turn never builds blocks");
+
+  // seeded turn: FTS hits kazee-mobile → fail-open keeps it, block rendered
+  const out = await disc.run({
+    userText: "help with the mobile app", contextText: "", fullContext: "help with the mobile app",
+    packLimit: 6, budget: {}, helpers,
+  });
+  assert.strictEqual(out.packBlock, "PACKBLOCK");
+  assert.strictEqual(out.packMatches.length, 1);
+  assert.strictEqual(out.packMatches[0].dir, "kazee-mobile");
+  assert.ok(builtPacks && builtPacks.some((m) => m.dir === "kazee-mobile"), "seed reached the builder");
+
+  // resilient: a throwing matcher must not blow up the engine
+  const out2 = await disc.run({
+    userText: "deploy something substantive please", contextText: "", fullContext: "",
+    packLimit: 6, budget: {},
+    helpers: { ...helpers, packsLib: { ...packsLib, matchPacks: () => { throw new Error("boom"); } } },
+  });
+  assert.strictEqual(typeof out2.packBlock, "string");
+
+  console.log("recall discoverer OK");
+})().catch((e) => { console.error(e); process.exit(1); });

package/test-recall-engine.js

@@ -0,0 +1,54 @@
+// Recall engine selector + classic-engine smoke tests.
+const assert = require("assert");
+const recall = require("./core/recall");
+
+// --- selector ---
+assert.strictEqual(recall.activeEngineName({}), "classic", "default → classic");
+assert.strictEqual(recall.activeEngineName({ recallEngine: "classic" }), "classic");
+assert.strictEqual(recall.activeEngineName({ recallEngine: "nope" }), "classic", "unknown → classic");
+assert.strictEqual(recall.activeEngineName({ recallEngine: "CLASSIC" }), "classic", "case-insensitive");
+assert.ok(recall.listEngines().includes("classic"));
+assert.strictEqual(typeof recall.getEngine("classic").run, "function");
+assert.strictEqual(recall.getEngine("bogus").name, "classic", "getEngine falls back to classic");
+
+// env override when no setting
+const prev = process.env.RECALL_ENGINE;
+process.env.RECALL_ENGINE = "classic";
+assert.strictEqual(recall.activeEngineName(null), "classic");
+if (prev === undefined) delete process.env.RECALL_ENGINE; else process.env.RECALL_ENGINE = prev;
+
+// --- classic engine orchestration: calls helpers and returns their blocks ---
+(async () => {
+  const calls = [];
+  const helpers = {
+    packsLib: { matchPacks: () => [{ dir: "p1", name: "P1" }] },
+    entitiesLib: { matchEntities: () => [{ slug: "e1", name: "E1" }] },
+    mergeMatches: (a, b) => { calls.push("merge"); return a.map((m) => ({ ...m, origin: "user" })); },
+    filterMatches: async (u, c, pm, em) => { calls.push("filter"); return { packMatches: pm, entityMatches: em }; },
+    logRecall: () => { calls.push("log"); },
+    buildPackBlock: (m) => { calls.push("buildPack"); return m.length ? "PACKBLOCK" : ""; },
+    buildEntityBlock: (m) => { calls.push("buildEntity"); return m.length ? "ENTITYBLOCK" : ""; },
+  };
+  const out = await recall.getEngine("classic").run({
+    userText: "hello", contextText: "", fullContext: "", packLimit: 6, budget: {}, helpers,
+  });
+  assert.strictEqual(out.packBlock, "PACKBLOCK");
+  assert.strictEqual(out.entityBlock, "ENTITYBLOCK");
+  assert.strictEqual(out.packMatches.length, 1);
+  assert.strictEqual(out.entityMatches.length, 1);
+  assert.ok(calls.includes("filter") && calls.includes("log") && calls.includes("buildPack"));
+
+  // resilient: a throwing matcher must not blow up the engine
+  const out2 = await recall.getEngine("classic").run({
+    userText: "x", contextText: "", fullContext: "",
+    packLimit: 6, budget: {},
+    helpers: {
+      ...helpers,
+      packsLib: { matchPacks: () => { throw new Error("boom"); } },
+      entitiesLib: { matchEntities: () => { throw new Error("boom"); } },
+    },
+  });
+  assert.strictEqual(typeof out2.packBlock, "string");
+
+  console.log("recall engine OK");
+})().catch((e) => { console.error(e); process.exit(1); });

package/test-recall-graph.js

@@ -0,0 +1,94 @@
+// Recall graph: edges, Hebbian reinforce, decay, spreading activation,
+// structural sync, orphan prune. Uses a throwaway sqlite db under a temp dir.
+const assert = require("assert");
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+
+const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "recall-graph-"));
+process.env.RECALL_GRAPH_DB = path.join(tmp, "graph.db");
+
+const graph = require("./core/recall/graph");
+
+if (!graph.available()) { console.log("recall graph OK (skipped — no node:sqlite)"); process.exit(0); }
+
+// --- edges + neighbours ---
+graph.addEdge("pack:a", "pack:b", "related");
+graph.addEdge("pack:b", "pack:c", "related");
+graph.addEdge("pack:a", "pack:theme", "governed-by");
+const nb = graph.neighbors("pack:a").map((x) => x.node).sort();
+assert.deepStrictEqual(nb, ["pack:b", "pack:theme"], "undirected neighbours of a");
+assert.strictEqual(graph.allEdges().length, 3);
+
+// addEdge keeps the max weight (structural re-derive never lowers reinforcement)
+graph.addEdge("pack:a", "pack:b", "related", { weight: 99 });
+let ab = graph.allEdges().find((e) => e.src === "pack:a" && e.dst === "pack:b");
+assert.strictEqual(ab.weight, 99, "weight raised to max");
+graph.addEdge("pack:a", "pack:b", "related", { weight: 1 });
+ab = graph.allEdges().find((e) => e.src === "pack:a" && e.dst === "pack:b");
+assert.strictEqual(ab.weight, 99, "weight not lowered by smaller structural weight");
+
+// --- Hebbian reinforce (both directions) ---
+graph.reinforce("pack:x", "pack:y", 2);
+const xy = graph.allEdges().find((e) => e.src === "pack:x" && e.dst === "pack:y");
+const yx = graph.allEdges().find((e) => e.src === "pack:y" && e.dst === "pack:x");
+assert.ok(xy && yx, "reinforce creates both directions");
+assert.ok(xy.last_reinforced, "reinforce stamps last_reinforced");
+graph.reinforce("pack:x", "pack:y", 2);
+const xy2 = graph.allEdges().find((e) => e.src === "pack:x" && e.dst === "pack:y");
+assert.ok(xy2.weight > xy.weight, "repeat reinforce bumps weight");
+
+graph.reinforceSet(["pack:a", "pack:b", "pack:c"]);
+assert.ok(graph.neighbors("pack:a").some((n) => n.node === "pack:c"), "reinforceSet links all pairs");
+
+// --- spreading activation ---
+// strong chain a→b→c; seed a, expect b (1 hop) and possibly c (2 hops).
+const act = graph.expand([{ id: "pack:a", score: 4 }], { hops: 2, threshold: 0.1 });
+assert.ok(act.has("pack:b"), "1-hop neighbour activates");
+assert.ok(!act.has("pack:a"), "seed excluded from activation result");
+for (const [, v] of act) assert.ok(v.activation > 0 && v.hop >= 1, "activation has metadata");
+
+// seeds with no edges produce nothing
+assert.strictEqual(graph.expand([{ id: "pack:orphanseed", score: 5 }]).size, 0);
+
+// --- decay (never below structural floor) ---
+graph.addEdge("pack:d", "pack:e", "parent"); // base weight 3, no last_reinforced → untouched
+graph.reinforce("pack:d", "pack:f", 10);
+// backdate the reinforced edge well past the half-life
+const db = graph.openDb();
+const old = new Date(Date.now() - 400 * 86400000).toISOString();
+db.prepare("UPDATE edges SET last_reinforced=? WHERE src=? AND dst=?").run(old, "pack:d", "pack:f");
+graph.decay({ halfLifeDays: 30 });
+const df = graph.allEdges().find((e) => e.src === "pack:d" && e.dst === "pack:f");
+assert.ok(df.weight < 11 && df.weight >= 1, "reinforced edge decayed toward floor");
+const de = graph.allEdges().find((e) => e.src === "pack:d" && e.dst === "pack:e");
+assert.strictEqual(de.weight, 3, "structural edge with no reinforcement untouched by decay");
+
+// --- structural sync from a stubbed corpus ---
+const packsStub = {
+  listPacks: () => [
+    { dir: "kazee-mobile", name: "Kazee Mobile", tags: [], parent: "kazee",
+      sections: { Stance: "uses [[kazee-theme]]", Procedure: "", State: "", Journal: "" } },
+    { dir: "kazee", name: "Kazee", tags: [], parent: null,
+      sections: { Stance: "", Procedure: "", State: "", Journal: "" } },
+    { dir: "kazee-theme", name: "Kazee Theme", tags: ["shared"], parent: null,
+      sections: { Stance: "lime palette", Procedure: "", State: "", Journal: "" } },
+  ],
+};
+const entStub = { listEntities: () => [] };
+const r = graph.syncFromCorpus(packsStub, entStub);
+assert.ok(r.edges >= 2, "sync derived parent + link edges");
+const edges = graph.allEdges();
+assert.ok(edges.some((e) => e.src === "pack:kazee-mobile" && e.dst === "pack:kazee" && e.type === "parent"), "parent edge from frontmatter");
+assert.ok(edges.some((e) => e.src === "pack:kazee-mobile" && e.dst === "pack:kazee-theme" && e.type === "governed-by"), "shared-concern link → governed-by");
+
+// --- orphan prune ---
+graph.addEdge("pack:ghost", "pack:kazee", "related");
+const pruned = graph.pruneOrphans(packsStub, entStub);
+assert.ok(pruned >= 1, "orphan edge pruned");
+assert.ok(!graph.allEdges().some((e) => e.src === "pack:ghost"), "ghost edge gone");
+
+// parseLinks
+assert.deepStrictEqual(graph.parseLinks("see [[Foo-Bar]] and [[baz]]"), ["foo-bar", "baz"]);
+
+console.log("recall graph OK");