pi-roundtable 0.1.0 → 0.2.0

package/src/cli/templates.test.ts

@@ -1,129 +0,0 @@
-import { afterAll, beforeAll, describe, expect, test } from "bun:test";
-import { mkdirSync, readFileSync, symlinkSync, writeFileSync } from "node:fs";
-import { join, resolve } from "node:path";
-import { addPlugin } from "./add-plugin.ts";
-import { init } from "./init.ts";
-import { tempDir } from "./testing/fixtures.ts";
-
-const ROOT = resolve(import.meta.dir, "../..");
-const TSC = join(ROOT, "node_modules/.bin/tsc");
-const BIOME = join(ROOT, "node_modules/.bin/biome");
-
-function run(cwd: string, cmd: string[]): { ok: boolean; output: string } {
-	const result = Bun.spawnSync(cmd, {
-		cwd,
-		stdout: "pipe",
-		stderr: "pipe",
-		env: { ...process.env, CI: "" },
-	});
-	return {
-		ok: result.exitCode === 0,
-		output: `${result.stdout.toString()}${result.stderr.toString()}`,
-	};
-}
-
-/**
- * The generated project with `pi-roundtable`, `typebox`, and the types linked from this
- * checkout, so it typechecks and tests against the source under test without the network.
- */
-function link(project: string): void {
-	const modules = join(project, "node_modules");
-	mkdirSync(join(modules, "pi-roundtable"), { recursive: true });
-	mkdirSync(join(modules, "@types"), { recursive: true });
-	writeFileSync(
-		join(modules, "pi-roundtable/package.json"),
-		JSON.stringify({
-			name: "pi-roundtable",
-			type: "module",
-			exports: { ".": "./src/index.ts", "./testing": "./src/testing.ts" },
-		}),
-	);
-	symlinkSync(join(ROOT, "src"), join(modules, "pi-roundtable/src"));
-	symlinkSync(join(ROOT, "node_modules/typebox"), join(modules, "typebox"));
-	symlinkSync(
-		join(ROOT, "node_modules/@types/bun"),
-		join(modules, "@types/bun"),
-	);
-}
-
-const dir = tempDir("roundtable-template-");
-const bun = { version: Bun.version, required: ">=1.3.0" };
-const check = (label: string) => {
-	const typecheck = run(dir.path, [TSC, "--noEmit"]);
-	const test = run(dir.path, ["bun", "test"]);
-	const lint = run(dir.path, [BIOME, "check", "."]);
-	return { label, typecheck, test, lint };
-};
-
-let fresh: ReturnType<typeof check>;
-let grown: ReturnType<typeof check>;
-
-beforeAll(() => {
-	const report = init({ cwd: dir.path, bun, version: "0.1.0" });
-	if (!report.ok) throw new Error(report.problems.join("\n"));
-	link(dir.path);
-	fresh = check("fresh");
-	const added = addPlugin({ cwd: dir.path, name: "second-plugin" });
-	if (!added.ok) throw new Error(added.problems.join("\n"));
-	grown = check("after add plugin");
-}, 120_000);
-afterAll(() => dir.done());
-
-describe("every template rendered into one project", () => {
-	test("typechecks with no edits", () => {
-		expect(fresh.typecheck.output).toBe("");
-		expect(fresh.typecheck.ok).toBe(true);
-	});
-	test("passes its own test with no edits", () => {
-		expect(fresh.test.output).toContain("1 pass");
-		expect(fresh.test.ok).toBe(true);
-	});
-	test("passes the linter it ships with", () => {
-		expect(fresh.lint.output).toContain("No fixes applied");
-		expect(fresh.lint.ok).toBe(true);
-	});
-	test("still typechecks, tests, and lints after `add plugin`", () => {
-		expect(grown.typecheck.output).toBe("");
-		expect(grown.test.output).toContain("2 pass");
-		expect(grown.lint.output).toContain("No fixes applied");
-		expect(grown.typecheck.ok && grown.test.ok && grown.lint.ok).toBe(true);
-	});
-});
-
-test("the generated project's pinned tools match this package's own", () => {
-	const project = JSON.parse(
-		readFileSync(join(dir.path, "package.json"), "utf8"),
-	) as {
-		dependencies: Record<string, string>;
-		devDependencies: Record<string, string>;
-	};
-	const own = JSON.parse(readFileSync(join(ROOT, "package.json"), "utf8")) as {
-		dependencies: Record<string, string>;
-		devDependencies: Record<string, string>;
-	};
-	expect(project.dependencies.typebox).toBe(own.dependencies.typebox);
-	for (const name of ["typescript", "@biomejs/biome", "@types/bun"])
-		expect(project.devDependencies[name]).toBe(own.devDependencies[name]);
-});
-
-test("no template file is hidden from git by an ignore rule, which would leave a clone unable to init", () => {
-	const inRepository = Bun.spawnSync(["git", "rev-parse", "--git-dir"], {
-		cwd: ROOT,
-		stdout: "pipe",
-		stderr: "pipe",
-	});
-	// The exported public tree is not a checkout; its own ignore file is packaging/.gitignore.
-	if (inRepository.exitCode !== 0) return;
-	const ignored = Bun.spawnSync(
-		[
-			"git",
-			"ls-files",
-			"--others",
-			"--ignored",
-			"--exclude-standard",
-			"templates",
-		],
-		{ cwd: ROOT, stdout: "pipe", stderr: "pipe" },
-	);
-	expect(ignored.stdout.toString().trim()).toBe("");
-});

