@f0rbit/overview 0.1.0

package/packages/core/src/git-status.ts

@@ -0,0 +1,316 @@
+import { ok, err, type Result } from "@f0rbit/corpus";
+import { basename, relative } from "node:path";
+import type {
+	RepoStatus,
+	GitFileChange,
+	BranchInfo,
+	StashEntry,
+	HealthStatus,
+} from "./types";
+
+export type GitStatusError =
+	| { kind: "not_a_repo"; path: string }
+	| { kind: "git_failed"; path: string; command: string; cause: string };
+
+async function git(
+	args: string[],
+	cwd: string,
+): Promise<Result<string, GitStatusError>> {
+	const proc = Bun.spawn(["git", ...args], {
+		cwd,
+		stdout: "pipe",
+		stderr: "pipe",
+	});
+
+	await proc.exited;
+
+	if (proc.exitCode !== 0) {
+		const stderr = await new Response(proc.stderr).text();
+		if (
+			stderr.includes("not a git repository") ||
+			stderr.includes("not a git repo")
+		) {
+			return err({ kind: "not_a_repo", path: cwd });
+		}
+		return err({
+			kind: "git_failed",
+			path: cwd,
+			command: `git ${args.join(" ")}`,
+			cause: stderr.trim(),
+		});
+	}
+
+	const stdout = await new Response(proc.stdout).text();
+	return ok(stdout);
+}
+
+function parseFileStatus(line: string): GitFileChange | null {
+	const first_char = line[0];
+	if (!first_char) return null;
+
+	if (first_char === "?") {
+		const path = line.slice(2);
+		return { path, status: "untracked", staged: false };
+	}
+
+	if (first_char === "u") {
+		const parts = line.split("\t");
+		const path = parts[1] ?? line.split(" ").pop() ?? "";
+		return { path, status: "conflicted", staged: false };
+	}
+
+	if (first_char === "1") {
+		const parts = line.split(" ");
+		const xy = parts[1] ?? "..";
+		const path = line.split("\t")[0]?.split(" ").pop() ?? parts.at(-1) ?? "";
+		const staged = xy[0] !== ".";
+		const status = parseXY(xy);
+		return { path, status, staged };
+	}
+
+	if (first_char === "2") {
+		const tab_parts = line.split("\t");
+		const path = tab_parts[2] ?? tab_parts[1] ?? "";
+		const parts = line.split(" ");
+		const xy = parts[1] ?? "..";
+		const staged = xy[0] !== ".";
+		return { path, status: "renamed", staged };
+	}
+
+	return null;
+}
+
+function parseXY(
+	xy: string,
+): GitFileChange["status"] {
+	const x = xy[0] ?? ".";
+	const y = xy[1] ?? ".";
+	const code = x !== "." ? x : y;
+	switch (code) {
+		case "A":
+			return "added";
+		case "D":
+			return "deleted";
+		case "R":
+			return "renamed";
+		case "C":
+			return "copied";
+		case "M":
+			return "modified";
+		default:
+			return "modified";
+	}
+}
+
+function parseStatusPorcelain(raw: string): {
+	branch: string;
+	ahead: number;
+	behind: number;
+	changes: GitFileChange[];
+} {
+	const lines = raw.split("\n").filter((l) => l.length > 0);
+	let branch = "HEAD";
+	let ahead = 0;
+	let behind = 0;
+	const changes: GitFileChange[] = [];
+
+	for (const line of lines) {
+		if (line.startsWith("# branch.head ")) {
+			branch = line.slice("# branch.head ".length);
+		} else if (line.startsWith("# branch.ab ")) {
+			const match = line.match(/\+(\d+) -(\d+)/);
+			if (match) {
+				ahead = Number.parseInt(match[1] ?? "0", 10);
+				behind = Number.parseInt(match[2] ?? "0", 10);
+			}
+		} else if (line.startsWith("#")) {
+			continue;
+		} else {
+			const change = parseFileStatus(line);
+			if (change) changes.push(change);
+		}
+	}
+
+	return { branch, ahead, behind, changes };
+}
+
+function parseStashList(raw: string): StashEntry[] {
+	return raw
+		.split("\n")
+		.filter((l) => l.length > 0)
+		.map((line) => {
+			const colon_idx = line.indexOf(":");
+			const ref = colon_idx >= 0 ? line.slice(0, colon_idx) : line;
+			const message = colon_idx >= 0 ? line.slice(colon_idx + 1) : "";
+			const index_match = ref.match(/\{(\d+)\}/);
+			return {
+				index: index_match ? Number.parseInt(index_match[1] ?? "0", 10) : 0,
+				message: message.trim(),
+				date: "",
+			};
+		});
+}
+
+function parseBranches(raw: string): {
+	branches: BranchInfo[];
+	local_count: number;
+	remote_count: number;
+} {
+	const names = raw
+		.split("\n")
+		.map((l) => l.trim())
+		.filter((l) => l.length > 0);
+
+	const branches: BranchInfo[] = [];
+	let local_count = 0;
+	let remote_count = 0;
+
+	for (const name of names) {
+		const is_remote = name.includes("/");
+		if (is_remote) {
+			remote_count++;
+		} else {
+			local_count++;
+		}
+		branches.push({
+			name,
+			is_current: false,
+			upstream: null,
+			ahead: 0,
+			behind: 0,
+			last_commit_time: 0,
+		});
+	}
+
+	return { branches, local_count, remote_count };
+}
+
+function deriveHealth(
+	ahead: number,
+	behind: number,
+	modified: number,
+	staged: number,
+	untracked: number,
+	conflicts: number,
+): HealthStatus {
+	if (conflicts > 0) return "conflict";
+	if (ahead > 0 && behind > 0) return "diverged";
+	if (ahead > 0) return "ahead";
+	if (behind > 0) return "behind";
+	if (modified + staged + untracked > 0) return "dirty";
+	return "clean";
+}
+
+export async function collectStatus(
+	repoPath: string,
+	scanRoot: string,
+): Promise<Result<RepoStatus, GitStatusError>> {
+	const [status_result, log_result, stash_result, branches_result, remote_result] =
+		await Promise.all([
+			git(["status", "--porcelain=v2", "--branch"], repoPath),
+			git(["log", "-1", "--format=%H:%s:%at"], repoPath),
+			git(["stash", "list", "--format=%gd:%gs"], repoPath),
+			git(["branch", "-a", "--format=%(refname:short)"], repoPath),
+			git(["remote", "get-url", "origin"], repoPath),
+		]);
+
+	if (!status_result.ok) return status_result;
+	if (!log_result.ok) return log_result;
+	if (!stash_result.ok) return stash_result;
+	if (!branches_result.ok) return branches_result;
+
+	const { branch, ahead, behind, changes } = parseStatusPorcelain(
+		status_result.value,
+	);
+
+	const log_parts = log_result.value.trim().split(":");
+	const head_commit = log_parts[0] ?? "";
+	const head_message = log_parts.slice(1, -1).join(":") ;
+	const head_time = Number.parseInt(log_parts.at(-1) ?? "0", 10);
+
+	const stashes = parseStashList(stash_result.value);
+	const { branches, local_count, remote_count } = parseBranches(
+		branches_result.value,
+	);
+
+	const current_branch =
+		branch === "(detached)" || branch === "HEAD" ? "HEAD (detached)" : branch;
+
+	const current_idx = branches.findIndex(
+		(b) => b.name === current_branch || b.name === branch,
+	);
+	if (current_idx >= 0 && branches[current_idx]) {
+		branches[current_idx].is_current = true;
+	}
+
+	const remote_url = remote_result.ok ? remote_result.value.trim() || null : null;
+
+	const modified_count = changes.filter(
+		(c) => !c.staged && c.status !== "untracked" && c.status !== "conflicted",
+	).length;
+	const staged_count = changes.filter((c) => c.staged).length;
+	const untracked_count = changes.filter(
+		(c) => c.status === "untracked",
+	).length;
+	const conflict_count = changes.filter(
+		(c) => c.status === "conflicted",
+	).length;
+
+	const is_clean =
+		modified_count === 0 &&
+		staged_count === 0 &&
+		untracked_count === 0 &&
+		conflict_count === 0 &&
+		ahead === 0;
+
+	const health = deriveHealth(
+		ahead,
+		behind,
+		modified_count,
+		staged_count,
+		untracked_count,
+		conflict_count,
+	);
+
+	return ok({
+		path: repoPath,
+		name: basename(repoPath),
+		display_path: relative(scanRoot, repoPath),
+
+		current_branch,
+		head_commit,
+		head_message,
+		head_time,
+
+		remote_url,
+		ahead,
+		behind,
+
+		modified_count,
+		staged_count,
+		untracked_count,
+		conflict_count,
+		changes,
+
+		stash_count: stashes.length,
+		stashes,
+
+		branches,
+		local_branch_count: local_count,
+		remote_branch_count: remote_count,
+
+		tags: [],
+		total_commits: 0,
+		repo_size_bytes: 0,
+		contributor_count: 0,
+
+		recent_commits: [],
+
+		commit_activity: null,
+
+		ocn_status: null,
+
+		is_clean,
+		health,
+	});
+}

