pi-roundtable 0.1.0 → 0.2.0

package/src/core/contract/discord.ts

@@ -1,33 +0,0 @@
-import type {
-	APIApplicationCommandSubcommandGroupOption,
-	APIApplicationCommandSubcommandOption,
-	Interaction,
-	InteractionContextType,
-	RESTPostAPIChatInputApplicationCommandsJSONBody,
-} from "discord.js";
-
-/** A group of slash commands and the components they post, handled together. */
-export interface InteractionModule {
-	/** Top-level commands of its own; never the configured root command. */
-	commands(): RESTPostAPIChatInputApplicationCommandsJSONBody[];
-	/** Resolves true when this module handled the interaction. */
-	handle(interaction: Interaction): Promise<boolean>;
-}
-
-/** A subcommand or subcommand group under the root command. */
-export type RootOption =
-	| APIApplicationCommandSubcommandOption
-	| APIApplicationCommandSubcommandGroupOption;
-
-/** A plugin's interactions: its module, and the subcommands it adds under the root command. */
-export interface InteractionContribution {
-	module: InteractionModule;
-	rootOptions?: readonly RootOption[];
-}
-
-/** The one root command every plugin's subcommands go under, such as `/roundtable`. */
-export interface CommandRoot {
-	name: string;
-	description: string;
-	contexts: readonly InteractionContextType[];
-}

package/src/core/db/migrations.test.ts

