pi-roundtable 0.1.0 → 0.2.0

package/src/core/modules/memory/owner-memory-store.test.ts

@@ -1,244 +0,0 @@
-import {
-	afterAll,
-	beforeAll,
-	beforeEach,
-	describe,
-	expect,
-	test,
-} from "bun:test";
-import { SQL } from "bun";
-import { MemoryError } from "../../domain/errors.ts";
-import {
-	describeDb,
-	TEST_GUILD as OWNER_ID,
-	openTestStore,
-	type TestStore,
-	testDatabaseUrl,
-} from "../../testing/database.ts";
-import { useTestLocale } from "../../testing/locale.ts";
-import { setTimeZone, zonedDate } from "../../time.ts";
-import { OwnerMemoryStore, searchTerms } from "./owner-memory-store.ts";
-
-// Runs against a real PostgreSQL, only when ROUNDTABLE_TEST_DATABASE_URL is set.
-describeDb("PostgreSQL", () => {
-	let store: TestStore<OwnerMemoryStore>;
-
-	const facts = async () => (await store.list()).map((memory) => memory.fact);
-
-	beforeAll(async () => {
-		const admin = new SQL(testDatabaseUrl);
-		await admin`DROP TABLE IF EXISTS owner_memory`;
-		// The milestone 1 table, so opening it exercises the upgrade.
-		await admin`
-		CREATE TABLE owner_memory (
-			id bigserial PRIMARY KEY,
-			fact text NOT NULL CHECK (length(btrim(fact)) > 0),
-			created_at timestamptz NOT NULL DEFAULT now()
-		)`;
-		await admin`INSERT INTO owner_memory (fact) VALUES ('old fact')`;
-		await admin.close();
-		store = await openTestStore(OwnerMemoryStore, OWNER_ID);
-	});
-
-	afterAll(async () => {
-		await store.close();
-	});
-
-	describe("OwnerMemoryStore", () => {
-		test("a milestone 1 row becomes a core fact", async () => {
-			expect(await store.list()).toMatchObject([
-				{ kind: "core", fact: "old fact", eventDate: null },
-			]);
-		});
-
-		describe("after the upgrade", () => {
-			beforeEach(async () => {
-				for (const fact of await facts()) await store.remove(fact);
-			});
-
-			test("each speaker has a memory of their own, which no other reads or changes", async () => {
-				const other = store.forSpeaker("900000000000000077");
-				await store.add("lives in Taipei");
-				await other.add("lives in Kaohsiung");
-				await other.add("loves coffee", "note");
-				expect((await store.list()).map((m) => m.fact)).toEqual([
-					"lives in Taipei",
-				]);
-				expect((await other.list()).map((m) => m.fact)).toEqual([
-					"lives in Kaohsiung",
-					"loves coffee",
-				]);
-				expect((await store.search("coffee")).map((m) => m.fact)).toEqual([]);
-				expect((await store.forPrompt("2026-09-30")).core).toHaveLength(1);
-				const theirs = (await other.list())[0];
-				expect(await store.removeById(theirs?.id ?? 0)).toBe(false);
-				expect(
-					await store.update(theirs?.id ?? 0, { fact: "x", kind: "core" }),
-				).toBeUndefined();
-				expect(await store.remove("lives in")).toEqual(["lives in Taipei"]);
-				expect((await other.list()).map((m) => m.fact)).toEqual([
-					"lives in Kaohsiung",
-					"loves coffee",
-				]);
-				for (const fact of await other.list()) await other.removeById(fact.id);
-			});
-
-			test("adds facts of each kind in order and trims them", async () => {
-				await store.add("  no coffee ");
-				await store.add("writing a dungeon adventure", "note");
-				await store.add("going to a whisky fair", "event", "2026-10-03");
-				expect(await store.list()).toMatchObject([
-					{ kind: "core", fact: "no coffee", eventDate: null },
-					{
-						kind: "note",
-						fact: "writing a dungeon adventure",
-						eventDate: null,
-					},
-					{
-						kind: "event",
-						fact: "going to a whisky fair",
-						eventDate: "2026-10-03",
-					},
-				]);
-			});
-
-			test("an event needs a date, and only an event has one", async () => {
-				expect(store.add("a meeting", "event")).rejects.toBeInstanceOf(
-					MemoryError,
-				);
-				expect(store.add("a meeting", "event", "10/3")).rejects.toBeInstanceOf(
-					MemoryError,
-				);
-				expect(
-					store.add("no coffee", "core", "2026-10-03"),
-				).rejects.toBeInstanceOf(MemoryError);
-			});
-
-			test("the prompt carries core facts and events not yet passed, never notes", async () => {
-				await store.add("no coffee");
-				await store.add("writing a dungeon adventure", "note");
-				await store.add("last week's game", "event", "2026-09-20");
-				await store.add("today's game", "event", "2026-09-26");
-				await store.add("next week's game", "event", "2026-10-03");
-				const prompt = await store.forPrompt("2026-09-26");
-				expect(prompt.core.map((m) => m.fact)).toEqual(["no coffee"]);
-				expect(prompt.events.map((m) => m.fact)).toEqual([
-					"today's game",
-					"next week's game",
-				]);
-			});
-
-			test("search finds every kind, most matched terms first", async () => {
-				await store.add("Obsidian knowledge base uses MOC notes", "note");
-				await store.add("Obsidian path is ~/obsidian", "note");
-				await store.add("last week's game", "event", "2026-09-20");
-				await store.add("no coffee");
-				const found = await store.search("obsidian MOC");
-				expect(found.map((m) => m.fact)).toEqual([
-					"Obsidian knowledge base uses MOC notes",
-					"Obsidian path is ~/obsidian",
-				]);
-				expect((await store.search("game")).map((m) => m.kind)).toEqual([
-					"event",
-				]);
-				expect(await store.search("tea")).toEqual([]);
-				expect(store.search("   ")).rejects.toBeInstanceOf(MemoryError);
-			});
-
-			test("search treats terms literally, not as patterns", async () => {
-				await store.add("100% sure");
-				await store.add("1000 sure");
-				expect((await store.search("0%")).map((m) => m.fact)).toEqual([
-					"100% sure",
-				]);
-			});
-
-			test("facts survive a new connection", async () => {
-				await store.add("lives in Taipei");
-				const other = await openTestStore(OwnerMemoryStore, OWNER_ID);
-				expect((await other.list()).map((m) => m.fact)).toEqual([
-					"lives in Taipei",
-				]);
-				await other.close();
-			});
-
-			test("remove deletes every fact containing the text, case-insensitively", async () => {
-				await store.add("Prefers Bun over Node");
-				await store.add("bun lover", "note");
-				await store.add("no coffee");
-				expect(await store.remove("BUN")).toEqual([
-					"Prefers Bun over Node",
-					"bun lover",
-				]);
-				expect(await facts()).toEqual(["no coffee"]);
-				expect(await store.remove("tea")).toEqual([]);
-			});
-
-			test("update replaces one memory's text, kind, and date under the same rules", async () => {
-				const note = await store.add("writing a dungeon adventure", "note");
-				const other = await store.add("no coffee");
-				expect(
-					await store.update(note.id, {
-						fact: " dungeon session ",
-						kind: "event",
-						eventDate: "2026-10-03",
-					}),
-				).toEqual({
-					id: note.id,
-					kind: "event",
-					fact: "dungeon session",
-					eventDate: "2026-10-03",
-				});
-				expect(
-					await store.update(note.id, {
-						fact: "dungeon session",
-						kind: "note",
-					}),
-				).toMatchObject({ kind: "note", eventDate: null });
-				expect(
-					store.update(note.id, { fact: "a meeting", kind: "event" }),
-				).rejects.toBeInstanceOf(MemoryError);
-				expect(
-					store.update(note.id, { fact: " ", kind: "note" }),
-				).rejects.toBeInstanceOf(MemoryError);
-				expect(
-					await store.update(other.id + 1000, { fact: "x", kind: "core" }),
-				).toBeUndefined();
-				expect(await facts()).toEqual(["dungeon session", "no coffee"]);
-			});
-
-			test("removeById deletes exactly one memory", async () => {
-				const first = await store.add("Prefers Bun");
-				await store.add("Prefers Bun too");
-				expect(await store.removeById(first.id)).toBe(true);
-				expect(await store.removeById(first.id)).toBe(false);
-				expect(await facts()).toEqual(["Prefers Bun too"]);
-			});
-
-			test("empty input is rejected", async () => {
-				expect(store.add("   ")).rejects.toBeInstanceOf(MemoryError);
-				expect(store.remove("")).rejects.toBeInstanceOf(MemoryError);
-			});
-		});
-	});
-});
-
-describe("helpers", () => {
-	test("search terms split on whitespace, lowercased and deduplicated", () => {
-		expect(searchTerms("  Obsidian  MOC obsidian\nknowledge ")).toEqual([
-			"obsidian",
-			"moc",
-			"knowledge",
-		]);
-	});
-
-	test("today is the date in the configured zone", () => {
-		setTimeZone("Asia/Taipei");
-		try {
-			expect(zonedDate(new Date("2026-09-26T16:30:00Z"))).toBe("2026-09-27");
-			expect(zonedDate(new Date("2026-09-26T15:30:00Z"))).toBe("2026-09-26");
-		} finally {
-			useTestLocale();
-		}
-	});
-});

