pi-roundtable 0.1.0 → 0.2.1

package/src/core/sessions.test.ts

@@ -1,85 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { PluginError } from "./errors.ts";
-import { compileSessionPlan, planOrder, type SessionTool } from "./sessions.ts";
-
-const tool = (name: string, phase: SessionTool["phase"]): SessionTool => ({
-	name,
-	phase,
-	...(phase === "compaction" ? { engine: `${name}-engine` } : {}),
-	snapshot: () => ({ revision: 0, factory: () => null }),
-});
-
-const names = (tools: readonly SessionTool[]) => tools.map((t) => t.name);
-
-describe("compileSessionPlan", () => {
-	test("orders tools, then the compactor, then MCP, keeping registration order in each", () => {
-		const plan = compileSessionPlan([
-			tool("mcp-a", "mcp"),
-			tool("memory", "tools"),
-			tool("summarizer", "compaction"),
-			tool("notify", "tools"),
-			tool("mcp-b", "mcp"),
-		]);
-		expect(names(planOrder(plan))).toEqual([
-			"memory",
-			"notify",
-			"summarizer",
-			"mcp-a",
-			"mcp-b",
-		]);
-	});
-
-	test("a plan without a compactor has none", () => {
-		const plan = compileSessionPlan([tool("memory", "tools")]);
-		expect(plan.compaction).toBeUndefined();
-		expect(names(planOrder(plan))).toEqual(["memory"]);
-	});
-
-	test("refuses a name registered twice", () => {
-		expect(() =>
-			compileSessionPlan([tool("memory", "tools"), tool("memory", "mcp")]),
-		).toThrow(
-			new PluginError(
-				"session tool memory is registered twice. Rename one of the two.",
-			),
-		);
-	});
-
-	test("refuses the names of the core's own extensions", () => {
-		for (const name of [
-			"read-attachment",
-			"confirmation-gate",
-			"ask-user",
-			"self-compact-guard",
-			"profile-tools",
-		]) {
-			expect(() => compileSessionPlan([tool(name, "tools")])).toThrow(
-				new PluginError(
-					`session tool ${name} takes a core extension name. Rename it.`,
-				),
-			);
-		}
-	});
-
-	test("refuses a compactor that names no engine", () => {
-		const { engine: _engine, ...unmarked } = tool("summarizer", "compaction");
-		expect(() => compileSessionPlan([unmarked])).toThrow(
-			new PluginError(
-				"compactor summarizer needs an engine: the value its compactions record as details.engine.",
-			),
-		);
-	});
-
-	test("refuses a second compactor", () => {
-		expect(() =>
-			compileSessionPlan([
-				tool("summarizer", "compaction"),
-				tool("pi", "compaction"),
-			]),
-		).toThrow(
-			new PluginError(
-				"only one compactor may run; got summarizer, pi. Keep one.",
-			),
-		);
-	});
-});

package/src/core/shared/unix-server.ts

@@ -1,18 +0,0 @@
-import { rmSync } from "node:fs";
-import type { Server } from "bun";
-
-/**
- * Serves HTTP on a unix socket without Bun's 10-second idle timeout, which would cut long
- * turns and quiet model streams. Bun 1.4.2 honors `idleTimeout` on unix sockets, but its
- * types reject the option there, hence the cast. A stale socket file is removed first.
- */
-export function serveUnix(
-	socketPath: string,
-	fetch: (request: Request) => Response | Promise<Response>,
-): Server<undefined> {
-	rmSync(socketPath, { force: true });
-	const options = { unix: socketPath, idleTimeout: 0, fetch };
-	return Bun.serve(
-		options as unknown as Parameters<typeof Bun.serve>[0],
-	) as Server<undefined>;
-}

package/src/core/size.test.ts

@@ -1,9 +0,0 @@
-import { expect, test } from "bun:test";
-import { resolve } from "node:path";
-import { oversizedFiles } from "./testing/file-size.ts";
-
-test("no file of the core is over the size limit", () => {
-	expect(
-		oversizedFiles(resolve(import.meta.dir, "../.."), ["src/core"]),
-	).toEqual([]);
-});

