@f0rbit/overview 0.1.0

package/packages/core/src/ocn.ts

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

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

package/packages/core/src/types.ts

@@ -0,0 +1,199 @@
+// Git file change
+export interface GitFileChange {
+	path: string;
+	status: "modified" | "added" | "deleted" | "renamed" | "copied" | "untracked" | "ignored" | "conflicted";
+	staged: boolean;
+}
+
+// Branch info
+export interface BranchInfo {
+	name: string;
+	is_current: boolean;
+	upstream: string | null;
+	ahead: number;
+	behind: number;
+	last_commit_time: number; // unix timestamp
+}
+
+// Stash entry
+export interface StashEntry {
+	index: number;
+	message: string;
+	date: string;
+}
+
+// Recent commit
+export interface RecentCommit {
+	hash: string;
+	message: string;
+	author: string;
+	time: number; // unix timestamp
+}
+
+// OpenCode session status (from ocn)
+export type OcnSessionStatus = "idle" | "busy" | "prompting" | "error";
+
+export interface OcnStatus {
+	pid: number;
+	status: OcnSessionStatus;
+	session_id: string;
+}
+
+// Health status
+export type HealthStatus = "clean" | "dirty" | "ahead" | "behind" | "diverged" | "conflict";
+
+// Full repo status
+export interface RepoStatus {
+	// Identity
+	path: string;
+	name: string;
+	display_path: string; // relative to scan root
+
+	// Current state
+	current_branch: string;
+	head_commit: string;
+	head_message: string;
+	head_time: number;
+
+	// Tracking
+	remote_url: string | null;
+	ahead: number;
+	behind: number;
+
+	// Working tree
+	modified_count: number;
+	staged_count: number;
+	untracked_count: number;
+	conflict_count: number;
+	changes: GitFileChange[];
+
+	// Stash
+	stash_count: number;
+	stashes: StashEntry[];
+
+	// Branches
+	branches: BranchInfo[];
+	local_branch_count: number;
+	remote_branch_count: number;
+
+	// Metadata
+	tags: string[];
+	total_commits: number;
+	repo_size_bytes: number;
+	contributor_count: number;
+
+	// Recent activity
+	recent_commits: RecentCommit[];
+
+	// Commit activity (populated by fetchDetails, not initial scan)
+	commit_activity: { daily_counts: number[]; total_this_week: number; total_last_week: number } | null;
+
+	// OpenCode session status (from ocn)
+	ocn_status: OcnStatus | null;
+
+	// Derived
+	is_clean: boolean;
+	health: HealthStatus;
+}
+
+// Worktree info
+export interface WorktreeInfo {
+	path: string;
+	branch: string;
+	head: string;
+	is_bare: boolean;
+	is_main: boolean;
+}
+
+// Git graph output
+export interface GitGraphOutput {
+	lines: string[];
+	total_lines: number;
+	repo_path: string;
+}
+
+// Repo tree node
+export interface RepoNode {
+	name: string;
+	path: string;
+	type: "directory" | "repo" | "worktree";
+	status: RepoStatus | null;
+	worktrees: WorktreeInfo[];
+	children: RepoNode[];
+	depth: number;
+	expanded: boolean;
+}
+
+// Widget system
+export type WidgetId =
+	| "git-status"
+	| "recent-commits"
+	| "branch-list"
+	| "github-prs"
+	| "github-issues"
+	| "github-ci"
+	| "devpad-tasks"
+	| "devpad-milestones"
+	| "repo-meta"
+	| "file-changes"
+	| "commit-activity"
+	| "github-release";
+
+export interface WidgetConfig {
+	id: WidgetId;
+	enabled: boolean;
+	priority: number;
+	collapsed: boolean;
+}
+
+export type WidgetSpan = "full" | "half" | "third" | "auto";
+
+export interface WidgetSizeHint {
+	span: WidgetSpan;
+	min_height: number;
+}
+
+export interface WidgetRenderProps {
+	width: number;
+	focused: boolean;
+}
+
+// Config
+export interface OverviewConfig {
+	scan_dirs: string[];
+	depth: number;
+	refresh_interval: number;
+	layout: {
+		left_width_pct: number;
+		graph_height_pct: number;
+	};
+	sort: "name" | "status" | "last-commit";
+	filter: "all" | "dirty" | "clean" | "ahead" | "behind";
+	ignore: string[];
+	actions: {
+		ggi: string;
+		editor: string;
+		sessionizer: string | null;
+	};
+}
+
+// Default config factory
+export function defaultConfig(): OverviewConfig {
+	return {
+		scan_dirs: ["~/dev"],
+		depth: 3,
+		refresh_interval: 30,
+		layout: {
+			left_width_pct: 35,
+			graph_height_pct: 45,
+		},
+		sort: "name",
+		filter: "all",
+		ignore: ["node_modules", ".git"],
+		actions: {
+			ggi: "ggi",
+			editor: "$EDITOR",
+			sessionizer: null,
+		},
+	};
+}

