pi-roundtable 0.1.0 → 0.2.1

package/src/core/discord/dispatch-thread-host.test.ts

@@ -1,114 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { ChannelType, type Client } from "discord.js";
-import { messages } from "../i18n/index.ts";
-import { DiscordThreadHost } from "./dispatch-thread-host.ts";
-
-class FakeThread {
-	readonly sent: string[] = [];
-	readonly edits: unknown[] = [];
-	archived = false;
-	failEdit = false;
-	constructor(readonly id: string) {}
-	isThread() {
-		return true;
-	}
-	async send({ content }: { content: string }) {
-		this.sent.push(content);
-	}
-	async edit(change: unknown) {
-		if (this.failEdit) throw new Error("Missing Permissions");
-		this.edits.push(change);
-	}
-	async setArchived(archived: boolean) {
-		this.archived = archived;
-	}
-}
-
-class FakeStartMessage {
-	deleted = false;
-	thread: { name: string; autoArchiveDuration: number } | undefined;
-	constructor(
-		public content: string,
-		readonly failThread: boolean,
-	) {}
-	async startThread(options: { name: string; autoArchiveDuration: number }) {
-		if (this.failThread) throw new Error("Missing Permissions");
-		this.thread = options;
-		return { id: "700" };
-	}
-	async edit({ content }: { content: string }) {
-		this.content = content;
-	}
-	async delete() {
-		this.deleted = true;
-	}
-}
-
-class FakeParent {
-	readonly messages: FakeStartMessage[] = [];
-	failThread = false;
-	constructor(readonly type: ChannelType) {}
-	isThread() {
-		return false;
-	}
-	isSendable() {
-		return true;
-	}
-	async send({ content }: { content: string }) {
-		const message = new FakeStartMessage(content, this.failThread);
-		this.messages.push(message);
-		return message;
-	}
-}
-
-function setup() {
-	const channels = new Map<string, unknown>([
-		["10", new FakeParent(ChannelType.GuildText)],
-		["11", new FakeParent(ChannelType.DM)],
-		["12", new FakeParent(ChannelType.PublicThread)],
-		["700", new FakeThread("700")],
-	]);
-	const client = {
-		channels: { fetch: async (id: string) => channels.get(id) ?? null },
-	} as unknown as Client;
-	return {
-		host: new DiscordThreadHost(client),
-		parent: (id: string) => channels.get(id) as FakeParent,
-		thread: channels.get("700") as FakeThread,
-	};
-}
-
-const line = (thread?: string) => messages().threadStarted("t", thread);
-
-describe("DiscordThreadHost", () => {
-	test("starts the thread from the start line, then links it there", async () => {
-		const { host, parent } = setup();
-		expect(await host.open("10", "repo #1", line)).toBe("700");
-		const [start] = parent("10").messages;
-		expect(start?.thread?.name).toBe("repo #1");
-		expect(start?.content).toBe(messages().threadStarted("t", "<#700>"));
-	});
-
-	test("DMs and threads cannot host one; a refused thread removes its start line", async () => {
-		const { host, parent } = setup();
-		expect(await host.open("11", "t", line)).toBeUndefined();
-		expect(await host.open("12", "t", line)).toBeUndefined();
-		expect(await host.open("99", "t", line).catch(() => "threw")).toBe(
-			undefined,
-		);
-		parent("10").failThread = true;
-		expect(await host.open("10", "t", line).catch(() => "threw")).toBe("threw");
-		expect(parent("10").messages[0]?.deleted).toBe(true);
-	});
-
-	test("posts in the thread, then archives and locks it, or only archives without the permission", async () => {
-		const { host, thread } = setup();
-		await host.post("700", "report");
-		expect(thread.sent).toEqual(["report"]);
-		await host.close("700");
-		expect(thread.edits).toEqual([{ archived: true, locked: true }]);
-		thread.failEdit = true;
-		await host.close("700");
-		expect(thread.archived).toBe(true);
-	});
-});

package/src/core/discord/dispatch-threads.test.ts

