@os-eco/overstory-cli 0.7.4 → 0.7.6

package/src/commands/init.ts

@@ -10,15 +10,148 @@
  */
 
 import { Database } from "bun:sqlite";
-import { mkdir, readdir } from "node:fs/promises";
+import { mkdir, readdir, stat } from "node:fs/promises";
 import { basename, join } from "node:path";
 import { DEFAULT_CONFIG } from "../config.ts";
 import { ValidationError } from "../errors.ts";
-import { printHint, printSuccess } from "../logging/color.ts";
+import { jsonOutput } from "../json.ts";
+import { printHint, printSuccess, printWarning } from "../logging/color.ts";
 import type { AgentManifest, OverstoryConfig } from "../types.ts";
 
 const OVERSTORY_DIR = ".overstory";
 
+// ---- Ecosystem Bootstrap ----
+
+/**
+ * Spawner abstraction for testability.
+ * Wraps Bun.spawn for running sibling CLI tools.
+ */
+export type Spawner = (
+	args: string[],
+	opts?: { cwd?: string },
+) => Promise<{ exitCode: number; stdout: string; stderr: string }>;
+
+const defaultSpawner: Spawner = async (args, opts) => {
+	const proc = Bun.spawn(args, {
+		cwd: opts?.cwd,
+		stdout: "pipe",
+		stderr: "pipe",
+	});
+	const exitCode = await proc.exited;
+	const stdout = await new Response(proc.stdout).text();
+	const stderr = await new Response(proc.stderr).text();
+	return { exitCode, stdout, stderr };
+};
+
+interface SiblingTool {
+	name: string;
+	cli: string;
+	dotDir: string;
+	initCmd: string[];
+	onboardCmd: string[];
+}
+
+const SIBLING_TOOLS: SiblingTool[] = [
+	{ name: "mulch", cli: "ml", dotDir: ".mulch", initCmd: ["init"], onboardCmd: ["onboard"] },
+	{ name: "seeds", cli: "sd", dotDir: ".seeds", initCmd: ["init"], onboardCmd: ["onboard"] },
+	{ name: "canopy", cli: "cn", dotDir: ".canopy", initCmd: ["init"], onboardCmd: ["onboard"] },
+];
+
+type ToolStatus = "initialized" | "already_initialized" | "skipped";
+type OnboardStatus = "appended" | "current";
+
+/**
+ * Resolve the set of sibling tools to bootstrap.
+ *
+ * If opts.tools is set (comma-separated list of names), filter to those.
+ * Otherwise start with all three and remove any skipped via skip flags.
+ */
+export function resolveToolSet(opts: InitOptions): SiblingTool[] {
+	if (opts.tools) {
+		const requested = opts.tools.split(",").map((t) => t.trim());
+		return SIBLING_TOOLS.filter((t) => requested.includes(t.name));
+	}
+	return SIBLING_TOOLS.filter((t) => {
+		if (t.name === "mulch" && opts.skipMulch) return false;
+		if (t.name === "seeds" && opts.skipSeeds) return false;
+		if (t.name === "canopy" && opts.skipCanopy) return false;
+		return true;
+	});
+}
+
+async function isToolInstalled(cli: string, spawner: Spawner): Promise<boolean> {
+	const result = await spawner([cli, "--version"]);
+	return result.exitCode === 0;
+}
+
+async function initSiblingTool(
+	tool: SiblingTool,
+	projectRoot: string,
+	spawner: Spawner,
+): Promise<ToolStatus> {
+	const installed = await isToolInstalled(tool.cli, spawner);
+	if (!installed) {
+		printWarning(
+			`${tool.name} not installed — skipping`,
+			`install: npm i -g @os-eco/${tool.name}-cli`,
+		);
+		return "skipped";
+	}
+
+	const result = await spawner([tool.cli, ...tool.initCmd], { cwd: projectRoot });
+	if (result.exitCode !== 0) {
+		// Check if dot directory already exists (already initialized)
+		try {
+			await stat(join(projectRoot, tool.dotDir));
+			return "already_initialized";
+		} catch {
+			// Directory doesn't exist — real failure
+			printWarning(`${tool.name} init failed`, result.stderr.trim() || result.stdout.trim());
+			return "skipped";
+		}
+	}
+
+	printSuccess(`Bootstrapped ${tool.name}`);
+	return "initialized";
+}
+
+async function onboardTool(
+	tool: SiblingTool,
+	projectRoot: string,
+	spawner: Spawner,
+): Promise<OnboardStatus> {
+	const installed = await isToolInstalled(tool.cli, spawner);
+	if (!installed) return "current";
+
+	const result = await spawner([tool.cli, ...tool.onboardCmd], { cwd: projectRoot });
+	return result.exitCode === 0 ? "appended" : "current";
+}
+
+/**
+ * Set up .gitattributes with merge=union entries for JSONL files.
+ *
+ * Only adds entries not already present. Returns true if file was modified.
+ */
+async function setupGitattributes(projectRoot: string): Promise<boolean> {
+	const entries = [".mulch/expertise/*.jsonl merge=union", ".seeds/issues.jsonl merge=union"];
+
+	const gitattrsPath = join(projectRoot, ".gitattributes");
+	let existing = "";
+
+	try {
+		existing = await Bun.file(gitattrsPath).text();
+	} catch {
+		// File doesn't exist yet — will be created
+	}
+
+	const missing = entries.filter((e) => !existing.includes(e));
+	if (missing.length === 0) return false;
+
+	const separator = existing.length > 0 && !existing.endsWith("\n") ? "\n" : "";
+	await Bun.write(gitattrsPath, `${existing}${separator}${missing.join("\n")}\n`);
+	return true;
+}
+
 /**
  * Detect the project name from git or fall back to directory name.
  */
