@f0rbit/overview 0.1.0 → 0.2.1

package/packages/core/src/github.ts

@@ -1,286 +0,0 @@
-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

@@ -1,58 +0,0 @@
-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);
-}

package/packages/core/src/ocn.ts

@@ -1,74 +0,0 @@
-import { ok, err, type Result } from "@f0rbit/corpus";
-import { join } from "node:path";
-import { readdir } from "node:fs/promises";
-import type { OcnStatus, OcnSessionStatus } from "./types";
-
-export type OcnError =
-	| { kind: "state_dir_not_found" }
-	| { kind: "read_failed"; path: string; cause: string };
-
-interface OcnStateFile {
-	pid: number;
-	directory: string;
-	project: string;
-	status: OcnSessionStatus;
-	last_transition: string;
-	session_id: string;
-}
-
-const VALID_STATUSES: Set<string> = new Set(["idle", "busy", "prompting", "error"]);
-
-function isAlive(pid: number): boolean {
-	try {
-		process.kill(pid, 0);
-		return true;
-	} catch {
-		return false;
-	}
-}
-
-function isValidState(data: unknown): data is OcnStateFile {
-	if (typeof data !== "object" || data === null) return false;
-	const obj = data as Record<string, unknown>;
-	return (
-		typeof obj.pid === "number" &&
-		typeof obj.directory === "string" &&
-		typeof obj.status === "string" &&
-		VALID_STATUSES.has(obj.status) &&
-		typeof obj.session_id === "string"
-	);
-}
-
-export async function readOcnStates(): Promise<Result<Map<string, OcnStatus>, OcnError>> {
-	const state_dir = process.env.OCN_STATE_DIR ?? join(process.env.HOME ?? "~", ".local", "state", "ocn");
-	const map = new Map<string, OcnStatus>();
-
-	let entries: string[];
-	try {
-		const dir_entries = await readdir(state_dir);
-		entries = dir_entries.filter((e) => e.endsWith(".json"));
-	} catch {
-		// State dir doesn't exist — ocn not installed or no sessions. Not an error.
-		return ok(map);
-	}
-
-	for (const entry of entries) {
-		const file_path = join(state_dir, entry);
-		try {
-			const data = await Bun.file(file_path).json();
-			if (!isValidState(data)) continue;
-			if (!isAlive(data.pid)) continue;
-
-			map.set(data.directory, {
-				pid: data.pid,
-				status: data.status,
-				session_id: data.session_id,
-			});
-		} catch {
-			// Malformed JSON or read error — skip silently
-			continue;
-		}
-	}
-
-	return ok(map);
-}

package/packages/core/src/scanner.ts

@@ -1,118 +0,0 @@
-import { readdir, stat, lstat } from "node:fs/promises";
-import { join, basename } from "node:path";
-import { ok, err, try_catch_async, format_error, type Result } from "@f0rbit/corpus";
-import type { RepoNode } from "./types";
-
-export type ScanError =
-	| { kind: "invalid_path"; path: string; message: string }
-	| { kind: "permission_denied"; path: string }
-	| { kind: "scan_failed"; path: string; cause: string };
-
-async function isGitRepo(dirPath: string): Promise<boolean> {
-	const proc = Bun.spawn(["git", "rev-parse", "--git-dir"], {
-		cwd: dirPath,
-		stdout: "pipe",
-		stderr: "pipe",
-	});
-	const code = await proc.exited;
-	return code === 0;
-}
-
-async function detectType(dirPath: string): Promise<"repo" | "worktree" | null> {
-	const git_path = join(dirPath, ".git");
-	const result = await try_catch_async(
-		() => lstat(git_path),
-		() => null,
-	);
-	if (!result.ok || result.value === null) return null;
-
-	const stats = result.value;
-	if (stats.isFile()) return "worktree";
-	if (stats.isDirectory()) return "repo";
-	return null;
-}
-
-async function walkDirectory(
-	dirPath: string,
-	current_depth: number,
-	max_depth: number,
-	ignore: string[],
-): Promise<Result<RepoNode[], ScanError>> {
-	if (current_depth > max_depth) return ok([]);
-
-	const entries_result = await try_catch_async(
-		() => readdir(dirPath, { withFileTypes: true }),
-		(e) => {
-			const msg = format_error(e);
-			if (msg.includes("EACCES") || msg.includes("permission"))
-				return { kind: "permission_denied" as const, path: dirPath };
-			return { kind: "scan_failed" as const, path: dirPath, cause: msg };
-		},
-	);
-
-	if (!entries_result.ok) return entries_result;
-
-	const dirs = entries_result.value
-		.filter((e) => e.isDirectory() && !ignore.some((pattern) => e.name.includes(pattern)))
-		.sort((a, b) => a.name.localeCompare(b.name));
-
-	const results = await Promise.all(
-		dirs.map(async (entry) => {
-			const full_path = join(dirPath, entry.name);
-			const repo_type = await detectType(full_path);
-			const is_repo = repo_type !== null && (await isGitRepo(full_path));
-
-			const children_result = await walkDirectory(full_path, current_depth + 1, max_depth, ignore);
-			if (!children_result.ok) return null;
-
-			const children = children_result.value;
-
-			if (is_repo) {
-				return {
-					name: entry.name,
-					path: full_path,
-					type: repo_type,
-					status: null,
-					worktrees: [],
-					children,
-					depth: current_depth,
-					expanded: current_depth <= 1,
-				} as RepoNode;
-			} else if (children.length > 0) {
-				return {
-					name: entry.name,
-					path: full_path,
-					type: "directory" as const,
-					status: null,
-					worktrees: [],
-					children,
-					depth: current_depth,
-					expanded: current_depth <= 1,
-				} as RepoNode;
-			}
-			return null;
-		}),
-	);
-
-	return ok(results.filter((n): n is RepoNode => n !== null));
-}
-
-export async function scanDirectory(
-	root: string,
-	options: { depth: number; ignore: string[] },
-): Promise<Result<RepoNode[], ScanError>> {
-	const root_stat = await try_catch_async(
-		() => stat(root),
-		(e) => ({
-			kind: "invalid_path" as const,
-			path: root,
-			message: format_error(e),
-		}),
-	);
-
-	if (!root_stat.ok) return root_stat;
-	if (!root_stat.value.isDirectory())
-		return err({ kind: "invalid_path", path: root, message: "Not a directory" });
-
-	return walkDirectory(root, 0, options.depth, options.ignore);
-}