@os-eco/overstory-cli 0.9.1 → 0.9.3

package/src/commands/dashboard.ts

@@ -46,6 +46,7 @@ import type {
 	MailMessage,
 	OverstoryConfig,
 	StoredEvent,
+	TaskTrackerBackend,
 } from "../types.ts";
 import { evaluateHealth } from "../watchdog/health.ts";
 import { isProcessAlive } from "../worktree/tmux.ts";
@@ -59,10 +60,13 @@ const PKG_VERSION: string = JSON.parse(await Bun.file(pkgPath).text()).version ?
  * These are not colors, so they stay separate from the color module.
  */
 const CURSOR = {
-	clear: "\x1b[2J\x1b[H", // Clear screen and home cursor
+	clear: "\x1b[H\x1b[J", // Home cursor then clear from cursor to end
+	home: "\x1b[H", // Home cursor only (for redraw without full clear)
 	cursorTo: (row: number, col: number) => `\x1b[${row};${col}H`,
 	hideCursor: "\x1b[?25l",
 	showCursor: "\x1b[?25h",
+	enterAltScreen: "\x1b[?1049h", // Enter alternate screen buffer
+	leaveAltScreen: "\x1b[?1049l", // Leave alternate screen buffer
 } as const;
 
 /**
@@ -353,6 +357,7 @@ async function loadDashboardData(
 	thresholds?: { staleMs: number; zombieMs: number },
 	eventBuffer?: EventBuffer,
 	runtimeConfig?: OverstoryConfig["runtime"],
+	taskTrackerBackend?: TaskTrackerBackend,
 ): Promise<DashboardData> {
 	// Get all sessions from the pre-opened session store — fall back to cache on SQLite errors.
 	let allSessions: AgentSession[];
@@ -513,7 +518,7 @@ async function loadDashboardData(
 	const now2 = Date.now();
 	if (!trackerCache || now2 - trackerCache.fetchedAt > TRACKER_CACHE_TTL_MS) {
 		try {
-			const backend = await resolveBackend("auto", root);
+			const backend = await resolveBackend(taskTrackerBackend ?? "auto", root);
 			const tracker = createTrackerClient(backend, root);
 			tasks = await tracker.list({ limit: 10 });
 			trackerCache = { tasks, fetchedAt: now2 };
@@ -960,11 +965,13 @@ function renderMetricsPanel(
 /**
  * Render the full dashboard.
  */
