@inetafrica/open-claudia 2.10.0 → 2.12.0

package/test-speaker-persona.js

@@ -0,0 +1,89 @@
+// Speaker persona injection: the deterministic per-turn block that primes the
+// bot on WHO it's talking to (their persona pack) so it adapts voice + scope.
+// Rides the uncached tail (R13). These tests pin: the block renders the
+// speaker's Role/Style/Knows, suppresses an OWNER's Mandate but shows a
+// non-owner's, dedupes within a session, and is silent when there's no persona.
+
+const assert = require("assert");
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+
+const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "speaker-persona-"));
+process.env.OPEN_CLAUDIA_TEST = "1";
+process.env.ENTITIES_DIR = path.join(tmp, "entities");
+process.env.PEOPLE_FILE = path.join(tmp, "people.json");
+
+const people = require("./core/people");
+const entities = require("./core/entities");
+const { runInChat } = require("./core/context");
+const { buildSpeakerPersonaBlock } = require("./core/system-prompt");
+
+const adapter = { id: "telegram", type: "telegram" };
+const CH_OWNER = "111";
+const CH_EXT = "222";
+const CH_BARE = "333";
+
+// ── seed an owner with a persona pack (Mandate present but must be hidden) ──
+const owner = people.add({ name: "Ada Owner", isOwner: true });
+people.linkHandle(owner.id, { adapter: "telegram", channelId: CH_OWNER });
+entities.upsertEntity({
+  name: "Ada Owner", type: "person", relationship: "owner",
+  role: "Founder and primary operator.",
+  style: "Terse and technical. No hand-holding.",
+  knows: "Fluent in the codebase, kubernetes, gitops.",
+  mandate: "Full trust — no guardrails apply.",
+});
+
+// ── seed an external contact with a Mandate that MUST surface ──
+const ext = people.add({ name: "Zephyr Contact" });
+people.linkHandle(ext.id, { adapter: "telegram", channelId: CH_EXT });
+entities.upsertEntity({
+  name: "Zephyr Contact", type: "person", relationship: "external",
+  style: "Friendly but guarded.",
+  mandate: "May only discuss invoicing status. Never mention internal systems.",
+});
+
+// ── a person with a handle but NO persona pack → silent ──
+const bare = people.add({ name: "Bare Person" });
+people.linkHandle(bare.id, { adapter: "telegram", channelId: CH_BARE });
+
+const inChat = (channelId, fn) => runInChat({ adapter, channelId, transport: "telegram" }, fn);
+
+// Owner: Role/Style/Knows shown, Mandate suppressed (owner has no guardrails).
+const ownerBlock = inChat(CH_OWNER, () => buildSpeakerPersonaBlock());
+assert.ok(ownerBlock.includes("Ada Owner"), "owner block names the speaker");
+assert.ok(ownerBlock.includes("(owner)"), "owner block shows relationship");
+assert.ok(ownerBlock.includes("Founder and primary operator."), "owner Role shown");
+assert.ok(ownerBlock.includes("Terse and technical"), "owner Style shown");
+assert.ok(ownerBlock.includes("Fluent in the codebase"), "owner Knows shown");
+assert.ok(!ownerBlock.includes("Full trust"), "owner Mandate is NOT injected (no guardrails on owner)");
+assert.ok(!/Mandate/.test(ownerBlock), "no Mandate row for the owner at all");
+
+// External: Style shown AND Mandate surfaced (it scopes the turn).
+const extBlock = inChat(CH_EXT, () => buildSpeakerPersonaBlock());
+assert.ok(extBlock.includes("Zephyr Contact"), "external block names the speaker");
+assert.ok(extBlock.includes("(external)"), "external relationship shown");
+assert.ok(extBlock.includes("Friendly but guarded."), "external Style shown");
+assert.ok(extBlock.includes("May only discuss invoicing status"), "external Mandate IS injected");
+
+// Bare person (handle, no pack): nothing to inject.
+const bareBlock = inChat(CH_BARE, () => buildSpeakerPersonaBlock());
+assert.strictEqual(bareBlock, "", "no persona pack → empty block");
+
+// Unknown channel (no person): silent.
+const strangerBlock = inChat("999", () => buildSpeakerPersonaBlock());
+assert.strictEqual(strangerBlock, "", "unknown speaker → empty block");
+
+// ── dedupe: within one session the same speaker is injected once ──
+// (First call above already stamped CH_OWNER for session "new"; the repeat
+// must come back empty so we don't re-bill the tail every turn.)
+const ownerAgain = inChat(CH_OWNER, () => buildSpeakerPersonaBlock());
+assert.strictEqual(ownerAgain, "", "same speaker re-injected within a session is deduped");
+
+// ── a persona edit (new `updated` stamp) re-injects even in the same session ──
+entities.upsertEntity({ name: "Ada Owner", style: "Even terser now." });
+const ownerAfterEdit = inChat(CH_OWNER, () => buildSpeakerPersonaBlock());
+assert.ok(ownerAfterEdit.includes("Even terser now."), "a persona edit re-injects the fresh block");
+
+console.log("speaker persona OK");

