@rumen.rusanov/pi-github 0.1.0

package/tests/gh-data.test.ts

@@ -0,0 +1,259 @@
+import { describe, expect, it, vi } from "vitest";
+import {
+	approvePullRequest,
+	fetchIssueDetail,
+	fetchIssues,
+	fetchPullRequestDetail,
+	fetchPullRequests,
+	getAllowedMergeMethods,
+	getCurrentAccount,
+	mergePullRequest,
+} from "../src/gh-data.ts";
+import type { ExecFn, ExecResult } from "../src/types.ts";
+
+function jsonExec(stdout: unknown): ExecFn {
+	return async () => ({ stdout: JSON.stringify(stdout), stderr: "", code: 0, killed: false });
+}
+
+function failingExec(stderr: string, code = 1): ExecFn {
+	return async () => ({ stdout: "", stderr, code, killed: false });
+}
+
+const ok = (over: Partial<ExecResult> = {}): ExecResult => ({ stdout: "", stderr: "", code: 0, killed: false, ...over });
+
+describe("fetchPullRequests", () => {
+	it("maps fields, computes check state, review counts, and sorts most-recently-updated first", async () => {
+		const exec = jsonExec([
+			{
+				number: 1,
+				title: "Older PR",
+				author: { login: "alice" },
+				isDraft: false,
+				updatedAt: "2026-08-01T00:00:00Z",
+				statusCheckRollup: [{ __typename: "CheckRun", status: "COMPLETED", conclusion: "SUCCESS", name: "build" }],
+				latestReviews: [{ author: { login: "bob" }, state: "APPROVED" }],
+			},
+			{
+				number: 2,
+				title: "Newer PR",
+				author: { login: "carol" },
+				isDraft: true,
+				updatedAt: "2026-08-15T00:00:00Z",
+				statusCheckRollup: [{ __typename: "CheckRun", status: "IN_PROGRESS", name: "build" }],
+				latestReviews: [{ author: { login: "dave" }, state: "CHANGES_REQUESTED" }],
+			},
+		]);
+
+		const result = await fetchPullRequests(exec, { repo: "owner/repo", cwd: "/repo", limit: 20 });
+		expect(result.ok).toBe(true);
+		if (!result.ok) return;
+
+		expect(result.data.map((pr) => pr.number)).toEqual([2, 1]);
+		expect(result.data[0]).toMatchObject({
+			number: 2,
+			title: "Newer PR",
+			author: "carol",
+			isDraft: true,
+			checkState: "pending",
+			changesRequested: 1,
+			approvals: 0,
+		});
+		expect(result.data[1]).toMatchObject({
+			checkState: "pass",
+			approvals: 1,
+			changesRequested: 0,
+		});
+	});
+
+	it("reports checkState 'none' when there are no checks", async () => {
+		const exec = jsonExec([
+			{ number: 1, title: "PR", author: { login: "a" }, updatedAt: "2026-08-01T00:00:00Z", statusCheckRollup: [] },
+		]);
+		const result = await fetchPullRequests(exec, { repo: "owner/repo", cwd: "/repo", limit: 20 });
+		expect(result.ok).toBe(true);
+		if (result.ok) expect(result.data[0]?.checkState).toBe("none");
+	});
+
+	it("reports checkState 'fail' when any check failed", async () => {
+		const exec = jsonExec([
+			{
+				number: 1,
+				title: "PR",
+				author: { login: "a" },
+				updatedAt: "2026-08-01T00:00:00Z",
+				statusCheckRollup: [
+					{ __typename: "CheckRun", status: "COMPLETED", conclusion: "SUCCESS", name: "lint" },
+					{ __typename: "CheckRun", status: "COMPLETED", conclusion: "FAILURE", name: "test" },
+				],
+			},
+		]);
+		const result = await fetchPullRequests(exec, { repo: "owner/repo", cwd: "/repo", limit: 20 });
+		expect(result.ok).toBe(true);
+		if (result.ok) expect(result.data[0]?.checkState).toBe("fail");
+	});
+
+	it("returns an error when gh fails", async () => {
+		const result = await fetchPullRequests(failingExec("boom"), { repo: "owner/repo", cwd: "/repo", limit: 20 });
+		expect(result).toEqual({ ok: false, error: "boom" });
+	});
+
+	it("returns an empty list for a repo with zero open PRs", async () => {
+		const result = await fetchPullRequests(jsonExec([]), { repo: "owner/repo", cwd: "/repo", limit: 20 });
+		expect(result).toEqual({ ok: true, data: [] });
+	});
+});
+
+describe("fetchIssues", () => {
+	it("maps fields including comment count and labels", async () => {
+		const exec = jsonExec([
+			{
+				number: 5,
+				title: "Bug",
+				author: { login: "eve" },
+				updatedAt: "2026-08-20T00:00:00Z",
+				comments: [{ author: { login: "x" }, body: "hi", createdAt: "2026-08-20T01:00:00Z" }],
+				labels: [{ name: "bug" }, { name: "p1" }],
+			},
+		]);
+		const result = await fetchIssues(exec, { repo: "owner/repo", cwd: "/repo", limit: 20 });
+		expect(result.ok).toBe(true);
+		if (result.ok) {
+			expect(result.data[0]).toMatchObject({
+				number: 5,
+				title: "Bug",
+				author: "eve",
+				commentCount: 1,
+				labels: ["bug", "p1"],
+			});
+		}
+	});
+});
+
+describe("fetchPullRequestDetail", () => {
+	it("maps full detail including checks, reviews, files, and comments", async () => {
+		const exec = jsonExec({
+			number: 9,
+			title: "Fix login bug",
+			author: { login: "alice" },
+			state: "OPEN",
+			isDraft: false,
+			labels: [{ name: "bug" }],
+			assignees: [{ login: "bob" }],
+			createdAt: "2026-08-01T00:00:00Z",
+			updatedAt: "2026-08-02T00:00:00Z",
+			body: "Fixes the thing.",
+			comments: [{ author: { login: "carol" }, body: "LGTM", createdAt: "2026-08-02T01:00:00Z" }],
+			baseRefName: "main",
+			headRefName: "fix-login",
+			statusCheckRollup: [{ __typename: "CheckRun", status: "COMPLETED", conclusion: "SUCCESS", name: "ci" }],
+			latestReviews: [{ author: { login: "dave" }, state: "APPROVED" }],
+			files: [{ path: "src/login.ts", additions: 10, deletions: 2 }],
+		});
+
+		const result = await fetchPullRequestDetail(exec, { repo: "owner/repo", cwd: "/repo", number: 9 });
+		expect(result.ok).toBe(true);
+		if (!result.ok) return;
+
+		expect(result.data).toMatchObject({
+			number: 9,
+			title: "Fix login bug",
+			author: "alice",
+			baseRefName: "main",
+			headRefName: "fix-login",
+			checks: [{ name: "ci", state: "pass" }],
+			reviews: [{ author: "dave", state: "APPROVED" }],
+			files: [{ path: "src/login.ts", additions: 10, deletions: 2 }],
+			comments: [{ author: "carol", body: "LGTM", createdAt: "2026-08-02T01:00:00Z" }],
+		});
+	});
+});
+
+describe("fetchIssueDetail", () => {
+	it("maps full detail without PR-specific fields", async () => {
+		const exec = jsonExec({
+			number: 3,
+			title: "Crash on start",
+			author: { login: "alice" },
+			state: "OPEN",
+			labels: [{ name: "bug" }],
+			assignees: [],
+			createdAt: "2026-08-01T00:00:00Z",
+			updatedAt: "2026-08-02T00:00:00Z",
+			body: "It crashes.",
+			comments: [{ author: { login: "bob" }, body: "Repro?", createdAt: "2026-08-02T01:00:00Z" }],
+		});
+
+		const result = await fetchIssueDetail(exec, { repo: "owner/repo", cwd: "/repo", number: 3 });
+		expect(result.ok).toBe(true);
+		if (result.ok) {
+			expect(result.data.title).toBe("Crash on start");
+			expect(result.data.comments).toEqual([{ author: "bob", body: "Repro?", createdAt: "2026-08-02T01:00:00Z" }]);
+		}
+	});
+});
+
+describe("getAllowedMergeMethods", () => {
+	it("returns only the allowed methods, in squash/merge/rebase order", async () => {
+		const exec = jsonExec({ squashMergeAllowed: true, mergeCommitAllowed: false, rebaseMergeAllowed: true });
+		const result = await getAllowedMergeMethods(exec, { repo: "owner/repo", cwd: "/repo" });
+		expect(result).toEqual({ ok: true, data: ["squash", "rebase"] });
+	});
+});
+
+describe("approvePullRequest", () => {
+	it("calls gh pr review --approve and succeeds", async () => {
+		const exec = vi.fn(async () => ok());
+		const result = await approvePullRequest(exec, { repo: "owner/repo", cwd: "/repo", number: 42 });
+		expect(result).toEqual({ ok: true, data: true });
+		expect(exec).toHaveBeenCalledWith(
+			"gh",
+			["pr", "review", "42", "--repo", "owner/repo", "--approve"],
+			expect.objectContaining({ cwd: "/repo" }),
+		);
+	});
+
+	it("surfaces gh's error on failure", async () => {
+		const result = await approvePullRequest(failingExec("review required"), { repo: "owner/repo", cwd: "/repo", number: 42 });
+		expect(result).toEqual({ ok: false, error: "review required" });
+	});
+});
+
+describe("mergePullRequest", () => {
+	it("passes the correct flag for each merge method", async () => {
+		const exec = vi.fn(async () => ok());
+		await mergePullRequest(exec, { repo: "owner/repo", cwd: "/repo", number: 7, method: "squash" });
+		expect(exec).toHaveBeenLastCalledWith(
+			"gh",
+			["pr", "merge", "7", "--repo", "owner/repo", "--squash"],
+			expect.objectContaining({ cwd: "/repo" }),
+		);
+
+		await mergePullRequest(exec, { repo: "owner/repo", cwd: "/repo", number: 7, method: "rebase" });
+		expect(exec).toHaveBeenLastCalledWith(
+			"gh",
+			["pr", "merge", "7", "--repo", "owner/repo", "--rebase"],
+			expect.objectContaining({ cwd: "/repo" }),
+		);
+	});
+
+	it("surfaces gh's error on a blocked merge", async () => {
+		const result = await mergePullRequest(failingExec("required checks pending"), {
+			repo: "owner/repo",
+			cwd: "/repo",
+			number: 7,
+			method: "merge",
+		});
+		expect(result).toEqual({ ok: false, error: "required checks pending" });
+	});
+});
+
+describe("getCurrentAccount", () => {
+	it("returns the trimmed login on success", async () => {
+		const exec: ExecFn = async () => ({ stdout: "octocat\n", stderr: "", code: 0, killed: false });
+		expect(await getCurrentAccount(exec, "/repo")).toBe("octocat");
+	});
+
+	it("returns undefined on failure", async () => {
+		expect(await getCurrentAccount(failingExec("not logged in"), "/repo")).toBeUndefined();
+	});
+});