package/src/core/modules/schedules/schedule.test.ts

@@ -1,358 +0,0 @@
-import {
-	afterAll,
-	beforeAll,
-	beforeEach,
-	describe,
-	expect,
-	test,
-} from "bun:test";
-import { SQL } from "bun";
-import { ScheduleError } from "../../domain/errors.ts";
-import { messages } from "../../i18n/index.ts";
-import { silentLogger } from "../../log.ts";
-import {
-	describeDb,
-	openTestStore,
-	type TestStore,
-	testDatabaseUrl,
-} from "../../testing/database.ts";
-import { useTestLocale } from "../../testing/locale.ts";
-import { setTimeZone, zonedStamp } from "../../time.ts";
-import { describeRecurrence, nextRun, parseRecurrence } from "./recurrence.ts";
-import { type Schedule, ScheduleStore } from "./schedule-store.ts";
-import {
-	callScheduleTool,
-	SCHEDULE_LIMITS,
-	type ScheduleToolContext,
-	scheduledTurnText,
-} from "./schedule-tools.ts";
-import { type ScheduledOutcome, Scheduler } from "./scheduler.ts";
-
-const taipei = (stamp: string) =>
-	new Date(`${stamp.replace(" ", "T")}:00+08:00`);
-
-// The schedules below are written in Taipei time; the suite's other files keep the neutral zone.
-beforeAll(() => setTimeZone("Asia/Taipei"));
-afterAll(useTestLocale);
-
-describe("recurrence", () => {
-	const now = taipei("2026-09-26 23:30");
-
-	test("a one-time run is the given Taipei time, and none once it has passed", () => {
-		const once = parseRecurrence({ at: "2026-09-27 09:00" }, now);
-		expect(nextRun(once, now)).toEqual(taipei("2026-09-27 09:00"));
-		expect(nextRun(once, taipei("2026-09-27 09:00"))).toBeUndefined();
-	});
-
-	test("in_minutes is one run that many minutes ahead, rounded up to the minute", () => {
-		const at = new Date(taipei("2026-09-26 23:58").getTime() + 30_000);
-		const relative = parseRecurrence({ in_minutes: 2 }, at);
-		expect(relative).toEqual({
-			kind: "once",
-			date: "2026-09-27",
-			time: "00:01",
-		});
-		expect(() =>
-			parseRecurrence({ in_minutes: 2, at: "2026-09-27 09:00" }, at),
-		).toThrow(ScheduleError);
-		expect(() => parseRecurrence({ in_minutes: 0 }, at)).toThrow(ScheduleError);
-	});
-
-	test("every n days counts from the start date and never returns the current instant", () => {
-		const every = parseRecurrence(
-			{ time: "09:00", every_days: 3, start_date: "2026-09-16" },
-			now,
-		);
-		expect(nextRun(every, now)).toEqual(taipei("2026-09-28 09:00"));
-		expect(nextRun(every, taipei("2026-09-28 09:00"))).toEqual(
-			taipei("2026-10-01 09:00"),
-		);
-		expect(describeRecurrence(every)).toBe(
-			messages().scheduleEveryDays(3, "09:00", "2026-09-16"),
-		);
-	});
-
-	test("daily defaults to starting today, so a time still ahead runs today", () => {
-		const daily = parseRecurrence({ time: "23:45" }, now);
-		expect(nextRun(daily, now)).toEqual(taipei("2026-09-26 23:45"));
-		expect(describeRecurrence(daily)).toBe(messages().scheduleDaily("23:45"));
-	});
-
-	test("weekly runs on the listed weekdays", () => {
-		// 2026-09-26 is a Saturday.
-		const weekly = parseRecurrence(
-			{ time: "08:00", weekdays: ["wed", "mon"] },
-			now,
-		);
-		expect(nextRun(weekly, now)).toEqual(taipei("2026-09-28 08:00"));
-		expect(nextRun(weekly, taipei("2026-09-28 08:00"))).toEqual(
-			taipei("2026-09-30 08:00"),
-		);
-		expect(describeRecurrence(weekly)).toBe(
-			messages().scheduleWeekly(
-				[messages().scheduleWeekday("mon"), messages().scheduleWeekday("wed")],
-				"08:00",
-			),
-		);
-	});
-
-	test("bad timing is refused with a message the model can act on", () => {
-		const cases = [
-			{},
-			{ at: "2026-02-30 09:00" },
-			{ at: "tomorrow" },
-			{ at: "2026-09-27 09:00", time: "09:00" },
-			{ time: "25:00" },
-			{ time: "09:00", every_days: 0 },
-			{ time: "09:00", weekdays: ["someday"] },
-			{ time: "09:00", weekdays: ["mon"], every_days: 2 },
-		];
-		for (const input of cases)
-			expect(() => parseRecurrence(input, now)).toThrow(ScheduleError);
-	});
-});
-
-// Runs against a real PostgreSQL, only when ROUNDTABLE_TEST_DATABASE_URL is set.
-describeDb("PostgreSQL", () => {
-	let store: TestStore<ScheduleStore>;
-
-	beforeAll(async () => {
-		const admin = new SQL(testDatabaseUrl);
-		await admin`DROP TABLE IF EXISTS schedules`;
-		await admin.close();
-		store = await openTestStore(ScheduleStore);
-	});
-
-	afterAll(async () => {
-		await store.close();
-	});
-
-	beforeEach(async () => {
-		const admin = new SQL(testDatabaseUrl);
-		await admin`TRUNCATE schedules`;
-		await admin.close();
-	});
-
-	const now = taipei("2026-09-26 23:30");
-	const ctx = (
-		over: Partial<ScheduleToolContext> = {},
-	): ScheduleToolContext => ({
-		store,
-		channel: "discord:a",
-		mode: "party",
-		author: { id: "u1", name: "Sam" },
-		now,
-		...over,
-	});
-
-	describe("schedule tools", () => {
-		test("a schedule keeps its creator's tier, and a lower tier cannot change it", async () => {
-			const admin = { id: "u2", name: "Ada", tier: "admin" } as const;
-			const member = { id: "u3", name: "Max", tier: "member" } as const;
-			await callScheduleTool(ctx({ author: admin }), "schedule_create", {
-				title: "patrol",
-				prompt: "check the disk",
-				time: "09:00",
-				every_days: 1,
-			});
-			const [schedule] = await store.forChannel("discord:a");
-			const id = schedule?.id ?? 0;
-			expect(schedule?.createdTier).toBe("admin");
-			for (const tool of ["schedule_update", "schedule_cancel"] as const)
-				await expect(
-					callScheduleTool(ctx({ author: member }), tool, {
-						id,
-						title: "renamed",
-					}),
-				).rejects.toThrow(/higher tier/);
-			await callScheduleTool(ctx({ author: admin }), "schedule_update", {
-				id,
-				title: "renamed",
-			});
-			expect((await store.get(id))?.title).toBe("renamed");
-			// The owner's own schedules default to the owner's tier.
-			await callScheduleTool(ctx(), "schedule_create", {
-				title: "morning report",
-				prompt: "report",
-				time: "10:00",
-				every_days: 1,
-			});
-			const owners = await store.forChannel("discord:a");
-			expect(owners.map((x) => x.createdTier).sort()).toEqual([
-				"admin",
-				"owner",
-			]);
-		});
-
-		test("create, list, update, and cancel act on the channel's schedules", async () => {
-			const created = await callScheduleTool(ctx(), "schedule_create", {
-				title: "jobs",
-				prompt: "find pastry shop openings",
-				time: "09:00",
-				every_days: 3,
-				start_date: "2026-09-16",
-			});
-			expect(created).toContain("first run 2026-09-28 09:00");
-			const [schedule] = await store.forChannel("discord:a");
-			expect(schedule?.createdByName).toBe("Sam");
-			expect(schedule?.mode).toBe("party");
-
-			const id = schedule?.id ?? 0;
-			expect(await callScheduleTool(ctx(), "schedule_list", {})).toContain(
-				`#${id} jobs`,
-			);
-			await callScheduleTool(ctx(), "schedule_update", {
-				id,
-				prompt: "find pastry shop openings; already seen: Acme",
-			});
-			expect(await callScheduleTool(ctx(), "schedule_list", { id })).toContain(
-				"already seen: Acme",
-			);
-			// Changing only the prompt keeps the timing.
-			expect((await store.get(id))?.nextRun).toEqual(
-				taipei("2026-09-28 09:00"),
-			);
-
-			await callScheduleTool(ctx(), "schedule_update", { id, time: "20:00" });
-			expect((await store.get(id))?.nextRun).toEqual(
-				taipei("2026-09-27 20:00"),
-			);
-
-			expect(
-				callScheduleTool(ctx({ channel: "discord:b" }), "schedule_cancel", {
-					id,
-				}),
-			).rejects.toThrow(ScheduleError);
-			await callScheduleTool(ctx(), "schedule_cancel", { id });
-			expect(await store.forChannel("discord:a")).toEqual([]);
-		});
-
-		test("a party channel is limited in count, prompt size, and distance", async () => {
-			const { perChannel, promptChars } = SCHEDULE_LIMITS.party;
-			for (let i = 0; i < perChannel; i += 1)
-				await callScheduleTool(ctx(), "schedule_create", {
-					title: `t${i}`,
-					prompt: "p",
-					time: "10:00",
-				});
-			expect(
-				callScheduleTool(ctx(), "schedule_create", {
-					title: "one more",
-					prompt: "p",
-					time: "10:00",
-				}),
-			).rejects.toThrow("cancel one first");
-			expect(
-				callScheduleTool(ctx({ channel: "discord:b" }), "schedule_create", {
-					title: "long",
-					prompt: "x".repeat(promptChars + 1),
-					time: "10:00",
-				}),
-			).rejects.toThrow(`within ${promptChars}`);
-			expect(
-				callScheduleTool(ctx({ channel: "discord:b" }), "schedule_create", {
-					title: "far",
-					prompt: "p",
-					at: "2027-09-26 10:00",
-				}),
-			).rejects.toThrow("within 90 days");
-			expect(
-				callScheduleTool(ctx({ channel: "discord:b" }), "schedule_create", {
-					title: "past",
-					prompt: "p",
-					at: "2026-09-26 10:00",
-				}),
-			).rejects.toThrow("already passed");
-		});
-
-		test("the scheduled message names the schedule and carries its prompt", async () => {
-			await callScheduleTool(ctx(), "schedule_create", {
-				title: "drink water",
-				prompt: "remind Sam to drink water",
-				at: "2026-09-27 09:00",
-			});
-			const [schedule] = await store.forChannel("discord:a");
-			if (!schedule) throw new Error("missing schedule");
-			const text = scheduledTurnText(schedule, taipei("2026-09-27 09:00"));
-			expect(text).toContain(`#${schedule.id}: drink water`);
-			expect(text).toContain("2026-09-27 09:00");
-			expect(text.endsWith("remind Sam to drink water")).toBe(true);
-		});
-	});
-
-	describe("scheduler", () => {
-		function scheduler(
-			clock: { now: Date },
-			fired: Schedule[],
-			outcome: ScheduledOutcome,
-		) {
-			return new Scheduler({
-				store,
-				runner: {
-					runScheduled: async (schedule) => {
-						fired.push(schedule);
-						return outcome;
-					},
-				},
-				logger: silentLogger(),
-				now: () => clock.now,
-			});
-		}
-
-		test("a due one-time schedule fires once and is deleted", async () => {
-			await callScheduleTool(ctx(), "schedule_create", {
-				title: "once",
-				prompt: "p",
-				at: "2026-09-27 09:00",
-			});
-			const clock = { now: taipei("2026-09-27 08:59") };
-			const fired: Schedule[] = [];
-			const s = scheduler(clock, fired, { status: "ran" });
-			await s.tick();
-			expect(fired).toHaveLength(0);
-			clock.now = taipei("2026-09-27 09:00");
-			await s.tick();
-			await s.tick();
-			await s.idle();
-			expect(fired.map((f) => f.title)).toEqual(["once"]);
-			expect(await store.forChannel("discord:a")).toEqual([]);
-		});
-
-		test("a repeating schedule moves to its next run and keeps the outcome", async () => {
-			await callScheduleTool(ctx(), "schedule_create", {
-				title: "daily",
-				prompt: "p",
-				time: "09:00",
-			});
-			const clock = { now: taipei("2026-09-27 09:00") };
-			const fired: Schedule[] = [];
-			const s = scheduler(clock, fired, {
-				status: "skipped",
-				reason: "party mode is off",
-			});
-			await s.tick();
-			await s.idle();
-			const [after] = await store.forChannel("discord:a");
-			expect(fired).toHaveLength(1);
-			expect(after && zonedStamp(after.nextRun)).toBe("2026-09-28 09:00");
-			expect(after?.lastStatus).toBe("skipped: party mode is off");
-		});
-
-		test("a run found long after it was due is skipped, not caught up", async () => {
-			await callScheduleTool(ctx(), "schedule_create", {
-				title: "daily",
-				prompt: "p",
-				time: "09:00",
-			});
-			const clock = { now: taipei("2026-09-29 12:00") };
-			const fired: Schedule[] = [];
-			const s = scheduler(clock, fired, { status: "ran" });
-			await s.tick();
-			await s.idle();
-			const [after] = await store.forChannel("discord:a");
-			expect(fired).toHaveLength(0);
-			expect(after && zonedStamp(after.nextRun)).toBe("2026-09-30 09:00");
-			expect(after?.lastStatus).toBe("skipped: missed while offline");
-		});
-	});
-});