package/packages/core/src/github.ts

@@ -0,0 +1,286 @@
+import { ok, err, type Result } from "@f0rbit/corpus";
+
+export type GithubError =
+	| { kind: "not_github_repo" }
+	| { kind: "gh_cli_not_found" }
+	| { kind: "gh_auth_required" }
+	| { kind: "api_error"; cause: string }
+	| { kind: "rate_limited" };
+
+export interface GithubPR {
+	number: number;
+	title: string;
+	state: string;
+	review_decision: string | null;
+	ci_status: "success" | "failure" | "pending" | "none";
+	is_draft: boolean;
+	author: string;
+}
+
+export interface GithubIssue {
+	number: number;
+	title: string;
+	labels: string[];
+	created_at: string;
+}
+
+export interface GithubWorkflowRun {
+	name: string;
+	status: string;
+	conclusion: string | null;
+	head_branch: string;
+	duration_seconds: number | null;
+}
+
+export interface GithubRelease {
+	tag_name: string;
+	name: string;
+	published_at: string;
+	commits_since: number;
+}
+
+export interface GithubRepoData {
+	prs: GithubPR[];
+	issues: GithubIssue[];
+	ci_runs: GithubWorkflowRun[];
+	latest_release: GithubRelease | null;
+}
+
+let gh_available: boolean | null = null;
+
+export function checkGhAvailable(): boolean {
+	if (gh_available === null) {
+		gh_available = Bun.which("gh") !== null;
+	}
+	return gh_available;
+}
+
+export function isGithubRemote(remote_url: string | null): boolean {
+	if (!remote_url) return false;
+	return remote_url.includes("github.com");
+}
+
+export function parseGhOwnerRepo(remote_url: string): { owner: string; repo: string } | null {
+	const match = remote_url.match(/github\.com[:/]([^/]+)\/([^/.]+)/);
+	if (match) return { owner: match[1]!, repo: match[2]! };
+	return null;
+}
+
+function safeJsonParse<T>(text: string): Result<T, GithubError> {
+	try {
+		return ok(JSON.parse(text) as T);
+	} catch {
+		return err({ kind: "api_error", cause: "invalid JSON response from gh CLI" });
+	}
+}
+
+async function gh(args: string[], cwd: string): Promise<Result<string, GithubError>> {
+	if (!checkGhAvailable()) return err({ kind: "gh_cli_not_found" });
+
+	const proc = Bun.spawn(["gh", ...args], {
+		cwd,
+		stdout: "pipe",
+		stderr: "pipe",
+	});
+
+	const stdout = await new Response(proc.stdout).text();
+	const stderr = await new Response(proc.stderr).text();
+	const exit_code = await proc.exited;
+
+	if (exit_code !== 0) {
+		if (stderr.includes("auth login")) return err({ kind: "gh_auth_required" });
+		if (stderr.includes("rate limit")) return err({ kind: "rate_limited" });
+		return err({ kind: "api_error", cause: stderr.trim() });
+	}
+
+	return ok(stdout);
+}
+
+interface RawPR {
+	number: number;
+	title: string;
+	state: string;
+	reviewDecision: string | null;
+	statusCheckRollup: Array<{ state: string; status: string; conclusion: string }> | null;
+	isDraft: boolean;
+	author: { login: string };
+}
+
+function deriveCiStatus(checks: RawPR["statusCheckRollup"]): GithubPR["ci_status"] {
+	if (!checks || checks.length === 0) return "none";
+	const has_failure = checks.some(
+		(c) => c.conclusion === "FAILURE" || c.conclusion === "failure",
+	);
+	if (has_failure) return "failure";
+	const all_success = checks.every(
+		(c) => c.conclusion === "SUCCESS" || c.conclusion === "success",
+	);
+	if (all_success) return "success";
+	return "pending";
+}
+
+function mapPR(raw: RawPR): GithubPR {
+	return {
+		number: raw.number,
+		title: raw.title,
+		state: raw.state,
+		review_decision: raw.reviewDecision ?? null,
+		ci_status: deriveCiStatus(raw.statusCheckRollup),
+		is_draft: raw.isDraft,
+		author: raw.author?.login ?? "unknown",
+	};
+}
+
+export async function collectPRs(cwd: string): Promise<Result<GithubPR[], GithubError>> {
+	const result = await gh(
+		["pr", "list", "--json", "number,title,state,reviewDecision,statusCheckRollup,isDraft,author", "--limit", "20"],
+		cwd,
+	);
+	if (!result.ok) return result;
+
+	const parsed = safeJsonParse<RawPR[]>(result.value);
+	if (!parsed.ok) return parsed;
+
+	return ok(parsed.value.map(mapPR));
+}
+
+interface RawIssue {
+	number: number;
+	title: string;
+	labels: Array<{ name: string }>;
+	createdAt: string;
+}
+
+export async function collectIssues(cwd: string): Promise<Result<GithubIssue[], GithubError>> {
+	const result = await gh(
+		["issue", "list", "--json", "number,title,labels,createdAt", "--limit", "10"],
+		cwd,
+	);
+	if (!result.ok) return result;
+
+	const parsed = safeJsonParse<RawIssue[]>(result.value);
+	if (!parsed.ok) return parsed;
+
+	return ok(
+		parsed.value.map((raw) => ({
+			number: raw.number,
+			title: raw.title,
+			labels: raw.labels.map((l) => l.name),
+			created_at: raw.createdAt,
+		})),
+	);
+}
+
+interface RawWorkflowRun {
+	name: string;
+	status: string;
+	conclusion: string | null;
+	headBranch: string;
+}
+
+export async function collectCIRuns(cwd: string): Promise<Result<GithubWorkflowRun[], GithubError>> {
+	const result = await gh(
+		["run", "list", "--json", "name,status,conclusion,headBranch", "--limit", "10"],
+		cwd,
+	);
+	if (!result.ok) return result;
+
+	const parsed = safeJsonParse<RawWorkflowRun[]>(result.value);
+	if (!parsed.ok) return parsed;
+
+	return ok(
+		parsed.value.map((raw) => ({
+			name: raw.name,
+			status: raw.status,
+			conclusion: raw.conclusion ?? null,
+			head_branch: raw.headBranch,
+			duration_seconds: null,
+		})),
+	);
+}
+
+interface RawRelease {
+	tagName: string;
+	name: string;
+	publishedAt: string;
+}
+
+async function countCommitsSince(tag: string, cwd: string): Promise<number> {
+	// Ensure tags are fetched — the release tag may not exist locally
+	const fetch_proc = Bun.spawn(["git", "fetch", "--tags", "--quiet"], {
+		cwd,
+		stdout: "pipe",
+		stderr: "pipe",
+	});
+	await fetch_proc.exited;
+
+	const proc = Bun.spawn(["git", "rev-list", `${tag}..HEAD`, "--count"], {
+		cwd,
+		stdout: "pipe",
+		stderr: "pipe",
+	});
+
+	const stdout = await new Response(proc.stdout).text();
+	const exit_code = await proc.exited;
+
+	if (exit_code !== 0) return 0;
+
+	const count = parseInt(stdout.trim(), 10);
+	return Number.isNaN(count) ? 0 : count;
+}
+
+export async function collectRelease(cwd: string): Promise<Result<GithubRelease | null, GithubError>> {
+	const result = await gh(
+		["release", "view", "--json", "tagName,publishedAt,name"],
+		cwd,
+	);
+	if (!result.ok) {
+		if (result.error.kind === "api_error" && result.error.cause.includes("no releases")) {
+			return ok(null);
+		}
+		return result;
+	}
+
+	const parsed = safeJsonParse<RawRelease>(result.value);
+	if (!parsed.ok) return parsed;
+
+	const raw = parsed.value;
+	const commits_since = await countCommitsSince(raw.tagName, cwd);
+
+	return ok({
+		tag_name: raw.tagName,
+		name: raw.name,
+		published_at: raw.publishedAt,
+		commits_since,
+	});
+}
+
+function isFatalError(error: GithubError): boolean {
+	return error.kind === "gh_auth_required" || error.kind === "rate_limited" || error.kind === "gh_cli_not_found";
+}
+
+export async function collectGithubData(
+	repo_path: string,
+	remote_url: string | null,
+): Promise<Result<GithubRepoData, GithubError>> {
+	if (!isGithubRemote(remote_url)) return err({ kind: "not_github_repo" });
+	if (!checkGhAvailable()) return err({ kind: "gh_cli_not_found" });
+
+	const [prs_result, issues_result, ci_result, release_result] = await Promise.all([
+		collectPRs(repo_path),
+		collectIssues(repo_path),
+		collectCIRuns(repo_path),
+		collectRelease(repo_path),
+	]);
+
+	const results = [prs_result, issues_result, ci_result, release_result];
+	const fatal = results.find((r) => !r.ok && isFatalError(r.error));
+	if (fatal && !fatal.ok) return fatal as Result<never, GithubError>;
+
+	return ok({
+		prs: prs_result.ok ? prs_result.value : [],
+		issues: issues_result.ok ? issues_result.value : [],
+		ci_runs: ci_result.ok ? ci_result.value : [],
+		latest_release: release_result.ok ? release_result.value : null,
+	});
+}

