@ag-eco/agentplate-cli 0.13.0

package/src/doctor/databases.ts

@@ -0,0 +1,243 @@
+import { Database } from "bun:sqlite";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+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, agentplateDir): DoctorCheck[] => {
+	const checks: DoctorCheck[] = [];
+
+	// Define expected databases and their required tables. `optional` databases
+	// are created lazily (e.g. merge-queue.db on first merge), so their absence
+	// is normal rather than a failure.
+	const databases: Array<{
+		name: string;
+		tables: string[];
+		requiredColumns: Record<string, string[]>;
+		optional?: boolean;
+	}> = [
+		{
+			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",
+					"task_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",
+					"task_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",
+				],
+			},
+		},
+		{
+			name: "merge-queue.db",
+			optional: true,
+			tables: ["merge_queue"],
+			requiredColumns: {
+				merge_queue: [
+					"id",
+					"branch_name",
+					"task_id",
+					"agent_name",
+					"files_modified",
+					"enqueued_at",
+					"status",
+					"resolved_tier",
+				],
+			},
+		},
+	];
+
+	for (const dbSpec of databases) {
+		const dbPath = join(agentplateDir, dbSpec.name);
+
+		// Check if database file exists
+		if (!existsSync(dbPath)) {
+			checks.push({
+				name: `${dbSpec.name} exists`,
+				category: "databases",
+				// Optional DBs are created on demand — a missing file is normal,
+				// not a failure (consistent with the `merge` category check).
+				status: dbSpec.optional ? "pass" : "fail",
+				message: dbSpec.optional
+					? `${dbSpec.name} not yet created (normal — created on first use)`
+					: `Database file ${dbSpec.name} does not exist`,
+				details: [`Expected at: ${dbPath}`],
+			});
+			continue;
+		}
+
+		// Try to open the database
+		let db: Database | null = null;
+		try {
+			db = new Database(dbPath);
+
+			// Check WAL mode is enabled
+			const journalMode = db.prepare<{ journal_mode: string }, []>("PRAGMA journal_mode").get();
+			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<{ count: number }, [string]>(
+						"SELECT COUNT(*) as count FROM sqlite_master WHERE type='table' AND name=?",
+					)
+					.get(tableName);
+
+				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<{ name: string }, []>(`PRAGMA table_info(${tableName})`).all();
+					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,
+					fix: () => {
+						const fixDb = new Database(dbPath);
+						fixDb.exec("PRAGMA journal_mode=WAL");
+						fixDb.close();
+						return [`Enabled WAL mode on ${dbSpec.name}`];
+					},
+				});
+			} 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,296 @@
+import { describe, expect, test } from "bun:test";
+import type { AgentplateConfig } from "../types.ts";
+import { checkAlias, checkDependencies, checkTool } from "./dependencies.ts";
+
+// Minimal config for testing
+const mockConfig: AgentplateConfig = {
+	project: {
+		name: "test-project",
+		root: "/tmp/test",
+		canonicalBranch: "main",
+	},
+	agents: {
+		manifestPath: "/tmp/.agentplate/agent-manifest.json",
+		baseDir: "/tmp/.agentplate/agents",
+		maxConcurrent: 5,
+		staggerDelayMs: 1000,
+		maxDepth: 2,
+		maxSessionsPerRun: 0,
+		maxAgentsPerLead: 5,
+	},
+	worktrees: {
+		baseDir: "/tmp/.agentplate/worktrees",
+	},
+	taskTracker: {
+		backend: "auto",
+		enabled: false,
+	},
+	loam: {
+		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,
+	},
+};
+
+describe("checkDependencies", () => {
+	test("returns checks for all required tools", async () => {
+		const checks = await checkDependencies(mockConfig, "/tmp/.agentplate");
+
+		expect(checks).toBeArray();
+		expect(checks.length).toBeGreaterThanOrEqual(7);
+
+		// Verify we have checks for each required tool
+		const toolNames = checks.map((c) => c.name);
+		expect(toolNames).toContain("git availability");
+		expect(toolNames).toContain("bun availability");
+		expect(toolNames).toContain("tmux availability");
+		expect(toolNames).toContain("sr availability");
+		expect(toolNames).toContain("loam availability");
+		expect(toolNames).toContain("ap availability");
+		expect(toolNames).toContain("tl availability");
+	});
+
+	test("includes bd CGO support check when bd is available", async () => {
+		const checks = await checkDependencies(mockConfig, "/tmp/.agentplate");
+
+		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/.agentplate");
+
+		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(check.details).toBeArray();
+			}
+
+			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/.agentplate");
+
+		// git and bun should definitely be available in this environment
+		const gitCheck = checks.find((c) => c.name === "git availability");
+		const bunCheck = checks.find((c) => c.name === "bun availability");
+
+		expect(gitCheck).toBeDefined();
+		expect(bunCheck).toBeDefined();
+
+		// These should pass in a normal development environment
+		expect(gitCheck?.status).toBe("pass");
+		expect(bunCheck?.status).toBe("pass");
+
+		// Passing checks should include version info
+		if (gitCheck?.status === "pass") {
+			expect(gitCheck.details).toBeArray();
+			expect(gitCheck.details?.length).toBeGreaterThan(0);
+		}
+	});
+
+	test("checks include version details for available tools", async () => {
+		const checks = await checkDependencies(mockConfig, "/tmp/.agentplate");
+
+		const passingChecks = checks.filter((c) => c.status === "pass");
+
+		for (const check of passingChecks) {
+			expect(check.details).toBeDefined();
+			expect(check.details).toBeArray();
+			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/.agentplate");
+
+		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);
+		}
+	});
+
+	test("checks for sr when backend is sprout", async () => {
+		const sproutConfig: typeof mockConfig = {
+			...mockConfig,
+			taskTracker: { backend: "sprout", enabled: true },
+		};
+		const checks = await checkDependencies(sproutConfig, "/tmp/.agentplate");
+		const toolNames = checks.map((c) => c.name);
+		expect(toolNames).toContain("sr availability");
+		expect(toolNames).not.toContain("bd availability");
+	});
+
+	test("checks for sr when backend is auto (sprout is default)", async () => {
+		const checks = await checkDependencies(mockConfig, "/tmp/.agentplate");
+		const toolNames = checks.map((c) => c.name);
+		expect(toolNames).toContain("sr availability");
+		expect(toolNames).not.toContain("bd availability");
+	});
+
+	test("skips bd CGO check when backend is sprout", async () => {
+		const sproutConfig: typeof mockConfig = {
+			...mockConfig,
+			taskTracker: { backend: "sprout", enabled: true },
+		};
+		const checks = await checkDependencies(sproutConfig, "/tmp/.agentplate");
+		const cgoCheck = checks.find((c) => c.name === "bd CGO support");
+		expect(cgoCheck).toBeUndefined();
+	});
+
+	test("tl check is warn (not fail) when missing", async () => {
+		const checks = await checkDependencies(mockConfig, "/tmp/.agentplate");
+		const cnCheck = checks.find((c) => c.name === "tl availability");
+		expect(cnCheck).toBeDefined();
+		// tl is optional — should never be "fail", only "pass" or "warn"
+		expect(cnCheck?.status).not.toBe("fail");
+	});
+
+	test("checks short aliases for available tools", async () => {
+		const checks = await checkDependencies(mockConfig, "/tmp/.agentplate");
+		const loamCheck = checks.find((c) => c.name === "loam availability");
+		if (loamCheck?.status === "pass") {
+			const mlAlias = checks.find((c) => c.name === "lm alias");
+			expect(mlAlias).toBeDefined();
+			expect(mlAlias?.category).toBe("dependencies");
+			expect(["pass", "warn"]).toContain(mlAlias?.status ?? "");
+		}
+		const ovCheck = checks.find((c) => c.name === "ap availability");
+		if (ovCheck?.status === "pass") {
+			const ovAlias = checks.find((c) => c.name === "agentplate alias");
+			expect(ovAlias).toBeDefined();
+			expect(["pass", "warn"]).toContain(ovAlias?.status ?? "");
+		}
+	});
+
+	test("alias checks are only run when primary tool passes", async () => {
+		const checks = await checkDependencies(mockConfig, "/tmp/.agentplate");
+		// If loam failed, lm alias should NOT be present
+		const loamCheck = checks.find((c) => c.name === "loam availability");
+		const mlAlias = checks.find((c) => c.name === "lm alias");
+		if (loamCheck?.status !== "pass") {
+			expect(mlAlias).toBeUndefined();
+		}
+	});
+
+	test("install hints appear in details for missing tools", async () => {
+		const checks = await checkDependencies(mockConfig, "/tmp/.agentplate");
+		// Check any failing/warning check with an installHint has npm install guidance
+		const cnCheck = checks.find((c) => c.name === "tl availability");
+		if (cnCheck?.status === "warn" || cnCheck?.status === "fail") {
+			const hasInstallHint = cnCheck.details?.some((d) => d.includes("npm install -g"));
+			expect(hasInstallHint).toBe(true);
+		}
+	});
+
+	test("includes ap availability check", async () => {
+		const checks = await checkDependencies(mockConfig, "/tmp/.agentplate");
+		const ovCheck = checks.find((c) => c.name === "ap availability");
+		expect(ovCheck).toBeDefined();
+		expect(ovCheck?.category).toBe("dependencies");
+	});
+});
+
+describe("checkTool", () => {
+	test("git with --version passes", async () => {
+		const check = await checkTool("git", "--version", true);
+		expect(check.name).toBe("git availability");
+		expect(check.category).toBe("dependencies");
+		expect(check.status).toBe("pass");
+		expect(check.message).toContain("git");
+		expect(check.details).toBeArray();
+		expect(check.details?.length).toBeGreaterThan(0);
+	});
+
+	test("nonexistent tool with required: true returns fail", async () => {
+		const check = await checkTool("nonexistent-tool-xyz-999", "--version", true);
+		expect(check.status).toBe("fail");
+		expect(check.message).toContain("nonexistent-tool-xyz-999");
+		expect(check.fixable).toBe(true);
+	});
+
+	test("nonexistent tool with required: false returns warn", async () => {
+		const check = await checkTool("nonexistent-tool-xyz-999", "--version", false);
+		expect(check.status).toBe("warn");
+		expect(check.fixable).toBe(true);
+	});
+
+	test("installHint appears in details for missing tool", async () => {
+		const check = await checkTool("nonexistent-tool-xyz-999", "--version", true, "@test/fake-pkg");
+		expect(check.status).toBe("fail");
+		const detailsText = check.details?.join(" ") ?? "";
+		expect(detailsText).toContain("npm install -g @test/fake-pkg");
+	});
+});
+
+describe("checkAlias", () => {
+	test("real tool alias passes", async () => {
+		// git is universally available — use it as a "real alias"
+		const check = await checkAlias("git-tool", "git");
+		expect(check.name).toBe("git alias");
+		expect(check.category).toBe("dependencies");
+		expect(check.status).toBe("pass");
+		expect(check.message).toContain("git");
+	});
+
+	test("nonexistent alias returns warn", async () => {
+		const check = await checkAlias("some-tool", "nonexistent-alias-xyz-999");
+		expect(check.status).toBe("warn");
+		expect(check.name).toBe("nonexistent-alias-xyz-999 alias");
+		expect(check.fixable).toBe(true);
+	});
+
+	test("nonexistent alias with installHint includes hint in details", async () => {
+		const check = await checkAlias("some-tool", "nonexistent-alias-xyz-999", "@test/fake-pkg");
+		expect(check.status).toBe("warn");
+		const detailsText = check.details?.join(" ") ?? "";
+		expect(detailsText).toContain("@test/fake-pkg");
+	});
+});