package/tests/messages.test.ts

@@ -0,0 +1,24 @@
+import { describe, expect, it } from "vitest";
+import { approveConfirmMessage, mergeConfirmMessage, mergeMethodLabel } from "../src/ui/messages.ts";
+
+describe("approveConfirmMessage", () => {
+	it("names the PR number, title, and acting account", () => {
+		const message = approveConfirmMessage({ number: 123, title: "Fix login bug" }, "octocat");
+		expect(message).toBe("Approve #123 'Fix login bug' as @octocat?");
+	});
+});
+
+describe("mergeMethodLabel", () => {
+	it("labels each merge method", () => {
+		expect(mergeMethodLabel("squash")).toBe("Squash and merge");
+		expect(mergeMethodLabel("merge")).toBe("Merge");
+		expect(mergeMethodLabel("rebase")).toBe("Rebase and merge");
+	});
+});
+
+describe("mergeConfirmMessage", () => {
+	it("names the PR number, title, method, base branch, and acting account", () => {
+		const message = mergeConfirmMessage({ number: 123, title: "Fix login bug", baseRefName: "main" }, "squash", "octocat");
+		expect(message).toBe("Squash and merge #123 'Fix login bug' into main as @octocat?");
+	});
+});

package/tests/repo.test.ts

@@ -0,0 +1,76 @@
+import { describe, expect, it } from "vitest";
+import { detectRepo, parseGitHubRemote, pickRemoteUrl } from "../src/repo.ts";
+import type { ExecFn } from "../src/types.ts";
+
+describe("parseGitHubRemote", () => {
+	it("parses an https remote", () => {
+		expect(parseGitHubRemote("https://github.com/owner/repo.git")).toBe("owner/repo");
+	});
+
+	it("parses an https remote without .git suffix", () => {
+		expect(parseGitHubRemote("https://github.com/owner/repo")).toBe("owner/repo");
+	});
+
+	it("parses an ssh remote", () => {
+		expect(parseGitHubRemote("git@github.com:owner/repo.git")).toBe("owner/repo");
+	});
+
+	it("parses an ssh:// remote", () => {
+		expect(parseGitHubRemote("ssh://git@github.com/owner/repo.git")).toBe("owner/repo");
+	});
+
+	it("returns undefined for a non-GitHub remote", () => {
+		expect(parseGitHubRemote("https://gitlab.com/owner/repo.git")).toBeUndefined();
+	});
+});
+
+describe("pickRemoteUrl", () => {
+	it("prefers origin when multiple remotes are present", () => {
+		const output = [
+			"upstream\thttps://github.com/upstream-owner/repo.git (fetch)",
+			"upstream\thttps://github.com/upstream-owner/repo.git (push)",
+			"origin\thttps://github.com/owner/repo.git (fetch)",
+			"origin\thttps://github.com/owner/repo.git (push)",
+		].join("\n");
+		expect(pickRemoteUrl(output)).toBe("https://github.com/owner/repo.git");
+	});
+
+	it("falls back to the first remote when there is no origin", () => {
+		const output = ["upstream\thttps://github.com/owner/repo.git (fetch)"].join("\n");
+		expect(pickRemoteUrl(output)).toBe("https://github.com/owner/repo.git");
+	});
+
+	it("returns undefined for empty output", () => {
+		expect(pickRemoteUrl("")).toBeUndefined();
+	});
+});
+
+describe("detectRepo", () => {
+	it("returns the repo when git remote resolves to GitHub", async () => {
+		const exec: ExecFn = async () => ({
+			stdout: "origin\thttps://github.com/owner/repo.git (fetch)\norigin\thttps://github.com/owner/repo.git (push)\n",
+			stderr: "",
+			code: 0,
+			killed: false,
+		});
+		const result = await detectRepo(exec, "/some/dir");
+		expect(result).toEqual({ ok: true, repo: "owner/repo" });
+	});
+
+	it("fails when cwd is not a git repository", async () => {
+		const exec: ExecFn = async () => ({ stdout: "", stderr: "not a git repository", code: 128, killed: false });
+		const result = await detectRepo(exec, "/some/dir");
+		expect(result.ok).toBe(false);
+	});
+
+	it("fails when there is no GitHub remote", async () => {
+		const exec: ExecFn = async () => ({
+			stdout: "origin\thttps://gitlab.com/owner/repo.git (fetch)\n",
+			stderr: "",
+			code: 0,
+			killed: false,
+		});
+		const result = await detectRepo(exec, "/some/dir");
+		expect(result.ok).toBe(false);
+	});
+});

