@rumen.rusanov/pi-github 0.1.0

package/src/ui/rows.ts

@@ -0,0 +1,98 @@
+import { truncateToWidth } from "@earendil-works/pi-tui";
+import { relativeTime } from "../format.ts";
+import type { CheckState, IssueSummary, PullRequestSummary } from "../types.ts";
+
+export interface PrRowPlan {
+  number: number;
+  title: string;
+  author: string;
+  isDraft: boolean;
+  checkState: CheckState | "none";
+  approvals: number;
+  changesRequested: number;
+  updated: string;
+}
+
+export interface IssueRowPlan {
+  number: number;
+  title: string;
+  author: string;
+  commentCount: number;
+  labels: string[];
+  updated: string;
+}
+
+export interface PrRowLines {
+  symbol: string;
+  title: string;
+  meta: string;
+}
+
+export interface IssueRowLines {
+  title: string;
+  meta: string;
+}
+
+const CHECK_SYMBOL: Record<CheckState | "none", string> = {
+  pass: "✓",
+  fail: "✗",
+  pending: "●",
+  none: "●",
+};
+
+const CHECK_COLOR: Record<CheckState | "none", "success" | "error" | "warning" | "dim"> = {
+  pass: "success",
+  fail: "error",
+  pending: "warning",
+  none: "warning",
+};
+
+export function buildPrRowPlan(pr: PullRequestSummary, now: Date = new Date()): PrRowPlan {
+  return {
+    number: pr.number,
+    title: pr.title,
+    author: pr.author,
+    isDraft: pr.isDraft,
+    checkState: pr.checkState,
+    approvals: pr.approvals,
+    changesRequested: pr.changesRequested,
+    updated: relativeTime(pr.updatedAt, now),
+  };
+}
+
+export function buildIssueRowPlan(issue: IssueSummary, now: Date = new Date()): IssueRowPlan {
+  return {
+    number: issue.number,
+    title: issue.title,
+    author: issue.author,
+    commentCount: issue.commentCount,
+    labels: issue.labels,
+    updated: relativeTime(issue.updatedAt, now),
+  };
+}
+
+export function prStatusColor(plan: PrRowPlan): "success" | "error" | "warning" | "dim" {
+  return CHECK_COLOR[plan.checkState];
+}
+
+/** Row indent used for the meta line, matching the "<symbol> " prefix width on the title line. */
+const ROW_INDENT = 2;
+
+/** Lays out a PR as two plain-text lines: title (with status symbol) and a dim meta line below it. Neither line exceeds `width`. */
+export function layoutPrRowLines(plan: PrRowPlan, width: number): PrRowLines {
+  const symbol = CHECK_SYMBOL[plan.checkState];
+  const titleRaw = `${plan.title}${plan.isDraft ? "  [draft]" : ""}`;
+  const title = truncateToWidth(titleRaw, Math.max(1, width - ROW_INDENT));
+  const metaRaw = `#${plan.number} · @${plan.author} · ✓${plan.approvals}/✗${plan.changesRequested} · ${plan.updated}`;
+  const meta = truncateToWidth(metaRaw, Math.max(1, width - ROW_INDENT));
+  return { symbol, title, meta };
+}
+
+/** Lays out an Issue as two plain-text lines: title and a dim meta line below it. Neither line exceeds `width`. */
+export function layoutIssueRowLines(plan: IssueRowPlan, width: number): IssueRowLines {
+  const title = truncateToWidth(plan.title, width);
+  const labels = plan.labels.length > 0 ? ` · ${plan.labels.join(",")}` : "";
+  const metaRaw = `#${plan.number} · @${plan.author} · 💬${plan.commentCount}${labels} · ${plan.updated}`;
+  const meta = truncateToWidth(metaRaw, width);
+  return { title, meta };
+}

package/src/ui/two-line-list.ts

