pi-roundtable 0.1.0 → 0.2.0

package/src/core/i18n/i18n.test.ts

@@ -1,139 +0,0 @@
-import { afterEach, describe, expect, test } from "bun:test";
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
-import { Glob } from "bun";
-import { useTestLocale } from "../testing/locale.ts";
-import { createEn } from "./en.ts";
-import { LOCALES, type Messages, messages, setLocale } from "./index.ts";
-import { createZhTW } from "./zh-tw.ts";
-
-const CTX = { assistant: "Roundtable", root: "roundtable" };
-const CJK = /[\u3400-\u9fff\u3000-\u303f\uff00-\uffef]/;
-
-type Entry = string | ((...args: never[]) => unknown);
-
-/** Calls a message function with plain arguments of one shape; the first shape it accepts wins. */
-function render(entry: (...values: unknown[]) => unknown): string {
-	for (const arg of ["x", ["x"], 1, { x: "x" }]) {
-		try {
-			return JSON.stringify(
-				entry(...Array.from({ length: entry.length }, () => arg)),
-			);
-		} catch {
-			// Try the next shape.
-		}
-	}
-	throw new Error(`no plain arguments fit ${entry.toString().slice(0, 60)}`);
-}
-
-/** Every entry of a catalog as text: a string as it is, a function called with plain arguments. */
-function rendered(catalog: Messages): [string, string][] {
-	return Object.entries(catalog as Record<string, unknown>).map(
-		([key, entry]) => [
-			key,
-			typeof entry === "string"
-				? entry
-				: typeof entry === "function"
-					? render(entry as (...values: unknown[]) => unknown)
-					: JSON.stringify(entry),
-		],
-	);
-}
-
-const kind = (entry: unknown): string =>
-	typeof entry === "function" ? `function/${entry.length}` : typeof entry;
-
-afterEach(() => {
-	useTestLocale();
-});
-
-describe("catalogs", () => {
-	test("the English and Traditional Chinese catalogs have the same keys, and functions the same arity", () => {
-		const en = createEn(CTX) as Record<string, Entry>;
-		const zh = createZhTW(CTX) as Record<string, Entry>;
-		expect(Object.keys(zh).sort()).toEqual(Object.keys(en).sort());
-		const shapes = (catalog: Record<string, Entry>) =>
-			Object.fromEntries(
-				Object.entries(catalog).map(([key, entry]) => [key, kind(entry)]),
-			);
-		expect(shapes(zh)).toEqual(shapes(en));
-	});
-
-	test("the English catalog has no Chinese text or fullwidth punctuation", () => {
-		const offenders = rendered(createEn(CTX))
-			.filter(([, text]) => CJK.test(text))
-			.map(([key]) => key);
-		expect(offenders).toEqual([]);
-	});
-
-	test("the Traditional Chinese catalog is not the English one", () => {
-		const en = new Map(rendered(createEn(CTX)));
-		const same = rendered(createZhTW(CTX)).filter(
-			([key, text]) => en.get(key) === text,
-		);
-		// A few entries are the same in both languages, such as a bare command name.
-		expect(same.length).toBeLessThan(en.size / 5);
-	});
-});
-
-describe("setLocale", () => {
-	test("names the assistant and the root command in the text", () => {
-		setLocale("en", { assistant: "Robin", root: "robin" });
-		const text = JSON.stringify(rendered(messages()));
-		expect(text).toContain("Robin");
-		expect(text).toContain("/robin");
-		expect(text).not.toContain("Roundtable");
-	});
-
-	test("shows English by default-style settings and Chinese for zh-TW", () => {
-		setLocale("en", CTX);
-		expect(messages().stopLabel).toBe("Stop");
-		setLocale("zh-TW", CTX);
-		expect(messages().stopLabel).toBe("停止");
-	});
-
-	test("an override replaces one message and leaves the others", () => {
-		setLocale("en", { ...CTX, overrides: { stopLabel: "Halt" } });
-		expect(messages().stopLabel).toBe("Halt");
-		expect(messages().ownerFailedTitle).toBe("Could not complete");
-	});
-
-	test("an unknown locale is refused", () => {
-		expect(() => setLocale("fr" as never, CTX)).toThrow("Unknown locale: fr");
-		expect(LOCALES).toEqual(["en", "zh-TW"]);
-	});
-});
-
-describe("what the core shows", () => {
-	const files = (root: string, pattern: string) =>
-		[...new Glob(pattern).scanSync({ cwd: root })].map((f) => join(root, f));
-
-	test("no Chinese text outside the catalogs and the tests", () => {
-		const offenders = files("src/core", "**/*.ts")
-			.filter((f) => !f.includes("/i18n/") && !/\.test\.ts$/.test(f))
-			.flatMap((f) =>
-				readFileSync(f, "utf8")
-					.split("\n")
-					.map((line, index) => ({ f, line, index }))
-					// Regexes may match fullwidth punctuation; only ideographs are text.
-					.filter(({ line }) => /[\u3400-\u9fff]/.test(line))
-					.map(({ f: file, index }) => `${file}:${index + 1}`),
-			);
-		expect(offenders).toEqual([]);
-	});
-
-	test("no source in the core names its first consumer", () => {
-		// Spelled in pieces so this test does not itself name the consumer.
-		const consumer = new RegExp(["mer", "lin"].join(""), "i");
-		const offenders = files("src/core", "**/*.ts")
-			.filter((f) => !/\.test\.ts$/.test(f) && !f.includes("/testing/"))
-			.flatMap((f) =>
-				readFileSync(f, "utf8")
-					.split("\n")
-					.map((line, index) => ({ f, line, index }))
-					.filter(({ line }) => consumer.test(line))
-					.map(({ f: file, index }) => `${file}:${index + 1}`),
-			);
-		expect(offenders).toEqual([]);
-	});
-});