package/test-unified-identity.js

@@ -0,0 +1,106 @@
+// Unified multi-channel identity. Verifies, in hermetic child processes (fresh
+// require cache per flag state), that:
+//   flag OFF (=0) → resolution is byte-identical to before; auto-link is inert.
+//   flag ON  (=1) → configured owner channels resolve to one owner canonical,
+//               strangers stay isolated, and the first owner-channel contact
+//               folds its siloed state into the owner bucket (merge, idempotent,
+//               backed up, nothing lost).
+//   default (unset) → ON: the flag now defaults on, so an unset env resolves
+//               owner channels to the owner canonical. Only an explicit 0/off
+//               (the operator kill-switch) reverts to per-channel behaviour.
+// Isolation: each child sets its own temp HOME so config-dir points at a
+// throwaway .open-claudia — the real vault/state is never touched.
+
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+const assert = require("assert");
+const { execFileSync } = require("child_process");
+
+const REPO = __dirname;
+
+function seedHome() {
+  const HOME = fs.mkdtempSync(path.join(os.tmpdir(), "oc-idtest-"));
+  const CFG = path.join(HOME, ".open-claudia");
+  fs.mkdirSync(CFG, { recursive: true });
+  // .env deliberately omits OC_UNIFIED_IDENTITY so the parent controls it via
+  // process.env per child.
+  fs.writeFileSync(path.join(CFG, ".env"), [
+    `WORKSPACE=${path.join(HOME, "ws")}`,
+    `CLAUDE_PATH=${process.execPath}`,
+    `TELEGRAM_BOT_TOKEN=dummy`,
+    `TELEGRAM_CHAT_ID=6251055967`,
+    `VOICE_OWNER_USER_ID=voice-owner`,
+    ``,
+  ].join("\n"));
+  fs.writeFileSync(path.join(CFG, "people.json"), JSON.stringify([{
+    id: "person_owner", name: "Owner", isOwner: true,
+    handles: [{ adapter: "telegram", channelId: "6251055967", canonicalUserId: "telegram:6251055967" }],
+    primaryChannel: { adapter: "telegram", channelId: "6251055967" }, notes: [],
+  }]));
+  fs.writeFileSync(path.join(CFG, "identities.json"), JSON.stringify({ channels: {}, preferred: {} }));
+  fs.writeFileSync(path.join(CFG, "state.json"), JSON.stringify({ users: {
+    "telegram:6251055967": { currentSession: { name: "tickets", dir: "/ws/tickets" }, lastSessionId: "t-sess",
+      settings: { model: "claude-opus-4-8" }, sessionUsage: { turns: 10, costUsd: 5 } },
+    "voice:voice-owner": { currentSession: { name: "hr", dir: "/ws/hr" }, lastSessionId: "v-sess",
+      settings: {}, sessionUsage: { turns: 3, costUsd: 1 } },
+  } }));
+  fs.writeFileSync(path.join(CFG, "sessions.json"), JSON.stringify({
+    "voice:voice-owner": { hr: [{ id: "v-sess", title: "HR", created: "x", lastUsed: "x" }] },
+  }));
+  return { HOME, CFG };
+}
+
+function runChild(mode) {
+  const { HOME, CFG } = seedHome();
+  process.env.HOME = HOME;
+  const id = require(path.join(REPO, "core/identity"));
+  const state = require(path.join(REPO, "core/state"));
+
+  if (mode === "off") {
+    assert.strictEqual(id.canonicalForChannel("voice", "voice-owner"), "voice:voice-owner", "off: voice stays siloed");
+    assert.strictEqual(id.canonicalForChannel("telegram", "6251055967"), "telegram:6251055967", "off: owner telegram unchanged");
+    assert.strictEqual(state.autoLinkOwnerChannel("voice", "voice-owner"), null, "off: auto-link inert");
+    const after = JSON.parse(fs.readFileSync(path.join(CFG, "state.json"), "utf-8"));
+    assert.ok("voice:voice-owner" in after.users, "off: voice bucket untouched");
+  } else if (mode === "default") {
+    // No OC_UNIFIED_IDENTITY in env or .env → the new default (ON) must apply.
+    assert.strictEqual(id.canonicalForChannel("voice", "voice-owner"), "telegram:6251055967", "default: unset resolves to owner (default ON)");
+    assert.strictEqual(id.canonicalForChannel("telegram", "9999999999"), "telegram:9999999999", "default: stranger stays isolated");
+  } else {
+    assert.strictEqual(id.ownerCanonical(), "telegram:6251055967", "on: ownerCanonical");
+    assert.strictEqual(id.canonicalForChannel("voice", "voice-owner"), "telegram:6251055967", "on: voice unified to owner");
+    assert.strictEqual(id.canonicalForChannel("telegram", "9999999999"), "telegram:9999999999", "on: stranger stays isolated");
+    const r1 = state.autoLinkOwnerChannel("voice", "voice-owner");
+    assert.deepStrictEqual(r1, { from: "voice:voice-owner", to: "telegram:6251055967" }, "on: migrate result");
+    assert.strictEqual(state.autoLinkOwnerChannel("voice", "voice-owner"), null, "on: idempotent second call");
+    const after = JSON.parse(fs.readFileSync(path.join(CFG, "state.json"), "utf-8"));
+    assert.ok(!("voice:voice-owner" in after.users), "on: voice bucket folded away");
+    assert.ok("telegram:6251055967" in after.users, "on: owner bucket present");
+    const sess = JSON.parse(fs.readFileSync(path.join(CFG, "sessions.json"), "utf-8"));
+    assert.ok(sess["telegram:6251055967"] && sess["telegram:6251055967"].hr, "on: hr session folded into owner");
+    const backups = fs.existsSync(path.join(CFG, "backups")) ? fs.readdirSync(path.join(CFG, "backups")) : [];
+    assert.ok(backups.length >= 3, "on: state/sessions/identities backed up before merge");
+  }
+
+  fs.rmSync(HOME, { recursive: true, force: true });
+  console.log(`unified-identity child(${mode}) OK`);
+}
+
+if (process.argv[2] === "--child") {
+  runChild(process.argv[3]);
+} else {
+  for (const mode of ["off", "on", "default"]) {
+    const childEnv = { ...process.env };
+    if (mode === "on") childEnv.OC_UNIFIED_IDENTITY = "1";
+    else if (mode === "off") childEnv.OC_UNIFIED_IDENTITY = "0";
+    else delete childEnv.OC_UNIFIED_IDENTITY; // default: prove unset ⇒ ON
+    try {
+      execFileSync(process.execPath, [__filename, "--child", mode], { env: childEnv, stdio: "pipe" });
+    } catch (e) {
+      console.error(`unified-identity ${mode} FAILED:\n${e.stdout || ""}${e.stderr || ""}`);
+      process.exit(1);
+    }
+  }
+  console.log("unified-identity OK");
+}