pi-roundtable 0.1.0 → 0.2.0

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

@@ -1,325 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { ChannelType, type Client, PermissionFlagsBits } from "discord.js";
-import { DiscordOwnerOps } from "./owner-discord.ts";
-
-const OWNER = "100";
-const BOT = "200";
-const {
-	KickMembers,
-	ManageNicknames,
-	ManageRoles,
-	Administrator,
-	ViewChannel,
-	ManageThreads,
-	CreatePrivateThreads,
-	SendMessagesInThreads,
-} = PermissionFlagsBits;
-
-class FakeRole {
-	constructor(
-		readonly id: string,
-		readonly position: number,
-	) {}
-	comparePositionTo(other: FakeRole): number {
-		return this.position - other.position;
-	}
-}
-
-/** A member with a fixed permission set, a highest role, and recorded actions. */
-class FakeMember {
-	actions: string[] = [];
-	readonly roles: {
-		highest: FakeRole;
-		add: (role: FakeRole) => Promise<void>;
-	};
-	readonly permissions: { has: (needed: bigint | bigint[]) => boolean };
-	constructor(
-		readonly id: string,
-		readonly guild: FakeGuild,
-		rank: number,
-		granted: bigint[],
-	) {
-		this.roles = {
-			highest: new FakeRole(`r${id}`, rank),
-			add: async (role) => {
-				this.actions.push(`add ${role.id}`);
-			},
-		};
-		this.permissions = {
-			has: (needed) =>
-				granted.includes(Administrator) ||
-				[needed].flat().every((p) => granted.includes(p)),
-		};
-	}
-	async kick(): Promise<void> {
-		this.actions.push("kick");
-	}
-	async setNickname(nickname: string | null): Promise<void> {
-		this.actions.push(`nick ${nickname}`);
-	}
-}
-
-class FakeGuild {
-	readonly id = "1";
-	ownerId = "999";
-	readonly people = new Map<string, FakeMember>();
-	readonly roleList = new Map<string, FakeRole>();
-	readonly members = {
-		fetch: async ({ user }: { user: string }) => {
-			const member = this.people.get(user);
-			if (!member) throw new Error("Unknown Member");
-			return member;
-		},
-		fetchMe: async () => this.people.get(BOT),
-	};
-	readonly roles = {
-		fetch: async (id: string) => this.roleList.get(id) ?? null,
-	};
-	readonly threadList = new Map<string, FakeThread>();
-	readonly channels = {
-		fetchActiveThreads: async () => ({ threads: this.threadList }),
-	};
-	add(id: string, rank: number, granted: bigint[]): FakeMember {
-		const member = new FakeMember(id, this, rank, granted);
-		this.people.set(id, member);
-		return member;
-	}
-}
-
-/** A thread whose permissions are its members' server permissions. */
-class FakeThread {
-	edits: object[] = [];
-	added: string[] = [];
-	readonly parentId = "50";
-	readonly guildId: string;
-	archived = false;
-	locked = false;
-	readonly messageCount = 0;
-	readonly createdAt = new Date(0);
-	readonly members = {
-		add: async (id: string) => {
-			this.added.push(id);
-		},
-	};
-	constructor(
-		readonly id: string,
-		readonly guild: FakeGuild,
-		readonly type: ChannelType,
-		readonly name = "t",
-	) {
-		this.guildId = guild.id;
-	}
-	isThread() {
-		return true;
-	}
-	permissionsFor(member: FakeMember) {
-		return member.permissions;
-	}
-	async edit(options: object) {
-		this.edits.push(options);
-	}
-}
-
-/** A text channel whose new threads are recorded. */
-class FakeTextChannel {
-	readonly id = "50";
-	readonly type = ChannelType.GuildText;
-	readonly guildId: string;
-	created: object[] = [];
-	readonly threads = {
-		create: async (options: { name: string; type?: ChannelType }) => {
-			this.created.push(options);
-			return new FakeThread(
-				"60",
-				this.guild,
-				options.type ?? ChannelType.PublicThread,
-				options.name,
-			);
-		},
-	};
-	constructor(readonly guild: FakeGuild) {
-		this.guildId = guild.id;
-	}
-	isThread() {
-		return false;
-	}
-	permissionsFor(member: FakeMember) {
-		return member.permissions;
-	}
-}
-
-function setup(ownerGrants: bigint[], botGrants: bigint[]) {
-	const guild = new FakeGuild();
-	const owner = guild.add(OWNER, 10, ownerGrants);
-	const bot = guild.add(BOT, 20, botGrants);
-	const guest = guild.add("300", 5, []);
-	const text = new FakeTextChannel(guild);
-	const channels = new Map<string, unknown>([["50", text]]);
-	const client = {
-		isReady: () => true,
-		channels: { fetch: async (id: string) => channels.get(id) ?? null },
-		guilds: {
-			fetch: async (id: string) => {
-				if (id !== guild.id) throw new Error("Unknown Guild");
-				return guild;
-			},
-		},
-	} as unknown as Client;
-	return {
-		ops: new DiscordOwnerOps(client, OWNER),
-		guild,
-		owner,
-		bot,
-		guest,
-		text,
-		channels,
-	};
-}
-
-const kick = (userId: string) => ({ guildId: "1", userId });
-
-describe("DiscordOwnerOps", () => {
-	test("a kick runs when both hold the permission and the owner outranks the member", async () => {
-		const { ops, guest } = setup([KickMembers], [KickMembers]);
-		expect(await ops.run("discord_kick_member", kick("300"))).toEqual({
-			userId: "300",
-			kicked: true,
-		});
-		expect(guest.actions).toEqual(["kick"]);
-	});
-
-	test.each([
-		["the owner lacks it", [], [KickMembers], "OWNER_PERMISSION_MISSING"],
-		["the bot lacks it", [KickMembers], [], "BOT_PERMISSION_MISSING"],
-	])(
-		"a kick is refused when %s",
-		async (_name, ownerGrants, botGrants, code) => {
-			const { ops, guest } = setup(ownerGrants, botGrants);
-			await expect(ops.run("discord_kick_member", kick("300"))).rejects.toThrow(
-				code,
-			);
-			expect(guest.actions).toEqual([]);
-		},
-	);
-
-	test("a member at or above the owner's highest role is refused unless the owner owns the server", async () => {
-		const { ops, guild, guest } = setup([KickMembers], [KickMembers]);
-		guest.roles.highest = new FakeRole("rtop", 10);
-		await expect(ops.run("discord_kick_member", kick("300"))).rejects.toThrow(
-			"HIERARCHY",
-		);
-		guild.ownerId = OWNER;
-		await ops.run("discord_kick_member", kick("300"));
-		expect(guest.actions).toEqual(["kick"]);
-	});
-
-	test("the owner must be in the server", async () => {
-		const { ops, guild } = setup([KickMembers], [KickMembers]);
-		guild.people.delete(OWNER);
-		await expect(ops.run("discord_kick_member", kick("300"))).rejects.toThrow(
-			"OWNER_NOT_IN_SERVER",
-		);
-	});
-
-	test("a role above the owner cannot be given", async () => {
-		const { ops, guild, guest } = setup([ManageRoles], [ManageRoles]);
-		guild.roleList.set("low", new FakeRole("low", 3));
-		guild.roleList.set("high", new FakeRole("high", 15));
-		const give = (roleId: string) =>
-			ops.run("discord_add_member_role", {
-				guildId: "1",
-				userId: "300",
-				roleId,
-			});
-		await give("low");
-		await expect(give("high")).rejects.toThrow("HIERARCHY");
-		expect(guest.actions).toEqual(["add low"]);
-	});
-
-	test("the owner may rename the assistant even though it ranks higher", async () => {
-		const { ops, bot } = setup([ManageNicknames], [ManageNicknames]);
-		await ops.run("discord_set_nickname", {
-			guildId: "1",
-			userId: BOT,
-			nickname: "Pika the Crow",
-		});
-		expect(bot.actions).toEqual(["nick Pika the Crow"]);
-	});
-});
-
-describe("threads", () => {
-	const threadMaker = [
-		ViewChannel,
-		CreatePrivateThreads,
-		SendMessagesInThreads,
-	];
-
-	test("a private thread starts on its own and has the owner added", async () => {
-		const { ops, text } = setup(threadMaker, threadMaker);
-		expect(
-			await ops.run("discord_create_thread", {
-				channelId: "50",
-				name: "plans",
-				private: true,
-			}),
-		).toEqual({ id: "60", name: "plans", parentId: "50", private: true });
-		expect(text.created).toMatchObject([
-			{ name: "plans", type: ChannelType.PrivateThread },
-		]);
-	});
-
-	test("a private thread from a message is refused before anything is made", async () => {
-		const { ops, text } = setup(threadMaker, threadMaker);
-		await expect(
-			ops.run("discord_create_thread", {
-				channelId: "50",
-				name: "x",
-				messageId: "70",
-				private: true,
-			}),
-		).rejects.toThrow("INVALID_ARGUMENT");
-		expect(text.created).toEqual([]);
-	});
-
-	test("editing a thread needs Manage Threads from both", async () => {
-		const { ops, guild, channels } = setup([ViewChannel], [Administrator]);
-		const thread = new FakeThread("61", guild, ChannelType.PublicThread);
-		channels.set("61", thread);
-		await expect(
-			ops.run("discord_edit_thread", { threadId: "61", archived: true }),
-		).rejects.toThrow("OWNER_PERMISSION_MISSING");
-		expect(thread.edits).toEqual([]);
-
-		const both = setup([ViewChannel, ManageThreads], [Administrator]);
-		const shared = new FakeThread("62", both.guild, ChannelType.PublicThread);
-		both.channels.set("62", shared);
-		await both.ops.run("discord_edit_thread", {
-			threadId: "62",
-			archived: true,
-		});
-		expect(shared.edits).toMatchObject([{ archived: true }]);
-	});
-
-	test("private threads are listed only when the owner may manage threads", async () => {
-		const list = async (ownerGrants: bigint[]) => {
-			const { ops, guild } = setup(ownerGrants, [Administrator]);
-			guild.threadList.set(
-				"63",
-				new FakeThread("63", guild, ChannelType.PublicThread, "open"),
-			);
-			guild.threadList.set(
-				"64",
-				new FakeThread("64", guild, ChannelType.PrivateThread, "secret"),
-			);
-			const threads = (await ops.run("discord_list_threads", {
-				guildId: "1",
-			})) as { name: string }[];
-			return threads.map((t) => t.name);
-		};
-		expect(await list([ViewChannel])).toEqual(["open"]);
-		expect(await list([ViewChannel, ManageThreads])).toEqual([
-			"open",
-			"secret",
-		]);
-	});
-});