package/src/core/identity.test.ts

@@ -1,18 +0,0 @@
-import { expect, test } from "bun:test";
-import { ownerWords } from "./identity.ts";
-
-test("owner words capitalize the subject and possessive for a sentence's start", () => {
-	expect(
-		ownerWords({
-			name: "Alice",
-			pronouns: { subject: "she", object: "her", possessive: "her" },
-		}),
-	).toEqual({
-		name: "Alice",
-		he: "she",
-		He: "She",
-		him: "her",
-		his: "her",
-		His: "Her",
-	});
-});

package/src/core/judging/effort-judge.test.ts

@@ -1,112 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import type { Judge, ScoreQuestion } from "../contract/providers.ts";
-import { JudgeError } from "../errors.ts";
-import { silentLogger } from "../log.ts";
-import {
-	AGENT_BRIEF,
-	EffortJudge,
-	levelIndex,
-	moveIndex,
-} from "./effort-judge.ts";
-
-class FakeJudge implements Judge {
-	constructor(private readonly scores: number[] | Error) {}
-	async askYesNo(): Promise<Record<string, number>> {
-		throw new Error("not used here");
-	}
-	async askChoice(): Promise<never> {
-		throw new Error("not used here");
-	}
-	scored: { state: Record<string, unknown>; criteria: readonly string[] }[] =
-		[];
-	async askScore(
-		state: Record<string, unknown>,
-		_name: string,
-		question: ScoreQuestion,
-	): Promise<number[]> {
-		this.scored.push({ state, criteria: question.criteria });
-		if (this.scores instanceof Error) throw this.scores;
-		return this.scores;
-	}
-}
-
-describe("EffortJudge", () => {
-	type Level = "low" | "medium" | "high" | "xhigh";
-	const judge = (
-		scores: number[] | Error,
-		previous: { reply?: string; level?: Level } = {},
-		fallback: Level = "low",
-	) => {
-		const fakeJudge = new FakeJudge(scores);
-		const level = new EffortJudge({
-			judge: fakeJudge,
-			brief: AGENT_BRIEF,
-			fallback,
-			threshold: 0.6,
-			logger: silentLogger(),
-		}).judge("sounds good, go ahead", previous);
-		return { level, fakeJudge };
-	};
-
-	test("a first turn takes the median of the judge's distribution up to high", async () => {
-		expect(await judge([0.9, 0.1, 0, 0]).level).toBe("low");
-		expect(await judge([0.2, 0.6, 0.2, 0]).level).toBe("medium");
-		expect(await judge([0, 0.1, 0.9, 0]).level).toBe("high");
-	});
-
-	test("xhigh takes a near-certain answer, otherwise it stays high", async () => {
-		expect(await judge([0, 0, 0.1, 0.9]).level).toBe("xhigh");
-		expect(await judge([0, 0, 0.3, 0.7]).level).toBe("high");
-		expect(await judge([0, 0, 0.3, 0.7], { level: "high" }).level).toBe("high");
-	});
-
-	test("a split first answer lands where the mass is, not in the middle", () => {
-		expect(levelIndex([0.6, 0, 0.4, 0])).toBe(0);
-		expect(levelIndex([0.4, 0, 0.6, 0])).toBe(2);
-	});
-
-	test("an unsure answer keeps the previous turn's level", async () => {
-		expect(await judge([0.4, 0.15, 0.45, 0], { level: "high" }).level).toBe(
-			"high",
-		);
-		expect(await judge([0.45, 0.1, 0.45, 0], { level: "low" }).level).toBe(
-			"low",
-		);
-	});
-
-	test("a confident answer moves off the previous level either way", async () => {
-		expect(await judge([0, 0.3, 0.7, 0], { level: "low" }).level).toBe("high");
-		expect(await judge([0.55, 0.45, 0, 0], { level: "high" }).level).toBe(
-			"medium",
-		);
-		expect(await judge([0.9, 0.1, 0, 0], { level: "high" }).level).toBe("low");
-	});
-
-	test("moveIndex checks upgrades before downgrades", () => {
-		expect(moveIndex(1, [0.5, 0, 0.5, 0], 0.5)).toBe(2);
-	});
-
-	test("a judge failure keeps the previous level, or runs at the fallback", async () => {
-		expect(await judge(new JudgeError("down")).level).toBe("low");
-		expect(await judge(new JudgeError("down"), {}, "medium").level).toBe(
-			"medium",
-		);
-		expect(
-			await judge(new JudgeError("down"), { level: "high" }, "medium").level,
-		).toBe("high");
-	});
-
-	test("the judge reads the previous reply with the message and the brief's rubric", async () => {
-		const { level, fakeJudge } = judge([1, 0, 0, 0], {
-			reply: "Plan: move the database first, then switch DNS.",
-		});
-		await level;
-		expect(fakeJudge.scored[0]).toEqual({
-			state: {
-				message: "sounds good, go ahead",
-				previous_reply: "Plan: move the database first, then switch DNS.",
-			},
-			criteria: AGENT_BRIEF.criteria,
-		});
-	});
-});