@@ -511,6 +644,17 @@ export interface InitOptions {
 	yes?: boolean;
 	name?: string;
 	force?: boolean;
+	/** Comma-separated list of ecosystem tools to bootstrap (e.g. "mulch,seeds"). Default: all. */
+	tools?: string;
+	skipMulch?: boolean;
+	skipSeeds?: boolean;
+	skipCanopy?: boolean;
+	/** Skip the onboard step (injecting CLAUDE.md sections for ecosystem tools). */
+	skipOnboard?: boolean;
+	/** Output final result as JSON envelope. */
+	json?: boolean;
+	/** Injectable spawner for testability. */
+	_spawner?: Spawner;
 }
 
 /**
@@ -531,6 +675,7 @@ export async function initCommand(opts: InitOptions): Promise<void> {
 	const force = opts.force ?? false;
 	const yes = opts.yes ?? false;
 	const projectRoot = process.cwd();
+	const spawner = opts._spawner ?? defaultSpawner;
 	const overstoryPath = join(projectRoot, OVERSTORY_DIR);
 
 	// 0. Verify we're inside a git repository
@@ -633,6 +778,53 @@ export async function initCommand(opts: InitOptions): Promise<void> {
 		}
 	}
 
+	// 9. Bootstrap sibling ecosystem tools
+	const toolSet = resolveToolSet(opts);
+	const toolResults: Record<string, { status: ToolStatus; path: string }> = {
+		overstory: { status: "initialized", path: overstoryPath },
+	};
+
+	if (toolSet.length > 0) {
+		process.stdout.write("\n");
+		process.stdout.write("Bootstrapping ecosystem tools...\n\n");
+	}
+
+	for (const tool of toolSet) {
+		const status = await initSiblingTool(tool, projectRoot, spawner);
+		toolResults[tool.name] = {
+			status,
+			path: join(projectRoot, tool.dotDir),
+		};
+	}
+
+	// 10. Set up .gitattributes with merge=union for JSONL files
+	const gitattrsUpdated = await setupGitattributes(projectRoot);
+	if (gitattrsUpdated) {
+		printCreated(".gitattributes");
+	}
+
+	// 11. Run onboard for each tool (inject CLAUDE.md sections)
+	const onboardResults: Record<string, OnboardStatus> = {};
+	if (!opts.skipOnboard) {
+		for (const tool of toolSet) {
+			if (toolResults[tool.name]?.status !== "skipped") {
+				const status = await onboardTool(tool, projectRoot, spawner);
+				onboardResults[tool.name] = status;
+			}
+		}
+	}
+
+	// 12. Output final result
+	if (opts.json) {
+		jsonOutput("init", {
+			project: projectName,
+			tools: toolResults,
+			onboard: onboardResults,
+			gitattributes: gitattrsUpdated,
+		});
+		return;
+	}
+
 	printSuccess("Initialized");
 	printHint("Next: run `ov hooks install` to enable Claude Code hooks.");
 	printHint("Then: run `ov status` to see the current state.");

package/src/commands/monitor.ts

@@ -142,17 +142,18 @@ async function startMonitor(opts: { json: boolean; attach: boolean }): Promise<v
 		}
 
 		// Spawn tmux session at project root with Claude Code (interactive mode).
+		// Pass file path (not content) to avoid tmux "command too long" (overstory#45).
 		const agentDefPath = join(projectRoot, ".overstory", "agent-defs", "monitor.md");
 		const agentDefFile = Bun.file(agentDefPath);
-		let appendSystemPrompt: string | undefined;
+		let appendSystemPromptFile: string | undefined;
 		if (await agentDefFile.exists()) {
-			appendSystemPrompt = await agentDefFile.text();
+			appendSystemPromptFile = agentDefPath;
 		}
 		const spawnCmd = runtime.buildSpawnCommand({
 			model: resolvedModel.model,
 			permissionMode: "bypass",
 			cwd: projectRoot,
-			appendSystemPrompt,
+			appendSystemPromptFile,
 			env: {
 				...runtime.buildEnv(resolvedModel),
 				OVERSTORY_AGENT_NAME: MONITOR_NAME,

package/src/commands/supervisor.ts

@@ -169,18 +169,19 @@ async function startSupervisor(opts: {
 
 		// Spawn tmux session at project root with Claude Code (interactive mode).
 		// Inject the supervisor base definition via --append-system-prompt.
+		// Pass file path (not content) to avoid tmux "command too long" (overstory#45).
 		const tmuxSession = `overstory-${config.project.name}-supervisor-${opts.name}`;
 		const agentDefPath = join(projectRoot, ".overstory", "agent-defs", "supervisor.md");
 		const agentDefFile = Bun.file(agentDefPath);
-		let appendSystemPrompt: string | undefined;
+		let appendSystemPromptFile: string | undefined;
 		if (await agentDefFile.exists()) {
-			appendSystemPrompt = await agentDefFile.text();
+			appendSystemPromptFile = agentDefPath;
 		}
 		const spawnCmd = runtime.buildSpawnCommand({
 			model: resolvedModel.model,
 			permissionMode: "bypass",
 			cwd: projectRoot,
-			appendSystemPrompt,
+			appendSystemPromptFile,
 			env: {
 				...runtime.buildEnv(resolvedModel),
 				OVERSTORY_AGENT_NAME: opts.name,

package/src/doctor/providers.test.ts

@@ -0,0 +1,373 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { OverstoryConfig } from "../types.ts";
+import { checkProviders } from "./providers.ts";
+
+/** Build a minimal valid OverstoryConfig for testing. */
+function makeConfig(overrides: Partial<OverstoryConfig> = {}): OverstoryConfig {
+	const tmp = tmpdir();
+	return {
+		project: {
+			name: "test-project",
+			root: tmp,
+			canonicalBranch: "main",
+		},
+		agents: {
+			manifestPath: join(tmp, ".overstory", "agent-manifest.json"),
+			baseDir: join(tmp, ".overstory", "agents"),
+			maxConcurrent: 5,
+			staggerDelayMs: 1000,
+			maxDepth: 2,
+			maxSessionsPerRun: 0,
+			maxAgentsPerLead: 5,
+		},
+		worktrees: {
+			baseDir: join(tmp, ".overstory", "worktrees"),
+		},
+		taskTracker: {
+			backend: "auto",
+			enabled: false,
+		},
+		mulch: {
+			enabled: false,
+			domains: [],
+			primeFormat: "markdown",
+		},
+		merge: {
+			aiResolveEnabled: false,
+			reimagineEnabled: false,
+		},
+		providers: {
+			anthropic: { type: "native" },
+		},
+		watchdog: {
+			tier0Enabled: false,
+			tier0IntervalMs: 30000,
+			tier1Enabled: false,
+			tier2Enabled: false,
+			staleThresholdMs: 300000,
+			zombieThresholdMs: 600000,
+			nudgeIntervalMs: 60000,
+		},
+		models: {},
+		logging: {
+			verbose: false,
+			redactSecrets: true,
+		},
+		...overrides,
+	};
+}
+
+// Dummy overstoryDir — provider checks don't use the filesystem
+const OVERSTORY_DIR = join(tmpdir(), ".overstory");
+
+describe("checkProviders", () => {
+	test("all checks have required DoctorCheck fields", async () => {
+		const config = makeConfig();
+		const checks = await checkProviders(config, OVERSTORY_DIR);
+
+		expect(checks).toBeArray();
+		for (const check of checks) {
+			expect(typeof check.name).toBe("string");
+			expect(check.category).toBe("providers");
+			expect(["pass", "warn", "fail"]).toContain(check.status);
+			expect(typeof check.message).toBe("string");
+			if (check.details !== undefined) {
+				expect(check.details).toBeArray();
+			}
+		}
+	});
+
+	describe("providers-configured check", () => {
+		test("native-only config (no gateway) returns pass for providers-configured", async () => {
+			const config = makeConfig({
+				providers: { anthropic: { type: "native" } },
+			});
+			const checks = await checkProviders(config, OVERSTORY_DIR);
+
+			const check = checks.find((c) => c.name === "providers-configured");
+			expect(check).toBeDefined();
+			expect(check?.status).toBe("pass");
+		});
+
+		test("empty providers returns warn for providers-configured", async () => {
+			const config = makeConfig({ providers: {} });
+			const checks = await checkProviders(config, OVERSTORY_DIR);
+
+			const check = checks.find((c) => c.name === "providers-configured");
+			expect(check).toBeDefined();
+			expect(check?.status).toBe("warn");
+		});
+
+		test("providers-configured details list provider names and types", async () => {
+			const config = makeConfig({
+				providers: {
+					anthropic: { type: "native" },
+					openrouter: { type: "gateway", baseUrl: "https://openrouter.ai/api/v1" },
+				},
+			});
+			const checks = await checkProviders(config, OVERSTORY_DIR);
+
+			const check = checks.find((c) => c.name === "providers-configured");
+			expect(check?.status).toBe("pass");
+			expect(check?.details).toBeDefined();
+			expect(check?.details?.some((d) => d.includes("anthropic"))).toBe(true);
+			expect(check?.details?.some((d) => d.includes("openrouter"))).toBe(true);
+		});
+	});
+
+	describe("provider-reachable-{name} check", () => {
+		test("gateway config triggers reachability check (warn path — no real server)", async () => {
+			const config = makeConfig({
+				providers: {
+					fake: {
+						type: "gateway",
+						// Use a port that is almost certainly not listening
+						baseUrl: "http://127.0.0.1:19873",
+					},
+				},
+			});
+			const checks = await checkProviders(config, OVERSTORY_DIR);
+
+			const check = checks.find((c) => c.name === "provider-reachable-fake");
+			expect(check).toBeDefined();
+			expect(check?.status).toBe("warn");
+			expect(check?.message).toContain("fake");
+		});
+
+		test("reachability pass path — local HTTP server", async () => {
+			// Start a minimal Bun HTTP server on an ephemeral port
+			const server = Bun.serve({
+				port: 0, // OS assigns a free port
+				fetch() {
+					return new Response("ok");
+				},
+			});
+
+			try {
+				const config = makeConfig({
+					providers: {
+						localtest: {
+							type: "gateway",
+							baseUrl: `http://127.0.0.1:${server.port}`,
+						},
+					},
+				});
+				const checks = await checkProviders(config, OVERSTORY_DIR);
+
+				const check = checks.find((c) => c.name === "provider-reachable-localtest");
+				expect(check).toBeDefined();
+				expect(check?.status).toBe("pass");
+			} finally {
+				await server.stop();
+			}
+		});
+
+		test("gateway without baseUrl skips reachability check", async () => {
+			const config = makeConfig({
+				providers: {
+					nourl: { type: "gateway" }, // no baseUrl
+				},
+			});
+			const checks = await checkProviders(config, OVERSTORY_DIR);
+
+			const reachCheck = checks.find((c) => c.name === "provider-reachable-nourl");
+			expect(reachCheck).toBeUndefined();
+		});
+	});
+
+	describe("provider-auth-token-{name} check", () => {
+		const ENV_KEY = "OVERSTORY_TEST_FAKE_PROVIDER_TOKEN_XYZ";
+
+		beforeAll(() => {
+			// Ensure env var is unset before tests
+			delete process.env[ENV_KEY];
+		});
+
+		afterAll(() => {
+			delete process.env[ENV_KEY];
+		});
+
+		test("gateway with authTokenEnv warns when env var missing", async () => {
+			const config = makeConfig({
+				providers: {
+					testgateway: {
+						type: "gateway",
+						authTokenEnv: ENV_KEY,
+					},
+				},
+			});
+			const checks = await checkProviders(config, OVERSTORY_DIR);
+
+			const check = checks.find((c) => c.name === "provider-auth-token-testgateway");
+			expect(check).toBeDefined();
+			expect(check?.status).toBe("warn");
+			// Details must include the env var NAME, never a value
+			expect(check?.details?.some((d) => d.includes(ENV_KEY))).toBe(true);
+		});
+
+		test("gateway with authTokenEnv passes when env var is set", async () => {
+			process.env[ENV_KEY] = "test-token-value";
+
+			const config = makeConfig({
+				providers: {
+					testgateway: {
+						type: "gateway",
+						authTokenEnv: ENV_KEY,
+					},
+				},
+			});
+			const checks = await checkProviders(config, OVERSTORY_DIR);
+
+			const check = checks.find((c) => c.name === "provider-auth-token-testgateway");
+			expect(check).toBeDefined();
+			expect(check?.status).toBe("pass");
+			// Details include the var name, not the value
+			expect(check?.details?.some((d) => d.includes(ENV_KEY))).toBe(true);
+			// Value must NOT appear in details
+			expect(check?.details?.some((d) => d.includes("test-token-value"))).toBe(false);
+		});
+
+		test("native provider with no authTokenEnv skips auth-token check", async () => {
+			const config = makeConfig({
+				providers: { anthropic: { type: "native" } },
+			});
+			const checks = await checkProviders(config, OVERSTORY_DIR);
+
+			const authCheck = checks.find((c) => c.name?.startsWith("provider-auth-token-"));
+			expect(authCheck).toBeUndefined();
+		});
+	});
+
+	describe("tool-use-compat check", () => {
+		test("tool-heavy role with provider-prefixed model warns", async () => {
+			const config = makeConfig({
+				models: { builder: "openrouter/openai/gpt-4o" },
+				providers: {
+					openrouter: { type: "gateway", baseUrl: "https://openrouter.ai/api/v1" },
+				},
+			});
+			const checks = await checkProviders(config, OVERSTORY_DIR);
+
+			const check = checks.find((c) => c.name === "tool-use-compat" && c.status === "warn");
+			expect(check).toBeDefined();
+			expect(check?.message).toContain("builder");
+		});
+
+		test("non-tool-heavy role with provider-prefixed model does not warn", async () => {
+			// "lead" is not a tool-heavy role
+			const config = makeConfig({
+				models: { lead: "openrouter/openai/gpt-4o" },
+				providers: {
+					openrouter: { type: "gateway", baseUrl: "https://openrouter.ai/api/v1" },
+				},
+			});
+			const checks = await checkProviders(config, OVERSTORY_DIR);
+
+			const warnChecks = checks.filter((c) => c.name === "tool-use-compat" && c.status === "warn");
+			expect(warnChecks.length).toBe(0);
+		});
+
+		test("no tool-heavy roles with prefixed models emits single pass", async () => {
+			const config = makeConfig({
+				models: { builder: "sonnet" }, // alias, not provider-prefixed
+			});
+			const checks = await checkProviders(config, OVERSTORY_DIR);
+
+			const passCheck = checks.find((c) => c.name === "tool-use-compat" && c.status === "pass");
+			expect(passCheck).toBeDefined();
+		});
+
+		test("all three tool-heavy roles can trigger separate warns", async () => {
+			const config = makeConfig({
+				models: {
+					builder: "openrouter/openai/gpt-4o",
+					scout: "openrouter/openai/gpt-4o",
+					merger: "openrouter/openai/gpt-4o",
+				},
+				providers: {
+					openrouter: { type: "gateway", baseUrl: "https://openrouter.ai/api/v1" },
+				},
+			});
+			const checks = await checkProviders(config, OVERSTORY_DIR);
+
+			const warnChecks = checks.filter((c) => c.name === "tool-use-compat" && c.status === "warn");
+			expect(warnChecks.length).toBe(3);
+		});
+	});
+
+	describe("model-provider-ref(s) check", () => {
+		test("model referencing unknown provider fails", async () => {
+			const config = makeConfig({
+				models: { builder: "unknownprovider/some-model" },
+				// unknownprovider not in providers
+				providers: { anthropic: { type: "native" } },
+			});
+			const checks = await checkProviders(config, OVERSTORY_DIR);
+
+			const check = checks.find((c) => c.name === "model-provider-ref" && c.status === "fail");
+			expect(check).toBeDefined();
+			expect(check?.message).toContain("unknownprovider");
+		});
+
+		test("model referencing defined provider passes", async () => {
+			const config = makeConfig({
+				models: { builder: "openrouter/openai/gpt-4o" },
+				providers: {
+					openrouter: { type: "gateway", baseUrl: "https://openrouter.ai/api/v1" },
+				},
+			});
+			const checks = await checkProviders(config, OVERSTORY_DIR);
+
+			const check = checks.find((c) => c.name === "model-provider-ref" && c.status === "pass");
+			expect(check).toBeDefined();
+		});
+
+		test("no provider-prefixed models emits single pass named model-provider-refs", async () => {
+			const config = makeConfig({
+				models: { builder: "sonnet", scout: "haiku" },
+			});
+			const checks = await checkProviders(config, OVERSTORY_DIR);
+
+			const check = checks.find((c) => c.name === "model-provider-refs");
+			expect(check).toBeDefined();
+			expect(check?.status).toBe("pass");
+		});
+
+		test("empty models emits single pass named model-provider-refs", async () => {
+			const config = makeConfig({ models: {} });
+			const checks = await checkProviders(config, OVERSTORY_DIR);
+
+			const check = checks.find((c) => c.name === "model-provider-refs");
+			expect(check).toBeDefined();
+			expect(check?.status).toBe("pass");
+		});
+	});
+
+	describe("gateway-api-key-reminder check", () => {
+		test("gateway present triggers api-key reminder warn", async () => {
+			const config = makeConfig({
+				providers: {
+					openrouter: { type: "gateway", baseUrl: "http://127.0.0.1:19873" },
+				},
+			});
+			const checks = await checkProviders(config, OVERSTORY_DIR);
+
+			const check = checks.find((c) => c.name === "gateway-api-key-reminder");
+			expect(check).toBeDefined();
+			expect(check?.status).toBe("warn");
+			expect(check?.message).toContain("ANTHROPIC_API_KEY");
+		});
+
+		test("no gateway providers — reminder is absent", async () => {
+			const config = makeConfig({
+				providers: { anthropic: { type: "native" } },
+			});
+			const checks = await checkProviders(config, OVERSTORY_DIR);
+
+			const check = checks.find((c) => c.name === "gateway-api-key-reminder");
+			expect(check).toBeUndefined();
+		});
+	});
+});