package/src/core/domain/expression.ts

@@ -1,21 +0,0 @@
-export const EXPRESSIONS = [
-	"neutral",
-	"happy",
-	"thinking",
-	"concerned",
-	"apologetic",
-	"surprised",
-	"proud",
-	"amused",
-	"curious",
-	"sympathetic",
-	"playful",
-	"determined",
-	"sleepy",
-] as const;
-
-export type Expression = (typeof EXPRESSIONS)[number];
-
-export function isExpression(value: string): value is Expression {
-	return (EXPRESSIONS as readonly string[]).includes(value);
-}

package/src/core/domain/profile.ts

@@ -1,32 +0,0 @@
-/** The built-in coordinator profiles; each owner connector adds one more at runtime. */
-export const STATIC_PROFILE_IDS = [
-	"general",
-	"research",
-	"workspace",
-	"discord",
-	"coding",
-] as const;
-
-export type StaticProfileId = (typeof STATIC_PROFILE_IDS)[number];
-
-/** A built-in profile id, or `connector:<name>` for an owner connector. */
-export type ProfileId = string;
-
-export const DEFAULT_PROFILE: StaticProfileId = "general";
-
-/** A coordinator profile: the same persona with a different set of active tools. */
-export interface Profile {
-	id: ProfileId;
-	/** What the judge reads to decide whether a message belongs to this profile. */
-	criterion: string;
-	/** Exact names of the assistant's own and Pi package tools active while this profile handles a turn. */
-	tools: readonly string[];
-	/** MCP gateway virtual servers whose every tool is also active. */
-	mcpServers: readonly string[];
-}
-
-/** The profiles a turn can be routed to right now. */
-export interface ProfileCatalog {
-	list(): Profile[];
-	get(id: ProfileId): Profile | undefined;
-}

