pi-roundtable 0.1.0 → 0.2.0

package/src/core/agents/agent-store.test.ts

@@ -1,205 +0,0 @@
-import { afterAll, beforeEach, describe, expect, test } from "bun:test";
-import { SQL } from "bun";
-import { AgentError } from "../domain/errors.ts";
-import {
-	describeDb,
-	openTestStore,
-	TEST_GUILD,
-	type TestStore,
-	testDatabaseUrl,
-} from "../testing/database.ts";
-import { AgentStore } from "./agent-store.ts";
-
-// Runs against a real PostgreSQL, only when ROUNDTABLE_TEST_DATABASE_URL is set.
-describeDb("PostgreSQL", () => {
-	let store: TestStore<AgentStore>;
-
-	const seed = (name: string, channelId?: string) => ({
-		name,
-		displayName: name.toUpperCase(),
-		prompt: `You are ${name}.`,
-		avatarPrompt: `A portrait of ${name}.`,
-		...(channelId ? { channelId } : {}),
-	});
-
-	beforeEach(async () => {
-		await store?.close();
-		const admin = new SQL(testDatabaseUrl);
-		for (const table of [
-			"agents",
-			"agent_groups",
-			"agent_group_messages",
-			"agent_group_cursors",
-		])
-			await admin.unsafe(`DROP TABLE IF EXISTS ${table}`);
-		await admin.close();
-		store = await openTestStore(AgentStore, TEST_GUILD);
-		await store.seed([
-			seed("coordinator", "100"),
-			seed("infra"),
-			seed("doctor"),
-		]);
-	});
-
-	afterAll(async () => {
-		await store.close();
-	});
-
-	describe("agents", () => {
-		test("seeding never overwrites an existing agent", async () => {
-			await store.updateAgent("infra", { prompt: "Edited." });
-			const added = await store.seed([seed("infra"), seed("new-one")]);
-			expect(added).toEqual(["new-one"]);
-			expect(store.agent("infra")?.prompt).toBe("Edited.");
-			const reopened = await openTestStore(AgentStore, TEST_GUILD);
-			expect(reopened.agent("infra")?.prompt).toBe("Edited.");
-			await reopened.close();
-		});
-
-		test("finds an active agent by its channel", async () => {
-			expect(store.agentByChannel("100")?.name).toBe("coordinator");
-			await store.archiveAgent("coordinator");
-			expect(store.agentByChannel("100")).toBeUndefined();
-		});
-
-		test("display names change; names are checked and never reused", async () => {
-			const agent = await store.updateAgent("infra", {
-				displayName: "  Ops  ",
-			});
-			expect(agent.displayName).toBe("Ops");
-			expect(agent.name).toBe("infra");
-			await expect(
-				store.updateAgent("infra", { displayName: "discord bot" }),
-			).rejects.toBeInstanceOf(AgentError);
-			expect(() => store.checkNewName("Bad Name")).toThrow(AgentError);
-			await store.archiveAgent("doctor");
-			expect(() => store.checkNewName("doctor")).toThrow(/taken/);
-			expect(() => store.activeAgent("doctor")).toThrow(/archived/);
-		});
-
-		test("prompts are limited to 4,000 characters", async () => {
-			await expect(
-				store.updateAgent("infra", { prompt: "x".repeat(4001) }),
-			).rejects.toThrow(/4000/);
-		});
-	});
-
-	describe("model settings", () => {
-		test("model and thinking are kept, survive a reopen, and reset with null", async () => {
-			await store.updateAgent("infra", {
-				model: "openai-codex/gpt-6-sol",
-				thinking: "high",
-			});
-			const reopened = await openTestStore(AgentStore, TEST_GUILD);
-			expect(reopened.agent("infra")).toMatchObject({
-				model: "openai-codex/gpt-6-sol",
-				thinking: "high",
-			});
-			await reopened.close();
-			await store.updateAgent("infra", { prompt: "Other." });
-			expect(store.agent("infra")?.model).toBe("openai-codex/gpt-6-sol");
-			const reset = await store.updateAgent("infra", {
-				model: null,
-				thinking: null,
-			});
-			expect(reset.model).toBeUndefined();
-			expect(reset.thinking).toBeUndefined();
-		});
-
-		test("a malformed model or unknown thinking level is refused", async () => {
-			await expect(
-				store.updateAgent("infra", { model: "gpt-6-sol" }),
-			).rejects.toThrow(AgentError);
-			await expect(
-				// @ts-expect-error: an unknown level from outside the type system
-				store.updateAgent("infra", { thinking: "extreme" }),
-			).rejects.toThrow(/thinking level/);
-		});
-	});
-
-	describe("groups", () => {
-		const makeGroup = () =>
-			store.createGroup({
-				name: "ops",
-				displayName: "Ops",
-				channelId: "200",
-				members: ["coordinator", "infra", "doctor"],
-				host: "coordinator",
-			});
-
-		test("a group needs 2 to 6 distinct active members and a member host", async () => {
-			expect(() => store.checkNewGroup("g", ["infra"], "infra")).toThrow(
-				AgentError,
-			);
-			expect(() =>
-				store.checkNewGroup("g", ["infra", "doctor"], "coordinator"),
-			).toThrow(/host/);
-			expect(() =>
-				store.checkNewGroup("infra", ["infra", "doctor"], "infra"),
-			).toThrow(/taken/);
-			const group = await makeGroup();
-			expect(store.groupByChannel("200")?.members).toEqual(group.members);
-		});
-
-		test("an archived agent leaves its groups, which hand over hosting or archive", async () => {
-			await makeGroup();
-			await store.archiveAgent("coordinator");
-			const group = store.group("ops");
-			expect(group?.members).toEqual(["infra", "doctor"]);
-			expect(group?.host).toBe("infra");
-			await store.archiveAgent("doctor");
-			expect(store.group("ops")?.status).toBe("archived");
-		});
-
-		test("each message reaches each member once, its own excluded", async () => {
-			await makeGroup();
-			const owner = await store.appendGroupMessage("ops", {
-				author: "owner",
-				authorName: "Riley",
-				text: "hi",
-			});
-			await store.appendGroupMessage("ops", {
-				author: "infra",
-				authorName: "INFRA",
-				text: "disk ok",
-			});
-			const first = await store.backlog("ops", "doctor", 40);
-			expect(first.messages.map((m) => m.text)).toEqual(["hi", "disk ok"]);
-			await store.advanceCursor("ops", "doctor", first.lastId ?? 0);
-			expect((await store.backlog("ops", "doctor", 40)).messages).toEqual([]);
-
-			const infra = await store.backlog("ops", "infra", 40);
-			expect(infra.messages.map((m) => m.id)).toEqual([owner]);
-			await store.advanceCursor("ops", "infra", infra.lastId ?? 0);
-
-			// A cursor never moves back, so a message is never delivered twice.
-			await store.advanceCursor("ops", "infra", owner - 1);
-			expect((await store.backlog("ops", "infra", 40)).messages).toEqual([]);
-		});
-
-		test("a long backlog carries the newest messages and counts the rest", async () => {
-			await makeGroup();
-			for (let i = 0; i < 5; i++)
-				await store.appendGroupMessage("ops", {
-					author: "owner",
-					authorName: "Riley",
-					text: `m${i}`,
-				});
-			const backlog = await store.backlog("ops", "doctor", 2);
-			expect(backlog.messages.map((m) => m.text)).toEqual(["m3", "m4"]);
-			expect(backlog.skipped).toBe(3);
-		});
-
-		test("catching up marks everything as received", async () => {
-			const group = await makeGroup();
-			await store.appendGroupMessage("ops", {
-				author: "owner",
-				authorName: "Riley",
-				text: "old",
-			});
-			await store.catchUp(group);
-			for (const member of group.members)
-				expect((await store.backlog("ops", member, 40)).messages).toEqual([]);
-		});
-	});
-});

