@os-eco/overstory-cli 0.9.4 → 0.11.0

package/src/commands/merge.test.ts

@@ -1,7 +1,9 @@
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { writeFileSync } from "node:fs";
 import { mkdir } from "node:fs/promises";
 import { join } from "node:path";
-import { ValidationError } from "../errors.ts";
+import { MergeError, ValidationError } from "../errors.ts";
+import { mergeLockPath } from "../merge/lock.ts";
 import { createMergeQueue } from "../merge/queue.ts";
 import {
 	cleanupTempDir,
@@ -597,6 +599,233 @@ merge:
 		});
 	});
 
+	describe("concurrent-merge lock", () => {
+		test("refuses to start when another live ov merge holds the lock for the same target", async () => {
+			await setupProject(repoDir, defaultBranch);
+			const branchName = "overstory/builder/bead-lock-1";
+			await createCleanFeatureBranch(repoDir, branchName);
+
+			// Simulate another live ov merge by writing a lock file with this
+			// process's own PID — it is guaranteed alive, so the lock-holder check
+			// must treat it as an in-flight merge.
+			const lockPath = mergeLockPath(join(repoDir, ".overstory"), defaultBranch);
+			writeFileSync(
+				lockPath,
+				JSON.stringify({
+					pid: process.pid,
+					acquiredAt: new Date().toISOString(),
+					targetBranch: defaultBranch,
+				}),
+			);
+
+			const originalWrite = process.stdout.write.bind(process.stdout);
+			process.stdout.write = (): boolean => true;
+
+			try {
+				await mergeCommand({ branch: branchName });
+				expect(true).toBe(false); // should not reach here
+			} catch (err: unknown) {
+				expect(err).toBeInstanceOf(MergeError);
+				const msg = (err as MergeError).message;
+				expect(msg).toContain("Another ov merge is already running");
+				expect(msg).toContain(defaultBranch);
+			} finally {
+				process.stdout.write = originalWrite;
+			}
+		});
+
+		test("releases the lock after a successful merge so a second run can proceed", async () => {
+			await setupProject(repoDir, defaultBranch);
+			const branchName = "overstory/builder/bead-lock-2";
+			await createCleanFeatureBranch(repoDir, branchName);
+
+			const originalWrite = process.stdout.write.bind(process.stdout);
+			process.stdout.write = (): boolean => true;
+
+			try {
+				await mergeCommand({ branch: branchName, json: true });
+			} finally {
+				process.stdout.write = originalWrite;
+			}
+
+			// After release, a fresh `ov merge --dry-run` for an unrelated branch
+			// (which doesn't take a lock) should still see no leftover lock file.
+			const lockPath = mergeLockPath(join(repoDir, ".overstory"), defaultBranch);
+			expect(await Bun.file(lockPath).exists()).toBe(false);
+		});
+
+		test("--dry-run does not acquire the lock", async () => {
+			await setupProject(repoDir, defaultBranch);
+			const branchName = "overstory/builder/bead-lock-dry";
+			await createCleanFeatureBranch(repoDir, branchName);
+
+			const originalWrite = process.stdout.write.bind(process.stdout);
+			process.stdout.write = (): boolean => true;
+
+			try {
+				await mergeCommand({ branch: branchName, dryRun: true, json: true });
+			} finally {
+				process.stdout.write = originalWrite;
+			}
+
+			const lockPath = mergeLockPath(join(repoDir, ".overstory"), defaultBranch);
+			expect(await Bun.file(lockPath).exists()).toBe(false);
+		});
+
+		test("steals a stale lock (dead PID) and proceeds", async () => {
+			await setupProject(repoDir, defaultBranch);
+			const branchName = "overstory/builder/bead-lock-stale";
+			await createCleanFeatureBranch(repoDir, branchName);
+
+			// PID 2147483647 (INT_MAX) is virtually never assigned — treat as dead.
+			const lockPath = mergeLockPath(join(repoDir, ".overstory"), defaultBranch);
+			writeFileSync(
+				lockPath,
+				JSON.stringify({
+					pid: 2147483647,
+					acquiredAt: new Date(Date.now() - 10 * 60_000).toISOString(),
+					targetBranch: defaultBranch,
+				}),
+			);
+
+			let output = "";
+			const originalWrite = process.stdout.write.bind(process.stdout);
+			process.stdout.write = (chunk: unknown): boolean => {
+				output += String(chunk);
+				return true;
+			};
+
+			try {
+				await mergeCommand({ branch: branchName, json: true });
+			} finally {
+				process.stdout.write = originalWrite;
+			}
+
+			const parsed = JSON.parse(output);
+			expect(parsed.success).toBe(true);
+			// Lock should be released after success.
+			expect(await Bun.file(lockPath).exists()).toBe(false);
+		});
+	});
+
+	describe("--dry-run conflict prediction", () => {
+		test("--dry-run --json includes prediction.wouldRequireAgent for contentful-canonical conflict", async () => {
+			await setupProject(repoDir, defaultBranch);
+
+			// Build a real contentful-canonical conflict on src/shared.ts.
+			await commitFile(repoDir, "src/shared.ts", "shared base\n");
+			const branchName = "overstory/builder/bead-predict-1";
+			await runGitInDir(repoDir, ["checkout", "-b", branchName]);
+			await commitFile(repoDir, "src/shared.ts", "feature side\n");
+			await runGitInDir(repoDir, ["checkout", defaultBranch]);
+			await commitFile(repoDir, "src/shared.ts", "main side\n");
+
+			let output = "";
+			const originalWrite = process.stdout.write.bind(process.stdout);
+			process.stdout.write = (chunk: unknown): boolean => {
+				output += String(chunk);
+				return true;
+			};
+
+			try {
+				await mergeCommand({ branch: branchName, dryRun: true, json: true });
+			} finally {
+				process.stdout.write = originalWrite;
+			}
+
+			const parsed = JSON.parse(output);
+			expect(parsed.prediction).toBeDefined();
+			expect(parsed.prediction.wouldRequireAgent).toBe(true);
+			expect(parsed.prediction.predictedTier).toBe("ai-resolve");
+			expect(parsed.prediction.conflictFiles).toContain("src/shared.ts");
+			expect(typeof parsed.prediction.reason).toBe("string");
+
+			// Existing dry-run fields must still be present.
+			expect(parsed.branchName).toBe(branchName);
+			expect(parsed.status).toBe("pending");
+		});
+
+		test("--dry-run --json reports clean-merge prediction for non-conflicting branch", async () => {
+			await setupProject(repoDir, defaultBranch);
+			const branchName = "overstory/builder/bead-predict-2";
+			await createCleanFeatureBranch(repoDir, branchName);
+
+			let output = "";
+			const originalWrite = process.stdout.write.bind(process.stdout);
+			process.stdout.write = (chunk: unknown): boolean => {
+				output += String(chunk);
+				return true;
+			};
+
+			try {
+				await mergeCommand({ branch: branchName, dryRun: true, json: true });
+			} finally {
+				process.stdout.write = originalWrite;
+			}
+
+			const parsed = JSON.parse(output);
+			expect(parsed.prediction.predictedTier).toBe("clean-merge");
+			expect(parsed.prediction.wouldRequireAgent).toBe(false);
+			expect(parsed.prediction.conflictFiles).toEqual([]);
+		});
+
+		test("--all --dry-run --json attaches prediction to each entry", async () => {
+			await setupProject(repoDir, defaultBranch);
+			const cleanBranch = "overstory/builder/bead-predict-all-clean";
+			await createCleanFeatureBranch(repoDir, cleanBranch);
+
+			// Add a contentful-canonical conflict branch.
+			await commitFile(repoDir, "src/shared.ts", "shared base\n");
+			const conflictBranch = "overstory/builder/bead-predict-all-conflict";
+			await runGitInDir(repoDir, ["checkout", "-b", conflictBranch]);
+			await commitFile(repoDir, "src/shared.ts", "feature side\n");
+			await runGitInDir(repoDir, ["checkout", defaultBranch]);
+			await commitFile(repoDir, "src/shared.ts", "main side\n");
+
+			const queuePath = join(repoDir, ".overstory", "merge-queue.db");
+			const queue = createMergeQueue(queuePath);
+			queue.enqueue({
+				branchName: cleanBranch,
+				taskId: "bead-predict-all-clean",
+				agentName: "builder",
+				filesModified: [`src/${cleanBranch}.ts`],
+			});
+			queue.enqueue({
+				branchName: conflictBranch,
+				taskId: "bead-predict-all-conflict",
+				agentName: "builder",
+				filesModified: ["src/shared.ts"],
+			});
+			queue.close();
+
+			let output = "";
+			const originalWrite = process.stdout.write.bind(process.stdout);
+			process.stdout.write = (chunk: unknown): boolean => {
+				output += String(chunk);
+				return true;
+			};
+
+			try {
+				await mergeCommand({ all: true, dryRun: true, json: true });
+			} finally {
+				process.stdout.write = originalWrite;
+			}
+
+			const parsed = JSON.parse(output);
+			expect(parsed.entries).toHaveLength(2);
+			const cleanEntry = parsed.entries.find(
+				(e: { branchName: string }) => e.branchName === cleanBranch,
+			);
+			const conflictEntry = parsed.entries.find(
+				(e: { branchName: string }) => e.branchName === conflictBranch,
+			);
+			expect(cleanEntry.prediction.predictedTier).toBe("clean-merge");
+			expect(cleanEntry.prediction.wouldRequireAgent).toBe(false);
+			expect(conflictEntry.prediction.predictedTier).toBe("ai-resolve");
+			expect(conflictEntry.prediction.wouldRequireAgent).toBe(true);
+		});
+	});
+
 	describe("conflict handling", () => {
 		test("content conflict auto-resolves: same file modified on both branches, verify incoming content wins", async () => {
 			await setupProject(repoDir, defaultBranch);

package/src/commands/merge.ts

@@ -16,10 +16,12 @@ import { loadConfig } from "../config.ts";
 import { MergeError, ValidationError } from "../errors.ts";
 import { jsonOutput } from "../json.ts";
 import { accent, printHint } from "../logging/color.ts";
+import { acquireMergeLock } from "../merge/lock.ts";
+import { predictConflicts } from "../merge/predict.ts";
 import { createMergeQueue } from "../merge/queue.ts";
 import { createMergeResolver } from "../merge/resolver.ts";
 import { createMulchClient } from "../mulch/client.ts";
-import type { MergeEntry, MergeResult } from "../types.ts";
+import type { ConflictPrediction, MergeEntry, MergeResult } from "../types.ts";
 
 export interface MergeOptions {
 	branch?: string;
@@ -108,7 +110,7 @@ function formatResult(result: MergeResult): string {
 }
 
 /** Format a dry-run report for a merge entry. */
-function formatDryRun(entry: MergeEntry): string {
+function formatDryRun(entry: MergeEntry, prediction?: ConflictPrediction): string {
 	const lines: string[] = [
 		`[dry-run] Branch: ${accent(entry.branchName)}`,
 		`   Agent: ${accent(entry.agentName)} | Task: ${accent(entry.taskId)}`,
@@ -122,9 +124,41 @@ function formatDryRun(entry: MergeEntry): string {
 		}
 	}
 
+	if (prediction) {
+		const agentSuffix = prediction.wouldRequireAgent ? " (would require merger agent)" : "";
+		lines.push(`   Prediction: ${prediction.predictedTier}${agentSuffix} — ${prediction.reason}`);
+		if (prediction.conflictFiles.length > 0) {
+			lines.push(`   Conflict files: ${prediction.conflictFiles.join(", ")}`);
+		}
+	}
+
 	return lines.join("\n");
 }
 
+/**
+ * Predict the merge tier for a single entry, swallowing errors into a
+ * deterministic `ai-resolve` envelope so that `--all --dry-run` can keep
+ * going if one branch's prediction blows up.
+ */
+async function safePredictForEntry(
+	entry: MergeEntry,
+	canonicalBranch: string,
+	repoRoot: string,
+	mulchClient: ReturnType<typeof createMulchClient>,
+): Promise<ConflictPrediction> {
+	try {
+		return await predictConflicts(entry, canonicalBranch, repoRoot, mulchClient);
+	} catch (err) {
+		const msg = err instanceof Error ? err.message : String(err);
+		return {
+			predictedTier: "ai-resolve",
+			conflictFiles: [],
+			wouldRequireAgent: true,
+			reason: `prediction-failed: ${msg}`,
+		};
+	}
+}
+
 /**
  * Entry point for `ov merge [flags]`.
  *
@@ -168,10 +202,22 @@ export async function mergeCommand(opts: MergeOptions): Promise<void> {
 		mulchClient,
 	});
 
-	if (branchName) {
-		await handleBranch(branchName, queue, resolver, config, targetBranch, dryRun, json);
-	} else {
-		await handleAll(queue, resolver, config, targetBranch, dryRun, json);
+	// Dry-run is read-only with respect to git state — no lock needed. The
+	// real merge path acquires a lock on the target branch so a parallel
+	// `ov merge` can't observe in-progress conflict markers and report a
+	// false failure (seeds: overstory-9610).
+	const lock = dryRun
+		? null
+		: acquireMergeLock(join(config.project.root, ".overstory"), targetBranch);
+
+	try {
+		if (branchName) {
+			await handleBranch(branchName, queue, resolver, config, targetBranch, dryRun, json);
+		} else {
+			await handleAll(queue, resolver, config, targetBranch, dryRun, json);
+		}
+	} finally {
+		lock?.release();
 	}
 }
 
@@ -225,10 +271,13 @@ async function handleBranch(
 	}
 
 	if (dryRun) {
+		const mulchClient = createMulchClient(config.project.root);
+		const prediction = await safePredictForEntry(entry, canonicalBranch, repoRoot, mulchClient);
+
 		if (json) {
-			jsonOutput("merge", { ...entry });
+			jsonOutput("merge", { ...entry, prediction });
 		} else {
-			process.stdout.write(`${formatDryRun(entry)}\n`);
+			process.stdout.write(`${formatDryRun(entry, prediction)}\n`);
 		}
 		return;
 	}
@@ -280,14 +329,21 @@ async function handleAll(
 	}
 
 	if (dryRun) {
+		const mulchClient = createMulchClient(config.project.root);
+		const enrichedEntries: Array<MergeEntry & { prediction: ConflictPrediction }> = [];
+		for (const entry of pendingEntries) {
+			const prediction = await safePredictForEntry(entry, canonicalBranch, repoRoot, mulchClient);
+			enrichedEntries.push({ ...entry, prediction });
+		}
+
 		if (json) {
-			jsonOutput("merge", { entries: pendingEntries });
+			jsonOutput("merge", { entries: enrichedEntries });
 		} else {
 			process.stdout.write(
-				`${pendingEntries.length} pending branch${pendingEntries.length === 1 ? "" : "es"}:\n\n`,
+				`${enrichedEntries.length} pending branch${enrichedEntries.length === 1 ? "" : "es"}:\n\n`,
 			);
-			for (const entry of pendingEntries) {
-				process.stdout.write(`${formatDryRun(entry)}\n\n`);
+			for (const entry of enrichedEntries) {
+				process.stdout.write(`${formatDryRun(entry, entry.prediction)}\n\n`);
 			}
 		}
 		return;