pi-roundtable 0.1.0 → 0.2.1

package/src/cli/cli.test.ts

@@ -1,122 +0,0 @@
-import { afterEach, expect, test } from "bun:test";
-import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
-import { type CliEnvironment, readPackage, runCli } from "./cli.ts";
-import { fakePorts, tempDir, validConfig } from "./testing/fixtures.ts";
-
-const dirs: ReturnType<typeof tempDir>[] = [];
-afterEach(() => {
-	for (const dir of dirs.splice(0)) dir.done();
-});
-
-function cli(overrides: Partial<CliEnvironment> = {}) {
-	const dir = tempDir();
-	dirs.push(dir);
-	const out: string[] = [];
-	const err: string[] = [];
-	const launched: unknown[] = [];
-	const io: CliEnvironment = {
-		cwd: dir.path,
-		env: {},
-		bun: () => ({ version: "1.3.10", required: ">=1.3.0" }),
-		version: () => "1.2.3",
-		ports: fakePorts(),
-		launch: async (defined) => void launched.push(defined),
-		out: (line) => out.push(line),
-		err: (line) => err.push(line),
-		...overrides,
-	};
-	return { io, out, err, launched, dir };
-}
-
-test("no command prints the usage and exits non-zero; help and --version exit zero", async () => {
-	const none = cli();
-	expect(await runCli([], none.io)).toBe(1);
-	expect(none.out.join("\n")).toContain("roundtable init");
-	const help = cli();
-	expect(await runCli(["--help"], help.io)).toBe(0);
-	const version = cli();
-	expect(await runCli(["--version"], version.io)).toBe(0);
-	expect(version.out).toEqual(["1.2.3"]);
-});
-
-test("an unknown command or a wrong argument list prints the problem and exits non-zero", async () => {
-	for (const argv of [
-		["frobnicate"],
-		["add"],
-		["add", "plugin"],
-		["add", "thing", "x"],
-		["add", "plugin", "a", "b"],
-		["init", "a", "b"],
-		["doctor", "extra"],
-		["start", "--reachable"],
-	]) {
-		const run = cli();
-		expect(await runCli(argv, run.io)).toBe(1);
-		expect(run.err.length).toBeGreaterThan(0);
-	}
-});
-
-test("init prints what it created and the three next steps, and exits zero; a second run refuses", async () => {
-	const run = cli();
-	expect(await runCli(["init", "bot"], run.io)).toBe(0);
-	const text = run.out.join("\n");
-	expect(text).toContain("roundtable.config.ts");
-	expect(text).toContain("1. cd bot && bun install");
-	expect(text).toContain("3. bunx roundtable start");
-	expect(existsSync(join(run.dir.path, "bot/plugins/hello.ts"))).toBe(true);
-	const again = await runCli(["init", "bot"], run.io);
-	expect(again).toBe(1);
-	expect(run.err.join("\n")).toContain("already exist");
-});
-
-test("init on an old Bun refuses with the install page and creates nothing", async () => {
-	const run = cli({ bun: () => ({ version: "1.0.0", required: ">=1.3.0" }) });
-	expect(await runCli(["init"], run.io)).toBe(1);
-	expect(run.err.join("\n")).toContain("https://bun.sh/docs/installation");
-	expect(existsSync(join(run.dir.path, "package.json"))).toBe(false);
-});
-
-test("add plugin exits zero after init and non-zero on a bad name", async () => {
-	const run = cli();
-	await runCli(["init"], run.io);
-	expect(await runCli(["add", "plugin", "notes"], run.io)).toBe(0);
-	expect(
-		readFileSync(join(run.dir.path, "roundtable.config.ts"), "utf8"),
-	).toContain("plugins: [hello, notes]");
-	expect(await runCli(["add", "plugin", "Bad_Name"], run.io)).toBe(1);
-});
-
-test("doctor exits non-zero when a check fails and zero when none does", async () => {
-	const failing = cli({
-		ports: fakePorts(validConfig, { login: async () => undefined }),
-	});
-	expect(await runCli(["doctor"], failing.io)).toBe(1);
-	expect(failing.out.join("\n")).toContain("✗ model login");
-});
-
-test("start exits non-zero without launching when an offline check fails, and launches otherwise", async () => {
-	const failing = cli({ ports: fakePorts({}) });
-	expect(await runCli(["start"], failing.io)).toBe(1);
-	expect(failing.launched).toEqual([]);
-	expect(failing.err.join("\n")).toContain("✗ configuration");
-	const working = cli();
-	expect(await runCli(["start"], working.io)).toBe(0);
-	expect(working.launched).toHaveLength(1);
-});
-
-test("readPackage reads the version and Bun range, and refuses a package.json without them", () => {
-	const dir = tempDir();
-	dirs.push(dir);
-	dir.write(
-		"package.json",
-		JSON.stringify({ version: "0.1.0", engines: { bun: ">=1.3.0" } }),
-	);
-	expect(readPackage(dir.path)).toEqual({ version: "0.1.0", bun: ">=1.3.0" });
-	dir.write("package.json", JSON.stringify({ name: "private" }));
-	expect(() => readPackage(dir.path)).toThrow(
-		"installed pi-roundtable package",
-	);
-	dir.write("package.json", "{ nope");
-	expect(() => readPackage(dir.path)).toThrow("not valid JSON");
-});