@@ -0,0 +1,78 @@
+export interface TwoLineListItem<T> {
+	value: string;
+	data: T;
+}
+
+export interface TwoLineListOptions<T> {
+	/** Renders an item's two lines. Output should already be themed but not padded/highlighted. */
+	renderRow: (item: T, isSelected: boolean, width: number) => [string, string];
+	/** Pads a line to `width` and applies the selection background. */
+	highlightRow: (line: string, width: number) => string;
+	/** Styles the "(i/n)" indicator shown when the list is scrolled. */
+	scrollInfo?: (text: string) => string;
+}
+
+/** A `SelectList`-like widget where each item renders as two lines (title + meta) instead of one. */
+export class TwoLineList<T> {
+	private selectedIndex = 0;
+
+	onSelectionChange?: (item: TwoLineListItem<T>) => void;
+
+	constructor(
+		private readonly items: TwoLineListItem<T>[],
+		private readonly maxVisible: number,
+		private readonly options: TwoLineListOptions<T>,
+	) {}
+
+	setSelectedIndex(index: number): void {
+		this.selectedIndex = Math.max(0, Math.min(index, this.items.length - 1));
+	}
+
+	getSelectedItem(): TwoLineListItem<T> | null {
+		return this.items[this.selectedIndex] ?? null;
+	}
+
+	moveUp(): void {
+		if (this.items.length === 0) return;
+		this.selectedIndex = this.selectedIndex === 0 ? this.items.length - 1 : this.selectedIndex - 1;
+		this.notifySelectionChange();
+	}
+
+	moveDown(): void {
+		if (this.items.length === 0) return;
+		this.selectedIndex = this.selectedIndex === this.items.length - 1 ? 0 : this.selectedIndex + 1;
+		this.notifySelectionChange();
+	}
+
+	render(width: number): string[] {
+		if (this.items.length === 0) return [];
+
+		const maxVisible = Math.max(1, this.maxVisible);
+		const startIndex = Math.max(0, Math.min(this.selectedIndex - Math.floor(maxVisible / 2), Math.max(0, this.items.length - maxVisible)));
+		const endIndex = Math.min(startIndex + maxVisible, this.items.length);
+
+		const lines: string[] = [];
+		for (let i = startIndex; i < endIndex; i++) {
+			const item = this.items[i];
+			if (!item) continue;
+			const isSelected = i === this.selectedIndex;
+			const [line1, line2] = this.options.renderRow(item.data, isSelected, width);
+			if (isSelected) {
+				lines.push(this.options.highlightRow(line1, width), this.options.highlightRow(line2, width));
+			} else {
+				lines.push(line1, line2);
+			}
+		}
+
+		if ((startIndex > 0 || endIndex < this.items.length) && this.options.scrollInfo) {
+			lines.push(this.options.scrollInfo(`  (${this.selectedIndex + 1}/${this.items.length})`));
+		}
+
+		return lines;
+	}
+
+	private notifySelectionChange(): void {
+		const item = this.getSelectedItem();
+		if (item && this.onSelectionChange) this.onSelectionChange(item);
+	}
+}

package/tests/app.test.ts