@@ -1,94 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { readFileSync } from "node:fs";
-import { messages } from "../i18n/index.ts";
-import { silentLogger } from "../log.ts";
-import { FakeThreadHost, fakeThreads } from "../testing/thread-host.ts";
-import { DispatchThreads, threadName } from "./dispatch-threads.ts";
-
-describe("DispatchThreads", () => {
-	test("opens a thread under the origin with a start line there and the intro inside", async () => {
-		const { host, threads } = fakeThreads();
-		const thread = await threads.open(
-			"discord:10",
-			"research",
-			"📋 Task: find it",
-		);
-		expect(host.opened).toEqual([
-			{ parentId: "10", name: "research", id: "900" },
-		]);
-		expect(host.lines.get("10")).toBe(
-			messages().threadStarted("research", "<#900>"),
-		);
-		expect(thread?.mention).toBe("<#900>");
-		expect(host.textsIn("900")).toEqual(["📋 Task: find it"]);
-	});
-
-	test("close posts the report, archives once, and forgets the thread", async () => {
-		const { host, threads, ledgerPath } = fakeThreads();
-		const thread = await threads.open("discord:10", "t");
-		expect(Object.keys(JSON.parse(readFileSync(ledgerPath, "utf8")))).toEqual([
-			"900",
-		]);
-		await thread?.close("✅ Done");
-		await thread?.close("again");
-		expect(host.textsIn("900")).toEqual(["✅ Done"]);
-		expect(host.closed).toEqual(["900"]);
-		expect(JSON.parse(readFileSync(ledgerPath, "utf8"))).toEqual({});
-	});
-
-	test("no thread outside Discord, in excluded channels, where the host cannot, or when creation fails", async () => {
-		const host = new FakeThreadHost();
-		host.hostless.add("20");
-		const { threads, ledgerPath } = fakeThreads(host);
-		const party = new DispatchThreads({
-			host,
-			ledgerPath,
-			excluded: (channel) => channel === "discord:30",
-			logger: silentLogger(),
-		});
-		expect(await threads.open(undefined, "t")).toBeUndefined();
-		expect(await threads.open("mcp:abc", "t")).toBeUndefined();
-		expect(await threads.open("discord:20", "t")).toBeUndefined();
-		expect(await party.open("discord:30", "t")).toBeUndefined();
-		host.failOpen = true;
-		expect(await threads.open("discord:40", "t")).toBeUndefined();
-		expect(host.opened).toEqual([]);
-	});
-
-	test("a failed post or archive is logged, not thrown", async () => {
-		const host = new FakeThreadHost();
-		host.post = async () => {
-			throw new Error("gone");
-		};
-		host.close = async () => {
-			throw new Error("gone");
-		};
-		const { threads } = fakeThreads(host);
-		const thread = await threads.open("discord:10", "t", "intro");
-		await thread?.post("x");
-		await thread?.close("report");
-	});
-
-	test("a start after a restart archives the threads left open, with a notice", async () => {
-		const { host, threads, ledgerPath } = fakeThreads();
-		await threads.open("discord:10", "a");
-		const done = await threads.open("discord:11", "b");
-		await done?.close();
-		const restarted = new DispatchThreads({
-			host,
-			ledgerPath,
-			logger: silentLogger(),
-		});
-		await restarted.sweep();
-		expect(host.closed).toEqual(["901", "900"]);
-		expect(host.textsIn("900")).toEqual([messages().restartNotice]);
-		expect(JSON.parse(readFileSync(ledgerPath, "utf8"))).toEqual({});
-	});
-
-	test("thread names are one line within Discord's 100 characters", () => {
-		expect(threadName(" a\nb ")).toBe("a b");
-		const long = threadName("x".repeat(150));
-		expect(long.length).toBe(100);
-		expect(long.endsWith("…")).toBe(true);
-	});
-});

package/src/core/discord/owner-cards.test.ts