package/packages/core/src/watcher.ts

@@ -0,0 +1,128 @@
+import { watch, type FSWatcher } from "node:fs";
+import { join } from "node:path";
+import { readFile, lstat } from "node:fs/promises";
+
+export interface WatcherOptions {
+	/** Debounce interval in ms (default 500) */
+	debounce_ms?: number;
+	/** Callback when a repo changes */
+	on_change: (repoPath: string) => void;
+}
+
+export interface RepoWatcher {
+	/** Start watching a list of repo paths */
+	watch(repoPaths: string[]): void;
+	/** Stop watching all repos */
+	close(): void;
+	/** Add a single repo to watch */
+	add(repoPath: string): void;
+	/** Remove a single repo from watching */
+	remove(repoPath: string): void;
+}
+
+async function resolveGitDir(repo_path: string): Promise<string | null> {
+	const git_path = join(repo_path, ".git");
+	try {
+		const stats = await lstat(git_path);
+		if (stats.isDirectory()) return git_path;
+		if (stats.isFile()) {
+			const content = await readFile(git_path, "utf-8");
+			const match = content.match(/^gitdir:\s*(.+)$/m);
+			const target = match?.[1]?.trim();
+			if (!target) return null;
+			return target.startsWith("/") ? target : join(repo_path, target);
+		}
+		return null;
+	} catch {
+		return null;
+	}
+}
+
+function tryWatch(
+	target: string,
+	options: { recursive?: boolean },
+	callback: () => void,
+): FSWatcher | null {
+	try {
+		const watcher = watch(target, options, callback);
+		watcher.on("error", () => {});
+		return watcher;
+	} catch {
+		return null;
+	}
+}
+
+export function createRepoWatcher(options: WatcherOptions): RepoWatcher {
+	const debounce_ms = options.debounce_ms ?? 500;
+	const watchers = new Map<string, FSWatcher[]>();
+	const timers = new Map<string, ReturnType<typeof setTimeout>>();
+
+	function debouncedChange(repo_path: string) {
+		const existing = timers.get(repo_path);
+		if (existing) clearTimeout(existing);
+		timers.set(
+			repo_path,
+			setTimeout(() => {
+				timers.delete(repo_path);
+				options.on_change(repo_path);
+			}, debounce_ms),
+		);
+	}
+
+	async function addRepo(repo_path: string) {
+		if (watchers.has(repo_path)) return;
+
+		const git_dir = await resolveGitDir(repo_path);
+		if (!git_dir) {
+			console.warn(`[watcher] skipping ${repo_path}: could not resolve .git directory`);
+			return;
+		}
+
+		const repo_watchers: FSWatcher[] = [];
+		const on_event = () => debouncedChange(repo_path);
+
+		const index_watcher = tryWatch(join(git_dir, "index"), {}, on_event);
+		if (index_watcher) repo_watchers.push(index_watcher);
+
+		const refs_watcher = tryWatch(join(git_dir, "refs"), { recursive: true }, on_event);
+		if (refs_watcher) repo_watchers.push(refs_watcher);
+
+		if (repo_watchers.length === 0) {
+			console.warn(`[watcher] skipping ${repo_path}: no watchable targets`);
+			return;
+		}
+
+		watchers.set(repo_path, repo_watchers);
+	}
+
+	function removeRepo(repo_path: string) {
+		const repo_watchers = watchers.get(repo_path);
+		if (repo_watchers) {
+			repo_watchers.forEach((w) => w.close());
+			watchers.delete(repo_path);
+		}
+		const timer = timers.get(repo_path);
+		if (timer) {
+			clearTimeout(timer);
+			timers.delete(repo_path);
+		}
+	}
+
+	return {
+		watch(repo_paths: string[]) {
+			repo_paths.forEach((p) => addRepo(p));
+		},
+		close() {
+			watchers.forEach((ws) => ws.forEach((w) => w.close()));
+			watchers.clear();
+			timers.forEach((t) => clearTimeout(t));
+			timers.clear();
+		},
+		add(repo_path: string) {
+			addRepo(repo_path);
+		},
+		remove(repo_path: string) {
+			removeRepo(repo_path);
+		},
+	};
+}