package/src/cli/testing/fixtures.ts

@@ -1,106 +0,0 @@
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { dirname, join } from "node:path";
-import type { RoundtableConfig } from "../../core/config/config.ts";
-import type { DefinedRoundtable } from "../../core/define-roundtable.ts";
-import type { Http, HttpResponse } from "../http.ts";
-import type { Ports } from "../project.ts";
-
-/** A configuration the schema accepts. */
-export const validConfig: RoundtableConfig = {
-	owner: { id: "100000000000000001", name: "Ada" },
-	discord: {
-		token: "bot-token",
-		guild: "900000000000000001",
-		entryChannel: "900000000000000002",
-	},
-	database: { url: "postgres://user:secret@db.example.test:5432/bot" },
-	dataDir: "/data",
-	model: "anthropic/claude-sonnet-5-5",
-	http: { publicUrl: "https://bot.example.test" },
-};
-
-/** A directory that is removed when the test ends; call `done` in `afterEach`. */
-export function tempDir(prefix = "roundtable-cli-"): {
-	path: string;
-	write(file: string, content: string): void;
-	done(): void;
-} {
-	const path = mkdtempSync(join(tmpdir(), prefix));
-	return {
-		path,
-		write(file, content) {
-			mkdirSync(dirname(join(path, file)), { recursive: true });
-			writeFileSync(join(path, file), content);
-		},
-		done: () => rmSync(path, { recursive: true, force: true }),
-	};
-}
-
-/** Ports that hand out `config`, assemble nothing real, and report a login from `source`. */
-export function fakePorts(
-	config: unknown = validConfig,
-	overrides: Partial<Ports> = {},
-): Ports {
-	const defined: DefinedRoundtable = {
-		options: { logger: {} as never },
-		plugins: [{ name: "database", setup: () => ({}) }],
-	};
-	return {
-		loadConfig: async () => config,
-		define: async () => defined,
-		login: async () => "ANTHROPIC_API_KEY",
-		...overrides,
-	};
-}
-
-/** An HTTP client that answers from `routes`, keyed by the path after the host, and fails on any other. */
-export function fakeHttp(
-	routes: Record<string, HttpResponse | Error>,
-): Http & { requests: string[] } {
-	const requests: string[] = [];
-	return {
-		requests,
-		async get(url) {
-			const key = url.replace(/^https?:\/\/[^/]+(\/api\/v10)?/, "") || "/";
-			requests.push(key);
-			const route = routes[key];
-			if (route === undefined) throw new Error(`no route for ${key}`);
-			if (route instanceof Error) throw route;
-			return route;
-		},
-	};
-}
-
-export const BOT_ID = "800000000000000001";
-
-/** Discord as it answers when everything is right: the token is good, the bot is in the guild, with every permission and the intent. */
-export function healthyDiscord(
-	permissions: bigint,
-	guild = validConfig.discord.guild,
-	channel = validConfig.discord.entryChannel,
-): Record<string, HttpResponse> {
-	return {
-		"/users/@me": { status: 200, body: { id: BOT_ID, username: "Bot" } },
-		"/applications/@me": { status: 200, body: { flags: 1 << 18 } },
-		[`/guilds/${guild}`]: {
-			status: 200,
-			body: {
-				name: "Test Guild",
-				owner_id: "100000000000000001",
-				roles: [
-					{ id: guild, permissions: "0" },
-					{ id: "700000000000000001", permissions: String(permissions) },
-				],
-			},
-		},
-		[`/guilds/${guild}/members/${BOT_ID}`]: {
-			status: 200,
-			body: { roles: ["700000000000000001"] },
-		},
-		[`/channels/${channel}`]: {
-			status: 200,
-			body: { id: channel, guild_id: guild, permission_overwrites: [] },
-		},
-	};
-}

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