package/src/cli/config-edit.test.ts

@@ -1,130 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { addPluginToConfig, ConfigEditError } from "./config-edit.ts";
-
-const notes = { name: "my-notes", ident: "myNotes" };
-const edit = (source: string) => addPluginToConfig(source, notes);
-const refusal = (source: string): string => {
-	try {
-		edit(source);
-	} catch (error) {
-		if (error instanceof ConfigEditError) return error.message;
-		throw error;
-	}
-	return "";
-};
-
-describe("addPluginToConfig", () => {
-	test("adds the import after the imports and the entry after the last one", () => {
-		const source = `import type { Config } from "node:fs";
-import { hello } from "./plugins/hello.ts";
-
-export default {
-	name: "Bot",
-	plugins: [hello],
-} satisfies Config;
-`;
-		expect(edit(source)).toBe(`import type { Config } from "node:fs";
-import { hello } from "./plugins/hello.ts";
-import { myNotes } from "./plugins/my-notes.ts";
-
-export default {
-	name: "Bot",
-	plugins: [hello, myNotes],
-} satisfies Config;
-`);
-	});
-
-	test("puts the import in sorted place among the relative imports", () => {
-		const source = `import { agents } from "./agents.ts";
-import { hello } from "./plugins/hello.ts";
-import { zed } from "./plugins/zed.ts";
-
-export default { plugins: [hello, zed] };
-`;
-		const lines = edit(source).split("\n");
-		expect(lines.slice(0, 4)).toEqual([
-			'import { agents } from "./agents.ts";',
-			'import { hello } from "./plugins/hello.ts";',
-			'import { myNotes } from "./plugins/my-notes.ts";',
-			'import { zed } from "./plugins/zed.ts";',
-		]);
-	});
-
-	test("keeps a multi-line list's layout, with or without a trailing comma", () => {
-		const bare = `import { a } from "./plugins/a.ts";
-export default {
-	plugins: [
-		a,
-	],
-};
-`;
-		expect(edit(bare)).toContain("\t\ta,\n\t\tmyNotes,\n\t],");
-		const noComma = bare.replace("a,\n\t]", "a\n\t]");
-		expect(edit(noComma)).toContain("\t\ta,\n\t\tmyNotes\n\t],");
-	});
-
-	test("fills an empty list and adds the import to a file without imports", () => {
-		const edited = edit("export default { plugins: [] };\n");
-		expect(edited).toBe(
-			'import { myNotes } from "./plugins/my-notes.ts";\n\nexport default { plugins: [myNotes] };\n',
-		);
-	});
-
-	test("finds the list under as, satisfies, parentheses, and a named constant", () => {
-		for (const source of [
-			"export default { plugins: [a] } as const;",
-			"export default ({ plugins: [a] });",
-			"export default { plugins: [a] as Plugin[] };",
-			"const config = { plugins: [a] } satisfies X;\nexport default config;",
-			'export default { "plugins": [a] };',
-		])
-			expect(edit(source)).toContain("a, myNotes]");
-	});
-
-	test("leaves comments and every other byte as they were", () => {
-		const source = `// the bot
-import { a } from "./plugins/a.ts";
-
-export default {
-	// who
-	owner: { id: "1" },
-	plugins: [a /* first */], // done
-};
-`;
-		const edited = edit(source);
-		expect(edited).toContain("// the bot");
-		expect(edited).toContain("// who");
-		// The entry goes right after the last element, before anything that follows it on the line.
-		expect(edited).toContain("plugins: [a, myNotes /* first */], // done");
-	});
-
-	test("refuses a default export with no plugin list, naming the file and what to add", () => {
-		for (const source of [
-			"export default { name: 'x' };",
-			"export default { plugins: somePlugins };",
-			"export default makeConfig();",
-			"export const config = { plugins: [] };",
-			"export default { other: { plugins: [] } };",
-		]) {
-			const text = refusal(source);
-			expect(text).toContain("roundtable.config.ts");
-			expect(text).toContain("cannot find the plugin list");
-			expect(text).toContain('import { myNotes } from "./plugins/my-notes.ts"');
-		}
-	});
-
-	test("refuses a name the file already uses, and a plugin already listed", () => {
-		expect(
-			refusal(
-				'import { myNotes } from "./plugins/my-notes.ts";\nexport default { plugins: [myNotes] };',
-			),
-		).toContain("myNotes is already used");
-		expect(
-			refusal("const myNotes = 1;\nexport default { plugins: [] };"),
-		).toContain("already used");
-	});
-
-	test("refuses a file that does not parse and says so", () => {
-		expect(refusal("export default { plugins: [ ")).toContain("does not parse");
-	});
-});

