@katyella/legio 0.1.0

package/src/doctor/databases.ts

@@ -0,0 +1,211 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import Database from "better-sqlite3";
+import type { DoctorCheck, DoctorCheckFn } from "./types.ts";
+
+/**
+ * Database integrity checks.
+ * Validates SQLite databases (mail.db, metrics.db, sessions.db) exist and have correct schema.
+ */
+export const checkDatabases: DoctorCheckFn = (_config, legioDir): DoctorCheck[] => {
+	const checks: DoctorCheck[] = [];
+
+	// Define expected databases and their required tables
+	const databases = [
+		{
+			name: "mail.db",
+			tables: ["messages"],
+			requiredColumns: {
+				messages: [
+					"id",
+					"from_agent",
+					"to_agent",
+					"subject",
+					"body",
+					"type",
+					"priority",
+					"thread_id",
+					"payload",
+					"read",
+					"created_at",
+				],
+			},
+		},
+		{
+			name: "metrics.db",
+			tables: ["sessions"],
+			requiredColumns: {
+				sessions: [
+					"agent_name",
+					"bead_id",
+					"capability",
+					"started_at",
+					"completed_at",
+					"duration_ms",
+					"exit_code",
+					"merge_result",
+					"parent_agent",
+					"input_tokens",
+					"output_tokens",
+					"cache_read_tokens",
+					"cache_creation_tokens",
+					"estimated_cost_usd",
+					"model_used",
+				],
+			},
+		},
+		{
+			name: "sessions.db",
+			tables: ["sessions", "runs"],
+			requiredColumns: {
+				sessions: [
+					"id",
+					"agent_name",
+					"capability",
+					"worktree_path",
+					"branch_name",
+					"bead_id",
+					"tmux_session",
+					"state",
+					"pid",
+					"parent_agent",
+					"depth",
+					"run_id",
+					"started_at",
+					"last_activity",
+					"escalation_level",
+					"stalled_since",
+				],
+				runs: [
+					"id",
+					"started_at",
+					"completed_at",
+					"agent_count",
+					"coordinator_session_id",
+					"status",
+				],
+			},
+		},
+	];
+
+	for (const dbSpec of databases) {
+		const dbPath = join(legioDir, dbSpec.name);
+
+		// Check if database file exists
+		if (!existsSync(dbPath)) {
+			checks.push({
+				name: `${dbSpec.name} exists`,
+				category: "databases",
+				status: "fail",
+				message: `Database file ${dbSpec.name} does not exist`,
+				details: [`Expected at: ${dbPath}`],
+			});
+			continue;
+		}
+
+		// Try to open the database
+		let db: InstanceType<typeof Database> | null = null;
+		try {
+			db = new Database(dbPath);
+
+			// Check WAL mode is enabled
+			const journalMode = db.prepare("PRAGMA journal_mode").get() as
+				| { journal_mode: string }
+				| undefined;
+			const walEnabled = journalMode?.journal_mode?.toLowerCase() === "wal";
+
+			// Check for required tables
+			const missingTables: string[] = [];
+			const schemaIssues: string[] = [];
+
+			for (const tableName of dbSpec.tables) {
+				const tableExists = db
+					.prepare("SELECT COUNT(*) as count FROM sqlite_master WHERE type='table' AND name=?")
+					.get(tableName) as { count: number } | undefined;
+
+				if (!tableExists || tableExists.count === 0) {
+					missingTables.push(tableName);
+					continue;
+				}
+
+				// Check columns if table exists
+				const requiredCols =
+					dbSpec.requiredColumns[tableName as keyof typeof dbSpec.requiredColumns];
+				if (requiredCols) {
+					const columns = db.prepare(`PRAGMA table_info(${tableName})`).all() as Array<{
+						name: string;
+					}>;
+					const existingCols = new Set(columns.map((c) => c.name));
+
+					for (const reqCol of requiredCols) {
+						if (!existingCols.has(reqCol)) {
+							schemaIssues.push(`Table ${tableName} missing column: ${reqCol}`);
+						}
+					}
+				}
+			}
+
+			// Determine check status
+			if (missingTables.length > 0 || schemaIssues.length > 0) {
+				const details: string[] = [];
+				if (missingTables.length > 0) {
+					details.push(`Missing tables: ${missingTables.join(", ")}`);
+				}
+				if (schemaIssues.length > 0) {
+					details.push(...schemaIssues);
+				}
+				if (!walEnabled) {
+					details.push("WAL mode not enabled");
+				}
+
+				checks.push({
+					name: `${dbSpec.name} schema`,
+					category: "databases",
+					status: "fail",
+					message: `Database ${dbSpec.name} has schema issues`,
+					details,
+					fixable: true,
+				});
+			} else if (!walEnabled) {
+				checks.push({
+					name: `${dbSpec.name} WAL mode`,
+					category: "databases",
+					status: "warn",
+					message: `Database ${dbSpec.name} is not using WAL mode`,
+					details: ["WAL mode improves concurrent access performance"],
+					fixable: true,
+				});
+			} else {
+				checks.push({
+					name: `${dbSpec.name} health`,
+					category: "databases",
+					status: "pass",
+					message: `Database ${dbSpec.name} is healthy`,
+				});
+			}
+
+			db.close();
+		} catch (err) {
+			if (db) {
+				try {
+					db.close();
+				} catch {
+					// Ignore close errors
+				}
+			}
+
+			checks.push({
+				name: `${dbSpec.name} integrity`,
+				category: "databases",
+				status: "fail",
+				message: `Failed to open or validate ${dbSpec.name}`,
+				details: [
+					err instanceof Error ? err.message : String(err),
+					"Database may be corrupted or locked",
+				],
+			});
+		}
+	}
+
+	return checks;
+};