package/src/core/drain.test.ts

@@ -1,46 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { waitUntilIdle } from "./drain.ts";
-import { ChannelQueue } from "./routing/channel-queue.ts";
-
-describe("waitUntilIdle", () => {
-	test("returns at once when nothing runs", async () => {
-		expect(await waitUntilIdle({ busy: () => [] })).toEqual([]);
-	});
-
-	test("waits for queued work, including work that arrives while waiting", async () => {
-		const queue = new ChannelQueue();
-		const done: string[] = [];
-		let release = () => {};
-		void queue.run("discord:1", async () => {
-			await new Promise<void>((r) => {
-				release = r;
-			});
-			done.push("first");
-		});
-		const waiting = waitUntilIdle({ busy: () => queue.busy(), intervalMs: 5 });
-		await Bun.sleep(20);
-		void queue.run("discord:2", async () => {
-			await Bun.sleep(30);
-			done.push("second");
-		});
-		release();
-		expect(await waiting).toEqual([]);
-		expect(done).toEqual(["first", "second"]);
-		expect(queue.busy()).toEqual([]);
-	});
-
-	test("gives up at the limit and says what is still busy", async () => {
-		let clock = 0;
-		const left = await waitUntilIdle({
-			busy: () => ["discord:1", "discord:1"],
-			limitMs: 3_000,
-			intervalMs: 1_000,
-			now: () => clock,
-			sleep: async (ms) => {
-				clock += ms;
-			},
-		});
-		expect(left).toEqual(["discord:1", "discord:1"]);
-		expect(clock).toBe(3_000);
-	});
-});

