@os-eco/overstory-cli 0.8.7 → 0.9.2

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();