package/src/doctor/dependencies.test.ts

@@ -0,0 +1,150 @@
+import { describe, expect, test } from "vitest";
+import type { LegioConfig } from "../types.ts";
+import { checkDependencies } from "./dependencies.ts";
+
+// Minimal config for testing
+const mockConfig: LegioConfig = {
+	project: {
+		name: "test-project",
+		root: "/tmp/test",
+		canonicalBranch: "main",
+	},
+	agents: {
+		manifestPath: "/tmp/.legio/agent-manifest.json",
+		baseDir: "/tmp/.legio/agents",
+		maxConcurrent: 5,
+		staggerDelayMs: 1000,
+		maxDepth: 2,
+	},
+	worktrees: {
+		baseDir: "/tmp/.legio/worktrees",
+	},
+	beads: {
+		enabled: false,
+	},
+	mulch: {
+		enabled: false,
+		domains: [],
+		primeFormat: "markdown",
+	},
+	merge: {
+		aiResolveEnabled: false,
+		reimagineEnabled: false,
+	},
+	watchdog: {
+		tier0Enabled: false,
+		tier0IntervalMs: 30000,
+		tier1Enabled: false,
+		tier2Enabled: false,
+		zombieThresholdMs: 600000,
+		nudgeIntervalMs: 60000,
+	},
+	models: {},
+	logging: {
+		verbose: false,
+		redactSecrets: true,
+	},
+};
+
+describe("checkDependencies", () => {
+	test("returns checks for all required tools", async () => {
+		const checks = await checkDependencies(mockConfig, "/tmp/.legio");
+
+		expect(Array.isArray(checks)).toBe(true);
+		expect(checks.length).toBeGreaterThanOrEqual(5);
+
+		// Verify we have checks for each required tool
+		const toolNames = checks.map((c) => c.name);
+		expect(toolNames).toContain("git availability");
+		expect(toolNames).toContain("node availability");
+		expect(toolNames).toContain("tmux availability");
+		expect(toolNames).toContain("bd availability");
+		expect(toolNames).toContain("mulch availability");
+	});
+
+	test("includes bd CGO support check when bd is available", async () => {
+		const checks = await checkDependencies(mockConfig, "/tmp/.legio");
+
+		const bdCheck = checks.find((c) => c.name === "bd availability");
+		if (bdCheck?.status === "pass") {
+			const cgoCheck = checks.find((c) => c.name === "bd CGO support");
+			expect(cgoCheck).toBeDefined();
+			expect(cgoCheck?.category).toBe("dependencies");
+			expect(["pass", "warn", "fail"]).toContain(cgoCheck?.status ?? "");
+		}
+	});
+
+	test("all checks have required DoctorCheck fields", async () => {
+		const checks = await checkDependencies(mockConfig, "/tmp/.legio");
+
+		for (const check of checks) {
+			expect(check).toHaveProperty("name");
+			expect(check).toHaveProperty("category");
+			expect(check).toHaveProperty("status");
+			expect(check).toHaveProperty("message");
+
+			expect(check.category).toBe("dependencies");
+			expect(["pass", "warn", "fail"]).toContain(check.status);
+			expect(typeof check.name).toBe("string");
+			expect(typeof check.message).toBe("string");
+
+			if (check.details !== undefined) {
+				expect(Array.isArray(check.details)).toBe(true);
+			}
+
+			if (check.fixable !== undefined) {
+				expect(typeof check.fixable).toBe("boolean");
+			}
+		}
+	});
+
+	test("checks for commonly available tools should pass", async () => {
+		const checks = await checkDependencies(mockConfig, "/tmp/.legio");
+
+		// git and node should definitely be available in this environment
+		const gitCheck = checks.find((c) => c.name === "git availability");
+		const nodeCheck = checks.find((c) => c.name === "node availability");
+
+		expect(gitCheck).toBeDefined();
+		expect(nodeCheck).toBeDefined();
+
+		// These should pass in a normal development environment
+		expect(gitCheck?.status).toBe("pass");
+		expect(nodeCheck?.status).toBe("pass");
+
+		// Passing checks should include version info
+		if (gitCheck?.status === "pass") {
+			expect(Array.isArray(gitCheck.details)).toBe(true);
+			expect(gitCheck.details?.length).toBeGreaterThan(0);
+		}
+	});
+
+	test("checks include version details for available tools", async () => {
+		const checks = await checkDependencies(mockConfig, "/tmp/.legio");
+
+		const passingChecks = checks.filter((c) => c.status === "pass");
+
+		for (const check of passingChecks) {
+			expect(check.details).toBeDefined();
+			expect(Array.isArray(check.details)).toBe(true);
+			expect(check.details?.length).toBeGreaterThan(0);
+
+			// Version string should not be empty
+			const version = check.details?.[0];
+			expect(version).toBeDefined();
+			expect(typeof version).toBe("string");
+			expect(version?.length).toBeGreaterThan(0);
+		}
+	});
+
+	test("failing checks are marked as fixable", async () => {
+		const checks = await checkDependencies(mockConfig, "/tmp/.legio");
+
+		const failingChecks = checks.filter((c) => c.status === "fail" || c.status === "warn");
+
+		// If there are any failing checks, they should be marked fixable
+		for (const check of failingChecks) {
+			expect(check.fixable).toBe(true);
+		}
+	});
+});