package/packages/core/src/worktree.ts

@@ -0,0 +1,80 @@
+import { ok, err, type Result } from "@f0rbit/corpus";
+import type { WorktreeInfo } from "./types";
+
+export type WorktreeError =
+	| { kind: "not_a_repo"; path: string }
+	| { kind: "worktree_failed"; path: string; cause: string };
+
+async function gitCommand(
+	args: string[],
+	cwd: string,
+): Promise<Result<string, WorktreeError>> {
+	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();
+		const is_not_repo =
+			stderr.includes("not a git repository") ||
+			stderr.includes("not a git repo");
+		if (is_not_repo) {
+			return err({ kind: "not_a_repo", path: cwd });
+		}
+		return err({
+			kind: "worktree_failed",
+			path: cwd,
+			cause: stderr.trim(),
+		});
+	}
+
+	const stdout = await new Response(proc.stdout).text();
+	return ok(stdout);
+}
+
+function parseWorktreeBlock(
+	lines: string[],
+	is_main: boolean,
+): WorktreeInfo | null {
+	const path = lines
+		.find((l) => l.startsWith("worktree "))
+		?.slice("worktree ".length);
+	if (!path) return null;
+
+	const head_line = lines.find((l) => l.startsWith("HEAD "));
+	const head = head_line ? head_line.slice("HEAD ".length, "HEAD ".length + 7) : "0000000";
+
+	const branch_line = lines.find((l) => l.startsWith("branch "));
+	const is_bare = lines.some((l) => l === "bare");
+	const branch = branch_line
+		? branch_line.slice("branch refs/heads/".length)
+		: is_bare
+			? "bare"
+			: "detached";
+
+	return { path, branch, head, is_bare, is_main };
+}
+
+export async function detectWorktrees(
+	repoPath: string,
+): Promise<Result<WorktreeInfo[], WorktreeError>> {
+	const result = await gitCommand(["worktree", "list", "--porcelain"], repoPath);
+	if (!result.ok) return result;
+
+	const blocks = result.value
+		.split("\n\n")
+		.map((b) => b.trim())
+		.filter((b) => b.length > 0);
+
+	const worktrees = blocks
+		.map((block, i) => parseWorktreeBlock(block.split("\n"), i === 0))
+		.filter((w): w is WorktreeInfo => w !== null);
+
+	if (worktrees.length <= 1) return ok([]);
+
+	return ok(worktrees);
+}

package/packages/core/tsconfig.json

@@ -0,0 +1,5 @@
+{
+  "extends": "../../tsconfig.json",
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/packages/render/bunfig.toml

@@ -0,0 +1,8 @@
+preload = ["@opentui/solid/preload"]
+
+[test]
+preload = ["@opentui/solid/preload"]
+
+[compilerOptions]
+jsxImportSource = "solid-js"
+jsx = "preserve"

package/packages/render/jsx-runtime.d.ts

@@ -0,0 +1,3 @@
+// JSX types provided by @opentui/solid/jsx-runtime via jsxImportSource config.
+// This file is included in tsconfig for any future type augmentations.
+export {}

package/packages/render/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "@overview/render",
+  "version": "0.1.0",
+  "main": "src/overview.tsx",
+  "scripts": {
+    "dev": "bun run src/overview.tsx",
+    "test": "bun test",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@opentui/core": "^0.1.80",
+    "@opentui/solid": "^0.1.80",
+    "solid-js": "^1.9.11",
+    "@overview/core": "workspace:*",
+    "@f0rbit/corpus": "link:@f0rbit/corpus",
+    "@devpad/api": "link:@devpad/api"
+  }
+}