pi-roundtable 0.1.0 → 0.2.1

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

@@ -1,376 +0,0 @@
-import { afterAll, beforeEach, describe, expect, test } from "bun:test";
-import {
-	existsSync,
-	mkdirSync,
-	mkdtempSync,
-	readFileSync,
-	rmSync,
-	writeFileSync,
-} from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { parseFrontmatter } from "@earendil-works/pi-coding-agent";
-import { SQL } from "bun";
-import { AgentError } from "../../domain/errors.ts";
-import { silentLogger } from "../../log.ts";
-import {
-	describeDb,
-	openTestStore,
-	TEST_GUILD,
-	type TestStore,
-	testDatabaseUrl,
-} from "../../testing/database.ts";
-import { SkillRegistry } from "./skill-registry.ts";
-import { SkillStore } from "./skill-store.ts";
-
-const BUILTIN = join(import.meta.dir, "..", "..", "assets", "skills");
-
-// Runs against a real PostgreSQL, only when ROUNDTABLE_TEST_DATABASE_URL is set.
-describeDb("PostgreSQL", () => {
-	let store: TestStore<SkillStore>;
-	let registry: SkillRegistry;
-	let dir: string;
-
-	const skillFile = (name: string, description: string) =>
-		`---\nname: ${name}\ndescription: ${description}\n---\n\n# ${name}\n`;
-
-	function repoSkill(
-		repo: string,
-		path: string,
-		name: string,
-		description = `Use when ${name}.`,
-	) {
-		mkdirSync(join(dir, "repos", repo, ".git"), { recursive: true });
-		mkdirSync(join(dir, "repos", repo, path), { recursive: true });
-		writeFileSync(
-			join(dir, "repos", repo, path, "SKILL.md"),
-			skillFile(name, description),
-		);
-	}
-
-	const open = async () => {
-		store = await openTestStore(SkillStore, TEST_GUILD);
-		registry = new SkillRegistry({
-			store,
-			reposDir: join(dir, "repos"),
-			writtenDir: join(dir, "skills"),
-			builtinDir: BUILTIN,
-			logger: silentLogger(),
-		});
-		registry.init();
-	};
-
-	beforeEach(async () => {
-		await store?.close();
-		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();
-		if (dir) rmSync(dir, { recursive: true, force: true });
-		dir = mkdtempSync(join(tmpdir(), "roundtable-skills-"));
-		repoSkill("acme/skills", "skills/plan-work", "plan-work");
-		repoSkill("acme/skills", "skills/write-tests", "write-tests");
-		await open();
-	});
-
-	afterAll(async () => {
-		await store.close();
-		rmSync(dir, { recursive: true, force: true });
-	});
-
-	const refuses = async (run: () => Promise<unknown>, text: string) => {
-		const error = await run().then(
-			() => undefined,
-			(e: unknown) => e,
-		);
-		expect(error).toBeInstanceOf(AgentError);
-		expect((error as Error).message).toContain(text);
-	};
-
-	describe("built-in skill", () => {
-		test("every set carries writing-skills from the release, with a trigger-only description", () => {
-			const set = registry.resolve([]);
-			expect(set.missing).toEqual([]);
-			expect(set.skills.map((s) => s.name)).toEqual(["writing-skills"]);
-			expect(set.skills[0]?.description.startsWith("Use when")).toBe(true);
-		});
-
-		test("it cannot be removed, changed, or taken as a name", async () => {
-			await refuses(
-				() => registry.attach("notes", [], ["writing-skills"]),
-				"built in",
-			);
-			await refuses(
-				() => registry.update("writing-skills", { body: "x" }),
-				"built in",
-			);
-			await refuses(
-				() =>
-					registry.create({
-						name: "writing-skills",
-						description: "Use when x.",
-						body: "x",
-					}),
-				"already exists",
-			);
-		});
-	});
-
-	describe("linked skills", () => {
-		test("a folder of skills links every child with its own name and description", async () => {
-			const text = await registry.link("acme/skills", "skills");
-			expect(text).toContain("Linked 2 skills");
-			const set = registry.resolve(["plan-work", "write-tests"]);
-			expect(set.skills.map((s) => s.name)).toEqual([
-				"writing-skills",
-				"plan-work",
-				"write-tests",
-			]);
-			expect(set.skills[1]?.file).toBe(
-				join(dir, "repos/acme/skills/skills/plan-work/SKILL.md"),
-			);
-		});
-
-		test("a single skill folder links just that skill", async () => {
-			await registry.link("acme/skills", "./skills/plan-work/");
-			expect(store.skill("plan-work")).toEqual({
-				kind: "linked",
-				name: "plan-work",
-				repo: "acme/skills",
-				path: "skills/plan-work",
-			});
-			expect(store.skill("write-tests")).toBeUndefined();
-		});
-
-		test("a pull that changes the description shows on the next resolve", async () => {
-			await registry.link("acme/skills", "skills/plan-work");
-			repoSkill(
-				"acme/skills",
-				"skills/plan-work",
-				"plan-work",
-				"Use when changed.",
-			);
-			expect(registry.resolve(["plan-work"]).skills[1]?.description).toBe(
-				"Use when changed.",
-			);
-		});
-
-		test("one taken name refuses the whole call", async () => {
-			await registry.link("acme/skills", "skills/plan-work");
-			await refuses(
-				() => registry.link("acme/skills", "skills"),
-				"Nothing was linked",
-			);
-			expect(store.skill("write-tests")).toBeUndefined();
-		});
-
-		test("unmanaged repositories, escaping paths, and folders without skills are refused", async () => {
-			await refuses(
-				() => registry.link("acme/other", "skills"),
-				"not a managed repository",
-			);
-			await refuses(() => registry.link("acme/skills", "../../x"), "inside");
-			mkdirSync(join(dir, "repos/acme/skills/docs"), { recursive: true });
-			await refuses(() => registry.link("acme/skills", "docs"), "no SKILL.md");
-		});
-
-		test("linked skills are read-only through the skill tools", async () => {
-			await registry.link("acme/skills", "skills/plan-work");
-			await refuses(
-				() => registry.update("plan-work", { body: "x" }),
-				"repo_task",
-			);
-			await refuses(() => registry.delete("plan-work"), "read-only");
-		});
-
-		test("a vanished or renamed file is reported missing, not loaded", async () => {
-			await registry.link("acme/skills", "skills");
-			rmSync(join(dir, "repos/acme/skills/skills/write-tests"), {
-				recursive: true,
-			});
-			repoSkill("acme/skills", "skills/plan-work", "plan-work-renamed");
-			const set = registry.resolve(["plan-work", "write-tests"]);
-			expect(set.skills.map((s) => s.name)).toEqual(["writing-skills"]);
-			expect(set.missing.map((m) => m.name)).toEqual([
-				"plan-work",
-				"write-tests",
-			]);
-			expect(set.missing[0]?.reason).toContain("plan-work-renamed");
-			expect(registry.list()).toContain("missing: file not found");
-		});
-	});
-
-	describe("agent-written skills", () => {
-		test("create writes a SKILL.md Pi reads back with the same name and description", async () => {
-			await registry.create({
-				name: "daily-notes",
-				description: 'Use when writing a "daily" note: summaries or logs.',
-				body: "# Daily notes\n\n1. Write.",
-			});
-			const file = join(dir, "skills/daily-notes/SKILL.md");
-			const { frontmatter, body } = parseFrontmatter<Record<string, string>>(
-				readFileSync(file, "utf8"),
-			);
-			expect(frontmatter.name).toBe("daily-notes");
-			expect(frontmatter.description).toBe(
-				'Use when writing a "daily" note: summaries or logs.',
-			);
-			expect(body.trim()).toBe("# Daily notes\n\n1. Write.");
-			expect(registry.resolve(["daily-notes"]).skills[1]?.file).toBe(file);
-		});
-
-		test("descriptions must be triggers, bodies bounded, names Pi-valid", async () => {
-			await refuses(
-				() =>
-					registry.create({
-						name: "x",
-						description: "Writes notes.",
-						body: "b",
-					}),
-				"Use when",
-			);
-			await refuses(
-				() =>
-					registry.create({
-						name: "x",
-						description: "Use when x.",
-						body: "b".repeat(12_001),
-					}),
-				"12000",
-			);
-			await refuses(
-				() =>
-					registry.create({
-						name: "Bad--name",
-						description: "Use when x.",
-						body: "b",
-					}),
-				"not a usable skill name",
-			);
-		});
-
-		test("update rewrites the file; delete removes it and detaches carriers and groups", async () => {
-			await registry.create({
-				name: "daily-notes",
-				description: "Use when a.",
-				body: "one",
-			});
-			await registry.update("daily-notes", { body: "two" });
-			expect(
-				readFileSync(join(dir, "skills/daily-notes/SKILL.md"), "utf8"),
-			).toContain("two");
-			await registry.attach("notes", ["daily-notes"], []);
-			await registry.setGroup("writing", "Writing skills.", [
-				"daily-notes",
-				"writing-skills",
-			]);
-			const text = await registry.delete("daily-notes");
-			expect(text).toBe(
-				"Removed skill daily-notes; detached from agents notes and groups writing.",
-			);
-			expect(existsSync(join(dir, "skills/daily-notes"))).toBe(false);
-			expect(store.carriedBy("notes")).toEqual([]);
-			expect(store.group("writing")?.skills).toEqual(["writing-skills"]);
-		});
-
-		test("a restart rewrites files from the database and clears stale folders", async () => {
-			await registry.create({
-				name: "daily-notes",
-				description: "Use when a.",
-				body: "one",
-			});
-			rmSync(join(dir, "skills/daily-notes"), { recursive: true });
-			mkdirSync(join(dir, "skills/stale"), { recursive: true });
-			await store.close();
-			await open();
-			expect(existsSync(join(dir, "skills/daily-notes/SKILL.md"))).toBe(true);
-			expect(existsSync(join(dir, "skills/stale"))).toBe(false);
-		});
-	});
-
-	describe("groups and carrying", () => {
-		test("attach adds and removes together and survives a restart", async () => {
-			await registry.link("acme/skills", "skills");
-			expect(
-				await registry.attach("infra", ["plan-work", "write-tests"], []),
-			).toEqual(["plan-work", "write-tests"]);
-			expect(await registry.attach("infra", [], ["write-tests"])).toEqual([
-				"plan-work",
-			]);
-			await store.close();
-			await open();
-			expect(store.carriedBy("infra")).toEqual(["plan-work"]);
-			expect(registry.describeCarried("infra")).toBe(
-				"writing-skills (built in), plan-work",
-			);
-		});
-
-		test("an unknown name changes nothing", async () => {
-			await registry.link("acme/skills", "skills");
-			await refuses(
-				() => registry.attach("infra", ["plan-work", "nope"], []),
-				"Unknown skills: nope",
-			);
-			expect(store.carriedBy("infra")).toEqual([]);
-		});
-
-		test("the catalog lists every skill with its source, groups, carriers, and missing files", async () => {
-			await registry.link("acme/skills", "skills");
-			await registry.setGroup("coding", "Coding workflow.", ["plan-work"]);
-			await registry.attach("infra", ["plan-work"], []);
-			rmSync(join(dir, "repos", "acme/skills", "skills/write-tests"), {
-				recursive: true,
-			});
-			const catalog = registry.catalog();
-			expect(catalog.map((entry) => entry.name)).toEqual([
-				"writing-skills",
-				"plan-work",
-				"write-tests",
-			]);
-			expect(catalog[0]).toMatchObject({
-				source: { kind: "builtin" },
-				file: join(BUILTIN, "writing-skills", "SKILL.md"),
-			});
-			expect(catalog[1]).toEqual({
-				name: "plan-work",
-				source: {
-					kind: "linked",
-					repo: "acme/skills",
-					path: "skills/plan-work",
-				},
-				description: "Use when plan-work.",
-				file: join(dir, "repos", "acme/skills", "skills/plan-work", "SKILL.md"),
-				groups: ["coding"],
-				carriers: ["infra"],
-			});
-			expect(catalog[2]?.missing).toBeString();
-			expect(catalog[2]?.file).toBeUndefined();
-		});
-
-		test("groups filter the list; unlinking detaches from groups too", async () => {
-			await registry.link("acme/skills", "skills");
-			await registry.setGroup("coding", "Coding workflow.", ["plan-work"]);
-			await registry.attach("infra", ["plan-work"], []);
-			const listed = registry.list({ group: "coding" });
-			expect(listed).toContain(
-				"- plan-work [linked from acme/skills:skills/plan-work]",
-			);
-			expect(listed).toContain("carried by: infra");
-			expect(listed).not.toContain("- write-tests");
-			expect(registry.list({ query: "write-tests" })).toContain(
-				"- write-tests",
-			);
-			expect(await registry.unlink("plan-work")).toBe(
-				"Removed skill plan-work; detached from agents infra and groups coding.",
-			);
-			await refuses(
-				() => registry.setGroup("coding", "x", ["nope"]),
-				"Unknown skills",
-			);
-			await refuses(
-				async () => registry.list({ group: "nope" }),
-				"no skill group",
-			);
-		});
-	});
-});