package/src/core/speakers.test.ts

@@ -1,78 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { ConfigError } from "./domain/errors.ts";
-import { parseTierMembers, speakerPolicy, tierAtLeast } from "./speakers.ts";
-
-const OWNER = "100000000000000001";
-const ADMIN = "100000000000000002";
-const MEMBER = "100000000000000003";
-const ROLE = "200000000000000001";
-const STRANGER = "100000000000000009";
-const author = (id: string, roleIds: string[] = []) => ({
-	id,
-	name: `u${id.slice(-1)}`,
-	roleIds,
-});
-
-describe("speakerPolicy", () => {
-	test("names only the owner by default, so nobody else is a speaker", () => {
-		const policy = speakerPolicy({ owners: [OWNER] });
-		expect(policy.resolve(author(OWNER))?.tier).toBe("owner");
-		expect(policy.resolve(author(STRANGER, [ROLE]))).toBeUndefined();
-	});
-
-	test("admins and members come from users or roles, and the highest tier wins", () => {
-		const policy = speakerPolicy({
-			owners: [OWNER],
-			admins: { users: [ADMIN], roles: [ROLE] },
-			members: { users: [MEMBER, ADMIN] },
-		});
-		expect(policy.resolve(author(ADMIN))?.tier).toBe("admin");
-		expect(policy.resolve(author(STRANGER, [ROLE]))?.tier).toBe("admin");
-		expect(policy.resolve(author(MEMBER))?.tier).toBe("member");
-		expect(policy.resolve(author(OWNER, [ROLE]))?.tier).toBe("owner");
-		expect(policy.resolve(author(STRANGER))).toBeUndefined();
-	});
-
-	test("@everyone makes every author a member", () => {
-		const policy = speakerPolicy({
-			owners: [OWNER],
-			members: { everyone: true },
-		});
-		expect(policy.resolve(author(STRANGER))).toEqual({
-			id: STRANGER,
-			name: "u9",
-			tier: "member",
-		});
-	});
-});
-
-test("tiers order owner above admin above member", () => {
-	expect(tierAtLeast("owner", "admin")).toBe(true);
-	expect(tierAtLeast("admin", "admin")).toBe(true);
-	expect(tierAtLeast("member", "admin")).toBe(false);
-});
-
-describe("parseTierMembers", () => {
-	test("reads users, roles, and @everyone", () => {
-		expect(
-			parseTierMembers(
-				`user:${ADMIN}, role:${ROLE}, ${MEMBER}, @everyone`,
-				"X",
-				true,
-			),
-		).toEqual({ users: [ADMIN, MEMBER], roles: [ROLE], everyone: true });
-	});
-
-	test("unset or empty means nobody", () => {
-		expect(parseTierMembers(undefined, "X", true)).toBeUndefined();
-		expect(parseTierMembers(" , ", "X", true)).toBeUndefined();
-	});
-
-	test("refuses a malformed entry, and @everyone where it is not allowed", () => {
-		expect(() => parseTierMembers("nope", "X", true)).toThrow(ConfigError);
-		expect(() => parseTierMembers("group:1", "X", true)).toThrow(ConfigError);
-		expect(() => parseTierMembers("@everyone", "X", false)).toThrow(
-			/@everyone/,
-		);
-	});
-});

package/src/core/testing/file-size.ts

@@ -1,34 +0,0 @@
-import { readdirSync, readFileSync } from "node:fs";
-import { join, relative } from "node:path";
-
-/** The most lines a source file may have before it is split along its responsibilities. */
-export const MAX_SOURCE_LINES = 500;
-/** The most lines a test file may have. */
-export const MAX_TEST_LINES = 700;
-
-function typeScriptFiles(dir: string): string[] {
-	return readdirSync(dir, { withFileTypes: true }).flatMap((entry) => {
-		if (entry.name === "node_modules") return [];
-		const path = join(dir, entry.name);
-		if (entry.isDirectory()) return typeScriptFiles(path);
-		return /\.tsx?$/.test(entry.name) ? [path] : [];
-	});
-}
-
-/** The files under `dirs` over their limit, each as `<path> has <n> lines`. */
-export function oversizedFiles(
-	root: string,
-	dirs: readonly string[],
-): string[] {
-	return dirs
-		.flatMap((dir) => typeScriptFiles(join(root, dir)))
-		.flatMap((file) => {
-			const lines = readFileSync(file, "utf8").split("\n").length - 1;
-			const limit = /\.test\.tsx?$/.test(file)
-				? MAX_TEST_LINES
-				: MAX_SOURCE_LINES;
-			return lines > limit
-				? [`${relative(root, file)} has ${lines} lines, over ${limit}`]
-				: [];
-		});
-}

