@f0rbit/overview 0.1.0 → 0.2.1

package/packages/render/src/lib/actions.ts

@@ -1,68 +0,0 @@
-import { ok, err, type Result } from "@f0rbit/corpus";
-
-export type ActionError =
-	| { kind: "not_found"; command: string }
-	| { kind: "spawn_failed"; command: string; cause: string }
-	| { kind: "exited_with_error"; command: string; code: number };
-
-type SuspendCallbacks = {
-	onSuspend: () => void;
-	onResume: () => void;
-};
-
-async function launchSubprocess(
-	command: string,
-	args: string[],
-	cwd: string,
-	callbacks: SuspendCallbacks,
-): Promise<Result<void, ActionError>> {
-	callbacks.onSuspend();
-
-	try {
-		const proc = Bun.spawn([command, ...args], {
-			cwd,
-			stdin: "inherit",
-			stdout: "inherit",
-			stderr: "inherit",
-		});
-
-		await proc.exited;
-
-		if (proc.exitCode !== 0 && proc.exitCode !== null) {
-			return err({ kind: "exited_with_error", command, code: proc.exitCode });
-		}
-
-		return ok(undefined);
-	} catch (e) {
-		return err({ kind: "spawn_failed", command, cause: String(e) });
-	} finally {
-		callbacks.onResume();
-	}
-}
-
-export async function launchGgi(
-	repoPath: string,
-	ggiCommand: string,
-	callbacks: SuspendCallbacks,
-): Promise<Result<void, ActionError>> {
-	return launchSubprocess(ggiCommand, [], repoPath, callbacks);
-}
-
-export async function launchEditor(
-	repoPath: string,
-	editorCommand: string,
-	callbacks: SuspendCallbacks,
-): Promise<Result<void, ActionError>> {
-	const resolved = editorCommand === "$EDITOR"
-		? (process.env.EDITOR ?? process.env.VISUAL ?? "vim")
-		: editorCommand;
-	return launchSubprocess(resolved, ["."], repoPath, callbacks);
-}
-
-export async function launchSessionizer(
-	repoPath: string,
-	sessionizerCommand: string,
-	callbacks: SuspendCallbacks,
-): Promise<Result<void, ActionError>> {
-	return launchSubprocess(sessionizerCommand, [repoPath], process.cwd(), callbacks);
-}

package/packages/render/src/lib/fetch-context.ts

@@ -1,102 +0,0 @@
-/**
- * FetchContext — manages debounced, cancellable, deduplicated async operations.
- *
- * Use for any async work triggered by reactive signal changes where:
- * - Rapid changes should coalesce (debounce)
- * - Stale results should be discarded (cancellation via request ID)
- * - Multiple callers for the same key should share a single in-flight fetch (dedup)
- */
-
-export interface FetchContext<T> {
-	/** Current request ID — increments on each trigger/cancel */
-	readonly request_id: number;
-	/** Schedule a debounced fetch. Cancels any pending. Returns the new request ID. */
-	trigger(fn: () => Promise<T>): number;
-	/** Execute immediately, bypassing debounce. Cancels any pending. Returns the new request ID. */
-	immediate(fn: () => Promise<T>): number;
-	/** Cancel any pending debounce and increment request ID to invalidate in-flight results. */
-	cancel(): void;
-	/** Clean up timers. Call in onCleanup. */
-	dispose(): void;
-}
-
-export function createFetchContext<T>(
-	delay_ms: number,
-	on_result: (value: T, request_id: number) => void,
-): FetchContext<T> {
-	let _request_id = 0;
-	let _timer: ReturnType<typeof setTimeout> | undefined;
-
-	function _run(fn: () => Promise<T>): number {
-		const my_id = _request_id;
-		fn().then((value) => {
-			if (my_id === _request_id) {
-				on_result(value, my_id);
-			}
-		});
-		return my_id;
-	}
-
-	return {
-		get request_id() { return _request_id; },
-
-		trigger(fn) {
-			clearTimeout(_timer);
-			_request_id++;
-			const id = _request_id;
-			_timer = setTimeout(() => {
-				if (id === _request_id) {
-					_run(fn);
-				}
-			}, delay_ms);
-			return _request_id;
-		},
-
-		immediate(fn) {
-			clearTimeout(_timer);
-			_request_id++;
-			return _run(fn);
-		},
-
-		cancel() {
-			clearTimeout(_timer);
-			_request_id++;
-		},
-
-		dispose() {
-			clearTimeout(_timer);
-		},
-	};
-}
-
-/**
- * InFlightDedup — prevents duplicate concurrent fetches for the same cache key.
- *
- * If a fetch for key K is already in-flight, subsequent callers await the existing
- * promise instead of starting a new one. Once complete, the in-flight entry is removed.
- */
-export class InFlightDedup<T> {
-	private _in_flight = new Map<string, Promise<T>>();
-
-	/**
-	 * Run `fn` for `key`, deduplicating against any in-flight fetch for the same key.
-	 * Returns the result (either from the new fetch or the existing in-flight one).
-	 */
-	async run(key: string, fn: () => Promise<T>): Promise<T> {
-		const existing = this._in_flight.get(key);
-		if (existing) return existing;
-
-		const promise = fn();
-		this._in_flight.set(key, promise);
-		try {
-			return await promise;
-		} finally {
-			this._in_flight.delete(key);
-		}
-	}
-
-	/** Check if a fetch is currently in-flight for the given key */
-	has(key: string): boolean {
-		return this._in_flight.has(key);
-	}
-}