package/src/cli/doctor.test.ts

@@ -1,184 +0,0 @@
-import { afterEach, describe, expect, test } from "bun:test";
-import type { DefinedRoundtable } from "../core/define-roundtable.ts";
-import type { DatabasePort } from "./checks/database.ts";
-import { INVITE_PERMISSIONS } from "./discord-api.ts";
-import { buildChecks, type DoctorInputs, doctor } from "./doctor.ts";
-import { type Check, formatOutcomes, runChecks } from "./report.ts";
-import { start } from "./start.ts";
-import {
-	fakeHttp,
-	fakePorts,
-	healthyDiscord,
-	tempDir,
-	validConfig,
-} from "./testing/fixtures.ts";
-
-const dirs: ReturnType<typeof tempDir>[] = [];
-afterEach(() => {
-	for (const dir of dirs.splice(0)) dir.done();
-});
-
-const workingDatabase: DatabasePort = { check: async () => {} };
-const bun = { version: "1.3.10", required: ">=1.3.0" };
-
-function inputs(overrides: Partial<DoctorInputs> = {}): DoctorInputs {
-	const dir = tempDir();
-	dirs.push(dir);
-	return {
-		cwd: dir.path,
-		env: {},
-		bun,
-		ports: fakePorts(),
-		database: workingDatabase,
-		http: fakeHttp({
-			...healthyDiscord(INVITE_PERMISSIONS),
-			"/": { status: 200, body: undefined },
-		}),
-		reachable: false,
-		...overrides,
-	};
-}
-
-describe("doctor", () => {
-	test("lists the checks in the order the spec gives", () => {
-		expect(buildChecks(inputs()).map((check) => check.name)).toEqual([
-			"Bun",
-			"environment",
-			"configuration",
-			"plugins",
-			"PostgreSQL",
-			"Discord token",
-			"Discord guild",
-			"Discord intents",
-			"Discord channel",
-			"model login",
-			"public URL",
-		]);
-	});
-
-	test("passes on a healthy setup", async () => {
-		const report = await doctor(inputs());
-		expect(report.ok).toBe(true);
-		expect(
-			report.outcomes.every(({ result }) => result.status !== "fail"),
-		).toBe(true);
-	});
-
-	test("fails when any check fails, and prints each check as passed or failed with its fix", async () => {
-		const report = await doctor(
-			inputs({
-				ports: fakePorts(validConfig, { login: async () => undefined }),
-			}),
-		);
-		expect(report.ok).toBe(false);
-		const lines = formatOutcomes(report.outcomes);
-		expect(lines.filter((line) => line.startsWith("✓"))).not.toHaveLength(0);
-		const failed = lines.findIndex((line) => line.startsWith("✗ model login"));
-		expect(failed).toBeGreaterThan(-1);
-		expect(lines[failed + 1]).toStartWith("    ");
-		expect(lines[failed + 1]).toContain("API key");
-	});
-
-	test("a missing credential fails the checks that need it and skips what depends on it, changing nothing", async () => {
-		const incomplete = {
-			...validConfig,
-			discord: { ...validConfig.discord, token: "" },
-		};
-		const http = fakeHttp({});
-		const report = await doctor(inputs({ ports: fakePorts(incomplete), http }));
-		const byName = Object.fromEntries(
-			report.outcomes.map(({ name, result }) => [name, result.status]),
-		);
-		expect(byName.configuration).toBe("fail");
-		expect(byName["Discord token"]).toBe("skipped");
-		expect(byName["Discord guild"]).toBe("skipped");
-		expect(byName["Discord channel"]).toBe("skipped");
-		expect(http.requests).toEqual([]);
-		expect(report.ok).toBe(false);
-	});
-
-	test("a check that throws is reported as failed without hiding the ones after it", async () => {
-		const checks: Check[] = [
-			{
-				name: "boom",
-				offline: true,
-				run: async () => {
-					throw new Error("kaput");
-				},
-			},
-			{ name: "fine", offline: true, run: async () => ({ status: "ok" }) },
-		];
-		const outcomes = await runChecks(checks);
-		expect(outcomes.map(({ result }) => result.status)).toEqual(["fail", "ok"]);
-		expect(formatOutcomes(outcomes).join("\n")).toContain("kaput");
-	});
-
-	test("asks the public address to answer only with reachable", async () => {
-		const quiet = inputs();
-		await doctor(quiet);
-		expect((quiet.http as ReturnType<typeof fakeHttp>).requests).not.toContain(
-			"/",
-		);
-		const asking = inputs({ reachable: true });
-		await doctor(asking);
-		expect((asking.http as ReturnType<typeof fakeHttp>).requests).toContain(
-			"/",
-		);
-	});
-});
-
-describe("start", () => {
-	const launched = () => {
-		const seen: DefinedRoundtable[] = [];
-		return {
-			seen,
-			launch: async (defined: DefinedRoundtable) => void seen.push(defined),
-		};
-	};
-
-	test("runs only the checks that need no network, then starts the bot", async () => {
-		const http = fakeHttp({});
-		const { seen, launch } = launched();
-		const report = await start({ ...inputs({ http }), launch });
-		expect(report.started).toBe(true);
-		expect(seen).toHaveLength(1);
-		expect(http.requests).toEqual([]);
-		expect(report.outcomes.map(({ name }) => name)).toEqual([
-			"Bun",
-			"environment",
-			"configuration",
-			"plugins",
-			"model login",
-			"public URL",
-		]);
-	});
-
-	test("a failing check stops it before anything launches, with the message doctor prints", async () => {
-		const failing = inputs({
-			ports: fakePorts(validConfig, { login: async () => undefined }),
-		});
-		const { seen, launch } = launched();
-		const started = await start({ ...failing, launch });
-		expect(started.started).toBe(false);
-		expect(seen).toEqual([]);
-		const fromDoctor = (await doctor(failing)).outcomes.find(
-			({ name }) => name === "model login",
-		);
-		const fromStart = started.outcomes.find(
-			({ name }) => name === "model login",
-		);
-		expect(fromStart).toEqual(fromDoctor as NonNullable<typeof fromDoctor>);
-	});
-
-	test("does not touch the network when the configuration is wrong", async () => {
-		const http = fakeHttp({});
-		const { seen, launch } = launched();
-		const report = await start({
-			...inputs({ ports: fakePorts({}), http }),
-			launch,
-		});
-		expect(report.started).toBe(false);
-		expect(seen).toEqual([]);
-		expect(http.requests).toEqual([]);
-	});
-});

