@inkeep/agents-core 0.0.0-dev-20260324095902 → 0.0.0-dev-20260324145046

package/dist/dolt/branches-api.js

@@ -1,9 +1,16 @@
+import { doltHashOf } from "./commit.js";
 import { SCHEMA_SOURCE_BRANCH, ensureSchemaSync, getSchemaDiff, syncSchemaFromMain } from "./schema-sync.js";
 import { doltBranch, doltCheckout, doltDeleteBranch, doltGetBranchNamespace, doltListBranches } from "./branch.js";
 import { sql } from "drizzle-orm";
 
 //#region src/dolt/branches-api.ts
 const MAIN_BRANCH_SUFFIX = "main";
+var invalidBranchParamsError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "invalidBranchParamsError";
+	}
+};
 /**
 * Get the tenant-scoped main branch name
 */
@@ -14,6 +21,12 @@ const getTenantMainBranch = (tenantId) => `${tenantId}_${MAIN_BRANCH_SUFFIX}`;
 const isProtectedBranchName = (branchName) => {
 	return branchName === MAIN_BRANCH_SUFFIX;
 };
+const getTempBranchSuffix = (prefix) => {
+	return `temp-${prefix}_${Date.now()}_${Math.random().toString(36).substring(2, 8)}`;
+};
+const isTempBranchName = (fullName) => {
+	return /temp-[a-z-]+_\d+_[a-z0-9]+$/.test(fullName);
+};
 /**
 * Checkout a branch with optional schema synchronization from main.
 *
@@ -49,6 +62,13 @@ const checkoutBranch = (db) => async (params) => {
 		}
 	};
 };
+const syncSchemaOnBranch = (db) => async (branchName) => {
+	if ((await getSchemaDiff(db)(branchName)).length > 0) {
+		await doltCheckout(db)({ branch: branchName });
+		const syncResult = await syncSchemaFromMain(db)({ autoCommitPending: true });
+		if (syncResult.error && !syncResult.synced) throw new Error(`Failed to sync schema on source branch '${branchName}': ${syncResult.error}`);
+	}
+};
 /**
 * Create a new branch with optional schema synchronization.
 *
@@ -58,55 +78,64 @@ const checkoutBranch = (db) => async (params) => {
 *
 * By syncing schema on the source branch first, we ensure the new branch
 * starts with the latest schema, avoiding schema conflicts later.
+* If you want to create a branch from a commit hash, use the fromCommit parameter.
 */
 const createBranch = (db) => async (params) => {
-	const { tenantId, projectId, name, from, syncSchemaOnSource = true } = params;
-	if (!name || name.trim() === "") throw new Error("Branch name cannot be empty");
+	const { tenantId, projectId, name, fromBranch, fromCommit, syncSchemaOnSource = true } = params;
+	if (fromBranch && fromCommit) throw new invalidBranchParamsError("Cannot specify both fromBranch and fromCommit");
+	if (!name || name.trim() === "") throw new invalidBranchParamsError("Branch name cannot be empty");
 	const fullName = doltGetBranchNamespace({
 		tenantId,
 		projectId,
 		branchName: name
 	})();
-	if ((await doltListBranches(db)()).some((b) => b.name === fullName)) throw new Error(`Branch '${name}' already exists`);
-	let fromFullBranchName;
-	if (from && from !== MAIN_BRANCH_SUFFIX) fromFullBranchName = doltGetBranchNamespace({
-		tenantId,
-		projectId,
-		branchName: from
-	})();
-	else fromFullBranchName = getTenantMainBranch(tenantId);
-	if (syncSchemaOnSource && fromFullBranchName !== SCHEMA_SOURCE_BRANCH) {
-		if ((await getSchemaDiff(db)(fromFullBranchName)).length > 0) {
-			await doltCheckout(db)({ branch: fromFullBranchName });
-			const syncResult = await syncSchemaFromMain(db)({ autoCommitPending: true });
-			if (syncResult.error && !syncResult.synced) throw new Error(`Failed to sync schema on source branch '${fromFullBranchName}': ${syncResult.error}`);
-		}
+	if ((await doltListBranches(db)()).some((b) => b.name === fullName)) throw new invalidBranchParamsError(`Branch '${name}' already exists`);
+	if (fromCommit) {
+		await doltBranch(db)({
+			name: fullName,
+			startPoint: fromCommit
+		});
+		if (syncSchemaOnSource) await syncSchemaOnBranch(db)(fullName);
+	} else {
+		let fromFullBranchName;
+		if (fromBranch) fromFullBranchName = doltGetBranchNamespace({
+			tenantId,
+			projectId,
+			branchName: fromBranch
+		})();
+		else fromFullBranchName = doltGetBranchNamespace({
+			tenantId,
+			projectId,
+			branchName: MAIN_BRANCH_SUFFIX
+		})();
+		if (syncSchemaOnSource && fromFullBranchName !== SCHEMA_SOURCE_BRANCH) await syncSchemaOnBranch(db)(fromFullBranchName);
+		await doltBranch(db)({
+			name: fullName,
+			startPoint: fromFullBranchName
+		});
 	}
-	await doltBranch(db)({
-		name: fullName,
-		startPoint: fromFullBranchName
-	});
-	const newBranch = (await doltListBranches(db)()).find((b) => b.name === fullName);
-	if (!newBranch) throw new Error("Failed to create branch");
 	return {
 		baseName: name,
 		fullName,
-		hash: newBranch.hash
+		hash: await doltHashOf(db)({ revision: fullName })
 	};
 };
 /**
 * Delete a branch
 */
 const deleteBranch = (db) => async (params) => {
-	const { tenantId, projectId, name } = params;
-	if (isProtectedBranchName(name)) throw new Error(`Cannot delete protected branch '${name}'`);
+	const { tenantId, projectId, branchName, force } = params;
+	if (isProtectedBranchName(branchName)) throw new invalidBranchParamsError(`Cannot delete protected branch '${branchName}'`);
 	const fullName = doltGetBranchNamespace({
 		tenantId,
 		projectId,
-		branchName: name
+		branchName
 	})();
-	if (!(await doltListBranches(db)()).some((b) => b.name === fullName)) throw new Error(`Branch '${name}' not found`);
-	await doltDeleteBranch(db)({ name: fullName });
+	if (!(await doltListBranches(db)()).some((b) => b.name === fullName)) throw new invalidBranchParamsError(`Branch '${branchName}' not found`);
+	await doltDeleteBranch(db)({
+		name: fullName,
+		force
+	});
 };
 /**
 * Get a single branch
@@ -159,4 +188,4 @@ const listBranchesForAgent = (db) => async (params) => {
 };
 
 //#endregion
-export { MAIN_BRANCH_SUFFIX, checkoutBranch, createBranch, deleteBranch, getBranch, getTenantMainBranch, isProtectedBranchName, listBranches, listBranchesForAgent };
+export { MAIN_BRANCH_SUFFIX, checkoutBranch, createBranch, deleteBranch, getBranch, getTempBranchSuffix, getTenantMainBranch, invalidBranchParamsError, isProtectedBranchName, isTempBranchName, listBranches, listBranchesForAgent, syncSchemaOnBranch };

package/dist/dolt/index.d.ts

@@ -1,10 +1,13 @@
+import { releaseAdvisoryLock, tryAdvisoryLock } from "./advisory-lock.js";
 import { branchScopes, doltActiveBranch, doltBranch, doltBranchExists, doltCheckout, doltDeleteBranch, doltGetBranchNamespace, doltListBranches, doltRenameBranch, ensureBranchExists } from "./branch.js";
-import { CheckoutBranchParams, CheckoutBranchResult, CreateBranchParams, DeleteBranchParams, GetBranchParams, MAIN_BRANCH_SUFFIX, checkoutBranch, createBranch, deleteBranch, getBranch, getTenantMainBranch, isProtectedBranchName, listBranches, listBranchesForAgent } from "./branches-api.js";
+import { CheckoutBranchParams, CheckoutBranchResult, CreateBranchParams, DeleteBranchParams, GetBranchParams, MAIN_BRANCH_SUFFIX, checkoutBranch, createBranch, deleteBranch, getBranch, getTempBranchSuffix, getTenantMainBranch, invalidBranchParamsError, isProtectedBranchName, isTempBranchName, listBranches, listBranchesForAgent, syncSchemaOnBranch } from "./branches-api.js";
 import { doltAdd, doltAddAndCommit, doltCommit, doltDeleteTag, doltHashOf, doltListTags, doltLog, doltReset, doltStatus, doltTag } from "./commit.js";
 import { doltDiff, doltDiffSummary } from "./diff.js";
-import { doltAbortMerge, doltConflicts, doltMerge, doltMergeStatus, doltResolveConflicts, doltSchemaConflicts, doltTableConflicts } from "./merge.js";
+import { MergeConflictError, doltAbortMerge, doltConflicts, doltMerge, doltMergeStatus, doltPreviewMergeConflicts, doltPreviewMergeConflictsSummary, doltResolveConflicts, doltSchemaConflicts, doltTableConflicts } from "./merge.js";
+import { PkMap, isValidManageTable, managePkMap } from "./pk-map.js";
 import { RefType, checkoutRef, getCurrentBranchOrCommit, getProjectMainResolvedRef, getProjectScopedRef, getTenantScopedRef, isRefWritable, isValidCommitHash, resolveProjectMainRefs, resolveRef } from "./ref-helpers.js";
-import { RefContext, RefMiddlewareOptions, createRefMiddleware, createWriteProtectionMiddleware, refMiddlewareFactory, writeProtectionMiddlewareFactory } from "./ref-middleware.js";
+import { RefContext, RefMiddlewareOptions, createRefMiddleware, createWriteProtectionMiddleware, isMergeRoute, refMiddlewareFactory, writeProtectionMiddlewareFactory } from "./ref-middleware.js";
 import { NestedRefScopeError, WithRefOptions, getCurrentRefScope, getRefScopedDb, isInRefScope, withRef } from "./ref-scope.js";
+import { ResolutionValidationError, applyResolutions } from "./resolve-conflicts.js";
 import { EnsureSchemaSyncOptions, SCHEMA_SOURCE_BRANCH, SchemaDiff, SchemaSyncOptions, SchemaSyncResult, areBranchesSchemaCompatible, ensureSchemaSync, formatSchemaDiffSummary, getActiveBranch, getSchemaDiff, hasSchemaDifferences, hasUncommittedChanges, isLocalhostUrl, syncSchemaFromMain } from "./schema-sync.js";
-export { CheckoutBranchParams, CheckoutBranchResult, CreateBranchParams, DeleteBranchParams, EnsureSchemaSyncOptions, GetBranchParams, MAIN_BRANCH_SUFFIX, NestedRefScopeError, RefContext, RefMiddlewareOptions, RefType, SCHEMA_SOURCE_BRANCH, SchemaDiff, SchemaSyncOptions, SchemaSyncResult, WithRefOptions, areBranchesSchemaCompatible, branchScopes, checkoutBranch, checkoutRef, createBranch, createRefMiddleware, createWriteProtectionMiddleware, deleteBranch, doltAbortMerge, doltActiveBranch, doltAdd, doltAddAndCommit, doltBranch, doltBranchExists, doltCheckout, doltCommit, doltConflicts, doltDeleteBranch, doltDeleteTag, doltDiff, doltDiffSummary, doltGetBranchNamespace, doltHashOf, doltListBranches, doltListTags, doltLog, doltMerge, doltMergeStatus, doltRenameBranch, doltReset, doltResolveConflicts, doltSchemaConflicts, doltStatus, doltTableConflicts, doltTag, ensureBranchExists, ensureSchemaSync, formatSchemaDiffSummary, getActiveBranch, getBranch, getCurrentBranchOrCommit, getCurrentRefScope, getProjectMainResolvedRef, getProjectScopedRef, getRefScopedDb, getSchemaDiff, getTenantMainBranch, getTenantScopedRef, hasSchemaDifferences, hasUncommittedChanges, isInRefScope, isLocalhostUrl, isProtectedBranchName, isRefWritable, isValidCommitHash, listBranches, listBranchesForAgent, refMiddlewareFactory, resolveProjectMainRefs, resolveRef, syncSchemaFromMain, withRef, writeProtectionMiddlewareFactory };
+export { CheckoutBranchParams, CheckoutBranchResult, CreateBranchParams, DeleteBranchParams, EnsureSchemaSyncOptions, GetBranchParams, MAIN_BRANCH_SUFFIX, MergeConflictError, NestedRefScopeError, PkMap, RefContext, RefMiddlewareOptions, RefType, ResolutionValidationError, SCHEMA_SOURCE_BRANCH, SchemaDiff, SchemaSyncOptions, SchemaSyncResult, WithRefOptions, applyResolutions, areBranchesSchemaCompatible, branchScopes, checkoutBranch, checkoutRef, createBranch, createRefMiddleware, createWriteProtectionMiddleware, deleteBranch, doltAbortMerge, doltActiveBranch, doltAdd, doltAddAndCommit, doltBranch, doltBranchExists, doltCheckout, doltCommit, doltConflicts, doltDeleteBranch, doltDeleteTag, doltDiff, doltDiffSummary, doltGetBranchNamespace, doltHashOf, doltListBranches, doltListTags, doltLog, doltMerge, doltMergeStatus, doltPreviewMergeConflicts, doltPreviewMergeConflictsSummary, doltRenameBranch, doltReset, doltResolveConflicts, doltSchemaConflicts, doltStatus, doltTableConflicts, doltTag, ensureBranchExists, ensureSchemaSync, formatSchemaDiffSummary, getActiveBranch, getBranch, getCurrentBranchOrCommit, getCurrentRefScope, getProjectMainResolvedRef, getProjectScopedRef, getRefScopedDb, getSchemaDiff, getTempBranchSuffix, getTenantMainBranch, getTenantScopedRef, hasSchemaDifferences, hasUncommittedChanges, invalidBranchParamsError, isInRefScope, isLocalhostUrl, isMergeRoute, isProtectedBranchName, isRefWritable, isTempBranchName, isValidCommitHash, isValidManageTable, listBranches, listBranchesForAgent, managePkMap, refMiddlewareFactory, releaseAdvisoryLock, resolveProjectMainRefs, resolveRef, syncSchemaFromMain, syncSchemaOnBranch, tryAdvisoryLock, withRef, writeProtectionMiddlewareFactory };

package/dist/dolt/index.js

@@ -1,11 +1,14 @@
 import { doltAdd, doltAddAndCommit, doltCommit, doltDeleteTag, doltHashOf, doltListTags, doltLog, doltReset, doltStatus, doltTag } from "./commit.js";
-import { doltAbortMerge, doltConflicts, doltMerge, doltMergeStatus, doltResolveConflicts, doltSchemaConflicts, doltTableConflicts } from "./merge.js";
+import { isValidManageTable, managePkMap } from "./pk-map.js";
+import { ResolutionValidationError, applyResolutions } from "./resolve-conflicts.js";
+import { MergeConflictError, doltAbortMerge, doltConflicts, doltMerge, doltMergeStatus, doltPreviewMergeConflicts, doltPreviewMergeConflictsSummary, doltResolveConflicts, doltSchemaConflicts, doltTableConflicts } from "./merge.js";
 import { SCHEMA_SOURCE_BRANCH, areBranchesSchemaCompatible, ensureSchemaSync, formatSchemaDiffSummary, getActiveBranch, getSchemaDiff, hasSchemaDifferences, hasUncommittedChanges, isLocalhostUrl, syncSchemaFromMain } from "./schema-sync.js";
-import { MAIN_BRANCH_SUFFIX, checkoutBranch, createBranch, deleteBranch, getBranch, getTenantMainBranch, isProtectedBranchName, listBranches, listBranchesForAgent } from "./branches-api.js";
+import { MAIN_BRANCH_SUFFIX, checkoutBranch, createBranch, deleteBranch, getBranch, getTempBranchSuffix, getTenantMainBranch, invalidBranchParamsError, isProtectedBranchName, isTempBranchName, listBranches, listBranchesForAgent, syncSchemaOnBranch } from "./branches-api.js";
 import { checkoutRef, getCurrentBranchOrCommit, getProjectMainResolvedRef, getProjectScopedRef, getTenantScopedRef, isRefWritable, isValidCommitHash, resolveProjectMainRefs, resolveRef } from "./ref-helpers.js";
 import { doltActiveBranch, doltBranch, doltBranchExists, doltCheckout, doltDeleteBranch, doltGetBranchNamespace, doltListBranches, doltRenameBranch, ensureBranchExists } from "./branch.js";
+import { releaseAdvisoryLock, tryAdvisoryLock } from "./advisory-lock.js";
 import { doltDiff, doltDiffSummary } from "./diff.js";
-import { createRefMiddleware, createWriteProtectionMiddleware, refMiddlewareFactory, writeProtectionMiddlewareFactory } from "./ref-middleware.js";
+import { createRefMiddleware, createWriteProtectionMiddleware, isMergeRoute, refMiddlewareFactory, writeProtectionMiddlewareFactory } from "./ref-middleware.js";
 import { NestedRefScopeError, getCurrentRefScope, getRefScopedDb, isInRefScope, withRef } from "./ref-scope.js";
 
-export { MAIN_BRANCH_SUFFIX, NestedRefScopeError, SCHEMA_SOURCE_BRANCH, areBranchesSchemaCompatible, checkoutBranch, checkoutRef, createBranch, createRefMiddleware, createWriteProtectionMiddleware, deleteBranch, doltAbortMerge, doltActiveBranch, doltAdd, doltAddAndCommit, doltBranch, doltBranchExists, doltCheckout, doltCommit, doltConflicts, doltDeleteBranch, doltDeleteTag, doltDiff, doltDiffSummary, doltGetBranchNamespace, doltHashOf, doltListBranches, doltListTags, doltLog, doltMerge, doltMergeStatus, doltRenameBranch, doltReset, doltResolveConflicts, doltSchemaConflicts, doltStatus, doltTableConflicts, doltTag, ensureBranchExists, ensureSchemaSync, formatSchemaDiffSummary, getActiveBranch, getBranch, getCurrentBranchOrCommit, getCurrentRefScope, getProjectMainResolvedRef, getProjectScopedRef, getRefScopedDb, getSchemaDiff, getTenantMainBranch, getTenantScopedRef, hasSchemaDifferences, hasUncommittedChanges, isInRefScope, isLocalhostUrl, isProtectedBranchName, isRefWritable, isValidCommitHash, listBranches, listBranchesForAgent, refMiddlewareFactory, resolveProjectMainRefs, resolveRef, syncSchemaFromMain, withRef, writeProtectionMiddlewareFactory };
+export { MAIN_BRANCH_SUFFIX, MergeConflictError, NestedRefScopeError, ResolutionValidationError, SCHEMA_SOURCE_BRANCH, applyResolutions, areBranchesSchemaCompatible, checkoutBranch, checkoutRef, createBranch, createRefMiddleware, createWriteProtectionMiddleware, deleteBranch, doltAbortMerge, doltActiveBranch, doltAdd, doltAddAndCommit, doltBranch, doltBranchExists, doltCheckout, doltCommit, doltConflicts, doltDeleteBranch, doltDeleteTag, doltDiff, doltDiffSummary, doltGetBranchNamespace, doltHashOf, doltListBranches, doltListTags, doltLog, doltMerge, doltMergeStatus, doltPreviewMergeConflicts, doltPreviewMergeConflictsSummary, doltRenameBranch, doltReset, doltResolveConflicts, doltSchemaConflicts, doltStatus, doltTableConflicts, doltTag, ensureBranchExists, ensureSchemaSync, formatSchemaDiffSummary, getActiveBranch, getBranch, getCurrentBranchOrCommit, getCurrentRefScope, getProjectMainResolvedRef, getProjectScopedRef, getRefScopedDb, getSchemaDiff, getTempBranchSuffix, getTenantMainBranch, getTenantScopedRef, hasSchemaDifferences, hasUncommittedChanges, invalidBranchParamsError, isInRefScope, isLocalhostUrl, isMergeRoute, isProtectedBranchName, isRefWritable, isTempBranchName, isValidCommitHash, isValidManageTable, listBranches, listBranchesForAgent, managePkMap, refMiddlewareFactory, releaseAdvisoryLock, resolveProjectMainRefs, resolveRef, syncSchemaFromMain, syncSchemaOnBranch, tryAdvisoryLock, withRef, writeProtectionMiddlewareFactory };

package/dist/dolt/merge.d.ts

@@ -1,10 +1,24 @@
+import { ConflictResolution } from "../validation/dolt-schemas.js";
 import { AgentsManageDatabaseClient } from "../db/manage/manage-client.js";
 
 //#region src/dolt/merge.d.ts
-
+declare class MergeConflictError extends Error {
+  readonly conflictCount: number;
+  readonly fromBranch: string;
+  readonly toBranch: string;
+  constructor(message: string, conflictCount: number, fromBranch: string, toBranch: string);
+}
 /**
- * Merge another branch into the current branch
- * Returns merge status and handles conflicts by allowing commit with conflicts
+ * Merge a branch into the currently checked out branch.
+ *
+ * Runs inside an explicit transaction so that conflicts and
+ * constraint-violations are surfaced to the caller instead of being
+ * auto-rolled-back by Dolt's AUTOCOMMIT mode.
+ *
+ * If conflicts arise and `resolutions` are provided, they are applied
+ * and the merge is committed. If conflicts arise without resolutions
+ * (or with insufficient resolutions), the transaction is rolled back
+ * and a `MergeConflictError` is thrown.
  */
 declare const doltMerge: (db: AgentsManageDatabaseClient) => (params: {
   fromBranch: string;
@@ -15,8 +29,9 @@ declare const doltMerge: (db: AgentsManageDatabaseClient) => (params: {
     name: string;
     email: string;
   };
+  resolutions?: ConflictResolution[];
 }) => Promise<{
-  status: "success" | "conflicts";
+  status: "success";
   from: string;
   to: string;
   toHead?: string;
@@ -52,6 +67,27 @@ declare const doltTableConflicts: (db: AgentsManageDatabaseClient) => (params: {
  * Get schema conflicts
  */
 declare const doltSchemaConflicts: (db: AgentsManageDatabaseClient) => () => Promise<any[]>;
+/**
+ * Preview merge conflicts without modifying the database (dry-run).
+ * Returns a summary of which tables have conflicts.
+ */
+declare const doltPreviewMergeConflictsSummary: (db: AgentsManageDatabaseClient) => (params: {
+  baseBranch: string;
+  mergeBranch: string;
+}) => Promise<{
+  table: string;
+  numDataConflicts: number;
+  numSchemaConflicts: number;
+}[]>;
+/**
+ * Preview detailed merge conflicts for a specific table without modifying the database (dry-run).
+ * Returns the same column shape as dolt_conflicts_$table.
+ */
+declare const doltPreviewMergeConflicts: (db: AgentsManageDatabaseClient) => (params: {
+  baseBranch: string;
+  mergeBranch: string;
+  tableName: string;
+}) => Promise<Record<string, unknown>[]>;
 /**
  * Resolve conflicts for a table using a strategy
  */
@@ -60,4 +96,4 @@ declare const doltResolveConflicts: (db: AgentsManageDatabaseClient) => (params:
   strategy: "ours" | "theirs";
 }) => Promise<void>;
 //#endregion
-export { doltAbortMerge, doltConflicts, doltMerge, doltMergeStatus, doltResolveConflicts, doltSchemaConflicts, doltTableConflicts };
+export { MergeConflictError, doltAbortMerge, doltConflicts, doltMerge, doltMergeStatus, doltPreviewMergeConflicts, doltPreviewMergeConflictsSummary, doltResolveConflicts, doltSchemaConflicts, doltTableConflicts };

package/dist/dolt/merge.js

@@ -1,36 +1,150 @@
+import { getLogger } from "../utils/logger.js";
+import { doltAddAndCommit } from "./commit.js";
+import { createApiError } from "../utils/error.js";
+import { managePkMap } from "./pk-map.js";
+import { ResolutionValidationError, applyResolutions } from "./resolve-conflicts.js";
 import { doltCheckout } from "./branch.js";
 import { sql } from "drizzle-orm";
 
 //#region src/dolt/merge.ts
+const logger = getLogger("dolt-merge");
+const TIMESTAMP_COLUMNS = new Set(["created_at", "updated_at"]);
+var MergeConflictError = class extends Error {
+	constructor(message, conflictCount, fromBranch, toBranch) {
+		super(message);
+		this.conflictCount = conflictCount;
+		this.fromBranch = fromBranch;
+		this.toBranch = toBranch;
+		this.name = "MergeConflictError";
+	}
+};
+function extractConflictCount(row) {
+	if (typeof row.conflicts === "number" || typeof row.conflicts === "string") return Number(row.conflicts);
+	const doltMerge$1 = row.dolt_merge;
+	if (Array.isArray(doltMerge$1)) return Number(doltMerge$1[2] ?? 0);
+	throw new Error(`Unexpected DOLT_MERGE result format: ${JSON.stringify(row)}`);
+}
+function isTimestampOnlyConflictRow(row, pkColumns) {
+	if (row.our_diff_type !== "modified" || row.their_diff_type !== "modified") return false;
+	const pkSet = new Set(pkColumns);
+	for (const key of Object.keys(row)) {
+		if (!key.startsWith("base_")) continue;
+		const col = key.slice(5);
+		if (col === "diff_type" || pkSet.has(col) || TIMESTAMP_COLUMNS.has(col)) continue;
+		if (String(row[`base_${col}`] ?? "") !== String(row[`our_${col}`] ?? "") || String(row[`base_${col}`] ?? "") !== String(row[`their_${col}`] ?? "")) return false;
+	}
+	return true;
+}
+function buildTimestampAutoResolution(tableName, row, pkColumns) {
+	const primaryKey = {};
+	for (const col of pkColumns) primaryKey[col] = String(row[`base_${col}`] ?? row[`our_${col}`] ?? row[`their_${col}`]);
+	return {
+		table: tableName,
+		primaryKey,
+		rowDefaultPick: (row.our_updated_at ? new Date(String(row.our_updated_at)) : /* @__PURE__ */ new Date(0)) >= (row.their_updated_at ? new Date(String(row.their_updated_at)) : /* @__PURE__ */ new Date(0)) ? "ours" : "theirs"
+	};
+}
 /**
-* Merge another branch into the current branch
-* Returns merge status and handles conflicts by allowing commit with conflicts
+* Merge a branch into the currently checked out branch.
+*
+* Runs inside an explicit transaction so that conflicts and
+* constraint-violations are surfaced to the caller instead of being
+* auto-rolled-back by Dolt's AUTOCOMMIT mode.
+*
+* If conflicts arise and `resolutions` are provided, they are applied
+* and the merge is committed. If conflicts arise without resolutions
+* (or with insufficient resolutions), the transaction is rolled back
+* and a `MergeConflictError` is thrown.
 */
 const doltMerge = (db) => async (params) => {
-	console.log("merging branch", params.fromBranch, "into", params.toBranch);
+	logger.info({
+		fromBranch: params.fromBranch,
+		toBranch: params.toBranch
+	}, "Merging branch");
 	await doltCheckout(db)({ branch: params.toBranch });
 	const toHead = (await db.execute(sql`SELECT HASHOF('HEAD') as hash`)).rows[0]?.hash;
-	const args = [`'${params.fromBranch}'`];
+	const args = [`'${params.fromBranch.replace(/'/g, "''")}'`];
 	if (params.noFastForward) args.push("'--no-ff'");
-	if (params.message) args.push("'-m'", `'${params.message.replace(/'/g, "''")}'`);
-	if (params.author) args.push("'--author'", `'${params.author.name} <${params.author.email}>'`);
-	const firstRow = (await db.execute(sql.raw(`SELECT DOLT_MERGE(${args.join(", ")})`))).rows[0] ?? {};
-	const mergeResult = typeof firstRow.conflicts === "number" || typeof firstRow.conflicts === "string" || firstRow.conflicts == null ? firstRow : Object.values(firstRow)[0] ?? {};
-	const conflicts = Number(mergeResult.conflicts ?? 0);
-	if (Number.isFinite(conflicts) && conflicts > 0) return {
-		status: "conflicts",
-		from: params.fromBranch,
-		to: params.toBranch,
-		toHead,
-		hasConflicts: true
-	};
-	return {
-		status: "success",
-		from: params.fromBranch,
-		to: params.toBranch,
-		toHead,
-		hasConflicts: false
-	};
+	if (params.message) {
+		const cleanedMessage = params.message.replace(/'/g, "''");
+		args.push("'-m'", `'${cleanedMessage}'`);
+	}
+	const cleanedAuthor = params.author?.name?.replace(/'/g, "''");
+	const cleanedEmail = params.author?.email?.replace(/'/g, "''");
+	if (params.author) args.push("'--author'", `'${cleanedAuthor} <${cleanedEmail}>'`);
+	await db.execute(sql.raw("START TRANSACTION"));
+	let txFinalized = false;
+	try {
+		let result;
+		try {
+			result = await db.execute(sql.raw(`SELECT DOLT_MERGE(${args.join(", ")})`));
+			logger.info({ result }, "DOLT_MERGE result");
+		} catch (error) {
+			const cause = error?.cause;
+			logger.error({
+				message: error?.message,
+				code: cause?.code,
+				severity: cause?.severity,
+				detail: cause?.detail,
+				hint: cause?.hint,
+				query: error?.query,
+				fromBranch: params.fromBranch,
+				toBranch: params.toBranch
+			}, "Error merging branch");
+			throw error;
+		}
+		const conflicts = extractConflictCount(result.rows[0] ?? {});
+		if (Number.isFinite(conflicts) && conflicts > 0) {
+			const userResolutions = params.resolutions ?? [];
+			const autoResolutions = [];
+			const conflictTables = await doltConflicts(db)();
+			let manualConflicts = 0;
+			for (const ct of conflictTables) {
+				const tableConflicts = await doltTableConflicts(db)({ tableName: ct.table });
+				const pkColumns = managePkMap[ct.table] ?? [];
+				for (const row of tableConflicts) if (isTimestampOnlyConflictRow(row, pkColumns)) autoResolutions.push(buildTimestampAutoResolution(ct.table, row, pkColumns));
+				else manualConflicts++;
+			}
+			if (manualConflicts > 0 && userResolutions.length < manualConflicts) throw new MergeConflictError(manualConflicts > 0 && userResolutions.length === 0 ? "Merge has conflicts but no resolutions were provided." : `Resolutions provided (${userResolutions.length}) do not cover all conflicts (${manualConflicts}). All conflicts must be resolved.`, manualConflicts, params.fromBranch, params.toBranch);
+			const allResolutions = [...autoResolutions, ...userResolutions];
+			try {
+				await applyResolutions(db)(allResolutions);
+			} catch (error) {
+				if (error instanceof ResolutionValidationError) throw createApiError({
+					code: "bad_request",
+					message: `Invalid resolution: ${error.message}`
+				});
+				throw error;
+			}
+			await doltAddAndCommit(db)({
+				message: params.message ? `${params.message} (with conflict resolution)` : `Merge ${params.fromBranch} into ${params.toBranch} (with conflict resolution)`,
+				author: params.author
+			});
+			txFinalized = true;
+			return {
+				status: "success",
+				from: params.fromBranch,
+				to: params.toBranch,
+				toHead,
+				hasConflicts: true
+			};
+		}
+		await db.execute(sql.raw("COMMIT"));
+		txFinalized = true;
+		return {
+			status: "success",
+			from: params.fromBranch,
+			to: params.toBranch,
+			toHead,
+			hasConflicts: false
+		};
+	} finally {
+		if (!txFinalized) try {
+			await db.execute(sql.raw("ROLLBACK"));
+		} catch (rollbackError) {
+			logger.error({ error: rollbackError }, "Failed to rollback transaction");
+		}
+	}
 };
 /**
 * Abort a merge
@@ -70,6 +184,29 @@ const doltSchemaConflicts = (db) => async () => {
 	return (await db.execute(sql`SELECT * FROM dolt_schema_conflicts`)).rows;
 };
 /**
+* Preview merge conflicts without modifying the database (dry-run).
+* Returns a summary of which tables have conflicts.
+*/
+const doltPreviewMergeConflictsSummary = (db) => async (params) => {
+	const escapedBaseBranch = params.baseBranch.replace(/'/g, "''");
+	const escapedMergeBranch = params.mergeBranch.replace(/'/g, "''");
+	return (await db.execute(sql.raw(`SELECT * FROM DOLT_PREVIEW_MERGE_CONFLICTS_SUMMARY('${escapedBaseBranch}', '${escapedMergeBranch}')`))).rows.map((row) => ({
+		table: row.table.replace("public.", ""),
+		numDataConflicts: Number(row.num_data_conflicts ?? 0),
+		numSchemaConflicts: Number(row.num_schema_conflicts ?? 0)
+	}));
+};
+/**
+* Preview detailed merge conflicts for a specific table without modifying the database (dry-run).
+* Returns the same column shape as dolt_conflicts_$table.
+*/
+const doltPreviewMergeConflicts = (db) => async (params) => {
+	const escapedBaseBranch = params.baseBranch.replace(/'/g, "''");
+	const escapedMergeBranch = params.mergeBranch.replace(/'/g, "''");
+	const escapedTableName = params.tableName.replace(/'/g, "''");
+	return (await db.execute(sql.raw(`SELECT * FROM DOLT_PREVIEW_MERGE_CONFLICTS('${escapedBaseBranch}', '${escapedMergeBranch}', '${escapedTableName}')`))).rows;
+};
+/**
 * Resolve conflicts for a table using a strategy
 */
 const doltResolveConflicts = (db) => async (params) => {
@@ -78,4 +215,4 @@ const doltResolveConflicts = (db) => async (params) => {
 };
 
 //#endregion
-export { doltAbortMerge, doltConflicts, doltMerge, doltMergeStatus, doltResolveConflicts, doltSchemaConflicts, doltTableConflicts };
+export { MergeConflictError, doltAbortMerge, doltConflicts, doltMerge, doltMergeStatus, doltPreviewMergeConflicts, doltPreviewMergeConflictsSummary, doltResolveConflicts, doltSchemaConflicts, doltTableConflicts };

package/dist/dolt/pk-map.d.ts

@@ -0,0 +1,6 @@
+//#region src/dolt/pk-map.d.ts
+type PkMap = Record<string, string[]>;
+declare const managePkMap: PkMap;
+declare const isValidManageTable: (tableName: string) => boolean;
+//#endregion
+export { PkMap, isValidManageTable, managePkMap };

package/dist/dolt/pk-map.js

@@ -0,0 +1,27 @@
+import { manage_schema_exports } from "../db/manage/manage-schema.js";
+import { getTableConfig } from "drizzle-orm/pg-core";
+
+//#region src/dolt/pk-map.ts
+function buildPkMapFromSchema() {
+	const pkMap = {};
+	for (const value of Object.values(manage_schema_exports)) {
+		if (value == null || typeof value !== "object") continue;
+		let config;
+		try {
+			config = getTableConfig(value);
+		} catch {
+			continue;
+		}
+		if (!config?.name || !config.primaryKeys?.length) continue;
+		const pkColumns = config.primaryKeys[0]?.columns.map((col) => col.name);
+		if (pkColumns && pkColumns.length > 0) pkMap[config.name] = pkColumns;
+	}
+	return pkMap;
+}
+const managePkMap = buildPkMapFromSchema();
+const isValidManageTable = (tableName) => {
+	return tableName in managePkMap;
+};
+
+//#endregion
+export { isValidManageTable, managePkMap };

package/dist/dolt/ref-middleware.d.ts

@@ -3,6 +3,7 @@ import { AgentsManageDatabaseClient } from "../db/manage/manage-client.js";
 import { Context, Next } from "hono";
 
 //#region src/dolt/ref-middleware.d.ts
+declare function isMergeRoute(path: string): boolean;
 type RefContext = {
   resolvedRef?: ResolvedRef;
 };
@@ -79,4 +80,4 @@ declare const refMiddlewareFactory: (db: AgentsManageDatabaseClient, options?: R
  */
 declare const writeProtectionMiddlewareFactory: () => (c: Context, next: Next) => Promise<void>;
 //#endregion
-export { RefContext, RefMiddlewareOptions, createRefMiddleware, createWriteProtectionMiddleware, refMiddlewareFactory, writeProtectionMiddlewareFactory };
+export { RefContext, RefMiddlewareOptions, createRefMiddleware, createWriteProtectionMiddleware, isMergeRoute, refMiddlewareFactory, writeProtectionMiddlewareFactory };

package/dist/dolt/ref-middleware.js

@@ -1,10 +1,14 @@
 import { getLogger } from "../utils/logger.js";
+import { createApiError } from "../utils/error.js";
 import { isRefWritable, resolveRef } from "./ref-helpers.js";
 import { ensureBranchExists } from "./branch.js";
-import { createApiError } from "../utils/error.js";
 
 //#region src/dolt/ref-middleware.ts
 const logger = getLogger("ref-middleware");
+const MERGE_ROUTE_PATTERN = /\/branches\/merge(\/preview)?$/;
+function isMergeRoute(path) {
+	return MERGE_ROUTE_PATTERN.test(path);
+}
 /**
 * Default tenant ID extractor - extracts from /tenants/{tenantId} path pattern
 */
@@ -43,8 +47,18 @@ const defaultExtractProjectId = (c) => {
 const createRefMiddleware = (db, options = {}) => {
 	const { extractTenantId = defaultExtractTenantId, extractProjectId = defaultExtractProjectId, allowProjectIdFromBody = true } = options;
 	return async (c, next) => {
-		const ref = c.req.query("ref");
-		const pathSplit = c.req.path.split("/");
+		let ref = c.req.query("ref");
+		const path = c.req.path;
+		const pathSplit = path.split("/");
+		if (!ref && isMergeRoute(path) && c.req.method === "POST") try {
+			const body = await c.req.json();
+			if (body && typeof body.targetBranch === "string") {
+				ref = body.targetBranch;
+				logger.debug({ ref }, "Extracted targetBranch from merge route body as ref");
+			}
+		} catch {
+			logger.debug({}, "Could not extract targetBranch from merge route body");
+		}
 		const tenantId = extractTenantId(c);
 		let projectId = extractProjectId(c);
 		if (!projectId && allowProjectIdFromBody && [
@@ -214,4 +228,4 @@ const refMiddlewareFactory = createRefMiddleware;
 const writeProtectionMiddlewareFactory = createWriteProtectionMiddleware;
 
 //#endregion
-export { createRefMiddleware, createWriteProtectionMiddleware, refMiddlewareFactory, writeProtectionMiddlewareFactory };
+export { createRefMiddleware, createWriteProtectionMiddleware, isMergeRoute, refMiddlewareFactory, writeProtectionMiddlewareFactory };

package/dist/dolt/resolve-conflicts.d.ts

@@ -0,0 +1,10 @@
+import { ConflictResolution } from "../validation/dolt-schemas.js";
+import { AgentsManageDatabaseClient } from "../db/manage/manage-client.js";
+
+//#region src/dolt/resolve-conflicts.d.ts
+declare class ResolutionValidationError extends Error {
+  constructor(message: string);
+}
+declare const applyResolutions: (db: AgentsManageDatabaseClient) => (resolutions: ConflictResolution[]) => Promise<void>;
+//#endregion
+export { ResolutionValidationError, applyResolutions };