package/tests/rows.test.ts

@@ -0,0 +1,90 @@
+import { visibleWidth } from "@earendil-works/pi-tui";
+import { describe, expect, it } from "vitest";
+import {
+	buildIssueRowPlan,
+	buildPrRowPlan,
+	layoutIssueRowLines,
+	layoutPrRowLines,
+	prStatusColor,
+} from "../src/ui/rows.ts";
+import type { IssueSummary, PullRequestSummary } from "../src/types.ts";
+
+const now = new Date("2026-09-01T12:00:00Z");
+
+const basePr: PullRequestSummary = {
+	number: 42,
+	title: "Fix the login bug that was very very long indeed",
+	author: "alice",
+	isDraft: false,
+	checkState: "pass",
+	approvals: 2,
+	changesRequested: 0,
+	updatedAt: "2026-09-01T09:00:00Z",
+};
+
+const baseIssue: IssueSummary = {
+	number: 7,
+	title: "Crash on startup when config is missing entirely somehow",
+	author: "bob",
+	commentCount: 3,
+	labels: ["bug", "p1"],
+	updatedAt: "2026-09-01T10:00:00Z",
+};
+
+describe("buildPrRowPlan / layoutPrRowLines", () => {
+	it("puts the check symbol and title on the first line, and number/author/time on the second", () => {
+		const plan = buildPrRowPlan(basePr, now);
+		const { symbol, title, meta } = layoutPrRowLines(plan, 100);
+		expect(symbol).toBe("✓");
+		expect(title).toContain("Fix the login bug");
+		expect(meta).toContain("#42");
+		expect(meta).toContain("@alice");
+		expect(meta).toContain("3h ago");
+	});
+
+	it("shows a draft indicator on the title only when the PR is a draft", () => {
+		const draft = layoutPrRowLines(buildPrRowPlan({ ...basePr, isDraft: true }, now), 100);
+		expect(draft.title).toContain("draft");
+
+		const ready = layoutPrRowLines(buildPrRowPlan({ ...basePr, isDraft: false }, now), 100);
+		expect(ready.title).not.toContain("draft");
+	});
+
+	it("shows review counts in the meta line", () => {
+		const { meta } = layoutPrRowLines(buildPrRowPlan({ ...basePr, approvals: 2, changesRequested: 1 }, now), 100);
+		expect(meta).toContain("2");
+		expect(meta).toContain("1");
+	});
+
+	it("never lets the title or meta line exceed the requested width", () => {
+		const { title, meta } = layoutPrRowLines(buildPrRowPlan(basePr, now), 40);
+		expect(visibleWidth(title)).toBeLessThanOrEqual(40);
+		expect(visibleWidth(meta)).toBeLessThanOrEqual(40);
+	});
+
+	it("maps check state to a status color key", () => {
+		expect(prStatusColor(buildPrRowPlan({ ...basePr, checkState: "fail" }, now))).toBe("error");
+		expect(prStatusColor(buildPrRowPlan({ ...basePr, checkState: "pending" }, now))).toBe("warning");
+		expect(prStatusColor(buildPrRowPlan({ ...basePr, checkState: "pass" }, now))).toBe("success");
+		expect(prStatusColor(buildPrRowPlan({ ...basePr, checkState: "none" }, now))).toBe("warning");
+	});
+});
+
+describe("buildIssueRowPlan / layoutIssueRowLines", () => {
+	it("puts the title on the first line, and number/author/comments/labels/time on the second", () => {
+		const { title, meta } = layoutIssueRowLines(buildIssueRowPlan(baseIssue, now), 100);
+		expect(title).toContain("Crash on startup");
+		expect(meta).toContain("#7");
+		expect(meta).toContain("@bob");
+		expect(meta).toContain("3");
+		expect(meta).toContain("bug");
+		expect(meta).toContain("p1");
+		expect(meta).toContain("2h ago");
+	});
+
+	it("never lets the title or meta line exceed the requested width", () => {
+		const { title, meta } = layoutIssueRowLines(buildIssueRowPlan(baseIssue, now), 30);
+		expect(visibleWidth(title)).toBeLessThanOrEqual(30);
+		expect(visibleWidth(meta)).toBeLessThanOrEqual(30);
+	});
+});