@@ -1,142 +0,0 @@
-import { expect, test } from "bun:test";
-import type { InboundMessage } from "../contract/channels.ts";
-import { silentLogger } from "../log.ts";
-import { type Speaker, speakerPolicy } from "../speakers.ts";
-import { TEST_OWNER } from "../testing/owner.ts";
-import { agentClaim } from "./agent-claim.ts";
-
-const OWNER = "100000000000000001";
-const ADMIN = "100000000000000002";
-const STRANGER = "100000000000000009";
-const ROLE = "200000000000000001";
-
-function setup() {
-	const answered: { kind: string; speaker: Speaker; text: string }[] = [];
-	const team = {
-		guildId: "1",
-		owns: (channel: string) =>
-			channel === "discord:10"
-				? ("agent" as const)
-				: channel === "discord:20"
-					? ("group" as const)
-					: undefined,
-		answerOwner: async (_c: string, speaker: Speaker, text: string) => {
-			answered.push({ kind: "agent", speaker, text });
-			return { ok: true as const, text: "" };
-		},
-		answerGroup: async (_c: string, speaker: Speaker, text: string) => {
-			answered.push({ kind: "group", speaker, text });
-		},
-		answerBackground: async (_c: string, speaker: Speaker, text: string) => {
-			answered.push({ kind: "background", speaker, text });
-			return { ok: true as const, text: "" };
-		},
-		startFresh: async () => {},
-	};
-	const claim = agentClaim({
-		owner: TEST_OWNER,
-		speakers: speakerPolicy({
-			owners: [OWNER],
-			admins: { users: [ADMIN] },
-			members: { roles: [ROLE] },
-		}),
-		// biome-ignore lint/suspicious/noExplicitAny: a recording stand-in for the team
-		team: team as any,
-		runtime: { steer: async () => false },
-		surface: { react: async () => {}, unreact: async () => {} },
-		attachmentDir: () => "/tmp",
-		logger: silentLogger(),
-	});
-	return { claim, answered };
-}
-
-const message = (
-	authorId: string,
-	channel: `${string}:${string}`,
-	extra: Partial<InboundMessage> = {},
-): InboundMessage => ({
-	channel,
-	messageId: "m1",
-	authorId,
-	authorName: `name-${authorId.slice(-1)}`,
-	authorIsBot: false,
-	isDirect: false,
-	guildId: "1",
-	mentionsBot: false,
-	repliesToBot: false,
-	text: "hello",
-	attachments: [],
-	...extra,
-});
-
-test("the owner, an admin, and a member by role are each answered as themselves", async () => {
-	const { claim, answered } = setup();
-	for (const [id, roles] of [
-		[OWNER, []],
-		[ADMIN, []],
-		[STRANGER, [ROLE]],
-	] as const) {
-		const admission = claim.admit(
-			message(id, "discord:10", { authorRoleIds: roles }),
-		);
-		if (admission?.kind !== "turn") throw new Error("expected a turn");
-		await admission.run();
-	}
-	expect(answered.map((a) => a.speaker.tier)).toEqual([
-		"owner",
-		"admin",
-		"member",
-	]);
-	expect(answered[1]?.speaker).toEqual({
-		id: ADMIN,
-		name: "name-2",
-		tier: "admin",
-	});
-});
-
-test("a turn in an agent's channel names a speaker who is not the owner, and the owner's stays plain", async () => {
-	const { claim, answered } = setup();
-	for (const id of [OWNER, ADMIN]) {
-		const admission = claim.admit(message(id, "discord:10"));
-		if (admission?.kind !== "turn") throw new Error("expected a turn");
-		await admission.run();
-	}
-	expect(answered[0]?.text).toBe("hello");
-	expect(answered[1]?.text).toBe(
-		"(Message from name-2, at the admin tier.)\n\nhello",
-	);
-});
-
-test("an author the policy does not name gets no turn, in an agent or a group channel", () => {
-	const { claim } = setup();
-	expect(claim.admit(message(STRANGER, "discord:10"))).toBeUndefined();
-	expect(claim.admit(message(STRANGER, "discord:20"))).toBeUndefined();
-	expect(
-		claim.admit(message(OWNER, "discord:10", { authorIsBot: true })),
-	).toBeUndefined();
-});
-
-test("a group message carries its speaker", async () => {
-	const { claim, answered } = setup();
-	const admission = claim.admit(message(ADMIN, "discord:20"));
-	if (admission?.kind !== "turn") throw new Error("expected a turn");
-	await admission.run();
-	expect(answered[0]).toMatchObject({
-		kind: "group",
-		speaker: { tier: "admin" },
-	});
-});
-
-test("a background turn runs at its creator's tier, the owner's when a person set none", async () => {
-	const { claim, answered } = setup();
-	const turn = {
-		channel: "discord:10" as const,
-		mode: "owner" as const,
-		author: { id: ADMIN, name: "n" },
-		turnId: "t",
-		text: "go",
-	};
-	await claim.background?.({ ...turn, tier: "admin" });
-	await claim.background?.(turn);
-	expect(answered.map((a) => a.speaker.tier)).toEqual(["admin", "owner"]);
-});

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