package/src/core/time.test.ts

@@ -1,166 +0,0 @@
-import { afterEach, describe, expect, test } from "bun:test";
-import { setLocale } from "./i18n/index.ts";
-import { nextRun, parseRecurrence } from "./modules/schedules/recurrence.ts";
-import { scheduleToolSpecs } from "./shared/schedule-tools.ts";
-import { useTestLocale } from "./testing/locale.ts";
-import {
-	setTimeZone,
-	timeZone,
-	zonedDate,
-	zonedInstant,
-	zonedStamp,
-	zonedToday,
-} from "./time.ts";
-
-afterEach(useTestLocale);
-
-describe("configured time zone", () => {
-	test("defaults to UTC before a host configures the process", () => {
-		const result = Bun.spawnSync({
-			cmd: [
-				"bun",
-				"-e",
-				'import { timeZone } from "./src/core/time.ts"; console.log(timeZone())',
-			],
-		});
-		expect(result.exitCode).toBe(0);
-		expect(result.stdout.toString().trim()).toBe("UTC");
-	});
-
-	test("rejects an invalid zone without changing the current one", () => {
-		setTimeZone("UTC");
-		expect(() => setTimeZone("Not/A_Zone")).toThrow("Not/A_Zone");
-		expect(timeZone()).toBe("UTC");
-	});
-
-	test("Taipei agrees with the former +8 arithmetic for a year-long sweep", () => {
-		setTimeZone("Asia/Taipei");
-		const start = Date.parse("2026-01-01T00:00:00Z");
-		for (let i = 0; i < 366; i += 1) {
-			const at = new Date(start + i * 86_400_000 + i * 61_000);
-			const old = new Date(at.getTime() + 8 * 3_600_000).toISOString();
-			expect(zonedDate(at)).toBe(old.slice(0, 10));
-			expect(zonedStamp(at)).toBe(old.slice(0, 16).replace("T", " "));
-		}
-		expect(zonedToday()).toBe(zonedDate(new Date()));
-	});
-
-	test("New York resolves spring gaps later and fall folds to the first occurrence", () => {
-		setTimeZone("America/New_York");
-		expect(zonedInstant("2026-03-08", "02:30").toISOString()).toBe(
-			"2026-03-08T07:30:00.000Z",
-		);
-		expect(zonedStamp(zonedInstant("2026-03-08", "02:30"))).toBe(
-			"2026-03-08 03:30",
-		);
-		expect(zonedInstant("2026-11-01", "01:30").toISOString()).toBe(
-			"2026-11-01T05:30:00.000Z",
-		);
-	});
-
-	test("handles +14 and half-hour offsets", () => {
-		setTimeZone("Pacific/Kiritimati");
-		expect(zonedInstant("2026-07-01", "09:15").toISOString()).toBe(
-			"2026-06-30T19:15:00.000Z",
-		);
-		setTimeZone("America/St_Johns");
-		expect(zonedInstant("2026-01-01", "09:15").toISOString()).toBe(
-			"2026-01-01T12:45:00.000Z",
-		);
-		expect(zonedInstant("2026-07-01", "09:15").toISOString()).toBe(
-			"2026-07-01T11:45:00.000Z",
-		);
-	});
-
-	test("daily, weekly, and interval recurrence stay at wall-clock time across DST", () => {
-		setTimeZone("America/New_York");
-		const before = new Date("2026-03-07T15:00:00Z");
-		const daily = parseRecurrence(
-			{ time: "09:00", start_date: "2026-03-07" },
-			before,
-		);
-		expect(nextRun(daily, before)?.toISOString()).toBe(
-			"2026-03-08T13:00:00.000Z",
-		);
-		expect(
-			nextRun(daily, new Date("2026-03-08T13:00:00Z"))?.toISOString(),
-		).toBe("2026-03-09T13:00:00.000Z");
-		expect(
-			nextRun(daily, new Date("2026-10-31T13:00:00Z"))?.toISOString(),
-		).toBe("2026-11-01T14:00:00.000Z");
-		const weekly = parseRecurrence(
-			{ time: "09:00", weekdays: ["sun"] },
-			before,
-		);
-		expect(nextRun(weekly, before)?.toISOString()).toBe(
-			"2026-03-08T13:00:00.000Z",
-		);
-		expect(
-			nextRun(weekly, new Date("2026-03-08T13:00:00Z"))?.toISOString(),
-		).toBe("2026-03-15T13:00:00.000Z");
-		const interval = parseRecurrence(
-			{ time: "09:00", every_days: 2, start_date: "2026-03-07" },
-			before,
-		);
-		expect(nextRun(interval, before)?.toISOString()).toBe(
-			"2026-03-09T13:00:00.000Z",
-		);
-		expect(
-			nextRun(
-				{ kind: "once", date: "2026-11-01", time: "01:30" },
-				new Date("2026-10-31T12:00:00Z"),
-			)?.toISOString(),
-		).toBe("2026-11-01T05:30:00.000Z");
-	});
-
-	test("the wording of every catalog derives from the configured zone, with none special", () => {
-		const errors = () => [
-			() => parseRecurrence({ at: "soon" }, new Date()),
-			() => parseRecurrence({ time: "soon" }, new Date()),
-		];
-		const messagesFor = (locale: "en" | "zh-TW") => {
-			setLocale(locale, { assistant: "Roundtable", root: "roundtable" });
-			return errors().map((run) => {
-				try {
-					run();
-				} catch (error) {
-					return String(error);
-				}
-				throw new Error("expected the recurrence to be refused");
-			});
-		};
-		setTimeZone("Europe/Berlin");
-		expect(messagesFor("en")).toEqual([
-			expect.stringContaining('at must be Europe/Berlin time as "YYYY-MM-DD'),
-			expect.stringContaining('"HH:MM", Europe/Berlin) to repeat'),
-		]);
-		setTimeZone("America/Argentina/Buenos_Aires");
-		expect(messagesFor("zh-TW")).toEqual([
-			expect.stringContaining('at must be Buenos Aires time as "YYYY-MM-DD'),
-			expect.stringContaining('"HH:MM", Buenos Aires) to repeat'),
-		]);
-		setTimeZone("UTC");
-		expect(scheduleToolSpecs()[0]?.description).toContain("UTC time");
-	});
-
-	test("relative once scheduling preserves the second occurrence of a fall-back hour", () => {
-		setTimeZone("America/New_York");
-		const now = new Date("2026-11-01T06:10:00Z");
-		const once = parseRecurrence({ in_minutes: 20 }, now);
-		expect(nextRun(once, now)?.toISOString()).toBe("2026-11-01T06:30:00.000Z");
-	});
-
-	test("tool descriptions take the zone when built, in the wording of the locale", () => {
-		setTimeZone("Asia/Taipei");
-		expect(scheduleToolSpecs()[0]?.description).toContain(
-			"set Asia/Taipei time",
-		);
-		setLocale("zh-TW", { assistant: "Roundtable", root: "roundtable" });
-		expect(scheduleToolSpecs()[0]?.description).toContain("set Taipei time");
-		setLocale("en", { assistant: "Roundtable", root: "roundtable" });
-		setTimeZone("America/New_York");
-		expect(scheduleToolSpecs()[0]?.description).toContain(
-			"America/New_York time",
-		);
-	});
-});