package/src/cli/init.test.ts

@@ -1,127 +0,0 @@
-import { afterEach, expect, test } from "bun:test";
-import { existsSync, readdirSync, readFileSync } from "node:fs";
-import { join } from "node:path";
-import { BUN_INSTALL_PAGE } from "./checks/bun.ts";
-import { init } from "./init.ts";
-import { tempDir } from "./testing/fixtures.ts";
-
-const dirs: ReturnType<typeof tempDir>[] = [];
-afterEach(() => {
-	for (const dir of dirs.splice(0)) dir.done();
-});
-const temp = () => {
-	const dir = tempDir();
-	dirs.push(dir);
-	return dir;
-};
-
-const bun = { version: "1.3.10", required: ">=1.3.0" };
-
-const everything = (dir: string): string[] =>
-	readdirSync(dir, { recursive: true, withFileTypes: true })
-		.filter((entry) => entry.isFile())
-		.map((entry) => join(entry.parentPath, entry.name).slice(dir.length + 1))
-		.sort();
-
-test("init writes the skeleton and the hello plugin, pins the version, and prints three next steps", () => {
-	const dir = temp();
-	const report = init({ cwd: dir.path, dir: "bot", bun, version: "1.2.3" });
-	expect(report.ok).toBe(true);
-	expect(everything(join(dir.path, "bot"))).toEqual(
-		[
-			".env.example",
-			".gitignore",
-			"README.md",
-			"agents.ts",
-			"biome.json",
-			"docker-compose.yml",
-			"package.json",
-			"persona/shared.md",
-			"plugins/hello.test.ts",
-			"plugins/hello.ts",
-			"roundtable.config.ts",
-			"tsconfig.json",
-		].sort(),
-	);
-	expect([...report.created].sort()).toEqual(everything(join(dir.path, "bot")));
-	const manifest = JSON.parse(
-		readFileSync(join(dir.path, "bot/package.json"), "utf8"),
-	) as { name: string; dependencies: Record<string, string> };
-	expect(manifest.name).toBe("bot");
-	expect(manifest.dependencies["pi-roundtable"]).toBe("1.2.3");
-	expect(report.nextSteps).toHaveLength(3);
-	expect(report.nextSteps[0]).toStartWith("cd bot && bun install");
-	expect(report.nextSteps[1]).toContain("roundtable doctor");
-	expect(report.nextSteps[2]).toContain("roundtable start");
-	const hello = readFileSync(join(dir.path, "bot/plugins/hello.ts"), "utf8");
-	expect(hello).toContain('name: "hello"');
-	expect(hello).toContain("hello_greet");
-});
-
-test("init in the current directory needs no cd, and no file keeps a placeholder", () => {
-	const dir = temp();
-	const report = init({ cwd: dir.path, bun, version: "1.2.3" });
-	expect(report.ok).toBe(true);
-	expect(report.nextSteps[0]).toStartWith("bun install");
-	for (const path of everything(dir.path))
-		expect(readFileSync(join(dir.path, path), "utf8")).not.toMatch(
-			/__[A-Z]+__/,
-		);
-});
-
-test("init refuses before writing anything when Bun is missing, naming the install page", () => {
-	const dir = temp();
-	const report = init({
-		cwd: dir.path,
-		bun: { version: undefined, required: ">=1.3.0" },
-		version: "1.2.3",
-	});
-	expect(report.ok).toBe(false);
-	expect(report.problems.join("\n")).toContain(BUN_INSTALL_PAGE);
-	expect(everything(dir.path)).toEqual([]);
-});
-
-test("init refuses when Bun is older than engines.bun, naming both versions and the page", () => {
-	const dir = temp();
-	const report = init({
-		cwd: dir.path,
-		bun: { version: "1.2.9", required: ">=1.3.0" },
-		version: "1.2.3",
-	});
-	expect(report.ok).toBe(false);
-	const text = report.problems.join("\n");
-	expect(text).toContain("1.2.9");
-	expect(text).toContain(">=1.3.0");
-	expect(text).toContain(BUN_INSTALL_PAGE);
-	expect(everything(dir.path)).toEqual([]);
-});
-
-test("init refuses, listing every file that exists, and writes nothing", () => {
-	const dir = temp();
-	dir.write("roundtable.config.ts", "// mine");
-	dir.write("plugins/hello.ts", "// mine");
-	const before = everything(dir.path);
-	const report = init({ cwd: dir.path, bun, version: "1.2.3" });
-	expect(report.ok).toBe(false);
-	const text = report.problems.join("\n");
-	expect(text).toContain("roundtable.config.ts");
-	expect(text).toContain("plugins/hello.ts");
-	expect(text).not.toContain("package.json");
-	expect(everything(dir.path)).toEqual(before);
-	expect(readFileSync(join(dir.path, "roundtable.config.ts"), "utf8")).toBe(
-		"// mine",
-	);
-	expect(existsSync(join(dir.path, "package.json"))).toBe(false);
-});
-
-test("the generated configuration reads credentials from the environment and holds none", () => {
-	const dir = temp();
-	init({ cwd: dir.path, bun, version: "1.2.3" });
-	const config = readFileSync(join(dir.path, "roundtable.config.ts"), "utf8");
-	expect(config).toContain("process.env");
-	for (const key of ["DISCORD_TOKEN", "DATABASE_URL", "OWNER_ID", "MODEL"])
-		expect(config).toContain(`env("${key}")`);
-	expect(config).not.toMatch(/\d{15,}/);
-	expect(config).not.toMatch(/token:\s*"/);
-	expect(readFileSync(join(dir.path, ".gitignore"), "utf8")).toContain(".env");
-});

package/src/cli/size.test.ts

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