package/src/core/judging/model-judge.test.ts

@@ -1,126 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { JudgeError } from "../errors.ts";
-import { type JudgeModel, ModelJudge } from "./model-judge.ts";
-
-/** A model that answers each prompt with the next scripted text and records the prompts. */
-function scripted(...answers: string[]): {
-	model: JudgeModel;
-	prompts: string[];
-} {
-	const prompts: string[] = [];
-	return {
-		prompts,
-		model: async (_system, prompt) => {
-			prompts.push(prompt);
-			const answer = answers.shift();
-			if (answer === undefined) throw new Error("no scripted answer left");
-			return answer;
-		},
-	};
-}
-
-/** 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 approval = {
-	approves: {
-		type: "yesno" as const,
-		instructions: "Does the reply approve the held actions?",
-		criteria: { true: "the owner agrees", false: "the owner declines" },
-	},
-};
-
-describe("ModelJudge", () => {
-	test("a yes-or-no answer gives each question's probability, and the prompt carries the state", async () => {
-		const { model, prompts } = scripted('{"approves": 0.92}');
-		const judge = new ModelJudge(model);
-		expect(
-			await judge.askYesNo({ reply: "sounds good, send it" }, approval),
-		).toEqual({
-			approves: 0.92,
-		});
-		expect(prompts[0]).toContain('"reply": "sounds good, send it"');
-		expect(prompts[0]).toContain("Yes means: the owner agrees.");
-		// A bare "how sure are you" made a model rate its own certainty, so a clear no scored 0.99.
-		expect(prompts[0]).toContain("probability that the answer is yes");
-	});
-
-	test("a code fence or words around the object are tolerated", async () => {
-		const { model } = scripted('Sure:\n```json\n{"approves": 0.1}\n```');
-		expect(await new ModelJudge(model).askYesNo({}, approval)).toEqual({
-			approves: 0.1,
-		});
-	});
-
-	test("a missing or out-of-range probability throws", async () => {
-		const { model } = scripted('{"other": 1}', '{"approves": 1.5}', "no JSON");
-		const judge = new ModelJudge(model);
-		for (let i = 0; i < 3; i++)
-			expect(await rejection(judge.askYesNo({}, approval))).toBeInstanceOf(
-				JudgeError,
-			);
-	});
-
-	test("a choice must name a listed option with a confidence", async () => {
-		const question = {
-			type: "choice" as const,
-			instructions: "Which expression fits the reply?",
-			criteria: { happy: "cheerful", neutral: "plain" },
-		};
-		const { model } = scripted(
-			'{"choice": "happy", "confidence": 0.8}',
-			'{"choice": "angry", "confidence": 0.8}',
-			'{"choice": "neutral"}',
-		);
-		const judge = new ModelJudge(model);
-		expect(await judge.askChoice({}, "expression", question)).toEqual({
-			choice: "happy",
-			confidence: 0.8,
-		});
-		expect(
-			await rejection(judge.askChoice({}, "expression", question)),
-		).toBeInstanceOf(JudgeError);
-		expect(
-			await rejection(judge.askChoice({}, "expression", question)),
-		).toBeInstanceOf(JudgeError);
-	});
-
-	test("a score gives one probability per level, normalized to sum to one", async () => {
-		const question = {
-			type: "score" as const,
-			instructions: "How much thinking does the turn need?",
-			criteria: ["low", "medium", "high"],
-		};
-		const { model } = scripted(
-			'{"probabilities": [0.2, 0.2, 0.4]}',
-			'{"probabilities": [0.5, 0.5]}',
-			'{"probabilities": [0, 0, 0]}',
-		);
-		const judge = new ModelJudge(model);
-		expect(await judge.askScore({}, "effort", question)).toEqual([
-			0.25, 0.25, 0.5,
-		]);
-		expect(
-			await rejection(judge.askScore({}, "effort", question)),
-		).toBeInstanceOf(JudgeError);
-		expect(
-			await rejection(judge.askScore({}, "effort", question)),
-		).toBeInstanceOf(JudgeError);
-	});
-
-	test("a failing model's error reaches the caller", async () => {
-		const judge = new ModelJudge(async () => {
-			throw new Error("offline");
-		});
-		expect(String(await rejection(judge.askYesNo({}, approval)))).toContain(
-			"offline",
-		);
-	});
-});

package/src/core/modules/delegation/delegator.test.ts

@@ -1,170 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import type { ChannelKey } from "../../domain/conversation.ts";
-import { messages } from "../../i18n/index.ts";
-import { silentLogger } from "../../log.ts";
-import { fakeThreads } from "../../testing/thread-host.ts";
-import {
-	type DelegationJob,
-	type DelegationOutcome,
-	Delegator,
-	delegatedTurnText,
-} from "./delegator.ts";
-
-const OWNER = { id: "1", name: "Riley" };
-
-function setup(
-	run: (task: string, signal: AbortSignal) => Promise<string>,
-	timeoutMs?: number,
-) {
-	const reports: [DelegationJob, DelegationOutcome][] = [];
-	const { host, threads } = fakeThreads();
-	/** Threads already archived when each report was delivered. */
-	const archived: string[][] = [];
-	const delegator = new Delegator({
-		worker: { run },
-		deliver: async (job, outcome) => {
-			archived.push([...host.closed]);
-			reports.push([job, outcome]);
-		},
-		threads,
-		logger: silentLogger(),
-		...(timeoutMs ? { timeoutMs } : {}),
-	});
-	return { delegator, reports, host, archived };
-}
-
-const request = (channel: ChannelKey = "discord:1") => ({
-	channel,
-	mode: "party" as const,
-	author: OWNER,
-	title: "t",
-	task: "find it",
-});
-
-describe("Delegator", () => {
-	test("a report comes back with its job, after start has returned", async () => {
-		const { delegator, reports } = setup(async (task) => `report for ${task}`);
-		const job = delegator.start(request());
-		expect(reports).toEqual([]);
-		await delegator.idle();
-		expect(reports).toEqual([
-			[job, { ok: true, report: "report for find it" }],
-		]);
-	});
-
-	test("a channel holds only so many running jobs; other channels are not affected", async () => {
-		let release = () => {};
-		const gate = new Promise<void>((resolve) => {
-			release = resolve;
-		});
-		const { delegator } = setup(async () => {
-			await gate;
-			return "done";
-		});
-		delegator.start(request());
-		delegator.start(request());
-		expect(() => delegator.start(request())).toThrow("already has 2");
-		expect(delegator.start(request("discord:2")).id).toBe(3);
-		release();
-		await delegator.idle();
-		expect(delegator.start(request()).id).toBe(4);
-		await delegator.idle();
-	});
-
-	test("a failing or slow worker reports the failure", async () => {
-		const { delegator, reports } = setup(
-			(_task, signal) =>
-				new Promise((_resolve, reject) =>
-					signal.addEventListener("abort", () =>
-						reject(new Error("timed out")),
-					),
-				),
-			10,
-		);
-		delegator.start(request());
-		await delegator.idle();
-		expect(reports[0]?.[1]).toEqual({ ok: false, error: "timed out" });
-	});
-
-	test("an owner job runs in a thread of its origin, archived with the report before the turn", async () => {
-		const { delegator, reports, host, archived } = setup(async () => "R");
-		delegator.start({
-			...request("discord:dm"),
-			mode: "owner",
-			origin: "discord:10",
-			title: "check the Bun version",
-		});
-		await delegator.idle();
-		expect(host.opened).toEqual([
-			{ parentId: "10", name: "check the Bun version", id: "900" },
-		]);
-		expect(host.lines.get("10")).toBe(
-			messages().threadStarted("check the Bun version", "<#900>"),
-		);
-		expect(host.textsIn("900")).toEqual([
-			messages().delegationTask("find it"),
-			messages().delegationDone("R"),
-		]);
-		expect(archived).toEqual([["900"]]);
-		const [job, outcome] = reports[0] ?? [];
-		expect(job?.channel).toBe("discord:dm");
-		expect(
-			delegatedTurnText(
-				job as DelegationJob,
-				outcome as DelegationOutcome,
-				"x",
-			),
-		).toContain("in the thread <#900>");
-	});
-
-	test("a failed or timed-out job's thread gets the failure and is archived", async () => {
-		const { delegator, host } = setup(
-			(_task, signal) =>
-				new Promise((_resolve, reject) =>
-					signal.addEventListener("abort", () =>
-						reject(new Error("timed out")),
-					),
-				),
-			10,
-		);
-		delegator.start({ ...request(), origin: "discord:10" });
-		await delegator.idle();
-		expect(host.textsIn("900").at(-1)).toBe(
-			messages().delegationFailed("timed out"),
-		);
-		expect(host.closed).toEqual(["900"]);
-	});
-
-	test("a party job, or one whose thread cannot open, reports only in its channel", async () => {
-		const { delegator, reports, host } = setup(async () => "R");
-		delegator.start(request());
-		host.failOpen = true;
-		delegator.start({ ...request("discord:2"), origin: "discord:2" });
-		await delegator.idle();
-		expect(host.posts).toEqual([]);
-		expect(reports.map(([job]) => job.thread)).toEqual([undefined, undefined]);
-		expect(reports.map(([, outcome]) => outcome.ok)).toEqual([true, true]);
-	});
-
-	test("an empty task is refused", () => {
-		const { delegator } = setup(async () => "x");
-		expect(() => delegator.start({ ...request(), task: " " })).toThrow(
-			"required",
-		);
-	});
-
-	test("the report turn carries the task and the report", () => {
-		const job: DelegationJob = { ...request(), id: 5, startedAt: new Date(0) };
-		const text = delegatedTurnText(
-			job,
-			{ ok: true, report: "R" },
-			"2026-09-27 01:00",
-		);
-		expect(text).toContain("## Delegated task #5: t");
-		expect(text).toContain("### Task\nfind it");
-		expect(text).toContain("### Report\nR");
-		expect(delegatedTurnText(job, { ok: false, error: "boom" }, "x")).toContain(
-			"failed: boom",
-		);
-	});
-});