@@ -0,0 +1,235 @@
+import { describe, expect, it, vi } from "vitest";
+import { GithubApp, type AppOptions, type AppUI } from "../src/ui/app.ts";
+import type { ExecFn } from "../src/types.ts";
+
+function flush(): Promise<void> {
+	return new Promise((resolve) => setTimeout(resolve, 0));
+}
+
+const fakeTheme = {
+	fg: (_c: string, t: string) => t,
+	bg: (_c: string, t: string) => t,
+	bold: (t: string) => t,
+	italic: (t: string) => t,
+	underline: (t: string) => t,
+	inverse: (t: string) => t,
+	strikethrough: (t: string) => t,
+} as unknown as AppOptions["theme"];
+
+function makeApp(overrides: {
+	exec?: ExecFn;
+	ui?: Partial<AppUI>;
+} = {}) {
+	const done = vi.fn();
+	const requestRender = vi.fn();
+	const tui = { requestRender, terminal: { rows: 40, columns: 100 } } as unknown as AppOptions["tui"];
+
+	const prList = [
+		{
+			number: 1,
+			title: "Fix the login bug",
+			author: { login: "alice" },
+			isDraft: false,
+			updatedAt: "2026-08-01T00:00:00Z",
+			statusCheckRollup: [],
+			latestReviews: [],
+		},
+	];
+	const issueList = [
+		{
+			number: 5,
+			title: "Crash on startup",
+			author: { login: "bob" },
+			updatedAt: "2026-08-01T00:00:00Z",
+			comments: [],
+			labels: [],
+		},
+	];
+	const prDetail = {
+		number: 1,
+		title: "Fix the login bug",
+		author: { login: "alice" },
+		state: "OPEN",
+		isDraft: false,
+		labels: [],
+		assignees: [],
+		createdAt: "2026-08-01T00:00:00Z",
+		updatedAt: "2026-08-01T00:00:00Z",
+		body: "This fixes login.",
+		comments: [],
+		baseRefName: "main",
+		headRefName: "fix-login",
+		statusCheckRollup: [],
+		latestReviews: [],
+		files: [],
+	};
+
+	const defaultExec: ExecFn = async (command, args) => {
+		if (command === "gh" && args[0] === "pr" && args[1] === "list") {
+			return { stdout: JSON.stringify(prList), stderr: "", code: 0, killed: false };
+		}
+		if (command === "gh" && args[0] === "issue" && args[1] === "list") {
+			return { stdout: JSON.stringify(issueList), stderr: "", code: 0, killed: false };
+		}
+		if (command === "gh" && args[0] === "pr" && args[1] === "view") {
+			return { stdout: JSON.stringify(prDetail), stderr: "", code: 0, killed: false };
+		}
+		if (command === "gh" && args[0] === "pr" && args[1] === "review") {
+			return { stdout: "", stderr: "", code: 0, killed: false };
+		}
+		if (command === "gh" && args[0] === "api") {
+			return { stdout: "octocat\n", stderr: "", code: 0, killed: false };
+		}
+		return { stdout: "", stderr: `unexpected command: ${command} ${args.join(" ")}`, code: 1, killed: false };
+	};
+
+	const ui: AppUI = {
+		confirm: vi.fn(async () => true),
+		select: vi.fn(async () => undefined),
+		notify: vi.fn(),
+		...overrides.ui,
+	};
+
+	const app = new GithubApp({
+		repo: "owner/repo",
+		cwd: "/repo",
+		exec: overrides.exec ?? defaultExec,
+		limit: 20,
+		ui,
+		theme: fakeTheme,
+		tui,
+		done,
+	});
+
+	return { app, done, ui, tui };
+}
+
+describe("GithubApp", () => {
+	it("renders without throwing before data has loaded", () => {
+		const { app } = makeApp();
+		const lines = app.render(80);
+		expect(lines.length).toBeGreaterThan(0);
+		for (const line of lines) {
+			expect(line.length).toBeLessThanOrEqual(80 + 20); // allow for ANSI codes in fake theme (no-ops here, so exact)
+		}
+	});
+
+	it("shows PR rows after the list loads", async () => {
+		const { app } = makeApp();
+		await flush();
+		const text = app.render(120).join("\n");
+		expect(text).toContain("owner/repo");
+		expect(text).toContain("#1");
+		expect(text).toContain("Fix the login bug");
+	});
+
+	it("switches to Issues on Tab and loads issue rows", async () => {
+		const { app } = makeApp();
+		await flush();
+		app.handleInput("\t");
+		await flush();
+		const text = app.render(120).join("\n");
+		expect(text).toContain("#5");
+		expect(text).toContain("Crash on startup");
+	});
+
+	it("filters the list by typing, and clearing with escape restores it", async () => {
+		const { app } = makeApp();
+		await flush();
+		app.handleInput("z");
+		app.handleInput("z");
+		app.handleInput("z");
+		let text = app.render(120).join("\n");
+		expect(text).toContain('No matches for "zzz"');
+
+		app.handleInput("\x1b"); // escape clears the filter
+		text = app.render(120).join("\n");
+		expect(text).toContain("Fix the login bug");
+	});
+
+	it("closes on escape when the list is not filtered", async () => {
+		const { app, done } = makeApp();
+		await flush();
+		app.handleInput("\x1b");
+		expect(done).toHaveBeenCalled();
+	});
+
+	it("opens PR detail on enter and shows the body", async () => {
+		const { app } = makeApp();
+		await flush();
+		app.render(120);
+		app.handleInput("\r");
+		await flush();
+		const text = app.render(120).join("\n");
+		expect(text).toContain("Fix the login bug");
+		expect(text).toContain("This fixes login.");
+		expect(text).toContain("approve");
+	});
+
+	it("returns to the list from detail on escape", async () => {
+		const { app } = makeApp();
+		await flush();
+		app.render(120);
+		app.handleInput("\r");
+		await flush();
+		app.handleInput("\x1b");
+		const text = app.render(120).join("\n");
+		expect(text).toContain("owner/repo");
+	});
+
+	it("approves the PR after confirmation", async () => {
+		const exec = vi.fn(async (command: string, args: string[]) => {
+			if (command === "gh" && args[0] === "pr" && args[1] === "list") {
+				return {
+					stdout: JSON.stringify([
+						{ number: 1, title: "Fix the login bug", author: { login: "alice" }, isDraft: false, updatedAt: "2026-08-01T00:00:00Z" },
+					]),
+					stderr: "",
+					code: 0,
+					killed: false,
+				};
+			}
+			if (command === "gh" && args[0] === "pr" && args[1] === "view") {
+				return {
+					stdout: JSON.stringify({
+						number: 1,
+						title: "Fix the login bug",
+						author: { login: "alice" },
+						state: "OPEN",
+						createdAt: "2026-08-01T00:00:00Z",
+						updatedAt: "2026-08-01T00:00:00Z",
+						body: "Body",
+						baseRefName: "main",
+						headRefName: "fix-login",
+					}),
+					stderr: "",
+					code: 0,
+					killed: false,
+				};
+			}
+			if (command === "gh" && args[0] === "api") {
+				return { stdout: "octocat\n", stderr: "", code: 0, killed: false };
+			}
+			if (command === "gh" && args[0] === "pr" && args[1] === "review") {
+				return { stdout: "", stderr: "", code: 0, killed: false };
+			}
+			return { stdout: "", stderr: "unexpected", code: 1, killed: false };
+		});
+
+		const confirm = vi.fn(async () => true);
+		const { app } = makeApp({ exec, ui: { confirm } });
+		await flush();
+		app.render(120);
+		app.handleInput("\r"); // open PR detail
+		await flush();
+		app.handleInput("a"); // approve
+		await flush();
+
+		expect(confirm).toHaveBeenCalledWith("Approve Pull Request", "Approve #1 'Fix the login bug' as @octocat?");
+		expect(exec).toHaveBeenCalledWith(
+			"gh",
+			["pr", "review", "1", "--repo", "owner/repo", "--approve"],
+			expect.objectContaining({ cwd: "/repo" }),
+		);
+	});
+});