package/packages/render/src/lib/filter.ts

@@ -1,94 +0,0 @@
-import type { RepoNode, HealthStatus } from "@overview/core";
-
-export type SortMode = "name" | "status" | "last-commit";
-export type FilterMode = "all" | "dirty" | "clean" | "ahead" | "behind";
-
-const FILTER_MODES: FilterMode[] = ["all", "dirty", "clean", "ahead", "behind"];
-const SORT_MODES: SortMode[] = ["name", "status", "last-commit"];
-
-const HEALTH_PRIORITY: Record<HealthStatus, number> = {
-	conflict: 0,
-	diverged: 1,
-	ahead: 2,
-	behind: 3,
-	dirty: 4,
-	clean: 5,
-};
-
-const FILTER_MATCHERS: Record<FilterMode, (h: HealthStatus) => boolean> = {
-	all: () => true,
-	dirty: (h) => h !== "clean",
-	clean: (h) => h === "clean",
-	ahead: (h) => h === "ahead" || h === "diverged",
-	behind: (h) => h === "behind" || h === "diverged",
-};
-
-function matchesFilter(node: RepoNode, filter: FilterMode): boolean {
-	if (!node.status) return false;
-	return FILTER_MATCHERS[filter](node.status.health);
-}
-
-export function filterTree(nodes: RepoNode[], filter: FilterMode): RepoNode[] {
-	if (filter === "all") return nodes;
-	return nodes
-		.map((node): RepoNode | null => {
-			if (node.type === "directory") {
-				const children = filterTree(node.children, filter);
-				return children.length > 0 ? { ...node, children } : null;
-			}
-			return matchesFilter(node, filter) ? node : null;
-		})
-		.filter((n): n is RepoNode => n !== null);
-}
-
-export function sortTree(nodes: RepoNode[], sort: SortMode): RepoNode[] {
-	const dirs = nodes
-		.filter((n) => n.type === "directory")
-		.map((n) => ({ ...n, children: sortTree(n.children, sort) }));
-	const repos = nodes.filter((n) => n.type !== "directory");
-
-	const sorted = [...repos].sort((a, b) => {
-		switch (sort) {
-			case "name":
-				return a.name.localeCompare(b.name);
-			case "status": {
-				const pa = a.status ? HEALTH_PRIORITY[a.status.health] : 6;
-				const pb = b.status ? HEALTH_PRIORITY[b.status.health] : 6;
-				return pa !== pb ? pa - pb : a.name.localeCompare(b.name);
-			}
-			case "last-commit": {
-				const ta = a.status?.head_time ?? 0;
-				const tb = b.status?.head_time ?? 0;
-				return tb !== ta ? tb - ta : a.name.localeCompare(b.name);
-			}
-		}
-	});
-
-	return [
-		...dirs.sort((a, b) => a.name.localeCompare(b.name)),
-		...sorted,
-	];
-}
-
-export function searchRepos(nodes: RepoNode[], query: string): RepoNode[] {
-	const q = query.toLowerCase();
-	const flatten = (ns: RepoNode[]): RepoNode[] =>
-		ns.flatMap((n) =>
-			n.type === "directory"
-				? flatten(n.children)
-				: [n],
-		);
-	return flatten(nodes).filter((n) => {
-		if (n.name.toLowerCase().includes(q)) return true;
-		if (n.status?.display_path.toLowerCase().includes(q)) return true;
-		return false;
-	});
-}
-
-export function nextFilter(current: FilterMode): FilterMode {
-	return FILTER_MODES[(FILTER_MODES.indexOf(current) + 1) % FILTER_MODES.length]!;
-}
-
-export function nextSort(current: SortMode): SortMode {
-	return SORT_MODES[(SORT_MODES.indexOf(current) + 1) % SORT_MODES.length]!;
-}

package/packages/render/src/lib/format.ts