package/tests/settings.test.ts

@@ -0,0 +1,54 @@
+import { describe, expect, it } from "vitest";
+import { DEFAULT_FETCH_LIMIT, getFetchLimit } from "../src/settings.ts";
+
+function readFileFrom(files: Record<string, string>) {
+	return async (path: string) => {
+		const content = files[path];
+		if (content === undefined) {
+			const error = new Error(`ENOENT: ${path}`) as NodeJS.ErrnoException;
+			error.code = "ENOENT";
+			throw error;
+		}
+		return content;
+	};
+}
+
+describe("getFetchLimit", () => {
+	it("falls back to the default when no settings files exist", async () => {
+		const limit = await getFetchLimit({ cwd: "/repo", home: "/home/user", readFile: readFileFrom({}) });
+		expect(limit).toBe(DEFAULT_FETCH_LIMIT);
+	});
+
+	it("reads the fetch limit from global settings", async () => {
+		const readFile = readFileFrom({
+			"/home/user/.pi/agent/settings.json": JSON.stringify({ "pi-github": { fetchLimit: 50 } }),
+		});
+		const limit = await getFetchLimit({ cwd: "/repo", home: "/home/user", readFile });
+		expect(limit).toBe(50);
+	});
+
+	it("prefers project settings over global settings", async () => {
+		const readFile = readFileFrom({
+			"/home/user/.pi/agent/settings.json": JSON.stringify({ "pi-github": { fetchLimit: 50 } }),
+			"/repo/.pi/settings.json": JSON.stringify({ "pi-github": { fetchLimit: 5 } }),
+		});
+		const limit = await getFetchLimit({ cwd: "/repo", home: "/home/user", readFile });
+		expect(limit).toBe(5);
+	});
+
+	it("ignores malformed JSON and falls back to the default", async () => {
+		const readFile = readFileFrom({
+			"/repo/.pi/settings.json": "{ not json",
+		});
+		const limit = await getFetchLimit({ cwd: "/repo", home: "/home/user", readFile });
+		expect(limit).toBe(DEFAULT_FETCH_LIMIT);
+	});
+
+	it("ignores a non-positive-integer fetchLimit and falls back to the default", async () => {
+		const readFile = readFileFrom({
+			"/repo/.pi/settings.json": JSON.stringify({ "pi-github": { fetchLimit: -3 } }),
+		});
+		const limit = await getFetchLimit({ cwd: "/repo", home: "/home/user", readFile });
+		expect(limit).toBe(DEFAULT_FETCH_LIMIT);
+	});
+});