package/src/core/tool-tiers.test.ts

@@ -1,117 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { ConfigError } from "./domain/errors.ts";
-import {
-	CORE_TOOL_TIERS,
-	parseToolTiers,
-	toolsForTier,
-	toolTiers,
-} from "./tool-tiers.ts";
-
-describe("default tiers", () => {
-	const tiers = toolTiers();
-
-	test("members may look, read, and message agents", () => {
-		for (const tool of [
-			"agent_list",
-			"agent_get",
-			"message_agent",
-			"channel_read",
-			"ask_user",
-			"web_search",
-		])
-			expect(tiers.minTier(tool)).toBe("member");
-	});
-
-	test("every speaker may keep a memory of their own", () => {
-		for (const tool of ["memory_add", "memory_search", "memory_remove"])
-			expect(tiers.minTier(tool)).toBe("member");
-	});
-
-	test("creating, editing, archiving, and arranging agents and groups need an admin", () => {
-		for (const tool of [
-			"agent_create",
-			"agent_update",
-			"agent_avatar",
-			"group_create",
-			"group_update",
-			"archive",
-			"channel_arrange",
-			"agent_skills",
-			"schedule_create",
-			"delegate_task",
-		])
-			expect(tiers.minTier(tool)).toBe("admin");
-	});
-
-	test("the shell, notifying the owner, Discord administration, and any tool nobody named stay with the owner", () => {
-		for (const tool of [
-			"bash",
-			"write",
-			"notify_owner",
-			"discord_ban",
-			"some_plugin_tool",
-		])
-			expect(tiers.minTier(tool)).toBe("owner");
-	});
-
-	test("every tool an agent carries from the core is named on purpose", () => {
-		expect(Object.keys(CORE_TOOL_TIERS)).toEqual(
-			expect.arrayContaining(["agent_create", "skill_create", "schedule_list"]),
-		);
-	});
-});
-
-describe("toolsForTier", () => {
-	const tiers = toolTiers();
-	const all = ["agent_list", "agent_create", "bash", "some_plugin_tool"];
-
-	test("each tier gets the tools at or below it, in order", () => {
-		expect(toolsForTier(all, "member", tiers)).toEqual(["agent_list"]);
-		expect(toolsForTier(all, "admin", tiers)).toEqual([
-			"agent_list",
-			"agent_create",
-		]);
-		expect(toolsForTier(all, "owner", tiers)).toEqual(all);
-	});
-
-	test("an operator's map lowers or raises a tool", () => {
-		const custom = toolTiers({ bash: "admin", agent_list: "owner" });
-		expect(toolsForTier(all, "member", custom)).toEqual([]);
-		expect(toolsForTier(all, "admin", custom)).toEqual([
-			"agent_create",
-			"bash",
-		]);
-	});
-
-	test("a plugin's declared tier is read at use time; the operator's still wins", () => {
-		const table = toolTiers({ plugin_b: "owner" });
-		expect(table.minTier("plugin_a")).toBe("owner");
-		table.declare("a", { plugin_a: "member" });
-		table.declare("b", { plugin_b: "member" });
-		expect(table.minTier("plugin_a")).toBe("member");
-		expect(table.minTier("plugin_b")).toBe("owner");
-	});
-
-	test("a tool two plugins declare names both plugins and the fix", () => {
-		const table = toolTiers();
-		table.declare("a", { shared_tool: "member" });
-		expect(() => table.declare("b", { shared_tool: "member" })).toThrow(
-			"plugin b: tool shared_tool is already defined by plugin a. Rename one of the two tools.",
-		);
-	});
-});
-
-describe("parseToolTiers", () => {
-	test("reads tool=tier pairs", () => {
-		expect(parseToolTiers("bash=admin, web_search=member", "X")).toEqual({
-			bash: "admin",
-			web_search: "member",
-		});
-		expect(parseToolTiers(undefined, "X")).toEqual({});
-	});
-
-	test("refuses a pair that is not a tier", () => {
-		expect(() => parseToolTiers("bash=root", "X")).toThrow(ConfigError);
-		expect(() => parseToolTiers("bash", "X")).toThrow(ConfigError);
-	});
-});