@@ -1,237 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import type { SQL } from "bun";
-import { MigrationError, PluginError } from "../errors.ts";
-import { Roundtable } from "../host.ts";
-import { silentLogger } from "../log.ts";
-import type { RoundtablePlugin } from "../plugin.ts";
-import { type Migration, migrate, openPool } from "./migrations.ts";
-
-// The core cannot import a consumer's test helpers, so it reads the test database itself.
-const url = process.env.ROUNDTABLE_TEST_DATABASE_URL;
-const describeDb = url ? describe : describe.skip;
-
-/** What the promise rejected with; undefined when it resolved. */
-async function rejection(
-	promise: Promise<unknown> | undefined,
-): Promise<unknown> {
-	try {
-		await promise;
-	} catch (error) {
-		return error;
-	}
-	return undefined;
-}
-
-function recording(name: string, log: string[], fails = false): Migration {
-	return {
-		name,
-		up: async () => {
-			log.push(name);
-			if (fails) throw new Error("boom");
-		},
-	};
-}
-
-function roundtable(
-	plugins: RoundtablePlugin[],
-	database?: { url: string },
-): { host: Roundtable; exits: number[] } {
-	const exits: number[] = [];
-	const host = new Roundtable(
-		{
-			logger: silentLogger(),
-			drain: { intervalMs: 1, limitMs: 50 },
-			exit: (code) => exits.push(code),
-			...(database ? { database } : {}),
-		},
-		plugins,
-	);
-	return { host, exits };
-}
-
-describe("migrate", () => {
-	// A pool connects on its first query, so these never reach a server.
-	const unreachable = () => openPool("postgres://nobody@127.0.0.1:1/none");
-
-	test("runs the migrations in order", async () => {
-		const log: string[] = [];
-		const sql = unreachable();
-		await migrate(sql, [recording("a", log), recording("b", log)]);
-		await sql.close();
-		expect(log).toEqual(["a", "b"]);
-	});
-
-	test("refuses a name declared twice before running any", async () => {
-		const log: string[] = [];
-		const sql = unreachable();
-		const error = await rejection(
-			migrate(sql, [recording("a", log), recording("a", log)]),
-		);
-		await sql.close();
-		expect(error).toBeInstanceOf(PluginError);
-		expect(log).toEqual([]);
-	});
-
-	test("stops at a failing migration and names it", async () => {
-		const log: string[] = [];
-		const sql = unreachable();
-		const error = await rejection(
-			migrate(sql, [recording("a", log, true), recording("b", log)]),
-		);
-		await sql.close();
-		expect(error).toBeInstanceOf(MigrationError);
-		expect(String(error)).toContain("migration a failed");
-		expect(log).toEqual(["a"]);
-	});
-});
-
-describe("Roundtable migrations", () => {
-	test("refuses migrations without a configured database, before any setup", async () => {
-		const log: string[] = [];
-		const { host } = roundtable([
-			{
-				name: "stores",
-				migrations: [recording("a", log)],
-				setup: () => {
-					log.push("setup");
-					return {};
-				},
-			},
-		]);
-		expect(await rejection(host.run())).toBeInstanceOf(PluginError);
-		expect(log).toEqual([]);
-	});
-
-	test("without a database, reading it during setup is a plugin error", async () => {
-		let error: unknown;
-		const { host } = roundtable([
-			{
-				name: "reader",
-				setup: ({ database }) => {
-					try {
-						database();
-					} catch (e) {
-						error = e;
-					}
-					return { events: {} };
-				},
-			},
-		]);
-		await host.run();
-		expect(error).toBeInstanceOf(PluginError);
-	});
-});
-
-describeDb("PostgreSQL", () => {
-	const table = "roundtable_migration_test";
-	const tableMigration: Migration = {
-		name: "test-table",
-		up: async (sql) => {
-			await sql.unsafe(
-				`CREATE TABLE IF NOT EXISTS ${table} (id int PRIMARY KEY, note text NOT NULL)`,
-			);
-			await sql.unsafe(
-				`ALTER TABLE ${table} ADD COLUMN IF NOT EXISTS added text NOT NULL DEFAULT 'x'`,
-			);
-		},
-	};
-
-	async function reset(): Promise<void> {
-		const admin = openPool(url ?? "");
-		await admin.unsafe(`DROP TABLE IF EXISTS ${table}`);
-		await admin.close();
-	}
-
-	test("migrates every plugin in order before any setup, then closes the pool last", async () => {
-		await reset();
-		const log: string[] = [];
-		let pool: SQL | undefined;
-		const { host, exits } = roundtable(
-			[
-				{
-					name: "first",
-					migrations: [recording("first", log), tableMigration],
-					setup: ({ database }) => {
-						log.push("setup first");
-						pool = database();
-						return {
-							services: [{ name: "uses", stop: () => void log.push("stop") }],
-						};
-					},
-				},
-				{
-					name: "second",
-					migrations: [recording("second", log)],
-					setup: () => {
-						log.push("setup second");
-						return {};
-					},
-				},
-			],
-			{ url: url ?? "" },
-		);
-		await host.run();
-		expect(log).toEqual(["first", "second", "setup first", "setup second"]);
-		await pool?.unsafe(`INSERT INTO ${table} (id, note) VALUES (1, 'kept')`);
-		await host.shutdown("SIGTERM");
-		expect(log.at(-1)).toBe("stop");
-		expect(exits).toEqual([0]);
-		// The pool closed after the services stopped.
-		expect(await rejection(pool?.unsafe("SELECT 1"))).toBeInstanceOf(Error);
-	});
-
-	test("a second boot over the existing schema keeps its rows", async () => {
-		const read: { id: number; note: string; added: string }[][] = [];
-		for (let boot = 0; boot < 2; boot++) {
-			const { host } = roundtable(
-				[
-					{
-						name: "stores",
-						migrations: [tableMigration],
-						setup: async ({ database }) => {
-							read.push(
-								await database().unsafe(
-									`SELECT id, note, added FROM ${table} ORDER BY id`,
-								),
-							);
-							return {};
-						},
-					},
-				],
-				{ url: url ?? "" },
-			);
-			await host.run();
-			await host.shutdown("SIGTERM");
-		}
-		expect(read).toEqual([
-			[{ id: 1, note: "kept", added: "x" }],
-			[{ id: 1, note: "kept", added: "x" }],
-		]);
-		await reset();
-	});
-
-	test("a failing migration stops the boot before any setup", async () => {
-		const log: string[] = [];
-		const { host } = roundtable(
-			[
-				{
-					name: "broken",
-					migrations: [recording("broken", log, true)],
-					setup: () => {
-						log.push("setup");
-						return {};
-					},
-				},
-			],
-			{ url: url ?? "" },
-		);
-		const error = await rejection(host.run());
-		expect(error).toBeInstanceOf(PluginError);
-		expect(String(error)).toContain("plugin broken: migration broken failed: ");
-		expect(String(error)).toContain(
-			"Fix the migration or restore the database, then start again.",
-		);
-		expect((error as Error).cause).toBeInstanceOf(MigrationError);
-		expect(log).toEqual(["broken"]);
-	});
-});

