@f0rbit/overview 0.1.0 → 0.2.1

package/package.json

@@ -1,42 +1,49 @@
 {
   "name": "@f0rbit/overview",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "description": "Terminal UI dashboard for multi-repo git health",
-  "workspaces": ["packages/*"],
+  "workspaces": [
+    "packages/*"
+  ],
   "bin": {
-    "overview": "packages/render/src/overview.tsx"
+    "overview": "bin/overview"
   },
   "files": [
-    "packages/",
-    "bunfig.toml",
-    "tsconfig.json"
+    "dist/",
+    "bin/"
   ],
   "scripts": {
     "dev": "bun run --filter @overview/render dev",
     "typecheck": "bun run --filter '*' typecheck",
     "lint": "biome check .",
     "test": "bun test",
-    "build": "bun build packages/render/src/overview.tsx --compile --outfile overview"
+    "build": "bun build packages/render/src/overview.tsx --compile --outfile overview",
+    "build:bundle": "rm -rf dist && bun build packages/render/src/overview.tsx --outdir dist --target=bun --format=esm --external '@opentui/*' --external 'solid-js' --external 'solid-js/*'"
   },
   "repository": {
     "type": "git",
     "url": "https://github.com/f0rbit/overview.git"
   },
   "license": "MIT",
-  "keywords": ["git", "tui", "terminal", "dashboard", "bun", "solidjs"],
+  "keywords": [
+    "git",
+    "tui",
+    "terminal",
+    "dashboard",
+    "bun",
+    "solidjs"
+  ],
   "engines": {
     "bun": ">=1.0.0"
   },
-  "devDependencies": {
-    "typescript": "^5.7.0",
-    "@types/bun": "latest",
-    "@biomejs/biome": "^1.9.0"
-  },
   "dependencies": {
-    "@devpad/api": "^2.0.4",
-    "@f0rbit/corpus": "^0.3.5",
     "@opentui/core": "^0.1.80",
     "@opentui/solid": "^0.1.80",
     "solid-js": "^1.9.11"
+  },
+  "devDependencies": {
+    "typescript": "^5.7.0",
+    "@types/bun": "latest",
+    "@biomejs/biome": "^1.9.0"
   }
 }

package/bunfig.toml

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

package/packages/core/__tests__/concurrency.test.ts