@@ -1,120 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { silentLogger } from "../log.ts";
-import { AgentDashboard, dashboardSections } from "./agent-dashboard.ts";
-import type { TeamStatus } from "./agent-team.ts";
-
-const NOW = new Date("2026-09-27T06:30:00Z");
-const TRACES = "https://example.com/traces/";
-const APP = "https://example.com/app/";
-/** The plugins' lines: the web app's, then the trace viewer's. */
-const LINES = [
-	`🧭 [Web app](${APP}) full dashboard, notes, and cleanup`,
-	`🔭 [Traces](${TRACES}) each message's model, tools, and tokens`,
-];
-
-const status: TeamStatus = {
-	agents: [
-		{
-			name: "infra",
-			displayName: "Infra",
-			channelId: "11",
-			model: "openai-codex/gpt-6-sol",
-			thinking: "high",
-			workingIn: "12",
-			waiting: 2,
-			context: { tokens: 42_000, contextWindow: 200_000 },
-			lastActive: new Date("2026-09-27T06:03:00Z"),
-			schedules: 1,
-		},
-		{
-			name: "doctor",
-			displayName: "Bot Doctor",
-			channelId: "13",
-			model: "claude-bridge/claude-opus-5-5",
-			thinking: "medium",
-			waiting: 0,
-			schedules: 0,
-		},
-	],
-	groups: [
-		{
-			name: "ops",
-			displayName: "Ops group",
-			channelId: "12",
-			members: ["Coordinator", "Infra"],
-			host: "Coordinator",
-			busy: 1,
-			lastActive: new Date("2026-09-26T06:03:00Z"),
-		},
-	],
-};
-
-describe("dashboardSections", () => {
-	test("shows the plugins' links, then each agent's and group's state", () => {
-		const [header, agents, groups] = dashboardSections(status, LINES, NOW);
-		// The header the links were written into before plugins contributed them, byte for byte.
-		expect(header).toBe(
-			"## Agent server\n🧭 [Web app](https://example.com/app/) full dashboard, notes, and cleanup\n🔭 [Traces](https://example.com/traces/) each message's model, tools, and tokens\n-# Updated 06:30; refreshed when a turn starts or ends, at most every 10 seconds",
-		);
-		expect(agents).toContain("**Infra** <#11>");
-		expect(agents).toContain("`openai-codex/gpt-6-sol` · thinking `high`");
-		expect(agents).toContain(
-			"🟠 Working (<#12>), 2 queued · context 42k / 200k (21%)",
-		);
-		expect(agents).toContain("-# Schedules 1 · Last active 06:03");
-		expect(agents).toContain("🟢 Idle · context —");
-		expect(agents).toContain("No activity since startup");
-		expect(groups).toContain("**Ops group** <#12>");
-		expect(groups).toContain("Members: Coordinator, Infra | Host: Coordinator");
-		expect(groups).toContain("🟠 1 in progress");
-		expect(groups).toContain("-# Last active 09-26 06:03");
-	});
-
-	test("stays within Discord's text limit, saying how many were left out", () => {
-		const many: TeamStatus = {
-			agents: Array.from({ length: 60 }, (_, i) => ({
-				...status.agents[1],
-				name: `a${i}`,
-				displayName: `Agent ${i}`,
-			})) as TeamStatus["agents"],
-			groups: [],
-		};
-		const sections = dashboardSections(many, LINES, NOW);
-		expect(sections.join("").length).toBeLessThan(4000);
-		expect(sections[1]).toMatch(/\d+ more not listed/);
-		expect(sections[2]).toContain("None.");
-	});
-});
-
-describe("AgentDashboard", () => {
-	test("updates at once, then at most once per interval, and keeps going after a failure", async () => {
-		const shown: string[][] = [];
-		let fail = true;
-		const dashboard = new AgentDashboard({
-			status: async () => status,
-			board: {
-				show: async (sections) => {
-					if (fail) {
-						fail = false;
-						throw new Error("discord down");
-					}
-					shown.push(sections);
-				},
-			},
-			lines: () => LINES,
-			logger: silentLogger(),
-			minIntervalMs: 40,
-			refreshMs: 60_000,
-		});
-		dashboard.start();
-		await Bun.sleep(10);
-		expect(shown).toHaveLength(0);
-		dashboard.changed();
-		dashboard.changed();
-		await Bun.sleep(15);
-		expect(shown).toHaveLength(0);
-		await Bun.sleep(50);
-		expect(shown).toHaveLength(1);
-		dashboard.stop();
-	});
-});

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