@@ -1,435 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import type { Interaction } from "discord.js";
-import type { OwnerQuestion } from "../domain/owner-prompts.ts";
-import { messages } from "../i18n/index.ts";
-import { silentLogger } from "../log.ts";
-import { speakerPolicy } from "../speakers.ts";
-import {
-	CARD_PREFIX,
-	type CardPayload,
-	OwnerCards,
-	type OwnerCardsOptions,
-} from "./owner-cards.ts";
-
-const OWNER = "100000000000000001";
-
-/** The card's JSON, where its text, custom ids, and disabled flags can be read. */
-const json = (payload: CardPayload | undefined) =>
-	JSON.stringify(payload?.components.map((c) => c.toJSON()));
-
-/** A channel, or a thread, that records the cards sent to it and every edit of them. */
-function fakeChannel(thread = false) {
-	const sent: CardPayload[] = [];
-	const edits: CardPayload[] = [];
-	return {
-		sent,
-		edits,
-		/** The id of the latest card sent. */
-		cardId: () =>
-			json(sent.at(-1)).match(new RegExp(`${CARD_PREFIX}([0-9a-f-]+):`))?.[1] ??
-			"",
-		channel: async () => ({
-			thread,
-			send: async (payload: CardPayload) => {
-				sent.push(payload);
-				return {
-					edit: async (change: CardPayload) => {
-						edits.push(change);
-					},
-				};
-			},
-		}),
-	};
-}
-
-type Kind = "button" | "select" | "modal";
-
-/** A press of a card's control, recording how it was answered. */
-function press(
-	kind: Kind,
-	customId: string,
-	options: {
-		user?: string;
-		roles?: string[];
-		values?: string[];
-		text?: string;
-	} = {},
-) {
-	const replies: string[] = [];
-	const updates: CardPayload[] = [];
-	const modals: unknown[] = [];
-	const interaction = {
-		isButton: () => kind === "button",
-		isStringSelectMenu: () => kind === "select",
-		isModalSubmit: () => kind === "modal",
-		isFromMessage: () => true,
-		customId,
-		user: { id: options.user ?? OWNER },
-		member: {
-			roles: { cache: new Map((options.roles ?? []).map((r) => [r, r])) },
-		},
-		values: options.values ?? [],
-		fields: { getTextInputValue: () => options.text ?? "" },
-		reply: async (answer: { content: string }) => {
-			replies.push(answer.content);
-		},
-		update: async (payload: CardPayload) => {
-			updates.push(payload);
-		},
-		showModal: async (modal: unknown) => {
-			modals.push(modal);
-		},
-		deferUpdate: async () => undefined,
-	} as unknown as Interaction;
-	return { interaction, replies, updates, modals };
-}
-
-function setup(options: Partial<OwnerCardsOptions> = {}) {
-	const fake = fakeChannel();
-	const cards = new OwnerCards({
-		ownerId: OWNER,
-		channel: fake.channel,
-		logger: silentLogger(),
-		...options,
-	});
-	const prompts = cards.prompts("discord:555");
-	if (!prompts) throw new Error("no prompts for a Discord channel");
-	return { fake, cards, prompts };
-}
-
-const tick = () => Bun.sleep(1);
-
-describe("OwnerCards", () => {
-	test("a conversation outside Discord has no cards", () => {
-		const { cards } = setup();
-		expect(cards.prompts("mcp:agent")).toBeUndefined();
-	});
-
-	test("a dispatch thread's cards are posted in the thread", async () => {
-		const asked: string[] = [];
-		const fake = fakeChannel();
-		const cards = new OwnerCards({
-			ownerId: OWNER,
-			channel: async (channelId) => {
-				asked.push(channelId);
-				return fake.channel();
-			},
-			logger: silentLogger(),
-			timeoutMs: 5,
-		});
-		await cards.prompts("discord:900")?.confirm("t", "m");
-		expect(asked).toEqual(["900"]);
-		expect(fake.sent).toHaveLength(1);
-	});
-
-	test("the owner approves; the card then shows the outcome with its buttons disabled", async () => {
-		const { fake, cards, prompts } = setup();
-		const answer = prompts.confirm(
-			"The assistant wants to run this action",
-			"**send mail**",
-		);
-		await tick();
-		expect(json(fake.sent[0])).toContain("send mail");
-		expect(json(fake.sent[0])).toContain(messages().cardRunLabel);
-		const yes = press("button", `${CARD_PREFIX}${fake.cardId()}:yes`);
-		expect(await cards.handle(yes.interaction)).toBe(true);
-		expect(await answer).toBe("approved");
-		expect(json(yes.updates[0])).toContain(messages().cardApproved);
-		expect(json(yes.updates[0])).toContain('"disabled":true');
-	});
-
-	test("a card in a channel mentions nobody", async () => {
-		const { fake, prompts } = setup({ timeoutMs: 5 });
-		await prompts.confirm(
-			"The assistant wants to run this action",
-			"**send mail**",
-		);
-		expect(fake.sent[0]?.allowedMentions).toEqual({ parse: [] });
-		expect(json(fake.sent[0])).not.toContain(`<@${OWNER}>`);
-	});
-
-	test("a card in a thread mentions the owner alone, above the unchanged card", async () => {
-		const inChannel = fakeChannel();
-		const inThread = fakeChannel(true);
-		const cards = (fake: ReturnType<typeof fakeChannel>) =>
-			new OwnerCards({
-				ownerId: OWNER,
-				channel: fake.channel,
-				logger: silentLogger(),
-			});
-		const threadCards = cards(inThread);
-		void cards(inChannel).prompts("discord:555")?.confirm("t", "**m**");
-		const answer = threadCards.prompts("discord:900")?.confirm("t", "**m**");
-		await tick();
-		const card = inThread.sent[0];
-		expect(card?.allowedMentions).toEqual({ users: [OWNER] });
-		const [mention, ...panel] = card?.components ?? [];
-		expect(mention?.toJSON()).toMatchObject({ content: `<@${OWNER}>` });
-		// Past the mention the card is the one a channel gets.
-		expect(JSON.stringify(panel.map((c) => c.toJSON()))).toBe(
-			json(inChannel.sent[0]).replaceAll(inChannel.cardId(), inThread.cardId()),
-		);
-		const yes = press("button", `${CARD_PREFIX}${inThread.cardId()}:yes`);
-		await threadCards.handle(yes.interaction);
-		expect(await answer).toBe("approved");
-		// The closed card keeps its mention line.
-		expect(json(yes.updates[0])).toContain(`<@${OWNER}>`);
-	});
-
-	test("only the owner may answer; anyone else is refused and the card stays open", async () => {
-		const { fake, cards, prompts } = setup();
-		const answer = prompts.confirm("t", "m");
-		await tick();
-		const id = fake.cardId();
-		const stranger = press("button", `${CARD_PREFIX}${id}:yes`, { user: "1" });
-		await cards.handle(stranger.interaction);
-		expect(stranger.replies).toEqual([messages().cardOwnerOnly]);
-		expect(stranger.updates).toHaveLength(0);
-		const no = press("button", `${CARD_PREFIX}${id}:no`);
-		await cards.handle(no.interaction);
-		expect(await answer).toBe("declined");
-		expect(json(no.updates[0])).toContain(messages().cardDeclined);
-	});
-
-	test("an unanswered card expires and is edited to say so", async () => {
-		const { fake, cards, prompts } = setup({ timeoutMs: 5 });
-		expect(await prompts.confirm("t", "m")).toBe("expired");
-		await tick();
-		expect(json(fake.edits[0])).toContain(messages().cardExpired);
-		expect(json(fake.edits[0])).toContain('"disabled":true');
-		// A late press finds the card gone.
-		const late = press("button", `${CARD_PREFIX}${fake.cardId()}:yes`);
-		await cards.handle(late.interaction);
-		expect(late.replies[0]).toContain(messages().cardInactive);
-	});
-
-	test("a stopped turn cancels its card", async () => {
-		const { fake, prompts } = setup();
-		const stop = new AbortController();
-		const answer = prompts.confirm("t", "m", stop.signal);
-		await tick();
-		stop.abort();
-		expect(await answer).toBe("cancelled");
-		await tick();
-		expect(json(fake.edits[0])).toContain(messages().cardStopped);
-	});
-
-	test("a card that cannot be posted counts as expired", async () => {
-		const { prompts } = setup({
-			channel: async () => {
-				throw new Error("missing access");
-			},
-		});
-		expect(await prompts.confirm("t", "m")).toBe("expired");
-	});
-
-	test("a press of a card from before a restart says it no longer works", async () => {
-		const { cards } = setup();
-		const old = press("button", `${CARD_PREFIX}gone:yes`);
-		expect(await cards.handle(old.interaction)).toBe(true);
-		expect(old.replies[0]).toContain(messages().cardInactive);
-	});
-
-	test("other components are left to other modules", async () => {
-		const { cards } = setup();
-		expect(
-			await cards.handle(press("button", "roundtable:stop").interaction),
-		).toBe(false);
-	});
-
-	describe("questions", () => {
-		const question = (q: Partial<OwnerQuestion>): OwnerQuestion => ({
-			question: "Which day?",
-			options: [
-				{ label: "Saturday", description: "morning" },
-				{ label: "Sunday" },
-				{ label: "Monday" },
-			],
-			multi: false,
-			allowOther: false,
-			...q,
-		});
-
-		test("a single choice", async () => {
-			const { fake, cards, prompts } = setup();
-			const answer = prompts.ask(
-				"The assistant has a question for you",
-				question({}),
-			);
-			await tick();
-			const card = json(fake.sent[0]);
-			expect(card).toContain("Which day?");
-			expect(card).toContain('"max_values":1');
-			expect(card).not.toContain(messages().cardOtherLabel);
-			const pick = press("select", `${CARD_PREFIX}${fake.cardId()}:pick`, {
-				values: ["1"],
-			});
-			await cards.handle(pick.interaction);
-			expect(await answer).toEqual({ choices: ["Sunday"] });
-			expect(json(pick.updates[0])).toContain(
-				messages().cardAnswered(["Sunday"]),
-			);
-		});
-
-		test("several choices, in the order they were offered", async () => {
-			const { fake, cards, prompts } = setup();
-			const answer = prompts.ask("t", question({ multi: true }));
-			await tick();
-			expect(json(fake.sent[0])).toContain('"max_values":3');
-			await cards.handle(
-				press("select", `${CARD_PREFIX}${fake.cardId()}:pick`, {
-					values: ["2", "0"],
-				}).interaction,
-			);
-			expect(await answer).toEqual({ choices: ["Saturday", "Monday"] });
-		});
-
-		test("the other option opens a form, and its text comes back with the other choices", async () => {
-			const { fake, cards, prompts } = setup();
-			const answer = prompts.ask(
-				"t",
-				question({ multi: true, allowOther: true }),
-			);
-			await tick();
-			const id = fake.cardId();
-			expect(json(fake.sent[0])).toContain(messages().cardOtherLabel);
-			const pick = press("select", `${CARD_PREFIX}${id}:pick`, {
-				values: ["0", "other"],
-			});
-			await cards.handle(pick.interaction);
-			expect(pick.modals).toHaveLength(1);
-			expect(pick.updates).toHaveLength(0);
-			const submit = press("modal", `${CARD_PREFIX}${id}:text`, {
-				text: "Wednesday evening",
-			});
-			await cards.handle(submit.interaction);
-			expect(await answer).toEqual({
-				choices: ["Saturday"],
-				text: "Wednesday evening",
-			});
-			expect(json(submit.updates[0])).toContain("Wednesday evening");
-		});
-
-		test("without options, a button opens the answer form", async () => {
-			const { fake, cards, prompts } = setup();
-			const answer = prompts.ask("t", question({ options: [] }));
-			await tick();
-			const id = fake.cardId();
-			const write = press("button", `${CARD_PREFIX}${id}:write`);
-			await cards.handle(write.interaction);
-			expect(write.modals).toHaveLength(1);
-			await cards.handle(
-				press("modal", `${CARD_PREFIX}${id}:text`, { text: "anything" })
-					.interaction,
-			);
-			expect(await answer).toEqual({ choices: [], text: "anything" });
-		});
-
-		test("an unanswered question has no answer", async () => {
-			const { prompts } = setup({ timeoutMs: 5 });
-			expect(await prompts.ask("t", question({}))).toBeUndefined();
-		});
-	});
-});
-
-describe("cards for lower tiers", () => {
-	const ADMIN = "100000000000000002";
-	const MEMBER = "100000000000000003";
-	const ROLE = "100000000000000004";
-	const speakers = speakerPolicy({
-		owners: [OWNER],
-		admins: { users: [ADMIN] },
-		members: { roles: [ROLE] },
-	});
-	const askAdminApproval = () => {
-		const fake = fakeChannel();
-		const cards = new OwnerCards({
-			ownerId: OWNER,
-			speakers,
-			channel: fake.channel,
-			logger: silentLogger(),
-		});
-		const speaker = { id: ADMIN, name: "Ada", tier: "admin" } as const;
-		const answer = cards
-			.prompts("discord:555", speaker)
-			?.confirm("t", "**create an agent**", undefined, "admin");
-		return { fake, cards, answer };
-	};
-
-	test("an approval for admin tools shows who may approve and takes an admin's press", async () => {
-		const { fake, cards, answer } = askAdminApproval();
-		await tick();
-		expect(json(fake.sent[0])).toContain(messages().cardApproversNote("admin"));
-		const admin = press("button", `${CARD_PREFIX}${fake.cardId()}:yes`, {
-			user: ADMIN,
-		});
-		await cards.handle(admin.interaction);
-		expect(await answer).toBe("approved");
-		expect(admin.replies).toEqual([]);
-	});
-
-	test("the owner may approve it too, but a member may not", async () => {
-		const { fake, cards, answer } = askAdminApproval();
-		await tick();
-		const member = press("button", `${CARD_PREFIX}${fake.cardId()}:yes`, {
-			user: MEMBER,
-			roles: [ROLE],
-		});
-		await cards.handle(member.interaction);
-		expect(member.replies).toEqual([messages().cardApproversRefusal("admin")]);
-		const owner = press("button", `${CARD_PREFIX}${fake.cardId()}:no`, {
-			user: OWNER,
-		});
-		await cards.handle(owner.interaction);
-		expect(await answer).toBe("declined");
-	});
-
-	test("a shell approval stays the owner's even when the speaker is an admin", async () => {
-		const fake = fakeChannel();
-		const cards = new OwnerCards({
-			ownerId: OWNER,
-			speakers,
-			channel: fake.channel,
-			logger: silentLogger(),
-		});
-		const speaker = { id: ADMIN, name: "Ada", tier: "admin" } as const;
-		void cards.prompts("discord:555", speaker)?.confirm("t", "**rm**");
-		await tick();
-		const admin = press("button", `${CARD_PREFIX}${fake.cardId()}:yes`, {
-			user: ADMIN,
-		});
-		await cards.handle(admin.interaction);
-		expect(admin.replies).toEqual([messages().cardOwnerOnly]);
-	});
-
-	test("a question is for the speaker who is asked, and the owner", async () => {
-		const fake = fakeChannel();
-		const cards = new OwnerCards({
-			ownerId: OWNER,
-			speakers,
-			channel: fake.channel,
-			logger: silentLogger(),
-		});
-		const speaker = { id: ADMIN, name: "Ada", tier: "admin" } as const;
-		const question = {
-			question: "Which one?",
-			options: [{ label: "First" }, { label: "Second" }],
-			multi: false,
-			allowOther: false,
-		};
-		const answer = cards.prompts("discord:555", speaker)?.ask("t", question);
-		await tick();
-		const stranger = press("select", `${CARD_PREFIX}${fake.cardId()}:pick`, {
-			user: MEMBER,
-			values: ["0"],
-		});
-		await cards.handle(stranger.interaction);
-		expect(stranger.replies).toEqual([messages().cardAskerRefusal]);
-		const asked = press("select", `${CARD_PREFIX}${fake.cardId()}:pick`, {
-			user: ADMIN,
-			values: ["1"],
-		});
-		await cards.handle(asked.interaction);
-		expect(await answer).toEqual({ choices: ["Second"] });
-	});
-});