package/src/core/ops/error-reporter.test.ts

@@ -1,283 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import pino from "pino";
-import type { ScheduledOutcome } from "../contract/channels.ts";
-import { createLogger, type LogEntry } from "../log.ts";
-import type { ChannelKey } from "../sessions.ts";
-import { ErrorReporter, fingerprint, reportText } from "./error-reporter.ts";
-
-const HOUR = 3_600_000;
-
-/** The ops agent as the delivery sees it: active with a channel, or not. */
-interface OpsAgent {
-	status: "active" | "archived";
-	channelId?: string;
-}
-
-const infra: OpsAgent = { status: "active", channelId: "42" };
-
-function stack(file: string, line: number): string {
-	return `Error: boom\n    at run (/opt/app/${file}:${line}:7)\n    at next (/opt/app/node_modules/x/index.js:1:1)`;
-}
-
-function entry(msg: string, fields: LogEntry = {}): LogEntry {
-	return {
-		level: 50,
-		time: Date.now(),
-		pid: 1,
-		hostname: "h",
-		app: "roundtable",
-		msg,
-		...fields,
-	};
-}
-
-function setup(options: { agent?: OpsAgent; turn?: () => Promise<void> } = {}) {
-	let now = 1_000_000;
-	const timers: { run: () => void; at: number }[] = [];
-	const reporter = new ErrorReporter({
-		opsAgent: "infra",
-		app: "Roundtable",
-		now: () => now,
-		setTimer: (run, ms) => timers.push({ run, at: now + ms }),
-		ignored: [/expected noise/],
-	});
-	const posts: { channel: ChannelKey; text: string }[] = [];
-	const turns: string[] = [];
-	const lines: LogEntry[] = [];
-	const logger = pino(
-		{ base: { app: "roundtable" } },
-		{
-			write(line: string) {
-				const logged = JSON.parse(line) as LogEntry;
-				lines.push(logged);
-				reporter.record(logged);
-			},
-		},
-	);
-	const agent = "agent" in options ? options.agent : infra;
-	const delivery = {
-		channelOf: (name: string): ChannelKey | undefined =>
-			name === "infra" && agent?.status === "active" && agent.channelId
-				? `discord:${agent.channelId}`
-				: undefined,
-		post: async (channel: ChannelKey, text: string) => {
-			posts.push({ channel, text });
-		},
-		turn: async (_channel: ChannelKey, text: string) => {
-			turns.push(text);
-			await options.turn?.();
-			return { status: "ran" } as ScheduledOutcome;
-		},
-		logger,
-	};
-	return {
-		reporter,
-		delivery,
-		posts,
-		turns,
-		lines,
-		logger,
-		connect: () => reporter.connect(delivery),
-		advance(ms: number) {
-			now += ms;
-			for (const timer of timers.splice(0))
-				if (timer.at <= now) timer.run();
-				else timers.push(timer);
-		},
-	};
-}
-
-const settle = () => new Promise((resolve) => setTimeout(resolve, 0));
-
-describe("ErrorReporter", () => {
-	test("an error is posted in Infra's channel and starts its report turn", async () => {
-		const { reporter, connect, posts, turns } = setup();
-		connect();
-		reporter.record(
-			entry("webhook post failed", {
-				module: "discord",
-				channel: "discord:7",
-				err: { type: "Error", message: "boom", stack: stack("src/a.ts", 12) },
-			}),
-		);
-		await settle();
-		expect(posts).toHaveLength(1);
-		expect(posts[0]?.channel).toBe("discord:42");
-		const text = posts[0]?.text ?? "";
-		expect(text).toStartWith(
-			"Roundtable logged an error: webhook post failed\n",
-		);
-		expect(text).toContain("app: roundtable · module: discord");
-		expect(text).toContain("channel: discord:7");
-		expect(text).toContain("at run (/opt/app/src/a.ts:12:7)");
-		expect(text).not.toContain("pid");
-		expect(turns).toEqual([text]);
-	});
-
-	test("a long report is trimmed", () => {
-		const text = reportText(
-			entry("big", {
-				err: { message: "x", stack: `Error: ${"y".repeat(5000)}` },
-			}),
-			"Roundtable",
-		);
-		expect(text.length).toBeLessThanOrEqual(1500);
-		expect(text).toEndWith("…");
-	});
-
-	test("the fingerprint ignores times and ids but not where the error was raised", () => {
-		const a = entry("failed", {
-			channel: "discord:1",
-			err: { stack: stack("src/a.ts", 3) },
-		});
-		const b = entry("failed", {
-			channel: "discord:2",
-			time: 5,
-			err: { stack: stack("src/a.ts", 3) },
-		});
-		const c = entry("failed", { err: { stack: stack("src/b.ts", 3) } });
-		expect(fingerprint(a)).toBe(fingerprint(b));
-		expect(fingerprint(a)).not.toBe(fingerprint(c));
-		expect(fingerprint(entry("no stack", { job: 1 }))).toBe(
-			fingerprint(entry("no stack", { job: 2 })),
-		);
-	});
-
-	test("the same error twice in an hour is reported once, and again after it", async () => {
-		const { reporter, connect, posts, advance } = setup();
-		connect();
-		const same = () =>
-			entry("failed", { err: { stack: stack("src/a.ts", 3) } });
-		reporter.record(same());
-		await settle();
-		advance(HOUR - 1);
-		reporter.record(same());
-		await settle();
-		expect(posts).toHaveLength(1);
-		advance(1);
-		reporter.record(same());
-		await settle();
-		expect(posts).toHaveLength(2);
-	});
-
-	test("six distinct errors in an hour make five reports and a later summary", async () => {
-		const { reporter, connect, posts, turns, advance } = setup();
-		connect();
-		for (let i = 0; i < 6; i++) {
-			reporter.record(entry(`failure ${i}`));
-			advance(60_000);
-		}
-		reporter.record(entry("failure 5"));
-		await settle();
-		expect(posts).toHaveLength(5);
-		advance(HOUR);
-		await settle();
-		expect(posts).toHaveLength(6);
-		expect(posts[5]?.text).toBe(
-			"Roundtable error reports: 2 more errors suppressed: failure 5 (×2)",
-		);
-		expect(turns).toHaveLength(6);
-	});
-
-	test("errors logged while Infra runs an error-report turn are summed up after it", async () => {
-		let finish = () => {};
-		const running = new Promise<void>((resolve) => {
-			finish = resolve;
-		});
-		const { reporter, connect, posts, logger } = setup({ turn: () => running });
-		connect();
-		reporter.record(entry("first"));
-		await settle();
-		reporter.record(entry("during the turn"));
-		logger.error("also during the turn");
-		await settle();
-		expect(posts).toHaveLength(1);
-		finish();
-		await settle();
-		await settle();
-		expect(posts).toHaveLength(2);
-		expect(posts[1]?.text).toStartWith(
-			"Roundtable error reports: 2 more errors suppressed:",
-		);
-		expect(posts[1]?.text).toContain("during the turn");
-		expect(posts[1]?.text).toContain("also during the turn");
-		await settle();
-		reporter.record(entry("after the turn"));
-		await settle();
-		expect(posts).toHaveLength(3);
-	});
-
-	test("the reporter's own failures are only logged", async () => {
-		const { reporter, delivery, lines, turns } = setup();
-		delivery.post = async () => {
-			throw new Error("discord down");
-		};
-		delivery.turn = async () => {
-			throw new Error("turn broke");
-		};
-		reporter.connect(delivery);
-		reporter.record(entry("first"));
-		await settle();
-		await settle();
-		expect(lines.map((l) => l.msg)).toEqual([
-			"error report not posted",
-			"error report turn failed",
-		]);
-		expect(turns).toHaveLength(0);
-	});
-
-	test("nothing is reported when Infra is missing or archived", async () => {
-		for (const agent of [
-			undefined,
-			{ ...infra, status: "archived" as const },
-		]) {
-			const { reporter, connect, posts, turns } = setup({ agent });
-			connect();
-			reporter.record(entry("failed"));
-			await settle();
-			expect(posts).toHaveLength(0);
-			expect(turns).toHaveLength(0);
-		}
-	});
-
-	test("warnings and ignored errors are not reported", async () => {
-		const { reporter, connect, posts } = setup();
-		connect();
-		reporter.record({ ...entry("just a warning"), level: 40 });
-		reporter.record(entry("some expected noise here"));
-		await settle();
-		expect(posts).toHaveLength(0);
-	});
-
-	test("errors before the agent server is ready wait, the last twenty kept", async () => {
-		const { reporter, connect, posts, lines } = setup();
-		for (let i = 0; i < 23; i++) reporter.record(entry(`early ${i}`));
-		expect(posts).toHaveLength(0);
-		connect();
-		await settle();
-		expect(posts.map((p) => p.text.split("\n")[0])).toEqual(
-			[3, 4, 5, 6, 7].map((i) => `Roundtable logged an error: early ${i}`),
-		);
-		expect(lines[0]).toMatchObject({
-			level: 40,
-			dropped: 3,
-			msg: "early errors dropped before reporting started",
-		});
-	});
-});
-
-describe("createLogger", () => {
-	test("hands error and fatal entries to the sink, not warnings", () => {
-		const taken: LogEntry[] = [];
-		const logger = createLogger("roundtable", (logged) => taken.push(logged));
-		logger.level = "error";
-		logger.warn("a warning");
-		logger.error({ job: 1 }, "an error");
-		logger.fatal("fatal");
-		expect(taken.map((t) => [t.level, t.msg, t.app])).toEqual([
-			[50, "an error", "roundtable"],
-			[60, "fatal", "roundtable"],
-		]);
-		expect(taken[0]?.job).toBe(1);
-	});
-});