-function renderDashboard(data: DashboardData, interval: number): void {
+function renderDashboard(data: DashboardData, interval: number, isFirstRender: boolean): void {
 	const width = process.stdout.columns ?? 100;
 	const height = process.stdout.rows ?? 30;
 
-	let output = CURSOR.clear;
+	// First render: clear entire alt screen. Subsequent: just home cursor
+	// and overwrite in-place (avoids Warp's block-per-clear issue).
+	let output = isFirstRender ? CURSOR.clear : CURSOR.home;
 
 	// Header (rows 1-2)
 	output += renderHeader(width, interval, data.currentRunId);
@@ -1050,20 +1057,44 @@ async function executeDashboard(opts: DashboardOpts): Promise<void> {
 		zombieMs: config.watchdog.zombieThresholdMs,
 	};
 
-	// Hide cursor
+	// Enter alternate screen buffer (like vim/htop) + hide cursor + raw stdin
+	process.stdout.write(CURSOR.enterAltScreen);
 	process.stdout.write(CURSOR.hideCursor);
+	if (process.stdin.isTTY) {
+		process.stdin.setRawMode(true);
+		process.stdin.resume();
+	}
 
-	// Clean exit on Ctrl+C
+	// Clean exit on Ctrl+C or 'q': restore original screen
 	let running = true;
-	process.on("SIGINT", () => {
+	const cleanup = () => {
 		running = false;
+		if (process.stdin.isTTY) {
+			process.stdin.setRawMode(false);
+			process.stdin.pause();
+		}
 		closeDashboardStores(stores);
 		process.stdout.write(CURSOR.showCursor);
-		process.stdout.write(CURSOR.clear);
+		process.stdout.write(CURSOR.leaveAltScreen);
+	};
+
+	process.on("SIGINT", () => {
+		cleanup();
 		process.exitCode = 0;
 	});
 
+	// Allow 'q' to quit the dashboard
+	process.stdin.on("data", (data: Buffer) => {
+		const key = data.toString();
+		if (key === "q" || key === "\x03") {
+			// 'q' or Ctrl+C
+			cleanup();
+			process.exitCode = 0;
+		}
+	});
+
 	// Poll loop — errors are caught per-tick so transient DB failures never crash the dashboard.
+	let isFirstRender = true;
 	let lastGoodData: DashboardData | null = null;
 	let lastErrorMsg: string | null = null;
 	while (running) {
@@ -1075,14 +1106,23 @@ async function executeDashboard(opts: DashboardOpts): Promise<void> {
 				thresholds,
 				eventBuffer,
 				config.runtime,
+				config.taskTracker.backend,
 			);
 			lastGoodData = data;
+			// If recovering from an error, clear the stale error line at the bottom
+			if (lastErrorMsg !== null) {
+				const w = process.stdout.columns ?? 100;
+				const h = process.stdout.rows ?? 30;
+				process.stdout.write(`${CURSOR.cursorTo(h, 1)}${" ".repeat(w)}`);
+			}
 			lastErrorMsg = null;
-			renderDashboard(data, interval);
+			renderDashboard(data, interval, isFirstRender);
+			isFirstRender = false;
 		} catch (err) {
 			// Render last good frame so the TUI stays alive, then show the error inline.
 			if (lastGoodData) {
-				renderDashboard(lastGoodData, interval);
+				renderDashboard(lastGoodData, interval, isFirstRender);
+				isFirstRender = false;
 			}
 			lastErrorMsg = err instanceof Error ? err.message : String(err);
 			const w = process.stdout.columns ?? 100;

package/src/commands/doctor.ts

@@ -19,6 +19,7 @@ import { checkProviders } from "../doctor/providers.ts";
 import { checkStructure } from "../doctor/structure.ts";
 import type { DoctorCategory, DoctorCheck, DoctorCheckFn } from "../doctor/types.ts";
 import { checkVersion } from "../doctor/version.ts";
+import { checkWatchdog } from "../doctor/watchdog.ts";
 import { ValidationError } from "../errors.ts";
 import { jsonOutput } from "../json.ts";
 import { color } from "../logging/color.ts";
@@ -37,6 +38,7 @@ const ALL_CHECKS: Array<{ category: DoctorCategory; fn: DoctorCheckFn }> = [
 	{ category: "version", fn: checkVersion },
 	{ category: "ecosystem", fn: checkEcosystem },
 	{ category: "providers", fn: checkProviders },
+	{ category: "watchdog", fn: checkWatchdog },
 ];
 
 /**
@@ -168,7 +170,7 @@ export function createDoctorCommand(options?: DoctorCommandOptions): Command {
 		.option("--fix", "Attempt to auto-fix issues")
 		.addHelpText(
 			"after",
-			"\nCategories: dependencies, structure, config, databases, consistency, agents, merge, logs, version, ecosystem, providers",
+			"\nCategories: dependencies, structure, config, databases, consistency, agents, merge, logs, version, ecosystem, providers, watchdog",
 		)
 		.action(
 			async (opts: { json?: boolean; verbose?: boolean; category?: string; fix?: boolean }) => {

package/src/commands/ecosystem.test.ts

@@ -7,7 +7,13 @@
  */
 
 import { describe, expect, test } from "bun:test";
-import { createEcosystemCommand, executeEcosystem } from "./ecosystem.ts";
+import {
+	createEcosystemCommand,
+	executeEcosystem,
+	formatDoctorLine,
+	printHumanOutput,
+	type ToolResult,
+} from "./ecosystem.ts";
 
 describe("createEcosystemCommand — CLI structure", () => {
 	test("command has correct name", () => {
@@ -99,3 +105,122 @@ describe("executeEcosystem — JSON output shape", () => {
 		}
 	}, 30_000);
 });
+
+describe("formatDoctorLine", () => {
+	test("pass-only shows green passed count", () => {
+		const result = formatDoctorLine({ pass: 5, warn: 0, fail: 0 });
+		expect(result).toContain("5 passed");
+		expect(result).not.toContain("warn");
+		expect(result).not.toContain("fail");
+	});
+
+	test("warn and fail without pass", () => {
+		const result = formatDoctorLine({ pass: 0, warn: 2, fail: 3 });
+		expect(result).toContain("2 warn");
+		expect(result).toContain("3 fail");
+		expect(result).not.toContain("passed");
+	});
+
+	test("all three counts present", () => {
+		const result = formatDoctorLine({ pass: 10, warn: 1, fail: 2 });
+		expect(result).toContain("10 passed");
+		expect(result).toContain("1 warn");
+		expect(result).toContain("2 fail");
+	});
+
+	test("all-zero returns 'no checks'", () => {
+		const result = formatDoctorLine({ pass: 0, warn: 0, fail: 0 });
+		expect(result).toBe("no checks");
+	});
+});
+
+// getInstalledVersion tests moved to src/utils/version.test.ts
+
+describe("printHumanOutput", () => {
+	function capturePrintOutput(results: ToolResult[]): string {
+		const chunks: string[] = [];
+		const original = process.stdout.write;
+		process.stdout.write = (chunk: string | Uint8Array) => {
+			chunks.push(typeof chunk === "string" ? chunk : new TextDecoder().decode(chunk));
+			return true;
+		};
+		try {
+			printHumanOutput(results);
+		} finally {
+			process.stdout.write = original;
+		}
+		return chunks.join("");
+	}
+
+	test("shows installed tool with version", () => {
+		const results: ToolResult[] = [
+			{
+				name: "test-tool",
+				cli: "tt",
+				npm: "@test/tool",
+				installed: true,
+				version: "1.2.3",
+				latest: "1.2.3",
+				upToDate: true,
+			},
+		];
+		const output = capturePrintOutput(results);
+		expect(output).toContain("test-tool");
+		expect(output).toContain("1.2.3");
+		expect(output).toContain("up to date");
+		expect(output).toContain("1/1 installed");
+	});
+
+	test("shows not-installed tool with install hint", () => {
+		const results: ToolResult[] = [
+			{
+				name: "missing-tool",
+				cli: "mt",
+				npm: "@test/missing",
+				installed: false,
+			},
+		];
+		const output = capturePrintOutput(results);
+		expect(output).toContain("missing-tool");
+		expect(output).toContain("not installed");
+		expect(output).toContain("npm i -g @test/missing");
+		expect(output).toContain("1 missing");
+	});
+
+	test("shows outdated tool with latest version", () => {
+		const results: ToolResult[] = [
+			{
+				name: "old-tool",
+				cli: "ot",
+				npm: "@test/old",
+				installed: true,
+				version: "1.0.0",
+				latest: "2.0.0",
+				upToDate: false,
+			},
+		];
+		const output = capturePrintOutput(results);
+		expect(output).toContain("old-tool");
+		expect(output).toContain("1.0.0");
+		expect(output).toContain("outdated");
+		expect(output).toContain("2.0.0");
+		expect(output).toContain("1 outdated");
+	});
+
+	test("shows latestError gracefully", () => {
+		const results: ToolResult[] = [
+			{
+				name: "err-tool",
+				cli: "et",
+				npm: "@test/err",
+				installed: true,
+				version: "1.0.0",
+				latestError: "network timeout",
+			},
+		];
+		const output = capturePrintOutput(results);
+		expect(output).toContain("err-tool");
+		expect(output).toContain("1.0.0");
+		expect(output).toContain("version check failed");
+	});
+});

package/src/commands/ecosystem.ts

@@ -9,6 +9,7 @@ import { Command } from "commander";
 import { jsonError, jsonOutput } from "../json.ts";
 import { accent, brand, color, muted } from "../logging/color.ts";
 import { thickSeparator } from "../logging/theme.ts";
+import { fetchLatestVersion, getInstalledVersion } from "../utils/version.ts";
 
 const TOOLS = [
 	{ name: "overstory", cli: "ov", npm: "@os-eco/overstory-cli" },
@@ -21,13 +22,13 @@ export interface EcosystemOptions {
 	json?: boolean;
 }
 
-interface DoctorSummary {
+export interface DoctorSummary {
 	pass: number;
 	warn: number;
 	fail: number;
 }
 
-interface ToolResult {
+export interface ToolResult {
 	name: string;
 	cli: string;
 	npm: string;
@@ -39,55 +40,6 @@ interface ToolResult {
 	latestError?: string;
 }
 
-async function getInstalledVersion(cli: string): Promise<string | null> {
-	// Try --version --json first
-	try {
-		const proc = Bun.spawn([cli, "--version", "--json"], {
-			stdout: "pipe",
-			stderr: "pipe",
-		});
-		const exitCode = await proc.exited;
-		if (exitCode === 0) {
-			const stdout = await new Response(proc.stdout).text();
-			try {
-				const data = JSON.parse(stdout.trim()) as { version?: string };
-				if (data.version) return data.version;
-			} catch {
-				// Not valid JSON, fall through to plain text
-			}
-		}
-	} catch {
-		// CLI not found — fall through to plain text fallback
-	}
-
-	// Fallback: --version plain text
-	try {
-		const proc = Bun.spawn([cli, "--version"], {
-			stdout: "pipe",
-			stderr: "pipe",
-		});
-		const exitCode = await proc.exited;
-		if (exitCode === 0) {
-			const stdout = await new Response(proc.stdout).text();
-			const match = stdout.match(/(\d+\.\d+\.\d+)/);
-			if (match?.[1]) return match[1];
-		}
-	} catch {
-		// CLI not found
-	}
-
-	return null;
-}
-
-async function fetchLatestVersion(packageName: string): Promise<string> {
-	const res = await fetch(`https://registry.npmjs.org/${packageName}/latest`);
-	if (!res.ok) {
-		throw new Error(`npm registry error: ${res.status} ${res.statusText}`);
-	}
-	const data = (await res.json()) as { version: string };
-	return data.version;
-}
-
 async function getDoctorSummary(): Promise<DoctorSummary | undefined> {
 	try {
 		const proc = Bun.spawn(["ov", "doctor", "--json"], {
@@ -158,7 +110,8 @@ async function checkTool(tool: { name: string; cli: string; npm: string }): Prom
 	};
 }
 
-function formatDoctorLine(summary: DoctorSummary): string {
+/** @internal Exported for testing. */
+export function formatDoctorLine(summary: DoctorSummary): string {
 	const parts: string[] = [];
 	if (summary.pass > 0) parts.push(color.green(`${summary.pass} passed`));
 	if (summary.warn > 0) parts.push(color.yellow(`${summary.warn} warn`));
@@ -166,7 +119,8 @@ function formatDoctorLine(summary: DoctorSummary): string {
 	return parts.length > 0 ? parts.join(", ") : "no checks";
 }
 
-function printHumanOutput(results: ToolResult[]): void {
+/** @internal Exported for testing. */
+export function printHumanOutput(results: ToolResult[]): void {
 	process.stdout.write(`${brand.bold("os-eco Ecosystem")}\n`);
 	process.stdout.write(`${thickSeparator()}\n`);
 	process.stdout.write("\n");

package/src/commands/feed.test.ts

@@ -14,9 +14,10 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { ValidationError } from "../errors.ts";
 import { createEventStore } from "../events/store.ts";
+import type { ColorFn } from "../logging/color.ts";
 import { cleanupTempDir } from "../test-helpers.ts";
-import type { InsertEvent } from "../types.ts";
-import { feedCommand } from "./feed.ts";
+import type { InsertEvent, StoredEvent } from "../types.ts";
+import { feedCommand, pollFeedTick } from "./feed.ts";
 
 /** Helper to create an InsertEvent with sensible defaults. */
 function makeEvent(overrides: Partial<InsertEvent> = {}): InsertEvent {
@@ -592,3 +593,117 @@ describe("feedCommand", () => {
 		});
 	});
 });
+
+describe("pollFeedTick", () => {
+	test("returns same lastSeenId when no new events", () => {
+		const queryFn = (): StoredEvent[] => [];
+		const colorMap = new Map<string, ColorFn>();
+
+		const result = pollFeedTick(42, queryFn, colorMap, true);
+		expect(result).toBe(42);
+	});
+
+	test("returns max id when new events are found", () => {
+		const events: StoredEvent[] = [
+			{
+				id: 50,
+				runId: "run-1",
+				agentName: "builder-1",
+				sessionId: "s1",
+				eventType: "tool_start",
+				toolName: "Bash",
+				toolArgs: null,
+				toolDurationMs: null,
+				level: "info",
+				data: null,
+				createdAt: new Date().toISOString(),
+			},
+			{
+				id: 51,
+				runId: "run-1",
+				agentName: "builder-1",
+				sessionId: "s1",
+				eventType: "tool_end",
+				toolName: "Bash",
+				toolArgs: null,
+				toolDurationMs: 100,
+				level: "info",
+				data: null,
+				createdAt: new Date().toISOString(),
+			},
+		];
+
+		const queryFn = (): StoredEvent[] => events;
+		const colorMap = new Map<string, ColorFn>();
+
+		// Capture stdout to avoid test noise
+		const origWrite = process.stdout.write;
+		const captured: string[] = [];
+		process.stdout.write = ((chunk: string) => {
+			captured.push(chunk);
+			return true;
+		}) as typeof process.stdout.write;
+
+		try {
+			const result = pollFeedTick(40, queryFn, colorMap, true);
+			expect(result).toBe(51);
+			// Should have produced JSON output
+			expect(captured.length).toBeGreaterThan(0);
+		} finally {
+			process.stdout.write = origWrite;
+		}
+	});
+
+	test("filters events to those with id > lastSeenId", () => {
+		const events: StoredEvent[] = [
+			{
+				id: 5,
+				runId: "run-1",
+				agentName: "builder-1",
+				sessionId: "s1",
+				eventType: "tool_start",
+				toolName: "Read",
+				toolArgs: null,
+				toolDurationMs: null,
+				level: "info",
+				data: null,
+				createdAt: new Date().toISOString(),
+			},
+			{
+				id: 10,
+				runId: "run-1",
+				agentName: "builder-1",
+				sessionId: "s1",
+				eventType: "tool_end",
+				toolName: "Read",
+				toolArgs: null,
+				toolDurationMs: 50,
+				level: "info",
+				data: null,
+				createdAt: new Date().toISOString(),
+			},
+		];
+
+		const queryFn = (): StoredEvent[] => events;
+		const colorMap = new Map<string, ColorFn>();
+
+		// With lastSeenId = 5, only event with id=10 should pass
+		const origWrite = process.stdout.write;
+		const captured: string[] = [];
+		process.stdout.write = ((chunk: string) => {
+			captured.push(chunk);
+			return true;
+		}) as typeof process.stdout.write;
+
+		try {
+			const result = pollFeedTick(5, queryFn, colorMap, true);
+			expect(result).toBe(10);
+			// Only 1 event should be emitted (the one with id > 5)
+			// Each JSON event is output on its own line
+			const jsonOutputs = captured.filter((c) => c.includes("tool_end"));
+			expect(jsonOutputs).toHaveLength(1);
+		} finally {
+			process.stdout.write = origWrite;
+		}
+	});
+});

package/src/commands/feed.ts

@@ -24,6 +24,51 @@ function printEvent(event: StoredEvent, colorMap: Map<string, ColorFn>): void {
 	process.stdout.write(`${formatEventLine(event, colorMap)}\n`);
 }
 
+/**
+ * Process one poll tick of the feed follow loop: query recent events,
+ * filter to those newer than lastSeenId, print them, and return the
+ * updated lastSeenId.
+ * @internal Exported for testing.
+ */
+export function pollFeedTick(
+	lastSeenId: number,
+	queryFn: (opts: { since: string; limit: number }) => StoredEvent[],
+	colorMap: Map<string, ColorFn>,
+	json: boolean,
+): number {
+	// Query events from 60s ago, then filter client-side for id > lastSeenId
+	const pollSince = new Date(Date.now() - 60 * 1000).toISOString();
+	const recentEvents = queryFn({ since: pollSince, limit: 1000 });
+
+	// Filter to new events only
+	const newEvents = recentEvents.filter((e) => e.id > lastSeenId);
+
+	if (newEvents.length > 0) {
+		if (!json) {
+			// Update color map for any new agents
+			extendAgentColorMap(colorMap, newEvents);
+
+			// Print new events
+			for (const event of newEvents) {
+				printEvent(event, colorMap);
+			}
+		} else {
+			// JSON mode: print each event as a line
+			for (const event of newEvents) {
+				jsonOutput("feed", { event });
+			}
+		}
+
+		// Update lastSeenId
+		const lastNew = newEvents[newEvents.length - 1];
+		if (lastNew) {
+			return lastNew.id;
+		}
+	}
+
+	return lastSeenId;
+}
+
 interface FeedOpts {
 	follow?: boolean;
 	interval?: string;
@@ -167,36 +212,7 @@ async function executeFeed(opts: FeedOpts): Promise<void> {
 		// Poll for new events
 		while (true) {
 			await Bun.sleep(interval);
-
-			// Query events from 60s ago, then filter client-side for id > lastSeenId
-			const pollSince = new Date(Date.now() - 60 * 1000).toISOString();
-			const recentEvents = queryEvents({ since: pollSince, limit: 1000 });
-
-			// Filter to new events only
-			const newEvents = recentEvents.filter((e) => e.id > lastSeenId);
-
-			if (newEvents.length > 0) {
-				if (!json) {
-					// Update color map for any new agents
-					extendAgentColorMap(globalColorMap, newEvents);
-
-					// Print new events
-					for (const event of newEvents) {
-						printEvent(event, globalColorMap);
-					}
-				} else {
-					// JSON mode: print each event as a line
-					for (const event of newEvents) {
-						jsonOutput("feed", { event });
-					}
-				}
-
-				// Update lastSeenId
-				const lastNew = newEvents[newEvents.length - 1];
-				if (lastNew) {
-					lastSeenId = lastNew.id;
-				}
-			}
+			lastSeenId = pollFeedTick(lastSeenId, queryEvents, globalColorMap, json);
 		}
 	} finally {
 		eventStore.close();