@@ -1,36 +0,0 @@
-export function truncate(str: string, maxLen: number): string {
-	if (str.length <= maxLen) return str;
-	return str.slice(0, maxLen - 1) + "…";
-}
-
-const BYTE_UNITS = ["B", "KB", "MB", "GB", "TB"] as const;
-
-export function formatBytes(bytes: number): string {
-	if (bytes === 0) return "0 B";
-	const exp = Math.min(Math.floor(Math.log(bytes) / Math.log(1024)), BYTE_UNITS.length - 1);
-	const value = bytes / 1024 ** exp;
-	const unit = BYTE_UNITS[exp]!;
-	return value < 10 ? `${value.toFixed(1)} ${unit}` : `${Math.round(value)} ${unit}`;
-}
-
-export function padTo(str: string, len: number): string {
-	if (str.length >= len) return str.slice(0, len);
-	return str + " ".repeat(len - str.length);
-}
-
-export function formatRelativeTime(timestamp: number): string {
-	const seconds = Math.floor(Date.now() / 1000) - timestamp;
-	if (seconds < 60) return "just now";
-	const minutes = Math.floor(seconds / 60);
-	if (minutes < 60) return `${minutes}m ago`;
-	const hours = Math.floor(minutes / 60);
-	if (hours < 24) return `${hours}h ago`;
-	const days = Math.floor(hours / 24);
-	if (days < 7) return `${days}d ago`;
-	const weeks = Math.floor(days / 7);
-	if (weeks < 5) return `${weeks}w ago`;
-	const months = Math.floor(days / 30);
-	if (months < 12) return `${months}mo ago`;
-	const years = Math.floor(days / 365);
-	return `${years}y ago`;
-}

package/packages/render/src/lib/use-devpad.ts

@@ -1,167 +0,0 @@
-import { createSignal, createEffect, type Accessor } from "solid-js";
-import ApiClient from "@devpad/api";
-import type { Project, TaskWithDetails } from "@devpad/api";
-import {
-	DataCache,
-	matchRepoToProject,
-	type DevpadProject,
-	type DevpadTask,
-	type DevpadMilestone,
-	type DevpadRepoData,
-} from "@overview/core";
-import { InFlightDedup } from "./fetch-context";
-import { getWidgetState } from "./widget-state";
-
-type ExtractOkArray<T> = T extends { ok: true; value: (infer U)[] } ? U : T extends { ok: false } ? never : never;
-type ApiMilestone = ExtractOkArray<Awaited<ReturnType<InstanceType<typeof ApiClient>["milestones"]["getByProject"]>>>;
-type ApiGoal = ExtractOkArray<Awaited<ReturnType<InstanceType<typeof ApiClient>["milestones"]["goals"]>>>;
-
-const project_cache = new DataCache<DevpadProject[]>();
-const data_cache = new DataCache<DevpadRepoData>();
-const dedup = new InFlightDedup<void>();
-
-const PROJECT_CACHE_TTL = 600_000;
-const DATA_CACHE_TTL = 300_000;
-
-function toDevpadProject(p: Project): DevpadProject {
-	return {
-		id: p.id,
-		project_id: p.project_id,
-		name: p.name,
-		description: p.description,
-		status: p.status,
-		repo_url: p.repo_url,
-	};
-}
-
-function toDevpadTask(t: TaskWithDetails): DevpadTask {
-	return {
-		id: t.task.id,
-		title: t.task.title,
-		description: t.task.description,
-		priority: t.task.priority,
-		progress: t.task.progress,
-		project_id: t.task.project_id,
-		tags: t.tags,
-	};
-}
-
-export function useDevpad(
-	remote_url: Accessor<string | null>,
-	repo_name: Accessor<string>,
-): {
-	data: Accessor<DevpadRepoData | null>;
-	error: Accessor<string | null>;
-	loading: Accessor<boolean>;
-} {
-	const [data, setData] = createSignal<DevpadRepoData | null>(null);
-	const [error, setError] = createSignal<string | null>(null);
-	const [loading, setLoading] = createSignal(false);
-
-	async function fetchData() {
-		const state = getWidgetState();
-		if (!state.devpad?.api_key) {
-			setError("devpad not configured");
-			setData(null);
-			return;
-		}
-
-		const client = new ApiClient({
-			base_url: state.devpad.api_url ?? "https://devpad.tools/api/v1",
-			api_key: state.devpad.api_key,
-		});
-
-		const name = repo_name();
-		const url = remote_url();
-
-		const cache_key = url ?? name;
-		const cached = data_cache.get(cache_key);
-		if (cached) {
-			setData(cached);
-			setError(null);
-			return;
-		}
-
-		setLoading(true);
-
-		try {
-			await dedup.run(cache_key, async () => {
-				let projects = project_cache.get("all");
-				if (!projects) {
-					const projects_result = await client.projects.list();
-					if (!projects_result.ok) {
-						throw new Error(projects_result.error.message);
-					}
-					projects = projects_result.value.map(toDevpadProject);
-					project_cache.set("all", projects, PROJECT_CACHE_TTL);
-				}
-
-				const matched = matchRepoToProject(url, name, projects);
-				if (!matched) {
-					data_cache.set(cache_key, { project: null, tasks: [], milestones: [] }, DATA_CACHE_TTL);
-					return;
-				}
-
-				const [tasks_result, milestones_result] = await Promise.all([
-					client.tasks.getByProject(matched.id),
-					client.milestones.getByProject(matched.id),
-				]);
-
-				const tasks: DevpadTask[] = tasks_result.ok
-					? tasks_result.value
-							.map(toDevpadTask)
-							.filter((t) => t.progress !== "COMPLETED")
-					: [];
-
-				const raw_milestones: ApiMilestone[] = milestones_result.ok
-					? milestones_result.value.filter((m) => !m.finished_at)
-					: [];
-
-				const milestones: DevpadMilestone[] = await Promise.all(
-					raw_milestones.map(async (m) => {
-						const goals_result = await client.milestones.goals(m.id);
-						const goals: ApiGoal[] = goals_result.ok ? goals_result.value : [];
-						return {
-							id: m.id,
-							name: m.name,
-							target_version: m.target_version ?? null,
-							target_time: m.target_time ?? null,
-							finished_at: m.finished_at ?? null,
-							goals_total: goals.length,
-							goals_completed: goals.filter((g) => g.finished_at !== null).length,
-						};
-					}),
-				);
-
-				const repo_data: DevpadRepoData = {
-					project: matched,
-					tasks,
-					milestones,
-				};
-
-				data_cache.set(cache_key, repo_data, DATA_CACHE_TTL);
-			});
-		} catch (e) {
-			setError(e instanceof Error ? e.message : String(e));
-			setLoading(false);
-			return;
-		}
-
-		// Read from cache (populated by whichever instance ran first)
-		const fresh = data_cache.get(cache_key);
-		if (fresh) {
-			setData(fresh);
-			setError(null);
-		}
-		setLoading(false);
-	}
-
-	createEffect(() => {
-		remote_url();
-		repo_name();
-		getWidgetState();
-		fetchData();
-	});
-
-	return { data, error, loading };
-}