package/src/core/modules/skills/skill-kind.test.ts

@@ -1,55 +0,0 @@
-import { afterEach, beforeEach, expect, test } from "bun:test";
-import { SQL } from "bun";
-import { migrate } from "../../db/migrations.ts";
-import {
-	describeDb,
-	migratedPool,
-	TEST_GUILD,
-	testDatabaseUrl,
-} from "../../testing/database.ts";
-import { LEGACY_WRITTEN_KIND, SkillStore } from "./skill-store.ts";
-
-// Runs against a real PostgreSQL, only when ROUNDTABLE_TEST_DATABASE_URL is set.
-describeDb("the written skill kind", () => {
-	let sql: SQL;
-
-	beforeEach(async () => {
-		const admin = new SQL(testDatabaseUrl);
-		for (const table of ["skills", "skill_groups", "agent_skills"])
-			await admin.unsafe(`DROP TABLE IF EXISTS ${table}`);
-		await admin.close();
-		// The tables as they were when an agent-written skill was stored under the legacy kind.
-		sql = await migratedPool(SkillStore.migration);
-		await sql`INSERT INTO skills (name, kind, description, body)
-			VALUES ('notes', ${LEGACY_WRITTEN_KIND}, 'Take notes.', 'Body.')`;
-		await sql`INSERT INTO skills (name, kind, repo, path)
-			VALUES ('linked-one', 'linked', 'owner/repo', 'skills/linked-one')`;
-	});
-
-	afterEach(async () => {
-		await sql.close();
-	});
-
-	const kinds = async () =>
-		(await sql`SELECT name, kind FROM skills ORDER BY name`) as {
-			name: string;
-			kind: string;
-		}[];
-
-	test("a legacy row becomes written, a linked row is left alone, and the store reads it", async () => {
-		await migrate(sql, SkillStore.migrations(TEST_GUILD));
-		expect(await kinds()).toEqual([
-			{ name: "linked-one", kind: "linked" },
-			{ name: "notes", kind: "written" },
-		]);
-		const store = await SkillStore.attach(sql, TEST_GUILD);
-		expect(store.skill("notes")?.kind).toBe("written");
-	});
-
-	test("running the migration again changes nothing", async () => {
-		await migrate(sql, SkillStore.migrations(TEST_GUILD));
-		const before = await kinds();
-		await migrate(sql, SkillStore.migrations(TEST_GUILD));
-		expect(await kinds()).toEqual(before);
-	});
-});