package/src/core/events.test.ts

@@ -1,81 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { EventBus } from "./events.ts";
-import { silentLogger } from "./log.ts";
-import type { EventHandlers } from "./plugin.ts";
-
-const turn = {
-	agent: "infra",
-	channel: "discord:1" as const,
-	speaker: undefined,
-};
-
-describe("EventBus", () => {
-	test("delivers to every plugin's handler in registration order", async () => {
-		const log: string[] = [];
-		const bus = new EventBus(silentLogger());
-		const handlers = (name: string): EventHandlers => ({
-			turnStarted: (event) => {
-				log.push(`${name} ${event.agent}`);
-			},
-		});
-		bus.link([
-			{ plugin: "a", events: handlers("a") },
-			{ plugin: "b", events: handlers("b") },
-		]);
-		await bus.deliver("turnStarted", turn);
-		expect(log).toEqual(["a infra", "b infra"]);
-	});
-
-	test("a handler that throws is logged with its plugin and never stops the others", async () => {
-		const logged: { plugin: string; event: string }[] = [];
-		const bus = new EventBus({
-			...silentLogger(),
-			error: (fields: unknown) => {
-				logged.push(fields as { plugin: string; event: string });
-			},
-		});
-		const reached: string[] = [];
-		bus.link([
-			{
-				plugin: "bad",
-				events: {
-					changed: () => {
-						throw new Error("boom");
-					},
-				},
-			},
-			{
-				plugin: "good",
-				events: {
-					changed: () => {
-						reached.push("good");
-					},
-				},
-			},
-		]);
-		await bus.deliver("changed");
-		expect(reached).toEqual(["good"]);
-		expect(logged).toMatchObject([{ plugin: "bad", event: "changed" }]);
-	});
-
-	test("reports to the sink before the handlers are linked are dropped", async () => {
-		const log: string[] = [];
-		const bus = new EventBus(silentLogger());
-		bus.sink.changed();
-		bus.link([
-			{
-				plugin: "a",
-				events: {
-					changed: () => {
-						log.push("changed");
-					},
-				},
-			},
-		]);
-		await Bun.sleep(1);
-		expect(log).toEqual([]);
-		bus.sink.changed();
-		await Bun.sleep(1);
-		expect(log).toEqual(["changed"]);
-	});
-});

package/src/core/holds.test.ts

@@ -1,54 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { PluginError } from "./errors.ts";
-import { type HoldRule, holdChain } from "./holds.ts";
-
-/** A rule that holds every call to `tool`, saying `said`. */
-const rule = (name: string, tool: string, said: string): HoldRule => ({
-	name,
-	describe: (called) => (called === tool ? said : undefined),
-});
-
-describe("holdChain", () => {
-	test("lets a call run when no rule holds it", () => {
-		const holds = holdChain([rule("a", "x", "do x")]);
-		expect(holds("y", {}, {})).toBeUndefined();
-		expect(holdChain([])("x", {}, {})).toBeUndefined();
-	});
-
-	test("the first rule that describes a call holds it", () => {
-		const holds = holdChain([
-			rule("first", "x", "first says x"),
-			rule("second", "x", "second says x"),
-			rule("third", "y", "third says y"),
-		]);
-		expect(holds("x", {}, {})).toBe("first says x");
-		expect(holds("y", {}, {})).toBe("third says y");
-	});
-
-	test("hands each rule the call's input and the session's workspace", () => {
-		const seen: unknown[] = [];
-		const holds = holdChain([
-			{
-				name: "spy",
-				describe: (tool, input, context) => {
-					seen.push({ tool, input, context });
-					return undefined;
-				},
-			},
-		]);
-		holds("bash", { command: "ls" }, { workspace: "/work" });
-		expect(seen).toEqual([
-			{
-				tool: "bash",
-				input: { command: "ls" },
-				context: { workspace: "/work" },
-			},
-		]);
-	});
-
-	test("refuses two rules with one name", () => {
-		expect(() =>
-			holdChain([rule("same", "x", "a"), rule("same", "y", "b")]),
-		).toThrow(PluginError);
-	});
-});