@ag-eco/agentplate-cli 0.13.0

package/src/doctor/merge-queue.test.ts

@@ -0,0 +1,315 @@
+import { Database } from "bun:sqlite";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { createMergeQueue } from "../merge/queue.ts";
+import type { AgentplateConfig } from "../types.ts";
+import { checkMergeQueue } from "./merge-queue.ts";
+import type { DoctorCheck } from "./types.ts";
+
+describe("checkMergeQueue", () => {
+	let tempDir: string;
+	let mockConfig: AgentplateConfig;
+
+	beforeEach(() => {
+		tempDir = mkdtempSync(join(tmpdir(), "agentplate-test-"));
+		mockConfig = {
+			project: { name: "test", root: tempDir, canonicalBranch: "main" },
+			agents: {
+				manifestPath: "",
+				baseDir: "",
+				maxConcurrent: 5,
+				staggerDelayMs: 100,
+				maxDepth: 2,
+				maxSessionsPerRun: 0,
+				maxAgentsPerLead: 5,
+			},
+			worktrees: { baseDir: "" },
+			taskTracker: { backend: "auto", enabled: true },
+			loam: { enabled: true, domains: [], primeFormat: "markdown" },
+			merge: { aiResolveEnabled: false, reimagineEnabled: false },
+			providers: {
+				anthropic: { type: "native" },
+			},
+			watchdog: {
+				tier0Enabled: true,
+				tier0IntervalMs: 30000,
+				tier1Enabled: false,
+				tier2Enabled: false,
+				staleThresholdMs: 300000,
+				zombieThresholdMs: 600000,
+				nudgeIntervalMs: 60000,
+			},
+			models: {},
+			logging: { verbose: false, redactSecrets: true },
+		};
+	});
+
+	afterEach(() => {
+		rmSync(tempDir, { recursive: true, force: true });
+	});
+
+	test("passes when merge queue db does not exist", () => {
+		const checks = checkMergeQueue(mockConfig, tempDir) as DoctorCheck[];
+
+		expect(checks).toHaveLength(1);
+		expect(checks[0]?.status).toBe("pass");
+		expect(checks[0]?.name).toBe("merge-queue.db exists");
+		expect(checks[0]?.message).toContain("normal for new installations");
+	});
+
+	test("passes when merge queue is empty", () => {
+		const dbPath = join(tempDir, "merge-queue.db");
+		// Create empty queue
+		const queue = createMergeQueue(dbPath);
+		queue.close();
+
+		const checks = checkMergeQueue(mockConfig, tempDir) as DoctorCheck[];
+
+		expect(checks).toHaveLength(1);
+		expect(checks[0]?.status).toBe("pass");
+		expect(checks[0]?.name).toBe("merge-queue.db schema");
+		expect(checks[0]?.message).toBe("Merge queue has 0 entries");
+	});
+
+	test("passes with valid queue entries", () => {
+		const dbPath = join(tempDir, "merge-queue.db");
+		const queue = createMergeQueue(dbPath);
+		queue.enqueue({
+			branchName: "feature/test",
+			taskId: "beads-abc",
+			agentName: "test-agent",
+			filesModified: ["src/test.ts"],
+		});
+		queue.enqueue({
+			branchName: "feature/another",
+			taskId: "beads-def",
+			agentName: "another-agent",
+			filesModified: ["src/another.ts"],
+		});
+		// Mark second entry as merged
+		const entry = queue.list()[1];
+		if (entry) {
+			queue.updateStatus(entry.branchName, "merged", "clean-merge");
+		}
+		queue.close();
+
+		const checks = checkMergeQueue(mockConfig, tempDir) as DoctorCheck[];
+
+		expect(checks).toHaveLength(1);
+		expect(checks[0]?.status).toBe("pass");
+		expect(checks[0]?.name).toBe("merge-queue.db schema");
+		expect(checks[0]?.message).toBe("Merge queue has 2 entries");
+	});
+
+	test("fails when db is corrupted", () => {
+		const dbPath = join(tempDir, "merge-queue.db");
+		// Write invalid data to db file
+		const fs = require("node:fs");
+		fs.writeFileSync(dbPath, "not a valid sqlite database");
+
+		const checks = checkMergeQueue(mockConfig, tempDir) as DoctorCheck[];
+
+		expect(checks).toHaveLength(1);
+		expect(checks[0]?.status).toBe("fail");
+		expect(checks[0]?.name).toBe("merge-queue.db readable");
+		expect(checks[0]?.message).toContain("Failed to read merge-queue.db");
+	});
+
+	test("fails when table does not exist", () => {
+		const dbPath = join(tempDir, "merge-queue.db");
+		// Create a db but without the merge_queue table
+		const db = new Database(dbPath);
+		db.exec("CREATE TABLE other_table (id INTEGER PRIMARY KEY)");
+		db.close();
+
+		const checks = checkMergeQueue(mockConfig, tempDir) as DoctorCheck[];
+
+		const schemaCheck = checks.find((c) => c?.name === "merge-queue.db schema");
+		expect(schemaCheck?.status).toBe("fail");
+		expect(schemaCheck?.message).toContain("merge_queue table not found");
+	});
+
+	test("warns about stale pending entries", () => {
+		const dbPath = join(tempDir, "merge-queue.db");
+		// Create queue and manually insert stale entry (2 days old)
+		const queue = createMergeQueue(dbPath);
+		queue.close();
+
+		const staleDate = new Date();
+		staleDate.setDate(staleDate.getDate() - 2); // 2 days ago
+
+		const db = new Database(dbPath);
+		db.prepare(
+			"INSERT INTO merge_queue (branch_name, task_id, agent_name, files_modified, status, enqueued_at) VALUES (?, ?, ?, ?, ?, ?)",
+		).run(
+			"feature/stale",
+			"beads-abc",
+			"test-agent",
+			JSON.stringify(["src/test.ts"]),
+			"pending",
+			staleDate.toISOString(),
+		);
+		db.close();
+
+		const checks = checkMergeQueue(mockConfig, tempDir) as DoctorCheck[];
+
+		const staleCheck = checks.find((c) => c?.name === "merge-queue.db staleness");
+		expect(staleCheck?.status).toBe("warn");
+		expect(staleCheck?.message).toContain("potentially stale");
+		expect(staleCheck?.details?.[0]).toContain("feature/stale");
+	});
+
+	test("does not warn about old completed entries", () => {
+		const dbPath = join(tempDir, "merge-queue.db");
+		// Create queue and manually insert old merged entry (2 days ago)
+		const queue = createMergeQueue(dbPath);
+		queue.close();
+
+		const oldDate = new Date();
+		oldDate.setDate(oldDate.getDate() - 2); // 2 days ago
+
+		const db = new Database(dbPath);
+		db.prepare(
+			"INSERT INTO merge_queue (branch_name, task_id, agent_name, files_modified, status, enqueued_at, resolved_tier) VALUES (?, ?, ?, ?, ?, ?, ?)",
+		).run(
+			"feature/old-merged",
+			"beads-abc",
+			"test-agent",
+			JSON.stringify(["src/test.ts"]),
+			"merged",
+			oldDate.toISOString(),
+			"clean-merge",
+		);
+		db.close();
+
+		const checks = checkMergeQueue(mockConfig, tempDir) as DoctorCheck[];
+
+		const staleCheck = checks.find((c) => c?.name === "merge-queue.db staleness");
+		expect(staleCheck).toBeUndefined();
+	});
+
+	test("warns about duplicate branches", () => {
+		const dbPath = join(tempDir, "merge-queue.db");
+		const queue = createMergeQueue(dbPath);
+		queue.enqueue({
+			branchName: "feature/duplicate",
+			taskId: "beads-abc",
+			agentName: "test-agent",
+			filesModified: ["src/test.ts"],
+		});
+		queue.enqueue({
+			branchName: "feature/duplicate",
+			taskId: "beads-def",
+			agentName: "another-agent",
+			filesModified: ["src/another.ts"],
+		});
+		queue.close();
+
+		const checks = checkMergeQueue(mockConfig, tempDir) as DoctorCheck[];
+
+		const duplicateCheck = checks.find((c) => c?.name === "merge-queue.db duplicates");
+		expect(duplicateCheck?.status).toBe("warn");
+		expect(duplicateCheck?.message).toContain("duplicate branch entries");
+		expect(duplicateCheck?.details?.[0]).toContain("feature/duplicate");
+	});
+
+	test("fix() deletes stale pending entries", () => {
+		const dbPath = join(tempDir, "merge-queue.db");
+		const queue = createMergeQueue(dbPath);
+		queue.close();
+
+		const staleDate = new Date();
+		staleDate.setDate(staleDate.getDate() - 2); // 2 days ago
+
+		const db = new Database(dbPath);
+		db.prepare(
+			"INSERT INTO merge_queue (branch_name, task_id, agent_name, files_modified, status, enqueued_at) VALUES (?, ?, ?, ?, ?, ?)",
+		).run(
+			"feature/stale-1",
+			"beads-abc",
+			"test-agent",
+			JSON.stringify(["src/test.ts"]),
+			"pending",
+			staleDate.toISOString(),
+		);
+		db.prepare(
+			"INSERT INTO merge_queue (branch_name, task_id, agent_name, files_modified, status, enqueued_at) VALUES (?, ?, ?, ?, ?, ?)",
+		).run(
+			"feature/stale-2",
+			"beads-def",
+			"test-agent",
+			JSON.stringify(["src/other.ts"]),
+			"merging",
+			staleDate.toISOString(),
+		);
+		db.close();
+
+		const checks = checkMergeQueue(mockConfig, tempDir) as DoctorCheck[];
+
+		const staleCheck = checks.find((c) => c?.name === "merge-queue.db staleness");
+		expect(staleCheck?.fix).toBeDefined();
+
+		const actions = staleCheck?.fix?.();
+		expect(Array.isArray(actions)).toBe(true);
+		const actionsArr = actions as string[];
+		expect(actionsArr.some((a) => a.includes("Deleted") && a.includes("stale"))).toBe(true);
+
+		// Verify entries were deleted
+		const verifyDb = new Database(dbPath);
+		const remaining = verifyDb
+			.prepare("SELECT COUNT(*) as count FROM merge_queue WHERE status IN ('pending', 'merging')")
+			.get() as { count: number };
+		verifyDb.close();
+		expect(remaining.count).toBe(0);
+	});
+
+	test("fix() removes duplicate entries keeping newest", () => {
+		const dbPath = join(tempDir, "merge-queue.db");
+		const queue = createMergeQueue(dbPath);
+		queue.enqueue({
+			branchName: "feature/dup",
+			taskId: "beads-abc",
+			agentName: "agent-1",
+			filesModified: ["src/a.ts"],
+		});
+		queue.enqueue({
+			branchName: "feature/dup",
+			taskId: "beads-def",
+			agentName: "agent-2",
+			filesModified: ["src/b.ts"],
+		});
+		queue.enqueue({
+			branchName: "feature/other",
+			taskId: "beads-ghi",
+			agentName: "agent-3",
+			filesModified: ["src/c.ts"],
+		});
+		queue.close();
+
+		const checks = checkMergeQueue(mockConfig, tempDir) as DoctorCheck[];
+
+		const dupCheck = checks.find((c) => c?.name === "merge-queue.db duplicates");
+		expect(dupCheck?.fix).toBeDefined();
+
+		const actions = dupCheck?.fix?.();
+		expect(Array.isArray(actions)).toBe(true);
+		const actionsArr = actions as string[];
+		expect(actionsArr.some((a) => a.includes("Removed") && a.includes("duplicate"))).toBe(true);
+
+		// Verify only 2 entries remain (1 per branch)
+		const verifyDb = new Database(dbPath);
+		const remaining = verifyDb.prepare("SELECT COUNT(*) as count FROM merge_queue").get() as {
+			count: number;
+		};
+		// Check the newest entry for feature/dup is kept (highest id)
+		const dupEntries = verifyDb
+			.prepare("SELECT agent_name FROM merge_queue WHERE branch_name = 'feature/dup'")
+			.all() as Array<{ agent_name: string }>;
+		verifyDb.close();
+		expect(remaining.count).toBe(2);
+		expect(dupEntries).toHaveLength(1);
+		expect(dupEntries[0]?.agent_name).toBe("agent-2"); // newest entry kept
+	});
+});