package/src/core/presentation/card-cadence.ts

@@ -1,41 +0,0 @@
-import type { ChannelKey } from "../domain/conversation.ts";
-import type { Expression } from "../domain/expression.ts";
-
-/** A channel quiet this long starts a new conversation, whose first reply shows a card. */
-export const CONVERSATION_GAP_MS = 30 * 60_000;
-
-/**
- * Decides which replies carry a card: one that opens a conversation or changes its tone.
- * Kept in memory; after a restart every channel's next reply opens a conversation.
- */
-export class CardCadence {
-	readonly #channels = new Map<
-		ChannelKey,
-		{ lastReplyAt: number; lastCard: Expression | undefined }
-	>();
-
-	/** Records a reply about to be posted and says whether it shows a card. */
-	shows(
-		channel: ChannelKey,
-		expression: Expression,
-		failed: boolean,
-		now = Date.now(),
-	): boolean {
-		const state = this.#channels.get(channel);
-		const card =
-			failed ||
-			!state ||
-			now - state.lastReplyAt >= CONVERSATION_GAP_MS ||
-			(expression !== "neutral" && expression !== state.lastCard);
-		this.#channels.set(channel, {
-			lastReplyAt: now,
-			lastCard: card ? expression : state?.lastCard,
-		});
-		return card;
-	}
-
-	/** The channel's next reply opens a conversation again. */
-	forget(channel: ChannelKey): void {
-		this.#channels.delete(channel);
-	}
-}