package/tests/filter.test.ts

@@ -0,0 +1,41 @@
+import { describe, expect, it } from "vitest";
+import { filterIssues, filterPullRequests } from "../src/ui/filter.ts";
+import type { IssueSummary, PullRequestSummary } from "../src/types.ts";
+
+const prs: PullRequestSummary[] = [
+	{ number: 1, title: "Fix login bug", author: "a", isDraft: false, checkState: "pass", approvals: 0, changesRequested: 0, updatedAt: "2026-08-01T00:00:00Z" },
+	{ number: 2, title: "Add dark mode toggle", author: "b", isDraft: false, checkState: "pass", approvals: 0, changesRequested: 0, updatedAt: "2026-08-01T00:00:00Z" },
+];
+
+const issues: IssueSummary[] = [
+	{ number: 10, title: "Crash on startup", author: "a", commentCount: 0, labels: [], updatedAt: "2026-08-01T00:00:00Z" },
+	{ number: 20, title: "Typo in README", author: "b", commentCount: 0, labels: [], updatedAt: "2026-08-01T00:00:00Z" },
+];
+
+describe("filterPullRequests", () => {
+	it("returns everything for an empty query", () => {
+		expect(filterPullRequests(prs, "")).toEqual(prs);
+	});
+
+	it("fuzzy-matches by title", () => {
+		expect(filterPullRequests(prs, "dark").map((p) => p.number)).toEqual([2]);
+	});
+
+	it("matches by number", () => {
+		expect(filterPullRequests(prs, "1").map((p) => p.number)).toEqual([1]);
+	});
+
+	it("returns nothing when nothing matches", () => {
+		expect(filterPullRequests(prs, "zzzzz")).toEqual([]);
+	});
+});
+
+describe("filterIssues", () => {
+	it("fuzzy-matches by title", () => {
+		expect(filterIssues(issues, "readme").map((i) => i.number)).toEqual([20]);
+	});
+
+	it("matches by number", () => {
+		expect(filterIssues(issues, "10").map((i) => i.number)).toEqual([10]);
+	});
+});