@@ -1,111 +0,0 @@
-import { describe, test, expect } from "bun:test";
-import { createPool } from "../src/concurrency";
-
-describe("createPool", () => {
-	test("respects concurrency limit", async () => {
-		const pool = createPool(2);
-		let max_concurrent = 0;
-		let current = 0;
-
-		const task = async () => {
-			current++;
-			max_concurrent = Math.max(max_concurrent, current);
-			await Bun.sleep(30);
-			current--;
-		};
-
-		await Promise.all([
-			pool.run(task),
-			pool.run(task),
-			pool.run(task),
-			pool.run(task),
-			pool.run(task),
-		]);
-
-		expect(max_concurrent).toBe(2);
-		expect(current).toBe(0);
-	});
-
-	test("all tasks complete", async () => {
-		const pool = createPool(3);
-		const results: number[] = [];
-
-		const tasks = Array.from({ length: 10 }, (_, i) =>
-			pool.run(async () => {
-				await Bun.sleep(10);
-				results.push(i);
-				return i;
-			}),
-		);
-
-		const returned = await Promise.all(tasks);
-
-		expect(returned).toEqual([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
-		expect(results).toHaveLength(10);
-	});
-
-	test("errors propagate correctly", async () => {
-		const pool = createPool(2);
-
-		const failing = pool.run(async () => {
-			throw new Error("boom");
-		});
-
-		await expect(failing).rejects.toThrow("boom");
-
-		// Pool should still work after error
-		const result = await pool.run(async () => "ok");
-		expect(result).toBe("ok");
-	});
-
-	test("queued tasks run as active tasks complete", async () => {
-		const pool = createPool(1);
-		const order: string[] = [];
-
-		const p1 = pool.run(async () => {
-			await Bun.sleep(30);
-			order.push("first");
-		});
-
-		const p2 = pool.run(async () => {
-			order.push("second");
-		});
-
-		await Promise.all([p1, p2]);
-		expect(order).toEqual(["first", "second"]);
-	});
-
-	test("active_count and queue_length track state", async () => {
-		const pool = createPool(2);
-		const started: Array<() => void> = [];
-
-		// Create tasks that block until we release them
-		const make_blocking = () =>
-			pool.run(() => new Promise<void>((resolve) => { started.push(resolve); }));
-
-		const p1 = make_blocking();
-		const p2 = make_blocking();
-		const p3 = make_blocking();
-
-		// Wait for first two to start
-		await Bun.sleep(10);
-
-		expect(pool.active_count).toBe(2);
-		expect(pool.queue_length).toBe(1);
-
-		// Release first task
-		started[0]!();
-		await Bun.sleep(10);
-
-		expect(pool.active_count).toBe(2); // third task started
-		expect(pool.queue_length).toBe(0);
-
-		// Release remaining
-		started[1]!();
-		started[2]!();
-		await Promise.all([p1, p2, p3]);
-
-		expect(pool.active_count).toBe(0);
-		expect(pool.queue_length).toBe(0);
-	});
-});

package/packages/core/__tests__/helpers.ts

@@ -1,60 +0,0 @@
-import { mkdtemp, rm } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-async function run(args: string[], cwd: string): Promise<void> {
-	const proc = Bun.spawn(args, { cwd, stdout: "pipe", stderr: "pipe" });
-	const code = await proc.exited;
-	if (code !== 0) {
-		const stderr = await new Response(proc.stderr).text();
-		throw new Error(`Command failed: ${args.join(" ")}\n${stderr}`);
-	}
-}
-
-export async function createTempDir(): Promise<string> {
-	return mkdtemp(join(tmpdir(), "overview-test-"));
-}
-
-export async function cleanupTempDir(dir: string): Promise<void> {
-	await rm(dir, { recursive: true, force: true });
-}
-
-export async function initRepo(dir: string, name: string): Promise<string> {
-	const repo_path = join(dir, name);
-	await Bun.spawn(["mkdir", "-p", repo_path]).exited;
-	await run(["git", "init"], repo_path);
-	await run(["git", "config", "user.email", "test@test.com"], repo_path);
-	await run(["git", "config", "user.name", "Test User"], repo_path);
-	await Bun.write(join(repo_path, "README.md"), "# " + name);
-	await run(["git", "add", "."], repo_path);
-	await run(["git", "commit", "-m", "initial commit"], repo_path);
-	return repo_path;
-}
-
-export async function addCommit(
-	repoPath: string,
-	filename: string,
-	content: string,
-	message: string,
-): Promise<void> {
-	await Bun.write(join(repoPath, filename), content);
-	await run(["git", "add", filename], repoPath);
-	await run(["git", "commit", "-m", message], repoPath);
-}
-
-export async function createBranch(repoPath: string, branchName: string): Promise<void> {
-	await run(["git", "checkout", "-b", branchName], repoPath);
-}
-
-export async function modifyFile(repoPath: string, filename: string, content: string): Promise<void> {
-	await Bun.write(join(repoPath, filename), content);
-}
-
-export async function addUntracked(repoPath: string, filename: string, content: string): Promise<void> {
-	await Bun.write(join(repoPath, filename), content);
-}
-
-export async function stashChanges(repoPath: string): Promise<void> {
-	await Bun.write(join(repoPath, "README.md"), "stash content");
-	await run(["git", "stash"], repoPath);
-}

package/packages/core/__tests__/integration/git-status.test.ts

@@ -1,62 +0,0 @@
-import { describe, test, expect, beforeAll, afterAll } from "bun:test";
-import { mkdir } from "node:fs/promises";
-import { join } from "node:path";
-import { collectStatus } from "../../src/git-status";
-import {
-	createTempDir,
-	cleanupTempDir,
-	initRepo,
-	stashChanges,
-} from "../helpers";
-
-describe("git-status integration", () => {
-	let temp_dir: string;
-
-	beforeAll(async () => {
-		temp_dir = await createTempDir();
-	});
-
-	afterAll(async () => {
-		await cleanupTempDir(temp_dir);
-	});
-
-	test("parses branch info", async () => {
-		const dir = join(temp_dir, "branch-test");
-		await mkdir(dir, { recursive: true });
-		const repo_path = await initRepo(dir, "branch-repo");
-
-		const result = await collectStatus(repo_path, dir);
-		expect(result.ok).toBe(true);
-		if (!result.ok) return;
-
-		// git init may default to "main" or "master"
-		expect(["main", "master"]).toContain(result.value.current_branch);
-	});
-
-	test("detects stashes", async () => {
-		const dir = join(temp_dir, "stash-test");
-		await mkdir(dir, { recursive: true });
-		const repo_path = await initRepo(dir, "stash-repo");
-		await stashChanges(repo_path);
-
-		const result = await collectStatus(repo_path, dir);
-		expect(result.ok).toBe(true);
-		if (!result.ok) return;
-
-		expect(result.value.stash_count).toBeGreaterThan(0);
-	});
-
-	test("handles repo with no remote", async () => {
-		const dir = join(temp_dir, "no-remote-test");
-		await mkdir(dir, { recursive: true });
-		const repo_path = await initRepo(dir, "no-remote-repo");
-
-		const result = await collectStatus(repo_path, dir);
-		expect(result.ok).toBe(true);
-		if (!result.ok) return;
-
-		expect(result.value.remote_url).toBeNull();
-		expect(result.value.ahead).toBe(0);
-		expect(result.value.behind).toBe(0);
-	});
-});

package/packages/core/__tests__/integration/scanner.test.ts

@@ -1,140 +0,0 @@
-import { describe, test, expect, beforeAll, afterAll } from "bun:test";
-import { mkdir } from "node:fs/promises";
-import { join } from "node:path";
-import { scanDirectory, scanAndCollect } from "../../src/index";
-import {
-	createTempDir,
-	cleanupTempDir,
-	initRepo,
-	addCommit,
-	modifyFile,
-	addUntracked,
-} from "../helpers";
-
-describe("scanner integration", () => {
-	let temp_dir: string;
-
-	beforeAll(async () => {
-		temp_dir = await createTempDir();
-	});
-
-	afterAll(async () => {
-		await cleanupTempDir(temp_dir);
-	});
-
-	test("discovers repos at root level", async () => {
-		const dir = join(temp_dir, "root-level");
-		await mkdir(dir, { recursive: true });
-		await initRepo(dir, "repo-a");
-		await initRepo(dir, "repo-b");
-		await initRepo(dir, "repo-c");
-
-		const result = await scanDirectory(dir, { depth: 1, ignore: [] });
-		expect(result.ok).toBe(true);
-		if (!result.ok) return;
-
-		const repos = result.value.filter((n) => n.type === "repo");
-		expect(repos.length).toBe(3);
-		expect(repos.map((r) => r.name).sort()).toEqual(["repo-a", "repo-b", "repo-c"]);
-	});
-
-	test("discovers nested repos", async () => {
-		const dir = join(temp_dir, "nested");
-		await mkdir(dir, { recursive: true });
-		const nested_path = join(dir, "a", "b");
-		await mkdir(nested_path, { recursive: true });
-		await initRepo(nested_path, "repo1");
-
-		const result = await scanDirectory(dir, { depth: 4, ignore: [] });
-		expect(result.ok).toBe(true);
-		if (!result.ok) return;
-
-		const find_repo = (nodes: typeof result.value): boolean =>
-			nodes.some((n) => (n.type === "repo" && n.name === "repo1") || find_repo(n.children));
-
-		expect(find_repo(result.value)).toBe(true);
-	});
-
-	test("ignores directories matching ignore patterns", async () => {
-		const dir = join(temp_dir, "ignore-test");
-		await mkdir(dir, { recursive: true });
-		await initRepo(dir, "good-repo");
-		const nm_dir = join(dir, "node_modules");
-		await mkdir(nm_dir, { recursive: true });
-		await initRepo(nm_dir, "hidden-repo");
-
-		const result = await scanDirectory(dir, { depth: 2, ignore: ["node_modules"] });
-		expect(result.ok).toBe(true);
-		if (!result.ok) return;
-
-		const all_names = flatNames(result.value);
-		expect(all_names).toContain("good-repo");
-		expect(all_names).not.toContain("node_modules");
-		expect(all_names).not.toContain("hidden-repo");
-	});
-
-	test("collects status for clean repo", async () => {
-		const dir = join(temp_dir, "clean-test");
-		await mkdir(dir, { recursive: true });
-		await initRepo(dir, "clean-repo");
-		await addCommit(join(dir, "clean-repo"), "file.txt", "content", "add file");
-
-		const result = await scanAndCollect(dir, { depth: 1, ignore: [] });
-		expect(result.ok).toBe(true);
-		if (!result.ok) return;
-
-		const repo = result.value.find((n) => n.name === "clean-repo");
-		expect(repo).toBeDefined();
-		expect(repo!.status).not.toBeNull();
-		expect(repo!.status!.is_clean).toBe(true);
-		expect(repo!.status!.health).toBe("clean");
-	});
-
-	test("detects dirty state", async () => {
-		const dir = join(temp_dir, "dirty-test");
-		await mkdir(dir, { recursive: true });
-		const repo_path = await initRepo(dir, "dirty-repo");
-		await addCommit(repo_path, "file.txt", "original", "add file");
-		await modifyFile(repo_path, "file.txt", "modified content");
-
-		const result = await scanAndCollect(dir, { depth: 1, ignore: [] });
-		expect(result.ok).toBe(true);
-		if (!result.ok) return;
-
-		const repo = result.value.find((n) => n.name === "dirty-repo");
-		expect(repo).toBeDefined();
-		expect(repo!.status).not.toBeNull();
-		expect(repo!.status!.modified_count).toBeGreaterThan(0);
-		expect(repo!.status!.health).toBe("dirty");
-	});
-
-	test("detects untracked files", async () => {
-		const dir = join(temp_dir, "untracked-test");
-		await mkdir(dir, { recursive: true });
-		const repo_path = await initRepo(dir, "untracked-repo");
-		await addUntracked(repo_path, "new-file.txt", "untracked content");
-
-		const result = await scanAndCollect(dir, { depth: 1, ignore: [] });
-		expect(result.ok).toBe(true);
-		if (!result.ok) return;
-
-		const repo = result.value.find((n) => n.name === "untracked-repo");
-		expect(repo).toBeDefined();
-		expect(repo!.status).not.toBeNull();
-		expect(repo!.status!.untracked_count).toBeGreaterThan(0);
-	});
-
-	test("returns empty array for empty directory", async () => {
-		const dir = join(temp_dir, "empty-test");
-		await mkdir(dir, { recursive: true });
-
-		const result = await scanDirectory(dir, { depth: 1, ignore: [] });
-		expect(result.ok).toBe(true);
-		if (!result.ok) return;
-		expect(result.value).toEqual([]);
-	});
-});
-
-function flatNames(nodes: { name: string; children: typeof nodes }[]): string[] {
-	return nodes.flatMap((n) => [n.name, ...flatNames(n.children)]);
-}

package/packages/core/__tests__/ocn.test.ts

@@ -1,164 +0,0 @@
-import { describe, test, expect, beforeEach, afterEach } from "bun:test";
-import { mkdtemp, rm, writeFile, mkdir } from "node:fs/promises";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-import { readOcnStates } from "../src/ocn";
-
-describe("readOcnStates", () => {
-	let temp_dir: string;
-	const original_env = process.env.OCN_STATE_DIR;
-
-	beforeEach(async () => {
-		temp_dir = await mkdtemp(join(tmpdir(), "ocn-test-"));
-		process.env.OCN_STATE_DIR = temp_dir;
-	});
-
-	afterEach(async () => {
-		if (original_env !== undefined) {
-			process.env.OCN_STATE_DIR = original_env;
-		} else {
-			delete process.env.OCN_STATE_DIR;
-		}
-		await rm(temp_dir, { recursive: true, force: true });
-	});
-
-	test("returns empty map when state dir is empty", async () => {
-		const result = await readOcnStates();
-		expect(result.ok).toBe(true);
-		if (result.ok) {
-			expect(result.value.size).toBe(0);
-		}
-	});
-
-	test("returns empty map when state dir does not exist", async () => {
-		process.env.OCN_STATE_DIR = join(temp_dir, "nonexistent");
-		const result = await readOcnStates();
-		expect(result.ok).toBe(true);
-		if (result.ok) {
-			expect(result.value.size).toBe(0);
-		}
-	});
-
-	test("reads valid state file with alive PID", async () => {
-		const pid = process.pid; // current process is always alive
-		const state = {
-			pid,
-			directory: "/Users/tom/dev/test-repo",
-			project: "test-repo",
-			status: "busy",
-			last_transition: "2026-01-01T00:00:00Z",
-			session_id: "ses_test123",
-		};
-		await writeFile(join(temp_dir, `${pid}.json`), JSON.stringify(state));
-
-		const result = await readOcnStates();
-		expect(result.ok).toBe(true);
-		if (result.ok) {
-			expect(result.value.size).toBe(1);
-			const entry = result.value.get("/Users/tom/dev/test-repo");
-			expect(entry).toBeDefined();
-			expect(entry!.pid).toBe(pid);
-			expect(entry!.status).toBe("busy");
-			expect(entry!.session_id).toBe("ses_test123");
-		}
-	});
-
-	test("filters out stale PIDs", async () => {
-		const state = {
-			pid: 99999999, // very unlikely to be a running process
-			directory: "/Users/tom/dev/stale-repo",
-			project: "stale-repo",
-			status: "busy",
-			last_transition: "2026-01-01T00:00:00Z",
-			session_id: "ses_stale",
-		};
-		await writeFile(join(temp_dir, "99999999.json"), JSON.stringify(state));
-
-		const result = await readOcnStates();
-		expect(result.ok).toBe(true);
-		if (result.ok) {
-			expect(result.value.size).toBe(0);
-		}
-	});
-
-	test("skips malformed JSON files", async () => {
-		await writeFile(join(temp_dir, "bad.json"), "not json {{{");
-		// Also write a valid one with alive PID
-		const pid = process.pid;
-		const state = {
-			pid,
-			directory: "/Users/tom/dev/good-repo",
-			project: "good-repo",
-			status: "idle",
-			last_transition: "2026-01-01T00:00:00Z",
-			session_id: "ses_good",
-		};
-		await writeFile(join(temp_dir, `${pid}.json`), JSON.stringify(state));
-
-		const result = await readOcnStates();
-		expect(result.ok).toBe(true);
-		if (result.ok) {
-			expect(result.value.size).toBe(1);
-			expect(result.value.has("/Users/tom/dev/good-repo")).toBe(true);
-		}
-	});
-
-	test("skips files with invalid status values", async () => {
-		const pid = process.pid;
-		const state = {
-			pid,
-			directory: "/Users/tom/dev/invalid",
-			project: "invalid",
-			status: "unknown_status",
-			last_transition: "2026-01-01T00:00:00Z",
-			session_id: "ses_invalid",
-		};
-		await writeFile(join(temp_dir, `${pid}.json`), JSON.stringify(state));
-
-		const result = await readOcnStates();
-		expect(result.ok).toBe(true);
-		if (result.ok) {
-			expect(result.value.size).toBe(0);
-		}
-	});
-
-	test("skips non-json files", async () => {
-		await writeFile(join(temp_dir, "readme.txt"), "not a state file");
-		const result = await readOcnStates();
-		expect(result.ok).toBe(true);
-		if (result.ok) {
-			expect(result.value.size).toBe(0);
-		}
-	});
-
-	test("reads multiple state files", async () => {
-		const pid = process.pid;
-		const state1 = {
-			pid,
-			directory: "/Users/tom/dev/repo-a",
-			project: "repo-a",
-			status: "busy",
-			last_transition: "2026-01-01T00:00:00Z",
-			session_id: "ses_a",
-		};
-		const state2 = {
-			pid,
-			directory: "/Users/tom/dev/repo-b",
-			project: "repo-b",
-			status: "prompting",
-			last_transition: "2026-01-01T00:00:00Z",
-			session_id: "ses_b",
-		};
-		// Use different filenames (same pid but different entries)
-		await writeFile(join(temp_dir, `${pid}.json`), JSON.stringify(state1));
-		await writeFile(join(temp_dir, `${pid}_2.json`), JSON.stringify(state2));
-
-		const result = await readOcnStates();
-		expect(result.ok).toBe(true);
-		if (result.ok) {
-			expect(result.value.size).toBe(2);
-			expect(result.value.get("/Users/tom/dev/repo-a")?.status).toBe("busy");
-			expect(result.value.get("/Users/tom/dev/repo-b")?.status).toBe("prompting");
-		}
-	});
-});

package/packages/core/package.json

@@ -1,13 +0,0 @@
-{
-  "name": "@overview/core",
-  "version": "0.1.0",
-  "main": "src/index.ts",
-  "types": "src/index.ts",
-  "scripts": {
-    "typecheck": "tsc --noEmit"
-  },
-  "dependencies": {
-    "@f0rbit/corpus": "link:@f0rbit/corpus",
-    "@devpad/api": "link:@devpad/api"
-  }
-}

package/packages/core/src/cache.ts

@@ -1,31 +0,0 @@
-export interface CacheEntry<T> {
-	data: T;
-	fetched_at: number;
-	ttl_ms: number;
-}
-
-export class DataCache<T> {
-	private entries = new Map<string, CacheEntry<T>>();
-
-	get(key: string): T | null {
-		const entry = this.entries.get(key);
-		if (!entry) return null;
-		if (Date.now() - entry.fetched_at > entry.ttl_ms) {
-			this.entries.delete(key);
-			return null;
-		}
-		return entry.data;
-	}
-
-	set(key: string, data: T, ttl_ms: number): void {
-		this.entries.set(key, { data, fetched_at: Date.now(), ttl_ms });
-	}
-
-	invalidate(key: string): void {
-		this.entries.delete(key);
-	}
-
-	clear(): void {
-		this.entries.clear();
-	}
-}