@@ -1,124 +0,0 @@
-import { afterEach, beforeEach, expect, test } from "bun:test";
-import { SQL } from "bun";
-import { migrate } from "../db/migrations.ts";
-import { SkillStore } from "../modules/skills/skill-store.ts";
-import {
-	describeDb,
-	migratedPool,
-	TEST_GUILD,
-	testDatabaseUrl,
-} from "../testing/database.ts";
-import { AgentStore } from "./agent-store.ts";
-
-const OTHER_GUILD = "900000000000000002";
-const TABLES = [
-	"agents",
-	"agent_groups",
-	"agent_group_messages",
-	"agent_group_cursors",
-	"agent_skills",
-];
-
-// Runs against a real PostgreSQL, only when ROUNDTABLE_TEST_DATABASE_URL is set.
-describeDb("guild scoping", () => {
-	let sql: SQL;
-
-	beforeEach(async () => {
-		const admin = new SQL(testDatabaseUrl);
-		for (const table of TABLES)
-			await admin.unsafe(`DROP TABLE IF EXISTS ${table}`);
-		await admin.close();
-		// The tables as they were before rows carried a guild, with rows in every one.
-		sql = await migratedPool(AgentStore.migration, SkillStore.migration);
-		await sql`INSERT INTO agents (name, display_name, prompt, avatar_prompt, channel_id)
-			VALUES ('infra', 'Infra', 'p', 'a', '10'), ('doctor', 'Doctor', 'p', 'a', '11')`;
-		await sql`INSERT INTO agent_groups (name, display_name, channel_id, members, host)
-			VALUES ('ops', 'Ops', '20', 'infra,doctor', 'infra')`;
-		await sql`INSERT INTO agent_group_messages (group_name, author, author_name, text)
-			VALUES ('ops', 'owner', 'Riley', 'hi')`;
-		await sql`INSERT INTO agent_group_cursors (group_name, agent_name, last_id)
-			VALUES ('ops', 'infra', 1)`;
-		await sql`INSERT INTO agent_skills (agent, skill) VALUES ('infra', 'ops-skill')`;
-	});
-
-	afterEach(async () => {
-		await sql.close();
-	});
-
-	const upgrade = (guild: string) =>
-		migrate(sql, [
-			...AgentStore.migrations(guild),
-			...SkillStore.migrations(guild),
-		]);
-
-	test("existing rows of every table go to the configured guild", async () => {
-		await upgrade(TEST_GUILD);
-		for (const table of TABLES) {
-			const rows: { guild_id: string }[] = await sql.unsafe(
-				`SELECT guild_id FROM ${table}`,
-			);
-			expect(rows.length).toBeGreaterThan(0);
-			expect(new Set(rows.map((r) => r.guild_id))).toEqual(
-				new Set([TEST_GUILD]),
-			);
-		}
-		const store = await AgentStore.attach(sql, TEST_GUILD);
-		expect(store.agents().map((a) => a.name)).toEqual(["infra", "doctor"]);
-		expect(store.group("ops")?.members).toEqual(["infra", "doctor"]);
-		expect(
-			(await store.recentGroupMessages("ops", 5)).map((m) => m.text),
-		).toEqual(["hi"]);
-		expect((await store.backlog("ops", "doctor", 40)).messages).toHaveLength(1);
-		const skills = await SkillStore.attach(sql, TEST_GUILD);
-		expect(skills.carriedBy("infra")).toEqual(["ops-skill"]);
-	});
-
-	test("running the migration again changes nothing", async () => {
-		await upgrade(TEST_GUILD);
-		const before = await sql`SELECT * FROM agents ORDER BY name`;
-		await upgrade(TEST_GUILD);
-		expect(await sql`SELECT * FROM agents ORDER BY name`).toEqual(before);
-	});
-
-	test("a guild sees only its own rows and may reuse a name of another", async () => {
-		await upgrade(TEST_GUILD);
-		const other = await AgentStore.attach(sql, OTHER_GUILD);
-		expect(other.agents()).toEqual([]);
-		expect(other.groups()).toEqual([]);
-		for (const name of ["infra", "doctor"])
-			await other.createAgent({
-				name,
-				displayName: `Other ${name}`,
-				prompt: "p",
-				avatarPrompt: "a",
-				channelId: `3${name.length}`,
-			});
-		await other.createGroup({
-			name: "ops",
-			displayName: "Other Ops",
-			channelId: "40",
-			members: ["infra", "doctor"],
-			host: "infra",
-		});
-		const mine = await AgentStore.attach(sql, TEST_GUILD);
-		expect(mine.agent("infra")?.displayName).toBe("Infra");
-		const reopened = await AgentStore.attach(sql, OTHER_GUILD);
-		expect(reopened.agent("infra")?.displayName).toBe("Other infra");
-		expect(reopened.group("ops")?.displayName).toBe("Other Ops");
-		// Messages and cursors of one guild's group are not the other's.
-		await other.appendGroupMessage("ops", {
-			author: "owner",
-			authorName: "X",
-			text: "elsewhere",
-		});
-		expect(
-			(await mine.recentGroupMessages("ops", 5)).map((m) => m.text),
-		).toEqual(["hi"]);
-	});
-
-	test("a name is still unique inside its guild", async () => {
-		await upgrade(TEST_GUILD);
-		const store = await AgentStore.attach(sql, TEST_GUILD);
-		expect(() => store.checkNewName("infra")).toThrow(/taken/);
-	});
-});