package/src/doctor/dependencies.ts

@@ -0,0 +1,179 @@
+import { spawn } from "node:child_process";
+import type { DoctorCheck, DoctorCheckFn } from "./types.ts";
+
+/**
+ * External dependency checks.
+ * Validates that required CLI tools (git, node, tmux, bd, mulch) are available
+ * and that bd has functional CGO support for its Dolt database backend.
+ */
+export const checkDependencies: DoctorCheckFn = async (
+	_config,
+	_legioDir,
+): Promise<DoctorCheck[]> => {
+	const requiredTools = [
+		{ name: "git", versionFlag: "--version", required: true },
+		{ name: "node", versionFlag: "--version", required: true },
+		{ name: "tmux", versionFlag: "-V", required: true },
+		{ name: "bd", versionFlag: "--version", required: true },
+		{ name: "mulch", versionFlag: "--version", required: true },
+	];
+
+	const checks: DoctorCheck[] = [];
+
+	for (const tool of requiredTools) {
+		const check = await checkTool(tool.name, tool.versionFlag, tool.required);
+		checks.push(check);
+	}
+
+	// If bd is available, probe for CGO/Dolt backend functionality
+	const bdCheck = checks.find((c) => c.name === "bd availability");
+	if (bdCheck?.status === "pass") {
+		const cgoCheck = await checkBdCgoSupport();
+		checks.push(cgoCheck);
+	}
+
+	return checks;
+};
+
+/**
+ * Probe whether bd's Dolt database backend is functional.
+ * The npm-distributed bd binary may be built without CGO, which causes
+ * `bd init` and all database operations to fail even though `bd --version` succeeds.
+ * We detect this by running `bd status` in a temp directory and checking for
+ * the characteristic "without CGO support" error message.
+ */
+async function checkBdCgoSupport(): Promise<DoctorCheck> {
+	const { mkdtemp, rm } = await import("node:fs/promises");
+	const { join } = await import("node:path");
+	const { tmpdir } = await import("node:os");
+
+	let tempDir: string | undefined;
+	try {
+		tempDir = await mkdtemp(join(tmpdir(), "legio-bd-cgo-"));
+		const { exitCode, stderr } = await new Promise<{ exitCode: number; stderr: string }>(
+			(resolve, reject) => {
+				const proc = spawn("bd", ["status"], {
+					cwd: tempDir,
+					stdio: ["ignore", "ignore", "pipe"],
+				});
+				let stderr = "";
+				proc.stderr?.on("data", (chunk: Buffer) => {
+					stderr += chunk.toString();
+				});
+				proc.on("close", (code) => resolve({ exitCode: code ?? 1, stderr }));
+				proc.on("error", reject);
+			},
+		);
+
+		if (stderr.includes("without CGO support")) {
+			return {
+				name: "bd CGO support",
+				category: "dependencies",
+				status: "fail",
+				message: "bd binary was built without CGO — Dolt database operations will fail",
+				details: [
+					"The installed bd binary lacks CGO support required by its Dolt backend.",
+					"Workaround: rebuild bd from source with CGO_ENABLED=1 and ICU headers.",
+					"See: https://github.com/katyella/legio/issues/10",
+				],
+				fixable: true,
+			};
+		}
+
+		// Any other exit code is fine — bd status may fail for other reasons
+		// (no .beads/ dir, etc.) but those aren't CGO issues
+		if (exitCode === 0 || !stderr.includes("CGO")) {
+			return {
+				name: "bd CGO support",
+				category: "dependencies",
+				status: "pass",
+				message: "bd has functional database backend",
+				details: ["Dolt backend operational"],
+			};
+		}
+
+		return {
+			name: "bd CGO support",
+			category: "dependencies",
+			status: "warn",
+			message: `bd status returned unexpected error (exit code ${exitCode})`,
+			details: [stderr.trim().split("\n")[0] || "unknown error"],
+		};
+	} catch (error) {
+		return {
+			name: "bd CGO support",
+			category: "dependencies",
+			status: "warn",
+			message: "Could not verify bd CGO support",
+			details: [error instanceof Error ? error.message : String(error)],
+		};
+	} finally {
+		if (tempDir) {
+			await rm(tempDir, { recursive: true }).catch(() => {});
+		}
+	}
+}
+
+/**
+ * Check if a CLI tool is available by attempting to run it with a version flag.
+ */
+async function checkTool(
+	name: string,
+	versionFlag: string,
+	required: boolean,
+): Promise<DoctorCheck> {
+	try {
+		const { exitCode, stdout, stderr } = await new Promise<{
+			exitCode: number;
+			stdout: string;
+			stderr: string;
+		}>((resolve, reject) => {
+			const proc = spawn(name, [versionFlag], { stdio: ["ignore", "pipe", "pipe"] });
+			let stdout = "";
+			let stderr = "";
+			proc.stdout?.on("data", (chunk: Buffer) => {
+				stdout += chunk.toString();
+			});
+			proc.stderr?.on("data", (chunk: Buffer) => {
+				stderr += chunk.toString();
+			});
+			proc.on("close", (code) => resolve({ exitCode: code ?? 1, stdout, stderr }));
+			proc.on("error", reject);
+		});
+
+		if (exitCode === 0) {
+			const version = stdout.split("\n")[0]?.trim() || "version unknown";
+
+			return {
+				name: `${name} availability`,
+				category: "dependencies",
+				status: "pass",
+				message: `${name} is available`,
+				details: [version],
+			};
+		}
+
+		// Non-zero exit code
+		return {
+			name: `${name} availability`,
+			category: "dependencies",
+			status: required ? "fail" : "warn",
+			message: `${name} command failed (exit code ${exitCode})`,
+			details: stderr ? [stderr.trim()] : undefined,
+			fixable: true,
+		};
+	} catch (error) {
+		// Command not found or spawn failed
+		return {
+			name: `${name} availability`,
+			category: "dependencies",
+			status: required ? "fail" : "warn",
+			message: `${name} is not installed or not in PATH`,
+			details: [
+				`Install ${name} or ensure it is in your PATH`,
+				error instanceof Error ? error.message : String(error),
+			],
+			fixable: true,
+		};
+	}
+}