package/packages/render/src/lib/use-github.ts

@@ -1,75 +0,0 @@
-import { createSignal, createEffect, type Accessor } from "solid-js";
-import { DataCache } from "@overview/core/cache";
-import { collectGithubData, type GithubRepoData, type GithubError } from "@overview/core/github";
-import { InFlightDedup } from "./fetch-context";
-
-const cache = new DataCache<GithubRepoData>();
-const dedup = new InFlightDedup<void>();
-
-const GITHUB_CACHE_TTL = 120_000;
-
-export function useGithub(
-	repo_path: Accessor<string | null>,
-	remote_url: Accessor<string | null>,
-): {
-	data: Accessor<GithubRepoData | null>;
-	error: Accessor<GithubError | null>;
-	loading: Accessor<boolean>;
-	refresh: () => void;
-} {
-	const [data, setData] = createSignal<GithubRepoData | null>(null);
-	const [error, setError] = createSignal<GithubError | null>(null);
-	const [loading, setLoading] = createSignal(false);
-
-	async function fetchData() {
-		const path = repo_path();
-		const url = remote_url();
-		if (!path) {
-			setData(null);
-			setError(null);
-			return;
-		}
-
-		const cached = cache.get(path);
-		if (cached) {
-			setData(cached);
-			setError(null);
-			return;
-		}
-
-		setLoading(true);
-
-		// Deduplicate: if another widget instance is already fetching this path,
-		// wait for it instead of starting a redundant fetch
-		await dedup.run(path, async () => {
-			const result = await collectGithubData(path, url);
-			if (result.ok) {
-				cache.set(path, result.value, GITHUB_CACHE_TTL);
-			}
-		});
-
-		// Read result from cache (populated by whichever instance ran first)
-		const fresh = cache.get(path);
-		if (fresh) {
-			setData(fresh);
-			setError(null);
-		} else {
-			setData(null);
-			setError(null);
-		}
-		setLoading(false);
-	}
-
-	createEffect(() => {
-		repo_path();
-		remote_url();
-		fetchData();
-	});
-
-	return {
-		data,
-		error,
-		loading,
-		refresh: fetchData,
-	};
-}