@os-eco/overstory-cli 0.6.9 → 0.6.11

package/src/commands/ecosystem.ts

@@ -0,0 +1,291 @@
+/**
+ * CLI command: ov ecosystem
+ *
+ * Shows a summary dashboard of all installed os-eco tools: version, update
+ * status (latest vs outdated), and doctor health (overstory only).
+ */
+
+import { Command } from "commander";
+import { jsonError, jsonOutput } from "../json.ts";
+import { accent, brand, color, muted } from "../logging/color.ts";
+
+const TOOLS = [
+	{ name: "overstory", cli: "ov", npm: "@os-eco/overstory-cli" },
+	{ name: "mulch", cli: "ml", npm: "@os-eco/mulch-cli" },
+	{ name: "seeds", cli: "sd", npm: "@os-eco/seeds-cli" },
+	{ name: "canopy", cli: "cn", npm: "@os-eco/canopy-cli" },
+] as const;
+
+export interface EcosystemOptions {
+	json?: boolean;
+}
+
+interface DoctorSummary {
+	pass: number;
+	warn: number;
+	fail: number;
+}
+
+interface ToolResult {
+	name: string;
+	cli: string;
+	npm: string;
+	installed: boolean;
+	version?: string;
+	latest?: string;
+	upToDate?: boolean;
+	doctorSummary?: DoctorSummary;
+	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"], {
+			stdout: "pipe",
+			stderr: "pipe",
+		});
+		await proc.exited;
+		const stdout = await new Response(proc.stdout).text();
+		const trimmed = stdout.trim();
+		if (trimmed) {
+			const data = JSON.parse(trimmed) as {
+				summary?: { pass?: number; warn?: number; fail?: number };
+			};
+			if (data.summary) {
+				return {
+					pass: data.summary.pass ?? 0,
+					warn: data.summary.warn ?? 0,
+					fail: data.summary.fail ?? 0,
+				};
+			}
+		}
+	} catch {
+		// Doctor failed — report nothing
+	}
+	return undefined;
+}
+
+async function checkTool(tool: { name: string; cli: string; npm: string }): Promise<ToolResult> {
+	const version = await getInstalledVersion(tool.cli);
+
+	if (version === null) {
+		return { name: tool.name, cli: tool.cli, npm: tool.npm, installed: false };
+	}
+
+	let latest: string | undefined;
+	let latestError: string | undefined;
+	let doctorSummary: DoctorSummary | undefined;
+
+	const latestPromise = fetchLatestVersion(tool.npm)
+		.then((v) => {
+			latest = v;
+		})
+		.catch((err) => {
+			latestError = err instanceof Error ? err.message : String(err);
+		});
+
+	const doctorPromise =
+		tool.name === "overstory"
+			? getDoctorSummary().then((d) => {
+					doctorSummary = d;
+				})
+			: Promise.resolve();
+
+	await Promise.all([latestPromise, doctorPromise]);
+
+	const upToDate = latest !== undefined ? version === latest : undefined;
+
+	return {
+		name: tool.name,
+		cli: tool.cli,
+		npm: tool.npm,
+		installed: true,
+		version,
+		latest,
+		upToDate,
+		doctorSummary,
+		latestError,
+	};
+}
+
+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`));
+	if (summary.fail > 0) parts.push(color.red(`${summary.fail} fail`));
+	return parts.length > 0 ? parts.join(", ") : "no checks";
+}
+
+function printHumanOutput(results: ToolResult[]): void {
+	process.stdout.write(`${brand.bold("os-eco Ecosystem")}\n`);
+	process.stdout.write(`${"═".repeat(60)}\n`);
+	process.stdout.write("\n");
+
+	for (const tool of results) {
+		if (!tool.installed) {
+			process.stdout.write(
+				`  ${color.red("x")} ${accent(tool.name)} ${muted(`(${tool.cli})`)}  ${color.red("not installed")}\n`,
+			);
+			process.stdout.write(`    ${muted(`npm i -g ${tool.npm}`)}\n`);
+			process.stdout.write("\n");
+			continue;
+		}
+
+		// Determine status icon
+		let icon: string;
+		if (tool.latestError !== undefined || tool.upToDate === undefined) {
+			icon = muted("-");
+		} else if (tool.upToDate) {
+			icon = color.green("-");
+		} else {
+			icon = color.yellow("!");
+		}
+
+		process.stdout.write(`  ${icon} ${accent(tool.name)} ${muted(`(${tool.cli})`)}\n`);
+
+		// Version line
+		let versionLine = `Version: ${tool.version}`;
+		if (tool.latestError !== undefined) {
+			versionLine += ` ${muted("(version check failed)")}`;
+		} else if (tool.upToDate === true) {
+			versionLine += ` ${color.green("(up to date)")}`;
+		} else if (tool.upToDate === false) {
+			versionLine += ` ${color.yellow(`(outdated, latest: ${tool.latest})`)}`;
+		}
+		process.stdout.write(`    ${versionLine}\n`);
+
+		// Doctor summary (overstory only)
+		if (tool.doctorSummary !== undefined) {
+			process.stdout.write(`    Doctor:  ${formatDoctorLine(tool.doctorSummary)}\n`);
+		}
+
+		process.stdout.write("\n");
+	}
+
+	const installed = results.filter((t) => t.installed).length;
+	const missing = results.filter((t) => !t.installed).length;
+	const outdated = results.filter(
+		(t) => t.installed && t.upToDate === false && t.latestError === undefined,
+	).length;
+
+	let summary = `Summary: ${installed}/${results.length} installed`;
+	if (missing > 0) summary += `, ${missing} missing`;
+	if (outdated > 0) summary += `, ${outdated} outdated`;
+	process.stdout.write(`${summary}\n`);
+}
+
+export async function executeEcosystem(opts: EcosystemOptions): Promise<void> {
+	const json = opts.json ?? false;
+
+	let results: ToolResult[];
+	try {
+		results = await Promise.all(TOOLS.map((tool) => checkTool(tool)));
+	} catch (err) {
+		const msg = err instanceof Error ? err.message : String(err);
+		if (json) {
+			jsonError("ecosystem", msg);
+		} else {
+			process.stderr.write(`Error: ${msg}\n`);
+		}
+		process.exitCode = 1;
+		return;
+	}
+
+	if (json) {
+		const installed = results.filter((t) => t.installed).length;
+		const missing = results.filter((t) => !t.installed).length;
+		const outdated = results.filter(
+			(t) => t.installed && t.upToDate === false && t.latestError === undefined,
+		).length;
+
+		jsonOutput("ecosystem", {
+			tools: results.map((t) => {
+				const entry: Record<string, unknown> = {
+					name: t.name,
+					cli: t.cli,
+					npm: t.npm,
+					installed: t.installed,
+				};
+				if (t.installed) {
+					entry.version = t.version;
+					entry.latest = t.latest;
+					entry.upToDate = t.upToDate;
+					if (t.doctorSummary !== undefined) {
+						entry.doctorSummary = t.doctorSummary;
+					}
+					if (t.latestError !== undefined) {
+						entry.latestError = t.latestError;
+					}
+				}
+				return entry;
+			}),
+			summary: {
+				total: results.length,
+				installed,
+				missing,
+				outdated,
+			},
+		});
+		return;
+	}
+
+	printHumanOutput(results);
+}
+
+export function createEcosystemCommand(): Command {
+	return new Command("ecosystem")
+		.description("Show a summary dashboard of all installed os-eco tools")
+		.option("--json", "Output as JSON")
+		.action(async (opts: EcosystemOptions) => {
+			await executeEcosystem(opts);
+		});
+}

package/src/commands/feed.ts

@@ -264,7 +264,7 @@ async function executeFeed(opts: FeedOpts): Promise<void> {
 		} else {
 			// JSON mode: print each event as a line
 			for (const event of initialEvents) {
-				process.stdout.write(`${JSON.stringify(event)}\n`);
+				jsonOutput("feed", { event });
 			}
 			if (initialEvents.length > 0) {
 				const lastEvent = initialEvents[initialEvents.length - 1];
@@ -308,7 +308,7 @@ async function executeFeed(opts: FeedOpts): Promise<void> {
 				} else {
 					// JSON mode: print each event as a line
 					for (const event of newEvents) {
-						process.stdout.write(`${JSON.stringify(event)}\n`);
+						jsonOutput("feed", { event });
 					}
 				}
 

package/src/commands/group.ts

@@ -2,7 +2,7 @@
  * CLI command: ov group create|status|add|remove|list
  *
  * Manages TaskGroups for batch work coordination. Groups track collections
- * of beads issues and auto-close when all member issues are closed.
+ * of issues and auto-close when all member issues are closed.
  *
  * Storage: `.overstory/groups.json` (array of TaskGroup objects).
  */
@@ -312,7 +312,7 @@ export function createGroupCommand(): Command {
 		.argument("<name>", "Group name")
 		.argument("<ids...>", "Issue IDs to include")
 		.option("--json", "Output as JSON")
-		.option("--skip-validation", "Skip beads issue validation (for offline use)")
+		.option("--skip-validation", "Skip task validation (for offline use)")
 		.action(
 			async (name: string, ids: string[], opts: { json?: boolean; skipValidation?: boolean }) => {
 				const config = await loadConfig(process.cwd());
@@ -343,7 +343,7 @@ export function createGroupCommand(): Command {
 		.description("Show progress for one or all groups")
 		.argument("[group-id]", "Group ID (optional, shows all if omitted)")
 		.option("--json", "Output as JSON")
-		.option("--skip-validation", "Skip beads issue validation (for offline use)")
+		.option("--skip-validation", "Skip task validation (for offline use)")
 		.action(
 			async (groupId: string | undefined, opts: { json?: boolean; skipValidation?: boolean }) => {
 				const config = await loadConfig(process.cwd());
@@ -398,7 +398,7 @@ export function createGroupCommand(): Command {
 		.argument("<group-id>", "Group ID")
 		.argument("<ids...>", "Issue IDs to add")
 		.option("--json", "Output as JSON")
-		.option("--skip-validation", "Skip beads issue validation (for offline use)")
+		.option("--skip-validation", "Skip task validation (for offline use)")
 		.action(
 			async (
 				groupId: string,

package/src/commands/mail.test.ts

@@ -14,7 +14,7 @@ import { stripAnsi } from "../logging/color.ts";
 import { createMailClient } from "../mail/client.ts";
 import { createMailStore } from "../mail/store.ts";
 import type { StoredEvent } from "../types.ts";
-import { mailCommand } from "./mail.ts";
+import { AUTO_NUDGE_TYPES, isDispatchNudge, mailCommand, shouldAutoNudge } from "./mail.ts";
 
 describe("mailCommand", () => {
 	let tempDir: string;
@@ -1269,3 +1269,65 @@ describe("mailCommand", () => {
 		});
 	});
 });
+
+describe("shouldAutoNudge", () => {
+	test("returns true for urgent priority regardless of type", () => {
+		expect(shouldAutoNudge("status", "urgent")).toBe(true);
+	});
+
+	test("returns true for high priority regardless of type", () => {
+		expect(shouldAutoNudge("status", "high")).toBe(true);
+	});
+
+	test("returns true for worker_done type at normal priority", () => {
+		expect(shouldAutoNudge("worker_done", "normal")).toBe(true);
+	});
+
+	test("returns true for merge_ready type at normal priority", () => {
+		expect(shouldAutoNudge("merge_ready", "normal")).toBe(true);
+	});
+
+	test("returns true for error type at normal priority", () => {
+		expect(shouldAutoNudge("error", "normal")).toBe(true);
+	});
+
+	test("returns false for status type at normal priority", () => {
+		expect(shouldAutoNudge("status", "normal")).toBe(false);
+	});
+
+	test("returns false for question type at low priority", () => {
+		expect(shouldAutoNudge("question", "low")).toBe(false);
+	});
+});
+
+describe("isDispatchNudge", () => {
+	test("returns true for dispatch type", () => {
+		expect(isDispatchNudge("dispatch")).toBe(true);
+	});
+
+	test("returns false for worker_done type", () => {
+		expect(isDispatchNudge("worker_done")).toBe(false);
+	});
+
+	test("returns false for status type", () => {
+		expect(isDispatchNudge("status")).toBe(false);
+	});
+
+	test("returns false for error type", () => {
+		expect(isDispatchNudge("error")).toBe(false);
+	});
+});
+
+describe("AUTO_NUDGE_TYPES", () => {
+	test("contains worker_done, merge_ready, and error", () => {
+		expect(AUTO_NUDGE_TYPES.has("worker_done")).toBe(true);
+		expect(AUTO_NUDGE_TYPES.has("merge_ready")).toBe(true);
+		expect(AUTO_NUDGE_TYPES.has("error")).toBe(true);
+	});
+
+	test("does not contain regular semantic types", () => {
+		expect(AUTO_NUDGE_TYPES.has("status")).toBe(false);
+		expect(AUTO_NUDGE_TYPES.has("question")).toBe(false);
+		expect(AUTO_NUDGE_TYPES.has("result")).toBe(false);
+	});
+});

package/src/commands/mail.ts

@@ -24,7 +24,7 @@ import { MAIL_MESSAGE_TYPES } from "../types.ts";
  * Protocol message types that require immediate recipient attention.
  * These trigger auto-nudge regardless of priority level.
  */
-const AUTO_NUDGE_TYPES: ReadonlySet<MailMessageType> = new Set([
+export const AUTO_NUDGE_TYPES: ReadonlySet<MailMessageType> = new Set([
 	"worker_done",
 	"merge_ready",
 	"error",
@@ -32,6 +32,23 @@ const AUTO_NUDGE_TYPES: ReadonlySet<MailMessageType> = new Set([
 	"merge_failed",
 ]);
 
+/**
+ * Check if a message type/priority combination should trigger a pending nudge.
+ * Exported for testability.
+ */
+export function shouldAutoNudge(type: MailMessageType, priority: MailMessage["priority"]): boolean {
+	return priority === "urgent" || priority === "high" || AUTO_NUDGE_TYPES.has(type);
+}
+
+/**
+ * Check if a message type should trigger an immediate tmux dispatch nudge.
+ * Dispatch nudges target newly spawned agents at the welcome screen.
+ * Exported for testability.
+ */
+export function isDispatchNudge(type: MailMessageType): boolean {
+	return type === "dispatch";
+}
+
 /** Format a single message for human-readable output. */
 function formatMessage(msg: MailMessage): string {
 	const readMarker = msg.read ? " " : "*";

package/src/commands/merge.ts

@@ -47,7 +47,7 @@ function parseAgentName(branchName: string): string {
  * Pattern: overstory/{agentName}/{taskId}
  * Falls back to "unknown" if the pattern does not match.
  */
-function parseBeadId(branchName: string): string {
+function parseTaskId(branchName: string): string {
 	const parts = branchName.split("/");
 	if (parts[0] === "overstory" && parts[2] !== undefined) {
 		return parts[2];
@@ -213,7 +213,7 @@ async function handleBranch(
 		}
 
 		const agentName = parseAgentName(branchName);
-		const taskId = parseBeadId(branchName);
+		const taskId = parseTaskId(branchName);
 		const filesModified = await detectModifiedFiles(repoRoot, canonicalBranch, branchName);
 
 		entry = queue.enqueue({

package/src/commands/monitor.ts

@@ -8,7 +8,7 @@
  *
  * Unlike regular agents spawned by sling, the monitor:
  * - Has no worktree (operates on the main working tree)
- * - Has no bead assignment (it monitors, not implements)
+ * - Has no task assignment (it monitors, not implements)
  * - Has no overlay CLAUDE.md (context comes via ov status + mail)
  * - Persists across patrol cycles
  */
@@ -158,7 +158,7 @@ async function startMonitor(opts: { json: boolean; attach: boolean }): Promise<v
 			capability: "monitor",
 			worktreePath: projectRoot, // Monitor uses project root, not a worktree
 			branchName: config.project.canonicalBranch, // Operates on canonical branch
-			taskId: "", // No specific bead assignment
+			taskId: "", // No specific task assignment
 			tmuxSession,
 			state: "booting",
 			pid,