package/src/core/define-roundtable.test.ts

@@ -1,134 +0,0 @@
-import { afterEach, describe, expect, test } from "bun:test";
-import { mkdirSync, mkdtempSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import type { RoundtableConfig } from "./config/config.ts";
-import { defineRoundtable } from "./define-roundtable.ts";
-import { ConfigError } from "./domain/errors.ts";
-import { messages } from "./i18n/index.ts";
-import { createZhTW } from "./i18n/zh-tw.ts";
-import type { RoundtablePlugin } from "./plugin.ts";
-import { useTestLocale } from "./testing/locale.ts";
-
-const dataDir = mkdtempSync(join(tmpdir(), "roundtable-define-"));
-
-const config: RoundtableConfig = {
-	owner: { id: "100000000000000001", name: "Ada" },
-	discord: {
-		token: "token",
-		guild: "900000000000000001",
-		entryChannel: "900000000000000002",
-	},
-	database: { url: "postgres://localhost/roundtable" },
-	dataDir,
-	model: "anthropic/claude-sonnet-5-5",
-	http: { publicUrl: "https://bot.example.com", port: 3456 },
-};
-
-const mine: RoundtablePlugin = {
-	name: "mine",
-	setup: () => ({ dashboard: ["a line"] }),
-};
-
-afterEach(() => {
-	// Other suites read the text through the catalog; leave it as the tests expect.
-	useTestLocale();
-});
-
-describe("defineRoundtable", () => {
-	test("returns the built-in plugins in their fixed order, the operator's, then the scheduler", async () => {
-		const { plugins } = await defineRoundtable({ ...config, plugins: [mine] });
-		expect(plugins.map((plugin) => plugin.name)).toEqual([
-			"stores",
-			"discord",
-			"modules",
-			"agent-server",
-			"seeds",
-			"mine",
-			"schedules",
-		]);
-	});
-
-	test("migrates the core's tables first, in a fixed order", async () => {
-		const { plugins } = await defineRoundtable(config);
-		expect(
-			plugins.flatMap((plugin) => (plugin.migrations ?? []).map((m) => m.name)),
-		).toEqual([
-			"owner-memory",
-			"owner-memory-speaker",
-			"schedules",
-			"pending-confirmations",
-			"agents",
-			"agents-guild",
-			"skills",
-			"skills-guild",
-			"skills-written-kind",
-		]);
-	});
-
-	test("the host options carry the database, the root command, the tool tiers, and one listener", async () => {
-		const { options } = await defineRoundtable({
-			...config,
-			name: "Robin",
-			toolTiers: { shell: "admin" },
-		});
-		expect(options.database).toEqual({ url: config.database.url });
-		expect(options.commands?.root.name).toBe("robin");
-		expect(options.listeners).toEqual([{ id: "public", port: 3456 }]);
-		expect(options.toolTiers?.minTier("shell")).toBe("admin");
-	});
-
-	test("the locale and the assistant's name reach the text the bot shows", async () => {
-		await defineRoundtable({ ...config, name: "Robin", locale: "zh-TW" });
-		expect(messages().ownerRootDescription).toContain("Robin");
-		expect(messages().stopLabel).toBe(
-			createZhTW({ assistant: "Robin", root: "robin" }).stopLabel,
-		);
-	});
-
-	test("a mistake in the configuration stops before anything is built, naming the key", async () => {
-		await expect(
-			defineRoundtable({
-				...config,
-				discord: { ...config.discord, guilld: "1" },
-			} as RoundtableConfig),
-		).rejects.toThrow(
-			'config discord.guilld: unknown key. Did you mean "guild"?',
-		);
-		await expect(
-			defineRoundtable({ ...config, model: "sonnet" }),
-		).rejects.toBeInstanceOf(ConfigError);
-	});
-
-	test("reads the prompt files named in the configuration, and refuses a missing or empty one", async () => {
-		const dir = join(dataDir, "prompts");
-		mkdirSync(dir, { recursive: true });
-		writeFileSync(join(dir, "shared.md"), "You are Robin.\n");
-		writeFileSync(join(dir, "empty.md"), "  \n");
-		await defineRoundtable({
-			...config,
-			prompts: { shared: join(dir, "shared.md") },
-		});
-		await expect(
-			defineRoundtable({
-				...config,
-				prompts: { shared: join(dir, "missing.md") },
-			}),
-		).rejects.toThrow("config prompts.shared: cannot read");
-		await expect(
-			defineRoundtable({
-				...config,
-				prompts: { shared: join(dir, "empty.md") },
-			}),
-		).rejects.toThrow(
-			`config prompts.shared: ${join(dir, "empty.md")} is empty`,
-		);
-	});
-
-	test("the judge answers with a clear error until the model is available", async () => {
-		const { options } = await defineRoundtable(config);
-		await expect(options.judgeModel?.("system", "question")).rejects.toThrow(
-			"the judge's model anthropic/claude-sonnet-5-5 is not available",
-		);
-	});
-});

package/src/core/define.test.ts

@@ -1,144 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { Type } from "typebox";
-import { definePlugin, defineTool, ToolRefusal } from "./define.ts";
-import { PluginError } from "./errors.ts";
-import type { SessionContext } from "./sessions.ts";
-import type { Speaker } from "./speakers.ts";
-
-const speaker: Speaker = { id: "1", name: "Ann", tier: "admin" };
-
-const note = {
-	name: "note_add",
-	description: "Save a note.",
-	parameters: Type.Object({ text: Type.String() }),
-	minTier: "member" as const,
-	run: (args: { text: string }) => `saved ${args.text}`,
-};
-
-type Registered = {
-	name: string;
-	execute(
-		id: string,
-		params: unknown,
-		signal?: AbortSignal,
-	): Promise<{ content: { text: string }[]; isError?: boolean }>;
-};
-
-/** Registers the tool in a fake Pi session the way the runtime does, and returns what it registered. */
-function register(tool: ReturnType<typeof defineTool>): Registered {
-	const registered: Registered[] = [];
-	const context = {
-		speaker: () => speaker,
-		turnChannel: "discord:2",
-		agent: { name: "helper", session: "discord:2", home: "discord:2" },
-	} as unknown as SessionContext;
-	const factory = tool.session.snapshot().factory(context);
-	factory?.({
-		registerTool: (def: Registered) => registered.push(def),
-	} as unknown as ExtensionAPI);
-	const [one] = registered;
-	if (!one) throw new Error("nothing was registered");
-	return one;
-}
-
-describe("defineTool", () => {
-	test("registers the tool in a session and runs it with the turn's speaker", async () => {
-		let seen: unknown;
-		const tool = defineTool({
-			...note,
-			run: (args, turn) => {
-				seen = { args, speaker: turn.speaker, channel: turn.channel };
-				return "ok";
-			},
-		});
-		const result = await register(tool).execute("call", { text: "milk" });
-		expect(result.content[0]?.text).toBe("ok");
-		expect(seen).toEqual({
-			args: { text: "milk" },
-			speaker,
-			channel: "discord:2",
-		});
-		expect(tool.session.snapshot().requiredTools).toEqual(["note_add"]);
-		expect(tool.minTier).toBe("member");
-		expect(tool.agent).toBe(true);
-	});
-
-	test("a ToolRefusal becomes an error result the model reads; any other error fails the call", async () => {
-		const refuse = defineTool({
-			...note,
-			run: () => {
-				throw new ToolRefusal("no empty notes");
-			},
-		});
-		const refused = await register(refuse).execute("c", { text: "" });
-		expect(refused.isError).toBe(true);
-		expect(refused.content[0]?.text).toBe("no empty notes");
-		const fail = defineTool({
-			...note,
-			run: () => {
-				throw new Error("disk gone");
-			},
-		});
-		await expect(register(fail).execute("c", { text: "x" })).rejects.toThrow(
-			"disk gone",
-		);
-	});
-
-	test("its hold rule describes the tool's own calls and no other", () => {
-		const tool = defineTool({
-			...note,
-			hold: (args) => (args.text === "rm" ? "delete everything" : undefined),
-		});
-		const rule = tool.hold;
-		expect(rule?.name).toBe("tool:note_add");
-		expect(rule?.describe("note_add", { text: "rm" }, {})).toBe(
-			"delete everything",
-		);
-		expect(rule?.describe("note_add", { text: "hi" }, {})).toBeUndefined();
-		expect(rule?.describe("other", { text: "rm" }, {})).toBeUndefined();
-	});
-
-	test("each mistake is refused with the tool's name and the fix", () => {
-		const refused = (change: Record<string, unknown>) => () =>
-			defineTool({ ...note, ...change } as typeof note);
-		expect(refused({ name: "NoteAdd" })).toThrow(PluginError);
-		expect(refused({ name: "NoteAdd" })).toThrow(
-			'tool "NoteAdd": the name must be lowercase words joined by underscores, such as note_add. Rename the tool.',
-		);
-		expect(refused({ name: "bash" })).toThrow(
-			"tool bash: the agents already have a tool of this name. Rename the tool.",
-		);
-		expect(refused({ minTier: undefined })).toThrow(
-			"tool note_add: minTier must be one of member, admin, owner; got undefined. Set the lowest tier that may use it.",
-		);
-		expect(refused({ description: " " })).toThrow(
-			"tool note_add: the description is empty. Tell the model when to call the tool.",
-		);
-		expect(refused({ run: undefined })).toThrow(
-			"tool note_add: run is missing. Give the function the tool runs.",
-		);
-	});
-});
-
-describe("definePlugin", () => {
-	const setup = () => ({});
-
-	test("returns the plugin it was given", () => {
-		const plugin = { name: "my-notes", setup };
-		expect(definePlugin(plugin)).toBe(plugin);
-	});
-
-	test("refuses a name that is not lowercase words joined by dashes, and a missing setup", () => {
-		expect(() => definePlugin({ name: "My Notes", setup })).toThrow(
-			'plugin "My Notes": the name must be lowercase words joined by dashes, such as my-notes. Rename the plugin.',
-		);
-		expect(() =>
-			definePlugin({ name: "notes" } as unknown as Parameters<
-				typeof definePlugin
-			>[0]),
-		).toThrow(
-			"plugin notes: setup is missing. Give the function that returns what the plugin adds.",
-		);
-	});
-});

package/src/core/discord/agent-commands.test.ts

@@ -1,58 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { messages } from "../i18n/index.ts";
-import { formModels, skillsText } from "./agent-commands.ts";
-
-describe("formModels", () => {
-	const usable = [
-		"claude-bridge/claude-opus-5-5",
-		"claude-bridge/claude-haiku-4-5",
-		"claude-bridge/claude-sonnet-5-5",
-		"openai-codex/gpt-6-luna",
-		"openai-codex/gpt-6-sol",
-		"openai-codex/gpt-6-astra",
-	];
-
-	test("offers the five form models in order, leaving out other usable ones", () => {
-		expect(formModels(usable)).toEqual([
-			"openai-codex/gpt-6-astra",
-			"openai-codex/gpt-6-sol",
-			"openai-codex/gpt-6-luna",
-			"claude-bridge/claude-sonnet-5-5",
-			"claude-bridge/claude-opus-5-5",
-		]);
-	});
-
-	test("leaves out form models the host cannot run", () => {
-		expect(
-			formModels(["claude-bridge/claude-opus-5-5", "openai-codex/gpt-6-sol"]),
-		).toEqual(["openai-codex/gpt-6-sol", "claude-bridge/claude-opus-5-5"]);
-	});
-
-	test("puts the agent's current model first when the form does not offer it", () => {
-		expect(formModels(usable, "claude-bridge/claude-haiku-4-5")[0]).toBe(
-			"claude-bridge/claude-haiku-4-5",
-		);
-		expect(formModels(usable, "openai-codex/gpt-6-sol")).toEqual(
-			formModels(usable),
-		);
-	});
-});
-
-describe("skillsText", () => {
-	test("lists carried skills with the built-in one marked, and missing ones with their reason", () => {
-		const skill = (name: string) => ({
-			name,
-			description: "Use when x.",
-			file: `/s/${name}/SKILL.md`,
-		});
-		const text = messages();
-		expect(
-			skillsText({
-				skills: [skill("writing-skills"), skill("example-skill")],
-				missing: [{ name: "gone", reason: "file not found" }],
-			}),
-		).toBe(
-			`${text.agentSkills([text.agentSkillBuiltin("writing-skills"), "`example-skill`"])}\n${text.agentSkillMissing("gone", "file not found")}`,
-		);
-	});
-});

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

@@ -1,70 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { ChannelType, type Client } from "discord.js";
-import { silentLogger } from "../log.ts";
-import { DiscordDashboard } from "./agent-discord.ts";
-
-const BOT = "900";
-
-/** A dashboard channel in a fake server whose one bot message may already be pinned. */
-function fixture(options: { pinned: boolean; pinFails?: boolean }) {
-	const pins: string[] = [];
-	const message = {
-		id: "m1",
-		pinned: options.pinned,
-		author: { id: BOT },
-		channel: { messages: { fetch: async () => message } },
-		edit: async () => message,
-		pin: async () => {
-			if (options.pinFails) throw new Error("Missing Permissions");
-			pins.push("m1");
-		},
-	};
-	const channel = {
-		type: ChannelType.GuildText,
-		name: "dashboard",
-		parentId: null,
-		topic: null,
-		setTopic: async () => undefined,
-		messages: {
-			fetch: async () => ({
-				find: (match: (m: typeof message) => boolean) => [message].find(match),
-			}),
-		},
-	};
-	channel.topic = null;
-	const client = {
-		user: { id: BOT },
-		guilds: {
-			fetch: async () => ({
-				channels: {
-					fetch: async () => ({
-						find: (match: (c: typeof channel) => boolean) =>
-							[channel].find(match),
-					}),
-				},
-			}),
-		},
-	} as unknown as Client;
-	return { pins, dashboard: new DiscordDashboard(client, "1", silentLogger()) };
-}
-
-describe("DiscordDashboard pinning", () => {
-	test("an existing unpinned message is pinned once, however often it is updated", async () => {
-		const { dashboard, pins } = fixture({ pinned: false });
-		await dashboard.show(["a"]);
-		await dashboard.show(["b"]);
-		expect(pins).toEqual(["m1"]);
-	});
-
-	test("an already pinned message is left alone", async () => {
-		const { dashboard, pins } = fixture({ pinned: true });
-		await dashboard.show(["a"]);
-		expect(pins).toEqual([]);
-	});
-
-	test("a refused pin does not stop the update", async () => {
-		const { dashboard } = fixture({ pinned: false, pinFails: true });
-		await dashboard.show(["a"]);
-		await dashboard.show(["b"]);
-	});
-});