package/tests/format.test.ts

@@ -0,0 +1,34 @@
+import { describe, expect, it } from "vitest";
+import { relativeTime } from "../src/format.ts";
+
+describe("relativeTime", () => {
+	const now = new Date("2026-09-01T12:00:00Z");
+
+	it("formats seconds", () => {
+		expect(relativeTime("2026-09-01T11:59:30Z", now)).toBe("30s ago");
+	});
+
+	it("formats minutes", () => {
+		expect(relativeTime("2026-09-01T11:45:00Z", now)).toBe("15m ago");
+	});
+
+	it("formats hours", () => {
+		expect(relativeTime("2026-09-01T09:00:00Z", now)).toBe("3h ago");
+	});
+
+	it("formats days", () => {
+		expect(relativeTime("2026-08-29T12:00:00Z", now)).toBe("3d ago");
+	});
+
+	it("formats months", () => {
+		expect(relativeTime("2026-06-01T12:00:00Z", now)).toBe("3mo ago");
+	});
+
+	it("formats years", () => {
+		expect(relativeTime("2024-09-01T12:00:00Z", now)).toBe("2y ago");
+	});
+
+	it("formats just now for sub-second differences", () => {
+		expect(relativeTime("2026-09-01T12:00:00Z", now)).toBe("just now");
+	});
+});

package/tests/gh-cli.test.ts

@@ -0,0 +1,31 @@
+import { describe, expect, it } from "vitest";
+import { checkGhAuthenticated, checkGhInstalled } from "../src/gh-cli.ts";
+import type { ExecFn } from "../src/types.ts";
+
+describe("checkGhInstalled", () => {
+	it("returns ok when gh --version succeeds", async () => {
+		const exec: ExecFn = async () => ({ stdout: "gh version 2.98.0", stderr: "", code: 0, killed: false });
+		expect(await checkGhInstalled(exec)).toEqual({ ok: true });
+	});
+
+	it("returns an error when gh is not found", async () => {
+		const exec: ExecFn = async () => {
+			throw new Error("spawn gh ENOENT");
+		};
+		const result = await checkGhInstalled(exec);
+		expect(result.ok).toBe(false);
+	});
+});
+
+describe("checkGhAuthenticated", () => {
+	it("returns ok when gh auth status exits 0", async () => {
+		const exec: ExecFn = async () => ({ stdout: "Logged in", stderr: "", code: 0, killed: false });
+		expect(await checkGhAuthenticated(exec, "/cwd")).toEqual({ ok: true });
+	});
+
+	it("returns an error when gh auth status exits non-zero", async () => {
+		const exec: ExecFn = async () => ({ stdout: "", stderr: "not logged in", code: 1, killed: false });
+		const result = await checkGhAuthenticated(exec, "/cwd");
+		expect(result.ok).toBe(false);
+	});
+});