pi-roundtable 0.1.0 → 0.2.1

package/src/core/presentation/presentation.test.ts

@@ -1,166 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { CardCadence, CONVERSATION_GAP_MS } from "./card-cadence.ts";
-import { headline } from "./headline.ts";
-import { quietLinks } from "./quiet-links.ts";
-import { DISCORD_MESSAGE_LIMIT, splitReply } from "./reply-splitter.ts";
-import { THINKING_LIMIT, thinkingLine } from "./thinking-line.ts";
-
-describe("headline", () => {
-	test("takes the first sentence", () => {
-		expect(headline("Today is a nice day。Let us go for a walk！")).toBe(
-			"Today is a nice day。",
-		);
-		expect(headline("Bun 1.4.2 is out. It fixes a lot.")).toBe(
-			"Bun 1.4.2 is out.",
-		);
-	});
-
-	test("does not stop at a decimal point", () => {
-		expect(headline("Version 1.4.2 ships today")).toBe(
-			"Version 1.4.2 ships today",
-		);
-	});
-
-	test("strips markdown and skips code", () => {
-		expect(
-			headline(
-				"```ts\nconst x = 1;\n```\n## **Key point**：see [this post](https://x.y)",
-			),
-		).toBe("Key point：see this post");
-		expect(headline("- `bun` is fast")).toBe("bun is fast");
-	});
-
-	test("truncates to 80 characters", () => {
-		const result = headline("é".repeat(120));
-		expect(Array.from(result)).toHaveLength(80);
-		expect(result.endsWith("…")).toBe(true);
-	});
-
-	test("emoji are left out, since the card font cannot draw them", () => {
-		expect(headline("Schedule test OK，get some water 💧")).toBe(
-			"Schedule test OK，get some water",
-		);
-		expect(headline("🎉 Congrats 👍🏽 done 🇹🇼！")).toBe("Congrats done ！");
-		expect(headline("👨‍👩‍👧 family❤️ all good")).toBe("family all good");
-		expect(headline("💧")).toBe("");
-	});
-
-	test("empty text gives an empty headline", () => {
-		expect(headline("\n\n")).toBe("");
-	});
-});
-
-describe("splitReply", () => {
-	test("short text stays one message", () => {
-		expect(splitReply("hello\n\nworld")).toEqual(["hello\n\nworld"]);
-	});
-
-	test("splits on paragraph boundaries within the limit", () => {
-		const [a, b, c] = ["a".repeat(900), "b".repeat(900), "c".repeat(900)];
-		expect(splitReply(`${a}\n\n${b}\n\n${c}`)).toEqual([`${a}\n\n${b}`, c]);
-	});
-
-	test("keeps a code block with blank lines intact", () => {
-		const code = "```ts\nconst a = 1;\n\nconst b = 2;\n```";
-		const text = `${"x".repeat(1980)}\n\n${code}`;
-		expect(splitReply(text)).toEqual(["x".repeat(1980), code]);
-	});
-
-	test("a long code block becomes several complete code blocks", () => {
-		const body = Array.from(
-			{ length: 200 },
-			(_, i) => `line ${i} ${"-".repeat(20)}`,
-		).join("\n");
-		const chunks = splitReply(`\`\`\`ts\n${body}\n\`\`\``);
-		expect(chunks.length).toBeGreaterThan(1);
-		for (const chunk of chunks) {
-			expect(chunk.length).toBeLessThanOrEqual(2000);
-			expect(chunk.startsWith("```ts\n")).toBe(true);
-			expect(chunk.endsWith("\n```")).toBe(true);
-		}
-		const rejoined = chunks.map((c) => c.slice(6, -4)).join("\n");
-		expect(rejoined).toBe(body);
-	});
-
-	test("one overlong line is split by characters", () => {
-		const chunks = splitReply("é".repeat(4500));
-		expect(chunks.map((c) => c.length)).toEqual([2000, 2000, 500]);
-	});
-
-	test("every chunk respects the limit", () => {
-		const text = Array.from(
-			{ length: 50 },
-			(_, i) => `Paragraph ${i} ${"é".repeat(i * 10)}`,
-		).join("\n\n");
-		const chunks = splitReply(text);
-		expect(chunks.every((c) => c.length <= 2000)).toBe(true);
-		expect(chunks.join("\n\n")).toBe(text);
-	});
-});
-
-describe("quietLinks", () => {
-	test("wraps cited links and keeps sentence punctuation outside", () => {
-		expect(
-			quietLinks("Source：https://example.com/a?b=1。Also https://x.org/p."),
-		).toBe("Source：<https://example.com/a?b=1>。Also <https://x.org/p>.");
-	});
-
-	test("GIF and video links keep their preview", () => {
-		const text =
-			"https://giphy.com/gifs/clap\nhttps://www.youtube.com/watch?v=abc";
-		expect(quietLinks(text)).toBe(text);
-	});
-
-	test("markdown links and already wrapped links", () => {
-		expect(
-			quietLinks("[review](https://example.com/r) and <https://a.io>"),
-		).toBe("[review](<https://example.com/r>) and <https://a.io>");
-	});
-});
-
-describe("thinkingLine", () => {
-	test("each line becomes small grey text and blank lines are dropped", () => {
-		expect(thinkingLine("  check the date\n\nthen answer  ")).toBe(
-			"-# check the date\n-# then answer",
-		);
-		expect(thinkingLine("   ")).toBeUndefined();
-	});
-
-	test("long thinking is cut and stays within one message", () => {
-		const line = thinkingLine("é".repeat(THINKING_LIMIT + 50));
-		expect(line?.endsWith("…")).toBe(true);
-		expect(line?.length).toBeLessThanOrEqual(DISCORD_MESSAGE_LIMIT);
-	});
-});
-
-describe("card cadence", () => {
-	const at = (minutes: number) => minutes * 60_000;
-
-	test("a conversation's first reply shows a card; the same tone does not repeat it", () => {
-		const cadence = new CardCadence();
-		expect(cadence.shows("discord:1", "neutral", false, at(0))).toBe(true);
-		expect(cadence.shows("discord:1", "neutral", false, at(1))).toBe(false);
-		expect(cadence.shows("discord:1", "happy", false, at(2))).toBe(true);
-		expect(cadence.shows("discord:1", "happy", false, at(3))).toBe(false);
-		expect(cadence.shows("discord:1", "neutral", false, at(4))).toBe(false);
-		expect(cadence.shows("discord:1", "thinking", false, at(5))).toBe(true);
-	});
-
-	test("a quiet channel opens a new conversation", () => {
-		const cadence = new CardCadence();
-		cadence.shows("discord:1", "neutral", false, 0);
-		expect(
-			cadence.shows("discord:1", "neutral", false, CONVERSATION_GAP_MS - 1),
-		).toBe(false);
-		expect(
-			cadence.shows("discord:1", "neutral", false, 2 * CONVERSATION_GAP_MS - 1),
-		).toBe(true);
-	});
-
-	test("a failure always shows its card; channels are independent", () => {
-		const cadence = new CardCadence();
-		cadence.shows("discord:1", "apologetic", true, at(0));
-		expect(cadence.shows("discord:1", "apologetic", true, at(1))).toBe(true);
-		expect(cadence.shows("discord:2", "neutral", false, at(1))).toBe(true);
-	});
-});