package/packages/core/src/index.ts

@@ -0,0 +1,58 @@
+import { ok, type Result } from "@f0rbit/corpus";
+import type { RepoNode, OcnStatus } from "./types";
+import { scanDirectory, type ScanError } from "./scanner";
+import { collectStatus } from "./git-status";
+import { detectWorktrees } from "./worktree";
+import { createPool } from "./concurrency";
+import { readOcnStates } from "./ocn";
+
+export * from "./types";
+export * from "./scanner";
+export * from "./worktree";
+export * from "./git-status";
+export * from "./git-graph";
+export * from "./git-stats";
+export * from "./watcher";
+export * from "./cache";
+export * from "./github";
+export * from "./devpad";
+export * from "./concurrency";
+export * from "./ocn";
+
+export type ScanAndCollectError = ScanError;
+
+const pool = createPool(8);
+
+async function populateNode(node: RepoNode, scanRoot: string, ocn_map: Map<string, OcnStatus>): Promise<void> {
+	if (node.type === "repo" || node.type === "worktree") {
+		await pool.run(async () => {
+			const [status_result, worktree_result] = await Promise.all([
+				collectStatus(node.path, scanRoot),
+				detectWorktrees(node.path),
+			]);
+			node.status = status_result.ok ? status_result.value : null;
+			if (node.status) {
+				node.status.ocn_status = ocn_map.get(node.path) ?? null;
+			}
+			node.worktrees = worktree_result.ok ? worktree_result.value : [];
+		});
+	}
+
+	await Promise.all(node.children.map((child) => populateNode(child, scanRoot, ocn_map)));
+}
+
+export async function scanAndCollect(
+	root: string,
+	options: { depth: number; ignore: string[] },
+): Promise<Result<RepoNode[], ScanAndCollectError>> {
+	const scan_result = await scanDirectory(root, options);
+	if (!scan_result.ok) return scan_result;
+
+	const ocn_result = await readOcnStates();
+	const ocn_map = ocn_result.ok ? ocn_result.value : new Map<string, OcnStatus>();
+
+	const nodes = scan_result.value;
+	await Promise.all(nodes.map((node) => populateNode(node, root, ocn_map)));
+
+	return ok(nodes);
+}