package/tests/two-line-list.test.ts

@@ -0,0 +1,62 @@
+import { describe, expect, it } from "vitest";
+import { TwoLineList } from "../src/ui/two-line-list.ts";
+
+function makeList(count: number, maxVisible: number) {
+	const items = Array.from({ length: count }, (_, i) => ({ value: String(i), data: `item-${i}` }));
+	return new TwoLineList(items, maxVisible, {
+		renderRow: (data, isSelected) => [`${isSelected ? "SEL:" : ""}${data}:line1`, `${isSelected ? "SEL:" : ""}${data}:line2`],
+		highlightRow: (line) => `[HL]${line}[/HL]`,
+		scrollInfo: (t) => `[SCROLL]${t}`,
+	});
+}
+
+describe("TwoLineList", () => {
+	it("starts selection at the first item", () => {
+		const list = makeList(3, 3);
+		expect(list.getSelectedItem()?.value).toBe("0");
+	});
+
+	it("moveDown/moveUp wrap around and fire onSelectionChange", () => {
+		const list = makeList(3, 3);
+		const seen: string[] = [];
+		list.onSelectionChange = (item) => seen.push(item.value);
+
+		list.moveDown();
+		list.moveDown();
+		list.moveDown(); // wraps back to 0
+		expect(seen).toEqual(["1", "2", "0"]);
+
+		list.moveUp(); // wraps to last
+		expect(seen).toEqual(["1", "2", "0", "2"]);
+	});
+
+	it("renders two lines per visible item, marking only the selected item", () => {
+		const list = makeList(2, 2);
+		list.setSelectedIndex(1);
+		const lines = list.render(80);
+		expect(lines).toEqual([
+			"item-0:line1",
+			"item-0:line2",
+			"[HL]SEL:item-1:line1[/HL]",
+			"[HL]SEL:item-1:line2[/HL]",
+		]);
+	});
+
+	it("shows a scroll indicator once items exceed maxVisible", () => {
+		const list = makeList(5, 2);
+		const noScroll = new TwoLineList(
+			Array.from({ length: 2 }, (_, i) => ({ value: String(i), data: `item-${i}` })),
+			2,
+			{ renderRow: (d, s) => [`${s}${d}`, `${s}${d}`], highlightRow: (l) => l, scrollInfo: (t) => `[SCROLL]${t}` },
+		);
+		expect(noScroll.render(80).some((line) => line.includes("SCROLL"))).toBe(false);
+
+		expect(list.render(80).some((line) => line.includes("[SCROLL]"))).toBe(true);
+	});
+
+	it("returns no lines for an empty list", () => {
+		const list = makeList(0, 3);
+		expect(list.render(80)).toEqual([]);
+		expect(list.getSelectedItem()).toBeNull();
+	});
+});

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+	"compilerOptions": {
+		"target": "ES2022",
+		"module": "ESNext",
+		"moduleResolution": "Bundler",
+		"lib": ["ES2022"],
+		"strict": true,
+		"noUncheckedIndexedAccess": true,
+		"skipLibCheck": true,
+		"esModuleInterop": true,
+		"resolveJsonModule": true,
+		"noEmit": true,
+		"allowImportingTsExtensions": true,
+		"types": ["node"]
+	},
+	"include": ["src", "tests"]
+}

package/vitest.config.ts

@@ -0,0 +1,7 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+	test: {
+		include: ["tests/**/*.test.ts"],
+	},
+});