package/src/core/agents/avatar-studio.test.ts

@@ -1,88 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { mkdtempSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { createCanvas, loadImage } from "canvas";
-import { AvatarStudio, type ImageDrawer } from "./avatar-studio.ts";
-
-const REFERENCE = join(import.meta.dir, "..", "assets", "neutral.png");
-
-function picture(width: number, height: number, color: string): Uint8Array {
-	const canvas = createCanvas(width, height);
-	const ctx = canvas.getContext("2d");
-	ctx.fillStyle = color;
-	ctx.fillRect(0, 0, width, height);
-	return canvas.toBuffer("image/png");
-}
-
-async function studio(draw: ImageDrawer) {
-	const s = new AvatarStudio({
-		dir: mkdtempSync(join(tmpdir(), "roundtable-avatars-")),
-		publicUrl: "https://example.com",
-		referencePath: REFERENCE,
-		draw,
-	});
-	await s.init();
-	return s;
-}
-
-describe("AvatarStudio", () => {
-	test("an agent without a picture gets the assistant's neutral avatar", async () => {
-		const s = await studio(async () => picture(10, 10, "red"));
-		const url = s.url(undefined);
-		expect(url).toMatch(/^https:\/\/example\.com\/avatars\/[0-9a-f]{64}\.png$/);
-		const served = s.serve(new URL(url).pathname);
-		expect(served?.status).toBe(200);
-		expect(served?.headers.get("Content-Type")).toBe("image/png");
-	});
-
-	test("draws with the reference and stores a square of at most 512 px", async () => {
-		const prompts: string[] = [];
-		const s = await studio(async (prompt, refs) => {
-			prompts.push(prompt);
-			expect(refs).toHaveLength(1);
-			return picture(1024, 768, "blue");
-		});
-		const hash = await s.draw("a friendly engineer");
-		expect(prompts[0]).toContain("a friendly engineer");
-		expect(prompts[0]).toContain("anime");
-		const served = s.serve(`/avatars/${hash}.png`);
-		if (!served) throw new Error("not served");
-		const image = await loadImage(Buffer.from(await served.arrayBuffer()));
-		expect([image.width, image.height]).toEqual([512, 512]);
-	});
-
-	test("an edit starts from the current picture and yields a new hash", async () => {
-		let references = 0;
-		const s = await studio(async (_prompt, refs) => {
-			references += refs.length;
-			return picture(64, 64, references > 1 ? "green" : "blue");
-		});
-		const first = await s.draw("x");
-		const second = await s.edit(first, "add glasses");
-		expect(second).not.toBe(first);
-	});
-
-	test("serves nothing but avatar pictures", async () => {
-		const s = await studio(async () => picture(4, 4, "red"));
-		expect(s.serve("/mcp/personal")).toBeUndefined();
-		expect(s.serve("/avatars/../secrets.env")).toBeUndefined();
-		expect(s.serve(`/avatars/${"0".repeat(64)}.png`)?.status).toBe(404);
-	});
-
-	test("its public route answers GET for pictures and 404 for any other avatar path", async () => {
-		const s = await studio(async () => picture(4, 4, "red"));
-		const hash = await s.draw("x");
-		const route = s.route("public");
-		expect(route).toMatchObject({
-			listener: "public",
-			path: { prefix: "/avatars/" },
-			methods: ["GET", "HEAD"],
-		});
-		const get = (path: string) =>
-			route.handle(new Request(`https://example.com${path}`));
-		expect((await get(`/avatars/${hash}.png`)).status).toBe(200);
-		const other = await get("/avatars/../secrets.env");
-		expect([other.status, await other.text()]).toEqual([404, "Not found"]);
-	});
-});

package/src/core/agents/group-round.test.ts

@@ -1,143 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import pino from "pino";
-import type { YesNoQuestion } from "../domain/ports.ts";
-import { TEST_OWNER as OWNER } from "../testing/owner.ts";
-import type { Agent } from "./agent-store.ts";
-import { mentionedMembers, planRound, RelevanceScorer } from "./group-round.ts";
-
-const agent = (name: string, displayName: string): Agent => ({
-	name,
-	displayName,
-	prompt: `You are ${displayName}.`,
-	avatarPrompt: "",
-	status: "active",
-});
-const members = [
-	agent("coordinator", "Координатор"),
-	agent("infra", "Infra"),
-	agent("doctor", "Bot Доктор"),
-];
-const logger = pino({ level: "silent" });
-
-describe("mentionedMembers", () => {
-	test("matches display names and names, ignoring case", () => {
-		expect(mentionedMembers("@Bot Доктор what do you think", members)).toEqual([
-			"doctor",
-		]);
-		expect(
-			mentionedMembers("@infra and @Координатор take a look", members),
-		).toEqual(["coordinator", "infra"]);
-	});
-
-	test("does not match a longer word", () => {
-		expect(mentionedMembers("@infrastructure", members)).toEqual([]);
-		expect(mentionedMembers("infra hello", members)).toEqual([]);
-	});
-});
-
-describe("planRound", () => {
-	const names = members.map((m) => m.name);
-
-	test("members above the threshold answer, most relevant last", () => {
-		expect(
-			planRound({
-				members: names,
-				host: "coordinator",
-				scores: { coordinator: 0.6, infra: 0.95, doctor: 0.2 },
-				forced: new Set(),
-			}),
-		).toEqual(["coordinator", "infra"]);
-	});
-
-	test("a forced member answers whatever its score, in score order", () => {
-		expect(
-			planRound({
-				members: names,
-				host: "coordinator",
-				scores: { coordinator: 0.1, infra: 0.9, doctor: 0.05 },
-				forced: new Set(["doctor"]),
-			}),
-		).toEqual(["doctor", "infra"]);
-	});
-
-	test("ties keep group order", () => {
-		expect(
-			planRound({
-				members: names,
-				host: "coordinator",
-				scores: { coordinator: 0.7, infra: 0.7, doctor: 0.7 },
-				forced: new Set(),
-			}),
-		).toEqual(names);
-	});
-
-	test("with nobody qualifying the host answers alone", () => {
-		expect(
-			planRound({
-				members: names,
-				host: "infra",
-				scores: { coordinator: 0.1, infra: 0.2, doctor: 0.3 },
-				forced: new Set(),
-			}),
-		).toEqual(["infra"]);
-	});
-
-	test("without scores only forced members answer, or the host", () => {
-		expect(
-			planRound({
-				members: names,
-				host: "coordinator",
-				scores: undefined,
-				forced: new Set(["doctor"]),
-			}),
-		).toEqual(["doctor"]);
-		expect(
-			planRound({
-				members: names,
-				host: "coordinator",
-				scores: undefined,
-				forced: new Set(),
-			}),
-		).toEqual(["coordinator"]);
-	});
-});
-
-describe("RelevanceScorer", () => {
-	test("asks one question per member in one request and maps the answers back", async () => {
-		const asked: Record<string, YesNoQuestion>[] = [];
-		const scorer = new RelevanceScorer(
-			{
-				askYesNo: async (_state, questions) => {
-					asked.push(questions);
-					return { m_coordinator: 0.3, m_infra: 0.9, m_doctor: 0.1 };
-				},
-			},
-			logger,
-			OWNER,
-		);
-		expect(await scorer.score(members, [], "the disk is almost full")).toEqual({
-			coordinator: 0.3,
-			infra: 0.9,
-			doctor: 0.1,
-		});
-		expect(asked).toHaveLength(1);
-		expect(Object.keys(asked[0] ?? {})).toEqual([
-			"m_coordinator",
-			"m_infra",
-			"m_doctor",
-		]);
-	});
-
-	test("a failed request yields no scores", async () => {
-		const scorer = new RelevanceScorer(
-			{
-				askYesNo: async () => {
-					throw new Error("down");
-				},
-			},
-			logger,
-			OWNER,
-		);
-		expect(await scorer.score(members, [], "hi")).toBeUndefined();
-	});
-});

package/src/core/agents/owner-identity.test.ts

@@ -1,172 +0,0 @@
-import { expect, test } from "bun:test";
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import type { InboundMessage } from "../domain/conversation.ts";
-import type { OwnerIdentity } from "../identity.ts";
-import { withReference } from "../routing/message-text.ts";
-import {
-	answerText,
-	askUserExtension,
-} from "../runtime/extensions/ask-user.ts";
-import {
-	ConfirmationGate,
-	confirmedTurnText,
-} from "../runtime/extensions/confirmation-gate.ts";
-import { PromptSlot } from "../runtime/prompt-slot.ts";
-import { addressee, type Speaker, THE_SPEAKER } from "../speakers.ts";
-import {
-	agentFailureText,
-	agentMessageText,
-	agentReplyText,
-	agentSystemPrompt,
-	chainLimitReason,
-	openingTaskText,
-} from "./agent-prompt.ts";
-import type { Agent } from "./agent-store.ts";
-
-const ALICE: OwnerIdentity = {
-	name: "Alice",
-	pronouns: { subject: "she", object: "her", possessive: "her" },
-};
-
-const agent: Agent = {
-	name: "scout",
-	displayName: "Scout",
-	prompt: "Scout things.",
-	avatarPrompt: "",
-	channelId: "5",
-	status: "active",
-};
-const coordinator: Agent = {
-	...agent,
-	name: "coordinator",
-	displayName: "Coordinator",
-	channelId: "1",
-};
-
-/** Every text these modules show a model, built for an owner who is not the test default. */
-function texts(): string[] {
-	const gate = new ConfirmationGate(() => "delete the task", ALICE);
-	return [
-		agentSystemPrompt({
-			agent,
-			coordinator,
-			shared: "",
-			workDir: "/w",
-			owner: ALICE,
-			shellUser: "alice-bot",
-		}),
-		agentSystemPrompt({
-			agent: coordinator,
-			coordinator,
-			shared: "",
-			workDir: "/w",
-			owner: ALICE,
-			shellUser: "alice-bot",
-		}),
-		agentMessageText(agent, "x", ALICE),
-		agentReplyText(ALICE, agent, "x"),
-		agentFailureText(ALICE, agent, "r"),
-		openingTaskText(undefined, "t", ALICE),
-		chainLimitReason(ALICE),
-		answerText(undefined, ALICE),
-		answerText({ choices: ["A"], text: "b" }, ALICE),
-		gate.hold("any", {}) ?? "",
-		confirmedTurnText(
-			{ profile: "general", heldAt: new Date(0), calls: [] },
-			"ok",
-			ALICE,
-		),
-		withReference(
-			{
-				text: "look",
-				forwarded: { channelMention: "<#2>", url: "https://x", text: "f" },
-			} as InboundMessage,
-			ALICE,
-		),
-	];
-}
-
-test("prompts name the configured owner and shell user, never the default's", () => {
-	const all = texts().join("\n");
-	expect(all).not.toContain("Riley");
-	expect(all).not.toContain("mcops");
-	expect(all).not.toMatch(/\b(he|him|his|He|His)\b/);
-	expect(all).toContain("Alice");
-	expect(all).toContain("alice-bot");
-});
-
-const BOB: Speaker = { id: "100000000000000007", name: "Bob", tier: "member" };
-const promptFor = (speaker?: Speaker) =>
-	agentSystemPrompt({
-		agent,
-		coordinator,
-		shared: "",
-		workDir: "/w",
-		owner: ALICE,
-		shellUser: "alice-bot",
-		...(speaker ? { speaker } : {}),
-	});
-
-test("an owner-tier speaker gets the owner's prompts unchanged", () => {
-	const owner: Speaker = { id: "1", name: "Alice", tier: "owner" };
-	expect(promptFor(owner)).toBe(promptFor());
-	expect(openingTaskText(undefined, "t", addressee(owner, ALICE))).toBe(
-		openingTaskText(undefined, "t", ALICE),
-	);
-});
-
-test("a member's turn addresses the member and says whose memory and approvals apply", () => {
-	const prompt = promptFor(BOB);
-	expect(prompt).toContain("only Bob approves held actions");
-	expect(prompt).toContain("held for Bob's confirmation");
-	expect(prompt).toContain(
-		"You are talking with Bob (Discord user 100000000000000007), who speaks at the member tier",
-	);
-	expect(prompt).toContain("Your memory is Bob's own, not Alice's");
-	expect(prompt).not.toContain("only Alice approves");
-	const bob = addressee(BOB, ALICE);
-	expect(chainLimitReason(bob)).toContain("without Bob in between");
-	expect(agentMessageText(agent, "x", bob)).toContain("not from Bob");
-	expect(gateHold(bob)).toContain("Held for Bob's confirmation");
-	expect(answerText(undefined, bob)).toContain("Bob did not answer");
-});
-
-function gateHold(who: OwnerIdentity): string {
-	const gate = new ConfirmationGate(() => "delete the task", ALICE);
-	gate.beginTurn("general", false, who);
-	return gate.hold("any", {}) ?? "";
-}
-
-test("a tool description in a shared session names the speaker, not the owner", () => {
-	let description = "";
-	askUserExtension(
-		new PromptSlot(),
-		THE_SPEAKER,
-	)({
-		registerTool: (tool: { description: string }) => {
-			description = tool.description;
-		},
-	} as unknown as ExtensionAPI);
-	expect(description).toContain("Ask the speaker a question");
-	expect(description).toContain("wait for the speaker's answer");
-	expect(description).toContain("The speaker has 30 minutes");
-	expect(description).not.toContain("Alice");
-});
-
-test("a speaker who is not the owner gets the guest's shared prompt, the owner the owner's", () => {
-	const prompt = (speaker?: Speaker) =>
-		agentSystemPrompt({
-			agent,
-			coordinator,
-			shared: "For the owner.",
-			guestShared: "For guests.",
-			workDir: "/w",
-			owner: ALICE,
-			shellUser: "alice-bot",
-			...(speaker ? { speaker } : {}),
-		});
-	expect(prompt().startsWith("For the owner.")).toBe(true);
-	expect(prompt({ id: "1", name: "Alice", tier: "owner" })).toBe(prompt());
-	expect(prompt(BOB).startsWith("For guests.")).toBe(true);
-	expect(prompt(BOB)).not.toContain("For the owner.");
-});