package/src/doctor/merge-queue.ts

@@ -0,0 +1,167 @@
+import { Database } from "bun:sqlite";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import type { DoctorCheck, DoctorCheckFn } from "./types.ts";
+
+/**
+ * Merge queue health checks.
+ * Validates merge-queue.db schema and detects stale entries.
+ */
+export const checkMergeQueue: DoctorCheckFn = (_config, agentplateDir): DoctorCheck[] => {
+	const checks: DoctorCheck[] = [];
+	const dbPath = join(agentplateDir, "merge-queue.db");
+
+	if (!existsSync(dbPath)) {
+		checks.push({
+			name: "merge-queue.db exists",
+			category: "merge",
+			status: "pass",
+			message: "No merge queue database (normal for new installations or no merges yet)",
+		});
+		return checks;
+	}
+
+	let db: Database;
+	try {
+		db = new Database(dbPath, { readonly: true });
+	} catch (err) {
+		checks.push({
+			name: "merge-queue.db readable",
+			category: "merge",
+			status: "fail",
+			message: "Failed to open merge-queue.db",
+			details: [err instanceof Error ? err.message : String(err)],
+			fixable: true,
+		});
+		return checks;
+	}
+
+	try {
+		// Check table exists
+		let tableCheck: unknown;
+		try {
+			tableCheck = db
+				.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='merge_queue'")
+				.get();
+		} catch (err) {
+			// Database is corrupted or not a valid SQLite file
+			checks.push({
+				name: "merge-queue.db readable",
+				category: "merge",
+				status: "fail",
+				message: "Failed to read merge-queue.db",
+				details: [err instanceof Error ? err.message : String(err)],
+				fixable: true,
+			});
+			db.close();
+			return checks;
+		}
+
+		if (!tableCheck) {
+			checks.push({
+				name: "merge-queue.db schema",
+				category: "merge",
+				status: "fail",
+				message: "merge_queue table not found in database",
+				fixable: true,
+			});
+			db.close();
+			return checks;
+		}
+
+		// Read all entries
+		const rows = db.prepare("SELECT * FROM merge_queue ORDER BY id ASC").all() as Array<{
+			branch_name: string;
+			agent_name: string;
+			status: string;
+			enqueued_at: string;
+			resolved_tier: string | null;
+		}>;
+
+		checks.push({
+			name: "merge-queue.db schema",
+			category: "merge",
+			status: "pass",
+			message: `Merge queue has ${rows.length} entries`,
+		});
+
+		// Check for stale entries (pending/merging older than 24h)
+		const now = new Date();
+		const staleThresholdMs = 24 * 60 * 60 * 1000;
+		const staleEntries: string[] = [];
+		for (const row of rows) {
+			if (row.status === "pending" || row.status === "merging") {
+				try {
+					const enqueuedAt = new Date(row.enqueued_at);
+					const ageMs = now.getTime() - enqueuedAt.getTime();
+					if (ageMs > staleThresholdMs) {
+						const ageHours = Math.floor(ageMs / (60 * 60 * 1000));
+						staleEntries.push(
+							`${row.branch_name} (${row.status}, ${ageHours}h old) - may be stuck`,
+						);
+					}
+				} catch {
+					/* invalid date */
+				}
+			}
+		}
+
+		if (staleEntries.length > 0) {
+			checks.push({
+				name: "merge-queue.db staleness",
+				category: "merge",
+				status: "warn",
+				message: `Found ${staleEntries.length} potentially stale queue entries`,
+				details: staleEntries,
+				fixable: true,
+				fix: () => {
+					const fixDb = new Database(dbPath);
+					fixDb.exec("PRAGMA busy_timeout=5000");
+					const staleThreshold = new Date(now.getTime() - staleThresholdMs).toISOString();
+					const result = fixDb
+						.prepare(
+							"DELETE FROM merge_queue WHERE status IN ('pending', 'merging') AND enqueued_at < ?",
+						)
+						.run(staleThreshold);
+					fixDb.close();
+					return [`Deleted ${result.changes} stale merge queue entries`];
+				},
+			});
+		}
+
+		// Check for duplicate branches
+		const branchCounts = new Map<string, number>();
+		for (const row of rows) {
+			branchCounts.set(row.branch_name, (branchCounts.get(row.branch_name) ?? 0) + 1);
+		}
+		const duplicates: string[] = [];
+		for (const [branch, count] of branchCounts) {
+			if (count > 1) duplicates.push(`${branch} (appears ${count} times)`);
+		}
+		if (duplicates.length > 0) {
+			checks.push({
+				name: "merge-queue.db duplicates",
+				category: "merge",
+				status: "warn",
+				message: "Found duplicate branch entries in queue",
+				details: duplicates,
+				fixable: true,
+				fix: () => {
+					const fixDb = new Database(dbPath);
+					fixDb.exec("PRAGMA busy_timeout=5000");
+					const result = fixDb
+						.prepare(
+							"DELETE FROM merge_queue WHERE id NOT IN (SELECT MAX(id) FROM merge_queue GROUP BY branch_name)",
+						)
+						.run();
+					fixDb.close();
+					return [`Removed ${result.changes} duplicate merge queue entries`];
+				},
+			});
+		}
+	} finally {
+		db.close();
+	}
+
+	return checks;
+};