package/src/entries.test.ts

@@ -1,112 +0,0 @@
-import { expect, test } from "bun:test";
-import { existsSync, readFileSync } from "node:fs";
-import { resolve } from "node:path";
-import * as main from "./index.ts";
-import * as testing from "./testing.ts";
-
-// Types disappear at runtime. Update this list AND the changelog for every entry change.
-export const MAIN_EXPORTS = [
-	"NotLinkedError",
-	"PluginError",
-	"Roundtable",
-	"ToolRefusal",
-	"definePlugin",
-	"defineRoundtable",
-	"defineTool",
-];
-export const MAIN_TYPE_EXPORTS = [
-	"AgentSeed",
-	"ChannelClaim",
-	"Contribution",
-	"DefinedRoundtable",
-	"EventHandlers",
-	"HoldRule",
-	"InteractionContribution",
-	"Migration",
-	"PluginContext",
-	"PromptSection",
-	"PromptTurn",
-	"RoundtableConfig",
-	"RoundtableOptions",
-	"RoundtablePlugin",
-	"Service",
-	"SessionTool",
-	"Speaker",
-	"Tier",
-	"ToolContribution",
-	"ToolSpec",
-	"ToolTurn",
-	"TurnEndEvent",
-	"TurnEvent",
-];
-export const TESTING_EXPORTS = ["testPlugin"];
-export const TESTING_TYPE_EXPORTS = [
-	"RecordedEvent",
-	"TestPluginOptions",
-	"TestPluginResult",
-];
-
-/** Source-level names include type-only exports, which Object.keys cannot observe. */
-function entryNames(path: string): string[] {
-	const source = readFileSync(path, "utf8");
-	if (path.endsWith("index.ts"))
-		return [...source.matchAll(/export(?: type)?\s*\{([^}]+)\}/gs)]
-			.flatMap((match) =>
-				(match[1] ?? "")
-					.split(",")
-					.map((name) => name.trim())
-					.filter(Boolean),
-			)
-			.sort();
-	return [
-		...source.matchAll(
-			/export (?:async )?(?:interface|function|type|class|const) (\w+)/g,
-		),
-	]
-		.map((match) => match[1] ?? "")
-		.sort();
-}
-
-test("the public entries have exactly the snapshotted runtime exports", () => {
-	expect(Object.keys(main).sort()).toEqual(MAIN_EXPORTS);
-	expect(Object.keys(testing).sort()).toEqual(TESTING_EXPORTS);
-});
-
-test("type-only names are snapshotted and every public name is in the changelog", () => {
-	expect(entryNames(resolve(import.meta.dir, "index.ts"))).toEqual(
-		[...MAIN_EXPORTS, ...MAIN_TYPE_EXPORTS].sort(),
-	);
-	expect(entryNames(resolve(import.meta.dir, "testing.ts"))).toEqual(
-		[...TESTING_EXPORTS, ...TESTING_TYPE_EXPORTS].sort(),
-	);
-	const local = resolve(import.meta.dir, "../packaging/CHANGELOG.md");
-	const changelog = readFileSync(
-		existsSync(local) ? local : resolve(import.meta.dir, "../CHANGELOG.md"),
-		"utf8",
-	);
-	for (const name of [
-		...MAIN_EXPORTS,
-		...MAIN_TYPE_EXPORTS,
-		...TESTING_EXPORTS,
-		...TESTING_TYPE_EXPORTS,
-	])
-		expect(changelog).toContain(`\`${name}\``);
-});
-
-test("the package export map names exactly the existing entries", () => {
-	const template = resolve(import.meta.dir, "../packaging/package.json.tmpl");
-	const packageFile = existsSync(template)
-		? template
-		: resolve(import.meta.dir, "../package.json");
-	const manifest = JSON.parse(readFileSync(packageFile, "utf8")) as {
-		exports: Record<string, string>;
-	};
-	expect(manifest.exports).toEqual({
-		".": "./src/index.ts",
-		"./testing": "./src/testing.ts",
-	});
-	for (const target of Object.values(manifest.exports))
-		expect(
-			Bun.file(resolve(import.meta.dir, "..", target)).size,
-		).toBeGreaterThan(0);
-});