package/src/core/public-entry.test.ts

@@ -1,59 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { readdirSync, readFileSync } from "node:fs";
-import { join, relative, resolve } from "node:path";
-
-const ROOT = resolve(import.meta.dir, "../..");
-const CORE = join(ROOT, "src/core");
-
-/** The core's modules, tests and test helpers aside. */
-function modules(dir: string): string[] {
-	return readdirSync(dir, { withFileTypes: true }).flatMap((entry) => {
-		const path = join(dir, entry.name);
-		if (entry.isDirectory())
-			return entry.name === "testing" ? [] : modules(path);
-		return entry.name.endsWith(".ts") && !entry.name.endsWith(".test.ts")
-			? [path]
-			: [];
-	});
-}
-
-/** The packages a module imports, by their bare names. */
-function packages(file: string): string[] {
-	const source = readFileSync(file, "utf8");
-	return [
-		...source.matchAll(/(?:from|import)\s*\(?\s*"([^."][^"]*)"/g),
-	].flatMap((match) => (match[1] ? [match[1]] : []));
-}
-
-/** Services only the first consumer's deployment runs; the core must work without them. */
-const PRIVATE = new RegExp(
-	// Spelled in pieces so this test does not itself name the private services.
-	["j" + "ev", "phoe" + "nix", "context" + "forge", "type" + "safe"].join("|"),
-	"i",
-);
-
-describe("the public core", () => {
-	test("imports no package of a private service", () => {
-		const found = modules(CORE).flatMap((file) =>
-			packages(file)
-				.filter((name) => PRIVATE.test(name))
-				.map((name) => `${relative(ROOT, file)} -> ${name}`),
-		);
-		expect(found).toEqual([]);
-	});
-
-	test("every module loads with no consumer configuration", () => {
-		const imports = modules(CORE)
-			.map((file) => `await import(${JSON.stringify(file)});`)
-			.join("\n");
-		const run = Bun.spawnSync({
-			cmd: [process.execPath, "-e", imports],
-			cwd: ROOT,
-			// Only what a process needs to start; none of a consumer's variables.
-			env: { PATH: process.env.PATH ?? "", HOME: process.env.HOME ?? "" },
-			stderr: "pipe",
-		});
-		expect(run.stderr.toString()).toBe("");
-		expect(run.exitCode).toBe(0);
-	});
-});

package/src/core/registry/contributions.test.ts

@@ -1,215 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { Type } from "typebox";
-import { defineTool } from "../define.ts";
-import { NotLinkedError, PluginError } from "../errors.ts";
-import { silentLogger } from "../log.ts";
-import type {
-	Contribution,
-	PluginContext,
-	RoundtablePlugin,
-} from "../plugin.ts";
-import { toolTiers } from "../tool-tiers.ts";
-import {
-	collectContributions,
-	linkSessions,
-	nearest,
-} from "./contributions.ts";
-
-/** A context the plugins under test never read. */
-const context = { logger: silentLogger() } as unknown as PluginContext;
-
-const plugin = (
-	name: string,
-	contribution: Contribution | (() => Contribution),
-): RoundtablePlugin => ({
-	name,
-	setup: () =>
-		typeof contribution === "function" ? contribution() : contribution,
-});
-
-const tool = (name: string, minTier: "member" | "admin" | "owner" = "member") =>
-	defineTool({
-		name,
-		description: "A tool.",
-		parameters: Type.Object({}),
-		minTier,
-		run: () => "ok",
-	});
-
-const collect = (plugins: RoundtablePlugin[], tiers = toolTiers()) =>
-	collectContributions(plugins, context, tiers);
-
-describe("collectContributions", () => {
-	test("names the part a typo meant, or lists the parts", async () => {
-		await expect(
-			collect([plugin("p", { serivces: [] } as unknown as Contribution)]),
-		).rejects.toThrow(
-			'plugin p: setup returned an unknown part "serivces". Did you mean "services"? The parts are services,',
-		);
-		await expect(
-			collect([plugin("p", { zzzzzz: [] } as unknown as Contribution)]),
-		).rejects.toThrow(
-			'plugin p: setup returned an unknown part "zzzzzz". The parts are services,',
-		);
-	});
-
-	test("refuses a plugin that adds nothing, and says what to give it", async () => {
-		await expect(collect([plugin("empty", {})])).rejects.toThrow(
-			"plugin empty adds nothing. Give it a part (tools, services, channels, and so on), a migration, or a provider, or remove it.",
-		);
-	});
-
-	test("a setup that throws or returns no object is named and keeps its cause", async () => {
-		const boom = new Error("boom");
-		const failing = collect([
-			plugin("p", () => {
-				throw boom;
-			}),
-		]);
-		await expect(failing).rejects.toThrow(
-			"plugin p: setup failed: boom. Fix the error, or remove the plugin.",
-		);
-		await expect(failing).rejects.toHaveProperty("cause", boom);
-		await expect(
-			collect([
-				plugin("early", () => {
-					throw new NotLinkedError("parts are linked later.");
-				}),
-			]),
-		).rejects.toThrow(
-			"plugin early: setup failed: parts are linked later. Fix the error, or remove the plugin.",
-		);
-		await expect(
-			collect([
-				{ name: "q", setup: () => undefined as unknown as Contribution },
-			]),
-		).rejects.toThrow(
-			"plugin q: setup must return an object of the parts it adds; return {} to add none.",
-		);
-	});
-
-	test("a service, a session tool, or a hold rule two plugins register names both plugins", async () => {
-		const service = { name: "sweeper" };
-		await expect(
-			collect([
-				plugin("a", { services: [service] }),
-				plugin("b", { services: [service] }),
-			]),
-		).rejects.toThrow(
-			"plugin b: service sweeper is already registered by plugin a. Rename one of the two.",
-		);
-		const rule = { name: "shell", describe: () => undefined };
-		await expect(
-			collect([
-				plugin("a", { holdRules: [rule] }),
-				plugin("b", { holdRules: [rule] }),
-			]),
-		).rejects.toThrow(
-			"plugin b: hold rule shell is already registered by plugin a. Rename one of the two.",
-		);
-	});
-
-	test("a tool two plugins define names both plugins", async () => {
-		await expect(
-			collect([
-				plugin("a", { tools: [tool("note_add")] }),
-				plugin("b", { tools: [tool("note_add")] }),
-			]),
-		).rejects.toThrow(
-			"plugin b: tool note_add is already defined by plugin a. Rename one of the two tools.",
-		);
-	});
-
-	test("a plugin's tools carry their tier, their hold rule, and their place among the agent's tools", async () => {
-		const tiers = toolTiers({ note_list: "admin" });
-		const held = defineTool({
-			name: "note_clear",
-			description: "Clear the notes.",
-			parameters: Type.Object({}),
-			minTier: "admin",
-			agent: false,
-			hold: () => "clear every note",
-			run: () => "cleared",
-		});
-		const registry = await collect(
-			[
-				plugin("notes", {
-					tools: [tool("note_add"), tool("note_list", "member"), held],
-				}),
-			],
-			tiers,
-		);
-		expect(tiers.minTier("note_add")).toBe("member");
-		// The operator's setting wins over the plugin's.
-		expect(tiers.minTier("note_list")).toBe("admin");
-		expect(tiers.minTier("note_clear")).toBe("admin");
-		const linked = linkSessions(registry);
-		expect(linked.agentTools).toEqual(["note_add", "note_list"]);
-		expect(linked.holds("note_clear", {}, {})).toBe("clear every note");
-		expect(linked.holds("note_add", {}, {})).toBeUndefined();
-	});
-
-	test("seeds and prompt sections are collected in contribution order", async () => {
-		const seed = (name: string) => ({
-			name,
-			displayName: name,
-			prompt: "p",
-			avatarPrompt: "a",
-		});
-		const section = (name: string) => ({ name, build: () => name });
-		const registry = await collect([
-			plugin("a", { seeds: [seed("one")], prompt: [section("x")] }),
-			plugin("b", { seeds: [seed("two")], prompt: [section("y")] }),
-		]);
-		const linked = linkSessions(registry);
-		expect(linked.seeds.map((s) => s.name)).toEqual(["one", "two"]);
-		expect(linked.prompt.map((s) => s.name)).toEqual(["x", "y"]);
-	});
-
-	test("every plugin's agent selection is merged when read, each name once", async () => {
-		let groups = ["mail"];
-		const registry = await collect([
-			plugin("a", {
-				agentSelection: () => ({ tools: ["web_search"], groups }),
-			}),
-			plugin("b", {
-				agentSelection: () => ({
-					tools: ["web_search", "notes"],
-					groups: ["mail", "calendar"],
-				}),
-			}),
-		]);
-		const linked = linkSessions(registry);
-		expect(linked.agentSelection()).toEqual({
-			tools: ["web_search", "notes"],
-			groups: ["mail", "calendar"],
-		});
-		// Read again at each turn, so a set that changes while the process runs stays current.
-		groups = ["docs"];
-		expect(linked.agentSelection().groups).toEqual([
-			"docs",
-			"mail",
-			"calendar",
-		]);
-		expect(
-			linkSessions(
-				await collect([plugin("c", { dashboard: ["a line"] })]),
-			).agentSelection(),
-		).toEqual({ tools: [], groups: [] });
-	});
-
-	test("every refusal is a PluginError", async () => {
-		await expect(collect([plugin("empty", {})])).rejects.toBeInstanceOf(
-			PluginError,
-		);
-	});
-});
-
-describe("nearest", () => {
-	test("finds a close word and nothing for a far one", () => {
-		const known = ["services", "events", "interactions"];
-		expect(nearest("serivces", known)).toBe("services");
-		expect(nearest("event", known)).toBe("events");
-		expect(nearest("banana", known)).toBeUndefined();
-	});
-});

package/src/core/registry/interactions.test.ts

@@ -1,87 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { InteractionContextType } from "discord.js";
-import type { InteractionModule, RootOption } from "../contract/discord.ts";
-import { PluginError } from "../errors.ts";
-import { composeInteractions } from "./interactions.ts";
-
-const ROOT = {
-	name: "roundtable",
-	description: "control",
-	contexts: [InteractionContextType.Guild, InteractionContextType.BotDM],
-};
-
-function module(...names: string[]): InteractionModule {
-	return {
-		commands: () =>
-			names.map((name) => ({ name, description: name, type: 1 as const })),
-		handle: async () => false,
-	};
-}
-
-const sub = (name: string): RootOption => ({
-	type: 1,
-	name,
-	description: name,
-});
-
-describe("composeInteractions", () => {
-	test("puts every contribution's subcommands under one root, after the modules' own commands", () => {
-		const a = module("roll");
-		const b = module();
-		const composed = composeInteractions(ROOT, [
-			{ module: b, rootOptions: [sub("help"), sub("status")] },
-			{ module: a },
-			{ module: module(), rootOptions: [sub("party")] },
-		]);
-		expect(composed.commands.map((c) => c.name)).toEqual([
-			"roll",
-			"roundtable",
-		]);
-		const root = composed.commands[1];
-		expect(root?.options?.map((o) => o.name)).toEqual([
-			"help",
-			"status",
-			"party",
-		]);
-		expect(root?.contexts).toEqual(ROOT.contexts);
-		expect(composed.modules[0]).toBe(b);
-		expect(composed.modules[1]).toBe(a);
-	});
-
-	test("registers no root without subcommands", () => {
-		const composed = composeInteractions(ROOT, [{ module: module("dice") }]);
-		expect(composed.commands.map((c) => c.name)).toEqual(["dice"]);
-	});
-
-	test("refuses a subcommand added twice, a command registered twice, and a module registering the root", () => {
-		const refused = (build: () => unknown) => {
-			try {
-				build();
-				return undefined;
-			} catch (error) {
-				return error;
-			}
-		};
-		expect(
-			refused(() =>
-				composeInteractions(ROOT, [
-					{ module: module(), rootOptions: [sub("mcp")] },
-					{ module: module(), rootOptions: [sub("mcp")] },
-				]),
-			),
-		).toBeInstanceOf(PluginError);
-		expect(
-			refused(() =>
-				composeInteractions(ROOT, [
-					{ module: module("roll") },
-					{ module: module("roll") },
-				]),
-			),
-		).toBeInstanceOf(PluginError);
-		expect(
-			refused(() =>
-				composeInteractions(ROOT, [{ module: module("roundtable") }]),
-			),
-		).toBeInstanceOf(PluginError);
-	});
-});

package/src/core/registry/providers.test.ts

@@ -1,103 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import type { Judge, Providers } from "../contract/providers.ts";
-import { PluginError, ProviderError } from "../errors.ts";
-import { Roundtable } from "../host.ts";
-import { ModelJudge } from "../judging/model-judge.ts";
-import { silentLogger } from "../log.ts";
-import type { RoundtablePlugin } from "../plugin.ts";
-import { resolveProviders } from "./providers.ts";
-
-/** What the promise rejected with; undefined when it resolved. */
-async function rejection(promise: Promise<unknown>): Promise<unknown> {
-	try {
-		await promise;
-	} catch (error) {
-		return error;
-	}
-	return undefined;
-}
-
-const fixedJudge: Judge = {
-	askYesNo: async () => ({ approves: 1 }),
-	askChoice: async () => ({ choice: "a", confidence: 1 }),
-	askScore: async () => [1],
-};
-
-const providing = (
-	name: string,
-	providers: Partial<Providers>,
-): RoundtablePlugin => ({ name, providers, setup: () => ({}) });
-
-describe("resolveProviders", () => {
-	test("without plugins, the judge asks the given model and images refuse", async () => {
-		const resolved = resolveProviders([], async () => '{"approves": 0.7}');
-		expect(resolved.judge).toBeInstanceOf(ModelJudge);
-		expect(
-			await resolved.judge.askYesNo(
-				{},
-				{
-					approves: { type: "yesno", instructions: "Approve?" },
-				},
-			),
-		).toEqual({ approves: 0.7 });
-		expect(await rejection(resolved.images("a cat", []))).toBeInstanceOf(
-			ProviderError,
-		);
-	});
-
-	test("without a judge model, every judgment refuses so callers keep their defaults", async () => {
-		const { judge } = resolveProviders([]);
-		expect(
-			await rejection(
-				judge.askScore({}, "effort", {
-					type: "score",
-					instructions: "",
-					criteria: [],
-				}),
-			),
-		).toBeInstanceOf(ProviderError);
-	});
-
-	test("a plugin's provider replaces the default for its slot only", () => {
-		const images = async () => new Uint8Array([1]);
-		const resolved = resolveProviders([
-			providing("acme-judge", { judge: fixedJudge }),
-			providing("codex", { images }),
-		]);
-		expect(resolved.judge).toBe(fixedJudge);
-		expect(resolved.images).toBe(images);
-	});
-
-	test("two plugins filling one slot clash", () => {
-		expect(() =>
-			resolveProviders([
-				providing("acme-judge", { judge: fixedJudge }),
-				providing("other", { judge: fixedJudge }),
-			]),
-		).toThrow(PluginError);
-	});
-});
-
-describe("Roundtable providers", () => {
-	test("a provider-only plugin is valid, and setups read the resolved providers", async () => {
-		let seen: Judge | undefined;
-		const roundtable = new Roundtable(
-			{
-				logger: silentLogger(),
-				exit: () => {},
-			},
-			[
-				providing("acme-judge", { judge: fixedJudge }),
-				{
-					name: "reader",
-					setup: ({ providers }) => {
-						seen = providers.judge;
-						return { events: {} };
-					},
-				},
-			],
-		);
-		await roundtable.run();
-		expect(seen).toBe(fixedJudge);
-	});
-});

package/src/core/routing/channel-queue.test.ts

@@ -1,31 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { ChannelQueue } from "./channel-queue.ts";
-
-describe("ChannelQueue", () => {
-	test("reports every change of a channel's count", async () => {
-		const queue = new ChannelQueue();
-		const seen: [string, number][] = [];
-		queue.onChange((channel) => seen.push([channel, queue.size(channel)]));
-		let release = () => {};
-		const first = queue.run(
-			"discord:1",
-			() => new Promise<void>((resolve) => (release = resolve)),
-		);
-		const second = queue.run("discord:1", async () => {});
-		expect(seen).toEqual([
-			["discord:1", 1],
-			["discord:1", 2],
-		]);
-		// The first task starts on a later tick.
-		await Bun.sleep(0);
-		release();
-		await Promise.all([first, second]);
-		await Bun.sleep(0);
-		expect(seen).toEqual([
-			["discord:1", 1],
-			["discord:1", 2],
-			["discord:1", 1],
-			["discord:1", 0],
-		]);
-	});
-});